From: Stephane Glondu Date: Thu, 3 Sep 2020 12:52:22 +0000 (+0200) Subject: New upstream version 4.11.0 X-Git-Tag: archive/raspbian/4.11.1-5+rpi1~1^2~25^2~1 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=8f6945967faecf8015573f41eaf8ba62bb9a1046;p=ocaml.git New upstream version 4.11.0 --- diff --git a/.depend b/.depend index c40e2f0f..1c2692e1 100644 --- a/.depend +++ b/.depend @@ -346,7 +346,8 @@ parsing/parse.cmx : \ parsing/docstrings.cmx \ parsing/parse.cmi parsing/parse.cmi : \ - parsing/parsetree.cmi + parsing/parsetree.cmi \ + parsing/longident.cmi parsing/parser.cmo : \ parsing/syntaxerr.cmi \ parsing/parsetree.cmi \ @@ -371,6 +372,7 @@ parsing/parser.cmx : \ parsing/parser.cmi parsing/parser.cmi : \ parsing/parsetree.cmi \ + parsing/longident.cmi \ parsing/location.cmi \ parsing/docstrings.cmi \ parsing/camlinternalMenhirLib.cmi @@ -400,6 +402,7 @@ parsing/printast.cmo : \ parsing/parsetree.cmi \ parsing/longident.cmi \ parsing/location.cmi \ + utils/clflags.cmi \ parsing/asttypes.cmi \ parsing/printast.cmi parsing/printast.cmx : \ @@ -407,6 +410,7 @@ parsing/printast.cmx : \ parsing/parsetree.cmi \ parsing/longident.cmx \ parsing/location.cmx \ + utils/clflags.cmx \ parsing/asttypes.cmi \ parsing/printast.cmi parsing/printast.cmi : \ @@ -437,6 +441,34 @@ typing/btype.cmi : \ typing/types.cmi \ typing/path.cmi \ parsing/asttypes.cmi +typing/cmt2annot.cmo : \ + typing/types.cmi \ + typing/typedtree.cmi \ + typing/tast_iterator.cmi \ + typing/stypes.cmi \ + typing/path.cmi \ + typing/oprint.cmi \ + parsing/location.cmi \ + typing/ident.cmi \ + typing/envaux.cmi \ + typing/env.cmi \ + file_formats/cmt_format.cmi \ + parsing/asttypes.cmi \ + typing/annot.cmi +typing/cmt2annot.cmx : \ + typing/types.cmx \ + typing/typedtree.cmx \ + typing/tast_iterator.cmx \ + typing/stypes.cmx \ + typing/path.cmx \ + typing/oprint.cmx \ + parsing/location.cmx \ + typing/ident.cmx \ + typing/envaux.cmx \ + typing/env.cmx \ + file_formats/cmt_format.cmx \ + parsing/asttypes.cmi \ + typing/annot.cmi typing/ctype.cmo : \ typing/types.cmi \ typing/type_immediacy.cmi \ @@ -549,6 +581,7 @@ typing/envaux.cmo : \ typing/subst.cmi \ typing/printtyp.cmi \ typing/path.cmi \ + parsing/location.cmi \ typing/ident.cmi \ typing/env.cmi \ parsing/asttypes.cmi \ @@ -557,6 +590,7 @@ typing/envaux.cmx : \ typing/subst.cmx \ typing/printtyp.cmx \ typing/path.cmx \ + parsing/location.cmx \ typing/ident.cmx \ typing/env.cmx \ parsing/asttypes.cmi \ @@ -637,6 +671,7 @@ typing/includemod.cmo : \ typing/subst.cmi \ typing/printtyp.cmi \ typing/primitive.cmi \ + typing/predef.cmi \ typing/path.cmi \ typing/oprint.cmi \ typing/mtype.cmi \ @@ -658,6 +693,7 @@ typing/includemod.cmx : \ typing/subst.cmx \ typing/printtyp.cmx \ typing/primitive.cmx \ + typing/predef.cmx \ typing/path.cmx \ typing/oprint.cmx \ typing/mtype.cmx \ @@ -813,6 +849,7 @@ typing/persistent_env.cmi : \ file_formats/cmi_format.cmi typing/predef.cmo : \ typing/types.cmi \ + typing/type_immediacy.cmi \ typing/path.cmi \ parsing/parsetree.cmi \ parsing/location.cmi \ @@ -823,6 +860,7 @@ typing/predef.cmo : \ typing/predef.cmi typing/predef.cmx : \ typing/types.cmx \ + typing/type_immediacy.cmx \ typing/path.cmx \ parsing/parsetree.cmi \ parsing/location.cmx \ @@ -927,6 +965,7 @@ typing/printtyped.cmo : \ parsing/longident.cmi \ parsing/location.cmi \ typing/ident.cmi \ + utils/clflags.cmi \ parsing/asttypes.cmi \ typing/printtyped.cmi typing/printtyped.cmx : \ @@ -938,6 +977,7 @@ typing/printtyped.cmx : \ parsing/longident.cmx \ parsing/location.cmx \ typing/ident.cmx \ + utils/clflags.cmx \ parsing/asttypes.cmi \ typing/printtyped.cmi typing/printtyped.cmi : \ @@ -1056,7 +1096,6 @@ typing/typeclass.cmo : \ typing/typedecl.cmi \ typing/typecore.cmi \ typing/subst.cmi \ - typing/stypes.cmi \ typing/printtyp.cmi \ typing/predef.cmi \ typing/path.cmi \ @@ -1085,7 +1124,6 @@ typing/typeclass.cmx : \ typing/typedecl.cmx \ typing/typecore.cmx \ typing/subst.cmx \ - typing/stypes.cmx \ typing/printtyp.cmx \ typing/predef.cmx \ typing/path.cmx \ @@ -1122,7 +1160,6 @@ typing/typecore.cmo : \ typing/typedtree.cmi \ typing/typedecl.cmi \ typing/subst.cmi \ - typing/stypes.cmi \ typing/rec_check.cmi \ typing/printtyp.cmi \ typing/printpat.cmi \ @@ -1132,7 +1169,6 @@ typing/typecore.cmo : \ typing/path.cmi \ parsing/parsetree.cmi \ typing/parmatch.cmi \ - typing/oprint.cmi \ typing/mtype.cmi \ utils/misc.cmi \ parsing/longident.cmi \ @@ -1155,7 +1191,6 @@ typing/typecore.cmx : \ typing/typedtree.cmx \ typing/typedecl.cmx \ typing/subst.cmx \ - typing/stypes.cmx \ typing/rec_check.cmx \ typing/printtyp.cmx \ typing/printpat.cmx \ @@ -1165,7 +1200,6 @@ typing/typecore.cmx : \ typing/path.cmx \ parsing/parsetree.cmi \ typing/parmatch.cmx \ - typing/oprint.cmx \ typing/mtype.cmx \ utils/misc.cmx \ parsing/longident.cmx \ @@ -1200,12 +1234,14 @@ typing/typedecl.cmo : \ typing/typedtree.cmi \ typing/typedecl_variance.cmi \ typing/typedecl_unboxed.cmi \ + typing/typedecl_separability.cmi \ typing/typedecl_immediacy.cmi \ typing/type_immediacy.cmi \ typing/subst.cmi \ typing/printtyp.cmi \ typing/primitive.cmi \ typing/predef.cmi \ + parsing/pprintast.cmi \ typing/path.cmi \ parsing/parsetree.cmi \ typing/oprint.cmi \ @@ -1215,7 +1251,6 @@ typing/typedecl.cmo : \ typing/includecore.cmi \ typing/ident.cmi \ typing/env.cmi \ - typing/datarepr.cmi \ typing/ctype.cmi \ utils/config.cmi \ utils/clflags.cmi \ @@ -1233,12 +1268,14 @@ typing/typedecl.cmx : \ typing/typedtree.cmx \ typing/typedecl_variance.cmx \ typing/typedecl_unboxed.cmx \ + typing/typedecl_separability.cmx \ typing/typedecl_immediacy.cmx \ typing/type_immediacy.cmx \ typing/subst.cmx \ typing/printtyp.cmx \ typing/primitive.cmx \ typing/predef.cmx \ + parsing/pprintast.cmx \ typing/path.cmx \ parsing/parsetree.cmi \ typing/oprint.cmx \ @@ -1248,7 +1285,6 @@ typing/typedecl.cmx : \ typing/includecore.cmx \ typing/ident.cmx \ typing/env.cmx \ - typing/datarepr.cmx \ typing/ctype.cmx \ utils/config.cmx \ utils/clflags.cmx \ @@ -1263,6 +1299,7 @@ typing/typedecl.cmi : \ typing/types.cmi \ typing/typedtree.cmi \ typing/typedecl_variance.cmi \ + typing/typedecl_separability.cmi \ typing/typedecl_immediacy.cmi \ typing/path.cmi \ parsing/parsetree.cmi \ @@ -1312,6 +1349,32 @@ typing/typedecl_properties.cmi : \ typing/types.cmi \ typing/ident.cmi \ typing/env.cmi +typing/typedecl_separability.cmo : \ + typing/types.cmi \ + typing/typedecl_properties.cmi \ + parsing/location.cmi \ + typing/env.cmi \ + typing/ctype.cmi \ + utils/config.cmi \ + typing/btype.cmi \ + parsing/asttypes.cmi \ + typing/typedecl_separability.cmi +typing/typedecl_separability.cmx : \ + typing/types.cmx \ + typing/typedecl_properties.cmx \ + parsing/location.cmx \ + typing/env.cmx \ + typing/ctype.cmx \ + utils/config.cmx \ + typing/btype.cmx \ + parsing/asttypes.cmi \ + typing/typedecl_separability.cmi +typing/typedecl_separability.cmi : \ + typing/types.cmi \ + typing/typedecl_properties.cmi \ + parsing/location.cmi \ + typing/ident.cmi \ + typing/env.cmi typing/typedecl_unboxed.cmo : \ typing/types.cmi \ typing/predef.cmi \ @@ -1401,10 +1464,10 @@ typing/typemod.cmo : \ typing/typecore.cmi \ typing/typeclass.cmi \ typing/subst.cmi \ - typing/stypes.cmi \ typing/printtyp.cmi \ typing/path.cmi \ parsing/parsetree.cmi \ + parsing/parse.cmi \ typing/mtype.cmi \ utils/misc.cmi \ parsing/longident.cmi \ @@ -1416,6 +1479,7 @@ typing/typemod.cmo : \ typing/ctype.cmi \ utils/config.cmi \ file_formats/cmt_format.cmi \ + typing/cmt2annot.cmo \ file_formats/cmi_format.cmi \ utils/clflags.cmi \ parsing/builtin_attributes.cmi \ @@ -1433,10 +1497,10 @@ typing/typemod.cmx : \ typing/typecore.cmx \ typing/typeclass.cmx \ typing/subst.cmx \ - typing/stypes.cmx \ typing/printtyp.cmx \ typing/path.cmx \ parsing/parsetree.cmi \ + parsing/parse.cmx \ typing/mtype.cmx \ utils/misc.cmx \ parsing/longident.cmx \ @@ -1448,6 +1512,7 @@ typing/typemod.cmx : \ typing/ctype.cmx \ utils/config.cmx \ file_formats/cmt_format.cmx \ + typing/cmt2annot.cmx \ file_formats/cmi_format.cmx \ utils/clflags.cmx \ parsing/builtin_attributes.cmx \ @@ -1508,7 +1573,9 @@ typing/types.cmo : \ utils/misc.cmi \ parsing/longident.cmi \ parsing/location.cmi \ + utils/identifiable.cmi \ typing/ident.cmi \ + utils/config.cmi \ parsing/asttypes.cmi \ typing/types.cmi typing/types.cmx : \ @@ -1519,7 +1586,9 @@ typing/types.cmx : \ utils/misc.cmx \ parsing/longident.cmx \ parsing/location.cmx \ + utils/identifiable.cmx \ typing/ident.cmx \ + utils/config.cmx \ parsing/asttypes.cmi \ typing/types.cmi typing/types.cmi : \ @@ -1529,6 +1598,7 @@ typing/types.cmi : \ parsing/parsetree.cmi \ parsing/longident.cmi \ parsing/location.cmi \ + utils/identifiable.cmi \ typing/ident.cmi \ parsing/asttypes.cmi typing/typetexp.cmo : \ @@ -1621,7 +1691,9 @@ bytecomp/bytegen.cmo : \ bytecomp/instruct.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ utils/config.cmi \ + utils/clflags.cmi \ parsing/asttypes.cmi \ bytecomp/bytegen.cmi bytecomp/bytegen.cmx : \ @@ -1635,7 +1707,9 @@ bytecomp/bytegen.cmx : \ bytecomp/instruct.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ utils/config.cmx \ + utils/clflags.cmx \ parsing/asttypes.cmi \ bytecomp/bytegen.cmi bytecomp/bytegen.cmi : \ @@ -2153,10 +2227,12 @@ asmcomp/branch_relaxation.cmi : \ asmcomp/branch_relaxation_intf.cmo asmcomp/branch_relaxation_intf.cmo : \ asmcomp/linear.cmi \ + lambda/debuginfo.cmi \ asmcomp/cmm.cmi \ asmcomp/arch.cmo asmcomp/branch_relaxation_intf.cmx : \ asmcomp/linear.cmx \ + lambda/debuginfo.cmx \ asmcomp/cmm.cmx \ asmcomp/arch.cmx asmcomp/cmm.cmo : \ @@ -2228,7 +2304,6 @@ asmcomp/cmm_helpers.cmx : \ asmcomp/cmm_helpers.cmi : \ utils/targetint.cmi \ typing/primitive.cmi \ - parsing/location.cmi \ lambda/lambda.cmi \ lambda/debuginfo.cmi \ file_formats/cmx_format.cmi \ @@ -2308,12 +2383,14 @@ asmcomp/coloring.cmi : asmcomp/comballoc.cmo : \ asmcomp/reg.cmi \ asmcomp/mach.cmi \ + lambda/debuginfo.cmi \ utils/config.cmi \ asmcomp/arch.cmo \ asmcomp/comballoc.cmi asmcomp/comballoc.cmx : \ asmcomp/reg.cmx \ asmcomp/mach.cmx \ + lambda/debuginfo.cmx \ utils/config.cmx \ asmcomp/arch.cmx \ asmcomp/comballoc.cmi @@ -2345,13 +2422,13 @@ asmcomp/emit.cmo : \ asmcomp/x86_ast.cmi \ asmcomp/reg.cmi \ asmcomp/proc.cmi \ + utils/numbers.cmi \ utils/misc.cmi \ asmcomp/mach.cmi \ asmcomp/linear.cmi \ lambda/lambda.cmi \ asmcomp/emitaux.cmi \ utils/domainstate.cmi \ - lambda/debuginfo.cmi \ utils/config.cmi \ middle_end/compilenv.cmi \ asmcomp/cmm.cmi \ @@ -2367,13 +2444,13 @@ asmcomp/emit.cmx : \ asmcomp/x86_ast.cmi \ asmcomp/reg.cmx \ asmcomp/proc.cmx \ + utils/numbers.cmx \ utils/misc.cmx \ asmcomp/mach.cmx \ asmcomp/linear.cmx \ lambda/lambda.cmx \ asmcomp/emitaux.cmx \ utils/domainstate.cmx \ - lambda/debuginfo.cmx \ utils/config.cmx \ middle_end/compilenv.cmx \ asmcomp/cmm.cmx \ @@ -2534,6 +2611,7 @@ asmcomp/printcmm.cmo : \ lambda/lambda.cmi \ lambda/debuginfo.cmi \ asmcomp/cmm.cmi \ + utils/clflags.cmi \ middle_end/backend_var.cmi \ parsing/asttypes.cmi \ asmcomp/printcmm.cmi @@ -2542,6 +2620,7 @@ asmcomp/printcmm.cmx : \ lambda/lambda.cmx \ lambda/debuginfo.cmx \ asmcomp/cmm.cmx \ + utils/clflags.cmx \ middle_end/backend_var.cmx \ parsing/asttypes.cmi \ asmcomp/printcmm.cmi @@ -2554,6 +2633,7 @@ asmcomp/printlinear.cmo : \ asmcomp/linear.cmi \ lambda/lambda.cmi \ lambda/debuginfo.cmi \ + utils/clflags.cmi \ asmcomp/printlinear.cmi asmcomp/printlinear.cmx : \ asmcomp/printmach.cmx \ @@ -2561,6 +2641,7 @@ asmcomp/printlinear.cmx : \ asmcomp/linear.cmx \ lambda/lambda.cmx \ lambda/debuginfo.cmx \ + utils/clflags.cmx \ asmcomp/printlinear.cmi asmcomp/printlinear.cmi : \ asmcomp/linear.cmi @@ -2725,6 +2806,7 @@ asmcomp/selectgen.cmi : \ lambda/debuginfo.cmi \ asmcomp/cmm.cmi \ middle_end/backend_var.cmi \ + parsing/asttypes.cmi \ asmcomp/arch.cmo asmcomp/selection.cmo : \ asmcomp/spacetime_profiling.cmi \ @@ -2808,7 +2890,6 @@ asmcomp/split.cmx : \ asmcomp/split.cmi : \ asmcomp/mach.cmi asmcomp/strmatch.cmo : \ - parsing/location.cmi \ lambda/lambda.cmi \ lambda/debuginfo.cmi \ asmcomp/cmm.cmi \ @@ -2817,7 +2898,6 @@ asmcomp/strmatch.cmo : \ asmcomp/arch.cmo \ asmcomp/strmatch.cmi asmcomp/strmatch.cmx : \ - parsing/location.cmx \ lambda/lambda.cmx \ lambda/debuginfo.cmx \ asmcomp/cmm.cmx \ @@ -2826,7 +2906,6 @@ asmcomp/strmatch.cmx : \ asmcomp/arch.cmx \ asmcomp/strmatch.cmi asmcomp/strmatch.cmi : \ - parsing/location.cmi \ lambda/debuginfo.cmi \ asmcomp/cmm.cmi asmcomp/x86_ast.cmi : @@ -2887,11 +2966,13 @@ middle_end/backend_var.cmo : \ typing/path.cmi \ typing/ident.cmi \ lambda/debuginfo.cmi \ + utils/clflags.cmi \ middle_end/backend_var.cmi middle_end/backend_var.cmx : \ typing/path.cmx \ typing/ident.cmx \ lambda/debuginfo.cmx \ + utils/clflags.cmx \ middle_end/backend_var.cmi middle_end/backend_var.cmi : \ typing/path.cmi \ @@ -3028,14 +3109,15 @@ middle_end/internal_variable_names.cmo : \ parsing/location.cmi \ lambda/lambda.cmi \ utils/int_replace_polymorphic_compare.cmi \ + lambda/debuginfo.cmi \ middle_end/internal_variable_names.cmi middle_end/internal_variable_names.cmx : \ parsing/location.cmx \ lambda/lambda.cmx \ utils/int_replace_polymorphic_compare.cmx \ + lambda/debuginfo.cmx \ middle_end/internal_variable_names.cmi middle_end/internal_variable_names.cmi : \ - parsing/location.cmi \ lambda/lambda.cmi middle_end/linkage_name.cmo : \ utils/int_replace_polymorphic_compare.cmi \ @@ -3136,22 +3218,28 @@ middle_end/variable.cmi : \ lambda/debuginfo.cmo : \ parsing/location.cmi \ utils/int_replace_polymorphic_compare.cmi \ + typing/ident.cmi \ + parsing/asttypes.cmi \ lambda/debuginfo.cmi lambda/debuginfo.cmx : \ parsing/location.cmx \ utils/int_replace_polymorphic_compare.cmx \ + typing/ident.cmx \ + parsing/asttypes.cmi \ lambda/debuginfo.cmi lambda/debuginfo.cmi : \ - parsing/location.cmi + parsing/location.cmi \ + typing/ident.cmi \ + parsing/asttypes.cmi lambda/lambda.cmo : \ typing/types.cmi \ typing/primitive.cmi \ typing/path.cmi \ utils/misc.cmi \ parsing/longident.cmi \ - parsing/location.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ parsing/asttypes.cmi \ lambda/lambda.cmi lambda/lambda.cmx : \ @@ -3160,18 +3248,18 @@ lambda/lambda.cmx : \ typing/path.cmx \ utils/misc.cmx \ parsing/longident.cmx \ - parsing/location.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ parsing/asttypes.cmi \ lambda/lambda.cmi lambda/lambda.cmi : \ typing/types.cmi \ typing/primitive.cmi \ typing/path.cmi \ - parsing/location.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ parsing/asttypes.cmi lambda/matching.cmo : \ typing/types.cmi \ @@ -3189,6 +3277,7 @@ lambda/matching.cmo : \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ utils/clflags.cmi \ typing/btype.cmi \ parsing/asttypes.cmi \ @@ -3209,6 +3298,7 @@ lambda/matching.cmx : \ lambda/lambda.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ utils/clflags.cmx \ typing/btype.cmx \ parsing/asttypes.cmi \ @@ -3217,7 +3307,8 @@ lambda/matching.cmi : \ typing/typedtree.cmi \ parsing/location.cmi \ lambda/lambda.cmi \ - typing/ident.cmi + typing/ident.cmi \ + lambda/debuginfo.cmi lambda/printlambda.cmo : \ typing/types.cmi \ typing/printtyp.cmi \ @@ -3225,6 +3316,8 @@ lambda/printlambda.cmo : \ parsing/location.cmi \ lambda/lambda.cmi \ typing/ident.cmi \ + lambda/debuginfo.cmi \ + utils/clflags.cmi \ parsing/asttypes.cmi \ lambda/printlambda.cmi lambda/printlambda.cmx : \ @@ -3234,6 +3327,8 @@ lambda/printlambda.cmx : \ parsing/location.cmx \ lambda/lambda.cmx \ typing/ident.cmx \ + lambda/debuginfo.cmx \ + utils/clflags.cmx \ parsing/asttypes.cmi \ lambda/printlambda.cmi lambda/printlambda.cmi : \ @@ -3246,38 +3341,32 @@ lambda/runtimedef.cmx : \ lambda/runtimedef.cmi : lambda/simplif.cmo : \ utils/warnings.cmi \ - typing/stypes.cmi \ typing/primitive.cmi \ parsing/location.cmi \ lambda/lambda.cmi \ typing/ident.cmi \ + lambda/debuginfo.cmi \ utils/clflags.cmi \ parsing/asttypes.cmi \ - typing/annot.cmi \ lambda/simplif.cmi lambda/simplif.cmx : \ utils/warnings.cmx \ - typing/stypes.cmx \ typing/primitive.cmx \ parsing/location.cmx \ lambda/lambda.cmx \ typing/ident.cmx \ + lambda/debuginfo.cmx \ utils/clflags.cmx \ parsing/asttypes.cmi \ - typing/annot.cmi \ lambda/simplif.cmi lambda/simplif.cmi : \ - parsing/location.cmi \ lambda/lambda.cmi \ typing/ident.cmi lambda/switch.cmo : \ - parsing/location.cmi \ lambda/switch.cmi lambda/switch.cmx : \ - parsing/location.cmx \ lambda/switch.cmi -lambda/switch.cmi : \ - parsing/location.cmi +lambda/switch.cmi : lambda/translattribute.cmo : \ utils/warnings.cmi \ typing/typedtree.cmi \ @@ -3315,6 +3404,7 @@ lambda/translclass.cmo : \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ utils/clflags.cmi \ typing/btype.cmi \ parsing/asttypes.cmi \ @@ -3331,6 +3421,7 @@ lambda/translclass.cmx : \ lambda/lambda.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ utils/clflags.cmx \ typing/btype.cmx \ parsing/asttypes.cmi \ @@ -3340,6 +3431,7 @@ lambda/translclass.cmi : \ parsing/location.cmi \ lambda/lambda.cmi \ typing/ident.cmi \ + lambda/debuginfo.cmi \ parsing/asttypes.cmi lambda/translcore.cmo : \ typing/types.cmi \ @@ -3362,6 +3454,7 @@ lambda/translcore.cmo : \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ utils/config.cmi \ utils/clflags.cmi \ typing/btype.cmi \ @@ -3388,6 +3481,7 @@ lambda/translcore.cmx : \ lambda/lambda.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ utils/config.cmx \ utils/clflags.cmx \ typing/btype.cmx \ @@ -3400,6 +3494,7 @@ lambda/translcore.cmi : \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ parsing/asttypes.cmi lambda/translmod.cmo : \ typing/types.cmi \ @@ -3418,6 +3513,7 @@ lambda/translmod.cmo : \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ typing/ctype.cmi \ utils/clflags.cmi \ parsing/asttypes.cmi \ @@ -3439,6 +3535,7 @@ lambda/translmod.cmx : \ lambda/lambda.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ typing/ctype.cmx \ utils/clflags.cmx \ parsing/asttypes.cmi \ @@ -3452,7 +3549,6 @@ lambda/translmod.cmi : \ lambda/translobj.cmo : \ typing/primitive.cmi \ utils/misc.cmi \ - parsing/location.cmi \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ @@ -3464,7 +3560,6 @@ lambda/translobj.cmo : \ lambda/translobj.cmx : \ typing/primitive.cmx \ utils/misc.cmx \ - parsing/location.cmx \ lambda/lambda.cmx \ typing/ident.cmx \ typing/env.cmx \ @@ -3490,6 +3585,7 @@ lambda/translprim.cmo : \ lambda/lambda.cmi \ typing/ident.cmi \ typing/env.cmi \ + lambda/debuginfo.cmi \ utils/config.cmi \ utils/clflags.cmi \ parsing/asttypes.cmi \ @@ -3507,6 +3603,7 @@ lambda/translprim.cmx : \ lambda/lambda.cmx \ typing/ident.cmx \ typing/env.cmx \ + lambda/debuginfo.cmx \ utils/config.cmx \ utils/clflags.cmx \ parsing/asttypes.cmi \ @@ -3855,7 +3952,6 @@ middle_end/flambda/closure_conversion_aux.cmo : \ utils/numbers.cmi \ middle_end/flambda/base_types/mutable_variable.cmi \ utils/misc.cmi \ - parsing/location.cmi \ lambda/lambda.cmi \ utils/int_replace_polymorphic_compare.cmi \ typing/ident.cmi \ @@ -3867,7 +3963,6 @@ middle_end/flambda/closure_conversion_aux.cmx : \ utils/numbers.cmx \ middle_end/flambda/base_types/mutable_variable.cmx \ utils/misc.cmx \ - parsing/location.cmx \ lambda/lambda.cmx \ utils/int_replace_polymorphic_compare.cmx \ typing/ident.cmx \ @@ -3877,7 +3972,6 @@ middle_end/flambda/closure_conversion_aux.cmi : \ middle_end/symbol.cmi \ middle_end/flambda/base_types/static_exception.cmi \ middle_end/flambda/base_types/mutable_variable.cmi \ - parsing/location.cmi \ lambda/lambda.cmi \ typing/ident.cmi middle_end/flambda/closure_offsets.cmo : \ @@ -5652,7 +5746,6 @@ driver/compile_common.cmo : \ typing/typemod.cmi \ typing/typedtree.cmi \ typing/typecore.cmi \ - typing/stypes.cmi \ utils/profile.cmi \ typing/printtyped.cmi \ typing/printtyp.cmi \ @@ -5673,7 +5766,6 @@ driver/compile_common.cmx : \ typing/typemod.cmx \ typing/typedtree.cmx \ typing/typecore.cmx \ - typing/stypes.cmx \ utils/profile.cmx \ typing/printtyped.cmx \ typing/printtyp.cmx \ @@ -5695,6 +5787,7 @@ driver/compile_common.cmi : \ typing/env.cmi driver/compmisc.cmo : \ utils/warnings.cmi \ + typing/types.cmi \ typing/typemod.cmi \ utils/misc.cmi \ parsing/location.cmi \ @@ -5707,6 +5800,7 @@ driver/compmisc.cmo : \ driver/compmisc.cmi driver/compmisc.cmx : \ utils/warnings.cmx \ + typing/types.cmx \ typing/typemod.cmx \ utils/misc.cmx \ parsing/location.cmx \ @@ -5781,7 +5875,6 @@ driver/makedepend.cmo : \ parsing/parser.cmi \ parsing/parse.cmi \ utils/misc.cmi \ - parsing/longident.cmi \ parsing/location.cmi \ parsing/lexer.cmi \ parsing/depend.cmi \ @@ -5795,7 +5888,6 @@ driver/makedepend.cmx : \ parsing/parser.cmx \ parsing/parse.cmx \ utils/misc.cmx \ - parsing/longident.cmx \ parsing/location.cmx \ parsing/lexer.cmx \ parsing/depend.cmx \ @@ -5928,13 +6020,16 @@ toplevel/expunge.cmx : \ bytecomp/bytesections.cmx toplevel/genprintval.cmo : \ typing/types.cmi \ + parsing/syntaxerr.cmi \ typing/printtyp.cmi \ typing/predef.cmi \ typing/path.cmi \ + parsing/parse.cmi \ typing/outcometree.cmi \ typing/oprint.cmi \ utils/misc.cmi \ parsing/longident.cmi \ + parsing/lexer.cmi \ typing/ident.cmi \ typing/env.cmi \ typing/datarepr.cmi \ @@ -5943,13 +6038,16 @@ toplevel/genprintval.cmo : \ toplevel/genprintval.cmi toplevel/genprintval.cmx : \ typing/types.cmx \ + parsing/syntaxerr.cmx \ typing/printtyp.cmx \ typing/predef.cmx \ typing/path.cmx \ + parsing/parse.cmx \ typing/outcometree.cmi \ typing/oprint.cmx \ utils/misc.cmx \ parsing/longident.cmx \ + parsing/lexer.cmx \ typing/ident.cmx \ typing/env.cmx \ typing/datarepr.cmx \ diff --git a/.gitattributes b/.gitattributes index 9be9e33a..200eb49c 100644 --- a/.gitattributes +++ b/.gitattributes @@ -116,7 +116,8 @@ testsuite/tests/**/*.reference typo.prune # Expect tests with overly long lines of expected output testsuite/tests/parsing/docstrings.ml typo.very-long-line -tools/magic typo.missing-header +tools/magic typo.missing-header +tools/eventlog_metadata.in typo.missing-header # TODO we should fix the long-line errors in yacc/*.c /yacc/*.[ch] typo.very-long-line=may @@ -142,7 +143,6 @@ menhir-bench.bash typo.missing-header typo.utf8 /tools/ci/appveyor/appveyor_build.cmd text eol=crlf configure.ac text eol=lf -autogen text eol=lf build-aux/compile text eol=lf build-aux/config.guess text eol=lf build-aux/config.sub text eol=lf @@ -150,8 +150,10 @@ build-aux/install text eol=lf build-aux/missing text eol=lf ocamldoc/remove_DEBUG text eol=lf ocamltest/getocamloptdefaultflags text eol=lf +ocamltest/ocamltest.org typo.long-line=may typo.missing-header stdlib/Compflags text eol=lf stdlib/sharpbang text eol=lf +tools/autogen text eol=lf tools/ci/inria/remove-sinh-primitive.patch text eol=lf tools/check-typo text eol=lf tools/ci-build text eol=lf diff --git a/.gitignore b/.gitignore index 5da73a82..ff94e3c7 100644 --- a/.gitignore +++ b/.gitignore @@ -73,9 +73,9 @@ _build /bytecomp/opcodes.ml /bytecomp/opcodes.mli -/debugger/lexer.ml -/debugger/parser.ml -/debugger/parser.mli +/debugger/debugger_lexer.ml +/debugger/debugger_parser.ml +/debugger/debugger_parser.mli /debugger/ocamldebug /emacs/ocamltags @@ -120,6 +120,7 @@ _build /ocamltest/tsl_lexer.ml /ocamltest/tsl_parser.ml /ocamltest/tsl_parser.mli +/ocamltest/ocamltest.html /otherlibs/dynlink/extract_crc /otherlibs/dynlink/dynlink_platform_intf.mli @@ -258,6 +259,7 @@ _build /tools/make_opcodes /tools/make_opcodes.ml /tools/caml-tex +/tools/eventlog_metadata /utils/config.ml /utils/domainstate.ml diff --git a/.travis.yml b/.travis.yml index 8fbf24c6..48bbfb99 100644 --- a/.travis.yml +++ b/.travis.yml @@ -14,7 +14,6 @@ #************************************************************************** dist: xenial -sudo: false language: c git: submodules: false diff --git a/BOOTSTRAP.adoc b/BOOTSTRAP.adoc index dbd99675..e73d01fe 100644 --- a/BOOTSTRAP.adoc +++ b/BOOTSTRAP.adoc @@ -6,10 +6,10 @@ update the binaries in the link:boot/[] directory. A bootstrap is required for example when something changes in the runtime system (the magic number of bytecode executables, the format of bytecode instructions, the set of available primitives) or when the -format of .cmi files is modified. In particular, given that the .cmi -files contain information related to types, modifying the way a type is -represented will modify the format of .cmi files and thus require a -bootstrap. +format of OCaml compilation object files like .cmi files is modified. In +particular, given that the .cmi files contain information related to +types, modifying the way a type is represented will modify the format +of .cmi files and thus require a bootstrap. Here is how to perform a change that requires a bootstrap: @@ -56,3 +56,7 @@ This will rebuild runtime/ocamlrun, ocamlc, etc. If you notice that this procedure fails for a given change you are trying to implement, please report it so that the procedure can be updated to also cope with your change. + +If you want to upstream your changes, indicate in the message of the +commit that the changes need a bootstrap. Perform the bootstrap and +commit the result of the bootstrap separately, after that commit. diff --git a/Changes b/Changes index 15fd521d..f4354afe 100644 --- a/Changes +++ b/Changes @@ -1,4 +1,562 @@ -OCaml 4.10.1 (20 August 2020) +OCaml 4.11.0 (19 August 2020) +--------------------------- + +(Changes that can break existing programs are marked with a "*") + +### Runtime system: + +- #9096: Print function names in backtraces. + Old output: + > Called from file "foo.ml", line 16, characters 42-53 + New output: + > Called from Foo.bar in file "foo.ml", line 16, characters 42-53 + (Stephen Dolan, review by Leo White and Mark Shinwell) + +- #9082: The instrumented runtime now records logs in the CTF format. + A new API is available in the runtime to collect runtime statistics, + replacing the previous instrumented runtime macros. + Gc.eventlog_pause and Gc.eventlog_resume were added to allow user to control + instrumentation in a running program. + See the manual for more information on how to use this instrumentation mode. + (Enguerrand Decorne and Stephen Dolan, with help and review from + David Allsopp, Sébastien Hinderer, review by Anil Madhavapeddy, + Nicolás Ojeda Bär, Shakthi Kannan, KC Sivaramakrishnan, Gabriel Scherer, + Guillaume Munch-Maccagnoni, Damien Doligez, Leo White, Daniel Bünzli + and Xavier Leroy) + +- #9230, #9362: Memprof support for native allocations. + (Jacques-Henri Jourdan and Stephen Dolan, review by Gabriel Scherer) + +- #8920, #9238, #9239, #9254, #9458: New API for statistical memory profiling + in Memprof.Gc. The new version does no longer use ephemerons and allows + registering callbacks for promotion and deallocation of memory + blocks. + The new API no longer gives the block tags to the allocation callback. + (Stephen Dolan and Jacques-Henri Jourdan, review by Damien Doligez + and Gabriel Scherer) + +- #9353: Reimplement `output_value` and the `Marshal.to_*` functions + using a hash table to detect sharing, instead of temporary in-place + modifications. This is a prerequisite for Multicore OCaml. + (Xavier Leroy and Basile Clément, review by Gabriel Scherer and + Stephen Dolan) + + +- #9119: Make [caml_stat_resize_noexc] compatible with the [realloc] + API when the old block is NULL. + (Jacques-Henri Jourdan, review by Xavier Leroy) + +- #9233: Restore the bytecode stack after an allocation. + (Stephen Dolan, review by Gabriel Scherer and Jacques-Henri Jourdan) + +- #9249: restore definition of ARCH_ALIGN_INT64 in m.h if the architecture + requires 64-bit integers to be double-word aligned (autoconf regression) + (David Allsopp, review by Sébastien Hinderer) + +- #9259: Made `Ephemeron.blit_key` and `Weak.blit` faster. They are now + linear in the size of the range being copied instead of depending on the + total sizes of the ephemerons or weak arrays involved. + (Arseniy Alekseyev, design advice by Leo White, review by François Bobot + and Damien Doligez) + +- #9279: Memprof optimisation. + (Stephen Dolan, review by Jacques-Henri Jourdan) + +- #9280: Micro-optimise allocations on amd64 to save a register. + (Stephen Dolan, review by Xavier Leroy) + +- #9426: build the Mingw ports with higher levels of GCC optimization + (Xavier Leroy, review by Sébastien Hinderer) + +* #9483: Remove accidental inclusion of in + The only release with the inclusion of stdio.h has been 4.10.0 + (Christopher Zimmermann, review by Xavier Leroy and David Allsopp) + +- #9282: Make Cconst_symbol have typ_int to fix no-naked-pointers mode. + (Stephen Dolan, review by Mark Shinwell, Xavier Leroy and Vincent Laviron) + +- #9497: Harmonise behaviour between bytecode and native code for + recursive module initialisation in one particular case (fixes #9494). + (Mark Shinwell, David Allsopp, Vincent Laviron, Xavier Leroy, + Geoff Reedy, original bug report by Arlen Cox) + +- #8791: use a variable-length encoding when marshalling bigarray dimensions, + avoiding overflow. + (Jeremy Yallop, Stephen Dolan, review by Xavier Leroy) + +### Code generation and optimizations: + +- #9441: Add RISC-V RV64G native-code backend. + (Nicolás Ojeda Bär, review by Xavier Leroy and Gabriel Scherer) + +- #9316, #9443, #9463, #9782: Use typing information from Clambda + for mutable Cmm variables. + (Stephen Dolan, review by Vincent Laviron, Guillaume Bury, Xavier Leroy, + and Gabriel Scherer; temporary bug report by Richard Jones) + +- #8637, #8805, #9247, #9296: Record debug info for each allocation. + (Stephen Dolan and Jacques-Henri Jourdan, review by Damien Doligez, + KC Sivaramakrishnan and Xavier Leroy) + + +- #9193: Make tuple matching optimisation apply to Lswitch and Lstringswitch. + (Stephen Dolan, review by Thomas Refis and Gabriel Scherer) + +- #9392: Visit registers at most once in Coloring.iter_preferred. + (Stephen Dolan, review by Pierre Chambart and Xavier Leroy) + +- #9549, #9557: Make -flarge-toc the default for PowerPC and introduce + -fsmall-toc to enable the previous behaviour. + (David Allsopp, report by Nathaniel Wesley Filardo, review by Xavier Leroy) + +### Language features + +- #8820, #9166: quoted extensions: {%foo|...|} is lighter syntax for + [%foo {||}], and {%foo bar|...|bar} for [%foo {bar|...|bar}]. + (Gabriel Radanne, Leo White, Gabriel Scherer and Pieter Goetschalckx, + request by Bikal Lem) + +- #7364, #2188, #9592, #9609: improvement of the unboxability check for types + with a single constructor. Mutually-recursive type declarations can + now contain unboxed types. This is based on the paper + https://arxiv.org/abs/1811.02300 + (Gabriel Scherer and Rodolphe Lepigre, + review by Jeremy Yallop, Damien Doligez and Frédéric Bour) + +- #1154, #1706: spellchecker hints and type-directed disambiguation + for extensible sum type constructors + (Florian Angeletti, review by Alain Frisch, Gabriel Radanne, Gabriel Scherer + and Leo White) + + +- #6673, #1132, #9617: Relax the handling of explicit polymorphic types. + This improves error messages in some polymorphic recursive definition, + and requires less polymorphic annotations in some cases of + mutually-recursive definitions involving polymorphic recursion. + (Leo White, review by Jacques Garrigue and Gabriel Scherer) + +- #9232: allow any class type paths in #-types, + For instance, "val f: #F(X).t -> unit" is now allowed. + (Florian Angeletti, review by Gabriel Scherer, suggestion by Leo White) + +### Standard library: + +- #9077: Add Seq.cons and Seq.append + (Sébastien Briais, review by Yawar Amin and Florian Angeletti) + +- #9235: Add Array.exists2 and Array.for_all2 + (Bernhard Schommer, review by Armaël Guéneau) + +- #9226: Add Seq.unfold. + (Jeremy Yallop, review by Hezekiah M. Carty, Gabriel Scherer and + Gabriel Radanne) + +- #9059: Added List.filteri function, same as List.filter but + with the index of the element. + (Léo Andrès, review by Alain Frisch) + +- #8894: Added List.fold_left_map function combining map and fold. + (Bernhard Schommer, review by Alain Frisch and github user @cfcs) + +- #9365: Set.filter_map and Map.filter_map + (Gabriel Scherer, review by Stephen Dolan and Nicolás Ojeda Bär) + + +- #9248: Add Printexc.default_uncaught_exception_handler + (Raphael Sousa Santos, review by Daniel Bünzli) + +- #8771: Lexing: add set_position and set_filename to change (fake) + the initial tracking position of the lexbuf. + (Konstantin Romanov, Miguel Lumapat, review by Gabriel Scherer, + Sébastien Hinderer, and David Allsopp) + +- #9237: `Format.pp_update_geometry ppf (fun geo -> {geo with ...})` + for formatter geometry changes that are robust to new geometry fields. + (Gabriel Scherer, review by Josh Berdine and Florian Angeletti) + +- #7110: Added Printf.ikbprintf and Printf.ibprintf + (Muskan Garg, review by Gabriel Scherer and Florian Angeletti) + +- #9266: Install pretty-printer for the exception Fun.Finally_raised. + (Guillaume Munch-Maccagnoni, review by Daniel Bünzli, Gabriel Radanne, + and Gabriel Scherer) + +### Other libraries: + +- #9106: Register printer for Unix_error in win32unix, as in unix. + (Christopher Zimmermann, review by David Allsopp) + +- #9183: Preserve exception backtrace of exceptions raised by top-level phrases + of dynlinked modules. + (Nicolás Ojeda Bär, review by Xavier Clerc and Gabriel Scherer) + +- #9320, #9550: under Windows, make sure that the Unix.exec* functions + properly quote their argument lists. + (Xavier Leroy, report by André Maroneze, review by Nicolás Ojeda Bär + and David Allsopp) + +- #9490, #9505: ensure proper rounding of file times returned by + Unix.stat, Unix.lstat, Unix.fstat. + (Xavier Leroy and Guillaume Melquiond, report by David Brown, + review by Gabriel Scherer and David Allsopp) + +### Tools: + +- #9283, #9455, #9457: add a new toplevel directive `#use_output ""` to + run a command and evaluate its output. + (Jérémie Dimino, review by David Allsopp) + + +- #6969: Argument -nocwd added to ocamldep + (Muskan Garg, review by Florian Angeletti) + +- #8676, #9594: turn debugger off in programs launched by the program + being debugged + (Xavier Leroy, report by Michael Soegtrop, review by Gabriel Scherer) + +- #9057: aid debugging the debugger by preserving backtraces of unhandled + exceptions. + (David Allsopp, review by Gabriel Scherer) + +- #9276: objinfo: cm[x]a print extra C options, objects and dlls in + the order given on the cli. Follow up to #4949. + (Daniel Bünzli, review by Gabriel Scherer) + +- #463: objinfo: better errors on object files coming + from a different (older or newer), incompatible compiler version. + (Gabriel Scherer, review by Gabriel Radanne and Damien Doligez) + +- #9181: make objinfo work on Cygwin and look for the caml_plugin_header + symbol in both the static and the dynamic symbol tables. + (Sébastien Hinderer, review by Gabriel Scherer and David Allsopp) + +* #9197: remove compatibility logic from #244 that was designed to + synchronize toplevel printing margins with Format.std_formatter, + but also resulted in unpredictable/fragile changes to formatter + margins. + Setting the margins on the desired formatters should now work. + typically on `Format.std_formatter`. + Note that there currently is no robust way to do this from the + toplevel, as applications may redirect toplevel printing. In + a compiler/toplevel driver, one should instead access + `Location.formatter_for_warnings`; it is not currently exposed + to the toplevel. + (Gabriel Scherer, review by Armaël Guéneau) + +- #9207, #9210: fix ocamlyacc to work correctly with up to 255 entry + points to the grammar. + (Andreas Abel, review by Xavier Leroy) + +- #9482, #9492: use diversions (@file) to work around OS limitations + on length of Sys.command argument. + (Xavier Leroy, report by Jérémie Dimino, review by David Allsopp) + +- #9552: restore ocamloptp build and installation + (Florian Angeletti, review by David Allsopp and Xavier Leroy) + +### Manual and documentation: + +- #9141: beginning of the ocamltest reference manual + (Sébastien Hinderer, review by Gabriel Scherer and Thomas Refis) + +- #9228: Various Map documentation improvements: add missing key argument in + the 'merge' example; clarify the relationship between input and output keys + in 'union'; note that find and find_opt return values, not bindings. + (Jeremy Yallop, review by Gabriel Scherer and Florian Angeletti) + +- #9255, #9300: reference chapter, split the expression grammar + (Florian Angeletti, report by Harrison Ainsworth, review by Gabriel Scherer) + +- #9325: documented base case for `List.for_all` and `List.exists` + (Glenn Slotte, review by Florian Angeletti) + +- #9410, #9422: replaced naive fibonacci example with gcd + (Anukriti Kumar, review by San Vu Ngoc, Florian Angeletti, Léo Andrès) + +- #9541: Add a documentation page for the instrumented runtime; + additional changes to option names in the instrumented runtime. + (Enguerrand Decorne, review by Anil Madhavapeddy, Gabriel Scherer, + Daniel Bünzli, David Allsopp, Florian Angeletti, + and Sébastien Hinderer) + +- #9610: manual, C FFI: naked pointers are deprecated, detail the + forward-compatible options for handling out-of-heap pointers. + (Xavier Leroy, review by Mark Shinwell, David Allsopp and Florian Angeletti) + +- #9618: clarify the Format documentation on the margin and maximum indentation + limit + (Florian Angeletti, review by Josh Berdine) + + +- #8644: fix formatting comment about @raise in stdlib's mli files + (Élie Brami, review by David Allsopp) + +- #9327, #9401: manual, fix infix attribute examples + (Florian Angeletti, report by David Cadé, review by Gabriel Scherer) + +- #9403: added a description for warning 67 and added a "." at the end of + warnings for consistency. + (Muskan Garg, review by Gabriel Scherer and Florian Angeletti) + +- #7708, #9580: Ensure Stdlib documentation index refers to Stdlib. + (Stephen Dolan, review by Florian Angeletti, report by Hannes Mehnert) + +### Compiler user-interface and warnings: + +- #9712: Update the version format to allow "~". + The new format is "major.minor[.patchlevel][(+|~)additional-info]", + for instance "4.12.0~beta1+flambda". + This is a documentation-only change for the 4.11 branch, the new format + will be used starting with the 4.12 branch. + (Florian Angeletti, review by Damien Doligez and Xavier Leroy) + +- #1664: make -output-complete-obj link the runtime native c libraries when + building shared libraries like `-output-obj`. + (Florian Angeletti, review by Nicolás Ojeda Bär) + +- #9349: Support [@inlined hint] attribute. + (Leo White, review by Stephen Dolan) + +- #2141: generate .annot files from cmt data; deprecate -annot. + (Nicolás Ojeda Bär, review by Alain Frisch, Gabriel Scherer and Damien + Doligez) + + +* #7678, #8631: ocamlc -c and ocamlopt -c pass same switches to the C + compiler when compiling .c files (in particular, this means ocamlopt + passes -fPIC on systems requiring it for shared library support). + (David Allsopp, report by Daniel Bünzli, review by Sébastien Hinderer) + +- #9074: reworded error message for non-regular structural types + (Florian Angeletti, review by Jacques Garrigue and Leo White, + report by Chas Emerick) + +- #8938: Extend ocamlopt option "-stop-after" to handle "scheduling" argument. + (Greta Yorsh, review by Florian Angeletti and Sébastien Hinderer) + +- #8945, #9086: Fix toplevel show directive to work with constructors + (Simon Parry, review by Gabriel Scherer, Jeremy Yallop, + Alain Frisch, Florian Angeletti) + +- #9107: improved error message for exceptions in module signature errors + (Gabriel Scherer, review by Florian Angeletti) + +- #9208: -dno-locations option to hide source locations (and debug events) + from intermediate-representation dumps (-dfoo). + (Gabriel Scherer, review by Vincent Laviron) + +- #9393: Improve recursive module usage warnings + (Leo White, review by Thomas Refis) + +- #9486: Fix configuration for the Haiku operating system + (Sylvain Kerjean, review by David Allsopp and Sébastien Hinderer) + +### Internal/compiler-libs changes: + +- #9021: expose compiler Longident.t parsers + (Florian Angeletti, review by Gabriel Scherer) + +- #9452: Add locations to docstring attributes + (Leo White, review by Gabriel Scherer) + + +- #463: a new Misc.Magic_number module for user-friendly parsing + and validation of OCaml magic numbers. + (Gabriel Scherer, review by Gabriel Radanne and Damien Doligez) + +- #1176: encourage better compatibility with older Microsoft C compilers by + using GCC's -Wdeclaration-after-statement when available. Introduce + Caml_inline to stop abuse of the inline keyword on MSVC and to help ensure + that only static inline is used in the codebase (erroneous instance in + runtime/win32.c removed). + (David Allsopp, review by Oliver Andrieu and Xavier Leroy) + +- #8934: Stop relying on location to track usage + (Thomas Refis, review by Gabriel Radanne) + +- #8970: separate value patterns (matching on values) from computation patterns + (matching on the effects of a copmutation) in the typedtree. + (Gabriel Scherer, review by Jacques Garrigue and Alain Frisch) + +- #9060: ensure that Misc.protect_refs preserves backtraces + (Gabriel Scherer, review by Guillaume Munch-Maccagnoni and David Allsopp) + +- #9078: make all compilerlibs/ available to ocamltest. + (Gabriel Scherer, review by Sébastien Hinderer) + +- #9079: typecore/parmatch: refactor ppat_of_type and refine + the use of backtracking on wildcard patterns + (Florian Angeletti, Jacques Garrigue, Gabriel Scherer, + review by Thomas Refis) + +- #9081: typedtree, make the pat_env field of pattern data immutable + (Gabriel Scherer, review by Jacques Garrigue, report by Alain Frisch) + +- #9178, #9182, #9196: refactor label-disambiguation (Typecore.NameChoice) + (Gabriel Scherer, Thomas Refis, Florian Angeletti and Jacques Garrigue, + reviewing each other without self-loops) + +- #9321, #9322, #9359, #9361, #9417, #9447: refactor the + pattern-matching compiler + (Thomas Refis and Gabriel Scherer, review by Florian Angeletti) + +- #9211, #9215, #9222: fix Makefile dependencies in + compilerlibs, dynlink, ocamltest. + (Gabriel Scherer, review by Vincent Laviron and David Allsopp) + +- #9305: Avoid polymorphic compare in Ident + (Leo White, review by Xavier Leroy and Gabriel Scherer) + +- #7927: refactor val_env met_env par_env to class_env + (Muskan Garg, review by Gabriel Scherer and Florian Angeletti) + +- #2324, #9613: Replace the caml_int_compare and caml_float_compare + (C functions) with primitives. + (Greta Yorsh, review by Stephen Dolan and Vincent Laviron) + +- #9246: Avoid rechecking functor applications + (Leo White, review by Jacques Garrigue) + +- #9402: Remove `sudo:false` from .travis.yml + (Hikaru Yoshimura) + +* #9411: forbid optional arguments reordering with -nolabels + (Thomas Refis, review by Frédéric Bour and Jacques Garrigue) + +- #9414: testsuite, ocamltest: keep test artifacts only on failure. + Use KEEP_TEST_DIR_ON_SUCCESS=1 to keep all artifacts. + (Gabriel Scherer, review by Sébastien Hinderer) + + +### Build system: + +- #9250: Add --disable-ocamltest to configure and disable building for + non-development builds. + (David Allsopp, review by Sébastien Hinderer) + +### Bug fixes: + +- #7520, #9547: Odd behaviour of refutation cases with polymorphic variants + (Jacques Garrigue, report by Leo White, reviews by Gabriel Scherer and Leo) + +- #7562, #9456: ocamlopt-generated code crashed on Alpine Linux on + ppc64le, arm, and i386. Fixed by turning PIE off for musl-based Linux + systems except amd64 (x86_64) and s390x. + (Xavier Leroy, review by Gabriel Scherer) + +- #7683, #1499: Fixes one case where the evaluation order in native-code + may not match the one in bytecode. + (Nicolás Ojeda Bär, report by Pierre Chambart, review by Gabriel Scherer) + +- #7696, #6608: Record expression deleted when all fields specified + (Jacques Garrigue, report by Jeremy Yallop) + +- #7741, #9645: Failure to report escaping type variable + (Jacques Garrigue, report by Gabriel Radanne, review by Gabriel Scherer) + +- #7817, #9546: Unsound inclusion check for polymorphic variant + (Jacques Garrigue, report by Mikhail Mandrykin, review by Gabriel Scherer) + +- #7897, #9537: Fix warning 38 for rebound extension constructors + (Leo White, review by Florian Angeletti) + +- #7917, #9426: Use GCC option -fexcess-precision=standard when available, + avoiding a problem with x87 excess precision in Float.round. + (Xavier Leroy, review by Sébastien Hinderer) + +- #9011: Allow linking .cmxa files with no units on MSVC by not requiring the + .lib file to be present. + (David Allsopp, report by Dimitry Bely, review by Xavier Leroy) + +- #9064: Relax the level handling when unifying row fields + (Leo White, review by Jacques Garrigue) + +- #9097: Do not emit references to dead labels introduced by #2321 (spacetime). + (Greta Yorsh, review by Mark Shinwell) + +- #9163: Treat loops properly in un_anf + (Leo White, review by Mark Shinwell, Pierre Chambart and Vincent Laviron) + +- #9189, #9281: fix a conflict with Gentoo build system + by removing an one-letter Makefile variable. + (Florian Angeletti, report by Ralph Seichter, review by David Allsopp + and Damien Doligez) + +- #9225: Do not drop bytecode debug info after C calls. + (Stephen Dolan, review by Gabriel Scherer and Jacques-Henri Jourdan) + +- #9231: Make sure a debug event (and the corresponding debug + information) is inserted after every primitive that can appear in a + collected call stack, and make sure ocamlc preserves such events + even if they are at tail position. + (Jacques-Henri Jourdan, review by Gabriel Scherer) + +- #9244: Fix some missing usage warnings + (Leo White, review by Florian Angeletti) + +- #9274, avoid reading cmi file while printing types + (Florian Angeletti, review by Gabriel Scherer) + +- #9307, #9345: reproducible env summaries for reproducible compilation + (Florian Angeletti, review by Leo White) + +- #9309, #9318: Fix exhaustivity checking with empty types + (Florian Angeletti, Stefan Muenzel and Thomas Refis, review by Gabriel Scherer + and Thomas Refis) + +- #9335: actually have --disable-stdlib-manpages not build the manpages + (implementation conflicted with #8837 which wasn't picked up in review) + (David Allsopp, review by Florian Angeletti and Sébastien Hinderer) + +- #9343: Re-enable `-short-paths` for some error messages + (Leo White, review by Florian Angeletti) + +- #9355, #9356: ocamldebug, fix a fatal error when printing values + whose type involves a functor application. + (Florian Angeletti, review by Gabriel Scherer, report by Cyril Six) + +- #9367: Make bytecode and native-code backtraces agree. + (Stephen Dolan, review by Gabriel Scherer) + +- #9375, #9477: add forgotten substitution when compiling anonymous modules + (Thomas Refis, review by Frédéric Bour, report by Andreas Hauptmann) + +- #9384, #9385: Fix copy scope bugs in substitutions + (Leo White, review by Thomas Refis, report by Nick Roberts) + +* #9388: Prohibit signature local types with constraints + (Leo White, review by Jacques Garrigue) + +- #9406, #9409: fix an error with packed module types from missing + cmis. + (Florian Angeletti, report by Thomas Leonard, review by Gabriel Radanne + and Gabriel Scherer) + +- #9415: Treat `open struct` as `include struct` in toplevel + (Leo White, review by Thomas Refis) + +- #9416: Avoid warning 58 in flambda ocamlnat + (Leo White, review by Florian Angeletti) + +- #9420: Fix memory leak when `caml_output_value_to_block` raises an exception + (Xavier Leroy, review by Guillaume Munch-Maccagnoni) + +- #9428: Fix truncated exception backtrace for C->OCaml callbacks + on Power and Z System + (Xavier Leroy, review by Nicolás Ojeda Bär) + +- #9623, #9642: fix typing environments in Typedecl.transl_with_constraint + (Gabriel Scherer, review by Jacques Garrigue and Leo White, + report by Hugo Heuzard) + +- #9695, #9702: no error when opening an alias to a missing module + (Jacques Garrigue, report and review by Gabriel Scherer) + +- #9714, #9724: Add a terminator to the `caml_domain_state` structure + to better ensure that members are correctly spaced. + (Antonin Décimo, review by David Allsopp and Xavier Leroy) + +OCaml 4.10 maintenance branch ----------------------------- ### Runtime system: @@ -27,19 +585,16 @@ OCaml 4.10.1 (20 August 2020) output channels would not be flushed). (Nicolás Ojeda Bär, review by David Allsopp) -- #9714, #9724: Use the C++ alignas keyword when compiling in C++ in MSVC. - Fixes a bug with MSVC C++ 2015 onwards. +- #9714, #9724: Use the C++ alignas keyword when compiling in C++. + Fixes a bug with MSVC C++ 2015/2017. Add a terminator to the + `caml_domain_state` structure to better ensure that members are + correctly spaced. (Antonin Décimo, review by David Allsopp and Xavier Leroy) - #9736, #9749: Compaction must start in a heap where all free blocks are blue, which was not the case with the best-fit allocator. (Damien Doligez, report and review by Leo White) -### Tools: - -- #9552: restore ocamloptp build and installation - (Florian Angeletti, review by David Allsopp and Xavier Leroy) - OCaml 4.10.0 (21 February 2020) ------------------------------- @@ -348,10 +903,6 @@ OCaml 4.10.0 (21 February 2020) - #9127, #9130: ocamldoc: fix the formatting of closing brace in record types. (David Allsopp, report by San Vu Ngoc) -- #9181: make objinfo work on Cygwin and look for the caml_plugin_header - symbol in both the static and the dynamic symbol tables. - (Sébastien Hinderer, review by Gabriel Scherer and David Allsopp) - ### Build system: - #8840: use ocaml{c,opt}.opt when available to build internal tools @@ -552,16 +1103,19 @@ OCaml 4.10.0 (21 February 2020) - #9261: Fix a soundness bug in Rec_check, new in 4.10 (from #8908) (Vincent Laviron, review by Jeremy Yallop and Gabriel Scherer) -OCaml 4.09 maintenance branch: ------------------------------- +- #9389: returns exit_code for better user response on linking_error + (Anukriti Kumar, review by Gabriel Scherer and sliquister) + +OCaml 4.09 maintenance branch +----------------------------- ### Build system: - #9383: Don't assume that AWKPATH includes . (David Allsopp, report by Ian Zimmerman) -OCaml 4.09.1 (16 Mars 2020): ----------------------------- +OCaml 4.09.1 (16 Mars 2020) +--------------------------- - #8855, #8858: Links for tools not created when installing with --disable-installing-byecode-programs (e.g. ocamldep.opt installed, but @@ -582,15 +1136,15 @@ OCaml 4.09.1 (16 Mars 2020): - #9050, #9076: install missing compilerlibs/ocamlmiddleend archives (Gabriel Scherer, review by Florian Angeletti, report by Olaf Hering) +- #9144, #9180: multiple definitions of global variables in the C runtime, + causing problems with GCC 10.0 and possibly with other C compilers + (Xavier Leroy, report by Jürgen Reuter, review by Mark Shinwell) + - #9180: pass -fno-common option to C compiler when available, so as to detect problematic multiple definitions of global variables in the C runtime (Xavier Leroy, review by Mark Shinwell) -- #9144, #9180: multiple definitions of global variables in the C runtime, - causing problems with GCC 10.0 and possibly with other C compilers - (Xavier Leroy, report by Jürgen Reuter, review by Mark Shinwell) - - #9128: Fix a bug in bytecode mode which could lead to a segmentation fault. The bug was caused by the fact that the atom table shared a page with some bytecode. The fix makes sure both the atom table and @@ -598,8 +1152,8 @@ OCaml 4.09.1 (16 Mars 2020): (Jacques-Henri Jourdan, review by Stephen Dolan, Xavier Leroy and Gabriel Scherer) -OCaml 4.09.0 (19 September 2019): ---------------------------------- +OCaml 4.09.0 (19 September 2019) +-------------------------------- ### Runtime system: @@ -738,6 +1292,9 @@ OCaml 4.09.0 (19 September 2019): - #8515: manual, precise constraints on reexported types (Florian Angeletti, review by Gabriel Scherer) +- #9327, #9401: manual, fix infix attribute examples + (Florian Angeletti, report by David Cadé, review by Gabriel Scherer) + ### Tools: - #2221: ocamldep will now correctly allow a .ml file in an include directory @@ -809,6 +1366,9 @@ OCaml 4.09.0 (19 September 2019): (Thomas Refis, review by David Allsopp, Florian Angeletti, Gabriel Radanne, Gabriel Scherer and Xavier Leroy) +- #9275: Short circuit simple inclusion checks + (Leo White, review by Thomas Refis) + ### Compiler distribution build system: - #2267: merge generation of header programs, also fixing parallel build on @@ -1331,6 +1891,9 @@ OCaml 4.08.0 (13 June 2019) - #8508: refresh \moduleref macro (Florian Angeletti, review by Gabriel Scherer) +- 9410: replaced fibonacci example with gcd of coreexamples manual + (Anukriti Kumar, review by San Vu Ngoc, Florian Angeletti, Léo Andrès) + ### Code generation and optimizations: - #7725, #1754: improve AFL instrumentation for objects and lazy values. @@ -2057,6 +2620,9 @@ OCaml 4.07.0 (10 July 2018) platforms, making this option unusable on platforms where it wasn't. (Jérémie Dimino, review by Sébastien Hinderer and Xavier Leroy) +- #9349: Support [@inlined hint] attribute. + (Leo White, review by Stephen Dolan) + ### Runtime system: - #515 #676 #7173: Add a public C API for weak arrays and diff --git a/HACKING.adoc b/HACKING.adoc index ea25c988..101f3f57 100644 --- a/HACKING.adoc +++ b/HACKING.adoc @@ -38,21 +38,15 @@ make runtop make tests ---- -5. Install in a new opam switch to try things out: -+ ----- -opam compiler-conf install ----- -+ -With opam 2, create a local opam switch with the compiler installed from -the current source directory: +6. Install in a new opam switch to try things out. With `opam` v2, create a local +opam switch with the compiler installed from the current source directory: + ---- opam switch create . --empty opam install . ---- -6. You did it, Well done! Consult link:CONTRIBUTING.md[] to send your contribution upstream. +7. You did it, Well done! Consult link:CONTRIBUTING.md[] to send your contribution upstream. See our <> for various helpful details, for example on how to automatically < +---- + +=== Testing with `opam` + +To test a particular branch `branch` of a public git repository +`$REPO` of the compiler in an `opam` v2 switch issue: + +---- +opam switch create ocaml-branch --empty +# Replace $VERSION by the trunk version +opam pin add ocaml-variants.$VERSION+branch git+https://$REPO#branch +---- === Useful Makefile targets diff --git a/Makefile b/Makefile index 0a95d319..2984178a 100644 --- a/Makefile +++ b/Makefile @@ -17,8 +17,21 @@ ROOTDIR = . +# The configure and *clean targets can all be run without running ./configure +# first. +# If no goals were specified (i.e. `make`), add defaultentry (since it requires +# ./configure to be run) +CAN_BE_UNCONFIGURED := $(strip \ + $(filter-out partialclean clean distclean configure, \ + $(if $(MAKECMDGOALS),$(MAKECMDGOALS),defaultentry))) + +ifeq "$(CAN_BE_UNCONFIGURED)" "" +-include Makefile.config +-include Makefile.common +else include Makefile.config include Makefile.common +endif .PHONY: defaultentry ifeq "$(NATIVE_COMPILER)" "true" @@ -38,7 +51,7 @@ include stdlib/StdlibModules CAMLC=$(BOOT_OCAMLC) -g -nostdlib -I boot -use-prims runtime/primitives CAMLOPT=$(CAMLRUN) ./ocamlopt -g -nostdlib -I stdlib -I otherlibs/dynlink -ARCHES=amd64 i386 arm arm64 power s390x +ARCHES=amd64 i386 arm arm64 power s390x riscv INCLUDES=-I utils -I parsing -I typing -I bytecomp -I file_formats \ -I lambda -I middle_end -I middle_end/closure \ -I middle_end/flambda -I middle_end/flambda/base_types \ @@ -63,218 +76,8 @@ DEPFLAGS=-slash DEPINCLUDES=$(INCLUDES) OCAMLDOC_OPT=$(WITH_OCAMLDOC:=.opt) +OCAMLTEST_OPT=$(WITH_OCAMLTEST:=.opt) -UTILS=utils/config.cmo utils/build_path_prefix_map.cmo utils/misc.cmo \ - utils/identifiable.cmo utils/numbers.cmo utils/arg_helper.cmo \ - utils/clflags.cmo utils/profile.cmo utils/load_path.cmo \ - utils/terminfo.cmo utils/ccomp.cmo utils/warnings.cmo \ - utils/consistbl.cmo utils/strongly_connected_components.cmo \ - utils/targetint.cmo utils/int_replace_polymorphic_compare.cmo \ - utils/domainstate.cmo - -PARSING=parsing/location.cmo parsing/longident.cmo \ - parsing/docstrings.cmo parsing/syntaxerr.cmo \ - parsing/ast_helper.cmo \ - parsing/pprintast.cmo \ - parsing/camlinternalMenhirLib.cmo parsing/parser.cmo \ - parsing/lexer.cmo parsing/parse.cmo parsing/printast.cmo \ - parsing/ast_mapper.cmo parsing/ast_iterator.cmo parsing/attr_helper.cmo \ - parsing/builtin_attributes.cmo parsing/ast_invariants.cmo parsing/depend.cmo - -TYPING=typing/ident.cmo typing/path.cmo \ - typing/primitive.cmo typing/type_immediacy.cmo typing/types.cmo \ - typing/btype.cmo typing/oprint.cmo \ - typing/subst.cmo typing/predef.cmo \ - typing/datarepr.cmo file_formats/cmi_format.cmo \ - typing/persistent_env.cmo typing/env.cmo \ - typing/typedtree.cmo typing/printtyped.cmo typing/ctype.cmo \ - typing/printtyp.cmo typing/includeclass.cmo \ - typing/mtype.cmo typing/envaux.cmo typing/includecore.cmo \ - typing/tast_iterator.cmo typing/tast_mapper.cmo \ - file_formats/cmt_format.cmo typing/untypeast.cmo \ - typing/includemod.cmo typing/typetexp.cmo typing/printpat.cmo \ - typing/parmatch.cmo typing/stypes.cmo \ - typing/typedecl_properties.cmo typing/typedecl_variance.cmo \ - typing/typedecl_unboxed.cmo typing/typedecl_immediacy.cmo \ - typing/typedecl.cmo typing/typeopt.cmo \ - typing/rec_check.cmo typing/typecore.cmo typing/typeclass.cmo \ - typing/typemod.cmo - -LAMBDA=lambda/debuginfo.cmo \ - lambda/lambda.cmo lambda/printlambda.cmo \ - lambda/switch.cmo lambda/matching.cmo \ - lambda/translobj.cmo lambda/translattribute.cmo \ - lambda/translprim.cmo lambda/translcore.cmo \ - lambda/translclass.cmo lambda/translmod.cmo \ - lambda/simplif.cmo lambda/runtimedef.cmo - -COMP=\ - bytecomp/meta.cmo bytecomp/opcodes.cmo \ - bytecomp/bytesections.cmo bytecomp/dll.cmo \ - bytecomp/symtable.cmo \ - driver/pparse.cmo driver/compenv.cmo \ - driver/main_args.cmo driver/compmisc.cmo \ - driver/makedepend.cmo \ - driver/compile_common.cmo - -COMMON=$(UTILS) $(PARSING) $(TYPING) $(LAMBDA) $(COMP) - -BYTECOMP=bytecomp/instruct.cmo bytecomp/bytegen.cmo \ - bytecomp/printinstr.cmo bytecomp/emitcode.cmo \ - bytecomp/bytelink.cmo bytecomp/bytelibrarian.cmo bytecomp/bytepackager.cmo \ - driver/errors.cmo driver/compile.cmo - -ARCH_SPECIFIC =\ - asmcomp/arch.ml asmcomp/proc.ml asmcomp/CSE.ml asmcomp/selection.ml \ - asmcomp/scheduling.ml asmcomp/reload.ml - -INTEL_ASM=\ - asmcomp/x86_proc.cmo \ - asmcomp/x86_dsl.cmo \ - asmcomp/x86_gas.cmo \ - asmcomp/x86_masm.cmo - -ARCH_SPECIFIC_ASMCOMP= -ifeq ($(ARCH),i386) -ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM) -endif -ifeq ($(ARCH),amd64) -ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM) -endif - -ASMCOMP=\ - $(ARCH_SPECIFIC_ASMCOMP) \ - asmcomp/arch.cmo \ - asmcomp/cmm.cmo asmcomp/printcmm.cmo \ - asmcomp/reg.cmo asmcomp/debug/reg_with_debug_info.cmo \ - asmcomp/debug/reg_availability_set.cmo \ - asmcomp/mach.cmo asmcomp/proc.cmo \ - asmcomp/afl_instrument.cmo \ - asmcomp/strmatch.cmo \ - asmcomp/cmmgen_state.cmo \ - asmcomp/cmm_helpers.cmo \ - asmcomp/cmmgen.cmo \ - asmcomp/interval.cmo \ - asmcomp/printmach.cmo asmcomp/selectgen.cmo \ - asmcomp/spacetime_profiling.cmo asmcomp/selection.cmo \ - asmcomp/comballoc.cmo \ - asmcomp/CSEgen.cmo asmcomp/CSE.cmo \ - asmcomp/liveness.cmo \ - asmcomp/spill.cmo asmcomp/split.cmo \ - asmcomp/interf.cmo asmcomp/coloring.cmo \ - asmcomp/linscan.cmo \ - asmcomp/reloadgen.cmo asmcomp/reload.cmo \ - asmcomp/deadcode.cmo \ - asmcomp/linear.cmo asmcomp/printlinear.cmo asmcomp/linearize.cmo \ - asmcomp/debug/available_regs.cmo \ - asmcomp/debug/compute_ranges_intf.cmo \ - asmcomp/debug/compute_ranges.cmo \ - asmcomp/schedgen.cmo asmcomp/scheduling.cmo \ - asmcomp/branch_relaxation_intf.cmo \ - asmcomp/branch_relaxation.cmo \ - asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \ - asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo \ - driver/opterrors.cmo driver/optcompile.cmo - -# Files under middle_end/ are not to reference files under asmcomp/. -# This ensures that the middle end can be linked (e.g. for objinfo) even when -# the native code compiler is not present for some particular target. - -MIDDLE_END_CLOSURE=\ - middle_end/closure/closure.cmo \ - middle_end/closure/closure_middle_end.cmo - -# Owing to dependencies through [Compilenv], which would be -# difficult to remove, some of the lower parts of Flambda (anything that is -# saved in a .cmx file) have to be included in the [MIDDLE_END] stanza, below. -MIDDLE_END_FLAMBDA=\ - middle_end/flambda/import_approx.cmo \ - middle_end/flambda/lift_code.cmo \ - middle_end/flambda/closure_conversion_aux.cmo \ - middle_end/flambda/closure_conversion.cmo \ - middle_end/flambda/initialize_symbol_to_let_symbol.cmo \ - middle_end/flambda/lift_let_to_initialize_symbol.cmo \ - middle_end/flambda/find_recursive_functions.cmo \ - middle_end/flambda/invariant_params.cmo \ - middle_end/flambda/inconstant_idents.cmo \ - middle_end/flambda/alias_analysis.cmo \ - middle_end/flambda/lift_constants.cmo \ - middle_end/flambda/share_constants.cmo \ - middle_end/flambda/simplify_common.cmo \ - middle_end/flambda/remove_unused_arguments.cmo \ - middle_end/flambda/remove_unused_closure_vars.cmo \ - middle_end/flambda/remove_unused_program_constructs.cmo \ - middle_end/flambda/simplify_boxed_integer_ops.cmo \ - middle_end/flambda/simplify_primitives.cmo \ - middle_end/flambda/inlining_stats_types.cmo \ - middle_end/flambda/inlining_stats.cmo \ - middle_end/flambda/inline_and_simplify_aux.cmo \ - middle_end/flambda/remove_free_vars_equal_to_args.cmo \ - middle_end/flambda/extract_projections.cmo \ - middle_end/flambda/augment_specialised_args.cmo \ - middle_end/flambda/unbox_free_vars_of_closures.cmo \ - middle_end/flambda/unbox_specialised_args.cmo \ - middle_end/flambda/unbox_closures.cmo \ - middle_end/flambda/inlining_transforms.cmo \ - middle_end/flambda/inlining_decision.cmo \ - middle_end/flambda/inline_and_simplify.cmo \ - middle_end/flambda/ref_to_variables.cmo \ - middle_end/flambda/flambda_invariants.cmo \ - middle_end/flambda/traverse_for_exported_symbols.cmo \ - middle_end/flambda/build_export_info.cmo \ - middle_end/flambda/closure_offsets.cmo \ - middle_end/flambda/un_anf.cmo \ - middle_end/flambda/flambda_to_clambda.cmo \ - middle_end/flambda/flambda_middle_end.cmo - -MIDDLE_END=\ - middle_end/internal_variable_names.cmo \ - middle_end/linkage_name.cmo \ - middle_end/compilation_unit.cmo \ - middle_end/variable.cmo \ - middle_end/flambda/base_types/closure_element.cmo \ - middle_end/flambda/base_types/closure_id.cmo \ - middle_end/symbol.cmo \ - middle_end/backend_var.cmo \ - middle_end/clambda_primitives.cmo \ - middle_end/printclambda_primitives.cmo \ - middle_end/clambda.cmo \ - middle_end/printclambda.cmo \ - middle_end/semantics_of_primitives.cmo \ - middle_end/convert_primitives.cmo \ - middle_end/flambda/base_types/id_types.cmo \ - middle_end/flambda/base_types/export_id.cmo \ - middle_end/flambda/base_types/tag.cmo \ - middle_end/flambda/base_types/mutable_variable.cmo \ - middle_end/flambda/base_types/set_of_closures_id.cmo \ - middle_end/flambda/base_types/set_of_closures_origin.cmo \ - middle_end/flambda/base_types/closure_origin.cmo \ - middle_end/flambda/base_types/var_within_closure.cmo \ - middle_end/flambda/base_types/static_exception.cmo \ - middle_end/flambda/pass_wrapper.cmo \ - middle_end/flambda/allocated_const.cmo \ - middle_end/flambda/parameter.cmo \ - middle_end/flambda/projection.cmo \ - middle_end/flambda/flambda.cmo \ - middle_end/flambda/flambda_iterators.cmo \ - middle_end/flambda/flambda_utils.cmo \ - middle_end/flambda/freshening.cmo \ - middle_end/flambda/effect_analysis.cmo \ - middle_end/flambda/inlining_cost.cmo \ - middle_end/flambda/simple_value_approx.cmo \ - middle_end/flambda/export_info.cmo \ - middle_end/flambda/export_info_for_pack.cmo \ - middle_end/compilenv.cmo \ - $(MIDDLE_END_CLOSURE) \ - $(MIDDLE_END_FLAMBDA) - -OPTCOMP=$(MIDDLE_END) $(ASMCOMP) - -TOPLEVEL=toplevel/genprintval.cmo toplevel/toploop.cmo \ - toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo - -OPTTOPLEVEL=toplevel/genprintval.cmo toplevel/opttoploop.cmo \ - toplevel/opttopdirs.cmo toplevel/opttopmain.cmo BYTESTART=driver/main.cmo OPTSTART=driver/optmain.cmo @@ -314,6 +117,9 @@ endif else endif +# targets for the compilerlibs/*.{cma,cmxa} archives +include compilerlibs/Makefile.compilerlibs + # The configuration file utils/config.ml: utils/config.mlp Makefile.config utils/Makefile @@ -329,6 +135,9 @@ utils/domainstate.ml: utils/domainstate.ml.c runtime/caml/domain_state.tbl utils/domainstate.mli: utils/domainstate.mli.c runtime/caml/domain_state.tbl $(CPP) -I runtime/caml $< > $@ +configure: configure.ac aclocal.m4 VERSION tools/autogen + tools/autogen + .PHONY: partialclean partialclean:: rm -f utils/config.ml utils/domainstate.ml utils/domainstate.mli @@ -413,12 +222,13 @@ opt.opt: checknative $(MAKE) ocaml $(MAKE) opt-core $(MAKE) ocamlc.opt - $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) ocamltest + $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) \ + $(WITH_OCAMLTEST) $(MAKE) ocamlopt.opt $(MAKE) otherlibrariesopt $(MAKE) ocamllex.opt ocamltoolsopt ocamltoolsopt.opt $(OCAMLDOC_OPT) \ - ocamltest.opt -ifneq "$(WITH_OCAMLDOC)" "" + $(OCAMLTEST_OPT) +ifeq "$(WITH_OCAMLDOC)-$(STDLIB_MANPAGES)" "ocamldoc-true" $(MAKE) manpages endif @@ -447,8 +257,9 @@ coreboot: .PHONY: all all: coreall $(MAKE) ocaml - $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) ocamltest -ifneq "$(WITH_OCAMLDOC)" "" + $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) \ + $(WITH_OCAMLTEST) +ifeq "$(WITH_OCAMLDOC)-$(STDLIB_MANPAGES)" "ocamldoc-true" $(MAKE) manpages endif @@ -783,20 +594,8 @@ manual-pregen: opt.opt # The clean target clean:: partialclean -# Shared parts of the system - -compilerlibs/ocamlcommon.cma: $(COMMON) - $(CAMLC) -a -linkall -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamlcommon.cma - # The bytecode compiler -compilerlibs/ocamlbytecomp.cma: $(BYTECOMP) - $(CAMLC) -a -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamlbytecomp.cma - ocamlc: compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma $(BYTESTART) $(CAMLC) $(LINKFLAGS) -compat-32 -o $@ $^ @@ -805,12 +604,6 @@ partialclean:: # The native-code compiler -compilerlibs/ocamloptcomp.cma: $(OPTCOMP) - $(CAMLC) -a -o $@ $^ - -partialclean:: - rm -f compilerlibs/ocamloptcomp.cma - ocamlopt: compilerlibs/ocamlcommon.cma compilerlibs/ocamloptcomp.cma \ $(OPTSTART) $(CAMLC) $(LINKFLAGS) -o $@ $^ @@ -820,11 +613,6 @@ partialclean:: # The toplevel -compilerlibs/ocamltoplevel.cma: $(TOPLEVEL) - $(CAMLC) -a -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamltoplevel.cma - ocaml_dependencies := \ compilerlibs/ocamlcommon.cma \ compilerlibs/ocamlbytecomp.cma \ @@ -872,20 +660,8 @@ partialclean:: beforedepend:: parsing/lexer.ml -# Shared parts of the system compiled with the native-code compiler - -compilerlibs/ocamlcommon.cmxa: $(COMMON:.cmo=.cmx) - $(CAMLOPT) -a -linkall -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlcommon.$(A) - # The bytecode compiler compiled with the native-code compiler -compilerlibs/ocamlbytecomp.cmxa: $(BYTECOMP:.cmo=.cmx) - $(CAMLOPT) -a $(OCAML_NATDYNLINKOPTS) -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamlbytecomp.cmxa compilerlibs/ocamlbytecomp.$(A) - ocamlc.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlbytecomp.cmxa \ $(BYTESTART:.cmo=.cmx) $(CAMLOPT_CMD) $(LINKFLAGS) -o $@ $^ -cclib "$(BYTECCLIBS)" @@ -895,11 +671,6 @@ partialclean:: # The native-code compiler compiled with itself -compilerlibs/ocamloptcomp.cmxa: $(OPTCOMP:.cmo=.cmx) - $(CAMLOPT) -a -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamloptcomp.cmxa compilerlibs/ocamloptcomp.$(A) - ocamlopt.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \ $(OPTSTART:.cmo=.cmx) $(CAMLOPT_CMD) $(LINKFLAGS) -o $@ $^ @@ -907,8 +678,6 @@ ocamlopt.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \ partialclean:: rm -f ocamlopt.opt -$(COMMON:.cmo=.cmx) $(BYTECOMP:.cmo=.cmx) $(OPTCOMP:.cmo=.cmx): ocamlopt - # The predefined exceptions and primitives runtime/primitives: @@ -980,7 +749,7 @@ stdlib/libcamlrun.$(A): runtime/libcamlrun.$(A) cd stdlib; $(LN) ../runtime/libcamlrun.$(A) . clean:: $(MAKE) -C runtime clean - rm -f stdlib/libcamlrun.$(A) + rm -f stdlib/libcamlrun.a stdlib/libcamlrun.lib otherlibs_all := bigarray dynlink raw_spacetime_lib \ str systhreads unix win32unix @@ -1010,7 +779,7 @@ runtime/libasmrun.$(A): makeruntimeopt ; stdlib/libasmrun.$(A): runtime/libasmrun.$(A) cp $< $@ clean:: - rm -f stdlib/libasmrun.$(A) + rm -f stdlib/libasmrun.a stdlib/libasmrun.lib # The standard library @@ -1184,17 +953,6 @@ lintapidiff: grep -Ev internal\|obj\|spacetime\|stdLabels\|moreLabels |\ tools/lintapidiff.opt $(VERSIONS) -# The middle end. - -compilerlibs/ocamlmiddleend.cma: $(MIDDLE_END) - $(CAMLC) -a -o $@ $^ -compilerlibs/ocamlmiddleend.cmxa: $(MIDDLE_END:%.cmo=%.cmx) - $(CAMLOPT) -a -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamlmiddleend.cma \ - compilerlibs/ocamlmiddleend.cmxa \ - compilerlibs/ocamlmiddleend.$(A) - # Tools .PHONY: ocamltools @@ -1244,11 +1002,6 @@ endif # The native toplevel -compilerlibs/ocamlopttoplevel.cmxa: $(OPTTOPLEVEL:.cmo=.cmx) - $(CAMLOPT) -a -o $@ $^ -partialclean:: - rm -f compilerlibs/ocamlopttoplevel.cmxa - # When the native toplevel executable has an extension (e.g. ".exe"), # provide a phony 'ocamlnat' synonym @@ -1265,7 +1018,7 @@ ocamlnat$(EXE): compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \ $(CAMLOPT_CMD) $(LINKFLAGS) -linkall -o $@ $^ partialclean:: - rm -f ocamlnat$(EXE) + rm -f ocamlnat ocamlnat.exe toplevel/opttoploop.cmx: otherlibs/dynlink/dynlink.cmxa @@ -1308,8 +1061,8 @@ partialclean:: lambda middle_end/closure middle_end/flambda \ middle_end/flambda/base_types asmcomp/debug \ driver toplevel tools; do \ - rm -f $$d/*.cm[ioxt] $$d/*.cmti $$d/*.annot $$d/*.$(S) \ - $$d/*.$(O) $$d/*.$(SO); \ + rm -f $$d/*.cm[ioxt] $$d/*.cmti $$d/*.annot $$d/*.s $$d/*.asm \ + $$d/*.o $$d/*.obj $$d/*.so $$d/*.dll; \ done .PHONY: depend @@ -1323,16 +1076,23 @@ depend: beforedepend .PHONY: distclean distclean: clean - rm -f boot/ocamlrun boot/ocamlrun$(EXE) boot/camlheader \ - boot/*.cm* boot/libcamlrun.$(A) boot/ocamlc.opt - rm -f Makefile.config runtime/caml/m.h runtime/caml/s.h + rm -f boot/ocamlrun boot/ocamlrun boot/ocamlrun.exe boot/camlheader \ + boot/*.cm* boot/libcamlrun.a boot/libcamlrun.lib boot/ocamlc.opt + rm -f Makefile.config Makefile.common runtime/caml/m.h runtime/caml/s.h + rm -rf autom4te.cache + rm -f config.log config.status libtool + rm -f tools/eventlog_metadata rm -f tools/*.bak rm -f ocaml ocamlc rm -f testsuite/_log* include .depend -Makefile.config Makefile.common: + +ifneq "$(strip $(CAN_BE_UNCONFIGURED))" "" +Makefile.config Makefile.common: config.status + +config.status: @echo "Please refer to the installation instructions:" @echo "- In file INSTALL for Unix systems." @echo "- In file README.win32.adoc for Windows systems." @@ -1343,3 +1103,4 @@ Makefile.config Makefile.common: @echo " make install" @echo "should work." @false +endif diff --git a/Makefile.config.in b/Makefile.config.in index 6d373239..fe9b2331 100644 --- a/Makefile.config.in +++ b/Makefile.config.in @@ -129,6 +129,9 @@ ARCH=@arch@ # Whether the architecture has 64 bits ARCH64=@arch64@ +# Endianess for this architecture +ENDIANNESS=@endianness@ + ### Name of architecture model for the native-code compiler. ### Some architectures come in several slightly different flavors ### that share a common code generator. This variable tailors the @@ -156,11 +159,14 @@ INSTALL_BYTECODE_PROGRAMS=@install_bytecode_programs@ ### Which libraries to compile and install # Currently available: -# unix Unix system calls -# str Regular expressions and high-level string processing -# systhreads Same as threads, requires POSIX threads -# dynlink Dynamic linking of bytecode -# bigarray Large, multidimensional numerical arrays +# bigarray Large, multidimensional numerical arrays +# (legacy support: this library is now part of the +# Standard Library) +# dynlink Dynamic linking (bytecode and native) +# (win32)unix Unix system calls +# str Regular expressions and high-level string processing +# raw_spacetime_lib Parsing of spacetime traces +# systhreads Same as threads, requires POSIX threads OTHERLIBRARIES=@otherlibraries@ ### Link-time options to ocamlc or ocamlopt for linking with POSIX threads @@ -190,8 +196,10 @@ NATDYNLINK=@natdynlink@ NATDYNLINKOPTS=@natdynlinkopts@ SYSLIB=@syslib@ MKLIB=@mklib@ -OCAMLOPT_CFLAGS=@ocamlopt_cflags@ -OCAMLOPT_CPPFLAGS=@ocamlopt_cppflags@ +# #7678: ocamlopt uses these only to compile .c files, and the behaviour for the +# two drivers should be identical. +OCAMLOPT_CFLAGS=@ocamlc_cflags@ +OCAMLOPT_CPPFLAGS=@ocamlc_cppflags@ NATIVECCLIBS=@nativecclibs@ SYSTHREAD_SUPPORT=@systhread_support@ PACKLD=@PACKLD@ @@ -215,6 +223,7 @@ RUNTIMEI=@instrumented_runtime@ WITH_DEBUGGER=@with_debugger@ WITH_CAMLTEX=@with_camltex@ WITH_OCAMLDOC=@ocamldoc@ +WITH_OCAMLTEST=@ocamltest@ ASM_CFI_SUPPORTED=@asm_cfi_supported@ WITH_FRAME_POINTERS=@frame_pointers@ WITH_SPACETIME=@spacetime@ diff --git a/Makefile.tools b/Makefile.tools index 1319b788..49f4d2f6 100644 --- a/Makefile.tools +++ b/Makefile.tools @@ -47,7 +47,7 @@ SET_LD_PATH=CAML_LD_LIBRARY_PATH="$(LD_PATH)" # variable. Note that for Windows we add Unix-syntax directory names in # PATH, and Cygwin will translate it to Windows syntax. -include $(TOPDIR)/Makefile.config +-include $(TOPDIR)/Makefile.config # Make sure USE_RUNTIME is defined USE_RUNTIME ?= diff --git a/README.adoc b/README.adoc index 504c7a70..4365c2f1 100644 --- a/README.adoc +++ b/README.adoc @@ -1,10 +1,18 @@ |===== -| Branch `trunk` | Branch `4.08` | Branch `4.07` | Branch `4.06` | Branch `4.05` +| Branch `trunk` | Branch `4.10` | Branch `4.09` | Branch `4.08` | Branch `4.07` | Branch `4.06` | Branch `4.05` | image:https://travis-ci.org/ocaml/ocaml.svg?branch=trunk["TravisCI Build Status (trunk branch)", link="https://travis-ci.org/ocaml/ocaml"] image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=trunk&svg=true["AppVeyor Build Status (trunk branch)", link="https://ci.appveyor.com/project/avsm/ocaml"] +| image:https://travis-ci.org/ocaml/ocaml.svg?branch=4.10["TravisCI Build Status (4.10 branch)", + link="https://travis-ci.org/ocaml/ocaml"] + image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=4.10&svg=true["AppVeyor Build Status (4.10 branch)", + link="https://ci.appveyor.com/project/avsm/ocaml"] +| image:https://travis-ci.org/ocaml/ocaml.svg?branch=4.09["TravisCI Build Status (4.09 branch)", + link="https://travis-ci.org/ocaml/ocaml"] + image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=4.09&svg=true["AppVeyor Build Status (4.09 branch)", + link="https://ci.appveyor.com/project/avsm/ocaml"] | image:https://travis-ci.org/ocaml/ocaml.svg?branch=4.08["TravisCI Build Status (4.08 branch)", link="https://travis-ci.org/ocaml/ocaml"] image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=4.08&svg=true["AppVeyor Build Status (4.08 branch)", @@ -54,6 +62,7 @@ compiler currently runs on the following platforms: | ARM 32 bits | Linux | FreeBSD, NetBSD, OpenBSD | Power 64 bits | Linux | | Power 32 bits | | Linux +| RISC-V 64 bits | Linux | | IBM Z (s390x) | Linux | |==== @@ -80,13 +89,13 @@ Windows, see link:README.win32.adoc[]. The OCaml manual is distributed in HTML, PDF, and Emacs Info files. It is available at -http://caml.inria.fr/pub/docs/manual-ocaml/ +https://ocaml.org/releases/latest/manual.html == Availability The complete OCaml distribution can be accessed at -http://ocaml.org/docs/install.html +https://ocaml.org/docs/install.html == Keeping in Touch with the Caml Community @@ -99,6 +108,10 @@ You can subscribe and access list archives via the Web interface at https://sympa.inria.fr/sympa/subscribe/caml-list +An alternative archive of the mailing list is also available at + +https://inbox.ocaml.org/ + You can also access a newer discussion forum at https://discuss.ocaml.org/ @@ -107,7 +120,7 @@ There also exist other mailing lists, chat channels, and various other forums around the internet for getting in touch with the OCaml and ML family language community. These can be accessed at -http://ocaml.org/community/ +https://ocaml.org/community/ In particular, the IRC channel `#ocaml` on https://freenode.net/[Freenode] has a long history and welcomes questions. diff --git a/VERSION b/VERSION index 636ba8d7..eeef3d9a 100644 --- a/VERSION +++ b/VERSION @@ -1,4 +1,4 @@ -4.10.1 +4.11.0 # The version string is the first line of this file. # It must be in the format described in stdlib/sys.mli diff --git a/appveyor.yml b/appveyor.yml index 5b4e821a..e87600b5 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -37,6 +37,7 @@ matrix: cache: - C:\cygwin64\var\cache\setup + - C:\projects\cache install: # This is a hangover from monitoring effects of MPR#7452 diff --git a/asmcomp/afl_instrument.ml b/asmcomp/afl_instrument.ml index 9e008411..7d4b90d2 100644 --- a/asmcomp/afl_instrument.ml +++ b/asmcomp/afl_instrument.ml @@ -73,6 +73,8 @@ and instrument = function (* these cases add no logging, but instrument subexpressions *) | Clet (v, e, body) -> Clet (v, instrument e, instrument body) + | Clet_mut (v, k, e, body) -> + Clet_mut (v, k, instrument e, instrument body) | Cphantom_let (v, defining_expr, body) -> Cphantom_let (v, defining_expr, instrument body) | Cassign (v, e) -> Cassign (v, instrument e) diff --git a/asmcomp/amd64/emit.mlp b/asmcomp/amd64/emit.mlp index e3ff9653..d9c5eb6e 100644 --- a/asmcomp/amd64/emit.mlp +++ b/asmcomp/amd64/emit.mlp @@ -28,6 +28,7 @@ open X86_ast open X86_proc open X86_dsl module String = Misc.Stdlib.String +module Int = Numbers.Int (* [Branch_relaxation] is not used in this file, but is required by emit.mlp files for certain other targets; the reference here ensures @@ -171,7 +172,17 @@ let emit_label lbl = let label s = sym (emit_label s) -let def_label s = D.label (emit_label s) +(* For Spacetime, keep track of code labels that have been emitted. *) +let used_labels = ref Int.Set.empty + +let mark_used lbl = + if Config.spacetime && not (Int.Set.mem lbl !used_labels) then begin + used_labels := Int.Set.add lbl !used_labels + end + +let def_label ?typ s = + mark_used s; + D.label ?typ (emit_label s) let emit_Llabel fallthrough lbl = if not fallthrough && !fastcode_flag then D.align 4; @@ -239,7 +250,7 @@ let addressing addr typ i n = (* Record live pointers at call points -- see Emitaux *) -let record_frame_label ?label live raise_ dbg = +let record_frame_label ?label live dbg = let lbl = match label with | None -> new_label() @@ -258,11 +269,11 @@ let record_frame_label ?label live raise_ dbg = ) live; record_frame_descr ~label:lbl ~frame_size:(frame_size()) - ~live_offset:!live_offset ~raise_frame:raise_ dbg; + ~live_offset:!live_offset dbg; lbl -let record_frame ?label live raise_ dbg = - let lbl = record_frame_label ?label live raise_ dbg in +let record_frame ?label live dbg = + let lbl = record_frame_label ?label live dbg in def_label lbl (* Spacetime instrumentation *) @@ -281,8 +292,7 @@ let spacetime_before_uninstrumented_call ~node_ptr ~index = (* Record calls to the GC -- we've moved them out of the way *) type gc_call = - { gc_size: int; (* Allocation size, in bytes *) - gc_lbl: label; (* Entry label *) + { gc_lbl: label; (* Entry label *) gc_return_lbl: label; (* Where to branch after GC *) gc_frame: label; (* Label of frame descriptor *) gc_spacetime : (X86_ast.arg * int) option; @@ -299,13 +309,7 @@ let emit_call_gc gc = assert Config.spacetime; spacetime_before_uninstrumented_call ~node_ptr ~index end; - begin match gc.gc_size with - | 16 -> emit_call "caml_call_gc1" - | 24 -> emit_call "caml_call_gc2" - | 32 -> emit_call "caml_call_gc3" - | n -> I.add (int n) r15; - emit_call "caml_call_gc" - end; + emit_call "caml_call_gc"; def_label gc.gc_frame; I.jmp (label gc.gc_return_lbl) @@ -327,7 +331,7 @@ let bound_error_call = ref 0 let bound_error_label ?label dbg ~spacetime = if !Clflags.debug || Config.spacetime then begin let lbl_bound_error = new_label() in - let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in + let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in bound_error_sites := { bd_lbl = lbl_bound_error; bd_frame = lbl_frame; bd_spacetime = spacetime; } :: !bound_error_sites; @@ -573,16 +577,16 @@ let emit_instr fallthrough i = load_symbol_addr s (res i 0) | Lop(Icall_ind { label_after; }) -> I.call (arg i 0); - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after | Lop(Icall_imm { func; label_after; }) -> add_used_symbol func; emit_call func; - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after | Lop(Itailcall_ind { label_after; }) -> output_epilogue begin fun () -> I.jmp (arg i 0); if Config.spacetime then begin - record_frame Reg.Set.empty false i.dbg ~label:label_after + record_frame Reg.Set.empty (Dbg_other i.dbg) ~label:label_after end end | Lop(Itailcall_imm { func; label_after; }) -> @@ -597,14 +601,14 @@ let emit_instr fallthrough i = end end; if Config.spacetime then begin - record_frame Reg.Set.empty false i.dbg ~label:label_after + record_frame Reg.Set.empty (Dbg_other i.dbg) ~label:label_after end | Lop(Iextcall { func; alloc; label_after; }) -> add_used_symbol func; if alloc then begin load_symbol_addr func rax; emit_call "caml_c_call"; - record_frame i.live false i.dbg ~label:label_after; + record_frame i.live (Dbg_other i.dbg) ~label:label_after; if system <> S_win64 then begin (* TODO: investigate why such a diff. This comes from: @@ -618,7 +622,7 @@ let emit_instr fallthrough i = end else begin emit_call func; if Config.spacetime then begin - record_frame Reg.Set.empty false i.dbg ~label:label_after + record_frame Reg.Set.empty (Dbg_other i.dbg) ~label:label_after end end | Lop(Istackoffset n) -> @@ -667,30 +671,26 @@ let emit_instr fallthrough i = | Double | Double_u -> I.movsd (arg i 0) (addressing addr REAL8 i 1) end - | Lop(Ialloc { bytes = n; label_after_call_gc; spacetime_index; }) -> + | Lop(Ialloc { bytes = n; label_after_call_gc; spacetime_index; dbginfo }) -> + assert (n <= (Config.max_young_wosize + 1) * Arch.size_addr); if !fastcode_flag then begin - let lbl_redo = new_label() in - def_label lbl_redo; I.sub (int n) r15; I.cmp (domain_field Domainstate.Domain_young_limit) r15; let lbl_call_gc = new_label() in - let dbg = - if not Config.spacetime then Debuginfo.none - else i.dbg - in let lbl_frame = - record_frame_label ?label:label_after_call_gc i.live false dbg + record_frame_label ?label:label_after_call_gc i.live (Dbg_alloc dbginfo) in I.jb (label lbl_call_gc); + let lbl_after_alloc = new_label() in + def_label lbl_after_alloc; I.lea (mem64 NONE 8 R15) (res i 0); let gc_spacetime = if not Config.spacetime then None else Some (arg i 0, spacetime_index) in call_gc_sites := - { gc_size = n; - gc_lbl = lbl_call_gc; - gc_return_lbl = lbl_redo; + { gc_lbl = lbl_call_gc; + gc_return_lbl = lbl_after_alloc; gc_frame = lbl_frame; gc_spacetime; } :: !call_gc_sites end else begin @@ -703,12 +703,12 @@ let emit_instr fallthrough i = | 24 -> emit_call "caml_alloc2" | 32 -> emit_call "caml_alloc3" | _ -> - I.mov (int n) rax; + I.sub (int n) r15; emit_call "caml_allocN" end; let label = - record_frame_label ?label:label_after_call_gc i.live false - Debuginfo.none + record_frame_label ?label:label_after_call_gc i.live + (Dbg_alloc dbginfo) in def_label label; I.lea (mem64 NONE 8 R15) (res i 0) @@ -914,10 +914,10 @@ let emit_instr fallthrough i = | Lambda.Raise_regular -> I.mov (int 0) (domain_field Domainstate.Domain_backtrace_pos); emit_call "caml_raise_exn"; - record_frame Reg.Set.empty true i.dbg + record_frame Reg.Set.empty (Dbg_raise i.dbg) | Lambda.Raise_reraise -> emit_call "caml_raise_exn"; - record_frame Reg.Set.empty true i.dbg + record_frame Reg.Set.empty (Dbg_raise i.dbg) | Lambda.Raise_notrace -> I.mov (domain_field Domainstate.Domain_exception_pointer) rsp; I.pop (domain_field Domainstate.Domain_exception_pointer); @@ -1013,11 +1013,9 @@ let begin_assembly() = reset_imp_table(); float_constants := []; all_functions := []; + used_labels := Int.Set.empty; if system = S_win64 then begin D.extrn "caml_call_gc" NEAR; - D.extrn "caml_call_gc1" NEAR; - D.extrn "caml_call_gc2" NEAR; - D.extrn "caml_call_gc3" NEAR; D.extrn "caml_c_call" NEAR; D.extrn "caml_allocN" NEAR; D.extrn "caml_alloc1" NEAR; @@ -1063,10 +1061,14 @@ let emit_spacetime_shapes () = begin match fundecl.fun_spacetime_shape with | None -> () | Some shape -> - let funsym = emit_symbol fundecl.fun_name in - D.comment ("Shape for " ^ funsym ^ ":"); - D.qword (ConstLabel funsym); - List.iter (fun (part_of_shape, label) -> + (* Instrumentation that refers to dead code may have been eliminated. *) + match List.filter (fun (_, l) -> Int.Set.mem l !used_labels) shape with + | [] -> () + | shape -> + let funsym = emit_symbol fundecl.fun_name in + D.comment ("Shape for " ^ funsym ^ ":"); + D.qword (ConstLabel funsym); + List.iter (fun (part_of_shape, label) -> let tag = match part_of_shape with | Direct_call_point _ -> 1 @@ -1081,7 +1083,7 @@ let emit_spacetime_shapes () = | Indirect_call_point -> () | Allocation_point -> () end) - shape; + shape; D.qword (Const 0L) end) !all_functions; @@ -1119,6 +1121,7 @@ let end_assembly() = emit_frames { efa_code_label = (fun l -> D.qword (ConstLabel (emit_label l))); efa_data_label = (fun l -> D.qword (ConstLabel (emit_label l))); + efa_8 = (fun n -> D.byte (const n)); efa_16 = (fun n -> D.word (const n)); efa_32 = (fun n -> D.long (const_32 n)); efa_word = (fun n -> D.qword (const n)); @@ -1142,6 +1145,11 @@ let end_assembly() = efa_string = (fun s -> D.bytes (s ^ "\000")) }; + if system = S_linux then begin + let frametable = emit_symbol (Compilenv.make_symbol (Some "frametable")) in + D.size frametable (ConstSub (ConstThis, ConstLabel frametable)) + end; + if Config.spacetime then begin emit_spacetime_shapes () end; diff --git a/asmcomp/amd64/proc.ml b/asmcomp/amd64/proc.ml index c64ad9a0..05b9633d 100644 --- a/asmcomp/amd64/proc.ml +++ b/asmcomp/amd64/proc.ml @@ -301,14 +301,20 @@ let destroyed_at_c_call = 100;101;102;103;104;105;106;107; 108;109;110;111;112;113;114;115]) +let destroyed_by_spacetime_at_alloc = + if Config.spacetime then + [| loc_spacetime_node_hole |] + else + [| |] + let destroyed_at_alloc = let regs = - if Config.spacetime then - [| rax; loc_spacetime_node_hole |] + if X86_proc.use_plt then + destroyed_by_plt_stub else - [| rax |] + [| r11 |] in - Array.concat [regs; destroyed_by_plt_stub] + Array.concat [regs; destroyed_by_spacetime_at_alloc] let destroyed_at_oper = function Iop(Icall_ind _ | Icall_imm _ | Iextcall { alloc = true; }) -> diff --git a/asmcomp/arm/emit.mlp b/asmcomp/arm/emit.mlp index 1393d457..b880319b 100644 --- a/asmcomp/arm/emit.mlp +++ b/asmcomp/arm/emit.mlp @@ -105,7 +105,7 @@ let emit_addressing addr r n = (* Record live pointers at call points *) -let record_frame_label ?label live raise_ dbg = +let record_frame_label ?label live dbg = let lbl = match label with | None -> new_label() @@ -123,11 +123,11 @@ let record_frame_label ?label live raise_ dbg = | _ -> ()) live; record_frame_descr ~label:lbl ~frame_size:(frame_size()) - ~live_offset:!live_offset ~raise_frame:raise_ dbg; + ~live_offset:!live_offset dbg; lbl -let record_frame ?label live raise_ dbg = - let lbl = record_frame_label ?label live raise_ dbg in `{emit_label lbl}:` +let record_frame ?label live dbg = + let lbl = record_frame_label ?label live dbg in `{emit_label lbl}:` (* Record calls to the GC -- we've moved them out of the way *) @@ -155,7 +155,7 @@ let bound_error_sites = ref ([] : bound_error_call list) let bound_error_label ?label dbg = if !Clflags.debug || !bound_error_sites = [] then begin let lbl_bound_error = new_label() in - let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in + let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in bound_error_sites := { bd_lbl = lbl_bound_error; bd_frame_lbl = lbl_frame } :: !bound_error_sites; @@ -542,15 +542,15 @@ let emit_instr i = | Lop(Icall_ind { label_after; }) -> if !arch >= ARMv5 then begin ` blx {emit_reg i.arg.(0)}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n`; 1 + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 1 end else begin ` mov lr, pc\n`; ` bx {emit_reg i.arg.(0)}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n`; 2 + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 2 end | Lop(Icall_imm { func; label_after; }) -> ` {emit_call func}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n`; 1 + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 1 | Lop(Itailcall_ind { label_after = _; }) -> output_epilogue begin fun () -> if !contains_calls then @@ -572,7 +572,7 @@ let emit_instr i = | Lop(Iextcall { func; alloc = true; label_after; }) -> let ninstr = emit_load_symbol_addr (phys_reg 7 (* r7 *)) func in ` {emit_call "caml_c_call"}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n`; + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 1 + ninstr | Lop(Istackoffset n) -> assert (n mod 8 = 0); @@ -642,34 +642,28 @@ let emit_instr i = | Double_u -> "fstd" | _ (* 32-bit quantities *) -> "str" in ` {emit_string instr} {emit_reg r}, {emit_addressing addr i.arg 1}\n`; 1 - | Lop(Ialloc { bytes = n; label_after_call_gc; }) -> + | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) -> let lbl_frame = - record_frame_label i.live false i.dbg ?label:label_after_call_gc + record_frame_label i.live (Dbg_alloc dbginfo) ?label:label_after_call_gc in if !fastcode_flag then begin - let lbl_redo = new_label() in - `{emit_label lbl_redo}:`; - let first = ref true in - let ninstr = - decompose_intconst (Int32.of_int (n - 4)) (fun a -> - if !first - then ` sub {emit_reg i.res.(0)}, alloc_ptr, #{emit_int32 a}\n` - else ` sub {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, #{emit_int32 a}\n`; - first := false) in + let ninstr = decompose_intconst + (Int32.of_int n) + (fun i -> + ` sub alloc_ptr, alloc_ptr, #{emit_int32 i}\n`) in let offset = Domainstate.(idx_of_field Domain_young_limit) * 8 in - let tmp = if i.res.(0).loc = Reg 8 (* r12 *) then phys_reg 7 (* r7 *) - else phys_reg 8 (* r12 *) - in - ` ldr {emit_reg tmp}, [domain_state_ptr, {emit_int offset}]\n`; - ` cmp {emit_reg i.res.(0)}, {emit_reg tmp}\n`; + ` ldr {emit_reg i.res.(0)}, [domain_state_ptr, {emit_int offset}]\n`; + ` cmp alloc_ptr, {emit_reg i.res.(0)}\n`; let lbl_call_gc = new_label() in - ` bls {emit_label lbl_call_gc}\n`; - ` sub alloc_ptr, {emit_reg i.res.(0)}, #4\n`; + ` bcc {emit_label lbl_call_gc}\n`; + let lbl_after_alloc = new_label() in + `{emit_label lbl_after_alloc}:`; + ` add {emit_reg i.res.(0)}, alloc_ptr, #4\n`; call_gc_sites := { gc_lbl = lbl_call_gc; - gc_return_lbl = lbl_redo; + gc_return_lbl = lbl_after_alloc; gc_frame_lbl = lbl_frame } :: !call_gc_sites; - 3 + ninstr + 4 + ninstr end else begin let ninstr = begin match n with @@ -912,10 +906,10 @@ let emit_instr i = ` mov r12, #0\n`; ` str r12, [domain_state_ptr, {emit_int offset}]\n`; ` {emit_call "caml_raise_exn"}\n`; - `{record_frame Reg.Set.empty true i.dbg}\n`; 3 + `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`; 3 | Lambda.Raise_reraise -> ` {emit_call "caml_raise_exn"}\n`; - `{record_frame Reg.Set.empty true i.dbg}\n`; 1 + `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`; 1 | Lambda.Raise_notrace -> ` mov sp, trap_ptr\n`; ` pop \{trap_ptr, pc}\n`; 2 @@ -1072,6 +1066,7 @@ let end_assembly () = efa_data_label = (fun lbl -> ` .type {emit_label lbl}, %object\n`; ` .word {emit_label lbl}\n`); + efa_8 = (fun n -> ` .byte {emit_int n}\n`); efa_16 = (fun n -> ` .short {emit_int n}\n`); efa_32 = (fun n -> ` .long {emit_int32 n}\n`); efa_word = (fun n -> ` .word {emit_int n}\n`); diff --git a/asmcomp/arm64/arch.ml b/asmcomp/arm64/arch.ml index ce5902aa..9cf923c6 100644 --- a/asmcomp/arm64/arch.ml +++ b/asmcomp/arm64/arch.ml @@ -38,7 +38,8 @@ type cmm_label = int (* Do not introduce a dependency to Cmm *) type specific_operation = - | Ifar_alloc of { bytes : int; label_after_call_gc : cmm_label option; } + | Ifar_alloc of { bytes : int; label_after_call_gc : cmm_label option; + dbginfo : Debuginfo.alloc_dbginfo } | Ifar_intop_checkbound of { label_after_error : cmm_label option; } | Ifar_intop_imm_checkbound of { bound : int; label_after_error : cmm_label option; } diff --git a/asmcomp/arm64/emit.mlp b/asmcomp/arm64/emit.mlp index eb8424bf..cddfc08a 100644 --- a/asmcomp/arm64/emit.mlp +++ b/asmcomp/arm64/emit.mlp @@ -126,7 +126,7 @@ let emit_addressing addr r = (* Record live pointers at call points *) -let record_frame_label ?label live raise_ dbg = +let record_frame_label ?label live dbg = let lbl = match label with | None -> new_label() @@ -144,11 +144,11 @@ let record_frame_label ?label live raise_ dbg = | _ -> ()) live; record_frame_descr ~label:lbl ~frame_size:(frame_size()) - ~live_offset:!live_offset ~raise_frame:raise_ dbg; + ~live_offset:!live_offset dbg; lbl -let record_frame ?label live raise_ dbg = - let lbl = record_frame_label ?label live raise_ dbg in `{emit_label lbl}:` +let record_frame ?label live dbg = + let lbl = record_frame_label ?label live dbg in `{emit_label lbl}:` (* Record calls to the GC -- we've moved them out of the way *) @@ -176,7 +176,7 @@ let bound_error_sites = ref ([] : bound_error_call list) let bound_error_label ?label dbg = if !Clflags.debug || !bound_error_sites = [] then begin let lbl_bound_error = new_label() in - let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in + let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in bound_error_sites := { bd_lbl = lbl_bound_error; bd_frame_lbl = lbl_frame } :: !bound_error_sites; @@ -512,8 +512,8 @@ module BR = Branch_relaxation.Make (struct | Lambda.Raise_notrace -> 4 end - let relax_allocation ~num_bytes ~label_after_call_gc = - Lop (Ispecific (Ifar_alloc { bytes = num_bytes; label_after_call_gc; })) + let relax_allocation ~num_bytes ~label_after_call_gc ~dbginfo = + Lop (Ispecific (Ifar_alloc { bytes = num_bytes; label_after_call_gc; dbginfo })) let relax_intop_checkbound ~label_after_error = Lop (Ispecific (Ifar_intop_checkbound { label_after_error; })) @@ -529,36 +529,32 @@ end) (* Output the assembly code for allocation. *) -let assembly_code_for_allocation ?label_after_call_gc i ~n ~far = +let assembly_code_for_allocation ~label_after_call_gc i ~n ~far ~dbginfo = let lbl_frame = - record_frame_label ?label:label_after_call_gc i.live false i.dbg + record_frame_label ?label:label_after_call_gc i.live (Dbg_alloc dbginfo) in if !fastcode_flag then begin - let lbl_redo = new_label() in + let lbl_after_alloc = new_label() in let lbl_call_gc = new_label() in (* n is at most Max_young_whsize * 8, i.e. currently 0x808, so it is reasonable to assume n < 0x1_000. This makes the generated code simpler. *) assert (16 <= n && n < 0x1_000 && n land 0x7 = 0); - (* Instead of checking whether young_ptr - n < young_limit, we check whether - young_ptr - (n - 8) <= young_limit. It's equivalent, but this way around - we can avoid mutating young_ptr on failed allocations, by doing the - calculations in i.res.(0) instead of young_ptr. *) - `{emit_label lbl_redo}:`; - ` sub {emit_reg i.res.(0)}, {emit_reg reg_alloc_ptr}, #{emit_int (n - 8)}\n`; - ` cmp {emit_reg i.res.(0)}, {emit_reg reg_alloc_limit}\n`; + ` sub {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_ptr}, #{emit_int n}\n`; + ` cmp {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_limit}\n`; if not far then begin - ` b.ls {emit_label lbl_call_gc}\n` + ` b.lo {emit_label lbl_call_gc}\n` end else begin let lbl = new_label () in - ` b.hi {emit_label lbl}\n`; + ` b.cs {emit_label lbl}\n`; ` b {emit_label lbl_call_gc}\n`; `{emit_label lbl}:\n` end; - ` sub {emit_reg reg_alloc_ptr}, {emit_reg i.res.(0)}, #8\n`; + `{emit_label lbl_after_alloc}:`; + ` add {emit_reg i.res.(0)}, {emit_reg reg_alloc_ptr}, #8\n`; call_gc_sites := { gc_lbl = lbl_call_gc; - gc_return_lbl = lbl_redo; + gc_return_lbl = lbl_after_alloc; gc_frame_lbl = lbl_frame } :: !call_gc_sites end else begin begin match n with @@ -626,10 +622,10 @@ let emit_instr i = emit_load_symbol_addr i.res.(0) s | Lop(Icall_ind { label_after; }) -> ` blr {emit_reg i.arg.(0)}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n` + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n` | Lop(Icall_imm { func; label_after; }) -> ` bl {emit_symbol func}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n` + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n` | Lop(Itailcall_ind { label_after = _; }) -> output_epilogue (fun () -> ` br {emit_reg i.arg.(0)}\n`) | Lop(Itailcall_imm { func; label_after = _; }) -> @@ -642,7 +638,7 @@ let emit_instr i = | Lop(Iextcall { func; alloc = true; label_after; }) -> emit_load_symbol_addr reg_x15 func; ` bl {emit_symbol "caml_c_call"}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n` + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n` | Lop(Istackoffset n) -> assert (n mod 16 = 0); emit_stack_adjustment (-n); @@ -697,10 +693,10 @@ let emit_instr i = | Word_int | Word_val | Double | Double_u -> ` str {emit_reg src}, {emit_addressing addr base}\n` end - | Lop(Ialloc { bytes = n; label_after_call_gc; }) -> - assembly_code_for_allocation i ~n ~far:false ?label_after_call_gc - | Lop(Ispecific (Ifar_alloc { bytes = n; label_after_call_gc; })) -> - assembly_code_for_allocation i ~n ~far:true ?label_after_call_gc + | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) -> + assembly_code_for_allocation i ~n ~far:false ~label_after_call_gc ~dbginfo + | Lop(Ispecific (Ifar_alloc { bytes = n; label_after_call_gc; dbginfo })) -> + assembly_code_for_allocation i ~n ~far:true ~label_after_call_gc ~dbginfo | Lop(Iintop(Icomp cmp)) -> ` cmp {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`; ` cset {emit_reg i.res.(0)}, {emit_string (name_for_comparison cmp)}\n` @@ -906,10 +902,10 @@ let emit_instr i = let offset = Domainstate.(idx_of_field Domain_backtrace_pos) * 8 in ` str xzr, [{emit_reg reg_domain_state_ptr}, {emit_int offset}]\n`; ` bl {emit_symbol "caml_raise_exn"}\n`; - `{record_frame Reg.Set.empty true i.dbg}\n` + `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n` | Lambda.Raise_reraise -> ` bl {emit_symbol "caml_raise_exn"}\n`; - `{record_frame Reg.Set.empty true i.dbg}\n` + `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n` | Lambda.Raise_notrace -> ` mov sp, {emit_reg reg_trap_ptr}\n`; ` ldr {emit_reg reg_tmp1}, [sp, #8]\n`; @@ -1027,6 +1023,7 @@ let end_assembly () = efa_data_label = (fun lbl -> ` .type {emit_label lbl}, %object\n`; ` .quad {emit_label lbl}\n`); + efa_8 = (fun n -> ` .byte {emit_int n}\n`); efa_16 = (fun n -> ` .short {emit_int n}\n`); efa_32 = (fun n -> ` .long {emit_int32 n}\n`); efa_word = (fun n -> ` .quad {emit_int n}\n`); diff --git a/asmcomp/asmgen.ml b/asmcomp/asmgen.ml index 1f209a50..a6468b6c 100644 --- a/asmcomp/asmgen.ml +++ b/asmcomp/asmgen.ml @@ -39,6 +39,17 @@ let pass_dump_linear_if ppf flag message phrase = if !flag then fprintf ppf "*** %s@.%a@." message Printlinear.fundecl phrase; phrase +let should_emit () = + not (should_stop_after Compiler_pass.Scheduling) + +let if_emit_do f x = if should_emit () then f x else () +let emit_begin_assembly = if_emit_do Emit.begin_assembly +let emit_end_assembly = if_emit_do Emit.end_assembly +let emit_data = if_emit_do Emit.data +let emit_fundecl = + if_emit_do + (Profile.record ~accumulate:true "emit" Emit.fundecl) + let rec regalloc ~ppf_dump round fd = if round > 50 then fatal_error(fd.Mach.fun_name ^ @@ -92,13 +103,13 @@ let compile_fundecl ~ppf_dump fd_cmm = ++ pass_dump_linear_if ppf_dump dump_linear "Linearized code" ++ Profile.record ~accumulate:true "scheduling" Scheduling.fundecl ++ pass_dump_linear_if ppf_dump dump_scheduling "After instruction scheduling" - ++ Profile.record ~accumulate:true "emit" Emit.fundecl + ++ emit_fundecl let compile_phrase ~ppf_dump p = if !dump_cmm then fprintf ppf_dump "%a@." Printcmm.phrase p; match p with | Cfunction fd -> compile_fundecl ~ppf_dump fd - | Cdata dl -> Emit.data dl + | Cdata dl -> emit_data dl (* For the native toplevel: generates generic functions unless @@ -111,8 +122,10 @@ let compile_genfuns ~ppf_dump f = | _ -> ()) (Cmm_helpers.generic_functions true [Compilenv.current_unit_infos ()]) -let compile_unit asm_filename keep_asm obj_filename gen = - let create_asm = keep_asm || not !Emitaux.binary_backend_available in +let compile_unit asm_filename keep_asm + obj_filename gen = + let create_asm = should_emit () && + (keep_asm || not !Emitaux.binary_backend_available) in Emitaux.create_asm_file := create_asm; Misc.try_finally ~exceptionally:(fun () -> remove_file obj_filename) @@ -123,18 +136,20 @@ let compile_unit asm_filename keep_asm obj_filename gen = if create_asm then close_out !Emitaux.output_channel) ~exceptionally:(fun () -> if create_asm && not keep_asm then remove_file asm_filename); - let assemble_result = - Profile.record "assemble" - (Proc.assemble_file asm_filename) obj_filename - in - if assemble_result <> 0 - then raise(Error(Assembler_error asm_filename)); + if should_emit () then begin + let assemble_result = + Profile.record "assemble" + (Proc.assemble_file asm_filename) obj_filename + in + if assemble_result <> 0 + then raise(Error(Assembler_error asm_filename)); + end; if create_asm && not keep_asm then remove_file asm_filename ) let end_gen_implementation ?toplevel ~ppf_dump (clambda : Clambda.with_constants) = - Emit.begin_assembly (); + emit_begin_assembly (); clambda ++ Profile.record "cmm" Cmmgen.compunit ++ Profile.record "compile_phrases" (List.iter (compile_phrase ~ppf_dump)) @@ -151,7 +166,7 @@ let end_gen_implementation ?toplevel ~ppf_dump if not (Primitive.native_name_is_external prim) then None else Some (Primitive.native_name prim)) !Translmod.primitive_declarations)); - Emit.end_assembly () + emit_end_assembly () type middle_end = backend:(module Backend_intf.S) diff --git a/asmcomp/asmlink.ml b/asmcomp/asmlink.ml index d0879339..6236b1ca 100644 --- a/asmcomp/asmlink.ml +++ b/asmcomp/asmlink.ml @@ -29,7 +29,7 @@ type error = | Inconsistent_interface of modname * filepath * filepath | Inconsistent_implementation of modname * filepath * filepath | Assembler_error of filepath - | Linking_error + | Linking_error of int | Multiple_definition of modname * filepath * filepath | Missing_cmx of filepath * modname @@ -59,7 +59,11 @@ let check_consistency file_name unit crc = then Cmi_consistbl.set crc_interfaces name crc file_name else Cmi_consistbl.check crc_interfaces name crc file_name) unit.ui_imports_cmi - with Cmi_consistbl.Inconsistency(name, user, auth) -> + with Cmi_consistbl.Inconsistency { + unit_name = name; + inconsistent_source = user; + original_source = auth; + } -> raise(Error(Inconsistent_interface(name, user, auth))) end; begin try @@ -73,7 +77,11 @@ let check_consistency file_name unit crc = | Some crc -> Cmx_consistbl.check crc_implementations name crc file_name) unit.ui_imports_cmx - with Cmx_consistbl.Inconsistency(name, user, auth) -> + with Cmx_consistbl.Inconsistency { + unit_name = name; + inconsistent_source = user; + original_source = auth; + } -> raise(Error(Inconsistent_implementation(name, user, auth))) end; begin try @@ -178,30 +186,43 @@ let read_file obj_name = end else raise(Error(Not_an_object_file file_name)) -let scan_file obj_name tolink = match read_file obj_name with +let scan_file obj_name (tolink, objfiles) = match read_file obj_name with | Unit (file_name,info,crc) -> (* This is a .cmx file. It must be linked in any case. *) remove_required info.ui_name; List.iter (add_required file_name) info.ui_imports_cmx; - (info, file_name, crc) :: tolink + ((info, file_name, crc) :: tolink, obj_name :: objfiles) | Library (file_name,infos) -> (* This is an archive file. Each unit contained in it will be linked in only if needed. *) add_ccobjs (Filename.dirname file_name) infos; - List.fold_right - (fun (info, crc) reqd -> - if info.ui_force_link - || !Clflags.link_everything - || is_required info.ui_name - then begin - remove_required info.ui_name; - List.iter (add_required (Printf.sprintf "%s(%s)" - file_name info.ui_name)) - info.ui_imports_cmx; - (info, file_name, crc) :: reqd - end else - reqd) - infos.lib_units tolink + let tolink = + List.fold_right + (fun (info, crc) reqd -> + if info.ui_force_link + || !Clflags.link_everything + || is_required info.ui_name + then begin + remove_required info.ui_name; + List.iter (add_required (Printf.sprintf "%s(%s)" + file_name info.ui_name)) + info.ui_imports_cmx; + (info, file_name, crc) :: reqd + end else + reqd) + infos.lib_units tolink + and objfiles = + if Config.ccomp_type = "msvc" + && infos.lib_units = [] + && not (Sys.file_exists (object_file_name obj_name)) then + (* MSVC doesn't support empty .lib files, so there shouldn't be one + if the .cmxa contains no units. The file_exists check is added to + be ultra-defensive for the case where a user has manually added + things to the .lib file *) + objfiles + else + obj_name :: objfiles + in (tolink, objfiles) (* Second pass: generate the startup file and link it with everything else *) @@ -272,18 +293,21 @@ let make_shared_startup_file ~ppf_dump units = Emit.end_assembly () let call_linker_shared file_list output_name = - if not (Ccomp.call_linker Ccomp.Dll output_name file_list "") - then raise(Error Linking_error) + let exitcode = Ccomp.call_linker Ccomp.Dll output_name file_list "" in + if not (exitcode = 0) + then raise(Error(Linking_error exitcode)) let link_shared ~ppf_dump objfiles output_name = Profile.record_call output_name (fun () -> - let units_tolink = List.fold_right scan_file objfiles [] in + let units_tolink, objfiles = + List.fold_right scan_file objfiles ([], []) + in List.iter (fun (info, file_name, crc) -> check_consistency file_name info crc) units_tolink; Clflags.ccobjs := !Clflags.ccobjs @ !lib_ccobjs; Clflags.all_ccopts := !lib_ccopts @ !Clflags.all_ccopts; - let objfiles = List.rev (List.map object_file_name objfiles) @ + let objfiles = List.rev_map object_file_name objfiles @ (List.rev !Clflags.ccobjs) in let startup = @@ -315,7 +339,7 @@ let call_linker file_list startup_file output_name = let files, c_lib = if (not !Clflags.output_c_object) || main_dll || main_obj_runtime then files @ (List.rev !Clflags.ccobjs) @ runtime_lib () @ libunwind, - (if !Clflags.nopervasives || main_obj_runtime + (if !Clflags.nopervasives || (main_obj_runtime && not main_dll) then "" else Config.native_c_libraries) else files, "" @@ -325,8 +349,9 @@ let call_linker file_list startup_file output_name = else if !Clflags.output_c_object then Ccomp.Partial else Ccomp.Exe in - if not (Ccomp.call_linker mode output_name files c_lib) - then raise(Error Linking_error) + let exitcode = Ccomp.call_linker mode output_name files c_lib in + if not (exitcode = 0) + then raise(Error(Linking_error exitcode)) (* Main entry point *) @@ -338,7 +363,9 @@ let link ~ppf_dump objfiles output_name = if !Clflags.nopervasives then objfiles else if !Clflags.output_c_object then stdlib :: objfiles else stdlib :: (objfiles @ [stdexit]) in - let units_tolink = List.fold_right scan_file objfiles [] in + let units_tolink, objfiles = + List.fold_right scan_file objfiles ([], []) + in Array.iter remove_required Runtimedef.builtin_exceptions; begin match extract_missing_globals() with [] -> () @@ -406,8 +433,8 @@ let report_error ppf = function intf | Assembler_error file -> fprintf ppf "Error while assembling %a" Location.print_filename file - | Linking_error -> - fprintf ppf "Error during linking" + | Linking_error exitcode -> + fprintf ppf "Error during linking (exit code %d)" exitcode | Multiple_definition(modname, file1, file2) -> fprintf ppf "@[Files %a@ and %a@ both define a module named %s@]" diff --git a/asmcomp/asmlink.mli b/asmcomp/asmlink.mli index 1c832276..6ee91ffb 100644 --- a/asmcomp/asmlink.mli +++ b/asmcomp/asmlink.mli @@ -36,7 +36,7 @@ type error = | Inconsistent_interface of modname * filepath * filepath | Inconsistent_implementation of modname * filepath * filepath | Assembler_error of filepath - | Linking_error + | Linking_error of int | Multiple_definition of modname * filepath * filepath | Missing_cmx of filepath * modname diff --git a/asmcomp/asmpackager.ml b/asmcomp/asmpackager.ml index c074dee5..604fac5e 100644 --- a/asmcomp/asmpackager.ml +++ b/asmcomp/asmpackager.ml @@ -141,11 +141,11 @@ let make_package_object ~ppf_dump members targetobj targetname coercion List.map (fun m -> Filename.remove_extension m.pm_file ^ Config.ext_obj) (List.filter (fun m -> m.pm_kind <> PM_intf) members) in - let ok = + let exitcode = Ccomp.call_linker Ccomp.Partial targetobj (objtemp :: objfiles) "" in remove_file objtemp; - if not ok then raise(Error Linking_error) + if not (exitcode = 0) then raise(Error Linking_error) ) (* Make the .cmx file for the package *) diff --git a/asmcomp/branch_relaxation.ml b/asmcomp/branch_relaxation.ml index 953c2827..74b749ea 100644 --- a/asmcomp/branch_relaxation.ml +++ b/asmcomp/branch_relaxation.ml @@ -86,8 +86,9 @@ module Make (T : Branch_relaxation_intf.S) = struct fixup did_fix (pc + T.instr_size instr.desc) instr.next else match instr.desc with - | Lop (Ialloc { bytes = num_bytes; label_after_call_gc; }) -> - instr.desc <- T.relax_allocation ~num_bytes ~label_after_call_gc; + | Lop (Ialloc { bytes = num_bytes; label_after_call_gc; dbginfo }) -> + instr.desc <- T.relax_allocation ~num_bytes + ~dbginfo ~label_after_call_gc; fixup true (pc + T.instr_size instr.desc) instr.next | Lop (Iintop (Icheckbound { label_after_error; })) -> instr.desc <- T.relax_intop_checkbound ~label_after_error; diff --git a/asmcomp/branch_relaxation_intf.ml b/asmcomp/branch_relaxation_intf.ml index d5552f83..b7a7271f 100644 --- a/asmcomp/branch_relaxation_intf.ml +++ b/asmcomp/branch_relaxation_intf.ml @@ -63,6 +63,7 @@ module type S = sig val relax_allocation : num_bytes:int -> label_after_call_gc:Cmm.label option + -> dbginfo:Debuginfo.alloc_dbginfo -> Linear.instruction_desc val relax_intop_checkbound : label_after_error:Cmm.label option diff --git a/asmcomp/cmm.ml b/asmcomp/cmm.ml index 15ec6dbd..e9fcbd9b 100644 --- a/asmcomp/cmm.ml +++ b/asmcomp/cmm.ml @@ -152,6 +152,8 @@ type expression = | Cblockheader of nativeint * Debuginfo.t | Cvar of Backend_var.t | Clet of Backend_var.With_provenance.t * expression * expression + | Clet_mut of Backend_var.With_provenance.t * machtype + * expression * expression | Cphantom_let of Backend_var.With_provenance.t * phantom_defining_expr option * expression | Cassign of Backend_var.t * expression @@ -208,7 +210,7 @@ let reset () = label_counter := 99 let iter_shallow_tail f = function - | Clet(_, _, body) | Cphantom_let (_, _, body) -> + | Clet(_, _, body) | Cphantom_let (_, _, body) | Clet_mut(_, _, _, body) -> f body; true | Cifthenelse(_cond, _ifso_dbg, ifso, _ifnot_dbg, ifnot, _dbg) -> @@ -247,6 +249,8 @@ let iter_shallow_tail f = function let rec map_tail f = function | Clet(id, exp, body) -> Clet(id, exp, map_tail f body) + | Clet_mut(id, kind, exp, body) -> + Clet_mut(id, kind, exp, map_tail f body) | Cphantom_let(id, exp, body) -> Cphantom_let (id, exp, map_tail f body) | Cifthenelse(cond, ifso_dbg, ifso, ifnot_dbg, ifnot, dbg) -> @@ -284,6 +288,8 @@ let rec map_tail f = function let map_shallow f = function | Clet (id, e1, e2) -> Clet (id, f e1, f e2) + | Clet_mut (id, kind, e1, e2) -> + Clet_mut (id, kind, f e1, f e2) | Cphantom_let (id, de, e) -> Cphantom_let (id, de, f e) | Cassign (id, e) -> diff --git a/asmcomp/cmm.mli b/asmcomp/cmm.mli index 84c79a27..ad8d804e 100644 --- a/asmcomp/cmm.mli +++ b/asmcomp/cmm.mli @@ -159,8 +159,11 @@ and expression = | Cblockheader of nativeint * Debuginfo.t | Cvar of Backend_var.t | Clet of Backend_var.With_provenance.t * expression * expression + | Clet_mut of Backend_var.With_provenance.t * machtype + * expression * expression | Cphantom_let of Backend_var.With_provenance.t * phantom_defining_expr option * expression + (* Cassign must refer to a variable bound by Clet_mut *) | Cassign of Backend_var.t * expression | Ctuple of expression list | Cop of operation * expression list * Debuginfo.t diff --git a/asmcomp/cmm_helpers.ml b/asmcomp/cmm_helpers.ml index c02e2b38..ff4b794e 100644 --- a/asmcomp/cmm_helpers.ml +++ b/asmcomp/cmm_helpers.ml @@ -273,6 +273,42 @@ let mk_not dbg cmm = (* 1 -> 3, 3 -> 1 *) Cop(Csubi, [Cconst_int (4, dbg); c], dbg) +let mk_compare_ints dbg a1 a2 = + match (a1,a2) with + | Cconst_int (c1, _), Cconst_int (c2, _) -> + int_const dbg (Int.compare c1 c2) + | Cconst_natint (c1, _), Cconst_natint (c2, _) -> + int_const dbg (Nativeint.compare c1 c2) + | Cconst_int (c1, _), Cconst_natint (c2, _) -> + int_const dbg Nativeint.(compare (of_int c1) c2) + | Cconst_natint (c1, _), Cconst_int (c2, _) -> + int_const dbg Nativeint.(compare c1 (of_int c2)) + | a1, a2 -> begin + bind "int_cmp" a1 (fun a1 -> + bind "int_cmp" a2 (fun a2 -> + let op1 = Cop(Ccmpi(Cgt), [a1; a2], dbg) in + let op2 = Cop(Ccmpi(Clt), [a1; a2], dbg) in + tag_int(sub_int op1 op2 dbg) dbg)) + end + +let mk_compare_floats dbg a1 a2 = + bind "float_cmp" a1 (fun a1 -> + bind "float_cmp" a2 (fun a2 -> + let op1 = Cop(Ccmpf(CFgt), [a1; a2], dbg) in + let op2 = Cop(Ccmpf(CFlt), [a1; a2], dbg) in + let op3 = Cop(Ccmpf(CFeq), [a1; a1], dbg) in + let op4 = Cop(Ccmpf(CFeq), [a2; a2], dbg) in + (* If both operands a1 and a2 are not NaN, then op3 = op4 = 1, + and the result is op1 - op2. + If at least one of the operands is NaN, + then op1 = op2 = 0, and the result is op3 - op4, + which orders NaN before other values. + To detect if the operand is NaN, we use the property: + for all x, NaN is not equal to x, even if x is NaN. + Therefore, op3 is 0 if and only if a1 is NaN, + and op4 is 0 if and only if a2 is NaN. + See also caml_float_compare_unboxed in runtime/floats.c *) + tag_int (add_int (sub_int op1 op2 dbg) (sub_int op3 op4 dbg) dbg) dbg)) let create_loop body dbg = let cont = Lambda.next_raise_count () in @@ -1353,6 +1389,7 @@ let simplif_primitive_32bits : | Pbintcomp(Pint64, Lambda.Cgt) -> Pccall (default_prim "caml_greaterthan") | Pbintcomp(Pint64, Lambda.Cle) -> Pccall (default_prim "caml_lessequal") | Pbintcomp(Pint64, Lambda.Cge) -> Pccall (default_prim "caml_greaterequal") + | Pcompare_bints Pint64 -> Pccall (default_prim "caml_int64_compare") | Pbigarrayref(_unsafe, n, Pbigarray_int64, _layout) -> Pccall (default_prim ("caml_ba_get_" ^ Int.to_string n)) | Pbigarrayset(_unsafe, n, Pbigarray_int64, _layout) -> @@ -1458,6 +1495,7 @@ struct let gtint = Ccmpi Cgt type act = expression + type loc = Debuginfo.t (* CR mshinwell: GPR#2294 will fix the Debuginfo here *) @@ -1469,8 +1507,7 @@ struct let make_if cond ifso ifnot = Cifthenelse (cond, Debuginfo.none, ifso, Debuginfo.none, ifnot, Debuginfo.none) - let make_switch loc arg cases actions = - let dbg = Debuginfo.from_location loc in + let make_switch dbg arg cases actions = let actions = Array.map (fun expr -> expr, dbg) actions in make_switch arg cases actions dbg let bind arg body = bind "switcher" arg body @@ -1538,7 +1575,7 @@ module SwitcherBlocks = Switch.Make(SArgBlocks) (* Int switcher, arg in [low..high], cases is list of individual cases, and is sorted by first component *) -let transl_int_switch loc arg low high cases default = match cases with +let transl_int_switch dbg arg low high cases default = match cases with | [] -> assert false | _::_ -> let store = StoreExp.mk_store () in @@ -1578,7 +1615,7 @@ let transl_int_switch loc arg low high cases default = match cases with bind "switcher" arg (fun a -> SwitcherBlocks.zyva - loc + dbg (low,high) a (Array.of_list inters) store) @@ -1684,10 +1721,10 @@ let cache_public_method meths tag cache dbg = let cconst_int i = Cconst_int (i, dbg) in let li = V.create_local "*li*" and hi = V.create_local "*hi*" and mi = V.create_local "*mi*" and tagged = V.create_local "*tagged*" in - Clet ( - VP.create li, cconst_int 3, - Clet ( - VP.create hi, Cop(Cload (Word_int, Mutable), [meths], dbg), + Clet_mut ( + VP.create li, typ_int, cconst_int 3, + Clet_mut ( + VP.create hi, typ_int, Cop(Cload (Word_int, Mutable), [meths], dbg), Csequence( ccatch (raise_num, [], @@ -1721,7 +1758,7 @@ let cache_public_method meths tag cache dbg = dbg), Clet ( VP.create tagged, - Cop(Cadda, [lsl_const (Cvar li) log2_size_addr dbg; + Cop(Caddi, [lsl_const (Cvar li) log2_size_addr dbg; cconst_int(1 - 3 * size_addr)], dbg), Csequence(Cop (Cstore (Word_int, Assignment), [cache; Cvar tagged], dbg), Cvar tagged))))) diff --git a/asmcomp/cmm_helpers.mli b/asmcomp/cmm_helpers.mli index 3503ab2b..c1ace961 100644 --- a/asmcomp/cmm_helpers.mli +++ b/asmcomp/cmm_helpers.mli @@ -153,6 +153,10 @@ val mk_if_then_else : (** Boolean negation *) val mk_not : Debuginfo.t -> expression -> expression +(** Integer and float comparison that returns int not bool *) +val mk_compare_ints : Debuginfo.t -> expression -> expression -> expression +val mk_compare_floats : Debuginfo.t -> expression -> expression -> expression + (** Loop construction (while true do expr done). Used to be represented as Cloop. *) val create_loop : expression -> Debuginfo.t -> expression @@ -526,12 +530,12 @@ val make_switch : (** [transl_int_switch loc arg low high cases default] *) val transl_int_switch : - Location.t -> expression -> int -> int -> + Debuginfo.t -> expression -> int -> int -> (int * expression) list -> expression -> expression (** [transl_switch_clambda loc arg index cases] *) val transl_switch_clambda : - Location.t -> expression -> int array -> expression array -> expression + Debuginfo.t -> expression -> int array -> expression array -> expression (** [strmatch_compile dbg arg default cases] *) val strmatch_compile : diff --git a/asmcomp/cmmgen.ml b/asmcomp/cmmgen.ml index fd42fc5d..8515e3d6 100644 --- a/asmcomp/cmmgen.ml +++ b/asmcomp/cmmgen.ml @@ -247,6 +247,11 @@ let box_int dbg bi arg = (* Boxed numbers *) +let typ_of_boxed_number = function + | Boxed_float _ -> Cmm.typ_float + | Boxed_integer (Pint64, _) when size_int = 4 -> [|Int;Int|] + | Boxed_integer _ -> Cmm.typ_int + let equal_unboxed_integer ui1 ui2 = match ui1, ui2 with | Pnativeint, Pnativeint -> true @@ -277,7 +282,6 @@ let unbox_number dbg bn arg = | Boxed_integer (bi, _) -> unbox_int dbg bi arg - (* Auxiliary functions for optimizing "let" of boxed numbers (floats and boxed integers *) @@ -543,6 +547,7 @@ let rec transl env e = | Psetfield (_, _, _) | Psetfield_computed (_, _) | Pfloatfield _ | Psetfloatfield (_, _) | Pduprecord (_, _) | Praise _ | Pdivint _ | Pmodint _ | Pintcomp _ | Poffsetint _ + | Pcompare_ints | Pcompare_floats | Pcompare_bints _ | Poffsetref _ | Pfloatcomp _ | Parraylength _ | Parrayrefu _ | Parraysetu _ | Parrayrefs _ | Parraysets _ | Pbintofint _ | Pintofbint _ | Pcvtbint (_, _) | Pnegbint _ @@ -557,7 +562,6 @@ let rec transl env e = (* Control structures *) | Uswitch(arg, s, dbg) -> - let loc = Debuginfo.to_location dbg in (* As in the bytecode interpreter, only matching against constants can be checked *) if Array.length s.us_index_blocks = 0 then @@ -568,17 +572,17 @@ let rec transl env e = dbg else if Array.length s.us_index_consts = 0 then bind "switch" (transl env arg) (fun arg -> - transl_switch loc env (get_tag arg dbg) + transl_switch dbg env (get_tag arg dbg) s.us_index_blocks s.us_actions_blocks) else bind "switch" (transl env arg) (fun arg -> Cifthenelse( Cop(Cand, [arg; Cconst_int (1, dbg)], dbg), dbg, - transl_switch loc env + transl_switch dbg env (untag_int arg dbg) s.us_index_consts s.us_actions_consts, dbg, - transl_switch loc env + transl_switch dbg env (get_tag arg dbg) s.us_index_blocks s.us_actions_blocks, dbg)) | Ustringswitch(arg,sw,d) -> @@ -627,8 +631,8 @@ let rec transl env e = let raise_num = next_raise_count () in let id_prev = VP.create (V.create_local "*id_prev*") in return_unit dbg - (Clet - (id, transl env low, + (Clet_mut + (id, typ_int, transl env low, bind_nonvar "bound" (transl env high) (fun high -> ccatch (raise_num, [], @@ -687,11 +691,6 @@ and transl_catch env nfail ids body handler dbg = in let env_body = add_notify_catch nfail report env in let body = transl env_body body in - let typ_of_bn = function - | Boxed_float _ -> Cmm.typ_float - | Boxed_integer (Pint64, _) when size_int = 4 -> [|Int;Int|] - | Boxed_integer _ -> Cmm.typ_int - in let new_env, rewrite, ids = List.fold_right (fun (id, _kind, u) (env, rewrite, ids) -> @@ -704,7 +703,7 @@ and transl_catch env nfail ids body handler dbg = let unboxed_id = V.create_local (VP.name id) in add_unboxed_id (VP.var id) unboxed_id bn env, (unbox_number Debuginfo.none bn) :: rewrite, - (VP.create unboxed_id, typ_of_bn bn) :: ids + (VP.create unboxed_id, typ_of_boxed_number bn) :: ids ) ids (env, [], []) in @@ -841,6 +840,7 @@ and transl_prim_1 env p arg dbg = | Pmakeblock (_, _, _) | Psetfield (_, _, _) | Psetfield_computed (_, _) | Psetfloatfield (_, _) | Pduprecord (_, _) | Pccall _ | Pdivint _ | Pmodint _ | Pintcomp _ | Pfloatcomp _ | Pmakearray (_, _) + | Pcompare_ints | Pcompare_floats | Pcompare_bints _ | Pduparray (_, _) | Parrayrefu _ | Parraysetu _ | Parrayrefs _ | Parraysets _ | Paddbint _ | Psubbint _ | Pmulbint _ | Pdivbint _ | Pmodbint _ | Pandbint _ | Porbint _ | Pxorbint _ @@ -907,6 +907,17 @@ and transl_prim_2 env p arg1 arg2 dbg = asr_int_caml (transl env arg1) (transl env arg2) dbg | Pintcomp cmp -> int_comp_caml cmp (transl env arg1) (transl env arg2) dbg + | Pcompare_ints -> + (* Compare directly on tagged ints *) + mk_compare_ints dbg (transl env arg1) (transl env arg2) + | Pcompare_bints bi -> + let a1 = transl_unbox_int dbg env bi arg1 in + let a2 = transl_unbox_int dbg env bi arg2 in + mk_compare_ints dbg a1 a2 + | Pcompare_floats -> + let a1 = transl_unbox_float dbg env arg1 in + let a2 = transl_unbox_float dbg env arg2 in + mk_compare_floats dbg a1 a2 | Pisout -> transl_isout (transl env arg1) (transl env arg2) dbg (* Float operations *) @@ -1063,6 +1074,7 @@ and transl_prim_3 env p arg1 arg2 arg3 dbg = | Pbswap16 | Pint_as_pointer | Popaque | Pread_symbol _ | Pmakeblock (_, _, _) | Pfield _ | Psetfield (_, _, _) | Pfloatfield _ | Psetfloatfield (_, _) | Pduprecord (_, _) | Pccall _ | Praise _ | Pdivint _ | Pmodint _ | Pintcomp _ + | Pcompare_ints | Pcompare_floats | Pcompare_bints _ | Poffsetint _ | Poffsetref _ | Pfloatcomp _ | Pmakearray (_, _) | Pduparray (_, _) | Parraylength _ | Parrayrefu _ | Parrayrefs _ | Pbintofint _ | Pintofbint _ | Pcvtbint (_, _) | Pnegbint _ | Paddbint _ @@ -1125,11 +1137,21 @@ and transl_let env str kind id exp body = | No_unboxing | Boxed (_, true) | No_result -> (* N.B. [body] must still be traversed even if [exp] will never return: there may be constant closures inside that need lifting out. *) - Clet(id, cexp, transl env body) - | Boxed (boxed_number, _false) -> + begin match str, kind with + | Immutable, _ -> Clet(id, cexp, transl env body) + | Mutable, Pintval -> Clet_mut(id, typ_int, cexp, transl env body) + | Mutable, _ -> Clet_mut(id, typ_val, cexp, transl env body) + end + | Boxed (boxed_number, false) -> let unboxed_id = V.create_local (VP.name id) in - Clet(VP.create unboxed_id, unbox_number dbg boxed_number cexp, - transl (add_unboxed_id (VP.var id) unboxed_id boxed_number env) body) + let v = VP.create unboxed_id in + let cexp = unbox_number dbg boxed_number cexp in + let body = + transl (add_unboxed_id (VP.var id) unboxed_id boxed_number env) body in + begin match str, boxed_number with + | Immutable, _ -> Clet (v, cexp, body) + | Mutable, bn -> Clet_mut (v, typ_of_boxed_number bn, cexp, body) + end and make_catch ncatch body handler dbg = match body with | Cexit (nexit,[]) when nexit=ncatch -> handler @@ -1270,12 +1292,12 @@ and transl_sequor env (approx : then_else) then_ (* This assumes that [arg] can be safely discarded if it is not used. *) -and transl_switch loc env arg index cases = match Array.length cases with +and transl_switch dbg env arg index cases = match Array.length cases with | 0 -> fatal_error "Cmmgen.transl_switch" | 1 -> transl env cases.(0) | _ -> let cases = Array.map (transl env) cases in - transl_switch_clambda loc arg index cases + transl_switch_clambda dbg arg index cases and transl_letrec env bindings cont = let dbg = Debuginfo.none in @@ -1298,7 +1320,7 @@ and transl_letrec env bindings cont = Clet(id, op_alloc "caml_alloc_dummy_float" [int_const dbg sz], init_blocks rem) | (id, _exp, RHS_nonrec) :: rem -> - Clet (id, Cconst_int (0, dbg), init_blocks rem) + Clet (id, Cconst_int (1, dbg), init_blocks rem) and fill_nonrec = function | [] -> fill_blocks bsz | (_id, _exp, diff --git a/asmcomp/coloring.ml b/asmcomp/coloring.ml index ffcd71b7..897da20d 100644 --- a/asmcomp/coloring.ml +++ b/asmcomp/coloring.ml @@ -74,18 +74,13 @@ let allocate_registers() = (* Iterate over all registers preferred by the given register (transitive) *) let iter_preferred f reg = let rec walk r w = - if not r.visited then begin + if not (Reg.is_visited r) then begin + Reg.mark_visited r; f r w; - begin match r.prefer with - [] -> () - | p -> r.visited <- true; - List.iter (fun (r1, w1) -> walk r1 (min w w1)) p; - r.visited <- false - end + List.iter (fun (r1, w1) -> walk r1 (min w w1)) r.prefer end in - reg.visited <- true; List.iter (fun (r, w) -> walk r w) reg.prefer; - reg.visited <- false in + Reg.clear_visited_marks () in (* Where to start the search for a suitable register. Used to introduce some "randomness" in the choice between registers diff --git a/asmcomp/comballoc.ml b/asmcomp/comballoc.ml index 29ee15b3..6d7e536e 100644 --- a/asmcomp/comballoc.ml +++ b/asmcomp/comballoc.ml @@ -17,34 +17,42 @@ open Mach +type pending_alloc = + { reg: Reg.t; (* register holding the result of the last allocation *) + dbginfos: Debuginfo.alloc_dbginfo; (* debug info for each pending alloc *) + totalsz: int } (* amount to be allocated in this block *) + type allocation_state = No_alloc - | Pending_alloc of - { reg: Reg.t; (* register holding the result of the last allocation *) - totalsz: int } (* amount to be allocated in this block *) - -let allocated_size = function - No_alloc -> 0 - | Pending_alloc {totalsz; _} -> totalsz + | Pending_alloc of pending_alloc let rec combine i allocstate = match i.desc with Iend | Ireturn | Iexit _ | Iraise _ -> - (i, allocated_size allocstate) - | Iop(Ialloc { bytes = sz; _ }) -> + (i, allocstate) + | Iop(Ialloc { bytes = sz; dbginfo; _ }) -> + assert (List.length dbginfo = 1); begin match allocstate with - | Pending_alloc {reg; totalsz} - when totalsz + sz < Config.max_young_wosize * Arch.size_addr -> - let (next, totalsz) = + | Pending_alloc {reg; dbginfos; totalsz} + when totalsz + sz <= (Config.max_young_wosize + 1) * Arch.size_addr -> + let (next, state) = combine i.next - (Pending_alloc { reg = i.res.(0); totalsz = totalsz + sz }) in + (Pending_alloc { reg = i.res.(0); + dbginfos = dbginfo @ dbginfos; + totalsz = totalsz + sz }) in (instr_cons_debug (Iop(Iintop_imm(Iadd, -sz))) [| reg |] i.res i.dbg next, - totalsz) + state) | No_alloc | Pending_alloc _ -> - let (next, totalsz) = + let (next, state) = combine i.next - (Pending_alloc { reg = i.res.(0); totalsz = sz }) in + (Pending_alloc { reg = i.res.(0); + dbginfos = dbginfo; + totalsz = sz }) in + let totalsz, dbginfo = + match state with + | No_alloc -> assert false + | Pending_alloc { totalsz; dbginfos; _ } -> totalsz, dbginfos in let next = let offset = totalsz - sz in if offset = 0 then next @@ -52,40 +60,40 @@ let rec combine i allocstate = i.res i.dbg next in (instr_cons_debug (Iop(Ialloc {bytes = totalsz; spacetime_index = 0; - label_after_call_gc = None; })) - i.arg i.res i.dbg next, allocated_size allocstate) + dbginfo; label_after_call_gc = None; })) + i.arg i.res i.dbg next, allocstate) end | Iop(Icall_ind _ | Icall_imm _ | Iextcall _ | Itailcall_ind _ | Itailcall_imm _) -> let newnext = combine_restart i.next in (instr_cons_debug i.desc i.arg i.res i.dbg newnext, - allocated_size allocstate) + allocstate) | Iop _ -> - let (newnext, sz) = combine i.next allocstate in - (instr_cons_debug i.desc i.arg i.res i.dbg newnext, sz) + let (newnext, s') = combine i.next allocstate in + (instr_cons_debug i.desc i.arg i.res i.dbg newnext, s') | Iifthenelse(test, ifso, ifnot) -> let newifso = combine_restart ifso in let newifnot = combine_restart ifnot in let newnext = combine_restart i.next in (instr_cons (Iifthenelse(test, newifso, newifnot)) i.arg i.res newnext, - allocated_size allocstate) + allocstate) | Iswitch(table, cases) -> let newcases = Array.map combine_restart cases in let newnext = combine_restart i.next in (instr_cons (Iswitch(table, newcases)) i.arg i.res newnext, - allocated_size allocstate) + allocstate) | Icatch(rec_flag, handlers, body) -> - let (newbody, sz) = combine body allocstate in + let (newbody, s') = combine body allocstate in let newhandlers = List.map (fun (io, handler) -> io, combine_restart handler) handlers in let newnext = combine_restart i.next in (instr_cons (Icatch(rec_flag, newhandlers, newbody)) - i.arg i.res newnext, sz) + i.arg i.res newnext, s') | Itrywith(body, handler) -> - let (newbody, sz) = combine body allocstate in + let (newbody, s') = combine body allocstate in let newhandler = combine_restart handler in let newnext = combine_restart i.next in - (instr_cons (Itrywith(newbody, newhandler)) i.arg i.res newnext, sz) + (instr_cons (Itrywith(newbody, newhandler)) i.arg i.res newnext, s') and combine_restart i = let (newi, _) = combine i No_alloc in newi diff --git a/asmcomp/emitaux.ml b/asmcomp/emitaux.ml index e0476d17..9a1e6214 100644 --- a/asmcomp/emitaux.ml +++ b/asmcomp/emitaux.ml @@ -105,26 +105,30 @@ let emit_float32_directive directive x = (* Record live pointers at call points *) +type frame_debuginfo = + | Dbg_alloc of Debuginfo.alloc_dbginfo + | Dbg_raise of Debuginfo.t + | Dbg_other of Debuginfo.t + type frame_descr = { fd_lbl: int; (* Return address *) fd_frame_size: int; (* Size of stack frame *) fd_live_offset: int list; (* Offsets/regs of live addresses *) - fd_raise: bool; (* Is frame for a raise? *) - fd_debuginfo: Debuginfo.t } (* Location, if any *) + fd_debuginfo: frame_debuginfo } (* Location, if any *) let frame_descriptors = ref([] : frame_descr list) -let record_frame_descr ~label ~frame_size ~live_offset ~raise_frame debuginfo = +let record_frame_descr ~label ~frame_size ~live_offset debuginfo = frame_descriptors := { fd_lbl = label; fd_frame_size = frame_size; fd_live_offset = List.sort_uniq (-) live_offset; - fd_raise = raise_frame; fd_debuginfo = debuginfo } :: !frame_descriptors type emit_frame_actions = { efa_code_label: int -> unit; efa_data_label: int -> unit; + efa_8: int -> unit; efa_16: int -> unit; efa_32: int32 -> unit; efa_word: int -> unit; @@ -143,6 +147,16 @@ let emit_frames a = Hashtbl.add filenames name lbl; lbl in + let defnames = Hashtbl.create 7 in + let label_defname filename defname = + try + snd (Hashtbl.find defnames (filename, defname)) + with Not_found -> + let file_lbl = label_filename filename in + let def_lbl = Cmm.new_label () in + Hashtbl.add defnames (filename, defname) (file_lbl, def_lbl); + def_lbl + in let module Label_table = Hashtbl.Make (struct type t = bool * Debuginfo.t @@ -155,68 +169,111 @@ let emit_frames a = end) in let debuginfos = Label_table.create 7 in - let rec label_debuginfos rs rdbg = + let label_debuginfos rs dbg = + let rdbg = List.rev dbg in let key = (rs, rdbg) in - try fst (Label_table.find debuginfos key) + try Label_table.find debuginfos key with Not_found -> let lbl = Cmm.new_label () in - let next = - match rdbg with - | [] -> assert false - | _ :: [] -> None - | _ :: ((_ :: _) as rdbg') -> Some (label_debuginfos false rdbg') - in - Label_table.add debuginfos key (lbl, next); + Label_table.add debuginfos key lbl; lbl in - let emit_debuginfo_label rs rdbg = - a.efa_data_label (label_debuginfos rs rdbg) - in let emit_frame fd = + assert (fd.fd_frame_size land 3 = 0); + let flags = + match fd.fd_debuginfo with + | Dbg_other d | Dbg_raise d -> + if Debuginfo.is_none d then 0 else 1 + | Dbg_alloc dbgs -> + if !Clflags.debug && not Config.spacetime && + List.exists (fun d -> + not (Debuginfo.is_none d.Debuginfo.alloc_dbg)) dbgs + then 3 else 2 + in a.efa_code_label fd.fd_lbl; - a.efa_16 (if Debuginfo.is_none fd.fd_debuginfo - then fd.fd_frame_size - else fd.fd_frame_size + 1); + a.efa_16 (fd.fd_frame_size + flags); a.efa_16 (List.length fd.fd_live_offset); List.iter a.efa_16 fd.fd_live_offset; - a.efa_align Arch.size_addr; - match List.rev fd.fd_debuginfo with - | [] -> () - | _ :: _ as rdbg -> emit_debuginfo_label fd.fd_raise rdbg + begin match fd.fd_debuginfo with + | _ when flags = 0 -> + () + | Dbg_other dbg -> + a.efa_align 4; + a.efa_label_rel (label_debuginfos false dbg) Int32.zero + | Dbg_raise dbg -> + a.efa_align 4; + a.efa_label_rel (label_debuginfos true dbg) Int32.zero + | Dbg_alloc dbg -> + assert (List.length dbg < 256); + a.efa_8 (List.length dbg); + List.iter (fun Debuginfo.{alloc_words;_} -> + (* Possible allocations range between 2 and 257 *) + assert (2 <= alloc_words && + alloc_words - 1 <= Config.max_young_wosize && + Config.max_young_wosize <= 256); + a.efa_8 (alloc_words - 2)) dbg; + if flags = 3 then begin + a.efa_align 4; + List.iter (fun Debuginfo.{alloc_dbg; _} -> + if Debuginfo.is_none alloc_dbg then + a.efa_32 Int32.zero + else + a.efa_label_rel (label_debuginfos false alloc_dbg) Int32.zero) dbg + end + end; + a.efa_align Arch.size_addr in let emit_filename name lbl = a.efa_def_label lbl; - a.efa_string name; - a.efa_align Arch.size_addr + a.efa_string name + in + let emit_defname (_filename, defname) (file_lbl, lbl) = + (* These must be 32-bit aligned, both because they contain a + 32-bit value, and because emit_debuginfo assumes the low 2 bits + of their addresses are 0. *) + a.efa_align 4; + a.efa_def_label lbl; + a.efa_label_rel file_lbl 0l; + a.efa_string defname in - let pack_info fd_raise d = + let pack_info fd_raise d has_next = let line = min 0xFFFFF d.Debuginfo.dinfo_line and char_start = min 0xFF d.Debuginfo.dinfo_char_start and char_end = min 0x3FF d.Debuginfo.dinfo_char_end - and kind = if fd_raise then 1 else 0 in + and kind = if fd_raise then 1 else 0 + and has_next = if has_next then 1 else 0 in Int64.(add (shift_left (of_int line) 44) (add (shift_left (of_int char_start) 36) (add (shift_left (of_int char_end) 26) - (of_int kind)))) + (add (shift_left (of_int kind) 1) + (of_int has_next))))) in - let emit_debuginfo (rs, rdbg) (lbl,next) = - let d = List.hd rdbg in - a.efa_align Arch.size_addr; + let emit_debuginfo (rs, rdbg) lbl = + (* Due to inlined functions, a single debuginfo may have multiple locations. + These are represented sequentially in memory (innermost frame first), + with the low bit of the packed debuginfo being 0 on the last entry. *) + a.efa_align 4; a.efa_def_label lbl; - let info = pack_info rs d in - a.efa_label_rel - (label_filename d.Debuginfo.dinfo_file) - (Int64.to_int32 info); - a.efa_32 (Int64.to_int32 (Int64.shift_right info 32)); - begin match next with - | Some next -> a.efa_data_label next - | None -> a.efa_word 0 - end - in + let rec emit rs d rest = + let open Debuginfo in + let info = pack_info rs d (rest <> []) in + let defname = Scoped_location.string_of_scopes d.dinfo_scopes in + a.efa_label_rel + (label_defname d.dinfo_file defname) + (Int64.to_int32 info); + a.efa_32 (Int64.to_int32 (Int64.shift_right info 32)); + match rest with + | [] -> () + | d :: rest -> emit false d rest in + match rdbg with + | [] -> assert false + | d :: rest -> emit rs d rest in a.efa_word (List.length !frame_descriptors); List.iter emit_frame !frame_descriptors; Label_table.iter emit_debuginfo debuginfos; Hashtbl.iter emit_filename filenames; + Hashtbl.iter emit_defname defnames; + a.efa_align Arch.size_addr; frame_descriptors := [] (* Detection of functions that can be duplicated between a DLL and diff --git a/asmcomp/emitaux.mli b/asmcomp/emitaux.mli index b2b2141c..2b4867d0 100644 --- a/asmcomp/emitaux.mli +++ b/asmcomp/emitaux.mli @@ -38,17 +38,22 @@ val emit_debug_info_gen : (file_num:int -> file_name:string -> unit) -> (file_num:int -> line:int -> col:int -> unit) -> unit +type frame_debuginfo = + | Dbg_alloc of Debuginfo.alloc_dbginfo + | Dbg_raise of Debuginfo.t + | Dbg_other of Debuginfo.t + val record_frame_descr : label:int -> (* Return address *) frame_size:int -> (* Size of stack frame *) live_offset:int list -> (* Offsets/regs of live addresses *) - raise_frame:bool -> (* Is frame for a raise? *) - Debuginfo.t -> (* Location, if any *) + frame_debuginfo -> (* Location, if any *) unit type emit_frame_actions = { efa_code_label: int -> unit; efa_data_label: int -> unit; + efa_8: int -> unit; efa_16: int -> unit; efa_32: int32 -> unit; efa_word: int -> unit; diff --git a/asmcomp/i386/emit.mlp b/asmcomp/i386/emit.mlp index 9c1ca30a..1bad19f9 100644 --- a/asmcomp/i386/emit.mlp +++ b/asmcomp/i386/emit.mlp @@ -200,7 +200,7 @@ let addressing addr typ i n = (* Record live pointers at call points *) -let record_frame_label ?label live raise_ dbg = +let record_frame_label ?label live dbg = let lbl = match label with | None -> new_label() @@ -218,11 +218,11 @@ let record_frame_label ?label live raise_ dbg = | _ -> ()) live; record_frame_descr ~label:lbl ~frame_size:(frame_size()) - ~live_offset:!live_offset ~raise_frame:raise_ dbg; + ~live_offset:!live_offset dbg; lbl -let record_frame ?label live raise_ dbg = - let lbl = record_frame_label ?label live raise_ dbg in +let record_frame ?label live dbg = + let lbl = record_frame_label ?label live dbg in def_label lbl (* Record calls to the GC -- we've moved them out of the way *) @@ -254,7 +254,7 @@ let bound_error_call = ref 0 let bound_error_label ?label dbg = if !Clflags.debug then begin let lbl_bound_error = new_label() in - let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in + let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in bound_error_sites := { bd_lbl = lbl_bound_error; bd_frame = lbl_frame } :: !bound_error_sites; lbl_bound_error @@ -540,11 +540,11 @@ let emit_instr fallthrough i = I.mov (immsym s) (reg i.res.(0)) | Lop(Icall_ind { label_after; }) -> I.call (reg i.arg.(0)); - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after | Lop(Icall_imm { func; label_after; }) -> add_used_symbol func; emit_call func; - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after | Lop(Itailcall_ind { label_after = _; }) -> output_epilogue begin fun () -> I.jmp (reg i.arg.(0)) @@ -563,7 +563,7 @@ let emit_instr fallthrough i = if alloc then begin I.mov (immsym func) eax; emit_call "caml_c_call"; - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after end else begin emit_call func end @@ -614,22 +614,24 @@ let emit_instr fallthrough i = I.fstp (addressing addr REAL8 i 1) end end - | Lop(Ialloc { bytes = n; label_after_call_gc; }) -> + | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) -> if !fastcode_flag then begin - let lbl_redo = new_label() in - def_label lbl_redo; load_domain_state ebx; I.mov (domain_field Domain_young_ptr RBX) eax; I.sub (int n) eax; + I.mov eax (domain_field Domain_young_ptr RBX); I.cmp (domain_field Domain_young_limit RBX) eax; let lbl_call_gc = new_label() in - let lbl_frame = record_frame_label i.live false Debuginfo.none in + let lbl_frame = + record_frame_label ?label:label_after_call_gc + i.live (Dbg_alloc dbginfo) in I.jb (label lbl_call_gc); - I.mov eax (domain_field Domain_young_ptr RBX); + let lbl_after_alloc = new_label() in + def_label lbl_after_alloc; I.lea (mem32 NONE 4 RAX) (reg i.res.(0)); call_gc_sites := { gc_lbl = lbl_call_gc; - gc_return_lbl = lbl_redo; + gc_return_lbl = lbl_after_alloc; gc_frame = lbl_frame } :: !call_gc_sites end else begin begin match n with @@ -641,8 +643,8 @@ let emit_instr fallthrough i = emit_call "caml_allocN" end; let label = - record_frame_label ?label:label_after_call_gc i.live false - Debuginfo.none + record_frame_label ?label:label_after_call_gc + i.live (Dbg_alloc dbginfo) in def_label label; I.lea (mem32 NONE 4 RAX) (reg i.res.(0)) @@ -895,10 +897,10 @@ let emit_instr fallthrough i = load_domain_state ebx; I.mov (int 0) (domain_field Domain_backtrace_pos RBX); emit_call "caml_raise_exn"; - record_frame Reg.Set.empty true i.dbg + record_frame Reg.Set.empty (Dbg_raise i.dbg) | Lambda.Raise_reraise -> emit_call "caml_raise_exn"; - record_frame Reg.Set.empty true i.dbg + record_frame Reg.Set.empty (Dbg_raise i.dbg) | Lambda.Raise_notrace -> load_domain_state ebx; I.mov (domain_field Domain_exception_pointer RBX) esp; @@ -1019,6 +1021,7 @@ let end_assembly() = emit_frames { efa_code_label = (fun l -> D.long (ConstLabel (emit_label l))); efa_data_label = (fun l -> D.long (ConstLabel (emit_label l))); + efa_8 = (fun n -> D.byte (const n)); efa_16 = (fun n -> D.word (const n)); efa_32 = (fun n -> D.long (const_32 n)); efa_word = (fun n -> D.long (const n)); diff --git a/asmcomp/mach.ml b/asmcomp/mach.ml index ab69e0ca..8518e9da 100644 --- a/asmcomp/mach.ml +++ b/asmcomp/mach.ml @@ -55,7 +55,7 @@ type operation = | Iload of Cmm.memory_chunk * Arch.addressing_mode | Istore of Cmm.memory_chunk * Arch.addressing_mode * bool | Ialloc of { bytes : int; label_after_call_gc : label option; - spacetime_index : int; } + dbginfo : Debuginfo.alloc_dbginfo; spacetime_index : int; } | Iintop of integer_operation | Iintop_imm of integer_operation * int | Inegf | Iabsf | Iaddf | Isubf | Imulf | Idivf diff --git a/asmcomp/mach.mli b/asmcomp/mach.mli index 5df79585..1141d57d 100644 --- a/asmcomp/mach.mli +++ b/asmcomp/mach.mli @@ -63,7 +63,7 @@ type operation = | Istore of Cmm.memory_chunk * Arch.addressing_mode * bool (* false = initialization, true = assignment *) | Ialloc of { bytes : int; label_after_call_gc : label option; - spacetime_index : int; } + dbginfo : Debuginfo.alloc_dbginfo; spacetime_index : int; } (** For Spacetime only, Ialloc instructions take one argument, being the pointer to the trie node for the current function. *) | Iintop of integer_operation diff --git a/asmcomp/power/arch.ml b/asmcomp/power/arch.ml index 70cd75dd..07bf8dbf 100644 --- a/asmcomp/power/arch.ml +++ b/asmcomp/power/arch.ml @@ -34,11 +34,13 @@ let abi = (* Machine-specific command-line options *) -let big_toc = ref false +let big_toc = ref true let command_line_options = [ "-flarge-toc", Arg.Set big_toc, - " Support TOC (table of contents) greater than 64 kbytes" + " Support TOC (table of contents) greater than 64 kbytes (default)"; + "-fsmall-toc", Arg.Clear big_toc, + " TOC (table of contents) is limited to 64 kbytes" ] (* Specific operations *) @@ -47,7 +49,8 @@ type specific_operation = Imultaddf (* multiply and add *) | Imultsubf (* multiply and subtract *) | Ialloc_far of (* allocation in large functions *) - { bytes : int; label_after_call_gc : int (*Cmm.label*) option; } + { bytes : int; label_after_call_gc : int (*Cmm.label*) option; + dbginfo : Debuginfo.alloc_dbginfo } (* note: we avoid introducing a dependency to Cmm since this dep is not detected when "make depend" is run under amd64 *) diff --git a/asmcomp/power/emit.mlp b/asmcomp/power/emit.mlp index 4c577d0b..5a28f556 100644 --- a/asmcomp/power/emit.mlp +++ b/asmcomp/power/emit.mlp @@ -308,7 +308,7 @@ let adjust_stack_offset delta = (* Record live pointers at call points *) -let record_frame ?label live raise_ dbg = +let record_frame ?label live dbg = let lbl = match label with | None -> new_label() @@ -326,7 +326,7 @@ let record_frame ?label live raise_ dbg = | _ -> ()) live; record_frame_descr ~label:lbl ~frame_size:(frame_size()) - ~live_offset:!live_offset ~raise_frame:raise_ dbg; + ~live_offset:!live_offset dbg; `{emit_label lbl}:\n` (* Record floating-point literals (for PPC32) *) @@ -398,38 +398,8 @@ let name_for_specific = function let function_name = ref "" (* Entry point for tail recursive calls *) let tailrec_entry_point = ref 0 - -module IntSet = Stdlib.Set.Make(Stdlib.Int) -module IntMap = Stdlib.Map.Make(Stdlib.Int) - -(* Labels of glue code for calling the GC. - There is one label per size allocated. *) -let call_gc_labels : label IntMap.t ref = ref IntMap.empty - (* size -> label *) - -(* Return the label of the call GC point for the given size *) - -let label_for_call_gc ?label_after_call_gc sz = - match IntMap.find_opt sz !call_gc_labels with - | Some lbl -> lbl - | None -> - let lbl = - match label_after_call_gc with Some l -> l | None -> new_label() in - call_gc_labels := IntMap.add sz lbl !call_gc_labels; - lbl - -(* Number of call GC points *) - -let num_call_gc instr = - let rec loop i cg = - match i.desc with - | Lend -> IntSet.cardinal cg - | Lop (Ialloc {bytes = sz}) -> loop i.next (IntSet.add sz cg) - (* The following should never be seen, since this function is run - before branch relaxation. *) - | Lop (Ispecific (Ialloc_far _)) -> assert false - | _ -> loop i.next cg - in loop instr IntSet.empty +(* Label of glue code for calling the GC *) +let call_gc_label = ref 0 (* Relaxation of branches that exceed the span of a relative branch. *) @@ -546,8 +516,8 @@ module BR = Branch_relaxation.Make (struct | Lpoptrap -> 2 | Lraise _ -> 6 - let relax_allocation ~num_bytes:bytes ~label_after_call_gc = - Lop (Ispecific (Ialloc_far { bytes; label_after_call_gc; })) + let relax_allocation ~num_bytes:bytes ~label_after_call_gc ~dbginfo = + Lop (Ispecific (Ialloc_far { bytes; label_after_call_gc; dbginfo })) (* [classify_addr], above, never identifies these instructions as needing relaxing. As such, these functions should never be called. *) @@ -652,26 +622,26 @@ let emit_instr i = | ELF32 -> ` mtctr {emit_reg i.arg.(0)}\n`; ` bctrl\n`; - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after | ELF64v1 -> ` ld 0, 0({emit_reg i.arg.(0)})\n`; (* code pointer *) ` mtctr 0\n`; ` ld 2, 8({emit_reg i.arg.(0)})\n`; (* TOC for callee *) ` bctrl\n`; - record_frame i.live false i.dbg ~label:label_after; + record_frame i.live (Dbg_other i.dbg) ~label:label_after; emit_reload_toc() | ELF64v2 -> ` mtctr {emit_reg i.arg.(0)}\n`; ` mr 12, {emit_reg i.arg.(0)}\n`; (* addr of fn in r12 *) ` bctrl\n`; - record_frame i.live false i.dbg ~label:label_after; + record_frame i.live (Dbg_other i.dbg) ~label:label_after; emit_reload_toc() end | Lop(Icall_imm { func; label_after; }) -> begin match abi with | ELF32 -> emit_call func; - record_frame i.live false i.dbg ~label:label_after + record_frame i.live (Dbg_other i.dbg) ~label:label_after | ELF64v1 | ELF64v2 -> (* For PPC64, we cannot just emit a "bl s; nop" sequence, because of the following scenario: @@ -691,7 +661,7 @@ let emit_instr i = Cost: 3 instructions if same TOC, 7 if different TOC. Let's try option 2. *) emit_call func; - record_frame i.live false i.dbg ~label:label_after; + record_frame i.live (Dbg_other i.dbg) ~label:label_after; ` nop\n`; emit_reload_toc() end @@ -751,11 +721,11 @@ let emit_instr i = ` addis 25, 0, {emit_upper emit_symbol func}\n`; ` addi 25, 25, {emit_lower emit_symbol func}\n`; emit_call "caml_c_call"; - record_frame i.live false i.dbg + record_frame i.live (Dbg_other i.dbg) | ELF64v1 | ELF64v2 -> emit_tocload emit_gpr 25 (TocSym func); emit_call "caml_c_call"; - record_frame i.live false i.dbg; + record_frame i.live (Dbg_other i.dbg); ` nop\n` end | Lop(Istackoffset n) -> @@ -786,23 +756,29 @@ let emit_instr i = | Single -> "stfs" | Double | Double_u -> "stfd" in emit_load_store storeinstr addr i.arg 1 i.arg.(0) - | Lop(Ialloc { bytes = n; label_after_call_gc; }) -> - let call_gc_lbl = label_for_call_gc ?label_after_call_gc n in + | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) -> + if !call_gc_label = 0 then begin + match label_after_call_gc with + | None -> call_gc_label := new_label () + | Some label -> call_gc_label := label + end; ` addi 31, 31, {emit_int(-n)}\n`; ` {emit_string cmplg} 31, 30\n`; + ` bltl {emit_label !call_gc_label}\n`; + record_frame i.live (Dbg_alloc dbginfo); ` addi {emit_reg i.res.(0)}, 31, {emit_int size_addr}\n`; - ` bltl {emit_label call_gc_lbl}\n`; - (* Exactly 4 instructions after the beginning of the alloc sequence *) - record_frame i.live false Debuginfo.none - | Lop(Ispecific(Ialloc_far { bytes = n; label_after_call_gc; })) -> - let call_gc_lbl = label_for_call_gc ?label_after_call_gc n in + | Lop(Ispecific(Ialloc_far { bytes = n; label_after_call_gc; dbginfo })) -> + if !call_gc_label = 0 then begin + match label_after_call_gc with + | None -> call_gc_label := new_label () + | Some label -> call_gc_label := label + end; let lbl = new_label() in ` addi 31, 31, {emit_int(-n)}\n`; ` {emit_string cmplg} 31, 30\n`; ` bge {emit_label lbl}\n`; - ` bl {emit_label call_gc_lbl}\n`; - (* Exactly 4 instructions after the beginning of the alloc sequence *) - record_frame i.live false Debuginfo.none; + ` bl {emit_label !call_gc_label}\n`; + record_frame i.live (Dbg_alloc dbginfo); `{emit_label lbl}: addi {emit_reg i.res.(0)}, 31, {emit_int size_addr}\n` | Lop(Iintop Isub) -> (* subfc has swapped arguments *) ` subfc {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n` @@ -821,7 +797,7 @@ let emit_instr i = end | Lop(Iintop (Icheckbound { label_after_error; })) -> if !Clflags.debug then - record_frame Reg.Set.empty false i.dbg ?label:label_after_error; + record_frame Reg.Set.empty (Dbg_other i.dbg) ?label:label_after_error; ` {emit_string tglle} {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` | Lop(Iintop op) -> let instr = name_for_intop op in @@ -839,7 +815,7 @@ let emit_instr i = end | Lop(Iintop_imm(Icheckbound { label_after_error; }, n)) -> if !Clflags.debug then - record_frame Reg.Set.empty false i.dbg ?label:label_after_error; + record_frame Reg.Set.empty (Dbg_other i.dbg) ?label:label_after_error; ` {emit_string tglle}i {emit_reg i.arg.(0)}, {emit_int n}\n` | Lop(Iintop_imm(op, n)) -> let instr = name_for_intop_imm op in @@ -1023,11 +999,11 @@ let emit_instr i = | _ -> ` std 0, {emit_int (backtrace_pos * 8)}(28)\n` end; emit_call "caml_raise_exn"; - record_frame Reg.Set.empty true i.dbg; + record_frame Reg.Set.empty (Dbg_raise i.dbg); emit_call_nop() | Lambda.Raise_reraise -> emit_call "caml_raise_exn"; - record_frame Reg.Set.empty true i.dbg; + record_frame Reg.Set.empty (Dbg_raise i.dbg); emit_call_nop() | Lambda.Raise_notrace -> ` {emit_string lg} 0, {emit_int trap_handler_offset}(29)\n`; @@ -1051,7 +1027,7 @@ let fundecl fundecl = function_name := fundecl.fun_name; tailrec_entry_point := fundecl.fun_tailrec_entry_point_label; stack_offset := 0; - call_gc_labels := IntMap.empty; + call_gc_label := 0; float_literals := []; jumptables := []; jumptables_lbl := -1; for i = 0 to Proc.num_register_classes - 1 do @@ -1088,30 +1064,14 @@ let fundecl fundecl = end; emit_debug_info fundecl.fun_dbg; cfi_startproc(); - let num_call_gc = num_call_gc fundecl.fun_body in - let max_out_of_line_code_offset = max (num_call_gc - 1) 0 in - BR.relax fundecl.fun_body ~max_out_of_line_code_offset; + (* On this target, there is at most one "out of line" code block per + function: a single "call GC" point. It comes immediately after the + function's body. *) + BR.relax fundecl.fun_body ~max_out_of_line_code_offset:0; emit_all fundecl.fun_body; (* Emit the glue code to call the GC *) - assert (IntMap.cardinal !call_gc_labels = num_call_gc); - if num_call_gc > 0 then begin - (* Replace sizes by deltas with next size *) - let rec delta_encode = function - | (sz1, lbl1) :: ((sz2, _) :: _ as l) -> - (sz1 - sz2, lbl1) :: delta_encode l - | ([] | [(_,_)]) as l -> l in - (* Enumerate the GC call points by decreasing size. This is not - necessary for correctness, but it is nice for two reasons: - 1- all deltas are positive, making the generated code - easier to read, and - 2- smaller allocation sizes, which are more frequent, execute - fewer instructions before calling the GC. *) - let delta_lbl_list = - delta_encode (List.rev (IntMap.bindings !call_gc_labels)) in - List.iter - (fun (delta, lbl) -> - `{emit_label lbl}: addi 31, 31, {emit_int delta}\n`) - delta_lbl_list; + if !call_gc_label > 0 then begin + `{emit_label !call_gc_label}:\n`; match abi with | ELF32 -> ` b {emit_symbol "caml_call_gc"}\n` @@ -1249,6 +1209,7 @@ let end_assembly() = (fun l -> ` {emit_string datag} {emit_label l}\n`); efa_data_label = (fun l -> ` {emit_string datag} {emit_label l}\n`); + efa_8 = (fun n -> ` .byte {emit_int n}\n`); efa_16 = (fun n -> ` .short {emit_int n}\n`); efa_32 = (fun n -> ` .long {emit_int32 n}\n`); efa_word = (fun n -> ` {emit_string datag} {emit_int n}\n`); diff --git a/asmcomp/printcmm.ml b/asmcomp/printcmm.ml index 1da5fe2a..377f9c2d 100644 --- a/asmcomp/printcmm.ml +++ b/asmcomp/printcmm.ml @@ -95,13 +95,17 @@ let phantom_defining_expr_opt ppf defining_expr = | None -> Format.pp_print_string ppf "()" | Some defining_expr -> phantom_defining_expr ppf defining_expr +let location d = + if not !Clflags.locations then "" + else Debuginfo.to_string d + let operation d = function - | Capply _ty -> "app" ^ Debuginfo.to_string d + | Capply _ty -> "app" ^ location d | Cextcall(lbl, _ty, _alloc, _) -> - Printf.sprintf "extcall \"%s\"%s" lbl (Debuginfo.to_string d) + Printf.sprintf "extcall \"%s\"%s" lbl (location d) | Cload (c, Asttypes.Immutable) -> Printf.sprintf "load %s" (chunk c) | Cload (c, Asttypes.Mutable) -> Printf.sprintf "load_mut %s" (chunk c) - | Calloc -> "alloc" ^ Debuginfo.to_string d + | Calloc -> "alloc" ^ location d | Cstore (c, init) -> let init = match init with @@ -135,8 +139,8 @@ let operation d = function | Cfloatofint -> "floatofint" | Cintoffloat -> "intoffloat" | Ccmpf c -> Printf.sprintf "%sf" (float_comparison c) - | Craise k -> Lambda.raise_kind k ^ Debuginfo.to_string d - | Ccheckbound -> "checkbound" ^ Debuginfo.to_string d + | Craise k -> Lambda.raise_kind k ^ location d + | Ccheckbound -> "checkbound" ^ location d let rec expr ppf = function | Cconst_int (n, _dbg) -> fprintf ppf "%i" n @@ -144,7 +148,7 @@ let rec expr ppf = function fprintf ppf "%s" (Nativeint.to_string n) | Cblockheader(n, d) -> fprintf ppf "block-hdr(%s)%s" - (Nativeint.to_string n) (Debuginfo.to_string d) + (Nativeint.to_string n) (location d) | Cconst_float (n, _dbg) -> fprintf ppf "%F" n | Cconst_symbol (s, _dbg) -> fprintf ppf "\"%s\"" s | Cconst_pointer (n, _dbg) -> fprintf ppf "%ia" n @@ -166,6 +170,10 @@ let rec expr ppf = function fprintf ppf "@[<2>(let@ @[<2>%a@ %a@]@ %a)@]" VP.print id expr def sequence body + | Clet_mut(id, kind, def, body) -> + fprintf ppf + "@[<2>(let_mut@ @[<2>%a: %a@ %a@]@ %a)@]" + VP.print id machtype kind expr def sequence body | Cphantom_let(var, def, (Cphantom_let(_, _, _) as body)) -> let print_binding var ppf def = fprintf ppf "@[<2>%a@ %a@]" VP.print var @@ -262,7 +270,7 @@ let fundecl ppf f = fprintf ppf "%a: %a" VP.print id machtype ty) cases in fprintf ppf "@[<1>(function%s %s@;<1 4>@[<1>(%a)@]@ @[%a@])@]@." - (Debuginfo.to_string f.fun_dbg) f.fun_name + (location f.fun_dbg) f.fun_name print_cases f.fun_args sequence f.fun_body let data_item ppf = function diff --git a/asmcomp/printlinear.ml b/asmcomp/printlinear.ml index 793580c0..916d2a1a 100644 --- a/asmcomp/printlinear.ml +++ b/asmcomp/printlinear.ml @@ -70,7 +70,7 @@ let instr ppf i = | Lraise k -> fprintf ppf "%s %a" (Lambda.raise_kind k) reg i.arg.(0) end; - if not (Debuginfo.is_none i.dbg) then + if not (Debuginfo.is_none i.dbg) && !Clflags.locations then fprintf ppf " %s" (Debuginfo.to_string i.dbg) let rec all_instr ppf i = @@ -80,7 +80,7 @@ let rec all_instr ppf i = let fundecl ppf f = let dbg = - if Debuginfo.is_none f.fun_dbg then + if Debuginfo.is_none f.fun_dbg || not !Clflags.locations then "" else " " ^ Debuginfo.to_string f.fun_dbg in diff --git a/asmcomp/printmach.ml b/asmcomp/printmach.ml index 64662e33..39128955 100644 --- a/asmcomp/printmach.ml +++ b/asmcomp/printmach.ml @@ -228,7 +228,7 @@ let rec instr ppf i = | Iraise k -> fprintf ppf "%s %a" (Lambda.raise_kind k) reg i.arg.(0) end; - if not (Debuginfo.is_none i.dbg) then + if not (Debuginfo.is_none i.dbg) && !Clflags.locations then fprintf ppf "%s" (Debuginfo.to_string i.dbg); begin match i.next.desc with Iend -> () @@ -237,7 +237,7 @@ let rec instr ppf i = let fundecl ppf f = let dbg = - if Debuginfo.is_none f.fun_dbg then + if Debuginfo.is_none f.fun_dbg || not !Clflags.locations then "" else " " ^ Debuginfo.to_string f.fun_dbg in diff --git a/asmcomp/reg.ml b/asmcomp/reg.ml index 72b68dab..145545d9 100644 --- a/asmcomp/reg.ml +++ b/asmcomp/reg.ml @@ -37,7 +37,7 @@ end type t = { mutable raw_name: Raw_name.t; stamp: int; - mutable typ: Cmm.machtype_component; + typ: Cmm.machtype_component; mutable loc: location; mutable spill: bool; mutable part: int option; @@ -45,7 +45,7 @@ type t = mutable prefer: (t * int) list; mutable degree: int; mutable spill_cost: int; - mutable visited: bool } + mutable visited: int } and location = Unknown @@ -62,16 +62,32 @@ type reg = t let dummy = { raw_name = Raw_name.Anon; stamp = 0; typ = Int; loc = Unknown; spill = false; interf = []; prefer = []; degree = 0; spill_cost = 0; - visited = false; part = None; + visited = 0; part = None; } let currstamp = ref 0 let reg_list = ref([] : t list) +let hw_reg_list = ref ([] : t list) + +let visit_generation = ref 1 + +(* Any visited value not equal to !visit_generation counts as "unvisited" *) +let unvisited = 0 + +let mark_visited r = + r.visited <- !visit_generation + +let is_visited r = + r.visited = !visit_generation + +let clear_visited_marks () = + incr visit_generation + let create ty = let r = { raw_name = Raw_name.Anon; stamp = !currstamp; typ = ty; loc = Unknown; spill = false; interf = []; prefer = []; degree = 0; - spill_cost = 0; visited = false; part = None; } in + spill_cost = 0; visited = unvisited; part = None; } in reg_list := r :: !reg_list; incr currstamp; r @@ -96,7 +112,8 @@ let clone r = let at_location ty loc = let r = { raw_name = Raw_name.R; stamp = !currstamp; typ = ty; loc; spill = false; interf = []; prefer = []; degree = 0; - spill_cost = 0; visited = false; part = None; } in + spill_cost = 0; visited = unvisited; part = None; } in + hw_reg_list := r :: !hw_reg_list; incr currstamp; r @@ -126,9 +143,15 @@ let reset() = all hard pseudo-registers that have been allocated by Proc, so remember it and use it as the base stamp for allocating soft pseudo-registers *) - if !first_virtual_reg_stamp = -1 then first_virtual_reg_stamp := !currstamp; + if !first_virtual_reg_stamp = -1 then begin + first_virtual_reg_stamp := !currstamp; + assert (!reg_list = []) (* Only hard regs created before now *) + end; currstamp := !first_virtual_reg_stamp; - reg_list := [] + reg_list := []; + visit_generation := 1; + !hw_reg_list |> List.iter (fun r -> + r.visited <- unvisited) let all_registers() = !reg_list let num_registers() = !currstamp diff --git a/asmcomp/reg.mli b/asmcomp/reg.mli index cd376394..8e40f431 100644 --- a/asmcomp/reg.mli +++ b/asmcomp/reg.mli @@ -23,7 +23,7 @@ end type t = { mutable raw_name: Raw_name.t; (* Name *) stamp: int; (* Unique stamp *) - mutable typ: Cmm.machtype_component;(* Type of contents *) + typ: Cmm.machtype_component; (* Type of contents *) mutable loc: location; (* Actual location *) mutable spill: bool; (* "true" to force stack allocation *) mutable part: int option; (* Zero-based index of part of value *) @@ -31,7 +31,7 @@ type t = mutable prefer: (t * int) list; (* Preferences for other regs *) mutable degree: int; (* Number of other regs live sim. *) mutable spill_cost: int; (* Estimate of spilling cost *) - mutable visited: bool } (* For graph walks *) + mutable visited: int } (* For graph walks *) and location = Unknown @@ -68,3 +68,7 @@ val reset: unit -> unit val all_registers: unit -> t list val num_registers: unit -> int val reinit: unit -> unit + +val mark_visited : t -> unit +val is_visited : t -> bool +val clear_visited_marks : unit -> unit diff --git a/asmcomp/riscv/CSE.ml b/asmcomp/riscv/CSE.ml new file mode 100644 index 00000000..6aed1c07 --- /dev/null +++ b/asmcomp/riscv/CSE.ml @@ -0,0 +1,39 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* CSE for the RISC-V *) + +open Arch +open Mach +open CSEgen + +class cse = object (_self) + +inherit cse_generic as super + +method! class_of_operation op = + match op with + | Ispecific(Imultaddf _ | Imultsubf _) -> Op_pure + | _ -> super#class_of_operation op + +method! is_cheap_operation op = + match op with + | Iconst_int n -> n <= 0x7FFn && n >= -0x800n + | _ -> false + +end + +let fundecl f = + (new cse)#fundecl f diff --git a/asmcomp/riscv/NOTES.md b/asmcomp/riscv/NOTES.md new file mode 100644 index 00000000..3b00d08e --- /dev/null +++ b/asmcomp/riscv/NOTES.md @@ -0,0 +1,18 @@ +# Supported platforms + +RISC-V in 64-bit mode, general variant, a.k.a `RV64G`. + +Debian architecture name: `riscv64` + +# Reference documents + +* Instruction set specification: + - https://riscv.org/specifications/isa-spec-pdf/ + - https://rv8.io/isa + +* ELF ABI specification: + - https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md + +* Assembly language manual + - https://github.com/riscv/riscv-asm-manual/blob/master/riscv-asm.md + - https://rv8.io/asm diff --git a/asmcomp/riscv/arch.ml b/asmcomp/riscv/arch.ml new file mode 100644 index 00000000..c6ade527 --- /dev/null +++ b/asmcomp/riscv/arch.ml @@ -0,0 +1,87 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* Specific operations for the RISC-V processor *) + +open Format + +(* Machine-specific command-line options *) + +let command_line_options = [] + +(* Specific operations *) + +type specific_operation = + | Imultaddf of bool (* multiply, optionally negate, and add *) + | Imultsubf of bool (* multiply, optionally negate, and subtract *) + +let spacetime_node_hole_pointer_is_live_before = function + | Imultaddf _ | Imultsubf _ -> false + +(* Addressing modes *) + +type addressing_mode = + | Iindexed of int (* reg + displ *) + +let is_immediate n = + (n <= 0x7FF) && (n >= -0x800) + +(* Sizes, endianness *) + +let big_endian = false + +let size_addr = 8 +let size_int = size_addr +let size_float = 8 + +let allow_unaligned_access = false + +(* Behavior of division *) + +let division_crashes_on_overflow = false + +(* Operations on addressing modes *) + +let identity_addressing = Iindexed 0 + +let offset_addressing addr delta = + match addr with + | Iindexed n -> Iindexed(n + delta) + +let num_args_addressing = function + | Iindexed _ -> 1 + +(* Printing operations and addressing modes *) + +let print_addressing printreg addr ppf arg = + match addr with + | Iindexed n -> + let idx = if n <> 0 then Printf.sprintf " + %i" n else "" in + fprintf ppf "%a%s" printreg arg.(0) idx + +let print_specific_operation printreg op ppf arg = + match op with + | Imultaddf false -> + fprintf ppf "%a *f %a +f %a" + printreg arg.(0) printreg arg.(1) printreg arg.(2) + | Imultaddf true -> + fprintf ppf "-f (%a *f %a +f %a)" + printreg arg.(0) printreg arg.(1) printreg arg.(2) + | Imultsubf false -> + fprintf ppf "%a *f %a -f %a" + printreg arg.(0) printreg arg.(1) printreg arg.(2) + | Imultsubf true -> + fprintf ppf "-f (%a *f %a -f %a)" + printreg arg.(0) printreg arg.(1) printreg arg.(2) diff --git a/asmcomp/riscv/emit.mlp b/asmcomp/riscv/emit.mlp new file mode 100644 index 00000000..dbfdc2d4 --- /dev/null +++ b/asmcomp/riscv/emit.mlp @@ -0,0 +1,686 @@ +# 2 "asmcomp/riscv/emit.mlp" +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* Emission of RISC-V assembly code *) + +open Cmm +open Arch +open Proc +open Reg +open Mach +open Linear +open Emitaux + +(* Layout of the stack. The stack is kept 16-aligned. *) + +let stack_offset = ref 0 + +let num_stack_slots = Array.make Proc.num_register_classes 0 + +let prologue_required = ref false + +let contains_calls = ref false + +let frame_size () = + let size = + !stack_offset + (* Trap frame, outgoing parameters *) + size_int * num_stack_slots.(0) + (* Local int variables *) + size_float * num_stack_slots.(1) + (* Local float variables *) + (if !contains_calls then size_addr else 0) in (* The return address *) + Misc.align size 16 + +let slot_offset loc cls = + match loc with + | Local n -> + if cls = 0 + then !stack_offset + num_stack_slots.(1) * size_float + n * size_int + else !stack_offset + n * size_float + | Incoming n -> frame_size() + n + | Outgoing n -> n + +(* Output a symbol *) + +let emit_symbol s = + emit_symbol '$' s + +let emit_jump op s = + if !Clflags.dlcode || !Clflags.pic_code + then `{emit_string op} {emit_symbol s}@plt` + else `{emit_string op} {emit_symbol s}` + +let emit_call = emit_jump "call" +let emit_tail = emit_jump "tail" + +(* Output a label *) + +let emit_label lbl = + emit_string ".L"; emit_int lbl + +(* Section switching *) + +let data_space = + ".section .data" + +let code_space = + ".section .text" + +let rodata_space = + ".section .rodata" + +(* Names for special regs *) + +let reg_tmp = phys_reg 22 +let reg_t2 = phys_reg 16 +let reg_domain_state_ptr = phys_reg 23 +let reg_trap = phys_reg 24 +let reg_alloc_ptr = phys_reg 25 +let reg_alloc_lim = phys_reg 26 + +(* Output a pseudo-register *) + +let reg_name = function + | {loc = Reg r} -> register_name r + | _ -> Misc.fatal_error "Emit.reg_name" + +let emit_reg r = + emit_string (reg_name r) + +(* Adjust sp by the given byte amount *) + +let emit_stack_adjustment = function + | 0 -> () + | n when is_immediate n -> + ` addi sp, sp, {emit_int n}\n` + | n -> + ` li {emit_reg reg_tmp}, {emit_int n}\n`; + ` add sp, sp, {emit_reg reg_tmp}\n` + +let emit_mem_op op src ofs = + if is_immediate ofs then + ` {emit_string op} {emit_string src}, {emit_int ofs}(sp)\n` + else begin + ` li {emit_reg reg_tmp}, {emit_int ofs}\n`; + ` add {emit_reg reg_tmp}, sp, {emit_reg reg_tmp}\n`; + ` {emit_string op} {emit_string src}, 0({emit_reg reg_tmp})\n` + end + +let emit_store src ofs = + emit_mem_op "sd" src ofs + +let emit_load dst ofs = + emit_mem_op "ld" dst ofs + +let reload_ra n = + emit_load "ra" (n - size_addr) + +let store_ra n = + emit_store "ra" (n - size_addr) + +let emit_store src ofs = + emit_store (reg_name src) ofs + +let emit_load dst ofs = + emit_load (reg_name dst) ofs + +let emit_float_load dst ofs = + emit_mem_op "fld" (reg_name dst) ofs + +let emit_float_store src ofs = + emit_mem_op "fsd" (reg_name src) ofs + +(* Record live pointers at call points *) + +let record_frame_label ?label live dbg = + let lbl = + match label with + | None -> new_label() + | Some label -> label + in + let live_offset = ref [] in + Reg.Set.iter + (function + {typ = Val; loc = Reg r} -> + live_offset := (r lsl 1) + 1 :: !live_offset + | {typ = Val; loc = Stack s} as reg -> + live_offset := slot_offset s (register_class reg) :: !live_offset + | {typ = Addr} as r -> + Misc.fatal_error ("bad GC root " ^ Reg.name r) + | _ -> () + ) + live; + record_frame_descr ~label:lbl ~frame_size:(frame_size()) + ~live_offset:!live_offset dbg; + lbl + +let record_frame ?label live dbg = + let lbl = record_frame_label ?label live dbg in + `{emit_label lbl}:\n` + +(* Record calls to the GC -- we've moved them out of the way *) + +type gc_call = + { gc_lbl: label; (* Entry label *) + gc_return_lbl: label; (* Where to branch after GC *) + gc_frame_lbl: label } (* Label of frame descriptor *) + +let call_gc_sites = ref ([] : gc_call list) + +let emit_call_gc gc = + `{emit_label gc.gc_lbl}:\n`; + ` {emit_call "caml_call_gc"}\n`; + `{emit_label gc.gc_frame_lbl}:\n`; + ` j {emit_label gc.gc_return_lbl}\n` + +(* Record calls to caml_ml_array_bound_error. + In debug mode, we maintain one call to caml_ml_array_bound_error + per bound check site. Otherwise, we can share a single call. *) + +type bound_error_call = + { bd_lbl: label; (* Entry label *) + bd_frame_lbl: label } (* Label of frame descriptor *) + +let bound_error_sites = ref ([] : bound_error_call list) + +let bound_error_label ?label dbg = + if !Clflags.debug || !bound_error_sites = [] then begin + let lbl_bound_error = new_label() in + let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in + bound_error_sites := + { bd_lbl = lbl_bound_error; + bd_frame_lbl = lbl_frame } :: !bound_error_sites; + lbl_bound_error + end else + let bd = List.hd !bound_error_sites in + bd.bd_lbl + +let emit_call_bound_error bd = + `{emit_label bd.bd_lbl}:\n`; + ` {emit_call "caml_ml_array_bound_error"}\n`; + `{emit_label bd.bd_frame_lbl}:\n` + +(* Record floating-point literals *) + +let float_literals = ref ([] : (int64 * int) list) + +(* Names for various instructions *) + +let name_for_intop = function + | Iadd -> "add" + | Isub -> "sub" + | Imul -> "mul" + | Imulh -> "mulh" + | Idiv -> "div" + | Iand -> "and" + | Ior -> "or" + | Ixor -> "xor" + | Ilsl -> "sll" + | Ilsr -> "srl" + | Iasr -> "sra" + | Imod -> "rem" + | _ -> Misc.fatal_error "Emit.Intop" + +let name_for_intop_imm = function + | Iadd -> "addi" + | Iand -> "andi" + | Ior -> "ori" + | Ixor -> "xori" + | Ilsl -> "slli" + | Ilsr -> "srli" + | Iasr -> "srai" + | _ -> Misc.fatal_error "Emit.Intop_imm" + +let name_for_floatop1 = function + | Inegf -> "fneg.d" + | Iabsf -> "fabs.d" + | _ -> Misc.fatal_error "Emit.Iopf1" + +let name_for_floatop2 = function + | Iaddf -> "fadd.d" + | Isubf -> "fsub.d" + | Imulf -> "fmul.d" + | Idivf -> "fdiv.d" + | _ -> Misc.fatal_error "Emit.Iopf2" + +let name_for_specific = function + | Imultaddf false -> "fmadd.d" + | Imultaddf true -> "fnmadd.d" + | Imultsubf false -> "fmsub.d" + | Imultsubf true -> "fnmsub.d" + +(* Name of current function *) +let function_name = ref "" + +(* Entry point for tail recursive calls *) +let tailrec_entry_point = ref 0 + +(* Output the assembly code for an instruction *) + +let emit_instr i = + emit_debug_info i.dbg; + match i.desc with + Lend -> () + | Lprologue -> + assert (!prologue_required); + let n = frame_size() in + emit_stack_adjustment (-n); + if !contains_calls then store_ra n + | Lop(Imove | Ispill | Ireload) -> + let src = i.arg.(0) and dst = i.res.(0) in + if src.loc <> dst.loc then begin + match (src, dst) with + | {loc = Reg _; typ = (Val | Int | Addr)}, {loc = Reg _} -> + ` mv {emit_reg dst}, {emit_reg src}\n` + | {loc = Reg _; typ = Float}, {loc = Reg _; typ = Float} -> + ` fmv.d {emit_reg dst}, {emit_reg src}\n` + | {loc = Reg _; typ = Float}, {loc = Reg _; typ = (Val | Int | Addr)} -> + ` fmv.x.d {emit_reg dst}, {emit_reg src}\n` + | {loc = Reg _; typ = (Val | Int | Addr)}, {loc = Stack s} -> + let ofs = slot_offset s (register_class dst) in + emit_store src ofs + | {loc = Reg _; typ = Float}, {loc = Stack s} -> + let ofs = slot_offset s (register_class dst) in + emit_float_store src ofs + | {loc = Stack s; typ = (Val | Int | Addr)}, {loc = Reg _} -> + let ofs = slot_offset s (register_class src) in + emit_load dst ofs + | {loc = Stack s; typ = Float}, {loc = Reg _} -> + let ofs = slot_offset s (register_class src) in + emit_float_load dst ofs + | {loc = Stack _}, {loc = Stack _} + | {loc = Unknown}, _ | _, {loc = Unknown} -> + Misc.fatal_error "Emit: Imove" + end + | Lop(Iconst_int n) -> + ` li {emit_reg i.res.(0)}, {emit_nativeint n}\n` + | Lop(Iconst_float f) -> + let lbl = new_label() in + float_literals := (f, lbl) :: !float_literals; + ` fld {emit_reg i.res.(0)}, {emit_label lbl}, {emit_reg reg_tmp}\n` + | Lop(Iconst_symbol s) -> + ` la {emit_reg i.res.(0)}, {emit_symbol s}\n` + | Lop(Icall_ind {label_after = label}) -> + ` jalr {emit_reg i.arg.(0)}\n`; + record_frame ~label i.live (Dbg_other i.dbg) + | Lop(Icall_imm {func; label_after = label}) -> + ` {emit_call func}\n`; + record_frame ~label i.live (Dbg_other i.dbg) + | Lop(Itailcall_ind {label_after = _}) -> + let n = frame_size() in + if !contains_calls then reload_ra n; + emit_stack_adjustment n; + ` jr {emit_reg i.arg.(0)}\n` + | Lop(Itailcall_imm {func; label_after = _}) -> + if func = !function_name then begin + ` j {emit_label !tailrec_entry_point}\n` + end else begin + let n = frame_size() in + if !contains_calls then reload_ra n; + emit_stack_adjustment n; + ` {emit_tail func}\n` + end + | Lop(Iextcall{func; alloc = true; label_after = label}) -> + ` la {emit_reg reg_t2}, {emit_symbol func}\n`; + ` {emit_call "caml_c_call"}\n`; + record_frame ~label i.live (Dbg_other i.dbg) + | Lop(Iextcall{func; alloc = false; label_after = _}) -> + ` {emit_call func}\n` + | Lop(Istackoffset n) -> + assert (n mod 16 = 0); + emit_stack_adjustment (-n); + stack_offset := !stack_offset + n + | Lop(Iload(Single, Iindexed ofs)) -> + ` flw {emit_reg i.res.(0)}, {emit_int ofs}({emit_reg i.arg.(0)})\n`; + ` fcvt.d.s {emit_reg i.res.(0)}, {emit_reg i.res.(0)}\n` + | Lop(Iload(chunk, Iindexed ofs)) -> + let instr = + match chunk with + | Byte_unsigned -> "lbu" + | Byte_signed -> "lb" + | Sixteen_unsigned -> "lhu" + | Sixteen_signed -> "lh" + | Thirtytwo_unsigned -> "lwu" + | Thirtytwo_signed -> "lw" + | Word_int | Word_val -> "ld" + | Single -> assert false + | Double | Double_u -> "fld" + in + ` {emit_string instr} {emit_reg i.res.(0)}, {emit_int ofs}({emit_reg i.arg.(0)})\n` + | Lop(Istore(Single, Iindexed ofs, _)) -> + (* ft0 is marked as destroyed for this operation *) + ` fcvt.s.d ft0, {emit_reg i.arg.(0)}\n`; + ` fsw ft0, {emit_int ofs}({emit_reg i.arg.(1)})\n` + | Lop(Istore(chunk, Iindexed ofs, _)) -> + let instr = + match chunk with + | Byte_unsigned | Byte_signed -> "sb" + | Sixteen_unsigned | Sixteen_signed -> "sh" + | Thirtytwo_unsigned | Thirtytwo_signed -> "sw" + | Word_int | Word_val -> "sd" + | Single -> assert false + | Double | Double_u -> "fsd" + in + ` {emit_string instr} {emit_reg i.arg.(0)}, {emit_int ofs}({emit_reg i.arg.(1)})\n` + | Lop(Ialloc {bytes; label_after_call_gc = label; dbginfo}) -> + let lbl_frame_lbl = record_frame_label ?label i.live (Dbg_alloc dbginfo) in + let lbl_after_alloc = new_label () in + let lbl_call_gc = new_label () in + let n = -bytes in + if is_immediate n then + ` addi {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_ptr}, {emit_int n}\n` + else begin + ` li {emit_reg reg_tmp}, {emit_int n}\n`; + ` add {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_ptr}, {emit_reg reg_tmp}\n` + end; + ` bltu {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_lim}, {emit_label lbl_call_gc}\n`; + `{emit_label lbl_after_alloc}:\n`; + ` addi {emit_reg i.res.(0)}, {emit_reg reg_alloc_ptr}, {emit_int size_addr}\n`; + call_gc_sites := + { gc_lbl = lbl_call_gc; + gc_return_lbl = lbl_after_alloc; + gc_frame_lbl = lbl_frame_lbl } :: !call_gc_sites + | Lop(Iintop(Icomp cmp)) -> + begin match cmp with + | Isigned Clt -> + ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | Isigned Cge -> + ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`; + ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`; + | Isigned Cgt -> + ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n` + | Isigned Cle -> + ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`; + ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`; + | Isigned Ceq | Iunsigned Ceq -> + ` sub {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`; + ` seqz {emit_reg i.res.(0)}, {emit_reg i.res.(0)}\n` + | Isigned Cne | Iunsigned Cne -> + ` sub {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`; + ` snez {emit_reg i.res.(0)}, {emit_reg i.res.(0)}\n` + | Iunsigned Clt -> + ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | Iunsigned Cge -> + ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`; + ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`; + | Iunsigned Cgt -> + ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n` + | Iunsigned Cle -> + ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`; + ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`; + end + | Lop(Iintop (Icheckbound {label_after_error = label; _})) -> + let lbl = bound_error_label ?label i.dbg in + ` bleu {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}, {emit_label lbl}\n` + | Lop(Iintop op) -> + let instr = name_for_intop op in + ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | Lop(Iintop_imm(Isub, n)) -> + ` addi {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_int(-n)}\n` + | Lop(Iintop_imm(Icomp _, _)) -> + Misc.fatal_error "Emit.emit_instr (Iintop_imm (Icomp _, _))" + | Lop(Iintop_imm(Icheckbound {label_after_error = label; _}, n)) -> + let lbl = bound_error_label ?label i.dbg in + ` li {emit_reg reg_tmp}, {emit_int n}\n`; + ` bleu {emit_reg i.arg.(0)}, {emit_reg reg_tmp}, {emit_label lbl}\n` + | Lop(Iintop_imm(op, n)) -> + let instr = name_for_intop_imm op in + ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_int n}\n` + | Lop(Inegf | Iabsf as op) -> + let instr = name_for_floatop1 op in + ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}\n` + | Lop(Iaddf | Isubf | Imulf | Idivf as op) -> + let instr = name_for_floatop2 op in + ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | Lop(Ifloatofint) -> + ` fcvt.d.l {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}\n` + | Lop(Iintoffloat) -> + ` fcvt.l.d {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, rtz\n` + | Lop(Ispecific sop) -> + let instr = name_for_specific sop in + ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(2)}\n` + | Lop (Iname_for_debugger _) -> + () + | Lreloadretaddr -> + let n = frame_size () in + reload_ra n + | Lreturn -> + let n = frame_size() in + emit_stack_adjustment n; + ` ret\n` + | Llabel lbl -> + `{emit_label lbl}:\n` + | Lbranch lbl -> + ` j {emit_label lbl}\n` + | Lcondbranch(tst, lbl) -> + begin match tst with + | Itruetest -> + ` bnez {emit_reg i.arg.(0)}, {emit_label lbl}\n` + | Ifalsetest -> + ` beqz {emit_reg i.arg.(0)}, {emit_label lbl}\n` + | Iinttest cmp -> + let name = match cmp with + | Iunsigned Ceq | Isigned Ceq -> "beq" + | Iunsigned Cne | Isigned Cne -> "bne" + | Iunsigned Cle -> "bleu" | Isigned Cle -> "ble" + | Iunsigned Cge -> "bgeu" | Isigned Cge -> "bge" + | Iunsigned Clt -> "bltu" | Isigned Clt -> "blt" + | Iunsigned Cgt -> "bgtu" | Isigned Cgt -> "bgt" + in + ` {emit_string name} {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}, {emit_label lbl}\n` + | Iinttest_imm _ -> + Misc.fatal_error "Emit.emit_instr (Iinttest_imm _)" + | Ifloattest cmp -> + let branch = + match cmp with + | CFneq | CFnlt | CFngt | CFnle | CFnge -> "beqz" + | CFeq | CFlt | CFgt | CFle | CFge -> "bnez" + in + begin match cmp with + | CFeq | CFneq -> ` feq.d {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | CFlt | CFnlt -> ` flt.d {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | CFgt | CFngt -> ` flt.d {emit_reg reg_tmp}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n` + | CFle | CFnle -> ` fle.d {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n` + | CFge | CFnge -> ` fle.d {emit_reg reg_tmp}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n` + end; + ` {emit_string branch} {emit_reg reg_tmp}, {emit_label lbl}\n` + | Ioddtest -> + ` andi {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, 1\n`; + ` bnez {emit_reg reg_tmp}, {emit_label lbl}\n` + | Ieventest -> + ` andi {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, 1\n`; + ` beqz {emit_reg reg_tmp}, {emit_label lbl}\n` + end + | Lcondbranch3(lbl0, lbl1, lbl2) -> + ` addi {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, -1\n`; + begin match lbl0 with + | None -> () + | Some lbl -> ` bltz {emit_reg reg_tmp}, {emit_label lbl}\n` + end; + begin match lbl1 with + | None -> () + | Some lbl -> ` beqz {emit_reg reg_tmp}, {emit_label lbl}\n` + end; + begin match lbl2 with + | None -> () + | Some lbl -> ` bgtz {emit_reg reg_tmp}, {emit_label lbl}\n` + end + | Lswitch jumptbl -> + (* t0 is marked as destroyed for this operation *) + let lbl = new_label() in + ` la {emit_reg reg_tmp}, {emit_label lbl}\n`; + ` slli t0, {emit_reg i.arg.(0)}, 2\n`; + ` add {emit_reg reg_tmp}, {emit_reg reg_tmp}, t0\n`; + ` jr {emit_reg reg_tmp}\n`; + `{emit_label lbl}:\n`; + for i = 0 to Array.length jumptbl - 1 do + ` j {emit_label jumptbl.(i)}\n` + done + | Lentertrap -> + () + | Ladjust_trap_depth { delta_traps } -> + (* each trap occupes 16 bytes on the stack *) + let delta = 16 * delta_traps in + stack_offset := !stack_offset + delta + | Lpushtrap {lbl_handler} -> + ` la {emit_reg reg_tmp}, {emit_label lbl_handler}\n`; + ` addi sp, sp, -16\n`; + stack_offset := !stack_offset + 16; + emit_store reg_tmp size_addr; + emit_store reg_trap 0; + ` mv {emit_reg reg_trap}, sp\n` + | Lpoptrap -> + emit_load reg_trap 0; + ` addi sp, sp, 16\n`; + stack_offset := !stack_offset - 16 + | Lraise k -> + begin match k with + | Lambda.Raise_regular -> + let offset = Domainstate.(idx_of_field Domain_backtrace_pos) * 8 in + ` sd zero, {emit_int offset}({emit_reg reg_domain_state_ptr})\n`; + ` {emit_call "caml_raise_exn"}\n`; + record_frame Reg.Set.empty (Dbg_raise i.dbg) + | Lambda.Raise_reraise -> + ` {emit_call "caml_raise_exn"}\n`; + record_frame Reg.Set.empty (Dbg_raise i.dbg) + | Lambda.Raise_notrace -> + ` mv sp, {emit_reg reg_trap}\n`; + emit_load reg_tmp size_addr; + emit_load reg_trap 0; + ` addi sp, sp, 16\n`; + ` jr {emit_reg reg_tmp}\n` + end + +(* Emit a sequence of instructions *) + +let rec emit_all = function + | {desc = Lend} -> () | i -> emit_instr i; emit_all i.next + +(* Emission of a function declaration *) + +let fundecl fundecl = + function_name := fundecl.fun_name; + tailrec_entry_point := fundecl.fun_tailrec_entry_point_label; + stack_offset := 0; + call_gc_sites := []; + bound_error_sites := []; + for i = 0 to Proc.num_register_classes - 1 do + num_stack_slots.(i) <- fundecl.fun_num_stack_slots.(i); + done; + prologue_required := fundecl.fun_prologue_required; + contains_calls := fundecl.fun_contains_calls; + float_literals := []; + ` .globl {emit_symbol fundecl.fun_name}\n`; + ` .type {emit_symbol fundecl.fun_name}, @function\n`; + ` {emit_string code_space}\n`; + ` .align 2\n`; + `{emit_symbol fundecl.fun_name}:\n`; + emit_debug_info fundecl.fun_dbg; + emit_all fundecl.fun_body; + List.iter emit_call_gc !call_gc_sites; + List.iter emit_call_bound_error !bound_error_sites; + ` .size {emit_symbol fundecl.fun_name}, .-{emit_symbol fundecl.fun_name}\n`; + (* Emit the float literals *) + if !float_literals <> [] then begin + ` {emit_string rodata_space}\n`; + ` .align 3\n`; + List.iter + (fun (f, lbl) -> + `{emit_label lbl}:\n`; + emit_float64_directive ".quad" f) + !float_literals; + end + +(* Emission of data *) + +let declare_global_data s = + ` .globl {emit_symbol s}\n`; + ` .type {emit_symbol s}, @object\n` + +let emit_item = function + | Cglobal_symbol s -> + declare_global_data s + | Cdefine_symbol s -> + `{emit_symbol s}:\n`; + | Cint8 n -> + ` .byte {emit_int n}\n` + | Cint16 n -> + ` .short {emit_int n}\n` + | Cint32 n -> + ` .long {emit_nativeint n}\n` + | Cint n -> + ` .quad {emit_nativeint n}\n` + | Csingle f -> + emit_float32_directive ".long" (Int32.bits_of_float f) + | Cdouble f -> + emit_float64_directive ".quad" (Int64.bits_of_float f) + | Csymbol_address s -> + ` .quad {emit_symbol s}\n` + | Cstring s -> + emit_bytes_directive " .byte " s + | Cskip n -> + if n > 0 then ` .space {emit_int n}\n` + | Calign n -> + ` .align {emit_int (Misc.log2 n)}\n` + +let data l = + ` {emit_string data_space}\n`; + List.iter emit_item l + +(* Beginning / end of an assembly file *) + +let begin_assembly() = + if !Clflags.dlcode || !Clflags.pic_code then ` .option pic\n`; + ` .file \"\"\n`; (* PR#7073 *) + reset_debug_info (); + (* Emit the beginning of the segments *) + let lbl_begin = Compilenv.make_symbol (Some "data_begin") in + ` {emit_string data_space}\n`; + declare_global_data lbl_begin; + `{emit_symbol lbl_begin}:\n`; + let lbl_begin = Compilenv.make_symbol (Some "code_begin") in + ` {emit_string code_space}\n`; + declare_global_data lbl_begin; + `{emit_symbol lbl_begin}:\n` + +let end_assembly() = + ` {emit_string code_space}\n`; + let lbl_end = Compilenv.make_symbol (Some "code_end") in + declare_global_data lbl_end; + `{emit_symbol lbl_end}:\n`; + ` .long 0\n`; + ` {emit_string data_space}\n`; + let lbl_end = Compilenv.make_symbol (Some "data_end") in + declare_global_data lbl_end; + ` .quad 0\n`; (* PR#6329 *) + `{emit_symbol lbl_end}:\n`; + ` .quad 0\n`; + (* Emit the frame descriptors *) + ` {emit_string rodata_space}\n`; + let lbl = Compilenv.make_symbol (Some "frametable") in + declare_global_data lbl; + `{emit_symbol lbl}:\n`; + emit_frames + { efa_code_label = (fun l -> ` .quad {emit_label l}\n`); + efa_data_label = (fun l -> ` .quad {emit_label l}\n`); + efa_8 = (fun n -> ` .byte {emit_int n}\n`); + efa_16 = (fun n -> ` .short {emit_int n}\n`); + efa_32 = (fun n -> ` .long {emit_int32 n}\n`); + efa_word = (fun n -> ` .quad {emit_int n}\n`); + efa_align = (fun n -> ` .align {emit_int (Misc.log2 n)}\n`); + efa_label_rel = (fun lbl ofs -> + ` .long ({emit_label lbl} - .) + {emit_int32 ofs}\n`); + efa_def_label = (fun l -> `{emit_label l}:\n`); + efa_string = (fun s -> emit_bytes_directive " .byte " (s ^ "\000")) + } diff --git a/asmcomp/riscv/proc.ml b/asmcomp/riscv/proc.ml new file mode 100644 index 00000000..4c7b5861 --- /dev/null +++ b/asmcomp/riscv/proc.ml @@ -0,0 +1,337 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* Description of the RISC-V *) + +open Misc +open Cmm +open Reg +open Arch +open Mach + +(* Instruction selection *) + +let word_addressed = false + +(* Registers available for register allocation *) + +(* Integer register map + -------------------- + + zero always zero + ra return address + sp, gp, tp stack pointer, global pointer, thread pointer + a0-a7 0-7 arguments/results + s2-s9 8-15 arguments/results (preserved by C) + t2-t6 16-20 temporary + t0-t1 21-22 temporary (used by code generator) + s0 23 domain pointer (preserved by C) + s1 24 trap pointer (preserved by C) + s10 25 allocation pointer (preserved by C) + s11 26 allocation limit (preserved by C) + + Floating-point register map + --------------------------- + + ft0-ft7 100-107 temporary + fs0-fs1 108-109 general purpose (preserved by C) + fa0-fa7 110-117 arguments/results + fs2-fs9 118-125 arguments/results (preserved by C) + fs10-fs11 126-127 general purpose (preserved by C) + ft8-ft11 128-131 temporary + + Additional notes + ---------------- + + - t0-t1 are used by the assembler and code generator, so + not available for register allocation. + + - t0-t6 may be used by PLT stubs, so should not be used to pass + arguments and may be clobbered by [Ialloc] in the presence of dynamic + linking. +*) + +let int_reg_name = + [| "a0"; "a1"; "a2"; "a3"; "a4"; "a5"; "a6"; "a7"; + "s2"; "s3"; "s4"; "s5"; "s6"; "s7"; "s8"; "s9"; + "t2"; "t3"; "t4"; "t5"; "t6"; + "t0"; "t1"; + "s0"; "s1"; "s10"; "s11" |] + +let float_reg_name = + [| "ft0"; "ft1"; "ft2"; "ft3"; "ft4"; "ft5"; "ft6"; "ft7"; + "fs0"; "fs1"; + "fa0"; "fa1"; "fa2"; "fa3"; "fa4"; "fa5"; "fa6"; "fa7"; + "fs2"; "fs3"; "fs4"; "fs5"; "fs6"; "fs7"; "fs8"; "fs9"; "fs10"; "fs11"; + "ft8"; "ft9"; "ft10"; "ft11" |] + +let num_register_classes = 2 + +let register_class r = + match r.typ with + | Val | Int | Addr -> 0 + | Float -> 1 + +let num_available_registers = [| 22; 32 |] + +let first_available_register = [| 0; 100 |] + +let register_name r = + if r < 100 then int_reg_name.(r) else float_reg_name.(r - 100) + +let rotate_registers = true + +(* Representation of hard registers by pseudo-registers *) + +let hard_int_reg = + let v = Array.make 27 Reg.dummy in + for i = 0 to 26 do + v.(i) <- Reg.at_location Int (Reg i) + done; + v + +let hard_float_reg = + let v = Array.make 32 Reg.dummy in + for i = 0 to 31 do + v.(i) <- Reg.at_location Float (Reg(100 + i)) + done; + v + +let all_phys_regs = + Array.append hard_int_reg hard_float_reg + +let phys_reg n = + if n < 100 then hard_int_reg.(n) else hard_float_reg.(n - 100) + +let stack_slot slot ty = + Reg.at_location ty (Stack slot) + +(* Calling conventions *) + +let calling_conventions + first_int last_int first_float last_float make_stack arg = + let loc = Array.make (Array.length arg) Reg.dummy in + let int = ref first_int in + let float = ref first_float in + let ofs = ref 0 in + for i = 0 to Array.length arg - 1 do + match arg.(i).typ with + | Val | Int | Addr as ty -> + if !int <= last_int then begin + loc.(i) <- phys_reg !int; + incr int + end else begin + loc.(i) <- stack_slot (make_stack !ofs) ty; + ofs := !ofs + size_int + end + | Float -> + if !float <= last_float then begin + loc.(i) <- phys_reg !float; + incr float + end else begin + loc.(i) <- stack_slot (make_stack !ofs) Float; + ofs := !ofs + size_float + end + done; + (loc, Misc.align !ofs 16) (* Keep stack 16-aligned. *) + +let incoming ofs = Incoming ofs +let outgoing ofs = Outgoing ofs +let not_supported _ = fatal_error "Proc.loc_results: cannot call" + +let max_arguments_for_tailcalls = 16 + +let loc_spacetime_node_hole = Reg.dummy (* Spacetime unsupported *) + +(* OCaml calling convention: + first integer args in a0 .. a7, s2 .. s9 + first float args in fa0 .. fa7, fs2 .. fs9 + remaining args on stack. + Return values in a0 .. a7, s2 .. s9 or fa0 .. fa7, fs2 .. fs9. *) + +let single_regs arg = Array.map (fun arg -> [| arg |]) arg +let ensure_single_regs res = + Array.map (function + | [| res |] -> res + | _ -> failwith "proc.ensure_single_regs" + ) res + +let loc_arguments arg = + calling_conventions 0 15 110 125 outgoing arg + +let loc_parameters arg = + let (loc, _ofs) = + calling_conventions 0 15 110 125 incoming arg + in + loc + +let loc_results res = + let (loc, _ofs) = + calling_conventions 0 15 110 125 not_supported res + in + loc + +(* C calling convention: + first integer args in a0 .. a7 + first float args in fa0 .. fa7 + remaining args on stack. + A FP argument can be passed in an integer register if all FP registers + are exhausted but integer registers remain. + Return values in a0 .. a1 or fa0 .. fa1. *) + +let external_calling_conventions + first_int last_int first_float last_float make_stack arg = + let loc = Array.make (Array.length arg) [| Reg.dummy |] in + let int = ref first_int in + let float = ref first_float in + let ofs = ref 0 in + for i = 0 to Array.length arg - 1 do + match arg.(i) with + | [| arg |] -> + begin match arg.typ with + | Val | Int | Addr as ty -> + if !int <= last_int then begin + loc.(i) <- [| phys_reg !int |]; + incr int + end else begin + loc.(i) <- [| stack_slot (make_stack !ofs) ty |]; + ofs := !ofs + size_int + end + | Float -> + if !float <= last_float then begin + loc.(i) <- [| phys_reg !float |]; + incr float + end else if !int <= last_int then begin + loc.(i) <- [| phys_reg !int |]; + incr int + end else begin + loc.(i) <- [| stack_slot (make_stack !ofs) Float |]; + ofs := !ofs + size_float + end + end + | _ -> + fatal_error "Proc.calling_conventions: bad number of register for \ + multi-register argument" + done; + (loc, Misc.align !ofs 16) (* Keep stack 16-aligned. *) + +let loc_external_arguments arg = + external_calling_conventions 0 7 110 117 outgoing arg + +let loc_external_results res = + let (loc, _ofs) = + external_calling_conventions 0 1 110 111 not_supported (single_regs res) + in + ensure_single_regs loc + +(* Exceptions are in a0 *) + +let loc_exn_bucket = phys_reg 0 + +(* Volatile registers: none *) + +let regs_are_volatile _ = false + +(* Registers destroyed by operations *) + +let destroyed_at_c_call = + (* s0-s11 and fs0-fs11 are callee-save *) + Array.of_list(List.map phys_reg + [0; 1; 2; 3; 4; 5; 6; 7; 16; 17; 18; 19; 20; 21; + 100; 101; 102; 103; 104; 105; 106; 107; 110; 111; 112; 113; 114; 115; 116; + 117; 128; 129; 130; 131]) + +let destroyed_at_alloc = + (* t0-t3 are used for PLT stubs *) + if !Clflags.dlcode then Array.map phys_reg [|16; 17; 18; 19; 20; 21|] + else [| |] + +let destroyed_at_oper = function + | Iop(Icall_ind _ | Icall_imm _ | Iextcall{alloc = true; _}) -> all_phys_regs + | Iop(Iextcall{alloc = false; _}) -> destroyed_at_c_call + | Iop(Ialloc _) -> destroyed_at_alloc + | Iop(Istore(Single, _, _)) -> [| phys_reg 100 |] + | Iswitch _ -> [| phys_reg 21 |] + | _ -> [||] + +let destroyed_at_raise = all_phys_regs + +let destroyed_at_reloadretaddr = [| |] + +(* Maximal register pressure *) + +let safe_register_pressure = function + | Iextcall _ -> 15 + | _ -> 22 + +let max_register_pressure = function + | Iextcall _ -> [| 15; 18 |] + | _ -> [| 22; 30 |] + +(* Pure operations (without any side effect besides updating their result + registers). *) + +let op_is_pure = function + | Icall_ind _ | Icall_imm _ | Itailcall_ind _ | Itailcall_imm _ + | Iextcall _ | Istackoffset _ | Istore _ | Ialloc _ + | Iintop(Icheckbound _) | Iintop_imm(Icheckbound _, _) -> false + | Ispecific(Imultaddf _ | Imultsubf _) -> true + | _ -> true + +(* Layout of the stack *) + +let frame_required fd = + fd.fun_contains_calls + || fd.fun_num_stack_slots.(0) > 0 + || fd.fun_num_stack_slots.(1) > 0 + +let prologue_required fd = + frame_required fd + +(* See + https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md *) + +let int_dwarf_reg_numbers = + [| 10; 11; 12; 13; 14; 15; 16; 17; + 18; 19; 20; 21; 22; 23; 24; 25; + 7; 28; 29; 30; 31; + 5; 6; + 8; 9; 26; 27; + |] + +let float_dwarf_reg_numbers = + [| 32; 33; 34; 35; 36; 37; 38; 39; + 40; 41; + 42; 43; 44; 45; 46; 47; 48; 49; + 50; 51; 52; 53; 54; 55; 56; 57; + 58; 59; + 60; 61; 62; 63; + |] + +let dwarf_register_numbers ~reg_class = + match reg_class with + | 0 -> int_dwarf_reg_numbers + | 1 -> float_dwarf_reg_numbers + | _ -> Misc.fatal_errorf "Bad register class %d" reg_class + +let stack_ptr_dwarf_register_number = 2 + +(* Calling the assembler *) + +let assemble_file infile outfile = + Ccomp.command + (Config.asm ^ " -o " ^ Filename.quote outfile ^ " " ^ Filename.quote infile) + +let init () = () diff --git a/asmcomp/riscv/reload.ml b/asmcomp/riscv/reload.ml new file mode 100644 index 00000000..be18cbd7 --- /dev/null +++ b/asmcomp/riscv/reload.ml @@ -0,0 +1,19 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* Reloading for the RISC-V *) + +let fundecl f = + (new Reloadgen.reload_generic)#fundecl f diff --git a/asmcomp/riscv/scheduling.ml b/asmcomp/riscv/scheduling.ml new file mode 100644 index 00000000..e56b723c --- /dev/null +++ b/asmcomp/riscv/scheduling.ml @@ -0,0 +1,22 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* Instruction scheduling for the RISC-V *) + +open! Schedgen (* to create a dependency *) + +(* Scheduling is turned off. *) + +let fundecl f = f diff --git a/asmcomp/riscv/selection.ml b/asmcomp/riscv/selection.ml new file mode 100644 index 00000000..87d3355d --- /dev/null +++ b/asmcomp/riscv/selection.ml @@ -0,0 +1,75 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Nicolas Ojeda Bar *) +(* *) +(* Copyright 2016 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. *) +(* *) +(**************************************************************************) + +(* Instruction selection for the RISC-V processor *) + +open Cmm +open Arch +open Mach + +(* Instruction selection *) + +class selector = object (self) + +inherit Selectgen.selector_generic as super + +method is_immediate n = is_immediate n + +method select_addressing _ = function + | Cop(Cadda, [arg; Cconst_int (n, _)], _) when self#is_immediate n -> + (Iindexed n, arg) + | Cop(Cadda, [arg1; Cop(Caddi, [arg2; Cconst_int (n, _)], _)], dbg) + when self#is_immediate n -> + (Iindexed n, Cop(Caddi, [arg1; arg2], dbg)) + | arg -> + (Iindexed 0, arg) + +method! select_operation op args dbg = + match (op, args) with + (* Recognize (neg-)mult-add and (neg-)mult-sub instructions *) + | (Caddf, [Cop(Cmulf, [arg1; arg2], _); arg3]) + | (Caddf, [arg3; Cop(Cmulf, [arg1; arg2], _)]) -> + (Ispecific (Imultaddf false), [arg1; arg2; arg3]) + | (Csubf, [Cop(Cmulf, [arg1; arg2], _); arg3]) -> + (Ispecific (Imultsubf false), [arg1; arg2; arg3]) + | (Cnegf, [Cop(Csubf, [Cop(Cmulf, [arg1; arg2], _); arg3], _)]) -> + (Ispecific (Imultsubf true), [arg1; arg2; arg3]) + | (Cnegf, [Cop(Caddf, [Cop(Cmulf, [arg1; arg2], _); arg3], _)]) -> + (Ispecific (Imultaddf true), [arg1; arg2; arg3]) + (* RISC-V does not support immediate operands for comparison operators *) + | (Ccmpi comp, args) -> (Iintop(Icomp (Isigned comp)), args) + | (Ccmpa comp, args) -> (Iintop(Icomp (Iunsigned comp)), args) + (* RISC-V does not support immediate operands for multiply/multiply high *) + | (Cmuli, _) -> (Iintop Imul, args) + | (Cmulhi, _) -> (Iintop Imulh, args) + | _ -> + super#select_operation op args dbg + +(* Instruction selection for conditionals *) + +method! select_condition = function + Cop(Ccmpi cmp, args, _) -> + (Iinttest(Isigned cmp), Ctuple args) + | Cop(Ccmpa cmp, args, _) -> + (Iinttest(Iunsigned cmp), Ctuple args) + | Cop(Ccmpf cmp, args, _) -> + (Ifloattest cmp, Ctuple args) + | Cop(Cand, [arg; Cconst_int (1, _)], _) -> + (Ioddtest, arg) + | arg -> + (Itruetest, arg) +end + +let fundecl f = (new selector)#emit_fundecl f diff --git a/asmcomp/s390x/emit.mlp b/asmcomp/s390x/emit.mlp index 05070ec7..419c43f3 100644 --- a/asmcomp/s390x/emit.mlp +++ b/asmcomp/s390x/emit.mlp @@ -168,7 +168,7 @@ let emit_set_comp cmp res = (* Record live pointers at call points *) -let record_frame_label ?label live raise_ dbg = +let record_frame_label ?label live dbg = let lbl = match label with | None -> new_label() @@ -186,11 +186,11 @@ let record_frame_label ?label live raise_ dbg = | _ -> ()) live; record_frame_descr ~label:lbl ~frame_size:(frame_size()) - ~live_offset:!live_offset ~raise_frame:raise_ dbg; + ~live_offset:!live_offset dbg; lbl -let record_frame ?label live raise_ dbg = - let lbl = record_frame_label ?label live raise_ dbg in +let record_frame ?label live dbg = + let lbl = record_frame_label ?label live dbg in `{emit_label lbl}:` (* Record calls to caml_call_gc, emitted out of line. *) @@ -218,7 +218,7 @@ let bound_error_call = ref 0 let bound_error_label ?label dbg = if !Clflags.debug then begin let lbl_bound_error = new_label() in - let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in + let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in bound_error_sites := { bd_lbl = lbl_bound_error; bd_frame = lbl_frame } :: !bound_error_sites; lbl_bound_error @@ -357,11 +357,11 @@ let emit_instr i = emit_load_symbol_addr i.res.(0) s | Lop(Icall_ind { label_after; }) -> ` basr %r14, {emit_reg i.arg.(0)}\n`; - `{record_frame i.live false i.dbg ~label:label_after}\n` + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n` | Lop(Icall_imm { func; label_after; }) -> emit_call func; - `{record_frame i.live false i.dbg ~label:label_after}\n` + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n` | Lop(Itailcall_ind { label_after = _; }) -> let n = frame_size() in if !contains_calls then @@ -387,7 +387,7 @@ let emit_instr i = else begin emit_load_symbol_addr reg_r7 func; emit_call "caml_c_call"; - `{record_frame i.live false i.dbg ~label:label_after}\n` + `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n` end | Lop(Istackoffset n) -> @@ -424,23 +424,22 @@ let emit_instr i = | Double | Double_u -> "stdy" in emit_load_store storeinstr addr i.arg 1 i.arg.(0) - | Lop(Ialloc { bytes = n; label_after_call_gc; }) -> - let lbl_redo = new_label() in + | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) -> + let lbl_after_alloc = new_label() in let lbl_call_gc = new_label() in let lbl_frame = - record_frame_label i.live false i.dbg ?label:label_after_call_gc + record_frame_label i.live (Dbg_alloc dbginfo) ?label:label_after_call_gc in call_gc_sites := { gc_lbl = lbl_call_gc; - gc_return_lbl = lbl_redo; + gc_return_lbl = lbl_after_alloc; gc_frame_lbl = lbl_frame } :: !call_gc_sites; - `{emit_label lbl_redo}:`; - ` lay {emit_reg i.res.(0)}, {emit_int(-n+8)}(%r11)\n`; + ` lay %r11, {emit_int(-n)}(%r11)\n`; let offset = Domainstate.(idx_of_field Domain_young_limit) * 8 in - ` clg {emit_reg i.res.(0)}, {emit_int offset}(%r10)\n`; - ` brcl 12, {emit_label lbl_call_gc}\n`; - (* less than or equal *) - ` lay %r11, -8({emit_reg i.res.(0)})\n` + ` clg %r11, {emit_int offset}(%r10)\n`; + ` brcl 4, {emit_label lbl_call_gc}\n`; (* less than *) + `{emit_label lbl_after_alloc}:`; + ` la {emit_reg i.res.(0)}, 8(%r11)\n` | Lop(Iintop Imulh) -> (* Hacker's Delight section 8.3: @@ -641,10 +640,10 @@ let emit_instr i = ` lghi %r1, 0\n`; ` stg %r1, {emit_int offset}(%r10)\n`; emit_call "caml_raise_exn"; - `{record_frame Reg.Set.empty true i.dbg}\n` + `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n` | Lambda.Raise_reraise -> emit_call "caml_raise_exn"; - `{record_frame Reg.Set.empty true i.dbg}\n` + `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n` | Lambda.Raise_notrace -> ` lg %r1, 0(%r13)\n`; ` lgr %r15, %r13\n`; @@ -782,6 +781,7 @@ let end_assembly() = emit_frames { efa_code_label = (fun l -> ` .quad {emit_label l}\n`); efa_data_label = (fun l -> ` .quad {emit_label l}\n`); + efa_8 = (fun n -> ` .byte {emit_int n}\n`); efa_16 = (fun n -> ` .short {emit_int n}\n`); efa_32 = (fun n -> ` .long {emit_int32 n}\n`); efa_word = (fun n -> ` .quad {emit_int n}\n`); diff --git a/asmcomp/selectgen.ml b/asmcomp/selectgen.ml index b024dfe7..20d070dc 100644 --- a/asmcomp/selectgen.ml +++ b/asmcomp/selectgen.ml @@ -25,22 +25,33 @@ module V = Backend_var module VP = Backend_var.With_provenance type environment = - { vars : (Reg.t array * Backend_var.Provenance.t option) V.Map.t; + { vars : (Reg.t array + * Backend_var.Provenance.t option + * Asttypes.mutable_flag) V.Map.t; static_exceptions : Reg.t array list Int.Map.t; (** Which registers must be populated when jumping to the given handler. *) } -let env_add var regs env = +let env_add ?(mut=Asttypes.Immutable) var regs env = let provenance = VP.provenance var in let var = VP.var var in - { env with vars = V.Map.add var (regs, provenance) env.vars } + { env with vars = V.Map.add var (regs, provenance, mut) env.vars } let env_add_static_exception id v env = { env with static_exceptions = Int.Map.add id v env.static_exceptions } let env_find id env = - let regs, _provenance = V.Map.find id env.vars in + let regs, _provenance, _mut = V.Map.find id env.vars in + regs + +let env_find_mut id env = + let regs, _provenance, mut = V.Map.find id env.vars in + begin match mut with + | Asttypes.Mutable -> () + | Asttypes.Immutable -> + Misc.fatal_error "Selectgen.env_find_mut: not mutable" + end; regs let env_find_static_exception id env = @@ -308,7 +319,8 @@ method is_simple_expr = function | Cblockheader _ -> true | Cvar _ -> true | Ctuple el -> List.for_all self#is_simple_expr el - | Clet(_id, arg, body) -> self#is_simple_expr arg && self#is_simple_expr body + | Clet(_id, arg, body) | Clet_mut(_id, _, arg, body) -> + self#is_simple_expr arg && self#is_simple_expr body | Cphantom_let(_var, _defining_expr, body) -> self#is_simple_expr body | Csequence(e1, e2) -> self#is_simple_expr e1 && self#is_simple_expr e2 | Cop(op, args, _) -> @@ -343,7 +355,7 @@ method effects_of exp = | Cconst_pointer _ | Cconst_natpointer _ | Cblockheader _ | Cvar _ -> EC.none | Ctuple el -> EC.join_list_map el self#effects_of - | Clet (_id, arg, body) -> + | Clet (_id, arg, body) | Clet_mut (_id, _, arg, body) -> EC.join (self#effects_of arg) (self#effects_of body) | Cphantom_let (_var, _defining_expr, body) -> self#effects_of body | Csequence (e1, e2) -> @@ -419,7 +431,8 @@ method mark_instr = function (* Default instruction selection for operators *) method select_allocation bytes = - Ialloc { bytes; spacetime_index = 0; label_after_call_gc = None; } + Ialloc { bytes; label_after_call_gc = None; + dbginfo = []; spacetime_index = 0; } method select_allocation_args _env = [| |] method select_checkbound () = @@ -596,24 +609,6 @@ method insert_moves env src dst = self#insert_move env src.(i) dst.(i) done -(* Adjust the types of destination pseudoregs for a [Cassign] assignment. - The type inferred at [let] binding might be [Int] while we assign - something of type [Val] (PR#6501). *) - -method adjust_type src dst = - let ts = src.typ and td = dst.typ in - if ts <> td then - match ts, td with - | Val, Int -> dst.typ <- Val - | Int, Val -> () - | _, _ -> Misc.fatal_error("Selection.adjust_type: bad assignment to " - ^ Reg.name dst) - -method adjust_types src dst = - for i = 0 to min (Array.length src) (Array.length dst) - 1 do - self#adjust_type src.(i) dst.(i) - done - (* Insert moves and stack offsets for function arguments and results *) method insert_move_args env arg loc stacksize = @@ -668,13 +663,20 @@ method emit_expr (env:environment) exp = let r = self#regs_for typ_float in Some(self#insert_op env (Iconst_float (Int64.bits_of_float n)) [||] r) | Cconst_symbol (n, _dbg) -> - let r = self#regs_for typ_val in + (* Cconst_symbol _ evaluates to a statically-allocated address, so its + value fits in a typ_int register and is never changed by the GC. + + Some Cconst_symbols point to statically-allocated blocks, some of + which may point to heap values. However, any such blocks will be + registered in the compilation unit's global roots structure, so + adding this register to the frame table would be redundant *) + let r = self#regs_for typ_int in Some(self#insert_op env (Iconst_symbol n) [||] r) | Cconst_pointer (n, _dbg) -> - let r = self#regs_for typ_val in (* integer as Caml value *) + let r = self#regs_for typ_int in Some(self#insert_op env (Iconst_int(Nativeint.of_int n)) [||] r) | Cconst_natpointer (n, _dbg) -> - let r = self#regs_for typ_val in (* integer as Caml value *) + let r = self#regs_for typ_int in Some(self#insert_op env (Iconst_int n) [||] r) | Cblockheader(n, dbg) -> self#emit_blockheader env n dbg @@ -689,18 +691,23 @@ method emit_expr (env:environment) exp = None -> None | Some r1 -> self#emit_expr (self#bind_let env v r1) e2 end + | Clet_mut(v, k, e1, e2) -> + begin match self#emit_expr env e1 with + None -> None + | Some r1 -> self#emit_expr (self#bind_let_mut env v k r1) e2 + end | Cphantom_let (_var, _defining_expr, body) -> self#emit_expr env body | Cassign(v, e1) -> let rv = try - env_find v env + env_find_mut v env with Not_found -> Misc.fatal_error ("Selection.emit_expr: unbound var " ^ V.name v) in begin match self#emit_expr env e1 with None -> None | Some r1 -> - self#adjust_types r1 rv; self#insert_moves env r1 rv; Some [||] + self#insert_moves env r1 rv; Some [||] end | Ctuple [] -> Some [||] @@ -775,8 +782,11 @@ method emit_expr (env:environment) exp = | Ialloc { bytes = _; spacetime_index; label_after_call_gc; } -> let rd = self#regs_for typ_val in let bytes = size_expr env (Ctuple new_args) in + assert (bytes mod Arch.size_addr = 0); + let alloc_words = bytes / Arch.size_addr in let op = - Ialloc { bytes; spacetime_index; label_after_call_gc; } + Ialloc { bytes; spacetime_index; label_after_call_gc; + dbginfo = [{alloc_words; alloc_dbg = dbg}] } in let args = self#select_allocation_args env in self#insert_debug env (Iop op) dbg args rd; @@ -904,6 +914,12 @@ method private bind_let (env:environment) v r1 = env_add v rv env end +method private bind_let_mut (env:environment) v k r1 = + let rv = self#regs_for k in + name_regs v rv; + self#insert_moves env r1 rv; + env_add ~mut:Mutable v rv env + (* The following two functions, [emit_parts] and [emit_parts_list], force right-to-left evaluation order as required by the Flambda [Un_anf] pass (and to be consistent with the bytecode compiler). *) @@ -1063,6 +1079,11 @@ method emit_tail (env:environment) exp = None -> () | Some r1 -> self#emit_tail (self#bind_let env v r1) e2 end + | Clet_mut (v, k, e1, e2) -> + begin match self#emit_expr env e1 with + None -> () + | Some r1 -> self#emit_tail (self#bind_let_mut env v k r1) e2 + end | Cphantom_let (_var, _defining_expr, body) -> self#emit_tail env body | Cop((Capply ty) as op, args, dbg) -> @@ -1198,8 +1219,14 @@ method emit_tail (env:environment) exp = self#insert_moves env r1 loc; self#insert env Ireturn loc [||] end - | _ -> - self#emit_return env exp + | Cop _ + | Cconst_int _ | Cconst_natint _ | Cconst_float _ | Cconst_symbol _ + | Cconst_pointer _ | Cconst_natpointer _ | Cblockheader _ + | Cvar _ + | Cassign _ + | Ctuple _ + | Cexit _ -> + self#emit_return env exp method private emit_tail_sequence env exp = let s = {< instr_seq = dummy_instr >} in diff --git a/asmcomp/selectgen.mli b/asmcomp/selectgen.mli index f3c734fc..96474564 100644 --- a/asmcomp/selectgen.mli +++ b/asmcomp/selectgen.mli @@ -19,7 +19,8 @@ type environment val env_add - : Backend_var.With_provenance.t + : ?mut:Asttypes.mutable_flag + -> Backend_var.With_provenance.t -> Reg.t array -> environment -> environment @@ -148,8 +149,6 @@ class virtual selector_generic : object method insert_move_results : environment -> Reg.t array -> Reg.t array -> int -> unit method insert_moves : environment -> Reg.t array -> Reg.t array -> unit - method adjust_type : Reg.t -> Reg.t -> unit - method adjust_types : Reg.t array -> Reg.t array -> unit method emit_expr : environment -> Cmm.expression -> Reg.t array option method emit_tail : environment -> Cmm.expression -> unit diff --git a/asmcomp/spacetime_profiling.ml b/asmcomp/spacetime_profiling.ml index a61cd1c4..62e182ab 100644 --- a/asmcomp/spacetime_profiling.ml +++ b/asmcomp/spacetime_profiling.ml @@ -396,6 +396,7 @@ class virtual instruction_selection = object (self) in Mach.Ialloc { bytes; + dbginfo = []; label_after_call_gc = Some label; spacetime_index = index; } diff --git a/asmcomp/strmatch.ml b/asmcomp/strmatch.ml index 07d77ebf..d71a5136 100644 --- a/asmcomp/strmatch.ml +++ b/asmcomp/strmatch.ml @@ -24,7 +24,7 @@ module VP = Backend_var.With_provenance module type I = sig val string_block_length : Cmm.expression -> Cmm.expression val transl_switch : - Location.t -> Cmm.expression -> int -> int -> + Debuginfo.t -> Cmm.expression -> int -> int -> (int * Cmm.expression) list -> Cmm.expression -> Cmm.expression end @@ -353,8 +353,7 @@ module Make(I:I) = struct (len,act)) (by_size cases) in let id = gen_size_id () in - let loc = Debuginfo.to_location dbg in - let switch = I.transl_switch loc (Cvar id) 1 max_int size_cases default in + let switch = I.transl_switch dbg (Cvar id) 1 max_int size_cases default in mk_let_size (VP.create id) str switch (* diff --git a/asmcomp/strmatch.mli b/asmcomp/strmatch.mli index 8c4c63eb..69f29896 100644 --- a/asmcomp/strmatch.mli +++ b/asmcomp/strmatch.mli @@ -18,7 +18,7 @@ module type I = sig val string_block_length : Cmm.expression -> Cmm.expression val transl_switch : - Location.t -> Cmm.expression -> int -> int -> + Debuginfo.t -> Cmm.expression -> int -> int -> (int * Cmm.expression) list -> Cmm.expression -> Cmm.expression end diff --git a/autogen b/autogen deleted file mode 100755 index 8c85c2cb..00000000 --- a/autogen +++ /dev/null @@ -1,40 +0,0 @@ -#!/bin/sh -e -#************************************************************************** -#* * -#* OCaml * -#* * -#* David Allsopp, MetaStack Solutions Ltd. * -#* * -#* Copyright 2019 MetaStack Solutions Ltd. * -#* * -#* 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. * -#* * -#************************************************************************** - -# Remove the autom4te.cache directory to make sure we start in a clean state -rm -rf autom4te.cache - -autoconf --force --warnings=all,error - -# Allow pre-processing of configure arguments for Git check-outs -# The sed call removes dra27's copyright on the whole configure script... -sed -e '/^#[^!]/d' tools/git-dev-options.sh > configure.tmp - -# Some distros have the 2013 --runstatedir patch to autoconf (see -# http://git.savannah.gnu.org/cgit/autoconf.git/commit/?id=a197431414088a417b407b9b20583b2e8f7363bd -# in the GNU autoconf repo), and some don't, so ensure its effects are -# removed for CI consistency... -# POSIX Notes -# - sed -i without a backup file is not portable, hence configure.tmp -# - GNU sed's /../,+8d becomes /../{N;..;d;} (and the last ; is important) -sed -e '/^runstatedir/d' \ - -e '/-runstatedir /{N;N;N;N;N;N;N;N;d;}' \ - -e '/--runstatedir=DIR/d' \ - -e 's/ runstatedir//' \ - -e '1d' \ - configure >> configure.tmp - -mv -f configure.tmp configure -chmod +x configure diff --git a/boot/menhir/menhirLib.ml b/boot/menhir/menhirLib.ml index 19e30f24..8e1dc20f 100644 --- a/boot/menhir/menhirLib.ml +++ b/boot/menhir/menhirLib.ml @@ -3513,5 +3513,5 @@ module MakeEngineTable (T : TableFormat.TABLES) = struct end end module StaticVersion = struct -let require_20181113 = () +let require_20190924 = () end diff --git a/boot/menhir/menhirLib.mli b/boot/menhir/menhirLib.mli index 343c9d6c..fa523f59 100644 --- a/boot/menhir/menhirLib.mli +++ b/boot/menhir/menhirLib.mli @@ -1701,5 +1701,5 @@ module MakeEngineTable and type nonterminal = int end module StaticVersion : sig -val require_20181113 : unit +val require_20190924 : unit end diff --git a/boot/menhir/parser.ml b/boot/menhir/parser.ml index 4cc10b83..a4a9fc6a 100644 --- a/boot/menhir/parser.ml +++ b/boot/menhir/parser.ml @@ -2,7 +2,7 @@ (* This generated code requires the following version of MenhirLib: *) let () = - MenhirLib.StaticVersion.require_20181113 + MenhirLib.StaticVersion.require_20190924 module MenhirBasics = struct @@ -16,7 +16,7 @@ module MenhirBasics = struct | VAL | UNDERSCORE | UIDENT of ( -# 688 "parsing/parser.mly" +# 697 "parsing/parser.mly" (string) # 22 "parsing/parser.ml" ) @@ -28,8 +28,8 @@ module MenhirBasics = struct | THEN | STRUCT | STRING of ( -# 680 "parsing/parser.mly" - (string * string option) +# 685 "parsing/parser.mly" + (string * Location.t * string option) # 34 "parsing/parser.ml" ) | STAR @@ -40,13 +40,23 @@ module MenhirBasics = struct | REC | RBRACKET | RBRACE + | QUOTED_STRING_ITEM of ( +# 689 "parsing/parser.mly" + (string * Location.t * string * Location.t * string option) +# 47 "parsing/parser.ml" + ) + | QUOTED_STRING_EXPR of ( +# 687 "parsing/parser.mly" + (string * Location.t * string * Location.t * string option) +# 52 "parsing/parser.ml" + ) | QUOTE | QUESTION | PRIVATE | PREFIXOP of ( -# 666 "parsing/parser.mly" +# 671 "parsing/parser.mly" (string) -# 50 "parsing/parser.ml" +# 60 "parsing/parser.ml" ) | PLUSEQ | PLUSDOT @@ -54,9 +64,9 @@ module MenhirBasics = struct | PERCENT | OR | OPTLABEL of ( -# 659 "parsing/parser.mly" +# 664 "parsing/parser.mly" (string) -# 60 "parsing/parser.ml" +# 70 "parsing/parser.ml" ) | OPEN | OF @@ -72,14 +82,14 @@ module MenhirBasics = struct | MATCH | LPAREN | LIDENT of ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 78 "parsing/parser.ml" +# 88 "parsing/parser.ml" ) | LETOP of ( -# 624 "parsing/parser.mly" +# 629 "parsing/parser.mly" (string) -# 83 "parsing/parser.ml" +# 93 "parsing/parser.ml" ) | LET | LESSMINUS @@ -97,49 +107,49 @@ module MenhirBasics = struct | LBRACE | LAZY | LABEL of ( -# 629 "parsing/parser.mly" +# 634 "parsing/parser.mly" (string) -# 103 "parsing/parser.ml" +# 113 "parsing/parser.ml" ) | INT of ( -# 628 "parsing/parser.mly" +# 633 "parsing/parser.mly" (string * char option) -# 108 "parsing/parser.ml" +# 118 "parsing/parser.ml" ) | INITIALIZER | INHERIT | INFIXOP4 of ( -# 622 "parsing/parser.mly" +# 627 "parsing/parser.mly" (string) -# 115 "parsing/parser.ml" +# 125 "parsing/parser.ml" ) | INFIXOP3 of ( -# 621 "parsing/parser.mly" +# 626 "parsing/parser.mly" (string) -# 120 "parsing/parser.ml" +# 130 "parsing/parser.ml" ) | INFIXOP2 of ( -# 620 "parsing/parser.mly" +# 625 "parsing/parser.mly" (string) -# 125 "parsing/parser.ml" +# 135 "parsing/parser.ml" ) | INFIXOP1 of ( -# 619 "parsing/parser.mly" +# 624 "parsing/parser.mly" (string) -# 130 "parsing/parser.ml" +# 140 "parsing/parser.ml" ) | INFIXOP0 of ( -# 618 "parsing/parser.mly" +# 623 "parsing/parser.mly" (string) -# 135 "parsing/parser.ml" +# 145 "parsing/parser.ml" ) | INCLUDE | IN | IF | HASHOP of ( -# 677 "parsing/parser.mly" +# 682 "parsing/parser.mly" (string) -# 143 "parsing/parser.ml" +# 153 "parsing/parser.ml" ) | HASH | GREATERRBRACKET @@ -150,9 +160,9 @@ module MenhirBasics = struct | FUN | FOR | FLOAT of ( -# 607 "parsing/parser.mly" +# 612 "parsing/parser.mly" (string * char option) -# 156 "parsing/parser.ml" +# 166 "parsing/parser.ml" ) | FALSE | EXTERNAL @@ -164,24 +174,24 @@ module MenhirBasics = struct | ELSE | DOWNTO | DOTOP of ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 170 "parsing/parser.ml" +# 180 "parsing/parser.ml" ) | DOTDOT | DOT | DONE | DOCSTRING of ( -# 696 "parsing/parser.mly" +# 705 "parsing/parser.mly" (Docstrings.docstring) -# 178 "parsing/parser.ml" +# 188 "parsing/parser.ml" ) | DO | CONSTRAINT | COMMENT of ( -# 695 "parsing/parser.mly" +# 704 "parsing/parser.mly" (string * Location.t) -# 185 "parsing/parser.ml" +# 195 "parsing/parser.ml" ) | COMMA | COLONGREATER @@ -190,9 +200,9 @@ module MenhirBasics = struct | COLON | CLASS | CHAR of ( -# 587 "parsing/parser.mly" +# 592 "parsing/parser.mly" (char) -# 196 "parsing/parser.ml" +# 206 "parsing/parser.ml" ) | BEGIN | BARRBRACKET @@ -203,9 +213,9 @@ module MenhirBasics = struct | ASSERT | AS | ANDOP of ( -# 625 "parsing/parser.mly" +# 630 "parsing/parser.mly" (string) -# 209 "parsing/parser.ml" +# 219 "parsing/parser.ml" ) | AND | AMPERSAND @@ -622,6 +632,11 @@ let wrap_sig_ext ~loc body ext = let wrap_mksig_ext ~loc (item, ext) = wrap_sig_ext ~loc (mksig ~loc item) ext +let mk_quotedext ~loc (id, idloc, str, strloc, delim) = + let exp_id = mkloc id idloc in + let e = ghexp ~loc (Pexp_constant (Pconst_string (str, strloc, delim))) in + (exp_id, PStr [mkstrexp e []]) + let text_str pos = Str.text (rhs_text pos) let text_sig pos = Sig.text (rhs_text pos) let text_cstr pos = Cf.text (rhs_text pos) @@ -774,7 +789,7 @@ let mk_directive ~loc name arg = } -# 778 "parsing/parser.ml" +# 793 "parsing/parser.ml" module Tables = struct @@ -784,200 +799,204 @@ module Tables = struct fun _tok -> match _tok with | AMPERAMPER -> - 121 + 123 | AMPERSAND -> - 120 + 122 | AND -> - 119 + 121 | ANDOP _ -> - 118 + 120 | AS -> - 117 + 119 | ASSERT -> - 116 + 118 | BACKQUOTE -> - 115 + 117 | BANG -> - 114 + 116 | BAR -> - 113 + 115 | BARBAR -> - 112 + 114 | BARRBRACKET -> - 111 + 113 | BEGIN -> - 110 + 112 | CHAR _ -> - 109 + 111 | CLASS -> - 108 + 110 | COLON -> - 107 + 109 | COLONCOLON -> - 106 + 108 | COLONEQUAL -> - 105 + 107 | COLONGREATER -> - 104 + 106 | COMMA -> - 103 + 105 | COMMENT _ -> - 102 + 104 | CONSTRAINT -> - 101 + 103 | DO -> - 100 + 102 | DOCSTRING _ -> - 99 + 101 | DONE -> - 98 + 100 | DOT -> - 97 + 99 | DOTDOT -> - 96 + 98 | DOTOP _ -> - 95 + 97 | DOWNTO -> - 94 + 96 | ELSE -> - 93 + 95 | END -> - 92 + 94 | EOF -> - 91 + 93 | EOL -> - 90 + 92 | EQUAL -> - 89 + 91 | EXCEPTION -> - 88 + 90 | EXTERNAL -> - 87 + 89 | FALSE -> - 86 + 88 | FLOAT _ -> - 85 + 87 | FOR -> - 84 + 86 | FUN -> - 83 + 85 | FUNCTION -> - 82 + 84 | FUNCTOR -> - 81 + 83 | GREATER -> - 80 + 82 | GREATERRBRACE -> - 79 + 81 | GREATERRBRACKET -> - 78 + 80 | HASH -> - 77 + 79 | HASHOP _ -> - 76 + 78 | IF -> - 75 + 77 | IN -> - 74 + 76 | INCLUDE -> - 73 + 75 | INFIXOP0 _ -> - 72 + 74 | INFIXOP1 _ -> - 71 + 73 | INFIXOP2 _ -> - 70 + 72 | INFIXOP3 _ -> - 69 + 71 | INFIXOP4 _ -> - 68 + 70 | INHERIT -> - 67 + 69 | INITIALIZER -> - 66 + 68 | INT _ -> - 65 + 67 | LABEL _ -> - 64 + 66 | LAZY -> - 63 + 65 | LBRACE -> - 62 + 64 | LBRACELESS -> - 61 + 63 | LBRACKET -> - 60 + 62 | LBRACKETAT -> - 59 + 61 | LBRACKETATAT -> - 58 + 60 | LBRACKETATATAT -> - 57 + 59 | LBRACKETBAR -> - 56 + 58 | LBRACKETGREATER -> - 55 + 57 | LBRACKETLESS -> - 54 + 56 | LBRACKETPERCENT -> - 53 + 55 | LBRACKETPERCENTPERCENT -> - 52 + 54 | LESS -> - 51 + 53 | LESSMINUS -> - 50 + 52 | LET -> - 49 + 51 | LETOP _ -> - 48 + 50 | LIDENT _ -> - 47 + 49 | LPAREN -> - 46 + 48 | MATCH -> - 45 + 47 | METHOD -> - 44 + 46 | MINUS -> - 43 + 45 | MINUSDOT -> - 42 + 44 | MINUSGREATER -> - 41 + 43 | MODULE -> - 40 + 42 | MUTABLE -> - 39 + 41 | NEW -> - 38 + 40 | NONREC -> - 37 + 39 | OBJECT -> - 36 + 38 | OF -> - 35 + 37 | OPEN -> - 34 + 36 | OPTLABEL _ -> - 33 + 35 | OR -> - 32 + 34 | PERCENT -> - 31 + 33 | PLUS -> - 30 + 32 | PLUSDOT -> - 29 + 31 | PLUSEQ -> - 28 + 30 | PREFIXOP _ -> - 27 + 29 | PRIVATE -> - 26 + 28 | QUESTION -> - 25 + 27 | QUOTE -> + 26 + | QUOTED_STRING_EXPR _ -> + 25 + | QUOTED_STRING_ITEM _ -> 24 | RBRACE -> 23 @@ -1228,6 +1247,10 @@ module Tables = struct Obj.repr () | QUOTE -> Obj.repr () + | QUOTED_STRING_EXPR _v -> + Obj.repr _v + | QUOTED_STRING_ITEM _v -> + Obj.repr _v | RBRACE -> Obj.repr () | RBRACKET -> @@ -1276,22 +1299,22 @@ module Tables = struct 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\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\029\001\148\001\127\001\145\001\144\001\143\001\149\001\153\000\000\003\030\001\147\001\146\001\128\001\151\001\142\001\141\001\140\001\139\001\138\001\136\001\152\001\150\000\000\000\000\000\000\000\215\000\000\000\000\001\131\000\000\000\000\000\000\001\133\000\000\000\000\000\000\001\135\001\157\001\154\001\137\001\129\001\155\001\156\000\000\003\028\003\027\003\026\000\000\000\000\000\016\001;\000\000\000\211\000\212\000\015\000\000\000\000\001\179\001\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\022\000\000\003\023\000\000\000\000\003\020\000\000\003\019\003\015\002\024\000\000\003\018\000\000\002\025\000\000\000\000\000\000\000\000\000f\000\000\000\000\000c\000\000\000\000\003\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\180\001?\000\000\000\000\000\000\000\000\000\000\000\000\002\003\000\000\000\000\000\000\000\000\000\000\000\000\000m\000_\000\000\000\000\000\000\000\000\0009\000\000\000\000\001@\000:\002l\000\000\001\r\000\000\000j\000\000\000\000\000\t\000\b\000\000\000\000\000\000\000\000\002\153\000\000\002K\002L\000\000\002I\002J\000\000\000\000\000\000\000\000\000\000\001P\001O\000\000\002\151\000\000\000\000\000\000\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\246\002\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000i\000\000\000\225\000\000\000\000\000\226\000\000\002N\002M\000\000\000\000\000\000\001\161\000\000\000\000\000\029\000\000\000\000\000\000\000\022\000\000\000\000\001h\000\017\000\000\000\000\000\000\000\000\000\000\000\000\001>\000\000\001=\000\000\001<\000\000\003\014\000 \000\000\000\000\000\023\000\018\000\000\000\000\000\000\000\196\000\000\000\000\000\000\000\198\002\"\002\020\000\000\000\026\000\000\002\021\000\000\000\000\001\158\000\000\000\000\000\000\000\n\000\000\000\000\000\000\000\011\002\247\000\000\002\248\000\000\000u\000\000\000\000\000\025\000\000\000\000\000\000\000\027\000\000\000\028\000\000\000\030\000\000\000\000\000\031\002\n\002\t\000\000\000\000\000\000\000\000\000\000\000\000\000]\000\000\002\158\000`\000l\000^\002\147\002\148\001\213\002\150\000\000\000\000\002\155\002H\002\157\000\000\000\000\000\000\002\164\002\161\000\000\000\000\000\000\001\210\001\196\000\000\000\000\000\000\000\000\001\200\000\000\001\195\000\000\001\212\002\170\000\000\001\211\001\203\000\000\000h\000\000\002\163\002\162\000\000\001\206\000\000\000\000\001\202\000\000\000\000\001\198\001\197\000\000\002\160\000\000\002P\002O\000\000\000\000\002,\002\159\002\156\000\000\000\000\000\000\000\000\001\163\001(\001)\002R\000\000\002S\002Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\236\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Z\000\000\000\000\000\000\000\000\000\000\000\000\0034\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\000\000\002\018\000\000\000\000\002\019\000\000\000\000\001Y\000\000\000\000\000\000\001`\001_\001]\002\006\002\005\000\000\001X\001W\000\000\000\200\000\000\000\000\001I\000\000\000\000\001M\000\000\001\183\001\182\000\000\000\000\001\181\001\180\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\002p\003\031\002u\002s\000\000\000\000\000\000\002\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\146\000\000\002\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\224\000\000\000\000\000\000\000\000\000\000\000\000\000\234\001\223\000\235\000\000\000\000\000\000\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\230\000\000\000\000\000\000\002}\000\000\000\000\000\000\002X\002W\000\000\000\000\000\000\000\000\002\127\002r\002q\000\000\000\000\000\165\000\000\000\000\000\000\000\000\000\000\000\179\000\000\000\000\000\000\000\164\000\000\000\000\000\000\0023\0022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\238\000\000\002\224\000\000\003\n\000\000\000\000\003\t\000\000\000\000\000\000\000\000\000\000\000\190\000\189\000\239\000\000\002\225\002\226\000\000\000\000\000k\000\000\002\165\002\149\000\000\002\168\000\000\002\167\002\166\000\000\000\000\000\000\000\000\000\000\000\000\000\243\000\000\000\000\002\012\000\000\000\000\000\000\000\242\000\000\000\000\000\241\000\240\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\244\000\000\001\209\000\000\000\000\001\220\000\000\000\000\001\222\000\000\000\000\001\218\001\217\001\215\001\216\000\000\000\000\000\000\000\000\000\000\001\019\000\012\000\247\000\000\000\000\000\000\002Z\002Y\000\000\000\000\002h\002g\000\000\000\000\000\000\000\000\002d\002c\000\000\000\000\002&\000\000\000\000\002b\002a\000\000\000\000\002f\002e\002y\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\007\000\163\000\000\002]\000\000\000\000\002[\000\000\000\000\002_\000\000\000v\000w\000\000\000\000\000\000\000\000\000\134\000\191\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000\000\193\000\194\000\127\000\000\000~\000\000\000\000\001+\000\000\001,\001*\002\014\000\000\000\000\002\015\002\r\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000\255\000\000\000\000\000\166\000\000\001\001\001\000\000\000\000\000\002\129\002z\000\000\002\138\000\000\002\139\002\137\000\000\002\143\000\000\002\144\002\142\000\000\000\000\002|\002{\000\000\000\000\000\000\001\246\000\000\001\177\000\000\000\000\000\000\002/\001\245\000\000\002\133\002\132\000\000\000\000\000\000\003 \000\000\002j\000\000\002k\002i\000\000\002\131\002\130\000\000\000\000\000\000\002)\002x\000\000\002w\002v\000\000\002\141\002\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\000\000\000\000\000\000\000\000\000\000y\000\000\001C\000\000\000\000\000\000\000a\000\000\000\000\000d\000\000\000b\000e\000\000\000\000\000\000\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\219\000\000\000\000\000q\000\000\000\222\000\220\000\000\000\000\000\000\000\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\000\000\000\000\001\244\000\000\000\000\000\246\001\175\000\000\000\232\000\233\000\253\000\000\000\000\000\000\000\000\000\000\001\190\001\184\000\000\001\189\000\000\001\187\000\000\001\188\000\000\001\185\000\000\000\000\001\186\000\000\001|\000\000\000\000\000\000\001{\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\001\t\002\239\000\000\000\000\002\238\000\000\000\000\000\000\000\000\000\000\001\229\000\000\000\000\000\000\000\000\000\000\000\000\002\244\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\001\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\002\223\000\000\000\000\0024\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\000\000\000\001R\000\000\001Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\011\002B\000\000\000\000\000\000\002@\000\000\000\000\000\000\002?\000\000\001E\000\000\000\000\000\000\000\000\002E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003(\000\000\000\000\000\000\000\188\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000>\000\000\000\000\000\000\000\000\001g\000\000\001f\000\000\000\000\000\000\000\000\000A\000\000\000\000\000\000\001\242\000\000\001\241\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\\\000G\000\000\000\000\000\000\000H\000F\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\000\000C\000\000\000J\000I\000\000\000D\000E\000\000\001\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\007\000Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000W\000\000\000Y\000X\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\005\002F\0028\000\000\002>\0029\002D\002C\002A\001\022\000\000\0026\000\000\000\000\000\000\000\000\000\000\002\003\000\000\000\000\001\015\002:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001w\001s\000\000\000\000\000\000\000\205\000\000\000\000\001\249\002\003\000\000\000\000\001\017\001\247\001\248\000\000\000\000\000\000\000\000\000\000\001z\001v\001r\000\000\000\000\000\206\000\000\000\000\001y\001u\001q\001o\002;\0027\002G\001\021\001\226\0025\000\000\000\000\000\000\000\000\000\000\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\000.\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\001\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001:\000\000\000\000\0018\0016\000\000\000/\000\000\000\000\003.\000\000\003-\000\000\000\000\000\000\0014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0019\000\000\000\000\0017\0015\000\000\000\000\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000Q\000\000\000\000\000\000\000\000\000\000\000\000\000+\000\000\000\000\000P\000\000\000)\000\250\000\000\0008\000%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\248\000\000\000O\000N\000\000\000\000\000T\000S\000\000\000\000\001\165\000\000\000-\000\000\000\000\000\000\000,\000\000\000\000\000\000\0000\000\000\000R\000U\000\000\0002\0003\000\000\001\030\000\000\000\000\000\000\000\000\000\000\000\000\0006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\003\002\242\002\233\000\000\000\000\002\237\002\222\002\232\002\241\002\240\001\026\000\000\000\000\002\230\000\000\002\234\002\231\002\243\001\225\000\000\000\000\002\228\000\000\000\186\002\227\000\000\000\000\000\217\000\000\000\000\001\025\001\024\000\000\001G\001F\000\000\000\000\002\169\002\152\000\000\000;\000\000\000\000\000<\000\000\000\000\000\138\000\137\002\136\000\000\002\135\002\134\002t\000\000\000\000\000\000\000\000\002m\000\000\002o\000\000\002n\000\000\002U\002T\000\000\002V\000\000\000\000\000\130\000\000\000\000\001\234\000\210\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\184\000\000\002\236\001\254\001\255\001\250\001\252\001\251\001\253\000\000\000\000\000\000\000\185\000\000\000\000\002\003\000\000\000\209\000\000\000\000\000\000\000\000\002\235\000\000\000\183\000\000\000\000\000\000\000\000\0013\001-\000\000\000\000\001.\000\021\000\000\000\020\000\000\000\000\000\197\000\000\000\000\000\000\000\024\000\019\000\000\000\000\000\000\000\r\000\000\000\000\000\000\000\000\001x\001t\000\000\001p\003\012\000\000\002\003\000\000\000\208\000\000\000\000\000\000\000\000\002=\002\002\002\000\002\001\000\000\000\000\000\000\002\003\000\000\000\207\000\000\000\000\000\000\000\000\002<\000\000\001T\001S\000\000\000\014\000\000\003&\000\000\000#\000\000\000\000\000\000\000\000\000\133\000\000\000\213\000\001\000\000\000\000\000\216\000\002\000\000\000\003\000\000\001\191\000\000\000\000\001\192\000\004\000\000\000\000\001\193\000\005\000\000\000\000\000\000\002\255\002\250\002\251\002\254\002\252\000\000\000\000\003\003\000\006\000\000\003\002\000\000\001 \000\000\000\000\003\000\000\000\003\001\000\000\000\000\000\000\000\000\001$\001%\000\000\000\000\001#\001\"\000\007\000\000\000\000\000\000\003\025\000\000\003\024") + (16, "\000\000\000\000\000\000\002\247\002\246\002\245\002\244\002\243\002\198\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\197\002\223\002\222\002\221\002\220\002\219\002\218\002\217\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\000\000\000\000\000*\000\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\001\168\001\147\001\165\001\164\001\163\001\169\001\173\000\000\0036\001\167\001\166\001\148\001\171\001\162\001\161\001\160\001\159\001\158\001\156\001\172\001\170\000\000\000\000\000\000\000\220\000\000\000\000\001\151\000\000\000\000\000\000\001\153\000\000\000\000\000\000\001\155\001\177\001\174\001\157\001\149\001\175\001\176\000\000\0034\0033\0037\000\000\000\000\000\024\001B\000\188\000\000\000\216\000\217\000\023\000\000\000\000\001\199\001\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003/\000\000\0030\000\000\000\000\003-\000\000\003,\003(\0022\000\000\003+\000\000\0023\000\000\000\000\000\000\000\000\000j\000\000\000\000\000h\000\000\000\000\001@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\184\001N\000\000\000\000\000\000\000\000\000\000\000\000\002\029\000\000\000\000\000\000\000\000\000\000\000\000\000e\000\000\000\000\000\000\000\000\001L\000\000\000\000\001O\001M\001U\000A\002\134\000\000\001\018\000\000\000\000\000\000\000\015\000\014\000\000\000\000\000\000\000\000\002\179\000\000\002e\002f\000\000\002c\002d\000\000\000\000\000\000\000\000\000\000\001e\001d\000\000\002\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\016\003\015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000g\000\000\000\231\000\000\002h\002g\000\000\000\000\000\000\001\181\000\000\000\000\000%\000\000\000\000\000\000\000\000\000\000\001T\000\000\001S\000\000\001C\001R\000\000\001A\000b\000\030\000\000\000\000\001|\000\025\000\000\000\000\000\000\000\000\003'\000(\000\000\000\000\000\031\000\026\000\000\000\000\000\000\000\201\000\000\000\000\000\000\000\203\002<\002.\000\000\000\"\000\000\002/\000\000\000\000\001\178\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\017\003\017\000\000\003\018\000\000\000y\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\000c\000\000\002\184\000f\000i\000d\002\173\0038\002\174\001\239\002\176\000\000\000\000\002\181\002b\002\183\000\000\000\000\000\000\002\190\002\187\000\000\000\000\000\000\001\236\001\222\000\000\000\000\000\000\000\000\001\226\000\000\001\221\000\000\001\238\002\196\000\000\001\237\000q\001\229\000\000\000o\000\000\002\189\002\188\000\000\001\232\000\000\000\000\001\228\000\000\000\000\001\224\001\223\000\000\002\186\000\000\002j\002i\000\000\000\000\002F\002\185\002\182\000\000\000\000\000\000\000\000\001\183\001-\001.\002l\000\000\002m\002k\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\242\000\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\000\000\000\000\000\000\000\001o\000\000\000\000\000\000\000\000\000\000\000\000\003M\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\002,\000\000\000\000\002-\000\000\000\000\001n\000\000\000\000\000\000\001K\001t\001J\001r\002 \002\031\000\000\001m\001l\000\000\000\205\000\000\000\000\001^\000\000\000\000\001b\000\000\001\203\001\202\000\000\000\000\001\201\001\200\001a\001_\000\000\001c\000\000\000\000\000\000\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\138\001P\002\143\002\141\000\000\000\000\000\000\002\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\172\000\000\002\171\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\250\000\000\000\000\000\000\000\000\000\000\000\000\000\239\001\249\000\240\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\234\000\000\000\235\000\000\000\000\000\000\002\151\000\000\000\000\000\000\002r\002q\000\000\000\000\000\000\000\000\0039\002\153\002\140\002\139\000\000\000\000\000\169\000\000\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\168\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\000\000\000\000\000\243\000\000\002\250\000\000\003$\000\000\000\000\003#\000\000\000\000\000\000\000\000\000\000\000\195\000\194\000\244\000\000\002\251\002\252\000\000\000\000\000p\000\000\002\191\002\175\000\000\002\194\000\000\002\193\002\192\000\000\000\000\000\000\000\000\000\000\000\000\000\248\000\000\000\000\002&\000\000\000\000\000\000\000\247\000\000\000\000\000\246\000\245\000\000\000\000\000\000\000\000\000\250\000\000\000\000\000\249\000\000\001\235\000\000\000\000\001\246\000\000\000\000\001\248\000\000\000\000\001\244\001\243\001\241\001\242\000\000\000\000\000\000\000\000\000\000\001\024\000\018\000\252\000\000\000\000\000\000\002t\002s\000\000\000\000\002\130\002\129\000\000\000\000\000\000\000\000\002~\002}\000\000\000\000\002@\000\000\000\000\002|\002{\000\000\000\000\002\128\002\127\002\147\000\000\000\000\000\000\000\000\000\000\002x\000\000\000\000\000\000\000\000\000\000\002v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\"\002!\000\167\000\000\002w\000\000\000\000\002u\000\000\000\000\002y\000\000\000z\000{\000\000\000\000\000\000\000\000\000\138\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\000\000\000\198\000\199\000\131\000\000\000\130\000\000\000\000\0010\000\000\0011\001/\002(\000\000\000\000\002)\002'\000\000\000\000\000\000\000\000\000\000\001\003\000\000\000\000\001\004\000\000\000\000\000\170\000\000\001\006\001\005\000\000\000\000\002\155\002\148\000\000\002\164\000\000\002\165\002\163\000\000\002\169\000\000\002\170\002\168\000\000\000\000\002\150\002\149\000\000\000\000\000\000\002\016\000\000\001\197\000\000\000\000\000\000\002I\002\015\000\000\002\159\002\158\000\000\000\000\000\000\001Q\000\000\002\132\000\000\002\133\002\131\000\000\002\157\002\156\000\000\000\000\000\000\002C\002\146\000\000\002\145\002\144\000\000\002\167\002\166\000\128\000\000\000\000\000\000\000\000\000\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\001X\000\000\000\000\000\000\000k\000\000\000\000\000l\000\000\000\000\000\000\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\000\000u\000\000\000\228\000\226\000\000\000\000\000\000\000\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000~\000m\000\000\000\000\002\014\000\000\000\000\000\251\001\195\000\000\000\237\000\238\001\002\000\000\000\000\000\000\000\000\000\000\001\210\001\204\000\000\001\209\000\000\001\207\000\000\001\208\000\000\001\205\000\000\000\000\001\206\000\000\001\144\000\000\000\000\000\000\001\143\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\014\003\t\000\000\000\000\003\b\000\000\000\000\000\000\000\000\000\000\001\255\000\000\000\000\000\000\000\000\000\000\000\000\003\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\000\002\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\249\000\000\000\000\002N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\146\000\000\000\000\000\000\001\145\000\000\000\000\000\000\000\000\000\000\001g\000\000\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\016\002\\\000\000\000\000\000\000\002Z\000\000\000\000\000\000\002Y\000\000\001Z\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\003A\000\000\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000E\000\000\000\000\000\000\000\000\001{\000\000\001z\000\000\000\000\000\000\000\000\000H\000\000\000\000\000\000\002\012\000\000\002\011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\000\000O\000M\000\000\000R\000\000\000\000\000\000\000\000\000\000\000G\000\000\000\000\000\000\000\000\000\000\000\000\000J\000\000\000Q\000P\000\000\000K\000L\000\000\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\012\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\000\000\000\000\000\000\000\000\000\000\001\n\002`\002R\000\000\002X\002S\002^\002]\002[\001\027\000\000\002P\000\000\000\000\000\000\000\000\000\000\002\029\000\000\000\000\001\020\002T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\139\001\135\000\000\000\000\000\000\000\210\000\000\000\000\002\019\002\029\000\000\000\000\001\022\002\017\002\018\000\000\000\000\000\000\000\000\000\000\001\142\001\138\001\134\000\000\000\000\000\211\000\000\000\000\001\141\001\137\001\133\001\131\002U\002Q\002a\001\026\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\0006\000\000\000\000\003D\000\000\003C\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\002\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001?\000\000\000\000\001=\001;\000\000\0007\000\000\000\000\003G\000\000\003F\000\000\000\000\000\000\0019\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001>\000\000\000\000\001<\001:\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\254\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\0003\000\000\000\000\000W\000\000\0001\000\255\000\000\000@\000-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253\000\000\000V\000U\000\000\000\000\000[\000Z\000\000\000\000\001\185\000\000\0005\000\000\000\000\000\000\0004\000\000\000\000\000\000\0008\000\000\000Y\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\b\003\012\003\003\000\000\000\000\003\007\002\248\003\002\003\011\003\n\001\031\000\000\000\000\003\000\000\000\003\004\003\001\003\r\001\251\000\000\000\000\002\254\000\000\000\191\002\253\000\000\000\000\000\222\000\000\000\000\001\030\001\029\000\000\001\\\001[\000\000\000\000\002\195\002\178\000\000\000B\000\000\000\000\000C\000\000\000\000\000\142\000\141\002\162\000\000\002\161\002\160\002\142\000\000\000\000\000\000\000\000\002\135\000\000\002\137\000\000\002\136\000\000\002o\002n\000\000\002p\000\000\000\000\000\134\000\000\000\000\002\004\000\215\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\189\000\000\003\006\002\024\002\025\002\020\002\022\002\021\002\023\000\000\000\000\000\000\000\190\000\000\000\000\002\029\000\000\000\214\000\000\000\000\000\000\000\000\003\005\000\000\000\187\000\000\000\000\000\000\000\000\0018\0012\000\000\000\000\0013\000\029\000\000\000\028\000\000\000\000\000\202\000\000\000\000\000\000\000 \000\027\000\000\000\000\000\000\000\021\000\000\000\000\000\000\000\000\001\140\001\136\000\000\001\132\003&\000\000\002\029\000\000\000\213\000\000\000\000\000\000\000\000\002W\002\028\002\026\002\027\000\000\000\000\000\000\002\029\000\000\000\212\000\000\000\000\000\000\000\000\002V\000\000\001i\001h\000\000\000\022\000\000\003?\000\000\000+\000\000\000\000\000\000\000\000\000\137\000\000\000\218\000\001\000\000\000\000\000\221\000\002\000\000\000\000\000\000\001E\001F\000\003\000\000\000\000\000\000\000\000\001H\001I\001G\000\019\001D\000\020\000\000\001\211\000\000\000\004\000\000\001\212\000\000\000\005\000\000\001\213\000\000\000\000\001\214\000\006\000\000\000\007\000\000\001\215\000\000\000\b\000\000\001\216\000\000\000\t\000\000\001\217\000\000\000\000\001\218\000\n\000\000\000\000\001\219\000\011\000\000\000\000\000\000\000\000\000\000\003\025\003\020\003\021\003\024\003\022\000\000\003\029\000\012\000\000\003\028\000\000\001%\000\000\000\000\003\026\000\000\003\027\000\000\000\000\000\000\000\000\001)\001*\000\000\000\000\001(\001'\000\r\000\000\000\000\000\000\0032\000\000\0031") and error = - (122, "'\225 \022*\183\204\207@P?\144\000\0148\b\216@\005\194\141\241'\208\004\015\128\000\001\142\007\223dB\011\248\212\000\019\007\007\184\226\192\160\208\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\254\182mf\235\252\205\255\005G\248\132A\231\129\247\217\016\130\2545\000\004\193\193\2388\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\0026\016\001`\163|I\244\001\003\224\000\000c\129\247\217\016\130\2545\000\004\193\193\2388\176(4'\225\"V*\183\204\207@P?\128\000\0308\000\000\000\000@\000\192\004\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\012\000\000\000\000\000\000\000\000\000\128\000\128\031\128\176\144\000\015\136\128A\000@\162\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\000\000\000\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\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\b\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\000\001\016\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\192\0000\016\000\197\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\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\003\000\000\192@\131\023\b\000\004\000\000\000\000\000\000@\016\000@ \193\004\000\000\016\000\000\000\000\000\016\004\000\000\b0A\000\000\004\000\000\000\000\000\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000\196\128*\000 \194Hp\000D\001\216@\136\001! \b\000\b \002\020\000\016\000b\000\002\000\bH\002\000\002\b\000\132\000\004\000\024\128\000\128\000\012\000\002\012\016L\000@\000\000\000\000\000\000\000\003\000\000\130\004\019\000\016\000\000\000\000\000\000\000\000\192\000 \129\004\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\012\000\002\b\000L\000\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 \128\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\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\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\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\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000! \b\130\b \002\024\000\016\000v\001\018\000@2\000\014\004\0001p\160\000@ \b\000\004\002\018\000\136\000\194\t!\192\001\016\006a\016a\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\0000\016\000\197\194\128\001\000\128 \000\016\0000\000\140\004\b1p\128\000@\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\000 \201Hp0D\129\216\005\152E\128\192\000 \000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\002\000\000\012\\ \000\018\000\002\000\000\000\001\000\016\000\000\001\000\000\000\004\128\000\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\002\020\002F\000\001$!\192\192\018\001!\018\000\016}\246D \191\141@\0010p{\142,\n\r\t\248H\149\138\173\2433\208\020\015\224\000\007\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\003\000\000\131\004\019\000\016\000\000\000\000\000\000\000\000\192\000 \129\004\192\004\000\000\000\000\000\000\000\0000\000\b A0\000\000\000\000\000\000\000\000\000\012\000\002\b\000L\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000! \b\130\b \018\024\000\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\006`\016 \004}\246D \191\141@\0010p{\142,\n\r\t\248H\149\138\173\2433\208\020\015\224\000\007\142\0026\016\001p\163|I\244\001\003\224\000\000c\128\141\132\000X(\223\018}\000@\248\000\000\024\224#a\000\022\n7\196\143@\016>\000\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\004\132\000@\b\012\0189\000\000\024\000\000\024\192\001\000\000\001\000\001\000\016\000\000\000\000\000\000\000\000@\000\000\000\000@\004\000\000\000\000\000\000\000\000\016\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\000\000\000\000\000+\250\221\253\155\239\247\255\252\029?\230!\003\158@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\141\134 ~*\223R=>b\249\004\001\154\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 HB\004\000\128\193#\144\000\001\128\000\001\140\0026\016\001`\163|H\244\001\003\224\000\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\000\000@\002\130\020\012\000\000\002\001\000\000\b@\000\000\000\000\160\133\003\000\000\000\128@\000\002\016\000\000\000\000(!\000\192\000\000 \016\000\000\003!\000\002\000\019\004\139@\004\006\128\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\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\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\131!\136\031\128\179\148\139O\140\134\193\000d\178\224\000\002\000\000\000\000\000\016\000\001\000\000\000\000\b0\000\000\016\000\000\001\000\000\000\000\000\000\000\000\012\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\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 \193\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\001\002\000\000\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\n~\018\001b\171|\205\244\005\003\248\128\000\227\130\159\132\128X\170\2233=\001@\254 \0008\224\167\225\"\022*\183\204\207@P?\152\000\0148\000@\128\000@\000\129\004\000\000\016\000\000\000\b\000\016 \000\016\000 A\000\000\004\000\000\000\000\000\004\b\000\000\000\b\016@\000\001\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000\001@\128\000\000\000\129\000\000\000\016\000\000\000\000\0026\016\001`\163|I\244\001\003\224\000\000c\128\141\132\000X(\223\018=\000@\248\000\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\0026\016\001p\163|I\244\001\003\224\000\000c\128\141\132\000X(\223\018}\000@\248\000\000\024\224#a\000\022\n7\196\143@\016>\000\000\00681on\215\248\190\223?\191\251a\247\219\127\252\2426\016\001`\163|H\244\001\003\224\000\000c\128\012\132\000\b\000L\018-\000\016\024\000\000\016@\003!\000\002\000\019\004\139@\004\006\128\000\005\016\000\200@\128\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\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\016\000\000\000\016\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\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\002\000\000D\000\000\000\000\000\000\000\001\000\000@\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000@\003\000\002\192@\003\023\b\000\004\000\000\000\000P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\001\000\012\000\003\001\000\012\\ \000\016\000\000\000\001@\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\001\000\004\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\012H\003\176\002\012\132\135\003\004H\029\128X\132X\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\196\128\187\000 \200Hp0D\129\216\005\136E\128\192\000 \000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\004\000\000\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\000\000\000\000\000\000\000\000\002\000\000\000\128\000\000\000\000\000\016\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\000\000\000\000\000\000\000\000\000\000\000\197\128\187\000 \201Hp0D\129\216\005\136E\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\003\000\000\128\000\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\000 \201Hp0D\129\216\005\136E\128\192\000 \000\000\197\194\000\001\000\000\000\000\000\012X\011\176\002\012\148\135\003\004H\029\128X\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\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\192@\003\023\b\000\004\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\000\001\000\000\b\000\000\000\004\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\001\000\000\b\000\000\000\004\b\012\000\003\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\128\000\000\000\004\000\000 \000\000\000\017 \000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\004\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\001\000\000\b\000\000\000\004H\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\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\012H\003\176\002\012\132\135\003\004H\029\128X\132P\000\000\b\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\016\0000\000\012\004\0001p\128\000@\000\000\000\001\000\000\000\b\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\128\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\b\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\000\000\000\000\000\000\000\004\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\b\000\001\016\000\000\000\001\000\000\000\004\000\000\000\002\000\000D\000\000\000\000\000\000\000\001\000\000\000\000\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\200@\000\192\004\193&\144\001\001\128\000\001\004\0002\016\000 \0010I\164\000@`\000\000A\000\012\132\000\b\000L\018)\000\016\024\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t2\145\180$\0050I\172\000@e\b\027U@\000\004\000\b\000@\000\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002L\164m\t\001L\018o\000\016\027A\006\213P\001\000\000\000\000\002\000\138\000\000\000\000\000\000\000 \200B\000\128\004\193\"\208\001\001\160\000\t\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\003!\000\003\000\019\004\155@\004\006\128\000\004\016\000\200@\000\128\004\193&\208\001\001\160\000\001\004\0002\016\000 \0010H\180\000@h\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\006\192\000\016\000\004\000\000\000\020\000LQ\0002\016\000 \0010H\180\000@h\000\000A\002@\000l\000\001\000\000@\000\000\001@\004\197\016\131!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\176\000\004\000\001\000\000\000\005\000\019\020@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\147!\027\002\000S\004\155@\004\006\208\0015T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002L\132l\b\001L\018m\000\016\027@\004\213P\000\000\000\000\000\000\000\000\000\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\128\000\b\000\000\000\000\016\000\000\000\000\001 D\000\000\000\000\000\000\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\012\132\000\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\006\192\000\016\000\004\000\000\000\020\000LQ\b2\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\027\000\000@\000\016\000\000\000P\0011D \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\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\002\002\000\019\004\139@\004\006\128\000\004\016\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\004\128\000\000\000\004\000\000\000\000\000HQ\b2\016 \0010H\180\000@h\000\000Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\016\000\000\000\001\000\000\000\000\000\018\004B\000\000D\000\000\000\000\000\000\000\000\000\000\000\000\131\000\001\000\000\001\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\202@\016\144\004\193&\176\001\001\144\000M\021\000\000\000\000\000\0000\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\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\128\000\000\000\001\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\0000\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\b\216@\005\130\141\241#\208\004\015\128\000\001\142\0002\016@2\t0I\180\000@h\000\000A\000\004\b\000\004\000\b\016@\000\001\000\000\000\000\128\001\002\000\001\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\004\000\000\016\000\000\000\000\000\016 \000\000\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\000\000\002\000\000\000\000\000\000\000\000\000\000\192\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\001\000@\000\000\131\004\000\000\000@\000\000\000\000\000@\016\000\000 \193\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\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\000\000\000\000\000\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018\000\168\000\131\001!\192\001\016\007`\002 \004\000\128\000\000\000\128\000\000\000\000\000\000\000\000\000\000\192\000 \128\004\192\000\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\000\003\000\000\224@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\003\018\000\168\000\131\001!\192\001\016\007`\002 \020\003\000\000\192@\003\023\b\000\004\000\000\000\000\0001 \n\128\b0\018\028\000\017\000v\001\"\001LH\002\160\002\012\004\135\000\004@\029\128H\128\016\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000@\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\012H\002\160\002\012\004\135\000\004@\029\128H\128\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\016\016\016\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018\000\168\000\131\t!\192\001\016\007a\002 \004\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\012H\002\160\002\012$\135\000\004@\029\132\b\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\000 \192Hp\000D\001\216\000\136\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\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000\196\128*\000 \192Hp\000D\001\216\000\136\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\004\000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\196\128*\000 \194Hp\000D\001\216@\136\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\012\000\000\128\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\000\000\000\000\000\000\000\000\000\016\000\002\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\000\000\000\001\b\000\000\000\000\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\160\002\012$\135\000\006@\029\128\t\128\016\020\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\002\000\000\000\128\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\000\000\000\000\000\000\000\001\000@\000\000\131\004\000\000\000@\000\000\000\0000\000\002\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\160\002\012$\135\000\006@\029\132\t\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\016\000 \000\000\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\0026\016!`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\004\000\000\000\004\000\000\000\000\000\128\000\016\000\000\000\000\000\000\001\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\018\016\001\000 0H\228\000\000`\000\000c\003\000\000D\000\000\000\000\000\0000\001\005\002@\000#a\000\023\n7\196\159@\016>\b\000\0068\b\216@\005\130\141\241'\208\004\015\130\000\001\142\0026\016\001`\163|H\244\001\003\224\128\000c\128\004\132\000D\b\012\018y\000\000\024\000\000\024\192\001!\000\016\002\003\004\158@\000\006\000\000\0060\000H@\004\000\128\193#\144\000\001\128\000\001\140\000\018\016\001\000 0H\228\000\000`\000\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\000\000\000\000\000\000\000\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\022\246\237\127\139\237s\251\255\182\031}\183\255\223\001\000\000\000\000\003\000\142\000\000\000\000\000\000\000(\216b\007\226\173\245#\211\230/\144@\025\174\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\141\132 X(\223\018=\000@\248\000\000\024\224\163a\b\022\n7\196\143@\016>\000\000\0068 @\128\000@\000\129\004\000\000\016\000\000\000\000\000\016 \000\000\000 A\000\000\004\000\000\000\000\000\004\b\000\000\000\b\016\000\000\001\000\000\000\000\000\000\000\000\000\000\002\000\016\000\000\000\000\000\016\000 @\016\000\000 \193\000\000\000\016\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(\216B\005\130\141\241#\208\004\015\128\000\001\142\n6\016\129`\163|H\244\001\003\224\000\000c\130\012\132 \b\000L\018-\000\016\024\000\000\016@\000\000\000\000\000\000\000\016\000\000\000@\0010D\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\004\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224#a\000\023\n7\196\159@\016>\000\000\0068\b\216@\005\130\141\241'\208\004\015\128\000\001\142\0026\016\001`\163|H\244\001\003\224\000\000c\128\012\132\000\012\000L\018m\000\016\026\000\000\017@\003!\000\002\000\019\004\155@\004\006\128\000\004P\000\200@\000\128\004\193\"\208\001\001\160\000\001\020\0002\016\000 \0010H\180\000@h\000\000A\000@\000\000\000\001\000\000@\000\000\000\000\004\129\016#a\000\022\n7\196\143@\016>\000\000\0068\000\202@\016\208\004\193&\176\001\001\128\000\001\004\0002\144\004$\0010I\172\000@`\000\000A\000\012\164\001\t\000L\018+\000\016\024\000\000\016@\002\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\0002\016\000 \0010H\180\000@h\000\000A\000\000\000 \000\000\000\000@\000\000\001\000\004\193\016\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000\128\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\014\134 ~\002\206R->2\027\004\001\146\203\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\002\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\003)\000B@S\004\138\192\004\006\000\000\020\016\b\216@\005\130\141\241#\208\004\015\128\000\001\142\0002\016\0000\0010I\180\000@h\000\000A\000\012\132\000\b\000L\018m\000\016\026\000\000\016@\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0026\016\001`\163|H\244\001\003\224\000\000c\128\004\132\000D\b\012\018y\000\000\024\000\000\024\192\001!\000\016\002\003\004\158@\000\006\000\000\0060\000H@\004\000\128\193#\144\000\001\128\000\001\140\012IK\176\250\015\133\135\003\254\216\029\246\223\156<\004\132\000@\b\012\0189\000\000\024\000\000\024\192\197\189\187_\226\251\\\254\255\237\135\223m\255\247\192\000\000\000\000\000\128\002\128\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\141\132\000X(\223\018=\000@\248\000\000\024\224\197\189\187_\226\251\\\254\255\237\135\223m\255\243\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\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\000H@\004\000\128\193#\144\000\001\128\000\001\140\012[\219\181\254/\181\207\239\254\216}\246\223\255|\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\192\002\128\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\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\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\197\189\187_\226\251\\\254\255\237\135\223m\255\243\241%.\195\232>\022\028\015\251`w\219~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\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\000B6\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\181\207\239\254\216}\246\223\255?\018R\236>\131\225a\192\255\182\007}\183\231\015#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\127[\177\250\175\253\207\247\255[\253\226\223\255\189\247\217\016\130\2545\000\004\193\193\2388\176(4#a\000\022\n7\196\143@\016>\000\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\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\012\132\000\b\000L\018m\000\016\024\000\000\016@\003!\000\002\000\019\004\139@\004\006\000\000\004\016\000\202@\016\144\004\193&\176\001\001\144\000m\021\b:\024\129\248\0119H\180\248\200l\016\006K,\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\202@\016\144\004\193\"\176\001\001\144\000%\004\0002\016\000 \0010H\164\000@`\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b0\000\012\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\025\000\000\000\000\016\000\000\000@\000\000\000 \192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000d\000\000\000\000@\000\000\001\000\002\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000 \000\006@\000\000\000\004\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\141\132\000X(\223\018=\000@\248\000\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\012\164\001\t\000L\018+\000\016\025\000\002P@\000\000\000\000\000\000\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\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\000\004\000\000\000\000\000L\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\131\000\000\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\000\b\000\000\128\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 \224\0000\016\000\197\194\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\000\000\001\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\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\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\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\001\000\000\000\000#a\000\022\n7\196\143@\016>\000\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\001\000\004\193\016\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\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@\001 D\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\012\132\000\b\000L\018-\000\016\026\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\004\000\000\000\016\000H\017\b2\016\000 \0010H\180\000@h\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\016\000\000\000@\001 D \200@\000\128\004\193\"\208\001\001\160\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\001\000\004\129\016\128\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0002\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\132\128\"\000 \128H`\000d\001\152\000\b\001! \b\128\b\"\018\024\012\025\000f\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001%.\195\232>\022\028\015\249`w\139~p\2426\016\001`\163|H\244\001\003\224\000\000c\130\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\0026\016\001`\163|H\244\001\003\224\000\000c\130\000\002\004>\000\192@@>\002\001\000\005\130\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\020\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068 \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\128\000\155\015\1280\016\016\015\128\128@\001a\128\232\216B\197\130\141\241#\208\004\015\128\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\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\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\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\001!\000\016\002\003\004\142@\000\006\000\000\00601on\215\248\190\215?\191\251a\247\219\127\253\240\000\000\000\000\000 \000\160\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\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\012[\219\181\254/\183\207\239\254\216}\246\223\255<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\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\197\189\187_\226\251|\254\255\237\135\223m\255\243\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\001\000\000\000\000\000\000\000\000\000\000\000\0001on\215\248\190\223?\191\251a\247\219\127\252\2426\016\001`\163|H\244\001\003\224\000\000c\131\018R\236>\131\225a\192\255\150\007x\183\231\015\128\000\145\015\1280\016\016\015\128\128@\001`\128\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0000\000\160\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\0001on\215\248\190\223?\191\251a\247\219\127\252\2426\016\001`\163|H\244\001\003\224\000\000c\131\018R\236>\131\225a\192\255\150\007x\183\231\015#a\000\022\n7\196\143@\016>\000\000\0068 \000\000\128\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\183\207\239\254\216}\246\223\255<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\b\000\b\016\248\003\001\001\000\248\b\004\000\022\b\015\022\246\237\127\139\237\243\251\255\182\031}\183\255\207#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\240\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068 \000\002\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\183\207\239\254\216}\246\223\255<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\003\022\246\237\127\139\237\243\251\255\182\031}\183\255\207#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\2426\016\001`\163|H\244\001\003\224\000\000c\130\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187_\226\251|\254\255\237\135\223m\255\243\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156?\022\246\237\127\139\237\243\251\255\182\031}\183\255\207#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\252[\219\181\254/\181\207\239\254\216}\246\223\255\127\022\246\237\127\139\237s\251\255\150\031x\183\255\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\b\216@\005\130\141\241#\208\004\015\128\000\001\142\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#a\000\022\n7\196\143@\016>\000\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\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\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000 \000\000#a\000\022\n7\196\143@\016>\000\000\0068\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\131\161\136\031\128\179\148\139O\140\134\193\000d\178\192\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\012\164\001\t\001L\018+\000\016\024\000\000P@\003\000\000\128\000\003\023\b\000\004\000\000\000\000\000\000@\000\000\000\016@\000\000\001\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000B@S\004\138\192\004\006\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\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)\000B@S\004\138\192\004\006\000\000\020\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\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\216@\005\130\141\241#\208\004\015\128\016\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\0001%.\195\232>\022\028\015\249`w\139~p\2402\016\000 \0010H\180\000@h\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\131\018R\236>\131\225a\192\255\150\007x\183\231\015#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~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\001\000\004\129\016#a\000\022\n7\196\143@\016>\000\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\002\000\000\000\000\000 \141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200@\000\128\004\193\"\208\001\001\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\129!\b\016\002\003\004\142@\000\006\000\000\0060 \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#a\000\022\n7\196\143@\016>\000\000\0078\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\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\b\216@\133\130\141\241#\208\004\015\128\000\001\142\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002\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\018\016\001\000 0H\228\000\000`\000\000c\001\000\000\000\000\000\000\000\000\0000\000\005\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\016\000\000\000\000\000\000\000\004\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\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\016\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\000\000\000\000\000\000\000\000\000\000\000\000 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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@\000\000\000@\000\000\000\000\192#\128\000\000\000\000\000\000\012\000\001\016\000\000\000\000\000\000\192\004\020\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\015\160\248Xp?\237\129\223m\249\195\192\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\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\128\000\145\015\1280\016\016\015\129\128@\001`\128\224\000\004\000\000\000\000\000\000\000@\000\000\000\000\b\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\002\000\000\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\000\000\000\000\000\000 \001\000\002\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000@\000\000\004\000\000\000\000\000\000\000\0000\000\000\000\000\000\001\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\002\000\000\000\000\000@\000\016\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\bH\002 \002\b$\135\000\006@\025\128\000\128\016\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000@\000\000\000\000@\000\016\000\000\000@\000\000\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\bH\002 \002\b$\135\000\006@\025\128\000\128\016\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\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\004\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\001\000\002\000\024\000\000\002\000\000\000\000\000H\000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\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\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\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\001\000\000\001\000\002\000\000\000\001\000\000\012\000\002\000\000\012\\(\000\016\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\016\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\192@\003\023\b\000\004\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\016\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000D\000\000\000\000@\000\002\000\000\000\000\016\000\000\017\000\000\000\000\016\000\000\000\000\000\000\000\000\000\004@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\016\016\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\017\000\000\000\000\016\000\000\128\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\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\b\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\002\000\000\012\\ \000\016\000\000\000\000\000\133\128\162\000 \193Hp\000d\001\152\004\bA\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bX\n \002\b\020\135\000\006@\025\128@\132\016\012\000\002\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\192\000 \000\000\197\194\000\001\000\000\000\000\000\bX\002 \002\b\020\135\000\006@\025\128@\132\018\022\002\136\000\131\005!\192\001\144\006`\016!\004\000\000\000\000\000\000\000\016\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\004\002\000\019\004\155@\004\006\000\000\004\016\000\200A\000\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\000\b\000L\018-\000\016\024\000\000\016@\132\128\"\000 \128H`\000d\001\152\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\018R\236>\131\225a\192\255\150\007x\183\231\015@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200@\000\128\004\193\"\208\001\001\160\000\001\020\012IK\176\250\015\133\135\003\254X\029\226\223\156>\000\002 >\000\192@@>\002\001\000\007\194\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\b\016\004\000\000\b0@\000\000\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\004\000\000\b0@\000\000\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\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\000\000\b0@\000\000\004\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! \b\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\b\000\000\000\b\016@\000\001\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000! \b\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\000\016\004\000\000\000@\000\000\000\000\000\000\000\001\000\000\001\000\001\000\016\000\000\000\000\000\000\000\000@\000\000\000\000@\004\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\007`\000 \000\001\000@\000\000\131\004\000\000\000@\000\000\000\0001 \b\128\b0\018\028\000\017\000f\000\002\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\004\000\000\000\000\016\000\000\000\000\000\000\000\000\192\001\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\b\000\000\000\000\001\000\000@\000\132\128\"\000 \128H`\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@0\000\000\000\000\000\001\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\002\000\000\000\000\000@\000\016\000! \b\128\b \018\024\000\017\000f\000\002\000HH\002 \002\b\004\132\000\004@\025\128\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\128\000\000\000\000\016\000\004\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\246D \191\141@\0010p{\142,\n\r\t\248H\149\138\173\2433\208\020\015\224\000\007\142\0002\016\000 \0010H\180\000@h\000\000A\000@\000\b\000\000\000\000@\000\000\000\000\004\129\016#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\223dB\011\248\212\000\019\007\007\184\226\192\160\208\159\132\137X\170\2233=\001@\254\000\000x\224\001\002\000\001\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\004\000\000\016\000\000\000\000\000\016 \000\000\000 @\000\000\004\000\000\000\000\002\018\000\136\000\130\t!\192\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\192\004\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\012\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\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\132\129\"\000 \128H`\000D\001\152\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\001\000\002\000\024\000\000\002\000\000\000\000\000H\000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000 \000\128\000\000 \000\000\000\002\018\000\136\000\194\001!\192\001\016\007`\000`\000\001 \000\000\000\002\000\b\000\000\002\000\000\000\000\000\000\002\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\002\018\000\136\000\130\001!\192\001\016\006a\000!\000\001\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\bH\002 \002\b\004\135\000\004@\025\128\000\128\002\018\000\136\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\128\"\192`\131\031H\000D\001\128\000\b\000! \b\128\b \002\016\000\016\000f\000\002\000\000\016\000\000\016\000\000\001\000\000\000\000\000\000\002\000\004\000\000\004\000\000\000@\000\000\000\000\000\000\000\001\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\bH\002 \002\b \134\000\004\000\025\132\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\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\bH\002 \002\b \134\000\004\000\025\132\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\004\001\000\000\000\016\000\000\000\000\000\000\000\000\192\001\000\000\000\000\004\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\b\000\000\000\000\001\000\001@\000\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\000\000\000\bH\002 \002\b \134\000\004\000\025\132\000\128\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\000\000\000\000\000\000\000\000\000\000\000\004\000\000\016\004\000\000\b0@\000\000\004\000\000\000\000\003\018\000\136\000\131\000!\192\001\000\006`\000 \004\132\128\"\000 \128\b@\000@\001\152\000\b\001\000\192\000\000\000\000\000\004\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\001\000@\000\000\131\004\000\000\000@\000\000\000\0001 \b\128\b0\002\028\000\016\000f\000\002\000HH\002 \002\b\000\132\000\004\000\025\128\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\128\000\000\000\000\016\000\004\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\000!\128\001\000\006a\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\012H\002 \002\012\000\135\000\004\000\025\128\000\128\002\018\000\136\000\130\000!\128\001\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\128\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\001\000\004\002\012\016@\000\001\000\000\000\000\000\001\000@\000\000\131\004\016\000\000@\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\012H\002 \002\012\000\135\000\004\000\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\001\000\002\000\024\000\000\002\000\000\000\000\000H\000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000 \000\128\000\000 \000\000\000\002\018\000\136\000\194\000!\192\001\000\006`\000`\000\b\128\000\001\000\001\000\024\000\000\000\000\000\000\000\002\000\000\000@\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\016\001\128\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@\002\000\000\000\000\000\000\000\000 \000\b \001\000\000\000\000\000\000\000\000\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\000\000\000\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\004\000\000\000 \005\016 \000\000\000\000\000\000\000\132\000\000\000\000\n\bP\016\000\000\b\004\000\000!\000\000\000\000\002\130\016\004\000\000\002\001\000\000\0000\000\012\004\0001p\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\002\002\016\004\000\000\002\001\000\000\000\128\000\000\000\016\016\001\000\000\000\000\000\000\000\000 \000\000\000\004\004\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\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\001\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\012\004\0001p\128\000@\000\000\000\000\002\016\000\000\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\b\000\000@\004\000\000\000\000\000\000\000\000\128\000\002\000\000\016\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\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\004\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\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\004\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\132\000\000\000\000\b\bp0\000\000H\004\000\000!\000\000\000\000\002\002\024\004\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\016\000\000\000\000 !\192\192\000\001 \016\000\000\001\000\000\000\b\001D\024\000\000\000\000\000\000\000\000@\000\000\002\000Q\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\128\000\000\000\000\000\000\000\000\000\000\001\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\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\001\000\000\000\001\000\000\000\b\001D\b\000\000\000\000\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\016\000\000\004\000\000\000\000\004\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\000\000\000\000\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\128\000\000\000\004\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\000\000\000\000\000\000\000\000\000\000\000! \n\128\b\"\018\028\004\017\000v\001\002\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\002\000Q\002\000\000\000\000\000\000\000\bH\002\160\002\b\132\135\001\004@\029\128@\128\018\016\000\000\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\0000\016\000\197\198\000\001\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000!\000\000\000\000\002\002\028\012\000\000\002\001\000\000\b@\000\000\000\000\128\134\001\000\000\000\128@\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\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\002\016\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\b@\000\000\000\000\128\132\001\000\000\000\128@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128Hp\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@\128\000\000\000\000\016\001\128\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\001\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\004\000\000\000\000\004\000\000\000 \005\016 \000\000\000\000\000\000\000\132\128\"\000 \128Hp\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\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\001\000\024\000\000\000\000\000\000\000\002\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\128\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\016\000\000\192\0000\018\000\213\194\000\001\000\000\000\000\000\bX\n\160\002\012\016\135\000\004@\029\128\001\128\016\012\000\002\000\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\192\0000\018\000\213\194\000\001\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\005\000\000\000\b\000\000\000\000@\000\000\000\000\004\001\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\192\0000\018\000\213\194\000\001\000\000\000\000\000\0000\000\b\000\0001p\128\000@\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000\192H\003W\b\000\004\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\016\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\002\022\002\168\000\131\004!\192\001\016\007`\000 \004\133\128\170\000 \193\bp\000D\001\216\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002\160\002\b\000\135\000\004\000\029\128\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! \b\128\b \002\024\000\016\000f\000\002\000HH\002 \002\b\000\132\000\004\000\025\128\000\128\016 \000\000\000\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\001\000\b\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\016\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\192H\003W\b\000\004\000\000\000\000\000! \b\128\b \002\024\000\016\000f\000\002\000HH\002 \002\b\000\132\000\004\000\025\128\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\000\000\000\000\000\000\000\000\bH\002 \002\b\000\132\000\004\000\025\128\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! \b\128\b \002\024\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\000!\000\001\000\006`\000 \004\002\000\000\130\000\019\000\016\000\000\000\000\000\000\000\000\128\000 \128\004\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\007`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\024\000\017\000f\001\002\000HH\002 \002\b\004\132\000\004@\025\128\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! \b\128\b \002\016\000\016\000f\000\002\000@ \000\b \0010\001\000\000\000\000\000\000\000\000\b\000\002\b\000L\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\016\000\0002\000\014\004\0001p\160\000@ \b\000\004\000\012\000\011\001\000\012\\ \000\016\000\000\000\001@\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\160\"\000 \130Hh\000D\003\152\004\b\001! \b\128\012 \018\028\000\017\000f\001\006\016HH\002 \002\b\004\135\000\004@\025\128@\132\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H`\000D\001\152\004\bA\000H\000\000\000\000\128\002\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\132\128\"\000 \128\b`\000@\001\152\004\b\001! \b\128\b \002\016\000\016\000f\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! \b\128\b \018\028\000\017\000v\001\002\000@\018\000\002\000\000 \000\160\000\000 \b\000\004\000\004\128\000\000\000\b\000(\000\000\b\002\000\001\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\000\000\000\000\000\000\000\000\000\000\000\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\012 \018\028\000\017\000f\001\006\016HH\002 \002\b\004\135\000\004@\025\128@\132\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\000\002 \000\000@\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\016\001\128\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\001\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\0002\144\004$\0010H\172\000@d\000\001A\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\132\000\000\000\000\n\bP0\000\000\b\004\000\000!\000\000\000\000\002\130\016\012\000\000\002\001\000\000\b@\000\000\000\000\128\132\003\000\000\000\128@\000\000 \000\000\000\004\004\000@\000\000\000\000\000\000\128\000\000\000\000\001\001\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\002@\000#a\000\022\n7\196\143@\016>\000\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\004\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\000\000\000\000\002\002\024\012\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\004\004\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\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\001\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\012\004\0001p\128\000@\000\000\000\000\002\016\000\000\000\000 !\192\192\000\000 \016\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\016\000$\000\0026\016\001`\163|H\244\001\003\224\000\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\b\216@\005\130\141\241#\208\004\015\128\000\001\142\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\128\000\000\000 \000\001\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\004\000\000\000\000\000\000\000\000\000\003)\000B@\019\004\138\192\004\006@\000\020\016\000\224\0000\016\000\197\194\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\000\000\001\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\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\b\216@\005\130\141\241#\208\004\015\128\000\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\132\000\000\000\000\b\b`0\000\000\b\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\002\000\000\016\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\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\004\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\192\0000\016\000\197\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\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000B@\019\004\138\192\004\006@\000\020\016\000\224\0000\016\000\197\194\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\000\000\001\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\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\b\216@\005\130\141\241#\208\004\015\128\000\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#a\000\022\n7\196\159@\016>\000\000\0068\b\216@\005\130\141\241#\208\004\015\128\000\001\142\b@\000\000\000\000\128\134\003\000\000\000\128@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\b\003D\024\000\000\016\000\000\000 \000@\000\000\002\000\209\006\000\000\004\000\000\000\000\000\016\000\000\000\1284@\128\000\001\000\000\000\000\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\003!\004\003 \019\004\155@\004\006\000\000\004\016\031}\145\b/\227P\000L\028\030\227\139\002\131@2\016@ \0010I\180\000@`\000\000A\000\012\132\016\b\000L\018-\000\016\024\000\000\016@\003!\000\002\000\019\004\139@\004\006\000\000\004\016\000\000\000\000\000\000\000\b\000\b\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\128\001\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\002\000\000\004\000\000\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000@\000\000\016\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\003)\000B@\019\004\154\192\004\006\000\000\004\016\000\202@\016\144\004\193\"\176\001\001\128\000\001\004\0002\144\004$\0050H\172\000@`\000\000A\000\004\000\000\000 \r\016 \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\209\002\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\022\164\169A\138-3\251\193\016\030`\016x\212\133\169*Pb\139L\254\240D\007\152\004\0305\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002\160\002\b\132\135\003\004@\025\128A\128P\000\000\000\000\000\000\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\128\b\"\018\028\012\017\000f\001\006\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\132\128*\000 \136Hp0D\001\152\004\024\005\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\004\000\000\000 \r\016 \000\000@\000\000\000\000\132\128*\000 \136Hp0D\001\152\004\024\005\000\200A\000\128\004\193\"\208\001\001\128\000\001\004\0002\016\000 \0010H\180\000@`\000\000A\000\000\000\000\000\000\000\000\128\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\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\000\000\000\000\000\000\000\003\000\000\192H\003W\b\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\132\000\000\000\000\b\bp0\000\000\b\004\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\002\016\000\000\000\000 !\128\192\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\209\002\000\000\004\000\000\000\000\b@\000\000\000\000\128\135\003\000\000\000\128@\000B\016\000\000\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\0000\016\000\197\198\000\001\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\002\016\000\000\000\000 !\128\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\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\132\000\000\000\000\b\b`0\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\000\000\000\000\000\002\016\000\000\000\000 !\000\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\000@0\000\012\004\1285p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\b\003D\b\000\000\016\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\000@2\144\004$\0010H\172\000@d\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H`\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@\128\000\000\000\000\016\001\128\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\001\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\0002\144\004$\0010H\172\000@d\000\001A\002\018\000\136\000\130\001!\128\001\016\006`\000 \004\132\128\"\000 \128H@\000D\001\152\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\000\000\132\128\"\000 \128H@\000@\001\152\000\b\000\000\200A\000\192\004\193&\208\001\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H@\000D\001\152\000\b\001! \b\128\b \018\024\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\000\001\016\006`\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\132\128\"\000 \128H`\000@\001\152\000\b\000! \b\128\b \018\016\000\016\000f\000\002\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\bH\002 \002\b\004\132\000\006@\025\128\000\128\016\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! \b\128\b \018\024\000\016\000f\000\002\000\bH\002 \002\b\004\132\000\004\000\025\128\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\000\000\000\000\196\128*\000 \194Hp\000D\001\216\000\136\0010\000\002\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\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\0010D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\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\002\002\016\012\000\000\002\001\000\000\b\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\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\000\000\000\000\000\000\000\000\000\000\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\016 \000\016\000 A\000\000\004\000\000\000\000\000\004\b\000\000\000\b\016@\000\001\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000\000\000\002\000\000\000\128\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\001\000\000\002\012\016\000\000\001\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\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\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\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 \200@\000\128\004\193\"\208\001\001\160\000\001\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018R\236>\131\225a\192\255\150\007x\183\231\015\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\001 \000 \000\002\000\b\000\000\002\000\000\000@\000H\000\000\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000 \000\128\000\000 \000\000\000\002\018\000\136\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\002\000\b\000\000\002\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\018\000\136\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\002\000\b\000\000\002\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\b \128H`\000D\001\216\004\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\004\134\000\004@\025\128@\128\016\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\000H\000\b\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000 \000\128\000\000 \000\000\004\002\018\000\136\000\130\001!\128\001\016\006`\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\002\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\128\000\000\000\000\000\192\000 \000\000\197\198\000\001 \000 \000\000\0000\000\b\000\0001p\128\000H\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@\004\000\000\000@\000\000\001 \000\000\000\000\0000\000\b\000\0001p\128\000H\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\001\000\000\000\000\000\000\000\000\000\000\003\000\000\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\000\000\000\000\128\000\000\000\000\000\000\000\000\000\016\000\000\004\000\000\000\000\004\000\000\000\016\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\000\000\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\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\016\000\000\000\000\001\000\000\000\000\002\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\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\016\000\000\000\000\001\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! \b\128\b \018\028\000\017\000f\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\003 \000\224@\003\023\n\000\004\002\000\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\000\134\000\004\000\025\128@\128\016\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\000H\000\b\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000 \000\128\000\000 \000\000\004\002\018\000\136\000\130\000!\128\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\000\000\000\000! \b\130\b \002\024\000\016\000v\001\018\000@2\000\014\004\0001p\160\000@ \b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128\b`\000@\001\152\004\b\001\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\004\128\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\002\000\b\000\000\002\000\000\000@! \b\128\b \002\024\000\016\000f\000\002\016\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\004\000\000\128\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\132\128\"\000 \128Hp\000D\001\152\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#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\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\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\004\128 \000 \128\b@\000@\001\144\000\b\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\003\000\000\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\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#a\000\022\n7\196\143@\016>\000\000\0068\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\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\004\000\000\000\004\000H\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'\225 \022*\183\204\207@T?\144\000\0148\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000Z\018\000\002\b4\132\004\004@9\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\004\128 \000 \128H@\000D\001\144@\b\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\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\002\b\004\132\000\004\000\024\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\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\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\t\248H\005\138\173\2433\208\021\015\228\000\003\142\002~\018\001b\171|\204\244\005C\249\000\000\227\128\018\000\128\000\130\001!\000\001\016\006@\000 \000\004\128 \000 \128H@\000D\001\144\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\018\000\128\000\130\001!\128\001\016\006@\000 \000\004\128 \000 \128H@\000D\001\144\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\004\128 \000 \128H`\000D\001\144\000\b\000\001 \b\000\b \018\016\000\017\000d\000\002\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000") + (124, "'\225 \197\138\173\2433\208\020\015\228\000\003\142\0026\016\004\\(\223\018}\000@\248\000\000\024\224}\246D\b/\227P\000L\028\030\227\139\002\131@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\175\235f\245\155\175\2437\252\021\031\226\017\007\158\007\223d@\130\2545\000\004\193\193\2388\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#a\000E\130\141\241'\208\004\015\128\000\001\142\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\000\000\000\000\004\000\012\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\192\004\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\128\000\128\007\224,$\000\003\226 \016@\016(\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\002\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\128\000\b\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\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\128\000\b\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\017\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\b\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\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\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\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\0000\000\007\001\002\012\\ \000\016\000\000\000\000\000\001\000@@@ \193\004\000\000\016\000\000\000\000\000\016\004\004\000\002\012\016@\000\001\000\000\000\000\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\012H\002\168\000\131\t!\192\001\016\007a\002 \004\132\128 \128\b \002\020\000\016\000b\000\002\000\bH\002\b\000\130\000!\000\001\000\006 \000 \000\003\000\000 \193\004\192\004\000\000\000\000\000\000\000\0000\000\002\b\016L\000@\000\000\000\000\000\000\000\003\000\000 \129\004\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\003\000\000 \128\004\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\002\000\000 \128\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\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\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\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\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\130\b \002\024\000\016\000v\001\018\000@2\000\007\129\000\012\\(\000\016\b\002\000\001\000\132\128\"\128\012 \146\028\000\017\000f\017\006\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003 \000p\016\000\197\194\128\001\000\128 \000\016\0000\000\135\001\002\012\\ \000\016\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012X\011\184\000\131%!\192\193\018\007`\022a\022\003\000\000`\000\000\197\194\000\001\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\016\001\000\000\000\004\000\000\000\018\000\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\133\000\145\160\000\018B\028\012\001 \018\017 \001\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\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\0000\000\002\012\016L\000@\000\000\000\000\000\000\000\003\000\000 \129\004\192\004\000\000\000\000\000\000\000\0000\000\002\b\016L\000\000\000\000\000\000\000\000\000\003\000\000 \128\004\192\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\130\b \018\024\000\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\001\002\000G\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\0026\016\004\\(\223\018}\000@\248\000\000\024\224#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\016\004@\b\012\0189\000\000\024\000\000\024\192\001\000\000\000@\000@\004\000\000\000\000\000\000\000\000\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\254\183\127\217\190\255\127\255\193\211\254b\0169\228\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n6\024\132~*\223R=>b\249\004\001\154\235\129!\bD\000\128\193#\144\000\001\128\000\001\140\0026\016\004X(\223\018=\000@\248\000\000\028\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\132\000\000\128@\002\130\020\012\000\000\002\001\000\000\b@\000\b\000\000(!@\192\000\000 \016\000\000\132\000\000\128\000\002\130\016\012\000\000\002\001\000\000\0002\016\004\b\000L\018-\000\016\026\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\001\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\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\b2\024\132~\002\206R->2\027\004\001\146\203\128\000\b\000\000\000\000\000\016\000\001\000\000\000\000\b0\000\000\004\000\000\000@\000\000\000\000\000\000\000\003\000\000\000\000\000\000\004\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000@@\000 \193\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\004\000\000\000\000\000\000\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\n~\018\012X\170\2233}\001@\254 \0008\224\167\225 \197\138\173\2433\208\020\015\226\000\003\142\n~\018,X\170\2233=\001@\254`\0008\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016 \004\004\000\b\016@\000\001\000\000\000\000\128\001\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\000P \004\000\000\b\016\000\000\001\000\000\000\000\000#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\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#a\000E\194\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018}\000@\248\000\000\024\224#a\000E\130\141\241#\208\004\015\128\000\001\142\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\0002\016\004\b\000L\018-\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\160\000\001D\0002\016$\b\000L\018-\000\016\026\000\000\016@\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\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\017\000\000\000\000\000\000\000\000\016\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\020\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\004\0000\000'\001\000\012\\ \000\016\000\000\000\001@\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@\003\000\000p\016\000\197\194\000\001\000\000\000\000\020\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\016\000\000\b\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\128\000\000\b\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\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\000\000\196\128;\128\b2\018\028\012\017 v\001b\017`0\000\007\001\000\012\\ \000\016\000\000\000\000\000\196\128\187\128\b2\018\028\012\017 v\001b\017`0\000\006\000\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\197\128\187\128\b2R\028\012\017 v\001b\017`\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\000\000\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\128\b2R\028\012\017 v\001b\017`0\000\006\000\000\012\\ \000\016\000\000\000\000\000\197\128\187\128\b2R\028\012\017 v\001b\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\002\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\004\000\000\004\000\000 \000\000\000\016\0000\000\007\001\000\012\\ \000\016\000\000\000\000\002\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\000\000\002\000\000\000\000\004\000\000 \000\000\000\016 0\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\002\000\000\000\001\018\000\000\000 \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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000 \000\000\000\017 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000 \000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128;\128\b2\018\028\012\017 v\001b\017@\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\001\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\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\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\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\000\000\000\000\000\000\000\000@\000\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\000\000\000\000\000\000\000\000\000\000\000\000\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\017\000\000\000\000\004\000\000\000\016\000\000\000\b\000\001\016\000\000\000\000\000\000\000\001\000\000\000\000\003!\000@\128\004\193\"\208\001\001\160\000\001\004\0002\016\004\012\000L\018i\000\016\024\000\000\016@\003!\000@\128\004\193&\144\001\001\128\000\001\004\0002\016\004\b\000L\018)\000\016\024\000\000\016@\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t2\145\181\t\001L\018k\000\016\025B\006\213P\000\001\000\000\128\004\000\000\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\147)\027P\144\020\193&\240\001\001\180\016mU\000\016\000\000\000\000\b\002(\000\000\000\000\000\000\000\131!\b@\128\004\193\"\208\001\001\160\000\t\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\0002\016\004\012\000L\018m\000\016\026\000\000\016@\003!\000@\128\004\193&\208\001\001\160\000\001\004\0002\016\004\b\000L\018-\000\016\026\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\144\000\027\000\000\016\000\004\000\000\000\020\000LQ\0002\016\004\b\000L\018-\000\016\026\000\000\016@\144\000\027\000\000\016\000\004\000\000\000\020\000LQ\b2\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\176\000\001\000\000@\000\000\001@\004\197\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t2\017\180\b\001L\018m\000\016\027@\004\213P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\147!\027@\128\020\193&\208\001\001\180\000MU\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\000\b\000\000\000\000\004\000\000\000\000\000H\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\b2\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\176\000\001\000\000@\000\000\001@\004\197\016\131!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\027\000\000\016\000\004\000\000\000\020\000LQ\b\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\003!\002@\128\004\193\"\208\001\001\160\000\001\004\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001 \000\000\000\000@\000\000\000\000\004\133\016\131!\002@\128\004\193\"\208\001\001\160\000\001D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\017\000\000\000\000\004\000\000\000\000\000H\017\b\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\131\000\001\000\000\000@\000\000\000\000\000\000\000\000\b\000\001\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\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\0002\144\005\t\000L\018k\000\016\025\000\004\209P\000\000\000\000\000\000\192\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\016\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\016\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\192\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\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\003!\004@\200$\193&\208\001\001\160\000\001\004\000\016 \004\004\000\b\016@\000\001\000\000\000\000\128\001\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\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\128\000\000\000\000\000\000\000\000\0000\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\001\000@@\000 \193\000\000\000\016\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\128\004\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\016\128\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\001!\192\001\016\007`\002 \004\000\128\000\000\000 \000\000\000\000\000\000\000\000\000\0000\000\002\b\000L\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\001\000\001\000\000\003\000\000x\016\000\197\194\000\001\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\012H\002\168\000\131\001!\192\001\016\007`\002 \020\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\012H\002\168\000\131\001!\192\001\016\007`\018 \020\196\128*\128\b0\018\028\000\017\000v\001\"\000@0\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\196\128*\128\b0\018\028\000\017\000v\001\"\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\001\001\001\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\t!\192\001\016\007a\002 \004\001\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\196\128*\128\b0\146\028\000\017\000v\016\"\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\128\b0\018\028\000\017\000v\000\"\000@\b\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\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128*\128\b0\018\028\000\017\000v\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\016\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\196\128*\128\b0\146\028\000\017\000v\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\012\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\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\016\128\000\000\000\000\000\000\000\000\000\016 \004\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\012H\002\168\000\131\t!\192\001\144\007`\002`\004\005\002\b@\000\000\129\000\000\000\016\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\128\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\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\192\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\t!\192\001\144\007a\002`\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\128\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\0026\016$X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000@\000\000\000@\000\000\000\000\b\000\001\000\000\000\000\000\000\000\004\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\018\016\004@\b\012\0189\000\000\024\000\000\024\192\192\000\017\000\000\000\000\000\000\003\000\016P$\000\0026\016\004\\(\223\018}\000@\248 \000\024\224#a\000E\130\141\241'\208\004\015\130\000\001\142\0026\016\004X(\223\018=\000@\248 \000\024\224\001!\000D@\128\193'\144\000\001\128\000\001\140\000\018\016\004@\b\012\018y\000\000\024\000\000\024\192\001!\000D\000\128\193#\144\000\001\128\000\001\140\000\018\016\004@\b\012\0189\000\000\024\000\000\024\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\000\000\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\189\187\215\248\190\215?\191\251a\247\219\127\253\240\016\000\000\000\000\012\0028\000\000\000\000\000\000\000\163a\136G\226\173\245#\211\230/\144@\025\174\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\163a\bE\130\141\241#\208\004\015\128\000\001\142\n6\016\132X(\223\018=\000@\248\000\000\024\224\129\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\000\000\000\000\000\000\b\000@\000\000\000\000\000@\000\129\000@@\000 \193\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\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\163a\bE\130\141\241#\208\004\015\128\000\001\142\n6\016\132X(\223\018=\000@\248\000\000\024\224\131!\b@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000@\000\000\001\000\004\193\016\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\0026\016\004\\(\223\018}\000@\248\000\000\024\224#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\003!\000@\192\004\193&\208\001\001\160\000\001\020\0002\016\004\b\000L\018m\000\016\026\000\000\017@\003!\000@\128\004\193\"\208\001\001\160\000\001\020\0002\016\004\b\000L\018-\000\016\026\000\000\016@\016\000\000\000\000\016\000\004\000\000\000\000\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\003)\000P\208\004\193&\176\001\001\128\000\001\004\0002\144\005\t\000L\018k\000\016\024\000\000\016@\003)\000P\144\004\193\"\176\001\001\128\000\001\004\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\0002\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\b\000\000\000\000\004\000\000\000\016\000L\017\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000\128\000\000\000\000\000\000\000\001\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\131\161\136G\224,\229\"\211\227!\176@\025,\176\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\016\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\0002\144\005\t\001L\018+\000\016\024\000\000P@#a\000E\130\141\241#\208\004\015\128\000\001\142\0002\016\004\012\000L\018m\000\016\026\000\000\016@\003!\000@\128\004\193&\208\001\001\160\000\001\004\0002\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\001!\000D@\128\193'\144\000\001\128\000\001\140\000\018\016\004@\b\012\018y\000\000\024\000\000\024\192\001!\000D\000\128\193#\144\000\001\128\000\001\140\012IK\184>\131\225a\192\255\182\007}\183\231\015\001!\000D\000\128\193#\144\000\001\128\000\001\140\012[\219\189\127\139\237s\251\255\182\031}\183\255\223\000\000\000\000\000\000\128\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224#a\000E\130\141\241#\208\004\015\128\000\001\142\012[\219\189\127\139\237s\251\255\182\031}\183\255\207\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\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!\000D\000\128\193#\144\000\001\128\000\001\140\012[\219\189\127\139\237s\251\255\182\031}\183\255\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\000\000\000\000\001\000\000\000\000\000\192\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\012[\219\189\127\139\237s\251\255\182\031}\183\255\207\196\148\187\131\232>\022\028\015\251`w\219~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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\215?\191\251a\247\219\127\252\252IK\184>\131\225a\192\255\182\007}\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\231\245\187\199\234\191\247?\223\253o\247\139\127\254\247\223d@\130\2545\000\004\193\193\2388\176(4#a\000E\130\141\241#\208\004\015\128\000\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\0026\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2402\016\004\b\000L\018m\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\128\000\001\004\0002\144\005\t\000L\018k\000\016\025\000\006\209P\131\161\136G\224,\229\"\211\227!\176@\025,\176\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\0002\144\005\t\000L\018+\000\016\025\000\002P@\003!\000@\128\004\193\"\144\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\025\000\000\000\000\004\000\000\000\016\000\000\000\b0\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\b\000\001\144\000\000\000\000@\000\000\001\000\002\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b\000\001\144\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\0026\016\004X(\223\018=\000@\248\000\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\0002\144\005\t\000L\018+\000\016\025\000\002P@\000\000\000\000\000\000\000\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\016\000\001\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\b\000\000\128\000\000\000\000@\000\000\000\000\004\193\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\131\000\000p\016\000\197\194\000\001\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\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\b8\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\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\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\016\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\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\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\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\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\001\000\004\193\016\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\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\004\000\000\000\016\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b2\016\004\b\000L\018-\000\016\026\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\001\000\004\129\016\131!\000@\128\004\193\"\208\001\001\160\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\004\000\000\000\016\000H\017\b2\016\004\b\000L\018-\000\016\026\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\001\000\004\129\016\128\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\129\016\003!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\132\128\"\128\b \018\024\000\025\000f\000\002\000HH\002(\000\130!!\128\193\144\006`\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\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\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#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\b\016>\000\192@@>\002\001\000\005\130\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\000P\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\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\128\000\155\003\224\012\004\004\003\224 \016\000X`:6\016\180X(\223\018=\000@\248\000\000\028\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\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\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\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\001!\000D\000\128\193#\144\000\001\128\000\001\140\012[\219\189\127\139\237s\251\255\182\031}\183\255\223\000\000\000\000\000\000\128\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\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\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\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\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\128\000\145\003\224\012\004\004\003\224 \016\000X 0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\192\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\128\000\129\003\224\012\004\004\003\224 \016\000X <[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\000\000\000\000\000\000\000\000\000\000\000\000P\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\252[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\197\189\187\215\248\190\215?\191\251a\247\219\127\253\252[\219\189\127\139\237s\251\255\150\031x\183\255\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\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@\248\000\000\024\224\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#a\000E\130\141\241#\208\004\015\128\000\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\001\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#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\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\131\161\136G\224,\229\"\211\227!\176@\025,\176\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\0002\144\005\t\001L\018+\000\016\024\000\000P@\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\016\000\000\000\001\004\000\000\000\016\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000P\144\020\193\"\176\001\001\128\000\005\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\003)\000P\144\020\193\"\176\001\001\128\000\005\004\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\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\001\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\012IK\184>\131\225a\192\255\150\007x\183\231\015\003!\000@\128\004\193\"\208\001\001\160\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#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\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\001\000\004\129\016#a\000E\130\141\241#\208\004\015\128\000\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\b\000\000\000\000\000\1306\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016\004\b\000L\018-\000\016\024\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\129!\bD\000\128\193#\144\000\001\128\000\001\140\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#a\000E\130\141\241#\208\004\015\128\000\001\206\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\0026\016$X(\223\018=\000@\248\000\000\024\224\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\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000D\000\128\193#\144\000\001\128\000\001\140\004\000\000\000\000\000\000\000\000\0000\000\005\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\128\000\017\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\017\000\000\000\000\000\000\000\000\016\000\000\000\b\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\129\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\b\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\003\000\000P\000\000\000\016\000\000\000\000\012\0028\000\000\000\000\000\000\000\192\000\017\000\000\000\000\000\000\003\000\016P$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\131\232>\022\028\015\251`w\219~p\240\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\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\b\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\128\000\145\003\224\012\004\004\003\224`\016\000X 8\000\001\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\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\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\002\000@\000\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\128\004\000\b\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\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\003\000\000\000\000\000\000\004\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\128\000\000\000\000\016\000\004\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\025\000f\000\002\000@\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000@\000\000\000\000\016\000\004\000\000\000\016\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\025\000f\000\002\000@\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000@\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000\b\000`\000\000\b\000\000\000\000\001 \000\000\000\000\128\002\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\000\000\000\000\000\000\000\b\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\004\000\b\000\000\000\004\000\0000\000\006\000\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\001\016\000\000\000\000@\000\002\000\000\000\000\016\000\000\017\000\000\000\000\004\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\001\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\017\000\000\000\000\004\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\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\128\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\006\000\000\012\\ \000\016\000\000\000\000\000\133\128\162\128\b0R\028\000\025\000f\001\002\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\128\162\128\b R\028\000\025\000f\001\002\016@0\000\006\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\006\000\000\012\\ \000\016\000\000\000\000\000\133\128\"\128\b R\028\000\025\000f\001\002\016HX\n(\000\131\005!\192\001\144\006`\016!\004\000\000\000\000\000\000\000\004\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\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\0002\016D\b\000L\018m\000\016\024\000\000\016@\003!\004@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000@\128\004\193\"\208\001\001\128\000\001\004\bH\002(\000\130\001!\128\001\144\006`\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\000\000\000\000\000\000\000\000\000\000\000\000\000\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\148\187\131\232>\022\028\015\249`w\139~p\244\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000@\128\004\193\"\208\001\001\160\000\001\020\012IK\184>\131\225a\192\255\150\007x\183\231\015\128\000\136\003\224\012\004\004\003\224 \016\000| 0\000\000\000\000\000\000\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\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\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\b\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\128\000\001\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\016\004\004\000\002\012\016\000\000\001\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\132\128\"\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\002\000@\000\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\004\000@\000\000\004\000\000\000\000\000\000\000\000\016\000\000\004\000\004\000@\000\000\000\000\000\000\000\001\000\000\000\000\000@\004\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000v\000\002\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128\"\128\b0\018\028\000\017\000f\000\002\000\bH\002(\000\130\001!\128\001\016\006`\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\003\000\004\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\128\000\000\000\000\016\000\004\000\bH\002(\000\130\001!\128\001\016\006`\000 \004\132\128\"\128\b \018\016\000\017\000f\000\002\000@0\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\000\000\000\000\b\000\000\000\000\001\000\000@\000\132\128\"\128\b \018\024\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\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\128\000\000\000\000\016\000\004\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\0002\016\004\b\000L\018-\000\016\026\000\000\016@\016\000\002\000\000\000\000\004\000\000\000\000\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\000\016 \004\004\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\192\004\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\192\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\000\000\000\000\000@\000\000\001\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\018(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\004\000\b\000`\000\000\b\000\000\000\000\001 \000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000\b\000 \000\000\b\000\000\000\000\132\128\"\128\012 \018\028\000\017\000v\000\006\000\000\018\000\000\000\000\b\000 \000\000\b\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\b\000\bH\002(\000\130\001!\192\001\016\006a\000!\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\000\000\000\000\128\000\132\128\"\128\b \018\028\000\017\000f\000\002\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000 \000\132\128\"\128\b \018\024\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\128\"\240\024 \199\210\000\017\000`\000\002\000\bH\002(\000\130\000!\000\001\000\006`\000 \000\001\000\000\000@\000\000\004\000\000\000\000\000\000\b\000\016\000\000\004\000\000\000@\000\000\000\000\000\000\000\001\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \130\024\000\016\000f\016\002\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\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \130\024\000\016\000f\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\004\000@\000\000\004\000\000\000\000\000\000\000\0000\000@\000\000\000\000@\000\000\000\000\000\000\000\003\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\001@\000\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\000\000\000\000\132\128\"\128\b \130\024\000\016\000f\016\002\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\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\012H\002(\000\131\000!\192\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\000\002\000@0\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\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\012H\002(\000\131\000!\192\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\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\b\000\000\000\000\001\000\000@\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\128\001\000\006a\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\001\000\000\000\000\000\196\128\"\128\b0\002\028\000\016\000f\000\002\000\bH\002(\000\130\000!\128\001\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\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\004\004\004\002\012\016@\000\001\000\000\000\000\000\001\000@@\000 \193\004\000\000\016\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128\"\128\b0\002\028\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000@\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000\b\000`\000\000\b\000\000\000\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\194\000!\192\001\000\006`\000`\000\b\128\000\000@\000@\006\000\000\000\000\000\000\000\000\128\000\000\004\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\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\004\000 \000\000\000\000\000\000\000\002\000\000 \128\004\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\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\016\000\004\000 \005\016 \000\000\000\000\000\000\000\132\000\000\128\000\002\130\020\004\000\000\002\001\000\000\b@\000\b\000\000(!\000@\000\000 \016\000\000\003\000\000p\016\000\197\194\000\001\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\b@\000\b\000\000 !\000@\000\000 \016\000\000\b\000\000\000\000@@\004\000\000\000\000\000\000\000\000\128\000\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\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\128\000\004\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\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\128\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\004\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\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\016\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\132\000\000\128\000\002\002\028\012\000\000\018\001\000\000\b@\000\b\000\000 !\128@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\192\192\000\001 \016\000\000\001\000\000@\002\000Q\006\000\000\000\000\000\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\000\000\000\000\b\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\001\000\000\000\000\000\000\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\000\000\000\000\000\000\b\000\000\016\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\004\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000@\000\000\000\000\004\000\000\000\000\002\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\bH\002\168\000\130!!\192A\016\007`\016 \004\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\b\000\000\016\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\132\128*\128\b\"\018\028\004\017\000v\001\002\000H@\000\b\000\000 !\192@\000\000 \016\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\192\192\000\000 \016\000\000\132\000\000\128\000\002\002\024\004\000\000\002\001\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\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\b@\000\b\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\132\000\000\128\000\002\002\016\004\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\028\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\000 \004\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\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\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\132\128\"\128\b \018\028\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\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\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\007\001 \r\\ \000\016\000\000\000\000\000\133\128\170\128\b0B\028\000\017\000v\000\006\000@0\000\006\000\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\007\001 \r\\ \000\016\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\020\000\000\000 \000\000\000\000@\000\000\000\000\004\001\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\007\001 \r\\ \000\016\000\000\000\000\000\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000p\018\000\213\194\000\001\000\000\000\000\000\bX\n\168\000\131\004!\192\001\016\007`\000 \004\133\128\170\128\b0B\028\000\017\000v\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128*\128\b \002\028\000\016\000v\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\bH\002(\000\130\000!\128\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\000\002\000@\128\000\000\000\000\004\000`\000\000\000\000\000\000\000\b\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\000\000\000\000\000\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\018\000\213\194\000\001\000\000\000\000\000\bH\002(\000\130\000!\128\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\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\132\128\"\128\b \002\016\000\016\000f\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\bH\002(\000\130\000!\128\001\000\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\000\001\000\006`\000 \004\002\000\000 \128\004\192\004\000\000\000\000\000\000\000\000 \000\002\b\000L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\007`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\006`\016 \004\132\128\"\128\b \018\016\000\017\000f\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\bH\002(\000\130\000!\000\001\000\006`\000 \004\002\000\000 \128\004\192\004\000\000\000\000\000\000\000\000 \000\002\b\000L\000\000\000\000\000\000\000\000\000\000\000\000\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\003 \000x\016\000\197\194\128\001\000\128 \000\016\0000\000'\001\000\012\\ \000\016\000\000\000\001@\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\133\160\"\128\b \146\026\000\017\000\230\001\002\000HH\002(\000\194\001!\192\001\016\006`\016a\004\132\128\"\128\b \018\028\000\017\000f\001\002\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\001\002\016@\018\000\000\000\000\b\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\132\128\"\128\b \002\024\000\016\000f\001\002\000HH\002(\000\130\000!\000\001\000\006`\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\bH\002(\000\130\001!\192\001\016\007`\016 \004\001 \000\b\000\000\128\002\128\000\000\128 \000\016\000\018\000\000\000\000\b\000(\000\000\b\002\000\001\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\bH\002(\000\194\001!\192\001\016\006`\016a\004\132\128\"\128\b \018\028\000\017\000f\001\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000\000\000\000\000\000\136\000\000\004\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\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\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\132\000\000\128\000\002\130\020\012\000\000\002\001\000\000\b@\000\b\000\000(!\000\192\000\000 \016\000\000\132\000\000\128\000\002\002\016\012\000\000\002\001\000\000\000\128\000\000\000\004\004\000@\000\000\000\000\000\000\128\000\000\000\000\000@@\004\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\001\000\002@\000#a\000E\130\141\241#\208\004\015\128\000\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\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\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\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\192\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\001\000\002@\000#a\000E\130\141\241#\208\004\015\128\000\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\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\128\000\004\000@\000\000\000\000\000\000\128\000\000\000\b\000\000@\004\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\004\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\0008\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\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\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\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\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\132\000\000\128\000\002\002\024\012\000\000\002\001\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\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\128\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\004\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\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\004\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\0008\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\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\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\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\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#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\132\000\000\128\000\002\002\024\012\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000@\002\000\209\006\000\000\004\000\000\000\b\000\016\000\004\000 \r\016`\000\000@\000\000\000\000\001\000\000@\002\000\209\002\000\000\004\000\000\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\003!\004@\200\004\193&\208\001\001\128\000\001\004\007\223d@\130\2545\000\004\193\193\2388\176(4\003!\004@\128\004\193&\208\001\001\128\000\001\004\0002\016D\b\000L\018-\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\128\000\128\000\000\000\000\004\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\001\000\000\000\000\000\000\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\000\000\000\000\000\000\b\000\000\016\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\004\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\003)\000P\144\004\193&\176\001\001\128\000\001\004\0002\144\005\t\000L\018+\000\016\024\000\000\016@\003)\000P\144\020\193\"\176\001\001\128\000\001\004\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000@\016\000\004\000 \r\016 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bZ\146\173A\138-3\251\193\016\030`\016x\212\133\169*\212\024\162\211?\188\017\001\230\001\007\141@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128*\128\b\"\018\028\012\017\000f\001\006\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\bH\002\168\000\130!!\192\193\016\006`\016`\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\132\128*\128\b\"\018\028\012\017\000f\001\006\001@\016\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\016\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\132\128*\128\b\"\018\028\012\017\000f\001\006\001@2\016D\b\000L\018-\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\128\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\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\003\000\000p\018\000\213\194\000\001\000\000\000\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\132\000\000\128\000\002\002\028\012\000\000\002\001\000\001\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\b@\000\b\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\132\000\000\128\000\002\002\028\012\000\000\002\001\000\001\b@\000\b\000\000 !\128\192\000\000 \016\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\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\128\192\000\000 \016\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\132\000\000\128\000\002\002\024\012\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\b@\000\b\000\000 !\000\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000 \004\003\000\000p\018\000\213\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000@\002\000\209\002\000\000\004\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000 \004\003)\000P\144\004\193\"\176\001\001\144\000\005\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\000 \004\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\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\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\bH\002(\000\130\001!\128\001\016\006`\000 \004\132\128\"\128\b \018\016\000\017\000f\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\132\128\"\128\b \018\016\000\016\000f\000\002\000\0002\016D\012\000L\018m\000\016\024\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\132\128\"\128\b \018\016\000\017\000f\000\002\000HH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\000\001\016\006`\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\132\128\"\128\b \018\024\000\016\000f\000\002\000\bH\002(\000\130\001!\000\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\016\000\025\000f\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\bH\002(\000\130\001!\128\001\000\006`\000 \000\132\128\"\128\b \018\016\000\016\000f\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\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\196\128*\128\b0\146\028\000\017\000v\000\"\000L\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\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\000L\017\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\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\b@\000\b\000\000 !\000\192\000\000 \016\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\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\000\000\000\000\000\000\000\000\000\000\000\129\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\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\000\000\000\000\b\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\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\b\000\000\128\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\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\b2\016\004\b\000L\018-\000\016\026\000\000\017@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\184>\131\225a\192\255\150\007x\183\231\015\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\001 \000\b\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002(\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\130\001!\192\001\016\006`\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\000\000\000\000\000\000\132\128\"\130\b \018\024\000\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\001\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\018\000\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\016\bH\002(\000\130\001!\128\001\016\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\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\002\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000 \000\000\000\000\0000\000\006\000\000\012\\`\000\018\000\002\000\000\000\003\000\000`\000\000\197\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\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000\000\000\004\000\000\000\018\000\000\000\000\000\003\000\000`\000\000\197\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\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\001\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\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\016\000\000\000\000\004\000\000\000\016\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\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\128\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\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\004\004\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\bH\002(\000\130\001!\192\001\016\006`\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\003 \000x\016\000\197\194\128\001\000\128 \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \002\024\000\016\000f\001\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\018\000\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\016\bH\002(\000\130\000!\128\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\bH\002( \130\000!\128\001\000\007`\017 \004\003 \000x\016\000\197\194\128\001\000\128 \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \002\024\000\016\000f\001\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\018\000\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\016\bH\002(\000\130\000!\128\001\000\006`\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\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\132\128\"\128\b \018\028\000\017\000f\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \128\b \002\016\000\016\000d\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\001 \000\000\000\000\192\002\000\000\000\128\000\000\000\b\000\b\128~\002\194@\000>\"\001\004\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\128\000\000\000\000\000\016\000\000\000\016\000\000\000\000\012\000\000\000\000\000\000\000\000\000\128\000\128\007\224,$\000\003\226 \016@\024(\176\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\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\128\002\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\004\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\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#a\000E\130\141\241#\208\004\015\128\000\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\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\128\000\000\000\000\004\016\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\004\016\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\004\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\001\160\000\001\004\000\000\000\000\000\000\000\000@\000\000\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\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\012\000\000\000\000\000\000\000\000\000'\225 \197\138\173\2433\208\021\015\228\000\003\142\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\005\161 \128\b \210\016\016\017\000\228\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\004\128 \128\b \018\016\000\017\000d\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\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\000H\002\b\000\130\001!\000\001\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\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'\225 \197\138\173\2433\208\021\015\228\000\003\142\002~\018\012X\170\2233=\001P\254@\0008\224\004\128 \128\b \018\016\000\017\000d\000\002\000\000H\002\b\000\130\001!\000\001\016\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\000\000\000\000\000\000\000\004\128 \128\b \018\024\000\017\000d\000\002\000\000H\002\b\000\130\001!\000\001\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002\b\000\130\001!\128\001\016\006@\000 \000\004\128 \128\b \018\016\000\017\000d\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") and start = - 7 + 13 and action = - ((16, "C\134O\006B\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\240B\154\000\000\000\000\020\004B\154C\134\025\128\005\162\003$YJ\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\002\170\005B\000|\000\000\001r\000\b\000\000\001j\001|\000\252\000\000\006.\002\b\005\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\244\000\000\000\000\000\000\001vd\250\000\000\000\000\0032\000\000\000\000\000\000\003J\003B\000\000\000\000m\128N\200\020\004A\028Z\132\020\004R\154O\006\020\004Lj\000\000\021P\000\000\021P\000\007\000\000\0032\000\000\000\000\000\000\003\014\000\000\021P\000\000\004&^\208Y\002b\136\000\000\128\252wd\000\000J\136D8\000\000I*\027:M \0032m\218B\154C\134\000\000\000\000O\006\020\004R\188\021P\005|t>\000\000|\194B\154C\134O\006\020\004\000\000\000\000\000\000\0164\020\184\000V\007\174\000\000\003\180\bR\000\000\000\000\000\000\020\004\000\000@\190\000\000v\254C\134\000\000\000\000NF\020\004BjT\208\000\000\001\022\000\000\000\000\002\n\000\000\000\000F\b\001\022\028\000\003\200\000&\000\000\000\000\000\017\000\000A\028\004\228\005&\019\168\020\180\020\004C\134C\134EjEj\019\168\020\180\020\180\020\004\000\000\000\000\000\000O\006\020\004\000\000\000\244\000\000T\208qjqj\000\000\tL\000\000\000}\n@\000\000\005\144\000\000\000\000 \140d\250bD\000\000d\250bD\000\000d\250d\250\007\174\000\000d\250\0032\000\000\000\000T:d\250R\172D8\006\158\001\016\000\000\001\146\000\000\005j\000\000\n\138\000\000\000\000LZ\007\174\000\000\000\000D8\007 d\250\000\000MLD8N>\000\000\000\000\000\000\006\238\000\000d\250\000\000\000\252p\200\000\000d\250\005\192d\250\000\000\023|\007H\0032\000\000\000\000\024p\000\000\007\168\000\000V\\\n\176\000\000\007Td\250\011x\000\000\011\138\000\000\004F\000\000\000\000\005\152\000\000\000\000\000\000\026\232\027\220T\208N\198\020\004T\208\000\000\002\234\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000KnEH\000\000\000\000\000\000\001\236 \224qj\000\000\000\000rv\020\004T\208\000\000\000\000P(T\208Q\148w\144\000\000W\216\000\000T\208\000\000\000\000U\184\000\000\000\000\b\026\000\000\023<\000\000\000\000w\246\000\000k:xp\000\000\128F\003$\000\000\000\000v~\000\000\011\140\000\000\000\000\023\002q\254\000\000\000\000\000\000@\000\019\168\025\248\021\142\000\000\000\000\000\000\000\000\000\028\000\000\000\000W\146\006\244\b\b\002\198d\250\000\216\bx\000\000\000\000\b\222\b\b\005\172\000\000O\006G\176Ej\019\168\020\180\005\162\003\134\000&\000\000\b\030A\028A\028\005\162\003\134\003\134A\028\000\000g \001\224\021P\tL\007c\218d\250\004\174d\250dp\000\000\000\000\021J\001\016[\212\bR\001\016\\\142\000\000g\182\001\224\000\000A\028hL\000\000\0078\011\022]H\000\000\000\000\000\000\000\000\000\000\0240\000\000\000\000\027\134\000\000\t\210\020\180\000\000Y\238Bb\000\000\021\196\000\000\000\000A\028\024\170\000\000\000\000\000\000\000\000X\030\000\000\003\168\000\000I\168\006B\0224\000\000\021\218M\024O\006\020\004H\194N\198\020\004\0164\0164\000\000\000\000\000\000\000\000\001\232\020ZA\168\000\000O\188PrEj\019\168\020\180\006\150A\"\000\000\029\028\000\000Q(Q\222x\214\022dd\250\006B\000\000O\006\020\004\000\000rv\020\004qjT\208@\160\000\000O\006\020\004t\168\000b\000\000T\208@\000d\250\004\168\005\172\t\014\000\000\000\000\000\000F\b\005\b\005\b\000\000\t n^\000\000rv\020\004T\208\023\002\000\000N\198\020\004\0164\021\218\0164\002\220\003\158\000\000\000\000\0164\t\030\000\000\t\138\000\000\0164\003\208\t\222\000\000!\212\000\000\002\228\000\000\000\000\025\170\000\000\017(\022\206\000\000\000\000\000\000\005~\000\000\000\000\026\158\000\000\027\146\000\000\028\134\000\000\018\028\023\194\000\000\000\000\000\000B\154\000\000\000\000\000\000\000\000\029z\000\000\030n\000\000\031b\000\000 V\000\000!J\000\000\">\000\000#2\000\000$&\000\000%\026\000\000&\014\000\000'\002\000\000'\246\000\000(\234\000\000)\222\000\000*\210\000\000+\198\000\000,\186\000\000-\174\000\000.\162\000\000/\150\020\004T\208V\230F\240\005\b\nHh\196T\208\000\000\000\000\000\000d\250\000\000\026\132j\224\000\000\024\236d\250\027x\n\018\000\000\000\000\000\000\000\000h\196\000\000\000\000\002f\011\026\000\000B\146\000\000\000\000\131\230\000\000\006\180\000\000\000\000M \005\b\n\216d\250\006\162\000\000\000\000\0046\0032\000\000d\250\0076\000\000\000\000\011`\000\000\000\000\000\000\025@d\250\007\138\000\000\000\000\027\198\000\000\000\000yP\000\000\028\028y\182\000\000\028\186z0\000\000\029\016\004l\000\000\000\000\000\000\000\000\029\174T\208\030\004n\216n\216\000\000\000\000\000\0000\138\000\000\012<\000\000\000\000\000\000i*\000\000\000\000\000}\bb\000\000\t\002\000\000\000\000X\196H\194\000\000\000\000\012\128\000\000\000\000\000\000\006\132\000\000\000\000\000\000\0164\004\196\tV\000\000\t\246\000\000\005\184\000\0001~\000\000\012\134\000\000\006\172\000\0002r\000\000\012`\007\160\000\0003fd\246\000\000\"\200\000\000\n\234\b\148\000\0004Z\000\000\012\152\t\136\000\0005N\000\000i\172\n|\000\0006B\t\198\nJ\000\000\011<\011p\000\00076\000\000\r0\012d\000\0008*\000\000\t`\rX\000\0009\030\014L\000\000:\018\015@\019\016\000\000\000\000\000\000\011\222\000\000\000\000\rN\000\000\000\000\012\180\000\000\bV\000\000\000\000\000\000\012>\000\000\012f\000\000\000\000G\216\005\b\rZn^D8\002\234\000\000\000\000n^\000\000\000\000\000\000n^\000\000\r\168\000\000\000\000\000\000\000\000\000\000\000\000;\006T\208\000\000\000\000\014&\000\000;\250\000\000<\238\000\000\030\162\000\000\000\000\n6\000\000\000\000T\208\000\000\000\000zF\011\238\000\000\000\000I\168\000\000\011\208\000\000\000\000St\000\000\r`\000\000\000\000\0022\011v\000\000\000\000\021\218\025.\tL\000\000\031\152\000\000\031\172\021\184\022\234\000\000\000\000\012\210\000\000\000\000\001\230\021FU0\000\000\024\182\000\000\b\226\000\000\000\000\rt\000\000\000\000]\236\005\188\0022\000\000\000\000\011\186\000\000\000\000\014$\000\000\000\000\000\000\019\168\020\180\004\174\000\000\000\000\021l\003\200\000&\004\\\020\180u\nA\028\020\144\020\180u\136\r\226\000\000\000\000\004\\\000\000E$\020\004\000\142\000\000\007\128\014T\000\000\014\158\000\000\000\000\003\186D8\006\168\000\000\014\148\014*M \n^d\250\0190\005\216\rx\002\252\000\000\029\012\015F\000\000\006\168\000\000\000\000\015hD8^\132\000\000e\142D8\015\214_\174\000\000\000\000Cj\000\000\029\232\000\000C\182\000\000\025$\000\000A\028\030\016\000\000}\156\000\000\019\168\020\180}\156\000\000\025\162\020\184\000V\0032\127PA\028z\212n\216\000\000\003\200\002\212\000&\004\\n\216\129~\003\200\000&\004\\n\216\129~\000\000\000\000\004\\n\216\000\000B\154C\134T\208F4\000\000\000\000B\154C\134Ej\019\168\020\180}\156\000\000\025\128\005\162\003$\014\232d\250\t\030\015\184\127\200\000\000n\216\000\000E$\020\004\000\142s\226\007:\011\b\015\176{.\t\248\015\014\020\004n\216\000\000\020\004n\216\000\000j\224\127B\024\172\b\138\000V\001\016o\162\000\000\000V\001\016o\162\000\000\025\162\003\200\007\152\022z\001T\000\000o\162\000\000\000&\015\016A\028}z\130\192\003\200\000&\015\018A\028}z\130\192\000\000\000\000\005P\000\000h\196\000\000A\028\128\020h\196\000\000\005P\000\000N\200\020\004A\028}z\000\000E$\020\004\000\142oV\020\184\020\184\019\174\b>\000\000\012\172\021P\011V\000\000\015\168\015Z\024`\020\004Fld\250\011T\000\000VP\003v\006p\012\186\000\000\r\244\000\000\015\218\015dd\250D|\000\000\020\004\t\132\011\216\000\000\r\246\000\000\015\222\015jM \011\232d\250StD|\000\000]\228\019\206\024`\000\000\016\002\tF\000V\000\000\r2\024`d\250\012>\014\n\0128\014\016\000\000\000\000d\250\b\194\003\254\000\000\000\000kT\000\000\000\000\014&\024`k\210D|\000\000\020\004d\250\012\214d\250S\252D|\000\000\011x\000\000\000\000D|\000\000\000\000VP\000\000n\216\129\130\019\174\b>\012\172\015\242\015\164\024`n\216\129\130\000\000\000\000\019\174\b>\012\172\016\000\015\142N\018f\012D8\016\022N\018d\250\003\254\016(N\018D8\016*N\018\r\002\0144lPl\206\000\000~\028\000\000\000\000n\216\130\206\019\174\b>\012\172\016 \015\172N\018n\216\130\206\000\000\000\000\000\000\127B\000\000\000\000\000\000\000\000\000\000\000\000h\196\000\000\129\252\020\004\021P\0160t>\000\000|\194\129\252\000\000\000\000\131N\020\004\021P\0166\015\198Y\002m\128\006\168\016r\000\000\000\000mFoV\020\004\000\000{\166\000\142\000\000\000\000o\162\131N\000\000\000\000\000\000v\006EZO\200\006\168\016t\000\000\000\000\000\000oV\020\004\000\000\006\168\016\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003v\020\184\019\174\b>\012\172\016lo\198B\178\020\004BjG\130\026\158\002\252\006\168\016r\003\198\000\000\000\000\016$\000\000\000\000F\224\000\000\n$\014H\000\000\014\146\000\000\016z\016\004d\250Wn\016~\004<\000\000\000\000\0166\000\000\000\000\029b\bf\r\162\000\000\016\150ph~J\005\b\0168d\250\012\238\000\000\000\000\016N\000\000\000\000\000\000F\224\000\000\nx\014\132\000\000\014\230\000\000\016\190\016HM \000\000\016\206q\n\132*\005\b\016ld\250\r<\000\000\000\000\016~\000\000\000\000\000\000\020\004\000\000F\224\000\000\020&\019\206B\178B\178r\240B\154\020\004}:T\208\007V\000\000\n:\000V\000\000\014\132B\178d\250\r>\007\174\000\000\020\004U\184o\198B\178\011\226B\178\000\000DfEH\000\000`B\000\000\000\000`\218\000\000\000\000ar\000\000\014\160B\178b\n}:T\208\007V\000\000\000\"\000\000\000\000N\018\014X\000\000\000\000L\028\016\214\000\000F\224\000\000B\178L\028F\224\000\000\020\004d\250F\224\000\000\014\148\000\000\000\000F\224\000\000\000\000G\130\000\000~vN\018\016\136B\178~\246o\198\000\000n\216\130t\019\174\b>\012\172\016\230o\198n\216\130t\000\000\000\000\000\000\131\\O\006\000\000\000\000\000\000\000\000\000\000\000\000\128\140n\216\000\000\129\252\000\000\000\000\000\000\000\000h\196\131\\\000\000\017\030\000\000\000\000\128\140\017&\000\000h\196\131\\\000\000\000\000\014\244\000\000\000\000f\138\026@\000\000\000\000@\160\000\000d\250\012H\000\000G\130\015H\000\000\000\000\000\000\014\172\000\000\000\000\000\000Ej\019\168\020\180\004\174\000\000Fz\000\000\030\220\000\000\001\180\000\000\000\000\0170\000\000\017Zv~\000\000?\202\017B\000\000\000\000\0178\0268\022h\000\142sj\007:\020\004\000\000n\216\000\000\000\000\000\000\000\000\000\000\000\000\000\000s|\007:\020\004\000\000\014\254t>\000\000|\194\000\000\017:\0268\022hn\216\000\000\017J\000\000\006\162\015D\020\004K\150\000\000\000\000\028F\132\\\000\000\000\000\016\226\000\000\0176d\250\000\000\r\144\t\150\007\174\000\000\000\000d\250\t\b\n\210\000\000d\250\n\240\006\168\017^\000\000\000\000{\170\000\000\000\000Y\002\000\000o\162\000\000\017\\\0268\023\\h\196\000\000\000\000\000\000\000\000\015(t>Y\002\000\000o\162\000\000\017^\0268\023\\h\196\000\000\015p\000\000\000\000\031\004\000\000n\216\000\000\017z\000\000\000\000\016\246\000\000\017\000\000\000\017\020\000\000\000\000K \017\022\000\000\000\000d\250\000\000\014\156\000\000\000\000\017\024\000\000\000\000T\208\031\150\000\000\000\000H\194\0032|h\000\000\000\000\000\000\000\000\000\000rh\023l\000\000\000\000\017\172\000\000JV\000\000\015\128\017\184\000\000\017\196\000\000I\168I\168\132>\132>\000\000\000\000nz\132>\000\000\000\000\000\000nz\132>\0178\000\000\017>\000\000"), (16, "\b\193\b\193\000\006\002.\006\005\b\193\002\154\002\158\b\193\002\202\002\214\b\193\003r\b\193\006n\002\218\b\193\023\138\b\193\b\193\b\193\0022\b\193\b\193\006\005\003f\003j\002\222\b\193\003\030\003\"\t\190\b\193\011\238\b\193\003\234\003&\023\142\002\226\006\202\b\193\b\193\003\178\003\182\b\193\003\186\003\014\003\198\003\206\006\170\004-\b\193\b\193\002\146\001v\b\182\003\026\b\193\b\193\b\193\007\234\007\238\007\250\b\014\001*\005R\b\193\b\193\b\193\b\193\b\193\b\193\b\193\b\193\b\193\b\130\000\238\b\193\015N\b\193\b\193\002b\b\142\b\166\b\250\005^\005b\b\193\b\193\b\193\004-\b\193\b\193\b\193\b\193\b\186\b\214\r\186\b\193\003v\b\193\b\193\000\238\b\193\b\193\b\193\b\193\b\193\b\193\005f\b\002\b\193\b\193\b\193\b\026\004.\t\014\015R\b\193\b\193\b\193\b\193\012e\012e\023\146\006r\006\r\012e\003}\012e\012e\015^\012e\012e\012e\012e\004R\012e\012e\0069\012e\012e\012e\001\206\012e\012e\006\r\012e\004-\012e\012e\012e\012e\012e\012e\012e\012e\015f\001j\0069\012e\004\190\012e\012e\012e\012e\012e\000\238\012e\012e\017\198\012e\003\202\012e\012e\012e\001\134\001\206\012e\012e\012e\012e\012e\012e\012e\000\238\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\003}\012e\012e\001f\012e\012e\003U\003>\001r\004-\012e\012e\012e\012e\012e\001\130\012e\012e\012e\012e\012e\0252\012e\012e\004Z\012e\012e\003B\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\0256\004-\012e\012e\012e\012e\001\153\001\153\001\153\004N\006\246\001\153\001\182\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\186\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\0072\b\157\001\153\001\146\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\198\001\153\001\153\001\153\004^\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\006E\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\n\154\001\153\001\153\n\166\003J\006E\007\242\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\014\150\b2\001\153\005\146\001\153\001\153\003N\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\b\157\001\153\001\153\001\153\001\153\001\153\t\245\t\245\003f\003j\tb\t\245\003J\t\245\t\245\003y\t\245\t\245\t\245\t\245\001\206\t\245\t\245\016\170\t\245\t\245\t\245\001b\t\245\t\245\tf\t\245\003N\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\001z\006\026\001\138\t\245\004-\t\245\t\245\t\245\t\245\t\245\002F\t\245\t\245\r\138\t\245\001\214\t\245\t\245\t\245\002z\004-\t\245\t\245\t\245\t\245\t\245\t\245\t\245\004-\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\000\238\t\245\t\245\003y\t\245\t\245\004-\001\002\001\190\004v\t\245\t\245\t\245\t\245\t\245\001\218\t\245\t\245\t\245\t\245\t&\006\134\tV\t\245\007\137\t\245\t\245\001\230\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\004-\t\245\t\245\t\245\t\245\t\245\003\153\003\153\004-\004-\006\230\003\153\002J\003\153\003\153\006\198\003\153\003\153\003\153\003\153\000\238\003\153\003\153\004-\003\153\003\153\003\153\t*\003\153\003\153\015n\003\153\007\174\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\r6\001\234\rB\003\153\000\238\003\153\003\153\003\153\003\153\003\153\bU\003\153\003\153\003!\003\153\001\206\003\153\003\153\003\153\007\230\000\238\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003!\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\011&\t\030\tN\011\150\003\153\003\153\005\"\000\238\002\246\021\194\003\153\003\153\003\153\003\153\003\153\002V\003\153\003\153\003\153\003\153\t&\015\206\tV\003\153\n\154\003\153\003\153\n\166\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\006\198\003\153\003\153\003\153\003\153\003\153\003\141\003\141\001\002\001\190\bU\003\141\003\237\003\141\003\141\025\026\003\141\003\141\003\141\003\141\b\137\003\141\003\141\005&\003\141\003\141\003\141\022\n\003\141\003\141\003~\003\141\011.\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\007\174\n\154\015\022\003\141\n\166\003\141\003\141\003\141\003\141\003\141\000\238\003\141\003\141\000\238\003\141\004\178\003\141\003\141\003\141\005\161\015\030\003\141\003\141\003\141\003\141\003\141\003\141\003\141\014\254\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\237\t\030\tN\007&\003\141\003\141\b\230\001f\003U\003\130\003\141\003\141\003\141\003\141\003\141\004b\003\141\003\141\003\141\003\141\t&\025\030\tV\003\141\001\206\003\141\003\141\003\246\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\006\198\003\141\003\141\003\141\003\141\003\141\tq\tq\b\153\003\250\006\021\tq\005.\tq\tq\005\161\tq\tq\tq\tq\006\181\tq\tq\002\182\tq\tq\tq\014\202\tq\tq\006\021\tq\004-\tq\tq\tq\tq\tq\tq\tq\tq\004-\004-\018\n\tq\004-\tq\tq\tq\tq\tq\t\138\tq\tq\000\238\tq\012N\tq\tq\tq\001\150\018\022\tq\tq\tq\tq\tq\tq\tq\000\238\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\000\238\tq\tq\001f\tq\tq\b\153\003U\006\166\004-\tq\tq\tq\tq\tq\nn\tq\tq\tq\tq\tq\018\162\tq\tq\004.\tq\tq\012&\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\007\242\004-\tq\tq\tq\tq\ti\ti\004\206\012*\n\254\ti\000\238\ti\ti\018\170\ti\ti\ti\ti\004-\ti\ti\005\137\ti\ti\ti\003q\ti\ti\011\002\ti\014\210\ti\ti\ti\ti\ti\ti\ti\ti\007\174\b~\015v\ti\004N\ti\ti\ti\ti\ti\005\129\ti\ti\000\238\ti\012f\ti\ti\ti\000\238\004\174\ti\ti\ti\ti\ti\ti\ti\000\238\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\004-\ti\ti\002\158\ti\ti\002\214\006~\006\150\011\026\ti\ti\ti\ti\ti\004f\ti\ti\ti\ti\ti\bV\ti\ti\004\138\ti\ti\004\222\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\004N\017V\ti\ti\ti\ti\ty\ty\003f\017\190\002n\ty\000\238\ty\ty\017Z\ty\ty\ty\ty\002\158\ty\ty\017\210\ty\ty\ty\002\194\ty\ty\004\178\ty\b\137\ty\ty\ty\ty\ty\ty\ty\ty\005b\0116\004E\ty\007\002\ty\ty\ty\ty\ty\007n\ty\ty\000\238\ty\012z\ty\ty\ty\002\238\007\n\ty\ty\ty\ty\ty\ty\ty\000\238\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\005\n\ty\ty\011Z\ty\ty\005\238\004E\018b\b\137\ty\ty\ty\ty\ty\015V\ty\ty\ty\ty\ty\002\250\ty\ty\006\130\ty\ty\rR\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\000\238\b\137\ty\ty\ty\ty\tY\tY\002\209\004-\012\153\tY\006\146\tY\tY\004-\tY\tY\tY\tY\002\254\tY\tY\012\153\tY\tY\tY\011\242\tY\tY\004-\tY\000\n\tY\tY\tY\tY\tY\tY\tY\tY\012\014\000\238\012\030\tY\014\174\tY\tY\tY\tY\tY\bY\tY\tY\006\210\tY\012\154\tY\tY\tY\002\209\011\250\tY\tY\tY\tY\tY\tY\tY\rV\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\011\254\tY\tY\bm\tY\tY\b\210\000\238\006\158\016\022\tY\tY\tY\tY\tY\b\242\tY\tY\tY\tY\tY\004-\tY\tY\002\158\tY\tY\012&\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\t:\000\238\tY\tY\tY\tY\ta\ta\018\206\r\002\bY\ta\000\238\ta\ta\014\178\ta\ta\ta\ta\001\206\ta\ta\003\226\ta\ta\ta\012>\ta\ta\018\214\ta\000\238\ta\ta\ta\ta\ta\ta\ta\ta\012V\017.\012n\ta\bm\ta\ta\ta\ta\ta\007\181\ta\ta\tB\ta\012\174\ta\ta\ta\002z\012F\ta\ta\ta\ta\ta\ta\ta\002\250\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\012J\ta\ta\007\162\ta\ta\019\022\021\226\006\198\026\"\ta\ta\ta\ta\ta\tR\ta\ta\ta\ta\ta\004-\ta\ta\002\250\ta\ta\017f\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\n\134\021\234\ta\ta\ta\ta\t\153\t\153\022n\005\129\012\206\t\153\003\234\t\153\t\153\011&\t\153\t\153\t\153\t\153\004b\t\153\t\153\003\238\t\153\t\153\t\153\012\210\t\153\t\153\022v\t\153\000\238\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\012\230\n\190\012\250\t\153\r\254\t\153\t\153\t\153\t\153\t\153\007\173\t\153\t\153\005\002\t\153\012\194\t\153\t\153\t\153\004j\tb\t\153\t\153\t\153\t\153\t\153\t\153\t\153\026:\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\012\150\t\153\t\153\bq\t\153\t\153\023\002\015\138\014\006\007r\t\153\t\153\t\153\t\153\t\153\003\018\t\153\t\153\t\153\t\153\t\153\011\250\t\153\t\153\n\226\t\153\t\153\000\238\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\012\218\000\238\t\153\t\153\t\153\t\153\t\137\t\137\001\218\014R\019\150\t\137\018\146\t\137\t\137\018r\t\137\t\137\t\137\t\137\006.\t\137\t\137\b\133\t\137\t\137\t\137\011\018\t\137\t\137\026>\t\137\005\018\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\005\026\0062\014\218\t\137\bq\t\137\t\137\t\137\t\137\t\137\000\238\t\137\t\137\014.\t\137\012\222\t\137\t\137\t\137\n\222\012F\t\137\t\137\t\137\t\137\t\137\t\137\t\137\014\026\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\r2\t\137\t\137\018\210\t\137\t\137\011B\014V\014\030\011&\t\137\t\137\t\137\t\137\t\137\002J\t\137\t\137\t\137\t\137\t\137\019\154\t\137\t\137\007\189\t\137\t\137\011\210\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\014\222\004\178\t\137\t\137\t\137\t\137\t\129\t\129\011\214\019.\004\178\t\129\024\226\t\129\t\129\0236\t\129\t\129\t\129\t\129\012\022\t\129\t\129\012^\t\129\t\129\t\129\012v\t\129\t\129\004N\t\129\011\210\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\018\238\012\026\0142\t\129\012b\t\129\t\129\t\129\t\129\t\129\000\238\t\129\t\129\012\170\t\129\012\242\t\129\t\129\t\129\nn\014\138\t\129\t\129\t\129\t\129\t\129\t\129\t\129\rJ\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\0196\t\129\t\129\014\142\t\129\t\129\rb\018\166\002\233\019B\t\129\t\129\t\129\t\129\t\129\005\145\t\129\t\129\t\129\t\129\t\129\018j\t\129\t\129\rj\t\129\t\129\012\022\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\000\238\012^\t\129\t\129\t\129\t\129\t\145\t\145\012\238\004N\014B\t\145\000\238\t\145\t\145\023\026\t\145\t\145\t\145\t\145\014\186\t\145\t\145\r>\t\145\t\145\t\145\r~\t\145\t\145\019\130\t\145\014F\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\015\154\022J\014\190\t\145\003e\t\145\t\145\t\145\t\145\t\145\000\238\t\145\t\145\026\030\t\145\r\006\t\145\t\145\t\145\020*\019\"\t\145\t\145\t\145\t\145\t\145\t\145\t\145\022*\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\022\170\t\145\t\145\007B\t\145\t\145\r\174\018\174\018\218\007\173\t\145\t\145\t\145\t\145\t\145\019B\t\145\t\145\t\145\t\145\t\145\001\206\t\145\t\145\004b\t\145\t\145\014\230\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\r\218\004b\t\145\t\145\t\145\t\145\t\225\t\225\014\234\005\141\007\185\t\225\023\154\t\225\t\225\026.\t\225\t\225\t\225\t\225\019\n\t\225\t\225\019:\t\225\t\225\t\225\0152\t\225\t\225\015Z\t\225\023\158\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\020.\023\218\021\230\t\225\021\238\t\225\t\225\t\225\t\225\t\225\012\161\t\225\t\225\024\254\t\225\r\018\t\225\t\225\t\225\022r\019f\t\225\t\225\t\225\t\225\t\225\t\225\t\225\015b\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\012\173\t\225\t\225\007B\t\225\t\225\022z\005\133\015~\024\186\t\225\t\225\t\225\t\225\t\225\015\130\t\225\t\225\t\225\t\225\t\225\001\206\t\225\t\225\000\238\t\225\t\225\023\014\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\023n\001\206\t\225\t\225\t\225\t\225\003\137\003\137\007\177\007B\024\238\003\137\023\222\003\137\003\137\027\031\003\137\003\137\003\137\003\137\025\178\003\137\003\137\007B\003\137\003\137\003\137\025\230\003\137\003\137\026\194\003\137\015\170\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\026\150\015\190\025\002\003\137\015\214\003\137\003\137\003\137\003\137\003\137\015\234\003\137\003\137\016\018\003\137\004E\003\137\003\137\003\137\024\190\016&\003\137\003\137\003\137\003\137\003\137\003\137\003\137\017&\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\0172\t\030\tN\003\218\003\137\003\137\005\234\004\193\017\218\017\242\003\137\003\137\003\137\003\137\003\137\002\194\003\137\003\137\003\137\003\137\t&\024\242\tV\003\137\018z\003\137\003\137\018~\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\026\198\003\137\003\137\003\137\003\137\003\137\001\221\001\221\018\182\018\186\018\226\001\221\018\230\002\158\001\221\019\018\002\214\001\221\t6\001\221\019\202\002\218\001\221\019\206\001\221\001\221\001\221\019\242\001\221\001\221\019\246\t>\020\006\002\222\001\221\001\221\001\221\001\221\001\221\tF\001\221\020\022\020\"\020^\002\226\020b\001\221\001\221\001\221\001\221\001\221\020\174\003\014\001\190\020\214\001\221\020\218\001\221\001\221\002\146\020\234\021:\003\026\001\221\001\221\001\221\007\234\007\238\007\250\021Z\0122\005R\001\221\001\221\001\221\001\221\001\221\001\221\001\221\001\221\001\221\021\154\t\030\tN\021\190\001\221\001\221\021\206\021\246\021\250\022\006\005^\005b\001\221\001\221\001\221\022\022\001\221\001\221\001\221\001\221\012:\0222\012\138\001\221\022B\001\221\001\221\022V\001\221\001\221\001\221\001\221\001\221\001\221\005f\b\002\001\221\001\221\001\221\b\026\004.\022\130\022\134\001\221\001\221\001\221\001\221\t\201\t\201\022\146\022\162\022\182\t\201\023\170\002\158\t\201\024\002\002\214\t\201\t\201\t\201\024*\002\218\t\201\024\146\t\201\t\201\t\201\024\162\t\201\t\201\025>\t\201\025F\002\222\t\201\t\201\t\201\t\201\t\201\t\201\t\201\025V\025b\025\198\002\226\025\218\t\201\t\201\t\201\t\201\t\201\026\n\003\014\001\190\026\018\t\201\026N\t\201\t\201\002\146\026v\026\174\003\026\t\201\t\201\t\201\007\234\007\238\007\250\026\222\t\201\005R\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\026\234\t\201\t\201\026\242\t\201\t\201\026\251\027\011\027+\027w\005^\005b\t\201\t\201\t\201\027\139\t\201\t\201\t\201\t\201\t\201\027\147\t\201\t\201\027\207\t\201\t\201\027\215\t\201\t\201\t\201\t\201\t\201\t\201\005f\b\002\t\201\t\201\t\201\b\026\004.\000\000\000\000\t\201\t\201\t\201\t\201\t\197\t\197\000\000\000\000\000\000\t\197\000\000\002\158\t\197\000\000\002\214\t\197\t\197\t\197\000\000\002\218\t\197\000\000\t\197\t\197\t\197\000\000\t\197\t\197\000\000\t\197\000\000\002\222\t\197\t\197\t\197\t\197\t\197\t\197\t\197\000\000\000\000\000\000\002\226\000\000\t\197\t\197\t\197\t\197\t\197\000\000\003\014\001\190\000\000\t\197\000\000\t\197\t\197\002\146\000\000\000\000\003\026\t\197\t\197\t\197\007\234\007\238\007\250\000\000\t\197\005R\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\000\000\t\197\t\197\000\000\t\197\t\197\000\000\000\000\000\000\000\000\005^\005b\t\197\t\197\t\197\000\000\t\197\t\197\t\197\t\197\t\197\000\000\t\197\t\197\000\000\t\197\t\197\000\000\t\197\t\197\t\197\t\197\t\197\t\197\005f\b\002\t\197\t\197\t\197\b\026\004.\000\000\000\000\t\197\t\197\t\197\t\197\002)\002)\000\000\000\000\000\000\002)\000\000\002\158\002)\000\000\002\214\002)\t6\002)\000\000\002\218\002)\000\000\002)\002)\002)\000\000\002)\002)\000\000\t>\000\000\002\222\002)\002)\002)\002)\002)\tF\002)\007\161\000\000\000\000\002\226\007\161\002)\002)\002)\002)\002)\000\000\003\014\001\190\000\000\002)\000\000\002)\002)\002\146\000\000\000\000\003\026\002)\002)\002)\007\234\007\238\007\250\000\000\0122\005R\002)\002)\002)\002)\002)\002)\002)\002)\002)\007\161\004\149\002)\000\000\002)\002)\000\000\000\000\004-\000\000\005^\005b\002)\002)\002)\004-\002)\002)\002)\002)\006R\007\161\000\000\002)\004\149\002)\002)\004-\002)\002)\002)\002)\002)\002)\005f\b\002\002)\002)\002)\b\026\004.\000\000\000\000\002)\002)\002)\002)\004-\000\000\004-\000\000\004-\004-\004-\004-\004-\004-\004-\004\218\004-\000\238\004-\004-\000\238\004-\004-\004-\004-\004-\004-\004-\004-\004-\004-\004-\000\000\004-\004-\000\000\000\238\004-\004-\004-\004-\004-\004-\004-\004-\000\000\004-\004-\004-\004-\004-\004-\004-\004-\002\250\004-\004-\004-\004-\004-\004-\004-\004-\000\238\004-\004-\004-\004-\004-\004-\004-\004-\000\000\000\000\004-\006\242\000\000\004-\004-\004-\000\238\004-\000\000\000\000\004-\004-\004-\004-\004-\004-\004-\004-\004-\b6\001\190\004-\004-\003\170\002\209\002\158\004-\002\209\018V\014\"\004-\004-\003\138\0146\014J\014Z\000\000\000\000\004-\004-\004-\007^\000\000\004-\004-\004-\004-\000\000\000\129\004-\000\129\000\n\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\238\000\129\022\214\000\129\000\129\003\166\000\129\000\129\002\209\000\000\000\129\000\129\002\146\000\129\000\129\000\000\000\129\000\000\000\129\000\129\002\209\002\209\000\129\000\129\000\000\000\129\000\129\000\129\000\000\000\129\015&\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\002\250\006\190\000\129\000\129\012Q\012=\000\129\000\129\000\000\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\002\209\002\209\000\000\000\000\012Q\000\129\000\000\000\129\000\000\000\129\002\026\006\133\000\000\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\b6\014\154\002\"\000\129\000\n\002&\012=\000\000\000\222\006Z\014\"\b\177\000\129\006\133\0146\014J\014Z\007\186\000\129\000\129\000\129\000\129\000\000\000\000\000\129\000\129\000\129\000\129\002\025\002\025\014z\000\000\002\209\002\025\b\177\002\158\002\025\007\190\002\214\002\025\000\000\002\025\000\000\002\218\002\025\007:\002\025\002\025\002\025\000\000\002\025\002\025\000\000\007B\000\000\002\222\002\025\002\025\002\025\002\025\002\025\007F\002\025\007\174\000\000\000\000\002\226\000\000\002\025\002\025\002\025\002\025\002\025\006\157\003\014\007\254\000\238\002\025\000\000\002\025\002\025\002\146\000\000\000\000\003\026\002\025\002\025\002\025\007\234\007\238\007\250\000\000\006\157\005R\002\025\002\025\002\025\002\025\002\025\002\025\002\025\002\025\002\025\000\000\t\030\tN\015N\002\025\002\025\002b\000\000\000\000\000\000\005^\005b\002\025\002\025\002\025\000\000\002\025\002\025\002\025\002\025\t&\007\194\tV\002\025\000\000\002\025\002\025\000\000\002\025\002\025\002\025\002\025\002\025\002\025\005f\b\002\002\025\002\025\002\025\b\026\004.\000\000\015R\002\025\002\025\002\025\002\025\0025\0025\006\157\000\000\0059\0025\007E\000\000\0025\015^\000\000\0025\007\246\0025\b\181\000\000\0025\000\000\0025\0025\0025\002\158\0025\0025\000\000\000\000\b\165\000\000\0025\0025\0025\0025\0025\000\000\0025\015f\007E\b\181\000\000\000\000\0025\0025\0025\0025\0025\006:\000\000\0059\b\165\0025\007E\0025\0025\007E\bv\005\246\000\000\0025\0025\0025\007E\003\226\025j\017\194\007E\0059\0025\0025\0025\0025\0025\0025\0025\0025\0025\005\250\t\030\tN\015N\0025\0025\002b\000\000\000\000\000\000\000\238\002\250\0025\0025\0025\000\000\0025\0025\0025\0025\t&\000\000\tV\0025\000\000\0025\0025\000\000\0025\0025\0025\0025\0025\0025\bA\000\000\0025\0025\0025\000\238\t\n\000\000\015R\0025\0025\0025\0025\0021\0021\000\000\001\002\001\190\0021\000\000\005\254\0021\015^\005\194\0021\000\000\0021\000\000\b\165\0021\006\n\0021\0021\0021\006\022\0021\0021\bA\000\000\000\000\000\000\0021\0021\0021\0021\0021\000\000\0021\015f\005\254\000\000\000\000\005\194\0021\0021\0021\0021\0021\bA\006\n\000\000\000\000\0021\006\022\0021\0021\000\000\000\000\007\142\006\242\0021\0021\0021\000\000\000\000\021\006\000\000\000\000\000\000\0021\0021\0021\0021\0021\0021\0021\0021\0021\007\146\t\030\tN\bA\0021\0021\000\000\004\218\000\000\000\000\bA\001\206\0021\0021\0021\000\000\0021\0021\0021\0021\t&\007^\tV\0021\000\000\0021\0021\000\000\0021\0021\0021\0021\0021\0021\b=\000\000\0021\0021\0021\000\238\018\130\007\202\006\242\0021\0021\0021\0021\002\029\002\029\002\209\000\000\019\n\002\029\019\014\000\000\002\029\000\000\002\146\002\029\000\000\002\029\007\206\000\000\002\029\019&\002\029\002\029\002\029\000\000\002\029\002\029\b=\000\000\000\n\012\021\002\029\002\029\002\029\002\029\002\029\000\000\002\029\007^\000\000\000\000\000\000\000\000\002\029\002\029\002\029\002\029\002\029\b=\012\021\012\021\000\000\002\029\012\021\002\029\002\029\000\238\002\209\000\000\006\242\002\029\002\029\002\029\000\000\014b\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\016V\t\030\tN\b=\002\029\002\029\000\000\004\218\000\000\000\000\b=\000\238\002\029\002\029\002\029\000\000\002\029\002\029\002\029\002\029\t&\007^\tV\002\029\000\000\002\029\002\029\000\000\002\029\002\029\002\029\002\029\002\029\002\029\017\142\000\000\002\029\002\029\002\029\000\238\000\000\012\021\000\000\002\029\002\029\002\029\002\029\002-\002-\002\209\002\209\016\130\002-\nM\000\000\002-\n\178\000\n\002-\000\000\002-\t\030\tN\002-\002\209\002-\002-\002-\000\000\002-\002-\000\000\002\209\002\209\000\n\002-\002-\002-\002-\002-\t&\002-\tV\nM\016Z\002\209\004\153\002-\002-\002-\002-\002-\006V\002\158\000\000\000\000\002-\nM\002-\002-\nM\011R\002\209\000\000\002-\002-\002-\nM\000\000\004\153\000\000\nM\000\000\002-\002-\002-\002-\002-\002-\002-\002-\002-\024\202\006\242\002-\007\173\002-\002-\007\173\000\000\000\000\000\000\000\000\003\226\002-\002-\002-\000\000\002-\002-\002-\002-\024\206\000\000\022*\002-\000\000\002-\002-\000\000\tn\002-\002-\002-\002-\002-\012\029\000\000\002-\002-\002-\000\000\000\000\007^\007\173\002-\002-\002-\002-\b\189\b\189\000\000\000\000\004-\b\189\012\029\012\029\b\189\007\173\012\029\b\189\000\238\b\189\000\000\000\000\t\150\000\000\b\189\t\186\b\189\000\000\b\189\b\189\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\b\189\007\173\000\000\006\153\000\000\004-\b\189\b\189\t\254\n\006\b\189\000\000\000\238\004-\000\000\b\189\000\000\n\014\b\189\000\000\000\000\000\000\006\153\b\189\b\189\000\238\006\153\000\000\007\173\000\000\000\000\000\000\b\189\b\189\t\158\t\222\n\022\n\030\n.\b\189\b\189\000\000\012\029\b\189\000\000\b\189\n6\000\000\000\000\000\000\000\000\0121\000\000\b\189\b\189\n>\000\000\b\189\b\189\b\189\b\189\000\000\000\238\0121\b\189\000\000\b\189\b\189\000\000\n^\b\189\nf\n&\b\189\b\189\012\025\000\000\b\189\nF\b\189\021\178\000\000\000\000\006\242\b\189\b\189\nN\nV\002a\002a\000\000\0121\006\153\002a\012\025\012\025\002a\000\000\012\025\002a\000\000\002a\007\154\000\000\002a\000\000\002a\002a\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\002a\002a\002a\002a\002a\0121\002a\007^\0121\006\173\000\000\000\000\002a\002a\002a\002a\002a\000\000\000\238\000\000\000\000\002a\000\000\002a\002a\000\238\000\000\001*\006\173\002a\002a\002a\006\173\002\209\002\209\002\134\000\000\000\000\002a\002a\t\158\002a\002a\002a\002a\002a\002a\000\000\012\025\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\000\238\000\n\002a\002a\002a\000\000\002a\002a\002a\002a\000\000\000\000\001\206\002a\000\000\002a\002a\000\000\002a\002a\002a\002a\002a\002a\025\250\000\000\002a\002a\002a\002\209\011f\000\000\000\000\002a\002a\002a\002a\002I\002I\000\000\000\000\005B\002I\000\238\011n\002I\000\000\011z\002I\000\000\002I\000\000\002z\002I\011\134\002I\002I\002I\011\146\002I\002I\000\000\000\000\000\000\000\000\002I\002I\002I\002I\002I\000\000\002I\000\000\007=\000\000\000\000\000\000\002I\002I\002I\002I\002I\004v\000\000\000\000\004\197\002I\007=\002I\002I\005\194\000\000\000\000\000\000\002I\002I\002I\007=\000\000\000\000\000\000\007=\000\000\002I\002I\t\158\002I\002I\002I\002I\002I\002I\000\000\006\242\002I\000\000\002I\002I\000\000\000\000\000\000\000\000\007U\007\157\002I\002I\002I\007\157\002I\002I\002I\002I\bb\000\000\000\000\002I\000\000\002I\002I\000\000\002I\002I\002I\002I\002I\002I\000\000\000\000\002I\002I\002I\004-\007U\007^\000\000\002I\002I\002I\002I\002U\002U\000\000\000\000\007\157\002U\000\238\007U\002U\000\000\005\194\002U\000\238\002U\004-\000\000\t\150\007U\002U\002U\002U\007U\002U\002U\000\000\007\157\000\000\000\000\002U\002U\002U\t\214\002U\000\000\002U\004-\007q\000\000\000\000\000\000\002U\002U\002U\002U\002U\000\000\000\000\000\238\000\000\002U\005\254\002U\002U\005\194\000\000\000\000\006\242\002U\002U\002U\007q\000\000\004\218\000\000\007q\000\000\002U\002U\t\158\t\222\002U\002U\002U\002U\002U\016F\006\242\002U\000\000\002U\002U\000\000\000\000\000\000\000\000\007i\000\000\002U\002U\002U\000\000\002U\002U\002U\002U\016b\007^\000\000\002U\000\000\002U\002U\022\"\002U\002U\002U\002U\002U\002U\000\000\000\000\002U\002U\002U\000\238\007i\007^\000\000\002U\002U\002U\002U\002e\002e\000\000\000\000\000\000\002e\000\238\011\170\002e\000\000\007i\002e\000\238\002e\000\000\000\000\002e\007i\002e\002e\002e\007i\002e\002e\000\000\000\000\000\000\000\000\002e\002e\002e\002e\002e\000\000\002e\000\000\0079\000\000\000\000\000\000\002e\002e\002e\002e\002e\000\000\000\000\000\000\000\000\002e\0079\002e\002e\005\194\000\000\000\000\006\242\002e\002e\002e\0079\000\000\000\000\000\000\0079\000\000\002e\002e\t\158\002e\002e\002e\002e\002e\002e\025*\006\242\002e\000\000\002e\002e\000\000\000\000\000\000\000\000\000\238\000\000\002e\002e\002e\000\000\002e\002e\002e\002e\026\206\007^\000\000\002e\000\000\002e\002e\000\000\002e\002e\002e\002e\002e\002e\000\000\000\000\002e\002e\002e\000\238\r\242\007^\000\000\002e\002e\002e\002e\002E\002E\000\000\000\000\000\000\002E\000\000\011n\002E\000\000\011z\002E\000\238\002E\000\000\000\000\002E\011\134\002E\002E\002E\011\146\002E\002E\000\000\000\000\000\000\006\189\002E\002E\002E\002E\002E\000\000\002E\000\000\000\000\006\157\000\000\000\000\002E\002E\002E\002E\002E\000\000\006\189\000\000\000\000\002E\006\189\002E\002E\000\000\000\000\000\000\006\157\002E\002E\002E\006\157\000\000\000\000\000\000\000\000\000\000\002E\002E\t\158\002E\002E\002E\002E\002E\002E\000\000\000\000\002E\000\000\002E\002E\000\000\000\000\000\000\000\000\000\238\000\000\002E\002E\002E\000\000\002E\002E\002E\002E\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\006\189\027;\002E\002E\002E\002E\002Q\002Q\000\000\000\000\007\246\002Q\000\000\005\254\002Q\n\154\005\194\002Q\n\166\002Q\000\000\000\000\t\150\006\n\002Q\002Q\002Q\006\022\002Q\002Q\000\000\000\000\000\000\006\149\002Q\002Q\002Q\t\214\002Q\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002Q\000\000\006\149\000\000\000\000\002Q\006\149\002Q\002Q\000\000\000\000\000\000\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\t\158\t\222\002Q\002Q\002Q\002Q\002Q\000\000\002\250\002Q\000\000\002Q\002Q\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\002Q\000\000\000\000\000\000\002Q\000\000\002Q\002Q\000\000\002Q\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\002Q\002Q\000\000\005\150\006\149\000\000\002Q\002Q\002Q\002Q\002M\002M\000\000\003\210\000\000\002M\000\000\006\"\002M\003\222\000\000\002M\004\002\002M\000\000\000\000\t\150\000\000\002M\002M\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\002M\002M\002M\t\214\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\t\158\t\222\002M\002M\002M\002M\002M\000\000\002\158\002M\000\000\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\002M\000\000\002M\002M\000\000\002M\002M\002M\002M\002M\002M\000\000\000\000\002M\002M\002M\000\000\tZ\003\226\000\000\002M\002M\002M\002M\002u\002u\000\000\000\000\000\000\002u\000\000\011\202\002u\011\218\000\000\002u\000\000\002u\000\000\000\000\t\150\000\000\002u\002u\002u\000\000\002u\002u\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002u\000\000\000\000\000\000\000\000\000\000\002u\002u\t\254\n\006\002u\000\000\000\000\000\000\000\000\002u\000\000\n\014\002u\000\000\000\000\000\000\000\000\002u\002u\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002u\002u\t\158\t\222\n\022\n\030\n.\002u\002u\000\000\002\158\002u\000\000\002u\n6\000\000\000\000\000\000\000\000\000\000\000\000\002u\002u\n>\000\000\002u\002u\002u\002u\000\000\000\000\000\000\002u\000\000\002u\002u\000\000\002u\002u\002u\n&\002u\002u\000\000\000\000\002u\nF\002u\000\000\012\142\003\226\000\000\002u\002u\nN\nV\002]\002]\000\000\000\000\000\000\002]\000\000\012\162\002]\012\182\000\000\002]\000\000\002]\000\000\000\000\t\150\000\000\002]\002]\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\002]\002]\002]\t\214\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]\t\158\t\222\002]\002]\002]\002]\002]\000\000\000\000\002]\000\000\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\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\000\000\002]\002]\002]\002]\002Y\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\t\150\000\000\002Y\002Y\002Y\000\000\002Y\002Y\000\000\000\000\000\000\000\000\002Y\002Y\002Y\t\214\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\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\t\158\t\222\002Y\002Y\002Y\002Y\002Y\000\000\000\000\002Y\000\000\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\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\000\000\002Y\002Y\002Y\002Y\002m\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\t\150\000\000\002m\002m\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002m\000\000\002m\000\000\000\000\000\000\000\000\000\000\002m\002m\t\254\n\006\002m\000\000\000\000\000\000\000\000\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\002m\002m\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002m\002m\t\158\t\222\n\022\n\030\002m\002m\002m\000\000\000\000\002m\000\000\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\002m\000\000\002m\002m\000\000\002m\002m\002m\n&\002m\002m\000\000\000\000\002m\002m\002m\000\000\000\000\000\000\000\000\002m\002m\002m\002m\002A\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\t\150\000\000\002A\002A\002A\000\000\002A\002A\000\000\000\000\000\000\000\000\002A\002A\002A\t\214\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\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\t\158\t\222\002A\002A\002A\002A\002A\000\000\000\000\002A\000\000\002A\002A\000\000\000\000\000\000\000\000\000\000\000\000\002A\002A\002A\000\000\002A\002A\002A\002A\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\000\000\002A\002A\002A\002A\002=\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\t\150\000\000\002=\002=\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002=\000\000\002=\000\000\000\000\000\000\000\000\000\000\002=\002=\t\254\n\006\002=\000\000\000\000\000\000\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=\t\158\t\222\n\022\n\030\002=\002=\002=\000\000\000\000\002=\000\000\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\002=\000\000\002=\002=\000\000\002=\002=\002=\n&\002=\002=\000\000\000\000\002=\002=\002=\000\000\000\000\000\000\000\000\002=\002=\002=\002=\002\153\002\153\000\000\000\000\000\000\002\153\000\000\000\000\002\153\000\000\000\000\002\153\000\000\002\153\000\000\000\000\t\150\000\000\002\153\002\153\002\153\000\000\002\153\002\153\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002\153\000\000\002\153\000\000\000\000\000\000\000\000\000\000\002\153\002\153\t\254\n\006\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\t\158\t\222\n\022\002\153\002\153\002\153\002\153\000\000\000\000\002\153\000\000\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\002\153\000\000\002\153\002\153\000\000\002\153\002\153\002\153\n&\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\0029\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\t\150\000\000\0029\0029\0029\000\000\0029\0029\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\0029\000\000\0029\000\000\000\000\000\000\000\000\000\000\0029\0029\t\254\n\006\0029\000\000\000\000\000\000\000\000\0029\000\000\0029\0029\000\000\000\000\000\000\000\000\0029\0029\000\238\000\000\000\000\000\000\000\000\000\000\000\000\0029\0029\t\158\t\222\n\022\n\030\0029\0029\0029\000\000\000\000\0029\000\000\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\0029\000\000\0029\0029\000\000\0029\0029\0029\n&\0029\0029\000\000\000\000\0029\0029\0029\000\000\000\000\000\000\000\000\0029\0029\0029\0029\002q\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\t\150\000\000\002q\002q\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002q\000\000\002q\000\000\000\000\000\000\000\000\000\000\002q\002q\t\254\n\006\002q\000\000\000\000\000\000\000\000\002q\000\000\002q\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\t\158\t\222\n\022\n\030\002q\002q\002q\000\000\000\000\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\000\000\000\000\002q\002q\002q\000\000\002q\002q\002q\002q\000\000\000\000\000\000\002q\000\000\002q\002q\000\000\002q\002q\002q\n&\002q\002q\000\000\000\000\002q\002q\002q\000\000\000\000\000\000\000\000\002q\002q\002q\002q\002i\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\t\150\000\000\002i\002i\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002i\000\000\002i\000\000\000\000\000\000\000\000\000\000\002i\002i\t\254\n\006\002i\000\000\000\000\000\000\000\000\002i\000\000\002i\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\t\158\t\222\n\022\n\030\002i\002i\002i\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\000\000\002i\002i\002i\002i\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\002i\002i\002i\n&\002i\002i\000\000\000\000\002i\002i\002i\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002y\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\t\150\000\000\002y\002y\002y\000\000\002y\002y\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\t\254\n\006\002y\000\000\000\000\000\000\000\000\002y\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002y\002y\000\000\000\000\002y\000\000\002y\n6\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\n>\000\000\002y\002y\002y\002y\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\002y\002y\002y\n&\002y\002y\000\000\000\000\002y\nF\002y\000\000\000\000\000\000\000\000\002y\002y\nN\nV\002}\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\t\150\000\000\002}\002}\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002}\000\000\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\t\254\n\006\002}\000\000\000\000\000\000\000\000\002}\000\000\n\014\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}\t\158\t\222\n\022\n\030\n.\002}\002}\000\000\000\000\002}\000\000\002}\n6\000\000\000\000\000\000\000\000\000\000\000\000\002}\002}\n>\000\000\002}\002}\002}\002}\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\002}\002}\002}\n&\002}\002}\000\000\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\002}\002}\nN\nV\002\129\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\t\150\000\000\002\129\002\129\002\129\000\000\002\129\002\129\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002\129\000\000\002\129\000\000\000\000\000\000\000\000\000\000\002\129\002\129\t\254\n\006\002\129\000\000\000\000\000\000\000\000\002\129\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\129\002\129\000\000\000\000\002\129\000\000\002\129\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\n>\000\000\002\129\002\129\002\129\002\129\000\000\000\000\000\000\002\129\000\000\002\129\002\129\000\000\002\129\002\129\002\129\n&\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\nN\nV\by\by\000\000\000\000\000\000\by\000\000\000\000\by\000\000\000\000\by\000\000\by\000\000\000\000\t\150\000\000\by\by\by\000\000\by\by\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\by\000\000\000\000\000\000\000\000\000\000\by\by\t\254\n\006\by\000\000\000\000\000\000\000\000\by\000\000\n\014\by\000\000\000\000\000\000\000\000\by\by\000\238\000\000\000\000\000\000\000\000\000\000\000\000\by\by\t\158\t\222\n\022\n\030\n.\by\by\000\000\000\000\by\000\000\by\n6\000\000\000\000\000\000\000\000\000\000\000\000\by\by\n>\000\000\by\by\by\by\000\000\000\000\000\000\by\000\000\by\by\000\000\by\by\by\n&\by\by\000\000\000\000\by\nF\by\000\000\000\000\000\000\000\000\by\by\nN\nV\002\133\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\t\150\000\000\002\133\002\133\002\133\000\000\002\133\002\133\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\133\000\000\000\000\000\000\000\000\000\000\002\133\002\133\t\254\n\006\002\133\000\000\000\000\000\000\000\000\002\133\000\000\n\014\002\133\000\000\000\000\000\000\000\000\002\133\002\133\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\t\158\t\222\n\022\n\030\n.\002\133\002\133\000\000\000\000\002\133\000\000\002\133\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\n>\000\000\002\133\002\133\002\133\002\133\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\n^\002\133\nf\n&\002\133\002\133\000\000\000\000\002\133\nF\002\133\000\000\000\000\000\000\000\000\002\133\002\133\nN\nV\bu\bu\000\000\000\000\000\000\bu\000\000\000\000\bu\000\000\000\000\bu\000\000\bu\000\000\000\000\t\150\000\000\bu\bu\bu\000\000\bu\bu\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\bu\000\000\000\000\000\000\000\000\000\000\bu\bu\t\254\n\006\bu\000\000\000\000\000\000\000\000\bu\000\000\n\014\bu\000\000\000\000\000\000\000\000\bu\bu\000\238\000\000\000\000\000\000\000\000\000\000\000\000\bu\bu\t\158\t\222\n\022\n\030\n.\bu\bu\000\000\000\000\bu\000\000\bu\n6\000\000\000\000\000\000\000\000\000\000\000\000\bu\bu\n>\000\000\bu\bu\bu\bu\000\000\000\000\000\000\bu\000\000\bu\bu\000\000\bu\bu\bu\n&\bu\bu\000\000\000\000\bu\nF\bu\000\000\000\000\000\000\000\000\bu\bu\nN\nV\002\181\002\181\000\000\000\000\000\000\002\181\000\000\000\000\002\181\000\000\000\000\002\181\000\000\002\181\000\000\000\000\t\150\000\000\002\181\002\181\002\181\000\000\002\181\002\181\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\181\000\000\000\000\000\000\000\000\000\000\002\181\002\181\t\254\n\006\002\181\000\000\000\000\000\000\000\000\002\181\000\000\n\014\002\181\000\000\000\000\000\000\000\000\002\181\002\181\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\t\158\t\222\n\022\n\030\n.\002\181\002\181\000\000\000\000\002\181\000\000\002\181\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\n>\000\000\002\181\002\181\002\181\002\181\000\000\000\000\000\000\002\181\000\000\002\181\002\181\000\000\n^\002\181\nf\n&\002\181\002\181\000\000\000\000\002\181\nF\002\181\000\000\000\000\000\000\000\000\002\181\002\181\nN\nV\002\177\002\177\000\000\000\000\000\000\002\177\000\000\000\000\002\177\000\000\000\000\002\177\000\000\002\177\000\000\000\000\t\150\000\000\002\177\002\177\002\177\000\000\002\177\002\177\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\177\000\000\000\000\000\000\000\000\000\000\002\177\002\177\t\254\n\006\002\177\000\000\000\000\000\000\000\000\002\177\000\000\n\014\002\177\000\000\000\000\000\000\000\000\002\177\002\177\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\t\158\t\222\n\022\n\030\n.\002\177\002\177\000\000\000\000\002\177\000\000\002\177\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\n>\000\000\002\177\002\177\002\177\002\177\000\000\000\000\000\000\002\177\000\000\002\177\002\177\000\000\n^\002\177\nf\n&\002\177\002\177\000\000\000\000\002\177\nF\002\177\000\000\000\000\000\000\000\000\002\177\002\177\nN\nV\002\185\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\t\150\000\000\002\185\002\185\002\185\000\000\002\185\002\185\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\t\254\n\006\002\185\000\000\000\000\000\000\000\000\002\185\000\000\n\014\002\185\000\000\000\000\000\000\000\000\002\185\002\185\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\t\158\t\222\n\022\n\030\n.\002\185\002\185\000\000\000\000\002\185\000\000\002\185\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n>\000\000\002\185\002\185\002\185\002\185\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\n^\002\185\nf\n&\002\185\002\185\000\000\000\000\002\185\nF\002\185\000\000\000\000\000\000\000\000\002\185\002\185\nN\nV\002\165\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\t\150\000\000\002\165\002\165\002\165\000\000\002\165\002\165\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\165\000\000\000\000\000\000\000\000\000\000\002\165\002\165\t\254\n\006\002\165\000\000\000\000\000\000\000\000\002\165\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\165\002\165\000\000\000\000\002\165\000\000\002\165\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\165\002\165\n>\000\000\002\165\002\165\002\165\002\165\000\000\000\000\000\000\002\165\000\000\002\165\002\165\000\000\n^\002\165\nf\n&\002\165\002\165\000\000\000\000\002\165\nF\002\165\000\000\000\000\000\000\000\000\002\165\002\165\nN\nV\002\169\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\t\150\000\000\002\169\002\169\002\169\000\000\002\169\002\169\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\169\000\000\000\000\000\000\000\000\000\000\002\169\002\169\t\254\n\006\002\169\000\000\000\000\000\000\000\000\002\169\000\000\n\014\002\169\000\000\000\000\000\000\000\000\002\169\002\169\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\t\158\t\222\n\022\n\030\n.\002\169\002\169\000\000\000\000\002\169\000\000\002\169\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\n>\000\000\002\169\002\169\002\169\002\169\000\000\000\000\000\000\002\169\000\000\002\169\002\169\000\000\n^\002\169\nf\n&\002\169\002\169\000\000\000\000\002\169\nF\002\169\000\000\000\000\000\000\000\000\002\169\002\169\nN\nV\002\173\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\t\150\000\000\002\173\002\173\002\173\000\000\002\173\002\173\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002\173\002\173\t\254\n\006\002\173\000\000\000\000\000\000\000\000\002\173\000\000\n\014\002\173\000\000\000\000\000\000\000\000\002\173\002\173\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\t\158\t\222\n\022\n\030\n.\002\173\002\173\000\000\000\000\002\173\000\000\002\173\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\n>\000\000\002\173\002\173\002\173\002\173\000\000\000\000\000\000\002\173\000\000\002\173\002\173\000\000\n^\002\173\nf\n&\002\173\002\173\000\000\000\000\002\173\nF\002\173\000\000\000\000\000\000\000\000\002\173\002\173\nN\nV\002\193\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\t\150\000\000\002\193\002\193\002\193\000\000\002\193\002\193\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\t\254\n\006\002\193\000\000\000\000\000\000\000\000\002\193\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\193\002\193\000\000\000\000\002\193\000\000\002\193\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n>\000\000\002\193\002\193\002\193\002\193\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\n^\002\193\nf\n&\002\193\002\193\000\000\000\000\002\193\nF\002\193\000\000\000\000\000\000\000\000\002\193\002\193\nN\nV\002\189\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\t\150\000\000\002\189\002\189\002\189\000\000\002\189\002\189\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\t\254\n\006\002\189\000\000\000\000\000\000\000\000\002\189\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\189\002\189\000\000\000\000\002\189\000\000\002\189\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\n>\000\000\002\189\002\189\002\189\002\189\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\n^\002\189\nf\n&\002\189\002\189\000\000\000\000\002\189\nF\002\189\000\000\000\000\000\000\000\000\002\189\002\189\nN\nV\002\197\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\t\150\000\000\002\197\002\197\002\197\000\000\002\197\002\197\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\t\254\n\006\002\197\000\000\000\000\000\000\000\000\002\197\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\197\002\197\000\000\000\000\002\197\000\000\002\197\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\n>\000\000\002\197\002\197\002\197\002\197\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\n^\002\197\nf\n&\002\197\002\197\000\000\000\000\002\197\nF\002\197\000\000\000\000\000\000\000\000\002\197\002\197\nN\nV\002\161\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\t\150\000\000\002\161\002\161\002\161\000\000\002\161\002\161\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\161\000\000\000\000\000\000\000\000\000\000\002\161\002\161\t\254\n\006\002\161\000\000\000\000\000\000\000\000\002\161\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\161\002\161\000\000\000\000\002\161\000\000\002\161\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\161\n>\000\000\002\161\002\161\002\161\002\161\000\000\000\000\000\000\002\161\000\000\002\161\002\161\000\000\n^\002\161\nf\n&\002\161\002\161\000\000\000\000\002\161\nF\002\161\000\000\000\000\000\000\000\000\002\161\002\161\nN\nV\001\241\001\241\000\000\000\000\000\000\001\241\000\000\000\000\001\241\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\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\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\000\000\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\000\000\001\241\001\241\001\241\001\241\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\r\202\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\002\r\002\r\000\000\000\000\000\000\002\r\000\000\000\000\002\r\000\000\000\000\002\r\000\000\002\r\000\000\000\000\t\150\000\000\002\r\002\r\002\r\000\000\002\r\002\r\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\r\000\000\000\000\000\000\000\000\000\000\002\r\002\r\t\254\n\006\002\r\000\000\000\000\000\000\000\000\002\r\000\000\n\014\002\r\000\000\000\000\000\000\000\000\002\r\002\r\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\t\158\t\222\n\022\n\030\n.\002\r\002\r\000\000\000\000\002\r\000\000\002\r\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\n>\000\000\002\r\002\r\r\226\002\r\000\000\000\000\000\000\002\r\000\000\002\r\002\r\000\000\n^\002\r\nf\n&\002\r\002\r\000\000\000\000\002\r\nF\002\r\000\000\000\000\000\000\000\000\002\r\002\r\nN\nV\002\t\002\t\000\000\000\000\000\000\002\t\000\000\000\000\002\t\000\000\000\000\002\t\000\000\002\t\000\000\000\000\t\150\000\000\002\t\002\t\002\t\000\000\002\t\002\t\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\t\000\000\000\000\000\000\000\000\000\000\002\t\002\t\t\254\n\006\002\t\000\000\000\000\000\000\000\000\002\t\000\000\n\014\002\t\000\000\000\000\000\000\000\000\002\t\002\t\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\t\002\t\t\158\t\222\n\022\n\030\n.\002\t\002\t\000\000\000\000\002\t\000\000\002\t\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\t\002\t\n>\000\000\002\t\002\t\002\t\002\t\000\000\000\000\000\000\002\t\000\000\002\t\002\t\000\000\n^\002\t\nf\n&\002\t\002\t\000\000\000\000\002\t\nF\002\t\000\000\000\000\000\000\000\000\002\t\002\t\nN\nV\002\157\002\157\000\000\000\000\000\000\002\157\000\000\000\000\002\157\000\000\000\000\002\157\000\000\002\157\000\000\000\000\t\150\000\000\002\157\002\157\002\157\000\000\002\157\002\157\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\157\000\000\000\000\000\000\000\000\000\000\002\157\002\157\t\254\n\006\002\157\000\000\000\000\000\000\000\000\002\157\000\000\n\014\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\t\158\t\222\n\022\n\030\n.\002\157\002\157\000\000\000\000\002\157\000\000\002\157\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002\157\n>\000\000\002\157\002\157\002\157\002\157\000\000\000\000\000\000\002\157\000\000\002\157\002\157\000\000\n^\002\157\nf\n&\002\157\002\157\000\000\000\000\002\157\nF\002\157\000\000\000\000\000\000\000\000\002\157\002\157\nN\nV\001\253\001\253\000\000\000\000\000\000\001\253\000\000\000\000\001\253\000\000\000\000\001\253\000\000\001\253\000\000\000\000\001\253\000\000\001\253\001\253\001\253\000\000\001\253\001\253\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\001\253\000\000\001\253\000\000\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\001\253\000\000\000\000\000\000\000\000\001\253\000\000\001\253\001\253\000\000\000\000\000\000\000\000\001\253\001\253\001\253\000\000\000\000\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\001\253\001\253\001\253\001\253\001\253\000\000\000\000\001\253\000\000\001\253\001\253\000\000\000\000\000\000\000\000\000\000\000\000\001\253\001\253\001\253\000\000\001\253\001\253\001\253\001\253\000\000\000\000\000\000\001\253\000\000\001\253\001\253\000\000\001\253\001\253\001\253\001\253\001\253\001\253\000\000\000\000\001\253\001\253\r\202\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\002\001\002\001\000\000\000\000\000\000\002\001\000\000\000\000\002\001\000\000\000\000\002\001\000\000\002\001\000\000\000\000\002\001\000\000\002\001\002\001\002\001\000\000\002\001\002\001\000\000\000\000\000\000\006\177\002\001\002\001\002\001\002\001\002\001\000\000\002\001\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\000\000\006\177\003\233\000\000\002\001\006\177\002\001\002\001\000\000\000\000\000\000\000\000\002\001\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\000\000\000\000\002\001\000\000\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\238\002\001\002\001\002\001\000\000\002\001\002\001\002\001\002\001\000\000\000\000\000\000\002\001\000\000\002\001\002\001\000\000\002\001\002\001\002\001\002\001\002\001\002\001\000\000\b\162\002\001\002\001\r\202\000\000\000\000\003\233\000\000\002\001\002\001\002\001\002\001\001\006\000\000\000\006\000\000\000\000\024\214\002\154\002\158\005\254\002\202\002\214\005\194\b\194\000\000\000\000\002\218\001\n\000\000\006\n\000\000\003\018\000\000\006\022\000\000\000\000\000\000\r\182\003\022\001\018\b>\bB\001\030\001\"\000\000\000\000\000\000\003&\000\000\002\226\000\000\025\n\000\000\bf\bj\000\238\003\186\003\014\003\198\bn\006\170\bZ\001:\000\000\002\146\002\002\000\000\003\026\002\002\000\000\000\000\007\234\007\238\007\250\b\014\002\006\005R\000\000\002\006\001>\001B\001F\001J\001N\000\000\000\000\b\130\001R\000\000\000\000\000\000\001V\000\000\b\142\b\166\b\250\005^\005b\003z\005\254\001Z\003z\005\194\024\218\006\214\001\218\001^\006\214\001\218\006\n\000\000\002\146\000\000\006\022\002\146\000\000\001\154\n\222\000\000\000\000\005f\b\002\000\000\001\158\000\000\014\018\004.\t\014\001\006\001\166\000\006\001\170\001\174\000\000\002\154\002\158\000\000\002\202\002\214\006\218\000\000\000\000\006\218\002\218\001\n\000\000\000\000\000\000\b:\000\000\000\000\000\000\000\000\000\000\000\000\003\022\001\018\b>\bB\001\030\001\"\000\000\000\000\000\000\003&\000\000\002\226\000\000\bF\000\000\bf\bj\000\000\003\186\003\014\003\198\bn\006\170\000\000\001:\000\000\002\146\000\000\000\000\003\026\000\000\000\000\000\000\007\234\007\238\007\250\b\014\000\000\005R\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\b\130\001R\000\000\000\000\000\000\001V\000\000\b\142\b\166\b\250\005^\005b\000\000\000\000\001Z\000\000\000\000\000\000\000\000\000\000\001^\000\000\000\241\003\170\000\000\002\158\000\000\000\241\000\000\000\000\001\154\005\234\003\138\000\000\005f\b\002\000\000\001\158\007\178\014\018\004.\t\014\n\234\001\166\000\000\001\170\001\174\000\014\000\018\000\022\000\026\000\030\000\000\000\"\000&\000*\000.\0002\000\000\0006\000:\000\000\n\238\000>\003\166\002\158\000\241\000B\0032\000\000\000\000\002\146\000F\000\000\000\241\000\000\000\000\000\000\000J\000\241\000N\000R\000V\000Z\000^\000b\000f\000\000\000\241\000\241\000j\000n\000\000\000r\021\162\000v\000\000\000\000\000\000\006\190\000\000\000\238\000\000\000\000\022\222\002\238\000\000\022\226\000\000\000z\000\000\002\146\000~\000\130\000\241\000\000\000\000\000\000\023\018\000\134\000\138\000\142\000\000\000\241\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\000\000\000\174\000\178\000\182\023\"\000\000\000\000\000\186\005\254\000\190\000\194\005\194\n\242\016>\000\000\000\000\000\000\000\198\006\n\000\202\002\002\000\000\006\022\000\000\000\000\000\206\000\210\004Y\000\214\000\006\002\006\000\000\000\246\002\154\002\158\002\162\002\202\002\214\000\000\000\000\000\000\000\000\002\218\000\000\000\000\003\146\000\000\000\000\000\000\004Y\000\000\016N\016\234\003z\002\222\000\000\003\030\003\"\002\002\006\214\001\218\003\150\000\000\003&\000\000\002\226\002\146\016~\002\006\003\178\003\182\000\000\003\186\003\014\003\198\003\206\006\170\000\000\000\000\016\226\002\146\000\000\000\000\003\026\016\250\000\000\000\000\007\234\007\238\007\250\b\014\003z\005R\000\000\006\218\000\000\000\000\006\214\001\218\000\000\017\002\000\000\b\130\000\000\002\146\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\017\022\017B\000\000\000\000\004Y\004Y\000\000\000\000\001\202\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\218\000\000\017\130\021\134\005f\b\002\024\246\000\141\001\210\b\026\004.\t\014\000\141\000\000\002\158\000\141\000\000\002\214\004E\t6\000\000\000\000\002\218\004E\000\000\000\141\000\000\000\141\000\000\000\141\001\242\002z\t>\000\000\002\222\002~\000\000\002\146\004\006\004\018\tF\000\141\000\000\000\000\004\030\002\226\015r\000\141\000\000\000\000\000\000\000\141\000\000\003\014\001\190\000\000\000\141\000\000\000\000\000\141\002\146\004\"\004E\003\026\000\141\000\141\000\141\007\234\007\238\007\250\004E\0122\005R\000\141\000\141\004E\002\194\000\238\000\000\000\000\000\141\000\000\000\000\000\000\000\141\004E\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\141\000\141\000\000\000\000\000\141\000\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\002\209\004E\000\000\002\209\000\000\000\141\000\141\005f\b\002\000\000\004E\000\165\b\026\004.\000\000\000\141\000\165\000\141\002\158\000\165\000\000\002\214\000\000\t6\000\n\000\000\002\218\015N\001*\000\165\002b\000\165\000\000\000\165\000\000\002\209\t>\000\000\002\222\002\209\000\000\003:\002\209\000\000\tF\000\165\021.\000\000\000\000\002\226\000\000\000\165\002\209\002\209\003F\000\165\000\000\003\014\001\190\000\n\000\165\000\000\000\000\000\165\002\146\000\000\015R\003\026\000\165\000\165\000\165\007\234\007\238\007\250\002\209\0122\005R\000\165\000\165\002\209\015^\002\209\021R\000\000\000\165\000\000\000\000\002\209\000\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\165\000\165\000\000\000\000\000\165\000\165\000\000\000\000\015f\001\006\000\000\002\209\000\000\000\000\000\165\0036\002\158\b\226\021^\002\214\000\165\000\165\005f\b\002\002\218\001\n\000\000\b\026\004.\003\018\000\165\000\000\000\165\000\000\016\242\020\242\001\014\001\018\001\022\003V\001\030\001\"\000\000\000\000\003\154\000\000\000\000\000\000\000\000\003Z\000\000\001.\n\218\007\141\000\000\003R\001\190\0016\000\000\000\249\001:\000\000\002\146\000\000\000\249\003\210\025\"\000\000\000\000\003\214\000\000\003\222\005F\002\002\005R\000\000\000\000\001>\001B\001F\001J\001N\000\000\002\006\000\000\001R\005V\000\000\000\000\001V\000\238\000\000\000\000\000\000\005^\005b\000\000\005\162\001Z\000\000\000\000\000\000\000\000\000\249\001^\018\138\003z\000\000\000\000\000\000\000\000\000\249\006\214\001\218\001\154\n\222\000\249\004E\005f\002\146\000\000\001\158\004E\001\162\004.\001\006\000\249\001\166\000\000\001\170\001\174\0036\002\158\n~\005\254\002\214\000\000\005\194\000\000\000\000\002\218\001\n\000\000\000\000\006\n\003\018\000\000\006\218\006\022\000\000\000\000\000\249\001\014\001\018\001\022\003V\001\030\001\"\000\000\000\000\000\249\004E\000\000\000\000\000\000\003Z\000\000\001.\n\218\004E\000\000\003R\001\190\0016\004E\002\194\001:\000\000\002\146\000\000\000\000\003\210\000\000\004E\004E\003\214\000\000\003\222\005F\000\000\005R\000\000\000\000\001>\001B\001F\001J\001N\004q\000\000\000\000\001R\005V\021\174\000\000\001V\000\000\000\000\000\000\004E\005^\005b\000\000\005\162\001Z\000\000\000\000\000\000\004E\000\000\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\001\154\n\222\000\000\000\000\005f\002\209\000\000\001\158\000\000\001\162\004.\001\006\022\030\001\166\000\000\001\170\001\174\0036\002\158\rv\016\226\002\214\000\n\000\000\000\000\016\250\002\218\001\n\000\000\000\000\000\000\003\018\000\000\000\000\022\194\022\210\000\000\002\209\001\014\001\018\001\022\003V\001\030\001\"\002\209\000\000\000\000\000\000\000\000\000\000\002\209\003Z\000\000\001.\n\218\000\000\000\000\003R\001\190\0016\004q\000\000\001:\000\000\002\146\000\000\000\000\003\210\000\000\023\198\000\000\003\214\002\209\003\222\005F\000\000\005R\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\005V\000\000\000\000\001V\000\000\000\000\000\000\000\000\005^\005b\000\000\005\162\001Z\000\000\000\000\000\000\000\000\006\178\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\n\222\000\000\000\000\005f\000\000\000\000\001\158\000\000\001\162\004.\000\000\b\145\001\166\000\006\001\170\001\174\000\246\002\154\002\158\002\162\002\202\002\214\000\000\000\000\000\000\000\000\002\218\000\000\000\000\004y\000\000\b\145\000\000\b\145\b\145\000\000\000\000\000\000\002\222\000\000\003\030\003\"\000\000\000\000\000\000\003\150\000\000\003&\000\000\002\226\000\000\016~\000\000\003\178\003\182\000\000\003\186\003\014\003\198\003\206\006\170\000\000\000\000\016\226\002\146\000\000\000\000\003\026\016\250\001\202\001\206\007\234\007\238\007\250\b\014\000\000\005R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\002\000\000\b\130\001\210\027F\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\017\022\017B\000\000\000\000\027k\014\166\000\000\000\000\000\000\000\000\000\000\001\242\002\130\000\000\000\000\000\000\002~\000\000\002\146\004\006\004\018\021\134\005f\b\002\b\145\004\030\000\000\b\026\004.\t\014\000\006\000\000\000\000\000\246\002\154\002\158\002\162\002\202\002\214\000\000\000\000\000\000\004\"\002\218\000\000\026\002\027\154\000\000\000\000\000\000\003\218\000\000\000\000\000\000\000\000\002\222\000\000\003\030\003\"\000\000\000\000\025\238\003\150\000\000\003&\000\000\002\226\000\000\016~\000\000\003\178\003\182\000\000\003\186\003\014\003\198\003\206\006\170\000\000\000\000\016\226\002\146\000\000\000\000\003\026\016\250\000\000\000\000\007\234\007\238\007\250\b\014\000\000\005R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\002\000\000\b\130\000\000\027F\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\017\022\017B\000\000\000\000\004\129\000\246\000\000\000\000\002\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004y\000\000\000\000\021\134\005f\b\002\014&\0121\0121\b\026\004.\t\014\0121\000\000\0121\0121\003\150\000\000\000\000\000\000\000\000\000\000\016~\0121\000\000\0121\0121\0121\000\000\0121\0121\024F\000\000\000\000\016\226\000\000\000\000\000\000\000\000\016\250\000\000\0121\000\000\000\000\000\000\000\000\000\000\0121\0121\000\000\000\000\0121\000\000\000\000\0121\017\002\0121\000\000\000\000\0121\000\000\000\000\000\000\000\000\0121\0121\0121\000\000\000\000\017\022\017B\000\000\000\000\0121\0121\000\000\000\000\000\000\000\000\000\000\0121\000\000\000\000\000\000\0121\000\000\000\000\0121\000\246\000\000\021\134\002\014\000\000\000\000\0121\0121\0121\000\000\0121\0121\000\000\017\134\000\000\000\000\000\000\000\000\000\000\000\000\0121\000\000\0121\0121\000\000\000\000\002v\0121\000\000\017\138\000\000\000\000\0121\000\000\ne\017\178\0121\ne\0121\0121\ne\ne\000\000\000\000\ne\000\000\ne\016\226\000\000\ne\000\000\000\000\016\250\ne\ne\000\000\ne\ne\000\000\ne\001\202\001\206\000\000\000\000\ne\000\000\000\000\ne\018.\000\000\000\000\000\000\000\000\000\000\000\000\ne\000\000\ne\001\210\000\000\ne\ne\017\022\018B\000\000\000\000\004M\ne\000\000\000\000\ne\000\000\000\000\ne\ne\000\000\ne\000\000\ne\ne\001\242\002\130\000\000\018R\000\000\002~\000\000\002\146\004\006\004\018\000\000\ne\000\000\000\000\004\030\000\000\000\000\000\000\000\000\ne\ne\006\141\000\000\ne\000\000\ne\006\141\000\000\000\000\000\000\005~\004\"\000\000\000\000\004\185\000\000\000\000\ne\ne\000\000\ne\ne\000\000\ne\000\000\ne\000\000\ne\000\000\ne\025\238\ne\b}\b}\000\000\000\000\000\000\b}\000\000\001\206\b}\000\000\000\000\000\000\000\000\006\141\012Q\012=\b}\000\000\b}\b}\b}\006\141\b}\b}\000\000\000\000\006\141\006\141\000\238\000\000\000\000\000\000\012Q\000\000\b}\006\141\006\141\000\000\002\026\000\000\b}\b}\000\000\000\000\b}\002\030\000\000\002z\000\000\b}\000\000\002\"\b}\000\000\002&\012=\000\000\b}\b}\b}\000\000\006\141\000\000\000\000\000\000\000\000\b}\b}\000\000\000\000\006\141\000\000\000\000\b}\000\000\000\000\000\000\004v\000\000\000\000\b}\000\000\000\000\000\000\000\000\000\000\023\166\b}\b}\b}\000\000\b}\b}\000\000\000\000\003\129\012e\000\000\000\000\n\170\000\000\b}\000\000\b}\b}\001\202\001\206\011\n\b}\000\000\000\000\000\000\000\000\b}\003\129\000\000\000\000\b}\003\129\b}\b}\012\r\012\r\002\138\001\226\000\000\012\r\000\000\001\206\012\r\000\000\000\000\001\238\000\000\000\000\000\000\000\000\004\150\000\000\012\r\012\r\012\r\000\000\012\r\012\r\001\242\002r\000\000\000\000\000\000\002~\000\000\002\146\004\006\004\018\012\r\000\000\000\000\000\000\004\030\000\000\012\r\012\r\000\000\000\000\012\r\000\000\000\000\002z\000\000\012\r\012e\012e\012\r\000\000\000\000\004\"\000\000\012\r\012\r\012\r\000\000\000\000\000\000\003\129\000\000\000\000\012\r\012\r\000\000\012e\000\000\012e\000\000\012\r\000\000\000\000\000\000\004v\003\129\000\000\012\r\003\129\000\000\000\000\000\000\000\000\000\000\012\r\012\r\012\r\000\000\012\r\012\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\r\000\000\012\r\012\r\001\202\001\206\000\000\012\r\000\000\000\000\000\000\000\000\012\r\000\000\000\000\000\000\012\r\000\000\012\r\012\r\b\129\b\129\001\210\001\226\002\209\b\129\000\000\001\206\b\129\002\209\000\000\001\238\000\000\000\000\018\130\000\000\b\129\000\000\b\129\b\129\b\129\000\000\b\129\b\129\001\242\019\250\000\000\019\014\000\000\002~\000\000\002\146\004\006\004\018\b\129\000\n\000\000\000\000\020\n\000\000\b\129\b\129\000\000\000\000\b\129\000\000\000\000\002z\002\209\b\129\002\209\000\000\b\129\000\000\000\000\004\"\002\209\b\129\b\129\b\129\000\000\002\209\000\000\002\209\000\000\000\000\b\129\b\129\000\000\000\000\002\209\002\209\000\000\b\129\002\209\002\209\002\209\004v\002\209\000\000\b\129\000\000\000\000\002\209\000\000\000\000\002\209\b\129\b\129\b\129\000\000\b\129\b\129\000\000\000\000\002\209\002\209\000\000\002\209\000\n\000\n\b\129\002\209\b\129\b\129\002\209\002\209\002\209\b\129\002\209\002\209\002\209\002\209\b\129\002\209\002\209\002\209\b\129\000\000\b\129\b\129\002\209\002\209\000\000\002\209\002\209\000\000\002\209\002\209\002\209\002\209\000\n\000\000\002\209\006\174\000\000\002\209\002\209\002\209\000\000\015\006\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\000\000\002\209\000\000\000\000\002\209\002\209\002\209\002\209\002\209\002\209\002\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\002\209\002\209\000\000\000\000\000\000\002\209\002\209\002\209\002\209\002\209\000\000\015B\000\000\000\000\006=\002\209\000!\000\000\000\000\000\000\000!\000!\000\000\000!\000!\000\000\000\000\015N\000\000\000!\002b\000\000\002\209\002\209\006=\000\000\000\000\002\209\002\209\002\209\000\000\000!\000\000\000!\000!\000\000\000\000\000\000\000\000\000\000\000!\000\000\000!\000\000\000\000\000\000\000!\000!\000\000\000!\000!\000!\000!\000!\000\000\000\000\015R\000!\007\025\000\000\000!\007\025\000\000\000\000\000!\000!\000!\000!\000\000\000!\015^\000\000\0212\000\000\000\000\000\000\000\000\007\025\007\025\000!\007\025\007\025\000\000\000\000\000\000\000\000\000!\000!\000!\000!\000!\000\000\000\000\000\000\000\000\0069\015f\000\029\000\000\007\025\000\000\000\029\000\029\000\000\000\029\000\029\021>\000\000\000\000\000\000\000\029\000\000\000\000\000!\000!\0069\000\000\007\025\000!\000!\000!\000\000\000\029\020\242\000\029\000\029\000\000\000\000\000\000\000\000\000\000\000\029\000\000\000\029\000\000\000\000\000\000\000\029\000\029\000\000\000\029\000\029\000\029\000\029\000\029\000\000\000\000\007\025\000\029\007\025\000\000\000\029\000\000\000\000\000\000\000\029\000\029\000\029\000\029\000\000\000\029\005\186\000\000\000\000\007\025\007\025\000\000\000\000\000\000\007\025\000\029\007\025\000\000\000\000\000\000\007\025\000\000\000\029\000\029\000\029\000\029\000\029\000\000\000\000\000\000\000\000\006I\000\000\011\213\000\000\000\000\000\000\011\213\011\213\000\000\011\213\011\213\000\000\000\000\000\000\000\000\011\213\000\000\000\000\000\029\000\029\006I\000\000\000\000\000\029\000\029\000\029\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\000\000\000\000\000\000\011\213\007-\000\000\011\213\007-\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\007-\007-\011\213\007-\007-\000\000\000\000\000\000\000\000\011\213\011\213\011\213\011\213\011\213\000\000\000\000\000\000\000\000\006E\000\000\011\209\000\000\007-\000\000\011\209\011\209\000\000\011\209\011\209\000\000\000\000\000\000\000\000\011\209\000\000\000\000\011\213\011\213\006E\000\000\000\238\011\213\011\213\011\213\000\000\011\209\000\000\011\209\011\209\000\000\000\000\000\000\000\000\000\000\011\209\000\000\011\209\000\000\000\000\000\000\011\209\011\209\000\000\011\209\011\209\011\209\011\209\011\209\000\000\000\000\007-\011\209\007-\000\000\011\209\000\000\000\000\000\000\011\209\011\209\011\209\011\209\000\000\011\209\007-\000\000\000\000\005\194\007-\000\000\000\000\000\000\007-\011\209\007-\000\000\000\000\000\000\007-\000\000\011\209\011\209\011\209\011\209\011\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004M\000\000\000\000\000\000\000\000\000\246\000\000\000\000\002\014\012\017\012\017\000\000\000\000\000\000\012\017\011\209\011\209\012\017\017\134\000\000\011\209\011\209\011\209\012Q\012=\004F\000\000\012\017\012\017\012\017\000\000\012\017\012\017\000\000\017\138\000\000\000\000\000\000\000\000\000\000\017\178\012Q\000\000\012\017\000\000\000\000\000\000\002\026\000\000\012\017\012\017\000\000\016\226\012\017\002\174\000\000\000\000\016\250\012\017\000\000\002\"\012\017\000\000\002&\012=\000\000\012\017\012\017\012\017\000\000\000\000\000\000\000\000\018.\000\000\012\017\012\017\000\000\000\000\000\000\000\000\000\000\012\017\000\000\000\000\000\000\012\017\017\022\018B\012\017\000\000\000\000\004M\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\000\000\000\000\018R\007\153\012\017\000\006\012\017\012\017\007\153\002\154\002\158\012\017\002\202\002\214\000\000\000\000\012\017\000\000\002\218\000\000\012\017\000\000\012\017\012\017\000\000\014:\000\000\000\000\000\000\000\000\002\222\000\000\003\030\003\"\000\000\000\000\000\000\000\000\000\000\003&\000\000\002\226\000\000\000\000\000\000\003\178\003\182\007\153\003\186\003\014\003\198\003\206\006\170\000\000\000\000\007\153\002\146\000\000\000\000\003\026\007\153\007\153\000\238\007\234\007\238\007\250\b\014\000\000\005R\007\153\007\153\001\181\000\000\000\000\000\000\000\000\001\181\000\000\b\130\000\000\000\000\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\000\000\000\000\007\153\000\000\000\000\007\153\000\000\000\000\000\000\000\000\000\000\000\000\003\t\003\t\007\153\000\000\000\000\003\t\000\000\000\000\003\t\000\000\005f\b\002\000\000\001\181\000\000\b\026\004.\t\014\003\t\003\t\003\t\001\181\003\t\003\t\000\000\000\000\001\181\001\181\000\238\000\000\000\000\000\000\000\000\000\000\003\t\001\181\001\181\000\000\000\000\000\000\003\t\004>\000\000\000\000\003\t\000\000\000\000\000\000\000\000\003\t\000\000\000\000\003\t\000\000\000\000\000\000\000\000\003\t\003\t\003\t\000\000\001\181\000\000\000\000\000\000\000\000\003\t\003\t\000\000\000\000\001\181\000\000\000\000\003\t\000\000\nq\000\000\003\t\nq\000\000\003\t\0036\002\158\000\000\000\000\002\214\000\000\003\t\003\t\003\t\002\218\003\t\003\t\000\000\nq\nq\000\000\nq\nq\000\000\000\000\003\t\000\000\003\t\003\t\003:\000\000\000\000\003\t\000\000\000\000\000\000\000\000\003\t\000\000\000\000\nq\003\t\003F\003\t\003\t\003R\001\190\003\133\012e\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\nq\003\214\000\000\003\222\005F\000\000\005R\000\000\003\133\000\000\000\000\000\000\003\133\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\005\162\nq\000\000\nq\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\nq\000\000\000\000\nq\nq\000\000\005f\000\000\nq\000\000\nq\000\000\004.\nm\nq\000\000\nm\000\000\000\000\0036\002\158\012e\012e\002\214\000\000\006z\000\000\000\000\002\218\000\000\000\000\000\000\nm\nm\003\133\nm\nm\000\000\006\154\000\000\012e\000\000\012e\003:\000\000\000\000\b\178\000\000\000\000\003\133\000\000\000\000\003\133\000\000\nm\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\nm\003\214\000\000\003\222\005F\n\138\005R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004i\005V\000\000\000\000\000\000\018\154\001\205\001\205\000\000\005^\005b\001\205\005\162\nm\001\205\nm\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\205\001\205\001\205\nm\001\205\001\205\nm\nm\000\000\005f\000\000\nm\000\000\nm\000\000\004.\001\205\nm\000\000\000\000\018\198\000\000\001\205\001\205\000\000\000\000\001\205\000\000\016\226\000\000\000\000\001\205\000\000\016\250\001\205\000\000\000\000\000\000\000\000\001\205\001\205\001\205\000\000\019\002\000\000\000\000\000\000\000\000\001\205\001\205\000\000\000\000\000\000\000\000\000\000\001\205\000\000\0036\002\158\001\205\000\000\002\214\001\205\006z\000\000\000\000\002\218\000\000\004i\001\205\001\205\001\205\000\000\001\205\001\205\000\000\006\154\019v\000\000\000\000\000\000\003:\000\000\001\205\b\178\001\205\001\205\000\000\000\000\000\000\001\205\000\000\000\000\000\000\003F\001\205\000\000\nz\001\190\004\218\000\000\001\205\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\nI\003\214\000\000\003\222\000\000\n\138\005R\000\000\000\000\012\129\000\000\000\000\000\000\000\000\012\129\000\000\000\000\000\000\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\000\000\n\146\000\000\000\000\0036\002\158\000\000\000\000\002\214\000\000\006z\000\000\000\000\002\218\000\000\nI\n\154\000\000\nI\011\006\000\000\005f\000\000\006\154\012\129\nI\000\000\004.\003:\nI\000\000\b\178\012\129\007\005\000\000\000\000\007\005\012\129\012\129\000\238\000\000\003F\000\000\000\000\nz\001\190\012\129\012\129\000\000\000\000\000\000\002\146\007\005\007\005\003\210\007\005\007\005\nI\003\214\000\000\003\222\000\000\n\138\005R\000\000\000\000\000\000\000\000\005)\005)\000\000\000\000\012\129\005)\007\005\005V\005)\000\000\000\000\000\000\000\000\012\129\000\000\005^\005b\000\000\005)\n\146\005)\000\000\005)\000\000\007\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\nI\005)\000\000\nI\nI\000\000\005f\005)\005)\000\000\nI\000\000\004.\005)\nI\000\000\005)\000\000\000\000\005)\000\000\007\005\000\000\007\005\005)\005)\005)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\005\000\000\000\000\005\194\007\005\005)\005)\000\000\007\005\005)\007\005\000\000\000\000\000\000\007\005\b\141\000\000\000\000\000\000\005)\005)\005)\000\000\005)\005)\000\000\000\000\000\000\000\000\007B\000\000\t\150\000\000\000\000\012\006\b\141\005)\b\141\b\141\005)\005)\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\000\000\000\000\005)\001\202\002^\000\000\000\000\002b\t\254\n\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\014\000\000\000\000\000\000\001\210\001\226\002f\000\000\000\238\000\000\000\000\000\000\000\000\001\238\000\000\000\000\001\006\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\000\000\002j\002r\000\000\n6\000\000\002~\001\n\002\146\004\006\004\018\000\000\000\000\n>\000\000\020\222\000\000\020\226\001\014\001\018\001\022\001\026\001\030\001\"\000\000\000\000\000\000\n^\000\000\nf\n&\001&\004\"\001.\0012\b\141\nF\000\000\000\000\0016\000\000\015f\001:\000\000\nN\nV\000\000\000\000\000\000\000\000\000\000\020\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\020\242\000\000\000\000\001V\000\000\005\029\005\029\000\000\000\000\000\000\005\029\000\000\001Z\005\029\000\000\000\000\000\000\000\000\001^\000\000\000\000\000\000\000\000\005\029\000\000\005\029\000\000\005\029\001\154\000\000\000\000\000\000\000\000\000\000\000\000\001\158\000\000\001\162\000\000\005\029\000\000\001\166\000\000\001\170\001\174\005\029\005\029\000\000\000\000\000\000\000\000\007\174\000\000\000\000\005\029\000\000\000\000\005\029\000\000\000\000\000\000\000\000\005\029\005\029\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\005\029\005\029\003I\003I\005\029\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\000\000\005\029\005\029\005\029\000\000\005\029\005\029\003I\000\000\003I\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\005\029\000\000\000\000\005\029\005\029\003I\000\000\000\000\000\000\000\000\000\000\003I\003I\000\000\000\000\005\029\000\000\004\233\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\000\000\000\000\003I\003I\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\003I\003I\000\000\003I\003I\b\t\b\t\000\000\000\000\004\233\b\t\000\000\000\000\b\t\000\000\000\000\003I\000\000\000\000\000\000\003I\000\000\000\000\b\t\000\000\b\t\000\000\b\t\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\t\000\000\000\000\000\000\000\000\000\000\b\t\b\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\t\000\000\000\000\b\t\000\000\000\000\000\000\000\000\b\t\b\t\b\t\000\000\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\t\000\000\012\193\012\193\b\t\000\000\000\000\012\193\000\000\000\000\012\193\000\000\000\000\000\000\b\t\b\t\b\t\000\000\b\t\b\t\012\193\000\000\012\193\000\000\012\193\000\000\000\000\000\000\b\t\000\000\000\000\b\t\000\000\000\000\000\000\b\t\012\193\000\000\000\000\000\000\000\000\000\000\012\193\012\193\004\218\000\000\b\t\000\000\004N\000\000\000\000\012\193\000\000\000\000\012\193\000\000\000\000\000\000\000\000\012\193\012\193\012\193\000\000\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\193\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\193\012\193\012\193\000\000\012\193\012\193\012\197\012\197\000\000\000\000\004^\012\197\000\000\000\000\012\197\000\000\000\000\012\193\000\000\000\000\000\000\012\193\000\000\000\000\012\197\000\000\012\197\000\000\012\197\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\197\000\000\000\000\000\000\000\000\000\000\012\197\012\197\000\000\000\000\000\000\000\000\004N\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\197\000\000\000\000\000\000\012\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\197\012\197\012\197\000\000\012\197\012\197\003I\003I\000\000\000\000\004^\003I\000\000\000\000\003I\000\000\000\000\012\197\000\000\000\000\000\000\012\197\000\000\000\000\003I\000\000\003I\000\000\003I\000\000\000\000\000\000\012\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\003I\003I\000\000\000\000\000\000\000\000\004\237\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\000\000\000\000\003I\003I\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\003I\007\149\000\000\000\000\000\000\006\161\007\149\000\000\000\000\000\000\003I\003I\003I\000\000\003I\003I\000\000\000\000\000\000\000\000\004\237\t\150\000\000\000\000\006\161\000\000\000\000\003I\006\161\000\000\000\000\003I\000\000\t\206\t\230\t\238\t\214\t\246\000\000\000\000\000\000\000\000\003I\000\000\000\000\007\149\000\000\t\254\n\006\000\000\000\000\000\000\000\000\007\149\000\000\000\000\n\014\000\000\007\149\007\149\000\238\000\000\000\000\000\000\000\238\000\000\000\000\007\149\007\149\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\001\189\000\000\000\000\006\161\n6\001\189\000\000\001\206\001\189\007\149\000\000\000\000\007\149\n>\000\000\000\000\bi\000\000\001\189\000\000\000\000\007\149\001\189\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\000\000\000\000\000\000\001\189\000\000\nF\000\000\012)\000\000\001\189\001\189\000\000\012)\nN\nV\012)\002z\000\000\001\189\000\000\000\000\001\189\000\000\000\000\000\000\012)\001\189\001\189\001\189\012)\000\000\000\000\003-\000\000\000\000\0121\000\000\003-\000\000\001\206\003-\012)\001\189\001\189\000\000\000\000\004v\012)\be\000\000\003-\000\000\000\000\000\000\003-\000\000\001\189\001\189\000\000\012)\001\189\001\189\000\000\000\000\012)\012)\003-\000\000\000\000\000\000\001\189\000\000\003-\001\185\000\000\000\000\000\000\001\189\000\000\002z\012)\003-\001\189\000\000\003-\000\000\000\000\000\000\001\189\003-\003-\003-\000\000\000\000\012)\012)\002Z\000\000\012)\012)\000\000\000\000\000\000\000\000\000\000\003-\003-\000\000\012)\004v\000\000\000\000\026b\000\000\000\000\012)\000\000\000\000\0162\003-\003-\000\000\000\000\003-\003-\000\000\012)\000\000\000\000\000\000\000\000\000\000\000\000\003-\t\150\000\000\000\000\000\000\0166\000\000\003-\000\000\000\000\000\000\000\000\003-\t\206\t\230\t\238\t\214\t\246\003-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\254\n\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\014\000\000\000\000\000\000\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\t\158\t\222\n\022\n\030\n.\000\000\000\149\000\000\000\000\000\000\000\000\000\149\n6\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\n>\000\000\000\000\000\149\000\000\000\149\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\n^\016:\nf\n&\016J\000\149\000\000\000\000\000\000\nF\000\000\000\149\000\000\000\000\000\000\000\149\000\000\nN\nV\000\000\000\149\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\149\000\149\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\149\000\149\000\000\000\000\000\000\000\000\000\000\000\149\000\000\000\000\000\217\000\149\000\000\000\000\000\000\000\217\000\000\000\000\000\217\000\000\000\000\000\149\000\149\000\000\000\000\000\149\000\149\000\000\000\217\000\000\000\217\000\000\000\217\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\149\000\149\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\217\000\149\000\000\000\149\000\217\000\000\000\000\000\000\000\000\000\217\000\000\000\000\000\217\000\000\000\000\000\000\000\000\000\217\000\217\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\217\000\217\000\000\000\000\000\000\000\000\000\000\000\217\000\000\000\000\000\157\000\217\000\000\000\000\000\000\000\157\000\000\000\000\000\157\000\000\000\000\000\217\000\217\000\000\000\000\000\217\000\217\000\000\000\157\000\000\000\157\000\000\000\157\000\000\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\217\000\217\000\000\000\157\000\000\000\000\000\000\000\000\000\000\000\157\000\217\000\000\000\217\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\000\000\000\000\000\000\000\000\000\157\000\000\000\000\000\153\000\157\000\000\000\000\000\000\000\153\000\000\000\000\000\153\000\000\000\000\000\157\000\157\000\000\000\000\000\157\000\157\000\000\000\153\000\000\000\153\000\000\000\153\000\000\000\000\000\157\000\000\000\000\000\000\000\000\000\000\000\157\000\157\000\000\000\153\006}\006}\000\000\000\000\000\000\000\153\000\157\000\000\000\157\000\153\000\000\000\000\000\000\000\000\000\153\000\000\004\022\000\153\006}\006}\000\000\000\000\000\153\000\153\000\238\000\000\000\000\006}\001\129\000\000\000\000\000\153\000\153\001\129\000\000\000\000\001\129\000\000\000\153\000\000\006}\006}\000\153\000\000\000\000\006}\001\129\006}\006}\006}\001\129\000\000\000\153\000\153\006}\000\000\000\153\000\153\000\000\000\000\000\000\000\000\001\129\001\129\000\000\000\000\000\153\000\000\001\129\000\000\000\000\006}\000\153\000\153\004\233\000\000\000\000\001\129\000\000\000\000\001\129\000\000\000\153\000\000\000\153\001\129\001\129\001\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\001\129\000\000\000\000\000\000\001\129\000\000\004\n\000\000\006}\000\000\000\000\000\000\000\000\000\000\001\129\001\129\000\000\000\000\001\129\001\129\000\000\012\189\012\189\000\000\004\233\000\000\012\189\000\000\001\129\012\189\000\000\000\000\000\000\000\000\001\129\001\129\000\000\000\000\000\000\012\189\001\129\012\189\000\000\012\189\000\000\000\000\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\000\000\000\000\000\000\000\000\012\189\012\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\000\000\012\189\000\000\000\000\000\000\000\000\012\189\012\189\012\189\000\000\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\189\000\000\012\185\012\185\012\189\000\000\000\000\012\185\000\000\000\000\012\185\000\000\000\000\000\000\012\189\012\189\012\189\000\000\012\189\012\189\012\185\000\000\012\185\000\000\012\185\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\000\000\000\000\012\189\012\185\000\000\000\000\000\000\000\000\000\000\012\185\012\185\004\218\000\000\012\189\000\000\000\000\000\000\000\000\012\185\000\000\000\000\012\185\000\000\000\000\000\000\000\000\012\185\012\185\012\185\000\000\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\185\000\000\b\r\b\r\012\185\000\000\000\000\b\r\000\000\000\000\b\r\000\000\000\000\000\000\012\185\012\185\012\185\000\000\012\185\012\185\b\r\000\000\b\r\000\000\b\r\000\000\000\000\000\000\007\030\000\000\000\000\012\185\000\000\000\000\000\000\012\185\b\r\000\000\000\000\000\000\000\000\000\000\b\r\b\r\000\000\000\000\012\185\000\000\000\000\000\000\000\000\b\r\000\000\000\000\b\r\000\000\000\000\000\000\000\000\b\r\b\r\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\134\000\000\n\158\000\000\000\000\000\000\b\r\000\000\001\202\001\206\b\r\000\000\000\000\000\000\000\000\000\000\t\150\000\000\000\000\012\006\b\r\b\r\b\r\b\141\b\r\b\r\001\210\001\226\t\206\t\230\t\238\t\214\t\246\000\000\b\r\001\238\000\000\b\r\000\000\000\000\000\000\b\r\t\254\n\006\000\000\000\000\000\000\000\000\001\242\002r\000\000\n\014\b\r\002~\000\000\002\146\004\006\004\018\000\000\000\238\000\000\000\000\004\030\000\000\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\001\185\000\000\000\000\004\"\n6\001\185\000\000\001\206\001\185\000\000\000\000\000\000\000\000\n>\000\000\000\000\be\000\000\001\185\000\000\000\000\000\000\001\185\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\000\000\000\000\000\000\001\185\000\000\nF\000\000\000\000\004*\001\185\004.\000\000\000\000\nN\nV\000\000\002z\000\000\001\185\000\000\000\000\001\185\000\000\000\000\000\000\000\000\001\185\001\185\001\185\000\000\000\000\000\000\001i\000\000\000\000\000\000\000\000\001i\000\000\0121\001i\000\000\001\185\001\185\000\000\000\000\004v\000\000\0121\000\000\001i\000\000\001i\000\000\001i\000\000\001\185\001\185\000\000\000\000\001\185\001\185\000\000\000\000\000\000\000\000\001i\000\000\000\000\000\000\001\185\000\000\001i\0121\000\000\000\000\000\000\001\185\000\000\0121\000\000\000\000\001\185\000\000\001i\000\000\000\000\000\000\001\185\001i\001i\001i\000\000\000\000\000\000\005U\005U\000\000\000\000\000\000\005U\000\000\000\000\005U\000\000\001i\000\000\000\000\000\000\0121\000\000\000\000\000\000\005U\000\000\005U\000\000\005U\000\000\001i\001i\001i\000\000\001i\001i\000\000\000\000\000\000\000\000\005U\000\000\000\000\000\000\000\000\000\000\005U\005U\000\000\000\000\019\254\001i\007\174\000\000\000\000\005U\000\000\000\000\005U\000\000\000\000\000\000\001i\005U\005U\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\005U\000\000\005Q\006\242\005U\000\000\000\000\005Q\000\000\000\000\005Q\000\000\000\000\000\000\005U\005U\005U\000\000\005U\005U\005Q\000\000\005Q\000\000\005Q\000\000\000\000\000\000\000\000\000\000\000\000\005U\000\000\000\000\000\000\005U\005Q\000\000\000\000\000\000\000\000\000\000\005Q\007^\000\000\000\000\005U\000\000\000\000\000\000\000\000\005Q\000\000\000\000\005Q\000\000\000\000\000\000\000\000\005Q\005Q\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\005Q\000\000\005m\005m\005Q\000\000\000\000\005m\000\000\000\000\005m\000\000\000\000\000\000\005Q\005Q\005Q\000\000\005Q\005Q\005m\000\000\005m\000\000\005m\000\000\000\000\000\000\000\000\000\000\000\000\005Q\000\000\000\000\000\000\005Q\005m\000\000\000\000\000\000\000\000\000\000\005m\005m\000\000\000\000\005Q\000\000\000\000\000\000\000\000\005m\000\000\000\000\005m\000\000\000\000\000\000\000\000\005m\005m\005m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005m\000\000\005i\006\242\005m\000\000\000\000\005i\000\000\000\000\005i\000\000\000\000\000\000\005m\005m\005m\000\000\005m\005m\005i\000\000\005i\000\000\005i\000\000\000\000\000\000\000\000\000\000\000\000\005m\000\000\000\000\000\000\005m\005i\000\000\000\000\000\000\000\000\000\000\005i\007^\000\000\000\000\007V\000\000\000\000\000\000\000\000\005i\000\000\000\000\005i\000\000\000\000\000\000\000\000\005i\005i\000\238\004E\000\000\000\000\000\000\000\000\004E\0036\002\158\004E\000\000\002\214\000\000\006z\005i\000\000\002\218\000\000\005i\004E\000\000\000\000\000\000\004E\000\000\000\000\006\154\000\000\005i\005i\005i\003:\005i\005i\b\178\004E\000\000\000\000\000\000\000\000\000\000\004E\000\000\000\000\003F\005i\000\000\nz\001\190\005i\004E\000\000\011\226\004E\002\146\000\000\000\000\003\210\004E\002\194\005i\003\214\000\000\003\222\000\000\n\138\005R\000\000\t\150\000\000\000\000\000\000\000\000\000\000\004E\011\230\000\000\000\000\005V\000\000\t\206\t\230\t\238\t\214\t\246\000\000\005^\005b\004E\004E\n\146\000\000\004E\004E\t\254\n\006\000\000\000\000\007B\000\000\000\000\000\000\000\000\n\014\000\000\n\154\000\000\000\000\n\166\004E\005f\000\238\000\000\000\000\021\006\000\000\004.\011\226\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n6\t\150\000\000\000\000\000\000\000\000\000\000\000\000\012\190\n>\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\t\254\n\006\000\000\000\000\000\000\nF\000\000\000\000\000\000\n\014\000\000\000\000\000\000\nN\nV\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\003)\000\000\000\000\000\000\n6\003)\000\000\001\206\003)\000\000\000\000\000\000\000\000\n>\000\000\000\000\000\000\000\000\003)\000\000\000\000\000\000\003)\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\000\000\000\000\000\000\003)\000\000\nF\000\000\000\000\000\000\003)\000\000\000\000\000\000\nN\nV\000\000\002z\000\000\003)\000\000\000\000\003)\000\000\000\000\000\000\000\000\003)\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\000\003)\003)\000\000\000\000\004v\n\170\000\000\000\000\000\000\000\000\000\246\001\202\001\206\002\014\003)\003)\000\000\000\000\003)\003)\000\000\000\000\000\000\017\134\000\000\000\000\000\000\004M\003)\001\210\001\226\000\000\000\000\000\000\000\000\003)\000\000\000\000\001\238\017\138\003)\000\000\000\000\000\000\000\000\017\178\003)\000\000\000\000\000\000\0071\001\242\002r\0071\000\000\000\000\002~\016\226\002\146\004\006\004\018\000\000\016\250\0011\000\000\004\030\000\000\000\000\0011\0071\0071\0011\0071\0071\000\000\000\000\000\000\000\000\018.\000\000\000\000\0011\004\"\0011\000\000\0011\000\000\000\000\000\000\000\000\000\000\0071\017\022\018B\000\000\000\000\000\000\0011\000\000\000\000\000\000\000\000\000\000\0011\000\000\000\000\000\000\0011\000\000\000\238\000\000\000\000\0011\018R\000\000\0011\000\000\000\000\000\000\000\000\0011\0011\000\238\000\000\000\000\000\000\001-\000\000\000\000\000\000\0011\001-\000\000\000\000\001-\000\000\0011\000\000\000\000\0071\0011\0071\000\000\000\000\001-\000\000\001-\000\000\001-\000\000\0011\0011\0011\0071\0011\0011\005\194\0071\000\000\000\000\001-\0071\000\000\0071\0011\000\000\001-\0071\000\000\000\000\001-\0011\000\000\000\000\000\000\001-\000\000\000\000\001-\000\000\000\000\000\000\0011\001-\001-\000\238\000\000\000\000\000\000\001m\000\000\000\000\000\000\001-\001m\000\000\0125\001m\000\000\001-\000\000\000\000\000\000\001-\000\000\0125\000\000\001m\000\000\001m\000\000\001m\000\000\001-\001-\001-\000\000\001-\001-\000\000\000\000\000\000\000\000\001m\000\000\000\000\000\000\001-\000\000\001m\0125\000\000\000\000\000\000\001-\000\000\0125\000\000\000\000\000\000\000\000\001m\000\000\000\000\000\000\001-\001m\001m\001m\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\001\029\000\000\000}\001\029\000\000\001m\000\000\000\000\000\000\0125\000\000\000}\000\000\001\029\000\000\001\029\000\000\001\029\000\000\001m\001m\001m\000\000\001m\001m\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\001\029\000}\000\000\000\000\000\000\001m\000\000\000}\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\001m\001\029\001\029\001\029\001\197\000\000\000\000\000\000\000\000\001\197\000\000\015N\001\197\000\000\002b\000\000\000\000\001\029\000\000\000\000\000\000\000}\001\197\000\000\000\000\000\000\001\197\000\000\000\000\000\000\000\000\001\029\001\029\001\029\000\000\001\029\001\029\000\000\001\197\001\202\001\206\000\000\000\000\000\000\001\197\000\000\000\000\000\000\000\000\000\000\015R\000\000\001\029\001\197\000\000\015b\001\197\001\210\001\226\000\000\000\000\001\197\001\197\001\029\015^\000\000\001\238\000\000\000\000\000\000\000\000\000\000\000\000\001\246\000\000\000\000\000\000\001\197\0009\001\242\002r\001\197\000\000\0009\002~\0009\002\146\004\006\004\018\000\000\015f\001\197\001\197\004\030\0009\001\197\001\197\0009\000\000\000\000\000\000\0009\b)\000\000\000\000\001\197\000\000\000\000\000\000\000\000\004\"\000\000\001\197\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\000\000\000\0009\001\197\000\000\0009\000\000\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\0009\0009\0009\000\000\000\000\000\000\000\000\000\000\000\000\0009\0009\004*\000\000\004.\000\000\0036\002\158\000\000\000\000\002\214\0009\006z\000\000\0009\002\218\000\000\000\000\000\000\004E\000\000\000\000\004E\0009\000\000\006\154\0009\000\000\000\000\000\000\003:\b)\004E\b\178\000\000\0009\000\000\000\000\0009\000\000\000\000\b\246\000\000\003F\000\000\000\000\rr\001\190\004E\000\000\000\000\0009\000\000\002\146\004E\000\000\003\210\000\000\000\000\000\000\003\214\004E\003\222\004E\n\138\005R\004E\000\000\000\000\004E\000\000\004E\002\194\000\000\000\000\000\000\000\000\005V\000\000\004E\000\000\000\000\000\000\004E\000\000\005^\005b\004E\000\000\000\000\000\000\004E\000\000\000\000\000\000\004E\000\000\000\000\000\000\000\000\000\000\004E\004E\000\000\000\000\004E\000\000\r\130\000\000\005f\004E\000\000\000\000\004E\000\000\004.\000\000\000\000\004E\002\194\000\238\000\000\004E\000\000\003!\000\000\000\000\004E\004E\003!\000\000\000\000\003!\000\000\004E\004E\000\000\000\000\004E\000\000\000\000\000\000\003!\000\000\000\000\000\000\003!\000\000\004E\004E\000\000\000\000\004E\004E\000\000\000\000\000\000\000\000\003!\015n\000\000\000\000\004E\000\000\003!\000\000\000\000\004E\000\000\004E\004E\000\000\000\000\003!\025j\000\000\003!\000\000\000\000\000\000\004E\003!\003!\003!\004E\000\000\0036\002\158\000\000\000\000\002\214\000\000\006z\000\000\000\000\002\218\004E\003!\000\000\000\000\000\000\003!\004E\000\000\000\000\006\154\000\000\000\000\004N\000\000\003:\003!\003!\b\178\004E\003!\003!\000\000\000\000\004E\002\194\023.\000\000\003F\000\000\003!\003R\001\190\000\000\000\000\000\000\015\206\003!\002\146\000\000\004E\003\210\003!\000\000\000\000\003\214\000\000\003\222\003!\n\138\005R\000\000\000\000\000\000\004E\004E\000\000\000\000\004E\004E\000\000\000\000\005V\000\000\004^\000\000\000\000\000\000\007\030\000\000\005^\005b\0036\002\158\021\158\004E\002\214\000\000\006z\000\000\000\000\002\218\000\000\000\000\000\000\000\000\004E\000\000\000\000\000\000\000\000\006\154\023\250\000\000\005f\000\000\003:\000\000\000\000\b\178\004.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\nz\001\190\000\000\000\000\000\000\000\000\000\000\002\146\006y\006y\003\210\000\000\000\000\000\000\003\214\000\000\003\222\000\000\n\138\005R\000\000\000\000\000\000\000\000\000\000\000\000\006y\006y\000\000\000\000\000\000\005V\000\000\000\000\000\000\006y\000\000\000\000\000\000\005^\005b\0036\002\158\n\146\000\000\002\214\000\000\006z\006y\006y\002\218\000\000\000\000\006y\000\000\006y\006y\006y\000\000\000\000\006\154\0226\006y\005f\000\000\003:\000\000\000\000\b\178\004.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003F\006y\000\000\nz\001\190\005\154\000\000\000\000\000\000\000\000\002\146\0036\002\158\003\210\000\000\002\214\000\000\003\214\000\000\003\222\002\218\n\138\005R\000\000\000\000\005\158\000\000\003\218\000\000\000\000\000\000\000\000\000\000\000\000\005V\003:\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\004\194\000\000\n\146\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\022\150\003\214\005f\003\222\005F\000\000\005R\000\000\004.\000\000\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\005V\000\000\000\000\0036\002\158\000\000\000\000\002\214\005^\005b\000\000\005\162\002\218\000\000\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003:\000\000\005\234\000\000\000\000\005f\000\000\006f\000\000\b\154\000\000\004.\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\011\241\000\000\003\214\011\241\003\222\005F\000\000\005R\002\209\002\209\000\000\000\000\002\209\011\241\000\000\000\000\000\000\002\209\000\000\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\011\241\005\162\000\000\002\209\000\n\000\000\011\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\241\002\209\000\000\011\241\002\209\002\209\000\000\005f\011\241\b\169\000\000\002\209\000\000\004.\002\209\000\000\000\000\002\209\002\209\000\000\002\209\002\209\000\000\002\209\011\241\004-\004-\000\000\011\241\004-\000\000\000\000\000\000\000\000\004-\002\209\000\000\000\000\011\241\011\241\004-\000\000\011\241\002\209\002\209\000\000\002\209\000\000\027f\004-\022\230\000\000\000\000\022\254\000\000\000\000\000\000\000\000\000\000\011\241\000\000\000\000\004-\000\000\000\000\004-\004-\002\209\000\000\000\000\000\000\002\209\004-\002\209\000\000\004-\000\000\000\000\000\238\004-\003!\004-\004-\000\000\004-\003!\000\000\000\000\003!\003!\000\000\000\000\000\000\000\000\003!\000\000\004-\003!\003!\000\000\000\000\000\000\003!\000\000\004-\004-\000\000\003!\000\000\000\000\000\000\003!\000\000\000\000\003!\015n\000\000\000\000\000\000\000\000\003!\000\000\000\000\003!\015n\000\000\000\000\000\000\004-\003!\000\000\000\000\003!\000\000\004-\000\000\000\000\003!\003!\003!\003!\003!\000\000\000\000\000\000\003!\003!\003!\003!\000\000\000\000\000\000\000\000\003!\000\000\000\000\000\000\003!\003!\000\000\000\000\000\000\003!\000\000\000\000\000\000\003!\003!\003!\025r\000\000\003!\003!\000\000\003!\015n\003!\003!\025\162\000\000\003!\003!\000\000\000\000\000\000\000\000\012)\015\206\003!\003!\000\000\012)\003!\003!\012)\000\000\015\206\003!\003!\003!\000\000\000\000\003!\000\000\012)\000\000\000\000\000\000\012)\000\000\000\000\000\000\000\000\003!\0121\000\000\000\000\003!\000\000\000\000\012)\000\000\000\000\000\000\000\000\000\000\012)\003!\003!\017R\000\000\003!\003!\000\000\000\000\012)\000\000\000\000\012)\000\000\000\000\000\000\000\000\012)\012)\0036\002\158\015\206\003!\002\214\000\000\006z\000\000\000\000\002\218\000\000\000\000\000\000\000\000\012)\000\000\000\000\000\000\012)\006\154\000\000\000\000\000\000\000\000\003:\000\000\000\000\b\178\012)\012)\002Z\000\000\012)\012)\000\000\000\000\000\000\003F\000\000\000\000\b\222\001\190\012)\005\001\000\000\000\000\026\154\002\146\005\001\012)\003\210\005\001\000\000\000\000\003\214\000\000\003\222\000\000\n\138\005R\012)\005\001\000\000\000\000\000\000\005\001\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\000\000\000\000\005\001\000\000\005^\005b\000\000\000\000\005\001\000\000\000\000\000\000\000\000\000\000\007\174\000\000\000\000\005\001\000\000\000\000\005\001\000\000\000\000\000\000\000\000\005\001\005\001\000\238\005f\000\000\000\000\005\005\000\000\000\000\004.\000\000\005\005\000\000\000\000\005\005\000\000\005\001\005\001\000\000\000\000\005\001\000\000\000\000\000\000\005\005\000\000\000\000\000\000\005\005\000\000\005\001\005\001\000\000\000\000\005\001\005\001\000\000\000\000\000\000\000\000\005\005\012\201\012\201\000\000\000\000\000\000\005\005\000\000\000\000\000\000\000\000\005\001\007\174\000\000\000\000\005\005\000\000\000\000\005\005\012\201\012\201\007\006\005\001\005\005\005\005\000\238\000\000\000\000\012\201\005\177\000\000\000\000\000\000\000\000\005\177\000\000\000\000\005\177\000\000\005\005\005\005\012\201\012\201\005\005\000\000\000\000\012\201\005\177\012\201\012\201\012\201\005\177\000\000\005\005\005\005\012\201\000\000\005\005\005\005\000\000\000\000\000\000\000\000\005\177\000\000\000\000\000\000\000\000\000\000\005\177\000\000\000\000\012\201\000\000\005\005\000\000\000\000\000\000\005\177\000\000\000\000\005\177\000\000\000\000\000\000\005\005\005\177\005\177\000\238\025J\000\000\000\000\000\000\000\000\000\000\0036\002\158\000\000\000\000\002\214\000\000\000\000\005\177\000\000\002\218\000\000\005\177\000\000\000\000\000\000\000\000\006&\000\000\000\000\000\000\000\000\005\177\005\177\021*\003:\005\177\005\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\177\000\000\003F\000\000\000\000\003R\001\190\005\177\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\005\177\003\214\000\000\003\222\005F\005\249\005R\000\000\000\000\000\000\000\000\000\000\002\158\000\000\000\000\002\214\000\000\000\000\005V\000\000\002\218\000\000\000\000\000\000\000\000\005\249\005^\005b\000\000\005\162\000\000\000\000\002\222\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\226\000\000\000\000\000\000\000\000\000\000\000\000\005f\003\014\001\190\000\000\b\154\000\000\004.\000\000\002\146\000\000\000\000\003\026\001\202\001\206\000\000\007\234\007\238\007\250\000\000\000\000\005R\000\000\000\000\000\000\000\000\000\000\002n\000\000\005\198\000\000\001\210\001\226\000\000\000\000\0036\002\158\000\000\000\000\002\214\001\238\005^\005b\000\000\002\218\000\000\000\000\001\246\000\000\000\000\000\000\000\000\000\000\001\242\002r\000\000\000\000\000\000\002~\003:\002\146\004\006\004\018\000\000\000\000\005f\b\002\004\030\000\000\000\000\b\026\004.\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\006\002\000\000\002\146\000\000\004\"\003\210\0036\002\158\000\000\003\214\002\214\003\222\005F\000\000\005R\002\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\003:\000\000\000\000\015V\005^\005b\000\000\005\162\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\005f\000\000\003\214\006\014\003\222\005F\004.\005R\000\000\0036\002\158\000\000\000\000\002\214\000\000\000\000\000\000\000\000\002\218\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\005\162\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\003F\000\000\000\000\003R\001\190\005f\000\000\000\000\005\253\000\000\002\146\004.\000\000\003\210\0036\002\158\000\000\003\214\002\214\003\222\005F\000\000\005R\002\218\000\000\000\000\000\000\000\000\005\253\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\003:\000\000\000\000\000\000\005^\005b\000\000\005\162\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\005f\000\000\003\214\011r\003\222\005F\004.\005R\000\000\0036\002\158\000\000\000\000\002\214\000\000\000\000\000\000\000\000\002\218\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\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\003F\000\000\000\000\003R\001\190\005f\000\000\000\000\011~\000\000\002\146\004.\000\000\003\210\0036\002\158\000\000\003\214\002\214\003\222\005F\000\000\005R\002\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\003:\000\000\000\000\000\000\005^\005b\000\000\005\162\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\005f\000\000\003\214\011\138\003\222\005F\004.\005R\000\000\0036\002\158\000\000\000\000\002\214\006!\000\000\000\000\000\000\002\218\005V\000\000\002\158\000\000\000\000\002\214\000\000\000\000\005^\005b\002\218\005\162\000\000\000\000\003:\006!\000\000\000\000\000\000\000\000\000\000\000\000\002\222\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\005f\002\226\000\000\000\000\000\000\002\146\004.\000\000\003\210\003\014\001\190\000\000\003\214\000\000\003\222\005F\002\146\005R\000\000\003\026\000\000\000\000\000\000\007\234\007\238\007\250\000\000\000\000\005R\005V\000\000\000\000\000\000\000\000\006\169\006\242\000\000\005^\005b\006\169\005\162\000\000\006\169\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\000\000\006\169\000\000\000\000\000\000\006\169\000\000\000\000\000\000\000\000\005f\000\000\000\000\000\000\000\000\000\000\004.\006\169\000\000\000\000\000\000\005f\b\002\006\169\007^\000\000\b\026\004.\001\153\000\000\000\000\000\000\006\169\001\153\000\000\006\169\001\153\000\000\000\000\000\000\006\169\006\169\000\238\000\000\000\000\000\000\001\153\000\000\000\000\000\000\001\153\000\000\000\000\000\000\000\000\000\000\006\169\000\000\000\000\000\000\006\169\000\000\001\153\000\000\000\000\000\000\000\000\000\000\001\153\000\000\006\169\006\169\000\000\000\000\006\169\006\169\000\000\001\153\000\000\000\000\001\153\000\000\000\000\000\000\000\000\001\153\001\153\001\153\001\201\000\000\005\181\006\169\000\000\001\201\000\000\005\181\001\201\000\000\005\181\000\000\000\000\001\153\000\000\000\000\000\000\001\153\001\201\000\000\005\181\000\000\001\201\000\000\005\181\000\000\000\000\001\153\001\153\000\000\000\000\001\153\001\153\000\000\001\201\000\000\005\181\017b\000\000\000\000\001\201\000\000\005\181\000\000\000\000\000\000\000\000\000\000\001\153\001\201\000\000\005\181\001\201\001\153\005\181\000\000\000\000\001\201\001\201\005\181\005\181\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\201\000\000\005\181\000\000\001\201\000\000\005\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\201\001\201\005\181\005\181\001\201\001\201\005\181\005\181\000\000\000\000\000\000\000\000\000\000\000\000\001\201\011\225\005\181\002\158\011\225\000\000\027N\001\201\000\000\005\181\000\000\027R\021\006\000\000\011\225\000\000\000\000\000\000\001\201\000\000\005\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\225\000\000\000\000\000\000\000\000\000\000\011\225\000\000\000\000\000\000\000\000\004E\001\002\001\190\000\000\011\225\004E\000\000\011\225\004E\000\000\000\000\000\000\011\225\000\000\000\000\000\000\000\000\000\000\004E\000\000\027V\000\000\004E\000\000\000\000\000\000\000\000\000\000\011\225\000\000\000\000\000\000\011\225\000\000\004E\000\000\000\000\000\000\000\000\000\000\004E\027Z\011\225\011\225\000\000\000\000\011\225\000\000\000\000\004E\000\000\000\000\004E\000\000\000\000\000\000\000\000\004E\002\194\000\000\000\000\000\000\000\000\011\225\000\000\000\000\007\201\007\201\000\000\000\000\007\201\000\000\000\000\004E\000\000\007\201\000\000\004E\000\000\000\000\000\000\015\250\000\000\000\000\000\000\000\000\000\000\004E\004E\000\000\007\201\004E\004E\006\242\000\000\000\000\000\000\004E\000\000\000\000\004E\007\030\000\000\007\201\000\000\000\000\007\201\007\201\004E\004E\004E\000\000\000\000\007\201\004E\000\000\007\201\004E\000\000\004E\007\201\000\000\007\201\007\201\000\000\007\201\004E\004E\000\000\000\000\000\000\004E\004E\007^\000\000\000\000\000\000\007\201\000\000\000\000\000\000\000\000\000\000\004E\004E\007\201\007\201\000\000\000\000\004E\002\194\000\238\000\000\000\000\000\000\007\174\000\000\000\000\004E\000\000\000\000\004E\000\000\000\000\000\000\004E\004E\002\194\000\238\007\201\000\000\000\000\000\000\001U\000\000\007\201\000\000\000\000\001U\004E\004E\001U\004E\004E\004E\000\000\004E\000\000\000\000\000\000\000\000\001U\000\000\001U\000\000\001U\004E\004E\000\000\000\000\004E\004E\001\202\001\206\022:\000\000\000\000\001U\000\000\000\000\000\000\004E\000\000\001U\000\000\000\000\000\000\004E\000\205\000\000\002\138\001\226\000\000\000\205\000\000\001U\000\205\000\000\000\000\001\238\001U\001U\000\238\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\205\000\000\001\242\002r\000\000\000\000\001U\002~\000\000\002\146\004\006\004\018\000\205\000\000\000\000\000\000\004\030\000\000\000\205\000\000\001U\001U\001U\000\000\001U\001U\000\000\000\205\000\000\000\000\000\205\000\000\000\000\004\"\000\000\000\205\000\205\000\238\000\000\000\000\000\000\001U\000\209\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\209\000\205\001U\000\000\000\000\000\205\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\000\000\209\000\205\000\205\000\000\000\000\000\205\000\205\000\000\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\000\004M\000\000\000\209\000\000\000\000\000\246\000\205\006\165\002\014\000\000\000\000\000\209\006\165\000\000\000\209\006\165\000\000\000\205\017\134\000\209\000\209\000\238\004M\000\000\000\000\006\165\000\000\000\000\000\000\006\165\000\000\000\000\000\000\000\000\017\138\000\209\000\000\000\000\000\000\000\209\017\178\006\165\000\000\000\000\000\000\000\000\000\000\006\165\000\000\000\209\000\209\000\000\016\226\000\209\000\209\000\000\006\165\016\250\000\000\006\165\000\000\000\000\000\000\000\000\006\165\006\165\000\000\005\169\000\000\000\000\000\209\000\000\005\169\018.\000\000\005\169\000\000\000\000\000\000\000\000\006\165\000\209\0172\000\000\006\165\005\169\000\000\017\022\018B\005\169\000\000\004M\004M\000\000\006\165\006\165\016\146\000\000\006\165\006\165\000\000\005\169\000\000\000\000\000\000\005\r\006\242\005\169\018R\000\000\005\r\000\000\000\000\005\r\000\000\006\165\005\169\000\000\000\000\005\169\000\000\000\000\000\000\005\r\005\169\005\169\000\000\005\r\000\000\000\000\007!\000\000\000\000\007!\000\000\000\000\000\000\000\000\000\000\005\r\005\169\000\000\000\000\000\000\005\169\005\r\007^\000\000\000\000\007!\007!\000\000\007!\007!\005\169\005\169\000\000\005\r\005\169\005\169\000\000\000\000\005\r\005\r\000\238\011\145\000\000\000\000\000\000\000\000\011\145\007!\000\000\011\145\000\000\005\169\000\000\000\000\005\r\000\000\000\000\000\000\000\000\011\145\000\000\000\000\000\000\011\145\000\000\000\238\000\000\000\000\005\r\005\r\000\000\000\000\005\r\005\r\000\000\011\145\000\000\000\000\000\000\000\000\000\000\011\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\r\011\145\000\000\000\000\011\145\000\000\007!\000\000\007!\011\145\000\000\000\000\000\000\000\000\001\202\002^\000\000\000\000\002b\000\000\005\254\000\000\000\000\005\194\007!\011\145\t\138\000\000\007!\011\145\007!\000\000\001\210\001\226\007!\000\000\000\000\000\000\000\000\011\145\011\145\001\238\000\000\011\145\011\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002j\002r\000\000\000\000\000\000\002~\011\145\002\146\004\006\004\018\000\000\000\000\000\000\000\000\020\222\000\000\026F\nn\000\000\004\029\000\000\004\021\000\000\000\000\004\029\000\000\004\021\004\029\000\000\004\021\000\000\004\"\000\000\000\000\000\000\000\000\000\000\004\029\000\000\004\021\015f\004\029\000\000\004\021\000\000\000\000\000\000\000\000\000\000\000\000\026R\000\000\000\000\004\029\000\000\004\021\000\000\000\000\000\000\004\029\000\000\004\021\000\000\000\000\000\000\000\000\000\000\020\242\004\029\000\000\004\021\004\029\000\000\004\021\000\000\000\000\004\029\000\000\004\021\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\0045\000\000\000\000\0045\000\000\004\029\000\000\004\021\000\000\004\029\000\000\004\021\000\000\0045\000\000\000\000\000\000\0045\000\000\004\029\004\029\004\021\004\021\004\029\004\029\004\021\004\021\000\000\000\000\0045\000\000\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\004\029\000\000\004\021\000\000\0045\000\000\000\000\0045\000\000\000\000\000\000\016\186\0045\019\186\000\000\004\005\000\000\000\000\000\000\000\000\004\005\000\000\000\000\004\005\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\0045\004\005\000\000\000\000\000\000\004\005\000\000\000\000\000\000\000\000\0045\0045\000\000\000\000\0045\0045\000\000\004\005\000\000\000\000\000\000\004%\000\000\004\005\000\000\000\000\004%\000\000\004\r\004%\000\000\0045\004\005\004\r\000\000\004\005\004\r\000\000\000\000\004%\004\005\000\000\020\162\004%\000\000\000\000\004\r\000\000\000\000\000\000\004\r\000\000\000\000\000\000\000\000\004%\004\005\000\000\000\000\000\000\004\005\004%\004\r\000\000\000\000\000\000\000\000\000\000\004\r\000\000\004\005\004\005\000\000\004%\004\005\004\005\000\000\000\000\004%\000\000\004\r\000\000\000\000\000\000\000\000\004\r\000\000\000\000\000\000\000\000\000\000\004\005\004=\000\000\004%\000\000\000\000\004=\000\000\004Y\004=\004\r\024\026\000\000\000\246\000\000\000\000\002\162\004%\004%\004=\000\000\004%\004%\004=\004\r\004\r\003\146\000\000\004\r\004\r\004Y\000\000\000\000\000\000\000\000\004=\000\000\000\000\004%\000\000\000\000\004=\003\150\000\000\000\000\004\r\000\000\000\000\016~\017\230\000\000\000\000\000\000\004=\000\000\000\000\020N\024F\004=\000\000\016\226\000\000\000\000\000\000\000\000\016\250\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004=\000\000\000\000\n\246\000\000\000\000\000\000\017\002\000\000\001\202\001\206\000\000\000\000\000\000\004=\004=\000\000\000\000\004=\004=\000\000\017\022\017B\000\000\000\000\004Y\004Y\001\210\001\226\000\000\000\000\000\000\000\000\000\000\000\000\004=\001\238\000\000\000\000\000\000\000\000\000\000\021\134\001\202\001\206\022\154\020\202\000\000\000\000\001\242\002r\000\000\000\246\000\000\002~\002\162\002\146\004\006\004\018\000\000\000\000\002\138\001\226\004\030\000\000\027\154\000\000\000\000\001\202\001\206\001\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\"\003\150\000\000\001\242\002r\000\000\001\210\016~\002~\000\000\002\146\004\006\004\018\000\000\000\000\000\000\024F\004\030\000\000\016\226\000\000\000\000\000\000\000\000\016\250\000\000\000\000\000\000\001\242\002\130\000\000\000\000\000\000\002~\004\"\002\146\004\006\004\018\000\000\000\000\017\002\000\000\004\030\000\000\027F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\022\017B\000\000\000\000\004\129\004\"\000\000\000\000\004\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021\134\000\000\000\000\025\238")) + ((16, "C\170P\226Ff\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021HFf\000\000\000\000\020XFfC\170\020\182\000-\000[\\(\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\021\238\006\168\000\218\000\000\003\188\t|\000\000\001\208\003\232\nt\000\000\000\244\004\198\011l\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\220\000\000\000\000\000\000\0046T\016\000\000\000\000\000\000\005.\000\000\000\000\000\000\005\022\005\b\000\000\000\000T\016H\254\020X\021\178^\128\020X\\\142Mj\020XB\146\000\000B\146\000\000\027\158\004\246\000\000\005.\000\000\000\000\000\000\002J\000\000\027\158\000\000\006&v\246]\160d\194\000\000\132l\134\028\000\000LP_\014\000\000X\\\026\206K\200\005.p\026FfC\170\000\000\000\000Mj\020XF\138B\146\007\012v\246\000\000\128\178FfC\170P\226\020X\000\000\000\000\016x\025\186\001N\b\198\000\000\002\138\b\252\000\000\000\000\000\000\000\000\000\000\020X\000\000A\206i\164C\170\000\000\000\000P\206\020XZ\024W\200\000\000\004\002\000\000\000\000\005\242\000\000\000\000H\166\004\002\024\138\003\130\0020\000\000\000\000\003\172\000\000\021\178\006f\006\154\020X\028\254\020XC\170C\170\000\000P\212P\148\020X\028\254E\166\020X\000\000\000\000\000\000P\226\020X\000\000\000\248\000\000W\200y\188zJ\000\000\b\198\000\000\n\"\000\000\000\000C,T\016\134h\000\000h\142\134h\000\000h\142h\142\000b\006:\0008\000\000\020\190\000\000\006\220\000\000\000\000\t\014\000\000\000\000\000\000h\142\005.\000\000\000\000V\222T\016T\132_\014\000\000\000\000N*\000b\000\000\000\000_\014\007\026T\016\000\000O _\014P\022\000\000\000\000\000\000\n\198\000\000h\142\000\000\001\000\1310\000\000T\016\005\216T\016\000\000\022\\\b&\005.\000\000\000\000\023\224\000\000\006\208\000\000Y\128\011\190\000\000\007\128h\142\011\230\000\000\012\182\000\000\007\200\000\000\000\000\004\184\000\000\000\000\000\000\021 4W\200P\206\020XW\200\000\000\000b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000M:\027v\000\000\000\000\000\000\001\244&\174t<\000\000\000\000P\206\020XW\200\000\000\000\000{hW\200\136.zJ\000\000\136v\000\000W\200\000\000\000\000X\180\000\000\000\000\000\000\b\162\000\000\022\168\000\000\000\000z\214\000\000\136\208{\030\000\000\137\018\t\002\000\000\000\000z\214\000\000\004\024\000\000\000\000DHt\200\000\000\000\000\000\000Bn\023|\019\252\023\176\000\000\000\000\000\000\000\000\004\250\000\000\000\000Z\204\b\164\t`\000\017T\016\002\204\n\204\000\000\000\000\t\246\t`\007X\000\000i\186P\234P\148\020X\028\254\000-\000\018\0020\000\000\n>\021\178\021\178\000-\000\018\000\018\021\178\000\000jL\0050B\146\b\198\000\236\137`\000\000T\016ebT\016_ f\002T\016\000\144T\016f\156\000\000\000\000\020d\0008_\192\b\130\0008`\024\000\000j\230\0050\000\000\021\178k\128\000\000\007\196\t\190`\184\000\000\000\000\000\000\000\000\000\000\000\000\001B\000\000\000\000\003\144\000\000\007|\028\254\000\000\\\192E\166\000\000\031\138\000\000\000\000\021\178\002\152\000\000\000\000\000\000\000\000[\132\000\000\001\200\000\000UP\001\130\005\"\000\000\0226V\170P\226\020XG,P\226\020X\016x\016x\000\000\000\000\000\000\000\000\001\240\024&B\188\000\000Q\150RJP\212\020X\028\254\007h\021\178\000\000\004*\000\000R\254S\178{\182I\190T\016\002\128\000\000P\226\020X\000\000u\016\020Xy\188W\200E\186\000\000P\226\020Xw\\\004~\000\000W\200A\012T\016\003x\007X\012<\000\000\000\000\000\000H\166\003\138\003\138\000\000\012Bp\156\000\000P\206\020XW\200\025R\000\000P\226\020X\016x\0226\016x\002\232\023\240\000\000\000\000\016x\012\014\000\000\r\000\000\000\016x\003\224\rX\000\000'\166\000\000\b\196\000\000\000\000\026\022\000\000\017p\023.\000\000\000\000\000\000\000\000\005\226\000\000\000\000\027\014\000\000\028\006\000\000\028\254\000\000\018h\024&\000\000\000\000\000\000Ff\000\000\000\000\000\000\000\000\029\246\000\000\030\238\000\000\031\230\000\000 \222\000\000!\214\000\000\"\206\000\000#\198\000\000$\190\000\000%\182\000\000&\174\000\000'\166\000\000(\158\000\000)\150\000\000*\142\000\000+\134\000\000,~\000\000-v\000\000.n\000\000/f\000\0000^\020XW\200ZJI\146\003\138\014 l\012W\200\000\000\000\000\000\000h\142\000\000\028\018\134\028\000\000\026\"T\016\029\220\r\164\000\000\000\000\000\000\000\000l\012\000\000\000\000\005\242\014V\000\000I\128\000\000\000\000\135\176\000\000\007:\000\000\000\000K\200\003\138\r\202T\016\t\148\000\000\000\000\b\188\005.\000\000T\016\n@\000\000\000\000\r\252\000\000\000\000\000\000JjT\016\nP\000\000\000\000\030*\000\000\000\000{\254\000\000\031\"|\138\000\000 \026|\210\000\000!\018\t\250\000\000\000\000\000\000\000\000\"\nW\200#\002p\234p\234\000\000\000\000\000\0001V\000\000\007\204\000\000\000\000\000\000q\140\000\000\000\000\002\138\023\248\000\000\t*\000\000\000\000]bKl\000\000\000\000\t\188\000\000\000\000\000\000\n\128\000\000\000\000\000\000\016x\004\216\024\232\000\000\t`\000\000\005\208\000\0002N\000\000\n\180\000\000\006\200\000\0003F\000\000\014\204\007\192\000\0004>lt\000\000(\158\000\000\t\218\b\184\000\00056\000\000\011\150\t\176\000\0006.\000\000q\150\n\168\000\0007&\t\234\025\016\000\000\n\210\011\160\000\0008\030\000\000\011\216\012\152\000\0009\022\000\000\r\n\r\144\000\000:\014\014\136\000\000;\006\015\128\019`\000\000\000\000\000\000\011\026\000\000\000\000\012\186\000\000\000\000\015n\000\000\012*\000\000\000\000\000\000\014\222\000\000\015\004\000\000\000\000J~\003\138\015\192p\156_\014\000b\000\000\000\000p\156\000\000\000\000\000\000p\156\000\000\015\156\000\000\000\000\000\000\000\000\000\000\000\000;\254W\200\000\000\000\000\015\232\000\000<\246\000\000=\238\000\000#\250\000\000\000\000\n\184\000\000\000\000W\200\000\000\000\000}j\011\202\000\000\000\000G,\000\000\011\238\000\000\000\000V\020\000\000\rh\000\000\000\000\001\130\011\254\000\000\000\000\0226\022\028\b\198\000\000A\214\000\000!,\025\160\021\220\000\000\000\000\r\150\000\000\000\000\001\238\025\030V\180\000\000\025\030\000\000\012\246\000\000\000\000\r\172\000\000\000\000g>\b\n\004H\000\000\000\000\r@\000\000\000\000\r\200\000\000\000\000\000\000\020X\028\254\005\168\000\000\000\000\023Z\003\130\0020\003\136\028\254w\228\021\178\001B\028\254xb\015\144\000\000\000\000\003\136\000\000H\232\019\248\021\204\000\000\t\144\016\002\000\000\016\000\000V_\014\006\196\000\000\015\232\015vK\200\r(T\016\030\128\0204\014\n\004\248\000\000\031x\016N\000\000\006\196\000\000\000\000\016^_\014aX\000\000g\144_\014\016*_\014m\012a\248\001N\015\236\000\000\000\000\000\000\020X\128\252\000\000W\200p\234\000\000\000\000\016b\000\000\000\000\000\000>\230\016\146y\188?\222h<\000\000\000\000HJ\000\000\005\128\000\000L\136\000\000\022\222\000\000\021\178\006\026\000\000\128\178\000\000\020X\028\254\128\178\000\000\025D\025\186\001N\005.\130\144\021\178}\248p\234\000\000\005r\b\176\0020\003\136p\234\132\224\003\130\0020\003\136p\234\132\224\000\000\000\000\003\136p\234\000\000FfC\170W\200\027B\000\000\000\000FfC\170P\148\020X\028\254\128\178\000\000\020\182\000-\000[\015\200T\016\012\142\016\146\131P\000\000p\234\000\000H\232\019\248\021\204x\186\023\228\t\236~,\b\130\015\234\020Xp\234\000\000\020Xp\234\000\000h\142ff\019\134\002\222\001N\0008N\234\000\000\001N\0008N\234\000\000\025D\005r\t\168\0212\012\180\000\000N\234\000\000\0020\015\234\021\178p\234\134\222\003\130\0020\015\236\021\178p\234\134\222\000\000\000\000\b`\000\000O\224\000\000\021\178\131\132N\234\000\000\b`\000\000H\254\020X\021\178p\234\000\000H\232\019\248\021\204rFC\186\026\222\019\170\002\142\000\000\r\216\027\158\000\017\000\000\016h\016 \024\196\020XT\184T\016\0118\000\000W\150\001N\005\204\011\246\000\000\011\228\000\000\016~\016\014T\016O(\000\000\0032\004\212\r\200\000\000\r6\000\000\016\136\016 K\200\r\206T\016K\182O(\000\000UP\020X\024\196\016\202\n$\001N\000\000\r\200\024\196T\016\012~\000b\000\000T\016\007\152\t,\000\000\000\000mf\000\000\000\000\r\228\024\196m\228O(\000\000\020XT\016\r(T\016V\\O(\000\000\014<\000\000\000\000O(\000\000\000\000W\150\000\000p\234\132\238\019\170\002\142\r\216\016\182\016h\024\196p\234\132\238\000\000\000\000\019\170\002\142\r\216\016\190\016HM\252LZ_\014\016\206M\252h\142\020\184\016\218M\252_\014\016\230M\252n\132o\004\000\000\129\140\000\000\000\000p\234\134\236\019\170\002\142\r\216\016\224\016nM\252p\234\134\236\000\000\000\000\000\000ff\000\000\000\000\000\000\000\000\000\000\000\000N\234\000\000\133\128\020\026A\228\017\002v\246\000\000\128\178\133\128\000\000\000\000\1358\020\026A\228\017\004\016\158]\160\135\176\006\196\017H\000\000\000\000o\130rF\020X\000\000~\200\021\204\000\000\000\000\128\178\1358\000\000\000\000\000\000y6DlD\228\006\196\017J\000\000\000\000\000\000rF\020X\000\000\006\196\017N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014`C\186\019\170\002\142\r\216\017 r\182\023\204\020XZ\024j\190\020(\001N\006\196\017*\nt\000\000\000\000\016\220\000\000\000\000a\152\000\000\b\022\014\132\000\000\r\212\000\000\0178\016\202T\016d\240\017F\n\158\000\000\000\000\017\004\000\000\000\000\020F\0032\014\210\000\000\017Zs8\137\172\003\138\016\248T\016\014r\000\000\000\000\017\012\000\000\000\000\000\000a\152\000\000\0070\014\234\000\000\014\204\000\000\017l\016\250K\200\000\000\017vs\186\137\248\003\138\017\026T\016\015\024\000\000\000\000\017,\000\000\000\000\000\000\020X\000\000a\152\000\000\020z\020X\023\204\023\204u\168Ff\020X\128\252W\200\021\162\000\000\012\020\001N\000\000\014\012\023\204T\016\014n\b\198\000\000\020XW\200r\182\023\204\014\154\023\204\000\000D\142Et\000\000bR\000\000\000\000b\238\000\000\000\000c\138\000\000\014\192\023\204d&\128\252W\200\021\162\000\000\000\"\000\000\000\000M\252\r\026\000\000\000\000d.\017\144\000\000a\152\000\000\023\204d.a\152\000\000\020XT\016a\152\000\000\015\136\000\000\000\000a\152\000\000\000\000j\190\000\000\129\192M\252\017T\023\204\130\\r\182\000\000p\234\133\142\019\170\002\142\r\216\017\174r\182p\234\133\142\000\000\000\000\000\000\135\248P\206\000\000\000\000\000\000\000\000\000\000\000\000\132\022p\234\000\000\133\128\000\000\000\000\000\000\000\000p\234\135\248\000\000\017\234\000\000\000\000\132\022\017\236\000\000p\234\135\248\000\000\000\000\015\222\000\000\000\000i4\0032\000\000\000\000DH\000\000T\016\015\242\000\000j\190\015\240\000\000\000\000\000\000\014\192\000\000\000\000\000\000P\212\020X\028\254\006\178\000\000Mt\000\000\007p\000\000\000*\000\000\000\000\017\242\000\000\018\026y\188\000\000@\214\017\252\000\000\000\000\017\248\026R\028B\021\204v0\023\228\020X\000\000\128\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000v8\023\228\020X\000\000\015\"v\246\000\000\128\178\000\000\017\254\026R\028B\128\178\000\000\018\020\000\000\000\238\t\214\020X`\226\000\000\000\000\028\190y\242\000\000\000\000\017\184\000\000\018\bT\016\000\000\r\234\011\174\000b\000\000\000\000T\016\004R\006B\000\000T\016\012\018\006\196\018>\000\000\000\000\127\"\000\000\000\000]\160\000\000\128\178\000\000\0182\026R\029:N\234\000\000\000\000\000\000\000\000\015h\127\188]\160\000\000\128\178\000\000\0184\026R\029:N\234\000\000\016 \000\000\000\000\b\n\000\000p\234\000\000\018H\000\000\000\000\017\174\000\000\017\188\000\000\017\208\000\000\000\000\\\142\017\216\000\000\000\000%\182\\(\018t\000\000\000\000\000\000\014\242\011D]\232\018x\000\000\000\000\000\000\000\000\000\000\000\000\017\248\000\000\023\228\000\000\017\250\000\000T\016\000\000\014\250\000\000\000\000\017\252\000\000\000\000\0008\000\000\003\210\000\000\000\000\000\000\001\214\000\000\015\196\000\000\018\000\000\000W\200\022\168\000\000\000\000\012<\018\012\000\000\000\000\018\006\r$G,\005.\128:\000\000\000\000\000\000\000\000\000\000YL\000\000\000\000\018\172\000\000\138<\000\000\015\192\018\180\000\000\018\182\000\000G\224G\224[\190[\190\000\000\000\000p\234[\190\000\000\000\000\000\000p\234[\190\0180\000\000\018H\000\000"), (16, "\t)\t)\000\006\001\002\001\190\t)\002\158\002\162\t)\002\206\002f\t)\003\145\t)\018\130\002\218\t)\023\130\t)\t)\t)\025*\t)\t)\t)\001\210\004A\004A\004*\002\222\t)\003\"\003&\t\214\t)\001\206\t)\023\134\003*\000\238\002\226\025.\t)\t)\003\186\003\190\t)\003\194\003\022\003\206\003\214\006\186\006\246\t)\t)\002\150\001\206\006\214\003\030\t)\t)\t)\007\254\b\002\b\014\b\"\001*\005Z\t)\t)\t)\t)\t)\t)\t)\t)\t)\b\150\000\238\t)\015~\t)\t)\003\145\b\162\b\186\t\014\005f\005j\t)\t)\t)\r\162\t)\t)\t)\t)\002N\002~\r\210\t)\006\150\t)\t)\0035\t)\t)\t)\t)\t)\t)\005n\b\022\t)\t)\t)\b.\004V\t\"\0035\t)\t)\t)\t)\012\217\012\217\023\138\n\178\004~\012\217\n\190\012\217\012\217\000\238\012\217\012\217\012\217\012\217\004A\012\217\012\217\001f\012\217\012\217\012\217\003i\012\217\012\217\012\217\012\217\004A\012\217\015\222\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\007\162\007\002\0076\012\217\004\198\012\217\012\217\012\217\012\217\012\217\004A\012\217\012\217\004A\012\217\003\210\012\217\012\217\012\217\000\238\007\166\012\217\012\217\012\217\012\217\012\217\012\217\012\217\000\238\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\004A\012\217\012\217\007n\012\217\012\217\001j\004A\007\018\004A\012\217\012\217\012\217\012\217\012\217\004A\012\217\012\217\012\217\012\217\012\217\000\238\012\217\012\217\007\026\012\217\012\217\000\238\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\b\006\004A\012\217\012\217\012\217\012\217\001\181\001\181\001\181\001f\015>\001\181\003i\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\014\234\001\181\007\194\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\003j\003n\001\181\000\238\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\006\218\001\181\001\181\001\181\007\250\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\002J\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\027\159\001\181\001\181\018r\007\222\007\002\007R\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\014\174\bF\001\181\005\158\001\181\001\181\007\226\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\182\001\181\001\181\001\181\001\181\001\181\n]\n]\002\225\007n\012\253\n]\003\149\n]\n]\000\238\n]\n]\n]\n]\001\186\n]\n]\012\253\n]\n]\n]\000\238\n]\n]\n]\n]\002N\n]\000\n\n]\n]\n]\n]\n]\n]\n]\n]\024\194\007\002\b\146\n]\004A\n]\n]\n]\n]\n]\000\238\n]\n]\012\006\n]\002\246\n]\n]\n]\002\225\024\198\n]\n]\n]\n]\n]\n]\n]\004A\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\003\149\n]\n]\007n\n]\n]\004A\004A\007\002\004A\n]\n]\n]\n]\n]\004\001\n]\n]\n]\n]\t:\000\238\tj\n]\005\241\n]\n]\007\174\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\003v\n]\n]\n]\n]\n]\003\173\003\173\001r\007n\006\214\003\173\b\250\003\173\003\173\000\238\003\173\003\173\003\173\003\173\000\238\003\173\003\173\006\137\003\173\003\173\003\173\000\238\003\173\003\173\003\173\003\173\001\130\003\173\006>\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\006\137\007\002\004\001\003\173\004&\003\173\003\173\003\173\003\173\003\173\015.\003\173\003\173\006B\003\173\t\005\003\173\003\173\003\173\005\241\bv\003\173\003\173\003\173\003\173\003\173\003\173\003\173\0156\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\b\213\t2\tb\007n\003\173\003\173\003z\003B\b\202\027\143\003\173\003\173\003\173\003\173\003\173\0046\003\173\003\173\003\173\003\173\t:\000\238\tj\003\173\b\006\003\173\003\173\003F\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\000\238\003\173\003\173\003\173\003\173\003\173\003\161\003\161\018\222\b\206\b\234\003\161\0056\003\161\003\161\t\005\003\161\003\161\003\161\003\161\001\146\003\161\003\161\006~\003\161\003\161\003\161\0022\003\161\003\161\003\161\003\161\018\230\003\161\001\198\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\006\237\b\213\004A\003\161\0026\003\161\003\161\003\161\003\161\003\161\b\029\003\161\003\161\001\218\003\161\007\006\003\161\003\161\003\161\006\237\004A\003\161\003\161\003\161\003\161\003\161\003\161\003\161\004A\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\000\238\t2\tb\001\234\003\161\003\161\004A\004A\007\002\007B\003\161\003\161\003\161\003\161\003\161\001\222\003\161\003\161\003\161\003\161\t:\004A\tj\003\161\004V\003\161\003\161\016Z\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\006\237\003\161\003\161\003\161\003\161\003\161\t\217\t\217\018\178\007n\b\n\t\217\006\130\t\217\t\217\001\238\t\217\t\217\t\217\t\217\000\238\t\217\t\217\006\149\t\217\t\217\t\217\000\238\t\217\t\217\t\217\t\217\004A\t\217\007\194\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\006\149\007\002\018\186\t\217\000\238\t\217\t\217\t\217\t\217\t\217\005\217\t\217\t\217\001\206\t\217\012f\t\217\t\217\t\217\015\022\016v\t\217\t\217\t\217\t\217\t\217\t\217\t\217\000\238\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\0262\t\217\t\217\007n\t\217\t\217\003\130\003N\t\162\004A\t\217\t\217\t\217\t\217\t\217\002Z\t\217\t\217\t\217\t\217\t\217\000\238\t\217\t\217\004&\t\217\t\217\003R\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\000\238\004A\t\217\t\217\t\217\t\217\t\209\t\209\004\214\001f\003i\t\209\n\134\t\209\t\209\025\018\t\209\t\209\t\209\t\209\003\134\t\209\t\209\004:\t\209\t\209\t\209\003\137\t\209\t\209\t\209\t\209\b\241\t\209\004B\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\007\194\0266\015\134\t\209\001\206\t\209\t\209\t\209\t\209\t\209\005\209\t\209\t\209\000\238\t\209\012~\t\209\t\209\t\209\022f\011\022\t\209\t\209\t\209\t\209\t\209\t\209\t\209\000\238\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\011\026\t\209\t\209\022n\t\209\t\209\002\186\004\146\007\002\b\241\t\209\t\209\t\209\t\209\t\209\007\005\t\209\t\209\t\209\t\209\t\209\025\022\t\209\t\209\b\021\t\209\t\209\025\"\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\000\238\b\241\t\209\t\209\t\209\t\209\t\225\t\225\b\193\007n\007\194\t\225\011\234\t\225\t\225\007\182\t\225\t\225\t\225\t\225\006\214\t\225\t\225\000\238\t\225\t\225\t\225\000\238\t\225\t\225\t\225\t\225\005*\t\225\011\238\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\001\007\002\006\182\t\225\000\238\t\225\t\225\t\225\t\225\t\225\021\218\t\225\t\225\004&\t\225\012\146\t\225\t\225\t\225\014\226\026\198\t\225\t\225\t\225\t\225\t\225\t\225\t\225\bj\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\004\230\t\225\t\225\007n\t\225\t\225\005\018\021\226\b\193\005.\t\225\t\225\t\225\t\225\t\225\005\209\t\225\t\225\t\225\t\225\t\225\000\238\t\225\t\225\007~\t\225\t\225\002\250\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\001\004\186\t\225\t\225\t\225\t\225\t\193\t\193\003j\003n\006\214\t\193\tv\t\193\t\193\005\254\t\193\t\193\t\193\t\193\002\162\t\193\t\193\016\190\t\193\t\193\t\193\017v\t\193\t\193\t\193\t\193\tz\t\193\011>\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\006*\006\142\006\166\t\193\002\250\t\193\t\193\t\193\t\193\t\193\018\026\t\193\t\193\004:\t\193\012\178\t\193\t\193\t\193\002\238\012\018\t\193\t\193\t\193\t\193\t\193\t\193\t\193\018&\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\012\022\t\193\t\193\b\189\t\193\t\193\002\254\012^\001\002\001\190\t\193\t\193\t\193\t\193\t\193\004F\t\193\t\193\t\193\t\193\t\193\006U\t\193\t\193\011F\t\193\t\193\012b\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\006U\000\238\t\193\t\193\t\193\t\193\t\201\t\201\003j\017\206\002r\t\201\012.\t\201\t\201\006\146\t\201\t\201\t\201\t\201\007\130\t\201\t\201\017\226\t\201\t\201\t\201\tv\t\201\t\201\t\201\t\201\001v\t\201\0122\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\011\174\025\222\b\189\t\201\012\174\t\201\t\201\t\201\t\201\t\201\000\238\t\201\t\201\002r\t\201\012\198\t\201\t\201\t\201\001\222\003\242\t\201\t\201\t\201\t\201\t\201\t\201\t\201\004A\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\0112\t\201\t\201\003\246\t\201\t\201\006\174\016*\001\002\001\190\t\201\t\201\t\201\t\201\t\201\015n\t\201\t\201\t\201\t\201\t\201\006]\t\201\t\201\004\213\t\201\t\201\012>\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\006]\000\238\t\201\t\201\t\201\t\201\n\001\n\001\012\230\012B\002\246\n\001\012v\n\001\n\001\000\238\n\001\n\001\n\001\n\001\n\246\n\001\n\001\000\238\n\001\n\001\n\001\012\018\n\001\n\001\n\001\n\001\001\134\n\001\012z\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\004\182\006\162\011N\n\001\012\242\n\001\n\001\n\001\n\001\n\001\011r\n\001\n\001\019\"\n\001\012\218\n\001\n\001\n\001\006\226\012^\n\001\n\001\n\001\n\001\n\001\n\001\n\001\021\186\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\rJ\n\001\n\001\n\178\n\001\n\001\n\190\014\022\007\130\022\002\n\001\n\001\n\001\n\001\n\001\018\162\n\001\n\001\n\001\n\001\n\001\006e\n\001\n\001\n\178\n\001\n\001\n\190\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\006e\011\234\n\001\n\001\n\001\n\001\t\241\t\241\027*\001\222\014\030\t\241\004\186\t\241\t\241\000\238\t\241\t\241\t\241\t\241\001\206\t\241\t\241\012\194\t\241\t\241\t\241\0142\t\241\t\241\t\241\t\241\001\150\t\241\012.\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\005\n\018\190\014F\t\241\0146\t\241\t\241\t\241\t\241\t\241\014j\t\241\t\241\r\006\t\241\012\246\t\241\t\241\t\241\002~\005\026\t\241\t\241\t\241\t\241\t\241\t\241\t\241\004A\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\b\217\t\241\t\241\rj\t\241\t\241\005\221\018\182\002\162\026\026\t\241\t\241\t\241\t\241\t\241\005\225\t\241\t\241\t\241\t\241\t\241\b\230\t\241\t\241\t\006\t\241\t\241\tN\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\000\238\000\238\t\241\t\241\t\241\t\241\t\233\t\233\001\002\001\190\014n\t\233\b\237\t\233\t\233\019:\t\233\t\233\t\233\t\233\017\214\t\233\t\233\012v\t\233\t\233\t\233\001\206\t\233\t\233\t\233\t\233\004\186\t\233\014J\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\005\"\b\217\rV\t\233\rn\t\233\t\233\t\233\t\233\t\233\014\198\t\233\t\233\022\250\t\233\r\n\t\233\t\233\t\233\000\238\012>\t\233\t\233\t\233\t\233\t\233\t\233\t\233\023\146\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\002\250\t\233\t\233\r\026\t\233\t\233\018\234\014\242\023\150\017B\t\233\t\233\t\233\t\233\t\233\019B\t\233\t\233\t\233\t\233\t\233\011>\t\233\t\233\tV\t\233\t\233\014Z\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\001\002\001\190\t\233\t\233\t\233\t\233\t\249\t\249\014^\014\162\b!\t\249\004\186\t\249\t\249\000\238\t\249\t\249\t\249\t\249\014\210\t\249\t\249\014\202\t\249\t\249\t\249\tf\t\249\t\249\t\249\t\249\014\166\t\249\014\254\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\014\214\021\230\019\130\t\249\014\246\t\249\t\249\t\249\t\249\t\249\015\154\t\249\t\249\015\002\t\249\r\030\t\249\t\249\t\249\018\226\011>\t\249\t\249\t\249\t\249\t\249\t\249\t\249\026\022\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\b%\t\249\t\249\015\170\t\249\t\249\005\213\003}\002\253\019\150\t\249\t\249\t\249\t\249\t\249\n\158\t\249\t\249\t\249\t\249\t\249\018z\t\249\t\249\n\214\t\249\t\249\019.\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\019f\n\250\t\249\t\249\t\249\t\249\nI\nI\007\241\007R\011*\nI\018\254\nI\nI\023\018\nI\nI\nI\nI\023\006\nI\nI\007R\nI\nI\nI\011Z\nI\nI\nI\nI\026&\nI\024\246\nI\nI\nI\nI\nI\nI\nI\nI\007R\022r\021\222\nI\000\238\nI\nI\nI\nI\nI\r\005\nI\nI\000\238\nI\r*\nI\nI\nI\019\154\012\142\nI\nI\nI\nI\nI\nI\nI\022\"\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\022j\nI\nI\022B\nI\nI\b\025\001\206\023.\b\021\nI\nI\nI\nI\nI\019B\nI\nI\nI\nI\nI\r\017\nI\nI\004&\nI\nI\023f\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\000\238\001\206\nI\nI\nI\nI\003\157\003\157\025\170\007R\023\210\003\157\n\134\003\157\003\157\000\238\003\157\003\157\003\157\003\157\rb\003\157\003\157\024\250\003\157\003\157\003\157\rz\003\157\003\157\003\157\003\157\027o\003\157\027&\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\026\142\r\130\022\162\003\157\002\006\003\157\003\157\003\157\003\157\003\157\024\178\003\157\003\157\004Y\003\157\r\150\003\157\003\157\003\157\024\230\r\198\003\157\003\157\003\157\003\157\003\157\003\157\003\157\r\242\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\024\218\t2\tb\026\186\003\157\003\157\001\222\015J\015r\003\226\003\157\003\157\003\157\003\157\003\157\002\198\003\157\003\157\003\157\003\157\t:\023\214\tj\003\157\015\142\003\157\003\157\015\146\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\000\238\003\157\003\157\003\157\003\157\003\157\001\237\001\237\015\186\015\206\015\230\001\237\015\250\002\162\001\237\016&\002f\001\237\tJ\001\237\016:\002\218\001\237\024\182\001\237\001\237\001\237\017:\001\237\001\237\001\237\001\210\024\234\tR\017F\002\222\001\237\001\237\001\237\001\237\001\237\tZ\001\237\005\250\017\234\018\002\002\226\018\138\001\237\001\237\001\237\001\237\001\237\018\142\003\022\001\190\026\190\001\237\018\198\001\237\001\237\002\150\018\202\018\242\003\030\001\237\001\237\001\237\007\254\b\002\b\014\018\246\012J\005Z\001\237\001\237\001\237\001\237\001\237\001\237\001\237\001\237\001\237\019\030\t2\tb\019\202\001\237\001\237\019\206\019\242\019\246\020\006\005f\005j\001\237\001\237\001\237\020\022\001\237\001\237\001\237\001\237\012R\020\"\012\162\001\237\020V\001\237\001\237\020Z\001\237\001\237\001\237\001\237\001\237\001\237\005n\b\022\001\237\001\237\001\237\b.\004V\020\166\020\206\001\237\001\237\001\237\001\237\n1\n1\020\210\020\226\0212\n1\021R\002\162\n1\021\146\002f\n1\n1\n1\021\182\002\218\n1\021\198\n1\n1\n1\021\238\n1\n1\n1\001\210\021\242\n1\021\254\002\222\n1\n1\n1\n1\n1\n1\n1\022\014\022*\022:\002\226\022N\n1\n1\n1\n1\n1\022z\003\022\001\190\022~\n1\022\138\n1\n1\002\150\022\154\022\174\003\030\n1\n1\n1\007\254\b\002\b\014\023\162\n1\005Z\n1\n1\n1\n1\n1\n1\n1\n1\n1\023\250\n1\n1\024\"\n1\n1\024\138\024\154\0256\025>\005f\005j\n1\n1\n1\025N\n1\n1\n1\n1\n1\025Z\n1\n1\025\190\n1\n1\025\210\n1\n1\n1\n1\n1\n1\005n\b\022\n1\n1\n1\b.\004V\026\002\026\n\n1\n1\n1\n1\n-\n-\026F\026n\026\166\n-\026\214\002\162\n-\026\226\002f\n-\n-\n-\026\234\002\218\n-\026\243\n-\n-\n-\027\003\n-\n-\n-\001\210\027\022\n-\0272\002\222\n-\n-\n-\n-\n-\n-\n-\027O\027_\027{\002\226\027\175\n-\n-\n-\n-\n-\027\203\003\022\001\190\027\214\n-\028\011\n-\n-\002\150\028\031\028'\003\030\n-\n-\n-\007\254\b\002\b\014\028c\n-\005Z\n-\n-\n-\n-\n-\n-\n-\n-\n-\028k\n-\n-\000\000\n-\n-\000\000\000\000\000\000\000\000\005f\005j\n-\n-\n-\000\000\n-\n-\n-\n-\n-\000\000\n-\n-\000\000\n-\n-\000\000\n-\n-\n-\n-\n-\n-\005n\b\022\n-\n-\n-\b.\004V\000\000\000\000\n-\n-\n-\n-\0029\0029\000\000\000\000\000\000\0029\000\000\002\162\0029\000\000\002f\0029\tJ\0029\000\000\002\218\0029\000\000\0029\0029\0029\000\000\0029\0029\0029\001\210\002\225\tR\000\000\002\222\0029\0029\0029\0029\0029\tZ\0029\000\000\000\000\000\000\002\226\004A\0029\0029\0029\0029\0029\000\000\003\022\001\190\000\000\0029\000\n\0029\0029\002\150\000\000\000\000\003\030\0029\0029\0029\007\254\b\002\b\014\000\000\012J\005Z\0029\0029\0029\0029\0029\0029\0029\0029\0029\000\000\004\173\0029\002\225\0029\0029\004A\006f\002\162\004A\005f\005j\0029\0029\0029\000\000\0029\0029\0029\0029\000\000\000\238\004A\0029\004\173\0029\0029\004A\0029\0029\0029\0029\0029\0029\005n\b\022\0029\0029\0029\b.\004V\000\000\004A\0029\0029\0029\0029\004A\004A\004A\002\238\004A\004A\004A\004A\004A\004A\004A\017\158\004A\000\238\004A\004A\000\000\004A\004A\004A\000\000\004A\004A\004A\004A\004A\004A\004A\004A\004A\000\238\004A\004A\000\000\000\000\004A\004A\000\238\004A\004A\004A\004A\004A\000\238\004A\004A\004A\004A\004A\004A\004A\004A\000\238\004A\004A\004A\004A\004A\004A\004A\004A\000\238\004A\004A\004A\004A\004A\004A\004A\004A\b\189\0042\004A\000\000\000\000\004A\004A\004A\000\238\004A\000\n\000\000\004A\004A\004A\004A\004A\004A\004A\004A\004A\000\000\021\170\004A\004A\002\225\002\225\007J\004A\004&\006\233\000\000\004A\004A\000\000\007R\000\000\022\026\002\225\000\238\004A\004A\004A\007V\000\000\004A\004A\004A\004A\006\233\000\161\004A\000\161\006\233\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\000\000\161\022\206\000\161\000\161\000\000\000\161\000\161\000\000\000\000\000\161\000\161\000\000\000\161\000\161\000\161\000\161\000\000\000\161\0046\000\161\000\161\b\189\000\000\000\161\000\161\005\141\000\161\000\161\000\161\000\238\000\161\b\241\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\000\bn\000\161\000\161\000\000\000\000\000\161\000\161\002\006\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\002\n\006\233\000\000\015f\t\029\000\161\002f\000\161\001\210\000\161\005\141\002\162\000\000\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\000\000\000\000\000\000\161\003~\017\210\t\029\005\141\000\222\000\000\006\230\001\222\000\161\000\000\002\198\000\000\014z\002\150\000\161\000\161\000\161\000\161\000\000\015j\000\161\000\161\000\161\000\161\002)\002)\004Y\000\000\002\238\002)\000\000\002\162\002)\015v\002f\002)\001b\002)\000\000\002\218\002)\006\234\002)\002)\002)\000\000\002)\002)\002)\001\210\001z\000\000\001\138\002\222\002)\002)\002)\002)\002)\005j\002)\000\000\000\000\000\000\002\226\b\169\002)\002)\002)\002)\002)\004Y\003\022\b\018\000\000\002)\000\000\002)\002)\002\150\000\000\006\006\003\030\002)\002)\002)\007\254\b\002\b\014\t2\tb\005Z\002)\002)\002)\002)\002)\002)\002)\002)\002)\006\n\t2\tb\b\169\002)\002)\000\000\t:\007\002\tj\005f\005j\002)\002)\002)\000\000\002)\002)\002)\002)\t:\000\000\tj\002)\b\169\002)\002)\016j\002)\002)\002)\002)\002)\002)\005n\b\022\002)\002)\002)\b.\004V\000\238\000\000\002)\002)\002)\002)\002E\002E\000\000\007n\000\000\002E\000\000\000\000\002E\000\000\b\169\002E\000\000\002E\004\226\000\000\002E\b\169\002E\002E\002E\000\238\002E\002E\002E\000\000\027\187\000\000\002\225\002\225\002E\002E\002E\002E\002E\000\000\002E\000\000\006\014\004\169\000\000\005\206\002E\002E\002E\002E\002E\000\000\006\026\000\000\000\000\002E\006&\002E\002E\000\n\000\000\000\000\006b\002E\002E\002E\004\169\000\000\000\000\006\213\016n\000\000\002E\002E\002E\002E\002E\002E\002E\002E\002E\000\000\t2\tb\000\000\002E\002E\002\225\006j\000\000\002\162\000\000\006\213\002E\002E\002E\000\000\002E\002E\002E\002E\t:\002\162\tj\002E\002f\002E\002E\001\210\002E\002E\002E\002E\002E\002E\b\165\000\000\002E\002E\002E\000\000\021\154\000\000\000\000\002E\002E\002E\002E\002A\002A\000\000\022\214\002\238\002A\022\218\002\250\002A\000\000\002\150\002A\000\000\002A\000\000\017j\002A\023\n\002A\002A\002A\t>\002A\002A\002A\012\n\b\165\000\000\000\000\015v\002A\002A\002A\002A\002A\rN\002A\rZ\000\000\012&\023\026\0126\002A\002A\002A\002A\002A\b\165\bJ\001\190\001*\002A\000\000\002A\002A\005j\002\225\002\225\014:\002A\002A\002A\014N\014b\014r\000\000\000\000\000\000\002A\002A\002A\002A\002A\002A\002A\002A\002A\000\000\t2\tb\b\165\002A\002A\000\n\004\226\000\000\001\206\b\165\000\000\002A\002A\002A\000\000\002A\002A\002A\002A\t:\000\000\tj\002A\000\000\002A\002A\001\210\002A\002A\002A\002A\002A\002A\002\225\000\000\002A\002A\002A\000\000\018\146\000\000\000\000\002A\002A\002A\002A\002-\002-\000\000\000\000\002~\002-\019\026\002\250\002-\000\000\002\150\002-\000\000\002-\000\000\000\000\002-\0192\002-\002-\002-\012V\002-\002-\002-\002\225\002\225\016\150\000\000\000\000\002-\002-\002-\002-\002-\012n\002-\012\134\000\000\000\000\002\225\012\234\002-\002-\002-\002-\002-\000\000\bJ\014\178\000\000\002-\000\n\002-\002-\012\254\000\000\r\018\014:\002-\002-\002-\014N\014b\014r\t\025\000\000\000\000\002-\002-\002-\002-\002-\002-\002-\002-\002-\000\000\t2\tb\002\225\002-\002-\000\000\014\146\002\225\000\000\000\238\t\025\002-\002-\002-\000\000\002-\002-\002-\002-\t:\000\000\tj\002-\000\000\002-\002-\000\000\002-\002-\002-\002-\002-\002-\000\n\000\000\002-\002-\002-\000\000\t\030\000\000\000\000\002-\002-\002-\002-\002=\002=\000\000\002\225\000\000\002=\012}\006\014\002=\000\000\005\206\002=\000\000\002=\000\000\002\225\002=\006\026\002=\002=\002=\006&\002=\002=\002=\012}\012}\000\000\000\000\012}\002=\002=\002=\002=\002=\000\000\002=\b\021\000\000\000\000\b\021\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\022\"\002=\002=\002=\000\000\000\000\000\000\000\000\000\000\000\238\002=\002=\002=\002=\002=\002=\002=\002=\002=\000\000\b\021\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\b\021\002=\002=\002=\002=\012}\000\000\004\253\002=\000\000\002=\002=\002\225\t\130\002=\002=\002=\002=\002=\004\253\n\202\002=\002=\002=\000\000\000\000\b\021\000\000\002=\002=\002=\002=\t%\t%\000\000\000\000\000\000\t%\000\000\000\000\t%\000\n\000\000\t%\000\000\t%\000\000\000\000\t\174\004\253\t%\t\210\t%\b\021\t%\t%\t%\002\225\000\000\000\000\000\000\017\006\t\230\t\254\n\006\t\238\n\014\000\000\t%\002\225\002\225\000\000\000\000\000\000\t%\t%\n\022\n\030\t%\004\253\007\245\000\000\004\253\t%\000\000\n&\t%\000\000\000\000\000\000\000\000\t%\t%\000\238\000\000\000\000\000\000\000\000\000\000\002\218\t%\t%\t\182\t\246\n.\n6\nF\t%\t%\002\138\012\181\t%\000\000\t%\nN\000\000\003>\000\000\000\000\000\238\000\000\t%\t%\nV\000\000\t%\t%\t%\t%\003J\012\181\000\000\t%\000\000\t%\t%\002\030\nv\t%\n~\n>\t%\t%\000\000\000\000\t%\n^\t%\000\000\002&\000\000\005Z\t%\t%\nf\nn\002q\002q\000\000\000\000\000\000\002q\012\133\006\014\002q\000\000\005\206\002q\000\000\002q\000\000\005f\002q\006\026\002q\002q\002q\006&\002q\002q\002q\012\133\012\133\000\000\000\000\012\133\002q\002q\002q\002q\002q\000\000\002q\015f\000\000\005n\002f\000\000\002q\002q\002q\002q\002q\000\000\000\000\000\000\000\000\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\002q\002q\002q\000\000\000\000\000\000\000\000\000\000\000\238\002q\002q\t\182\002q\002q\002q\002q\002q\002q\000\000\015j\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\000\000\000\000\002q\002q\002q\015v\002q\002q\002q\002q\012\133\000\000\001\206\002q\000\000\002q\002q\000\000\002q\002q\002q\002q\002q\002q\025\242\000\000\002q\002q\002q\000\000\000\000\005j\000\000\002q\002q\002q\002q\002Y\002Y\000\000\000\000\000\000\002Y\000\000\002\162\002Y\000\000\000\000\002Y\000\000\002Y\003\142\000\000\002Y\002~\002Y\002Y\002Y\025b\002Y\002Y\002Y\001\210\000\000\000\000\000\000\000\000\002Y\002Y\002Y\002Y\002Y\000\000\002Y\015f\000\000\000\000\002f\000\000\002Y\002Y\002Y\002Y\002Y\004~\003\174\000\000\004\217\002Y\000\000\002Y\002Y\002\150\000\000\000\000\000\000\002Y\002Y\002Y\000\000\000\000\000\000\000\000\000\000\000\000\002Y\002Y\t\182\002Y\002Y\002Y\002Y\002Y\002Y\000\000\015j\002Y\000\000\002Y\002Y\006\206\000\000\000\000\000\000\000\000\000\000\002Y\002Y\002Y\015v\002Y\002Y\002Y\002Y\000\000\000\000\000\000\002Y\000\000\002Y\002Y\000\000\002Y\002Y\002Y\002Y\002Y\002Y\012\129\000\000\002Y\002Y\002Y\000\000\000\000\005j\000\000\002Y\002Y\002Y\002Y\002e\002e\000\000\000\000\000\000\002e\012\129\012\129\002e\000\000\012\129\002e\000\000\002e\000\000\000\000\t\174\000\000\002e\002e\002e\020\254\002e\002e\002e\000\000\000\000\000\000\000\000\000\000\002e\002e\002e\t\238\002e\000\000\002e\000\000\000\000\000\000\000\000\000\000\002e\002e\002e\002e\002e\000\000\000\238\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\t\182\t\246\002e\002e\002e\002e\002e\000\000\012\129\002e\000\000\002e\002e\000\000\000\000\000\000\000\000\000\238\b\t\002e\002e\002e\b\t\002e\002e\002e\002e\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\011~\000\000\000\000\002e\002e\002e\002e\002u\002u\000\000\000\000\000\000\002u\b\t\011\134\002u\000\000\011\146\002u\000\000\002u\000\000\000\000\002u\011\158\002u\002u\002u\011\170\002u\002u\002u\000\000\000\000\b\t\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\004\226\000\000\000\000\000\000\002u\002u\t\182\002u\002u\002u\002u\002u\002u\000\000\007\206\002u\000\000\002u\002u\000\000\000\000\000\000\000\000\000\238\b\005\002u\002u\002u\b\005\002u\002u\002u\002u\000\000\007\210\000\000\002u\000\000\002u\002u\000\000\002u\002u\002u\002u\002u\002u\000\000\000\000\002u\002u\002u\000\000\007\165\000\000\000\000\002u\002u\002u\002u\002U\002U\007\194\000\000\000\000\002U\b\005\007\165\002U\000\000\005\206\002U\000\000\002U\000\000\000\238\002U\007\165\002U\002U\002U\007\165\002U\002U\002U\000\000\000\000\b\005\000\000\000\000\002U\002U\002U\002U\002U\000\000\002U\000\000\000\000\006\253\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\006\253\002U\002U\002U\006\253\007\214\004\226\000\000\000\000\000\000\002U\002U\t\182\002U\002U\002U\002U\002U\002U\000\000\000\000\002U\000\000\002U\002U\000\000\000\000\000\000\000\000\007\189\000\000\002U\002U\002U\000\000\002U\002U\002U\002U\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\007\189\000\000\000\000\002U\002U\002U\002U\002a\002a\000\000\000\000\000\000\002a\005J\007\189\002a\000\000\005\206\002a\000\000\002a\000\000\000\000\t\174\007\189\002a\002a\002a\007\189\002a\002a\002a\000\000\000\000\000\000\000\000\000\000\002a\002a\002a\t\238\002a\000\000\002a\000\000\000\000\006\237\000\000\000\000\002a\002a\002a\002a\002a\000\000\000\000\000\000\000\000\002a\000\000\002a\002a\000\000\000\000\000\000\006\237\002a\002a\002a\006\237\000\000\000\000\000\000\000\000\000\000\002a\002a\t\182\t\246\002a\002a\002a\002a\002a\000\000\000\000\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\000\238\000\000\002a\002a\002a\000\000\002a\002a\002a\002a\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\007\217\000\000\000\000\002a\002a\002a\002a\002]\002]\000\000\000\000\000\000\002]\b\n\006\014\002]\000\000\005\206\002]\000\000\002]\000\000\000\000\t\174\007\217\002]\002]\002]\007\217\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\002]\002]\002]\t\238\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]\t\182\t\246\002]\002]\002]\002]\002]\000\000\000\000\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\007\209\000\000\002]\002]\002]\000\000\002]\002]\002]\002]\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\007\209\000\000\000\000\002]\002]\002]\002]\002\133\002\133\000\000\000\000\000\000\002\133\000\000\011\194\002\133\000\000\007\209\002\133\000\000\002\133\000\000\000\000\t\174\007\209\002\133\002\133\002\133\007\209\002\133\002\133\002\133\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\133\000\000\000\000\000\000\000\000\000\000\002\133\002\133\n\022\n\030\002\133\000\000\000\000\000\000\000\000\002\133\000\000\n&\002\133\000\000\000\000\000\000\000\000\002\133\002\133\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\t\182\t\246\n.\n6\nF\002\133\002\133\000\000\000\000\002\133\000\000\002\133\nN\000\000\000\000\000\000\000\000\000\238\000\000\002\133\002\133\nV\000\000\002\133\002\133\002\133\002\133\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\002\133\002\133\002\133\n>\002\133\002\133\000\000\000\000\002\133\n^\002\133\000\000\007\161\000\000\000\000\002\133\002\133\nf\nn\002m\002m\000\000\000\000\000\000\002m\000\000\007\161\002m\000\000\005\206\002m\000\000\002m\000\000\000\000\t\174\007\161\002m\002m\002m\007\161\002m\002m\002m\000\000\000\000\000\000\000\000\000\000\002m\002m\002m\t\238\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\t\182\t\246\002m\002m\002m\002m\002m\000\000\000\000\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\000\238\000\000\002m\002m\002m\000\000\002m\002m\002m\002m\000\000\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\014\n\000\000\000\000\002m\002m\002m\002m\002i\002i\000\000\000\000\000\000\002i\000\000\011\134\002i\000\000\011\146\002i\000\000\002i\000\000\000\000\t\174\011\158\002i\002i\002i\011\170\002i\002i\002i\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\t\238\002i\000\000\002i\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002i\000\000\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\002i\002i\002i\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\t\182\t\246\002i\002i\002i\002i\002i\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\000\000\002i\002i\002i\002i\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\002i\002i\002i\002i\002i\002i\000\000\000\000\002i\002i\002i\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002}\002}\000\000\000\000\000\000\002}\000\000\002\006\002}\000\000\002f\002}\000\000\002}\000\000\000\000\t\174\000\000\002}\002}\002}\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002}\000\000\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\n\022\n\030\002}\000\000\027\014\001\222\000\000\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\002}\002}\000\238\015v\000\000\000\000\000\000\000\000\000\000\002}\002}\t\182\t\246\n.\n6\002}\002}\002}\000\000\000\000\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\000\000\005j\002}\002}\002}\000\000\002}\002}\002}\002}\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\002}\002}\002}\n>\002}\002}\000\000\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002Q\002Q\000\000\000\000\000\000\002Q\000\000\002\250\002Q\000\000\000\000\002Q\000\000\002Q\000\000\000\000\t\174\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\t\238\002Q\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002Q\000\000\005\162\000\000\000\000\002Q\000\000\002Q\002Q\000\000\000\000\000\000\003\218\002Q\002Q\002Q\0062\000\000\003\230\000\000\000\000\000\000\002Q\002Q\t\182\t\246\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\000\000\002Q\002Q\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\002Q\000\000\000\000\000\000\002Q\000\000\002Q\002Q\000\000\002Q\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002M\002M\000\000\000\000\000\000\002M\000\000\002\162\002M\000\000\000\000\002M\000\000\002M\000\000\000\000\t\174\000\000\002M\002M\002M\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002M\000\000\002M\000\000\000\000\000\000\000\000\000\000\002M\002M\n\022\n\030\002M\000\000\tn\002\238\000\000\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\002M\002M\000\238\011\226\000\000\011\242\000\000\000\000\000\000\002M\002M\t\182\t\246\n.\n6\002M\002M\002M\000\000\000\000\002M\000\000\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\002M\000\000\002M\002M\000\000\002M\002M\002M\n>\002M\002M\000\000\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002\169\002\169\000\000\000\000\000\000\002\169\000\000\002\162\002\169\000\000\000\000\002\169\000\000\002\169\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\002\169\000\000\002\169\000\000\000\000\000\000\000\000\000\000\002\169\002\169\n\022\n\030\002\169\000\000\012\166\002\238\000\000\002\169\000\000\002\169\002\169\000\000\000\000\000\000\000\000\002\169\002\169\002\169\012\186\000\000\012\206\000\000\000\000\000\000\002\169\002\169\t\182\t\246\n.\002\169\002\169\002\169\002\169\000\000\000\000\002\169\000\000\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\002\169\000\000\002\169\002\169\000\000\002\169\002\169\002\169\n>\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\002I\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\t\174\000\000\002I\002I\002I\000\000\002I\002I\002I\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002I\000\000\002I\000\000\000\000\000\000\000\000\000\000\002I\002I\n\022\n\030\002I\000\000\000\000\000\000\000\000\002I\000\000\002I\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\t\182\t\246\n.\n6\002I\002I\002I\000\000\000\000\002I\000\000\002I\002I\000\000\000\000\000\000\000\000\000\000\000\000\002I\002I\002I\000\000\002I\002I\002I\002I\000\000\000\000\000\000\002I\000\000\002I\002I\000\000\002I\002I\002I\n>\002I\002I\000\000\000\000\002I\002I\002I\000\000\000\000\000\000\000\000\002I\002I\002I\002I\002\129\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\t\174\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\t\230\t\254\n\006\t\238\002\129\000\000\002\129\000\000\000\000\000\000\000\000\000\000\002\129\002\129\n\022\n\030\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\t\182\t\246\n.\n6\002\129\002\129\002\129\000\000\000\000\002\129\000\000\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\002\129\000\000\002\129\002\129\000\000\002\129\002\129\002\129\n>\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\002y\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\t\174\000\000\002y\002y\002y\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002y\000\000\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\n\022\n\030\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\t\182\t\246\n.\n6\002y\002y\002y\000\000\000\000\002y\000\000\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\002y\000\000\002y\002y\000\000\002y\002y\002y\n>\002y\002y\000\000\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\002y\002y\002y\002y\002\137\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\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\137\000\000\000\000\000\000\000\000\000\000\002\137\002\137\n\022\n\030\002\137\000\000\000\000\000\000\000\000\002\137\000\000\n&\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\t\182\t\246\n.\n6\nF\002\137\002\137\000\000\000\000\002\137\000\000\002\137\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\137\002\137\nV\000\000\002\137\002\137\002\137\002\137\000\000\000\000\000\000\002\137\000\000\002\137\002\137\000\000\002\137\002\137\002\137\n>\002\137\002\137\000\000\000\000\002\137\n^\002\137\000\000\000\000\000\000\000\000\002\137\002\137\nf\nn\002\141\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\t\174\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\t\230\t\254\n\006\t\238\002\141\000\000\002\141\000\000\000\000\000\000\000\000\000\000\002\141\002\141\n\022\n\030\002\141\000\000\000\000\000\000\000\000\002\141\000\000\n&\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\t\182\t\246\n.\n6\nF\002\141\002\141\000\000\000\000\002\141\000\000\002\141\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\141\002\141\nV\000\000\002\141\002\141\002\141\002\141\000\000\000\000\000\000\002\141\000\000\002\141\002\141\000\000\002\141\002\141\002\141\n>\002\141\002\141\000\000\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\002\141\002\141\nf\nn\002\145\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\t\174\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\t\230\t\254\n\006\t\238\002\145\000\000\002\145\000\000\000\000\000\000\000\000\000\000\002\145\002\145\n\022\n\030\002\145\000\000\000\000\000\000\000\000\002\145\000\000\n&\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\t\182\t\246\n.\n6\nF\002\145\002\145\000\000\000\000\002\145\000\000\002\145\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\145\002\145\nV\000\000\002\145\002\145\002\145\002\145\000\000\000\000\000\000\002\145\000\000\002\145\002\145\000\000\002\145\002\145\002\145\n>\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\nf\nn\b\225\b\225\000\000\000\000\000\000\b\225\000\000\000\000\b\225\000\000\000\000\b\225\000\000\b\225\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\b\225\000\000\000\000\000\000\000\000\000\000\b\225\b\225\n\022\n\030\b\225\000\000\000\000\000\000\000\000\b\225\000\000\n&\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\t\182\t\246\n.\n6\nF\b\225\b\225\000\000\000\000\b\225\000\000\b\225\nN\000\000\000\000\000\000\000\000\000\000\000\000\b\225\b\225\nV\000\000\b\225\b\225\b\225\b\225\000\000\000\000\000\000\b\225\000\000\b\225\b\225\000\000\b\225\b\225\b\225\n>\b\225\b\225\000\000\000\000\b\225\n^\b\225\000\000\000\000\000\000\000\000\b\225\b\225\nf\nn\002\149\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\000\000\000\000\t\174\000\000\002\149\002\149\002\149\000\000\002\149\002\149\002\149\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\149\000\000\000\000\000\000\000\000\000\000\002\149\002\149\n\022\n\030\002\149\000\000\000\000\000\000\000\000\002\149\000\000\n&\002\149\000\000\000\000\000\000\000\000\002\149\002\149\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\149\002\149\t\182\t\246\n.\n6\nF\002\149\002\149\000\000\000\000\002\149\000\000\002\149\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\149\002\149\nV\000\000\002\149\002\149\002\149\002\149\000\000\000\000\000\000\002\149\000\000\002\149\002\149\000\000\nv\002\149\n~\n>\002\149\002\149\000\000\000\000\002\149\n^\002\149\000\000\000\000\000\000\000\000\002\149\002\149\nf\nn\b\221\b\221\000\000\000\000\000\000\b\221\000\000\000\000\b\221\000\000\000\000\b\221\000\000\b\221\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\b\221\000\000\000\000\000\000\000\000\000\000\b\221\b\221\n\022\n\030\b\221\000\000\000\000\000\000\000\000\b\221\000\000\n&\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\t\182\t\246\n.\n6\nF\b\221\b\221\000\000\000\000\b\221\000\000\b\221\nN\000\000\000\000\000\000\000\000\000\000\000\000\b\221\b\221\nV\000\000\b\221\b\221\b\221\b\221\000\000\000\000\000\000\b\221\000\000\b\221\b\221\000\000\b\221\b\221\b\221\n>\b\221\b\221\000\000\000\000\b\221\n^\b\221\000\000\000\000\000\000\000\000\b\221\b\221\nf\nn\002\197\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\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\n\022\n\030\002\197\000\000\000\000\000\000\000\000\002\197\000\000\n&\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\t\182\t\246\n.\n6\nF\002\197\002\197\000\000\000\000\002\197\000\000\002\197\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\nV\000\000\002\197\002\197\002\197\002\197\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\nv\002\197\n~\n>\002\197\002\197\000\000\000\000\002\197\n^\002\197\000\000\000\000\000\000\000\000\002\197\002\197\nf\nn\002\193\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\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n\022\n\030\002\193\000\000\000\000\000\000\000\000\002\193\000\000\n&\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\t\182\t\246\n.\n6\nF\002\193\002\193\000\000\000\000\002\193\000\000\002\193\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\nV\000\000\002\193\002\193\002\193\002\193\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\nv\002\193\n~\n>\002\193\002\193\000\000\000\000\002\193\n^\002\193\000\000\000\000\000\000\000\000\002\193\002\193\nf\nn\002\201\002\201\000\000\000\000\000\000\002\201\000\000\000\000\002\201\000\000\000\000\002\201\000\000\002\201\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\201\000\000\000\000\000\000\000\000\000\000\002\201\002\201\n\022\n\030\002\201\000\000\000\000\000\000\000\000\002\201\000\000\n&\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\t\182\t\246\n.\n6\nF\002\201\002\201\000\000\000\000\002\201\000\000\002\201\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\201\002\201\nV\000\000\002\201\002\201\002\201\002\201\000\000\000\000\000\000\002\201\000\000\002\201\002\201\000\000\nv\002\201\n~\n>\002\201\002\201\000\000\000\000\002\201\n^\002\201\000\000\000\000\000\000\000\000\002\201\002\201\nf\nn\002\181\002\181\000\000\000\000\000\000\002\181\000\000\000\000\002\181\000\000\000\000\002\181\000\000\002\181\000\000\000\000\t\174\000\000\002\181\002\181\002\181\000\000\002\181\002\181\002\181\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\181\000\000\000\000\000\000\000\000\000\000\002\181\002\181\n\022\n\030\002\181\000\000\000\000\000\000\000\000\002\181\000\000\n&\002\181\000\000\000\000\000\000\000\000\002\181\002\181\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\t\182\t\246\n.\n6\nF\002\181\002\181\000\000\000\000\002\181\000\000\002\181\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\nV\000\000\002\181\002\181\002\181\002\181\000\000\000\000\000\000\002\181\000\000\002\181\002\181\000\000\nv\002\181\n~\n>\002\181\002\181\000\000\000\000\002\181\n^\002\181\000\000\000\000\000\000\000\000\002\181\002\181\nf\nn\002\185\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\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n\022\n\030\002\185\000\000\000\000\000\000\000\000\002\185\000\000\n&\002\185\000\000\000\000\000\000\000\000\002\185\002\185\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\t\182\t\246\n.\n6\nF\002\185\002\185\000\000\000\000\002\185\000\000\002\185\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\nV\000\000\002\185\002\185\002\185\002\185\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\nv\002\185\n~\n>\002\185\002\185\000\000\000\000\002\185\n^\002\185\000\000\000\000\000\000\000\000\002\185\002\185\nf\nn\002\189\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\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\n\022\n\030\002\189\000\000\000\000\000\000\000\000\002\189\000\000\n&\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\t\182\t\246\n.\n6\nF\002\189\002\189\000\000\000\000\002\189\000\000\002\189\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\nV\000\000\002\189\002\189\002\189\002\189\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\nv\002\189\n~\n>\002\189\002\189\000\000\000\000\002\189\n^\002\189\000\000\000\000\000\000\000\000\002\189\002\189\nf\nn\002\209\002\209\000\000\000\000\000\000\002\209\000\000\000\000\002\209\000\000\000\000\002\209\000\000\002\209\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\209\000\000\000\000\000\000\000\000\000\000\002\209\002\209\n\022\n\030\002\209\000\000\000\000\000\000\000\000\002\209\000\000\n&\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\t\182\t\246\n.\n6\nF\002\209\002\209\000\000\000\000\002\209\000\000\002\209\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\209\002\209\nV\000\000\002\209\002\209\002\209\002\209\000\000\000\000\000\000\002\209\000\000\002\209\002\209\000\000\nv\002\209\n~\n>\002\209\002\209\000\000\000\000\002\209\n^\002\209\000\000\000\000\000\000\000\000\002\209\002\209\nf\nn\002\205\002\205\000\000\000\000\000\000\002\205\000\000\000\000\002\205\000\000\000\000\002\205\000\000\002\205\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\205\000\000\000\000\000\000\000\000\000\000\002\205\002\205\n\022\n\030\002\205\000\000\000\000\000\000\000\000\002\205\000\000\n&\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\t\182\t\246\n.\n6\nF\002\205\002\205\000\000\000\000\002\205\000\000\002\205\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\205\002\205\nV\000\000\002\205\002\205\002\205\002\205\000\000\000\000\000\000\002\205\000\000\002\205\002\205\000\000\nv\002\205\n~\n>\002\205\002\205\000\000\000\000\002\205\n^\002\205\000\000\000\000\000\000\000\000\002\205\002\205\nf\nn\002\213\002\213\000\000\000\000\000\000\002\213\000\000\000\000\002\213\000\000\000\000\002\213\000\000\002\213\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\213\000\000\000\000\000\000\000\000\000\000\002\213\002\213\n\022\n\030\002\213\000\000\000\000\000\000\000\000\002\213\000\000\n&\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\t\182\t\246\n.\n6\nF\002\213\002\213\000\000\000\000\002\213\000\000\002\213\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\213\002\213\nV\000\000\002\213\002\213\002\213\002\213\000\000\000\000\000\000\002\213\000\000\002\213\002\213\000\000\nv\002\213\n~\n>\002\213\002\213\000\000\000\000\002\213\n^\002\213\000\000\000\000\000\000\000\000\002\213\002\213\nf\nn\002\177\002\177\000\000\000\000\000\000\002\177\000\000\000\000\002\177\000\000\000\000\002\177\000\000\002\177\000\000\000\000\t\174\000\000\002\177\002\177\002\177\000\000\002\177\002\177\002\177\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\177\000\000\000\000\000\000\000\000\000\000\002\177\002\177\n\022\n\030\002\177\000\000\000\000\000\000\000\000\002\177\000\000\n&\002\177\000\000\000\000\000\000\000\000\002\177\002\177\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\t\182\t\246\n.\n6\nF\002\177\002\177\000\000\000\000\002\177\000\000\002\177\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\nV\000\000\002\177\002\177\002\177\002\177\000\000\000\000\000\000\002\177\000\000\002\177\002\177\000\000\nv\002\177\n~\n>\002\177\002\177\000\000\000\000\002\177\n^\002\177\000\000\000\000\000\000\000\000\002\177\002\177\nf\nn\002\001\002\001\000\000\000\000\000\000\002\001\000\000\000\000\002\001\000\000\000\000\002\001\000\000\002\001\000\000\000\000\002\001\000\000\002\001\002\001\002\001\000\000\002\001\002\001\002\001\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\000\000\002\001\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\000\000\000\000\000\000\000\000\002\001\000\000\002\001\002\001\000\000\000\000\000\000\000\000\002\001\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\000\000\000\000\002\001\000\000\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\000\000\002\001\002\001\002\001\002\001\000\000\000\000\000\000\002\001\000\000\002\001\002\001\000\000\002\001\002\001\002\001\002\001\002\001\002\001\000\000\000\000\002\001\002\001\r\226\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\029\002\029\000\000\000\000\000\000\002\029\000\000\000\000\002\029\000\000\000\000\002\029\000\000\002\029\000\000\000\000\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\029\000\000\000\000\000\000\000\000\000\000\002\029\002\029\n\022\n\030\002\029\000\000\000\000\000\000\000\000\002\029\000\000\n&\002\029\000\000\000\000\000\000\000\000\002\029\002\029\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\029\002\029\t\182\t\246\n.\n6\nF\002\029\002\029\000\000\000\000\002\029\000\000\002\029\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\029\002\029\nV\000\000\002\029\002\029\r\250\002\029\000\000\000\000\000\000\002\029\000\000\002\029\002\029\000\000\nv\002\029\n~\n>\002\029\002\029\000\000\000\000\002\029\n^\002\029\000\000\000\000\000\000\000\000\002\029\002\029\nf\nn\002\025\002\025\000\000\000\000\000\000\002\025\000\000\000\000\002\025\000\000\000\000\002\025\000\000\002\025\000\000\000\000\t\174\000\000\002\025\002\025\002\025\000\000\002\025\002\025\002\025\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\025\000\000\000\000\000\000\000\000\000\000\002\025\002\025\n\022\n\030\002\025\000\000\000\000\000\000\000\000\002\025\000\000\n&\002\025\000\000\000\000\000\000\000\000\002\025\002\025\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\025\002\025\t\182\t\246\n.\n6\nF\002\025\002\025\000\000\000\000\002\025\000\000\002\025\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\025\002\025\nV\000\000\002\025\002\025\002\025\002\025\000\000\000\000\000\000\002\025\000\000\002\025\002\025\000\000\nv\002\025\n~\n>\002\025\002\025\000\000\000\000\002\025\n^\002\025\000\000\000\000\000\000\000\000\002\025\002\025\nf\nn\002\173\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\t\174\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\t\230\t\254\n\006\t\238\n\014\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002\173\002\173\n\022\n\030\002\173\000\000\000\000\000\000\000\000\002\173\000\000\n&\002\173\000\000\000\000\000\000\000\000\002\173\002\173\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\t\182\t\246\n.\n6\nF\002\173\002\173\000\000\000\000\002\173\000\000\002\173\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\nV\000\000\002\173\002\173\002\173\002\173\000\000\000\000\000\000\002\173\000\000\002\173\002\173\000\000\nv\002\173\n~\n>\002\173\002\173\000\000\000\000\002\173\n^\002\173\000\000\000\000\000\000\000\000\002\173\002\173\nf\nn\002\r\002\r\000\000\000\000\000\000\002\r\000\000\000\000\002\r\000\000\000\000\002\r\000\000\002\r\000\000\000\000\002\r\000\000\002\r\002\r\002\r\000\000\002\r\002\r\002\r\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\r\000\000\002\r\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\r\000\000\000\000\000\000\000\000\002\r\000\000\002\r\002\r\000\000\000\000\000\000\000\000\002\r\002\r\002\r\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\r\002\r\002\r\002\r\002\r\000\000\000\000\002\r\000\000\002\r\002\r\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\000\000\002\r\002\r\002\r\002\r\000\000\000\000\000\000\002\r\000\000\002\r\002\r\000\000\002\r\002\r\002\r\002\r\002\r\002\r\000\000\000\000\002\r\002\r\r\226\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\017\002\017\000\000\000\000\000\000\002\017\000\000\000\000\002\017\000\000\000\000\002\017\000\000\002\017\000\000\000\000\002\017\000\000\002\017\002\017\002\017\000\000\002\017\002\017\002\017\000\000\000\000\000\000\000\000\000\000\002\017\002\017\002\017\002\017\002\017\000\000\002\017\000\000\000\000\000\000\000\000\000\000\002\017\002\017\002\017\002\017\002\017\003\253\000\000\000\000\000\000\002\017\000\000\002\017\002\017\000\000\000\000\000\000\000\000\002\017\002\017\002\017\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002\017\002\017\002\017\002\017\002\017\002\017\002\017\002\017\000\000\000\000\002\017\000\000\002\017\002\017\000\000\000\000\000\000\000\000\000\000\000\238\002\017\002\017\002\017\000\000\002\017\002\017\002\017\002\017\000\000\000\000\000\000\002\017\000\000\002\017\002\017\000\000\002\017\002\017\002\017\002\017\002\017\002\017\000\000\000\000\002\017\002\017\r\226\000\000\000\000\003\253\000\000\002\017\002\017\002\017\002\017\001\006\000\000\000\006\000\000\007\r\000\000\002\158\002\162\006\014\002\206\002f\005\206\b\214\000\000\000\000\002\218\001\n\012\181\006\026\000\000\002r\000\000\006&\007\r\000\000\001\210\000\000\007\r\000\000\003\026\001\018\bR\bV\001\030\001\"\000\000\000\000\012\181\003*\000\000\002\226\000\000\025\002\002\030\bz\b~\000\000\003\194\003\022\003\206\b\130\006\186\000\000\001:\000\000\002\150\002&\000\000\003\030\002*\012\161\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\b\150\001R\000\000\007\001\000\000\001V\000\000\b\162\b\186\t\014\005f\005j\000\000\000\000\001Z\000\000\000\000\000\000\007\r\000\000\001^\000\000\007\001\000\000\000\000\000\000\007\001\012\181\012\161\000\000\001\154\n\246\000\000\n\178\005n\b\022\n\190\001\158\000\000\014*\004V\t\"\001\006\001\166\000\006\001\170\001\174\012\181\002\158\002\162\000\000\002\206\002f\002\030\000\000\000\000\000\000\002\218\001\n\000\000\002\"\000\000\bN\000\000\000\238\000\000\002&\001\210\000\000\002*\012\161\003\026\001\018\bR\bV\001\030\001\"\000\000\000\000\000\000\003*\000\000\002\226\000\000\bZ\000\000\bz\b~\000\000\003\194\003\022\003\206\b\130\006\186\000\000\001:\000\000\002\150\006\229\000\000\003\030\000\000\000\000\000\000\007\254\b\002\b\014\b\"\006\014\005Z\000\000\005\206\001>\001B\001F\001J\001N\006\229\006\026\b\150\001R\006\229\006&\000\000\001V\000\000\b\162\b\186\t\014\005f\005j\000\000\000\000\001Z\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\001\154\005\250\000\000\000\000\005n\b\022\000\000\001\158\000\000\014*\004V\t\"\004m\001\166\000\006\001\170\001\174\000\246\002\158\002\162\002\166\002\206\002f\000\000\002\225\000\000\000\000\002\218\018f\000\000\003\150\000\000\000\000\000\000\004m\000\000\003\154\001\210\000\000\016\254\006\229\002\222\000\000\003\"\003&\000\000\000\000\000\000\003\158\000\000\003*\000\000\002\226\000\n\016\146\000\000\003\186\003\190\003\254\003\194\003\022\003\206\003\214\006\186\000\000\000\000\016\246\002\150\000\000\002\225\003\030\017\014\000\000\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\002\225\002\225\000\000\000\000\000\000\000\000\017\022\000\000\b\150\000\000\t\r\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\017*\017V\000\000\000\000\004m\004m\000\000\000\000\000\000\006J\024\206\000\000\t\r\000\000\000\000\015f\000\000\000\000\002f\000\000\017\146\021~\005n\b\022\024\238\000\173\000\000\b.\004V\t\"\000\173\000\000\002\162\000\173\000\000\002f\021&\tJ\000\000\000\000\002\218\000\000\000\000\000\173\000\000\000\173\000\000\000\173\000\000\000\173\001\210\000\238\tR\000\000\002\222\000\000\015j\000\000\000\000\000\000\tZ\000\173\000\000\000\000\000\000\002\226\000\000\000\173\000\000\000\000\015v\000\173\021J\003\022\001\190\015f\000\173\000\000\002f\000\173\002\150\000\000\000\000\003\030\000\173\000\173\000\173\007\254\b\002\b\014\000\000\012J\005Z\000\173\000\173\006\014\005j\000\000\005\206\024\210\000\173\000\000\000\000\t\r\000\173\006\026\021V\000\000\000\000\006&\000\000\000\000\005f\005j\000\173\000\173\015j\000\000\000\173\000\173\000\000\000\000\000\000\020\234\000\000\000\000\000\000\000\000\000\173\000\000\015v\000\000\021*\000\000\000\173\000\173\005n\b\022\000\000\000\000\000\197\b.\004V\000\000\000\173\000\197\000\173\002\162\000\197\000\000\002f\000\000\tJ\000\000\000\000\002\218\005j\000\000\000\197\000\000\000\197\000\000\000\197\000\000\000\197\001\210\0216\tR\000\000\002\222\003\178\000\000\002\162\000\000\000\000\tZ\000\197\000\000\b\182\003\142\002\226\000\000\000\197\020\234\000\000\007\198\000\197\000\000\003\022\001\190\001\210\000\197\000\000\000\000\000\197\002\150\000\000\000\000\003\030\000\197\000\197\000\197\007\254\b\002\b\014\000\000\012J\005Z\000\197\000\197\000\000\000\000\000\000\003\174\000\000\000\197\000\000\000\000\r\206\000\197\002\150\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\197\000\197\000\000\000\000\000\197\000\197\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\197\000\000\000\000\000\000\000\000\006\206\000\197\000\197\005n\b\022\000\000\000\000\000\000\b.\004V\000\000\000\197\000\000\000\197\000\014\000\018\000\022\000\026\000\030\000\000\000\"\000&\000*\000.\0002\000\000\0006\000:\000\000\000\000\000>\000\000\006\014\000\000\000B\005\206\000\000\012\181\012\161\000\000\000\000\000F\006\026\000\000\000\000\000\000\006&\000J\000\000\000N\000R\000V\000Z\000^\000b\000f\000\000\012\181\000\000\000j\000n\000\000\000r\002\030\000v\000\000\000\000\000\000\000\000\000\000\002\178\000\000\000\000\000\000\000\000\000\000\002&\000\000\000z\002*\012\161\000~\000\130\000\000\000\000\000\000\000\000\000\000\000\134\000\138\000\142\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\000\000\000\174\000\178\000\182\000\000\000\000\000\000\000\186\000\006\000\190\000\194\000\246\002\158\002\162\002\166\002\206\002f\000\198\000\000\000\202\000\000\002\218\000\000\000\000\004\141\000\206\000\210\000\000\000\214\000\000\003\154\001\210\000\000\000\000\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\003\158\000\000\003*\000\000\002\226\000\000\016\146\000\000\003\186\003\190\000\000\003\194\003\022\003\206\003\214\006\186\000\000\000\000\016\246\002\150\000\000\000\000\003\030\017\014\000\000\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\022\000\000\b\150\000\000\027\222\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\017*\017V\000\000\000\006\027\255\014\190\000\246\002\158\002\162\002\166\002\206\002f\000\000\000\000\000\000\000\000\002\218\000\000\000\000\028.\000\000\021~\005n\b\022\014>\003\154\001\210\b.\004V\t\"\002\222\000\000\003\"\003&\000\000\000\000\000\000\003\158\000\000\003*\000\000\002\226\000\000\016\146\000\000\003\186\003\190\000\000\003\194\003\022\003\206\003\214\006\186\000\000\016R\016\246\002\150\000\000\000\000\003\030\017\014\002\006\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\002\n\000\000\000\000\000\000\000\000\017\022\000\000\b\150\001\210\027\222\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\017*\017V\000\000\000\000\004\149\000\000\003~\000\000\000\000\000\000\001\006\000\000\006\230\001\222\000\000\000\000\003:\002\162\b\246\002\150\002f\021~\005n\b\022\000\000\002\218\001\n\b.\004V\t\"\002r\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\001\014\001\018\001\022\003Z\001\030\001\"\000\000\000\000\006\234\000\000\000\000\002\225\000\000\003^\002\225\001.\n\242\000\000\000\000\003V\001\190\0016\002\225\000\000\001:\000\000\002\150\000\000\000\000\003\218\000\000\000\000\002\225\003\222\000\000\003\230\005N\000\n\005Z\000\000\002\225\001>\001B\001F\001J\001N\000\000\000\000\000\n\001R\005^\000\000\002\225\001V\000\000\000\000\000\000\002\225\005f\005j\000\000\005\174\001Z\002\225\002\225\002\225\002\225\000\000\001^\000\000\002\225\000\000\000\000\000\000\000\000\000\000\002\225\000\000\001\154\n\246\011\002\000\000\005n\000\000\000\000\001\158\000\000\001\162\004V\001\006\000\000\001\166\002\225\001\170\001\174\003:\002\162\n\150\002\225\002f\011\006\000\000\000\000\000\000\002\218\001\n\000\000\000\000\000\000\002r\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\001\014\001\018\001\022\003Z\001\030\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003^\000\000\001.\n\242\000\000\000\000\003V\001\190\0016\000\000\000\238\001:\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\005^\000\000\000\000\001V\007\173\000\000\000\000\000\000\005f\005j\000\000\005\174\001Z\000\000\000\000\000\000\000\000\006\014\001^\000\000\005\206\011\n\000\000\000\000\000\000\000\000\000\000\006\026\001\154\n\246\000\000\006&\005n\000\000\007\173\001\158\000\000\001\162\004V\001\006\000\000\001\166\000\000\001\170\001\174\003:\002\162\r\142\007\173\002f\000\000\007\173\b\138\000\000\002\218\001\n\000\000\000\000\007\173\002r\000\000\000\000\007\173\000\000\001\210\000\000\000\000\000\000\001\014\001\018\001\022\003Z\001\030\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003^\000\000\001.\n\242\000\000\000\000\003V\001\190\0016\n\181\000\000\001:\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\005^\000\000\n\181\001V\000\000\000\000\000\000\000\000\005f\005j\000\000\005\174\001Z\000\000\000\000\000\000\n\181\000\000\001^\n\181\011j\000\000\000\000\000\000\000\000\000\000\n\181\000\000\001\154\n\246\n\181\000\000\005n\000\000\000\000\001\158\000\000\001\162\004V\000\000\b\249\001\166\000\006\001\170\001\174\000\000\002\158\002\162\000\000\002\206\002f\000\000\000\000\000\000\000\000\002\218\000\000\000\000\000\000\000\000\b\249\000\000\b\249\b\249\000\000\001\210\000\000\000\000\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\000\000\b\001\003*\000\000\002\226\000\000\b\001\000\000\003\186\003\190\n\194\003\194\003\022\003\206\003\214\006\186\001\202\001\206\011\"\002\150\000\000\000\000\003\030\000\000\000\000\b\001\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\000\000\001\210\002\142\001\230\000\000\000\000\000\000\b\150\000\000\000\000\000\000\001\242\000\000\b\001\b\162\b\186\t\014\005f\005j\000\000\000\000\b\001\000\000\000\000\001\246\002v\b\001\b\001\000\238\002\130\000\000\002\150\004\002\004\014\000\000\b\001\b\001\000\000\004\026\000\000\000\000\005n\b\022\b\249\004\253\004\253\b.\004V\t\"\004\253\000\000\004\253\004\253\000\000\004\253\004\030\004\253\004\253\b\001\000\000\004\253\b\001\004\253\004\253\004\253\004\253\004\253\004\253\004\253\004\253\b\001\004\253\016b\004\253\000\000\000\000\000\000\000\000\000\000\002\006\004\253\000\000\000\000\000\000\000\000\004\253\004\253\004\253\000\000\002\n\004\253\004\253\004\253\004\253\000\000\004\253\000\000\001\210\004\253\000\000\000\000\000\000\000\000\004\253\004\253\004\253\000\000\000\000\004\253\004\253\004\253\000\000\004\253\004\253\003~\000\000\000\000\000\000\000\000\004\253\006\230\001\222\000\000\004\253\004\253\000\000\004\253\002\150\004\253\000\000\000\000\000\000\000\000\004\253\004\253\004\253\000\000\004\253\004\253\004\253\004\253\000\000\004\253\004\253\000\000\000\000\000\000\004\253\000\000\004\253\004\253\000\000\000\000\002z\004\253\006\234\000\000\000\000\019\254\004\253\000\000\n\205\000\000\004\253\n\205\004\253\004\253\n\205\n\205\000\000\004\253\n\205\000\000\n\205\000\000\000\000\n\205\000\000\000\000\000\000\n\205\n\205\000\000\n\205\n\205\000\000\n\205\000\000\n\205\000\000\025\026\002\225\002\225\n\205\000\000\000\000\n\205\002\006\000\000\000\000\000\000\000\000\000\000\000\000\n\205\000\000\n\205\002\n\000\000\n\205\n\205\002\225\000\000\000\000\000\000\001\210\n\205\002\225\000\n\n\205\000\000\000\000\n\205\n\205\002\225\n\205\000\000\n\205\n\205\000\000\002\225\000\000\003~\002\225\002\225\000\000\000\000\000\000\006\230\001\222\n\205\000\000\000\000\000\000\000\000\002\150\002\225\000\000\n\205\n\205\000\000\000\000\n\205\000\000\n\205\000\000\000\000\000\000\000\000\005\138\000\000\000\000\000\000\000\000\001\202\001\206\n\205\n\205\000\000\n\205\n\205\000\000\n\205\006\234\n\205\000\000\n\205\000\000\n\205\000\000\n\205\b\229\b\229\001\210\001\214\001\230\b\229\000\000\001\206\b\229\000\000\000\000\000\000\001\242\000\000\000\000\018\146\b\229\000\000\b\229\b\229\b\229\000\000\b\229\b\229\b\229\001\246\019\250\000\000\019\026\000\000\002\130\000\000\002\150\004\002\004\014\000\000\b\229\000\000\000\000\020\n\000\000\000\000\b\229\b\229\000\000\000\000\b\229\000\000\000\000\002~\000\000\b\229\000\000\000\000\b\229\000\000\004\030\000\000\000\000\b\229\b\229\b\229\000\000\000\000\000\000\000\000\000\000\000\000\b\229\b\229\000\000\000\000\000\000\000\000\000\000\b\229\000\000\000\000\000\000\004~\000\000\000\000\b\229\000\000\000\000\000\000\000\000\000\000\000\000\b\229\b\229\b\229\000\000\b\229\b\229\000\000\004Y\000\000\000\000\000\000\000\000\004Y\000\000\b\229\004Y\b\229\b\229\000\000\000\000\000\000\b\229\000\000\000\000\000\000\004Y\b\229\000\000\000\000\004Y\b\229\004Y\b\229\b\229\012u\012u\000\000\000\000\004Y\012u\000\000\001\206\012u\004Y\000\000\000\000\000\000\000\000\000\000\004Y\004\158\000\000\012u\012u\012u\004&\012u\012u\012u\000\000\000\000\004Y\004Y\000\000\000\000\000\000\004Y\002\198\000\000\000\000\012u\000\000\000\000\000\000\000\000\000\000\012u\012u\000\000\000\000\012u\000\000\004Y\002~\004Y\012u\000\000\000\000\012u\000\000\000\000\000\000\004Y\012u\012u\012u\004Y\004Y\002\198\000\238\004Y\004Y\012u\012u\000\000\000\000\0046\004Y\000\000\012u\000\000\000\000\000\000\004~\000\000\000\000\012u\004Y\000\000\000\000\000\000\000\000\020\254\012u\012u\012u\000\000\012u\012u\000\000\004Y\000\000\004Y\000\000\000\000\004Y\000\000\012u\004Y\012u\012u\004Y\000\000\000\000\012u\000\000\000\000\000\000\004Y\012u\000\000\000\000\004Y\012u\004Y\012u\012u\b\233\b\233\000\000\000\000\000\000\b\233\000\000\001\206\b\233\004Y\000\000\000\000\000\000\000\000\000\000\004Y\b\233\000\000\b\233\b\233\b\233\000\000\b\233\b\233\b\233\000\000\000\000\004Y\000\000\000\000\000\000\000\000\004Y\002\198\000\000\000\000\b\233\000\000\000\000\000\000\000\000\000\000\b\233\b\233\000\000\000\000\b\233\000\000\004Y\002~\000\000\b\233\000\000\000\000\b\233\000\000\000\000\000\000\000\000\b\233\b\233\b\233\004Y\004Y\000\000\000\000\004Y\004Y\b\233\b\233\002\225\000\000\007R\000\000\000\000\b\233\000\000\002\225\000\000\004~\000\000\000\000\b\233\004Y\000\000\000\000\000\000\000\000\002\225\b\233\b\233\b\233\002\225\b\233\b\233\001*\000\n\002\225\002\225\002\225\000\000\000\000\002\225\b\233\002\225\b\233\b\233\002\225\002\225\002\225\b\233\002\225\002\225\002\225\002\225\b\233\002\225\002\225\002\225\b\233\002\225\b\233\b\233\000\000\002\225\000\n\000\000\002\225\000\n\002\225\000\000\002\225\000\000\002\225\002\225\000\n\000\000\002\225\002\225\000\n\002\225\002\225\002\225\002\225\000\000\000\000\002\225\002\225\000\000\002\225\002\225\002\225\002\225\002\225\002\225\000\000\002\225\002\225\000\000\002\225\002\225\002\225\000\000\002\225\002\225\002\225\002\225\002\225\002\225\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\000\000\002\225\002\225\002\225\002\225\002\225\000\000\000\000\000\000\002\225\002\225\002\225\002\225\002\225\000\000\006\141\000\000\0009\002\225\002\225\000\000\0009\0009\000\000\0009\0009\002\225\000\000\000\000\000\000\0009\000\000\002\225\000\000\003\162\006\141\002\225\002\225\000\000\000\000\0009\002\225\002\225\002\225\0009\006\194\0009\0009\000\000\000\000\000\000\000\000\000\000\0009\000\000\0009\000\000\000\000\000\000\0009\0009\000\000\0009\0009\0009\0009\0009\000\000\000\000\000\000\0009\000\000\000\000\0009\000\000\000\000\000\000\0009\0009\0009\0009\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\0009\0009\0009\0009\0009\000\000\006\137\000\000\0005\000\000\000\000\000\000\0005\0005\000\000\0005\0005\000\000\000\000\000\000\000\000\0005\000\000\000\000\000\000\000\000\006\137\0009\0009\000\000\000\000\0005\0009\0009\0009\0005\000\000\0005\0005\000\000\000\000\000\000\000\000\000\000\0005\000\000\0005\000\000\000\000\000\000\0005\0005\000\000\0005\0005\0005\0005\0005\000\000\000\000\000\000\0005\000\000\000\000\0005\000\000\000\000\000\000\0005\0005\0005\0005\000\000\0005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0005\000\000\000\000\000\000\000\000\000\000\000\000\0005\0005\0005\0005\0005\000\000\006\153\000\000\012=\000\000\000\000\000\000\012=\012=\000\000\012=\012=\000\000\000\000\000\000\000\000\012=\000\000\000\000\000\000\000\000\006\153\0005\0005\000\000\000\000\012=\0005\0005\0005\012=\000\000\012=\012=\000\000\000\000\000\000\000\000\000\000\012=\000\000\012=\000\000\000\000\000\000\012=\012=\000\000\012=\012=\012=\012=\012=\000\000\000\000\000\000\012=\000\000\000\000\012=\000\000\000\000\000\000\012=\012=\012=\012=\000\000\012=\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\012=\012=\012=\012=\012=\000\000\006\149\000\000\0129\000\000\000\000\000\000\0129\0129\000\000\0129\0129\000\000\000\000\000\000\000\000\0129\000\000\000\000\000\000\000\000\006\149\012=\012=\000\000\000\000\0129\012=\012=\012=\0129\000\000\0129\0129\000\000\000\000\000\000\000\000\000\000\0129\000\000\0129\000\000\000\000\000\000\0129\0129\000\000\0129\0129\0129\0129\0129\000\000\001\202\001\206\0129\000\000\000\000\0129\000\000\000\000\000\000\0129\0129\0129\0129\000\000\0129\000\000\000\000\000\000\000\000\001\210\001\214\001\230\000\000\000\000\0129\000\000\000\000\000\000\000\000\001\242\000\000\0129\0129\0129\0129\0129\001\250\000\000\000\000\000\000\000\000\000\000\001\246\002v\000\000\000\000\000\000\002\130\000\000\002\150\004\002\004\014\012y\012y\000\000\000\000\004\026\012y\0129\0129\012y\000\000\000\000\0129\0129\0129\000\000\000\000\004n\000\000\012y\012y\012y\004\030\012y\012y\012y\000\000\001\021\000\000\000\000\000\000\000\000\001\021\000\000\000\000\000\000\000\000\012y\000\000\000\000\000\000\000\000\000\000\012y\012y\000\000\000\000\012y\000\000\000\000\000\000\001\021\012y\000\000\000\000\012y\000\000\000\000\000\000\000\000\012y\012y\012y\000\000\000\000\000\000\000\000\000\000\000\000\012y\012y\000\000\000\000\001\021\000\000\018\154\012y\000\000\000\000\000\000\012y\001\021\000\000\012y\000\000\000\000\001\021\000\000\000\000\000\000\012y\012y\012y\000\000\012y\012y\001\021\000\000\000\000\000\000\000\000\000\000\000\000\007\253\012y\000\006\012y\012y\007\253\002\158\002\162\012y\002\206\002f\000\000\000\000\012y\000\000\002\218\000\000\012y\001\021\012y\012y\000\000\003\226\000\000\007\253\001\210\000\000\001\021\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\000\000\000\000\003*\000\000\002\226\000\000\000\000\000\000\003\186\003\190\007\253\003\194\003\022\003\206\003\214\006\186\000\000\000\000\007\253\002\150\000\000\000\000\003\030\007\253\007\253\000\238\007\254\b\002\b\014\b\"\000\000\005Z\007\253\007\253\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\150\000\000\000\000\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\000\000\000\000\007\253\000\000\000\000\007\253\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\007\253\002\158\002\162\000\000\002\206\002f\000\000\000\000\005n\b\022\002\218\000\000\000\000\b.\004V\t\"\000\000\014R\000\000\000\000\001\210\000\000\000\000\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\001\197\000\000\003*\000\000\002\226\001\197\000\000\000\000\003\186\003\190\000\000\003\194\003\022\003\206\003\214\006\186\000\000\000\000\000\000\002\150\000\000\000\000\003\030\000\000\001\197\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005-\012\217\b\150\000\000\000\000\0051\012\217\001\197\000\000\b\162\b\186\t\014\005f\005j\000\000\001\197\000\000\000\000\000\000\005-\001\197\001\197\000\238\005-\0051\000\000\003\029\003\029\0051\001\197\001\197\003\029\000\000\000\000\003\029\000\000\005n\b\022\000\000\000\000\000\000\b.\004V\t\"\003\029\003\029\003\029\000\000\003\029\003\029\003\029\000\000\000\000\000\000\000\000\001\197\000\000\000\000\000\000\000\000\000\000\000\000\003\029\000\000\001\197\000\000\000\000\000\000\003\029\004f\000\000\000\000\003\029\000\000\000\000\000\000\000\000\003\029\012\217\012\217\003\029\000\000\000\000\012\217\012\217\003\029\003\029\003\029\000\000\000\000\000\000\005-\000\000\000\000\003\029\003\029\0051\012\217\000\000\012\217\000\000\003\029\012\217\000\000\012\217\003\029\005-\000\000\003\029\005-\000\000\0051\000\000\000\000\0051\003\029\003\029\003\029\004}\003\029\003\029\000\000\000\000\018\170\000\000\000\000\000\000\000\000\000\000\003\029\000\000\003\029\003\029\000\000\000\000\000\000\003\029\000\000\000\000\000\000\000\000\003\029\003\154\n\217\000\000\003\029\n\217\003\029\003\029\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\n\217\n\217\018\214\n\217\n\217\000\000\001\210\000\000\006\170\000\000\016\246\000\000\000\000\003>\000\000\017\014\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\217\019\018\003J\000\000\000\000\003V\001\190\000\000\000\000\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\n\217\003\222\000\000\003\230\005N\n\162\005Z\000\000\004}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019v\005^\001\202\001\206\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\005\174\n\217\000\000\n\217\000\000\000\000\000\000\000\000\000\000\001\210\001\214\000\000\000\000\000\000\000\000\n\217\000\000\000\000\n\217\n\217\000\000\005n\000\000\n\217\000\000\n\217\000\000\004V\n\213\n\217\000\000\n\213\001\246\002\134\003:\002\162\000\000\002\130\002f\002\150\004\002\004\014\000\000\002\218\000\000\000\000\004\026\n\213\n\213\000\000\n\213\n\213\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\004\030\000\000\000\000\025\250\000\000\000\000\000\000\000\000\n\213\000\000\003J\000\000\000\000\003V\001\190\000\000\000\000\000\000\000\000\025\230\002\150\000\000\000\000\003\218\000\000\000\000\n\213\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\012Y\000\000\000\000\012Y\000\000\000\000\005f\005j\000\000\005\174\n\213\000\000\n\213\012Y\000\000\000\000\000\000\000\000\000\000\012Y\000\000\001\221\001\221\000\000\n\213\000\000\001\221\n\213\n\213\001\221\005n\012Y\n\213\000\000\n\213\000\000\004V\012Y\n\213\001\221\001\221\001\221\000\000\001\221\001\221\001\221\012Y\000\000\000\000\012Y\000\000\000\000\000\000\000\000\012Y\000\000\000\000\001\221\000\000\000\000\000\000\000\000\000\000\001\221\001\221\000\000\000\000\001\221\000\000\000\000\012Y\000\000\001\221\000\000\012Y\001\221\000\000\000\000\000\000\000\000\001\221\001\221\001\221\000\000\012Y\012Y\000\000\000\000\012Y\001\221\001\221\000\000\000\000\000\000\027\214\000\000\001\221\001\r\000\000\000\000\001\221\000\000\001\r\001\221\000\000\012Y\000\000\000\000\000\000\000\000\001\221\001\221\001\221\000\000\001\221\001\221\000\000\000\000\000\000\000\000\000\000\001\r\000\000\000\000\001\221\000\000\001\221\001\221\003:\002\162\000\000\001\221\002f\000\000\006\138\000\000\001\221\002\218\000\000\000\000\004\226\000\000\001\221\001\r\000\000\0036\000\000\001\210\000\000\006\170\000\000\001\r\000\000\000\000\003>\000\000\001\r\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\r\001\r\003J\000\000\000\000\n\146\001\190\000\000\000\000\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\n\177\003\222\000\000\003\230\000\000\n\162\005Z\000\000\001\r\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\001\r\005^\002\218\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\001\210\n\170\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\000\000\000\000\n\177\n\178\000\000\n\177\011\030\003J\005n\000\000\n\146\001\190\n\177\000\000\004V\000\000\n\177\002\150\000\000\000\000\003\218\000\000\000\000\n\177\003\222\000\000\003\230\000\000\n\162\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\000\000\n\170\005}\005}\000\000\000\000\000\000\005}\000\000\000\000\005}\000\000\000\000\000\000\000\000\n\177\000\000\000\000\n\177\n\177\005}\005n\005}\000\000\005}\n\177\005}\004V\000\000\n\177\000\000\000\000\000\000\000\000\000\000\000\000\000\246\000\000\005}\002\166\000\000\000\000\000\000\000\000\005}\005}\000\000\000\000\000\000\028.\005}\000\000\000\000\005}\000\000\003\154\005}\000\000\000\000\000\000\000\000\005}\005}\005}\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\000\000\016\146\000\000\000\000\000\000\005}\005}\000\000\000\000\005}\024>\000\000\001\006\016\246\000\000\000\000\000\000\000\000\017\014\005}\005}\005}\000\000\005}\005}\000\000\000\000\000\000\001\n\007R\000\000\000\000\002r\000\000\017\022\000\000\005}\000\000\027\222\005}\005}\001\014\001\018\001\022\001\026\001\030\001\"\000\000\017*\017V\000\000\005}\004\149\000\000\001&\000\000\001.\0012\000\000\000\000\000\000\000\000\0016\004a\000\000\001:\000\000\000\000\000\246\021~\000\000\002\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\150\001>\001B\001F\001J\001N\003\154\005q\005q\001R\000\000\000\000\005q\001V\000\000\005q\000\000\000\000\017\154\000\000\000\000\000\000\001Z\000\000\017\194\005q\000\000\005q\001^\005q\000\000\005q\000\000\000\000\000\000\000\000\016\246\000\000\001\154\027\018\000\000\017\014\000\000\005q\000\000\001\158\000\000\001\162\000\000\005q\005q\001\166\000\000\001\170\001\174\007\194\000\000\018>\005q\000\000\000\000\005q\000\000\000\000\000\000\000\000\005q\005q\000\238\000\000\000\000\017*\018R\000\000\000\000\004a\004a\000\000\000\000\000\000\000\000\000\000\005q\005q\000\000\000\000\005q\000\000\b\245\000\000\000\000\000\000\018b\000\000\000\000\000\000\005q\005q\005q\000\000\005q\005q\000\000\000\000\t\174\000\000\000\000\012\030\b\245\000\000\b\245\b\245\000\000\005q\000\000\000\000\005q\005q\t\230\t\254\n\006\t\238\n\014\000\000\000\000\001\202\002b\000\000\005q\002f\000\000\000\000\n\022\n\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n&\000\000\000\000\001\210\001\214\001\230\002j\000\000\000\238\000\000\000\000\000\000\000\000\001\242\001\006\000\000\000\000\t\182\t\246\n.\n6\nF\000\000\000\000\000\000\000\000\002n\002v\000\000\nN\001\n\002\130\000\000\002\150\004\002\004\014\000\000\000\000\nV\000\000\020\214\000\000\020\218\001\014\001\018\001\022\001\026\001\030\001\"\000\000\000\000\000\000\nv\000\000\n~\n>\001&\004\030\001.\0012\b\245\n^\000\000\000\000\0016\000\000\005j\001:\000\000\nf\nn\000\000\000\000\000\000\000\000\000\000\020\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001>\001B\001F\001J\001N\000\000\003]\003]\001R\020\234\000\000\003]\001V\000\000\003]\000\000\000\000\000\000\000\000\000\000\000\000\001Z\000\000\000\000\003]\000\000\003]\001^\003]\000\000\003]\000\000\000\000\000\000\000\000\000\000\000\000\001\154\027.\000\000\000\000\000\000\003]\000\000\001\158\000\000\001\162\000\000\003]\003]\001\166\000\000\001\170\001\174\005\005\000\000\000\000\003]\000\000\000\000\003]\000\000\000\000\000\000\000\000\003]\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\000\003]\000\000\001\202\001\206\003]\bq\bq\000\000\000\000\000\000\bq\000\000\000\000\bq\003]\003]\003]\000\000\003]\003]\000\000\001\210\001\214\bq\005\005\bq\000\000\bq\000\000\bq\000\000\003]\000\000\000\000\000\000\003]\000\000\000\000\000\000\000\000\000\000\bq\000\000\000\000\001\246\002~\003]\bq\bq\002\130\000\000\002\150\004\002\004\014\000\000\000\000\bq\000\000\004\026\bq\015\130\000\000\000\000\000\000\bq\bq\bq\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\030\000\000\000\000\000\000\000\000\bq\000\000\000\000\000\000\bq\r%\r%\000\000\000\000\000\000\r%\000\000\000\000\r%\bq\bq\bq\000\000\bq\bq\000\000\000\000\000\000\r%\000\000\r%\000\000\r%\bq\r%\000\000\bq\000\000\000\000\000\000\bq\000\000\000\000\000\000\000\000\000\000\r%\000\000\000\000\004\226\000\000\bq\r%\r%\r)\r)\000\000\000\000\004&\r)\000\000\r%\r)\000\000\r%\000\000\000\000\000\000\000\000\r%\r%\r%\r)\000\000\r)\000\000\r)\000\000\r)\000\000\000\000\000\000\000\000\000\000\000\000\r%\000\000\000\000\000\000\r%\r)\000\000\000\000\000\000\000\000\000\000\r)\r)\000\000\r%\r%\r%\004&\r%\r%\r)\000\000\000\000\r)\0046\000\000\000\000\000\000\r)\r)\r)\r%\000\000\000\000\000\000\r%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r)\000\000\r%\000\000\r)\003]\003]\000\000\000\000\000\000\003]\000\000\000\000\003]\r)\r)\r)\000\000\r)\r)\000\000\000\000\000\000\003]\0046\003]\000\000\003]\000\000\003]\000\000\r)\001\202\001\206\000\000\r)\000\000\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\000\000\r)\003]\003]\000\000\000\000\001\210\001\214\005\t\000\000\000\000\003]\000\000\000\000\003]\000\000\000\000\000\000\000\000\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\246\002\134\000\000\000\000\000\000\002\130\003]\002\150\004\002\004\014\003]\001\205\000\000\000\000\004\026\000\000\001\205\000\000\001\206\001\205\003]\003]\003]\000\000\003]\003]\000\000\b\209\000\000\001\205\005\t\004\030\000\000\001\205\004\205\001\205\000\000\003]\000\000\000\000\000\000\003]\000\000\004Y\000\000\000\000\000\000\001\205\004Y\000\000\025\230\000\000\003]\001\205\001\205\000\000\000\000\000\000\000\000\000\000\002~\000\000\001\205\000\000\000\000\001\205\000\000\004Y\000\000\000\000\001\205\001\205\001\205\000\000\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\205\001\205\000\000\004Y\004~\003A\000\000\000\000\000\000\000\000\003A\004Y\001\206\003A\001\205\001\205\004Y\002\198\001\205\001\205\000\000\b\205\000\000\003A\000\000\004Y\004Y\003A\001\205\003A\000\000\000\000\000\000\000\000\000\000\001\205\000\000\000\000\000\000\000\000\001\205\003A\000\000\000\000\000\000\000\000\001\205\003A\001\201\000\000\000\181\004Y\000\000\000\000\002~\000\181\003A\000\000\000\181\003A\004Y\000\000\000\000\000\000\003A\003A\003A\000\000\000\181\000\000\000\181\000\000\000\181\000\000\000\181\000\000\000\000\000\000\000\000\000\000\003A\003A\000\000\000\000\004~\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\181\000\000\003A\003A\000\181\000\000\003A\003A\000\000\000\181\000\000\000\000\000\181\000\000\000\000\000\000\003A\000\181\000\181\000\238\000\000\000\000\000\000\003A\000\000\000\000\000\181\000\181\003A\000\000\000\000\000\000\000\000\000\181\003A\000\000\000\249\000\181\000\000\000\000\000\000\000\249\000\000\000\000\000\249\000\000\000\000\000\181\000\181\000\000\000\000\000\181\000\181\000\000\000\249\000\000\000\249\000\000\000\249\000\000\000\249\000\181\000\000\000\000\000\000\000\000\000\000\000\181\000\181\000\000\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\181\000\249\000\181\000\000\000\000\000\249\000\000\000\000\000\000\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\000\000\000\000\000\000\249\000\249\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\189\000\249\000\000\000\000\000\000\000\189\000\000\000\000\000\189\000\000\000\000\000\249\000\249\000\000\000\000\000\249\000\249\000\000\000\189\000\000\000\189\000\000\000\189\000\000\000\189\000\249\000\000\000\000\000\000\000\000\000\000\000\249\000\249\000\000\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\249\000\189\000\249\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\189\000\189\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\185\000\189\000\000\000\000\006\221\000\185\000\000\000\000\000\185\006\221\000\000\000\189\000\189\000\000\000\000\000\189\000\189\000\000\000\185\000\000\000\185\000\000\000\185\000\000\000\185\000\189\000\000\000\000\006\221\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\189\000\185\000\189\000\000\000\000\000\185\000\000\000\000\000\000\006\221\000\185\000\000\000\000\000\185\000\000\000\000\000\000\006\221\000\185\000\185\000\238\000\000\006\221\006\221\000\238\000\000\000\000\000\185\000\185\000\000\000\000\006\221\006\221\000\000\000\185\000\000\000\000\001\169\000\185\000\000\000\000\000\000\001\169\000\000\000\000\001\169\000\000\000\000\000\185\000\185\000\000\000\000\000\185\000\185\000\000\001\169\000\000\006\221\000\000\001\169\012\229\001\169\000\185\000\000\000\000\012\229\006\221\000\000\000\185\000\185\000\000\000\000\000\000\001\169\001\169\000\000\000\000\000\000\000\185\001\169\000\185\000\000\023\158\000\000\012\229\005\005\000\000\000\000\001\169\000\000\000\000\001\169\000\000\000\000\000\000\000\000\001\169\001\169\001\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\229\000\000\000\000\000\000\000\000\000\000\001\169\000\000\012\229\000\000\001\169\r!\r!\012\229\012\229\000\238\r!\000\000\000\000\r!\001\169\001\169\012\229\012\229\001\169\001\169\000\000\000\000\000\000\r!\005\005\r!\000\000\r!\001\169\r!\000\000\000\000\000\000\000\000\001\169\001\169\000\000\000\000\000\000\000\000\001\169\r!\012\229\000\000\000\000\000\000\001\169\r!\r!\000\000\000\000\012\229\000\000\000\000\000\000\000\000\r!\000\000\000\000\r!\000\000\000\000\000\000\000\000\r!\r!\r!\000\000\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!\000\000\000\000\000\000\r!\r\029\r\029\000\000\000\000\000\000\r\029\000\000\000\000\r\029\r!\r!\r!\000\000\r!\r!\000\000\000\000\000\000\r\029\000\000\r\029\000\000\r\029\000\000\r\029\000\000\r!\000\000\000\000\000\000\r!\000\000\000\000\000\000\000\000\000\000\r\029\000\000\000\000\004\226\000\000\r!\r\029\r\029\000\000\000\000\000\000\000\000\000\000\000\000\004a\r\029\000\000\000\000\r\029\000\246\000\000\000\000\002\018\r\029\r\029\r\029\000\000\000\000\000\000\000\000\000\000\000\000\017\150\000\000\000\000\000\000\004a\000\000\003\154\r\029\000\000\bu\bu\r\029\000\000\000\000\bu\000\000\000\000\bu\017\154\000\000\000\000\r\029\r\029\r\029\017\194\r\029\r\029\bu\000\000\bu\000\000\bu\000\000\bu\000\000\007.\016\246\000\000\r\029\000\000\000\000\017\014\r\029\000\000\000\000\bu\000\000\000\000\000\000\000\000\000\000\bu\bu\r\029\000\000\000\000\000\000\018>\000\000\000\000\bu\000\000\000\000\bu\000\000\000\000\000\000\000\000\bu\bu\000\238\017*\018R\000\000\000\000\004a\004a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bu\000\000\000\000\000\000\bu\000\000\006\241\000\000\018b\000\000\000\000\000\000\000\000\000\000\bu\bu\bu\000\000\bu\bu\000\000\000\000\t\174\000\000\000\000\006\241\000\000\000\000\bu\006\241\000\000\bu\000\000\000\000\000\000\bu\t\230\t\254\n\006\t\238\n\014\000\000\000\000\000\000\000\000\000\000\bu\001\201\000\000\000\000\n\022\n\030\001\201\000\000\001\206\001\201\000\000\000\000\000\000\n&\000\000\000\000\000\000\b\205\000\000\001\201\000\000\000\238\000\000\001\201\000\000\001\201\000\000\000\000\000\000\000\000\t\182\t\246\n.\n6\nF\000\000\000\000\001\201\000\000\000\000\000\000\006\241\nN\001\201\000\000\000\000\000\000\000\000\000\000\000\000\002~\nV\001\201\000\000\000\000\001\201\000\000\000\000\000\000\000\000\001\201\001\201\001\201\000\000\000\000\nv\000\000\n~\n>\000\000\000\000\000\000\000\000\000\000\n^\000\000\001\201\001\201\000\000\000\000\004~\000\000\nf\nn\000\000\000\000\000\000\016F\000\000\000\000\001\201\001\201\000\000\000\000\001\201\001\201\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\174\001\201\000\000\000\000\016J\000\000\000\000\000\000\001\201\000\000\000\000\000\000\000\000\001\201\t\230\t\254\n\006\t\238\n\014\001\201\000\000\000\000\000\000\000\000\000\000\n\182\000\000\000\000\n\022\n\030\000\246\001\202\001\206\002\018\000\000\000\000\000\000\n&\000\000\000\000\000\000\000\000\000\000\017\150\000\000\000\238\000\000\004a\000\000\003\154\001\210\001\214\001\230\000\000\t\182\t\246\n.\n6\nF\000\000\001\242\017\154\000\000\000\000\000\000\000\000\nN\017\194\000\000\000\000\000\000\000\000\000\000\001\246\002v\nV\000\000\000\000\002\130\016\246\002\150\004\002\004\014\000\000\017\014\000\000\000\000\004\026\000\000\nv\016N\n~\n>\016^\000\000\000\000\000\000\000\000\n^\000\000\018>\000\000\000\000\000\000\004\030\000\000\nf\nn\005\169\005\169\000\000\000\000\000\000\005\169\017*\018R\005\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\169\000\000\005\169\000\000\005\169\000\000\005\169\000\000\000\000\018b\000\000\000\000\000\000\000\000\004R\000\000\004V\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\007\194\000\000\000\000\005\169\000\000\000\000\005\169\000\000\006I\000\000\000\000\005\169\005\169\000\238\000\000\002\162\000\000\000\000\002f\000\000\000\000\000\000\000\000\002\218\000\000\002\225\002\225\005\169\006I\002\225\000\000\005\169\000\000\001\210\002\225\000\000\000\000\002\222\000\000\000\000\002\225\005\169\005\169\005\169\002\225\005\169\005\169\000\000\002\226\000\000\000\000\002\225\000\n\000\000\000\000\006\190\003\022\001\190\005\169\000\000\000\000\015\030\005\169\002\150\002\225\000\000\003\030\002\225\002\225\000\000\007\254\b\002\b\014\005\169\002\225\005Z\000\000\002\225\000\000\000\000\002\225\002\225\000\000\002\225\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\005\165\007\002\000\000\005f\005j\005\165\002\225\000\000\005\165\000\000\000\000\000\000\000\000\000\000\002\225\002\225\000\000\015Z\005\165\000\000\005\165\000\000\005\165\000\000\005\165\000\000\000\000\005n\b\022\000\000\000\000\000\000\b.\004V\000\000\000\000\005\165\000\000\002\225\000\000\000\000\000\000\005\165\007n\002\225\000\000\000\000\000\000\000\000\000\000\000\000\005\165\000\000\000\000\005\165\000\000\000\000\004\133\000\000\005\165\005\165\000\238\021\166\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\165\000\000\005\193\005\193\005\165\000\000\003\154\005\193\000\000\000\000\005\193\000\000\000\000\000\000\005\165\005\165\005\165\000\000\005\165\005\165\005\193\000\000\005\193\000\000\005\193\000\000\005\193\000\000\022\022\000\000\000\000\005\165\000\000\000\000\000\000\005\165\016\246\000\000\005\193\000\000\000\000\017\014\000\000\000\000\005\193\005\193\005\165\000\000\000\000\000\000\022\186\022\202\000\000\005\193\000\000\000\000\005\193\000\000\000\000\000\000\000\000\005\193\005\193\005\193\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\133\005\193\000\000\005\189\007\002\005\193\000\000\000\000\005\189\023\190\000\000\005\189\000\000\000\000\000\000\005\193\005\193\005\193\000\000\005\193\005\193\005\189\000\000\005\189\000\000\005\189\000\000\005\189\000\000\000\000\000\000\000\000\005\193\000\000\000\000\000\000\005\193\000\000\000\000\005\189\000\000\000\000\000\000\000\000\000\000\005\189\007n\007f\000\000\000\000\000\000\000\000\000\000\000\000\005\189\000\000\000\000\005\189\000\000\000\000\000\000\000\000\005\189\005\189\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\005\189\003:\002\162\000\000\005\189\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\005\189\005\189\005\189\000\000\005\189\005\189\001\210\000\000\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\005\189\000\000\000\000\000\000\005\189\000\000\000\000\000\000\000\000\003J\000\000\000\000\n\146\001\190\000\000\005\189\012\158\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\000\000\n\162\005Z\t\174\000\000\000\000\012\030\000\000\000\000\000\000\b\245\000\000\000\000\000\000\005^\000\000\000\000\t\230\t\254\n\006\t\238\n\014\005f\005j\000\000\000\000\n\170\000\000\000\000\000\000\000\000\n\022\n\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n&\n\178\000\000\000\000\n\190\000\000\005n\000\000\000\238\000\000\000\000\000\000\004V\000\000\000\000\000\000\000\000\t\182\t\246\n.\n6\nF\000\000\003=\000\000\000\000\000\000\000\000\003=\nN\001\206\003=\000\000\000\000\000\000\000\000\000\000\000\000\nV\000\000\000\000\003=\000\000\000\000\000\000\003=\000\000\003=\000\000\000\000\000\000\000\000\nv\000\000\n~\n>\000\000\000\000\000\000\003=\000\000\n^\000\000\000\000\000\000\003=\000\000\000\000\001M\nf\nn\000\000\002~\001M\003=\000\000\001M\003=\000\000\000\000\000\000\000\000\003=\003=\003=\000\000\001M\000\000\001M\000\000\001M\000\000\001M\000\000\000\000\000\000\000\000\000\000\003=\003=\000\000\000\000\004~\000\000\001M\000\000\000\000\000\000\000\000\000\000\001M\000\000\003=\003=\001M\000\000\003=\003=\000\000\001M\000\000\000\000\001M\000\000\000\000\000\000\003=\001M\001M\000\238\000\000\001I\000\000\003=\000\000\000\000\001I\001M\003=\001I\000\000\000\000\000\000\001M\003=\000\000\000\000\001M\000\000\001I\000\000\001I\000\000\001I\000\000\001I\000\000\001M\001M\001M\000\000\001M\001M\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\001M\000\000\001I\000\000\000\000\000\000\001I\001M\000\000\000\000\000\000\001I\000\000\000\000\001I\000\000\000\000\000\000\001M\001I\001I\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\001I\001\133\000\000\000\000\000\000\000\000\001\133\000\000\012\153\001\133\001I\001I\001I\000\000\001I\001I\000\000\012\153\000\000\001\133\000\000\001\133\000\000\001\133\001I\001\133\000\000\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\000\001I\001\133\012\153\000\000\000\000\000\000\000\000\000\000\012\153\000\000\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\000\001\133\001\133\001\133\000\000\000\000\0019\000\000\000\000\000\000\000\000\0019\000\000\000\157\0019\000\000\000\000\001\133\000\000\000\000\000\000\012\153\000\157\000\000\0019\000\000\0019\000\000\0019\000\000\0019\001\133\001\133\001\133\000\000\001\133\001\133\000\000\000\000\000\000\000\000\000\000\0019\000\000\000\000\000\000\000\000\000\000\0019\000\157\000\000\000\000\001\133\000\000\000\000\000\157\000\000\000\000\000\000\000\000\0019\000\000\000\000\001\133\000\000\0019\0019\0019\000\000\001\213\000\000\000\000\000\000\000\000\001\213\000\000\015f\001\213\000\000\002f\000\000\0019\000\000\000\000\000\000\000\157\000\000\001\213\000\000\000\000\000\000\001\213\000\000\001\213\000\000\0019\0019\0019\000\000\0019\0019\000\000\000\000\000\000\000\000\001\213\000\000\000\000\000\000\000\000\000\000\001\213\000\000\000\000\000\000\000\000\0019\015j\000\000\000\000\001\213\000\000\000\000\001\213\000\000\000\000\000\000\0019\001\213\001\213\000\000\015v\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\213\000Y\000\000\000\000\001\213\000\000\000Y\000\000\000Y\000\000\000\000\000\000\000\000\005j\001\213\001\213\000\000\000Y\001\213\001\213\000Y\000\000\000\000\000\000\000Y\000Y\000\000\b\145\001\213\000\000\000\000\000\000\000\000\000\000\000\000\001\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000Y\000\000\001\213\000Y\000\000\000\000\000Y\000\000\000\000\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\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\000Y\002\218\000\000\000Y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\210\000Y\006\170\000\000\000Y\000\000\000\000\003>\000\000\b\145\b\198\000\000\000\000\000Y\004Y\007\002\000Y\000\000\t\n\004Y\003J\000\000\004Y\r\138\001\190\000\000\000\000\000\000\000\000\000Y\002\150\000\000\004Y\003\218\000\000\000\000\004Y\003\222\004Y\003\230\000\000\n\162\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004Y\000\000\000\000\000\000\005^\000\000\004Y\007n\000\000\000\000\004Y\000\000\005f\005j\000\000\004Y\000\000\000\000\004Y\000\000\000\000\000\000\000\000\004Y\002\198\000\238\000\000\000\000\000\000\000\000\000\000\000\000\004Y\004Y\r\154\000\000\005n\000\000\000\000\004Y\004Y\000\000\004V\004Y\000\000\011\250\000\000\000\000\000\000\000\000\011\250\000\000\000\000\004Y\004Y\000\000\000\000\004Y\004Y\000\000\000\000\t\174\000\000\000\000\000\000\000\000\t\174\004Y\011\254\000\000\000\000\000\000\000\000\012\214\004Y\t\230\t\254\n\006\t\238\n\014\t\230\t\254\n\006\t\238\n\014\004Y\000\000\000\000\000\000\n\022\n\030\000\000\000\000\000\000\n\022\n\030\000\000\000\000\n&\000\000\000\000\000\000\000\000\n&\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\238\000\000\000\000\000\000\t\182\t\246\n.\n6\nF\t\182\t\246\n.\n6\nF\000\000\000\000\nN\000\000\000\000\000\000\000\000\nN\000\000\000\000\000\000\nV\000\000\0035\000\000\000\000\nV\000\000\0035\000\000\000\000\0035\000\000\000\000\000\000\nv\000\000\n~\n>\000\000\nv\0035\n~\n>\n^\0035\000\000\0035\000\000\n^\000\000\000\000\nf\nn\000\000\000\000\000\000\nf\nn\0035\015~\000\000\000\000\000\000\000\000\0035\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\000\000\000\000\0035\000\000\000\000\000\000\000\000\0035\0035\0035\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\0035\000\000\000\000\000\000\0035\000\000\001\210\000\000\006\170\000\000\000\000\000\000\000\000\003>\0035\0035\b\198\000\000\0035\0035\000\000\000\000\000\000\000\000\023&\000\000\003J\000\000\0035\003V\001\190\000\000\000\000\000\000\015\222\0035\002\150\000\000\000\000\003\218\0035\000\000\000\000\003\222\000\000\003\230\0035\n\162\005Z\000\000\000\000\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\005^\002\218\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\001\210\021\150\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\023\242\003J\005n\000\000\n\146\001\190\000\000\000\000\004V\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\000\000\n\162\005Z\000\000\000\000\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\005^\002\218\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\001\210\n\170\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022.\003J\005n\000\000\n\146\001\190\000\000\000\000\004V\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005\166\n\162\005Z\000\000\000\000\000\000\003:\002\162\000\000\000\000\002f\000\000\000\000\000\000\005^\002\218\000\000\000\000\000\000\000\000\005\170\000\000\005f\005j\000\000\001\210\n\170\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\022\142\003J\005n\000\000\003V\001\190\000\000\000\000\004V\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\t\017\000\000\000\000\000\000\000\000\000\000\003:\002\162\000\000\005^\002f\000\000\000\000\000\000\000\000\002\218\000\000\005f\005j\000\000\005\174\000\000\t\017\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\000\000\000\000\005\250\000\000\000\000\005n\002\225\002\225\000\000\003J\002\225\004V\003V\001\190\000\000\002\225\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\002\225\003\222\000\000\003\230\005N\000\000\005Z\002\225\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\002\225\000\000\000\000\002\225\002\225\000\000\005f\005j\000\000\005\174\002\225\000\000\000\000\002\225\000\000\000\000\002\225\002\225\000\000\002\225\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005n\000\000\t\017\000\000\002\225\000\000\004V\004A\004A\000\000\000\000\004A\002\225\002\225\000\000\002\225\004A\000\000\000\000\000\000\000\000\000\000\004A\000\000\000\000\000\000\004A\000\000\000\000\000\000\000\000\000\000\000\000\004A\022\222\000\000\002\225\022\246\000\000\000\000\002\225\000\000\002\225\000\000\000\000\000\000\004A\000\000\000\000\004A\004A\000\000\000\000\000\000\000\000\000\000\004A\000\000\000\000\004A\000\000\000\000\000\238\004A\000\000\004A\004A\000\000\004A\0035\000\000\000\000\000\000\0035\0035\000\000\000\000\0035\0035\000\000\004A\0035\000\000\000\000\000\000\000\000\000\000\0035\004A\004A\000\000\0035\000\000\0035\000\000\0035\000\000\0035\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\015~\000\000\000\000\0035\015~\0035\004A\000\000\000\000\0035\000\000\000\000\004A\000\000\0035\000\000\000\000\0035\0035\000\000\000\000\0035\0035\0035\0035\000\000\0035\0035\0035\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\000\000\000\000\000\000\0035\000\000\000\000\000\000\0035\000\000\000\000\000\000\000\000\000\000\0035\0035\025j\000\000\0035\0035\025\154\000\000\0035\0035\012\145\000\000\000\000\000\000\000\000\012\145\000\000\000\000\012\145\000\000\015\222\0035\000\000\000\000\015\222\0035\0035\000\000\012\145\000\000\0035\000\000\012\145\000\000\012\145\000\000\000\000\000\000\000\000\000\000\004\253\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\012\145\000\000\000\000\003:\002\162\012\145\012\145\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\001\210\000\000\006\170\012\145\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\012\145\012\145\002^\000\000\012\145\012\145\000\000\003J\000\000\000\000\b\242\001\190\000\000\000\000\012\145\000\000\000\000\002\150\026Z\000\000\003\218\012\145\000\000\000\000\003\222\000\000\003\230\000\000\n\162\005Z\005U\000\000\012\145\000\000\000\000\005U\000\000\000\000\005U\000\000\000\000\005^\000\000\000\000\000\000\000\000\000\000\000\000\005U\005f\005j\000\000\005U\000\000\005U\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005U\000\000\000\000\000\000\000\000\000\000\005U\005n\000\000\000\000\000\000\000\000\007\194\004V\000\000\005U\000\000\000\000\005U\000\000\000\000\000\000\000\000\005U\005U\000\238\000\000\005Y\000\000\000\000\000\000\000\000\005Y\000\000\000\000\005Y\000\000\000\000\000\000\005U\005U\000\000\000\000\005U\000\000\005Y\000\000\000\000\000\000\005Y\000\000\005Y\000\000\005U\005U\000\000\000\000\005U\005U\000\000\000\000\000\000\000\000\005Y\000\000\000\000\000\000\000\000\000\000\005Y\000\000\0035\000\000\000\000\005U\007\194\0035\000\000\005Y\0035\000\000\005Y\000\000\000\000\000\000\005U\005Y\005Y\000\238\0035\000\000\000\000\000\000\0035\000\000\0035\000\000\000\000\000\000\000\000\000\000\000\000\005Y\005Y\000\000\000\000\005Y\0035\015~\000\000\000\000\000\000\000\000\0035\000\000\000\000\005Y\005Y\000\000\000\000\005Y\005Y\0035\000\000\000\000\0035\000\000\000\000\000\000\000\000\0035\0035\0035\006\001\000\000\000\000\000\000\005Y\006\001\000\000\000\000\006\001\000\000\000\000\000\000\000\000\0035\000\000\005Y\000\000\0035\006\001\000\000\000\000\000\000\006\001\000\000\006\001\000\000\000\000\0035\0035\017f\000\000\0035\0035\000\000\000\000\000\000\006\001\000\000\000\000\000\000\000\000\000\000\006\001\000\000\000\000\000\000\000\000\015\222\0035\000\000\000\000\006\001\000\000\000\000\006\001\000\000\000\000\000\000\000\000\006\001\006\001\000\238\000\000\000\000\000\000\000\000\000\000\025B\000\000\000\000\000\000\000\000\000\000\003:\002\162\006\001\000\000\002f\000\000\006\001\000\000\000\000\002\218\000\000\000\000\000\000\000\000\000\000\000\000\006\001\006\001\021\"\001\210\006\001\006\001\000\000\000\000\000\000\000\000\003>\001\202\001\206\000\000\006\001\000\000\000\000\000\000\000\000\000\000\000\000\006\001\000\000\003J\000\000\000\000\003V\001\190\000\000\000\000\001\210\001\214\006\001\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\005\210\000\000\000\000\000\000\001\246\002\134\003:\002\162\005^\002\130\002f\002\150\004\002\004\014\000\000\002\218\005f\005j\004\026\005\174\000\000\000\000\003\226\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\004\030\000\000\000\000\004\209\000\000\005n\000\000\006v\000\000\b\174\003J\004V\000\000\003V\001\190\000\000\000\000\000\000\000\000\025\230\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\006\018\000\000\000\000\000\000\000\000\000\000\003:\002\162\000\000\005^\002f\000\000\000\000\000\000\000\000\002\218\000\000\005f\005j\000\000\005\174\000\000\0066\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\006\030\000\000\000\000\000\000\000\000\005n\003:\002\162\000\000\003J\002f\004V\003V\001\190\000\000\002\218\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\001\210\003\222\000\000\003\230\005N\000\000\005Z\003>\000\000\000\000\000\000\000\000\007\129\000\000\000\000\007\129\000\000\000\000\005^\000\000\003J\000\000\000\000\003V\001\190\000\000\005f\005j\000\000\005\174\002\150\007\129\007\129\003\218\007\129\007\129\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005n\006M\000\000\000\000\005^\007\129\004V\003:\002\162\000\000\000\000\002f\005f\005j\000\000\005\174\002\218\000\000\000\000\000\000\000\000\006M\000\000\007\129\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\005n\011\138\000\000\000\000\000\000\000\000\004V\003:\002\162\000\000\003J\002f\000\000\003V\001\190\000\000\002\218\007\129\000\000\007\129\002\150\000\000\000\000\003\218\000\000\000\000\001\210\003\222\000\000\003\230\005N\005\198\005Z\003>\007\129\007\129\000\000\000\000\000\000\007\129\000\000\007\129\000\000\000\000\005^\007\129\003J\000\000\000\000\003V\001\190\000\000\005f\005j\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\011\150\000\000\000\000\000\000\000\000\005n\003:\002\162\000\000\005^\002f\004V\000\000\000\000\000\000\002\218\000\000\005f\005j\000\000\005\174\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\011\162\000\000\000\000\000\000\000\000\005n\003:\002\162\000\000\003J\002f\004V\003V\001\190\000\000\002\218\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\001\210\003\222\000\000\003\230\005N\000\000\005Z\003>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\003J\000\000\000\000\003V\001\190\000\000\005f\005j\000\000\005\174\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005n\006q\000\000\000\000\005^\000\000\004V\000\000\002\162\000\000\000\000\002f\005f\005j\000\000\005\174\002\218\000\000\000\000\000\000\000\000\006q\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\002\222\000\000\000\000\000\000\000\000\000\000\005n\000\000\000\000\000\000\000\000\002\226\004V\000\000\000\000\000\000\000\000\000\000\000\000\003\022\001\190\000\000\000\000\000\000\000\000\000\000\002\150\000\000\000\000\003\030\000\000\000\000\000\000\007\254\b\002\b\014\000\000\000\000\005Z\000\000\000\000\000\000\006\249\007\002\000\000\000\000\000\000\006\249\000\000\000\000\006\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\006\249\000\000\000\000\000\000\006\249\000\000\006\249\000\000\001\181\000\000\000\000\000\000\000\000\001\181\000\000\000\000\001\181\000\000\006\249\000\000\000\000\000\000\005n\b\022\006\249\007n\001\181\b.\004V\000\000\001\181\000\000\001\181\006\249\000\000\000\000\006\249\000\000\000\000\000\000\000\000\006\249\006\249\000\238\001\181\000\000\000\000\000\000\000\000\000\000\001\181\000\000\000\000\000\000\000\000\000\000\000\000\006\249\000\000\001\181\000\000\006\249\001\181\000\000\000\000\000\000\000\000\001\181\001\181\001\181\000\000\006\249\006\249\000\000\000\000\006\249\006\249\000\000\000\000\000\000\000\000\000\000\000\000\001\181\000\000\000\000\001\217\001\181\000\000\000\000\000\000\001\217\006\249\000\000\001\217\000\000\000\000\001\181\001\181\000\000\000\000\001\181\001\181\000\000\001\217\000\000\000\000\017r\001\217\000\000\001\217\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\181\000\000\000\000\000\000\001\217\001\181\000\000\000\000\000\000\000\000\001\217\000\000\000\000\006\005\000\000\000\000\000\000\000\000\006\005\001\217\000\000\006\005\001\217\000\000\000\000\000\000\000\000\001\217\001\217\000\000\000\000\006\005\000\000\000\000\000\000\006\005\000\000\006\005\000\000\000\000\000\000\000\000\000\000\001\217\000\000\000\000\000\000\001\217\000\000\006\005\000\000\000\000\000\000\000\000\000\000\006\005\000\000\001\217\001\217\000\000\000\000\001\217\001\217\000\000\006\005\000\000\000\000\006\005\000\000\000\000\000\000\001\217\006\005\006\005\000\238\000\000\000\000\000\000\001\217\000\000\000\000\000\000\000\000\020\254\000\000\000\000\000\000\000\000\006\005\001\217\012\145\000\000\006\005\000\000\000\000\012\145\000\000\000\000\012\145\000\000\000\000\000\000\006\005\006\005\000\000\000\000\006\005\006\005\012\145\000\000\000\000\000\000\012\145\000\000\012\145\000\000\006\005\000\000\000\000\000\000\004\253\000\000\000\000\006\005\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\012\145\000\000\006\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\012\145\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012I\000\000\002\162\012I\000\000\027\230\000\000\012\145\000\000\000\000\027\234\000\000\000\000\012I\000\000\000\000\000\000\000\000\000\000\012I\000\000\012\145\012\145\002^\000\000\012\145\012\145\000\000\000\000\000\000\000\000\012I\000\000\000\000\000\000\012\145\000\000\012I\000\000\026\146\000\000\000\000\012\145\001\002\001\190\000\000\012I\000\000\000\000\012I\000\000\000\000\000\000\012\145\012I\004Y\000\000\000\000\000\000\000\000\004Y\000\000\027\238\004Y\000\000\000\000\000\000\000\000\000\000\000\000\012I\000\000\000\000\004Y\012I\000\000\000\000\004Y\000\000\004Y\000\000\000\000\000\000\027\242\012I\012I\000\000\000\000\012I\000\000\000\000\004Y\000\000\000\000\000\000\000\000\000\000\004Y\b1\b1\000\000\000\000\b1\007\194\000\000\012I\004Y\b1\000\000\004Y\000\000\000\000\000\000\016\014\004Y\002\198\000\238\b1\000\000\000\000\000\000\000\000\000\000\000\000\b1\000\000\000\000\000\000\000\000\000\000\004Y\000\000\000\000\000\000\004Y\000\000\000\000\b1\000\000\000\000\b1\b1\000\000\000\000\004Y\004Y\000\000\b1\004Y\004Y\b1\000\000\000\000\000\000\b1\000\000\b1\b1\007.\b1\000\000\000\000\000\000\000\000\001q\004Y\000\000\000\000\000\000\001q\025b\b1\001q\000\000\000\000\000\000\004Y\000\000\000\000\b1\b1\000\000\001q\000\000\001q\000\000\001q\000\000\001q\000\000\000\237\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\237\000\000\001q\000\000\000\000\b1\000\000\000\000\001q\000\000\000\237\b1\000\000\000\000\000\237\000\000\000\237\000\000\000\000\000\000\001q\000\000\000\000\000\000\000\000\001q\001q\000\238\000\237\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\001q\000\000\000\237\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\237\000\237\000\238\000\000\001q\001q\001q\000\000\001q\001q\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\241\000\237\000\000\000\000\000\000\000\241\001q\000\000\000\241\000\000\000\000\000\237\000\237\000\000\000\000\000\237\000\237\001q\000\241\000\000\000\000\000\000\000\241\000\000\000\241\000\000\006\245\000\000\000\000\000\000\000\000\006\245\000\237\000\000\006\245\000\000\000\241\000\000\000\000\000\000\000\000\000\000\000\241\000\237\006\245\000\000\000\000\000\000\006\245\000\000\006\245\000\241\000\000\000\000\000\241\000\000\000\000\000\000\000\000\000\241\000\241\000\238\006\245\000\000\000\000\000\000\000\000\000\000\006\245\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\006\245\000\000\000\241\006\245\000\000\000\000\000\000\000\000\006\245\006\245\000\000\000\000\000\241\000\241\000\000\000\000\000\241\000\241\000\000\000\000\000\000\000\000\000\000\000\000\006\245\000\000\000\000\000\000\006\245\000\000\000\000\000\000\000\000\000\241\000\000\006\201\006\201\000\000\006\245\006\245\016\166\000\000\006\245\006\245\000\241\005\249\000\000\000\000\000\000\000\000\005\249\000\000\000\000\005\249\006\201\006\201\006\201\000\000\000\000\006\245\017F\000\000\000\000\005\249\006\201\000\000\000\000\005\249\000\000\005\249\000\000\005a\007\002\000\000\000\000\000\000\005a\006\201\006\201\005a\000\000\005\249\006\201\000\000\006\201\006\201\006\201\005\249\000\000\005a\000\000\006\201\000\000\005a\000\000\005a\005\249\000\000\000\000\005\249\000\000\000\000\000\000\000\000\005\249\005\249\000\000\005a\006\201\000\000\000\000\000\000\000\000\005a\007n\000\000\000\000\000\000\000\000\000\000\005\249\000\000\000\000\000\000\005\249\005a\000\000\000\000\000\000\000\000\005a\005a\000\238\000\000\005\249\005\249\000\000\000\000\005\249\005\249\000\000\000\000\000\000\000\000\011\249\000\000\005a\000\000\000\000\011\249\000\000\004\202\011\249\000\000\000\000\005\249\000\000\000\000\000\000\000\000\005a\005a\011\249\000\000\005a\005a\011\249\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\005a\000\000\000\000\000\000\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\001\202\002b\011\249\000\000\002f\011\249\000\000\000\000\000\000\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\210\001\214\001\230\000\000\000\000\000\000\000\000\011\249\t\162\000\000\001\242\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\011\249\002n\002v\011\249\011\249\000\000\002\130\000\000\002\150\004\002\004\014\0041\000\000\000\000\000\000\020\214\0041\026>\004)\0041\011\249\000\000\000\000\004)\000\000\000\000\004)\000\000\000\000\0041\000\000\n\134\004\030\0041\000\000\0041\004)\000\000\000\000\000\000\004)\005j\004)\000\000\000\000\000\000\000\000\0041\000\000\000\000\000\000\026J\000\000\0041\004)\000\000\000\000\000\000\000\000\000\000\004)\000\000\0041\000\000\000\000\0041\000\000\000\000\020\234\004)\0041\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\0041\000\000\000\000\000\000\0041\004I\000\000\004)\000\000\000\000\004I\004)\004\025\004I\0041\0041\000\000\004\025\0041\0041\004\025\004)\004)\004I\000\000\004)\004)\004I\000\000\004I\004\025\000\000\000\000\000\000\004\025\0041\004\025\000\000\000\000\000\000\000\000\004I\004)\000\000\000\000\000\000\016\206\004I\004\025\000\000\000\000\000\000\000\000\019\186\004\025\000\000\004I\000\000\000\000\004I\000\000\000\000\000\000\004\025\004I\000\000\004\025\000\000\000\000\000\000\000\000\004\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004I\000\000\000\000\n\194\004I\000\000\000\000\004\025\000\000\001\202\001\206\004\025\000\000\000\000\004I\004I\000\000\000\000\004I\004I\000\000\004\025\004\025\002r\000\000\004\025\004\025\000\000\001\210\001\214\001\230\000\000\000\000\000\000\000\000\004I\000\000\000\000\001\242\000\000\000\000\000\000\004\025\000\000\000\000\001\250\020\154\006\205\006\205\000\000\000\000\001\246\002v\024\018\000\000\000\000\002\130\000\000\002\150\004\002\004\014\000\000\000\000\004\018\000\000\004\026\006\205\006\205\006\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\205\000\000\000\000\000\000\000\000\000\000\004\030\000\000\000\000\000\000\000\000\000\000\000\000\006\205\006\205\000\000\000\000\000\000\006\205\000\000\006\205\006\205\006\205\000\000\0049\000\000\000\000\006\205\000\000\0049\000\000\004!\0049\000\000\000\000\015n\004!\000\000\000\000\004!\000\000\000\000\0049\000\000\006\205\000\000\0049\000\000\0049\004!\000\000\000\000\000\000\004!\000\000\004!\000\000\000\000\000\000\000\000\0049\000\000\000\000\000\000\000\000\000\000\0049\004!\000\000\004Q\000\000\000\000\000\000\004!\004Q\000\000\000\000\004Q\0049\000\000\004\006\000\000\006\205\0049\000\000\004!\000\000\004Q\000\000\000\000\004!\004Q\000\000\004Q\000\000\000\000\000\000\000\000\000\000\0049\000\000\000\000\000\000\000\000\000\000\004Q\004!\000\000\000\000\000\000\000\000\004Q\000\000\0049\0049\000\000\000\000\0049\0049\000\000\004!\004!\000\000\004Q\004!\004!\000\000\000\000\004Q\011\014\000\000\000\000\000\000\000\000\0049\001\202\001\206\000\000\000\000\000\000\000\000\004!\000\000\000\000\004Q\017\246\000\000\000\000\000\000\000\000\000\000\003\226\020F\000\000\001\210\001\214\001\230\000\000\004Q\004Q\000\000\000\000\004Q\004Q\001\242\004m\000\000\000\000\000\000\000\000\000\246\000\000\000\000\002\166\000\000\000\000\000\000\001\246\002v\004Q\000\000\000\000\002\130\003\150\002\150\004\002\004\014\004m\000\000\003\154\020\194\004\026\007\149\000\000\000\000\007\149\000\000\000\000\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\000\000\016\146\004\030\000\000\000\000\007\149\007\149\000\000\007\149\007\149\024>\000\000\000\000\016\246\000\000\000\000\000\000\000\000\017\014\000\000\000\000\000\000\007m\000\000\000\000\007m\000\000\000\000\000\000\007\149\000\000\000\000\000\000\000\000\017\022\000\000\000\000\000\000\004R\000\000\004V\007m\007m\000\000\007m\007m\000\000\000\238\017*\017V\000\000\000\000\004m\004m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007m\000\000\007\153\000\000\021~\007\153\000\000\000\000\000\000\000\000\000\000\000\000\007\149\000\000\007\149\000\000\000\000\000\000\007m\000\000\000\000\007\153\007\153\000\000\007\153\007\153\007\149\000\000\000\000\005\206\007\149\000\000\000\000\000\000\007\149\007\137\007\149\000\000\007\137\000\000\007\149\000\000\000\000\000\000\000\000\007\153\000\000\000\000\007m\000\000\007m\000\000\000\000\000\000\007\137\007\137\000\000\007\137\007\137\000\000\000\000\000\000\007m\000\238\000\000\005\206\007m\000\000\000\000\000\000\007m\000\000\007m\000\000\000\000\000\000\007m\000\000\007\137\000\000\r-\r-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\153\000\000\007\153\000\238\000\000\000\000\r-\r-\r-\007\022\000\000\000\000\000\000\000\000\007\153\000\000\r-\005\206\007\153\000\000\000\000\000\000\007\153\000\000\007\153\001\202\001\206\0222\007\153\r-\r-\000\000\000\000\007\137\r-\007\137\r-\r-\r-\000\000\000\000\000\000\000\000\r-\001\210\002\142\001\230\006\014\000\000\000\000\005\206\007\137\000\000\000\000\001\242\007\137\000\000\007\137\000\000\000\000\r-\007\137\000\000\001\202\001\206\022\146\000\000\001\246\002v\000\000\000\000\000\000\002\130\000\000\002\150\004\002\004\014\000\000\000\000\000\000\000\000\004\026\001\210\002\142\001\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\000\000\000\000\246\000\000\004\030\002\166\000\000\000\000\000\000\000\000\000\000\001\246\002v\000\000\000\000\004\141\002\130\000\000\002\150\004\002\004\014\003\154\000\000\000\000\000\000\004\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\000\000\016\146\000\000\000\000\004\030\000\000\000\000\000\000\000\000\000\000\024>\000\000\000\000\016\246\000\000\000\000\000\000\000\000\017\014\000\000\000\000\000\000\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\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\017*\017V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021~")) and lhs = - (8, "\006\005\004\003\002\001\000\194\194\193\193\192\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\190\190\189\188\188\188\188\188\188\188\188\187\187\187\187\187\187\187\187\186\186\186\185\185\184\184\183\183\183\182\182\181\181\181\181\181\181\180\180\180\180\180\180\180\180\179\179\179\179\179\179\179\179\178\178\178\178\177\176\176\175\175\175\175\174\174\174\174\174\174\173\173\173\173\173\173\173\172\171\171\171\170\170\169\169\168\168\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\166\166\165\164\163\162\161\161\160\160\159\159\159\159\158\158\158\158\157\157\156\156\156\156\155\154\153\153\152\152\151\151\150\149\149\148\147\146\145\144\144\144\143\143\142\142\141\141\141\141\141\140\140\140\140\140\140\140\140\139\139\139\139\139\139\138\138\137\137\137\136\136\135\135\135\134\134\133\133\132\132\131\131\130\130\129\129\128\128\127\127~~}}|||{{{{zzyyxxwwwwwvvvvuuutttttttsssssssrrrrqqpppoonnnnnnnnnmmllkkkkkkkkkkkjiihhgggggfeeddccccccccccccccbbaa```````````````````````````````__^^]]\\\\[[ZZYYXXWWVVUUTTTTTTTTTTTSRQPPPPPPPPPPOOONNNMMMMLLLLLLLLLKKJJJJJIIHHGFEEDDDDDCCBBAAA@@@@@@???>>==<<;;::999887766554433221100//...---,,,+++****)(''''''''''''''''''&&&&&%%%%%%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$##\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! \031\031\031\030\030\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\028\028\027\027\026\026\026\026\026\026\026\025\025\025\025\024\024\023\023\023\023\023\022\022\021\021\020\019\019\019\018\018\017\017\017\016\016\015\015\015\015\015\014\014\r\r\r\r\r\012\011\011\n\n\n\t\t\t\b\b\b\b\007\007") + (8, "\012\011\n\t\b\007\006\005\004\003\002\001\000\216\216\215\215\214\213\213\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\211\211\210\209\209\209\209\209\209\209\209\208\208\208\208\208\208\208\208\207\207\207\206\206\205\204\204\204\203\203\202\202\202\202\202\202\201\201\201\201\201\201\201\201\200\200\200\200\200\200\200\200\199\199\199\199\198\197\196\196\196\196\195\195\195\195\194\194\194\193\193\193\193\192\191\191\191\190\190\189\189\188\188\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\186\186\185\185\184\183\182\181\181\180\180\179\179\179\179\178\178\178\178\177\177\176\176\176\176\175\174\173\173\172\172\171\171\170\169\169\168\167\167\166\165\164\164\164\163\163\162\161\161\161\161\161\160\160\160\160\160\160\160\160\159\159\159\159\159\159\158\158\157\157\157\156\156\155\155\155\154\154\153\153\152\152\151\151\150\150\149\149\148\148\147\147\146\146\145\145\144\144\144\143\143\143\143\142\142\141\141\140\140\139\139\139\139\139\138\138\138\138\137\137\137\136\136\136\136\136\136\136\135\135\135\135\135\135\135\134\134\133\133\132\132\132\132\132\132\131\131\130\130\129\129\128\128\127\127\127~}}}||{{{{{{{{{zzyyxxxxxxxxxxxwvuutttttsrrqqppppppppppppppoonnmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmllkkjjiihhggffeeddccbbaaaaaaaaaaa`_^]\\[ZYXWWWWWWWWWWVVVUUUTTTTSSSSSSSSSRRQQQQQPPOONMLLKKKKKJJIIHHHGGGGGGFFFEEDDCCBBAA@@@??>>==<<;;::9988776655544433322211110/..................-----,,,,,,,+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++**))))))))))))))))))))))(((((((((((((((((((((((((((((((((((((((((((((((((((''&&&%%$$$$$$$$$$$$$$$$##\"\"!!!!!!! \031\031\030\030\030\030\030\029\029\028\027\026\026\026\025\025\024\024\024\023\023\022\022\022\022\021\021\020\019\019\019\019\019\018\017\017\016\016\016\015\015\015\014\014\014\014\r\r") and goto = - ((16, "\000\025\0017\000\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\001\136\000h\000&\000\243\002\b\000L\000K\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\165\000\000\000\000\000\000\000\000\000\000\000\131\000\000\000\000\000\000\000<\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000,\250\000\000\000\000\001\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\148\001`\002v\000\203\000\000\002\156\t$\001j\002\210\000\025\000\000\000|\000\000\000Z\002\174\000\000\002X\000\000\000\000\000\000\000\000\000\000\000$\000\000\000\r\003\162\0074\000\000\000\000\000\190\003\148\000\000\000\000\000\b\000\000\001\020\000\000+`\002\216\000\000\002\222\001B\000\000\000\000\003*\003f\000\222\003\016\000&\003\162\004&\001\176\003h\001\128\003f\003\138\t\208\000\000\000\000\005F\003n\004\026\000\173\000\000\000\000\000\000\000\000\000\000\000\000\004F\000\000\005\226\000\000\005F\n\016\000\000\000\000\003\130\004L\003\236\028\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\000\004.\004^\004\178\000\000\000\000\000\000\000\000\000\191\000\000\000\000\005B\000%\005l\005h\006\194\004\176\004\228\005t\001~\002\168\006\014\029\020\000\000\000\000\005\006\006\018\nD\000\000\029V\004\168\nd\n\164\000\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\224,\252\005\244\000\000\n\168\006 \000\000\011<\029r\000Q\000\000\011L\005\202\000\000\000\000\000\000\006T\000\000\004\228\000\000\006J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\018\002\030\000\000\000\000\001\160\000\000\r\230\000\000\001\018\005@\001\018\000\000\000\000\000\000\000\000\000\000\029\174\000\000\006\030\006\176\000\000\021\170\006D\006\246\000\000\000\000\000\000\006J\000\000\000\000\000\000\000\000\003\130\000\000\000\000\000\000\000\000\000\000\011\166\000\000\000\000\000\000\000\000\000\000\000\000\004f\006\228\000\000\000\000\000\000\003\130\007<\029\234\006\178\006T-(\000\000\001\190\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\007\208\029\252\000\000\000\000\006\214\006h\030\156\000\000\000\000\000\000\030\190\006\212\030\208\000\000\006\212\000\000\030\220\006\212\000\000\031B\006\212\006\212\000\000\000\000\006\212\000\000\000\000\031v\000\000\006\212\031\166\000\000\006\212\bz\000\000\000\000\n\164\000\000\000\000\000\000\000\000\006\212\011\148\000\000\000\000\000\000\006\212\000\000\001z\007\234\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\n\000\000\007\178\000\000-X\003\130\000\000\000\000\000\000\000\000\007\208\bJ\011\240\007\200\b.\b6\006z\004\240\006\188\000G\b\172\000\000\000\000\000I\000?\006\196\000f\b\162\001\158\000\000\000e\000\230\003R\002\230\t\254\000\000\000\000\019\"\000\0001\234\t\164\000\000-d\003\130-\160\003\130\000\000\tV\000\000\tx\000\000\000\000\t\140\000\000\000\000\000\000\nf\000\000\001\220\000e\000\000\000\000\tL\000\000\000\000\000\000\000\000\000\000\000\000\000e\000\000\000\000\000e\000\000\b\162\005\\\000\000\000}\002\168\000\000\000}\000\000\000\000\002v\000e\000\000\000\000\000\000\000\000\000\000\000\000\000}\012 \012H\nf\n8\031\176\015\144\000\000\t\232\007\020\012\148\n\004\0070\nl\027\002\000\000\000\000\000\000\000\000\000\000\0118\b\128\000\000\000\000\000\000\n\016\007b\006*\000}\003\210\000\000\000e\000\000\000\000\000\000\004\168\000\000-\194\003\130\012\238\n\024\007n\012\244\n4\007\196\002\250\r\186\006\212\rH\n<\007\216,<\n\244\000\000\003n\006\212.D\003\130\n\248\000\000\000\000\000\000\000\000\000\144\n\234\n\250\000\000\000\000\007|\rh\n\130\b& \n\006\212\r\168\n\134\bH\027<\000\000&B\000\000\000\000\014\b\031\232\0246\000\000\000\000\000\000\000\000)\004\000\000\000\000\000\000\004\150\014f\000\000\000\000\000\000\000\000 L,\208\000\000\000\000\000\000\000\000\n|\014\194\000\000\n\154 \170\n\154 \176\n\154\000\0000\232\000\000 \216\n\154\014\242\003\152\015 \000\000\000\000!\000\n\154!\b\n\154!d\n\154!\190\n\154!\200\n\154\" \n\154\"N\n\154\"|\n\154\"\172\n\154#\002\n\154# \n\154#v\n\154#\166\n\154#\196\n\154#\214\n\154$\006\n\154$z\n\154$\170\n\154%\n\n\154%:\n\154\bn\006\002\002\004\000\144\011L\000\000\000\130.n\000\000\015~\000\000.^\000\000\003\130\003x\000\000\003\130.h\003\130\000\000\015\172\000\000\000\000\000\000\015\236\000\000\000\000\000\000\000\000\000\000\006\212\000\000\000\000.\198\000\000\003\130\000\000\000\000\003x\011R\000\000.\208\003\130\016\006\000\000\000\000\n\246\000\000.\210\003\130\016H\000\000\000\000\016|\000\000\000\000\000\000/$\003\130\016\158\000\000\n\218\016\224\000\000%\\\000\000\006\212%\150\000\000\006\212%\252\000\000\006\212\012@\000\000\000\000\000\000\000\000\000\000&&\006\212\005V\006\176\000\000\000\000\000\000\n\154\017\004\000\000\000\000\000\000&\004\n\154\000\000\000\000\000\000\000\000\017T\000\000\000\000\000\000\n\154\017\194\000\000\018\020\000\000\000\000\000\000\018`\000\000\000\000\000\000\000\0001\136\000\000\000\000\018h\000\000\000\000\000\000&\148\n\154\018\156\000\000\000\000\000\000&\204\n\154\018\248\000\000\000\000&\238\n\154\n\154\000\000\006n\019l\000\000\000\000'\028\n\154\019\186\000\000\000\000'\\\n\154't\n\154\000\000'\172\n\154\000\000\000\000\019\210\000\000\000\000(6\n\154\020\020\000\000\000\000(<\n\154\020,\000\000\000\000(t\n\154\000\000(\146\n\154\000\000\0038\000\000\000\000\n\154\000\000\000\000\020x\000\000\000\000\020\160\000\000\000\000\011,\000\000\000\000\020\238\000\000\021,\000\000\000\000\000\000\000\144\011\194\000\000)&\006\174\001\018\021L\000\000*(\000\000\000\000\000\000*p\000\000\000\000\021\212\000\000\022\002\000\000\000\000\000\000\000\000\022$\000\000\000\000\000\000(\198\n\154(\212\n\154\000\000\n\218\022d\000\000\000\000\022\196\000\000\023\030\000\000\000\000\027\002\000\000\000\000\000\000\0238\000\000\000\000\000\000\000\000\023l\000\000\000\000\000\000\000\000\0128\000\000\000\000\000\000,N\000\000\002\024\000\000\002\190\000\000\011\228\000\000\002H\000\000\000\000\000\000\000\000\000\000\000\000\0118\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\154\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bx\006\142\000}\023\140\000\000\011v\b\164\011\234\001\186\006\154\000}\003\218\000e\b\130\000}\000\000\023\174\000\000\003\174\000\000\011|\b\200\011z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\194\002V\000\207\000\000\000\000\000\000,T\000\0001\242\000\000\tZ\000\000\tf\000\000\000\000\000\000\000\000\001Z\000\000\000\000\000\000\b\198\001\018\000\000\001\018\004\146\000\000\nN\001\018\001\018\t\162\000\000\023\222\000\000\t\230\012\144\000\000\024\136\006\240\000\000\000\000\000\000\000\000\000\000\000\000\n\154\000\000\007b\000\000\n\154\000\000\000\000\004T\000\000\000e\000\000\0058\000\000\000e\000\000\005B\000e\000\000\000}\000\000\n\022\b\138\000a\000\000\011\204\011\248\n6\012\024\012\176\005\138\000e\006\244\000\000\n@\012\196\012\210\006\188\007\228\012\190\nz\012\238\006\212\b\180\012\214\000\000\000\000\0072\tt\000\000\0066\002\156)\182\006\212\024\018\000\000\b\014\002\218\012\154\n\150\b\244\000\186\000\000\012\192\n\164\014\000\000\000/0\003\130\rn\r\168\000\000\t\148\000\000\r*\n\188\r\"\rH\002p\000\000\000\000\000\000\000\000\000\000\n\192\t\166\000\000\n\212\t\190\000\000\006\248\017\244\rN\rT\n\226\r\196\t\214\000\000\n\232\r\198\n(\000\000\r`\n\240\r\222\000\000\r\218\000\000\nh\000\000\r\230\000\000\007\128\000e\r\194\011\000\r\244\000\000\007\130\002\130\r\206\000\000\000\000\003l\014\006\n~\000\000\007\208\000e\n\240\000\000\003\246\000\000\r\162\011\n\t\242\002\188\000\000\r\168\011\026\r\156\rH\r\176\r\178\011\"\014\242\000\000\r\216\001\182\000\000\000\000\000\000\000\000\000\206\011,\r\178/B\003\130\000\000\000\181\011F\014R\000\000\000\000\000\000\000\000\000\000\000\000/N\003\130\000\000\011V\014\158\000\000\000\000\000\000\000\000\000\000\000\000\017\014\000\000/\160\003\130\011\178\000\000\003\130\011Z\002(\000\000\000\000\011l\011\162\014R\000\000\0030,\146\000\000\002\178\000\000\000\000\000\000\000\000/\254\003\130\003\130\000\000\000\000\0042\000\000\014T\000\000\b \0042\0042\000\000\011\168,d\003\1300\n\003\130\011\180\000\000\000\000\000\000\000\000\011\224\000\000\000\000\000\130\000\000\005F\0142\011\180\015*\014\b\000\000\000\000\t6\005\232\014F\000\000\000\000\011\182\0158\014,\000\000\000\000%n\000\000\001\218\000\000'\156\024:\003\130\000\000/\148\003\184\000\0000^\000\000\000\000\000\000\000\000\000\000\0042\000\000\000\000\011\240\014h\011\184\015`\0146\000\000\000\0000z\012R\014t\000\000\000\000\000\000 T\000\000\000\000\000\000\000\000\000\000\000\000\012n\000\000\014\130\011\198\004L\000\000\015X\015\n\012r\014\138\000\000\000\000\014\148\011\228\004\228\000\000\000\000\007\182\029r\003\014\000\000\000\000\000\000\0146\014\\\012\b\000\000\014`\0146\000\000\015\028\012\144\014\162\000\000\000\000\000\000\003\130\005t\005\254\tp\000\000\000\000\000\000\000\000\014h\012\014\000\000\n(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\130\014V\012\026\015\144\014h\000\000*\140\000F\012 \014D\003\248\0004\0128\014\232\000\000\015\140\024\226\000\000\000\000\025\018\000\000\012\196\000\000\004\150\000\000\000\000\000\000\000\000\000\000\000\0000\028\003\130\000\000\015\142\025:\000\000\000\000\025j\000\000\002\\\012T\015B\000\000\000\000\019H%V\015\004\000\0000\198\003\130\025\136\000\000\000\000\025\224\000\000\000\000\012\226\000\000\005\208\000\000\000\000\000\000\000\000\000\000\000\000*\186\000\000\000\000+2*\226\015\006\000\0000\228\003\130\026\002\000\000\000\000\026Z\000\000\000\000\012X\026\136\012\234\000\000\012Z\012r\001\150\004\166\012|\b\238\012\152\015T\026\172\012\254\000\000\012\174\012\180\014\250\000\000\007\240,\214\000\000\007&\000\000\012\182+N+\\\br\014n\t4\000\0001\026\0038\000\000\005\160\000\000\000\000\005\160\000\000\000\000\005\160\015\016\000\000\011\142\005\160\015p\0270\r\000\000\000\005\160\000\000\000\0001\"\000\000\000\000\000\000\005\160\000\000\000\000\r\\\000\000\r\250\b\140\rf\000\000\012\184,\226\r\128\000\000\000\000\000\000\000\000\r\142\000\000\000\000\004X\000\000\005\1601B\000\000\014x\005\160+\150\000\000\r\146\014\238\012\232\015\228\014\186\000\000,\b\r\148\014\244\000\000\000\000\000\000#\216\007\200\000\000\000\000\000\000\000\000\000\000\000\000\n|\r\158\000\000\015\006\000\000\000\000\000\000\000\000\r\182)\164\000\000\000\000\000\000\000\000\n|\000\000\000\000\r\216)\250\000\000\000\000\000\000\000\000\000\000\000}\000e\000\000\000\000\006\212\000\0001Z\003\130\000\000\005\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\188\r\026\n\030\000}\000\000\nV\000\000\000e\000\000\015\228\000\000\000\000\000\000\000\000\000\000\b\176\000\000\000\000\000\000\000\000\000\000\000\000\015\140\000e\014\188\014\\\b$\r:\000\000\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014h\b\208\r^\000\000\007\252\015\242\015\170\r\224\000\000\000\000\015\158\000%\003\142\000\000\000\000\000\000\rh\000\000\rl\001\026\000\000\000\000\001\018\001D\000\000\000\000\000\000\000\000\000\000\014\254\000\000\000\000\n&\007\168\000\000\000\0001\196\003\130\003\130\000\0001\208\003\130\011(\000\000\000\000\000\000\003\130\000\000\000\000\007\218\015\176\014H\000\000\000\000\015\164\007L\0016\000\000\000\000\000\000\000\000\n4\015\242\bb\015\198\014V\000\000\000\000\015\186\b\242\005\\\000\000\000\000\000\000\000\000\000e\000\000\005\248\000\000\000\000\000\000\027J\000\000\027b\000\000\000\000\000\000\000\000\000\000\b\206\000\000\000\000\000\000\t\144\000\000\003\130\000\000\tp\000\000\000\000\000\000\028$\006\212\000\000\000\000\004\014\015$\001p\000\000\000\000\000\000\000\000\000\000\000\000\0118\000\000\000\000\000\000\000\000)b\000\000\014b\000\000\000\000\000\000\000\000\004L\005\166\027\230\028\026\000\000\000\000\014r\028\150\000\000\000\000\000\000\014\132\028\194\000\000\000\000\000\000\000\000"), (16, "\006\016\003\223\002\b\002\t\001\187\000\139\006\179\006\165\001\204\002\238\001\187\000;\0062\001\219\006`\006\157\002L\006\017\006\190\001\219\006\019\002\238\001\245\002\238\002M\001\014\001\232\000\189\006\132\006\020\006!\006\016\004\229\002\b\002\t\000\139\001\245\002[\000\148\005v\006X\003\234\003\236\003\238\0007\000?\006t\002L\006\017\006 \001\223\006\019\001\017\000q\0007\002M\001\223\004\232\006\021\000m\006\020\006!\000\139\004\027\001\224\000\144\001\234\000\\\002[\001\187\001\224\001\230\004\234\000\189\001\187\004y\001\227\004\031\001\219\000\139\001[\000\149\001\204\001\219\000`\0007\006\022\001[\002\175\006\021\002]\004\235\0061\006\183\006\023\001\247\002\178\000\145\000\193\001\\\002\179\002\012\001^\001_\006d\006e\001\\\001l\001\019\001^\001_\006&\001\185\006f\006g\001\223\001\014\006\022\001\019\001\015\001\223\002]\001\226\001\212\006h\006\023\006'\001\246\000\139\001\224\006l\001\204\002\012\001\019\001\224\006\026\006d\006e\006\192\001\218\006\028\001\246\006&\001\017\001\n\006f\006g\001\248\000\189\001m\006\030\001n\002\186\002_\005x\002e\006h\006'\001 \001\014\005A\002k\001\014\002a\002\238\006\031\006\026\001c\000m\001\028\001\213\006\028\005\205\006\016\001u\002\b\002\t\001\245\001d\000d\001!\006\030\002m\001\014\002_\001d\002e\004\236\001a\002L\006\017\006 \002k\006\019\002a\001%\006\031\002M\006\216\002\t\005\207\000:\006\020\006!\006\016\002\180\002\b\002\t\001\226\001\019\002[\0009\004\232\002m\005\208\000\194\002\238\004\205\004E\005\210\002L\006\017\006 \005\254\006\019\002\182\002\238\004\234\002M\001\014\001w\006\021\001\"\006\020\006!\006v\000\139\001w\001\146\000\144\001b\002[\000=\000\250\001W\001x\004\235\001b\000\253\005H\005I\001\019\001\019\0015\006\130\001\019\001\017\006}\001\014\006\022\001\028\005\001\006\021\002]\006\150\006\151\006U\006\023\004\212\005R\006a\004\156\001\000\001[\002\012\001\234\001\019\003\223\006\128\004\213\006\161\002\208\001\246\004\237\006&\001\017\001%\002\238\001?\002\211\006\022\000x\001\\\002\179\002]\001^\001_\006\217\006\023\006'\006b\004\026\000\250\001\028\001\247\002\012\001\028\001\153\006\026\006c\006\162\003\154\001\187\006\028\001\188\006&\000\189\003\237\003\236\003\238\001\014\001\219\001\019\006\030\006\185\001b\002_\001\028\002e\006~\006'\001\000\006~\003\204\002k\003\160\002a\001\019\006\031\006\026\005\205\006W\000\127\001\187\006\028\001\217\006\016\000\133\002\b\002\t\003\239\001\019\001\219\006~\006\030\002m\001\248\002_\001\223\002e\001c\000\143\002L\006\017\006 \002k\006\019\002a\005\207\006\031\002M\001d\001\224\001\028\003\156\006\020\006!\006\016\003\207\002\b\002\t\000\250\005\208\002[\000\189\000\194\002m\005\210\000@\001\223\004\205\005\233\002\238\002L\006\017\006 \001[\006\019\002\180\001%\0007\002M\001\028\001\224\006\021\000\250\006\020\006!\006(\000\139\003\155\000\173\001\204\001\019\002[\001\\\001l\005\153\001^\001_\001\187\002\238\001\242\001w\001\234\004X\002\b\002\t\001%\001\219\005\155\001\146\006\022\001b\003\155\006\021\002]\003\157\003r\006$\006\023\004\212\000\139\000\128\001\191\001\204\004\127\002\012\003G\000\194\001\238\000\142\004\213\001\247\001[\001\031\004\220\006&\001m\004\205\001n\002(\000\131\006\022\001\028\001\014\001\223\002]\001\015\0007\003\242\006\023\006'\001\\\001l\004\144\001^\001_\002\012\001\014\001\224\006\026\001\015\001u\000\250\004[\006\028\000\175\006&\000\134\003\243\000\194\001\017\0007\001d\003\223\006\030\001\014\003u\002_\005\b\002e\002\201\006'\000\194\001\248\001\017\002k\006\135\002a\001\218\006\031\006\026\001\192\002\011\000\164\001m\006\028\001n\0020\002\238\004\208\004\205\000\194\001\017\002\012\002\238\006\030\002m\001!\002_\006\016\002e\002\b\002\t\005:\003\236\003\238\002k\001\218\002a\001u\006\031\001!\006\220\006\221\001w\002L\006\223\004\136\000\194\006\019\001d\003I\001x\002M\001b\000\166\001\019\002m\006\020\006\225\006\016\000\171\002\b\002\t\006\240\000\139\002[\005+\001\204\000\170\001\019\004\212\004\177\0023\006\232\002_\002L\006\233\006u\000\181\006\019\003\208\004\213\002`\002M\002a\004\214\006\021\001\019\006\020\006\241\000\176\001\187\004\138\002\024\005}\001\187\002[\003\201\000\180\0015\001\219\001w\000\186\001\014\001\219\002\238\001\028\006b\001\158\001x\002\172\001b\000\203\0015\006\022\004\139\006c\006\021\002]\001K\001\028\000\194\006\023\000\178\006\142\003\207\005\246\001\\\002\029\002\012\001^\001_\001%\003\239\001?\001>\006\228\001\223\001\028\000\194\000\139\001\223\0055\001\204\001\014\006\022\001%\002q\001?\002]\000\187\001\224\005\249\006\023\006'\001\224\001\187\001[\004\017\004\221\002\012\004\138\001N\006\026\001%\001\219\006\245\005\251\006\028\003|\002\233\002\234\000\195\004\007\005\253\000\204\001\\\002\179\006\030\001^\001_\002_\006:\002e\000\217\006'\002\b\002\t\005\129\002k\001\014\002a\005\252\006\031\006\026\001u\001\019\002\251\000\216\006\028\005\249\006\016\001\223\002\b\002\t\000\189\001d\000\220\006B\006\030\002m\000\194\002_\001\234\002e\005\251\001\224\002L\006\017\006.\002k\006\019\002a\004\215\006\031\002M\003\012\003\127\003\132\005\205\006\020\006!\006\016\000\194\002\b\002\t\000\194\001\019\002[\001\249\005\252\002m\001\247\002\238\001c\000\194\006\232\001\028\002L\006\233\005\160\002\238\006\019\003\245\002\238\001d\002M\005\207\001w\006\021\005A\006\020\006\236\004\028\002\b\002\t\001x\001\234\001b\002[\001\187\005\208\004\021\003\248\002\011\001\187\005\210\004\024\002L\001\219\005\226\002\158\002\180\001\019\001\219\002\012\002M\006\022\001\028\000\232\006\021\002]\006L\001\235\001\248\006\023\001\247\004\238\000\226\002[\002\212\001l\002\012\001^\001_\002\240\000\240\001w\006\175\005\236\005\164\001\187\006&\004&\001\029\001\146\001\223\001b\006\022\000\228\001\219\001\223\002]\000\233\002\238\0007\006\023\006'\001\014\005A\001\224\001\015\002\238\002\012\001\028\001\224\006\026\002_\006\162\006\239\001P\006\028\002\217\002\233\002\234\002`\000m\002a\001\248\005H\005I\006\030\002]\001\004\002_\001\017\002e\001\223\006'\000\194\001'\004\215\002k\002\012\002a\005Y\006\031\006\026\001u\005R\001\234\001\224\006\028\001\014\006\016\001\007\002\b\002\t\004\246\001d\000\194\006;\006\030\002m\000\194\002_\006\182\002e\002b\001\r\002L\006\017\001!\002k\006\019\002a\002\021\006\031\002M\001\247\000\236\005\030\000\241\006\020\006*\002\237\005\212\005\249\001<\001\014\001\014\002[\001\015\001\015\002m\002_\001\022\002e\005H\005I\001\234\001\019\005\251\002k\002\238\002a\001\234\001:\005\031\005_\005 \001w\006\021\0033\005Q\001T\001\017\001\017\005R\001x\001\014\001b\004\215\001\015\002m\001k\003\191\005\252\0012\001\247\001>\001\248\003\199\0019\001\175\001\247\002\238\001[\002\238\005!\006\022\000\194\003D\000\194\002]\001(\001\019\001\017\006\023\000\194\001[\004-\001\028\001!\001!\002\012\001\\\001l\002\239\001^\001_\001M\004:\0042\005A\006-\005\"\001\177\000\194\001\\\002\179\001\184\001^\001_\006\160\005#\000\194\005$\001%\004\011\006'\001\248\001\019\001\019\001!\001\014\000\194\001\248\001\015\006\026\004\002\001\148\004(\005`\006\028\000\194\003\207\001\028\006\152\001m\001S\001n\002(\001\014\006\030\000\189\001\015\002_\003\207\002e\0047\002\003\001\017\001\019\001\145\002k\005&\002a\001j\006\031\006q\005(\0052\003b\001u\002\006\0015\0015\000\194\005A\001\017\005\\\000\194\001\028\001\028\001d\002m\001c\005a\003u\001t\0007\001\187\001\187\004x\004~\005]\005A\001d\001!\002\020\001\219\001\219\005H\005I\003\207\002#\0015\002\238\001%\001%\0016\001?\005D\001\028\006\163\006\164\001!\005J\005Z\000\189\001\014\000\194\005R\001\015\003e\005\200\001\136\001\019\002\b\002\t\006\154\001\187\001\152\004\135\005R\000\194\001w\001\223\001\223\001%\001\219\001?\002L\003h\001x\001\019\001b\001\017\002&\001w\002M\001\224\001\224\001[\001\164\000\189\003\134\001\146\002,\001b\000\194\004.\001\019\002[\005A\005\030\000\194\005H\005I\001\169\001\014\0015\001\\\001l\004\004\001^\001_\001\223\001\028\005\205\004\205\004X\005J\005Z\001!\005H\005I\005R\003\253\0015\006\138\001\224\005\031\006\194\005 \006T\001\028\002A\006\168\001\234\005J\005Z\0007\001\234\001%\005R\001?\005\207\005\030\000\194\000m\002\238\005\240\001\019\002F\001m\002]\001n\002(\000\194\000\189\005\208\001%\005!\001?\003\203\005\210\002\012\001\247\004\030\005\217\004\212\001\247\002\157\006\174\005\031\006\176\005 \003\190\003\189\001u\006^\004\213\001\174\005\205\001\180\004\219\004@\002\b\002\t\005\"\001d\002b\005H\005I\003u\001\234\0015\000\194\005#\003\196\005$\002L\001\019\001\028\0043\005!\004X\005J\005Z\002M\001\014\005\207\005R\001\015\000\194\006\202\005`\003\211\002_\001\248\002e\004D\002[\001\248\001\247\005\208\002k\001\225\002a\001%\005\210\001?\005\"\000\194\005\214\002\b\002\t\001\017\000\194\005&\006\196\005#\001w\005$\005(\0052\002\238\002m\005\212\002L\001x\001\197\001b\001\028\005\\\006\204\000\189\002M\004\205\005`\000\194\001\199\002\238\006Q\006\163\006\164\006j\002\b\002\t\005]\002[\002\238\006\198\001\206\001!\002]\001\248\003\223\000\194\003\241\005\205\002L\005&\002\238\005R\006\139\002\012\005(\0052\002M\003\230\001\208\006\171\002\b\002\t\002\238\003\232\005\\\005\187\006?\0048\001\211\002[\001\019\001\215\001\014\001\222\002L\005\207\004\212\001[\002b\005]\002\b\002\t\002M\004P\005N\003\236\003\238\004\213\004\t\005\208\002]\004\245\004]\003\250\005\210\002[\001\\\001l\005\211\001^\001_\002\012\003\169\002\238\004`\002_\001\155\002e\003\182\001[\001\187\001\234\004\143\002k\0015\002a\004h\001\014\000\194\001\219\001\015\001\028\002]\001)\000\194\006\199\002b\003\254\001\\\001l\003\178\001^\001_\002\012\002m\002\238\003\223\006F\001\139\001m\001\247\001n\001\142\001*\001\017\001\019\002\238\001%\002]\001?\001H\004\029\001\019\002_\000\194\002e\001\223\004l\002b\002\012\001\187\002k\006J\002a\001u\001\019\002\002\004#\002\011\001\219\001\224\001m\004*\001n\001\142\001d\005V\003\236\003\238\002\012\002\005\001!\002m\003\168\002b\002_\002\019\003\001\000\194\004t\002\"\001\014\001\248\002k\001\015\002a\001u\001)\001/\001\014\004\133\0040\001\015\002\238\002%\001)\001\223\001d\002+\0027\001\019\002_\000\194\002e\002m\004C\001\028\001*\001\017\002k\001\224\002a\004H\0024\001F\001*\001\017\001w\000\194\001[\002<\002_\001+\000\194\004S\001x\004\\\001b\002;\002`\002m\002a\003\247\002@\001\014\002E\004_\001\015\001\\\001l\001)\001^\001_\004f\0015\001!\004j\004\137\001\144\001w\004o\001\028\000\194\001!\003\223\001=\002\241\001x\004{\001b\001*\001\017\001/\004\142\002\b\002\t\000\194\001D\002j\002\161\001/\004\147\002\196\000\194\001\019\004\152\002\203\001%\002L\001?\004\162\001m\001\019\001n\001\142\000\194\002M\000\194\002\b\002\t\002\238\002\238\004\003\004\168\006\147\003\236\003\238\000\194\001!\002[\002\232\004\179\002L\004\194\000\194\002\231\001u\000\194\002\b\002\t\002M\000\194\004\216\002\238\000\189\001/\003\188\001d\0015\000\194\003W\002\238\002L\002[\000\194\001\028\0015\001\019\003_\001=\002M\003\148\000\194\001\028\003\158\003\180\000\194\001=\005\205\004\199\003\185\000\194\004\223\002[\004\191\004\228\002\b\002\t\004\240\004\250\005\021\001%\002]\001?\000\194\003\195\003\197\005*\003\210\001%\002L\001?\000\194\002\012\000\194\003\219\005\207\004\233\002M\001w\002\238\0015\0054\000\194\003\171\005\019\002]\001x\001\028\001b\005\208\002[\001=\003\249\002\238\005\210\002\238\002\012\002b\005\221\005@\002\b\002\t\005T\002\b\002\t\002]\004\000\004)\005d\000\194\002\238\005j\000\194\001%\002L\001?\002\012\002L\000\194\000\194\000\194\002b\002M\005n\002_\002M\002e\000\194\003{\004\"\004$\003v\002k\005\027\002a\002[\002\238\005\138\002[\005\178\005\238\002b\000\194\002]\004'\002\b\002\t\005'\002_\005/\002e\002\238\005\183\002m\002\012\002\238\002k\005\222\002a\002L\000\194\002\b\002\t\000\194\005F\002\238\002\238\002M\002_\000\194\003\001\005\188\000\194\003k\0046\002L\002k\002m\002a\002b\002[\004,\005\218\002M\000\194\005\194\005\202\005\243\002]\003\\\005w\002]\0045\002\b\002\t\0041\002[\002m\000\194\002\012\000\194\000\194\002\012\001[\0044\005\154\002_\002L\002e\005\180\004B\006\b\002\238\000\194\002k\002M\002a\002\238\000\194\005\191\005\225\003T\001\\\001l\002b\001^\001_\002b\002[\004G\002\238\001\014\000\194\002]\001\015\002m\006E\002\238\004I\002\238\002\238\002\b\002\t\000\194\002\012\002\238\000\194\000\194\000\194\002]\004O\002_\006_\002e\002_\002L\002e\002\238\001\017\002k\002\012\002a\002k\002M\002a\001m\005\237\001n\002(\002b\006k\005\241\000\194\003L\002\238\006y\002[\006{\002\238\004N\002m\002]\004R\002m\005\245\002b\004T\004^\002\b\002\t\001u\005\250\002\012\006\006\006\r\001!\002_\000\194\002e\006\027\004i\001d\002L\004e\002k\003q\002a\004g\004k\004n\002M\006\"\002_\000\194\002e\004\130\002X\002b\004s\004v\002k\004\129\002a\002[\001\019\002m\004|\004\128\006+\002]\002\238\000\194\006p\000\189\002\b\002\t\000\194\002\238\000\194\004\132\002\012\002m\004\141\002\238\002_\004\146\002e\004\148\002L\004\249\004\151\002\238\002k\001w\002a\004\154\002M\005\205\002\b\002\t\002\238\001x\002d\001b\004\158\002b\004\166\004\173\001$\002[\004\184\001\014\002L\002m\001\015\001\028\002]\004\200\004\217\004\248\002M\002\b\002\t\004\241\006\156\005\207\002s\002\012\004\242\004\247\004\251\006\170\002_\002[\003\001\002L\000\189\006\226\001\017\005\208\002k\001%\002a\002M\005\210\006\237\004\252\005\029\005\239\002r\005\022\005\023\002b\005\028\006\242\0051\002[\005-\005.\0050\005\205\002m\002]\005[\005>\005?\005C\005E\002\b\002\t\005G\005S\005c\002\012\005e\001!\005f\002\b\002\t\002_\005k\002e\002L\005o\005s\005\133\002]\002k\005\207\002a\002M\002\b\002\t\005\140\005\144\005\168\002\166\002\012\002b\003\152\005\189\005\195\005\208\002[\001\019\002L\003\161\005\210\002m\002]\005\213\006\002\005\219\002M\005\223\006\015\006\t\006\n\006\014\002\177\002\012\006\029\002b\006D\001[\002_\002[\002e\006O\003\174\006Z\006\\\002\175\002k\006n\002a\002\b\002\t\006o\006s\002\178\006\155\006\159\001\\\002\179\002b\001^\001_\006\134\002_\002L\002e\006\169\006\173\002m\001\028\002]\002k\002M\002a\006\211\000\000\000\000\000\000\002\200\002\011\000\000\002\012\000\000\002\b\002\t\002[\002_\000\000\002e\000\000\003\165\000\000\002m\002]\002k\001%\002a\002L\000\000\000\000\000\000\000\000\000\000\000\000\002\012\002M\002b\000\000\000\000\002\b\002\t\002\207\000\000\000\000\000\000\002m\000\000\000\000\002[\003\155\000\000\000\000\000\000\002L\000\000\001c\002\b\002\t\000\000\002b\000\000\002M\000\000\002_\000\000\002e\001d\002\210\002]\000\000\002L\002k\002_\002a\002[\000\000\000\000\000\000\002M\002\012\002`\000\000\002a\000\000\002\216\000\000\002_\000\000\002e\002\b\002\t\002[\002m\002\180\002k\000\000\002a\000\000\000\000\000\000\000\000\002]\000\000\002L\002b\000\000\000\000\002\b\002\t\000\000\000\000\002M\002\012\002\181\000\000\002m\000\000\002\219\001w\001\014\000\000\002L\001\015\000\000\002[\000\000\001\146\002]\001b\002M\000\000\002_\000\000\002e\000\000\002\244\000\000\002b\002\012\002k\000\000\002a\002[\000\000\002]\000\000\001\017\002\b\002\t\000\000\000\000\000\000\000\000\000\000\000\000\002\012\004\187\000\000\000\000\000\000\002m\002L\000\000\002b\002_\000\000\002e\000\000\000\000\002M\000\000\004\190\002k\000\000\002a\000\000\000\000\002]\000\000\002\254\002b\000\000\002[\001!\000\000\000\000\000\000\000\000\002\012\000\000\002_\000\000\002e\002m\000\000\002]\000\000\000\000\002k\000\000\002a\000\000\002\b\002\t\000\000\000\000\002\012\002_\000\000\002e\000\000\000\000\001\019\002b\000\000\002k\002L\002a\000\000\002m\000\000\000\000\000\000\000\000\002M\005\030\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\003\003\002]\002m\002[\000\000\000\000\002_\000\000\002e\002\b\002\t\000\000\002\012\000\000\002k\000\000\002a\000\000\005\031\000\000\005 \000\000\0015\002L\002_\000\000\002e\000\000\000\000\001\028\000\000\002M\002k\004\192\002a\002m\000\000\002b\000\000\000\000\000\000\003\005\000\000\000\000\002[\000\000\000\000\002\b\002\t\005!\000\000\002\b\002\t\002m\000\000\001%\002]\001?\000\000\000\000\000\000\002L\000\000\000\000\002_\002L\003\001\002\012\000\000\002M\000\000\000\000\002k\002M\002a\000\000\005\"\002\b\002\t\003\t\000\000\000\000\002[\003\017\000\000\005#\002[\005$\000\000\000\000\000\000\002L\002b\002m\000\000\000\000\000\000\002]\000\000\002M\000\000\000\000\000\000\005^\000\000\000\000\000\000\000\000\002\012\003\023\000\000\000\000\002[\000\000\000\000\000\000\000\000\000\000\000\000\002_\000\000\003\001\000\000\002\b\002\t\000\000\005&\002k\000\000\002a\000\000\005(\0052\002b\000\000\002]\000\000\002L\000\000\002]\000\000\005\\\000\000\000\000\000\000\002M\002\012\000\000\002m\000\000\002\012\001\014\000\000\000\000\001\015\003\029\005]\000\000\002[\000\000\002_\000\000\003\001\000\000\001[\002]\000\000\000\000\002k\000\000\002a\002b\000\000\000\000\000\000\002b\002\012\000\000\001\017\000\000\005\152\002\b\002\t\001\\\002\179\000\000\001^\001_\000\000\002m\000\000\000\000\000\000\000\000\000\000\002L\000\000\000\000\002_\000\000\003\001\002b\002_\002M\003\001\000\000\002k\000\000\002a\003%\002k\002]\002a\000\000\000\000\001!\002[\000\000\000\000\000\000\002\b\002\t\002\012\000\000\000\000\000\000\000\000\002m\002_\000\000\003\001\002m\002\b\002\t\002L\000\000\002k\000\000\002a\000\000\000\000\000\000\002M\000\000\001\019\000\000\002L\002b\003*\000\000\000\000\001c\000\000\000\000\002M\002[\000\000\002m\000\000\000\000\000\000\000\000\001d\000\000\0036\002\b\002\t\002[\000\000\002]\000\000\000\000\000\000\000\000\002_\000\000\003!\002\b\002\t\002L\002\012\000\000\002k\000\000\002a\000\000\000\000\002M\0015\002\180\000\000\002L\000\000\000\000\000\000\001\028\000\000\003;\000\000\002M\002[\000\000\000\000\002m\000\000\002b\000\000\000\000\002]\003@\000\000\000\000\002[\000\000\001w\002\b\002\t\000\000\000\000\002\012\002]\001%\001\146\001\196\001b\000\000\000\000\000\000\000\000\002L\000\000\002\012\002_\000\000\002e\002\b\002\t\002M\000\000\000\000\002k\000\000\002a\000\000\002b\000\000\000\000\003O\000\000\002L\002[\000\000\000\000\002]\000\000\000\000\002b\002M\000\000\000\000\000\000\002m\000\000\000\000\002\012\002]\000\000\003R\000\000\000\000\002[\002_\000\000\002e\002\b\002\t\002\012\000\000\000\000\002k\000\000\002a\000\000\002_\000\000\003\001\000\000\000\000\002L\002b\000\000\002k\000\000\002a\000\000\000\000\002M\000\000\000\000\000\000\002m\002b\003X\002]\000\000\002\b\002\t\000\000\000\000\002[\000\000\000\000\002m\000\000\002\012\000\000\002_\000\000\003\001\002L\000\000\002\b\002\t\002]\002k\000\000\002a\002M\002_\000\000\003\001\000\000\000\000\003Z\002\012\002L\002k\000\000\002a\002b\002[\000\000\000\000\002M\000\000\002m\000\000\000\000\000\000\003d\000\000\000\000\000\000\000\000\000\000\000\000\002[\002m\000\000\002b\000\000\000\000\002]\000\000\000\000\000\000\002_\000\000\003\001\000\000\000\000\000\000\000\000\002\012\002k\001\014\002a\000\000\001\015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002_\000\000\003!\002\b\002\t\000\000\000\000\002]\002k\002m\002a\000\000\002b\000\000\000\000\000\000\001\017\002L\002\012\000\000\000\000\000\000\000\000\002]\0013\002M\002\b\002\t\000\000\002m\000\000\003m\000\000\000\000\002\012\000\000\000\000\000\000\002[\002_\002L\002e\000\000\002b\001[\000\000\000\000\002k\002M\002a\000\000\000\000\000\000\001!\003p\000\000\000\000\000\000\000\000\002b\000\000\002[\000\000\001\\\001l\000\000\001^\001_\002m\000\000\002_\000\000\002e\000\000\000\000\002\b\002\t\000\000\002k\000\000\002a\000\000\001\019\000\000\000\000\000\000\002_\000\000\002e\002L\000\000\002]\000\000\000\000\002k\000\000\002a\002M\000\000\002m\000\000\000\000\002\012\003~\000\000\000\000\001m\000\000\001n\002(\002[\000\000\000\000\000\000\002]\002m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\b\002\t\002\012\0015\002b\000\000\000\000\000\000\001u\000\000\001\028\000\000\000\000\000\000\002L\000\000\000\000\000\000\000\000\001d\000\000\000\000\002M\003t\000\000\000\000\000\000\002b\003\129\000\000\000\000\002_\000\000\002e\000\000\002[\001%\000\000\001;\002k\002]\002a\000\000\000\000\000\000\000\000\002\158\000\000\000\000\000\000\000\000\002\012\000\000\000\000\002_\000\000\002e\000\000\002\b\002\t\002m\000\000\002k\000\000\002a\002\212\001l\000\000\001^\001_\000\000\001w\002L\000\000\000\000\000\000\002b\000\000\000\000\001x\002M\001b\000\000\002m\002\b\002\t\000\000\000\000\002]\000\000\003\139\000\000\000\000\002[\000\000\000\000\000\000\000\000\002L\002\012\002\b\002\t\000\000\002_\000\000\002e\002M\002\217\002\233\002\234\000\000\002k\000\000\002a\002L\000\000\003\144\002\b\002\t\002[\000\000\000\000\002M\000\000\002b\000\000\000\000\000\000\003\193\000\000\000\000\002L\002m\001u\000\000\002[\000\000\000\000\000\000\002M\000\000\002\b\002\t\000\000\001d\003\206\002]\000\000\000\000\000\000\000\000\002_\002[\002e\000\000\002L\000\000\002\012\000\000\002k\000\000\002a\000\000\002M\000\000\000\000\000\000\002\b\002\t\003\252\003\131\000\000\002]\000\000\000\000\000\000\002[\000\000\000\000\000\000\002m\002L\002b\002\012\000\000\002\b\002\t\000\000\002]\002M\000\000\000\000\000\000\000\000\001\014\004>\001w\001\015\000\000\002\012\001@\000\000\002[\000\000\001x\002]\001b\003G\002b\002_\000\000\003\001\000\000\000\000\000\000\000\000\002\012\002k\000\000\002a\001B\001\017\000\000\000\000\002b\000\000\004\203\002\158\000\000\002]\000\000\003H\000\000\000\000\000\000\002_\000\000\003\001\002m\000\000\002\012\002b\000\000\002k\000\000\002a\002\212\001l\000\000\001^\001_\002_\000\000\002e\000\000\002]\000\000\000\000\001!\002k\000\000\002a\000\000\000\000\002m\002b\002\012\000\000\002_\000\000\002e\002\b\002\t\002\011\000\000\001/\002k\000\000\002a\000\000\002m\000\000\000\000\000\000\002\012\002L\000\000\001\019\002\217\002\233\002\234\002b\002_\002M\002e\002\b\002\t\002m\000\000\005r\002k\000\000\002a\000\000\000\000\000\000\002[\000\000\000\000\002L\000\000\000\000\003J\000\000\001u\002\b\002\t\002M\002_\000\000\002e\002m\000\000\005u\000\000\001d\002k\000\000\002a\002L\002[\0015\000\000\000\000\000\000\000\000\002_\002M\001\028\002\b\002\t\000\000\005\004\005\132\002`\000\000\002a\002m\000\000\000\000\002[\004\001\000\000\002L\002\b\002\t\000\000\000\000\000\000\002]\000\000\002M\000\000\000\000\001%\000\000\001?\005\135\002L\000\000\002\012\000\000\000\000\000\000\002[\000\000\002M\001w\000\000\000\000\000\000\000\000\005\148\002]\000\000\001x\000\000\001b\000\000\002[\000\000\000\000\000\000\000\000\002\012\002b\000\000\000\000\002\b\002\t\000\000\000\000\000\000\002]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002L\000\000\002\012\002\b\002\t\000\000\000\000\002b\002M\000\000\002_\000\000\002e\000\000\005\151\002]\000\000\002L\002k\000\000\002a\002[\000\000\000\000\000\000\002M\002\012\002b\000\000\000\000\002]\005\172\000\000\000\000\002_\000\000\002e\000\000\002[\002m\000\000\002\012\002k\000\000\002a\000\000\000\000\002\b\002\t\000\000\000\000\002b\000\000\000\000\002_\000\000\002e\000\000\000\000\000\000\000\000\002L\002k\002m\002a\000\000\002b\000\000\000\000\002M\002\b\002\t\000\000\000\000\002]\005\175\000\000\000\000\002_\000\000\002e\000\000\002[\002m\002L\002\012\002k\000\000\002a\002\158\000\000\002]\002M\002_\000\000\002e\000\000\000\000\005\179\000\000\000\000\002k\002\012\002a\000\000\002[\000\000\002m\002\212\001l\002b\001^\001_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002m\000\000\000\000\000\000\000\000\002b\000\000\000\000\000\000\002\b\002\t\000\000\000\000\002]\000\000\002_\000\000\002e\000\000\000\000\000\000\000\000\000\000\002k\002\012\002a\000\000\000\000\002\217\002\233\002\234\002\n\002_\002\158\002e\000\000\002]\000\000\002\b\002\t\002k\000\000\002a\000\000\002m\002\b\002\t\002\012\000\000\002b\000\000\000\000\002\212\001l\001u\001^\001_\002\b\002\t\002L\002G\002m\000\000\000\000\000\000\001d\000\000\002M\000\000\000\000\000\000\002L\002b\006\186\000\000\000\000\002_\000\000\002e\002M\002[\000\000\000\000\000\000\002k\006\188\002a\000\000\000\000\000\000\000\000\005\190\002[\000\000\002\217\002\233\002\234\002\011\000\000\002_\000\000\002e\000\000\000\000\000\000\002m\000\000\002k\002\012\002a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\001u\006\016\000\000\000\000\000\000\001x\002\011\001b\002m\000\000\000\000\001d\000\000\002]\000\000\006\232\000\000\002\012\006\233\000\000\000\000\006\019\000\000\000\000\002\012\002]\000\000\006\016\000\000\000\000\006\020\000\000\000\000\000\000\000\000\001[\002\012\005\224\000\000\000\000\002_\006\232\000\000\000\000\006\233\000\000\000\000\006\019\002`\002b\002a\000\000\000\000\000\000\001\\\001l\006\020\001^\001_\006\021\000\000\002b\000\000\001w\000\000\000\000\000\000\000\000\000\000\002_\000\000\001x\000\000\001b\000\000\000\000\002_\002`\002e\002a\000\000\000\000\000\000\000\000\002k\006\021\002a\006\022\002_\006\016\002e\000\000\000\000\000\000\000\000\006\023\002k\001m\002a\001n\006\206\006\208\000\000\006\232\000\000\002m\006\233\000\000\006\235\006\019\000\000\006\016\000\000\006\022\000\000\000\000\000\000\002m\006\020\000\000\000\000\006\023\001u\000\000\000\000\006\232\000\000\006\025\006\233\000\000\000\000\006\019\000\000\001d\006\234\000\000\006\026\000\000\001[\000\000\006\020\006\028\000\000\000\000\000\000\000\000\000\000\006\021\000\000\000\000\000\000\006\030\000\000\006\025\002\b\002\t\000\000\001\\\001l\000\000\001^\001_\006\026\000\000\000\000\000\000\006\031\006\028\002L\006\021\000\000\000\000\000\000\000\000\000\000\006\022\002M\006\030\000\000\000\000\000\000\000\000\000\000\006\023\000\000\001w\000\000\002\b\002\t\002[\000\000\000\000\006\031\001x\000\000\001b\006\238\006\022\000\000\000\000\001m\002L\001n\0065\000\000\006\023\000\000\000\000\001\014\002M\000\000\001\015\000\000\000\000\001@\006\025\000\000\000\000\006\243\000\000\000\000\000\000\002[\000\000\006\026\001u\000\000\000\000\000\000\006\028\000\000\000\000\000\000\000\000\001B\001\017\001d\006\025\001\014\006\030\000\000\001\015\002]\000\000\001)\000\000\006\026\000\000\000\000\000\000\000\000\006\028\000\000\002\012\006\031\000\000\000\000\000\000\000\000\000\000\000\000\006\030\001[\000\000\001.\001\017\000\000\000\000\000\000\000\000\000\000\001[\001!\000\000\000\000\002]\006\031\000\000\002b\000\000\000\000\001\\\001l\000\000\001^\001_\002\012\000\000\001w\001/\001\\\001l\000\000\001^\001_\000\000\001x\000\000\001b\000\000\000\000\001\019\001!\000\000\000\000\002_\000\000\004\012\000\000\000\000\000\000\002b\000\000\002k\000\000\002a\000\000\000\000\000\000\001/\000\000\000\000\000\000\000\000\001m\000\000\001n\001\147\000\000\000\000\000\000\001\019\000\000\001m\002m\001n\001}\000\000\002_\000\000\004\b\000\000\000\000\000\000\000\000\0015\002k\000\000\002a\001u\000\000\001[\001\028\000\000\000\000\000\000\001=\000\000\001u\000\000\001d\000\000\000\000\000\000\000\000\000\000\000\000\002m\001[\001d\001\\\001l\000\000\001^\001_\0015\000\000\001[\001%\000\000\001?\000\000\001\028\001[\000\000\000\000\001=\001\\\001l\000\000\001^\001_\000\000\000\000\000\000\000\000\001\\\001l\000\000\001^\001_\000\000\001\\\001l\000\000\001^\001_\000\000\001%\000\000\001?\000\000\001w\001m\000\000\001n\001z\000\000\000\000\000\000\001x\001w\001b\000\000\000\000\000\000\000\000\000\000\000\000\001x\001m\001b\001n\001p\001[\000\000\000\000\000\000\001u\001m\000\000\001n\001s\000\000\000\000\001m\000\000\001n\001v\001d\000\000\000\000\000\000\001\\\001l\001u\001^\001_\000\000\000\000\001[\000\000\000\000\000\000\001u\000\000\001d\000\000\000\000\000\000\001u\000\000\000\000\000\000\000\000\001d\000\000\000\000\000\000\001\\\001l\001d\001^\001_\001[\000\000\000\000\000\000\002\b\002\t\000\000\000\000\000\000\000\000\000\000\000\000\001m\000\000\001n\001y\000\000\001w\002L\001\\\001l\000\000\001^\001_\000\000\001x\002M\001b\000\000\000\000\000\000\000\000\002\b\002\t\001w\000\000\000\000\001u\001m\002[\001n\001\130\001x\001w\001b\000\000\002L\000\000\001d\001w\001[\001x\000\000\001b\002M\000\000\000\000\001x\000\000\001b\000\000\000\000\001m\001u\001n\001\133\000\000\002[\000\000\001\\\001l\000\000\001^\001_\001d\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\b\002\t\005\030\000\000\000\000\001u\000\000\000\000\000\000\000\000\002]\000\000\000\000\000\000\002L\000\000\001d\000\000\001w\000\000\000\000\002\012\002M\000\000\000\000\000\000\001x\000\000\001b\005\031\001m\005 \001n\002B\000\000\002[\000\000\000\000\002]\000\000\000\000\000\000\000\000\000\000\001w\000\000\002b\002\b\002\t\002\012\002\b\002\t\001x\000\000\001b\001u\000\000\000\000\000\000\000\000\005!\002L\000\000\000\000\002L\000\000\001d\000\000\001w\002M\002\b\002\t\002M\002_\002b\003\177\001x\000\000\001b\000\000\000\000\002k\002[\002a\002L\002[\000\000\005\"\002]\000\000\002\b\002\t\002M\000\000\002\b\002\t\005#\000\000\005$\002\012\000\000\002_\002m\003K\002L\002[\000\000\000\000\002L\002k\000\000\002a\002M\000\000\005%\000\000\002M\000\000\001w\000\000\000\000\000\000\000\000\000\000\002b\002[\001x\000\000\001b\002[\002m\000\000\000\000\000\000\000\000\002]\000\000\005&\002]\000\000\002\b\002\t\005(\0052\000\000\000\000\002\012\000\000\000\000\002\012\000\000\002_\005\\\002\242\002L\000\000\000\000\000\000\002]\002k\000\000\002a\002M\000\000\000\000\000\000\000\000\005]\000\000\002\012\000\000\002b\000\000\000\000\002b\002[\000\000\000\000\002]\000\000\002m\000\000\002]\000\000\000\000\002\b\002\t\000\000\000\000\002\012\002\b\002\t\000\000\002\012\002b\000\000\000\000\000\000\002_\002L\002g\002_\000\000\002i\002L\000\000\002k\002M\002a\002k\000\000\002a\002M\000\000\002b\000\000\000\000\000\000\002b\000\000\002[\002_\000\000\002n\000\000\002[\000\000\002m\002]\002k\002m\002a\000\000\000\000\002\b\002\t\000\000\000\000\000\000\002\012\000\000\002_\000\000\002u\000\000\002_\000\000\002w\002L\002k\002m\002a\000\000\002k\000\000\002a\002M\002\b\002\t\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\002[\002m\002L\000\000\002]\002m\000\000\000\000\000\000\002]\002M\002\b\002\t\000\000\000\000\002\012\000\000\000\000\000\000\000\000\002\012\000\000\002_\002[\002y\002L\000\000\000\000\000\000\000\000\002k\000\000\002a\002M\000\000\002\b\002\t\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\002b\002[\000\000\000\000\002L\000\000\002m\000\000\002]\000\000\000\000\000\000\002M\000\000\000\000\000\000\000\000\000\000\000\000\002\012\000\000\000\000\002_\000\000\002{\002[\000\000\002_\000\000\002}\002k\002]\002a\002\b\002\t\002k\000\000\002a\000\000\000\000\000\000\000\000\002\012\000\000\002b\000\000\000\000\002L\002\b\002\t\000\000\002m\000\000\000\000\002]\002M\002m\000\000\000\000\000\000\000\000\000\000\002L\000\000\000\000\002\012\000\000\002b\002[\000\000\002M\002_\000\000\002\127\000\000\000\000\000\000\000\000\002]\002k\000\000\002a\000\000\002[\000\000\000\000\000\000\000\000\000\000\002\012\002b\002\b\002\t\000\000\002_\000\000\002\129\000\000\000\000\000\000\002m\000\000\002k\000\000\002a\002L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002M\002b\002\b\002\t\002_\000\000\002\131\000\000\002]\000\000\002m\000\000\002k\002[\002a\000\000\002L\002\b\002\t\002\012\000\000\000\000\000\000\002]\002M\006\016\002\b\002\t\002_\000\000\002\133\002L\000\000\002m\002\012\000\000\002k\002[\002a\002M\002L\000\000\006\017\000\000\002b\006\019\000\000\000\000\002M\000\000\002\b\002\t\002[\000\000\006\020\000\000\000\000\002m\000\000\002b\000\000\002[\000\000\000\000\002L\000\000\002]\000\000\000\000\000\000\000\000\002_\002M\002\135\000\000\000\000\000\000\002\012\000\000\002k\000\000\002a\000\000\006\021\000\000\002[\002_\000\000\002\137\000\000\002]\000\000\000\000\000\000\002k\000\000\002a\000\000\000\000\000\000\002m\002\012\002b\000\000\000\000\002]\000\000\000\000\002\b\002\t\000\000\006\022\000\000\000\000\002]\002m\002\012\000\000\000\000\006\023\000\000\000\000\002L\000\000\000\000\002\012\002b\000\000\000\000\002_\002M\002\139\002\b\002\t\000\000\000\000\006\024\002k\002]\002a\000\000\002b\000\000\002[\000\000\000\000\002L\000\000\000\000\002\012\002b\006\025\000\000\002_\002M\002\141\000\000\000\000\002m\000\000\006\026\002k\000\000\002a\000\000\006\028\000\000\002[\002_\000\000\002\143\000\000\000\000\000\000\002b\006\030\002k\002_\002a\002\145\002\b\002\t\002m\000\000\000\000\002k\000\000\002a\000\000\000\000\006\031\000\000\000\000\000\000\002L\000\000\002]\002m\000\000\000\000\000\000\002_\002M\002\147\002\b\002\t\002m\002\012\000\000\002k\000\000\002a\000\000\000\000\000\000\002[\000\000\000\000\002L\000\000\002]\000\000\001[\000\000\000\000\001\014\002M\000\000\001\015\000\000\002m\002\012\002b\000\000\000\000\000\000\000\000\001\014\000\000\002[\005\005\001\\\001l\000\000\001^\001_\000\000\000\000\000\000\000\000\000\000\001[\001\017\000\000\000\000\000\000\002b\000\000\000\000\002_\000\000\002\149\004\187\000\000\001\017\000\000\000\000\002k\002]\002a\001\\\001l\000\000\001^\001_\000\000\000\000\005\149\000\000\002\012\000\000\000\000\000\000\002_\001m\002\151\001n\002\222\002m\001!\000\000\002k\002]\002a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\007\001[\002\012\002b\002\b\002\t\000\000\000\000\001u\000\000\000\000\002m\001m\000\000\001n\002\225\000\000\001\019\002L\001d\001\\\001l\001[\001^\001_\000\000\002M\002b\000\000\005\n\002_\000\000\002\153\000\000\000\000\002\b\002\t\001u\002k\002[\002a\001\\\001l\000\000\001^\001_\000\000\000\000\001d\000\000\000\000\000\000\000\000\000\000\002_\000\000\002\155\002I\000\000\002m\000\000\0015\002k\001m\002a\001n\002\228\000\000\001\028\000\000\000\000\001w\004\192\000\000\000\000\000\000\002\b\002\t\000\000\001x\005\r\001b\000\000\002m\001m\000\000\001n\002\236\001u\000\000\002L\004\213\002]\005\018\001%\005\015\001?\000\000\002M\001d\001w\000\000\000\000\002\012\002\b\002\t\001%\000\000\001x\001u\001b\002[\000\000\000\000\000\000\000\000\000\000\000\000\002L\000\000\001d\002\b\002\t\002\011\000\000\000\000\002M\000\000\002b\000\000\000\000\000\000\000\000\000\000\002\012\002L\000\000\000\000\000\000\002[\000\000\000\000\000\000\002M\002\b\002\t\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\000\000\002_\002[\002\248\002L\001x\000\000\001b\000\000\002k\002]\002a\002M\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\002\012\002\b\002\t\000\000\002[\001x\000\000\001b\000\000\002m\000\000\002_\000\000\002\b\002\t\002L\000\000\002]\000\000\002`\000\000\002a\000\000\002M\000\000\002b\000\000\002L\002\012\000\000\000\000\000\000\000\000\000\000\002]\002M\002[\000\000\000\000\000\000\001\014\002\b\002\t\005\005\000\000\002\012\000\000\000\000\002[\000\000\000\000\000\000\002_\002b\003\021\002L\000\000\002]\000\000\000\000\002k\000\000\002a\002M\000\000\000\000\000\000\001\017\002\012\000\000\002b\000\000\000\000\000\000\000\000\000\000\002[\000\000\000\000\000\000\002_\002m\003\027\000\000\000\000\000\000\000\000\000\000\002k\002]\002a\000\000\000\000\002b\000\000\000\000\000\000\002_\000\000\003 \002\012\002]\000\000\000\000\005\007\002k\000\000\002a\000\000\002m\002\b\002\t\002\012\002\b\002\t\000\000\000\000\000\000\000\000\000\000\002_\000\000\003(\000\000\002L\002b\002m\002L\002k\002]\002a\000\000\002M\005\n\000\000\002M\000\000\002b\000\000\000\000\002\012\002\b\002\t\000\000\000\000\002[\000\000\000\000\002[\002m\000\000\000\000\002_\000\000\003-\002L\002\b\002\t\000\000\000\000\002k\000\000\002a\002M\002_\002b\003/\000\000\000\000\000\000\002L\000\000\002k\000\000\002a\000\000\002[\000\000\002M\000\000\000\000\002m\002\b\002\t\005\r\000\000\000\000\000\000\000\000\002\b\002\t\002[\002_\002m\0032\004\213\002L\005\017\002]\005\015\002k\002]\002a\002L\002M\000\000\000\000\000\000\000\000\002\012\001%\002M\002\012\002\b\002\t\000\000\000\000\002[\000\000\000\000\000\000\002m\000\000\000\000\002[\000\000\000\000\000\000\000\000\002]\000\000\001[\000\000\000\000\002b\002S\000\000\002b\000\000\000\000\002\012\000\000\000\000\000\000\002]\000\000\000\000\000\000\000\000\000\000\001\\\002\179\000\000\001^\001_\002\012\000\000\000\000\006\016\000\000\000\000\002_\000\000\0039\002_\002b\003>\000\000\000\000\002k\002]\002a\002k\000\000\002a\006\223\000\000\002]\006\019\000\000\002b\002\012\000\000\000\000\000\000\000\000\000\000\006\020\002\012\000\000\002m\006\016\002_\002m\003C\000\000\000\000\000\000\000\000\000\000\002k\002\011\002a\001[\000\000\000\000\002b\002_\006\017\003F\000\000\006\019\002\012\002b\000\000\002k\006\021\002a\001c\000\000\006\020\002m\001\\\001l\000\000\001^\001_\000\000\000\000\001d\000\000\000\000\000\000\002_\006\016\003x\002m\000\000\000\000\000\000\002_\002k\003z\002a\006\022\000\000\000\000\000\000\002k\006\021\002a\006\017\006\023\000\000\006\019\000\000\003e\000\000\000\000\000\000\001[\000\000\002m\006\020\002_\001m\006\224\001n\004<\002m\000\000\000\000\002`\000\000\002a\003g\000\000\006\022\000\000\001\\\002\179\001w\001^\001_\006\025\006\023\000\000\000\000\000\000\001\146\001u\001b\006\021\006\026\000\000\000\000\001[\000\000\006\028\000\000\000\000\001d\006#\000\000\000\000\000\000\000\000\000\000\006\030\000\000\001[\000\000\000\000\000\000\000\000\001\\\002\179\006\025\001^\001_\006\022\000\000\000\000\006\031\000\000\000\000\006\026\000\000\006\023\001\\\002\179\006\028\001^\001_\000\000\000\000\000\000\000\000\000\000\001\014\000\000\006\030\001\015\000\000\000\000\006,\000\000\001c\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\006\031\000\000\001d\001\014\006\025\001x\001\015\001b\000\000\000\000\001\017\000\000\000\000\006\026\000\000\000\000\000\000\000\000\006\028\000\000\004\187\000\000\000\000\000\000\000\000\000\000\000\000\001c\006\030\003e\001\017\000\000\000\000\000\000\000\000\005\163\000\000\001[\001d\000\000\004\187\001c\000\000\006\031\000\000\000\000\000\000\001!\003f\000\000\000\000\001[\001d\005\176\001w\005\173\001\\\002\179\001[\001^\001_\000\000\001\146\000\000\001b\003e\001\014\001!\000\000\001\015\001\\\002\179\000\000\001^\001_\000\000\001\019\001\\\002\179\006\003\001^\001_\000\000\000\000\003j\000\000\000\000\001[\000\000\000\000\001w\000\000\000\000\001\017\000\000\000\000\001\019\000\000\001\146\000\000\001b\000\000\000\000\003\226\001w\000\000\001\\\002\179\000\000\001^\001_\000\000\001\146\000\000\001b\000\000\000\000\006x\000\000\000\000\0015\000\000\000\000\000\000\001c\006\005\000\000\001\028\000\000\000\000\001!\004\192\000\000\000\000\000\000\001d\000\000\000\000\001c\000\000\0015\000\000\000\000\000\000\001[\001c\000\000\001\028\000\000\001d\000\000\004\192\000\000\001%\000\000\001?\001d\000\000\000\000\001\019\000\000\000\000\002\180\001\\\002\179\000\000\001^\001_\000\000\000\000\001[\000\000\000\000\001%\001c\001?\005\203\000\000\002\b\002\t\000\000\000\000\000\000\005\203\000\000\001d\000\000\001w\001\014\001\\\002\179\001\015\001^\001_\000\000\001\146\001\014\001b\000\000\001\015\003\152\001w\000\000\0015\000\000\000\000\000\000\003\161\001w\001\146\001\028\001b\006\003\000\000\000\000\001\017\001\146\000\000\001b\001\014\000\000\005\216\001\015\001\017\000\000\003\226\000\000\000\000\005\215\000\000\003\162\001c\000\000\000\000\000\000\000\000\001%\001w\003\233\003\229\000\000\000\000\001d\002\b\002\t\001\146\001\017\001b\000\000\000\000\000\000\004\203\001!\001\014\000\000\000\000\001\015\001c\006\004\001\014\001!\000\000\001\015\000\000\000\000\002^\002\011\000\000\001d\006\003\000\000\001\014\001\014\000\000\001\015\001\015\000\000\003\165\000\000\000\000\001\017\001\019\000\000\001!\000\000\005\198\001\017\000\000\001[\001\019\000\000\000\000\000\000\000\000\001w\003i\000\000\000\000\001\017\001\017\000\000\000\000\001\146\000\000\001b\000\000\003\155\001\\\001]\000\000\001^\001_\001\019\000\000\000\000\006\012\000\000\001!\001\014\000\000\001w\001\015\000\000\001!\001\014\0015\000\000\001\015\001\146\002_\001b\002\011\001\028\0015\000\000\001!\001!\002`\000\000\002a\001\028\000\000\002\012\000\000\004\224\001\017\001\019\004\227\000\000\000\000\000\000\001\017\001\019\000\000\001\014\000\000\0015\001\015\001%\000\000\003\233\000\000\000\000\001\028\001\019\001\019\001%\004\211\001?\000\000\000\000\001\014\000\000\000\000\001\015\001c\000\000\000\000\000\000\000\000\000\000\001\017\001!\000\000\000\000\000\000\001d\000\000\001!\001%\0015\001?\000\000\000\000\002_\000\000\0015\001\028\001\017\000\000\000\000\004\211\002`\001\028\002a\000\000\000\000\004\224\0015\0015\005\244\001\019\000\000\000\000\000\000\001\028\001\028\001\019\001!\006\181\001O\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\001!\001\014\000\000\001w\001\015\000\000\001%\001%\001?\001?\000\000\001\146\001\019\001b\001\014\000\000\001[\001\015\000\000\001\014\0015\000\000\001\015\000\000\000\000\000\000\0015\001\028\001\017\001\019\000\000\001\163\000\000\001\028\000\000\001\\\002\164\001\201\001^\001_\000\000\001\017\000\000\000\000\000\000\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\001%\000\000\001?\0015\000\000\000\000\001%\000\000\001?\000\000\001\028\000\000\001!\001\014\001\203\000\000\001\015\000\000\001\014\001\014\0015\001\015\001\015\000\000\000\000\001!\000\000\001\028\000\000\000\000\001!\002\031\000\000\000\000\000\000\000\000\001%\000\000\001?\000\000\001\017\001\019\000\000\000\000\000\000\001\017\001\017\000\000\000\000\000\000\001c\000\000\000\000\001%\001\019\001?\000\000\000\000\000\000\001\019\001\014\001d\000\000\001\015\000\000\000\000\001\014\000\000\000\000\001\015\000\000\000\000\000\000\000\000\000\000\001\014\000\000\001!\001\015\000\000\000\000\001\014\001!\001!\001\015\0015\000\000\001\017\000\000\000\000\000\000\000\000\001\028\001\017\000\000\000\000\0022\000\000\0015\000\000\000\000\000\000\001\017\0015\000\000\001\028\001\019\000\000\001\017\002\169\001\028\001\019\001\019\001w\002\174\000\000\001\014\000\000\001%\005\005\001?\001\146\001\014\001b\001!\001\015\000\000\000\000\000\000\000\000\001!\001%\000\000\001?\000\000\000\000\001%\000\000\001?\001!\000\000\000\000\000\000\001\017\000\000\001!\000\000\000\000\000\000\001\017\0015\000\000\000\000\001\019\000\000\0015\0015\001\028\000\000\001\019\000\000\002\191\001\028\001\028\000\000\000\000\002\198\002\205\001\019\001\014\000\000\000\000\001\015\000\000\001\019\001\014\000\000\000\000\001\015\000\000\005\007\000\000\000\000\001%\001\014\001?\001!\001\015\001%\001%\001?\001?\000\000\000\000\000\000\000\000\001\017\0015\000\000\000\000\000\000\000\000\001\017\0015\001\028\000\000\000\000\000\000\002\214\005\n\001\028\001\017\0015\000\000\004K\001\019\000\000\001\014\0015\001\028\005\005\000\000\000\000\004\164\000\000\001\028\000\000\000\000\000\000\004\176\001%\001\014\001?\001!\005\005\000\000\001%\000\000\001?\001!\000\000\000\000\000\000\000\000\001\017\001%\000\000\001?\001!\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\000\000\001\017\0015\005\r\000\000\001\019\000\000\000\000\000\000\001\028\000\000\001\019\001\014\004\189\004\213\001\015\005\016\000\000\005\015\000\000\001\019\000\000\002\b\002\t\005\007\000\000\000\000\001\014\000\000\001%\001\015\000\000\000\000\000\000\000\000\001%\000\000\001?\005\007\001\017\000\000\000\000\000\000\000\000\002l\000\000\000\000\002\b\002\t\0015\000\000\000\000\000\000\005\n\001\017\0015\001\028\000\000\001\014\000\000\004\210\005\005\001\028\000\000\0015\000\000\004\226\005\n\000\000\003G\000\000\001\028\000\000\000\000\001\014\005\128\001!\005\005\000\000\000\000\000\000\000\000\001%\000\000\001?\001\017\001\014\000\000\001%\001\015\001?\001!\000\000\005\209\000\000\000\000\000\000\001%\000\000\001?\000\000\001\017\002\b\002\t\005\r\001\019\000\000\000\000\000\000\000\000\002\011\000\000\000\000\001\017\000\000\004\213\000\000\005\014\005\r\005\015\001\019\002\012\005\007\000\000\003\014\000\000\000\000\000\000\000\000\004\213\001%\005\026\000\000\005\015\000\000\002\011\000\000\000\000\005\007\001\014\000\000\000\000\001\015\000\000\001%\001\014\002\012\000\000\001\015\0015\001!\005\n\000\000\000\000\000\000\000\000\001\028\000\000\001\014\000\000\005\146\001\015\001\014\000\000\0015\001\015\001\017\005\n\000\000\000\000\000\000\001\028\001\017\002_\003J\005\170\000\000\000\000\000\000\001\019\000\000\002`\001%\002a\001?\001\017\000\000\000\000\000\000\001\017\002\011\000\000\000\000\000\000\000\000\000\000\000\000\001%\002_\001?\000\000\002\012\005\r\001!\000\000\000\000\002`\000\000\002a\001!\000\000\000\000\000\000\004\213\000\000\005\230\000\000\005\015\005\r\000\000\000\000\000\000\001!\0015\000\000\000\000\001!\000\000\001%\004\213\001\028\006\000\001\019\005\015\0068\000\000\000\000\000\000\001\019\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\000\000\000\000\000\000\000\000\001\019\000\000\002_\000\000\001\019\001%\000\000\001?\000\000\000\000\002`\000\000\002a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0015\000\000\000\000\000\000\000\000\000\000\0015\001\028\000\000\000\000\000\000\006\141\000\000\001\028\000\000\000\000\000\000\006\145\000\000\0015\000\000\000\000\000\000\0015\000\000\000\000\001\028\000\000\000\000\000\000\001\028\000\000\000\000\001%\000\000\001?\000\000\000\000\000\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\001%\000\000\001\198\000\000\001%\000\000\003\228")) + ((16, "\000%\000\193\000G\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\012\000\000\000\000\000\129\001\152\000\030\0003\000#\000\004\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000t\000\000\000\000\000\000\000\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=2\000\000\000\000\000\000\000\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000'\238\001T\001>\000\223\000\000\001B9\220\001\236\001\218\000:\000\000\001x\000\000\000\182\003\156\000\000\002\150\000\000\000\000\000\000\000\000\000\000\001\022\000\000\000\218\003\202\bf\000\000\000\000\011\018'\238\000\000\000\000\001\254\000\000\000\027\000\000:~\002\184\000\000\001\156\001r\000\000\000\000\002\172\002\142\002\208\003b\001\226\003\202\004\142\000f\001\194\0022\003\216\002\152\011b\000\000\005(\003\244\003\188\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004r\000\000\t>\005(\011\194\000\000\000\000\004.\005d\004\0301\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\148\000\000\004\168\005l\005@\000\000\000\000\000\000\000\000\000\173\000\000\000\000\005\144\000\167\006\018\006(\007\214\000\000\0050\005H\006*\000Q\004\228\006L \232\000\000\000\000\005X\006\254\011\204\000\000!\b\001\244!\026\"V\000\000\003B\000\000\000\000\000\000\000\000\006\018=F\006\020\000\000\001\012\0064\000\000\004P6\150\000\131\000\000\001\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002:\005\190\000\000\000\000\000\000\000\192\000\000\tD\000\000\000\000\002\164\000o\000\000\000\000\003\248\000\000\006n\000\000\002\164\t\148\002\164\000\000\000\000\000\000\000\000\000\0007 \000\000\007\"\006@\000\000=\168\007N\030`\000\000\000\000\000\000\0062\000\000\000\000\000\000\000\000\006F\000\000\000\000\000\000\000\000\000\0002L\000\000\000\000\000\000\000\000\000\000\000\000\001\158\007N\000\000\000\000\000\000\006F\007\1342\146\006\224\007p\015\214\000\000\003\014\000\000\000\000\000\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\0122\160\000\000\000\000\007\030\b\0042\214\000\000\000\000\000\00038\007\0143\152\000\000\007\014\000\0003\164\007\014\000\0003\228\007\014\000\000\007\014\000\000\000\000\007\014\000\000\000\0004J\000\000\007\0144\138\000\000\007\014\002|\000\000\000\000\"V\000\000\000\000\000\000\000\000\007\014\"z\000\000\000\000\000\000\007\014\000\000\006F\007\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\016\000\000\007\136\000\000=\132\006F\000\000\000\000\000\000\000\000\b\b\b\184\012$\b\026\b\030\b@\b\028\005\014\b`\0001\t\006\000\000\000\000\000\029\005\136\b\160\001\172\b\200\bL\000\000\000\145\004\138\005\180\007\136\n\"\000\000\000\000C\158\000\000C\224\t\212\000\000=\198\006F>@\006F\000\000\003\"\000\000\003x\000\000\000\000\003\220\000\000\000\000\000\000\nt\000\000\n\030\000\145\000\000\000\000\t>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\145\000\000\000\000\000\145\000\000\b\200\007\014\000\000\002\182\004\228\000\000\002\182\000\000\000\000\n\206\000\145\000\000\000\000\000\000\000\000\000\000\000\000\002\182\012\132\rL\n4\t\218\"\152\000n\000\000\t\130\b\182\r\158\t\234\b\228\025X1N\000\000\000\000\000\000\000\000\000\000\0032\t\188\000\000\000\000\000\000\t\250\b\244\007V\002\182\011\240\000\000\000\145\000\000\000\000\000\000\001\244\000\000>T\006F\r\166\n\018\t\030\r\254\n \t0\014\180\"\186\007\014\015\024\n\"\t89\190\n\244\000\000#\002\007\014>x\006F\n\238\000\000\000\000\000\000\000\000\007\148\011&\011L\000\000\000\000\b\176\015 \n\208\t>4\172\007\014\015t\n\222\tF6(\000\000>\172\000\000\000\000\015|\"\244\018\\\000\000\000\000\000\000\000\000>\208\000\000\000\000\000\000\007\172\016B\000\000\000\000\000\000\000\000#^>\222\000\000\000\000\000\000\000\000\000\000\n\170\016\150\000\000\n\180$\"\n\180$,\n\180\000\000?\026\000\000$\128\n\180\016\234\004\152\016\244\000\000\000\000$\136\n\180%\022\n\180%\030\n\180%\250\n\180&\002\n\180&\026\n\180&\152\n\180&\246\n\180&\254\n\180'\140\n\180'\148\n\180'\232\n\180(v\n\180(\128\n\180)\014\n\180)^\n\180)h\n\180)\246\n\180*F\n\180*\212\n\180\t\170*\2484\232\007\148\011x\000\000+8;l\000\000\017N\000\000?,\000\000\006F;\166\000\000\006F?P\006F\000\000\017\184\000\000\000\000\000\000+\\\000\000\000\000\000\000\000\000\000\000\007\014\000\000\000\000?\210\000\000\006F\000\000\000\000;\166\011\136\000\000@6\006F\018\018\000\000\000\000\011\"\000\000@H\006F\018\160\000\000\000\000\018\196\000\000\000\000\000\000@Z\006F\019\028\000\000\n\252\019\132\000\0005J\000\000\007\0145\142\000\000\007\0145\176\000\000\007\014\003d\000\000\000\000\000\000\000\000\000\0005\240\007\014\004\222\005\022\000\000\000\000\000\000\n\180\019\222\000\000\000\000\000\000+\150\n\180\000\000\000\000\000\000\000\000\0206\000\000\000\000\000\000\n\180\020D\000\000\020\158\000\000\000\000\000\000\021\004\000\000\000\000\000\000\000\000@\146\000\000\000\000\021^\000\000\000\000\000\000,H\n\180\021l\000\000\000\000\000\000,\138\n\180\021\196\000\000\000\000,\176\n\180\n\180\000\000\007\228\022\030\000\000\000\000-\b\n\180\022l\000\000\000\000-(\n\180-v\n\180\000\000.\004\n\180\000\000\000\000\022\250\000\000\000\000.\152\n\180\023,\000\000\000\000.\200\n\180\023\\\000\000\000\000.\232\n\180\000\000/\000\n\180\000\000;\138\000\000\000\000\n\180\000\000\000\000\023\142\000\000\000\000\023\192\000\000\000\000\011D\000\000\000\000\024\028\000\000\024$\000\000\000\000\000\000\007\148\011\226\000\0007\022\n<\002\164\025\004\000\0007r\000\000\000\000\000\0007\194\000\000\000\000\025$\000\000\025\146\000\000\000\000\000\000\000\000/\n\000\000\000\000\000\000/f\n\1800r\n\180\000\000\n\252\025\156\000\000\000\000\025\236\000\0000T\000\000\000\0001N\000\000\000\000\000\000\026\134\000\000\000\000\000\000\000\000\026\144\000\000\000\000\000\000\000\000\012\152\000\000\000\000\000\000\003\154\000\000\000<\000\000\000;\000\000\0128\000\000\004\144\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\180\000\000\012\164\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\184\007\232\002\182\027T\000\000\011\166\t\224\012*\001\144\t\136\002\182\r@\000\145\t\176\002\182\000\000\027x\000\000\004\142\000\000\011\194\t\238\004X\000\000\000\000\000\000\000\000\000\000\011\218\001.\000\146\000\000\000\000\000\000;\222\000\000C\240\000\000\t\246\000\000\n\016\000\000\000\000\000\000\000\000\002\158\000\000\000\000\000\000\011*\002\164\000\000\002\164\001\178\000\000\rv\002\164\002\164\n\024\000\000\027\186\000\000\000\000\n8\012\172\000\0000\180\005$\000\000\000\000\000\000\000\000\000\000\000\000\n\180\000\000\028\180\000\000\n\180\000\000\000\000\014\242\000\000\000\145\000\000\016H\000\000\000\145\000\000\017\012\000\145\000\000\003Z\000\000\n<\n\022\005`\000\000\011\226\011\234\nV\012\024\012\164\017T\000\145\006\012\000\000\nZ\012\134\012\188\005\024\006\184\012\150\n\130\r\014\006\146\b\132\012\228\000\000\000\000\007\188\b\148\000\000\004\168\002\2426N\007\014\028\028\000\000\007X\003\178\012\158\n\154\011^\005\224\000\000\012\168\n\158\006\200\000\000@\172\006F\rZ\r\132\000\000\t:\000\000\012\244\n\166\006>\r2\003V\000\000\000\000\000\000\000\000\n\216\tZ\000\000\n\222\tl\000\000\bb\0164\rF\rP\n\228\006\216\t\172\000\000\n\230\007\138\n\018\000\000\rR\n\238\r\220\000\000\t\028\000\000\n\132\000\000\r\252\000\000\018\024\000\145\r\216\011\002\014\022\000\000\018\202\0056\r\236\000\000\000\000\003j\006\160\011$\000\000\019\228\000\145\011F\000\000\004\022\000\000\r\210\011\016\0212\006\154\000\000\r\222\011>\007\176\r2\r\230\r\240\011L\015F\000\000\014\000\001\200\000\000\000\000\000\000\000\000\000\171\011X\r\226@\190\006F\000\000\002\200\011\142\014\148\000\000\000\000\000\000\000\000\000\000\000\000A\000\006\164\000\000\011\182\014\246\000\000\000\000\000\000\000\000\000\000\000\000\006\174\000\000A\030\006F\011\226\000\000\006F\011\218\000\184\000\000\011\230\011\232\007\024\000\000\001\004\004L\000\000\002\190\000\000A\"\006F\006F\000\000\000\000\007\b\000\000\b\252\000\000\001\186\007\b\007\b\000\000\011\236;\204\006FA\152\006F\012\b\000\000\000\000\000\000\000\000\012\014\000\000\000\000\007N\000\000\007l\014`\011\240\015p\014*\000\000\000\000\001\196\b|\014h\000\000\000\000\011\250\015\128\014@\000\000\000\000\029\018\000\000\012\222\000\000!(6H\006F\000\000,N\018\132\000\000A\252\000\000\000\000\000\000\007\b\000\000\000\000\012:\014|\012\000\015\144\014J\000\000\000\000B\014\012\144\014\140\000\000\000\000\000\000<:\000\000\000\000\000\000\000\000\000\000\000\000\012\146\000\000\014\152\012\020\006\162\000\000\015\134\015>\012\180\014\166\000\000\000\000\014\170\012>\b*\000\000\000\000\tl6\150\005|\000\000\000\000\000\000\bL\014p\012p\000\000\014z\bL\000\000\015V\012\188\014\196\000\000\000\000\000\000\006F\003v\004(\005\180\000\000\000\000\000\000\000\000\014\138\012t\000\000\006\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006F\014z\012\128\015\208\014\138\000\0007\224\000\237\012\146\014^\003\156\000\019\012\150\015\016\000\000\015\200\028\130\000\000\000\000\029J\000\000\012\208\000\000\nL\000\000\000\000\000\000\000\000\000\000\000\000B\018\006F\000\000\015\204\029l\000\000\000\000\030\002\000\000\000\245\012\156\015r\000\000\000\0007\250:\020\015(\000\000B0\006F\0302\000\000\000\000\030T\000\000\000\000\r0\000\000\000\\\000\000\000\000\000\000\000\000\000\000\000\000:\204\000\000\000\0008\188:\208\015*\000\000BP\006F\030\234\000\000\000\000\031\028\000\000\000\000\012\184\031<\r<\000\000\012\190\012\198\002\016\002\208\012\200\t&\012\214\015|0\214\r\\\000\000\r\016\r2\tf\000\000\004*\002\026\006\026\001\152\001\252\001U\001'\000\193\000\140\001A\0053\001\208\006\028\001\149\001\t\002e\004\236\002k\000m\006\019\001\016\001\029\001<\002q\001x\001}\002g\001\253\006\029\000\189\005\028\004o\000\193\000\251\004\238\001g\001m\001\016\000\193\001V\001\024\004\232\001\024\001\025\000\196\001\025\002s\003\001\001\239\004\215\000\193\000\251\001w\006\020\004<\001\024\004\234\002b\005\029\005]\005\030\006\021\000\196\001\253\001\156\001\196\001\168\001\027\002\017\001\027\002d\000\193\001]\001^\003\197\0039\004\235\001\252\000\193\000\251\000\193\001\t\0069\003\018\000\196\006+\005?\001\016\001\019\005\031\004E\001\t\001_\002\185\001z\001a\001b\001\016\001\029\004\215\006%\000\196\001{\002\244\001}\001e\003\213\002\244\005\247\006\024\001#\003J\001#\001n\006\026\002\244\002\244\004\152\004\001\001\191\003\227\001\192\005 \005\249\006\028\001\179\006\150\002e\001\223\002k\001\173\005!\001\227\005\"\001\016\002q\001\253\001}\002g\001\t\006\029\001\t\002\r\002\014\001^\001\016\001\029\001\016\001\029\005\250\0007\006\136\002\244\001\024\001\t\004\t\005^\002Q\002s\001\181\001\016\001\029\004\002\006~\003\195\002R\001f\006\145\003\240\003\242\004\246\006J\001\228\001\024\0048\000\196\001\025\001g\002`\005$\000\193\001\178\004=\006s\005&\0050\001\229\000\196\005F\005G\0017\001\188\0017\001\024\005Z\005<\004\001\001\030\002\244\001\030\001\027\005_\002\b\005H\005X\002\r\002\014\001^\005P\004\001\005[\003k\001\030\006`\002\244\004\217\001\184\005?\000\193\006\180\002Q\000\196\006a\002\244\001'\002\011\001'\001A\002R\001A\003n\000m\004w\002\025\003\140\004\215\001z\002b\001\016\006|\001\230\002`\001\024\001#\001\150\001\025\001}\001e\002\017\001\201\002d\000\193\001\t\000\196\002(\002\244\001\239\005B\001\016\001\029\002\r\002\014\001^\002+\000\196\004U\001\203\0021\005\193\001\027\002F\000\193\001\t\005{\002K\002Q\001\239\001\024\001\016\001\029\002h\004a\003\205\002R\001@\001\252\005?\000\196\000\193\006\222\004d\001\219\001\t\001\226\000m\000\196\002`\003\188\001\016\001\029\002b\001\024\003\209\003\184\001\025\001\252\002\244\002e\000\193\002k\001\030\002\017\001#\002d\000\193\002q\000\196\001}\002g\005F\005G\005\185\004l\0017\002\163\000\196\006\152\001\239\001\027\000\196\001\030\003\196\000\196\006\224\005H\005X\000\196\001\031\002s\005P\004\001\001\t\002\007\002h\001\253\005?\005\217\001\016\001\029\000\193\001\030\003\202\001\191\004#\001\221\002b\001\252\001'\003\217\000\193\001A\001\223\003\234\002\244\001\253\001\227\002\017\001\016\002d\000\193\002e\001#\002k\004p\005\127\003\236\001\t\001)\002q\003\254\001}\002g\001\016\001\029\001\024\006\166\000\196\001\025\005F\005G\006Z\004\001\0017\000\196\002\n\004\003\001\024\004\"\002h\001\030\001\t\002s\002\024\005H\005X\001\228\001\016\001\029\005P\004\001\004(\001\027\004/\000\196\002'\001\253\002\r\002\014\001^\001\229\000\196\002*\0020\002<\000\196\002e\001'\002k\005?\001A\004x\002Q\0045\002q\001\030\001}\002g\000\196\0029\002R\001\191\000\196\001\247\002\244\004H\006O\004M\005F\005G\001\223\004X\0017\002`\001\227\001#\001\016\002s\000\196\001\030\000\196\002\244\003h\005H\005X\002\r\002\014\001^\005P\004\001\002\r\002\014\001^\000\196\000\189\000\196\004`\000\193\000\194\004c\002Q\002A\004j\004n\001\t\002Q\001'\004s\002R\001A\001\016\001\029\001\239\002R\001\228\000\196\001\t\004\127\006=\004\014\002@\002`\001\016\001\029\004\146\005\203\002`\000\196\001\229\000\196\002E\004\137\002b\000\196\002\r\002\014\001^\002J\004I\002\247\002p\001\252\002\167\002\017\000\193\002d\000\193\004\151\004\141\002Q\002\202\005F\005G\005\205\004\156\0017\002\209\002R\000\196\002\244\004\166\000\196\001\030\004\b\000\196\000\196\006\148\006\149\005\206\000\196\002`\005P\004\001\005\208\001\030\002h\002\238\005\219\002\244\000\196\002b\002\244\002\r\002\014\001^\002b\000\196\004\172\001\239\001'\003]\002\017\001A\002d\000\193\003e\002\017\002Q\002d\000\193\001\253\003\245\002e\002\244\002k\002R\001\191\004\183\002\029\000\196\002q\003\194\001}\002g\006D\001\223\000\196\001\252\002`\001\227\000\193\001\016\000\196\002h\003\154\004\198\004\195\003\164\002h\002b\003\186\004\216\004\202\002s\004\223\001\024\004\240\003\201\005\001\003\203\002\017\004\250\002d\000\193\005\019\004\228\002\244\002\244\004\233\000\196\002e\003\216\003\007\003\253\005(\002e\004\005\002k\002q\001\228\001}\002g\001\027\002q\002\244\001}\002g\004.\002\244\000\196\005\017\004'\002h\001\229\006\014\0052\001\253\002b\002\244\004)\004,\002s\002\r\002\014\001^\004;\002s\000\196\002\017\007\r\002d\000\193\007\014\000\196\000\196\006\017\000\196\002Q\000\196\002e\005>\002k\005R\000\196\006\018\002R\000\196\002q\005b\001}\002g\001\024\0041\005\025\005%\003\191\000\196\005h\002`\005l\002h\004:\005\136\002\r\002\014\001^\002\244\002\r\002\014\001^\002s\005-\002\244\006\019\001\t\005D\005\176\000\196\002Q\005\236\001\016\001\029\002Q\005\181\005\220\005u\002R\002e\002\244\002k\002R\005\186\003\177\0046\002\244\002q\003\129\001}\002g\002`\0049\004G\000\196\002`\000\196\000\189\004L\006\020\000\193\000\194\000\196\002\r\002\014\001^\001\191\006\021\003\207\002b\002s\000\196\005\216\000\196\004T\001\223\000\196\002\244\002Q\001\227\002\017\001\016\002d\000\193\001\030\005\152\002R\007\016\005\203\005\192\000\196\005\178\003|\000\196\002\244\004S\004W\000\196\000\196\002`\005\200\005\241\001\t\006\006\006C\000\196\006\023\005\189\001\016\001\029\002b\001'\002h\005\223\002b\006\024\005\205\004b\002\244\001\228\006\026\002\017\002\244\002d\000\193\002\017\002\244\002d\000\193\002\244\006\028\005\206\002\244\001\229\000\196\002\244\005\208\004m\006]\002e\005\237\003\007\004i\004r\005\235\002\244\006\029\002q\004\134\001}\002g\000\196\006i\002h\006w\001]\001^\002h\002b\002\244\001\030\005\239\000\196\000\196\004z\000\196\000\196\006y\002\244\002\017\002s\002d\000\193\004\133\002\244\001_\001o\004\128\001a\001b\002e\002\244\002k\004\132\002e\005\243\002k\003\251\002q\005\248\001}\002g\002q\006\004\001}\002g\006\011\002\244\003x\006\025\000\196\002h\006 \002\244\002\r\002\014\001^\004\145\002\r\002\014\001^\002s\006)\004\150\000\196\002s\000\196\004\249\001p\002Q\001q\002-\004\155\002Q\004\158\004\162\006n\002R\002e\000\196\002k\002R\004\170\003q\004\177\006\154\002q\003b\001}\002g\002`\006\168\004\188\004\248\002`\004\241\004\242\004\247\007\007\001x\002\r\002\014\001^\004\251\002\r\002\014\001^\004\252\005\027\002s\001g\005\020\005\021\000\193\007\018\002Q\005\026\005/\005+\002Q\007\023\003{\005,\002R\005.\005Y\005=\002R\000\189\003Z\005A\000\193\000\194\001\191\005C\004\022\002`\003R\005E\005Q\002`\005a\001\223\005c\005d\005i\001\227\005m\001\016\002b\001]\001^\005q\002b\005\131\005\138\005\142\005\166\005\187\005\203\002\017\005\211\002d\000\193\002\017\005\221\002d\000\193\006\r\001z\001_\001`\006\007\001a\001b\006\b\006\012\001{\006\027\001}\001e\006B\006M\006X\006l\006m\001\228\005\205\006q\006\153\006\157\006\167\002h\006\171\005\028\002b\002h\006\249\000\000\002b\001\229\000\000\005\206\002\r\002\014\001^\002\017\005\208\002d\000\193\002\017\006\000\002d\000\193\000\000\000\000\000\000\000\000\002Q\002e\000\000\002k\005\029\002e\005\030\002k\002R\002q\000\000\001}\002g\002q\002]\001}\002g\000\000\000\000\000\000\002h\002`\000\000\000\000\002h\000\000\001f\002\r\002\014\001^\000\000\000\000\002s\000\000\000\000\005\031\002s\001g\000\000\000\000\000\193\000\000\002Q\000\000\000\000\000\000\000\000\002e\000\000\002k\002R\002e\000\000\003\007\000\000\002q\002j\001}\002g\002q\000\000\001}\002g\002`\000\000\000\000\000\000\000\000\005 \002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\005!\002s\005\"\002b\000\000\002s\000\000\002Q\000\000\001\191\000\000\004\026\002Q\000\000\002\017\002R\002d\000\193\001\223\001z\002R\002y\001\227\000\000\001\016\005\\\002x\001\150\002`\001}\001e\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002b\002h\000\000\005$\000\000\000\000\000\000\000\000\005&\0050\000\000\002\017\002Q\002d\000\193\000\000\000\000\001\228\005Z\000\000\002R\000\000\000\000\000\000\000\000\000\000\002\172\000\000\002e\000\000\002k\001\229\000\000\002`\005[\000\000\002q\000\000\001}\002g\000\000\000\000\002b\002h\000\000\000\000\000\000\002b\000\000\000\000\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\002\017\002s\002d\000\193\001\191\000\000\004\029\002Q\000\000\000\000\000\000\000\000\002e\001\223\002k\002R\000\000\001\227\000\000\001\016\002q\002\183\001}\002g\000\000\000\000\000\000\002h\002`\000\000\000\000\000\000\002h\000\000\002b\000\000\000\000\002\r\002\014\001^\001\191\000\000\004+\002s\000\000\002\017\000\000\002d\000\193\001\223\000\000\000\000\002Q\001\227\002e\001\016\002k\001\228\000\000\002e\002R\002k\002q\000\000\001}\002g\002\206\002q\000\000\001}\002g\001\229\000\000\002`\002\r\002\014\001^\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\002b\000\000\000\000\002s\000\000\000\000\001\228\000\000\000\000\000\000\003M\002\017\000\000\002d\000\193\001\024\000\000\002e\005\b\002k\001\229\002\r\002\014\001^\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\003N\000\000\002Q\000\000\000\000\002\r\002\014\001^\001\027\002h\002R\002b\000\000\000\000\002s\000\000\002\213\001\191\000\000\004|\002Q\000\000\002\017\002`\002d\000\193\001\223\000\000\002R\000\000\001\227\000\000\001\016\000\000\002\216\000\000\002e\000\000\002k\006\014\000\000\002`\000\000\000\000\002q\000\000\001}\002g\002\016\002\r\002\014\001^\000\000\000\000\002h\000\000\000\000\006\015\000\000\002\017\006\017\002d\000\193\000\000\002Q\000\000\000\000\002s\000\000\006\018\001\228\000\000\002R\000\000\000\000\000\000\000\000\000\000\002\222\000\000\001\t\002e\002b\002k\001\229\002`\001\016\001\029\000\000\002q\000\000\001}\002g\002\017\003P\002d\000\193\000\000\006\019\000\000\002b\002\r\002\014\001^\000\000\000\000\001\191\000\000\004\130\000\000\000\000\002\017\002s\002d\000\193\001\223\002Q\000\000\002e\001\227\000\000\001\016\000\000\000\000\002R\002h\002f\000\000\001}\002g\002\225\000\000\006\020\000\000\000\000\000\000\000\000\002`\001\030\000\000\006\021\000\000\000\000\002h\002b\000\000\002\r\002\014\001^\000\000\000\000\000\000\002e\000\000\002k\002\017\000\000\002d\000\193\001\228\002q\002Q\001}\002g\006\022\001'\000\000\000\000\000\000\002R\002e\000\000\002k\001\229\000\000\002\250\000\000\000\000\002q\006\023\001}\002g\002`\002s\000\000\000\000\000\000\002h\006\024\000\000\002\r\002\014\001^\006\026\000\000\000\000\002b\002\r\002\014\001^\000\000\002s\000\000\006\028\000\000\002Q\000\000\002\017\000\000\002d\000\193\000\000\002Q\002R\002e\000\000\002k\000\000\000\000\006\029\002R\000\000\002q\003\004\001}\002g\002`\000\000\000\000\000\000\003\t\000\000\000\000\002`\000\000\002\r\002\014\001^\000\000\002h\000\000\002b\002\r\002\014\001^\002s\000\000\001\191\000\000\004\139\000\000\000\000\002\017\000\000\002d\000\193\001\223\002Q\003M\000\000\001\227\000\000\001\016\000\000\000\000\002R\002e\000\000\002k\000\000\000\000\000\000\000\000\000\000\002q\003\011\001}\002g\002`\000\000\000\000\000\000\005\207\000\000\002h\002b\000\000\000\000\000\000\000\000\000\000\000\000\002b\002\r\002\014\001^\002\017\002s\002d\000\193\001\228\000\000\000\000\002\017\000\000\002d\000\193\000\000\002Q\000\000\000\000\002e\000\000\002k\001\229\000\000\002R\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\003\015\000\000\002h\002`\002\016\000\000\000\000\000\000\000\000\002h\000\000\002b\002\r\002\014\001^\002\017\002s\002d\000\193\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\002Q\000\000\002e\000\000\003\007\000\000\000\000\002Q\002R\002e\002q\003\007\001}\002g\000\000\002R\000\000\002q\003\023\001}\002g\002`\000\000\003P\000\000\003\029\000\000\002h\002`\000\000\000\000\000\000\000\000\002s\000\000\002b\002\r\002\014\001^\000\000\002s\000\000\000\000\000\000\000\000\000\000\002\017\002e\002d\000\193\000\000\002Q\000\000\000\000\002e\002f\003\007\001}\002g\002R\000\000\001\191\002q\004\147\001}\002g\000\000\000\000\000\000\003#\001\223\000\000\002`\000\000\001\227\000\000\001\016\000\000\002h\000\000\002b\002\r\002\014\001^\000\000\002s\000\000\002b\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002Q\000\000\002\017\000\000\002d\000\193\000\000\000\000\002R\002e\000\000\003\007\000\000\000\000\003+\000\000\000\000\002q\001\228\001}\002g\002`\000\000\000\000\002\r\002\014\001^\002h\000\000\000\000\000\000\000\000\001\229\000\000\002h\002b\000\000\000\000\000\000\002Q\002s\000\000\000\000\000\000\000\000\000\000\002\017\002R\002d\000\193\000\000\000\000\000\000\0030\002e\000\000\003\007\000\000\000\000\000\000\002`\002e\002q\003\007\001}\002g\000\000\000\000\000\000\002q\000\000\001}\002g\001\191\000\000\006H\000\000\000\000\002h\000\000\002b\000\000\001\223\000\000\000\000\002s\001\227\000\000\001\016\000\000\000\000\002\017\002s\002d\000\193\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\003'\000\000\000\000\002Q\000\000\000\000\002q\000\000\001}\002g\000\000\002R\002b\002\r\002\014\001^\002h\000\000\000\000\001\228\000\000\003<\000\000\002\017\002`\002d\000\193\000\000\002Q\002s\000\000\000\000\000\000\001\229\000\000\000\000\002R\002\r\002\014\001^\000\000\000\000\000\000\002e\000\000\002k\003A\000\000\000\000\002`\000\000\002q\002Q\001}\002g\002h\000\000\000\000\000\000\000\000\002R\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\002`\002s\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002e\002b\002k\002R\000\000\002\r\002\014\001^\002q\000\000\001}\002g\002\017\003U\002d\000\193\002`\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002b\000\000\002R\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\002\017\003X\002d\000\193\002`\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\002b\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002Q\000\000\000\000\002h\002Q\002e\000\000\003\007\002R\002b\000\000\000\000\002R\002q\003^\001}\002g\000\000\003`\000\000\002\017\002`\002d\000\193\000\000\002`\000\000\002h\000\000\000\000\002e\000\000\003\007\000\000\002b\000\000\002s\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\002h\000\000\002e\000\000\003\007\000\000\000\000\000\000\000\000\002s\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002h\000\000\002e\002b\003\007\000\000\000\000\002b\002s\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002\017\000\000\002d\000\193\000\000\000\000\002\r\002\014\001^\002e\000\000\003'\000\000\000\000\000\000\002s\000\000\002q\000\000\001}\002g\002Q\002\r\002\014\001^\000\000\000\000\000\000\002h\002R\000\000\000\000\002h\000\000\000\000\003j\000\000\002Q\000\000\000\000\002s\000\000\002`\000\000\000\000\002R\000\000\000\000\002\r\002\014\001^\003s\000\000\000\000\000\000\002e\000\000\002k\002`\002e\000\000\002k\000\000\002q\000\000\001}\002g\002q\000\000\001}\002g\003\175\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\000\000\002s\000\000\000\000\000\000\002s\000\000\002Q\000\000\000\000\000\000\000\000\002Q\000\000\000\000\002R\002b\000\000\000\000\000\000\002R\003v\000\000\000\000\000\000\000\000\003\132\002\017\002`\002d\000\193\000\000\002b\002`\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002\016\002h\002R\000\000\000\000\000\000\000\000\000\000\003\135\000\000\000\000\002\017\000\000\002d\000\193\002`\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002b\002k\000\000\000\000\000\000\002b\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002e\002\017\002k\002d\000\193\000\000\000\000\000\000\002q\000\000\001}\002g\002\r\002\014\001^\002s\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\002e\002Q\002h\000\000\002b\002s\002Q\002h\002f\002R\001}\002g\000\000\000\000\002R\002\017\000\000\002d\000\193\003\145\000\000\000\000\002`\000\000\003\150\000\000\000\000\002`\000\000\002e\000\000\002k\000\000\000\000\002e\000\000\002k\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002k\000\000\000\000\000\000\006\014\002b\002q\000\000\001}\002g\002b\000\000\000\000\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\002\017\006\015\002d\000\193\006\017\000\000\000\000\002Q\002s\000\000\002\r\002\014\001^\006\018\000\000\002R\000\000\000\000\000\000\000\000\000\000\003\199\000\000\000\000\000\000\002Q\000\000\002h\002`\000\000\000\000\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\003\212\000\000\000\000\006\019\002\r\002\014\001^\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\003\007\000\000\002Q\002e\000\000\003\007\002q\000\000\001}\002g\002R\002q\000\000\001}\002g\000\000\004\000\000\000\000\000\000\000\006\020\000\000\000\000\002`\000\000\000\000\000\000\000\000\006\021\002s\000\000\002b\000\000\000\000\002s\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\002b\000\000\002Q\006!\000\000\000\000\000\000\000\000\000\000\000\000\002R\002\017\000\000\002d\000\193\000\000\004C\000\000\006\023\000\000\000\000\000\000\000\000\002`\000\000\002h\000\000\006\024\000\000\000\000\000\000\000\000\006\026\002b\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\006\028\002h\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\002e\002Q\002k\000\000\000\000\000\000\006\029\000\000\002q\002R\001}\002g\001]\001^\000\000\005p\000\000\000\000\002e\000\000\002k\000\000\002`\000\000\002h\000\000\002q\000\000\001}\002g\002b\002s\001_\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\002s\000\000\002e\000\000\002k\000\000\004\016\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\001\024\000\000\000\000\005\005\000\000\000\000\000\000\002h\000\000\001p\000\000\001q\002-\000\000\000\000\002b\002s\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\001\027\002d\000\193\000\000\000\000\000\000\000\000\002e\002Q\002k\002\r\002\014\001^\001x\000\000\002q\002R\001}\002g\000\000\000\000\000\000\005s\000\000\001g\002Q\000\000\000\193\000\000\002`\000\000\002h\000\000\002R\000\000\003{\000\000\000\000\002s\005\130\000\000\000\000\000\000\005\007\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\002e\000\000\002k\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\001\016\005\n\000\000\000\000\000\000\001z\000\000\002\r\002\014\001^\002b\002s\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\002\017\002Q\002d\000\193\000\000\000\000\002b\000\000\000\000\002R\002\r\002\014\001^\000\000\000\000\005\133\000\000\002\017\000\000\002d\000\193\000\000\002`\000\000\000\000\002Q\000\000\002\r\002\014\001^\000\000\005\011\002h\002R\000\000\000\000\000\000\000\000\000\000\005\146\000\000\001\024\002Q\004\213\001\025\005\016\002`\005\r\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\005\149\000\000\001'\002e\000\000\002k\000\000\002`\000\000\000\000\000\000\002q\001\027\001}\002g\000\000\000\000\000\000\000\000\000\000\002e\000\000\002k\000\000\000\000\002b\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\002s\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002b\000\000\002s\000\000\000\000\000\000\001#\000\000\000\000\000\000\000\000\002\017\002Q\002d\000\193\000\000\000\000\002b\000\000\002h\002R\000\000\002\r\002\014\001^\000\000\005\170\000\000\002\017\000\000\002d\000\193\000\000\002`\000\000\001\t\000\000\002Q\002\r\002\014\001^\001\016\001\029\002h\000\000\002R\002e\000\000\002k\000\000\000\000\005\173\000\000\002Q\002q\000\000\001}\002g\002`\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\005\177\000\000\000\000\002e\000\000\002k\000\000\002`\000\000\000\000\002s\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\0017\002e\000\000\002k\000\000\006\014\002b\001\030\000\000\002q\000\000\001}\002g\000\000\000\000\002s\000\000\002\017\000\000\002d\000\193\000\000\000\000\006\015\000\000\000\000\006\017\000\000\000\000\000\000\000\000\002b\002s\000\000\001'\006\018\000\000\0018\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002b\000\000\002h\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\006\019\000\000\000\000\002Q\000\000\000\000\000\000\001]\001^\000\000\002h\002R\002e\000\000\002k\000\000\000\000\006\184\000\000\000\000\002q\000\000\001}\002g\002`\000\000\002h\001_\001o\000\000\001a\001b\000\000\000\000\006\020\000\000\000\000\002e\000\000\002k\000\000\000\000\006\021\002s\000\000\002q\000\000\001}\002g\000\000\006R\000\000\000\000\002e\000\000\002k\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\006*\000\000\002s\000\000\001p\000\000\001q\002-\000\000\000\000\000\000\002\r\002\014\001^\000\000\006\023\000\000\002b\002s\000\000\000\000\000\000\000\000\000\000\006\024\000\000\002Q\000\000\002\017\006\026\002d\000\193\000\000\000\000\002R\001x\002\r\002\014\001^\006\028\006\186\000\000\000\000\000\000\000\000\000\000\001g\002`\000\000\000\193\000\000\002Q\002\r\002\014\001^\006\029\000\000\003{\000\000\002R\002h\000\000\001]\001^\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002`\000\000\000\000\002R\001\024\000\000\000\000\005\005\000\000\000\000\001_\001o\000\000\001a\001b\002e\002`\002k\000\000\000\000\001\159\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\001\027\000\000\001z\002b\000\000\000\000\000\000\000\000\000\000\000\000\001{\000\000\001}\001e\002\017\002s\002d\000\193\000\000\000\000\000\000\000\000\001p\000\000\001q\001\146\000\000\000\000\002b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\005\007\002b\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\001x\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\002h\001\t\002e\000\000\002k\000\000\000\000\001\016\005\n\000\000\002q\000\000\001}\002g\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\004\017\000\000\000\000\000\000\002s\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\002e\000\000\004\r\001]\001^\000\000\000\000\000\000\002q\001z\001}\002g\000\000\000\000\000\000\002s\005\011\001{\000\000\001}\001e\001]\001^\001_\001o\000\000\001a\001b\004\213\000\000\005\015\002s\005\r\001\143\000\000\002\r\002\014\001^\000\000\000\000\000\000\001_\001o\001'\001a\001b\000\000\000\000\000\000\000\000\002Q\001\148\000\000\001]\001^\000\000\000\000\000\000\002R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001p\000\000\001q\001\146\000\000\002`\000\000\001_\001o\000\000\001a\001b\000\000\000\000\000\000\002\r\002\014\001^\001p\000\000\001q\001\146\000\000\001]\001^\000\000\000\000\000\000\000\000\000\000\002Q\001x\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\000\001g\001_\001o\000\193\001a\001b\000\000\001x\001p\002`\001q\002-\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\002b\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\001x\000\000\002Q\000\000\000\000\001p\000\000\001q\0025\000\000\002R\001g\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\000\001z\000\000\003w\002`\000\000\000\000\002h\000\000\001{\002b\001}\001e\000\000\000\000\000\000\000\000\001x\000\000\001z\000\000\002\017\000\000\002d\000\193\000\000\000\000\001{\001g\001}\001e\000\193\000\000\000\000\002e\000\000\003\183\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\001z\000\000\002h\000\000\000\000\000\000\000\000\0028\001{\000\000\001}\001e\002b\000\000\002s\002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\000\000\002e\002Q\003Q\000\000\000\000\000\000\002Q\001z\002q\002R\001}\002g\000\000\000\000\002R\001{\000\000\001}\001e\000\000\000\000\000\000\002`\000\000\000\000\000\000\002h\002`\000\000\000\000\000\000\002s\000\000\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\002Q\002e\000\000\002\248\002R\000\000\000\000\000\000\002R\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\002s\000\000\002b\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002h\000\000\000\000\002Q\002b\002h\000\000\002R\002b\000\000\000\000\002R\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\017\002`\002d\000\193\000\000\002`\000\000\000\000\002e\000\000\002m\000\000\000\000\002e\000\000\002o\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\002h\000\000\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002t\000\000\002e\002b\002{\000\000\002q\002b\001}\002g\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002\017\000\000\002d\000\193\002\r\002\014\001^\000\000\002\r\002\014\001^\002s\000\000\000\000\000\000\002s\000\000\000\000\000\000\002Q\002\r\002\014\001^\002Q\000\000\000\000\000\000\002R\002h\000\000\000\000\002R\002h\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002`\000\000\000\000\002R\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002`\002}\000\000\002e\000\000\002\127\000\000\002q\000\000\001}\002g\002q\000\000\001}\002g\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\r\002\014\001^\002s\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002b\000\000\000\000\000\000\002b\000\000\000\000\002R\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\017\002b\002d\000\193\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\002h\000\000\000\000\002Q\002h\000\000\000\000\002Q\000\000\000\000\000\000\002R\000\000\000\000\000\000\002R\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\002e\002`\002\129\000\000\002e\000\000\002\131\000\000\002q\002b\001}\002g\002q\000\000\001}\002g\002e\000\000\002\133\000\000\002\017\000\000\002d\000\193\002q\000\000\001}\002g\000\000\000\000\000\000\002s\000\000\000\000\000\000\002s\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\002Q\002h\000\000\000\000\002Q\002b\000\000\000\000\002R\002b\000\000\000\000\002R\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\017\002`\002d\000\193\000\000\002`\000\000\000\000\002e\000\000\002\135\002\r\002\014\001^\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\001\024\000\000\000\000\001\025\002Q\000\000\002h\000\000\000\000\000\000\002h\000\000\002R\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\001\027\000\000\006\133\000\000\000\000\000\000\002e\000\000\002\137\000\000\002e\002b\002\139\000\000\002q\002b\001}\002g\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002\017\000\000\002d\000\193\000\000\000\000\000\000\002\r\002\014\001^\000\000\002s\002\r\002\014\001^\002s\000\000\001#\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002Q\002h\000\000\002R\002b\002h\000\000\000\000\002R\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002`\002d\000\193\001\t\000\000\002`\000\000\000\000\000\000\001\016\001\029\000\000\002e\000\000\002\141\000\000\002e\000\000\002\143\000\000\002q\000\000\001}\002g\002q\000\000\001}\002g\000\000\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002s\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\0017\002Q\000\000\000\000\002e\002b\002\145\001\030\000\000\002R\002b\006\140\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\002\017\002`\002d\000\193\000\000\002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\001'\002s\000\000\001A\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002Q\000\000\002h\002R\000\000\000\000\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002\147\000\000\000\000\002e\002b\002\149\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\002s\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\002b\000\000\000\000\002h\002R\002b\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002\017\002`\002d\000\193\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002\151\000\000\000\000\000\000\002Q\000\000\002q\000\000\001}\002g\000\000\002h\002R\000\000\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002\153\000\000\000\000\002e\002b\002\155\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\002s\002Q\000\000\000\000\000\000\002\164\001^\000\000\000\000\002R\002b\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002`\002d\000\193\002\218\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\002e\000\000\002\157\000\000\000\000\000\000\002\181\000\000\002q\000\000\001}\002g\000\000\002h\002\184\001]\001^\001_\002\185\000\000\001a\001b\000\000\000\000\002\181\000\000\000\000\002\223\002\239\002\240\000\000\002s\002\184\000\000\000\000\001_\002\185\000\000\001a\001b\002e\002b\002\159\002\r\002\014\001^\000\000\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\006\014\002Q\001x\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\000\001g\002s\007\r\000\193\000\000\007\014\000\000\000\000\006\017\002`\000\000\000\000\000\000\000\000\002h\000\000\000\000\006\018\000\000\000\000\000\000\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\002\243\000\000\000\193\000\000\000\000\000\000\001f\000\000\002e\000\000\002\161\000\000\000\000\006\019\000\000\000\000\002q\001g\001}\002g\000\193\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\002\r\002\014\001^\000\000\002\186\001{\002b\001}\001e\000\000\002s\001\024\000\000\000\000\005\005\002Q\000\000\002\017\006\020\002d\000\193\000\000\002\186\002R\002\188\000\000\006\021\000\000\000\000\001z\000\000\000\000\000\000\002\r\002\014\001^\002`\001\150\001\027\001}\001e\000\000\002\187\000\000\000\000\000\000\007\015\001z\002Q\002h\000\000\000\000\002\r\002\014\001^\001\150\002R\001}\001e\000\000\000\000\000\000\000\000\000\000\000\000\006\023\000\000\002Q\000\000\002`\000\000\000\000\000\000\000\000\006\024\002R\002e\000\000\002\254\006\026\000\000\005\007\000\000\000\000\002q\000\000\001}\002g\002`\006\028\000\000\000\000\000\000\000\000\000\000\002b\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\006\029\002\017\002s\002d\000\193\001\t\002Q\002\r\002\014\001^\000\000\001\016\005\n\000\000\002R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002b\000\000\000\000\000\000\002`\000\000\000\000\002R\000\000\000\000\002h\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\002b\002`\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\002e\002Q\003\027\005\011\000\000\000\000\002h\000\000\002q\002R\001}\002g\000\000\000\000\000\000\004\213\000\000\005\014\000\000\005\r\000\000\000\000\002`\000\000\000\000\002h\002b\000\000\000\000\000\000\001'\002s\000\000\002e\000\000\003!\000\000\002\017\005\028\002d\000\193\002q\002b\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002\017\003&\002d\000\193\002\r\002\014\001^\002q\000\000\001}\002g\002s\000\000\005\029\006\192\005\030\002h\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002R\002b\000\000\002s\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002`\002d\000\193\002e\005\031\003.\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\002e\000\000\0033\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\002h\000\000\000\000\002s\000\000\000\000\005 \002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\005!\000\000\005\"\000\000\002s\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002e\002b\0035\002R\002\r\002\014\001^\000\000\002q\000\000\001}\002g\002\017\005^\002d\000\193\002`\000\000\000\000\002Q\002\r\002\014\001^\000\000\000\000\001\024\000\000\002R\001\025\000\000\000\000\002s\002\r\002\014\001^\002Q\005$\006\194\001]\001^\002`\005&\0050\002R\002h\000\000\000\000\002Q\000\000\000\000\000\000\005Z\001\027\000\000\000\000\002R\002`\000\000\001_\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\005[\002`\000\000\000\000\002e\000\000\0038\000\000\002b\000\000\000\000\000\000\002q\000\000\001}\002g\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\000\000\000\000\006\014\000\000\001#\000\000\000\000\002Q\002b\000\000\001p\002s\001q\002-\000\000\002R\000\000\007\r\000\000\002\017\007\014\002d\000\193\006\017\002b\000\000\000\000\002h\002`\000\000\000\000\000\000\006\018\001\t\000\000\002\017\002b\002d\000\193\001\016\001\029\001x\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\002h\001g\000\000\002e\000\193\003?\000\000\000\000\000\000\000\000\006\019\002q\003z\001}\002g\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002h\003D\000\000\000\000\000\000\006\132\002s\002q\002b\001}\002g\000\000\001\030\000\000\000\000\002e\006\020\003I\000\000\002\017\000\000\002d\000\193\002q\006\021\001}\002g\002e\000\000\003L\002s\000\000\001z\002\164\001^\002q\000\000\001}\002g\001'\001{\000\000\001}\001e\007\019\000\000\002s\002\r\002\014\001^\000\000\002h\000\000\002\218\001o\000\000\001a\001b\002s\000\000\000\000\000\000\002Q\006\023\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\006\024\000\000\000\000\000\000\000\000\006\026\002e\000\000\003~\002\164\001^\002`\000\000\000\000\002q\006\028\001}\002g\000\000\000\000\000\000\000\000\000\000\002\223\002\239\002\240\002\164\001^\000\000\002\218\001o\006\029\001a\001b\000\000\000\000\000\000\002s\002\164\001^\000\000\000\000\000\000\000\000\001]\001^\002\218\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\001x\000\000\000\000\002\218\001o\000\000\001a\001b\000\000\001_\001o\001g\001a\001b\000\193\002b\002\223\002\239\002\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\r\002\014\001^\002\223\002\239\002\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\137\002\223\002\239\002\240\001x\000\000\000\000\000\000\001p\002\015\001q\006\238\000\000\006\240\002h\001g\000\000\000\000\000\193\000\000\000\000\001x\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\000\000\000\000\001g\001x\001{\000\193\001}\001e\000\000\001x\000\000\002e\000\000\003\128\001g\000\000\000\000\000\193\004\006\002q\001g\001}\002g\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\188\001]\001^\000\000\000\000\000\000\000\000\002s\000\000\001z\000\000\000\000\005\222\000\000\000\000\000\000\002\016\001{\000\000\001}\001e\001_\001o\000\000\001a\001b\001z\002\017\000\000\002d\000\193\000\000\000\000\000\000\001{\000\000\001}\001e\001z\000\000\000\000\000\000\000\000\000\000\001z\000\000\001{\001\024\001}\001e\001\025\000\000\001{\001+\001}\001e\001\024\000\000\000\000\001\025\000\000\000\000\001+\000\000\001p\000\000\001q\0063\000\000\000\000\000\000\000\000\000\000\001,\001\027\000\000\000\000\000\000\000\000\000\000\001-\000\000\001,\001\027\001]\001^\002e\000\000\000\000\001F\000\000\001]\001^\000\000\002f\001x\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\001_\001o\001g\001a\001b\000\193\000\000\001_\001o\000\000\001a\001b\000\000\001#\001]\001^\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\0011\000\000\000\000\000\000\001_\001o\000\000\001a\001b\0011\000\000\000\000\001\t\001p\000\000\001q\001\151\000\000\001\016\001\029\001p\001\t\001q\001\129\000\000\000\000\000\000\001\016\001\029\000\000\000\000\001z\000\000\001]\001^\000\000\000\000\000\000\000\000\001{\000\000\001}\001e\000\000\001x\000\000\000\000\001p\000\000\001q\001~\001x\000\000\001_\001o\001g\001a\001b\000\193\000\000\000\000\000\000\001g\0017\000\000\000\193\000\000\000\000\000\000\000\000\001\030\000\000\0017\000\000\001?\000\000\000\000\000\000\001x\001\030\000\000\001]\001^\001?\000\000\000\000\000\000\001]\001^\001g\000\000\000\000\000\193\000\000\000\000\000\000\001p\001'\001q\001s\001A\001_\001o\000\000\001a\001b\001'\001_\001o\001A\001a\001b\000\000\000\000\001z\000\000\000\000\000\000\000\000\001]\001^\001z\001{\000\000\001}\001e\000\000\001x\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\001g\001_\001o\000\193\001a\001b\001p\000\000\001q\001v\001z\000\000\001p\000\000\001q\001y\000\000\000\000\001{\000\000\001}\001e\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\001x\000\000\000\000\000\000\000\000\000\000\001x\001p\000\000\001q\001|\001g\000\000\000\000\000\193\001_\001o\001g\001a\001b\000\193\000\000\001z\000\000\000\000\000\000\000\000\001]\001^\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\001x\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\001_\001o\001g\001a\001b\000\193\000\000\000\000\000\000\000\000\000\000\001p\000\000\001q\001\134\000\000\000\000\001_\001o\000\000\001a\001b\000\000\001z\000\000\000\000\000\000\001]\001^\001z\000\000\001{\000\000\001}\001e\000\000\002\214\001{\000\000\001}\001e\000\000\001x\001p\002\217\001q\001\137\001_\002\185\000\000\001a\001b\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\001p\001z\001q\002G\000\000\000\000\000\000\000\000\000\000\001{\000\000\001}\001e\000\000\001x\000\000\001]\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\000\000\001x\000\000\000\000\000\000\000\000\001_\001o\000\000\001a\001b\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\000\000\001]\001^\001z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001{\001f\001}\001e\000\000\000\000\000\000\001]\001^\000\000\001_\001o\001g\001a\001b\000\193\000\000\000\000\000\000\001p\000\000\001q\002\228\000\000\001z\000\000\000\000\001_\001o\000\000\001a\001b\001{\000\000\001}\001e\000\000\000\000\000\000\001]\001^\001z\000\000\000\000\000\000\000\000\002\186\000\000\000\000\001{\001x\001}\001e\001p\000\000\001q\002\231\000\000\000\000\001_\001o\001g\001a\001b\000\193\000\000\002\r\002\014\001^\000\000\001p\001z\001q\002\234\000\000\000\000\000\000\000\000\000\000\001\150\000\000\001}\001e\000\000\001x\000\000\001]\001^\000\000\002L\001\024\000\000\000\000\001\025\000\000\001g\001B\000\000\000\193\000\000\000\000\001x\001p\000\000\001q\002\242\001_\001o\000\000\001a\001b\000\000\001g\000\000\000\000\000\193\001D\001\027\000\000\000\000\001z\000\000\004\206\000\000\000\000\000\000\000\000\000\000\001{\001\024\001}\001e\001\025\001x\000\000\001B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\001p\000\000\001q\004A\000\000\001z\001D\001\027\000\000\000\000\000\000\001#\002\016\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\001z\002\017\000\000\002d\000\193\000\000\0011\000\000\001{\001x\001}\001e\000\000\000\000\000\000\001]\001^\000\000\001\t\000\000\001g\000\000\000\000\000\193\001\016\001\029\000\000\001\024\001#\000\000\001\025\000\000\001z\001+\000\000\001_\002\185\000\000\001a\001b\001{\000\000\001}\001e\000\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0010\001\027\000\000\000\000\001\t\000\000\000\000\002e\001]\001^\001\016\001\029\000\000\000\000\000\000\002f\0017\001}\002g\000\000\000\000\000\000\000\000\001\030\000\000\000\000\001z\005\004\001_\002\185\000\000\001a\001b\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\000\000\001]\001^\001'\000\000\000\000\001A\000\000\0017\001f\000\000\000\000\000\000\000\000\0011\001\030\001]\001^\000\000\001?\001g\001_\002\185\000\193\001a\001b\001\t\000\000\000\000\001]\001^\000\000\001\016\001\029\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\001'\000\000\000\000\001A\005\150\000\000\000\000\001_\002\185\000\000\001a\001b\003k\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\003m\000\000\000\000\000\000\0017\000\000\001z\000\000\000\000\000\000\000\000\001\030\000\000\000\000\001\150\001?\001}\001e\000\000\000\000\000\000\000\000\001f\000\000\000\000\000\000\000\000\003k\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\001f\001'\000\000\000\000\001A\000\000\000\000\000\000\000\000\003l\000\000\001g\000\000\001f\000\193\001z\001]\001^\000\000\000\000\000\000\000\000\000\000\001\150\001g\001}\001e\000\193\000\000\000\000\003k\000\000\000\000\005\174\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\000\000\000\000\000\000\006\001\000\000\000\000\000\000\003p\000\000\000\000\000\000\001]\001^\001z\000\000\000\000\002\186\000\000\000\000\000\000\000\000\001\150\000\000\001}\001e\000\000\000\000\000\000\001z\000\000\000\000\001_\002\185\000\000\001a\001b\001\150\000\000\001}\001e\000\000\001z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\150\006\003\001}\001e\001]\001^\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\000\000\000\000\001]\001^\000\000\001f\000\000\000\000\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\001g\001_\002\185\000\193\001a\001b\001_\002\185\000\000\001a\001b\000\000\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^\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\186\000\000\005\028\001g\000\000\000\000\000\193\000\000\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\000\000\005\029\006\174\005\030\001\150\001f\001}\001e\005\201\000\000\000\000\001\024\001f\000\000\001\025\000\000\001g\001f\000\000\000\193\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\001g\000\000\000\000\000\193\005\031\001z\000\000\000\000\000\000\000\000\001\027\000\000\000\000\001\150\000\000\001}\001e\000\000\000\000\000\000\004\191\000\000\005\201\000\000\000\000\000\000\005\214\001f\000\000\006\001\000\000\000\000\000\000\000\000\006\001\005\147\001\024\005 \001g\001\025\000\000\000\193\000\000\000\000\000\000\000\000\005!\001z\005\"\000\000\000\000\000\000\000\000\001#\001z\001\150\000\000\001}\001e\001z\000\000\000\000\001\150\001\027\001}\001e\000\000\001\150\005\213\001}\001e\005^\003o\003\230\000\000\001\024\006\002\001\024\001\025\000\000\001\025\006\n\001\t\000\000\000\000\000\000\000\000\006v\001\016\001\029\000\000\000\000\000\000\000\000\005$\000\000\000\000\001z\000\000\005&\0050\006\014\001\027\000\000\001\027\001\150\001#\001}\001e\005Z\000\000\000\000\004\191\000\000\004\191\000\000\007\r\000\000\000\000\007\014\000\000\000\000\006\017\000\000\000\000\005[\000\000\005\161\000\000\005\171\000\000\006\018\000\000\0017\000\000\001\t\000\000\000\000\000\000\000\000\001\030\001\016\001\029\000\000\004\196\001#\000\000\001#\001]\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\019\000\000\002\r\002\014\001^\000\000\000\000\001'\001_\002\170\001A\001a\001b\000\000\001\t\000\000\001\t\000\000\000\000\000\000\001\016\001\029\001\016\001\029\001\024\003M\0017\001\025\000\000\000\000\000\000\000\000\000\000\001\030\006\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\021\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\001\027\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\001'\002\207\007\024\003\237\000\000\0017\000\000\0017\000\000\000\000\001\027\000\000\001\030\000\000\001\030\000\000\004\196\000\000\004\196\001\027\000\000\006\023\001f\000\000\000\000\000\000\000\000\000\000\005\028\003\230\006\024\000\000\000\000\001g\001#\006\026\000\193\002\016\000\000\001'\000\000\001'\001A\003\233\001A\006\028\000\000\000\000\002\017\000\000\002d\000\193\000\000\001#\001\024\000\000\005\029\001\025\005\030\000\000\000\000\006\029\001#\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\027\001\t\003O\000\000\000\000\005\196\005\031\001\016\001\029\000\000\001\t\001z\000\000\000\000\000\000\001\024\001\016\001\029\001\025\001\150\000\000\001}\001e\000\000\000\000\000\000\002e\001\024\000\000\000\000\001\025\000\000\000\000\0017\002f\000\000\001}\002g\000\000\005 \001\030\000\000\001\027\001#\002\178\000\000\000\000\000\000\005!\000\000\005\"\000\000\0017\000\000\001\027\000\000\000\000\000\000\000\000\001\030\000\000\0017\000\000\004\224\000\000\000\000\004\227\001'\001\030\006\014\001A\000\000\001\t\005#\000\000\000\000\000\000\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\001#\001'\007\004\000\000\001A\006\017\001\024\000\000\006\218\001\025\001'\005$\001#\003\237\006\018\000\000\005&\0050\000\000\000\000\000\000\000\000\000\000\001\027\000\000\000\000\005Z\000\000\000\000\001\t\000\000\000\000\000\000\001\027\000\000\001\016\001\029\001\024\0017\000\000\001\025\001\t\005[\006\019\000\000\001\030\000\000\001\016\001\029\004\211\000\000\000\000\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\000\000\001\027\000\000\001#\000\000\000\000\000\000\001\024\000\000\001'\001\025\000\000\001A\001#\006\020\000\000\000\000\0017\000\000\001\027\000\000\000\000\006\021\000\000\001\030\000\000\000\000\0015\004\224\0017\000\000\005\242\001\t\000\000\001\027\000\000\001\030\000\000\001\016\001\029\006\219\000\000\001\t\007\005\001#\000\000\000\000\000\000\001\016\001\029\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\006\023\001#\001'\000\000\000\000\001A\000\000\001\024\000\000\006\024\001\025\000\000\001\t\000\000\006\026\000\000\001#\001\024\001\016\001\029\001\025\000\000\0017\000\000\006\028\000\000\000\000\000\000\000\000\001\030\001\t\000\000\0017\006\179\001\027\001\024\001\016\001\029\001\025\001\030\006\029\000\000\000\000\001Q\001\027\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\002\r\002\014\001^\001'\000\000\000\000\001A\000\000\000\000\001\027\0017\000\000\000\000\001'\000\000\000\000\001A\001\030\002\r\002\014\001^\001\167\000\000\002N\001#\002\r\002\014\001^\0017\000\000\000\000\000\000\000\000\000\000\001#\001\030\000\000\000\000\000\000\000\000\000\000\002X\000\000\0017\001'\000\000\000\000\001A\002c\000\000\001\030\000\000\001#\001\t\001\205\002\r\002\014\001^\000\000\001\016\001\029\000\000\001'\001\t\000\000\001=\000\000\000\000\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\000\000\001'\002r\000\000\001A\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\000\000\002\016\000\000\000\000\000\000\001\027\000\000\000\000\000\000\000\000\0017\000\000\002\017\000\000\002d\000\193\000\000\001\030\000\000\002\016\0017\001\207\000\000\001\027\000\000\000\000\002\016\001\030\000\000\000\000\002\017\002$\002d\000\193\000\000\000\000\000\000\002\017\0017\002d\000\193\000\000\000\000\000\000\001'\001\030\000\000\001A\001#\0027\000\000\000\000\000\000\000\000\001'\000\000\002\016\001A\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\001#\002\017\000\000\002d\000\193\002e\001'\000\000\000\000\001A\000\000\001\t\000\000\002f\000\000\001}\002g\001\016\001\029\000\000\000\000\000\000\001\027\002e\000\000\000\000\000\000\000\000\000\000\001\t\002e\002f\000\000\001}\002g\001\016\001\029\000\000\002f\000\000\001}\002g\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\000\000\002e\000\000\0017\001\024\000\000\001#\001\025\000\000\002f\001\030\001}\002g\001\027\002\175\000\000\000\000\000\000\000\000\000\000\000\000\0017\001\027\000\000\002\r\002\014\001^\000\000\001\030\000\000\000\000\001\027\002\180\000\000\000\000\001\t\000\000\001'\000\000\000\000\001A\001\016\001\029\000\000\000\000\001\024\000\000\003\020\001\025\000\000\000\000\000\000\000\000\000\000\001\024\001'\001#\001\025\001A\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\027\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\001\027\000\000\000\000\000\000\001\t\0017\001\024\000\000\000\000\001\025\001\016\001\029\001\030\001\t\000\000\000\000\002\197\000\000\000\000\001\016\001\029\001\024\001\t\001\024\001\025\000\000\001\025\000\000\001\016\001\029\000\000\000\000\000\000\001\027\001#\000\000\000\000\000\000\002\016\001'\000\000\000\000\001A\001#\000\000\000\000\000\000\000\000\001\027\002\017\001\027\002d\000\193\000\000\000\000\0017\000\000\000\000\000\000\000\000\000\000\000\000\001\030\001\t\0017\000\000\002\204\000\000\000\000\001\016\001\029\001\030\001\t\0017\000\000\002\211\001#\000\000\001\016\001\029\001\030\000\000\001\024\000\000\002\220\001\025\000\000\000\000\000\000\001'\000\000\001#\001A\001#\000\000\000\000\000\000\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\001\t\000\000\001'\002e\001\027\001A\001\016\001\029\000\000\0017\000\000\002f\000\000\001}\002g\001\t\001\030\001\t\0017\000\000\004P\001\016\001\029\001\016\001\029\001\030\000\000\001\024\000\000\004\168\005\005\000\000\000\000\000\000\000\000\000\000\001\024\000\000\001\024\005\005\000\000\001\025\000\000\001'\000\000\000\000\001A\001#\000\000\000\000\000\000\0017\001'\001\024\001\027\001A\001\025\000\000\001\030\000\000\000\000\000\000\004\180\001\027\000\000\001\027\0017\000\000\0017\001\024\000\000\000\000\001\025\001\030\000\000\001\030\001\t\004\193\000\000\004\210\001\027\000\000\001\016\001\029\001\024\001'\001\024\001\025\001A\005\005\000\000\000\000\000\000\000\000\000\000\000\000\001\027\005\007\000\000\000\000\001'\000\000\001'\001A\000\000\001A\005\007\000\000\001#\000\000\000\000\001\027\000\000\001\027\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\001\t\0017\000\000\000\000\000\000\000\000\001\016\005\n\001\030\001\t\000\000\001\t\004\226\001#\000\000\001\016\005\n\001\016\001\029\001\024\000\000\000\000\005\005\000\000\000\000\000\000\001\t\000\000\001#\000\000\005\007\000\000\001\016\001\029\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\001\t\000\000\000\000\000\000\001\027\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\000\000\000\000\001\t\005\011\001\t\000\000\000\000\0017\001\016\001\029\001\016\005\n\005\011\001\024\001\030\004\213\001\025\005\012\005~\005\r\000\000\000\000\0017\001\027\004\213\000\000\005\024\000\000\005\r\001\030\001'\000\000\000\000\005\144\005\007\000\000\000\000\000\000\0017\001'\001\027\001'\000\000\000\000\001A\001\030\000\000\000\000\000\000\005\168\000\000\000\000\000\000\0017\000\000\001\024\001'\000\000\001\025\001A\001\030\000\000\005\011\001\t\0066\000\000\001#\000\000\000\000\001\016\005\n\000\000\001'\000\000\004\213\001A\005\228\000\000\005\r\000\000\000\000\000\000\001\027\001#\000\000\000\000\000\000\001'\001\024\001'\001A\001\025\000\000\000\000\000\000\001\t\001\024\000\000\000\000\001\025\000\000\001\016\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\t\000\000\000\000\001\027\000\000\000\000\001\016\001\029\000\000\005\011\000\000\001\027\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\213\000\000\005\254\000\000\005\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0017\000\000\001'\000\000\000\000\000\000\000\000\001\030\001\t\000\000\000\000\006\139\001#\000\000\001\016\001\029\000\000\0017\000\000\000\000\001#\000\000\000\000\000\000\001\030\000\000\000\000\000\000\006\143\000\000\000\000\000\000\000\000\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\001\t\000\000\001'\000\000\000\000\001A\001\016\001\029\000\000\000\000\0017\000\000\000\000\000\000\000\000\000\000\000\000\001\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\000\000\0017\001'\000\000\000\000\001\200\000\000\000\000\001\030\0017\000\000\000\000\000\000\000\000\000\000\000\000\001\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\001'\000\000\000\000\001\202\000\000\000\000\000\000\000\000\001'\000\000\000\000\003\232")) and semantic_action = [| @@ -1309,9 +1332,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3579 "parsing/parser.mly" +# 3641 "parsing/parser.mly" ( "+" ) -# 1315 "parsing/parser.ml" +# 1338 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1334,9 +1357,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3580 "parsing/parser.mly" +# 3642 "parsing/parser.mly" ( "+." ) -# 1340 "parsing/parser.ml" +# 1363 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1359,9 +1382,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = -# 3148 "parsing/parser.mly" +# 3198 "parsing/parser.mly" ( _1 ) -# 1365 "parsing/parser.ml" +# 1388 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1406,24 +1429,24 @@ module Tables = struct let _endpos = _endpos_tyvar_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3151 "parsing/parser.mly" +# 3201 "parsing/parser.mly" ( Ptyp_alias(ty, tyvar) ) -# 1412 "parsing/parser.ml" +# 1435 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_tyvar_, _startpos_ty_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1421 "parsing/parser.ml" +# 1444 "parsing/parser.ml" in -# 3153 "parsing/parser.mly" +# 3203 "parsing/parser.mly" ( _1 ) -# 1427 "parsing/parser.ml" +# 1450 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1469,30 +1492,80 @@ module Tables = struct let _v : (let_binding) = let attrs2 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 1475 "parsing/parser.ml" +# 1498 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 1484 "parsing/parser.ml" +# 1507 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2428 "parsing/parser.mly" +# 2478 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in mklb ~loc:_sloc false body attrs ) -# 1496 "parsing/parser.ml" +# 1519 "parsing/parser.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 : (Longident.t) = 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) = +# 3528 "parsing/parser.mly" + ( _1 ) +# 1544 "parsing/parser.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 : (Asttypes.label) = 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) = +# 3529 "parsing/parser.mly" + ( Lident _1 ) +# 1569 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1529,9 +1602,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.core_type) = -# 3209 "parsing/parser.mly" +# 3259 "parsing/parser.mly" ( _2 ) -# 1535 "parsing/parser.ml" +# 1608 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1592,23 +1665,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 1598 "parsing/parser.ml" +# 1671 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1606 "parsing/parser.ml" +# 1679 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 1612 "parsing/parser.ml" +# 1685 "parsing/parser.ml" in let _3 = @@ -1616,24 +1689,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 1622 "parsing/parser.ml" +# 1695 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 1628 "parsing/parser.ml" +# 1701 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3211 "parsing/parser.mly" +# 3261 "parsing/parser.mly" ( wrap_typ_attrs ~loc:_sloc (reloc_typ ~loc:_sloc _4) _3 ) -# 1637 "parsing/parser.ml" +# 1710 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1664,24 +1737,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3214 "parsing/parser.mly" +# 3264 "parsing/parser.mly" ( Ptyp_var _2 ) -# 1670 "parsing/parser.ml" +# 1743 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1679 "parsing/parser.ml" +# 1752 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 1685 "parsing/parser.ml" +# 1758 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1705,23 +1778,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3216 "parsing/parser.mly" +# 3266 "parsing/parser.mly" ( Ptyp_any ) -# 1711 "parsing/parser.ml" +# 1784 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1719 "parsing/parser.ml" +# 1792 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 1725 "parsing/parser.ml" +# 1798 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1750,35 +1823,35 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 1756 "parsing/parser.ml" +# 1829 "parsing/parser.ml" in let tys = -# 3261 "parsing/parser.mly" +# 3311 "parsing/parser.mly" ( [] ) -# 1762 "parsing/parser.ml" +# 1835 "parsing/parser.ml" in -# 3219 "parsing/parser.mly" +# 3269 "parsing/parser.mly" ( Ptyp_constr(tid, tys) ) -# 1767 "parsing/parser.ml" +# 1840 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1776 "parsing/parser.ml" +# 1849 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 1782 "parsing/parser.ml" +# 1855 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1814,20 +1887,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 1820 "parsing/parser.ml" +# 1893 "parsing/parser.ml" in let tys = -# 3263 "parsing/parser.mly" +# 3313 "parsing/parser.mly" ( [ty] ) -# 1826 "parsing/parser.ml" +# 1899 "parsing/parser.ml" in -# 3219 "parsing/parser.mly" +# 3269 "parsing/parser.mly" ( Ptyp_constr(tid, tys) ) -# 1831 "parsing/parser.ml" +# 1904 "parsing/parser.ml" in let _startpos__1_ = _startpos_ty_ in @@ -1835,15 +1908,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1841 "parsing/parser.ml" +# 1914 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 1847 "parsing/parser.ml" +# 1920 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1894,34 +1967,34 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 1900 "parsing/parser.ml" +# 1973 "parsing/parser.ml" in let tys = let tys = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 1908 "parsing/parser.ml" +# 1981 "parsing/parser.ml" in -# 954 "parsing/parser.mly" +# 975 "parsing/parser.mly" ( xs ) -# 1913 "parsing/parser.ml" +# 1986 "parsing/parser.ml" in -# 3265 "parsing/parser.mly" +# 3315 "parsing/parser.mly" ( tys ) -# 1919 "parsing/parser.ml" +# 1992 "parsing/parser.ml" in -# 3219 "parsing/parser.mly" +# 3269 "parsing/parser.mly" ( Ptyp_constr(tid, tys) ) -# 1925 "parsing/parser.ml" +# 1998 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -1929,15 +2002,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1935 "parsing/parser.ml" +# 2008 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 1941 "parsing/parser.ml" +# 2014 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1975,24 +2048,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3221 "parsing/parser.mly" +# 3271 "parsing/parser.mly" ( let (f, c) = _2 in Ptyp_object (f, c) ) -# 1981 "parsing/parser.ml" +# 2054 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 1990 "parsing/parser.ml" +# 2063 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 1996 "parsing/parser.ml" +# 2069 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2023,24 +2096,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3223 "parsing/parser.mly" +# 3273 "parsing/parser.mly" ( Ptyp_object ([], Closed) ) -# 2029 "parsing/parser.ml" +# 2102 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2038 "parsing/parser.ml" +# 2111 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2044 "parsing/parser.ml" +# 2117 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2076,20 +2149,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 2082 "parsing/parser.ml" +# 2155 "parsing/parser.ml" in let tys = -# 3261 "parsing/parser.mly" +# 3311 "parsing/parser.mly" ( [] ) -# 2088 "parsing/parser.ml" +# 2161 "parsing/parser.ml" in -# 3227 "parsing/parser.mly" +# 3277 "parsing/parser.mly" ( Ptyp_class(cid, tys) ) -# 2093 "parsing/parser.ml" +# 2166 "parsing/parser.ml" in let _startpos__1_ = _startpos__2_ in @@ -2097,15 +2170,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2103 "parsing/parser.ml" +# 2176 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2109 "parsing/parser.ml" +# 2182 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2148,20 +2221,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 2154 "parsing/parser.ml" +# 2227 "parsing/parser.ml" in let tys = -# 3263 "parsing/parser.mly" +# 3313 "parsing/parser.mly" ( [ty] ) -# 2160 "parsing/parser.ml" +# 2233 "parsing/parser.ml" in -# 3227 "parsing/parser.mly" +# 3277 "parsing/parser.mly" ( Ptyp_class(cid, tys) ) -# 2165 "parsing/parser.ml" +# 2238 "parsing/parser.ml" in let _startpos__1_ = _startpos_ty_ in @@ -2169,15 +2242,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2175 "parsing/parser.ml" +# 2248 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2181 "parsing/parser.ml" +# 2254 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2235,34 +2308,34 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 2241 "parsing/parser.ml" +# 2314 "parsing/parser.ml" in let tys = let tys = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2249 "parsing/parser.ml" +# 2322 "parsing/parser.ml" in -# 954 "parsing/parser.mly" +# 975 "parsing/parser.mly" ( xs ) -# 2254 "parsing/parser.ml" +# 2327 "parsing/parser.ml" in -# 3265 "parsing/parser.mly" +# 3315 "parsing/parser.mly" ( tys ) -# 2260 "parsing/parser.ml" +# 2333 "parsing/parser.ml" in -# 3227 "parsing/parser.mly" +# 3277 "parsing/parser.mly" ( Ptyp_class(cid, tys) ) -# 2266 "parsing/parser.ml" +# 2339 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -2270,15 +2343,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2276 "parsing/parser.ml" +# 2349 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2282 "parsing/parser.ml" +# 2355 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2316,24 +2389,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3230 "parsing/parser.mly" +# 3280 "parsing/parser.mly" ( Ptyp_variant([_2], Closed, None) ) -# 2322 "parsing/parser.ml" +# 2395 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2331 "parsing/parser.ml" +# 2404 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2337 "parsing/parser.ml" +# 2410 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2381,26 +2454,26 @@ module Tables = struct let _3 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2387 "parsing/parser.ml" +# 2460 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 2392 "parsing/parser.ml" +# 2465 "parsing/parser.ml" in -# 3275 "parsing/parser.mly" +# 3325 "parsing/parser.mly" ( _1 ) -# 2398 "parsing/parser.ml" +# 2471 "parsing/parser.ml" in -# 3232 "parsing/parser.mly" +# 3282 "parsing/parser.mly" ( Ptyp_variant(_3, Closed, None) ) -# 2404 "parsing/parser.ml" +# 2477 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -2408,15 +2481,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2414 "parsing/parser.ml" +# 2487 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2420 "parsing/parser.ml" +# 2493 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2471,26 +2544,26 @@ module Tables = struct let _4 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2477 "parsing/parser.ml" +# 2550 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 2482 "parsing/parser.ml" +# 2555 "parsing/parser.ml" in -# 3275 "parsing/parser.mly" +# 3325 "parsing/parser.mly" ( _1 ) -# 2488 "parsing/parser.ml" +# 2561 "parsing/parser.ml" in -# 3234 "parsing/parser.mly" +# 3284 "parsing/parser.mly" ( Ptyp_variant(_2 :: _4, Closed, None) ) -# 2494 "parsing/parser.ml" +# 2567 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -2498,15 +2571,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2504 "parsing/parser.ml" +# 2577 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2510 "parsing/parser.ml" +# 2583 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2554,26 +2627,26 @@ module Tables = struct let _3 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2560 "parsing/parser.ml" +# 2633 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 2565 "parsing/parser.ml" +# 2638 "parsing/parser.ml" in -# 3275 "parsing/parser.mly" +# 3325 "parsing/parser.mly" ( _1 ) -# 2571 "parsing/parser.ml" +# 2644 "parsing/parser.ml" in -# 3236 "parsing/parser.mly" +# 3286 "parsing/parser.mly" ( Ptyp_variant(_3, Open, None) ) -# 2577 "parsing/parser.ml" +# 2650 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -2581,15 +2654,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2587 "parsing/parser.ml" +# 2660 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2593 "parsing/parser.ml" +# 2666 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2620,24 +2693,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3238 "parsing/parser.mly" +# 3288 "parsing/parser.mly" ( Ptyp_variant([], Open, None) ) -# 2626 "parsing/parser.ml" +# 2699 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2635 "parsing/parser.ml" +# 2708 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2641 "parsing/parser.ml" +# 2714 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2685,26 +2758,26 @@ module Tables = struct let _3 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2691 "parsing/parser.ml" +# 2764 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 2696 "parsing/parser.ml" +# 2769 "parsing/parser.ml" in -# 3275 "parsing/parser.mly" +# 3325 "parsing/parser.mly" ( _1 ) -# 2702 "parsing/parser.ml" +# 2775 "parsing/parser.ml" in -# 3240 "parsing/parser.mly" +# 3290 "parsing/parser.mly" ( Ptyp_variant(_3, Closed, Some []) ) -# 2708 "parsing/parser.ml" +# 2781 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -2712,15 +2785,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2718 "parsing/parser.ml" +# 2791 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2724 "parsing/parser.ml" +# 2797 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2783,45 +2856,45 @@ module Tables = struct let xs = xs_inlined1 in let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2789 "parsing/parser.ml" +# 2862 "parsing/parser.ml" in -# 894 "parsing/parser.mly" +# 915 "parsing/parser.mly" ( xs ) -# 2794 "parsing/parser.ml" +# 2867 "parsing/parser.ml" in -# 3303 "parsing/parser.mly" +# 3353 "parsing/parser.mly" ( _1 ) -# 2800 "parsing/parser.ml" +# 2873 "parsing/parser.ml" in let _3 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 2808 "parsing/parser.ml" +# 2881 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 2813 "parsing/parser.ml" +# 2886 "parsing/parser.ml" in -# 3275 "parsing/parser.mly" +# 3325 "parsing/parser.mly" ( _1 ) -# 2819 "parsing/parser.ml" +# 2892 "parsing/parser.ml" in -# 3242 "parsing/parser.mly" +# 3292 "parsing/parser.mly" ( Ptyp_variant(_3, Closed, Some _5) ) -# 2825 "parsing/parser.ml" +# 2898 "parsing/parser.ml" in let _endpos__1_ = _endpos__6_ in @@ -2829,15 +2902,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2835 "parsing/parser.ml" +# 2908 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2841 "parsing/parser.ml" +# 2914 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2861,23 +2934,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3244 "parsing/parser.mly" +# 3294 "parsing/parser.mly" ( Ptyp_extension _1 ) -# 2867 "parsing/parser.ml" +# 2940 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 2875 "parsing/parser.ml" +# 2948 "parsing/parser.ml" in -# 3246 "parsing/parser.mly" +# 3296 "parsing/parser.mly" ( _1 ) -# 2881 "parsing/parser.ml" +# 2954 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2901,23 +2974,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (string Asttypes.loc) = let _1 = let _1 = -# 3646 "parsing/parser.mly" +# 3708 "parsing/parser.mly" ( _1 ) -# 2907 "parsing/parser.ml" +# 2980 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 822 "parsing/parser.mly" +# 843 "parsing/parser.mly" ( mkloc _1 (make_loc _sloc) ) -# 2915 "parsing/parser.ml" +# 2988 "parsing/parser.ml" in -# 3648 "parsing/parser.mly" +# 3710 "parsing/parser.mly" ( _1 ) -# 2921 "parsing/parser.ml" +# 2994 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2955,24 +3028,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (string Asttypes.loc) = let _1 = let _1 = -# 3647 "parsing/parser.mly" +# 3709 "parsing/parser.mly" ( _1 ^ "." ^ _3.txt ) -# 2961 "parsing/parser.ml" +# 3034 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 822 "parsing/parser.mly" +# 843 "parsing/parser.mly" ( mkloc _1 (make_loc _sloc) ) -# 2970 "parsing/parser.ml" +# 3043 "parsing/parser.ml" in -# 3648 "parsing/parser.mly" +# 3710 "parsing/parser.mly" ( _1 ) -# 2976 "parsing/parser.ml" +# 3049 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3019,9 +3092,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3652 "parsing/parser.mly" +# 3714 "parsing/parser.mly" ( Attr.mk ~loc:(make_loc _sloc) _2 _3 ) -# 3025 "parsing/parser.ml" +# 3098 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3044,9 +3117,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.class_expr) = -# 1712 "parsing/parser.mly" +# 1762 "parsing/parser.mly" ( _1 ) -# 3050 "parsing/parser.ml" +# 3123 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3085,18 +3158,18 @@ module Tables = struct let _v : (Parsetree.class_expr) = let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3091 "parsing/parser.ml" +# 3164 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1714 "parsing/parser.mly" +# 1764 "parsing/parser.mly" ( wrap_class_attrs ~loc:_sloc _3 _2 ) -# 3100 "parsing/parser.ml" +# 3173 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3136,9 +3209,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1716 "parsing/parser.mly" +# 1766 "parsing/parser.mly" ( class_of_let_bindings ~loc:_sloc _1 _3 ) -# 3142 "parsing/parser.ml" +# 3215 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3201,34 +3274,34 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 3207 "parsing/parser.ml" +# 3280 "parsing/parser.ml" in let _4 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3215 "parsing/parser.ml" +# 3288 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined1_ in let _3 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 3222 "parsing/parser.ml" +# 3295 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1718 "parsing/parser.mly" +# 1768 "parsing/parser.mly" ( let loc = (_startpos__2_, _endpos__4_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) ) -# 3232 "parsing/parser.ml" +# 3305 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3298,37 +3371,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 3304 "parsing/parser.ml" +# 3377 "parsing/parser.ml" in let _4 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3312 "parsing/parser.ml" +# 3385 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 3321 "parsing/parser.ml" +# 3394 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1718 "parsing/parser.mly" +# 1768 "parsing/parser.mly" ( let loc = (_startpos__2_, _endpos__4_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) ) -# 3332 "parsing/parser.ml" +# 3405 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3358,9 +3431,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.class_expr) = -# 1722 "parsing/parser.mly" +# 1772 "parsing/parser.mly" ( Cl.attr _1 _2 ) -# 3364 "parsing/parser.ml" +# 3437 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3393,20 +3466,20 @@ module Tables = struct let _1 = let _2 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 3399 "parsing/parser.ml" +# 3472 "parsing/parser.ml" in -# 894 "parsing/parser.mly" +# 915 "parsing/parser.mly" ( xs ) -# 3404 "parsing/parser.ml" +# 3477 "parsing/parser.ml" in -# 1725 "parsing/parser.mly" +# 1775 "parsing/parser.mly" ( Pcl_apply(_1, _2) ) -# 3410 "parsing/parser.ml" +# 3483 "parsing/parser.ml" in let _endpos__1_ = _endpos_xs_ in @@ -3414,15 +3487,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 3420 "parsing/parser.ml" +# 3493 "parsing/parser.ml" in -# 1728 "parsing/parser.mly" +# 1778 "parsing/parser.mly" ( _1 ) -# 3426 "parsing/parser.ml" +# 3499 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3446,23 +3519,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1727 "parsing/parser.mly" +# 1777 "parsing/parser.mly" ( Pcl_extension _1 ) -# 3452 "parsing/parser.ml" +# 3525 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 3460 "parsing/parser.ml" +# 3533 "parsing/parser.ml" in -# 1728 "parsing/parser.mly" +# 1778 "parsing/parser.mly" ( _1 ) -# 3466 "parsing/parser.ml" +# 3539 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3515,33 +3588,33 @@ module Tables = struct let _v : (Parsetree.class_field) = let _6 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3521 "parsing/parser.ml" +# 3594 "parsing/parser.ml" in let _endpos__6_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3530 "parsing/parser.ml" +# 3603 "parsing/parser.ml" in let _2 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 3536 "parsing/parser.ml" +# 3609 "parsing/parser.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1777 "parsing/parser.mly" +# 1827 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs ) -# 3545 "parsing/parser.ml" +# 3618 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3601,36 +3674,36 @@ module Tables = struct let _v : (Parsetree.class_field) = let _6 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3607 "parsing/parser.ml" +# 3680 "parsing/parser.ml" in let _endpos__6_ = _endpos__1_inlined3_ in let _3 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3616 "parsing/parser.ml" +# 3689 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 3624 "parsing/parser.ml" +# 3697 "parsing/parser.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1777 "parsing/parser.mly" +# 1827 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs ) -# 3634 "parsing/parser.ml" +# 3707 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3671,9 +3744,9 @@ module Tables = struct let _v : (Parsetree.class_field) = let _3 = let _1 = _1_inlined1 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3677 "parsing/parser.ml" +# 3750 "parsing/parser.ml" in let _endpos__3_ = _endpos__1_inlined1_ in @@ -3681,11 +3754,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1780 "parsing/parser.mly" +# 1830 "parsing/parser.mly" ( let v, attrs = _2 in let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_val v) ~attrs:(attrs@_3) ~docs ) -# 3689 "parsing/parser.ml" +# 3762 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3726,9 +3799,9 @@ module Tables = struct let _v : (Parsetree.class_field) = let _3 = let _1 = _1_inlined1 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3732 "parsing/parser.ml" +# 3805 "parsing/parser.ml" in let _endpos__3_ = _endpos__1_inlined1_ in @@ -3736,11 +3809,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1784 "parsing/parser.mly" +# 1834 "parsing/parser.mly" ( let meth, attrs = _2 in let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_method meth) ~attrs:(attrs@_3) ~docs ) -# 3744 "parsing/parser.ml" +# 3817 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3786,28 +3859,28 @@ module Tables = struct let _v : (Parsetree.class_field) = let _4 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3792 "parsing/parser.ml" +# 3865 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3801 "parsing/parser.ml" +# 3874 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1788 "parsing/parser.mly" +# 1838 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_constraint _3) ~attrs:(_2@_4) ~docs ) -# 3811 "parsing/parser.ml" +# 3884 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3853,28 +3926,28 @@ module Tables = struct let _v : (Parsetree.class_field) = let _4 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3859 "parsing/parser.ml" +# 3932 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 3868 "parsing/parser.ml" +# 3941 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1791 "parsing/parser.mly" +# 1841 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_initializer _3) ~attrs:(_2@_4) ~docs ) -# 3878 "parsing/parser.ml" +# 3951 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3906,9 +3979,9 @@ module Tables = struct let _v : (Parsetree.class_field) = let _2 = let _1 = _1_inlined1 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 3912 "parsing/parser.ml" +# 3985 "parsing/parser.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -3916,10 +3989,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1794 "parsing/parser.mly" +# 1844 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_extension _1) ~attrs:_2 ~docs ) -# 3923 "parsing/parser.ml" +# 3996 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3943,23 +4016,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_field) = let _1 = let _1 = -# 1797 "parsing/parser.mly" +# 1847 "parsing/parser.mly" ( Pcf_attribute _1 ) -# 3949 "parsing/parser.ml" +# 4022 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 843 "parsing/parser.mly" +# 864 "parsing/parser.mly" ( mkcf ~loc:_sloc _1 ) -# 3957 "parsing/parser.ml" +# 4030 "parsing/parser.ml" in -# 1798 "parsing/parser.mly" +# 1848 "parsing/parser.mly" ( _1 ) -# 3963 "parsing/parser.ml" +# 4036 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3989,9 +4062,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.class_expr) = -# 1692 "parsing/parser.mly" +# 1742 "parsing/parser.mly" ( _2 ) -# 3995 "parsing/parser.ml" +# 4068 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4036,24 +4109,24 @@ module Tables = struct let _endpos = _endpos__4_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1695 "parsing/parser.mly" +# 1745 "parsing/parser.mly" ( Pcl_constraint(_4, _2) ) -# 4042 "parsing/parser.ml" +# 4115 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 4051 "parsing/parser.ml" +# 4124 "parsing/parser.ml" in -# 1698 "parsing/parser.mly" +# 1748 "parsing/parser.mly" ( _1 ) -# 4057 "parsing/parser.ml" +# 4130 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4084,24 +4157,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1697 "parsing/parser.mly" +# 1747 "parsing/parser.mly" ( let (l,o,p) = _1 in Pcl_fun(l, o, p, _2) ) -# 4090 "parsing/parser.ml" +# 4163 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 4099 "parsing/parser.ml" +# 4172 "parsing/parser.ml" in -# 1698 "parsing/parser.mly" +# 1748 "parsing/parser.mly" ( _1 ) -# 4105 "parsing/parser.ml" +# 4178 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4139,24 +4212,24 @@ module Tables = struct let _endpos = _endpos_e_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1753 "parsing/parser.mly" +# 1803 "parsing/parser.mly" ( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) ) -# 4145 "parsing/parser.ml" +# 4218 "parsing/parser.ml" in let _endpos__1_ = _endpos_e_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 4154 "parsing/parser.ml" +# 4227 "parsing/parser.ml" in -# 1754 "parsing/parser.mly" +# 1804 "parsing/parser.mly" ( _1 ) -# 4160 "parsing/parser.ml" +# 4233 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4187,24 +4260,24 @@ module Tables = struct let _endpos = _endpos_e_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1753 "parsing/parser.mly" +# 1803 "parsing/parser.mly" ( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) ) -# 4193 "parsing/parser.ml" +# 4266 "parsing/parser.ml" in let _endpos__1_ = _endpos_e_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 4202 "parsing/parser.ml" +# 4275 "parsing/parser.ml" in -# 1754 "parsing/parser.mly" +# 1804 "parsing/parser.mly" ( _1 ) -# 4208 "parsing/parser.ml" +# 4281 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4222,61 +4295,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : ( -# 642 "parsing/parser.mly" - (string) -# 4229 "parsing/parser.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) = -# 3466 "parsing/parser.mly" - ( Lident _1 ) -# 4237 "parsing/parser.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 : ( -# 642 "parsing/parser.mly" - (string) -# 4270 "parsing/parser.ml" - ) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3467 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 4280 "parsing/parser.ml" +# 3519 "parsing/parser.mly" + ( _1 ) +# 4306 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4316,9 +4342,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1762 "parsing/parser.mly" +# 1812 "parsing/parser.mly" ( reloc_pat ~loc:_sloc _2 ) -# 4322 "parsing/parser.ml" +# 4348 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4370,24 +4396,24 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 1764 "parsing/parser.mly" +# 1814 "parsing/parser.mly" ( Ppat_constraint(_2, _4) ) -# 4376 "parsing/parser.ml" +# 4402 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 4385 "parsing/parser.ml" +# 4411 "parsing/parser.ml" in -# 1765 "parsing/parser.mly" +# 1815 "parsing/parser.mly" ( _1 ) -# 4391 "parsing/parser.ml" +# 4417 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4406,9 +4432,9 @@ module Tables = struct let _symbolstartpos = _endpos in let _sloc = (_symbolstartpos, _endpos) in -# 1767 "parsing/parser.mly" +# 1817 "parsing/parser.mly" ( ghpat ~loc:_sloc Ppat_any ) -# 4412 "parsing/parser.ml" +# 4438 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4445,9 +4471,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.core_type) = -# 1892 "parsing/parser.mly" +# 1942 "parsing/parser.mly" ( _2 ) -# 4451 "parsing/parser.ml" +# 4477 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4464,24 +4490,24 @@ module Tables = struct let _endpos = _startpos in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 1893 "parsing/parser.mly" +# 1943 "parsing/parser.mly" ( Ptyp_any ) -# 4470 "parsing/parser.ml" +# 4496 "parsing/parser.ml" in let _endpos__1_ = _endpos__0_ in let _endpos = _endpos__1_ in let _symbolstartpos = _endpos in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 4479 "parsing/parser.ml" +# 4505 "parsing/parser.ml" in -# 1894 "parsing/parser.mly" +# 1944 "parsing/parser.mly" ( _1 ) -# 4485 "parsing/parser.ml" +# 4511 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4527,28 +4553,28 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _4 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 4533 "parsing/parser.ml" +# 4559 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 4542 "parsing/parser.ml" +# 4568 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1902 "parsing/parser.mly" +# 1952 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_inherit _3) ~attrs:(_2@_4) ~docs ) -# 4552 "parsing/parser.ml" +# 4578 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4606,9 +4632,9 @@ module Tables = struct let ty : (Parsetree.core_type) = Obj.magic ty in let _3 : unit = Obj.magic _3 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 4612 "parsing/parser.ml" +# 4638 "parsing/parser.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 @@ -4619,9 +4645,9 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _4 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 4625 "parsing/parser.ml" +# 4651 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined3_ in @@ -4629,44 +4655,44 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let label = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 4635 "parsing/parser.ml" +# 4661 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 4643 "parsing/parser.ml" +# 4669 "parsing/parser.ml" in -# 1927 "parsing/parser.mly" +# 1977 "parsing/parser.mly" ( let mut, virt = flags in label, mut, virt, ty ) -# 4652 "parsing/parser.ml" +# 4678 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 4660 "parsing/parser.ml" +# 4686 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1905 "parsing/parser.mly" +# 1955 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_val _3) ~attrs:(_2@_4) ~docs ) -# 4670 "parsing/parser.ml" +# 4696 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4724,9 +4750,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 4730 "parsing/parser.ml" +# 4756 "parsing/parser.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 @@ -4737,53 +4763,53 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _7 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 4743 "parsing/parser.ml" +# 4769 "parsing/parser.ml" in let _endpos__7_ = _endpos__1_inlined4_ in let _6 = let _1 = _1_inlined3 in -# 3114 "parsing/parser.mly" +# 3164 "parsing/parser.mly" ( _1 ) -# 4752 "parsing/parser.ml" +# 4778 "parsing/parser.ml" in let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 4760 "parsing/parser.ml" +# 4786 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 4768 "parsing/parser.ml" +# 4794 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 4776 "parsing/parser.ml" +# 4802 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1909 "parsing/parser.mly" +# 1959 "parsing/parser.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 ) -# 4787 "parsing/parser.ml" +# 4813 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4829,28 +4855,28 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _4 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 4835 "parsing/parser.ml" +# 4861 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 4844 "parsing/parser.ml" +# 4870 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1913 "parsing/parser.mly" +# 1963 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_constraint _3) ~attrs:(_2@_4) ~docs ) -# 4854 "parsing/parser.ml" +# 4880 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4882,9 +4908,9 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _2 = let _1 = _1_inlined1 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 4888 "parsing/parser.ml" +# 4914 "parsing/parser.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -4892,10 +4918,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1916 "parsing/parser.mly" +# 1966 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_extension _1) ~attrs:_2 ~docs ) -# 4899 "parsing/parser.ml" +# 4925 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4919,23 +4945,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_type_field) = let _1 = let _1 = -# 1919 "parsing/parser.mly" +# 1969 "parsing/parser.mly" ( Pctf_attribute _1 ) -# 4925 "parsing/parser.ml" +# 4951 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 841 "parsing/parser.mly" +# 862 "parsing/parser.mly" ( mkctf ~loc:_sloc _1 ) -# 4933 "parsing/parser.ml" +# 4959 "parsing/parser.ml" in -# 1920 "parsing/parser.mly" +# 1970 "parsing/parser.mly" ( _1 ) -# 4939 "parsing/parser.ml" +# 4965 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4964,42 +4990,42 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 4970 "parsing/parser.ml" +# 4996 "parsing/parser.ml" in let tys = let tys = -# 1878 "parsing/parser.mly" +# 1928 "parsing/parser.mly" ( [] ) -# 4977 "parsing/parser.ml" +# 5003 "parsing/parser.ml" in -# 1884 "parsing/parser.mly" +# 1934 "parsing/parser.mly" ( tys ) -# 4982 "parsing/parser.ml" +# 5008 "parsing/parser.ml" in -# 1861 "parsing/parser.mly" +# 1911 "parsing/parser.mly" ( Pcty_constr (cid, tys) ) -# 4988 "parsing/parser.ml" +# 5014 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 839 "parsing/parser.mly" +# 860 "parsing/parser.mly" ( mkcty ~loc:_sloc _1 ) -# 4997 "parsing/parser.ml" +# 5023 "parsing/parser.ml" in -# 1864 "parsing/parser.mly" +# 1914 "parsing/parser.mly" ( _1 ) -# 5003 "parsing/parser.ml" +# 5029 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5050,41 +5076,41 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 5056 "parsing/parser.ml" +# 5082 "parsing/parser.ml" in let tys = let tys = let params = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 5065 "parsing/parser.ml" +# 5091 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 5070 "parsing/parser.ml" +# 5096 "parsing/parser.ml" in -# 1880 "parsing/parser.mly" +# 1930 "parsing/parser.mly" ( params ) -# 5076 "parsing/parser.ml" +# 5102 "parsing/parser.ml" in -# 1884 "parsing/parser.mly" +# 1934 "parsing/parser.mly" ( tys ) -# 5082 "parsing/parser.ml" +# 5108 "parsing/parser.ml" in -# 1861 "parsing/parser.mly" +# 1911 "parsing/parser.mly" ( Pcty_constr (cid, tys) ) -# 5088 "parsing/parser.ml" +# 5114 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -5092,15 +5118,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 839 "parsing/parser.mly" +# 860 "parsing/parser.mly" ( mkcty ~loc:_sloc _1 ) -# 5098 "parsing/parser.ml" +# 5124 "parsing/parser.ml" in -# 1864 "parsing/parser.mly" +# 1914 "parsing/parser.mly" ( _1 ) -# 5104 "parsing/parser.ml" +# 5130 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5124,23 +5150,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_type) = let _1 = let _1 = -# 1863 "parsing/parser.mly" +# 1913 "parsing/parser.mly" ( Pcty_extension _1 ) -# 5130 "parsing/parser.ml" +# 5156 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 839 "parsing/parser.mly" +# 860 "parsing/parser.mly" ( mkcty ~loc:_sloc _1 ) -# 5138 "parsing/parser.ml" +# 5164 "parsing/parser.ml" in -# 1864 "parsing/parser.mly" +# 1914 "parsing/parser.mly" ( _1 ) -# 5144 "parsing/parser.ml" +# 5170 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5195,46 +5221,46 @@ module Tables = struct let _2 = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 5201 "parsing/parser.ml" +# 5227 "parsing/parser.ml" in -# 1898 "parsing/parser.mly" +# 1948 "parsing/parser.mly" ( _1 ) -# 5206 "parsing/parser.ml" +# 5232 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 787 "parsing/parser.mly" +# 808 "parsing/parser.mly" ( extra_csig _startpos _endpos _1 ) -# 5215 "parsing/parser.ml" +# 5241 "parsing/parser.ml" in -# 1888 "parsing/parser.mly" +# 1938 "parsing/parser.mly" ( Csig.mk _1 _2 ) -# 5221 "parsing/parser.ml" +# 5247 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 5229 "parsing/parser.ml" +# 5255 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1866 "parsing/parser.mly" +# 1916 "parsing/parser.mly" ( mkcty ~loc:_sloc ~attrs:_2 (Pcty_signature _3) ) -# 5238 "parsing/parser.ml" +# 5264 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5289,45 +5315,45 @@ module Tables = struct let _2 = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 5295 "parsing/parser.ml" +# 5321 "parsing/parser.ml" in -# 1898 "parsing/parser.mly" +# 1948 "parsing/parser.mly" ( _1 ) -# 5300 "parsing/parser.ml" +# 5326 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 787 "parsing/parser.mly" +# 808 "parsing/parser.mly" ( extra_csig _startpos _endpos _1 ) -# 5309 "parsing/parser.ml" +# 5335 "parsing/parser.ml" in -# 1888 "parsing/parser.mly" +# 1938 "parsing/parser.mly" ( Csig.mk _1 _2 ) -# 5315 "parsing/parser.ml" +# 5341 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 5323 "parsing/parser.ml" +# 5349 "parsing/parser.ml" in let _loc__4_ = (_startpos__4_, _endpos__4_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1868 "parsing/parser.mly" +# 1918 "parsing/parser.mly" ( unclosed "object" _loc__1_ "end" _loc__4_ ) -# 5331 "parsing/parser.ml" +# 5357 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5357,9 +5383,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.class_type) = -# 1870 "parsing/parser.mly" +# 1920 "parsing/parser.mly" ( Cty.attr _1 _2 ) -# 5363 "parsing/parser.ml" +# 5389 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5422,34 +5448,34 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 5428 "parsing/parser.ml" +# 5454 "parsing/parser.ml" in let _4 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 5436 "parsing/parser.ml" +# 5462 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined1_ in let _3 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 5443 "parsing/parser.ml" +# 5469 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1872 "parsing/parser.mly" +# 1922 "parsing/parser.mly" ( let loc = (_startpos__2_, _endpos__4_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) ) -# 5453 "parsing/parser.ml" +# 5479 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5519,37 +5545,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 5525 "parsing/parser.ml" +# 5551 "parsing/parser.ml" in let _4 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 5533 "parsing/parser.ml" +# 5559 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 5542 "parsing/parser.ml" +# 5568 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1872 "parsing/parser.mly" +# 1922 "parsing/parser.mly" ( let loc = (_startpos__2_, _endpos__4_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) ) -# 5553 "parsing/parser.ml" +# 5579 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5586,9 +5612,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.class_expr) = -# 1732 "parsing/parser.mly" +# 1782 "parsing/parser.mly" ( _2 ) -# 5592 "parsing/parser.ml" +# 5618 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5627,9 +5653,9 @@ module Tables = struct let _v : (Parsetree.class_expr) = let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1734 "parsing/parser.mly" +# 1784 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__3_ ) -# 5633 "parsing/parser.ml" +# 5659 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5658,42 +5684,42 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 5664 "parsing/parser.ml" +# 5690 "parsing/parser.ml" in let tys = let tys = -# 1878 "parsing/parser.mly" +# 1928 "parsing/parser.mly" ( [] ) -# 5671 "parsing/parser.ml" +# 5697 "parsing/parser.ml" in -# 1884 "parsing/parser.mly" +# 1934 "parsing/parser.mly" ( tys ) -# 5676 "parsing/parser.ml" +# 5702 "parsing/parser.ml" in -# 1737 "parsing/parser.mly" +# 1787 "parsing/parser.mly" ( Pcl_constr(cid, tys) ) -# 5682 "parsing/parser.ml" +# 5708 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 5691 "parsing/parser.ml" +# 5717 "parsing/parser.ml" in -# 1744 "parsing/parser.mly" +# 1794 "parsing/parser.mly" ( _1 ) -# 5697 "parsing/parser.ml" +# 5723 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5744,41 +5770,41 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 5750 "parsing/parser.ml" +# 5776 "parsing/parser.ml" in let tys = let tys = let params = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 5759 "parsing/parser.ml" +# 5785 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 5764 "parsing/parser.ml" +# 5790 "parsing/parser.ml" in -# 1880 "parsing/parser.mly" +# 1930 "parsing/parser.mly" ( params ) -# 5770 "parsing/parser.ml" +# 5796 "parsing/parser.ml" in -# 1884 "parsing/parser.mly" +# 1934 "parsing/parser.mly" ( tys ) -# 5776 "parsing/parser.ml" +# 5802 "parsing/parser.ml" in -# 1737 "parsing/parser.mly" +# 1787 "parsing/parser.mly" ( Pcl_constr(cid, tys) ) -# 5782 "parsing/parser.ml" +# 5808 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -5786,15 +5812,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 5792 "parsing/parser.ml" +# 5818 "parsing/parser.ml" in -# 1744 "parsing/parser.mly" +# 1794 "parsing/parser.mly" ( _1 ) -# 5798 "parsing/parser.ml" +# 5824 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5851,45 +5877,45 @@ module Tables = struct let _2 = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 5857 "parsing/parser.ml" +# 5883 "parsing/parser.ml" in -# 1771 "parsing/parser.mly" +# 1821 "parsing/parser.mly" ( _1 ) -# 5862 "parsing/parser.ml" +# 5888 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 786 "parsing/parser.mly" +# 807 "parsing/parser.mly" ( extra_cstr _startpos _endpos _1 ) -# 5871 "parsing/parser.ml" +# 5897 "parsing/parser.ml" in -# 1758 "parsing/parser.mly" +# 1808 "parsing/parser.mly" ( Cstr.mk _1 _2 ) -# 5877 "parsing/parser.ml" +# 5903 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 5885 "parsing/parser.ml" +# 5911 "parsing/parser.ml" in let _loc__4_ = (_startpos__4_, _endpos__4_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1739 "parsing/parser.mly" +# 1789 "parsing/parser.mly" ( unclosed "object" _loc__1_ "end" _loc__4_ ) -# 5893 "parsing/parser.ml" +# 5919 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -5897,15 +5923,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 5903 "parsing/parser.ml" +# 5929 "parsing/parser.ml" in -# 1744 "parsing/parser.mly" +# 1794 "parsing/parser.mly" ( _1 ) -# 5909 "parsing/parser.ml" +# 5935 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5957,24 +5983,24 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1741 "parsing/parser.mly" +# 1791 "parsing/parser.mly" ( Pcl_constraint(_2, _4) ) -# 5963 "parsing/parser.ml" +# 5989 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 5972 "parsing/parser.ml" +# 5998 "parsing/parser.ml" in -# 1744 "parsing/parser.mly" +# 1794 "parsing/parser.mly" ( _1 ) -# 5978 "parsing/parser.ml" +# 6004 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6029,9 +6055,9 @@ module Tables = struct let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1743 "parsing/parser.mly" +# 1793 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__5_ ) -# 6035 "parsing/parser.ml" +# 6061 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -6039,15 +6065,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 845 "parsing/parser.mly" +# 866 "parsing/parser.mly" ( mkclass ~loc:_sloc _1 ) -# 6045 "parsing/parser.ml" +# 6071 "parsing/parser.ml" in -# 1744 "parsing/parser.mly" +# 1794 "parsing/parser.mly" ( _1 ) -# 6051 "parsing/parser.ml" +# 6077 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6102,46 +6128,46 @@ module Tables = struct let _2 = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 6108 "parsing/parser.ml" +# 6134 "parsing/parser.ml" in -# 1771 "parsing/parser.mly" +# 1821 "parsing/parser.mly" ( _1 ) -# 6113 "parsing/parser.ml" +# 6139 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 786 "parsing/parser.mly" +# 807 "parsing/parser.mly" ( extra_cstr _startpos _endpos _1 ) -# 6122 "parsing/parser.ml" +# 6148 "parsing/parser.ml" in -# 1758 "parsing/parser.mly" +# 1808 "parsing/parser.mly" ( Cstr.mk _1 _2 ) -# 6128 "parsing/parser.ml" +# 6154 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 6136 "parsing/parser.ml" +# 6162 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1746 "parsing/parser.mly" +# 1796 "parsing/parser.mly" ( mkclass ~loc:_sloc ~attrs:_2 (Pcl_structure _3) ) -# 6145 "parsing/parser.ml" +# 6171 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6164,9 +6190,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.class_type) = -# 1849 "parsing/parser.mly" +# 1899 "parsing/parser.mly" ( _1 ) -# 6170 "parsing/parser.ml" +# 6196 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6212,14 +6238,14 @@ module Tables = struct let _v : (Parsetree.class_type) = let _1 = let _1 = let label = -# 3177 "parsing/parser.mly" +# 3227 "parsing/parser.mly" ( Optional label ) -# 6218 "parsing/parser.ml" +# 6244 "parsing/parser.ml" in -# 1855 "parsing/parser.mly" +# 1905 "parsing/parser.mly" ( Pcty_arrow(label, domain, codomain) ) -# 6223 "parsing/parser.ml" +# 6249 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -6227,15 +6253,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 839 "parsing/parser.mly" +# 860 "parsing/parser.mly" ( mkcty ~loc:_sloc _1 ) -# 6233 "parsing/parser.ml" +# 6259 "parsing/parser.ml" in -# 1856 "parsing/parser.mly" +# 1906 "parsing/parser.mly" ( _1 ) -# 6239 "parsing/parser.ml" +# 6265 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6282,9 +6308,9 @@ module Tables = struct let domain : (Parsetree.core_type) = Obj.magic domain in let _2 : unit = Obj.magic _2 in let label : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 6288 "parsing/parser.ml" +# 6314 "parsing/parser.ml" ) = Obj.magic label in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_label_ in @@ -6292,14 +6318,14 @@ module Tables = struct let _v : (Parsetree.class_type) = let _1 = let _1 = let label = -# 3179 "parsing/parser.mly" +# 3229 "parsing/parser.mly" ( Labelled label ) -# 6298 "parsing/parser.ml" +# 6324 "parsing/parser.ml" in -# 1855 "parsing/parser.mly" +# 1905 "parsing/parser.mly" ( Pcty_arrow(label, domain, codomain) ) -# 6303 "parsing/parser.ml" +# 6329 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -6307,15 +6333,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 839 "parsing/parser.mly" +# 860 "parsing/parser.mly" ( mkcty ~loc:_sloc _1 ) -# 6313 "parsing/parser.ml" +# 6339 "parsing/parser.ml" in -# 1856 "parsing/parser.mly" +# 1906 "parsing/parser.mly" ( _1 ) -# 6319 "parsing/parser.ml" +# 6345 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6354,14 +6380,14 @@ module Tables = struct let _v : (Parsetree.class_type) = let _1 = let _1 = let label = -# 3181 "parsing/parser.mly" +# 3231 "parsing/parser.mly" ( Nolabel ) -# 6360 "parsing/parser.ml" +# 6386 "parsing/parser.ml" in -# 1855 "parsing/parser.mly" +# 1905 "parsing/parser.mly" ( Pcty_arrow(label, domain, codomain) ) -# 6365 "parsing/parser.ml" +# 6391 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_domain_) in @@ -6369,15 +6395,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 839 "parsing/parser.mly" +# 860 "parsing/parser.mly" ( mkcty ~loc:_sloc _1 ) -# 6375 "parsing/parser.ml" +# 6401 "parsing/parser.ml" in -# 1856 "parsing/parser.mly" +# 1906 "parsing/parser.mly" ( _1 ) -# 6381 "parsing/parser.ml" +# 6407 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6460,9 +6486,9 @@ module Tables = struct let csig : (Parsetree.class_type) = Obj.magic csig in let _8 : unit = Obj.magic _8 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 6466 "parsing/parser.ml" +# 6492 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -6478,9 +6504,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 6484 "parsing/parser.ml" +# 6510 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -6490,24 +6516,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 6496 "parsing/parser.ml" +# 6522 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 6504 "parsing/parser.ml" +# 6530 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1994 "parsing/parser.mly" +# 2044 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -6515,19 +6541,19 @@ module Tables = struct ext, Ci.mk id csig ~virt ~params ~attrs ~loc ~docs ) -# 6519 "parsing/parser.ml" +# 6545 "parsing/parser.ml" in -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 6525 "parsing/parser.ml" +# 6551 "parsing/parser.ml" in -# 1982 "parsing/parser.mly" +# 2032 "parsing/parser.mly" ( _1 ) -# 6531 "parsing/parser.ml" +# 6557 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6545,61 +6571,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : ( -# 642 "parsing/parser.mly" - (string) -# 6552 "parsing/parser.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) = -# 3462 "parsing/parser.mly" - ( Lident _1 ) -# 6560 "parsing/parser.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 : ( -# 642 "parsing/parser.mly" - (string) -# 6593 "parsing/parser.ml" - ) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3463 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 6603 "parsing/parser.ml" +# 3516 "parsing/parser.mly" + ( _1 ) +# 6582 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6618,17 +6597,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 628 "parsing/parser.mly" +# 633 "parsing/parser.mly" (string * char option) -# 6624 "parsing/parser.ml" +# 6603 "parsing/parser.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) = -# 3349 "parsing/parser.mly" +# 3399 "parsing/parser.mly" ( let (n, m) = _1 in Pconst_integer (n, m) ) -# 6632 "parsing/parser.ml" +# 6611 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6647,17 +6626,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 587 "parsing/parser.mly" +# 592 "parsing/parser.mly" (char) -# 6653 "parsing/parser.ml" +# 6632 "parsing/parser.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) = -# 3350 "parsing/parser.mly" +# 3400 "parsing/parser.mly" ( Pconst_char _1 ) -# 6661 "parsing/parser.ml" +# 6640 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6676,17 +6655,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 680 "parsing/parser.mly" - (string * string option) -# 6682 "parsing/parser.ml" +# 685 "parsing/parser.mly" + (string * Location.t * string option) +# 6661 "parsing/parser.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) = -# 3351 "parsing/parser.mly" - ( let (s, d) = _1 in Pconst_string (s, d) ) -# 6690 "parsing/parser.ml" +# 3401 "parsing/parser.mly" + ( let (s, strloc, d) = _1 in Pconst_string (s, strloc, d) ) +# 6669 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6705,46 +6684,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 607 "parsing/parser.mly" +# 612 "parsing/parser.mly" (string * char option) -# 6711 "parsing/parser.ml" +# 6690 "parsing/parser.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) = -# 3352 "parsing/parser.mly" +# 3402 "parsing/parser.mly" ( let (f, m) = _1 in Pconst_float (f, m) ) -# 6719 "parsing/parser.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 : ( -# 688 "parsing/parser.mly" - (string) -# 6740 "parsing/parser.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) = -# 3416 "parsing/parser.mly" - ( _1 ) -# 6748 "parsing/parser.ml" +# 6698 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6773,10 +6723,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 : (string) = -# 3417 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3473 "parsing/parser.mly" ( "[]" ) -# 6780 "parsing/parser.ml" +# 6730 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6805,9 +6755,59 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (string) = -# 3418 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3474 "parsing/parser.mly" ( "()" ) +# 6762 "parsing/parser.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.label) = +# 3475 "parsing/parser.mly" + ( "false" ) +# 6787 "parsing/parser.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.label) = +# 3476 "parsing/parser.mly" + ( "true" ) # 6812 "parsing/parser.ml" in { @@ -6817,6 +6817,35 @@ module Tables = struct 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 : ( +# 697 "parsing/parser.mly" + (string) +# 6833 "parsing/parser.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.label) = +# 3479 "parsing/parser.mly" + ( _1 ) +# 6841 "parsing/parser.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 { @@ -6844,35 +6873,15 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (string) = -# 3419 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3470 "parsing/parser.mly" ( "::" ) -# 6851 "parsing/parser.ml" +# 6880 "parsing/parser.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 : (string) = -# 3420 "parsing/parser.mly" - ( "false" ) -# 6876 "parsing/parser.ml" + +# 3480 "parsing/parser.mly" + ( _1 ) +# 6885 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6890,14 +6899,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 : (Asttypes.label) = 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) = -# 3421 "parsing/parser.mly" - ( "true" ) -# 6901 "parsing/parser.ml" + let _v : (Asttypes.label) = +# 3481 "parsing/parser.mly" + ( _1 ) +# 6910 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6920,9 +6929,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3429 "parsing/parser.mly" - ( _1 ) -# 6926 "parsing/parser.ml" +# 3484 "parsing/parser.mly" + ( _1 ) +# 6935 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6935,19 +6944,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 = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; 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_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2; @@ -6964,18 +6973,26 @@ module Tables = struct }; }; } = _menhir_stack in - let _5 : unit = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in let _3 : unit = Obj.magic _3 in + let _2_inlined1 : unit = Obj.magic _2_inlined1 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _2 : unit = 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__5_ in - let _v : (Longident.t) = -# 3430 "parsing/parser.mly" - ( Ldot(_1,"::") ) -# 6979 "parsing/parser.ml" + let _endpos = _endpos__3_ in + let _v : (Longident.t) = let _3 = + let (_2, _1) = (_2_inlined1, _1_inlined1) in + +# 3470 "parsing/parser.mly" + ( "::" ) +# 6990 "parsing/parser.ml" + + in + +# 3485 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 6996 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6988,26 +7005,38 @@ 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 = _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 = _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 : 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 : (Longident.t) = -# 3431 "parsing/parser.mly" - ( Lident "[]" ) -# 7011 "parsing/parser.ml" + let _endpos = _endpos__3_ in + let _v : (Longident.t) = let _1 = +# 3470 "parsing/parser.mly" + ( "::" ) +# 7035 "parsing/parser.ml" + in + +# 3486 "parsing/parser.mly" + ( Lident _1 ) +# 7040 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7019,116 +7048,20 @@ module Tables = struct (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; - }; + 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 _1 : (Asttypes.label) = 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__1_ in let _v : (Longident.t) = -# 3432 "parsing/parser.mly" - ( Lident "()" ) -# 7043 "parsing/parser.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 : 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 : (Longident.t) = -# 3433 "parsing/parser.mly" - ( Lident "::" ) -# 7082 "parsing/parser.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 : (Longident.t) = -# 3434 "parsing/parser.mly" - ( Lident "false" ) -# 7107 "parsing/parser.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 : (Longident.t) = -# 3435 "parsing/parser.mly" - ( Lident "true" ) -# 7132 "parsing/parser.ml" +# 3487 "parsing/parser.mly" + ( Lident _1 ) +# 7065 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7165,9 +7098,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.core_type * Parsetree.core_type) = -# 1938 "parsing/parser.mly" +# 1988 "parsing/parser.mly" ( _1, _3 ) -# 7171 "parsing/parser.ml" +# 7104 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7192,26 +7125,26 @@ module Tables = struct let _v : (Parsetree.constructor_arguments) = let tys = let xs = let xs = -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 7198 "parsing/parser.ml" +# 7131 "parsing/parser.ml" in -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 7203 "parsing/parser.ml" +# 7136 "parsing/parser.ml" in -# 930 "parsing/parser.mly" +# 951 "parsing/parser.mly" ( xs ) -# 7209 "parsing/parser.ml" +# 7142 "parsing/parser.ml" in -# 2984 "parsing/parser.mly" +# 3034 "parsing/parser.mly" ( Pcstr_tuple tys ) -# 7215 "parsing/parser.ml" +# 7148 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7250,26 +7183,26 @@ module Tables = struct let _v : (Parsetree.constructor_arguments) = let tys = let xs = let xs = -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 7256 "parsing/parser.ml" +# 7189 "parsing/parser.ml" in -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 7261 "parsing/parser.ml" +# 7194 "parsing/parser.ml" in -# 930 "parsing/parser.mly" +# 951 "parsing/parser.mly" ( xs ) -# 7267 "parsing/parser.ml" +# 7200 "parsing/parser.ml" in -# 2984 "parsing/parser.mly" +# 3034 "parsing/parser.mly" ( Pcstr_tuple tys ) -# 7273 "parsing/parser.ml" +# 7206 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7306,9 +7239,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.constructor_arguments) = -# 2986 "parsing/parser.mly" +# 3036 "parsing/parser.mly" ( Pcstr_record _2 ) -# 7312 "parsing/parser.ml" +# 7245 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7331,9 +7264,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constructor_declaration list) = -# 2905 "parsing/parser.mly" +# 2955 "parsing/parser.mly" ( [] ) -# 7337 "parsing/parser.ml" +# 7270 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7356,14 +7289,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.constructor_declaration list) = let cs = -# 1015 "parsing/parser.mly" +# 1036 "parsing/parser.mly" ( List.rev xs ) -# 7362 "parsing/parser.ml" +# 7295 "parsing/parser.ml" in -# 2907 "parsing/parser.mly" +# 2957 "parsing/parser.mly" ( cs ) -# 7367 "parsing/parser.ml" +# 7300 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7386,14 +7319,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 7392 "parsing/parser.ml" +# 7325 "parsing/parser.ml" in -# 3129 "parsing/parser.mly" +# 3179 "parsing/parser.mly" ( _1 ) -# 7397 "parsing/parser.ml" +# 7330 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7423,9 +7356,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type) = -# 3131 "parsing/parser.mly" +# 3181 "parsing/parser.mly" ( Typ.attr _1 _2 ) -# 7429 "parsing/parser.ml" +# 7362 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7448,9 +7381,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.direction_flag) = -# 3516 "parsing/parser.mly" +# 3578 "parsing/parser.mly" ( Upto ) -# 7454 "parsing/parser.ml" +# 7387 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7473,9 +7406,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.direction_flag) = -# 3517 "parsing/parser.mly" +# 3579 "parsing/parser.mly" ( Downto ) -# 7479 "parsing/parser.ml" +# 7412 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7498,9 +7431,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = -# 2085 "parsing/parser.mly" +# 2135 "parsing/parser.mly" ( _1 ) -# 7504 "parsing/parser.ml" +# 7437 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7578,9 +7511,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 7584 "parsing/parser.ml" +# 7517 "parsing/parser.ml" in let _3 = @@ -7588,21 +7521,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 7594 "parsing/parser.ml" +# 7527 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 7600 "parsing/parser.ml" +# 7533 "parsing/parser.ml" in -# 2133 "parsing/parser.mly" +# 2183 "parsing/parser.mly" ( Pexp_letmodule(_4, _5, _7), _3 ) -# 7606 "parsing/parser.ml" +# 7539 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -7610,10 +7543,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 7617 "parsing/parser.ml" +# 7550 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7683,7 +7616,7 @@ module Tables = struct let _5 : unit = Obj.magic _5 in let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in let _2_inlined1 : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic _2_inlined1 in - let _1_inlined3 : (string) = Obj.magic _1_inlined3 in + let _1_inlined3 : (Asttypes.label) = Obj.magic _1_inlined3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in @@ -7697,9 +7630,9 @@ module Tables = struct let _3 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 7703 "parsing/parser.ml" +# 7636 "parsing/parser.ml" in let _endpos__3_ = _endpos__1_inlined1_ in @@ -7708,19 +7641,19 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 7714 "parsing/parser.ml" +# 7647 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2969 "parsing/parser.mly" +# 3019 "parsing/parser.mly" ( let args, res = _2 in Te.decl _1 ~args ?res ~attrs:_3 ~loc:(make_loc _sloc) ) -# 7724 "parsing/parser.ml" +# 7657 "parsing/parser.ml" in let _3 = @@ -7728,21 +7661,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 7734 "parsing/parser.ml" +# 7667 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 7740 "parsing/parser.ml" +# 7673 "parsing/parser.ml" in -# 2135 "parsing/parser.mly" +# 2185 "parsing/parser.mly" ( Pexp_letexception(_4, _6), _3 ) -# 7746 "parsing/parser.ml" +# 7679 "parsing/parser.ml" in let _endpos__1_ = _endpos__6_ in @@ -7750,10 +7683,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 7757 "parsing/parser.ml" +# 7690 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7823,28 +7756,28 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 7829 "parsing/parser.ml" +# 7762 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 7835 "parsing/parser.ml" +# 7768 "parsing/parser.ml" in let _3 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 7841 "parsing/parser.ml" +# 7774 "parsing/parser.ml" in -# 2137 "parsing/parser.mly" +# 2187 "parsing/parser.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, _7), _4 ) -# 7848 "parsing/parser.ml" +# 7781 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -7852,10 +7785,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 7859 "parsing/parser.ml" +# 7792 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7932,31 +7865,31 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 7938 "parsing/parser.ml" +# 7871 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 7944 "parsing/parser.ml" +# 7877 "parsing/parser.ml" in let _3 = let _1 = _1_inlined1 in -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 7952 "parsing/parser.ml" +# 7885 "parsing/parser.ml" in -# 2137 "parsing/parser.mly" +# 2187 "parsing/parser.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, _7), _4 ) -# 7960 "parsing/parser.ml" +# 7893 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -7964,10 +7897,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 7971 "parsing/parser.ml" +# 7904 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8014,20 +7947,20 @@ module Tables = struct let _3 = let xs = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 8020 "parsing/parser.ml" +# 7953 "parsing/parser.ml" in -# 987 "parsing/parser.mly" +# 1008 "parsing/parser.mly" ( xs ) -# 8025 "parsing/parser.ml" +# 7958 "parsing/parser.ml" in -# 2469 "parsing/parser.mly" +# 2519 "parsing/parser.mly" ( xs ) -# 8031 "parsing/parser.ml" +# 7964 "parsing/parser.ml" in let _2 = @@ -8035,21 +7968,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8041 "parsing/parser.ml" +# 7974 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8047 "parsing/parser.ml" +# 7980 "parsing/parser.ml" in -# 2141 "parsing/parser.mly" +# 2191 "parsing/parser.mly" ( Pexp_function _3, _2 ) -# 8053 "parsing/parser.ml" +# 7986 "parsing/parser.ml" in let _endpos__1_ = _endpos_xs_ in @@ -8057,10 +7990,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8064 "parsing/parser.ml" +# 7997 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8116,22 +8049,22 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8122 "parsing/parser.ml" +# 8055 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8128 "parsing/parser.ml" +# 8061 "parsing/parser.ml" in -# 2143 "parsing/parser.mly" +# 2193 "parsing/parser.mly" ( let (l,o,p) = _3 in Pexp_fun(l, o, p, _4), _2 ) -# 8135 "parsing/parser.ml" +# 8068 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -8139,10 +8072,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8146 "parsing/parser.ml" +# 8079 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8215,33 +8148,33 @@ module Tables = struct let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _1 = let _5 = -# 2364 "parsing/parser.mly" +# 2414 "parsing/parser.mly" ( xs ) -# 8221 "parsing/parser.ml" +# 8154 "parsing/parser.ml" in let _2 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8230 "parsing/parser.ml" +# 8163 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8236 "parsing/parser.ml" +# 8169 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2146 "parsing/parser.mly" +# 2196 "parsing/parser.mly" ( (mk_newtypes ~loc:_sloc _5 _7).pexp_desc, _2 ) -# 8245 "parsing/parser.ml" +# 8178 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -8249,10 +8182,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8256 "parsing/parser.ml" +# 8189 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8313,20 +8246,20 @@ module Tables = struct let _5 = let xs = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 8319 "parsing/parser.ml" +# 8252 "parsing/parser.ml" in -# 987 "parsing/parser.mly" +# 1008 "parsing/parser.mly" ( xs ) -# 8324 "parsing/parser.ml" +# 8257 "parsing/parser.ml" in -# 2469 "parsing/parser.mly" +# 2519 "parsing/parser.mly" ( xs ) -# 8330 "parsing/parser.ml" +# 8263 "parsing/parser.ml" in let _2 = @@ -8334,21 +8267,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8340 "parsing/parser.ml" +# 8273 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8346 "parsing/parser.ml" +# 8279 "parsing/parser.ml" in -# 2148 "parsing/parser.mly" +# 2198 "parsing/parser.mly" ( Pexp_match(_3, _5), _2 ) -# 8352 "parsing/parser.ml" +# 8285 "parsing/parser.ml" in let _endpos__1_ = _endpos_xs_ in @@ -8356,10 +8289,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8363 "parsing/parser.ml" +# 8296 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8420,20 +8353,20 @@ module Tables = struct let _5 = let xs = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 8426 "parsing/parser.ml" +# 8359 "parsing/parser.ml" in -# 987 "parsing/parser.mly" +# 1008 "parsing/parser.mly" ( xs ) -# 8431 "parsing/parser.ml" +# 8364 "parsing/parser.ml" in -# 2469 "parsing/parser.mly" +# 2519 "parsing/parser.mly" ( xs ) -# 8437 "parsing/parser.ml" +# 8370 "parsing/parser.ml" in let _2 = @@ -8441,21 +8374,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8447 "parsing/parser.ml" +# 8380 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8453 "parsing/parser.ml" +# 8386 "parsing/parser.ml" in -# 2150 "parsing/parser.mly" +# 2200 "parsing/parser.mly" ( Pexp_try(_3, _5), _2 ) -# 8459 "parsing/parser.ml" +# 8392 "parsing/parser.ml" in let _endpos__1_ = _endpos_xs_ in @@ -8463,10 +8396,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8470 "parsing/parser.ml" +# 8403 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8529,21 +8462,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8535 "parsing/parser.ml" +# 8468 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8541 "parsing/parser.ml" +# 8474 "parsing/parser.ml" in -# 2152 "parsing/parser.mly" +# 2202 "parsing/parser.mly" ( syntax_error() ) -# 8547 "parsing/parser.ml" +# 8480 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -8551,10 +8484,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8558 "parsing/parser.ml" +# 8491 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8631,21 +8564,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8637 "parsing/parser.ml" +# 8570 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8643 "parsing/parser.ml" +# 8576 "parsing/parser.ml" in -# 2154 "parsing/parser.mly" +# 2204 "parsing/parser.mly" ( Pexp_ifthenelse(_3, _5, Some _7), _2 ) -# 8649 "parsing/parser.ml" +# 8582 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -8653,10 +8586,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8660 "parsing/parser.ml" +# 8593 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8719,21 +8652,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8725 "parsing/parser.ml" +# 8658 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8731 "parsing/parser.ml" +# 8664 "parsing/parser.ml" in -# 2156 "parsing/parser.mly" +# 2206 "parsing/parser.mly" ( Pexp_ifthenelse(_3, _5, None), _2 ) -# 8737 "parsing/parser.ml" +# 8670 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -8741,10 +8674,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8748 "parsing/parser.ml" +# 8681 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8814,21 +8747,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8820 "parsing/parser.ml" +# 8753 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8826 "parsing/parser.ml" +# 8759 "parsing/parser.ml" in -# 2158 "parsing/parser.mly" +# 2208 "parsing/parser.mly" ( Pexp_while(_3, _5), _2 ) -# 8832 "parsing/parser.ml" +# 8765 "parsing/parser.ml" in let _endpos__1_ = _endpos__6_ in @@ -8836,10 +8769,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8843 "parsing/parser.ml" +# 8776 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8937,21 +8870,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 8943 "parsing/parser.ml" +# 8876 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 8949 "parsing/parser.ml" +# 8882 "parsing/parser.ml" in -# 2161 "parsing/parser.mly" +# 2211 "parsing/parser.mly" ( Pexp_for(_3, _5, _7, _6, _9), _2 ) -# 8955 "parsing/parser.ml" +# 8888 "parsing/parser.ml" in let _endpos__1_ = _endpos__10_ in @@ -8959,10 +8892,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 8966 "parsing/parser.ml" +# 8899 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9011,21 +8944,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 9017 "parsing/parser.ml" +# 8950 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 9023 "parsing/parser.ml" +# 8956 "parsing/parser.ml" in -# 2163 "parsing/parser.mly" +# 2213 "parsing/parser.mly" ( Pexp_assert _3, _2 ) -# 9029 "parsing/parser.ml" +# 8962 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -9033,10 +8966,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9040 "parsing/parser.ml" +# 8973 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9085,21 +9018,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 9091 "parsing/parser.ml" +# 9024 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 9097 "parsing/parser.ml" +# 9030 "parsing/parser.ml" in -# 2165 "parsing/parser.mly" +# 2215 "parsing/parser.mly" ( Pexp_lazy _3, _2 ) -# 9103 "parsing/parser.ml" +# 9036 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -9107,10 +9040,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9114 "parsing/parser.ml" +# 9047 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9173,29 +9106,29 @@ module Tables = struct let _2 = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 9179 "parsing/parser.ml" +# 9112 "parsing/parser.ml" in -# 1771 "parsing/parser.mly" +# 1821 "parsing/parser.mly" ( _1 ) -# 9184 "parsing/parser.ml" +# 9117 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 786 "parsing/parser.mly" +# 807 "parsing/parser.mly" ( extra_cstr _startpos _endpos _1 ) -# 9193 "parsing/parser.ml" +# 9126 "parsing/parser.ml" in -# 1758 "parsing/parser.mly" +# 1808 "parsing/parser.mly" ( Cstr.mk _1 _2 ) -# 9199 "parsing/parser.ml" +# 9132 "parsing/parser.ml" in let _2 = @@ -9203,21 +9136,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 9209 "parsing/parser.ml" +# 9142 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 9215 "parsing/parser.ml" +# 9148 "parsing/parser.ml" in -# 2167 "parsing/parser.mly" +# 2217 "parsing/parser.mly" ( Pexp_object _3, _2 ) -# 9221 "parsing/parser.ml" +# 9154 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -9225,10 +9158,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9232 "parsing/parser.ml" +# 9165 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9291,29 +9224,29 @@ module Tables = struct let _2 = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 9297 "parsing/parser.ml" +# 9230 "parsing/parser.ml" in -# 1771 "parsing/parser.mly" +# 1821 "parsing/parser.mly" ( _1 ) -# 9302 "parsing/parser.ml" +# 9235 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 786 "parsing/parser.mly" +# 807 "parsing/parser.mly" ( extra_cstr _startpos _endpos _1 ) -# 9311 "parsing/parser.ml" +# 9244 "parsing/parser.ml" in -# 1758 "parsing/parser.mly" +# 1808 "parsing/parser.mly" ( Cstr.mk _1 _2 ) -# 9317 "parsing/parser.ml" +# 9250 "parsing/parser.ml" in let _2 = @@ -9321,23 +9254,23 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 9327 "parsing/parser.ml" +# 9260 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 9333 "parsing/parser.ml" +# 9266 "parsing/parser.ml" in let _loc__4_ = (_startpos__4_, _endpos__4_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2169 "parsing/parser.mly" +# 2219 "parsing/parser.mly" ( unclosed "object" _loc__1_ "end" _loc__4_ ) -# 9341 "parsing/parser.ml" +# 9274 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -9345,10 +9278,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2087 "parsing/parser.mly" +# 2137 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9352 "parsing/parser.ml" +# 9285 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9381,20 +9314,20 @@ module Tables = struct let _1 = let _2 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 9387 "parsing/parser.ml" +# 9320 "parsing/parser.ml" in -# 894 "parsing/parser.mly" +# 915 "parsing/parser.mly" ( xs ) -# 9392 "parsing/parser.ml" +# 9325 "parsing/parser.ml" in -# 2173 "parsing/parser.mly" +# 2223 "parsing/parser.mly" ( Pexp_apply(_1, _2) ) -# 9398 "parsing/parser.ml" +# 9331 "parsing/parser.ml" in let _endpos__1_ = _endpos_xs_ in @@ -9402,15 +9335,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9408 "parsing/parser.ml" +# 9341 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9414 "parsing/parser.ml" +# 9347 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9437,26 +9370,26 @@ module Tables = struct let _1 = let es = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 9443 "parsing/parser.ml" +# 9376 "parsing/parser.ml" in -# 954 "parsing/parser.mly" +# 975 "parsing/parser.mly" ( xs ) -# 9448 "parsing/parser.ml" +# 9381 "parsing/parser.ml" in -# 2496 "parsing/parser.mly" +# 2546 "parsing/parser.mly" ( es ) -# 9454 "parsing/parser.ml" +# 9387 "parsing/parser.ml" in -# 2175 "parsing/parser.mly" +# 2225 "parsing/parser.mly" ( Pexp_tuple(_1) ) -# 9460 "parsing/parser.ml" +# 9393 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in @@ -9464,15 +9397,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9470 "parsing/parser.ml" +# 9403 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9476 "parsing/parser.ml" +# 9409 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9508,15 +9441,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 9514 "parsing/parser.ml" +# 9447 "parsing/parser.ml" in -# 2177 "parsing/parser.mly" +# 2227 "parsing/parser.mly" ( Pexp_construct(_1, Some _2) ) -# 9520 "parsing/parser.ml" +# 9453 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in @@ -9524,15 +9457,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9530 "parsing/parser.ml" +# 9463 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9536 "parsing/parser.ml" +# 9469 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9563,24 +9496,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2179 "parsing/parser.mly" +# 2229 "parsing/parser.mly" ( Pexp_variant(_1, Some _2) ) -# 9569 "parsing/parser.ml" +# 9502 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9578 "parsing/parser.ml" +# 9511 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9584 "parsing/parser.ml" +# 9517 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9612,9 +9545,9 @@ module Tables = struct } = _menhir_stack in let e2 : (Parsetree.expression) = Obj.magic e2 in let op : ( -# 618 "parsing/parser.mly" +# 623 "parsing/parser.mly" (string) -# 9618 "parsing/parser.ml" +# 9551 "parsing/parser.ml" ) = Obj.magic op in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -9624,24 +9557,24 @@ module Tables = struct let _1 = let op = let _1 = -# 3390 "parsing/parser.mly" +# 3443 "parsing/parser.mly" ( op ) -# 9630 "parsing/parser.ml" +# 9563 "parsing/parser.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 -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 9639 "parsing/parser.ml" +# 9572 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 9645 "parsing/parser.ml" +# 9578 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -9649,15 +9582,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9655 "parsing/parser.ml" +# 9588 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9661 "parsing/parser.ml" +# 9594 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9689,9 +9622,9 @@ module Tables = struct } = _menhir_stack in let e2 : (Parsetree.expression) = Obj.magic e2 in let op : ( -# 619 "parsing/parser.mly" +# 624 "parsing/parser.mly" (string) -# 9695 "parsing/parser.ml" +# 9628 "parsing/parser.ml" ) = Obj.magic op in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -9701,24 +9634,24 @@ module Tables = struct let _1 = let op = let _1 = -# 3391 "parsing/parser.mly" +# 3444 "parsing/parser.mly" ( op ) -# 9707 "parsing/parser.ml" +# 9640 "parsing/parser.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 -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 9716 "parsing/parser.ml" +# 9649 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 9722 "parsing/parser.ml" +# 9655 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -9726,15 +9659,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9732 "parsing/parser.ml" +# 9665 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9738 "parsing/parser.ml" +# 9671 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9766,9 +9699,9 @@ module Tables = struct } = _menhir_stack in let e2 : (Parsetree.expression) = Obj.magic e2 in let op : ( -# 620 "parsing/parser.mly" +# 625 "parsing/parser.mly" (string) -# 9772 "parsing/parser.ml" +# 9705 "parsing/parser.ml" ) = Obj.magic op in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -9778,24 +9711,24 @@ module Tables = struct let _1 = let op = let _1 = -# 3392 "parsing/parser.mly" +# 3445 "parsing/parser.mly" ( op ) -# 9784 "parsing/parser.ml" +# 9717 "parsing/parser.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 -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 9793 "parsing/parser.ml" +# 9726 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 9799 "parsing/parser.ml" +# 9732 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -9803,15 +9736,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9809 "parsing/parser.ml" +# 9742 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9815 "parsing/parser.ml" +# 9748 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9843,9 +9776,9 @@ module Tables = struct } = _menhir_stack in let e2 : (Parsetree.expression) = Obj.magic e2 in let op : ( -# 621 "parsing/parser.mly" +# 626 "parsing/parser.mly" (string) -# 9849 "parsing/parser.ml" +# 9782 "parsing/parser.ml" ) = Obj.magic op in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -9855,24 +9788,24 @@ module Tables = struct let _1 = let op = let _1 = -# 3393 "parsing/parser.mly" +# 3446 "parsing/parser.mly" ( op ) -# 9861 "parsing/parser.ml" +# 9794 "parsing/parser.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 -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 9870 "parsing/parser.ml" +# 9803 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 9876 "parsing/parser.ml" +# 9809 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -9880,15 +9813,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9886 "parsing/parser.ml" +# 9819 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9892 "parsing/parser.ml" +# 9825 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9920,9 +9853,9 @@ module Tables = struct } = _menhir_stack in let e2 : (Parsetree.expression) = Obj.magic e2 in let op : ( -# 622 "parsing/parser.mly" +# 627 "parsing/parser.mly" (string) -# 9926 "parsing/parser.ml" +# 9859 "parsing/parser.ml" ) = Obj.magic op in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -9932,24 +9865,24 @@ module Tables = struct let _1 = let op = let _1 = -# 3394 "parsing/parser.mly" +# 3447 "parsing/parser.mly" ( op ) -# 9938 "parsing/parser.ml" +# 9871 "parsing/parser.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 -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 9947 "parsing/parser.ml" +# 9880 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 9953 "parsing/parser.ml" +# 9886 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -9957,15 +9890,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 9963 "parsing/parser.ml" +# 9896 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 9969 "parsing/parser.ml" +# 9902 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10005,23 +9938,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3395 "parsing/parser.mly" +# 3448 "parsing/parser.mly" ("+") -# 10011 "parsing/parser.ml" +# 9944 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10019 "parsing/parser.ml" +# 9952 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10025 "parsing/parser.ml" +# 9958 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10029,15 +9962,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10035 "parsing/parser.ml" +# 9968 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10041 "parsing/parser.ml" +# 9974 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10077,23 +10010,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3396 "parsing/parser.mly" +# 3449 "parsing/parser.mly" ("+.") -# 10083 "parsing/parser.ml" +# 10016 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10091 "parsing/parser.ml" +# 10024 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10097 "parsing/parser.ml" +# 10030 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10101,15 +10034,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10107 "parsing/parser.ml" +# 10040 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10113 "parsing/parser.ml" +# 10046 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10149,23 +10082,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3397 "parsing/parser.mly" +# 3450 "parsing/parser.mly" ("+=") -# 10155 "parsing/parser.ml" +# 10088 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10163 "parsing/parser.ml" +# 10096 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10169 "parsing/parser.ml" +# 10102 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10173,15 +10106,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10179 "parsing/parser.ml" +# 10112 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10185 "parsing/parser.ml" +# 10118 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10221,23 +10154,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3398 "parsing/parser.mly" +# 3451 "parsing/parser.mly" ("-") -# 10227 "parsing/parser.ml" +# 10160 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10235 "parsing/parser.ml" +# 10168 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10241 "parsing/parser.ml" +# 10174 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10245,15 +10178,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10251 "parsing/parser.ml" +# 10184 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10257 "parsing/parser.ml" +# 10190 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10293,23 +10226,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3399 "parsing/parser.mly" +# 3452 "parsing/parser.mly" ("-.") -# 10299 "parsing/parser.ml" +# 10232 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10307 "parsing/parser.ml" +# 10240 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10313 "parsing/parser.ml" +# 10246 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10317,15 +10250,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10323 "parsing/parser.ml" +# 10256 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10329 "parsing/parser.ml" +# 10262 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10365,23 +10298,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3400 "parsing/parser.mly" +# 3453 "parsing/parser.mly" ("*") -# 10371 "parsing/parser.ml" +# 10304 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10379 "parsing/parser.ml" +# 10312 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10385 "parsing/parser.ml" +# 10318 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10389,15 +10322,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10395 "parsing/parser.ml" +# 10328 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10401 "parsing/parser.ml" +# 10334 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10437,23 +10370,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3401 "parsing/parser.mly" +# 3454 "parsing/parser.mly" ("%") -# 10443 "parsing/parser.ml" +# 10376 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10451 "parsing/parser.ml" +# 10384 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10457 "parsing/parser.ml" +# 10390 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10461,15 +10394,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10467 "parsing/parser.ml" +# 10400 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10473 "parsing/parser.ml" +# 10406 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10509,23 +10442,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3402 "parsing/parser.mly" +# 3455 "parsing/parser.mly" ("=") -# 10515 "parsing/parser.ml" +# 10448 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10523 "parsing/parser.ml" +# 10456 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10529 "parsing/parser.ml" +# 10462 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10533,15 +10466,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10539 "parsing/parser.ml" +# 10472 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10545 "parsing/parser.ml" +# 10478 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10581,23 +10514,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3403 "parsing/parser.mly" +# 3456 "parsing/parser.mly" ("<") -# 10587 "parsing/parser.ml" +# 10520 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10595 "parsing/parser.ml" +# 10528 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10601 "parsing/parser.ml" +# 10534 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10605,15 +10538,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10611 "parsing/parser.ml" +# 10544 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10617 "parsing/parser.ml" +# 10550 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10653,23 +10586,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3404 "parsing/parser.mly" +# 3457 "parsing/parser.mly" (">") -# 10659 "parsing/parser.ml" +# 10592 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10667 "parsing/parser.ml" +# 10600 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10673 "parsing/parser.ml" +# 10606 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10677,15 +10610,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10683 "parsing/parser.ml" +# 10616 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10689 "parsing/parser.ml" +# 10622 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10725,23 +10658,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3405 "parsing/parser.mly" +# 3458 "parsing/parser.mly" ("or") -# 10731 "parsing/parser.ml" +# 10664 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10739 "parsing/parser.ml" +# 10672 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10745 "parsing/parser.ml" +# 10678 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10749,15 +10682,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10755 "parsing/parser.ml" +# 10688 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10761 "parsing/parser.ml" +# 10694 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10797,23 +10730,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3406 "parsing/parser.mly" +# 3459 "parsing/parser.mly" ("||") -# 10803 "parsing/parser.ml" +# 10736 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10811 "parsing/parser.ml" +# 10744 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10817 "parsing/parser.ml" +# 10750 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10821,15 +10754,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10827 "parsing/parser.ml" +# 10760 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10833 "parsing/parser.ml" +# 10766 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10869,23 +10802,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3407 "parsing/parser.mly" +# 3460 "parsing/parser.mly" ("&") -# 10875 "parsing/parser.ml" +# 10808 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10883 "parsing/parser.ml" +# 10816 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10889 "parsing/parser.ml" +# 10822 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10893,15 +10826,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10899 "parsing/parser.ml" +# 10832 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10905 "parsing/parser.ml" +# 10838 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10941,23 +10874,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3408 "parsing/parser.mly" +# 3461 "parsing/parser.mly" ("&&") -# 10947 "parsing/parser.ml" +# 10880 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 10955 "parsing/parser.ml" +# 10888 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 10961 "parsing/parser.ml" +# 10894 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -10965,15 +10898,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 10971 "parsing/parser.ml" +# 10904 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 10977 "parsing/parser.ml" +# 10910 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11013,23 +10946,23 @@ module Tables = struct let _1 = let op = let _1 = -# 3409 "parsing/parser.mly" +# 3462 "parsing/parser.mly" (":=") -# 11019 "parsing/parser.ml" +# 10952 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 11027 "parsing/parser.ml" +# 10960 "parsing/parser.ml" in -# 2181 "parsing/parser.mly" +# 2231 "parsing/parser.mly" ( mkinfix e1 op e2 ) -# 11033 "parsing/parser.ml" +# 10966 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in @@ -11037,15 +10970,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 11043 "parsing/parser.ml" +# 10976 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 11049 "parsing/parser.ml" +# 10982 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11078,9 +11011,9 @@ module Tables = struct let _1 = let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2183 "parsing/parser.mly" +# 2233 "parsing/parser.mly" ( mkuminus ~oploc:_loc__1_ _1 _2 ) -# 11084 "parsing/parser.ml" +# 11017 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in @@ -11088,15 +11021,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 11094 "parsing/parser.ml" +# 11027 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 11100 "parsing/parser.ml" +# 11033 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11129,9 +11062,9 @@ module Tables = struct let _1 = let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2185 "parsing/parser.mly" +# 2235 "parsing/parser.mly" ( mkuplus ~oploc:_loc__1_ _1 _2 ) -# 11135 "parsing/parser.ml" +# 11068 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in @@ -11139,15 +11072,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 11145 "parsing/parser.ml" +# 11078 "parsing/parser.ml" in -# 2090 "parsing/parser.mly" +# 2140 "parsing/parser.mly" ( _1 ) -# 11151 "parsing/parser.ml" +# 11084 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11187,9 +11120,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2092 "parsing/parser.mly" +# 2142 "parsing/parser.mly" ( expr_of_let_bindings ~loc:_sloc _1 _3 ) -# 11193 "parsing/parser.ml" +# 11126 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11229,9 +11162,9 @@ module Tables = struct let _3 : unit = Obj.magic _3 in let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in let _1 : ( -# 624 "parsing/parser.mly" +# 629 "parsing/parser.mly" (string) -# 11235 "parsing/parser.ml" +# 11168 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -11241,9 +11174,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 11247 "parsing/parser.ml" +# 11180 "parsing/parser.ml" in let _startpos_pbop_op_ = _startpos__1_ in @@ -11251,13 +11184,13 @@ module Tables = struct let _symbolstartpos = _startpos_pbop_op_ in let _sloc = (_symbolstartpos, _endpos) in -# 2094 "parsing/parser.mly" +# 2144 "parsing/parser.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}) ) -# 11261 "parsing/parser.ml" +# 11194 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11298,9 +11231,9 @@ module Tables = struct let _loc__2_ = (_startpos__2_, _endpos__2_) in let _sloc = (_symbolstartpos, _endpos) in -# 2100 "parsing/parser.mly" +# 2150 "parsing/parser.mly" ( mkexp_cons ~loc:_sloc _loc__2_ (ghexp ~loc:_sloc (Pexp_tuple[_1;_3])) ) -# 11304 "parsing/parser.ml" +# 11237 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11333,35 +11266,35 @@ module Tables = struct let _3 : (Parsetree.expression) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 11339 "parsing/parser.ml" +# 11272 "parsing/parser.ml" ) = 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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 11348 "parsing/parser.ml" +# 11281 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 11356 "parsing/parser.ml" +# 11289 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2102 "parsing/parser.mly" +# 2152 "parsing/parser.mly" ( mkexp ~loc:_sloc (Pexp_setinstvar(_1, _3)) ) -# 11365 "parsing/parser.ml" +# 11298 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11417,18 +11350,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 11423 "parsing/parser.ml" +# 11356 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2104 "parsing/parser.mly" +# 2154 "parsing/parser.mly" ( mkexp ~loc:_sloc (Pexp_setfield(_1, _3, _5)) ) -# 11432 "parsing/parser.ml" +# 11365 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11496,9 +11429,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2106 "parsing/parser.mly" +# 2156 "parsing/parser.mly" ( array_set ~loc:_sloc _1 _4 _7 ) -# 11502 "parsing/parser.ml" +# 11435 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11566,9 +11499,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2108 "parsing/parser.mly" +# 2158 "parsing/parser.mly" ( string_set ~loc:_sloc _1 _4 _7 ) -# 11572 "parsing/parser.ml" +# 11505 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11636,9 +11569,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2110 "parsing/parser.mly" +# 2160 "parsing/parser.mly" ( bigarray_set ~loc:_sloc _1 _4 _7 ) -# 11642 "parsing/parser.ml" +# 11575 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11698,26 +11631,26 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 11704 "parsing/parser.ml" +# 11637 "parsing/parser.ml" ) = 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__7_ in let _v : (Parsetree.expression) = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 11713 "parsing/parser.ml" +# 11646 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2112 "parsing/parser.mly" +# 2162 "parsing/parser.mly" ( dotop_set ~loc:_sloc lident bracket _2 _1 _4 _7 ) -# 11721 "parsing/parser.ml" +# 11654 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11777,26 +11710,26 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 11783 "parsing/parser.ml" +# 11716 "parsing/parser.ml" ) = 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__7_ in let _v : (Parsetree.expression) = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 11792 "parsing/parser.ml" +# 11725 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2114 "parsing/parser.mly" +# 2164 "parsing/parser.mly" ( dotop_set ~loc:_sloc lident paren _2 _1 _4 _7 ) -# 11800 "parsing/parser.ml" +# 11733 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11856,26 +11789,26 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 11862 "parsing/parser.ml" +# 11795 "parsing/parser.ml" ) = 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__7_ in let _v : (Parsetree.expression) = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 11871 "parsing/parser.ml" +# 11804 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2116 "parsing/parser.mly" +# 2166 "parsing/parser.mly" ( dotop_set ~loc:_sloc lident brace _2 _1 _4 _7 ) -# 11879 "parsing/parser.ml" +# 11812 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11947,9 +11880,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 11953 "parsing/parser.ml" +# 11886 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -11958,17 +11891,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__9_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 11964 "parsing/parser.ml" +# 11897 "parsing/parser.ml" in let _endpos = _endpos__9_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2119 "parsing/parser.mly" +# 2169 "parsing/parser.mly" ( dotop_set ~loc:_sloc (ldot _3) bracket _4 _1 _6 _9 ) -# 11972 "parsing/parser.ml" +# 11905 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12040,9 +11973,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 12046 "parsing/parser.ml" +# 11979 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -12051,17 +11984,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__9_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 12057 "parsing/parser.ml" +# 11990 "parsing/parser.ml" in let _endpos = _endpos__9_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2122 "parsing/parser.mly" +# 2172 "parsing/parser.mly" ( dotop_set ~loc:_sloc (ldot _3) paren _4 _1 _6 _9 ) -# 12065 "parsing/parser.ml" +# 11998 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12133,9 +12066,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 12139 "parsing/parser.ml" +# 12072 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -12144,17 +12077,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__9_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 12150 "parsing/parser.ml" +# 12083 "parsing/parser.ml" in let _endpos = _endpos__9_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2125 "parsing/parser.mly" +# 2175 "parsing/parser.mly" ( dotop_set ~loc:_sloc (ldot _3) brace _4 _1 _6 _9 ) -# 12158 "parsing/parser.ml" +# 12091 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12184,9 +12117,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = -# 2127 "parsing/parser.mly" +# 2177 "parsing/parser.mly" ( Exp.attr _1 _2 ) -# 12190 "parsing/parser.ml" +# 12123 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12210,9 +12143,9 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2129 "parsing/parser.mly" +# 2179 "parsing/parser.mly" ( not_expecting _loc__1_ "wildcard \"_\"" ) -# 12216 "parsing/parser.ml" +# 12149 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12228,9 +12161,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (string Asttypes.loc option) = -# 3672 "parsing/parser.mly" +# 3734 "parsing/parser.mly" ( None ) -# 12234 "parsing/parser.ml" +# 12167 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12260,9 +12193,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (string Asttypes.loc option) = -# 3673 "parsing/parser.mly" +# 3735 "parsing/parser.mly" ( Some _2 ) -# 12266 "parsing/parser.ml" +# 12199 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12306,9 +12239,41 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.extension) = -# 3683 "parsing/parser.mly" - ( (_2, _3) ) -# 12312 "parsing/parser.ml" +# 3745 "parsing/parser.mly" + ( (_2, _3) ) +# 12245 "parsing/parser.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 : ( +# 687 "parsing/parser.mly" + (string * Location.t * string * Location.t * string option) +# 12266 "parsing/parser.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.extension) = let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3747 "parsing/parser.mly" + ( mk_quotedext ~loc:_sloc _1 ) +# 12277 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12353,7 +12318,7 @@ module Tables = struct 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_inlined1 : (Asttypes.label) = 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 @@ -12361,9 +12326,9 @@ module Tables = struct let _v : (Parsetree.extension_constructor) = let attrs = let _1 = _1_inlined3 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 12367 "parsing/parser.ml" +# 12332 "parsing/parser.ml" in let _endpos_attrs_ = _endpos__1_inlined3_ in @@ -12373,9 +12338,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 12379 "parsing/parser.ml" +# 12344 "parsing/parser.ml" in let cid = @@ -12384,19 +12349,19 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 12390 "parsing/parser.ml" +# 12355 "parsing/parser.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3053 "parsing/parser.mly" +# 3103 "parsing/parser.mly" ( let info = symbol_info _endpos in Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info ) -# 12400 "parsing/parser.ml" +# 12365 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12435,16 +12400,16 @@ module Tables = struct 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 _1 : (Asttypes.label) = 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 -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 12448 "parsing/parser.ml" +# 12413 "parsing/parser.ml" in let _endpos_attrs_ = _endpos__1_inlined2_ in @@ -12454,9 +12419,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 12460 "parsing/parser.ml" +# 12425 "parsing/parser.ml" in let cid = @@ -12464,25 +12429,25 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 12470 "parsing/parser.ml" +# 12435 "parsing/parser.ml" in let _startpos_cid_ = _startpos__1_ in let _1 = -# 3492 "parsing/parser.mly" +# 3554 "parsing/parser.mly" ( () ) -# 12477 "parsing/parser.ml" +# 12442 "parsing/parser.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos_cid_ in let _sloc = (_symbolstartpos, _endpos) in -# 3053 "parsing/parser.mly" +# 3103 "parsing/parser.mly" ( let info = symbol_info _endpos in Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info ) -# 12486 "parsing/parser.ml" +# 12451 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12529,10 +12494,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3660 "parsing/parser.mly" +# 3722 "parsing/parser.mly" ( mark_symbol_docs _sloc; Attr.mk ~loc:(make_loc _sloc) _2 _3 ) -# 12536 "parsing/parser.ml" +# 12501 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12548,14 +12513,14 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : ((Parsetree.core_type * Asttypes.variance) list) = let params = -# 1878 "parsing/parser.mly" +# 1928 "parsing/parser.mly" ( [] ) -# 12554 "parsing/parser.ml" +# 12519 "parsing/parser.ml" in -# 1703 "parsing/parser.mly" +# 1753 "parsing/parser.mly" ( params ) -# 12559 "parsing/parser.ml" +# 12524 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12594,26 +12559,26 @@ module Tables = struct let _v : ((Parsetree.core_type * Asttypes.variance) list) = let params = let params = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 12600 "parsing/parser.ml" +# 12565 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 12605 "parsing/parser.ml" +# 12570 "parsing/parser.ml" in -# 1880 "parsing/parser.mly" +# 1930 "parsing/parser.mly" ( params ) -# 12611 "parsing/parser.ml" +# 12576 "parsing/parser.ml" in -# 1703 "parsing/parser.mly" +# 1753 "parsing/parser.mly" ( params ) -# 12617 "parsing/parser.ml" +# 12582 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12636,9 +12601,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = -# 2455 "parsing/parser.mly" +# 2505 "parsing/parser.mly" ( _1 ) -# 12642 "parsing/parser.ml" +# 12607 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12678,9 +12643,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2457 "parsing/parser.mly" +# 2507 "parsing/parser.mly" ( mkexp_constraint ~loc:_sloc _3 _1 ) -# 12684 "parsing/parser.ml" +# 12649 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12710,9 +12675,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = -# 2481 "parsing/parser.mly" +# 2531 "parsing/parser.mly" ( _2 ) -# 12716 "parsing/parser.ml" +# 12681 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12757,24 +12722,24 @@ module Tables = struct let _endpos = _endpos__4_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2483 "parsing/parser.mly" +# 2533 "parsing/parser.mly" ( Pexp_constraint (_4, _2) ) -# 12763 "parsing/parser.ml" +# 12728 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 12772 "parsing/parser.ml" +# 12737 "parsing/parser.ml" in -# 2484 "parsing/parser.mly" +# 2534 "parsing/parser.mly" ( _1 ) -# 12778 "parsing/parser.ml" +# 12743 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12807,12 +12772,12 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2487 "parsing/parser.mly" +# 2537 "parsing/parser.mly" ( let (l,o,p) = _1 in ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) ) -# 12816 "parsing/parser.ml" +# 12781 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12863,17 +12828,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _3 = -# 2364 "parsing/parser.mly" +# 2414 "parsing/parser.mly" ( xs ) -# 12869 "parsing/parser.ml" +# 12834 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2492 "parsing/parser.mly" +# 2542 "parsing/parser.mly" ( mk_newtypes ~loc:_sloc _3 _5 ) -# 12877 "parsing/parser.ml" +# 12842 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12896,9 +12861,9 @@ module Tables = struct let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : (Parsetree.core_type) = -# 3165 "parsing/parser.mly" +# 3215 "parsing/parser.mly" ( ty ) -# 12902 "parsing/parser.ml" +# 12867 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12944,19 +12909,19 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let domain = -# 790 "parsing/parser.mly" +# 811 "parsing/parser.mly" ( extra_rhs_core_type _1 ~pos:_endpos__1_ ) -# 12950 "parsing/parser.ml" +# 12915 "parsing/parser.ml" in let label = -# 3177 "parsing/parser.mly" +# 3227 "parsing/parser.mly" ( Optional label ) -# 12955 "parsing/parser.ml" +# 12920 "parsing/parser.ml" in -# 3171 "parsing/parser.mly" +# 3221 "parsing/parser.mly" ( Ptyp_arrow(label, domain, codomain) ) -# 12960 "parsing/parser.ml" +# 12925 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -12964,15 +12929,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 12970 "parsing/parser.ml" +# 12935 "parsing/parser.ml" in -# 3173 "parsing/parser.mly" +# 3223 "parsing/parser.mly" ( _1 ) -# 12976 "parsing/parser.ml" +# 12941 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13019,9 +12984,9 @@ module Tables = struct let _1 : (Parsetree.core_type) = Obj.magic _1 in let _2 : unit = Obj.magic _2 in let label : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 13025 "parsing/parser.ml" +# 12990 "parsing/parser.ml" ) = Obj.magic label in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_label_ in @@ -13029,19 +12994,19 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let domain = -# 790 "parsing/parser.mly" +# 811 "parsing/parser.mly" ( extra_rhs_core_type _1 ~pos:_endpos__1_ ) -# 13035 "parsing/parser.ml" +# 13000 "parsing/parser.ml" in let label = -# 3179 "parsing/parser.mly" +# 3229 "parsing/parser.mly" ( Labelled label ) -# 13040 "parsing/parser.ml" +# 13005 "parsing/parser.ml" in -# 3171 "parsing/parser.mly" +# 3221 "parsing/parser.mly" ( Ptyp_arrow(label, domain, codomain) ) -# 13045 "parsing/parser.ml" +# 13010 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -13049,15 +13014,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 13055 "parsing/parser.ml" +# 13020 "parsing/parser.ml" in -# 3173 "parsing/parser.mly" +# 3223 "parsing/parser.mly" ( _1 ) -# 13061 "parsing/parser.ml" +# 13026 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13096,19 +13061,19 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let domain = -# 790 "parsing/parser.mly" +# 811 "parsing/parser.mly" ( extra_rhs_core_type _1 ~pos:_endpos__1_ ) -# 13102 "parsing/parser.ml" +# 13067 "parsing/parser.ml" in let label = -# 3181 "parsing/parser.mly" +# 3231 "parsing/parser.mly" ( Nolabel ) -# 13107 "parsing/parser.ml" +# 13072 "parsing/parser.ml" in -# 3171 "parsing/parser.mly" +# 3221 "parsing/parser.mly" ( Ptyp_arrow(label, domain, codomain) ) -# 13112 "parsing/parser.ml" +# 13077 "parsing/parser.ml" in let _endpos__1_ = _endpos_codomain_ in @@ -13116,15 +13081,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 13122 "parsing/parser.ml" +# 13087 "parsing/parser.ml" in -# 3173 "parsing/parser.mly" +# 3223 "parsing/parser.mly" ( _1 ) -# 13128 "parsing/parser.ml" +# 13093 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13154,9 +13119,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.functor_parameter) = -# 1136 "parsing/parser.mly" +# 1186 "parsing/parser.mly" ( Unit ) -# 13160 "parsing/parser.ml" +# 13125 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13212,15 +13177,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 13218 "parsing/parser.ml" +# 13183 "parsing/parser.ml" in -# 1139 "parsing/parser.mly" +# 1189 "parsing/parser.mly" ( Named (x, mty) ) -# 13224 "parsing/parser.ml" +# 13189 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13236,9 +13201,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) = -# 2973 "parsing/parser.mly" +# 3023 "parsing/parser.mly" ( (Pcstr_tuple [],None) ) -# 13242 "parsing/parser.ml" +# 13207 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13268,9 +13233,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) = -# 2974 "parsing/parser.mly" +# 3024 "parsing/parser.mly" ( (_2,None) ) -# 13274 "parsing/parser.ml" +# 13239 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13314,9 +13279,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) = -# 2976 "parsing/parser.mly" +# 3026 "parsing/parser.mly" ( (_2,Some _4) ) -# 13320 "parsing/parser.ml" +# 13285 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13346,9 +13311,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) = -# 2978 "parsing/parser.mly" +# 3028 "parsing/parser.mly" ( (Pcstr_tuple [],Some _2) ) -# 13352 "parsing/parser.ml" +# 13317 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13386,7 +13351,7 @@ module Tables = struct } = _menhir_stack in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let args_res : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic args_res in - let _1_inlined1 : (string) = Obj.magic _1_inlined1 in + let _1_inlined1 : (Asttypes.label) = 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 @@ -13396,9 +13361,9 @@ module Tables = struct Docstrings.info) = let attrs = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 13402 "parsing/parser.ml" +# 13367 "parsing/parser.ml" in let _endpos_attrs_ = _endpos__1_inlined2_ in @@ -13408,23 +13373,23 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 13414 "parsing/parser.ml" +# 13379 "parsing/parser.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2921 "parsing/parser.mly" +# 2971 "parsing/parser.mly" ( let args, res = args_res in let info = symbol_info _endpos in let loc = make_loc _sloc in cid, args, res, attrs, loc, info ) -# 13428 "parsing/parser.ml" +# 13393 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13456,7 +13421,7 @@ module Tables = struct } = _menhir_stack in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let args_res : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic args_res in - let _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_inlined1_ in @@ -13465,9 +13430,9 @@ module Tables = struct Docstrings.info) = let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 13471 "parsing/parser.ml" +# 13436 "parsing/parser.ml" in let _endpos_attrs_ = _endpos__1_inlined1_ in @@ -13476,29 +13441,29 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 13482 "parsing/parser.ml" +# 13447 "parsing/parser.ml" in let _startpos_cid_ = _startpos__1_ in let _1 = -# 3492 "parsing/parser.mly" +# 3554 "parsing/parser.mly" ( () ) -# 13489 "parsing/parser.ml" +# 13454 "parsing/parser.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos_cid_ in let _sloc = (_symbolstartpos, _endpos) in -# 2921 "parsing/parser.mly" +# 2971 "parsing/parser.mly" ( let args, res = args_res in let info = symbol_info _endpos in let loc = make_loc _sloc in cid, args, res, attrs, loc, info ) -# 13502 "parsing/parser.ml" +# 13467 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13569,9 +13534,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 13575 "parsing/parser.ml" +# 13540 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -13584,37 +13549,37 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 13590 "parsing/parser.ml" +# 13555 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cstrs = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 13599 "parsing/parser.ml" +# 13564 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 13604 "parsing/parser.ml" +# 13569 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 13610 "parsing/parser.ml" +# 13575 "parsing/parser.ml" in let kind_priv_manifest = let _1 = _1_inlined3 in -# 2872 "parsing/parser.mly" +# 2922 "parsing/parser.mly" ( _2 ) -# 13618 "parsing/parser.ml" +# 13583 "parsing/parser.ml" in let id = @@ -13623,29 +13588,29 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 13629 "parsing/parser.ml" +# 13594 "parsing/parser.ml" in let flag = -# 3512 "parsing/parser.mly" +# 3574 "parsing/parser.mly" ( Recursive ) -# 13635 "parsing/parser.ml" +# 13600 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 13642 "parsing/parser.ml" +# 13607 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2809 "parsing/parser.mly" +# 2859 "parsing/parser.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -13654,7 +13619,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 13658 "parsing/parser.ml" +# 13623 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13731,9 +13696,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 13737 "parsing/parser.ml" +# 13702 "parsing/parser.ml" ) = Obj.magic _1_inlined3 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let _1_inlined2 : unit = Obj.magic _1_inlined2 in @@ -13747,37 +13712,37 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined5 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 13753 "parsing/parser.ml" +# 13718 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined5_ in let cstrs = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 13762 "parsing/parser.ml" +# 13727 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 13767 "parsing/parser.ml" +# 13732 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 13773 "parsing/parser.ml" +# 13738 "parsing/parser.ml" in let kind_priv_manifest = let _1 = _1_inlined4 in -# 2872 "parsing/parser.mly" +# 2922 "parsing/parser.mly" ( _2 ) -# 13781 "parsing/parser.ml" +# 13746 "parsing/parser.ml" in let id = @@ -13786,9 +13751,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 13792 "parsing/parser.ml" +# 13757 "parsing/parser.ml" in let flag = @@ -13797,24 +13762,24 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3513 "parsing/parser.mly" +# 3575 "parsing/parser.mly" ( not_expecting _loc "nonrec flag" ) -# 13803 "parsing/parser.ml" +# 13768 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 13811 "parsing/parser.ml" +# 13776 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2809 "parsing/parser.mly" +# 2859 "parsing/parser.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -13823,7 +13788,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 13827 "parsing/parser.ml" +# 13792 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13887,9 +13852,9 @@ module Tables = struct let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) 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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 13893 "parsing/parser.ml" +# 13858 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -13902,29 +13867,29 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 13908 "parsing/parser.ml" +# 13873 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let cstrs = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 13917 "parsing/parser.ml" +# 13882 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 13922 "parsing/parser.ml" +# 13887 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 13928 "parsing/parser.ml" +# 13893 "parsing/parser.ml" in let id = @@ -13933,29 +13898,29 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 13939 "parsing/parser.ml" +# 13904 "parsing/parser.ml" in let flag = -# 3508 "parsing/parser.mly" +# 3570 "parsing/parser.mly" ( Recursive ) -# 13945 "parsing/parser.ml" +# 13910 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 13952 "parsing/parser.ml" +# 13917 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2809 "parsing/parser.mly" +# 2859 "parsing/parser.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -13964,7 +13929,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 13968 "parsing/parser.ml" +# 13933 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14034,9 +13999,9 @@ module Tables = struct let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) 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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14040 "parsing/parser.ml" +# 14005 "parsing/parser.ml" ) = Obj.magic _1_inlined3 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let _1_inlined2 : unit = Obj.magic _1_inlined2 in @@ -14050,29 +14015,29 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 14056 "parsing/parser.ml" +# 14021 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cstrs = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 14065 "parsing/parser.ml" +# 14030 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 14070 "parsing/parser.ml" +# 14035 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 14076 "parsing/parser.ml" +# 14041 "parsing/parser.ml" in let id = @@ -14081,32 +14046,32 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 14087 "parsing/parser.ml" +# 14052 "parsing/parser.ml" in let flag = let _1 = _1_inlined2 in -# 3509 "parsing/parser.mly" +# 3571 "parsing/parser.mly" ( Nonrecursive ) -# 14095 "parsing/parser.ml" +# 14060 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 14103 "parsing/parser.ml" +# 14068 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2809 "parsing/parser.mly" +# 2859 "parsing/parser.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -14115,7 +14080,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 14119 "parsing/parser.ml" +# 14084 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14134,17 +14099,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 688 "parsing/parser.mly" +# 697 "parsing/parser.mly" (string) -# 14140 "parsing/parser.ml" +# 14105 "parsing/parser.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.label) = -# 3365 "parsing/parser.mly" +# 3415 "parsing/parser.mly" ( _1 ) -# 14148 "parsing/parser.ml" +# 14113 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14163,17 +14128,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14169 "parsing/parser.ml" +# 14134 "parsing/parser.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.label) = -# 3366 "parsing/parser.mly" +# 3416 "parsing/parser.mly" ( _1 ) -# 14177 "parsing/parser.ml" +# 14142 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14203,13 +14168,13 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 768 "parsing/parser.mly" +# 777 "parsing/parser.mly" (Parsetree.structure) -# 14209 "parsing/parser.ml" +# 14174 "parsing/parser.ml" ) = -# 1047 "parsing/parser.mly" +# 1068 "parsing/parser.mly" ( _1 ) -# 14213 "parsing/parser.ml" +# 14178 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14225,9 +14190,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (string) = -# 3412 "parsing/parser.mly" +# 3465 "parsing/parser.mly" ( "" ) -# 14231 "parsing/parser.ml" +# 14196 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14257,9 +14222,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (string) = -# 3413 "parsing/parser.mly" +# 3466 "parsing/parser.mly" ( ";.." ) -# 14263 "parsing/parser.ml" +# 14228 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14289,13 +14254,13 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 770 "parsing/parser.mly" +# 779 "parsing/parser.mly" (Parsetree.signature) -# 14295 "parsing/parser.ml" +# 14260 "parsing/parser.ml" ) = -# 1053 "parsing/parser.mly" +# 1074 "parsing/parser.mly" ( _1 ) -# 14299 "parsing/parser.ml" +# 14264 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14339,9 +14304,41 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.extension) = -# 3686 "parsing/parser.mly" - ( (_2, _3) ) -# 14345 "parsing/parser.ml" +# 3750 "parsing/parser.mly" + ( (_2, _3) ) +# 14310 "parsing/parser.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 : ( +# 689 "parsing/parser.mly" + (string * Location.t * string * Location.t * string option) +# 14331 "parsing/parser.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.extension) = let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3752 "parsing/parser.mly" + ( mk_quotedext ~loc:_sloc _1 ) +# 14342 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14387,9 +14384,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14393 "parsing/parser.ml" +# 14390 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -14398,34 +14395,34 @@ module Tables = struct let _v : (Parsetree.label_declaration) = let _5 = let _1 = _1_inlined3 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 14404 "parsing/parser.ml" +# 14401 "parsing/parser.ml" in let _endpos__5_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 3118 "parsing/parser.mly" +# 3168 "parsing/parser.mly" ( _1 ) -# 14413 "parsing/parser.ml" +# 14410 "parsing/parser.ml" in let _2 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 14421 "parsing/parser.ml" +# 14418 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 14429 "parsing/parser.ml" +# 14426 "parsing/parser.ml" in let _startpos__2_ = _startpos__1_inlined1_ in @@ -14436,10 +14433,10 @@ module Tables = struct _startpos__2_ in let _sloc = (_symbolstartpos, _endpos) in -# 2995 "parsing/parser.mly" +# 3045 "parsing/parser.mly" ( let info = symbol_info _endpos in Type.field _2 _4 ~mut:_1 ~attrs:_5 ~loc:(make_loc _sloc) ~info ) -# 14443 "parsing/parser.ml" +# 14440 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14499,9 +14496,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14505 "parsing/parser.ml" +# 14502 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -14510,43 +14507,43 @@ module Tables = struct let _v : (Parsetree.label_declaration) = let _7 = let _1 = _1_inlined4 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 14516 "parsing/parser.ml" +# 14513 "parsing/parser.ml" in let _endpos__7_ = _endpos__1_inlined4_ in let _5 = let _1 = _1_inlined3 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 14525 "parsing/parser.ml" +# 14522 "parsing/parser.ml" in let _endpos__5_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 3118 "parsing/parser.mly" +# 3168 "parsing/parser.mly" ( _1 ) -# 14534 "parsing/parser.ml" +# 14531 "parsing/parser.ml" in let _2 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 14542 "parsing/parser.ml" +# 14539 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 14550 "parsing/parser.ml" +# 14547 "parsing/parser.ml" in let _startpos__2_ = _startpos__1_inlined1_ in @@ -14557,14 +14554,14 @@ module Tables = struct _startpos__2_ in let _sloc = (_symbolstartpos, _endpos) in -# 3000 "parsing/parser.mly" +# 3050 "parsing/parser.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 ) -# 14568 "parsing/parser.ml" +# 14565 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14587,9 +14584,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.label_declaration list) = -# 2989 "parsing/parser.mly" +# 3039 "parsing/parser.mly" ( [_1] ) -# 14593 "parsing/parser.ml" +# 14590 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14612,9 +14609,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.label_declaration list) = -# 2990 "parsing/parser.mly" +# 3040 "parsing/parser.mly" ( [_1] ) -# 14618 "parsing/parser.ml" +# 14615 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14644,9 +14641,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.label_declaration list) = -# 2991 "parsing/parser.mly" +# 3041 "parsing/parser.mly" ( _1 :: _2 ) -# 14650 "parsing/parser.ml" +# 14647 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14665,9 +14662,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14671 "parsing/parser.ml" +# 14668 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -14678,24 +14675,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 14684 "parsing/parser.ml" +# 14681 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2073 "parsing/parser.mly" +# 2123 "parsing/parser.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 14693 "parsing/parser.ml" +# 14690 "parsing/parser.ml" in -# 2065 "parsing/parser.mly" +# 2115 "parsing/parser.mly" ( x ) -# 14699 "parsing/parser.ml" +# 14696 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14728,9 +14725,9 @@ module Tables = struct let cty : (Parsetree.core_type) = Obj.magic cty in let _2 : unit = Obj.magic _2 in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14734 "parsing/parser.ml" +# 14731 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -14741,18 +14738,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 14747 "parsing/parser.ml" +# 14744 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2073 "parsing/parser.mly" +# 2123 "parsing/parser.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 14756 "parsing/parser.ml" +# 14753 "parsing/parser.ml" in let _startpos_x_ = _startpos__1_ in @@ -14760,11 +14757,11 @@ module Tables = struct let _symbolstartpos = _startpos_x_ in let _sloc = (_symbolstartpos, _endpos) in -# 2067 "parsing/parser.mly" +# 2117 "parsing/parser.mly" ( let lab, pat = x in lab, mkpat ~loc:_sloc (Ppat_constraint (pat, cty)) ) -# 14768 "parsing/parser.ml" +# 14765 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14782,61 +14779,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : ( -# 642 "parsing/parser.mly" - (string) -# 14789 "parsing/parser.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) = -# 3438 "parsing/parser.mly" - ( Lident _1 ) -# 14797 "parsing/parser.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 : ( -# 642 "parsing/parser.mly" - (string) -# 14830 "parsing/parser.ml" - ) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3439 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 14840 "parsing/parser.ml" +# 3497 "parsing/parser.mly" + ( _1 ) +# 14790 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14859,9 +14809,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.arg_label * Parsetree.expression) = -# 2350 "parsing/parser.mly" +# 2400 "parsing/parser.mly" ( (Nolabel, _1) ) -# 14865 "parsing/parser.ml" +# 14815 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14887,17 +14837,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : ( -# 629 "parsing/parser.mly" +# 634 "parsing/parser.mly" (string) -# 14893 "parsing/parser.ml" +# 14843 "parsing/parser.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) = -# 2352 "parsing/parser.mly" +# 2402 "parsing/parser.mly" ( (Labelled _1, _2) ) -# 14901 "parsing/parser.ml" +# 14851 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14922,9 +14872,9 @@ module Tables = struct }; } = _menhir_stack in let label : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14928 "parsing/parser.ml" +# 14878 "parsing/parser.ml" ) = Obj.magic label in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -14932,10 +14882,10 @@ module Tables = struct let _endpos = _endpos_label_ in let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in -# 2354 "parsing/parser.mly" +# 2404 "parsing/parser.mly" ( let loc = _loc_label_ in (Labelled label, mkexpvar ~loc label) ) -# 14939 "parsing/parser.ml" +# 14889 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14960,9 +14910,9 @@ module Tables = struct }; } = _menhir_stack in let label : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 14966 "parsing/parser.ml" +# 14916 "parsing/parser.ml" ) = Obj.magic label in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -14970,10 +14920,10 @@ module Tables = struct let _endpos = _endpos_label_ in let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in -# 2357 "parsing/parser.mly" +# 2407 "parsing/parser.mly" ( let loc = _loc_label_ in (Optional label, mkexpvar ~loc label) ) -# 14977 "parsing/parser.ml" +# 14927 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14999,17 +14949,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : ( -# 659 "parsing/parser.mly" +# 664 "parsing/parser.mly" (string) -# 15005 "parsing/parser.ml" +# 14955 "parsing/parser.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) = -# 2360 "parsing/parser.mly" +# 2410 "parsing/parser.mly" ( (Optional _1, _2) ) -# 15013 "parsing/parser.ml" +# 14963 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15062,15 +15012,15 @@ module Tables = struct let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 = let _1 = _1_inlined1 in -# 2061 "parsing/parser.mly" +# 2111 "parsing/parser.mly" ( _1 ) -# 15068 "parsing/parser.ml" +# 15018 "parsing/parser.ml" in -# 2035 "parsing/parser.mly" +# 2085 "parsing/parser.mly" ( (Optional (fst _3), _4, snd _3) ) -# 15074 "parsing/parser.ml" +# 15024 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15095,9 +15045,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 15101 "parsing/parser.ml" +# 15051 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15110,24 +15060,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 15116 "parsing/parser.ml" +# 15066 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2073 "parsing/parser.mly" +# 2123 "parsing/parser.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 15125 "parsing/parser.ml" +# 15075 "parsing/parser.ml" in -# 2037 "parsing/parser.mly" +# 2087 "parsing/parser.mly" ( (Optional (fst _2), None, snd _2) ) -# 15131 "parsing/parser.ml" +# 15081 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15174,9 +15124,9 @@ module Tables = struct let _3 : (Parsetree.pattern) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 659 "parsing/parser.mly" +# 664 "parsing/parser.mly" (string) -# 15180 "parsing/parser.ml" +# 15130 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -15184,15 +15134,15 @@ module Tables = struct let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 = let _1 = _1_inlined1 in -# 2061 "parsing/parser.mly" +# 2111 "parsing/parser.mly" ( _1 ) -# 15190 "parsing/parser.ml" +# 15140 "parsing/parser.ml" in -# 2039 "parsing/parser.mly" +# 2089 "parsing/parser.mly" ( (Optional _1, _4, _3) ) -# 15196 "parsing/parser.ml" +# 15146 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15218,17 +15168,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.pattern) = Obj.magic _2 in let _1 : ( -# 659 "parsing/parser.mly" +# 664 "parsing/parser.mly" (string) -# 15224 "parsing/parser.ml" +# 15174 "parsing/parser.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) = -# 2041 "parsing/parser.mly" +# 2091 "parsing/parser.mly" ( (Optional _1, None, _2) ) -# 15232 "parsing/parser.ml" +# 15182 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15272,9 +15222,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = -# 2043 "parsing/parser.mly" +# 2093 "parsing/parser.mly" ( (Labelled (fst _3), None, snd _3) ) -# 15278 "parsing/parser.ml" +# 15228 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15299,9 +15249,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 15305 "parsing/parser.ml" +# 15255 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15314,24 +15264,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 15320 "parsing/parser.ml" +# 15270 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2073 "parsing/parser.mly" +# 2123 "parsing/parser.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 15329 "parsing/parser.ml" +# 15279 "parsing/parser.ml" in -# 2045 "parsing/parser.mly" +# 2095 "parsing/parser.mly" ( (Labelled (fst _2), None, snd _2) ) -# 15335 "parsing/parser.ml" +# 15285 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15357,17 +15307,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.pattern) = Obj.magic _2 in let _1 : ( -# 629 "parsing/parser.mly" +# 634 "parsing/parser.mly" (string) -# 15363 "parsing/parser.ml" +# 15313 "parsing/parser.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) = -# 2047 "parsing/parser.mly" +# 2097 "parsing/parser.mly" ( (Labelled _1, None, _2) ) -# 15371 "parsing/parser.ml" +# 15321 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15390,9 +15340,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = -# 2049 "parsing/parser.mly" +# 2099 "parsing/parser.mly" ( (Nolabel, None, _1) ) -# 15396 "parsing/parser.ml" +# 15346 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15417,7 +15367,7 @@ module Tables = struct }; } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in @@ -15426,15 +15376,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2367 "parsing/parser.mly" +# 2417 "parsing/parser.mly" ( mkpatvar ~loc:_sloc _1 ) -# 15432 "parsing/parser.ml" +# 15382 "parsing/parser.ml" in -# 2371 "parsing/parser.mly" +# 2421 "parsing/parser.mly" ( (_1, _2) ) -# 15438 "parsing/parser.ml" +# 15388 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15473,7 +15423,7 @@ module Tables = struct 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 _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in @@ -15482,16 +15432,16 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2367 "parsing/parser.mly" +# 2417 "parsing/parser.mly" ( mkpatvar ~loc:_sloc _1 ) -# 15488 "parsing/parser.ml" +# 15438 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2373 "parsing/parser.mly" +# 2423 "parsing/parser.mly" ( let v = _1 in (* PR#7344 *) let t = match _2 with @@ -15504,7 +15454,7 @@ module Tables = struct let patloc = (_startpos__1_, _endpos__2_) in (ghpat ~loc:patloc (Ppat_constraint(v, typ)), mkexp_constraint ~loc:_sloc _4 _2) ) -# 15508 "parsing/parser.ml" +# 15458 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15564,27 +15514,27 @@ module Tables = struct let _4 : unit = Obj.magic _4 in let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in let _2 : unit = Obj.magic _2 in - let _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = 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.pattern * Parsetree.expression) = let _3 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 15577 "parsing/parser.ml" +# 15527 "parsing/parser.ml" in -# 894 "parsing/parser.mly" +# 915 "parsing/parser.mly" ( xs ) -# 15582 "parsing/parser.ml" +# 15532 "parsing/parser.ml" in -# 3100 "parsing/parser.mly" +# 3150 "parsing/parser.mly" ( _1 ) -# 15588 "parsing/parser.ml" +# 15538 "parsing/parser.ml" in let _startpos__3_ = _startpos_xs_ in @@ -15593,19 +15543,19 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2367 "parsing/parser.mly" +# 2417 "parsing/parser.mly" ( mkpatvar ~loc:_sloc _1 ) -# 15599 "parsing/parser.ml" +# 15549 "parsing/parser.ml" in -# 2389 "parsing/parser.mly" +# 2439 "parsing/parser.mly" ( let typloc = (_startpos__3_, _endpos__5_) in let patloc = (_startpos__1_, _endpos__5_) in (ghpat ~loc:patloc (Ppat_constraint(_1, ghtyp ~loc:typloc (Ptyp_poly(_3,_5)))), _7) ) -# 15609 "parsing/parser.ml" +# 15559 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15672,35 +15622,35 @@ module Tables = struct let xs : (string Asttypes.loc list) = Obj.magic xs in let _3 : unit = Obj.magic _3 in let _2 : unit = Obj.magic _2 in - let _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = 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.pattern * Parsetree.expression) = let _4 = -# 2364 "parsing/parser.mly" +# 2414 "parsing/parser.mly" ( xs ) -# 15683 "parsing/parser.ml" +# 15633 "parsing/parser.ml" in let _1 = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2367 "parsing/parser.mly" +# 2417 "parsing/parser.mly" ( mkpatvar ~loc:_sloc _1 ) -# 15692 "parsing/parser.ml" +# 15642 "parsing/parser.ml" in let _endpos = _endpos__8_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2395 "parsing/parser.mly" +# 2445 "parsing/parser.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) ) -# 15704 "parsing/parser.ml" +# 15654 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15737,9 +15687,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern * Parsetree.expression) = -# 2400 "parsing/parser.mly" +# 2450 "parsing/parser.mly" ( (_1, _3) ) -# 15743 "parsing/parser.ml" +# 15693 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15790,10 +15740,10 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.pattern * Parsetree.expression) = -# 2402 "parsing/parser.mly" +# 2452 "parsing/parser.mly" ( let loc = (_startpos__1_, _endpos__3_) in (ghpat ~loc (Ppat_constraint(_1, _3)), _5) ) -# 15797 "parsing/parser.ml" +# 15747 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15854,36 +15804,36 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 15860 "parsing/parser.ml" +# 15810 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 15869 "parsing/parser.ml" +# 15819 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "parsing/parser.mly" +# 2468 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in mklbs ~loc:_sloc ext rec_flag (mklb ~loc:_sloc true body attrs) ) -# 15881 "parsing/parser.ml" +# 15831 "parsing/parser.ml" in -# 2408 "parsing/parser.mly" +# 2458 "parsing/parser.mly" ( _1 ) -# 15887 "parsing/parser.ml" +# 15837 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15913,9 +15863,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (let_bindings) = -# 2409 "parsing/parser.mly" +# 2459 "parsing/parser.mly" ( addlb _1 _2 ) -# 15919 "parsing/parser.ml" +# 15869 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15969,41 +15919,41 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 15975 "parsing/parser.ml" +# 15925 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 15984 "parsing/parser.ml" +# 15934 "parsing/parser.ml" in let ext = -# 3676 "parsing/parser.mly" +# 3738 "parsing/parser.mly" ( None ) -# 15990 "parsing/parser.ml" +# 15940 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "parsing/parser.mly" +# 2468 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in mklbs ~loc:_sloc ext rec_flag (mklb ~loc:_sloc true body attrs) ) -# 16001 "parsing/parser.ml" +# 15951 "parsing/parser.ml" in -# 2408 "parsing/parser.mly" +# 2458 "parsing/parser.mly" ( _1 ) -# 16007 "parsing/parser.ml" +# 15957 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16071,18 +16021,18 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 16077 "parsing/parser.ml" +# 16027 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let attrs1 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 16086 "parsing/parser.ml" +# 16036 "parsing/parser.ml" in let ext = @@ -16091,27 +16041,27 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3677 "parsing/parser.mly" +# 3739 "parsing/parser.mly" ( not_expecting _loc "extension" ) -# 16097 "parsing/parser.ml" +# 16047 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "parsing/parser.mly" +# 2468 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in mklbs ~loc:_sloc ext rec_flag (mklb ~loc:_sloc true body attrs) ) -# 16109 "parsing/parser.ml" +# 16059 "parsing/parser.ml" in -# 2408 "parsing/parser.mly" +# 2458 "parsing/parser.mly" ( _1 ) -# 16115 "parsing/parser.ml" +# 16065 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16141,9 +16091,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (let_bindings) = -# 2409 "parsing/parser.mly" +# 2459 "parsing/parser.mly" ( addlb _1 _2 ) -# 16147 "parsing/parser.ml" +# 16097 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16166,9 +16116,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2077 "parsing/parser.mly" +# 2127 "parsing/parser.mly" ( _1 ) -# 16172 "parsing/parser.ml" +# 16122 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16206,24 +16156,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2079 "parsing/parser.mly" +# 2129 "parsing/parser.mly" ( Ppat_constraint(_1, _3) ) -# 16212 "parsing/parser.ml" +# 16162 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 16221 "parsing/parser.ml" +# 16171 "parsing/parser.ml" in -# 2080 "parsing/parser.mly" +# 2130 "parsing/parser.mly" ( _1 ) -# 16227 "parsing/parser.ml" +# 16177 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16248,7 +16198,7 @@ module Tables = struct }; } = _menhir_stack in let exp : (Parsetree.expression) = Obj.magic exp in - let _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos_exp_ in @@ -16257,15 +16207,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2367 "parsing/parser.mly" +# 2417 "parsing/parser.mly" ( mkpatvar ~loc:_sloc _1 ) -# 16263 "parsing/parser.ml" +# 16213 "parsing/parser.ml" in -# 2435 "parsing/parser.mly" +# 2485 "parsing/parser.mly" ( (pat, exp) ) -# 16269 "parsing/parser.ml" +# 16219 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16316,10 +16266,10 @@ module Tables = struct let _startpos = _startpos_pat_ in let _endpos = _endpos_exp_ in let _v : (Parsetree.pattern * Parsetree.expression) = -# 2437 "parsing/parser.mly" +# 2487 "parsing/parser.mly" ( let loc = (_startpos_pat_, _endpos_typ_) in (ghpat ~loc (Ppat_constraint(pat, typ)), exp) ) -# 16323 "parsing/parser.ml" +# 16273 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16356,9 +16306,9 @@ module Tables = struct let _startpos = _startpos_pat_ in let _endpos = _endpos_exp_ in let _v : (Parsetree.pattern * Parsetree.expression) = -# 2440 "parsing/parser.mly" +# 2490 "parsing/parser.mly" ( (pat, exp) ) -# 16362 "parsing/parser.ml" +# 16312 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16381,10 +16331,10 @@ module Tables = struct let _startpos = _startpos_body_ in let _endpos = _endpos_body_ in let _v : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = -# 2444 "parsing/parser.mly" +# 2494 "parsing/parser.mly" ( let let_pat, let_exp = body in let_pat, let_exp, [] ) -# 16388 "parsing/parser.ml" +# 16338 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16416,9 +16366,9 @@ module Tables = struct } = _menhir_stack in let body : (Parsetree.pattern * Parsetree.expression) = Obj.magic body in let _1 : ( -# 625 "parsing/parser.mly" +# 630 "parsing/parser.mly" (string) -# 16422 "parsing/parser.ml" +# 16372 "parsing/parser.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 @@ -16429,22 +16379,22 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 16435 "parsing/parser.ml" +# 16385 "parsing/parser.ml" in let _endpos = _endpos_body_ in let _symbolstartpos = _startpos_bindings_ in let _sloc = (_symbolstartpos, _endpos) in -# 2447 "parsing/parser.mly" +# 2497 "parsing/parser.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 ) -# 16448 "parsing/parser.ml" +# 16398 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16460,9 +16410,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.class_declaration list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 16466 "parsing/parser.ml" +# 16416 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16526,9 +16476,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 16532 "parsing/parser.ml" +# 16482 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -16541,9 +16491,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 16547 "parsing/parser.ml" +# 16497 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -16553,24 +16503,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 16559 "parsing/parser.ml" +# 16509 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 16567 "parsing/parser.ml" +# 16517 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1681 "parsing/parser.mly" +# 1731 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -16578,13 +16528,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Ci.mk id body ~virt ~params ~attrs ~loc ~text ~docs ) -# 16582 "parsing/parser.ml" +# 16532 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 16588 "parsing/parser.ml" +# 16538 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16600,9 +16550,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.class_description list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 16606 "parsing/parser.ml" +# 16556 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16673,9 +16623,9 @@ module Tables = struct let cty : (Parsetree.class_type) = Obj.magic cty in let _6 : unit = Obj.magic _6 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 16679 "parsing/parser.ml" +# 16629 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -16688,9 +16638,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 16694 "parsing/parser.ml" +# 16644 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -16700,24 +16650,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 16706 "parsing/parser.ml" +# 16656 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 16714 "parsing/parser.ml" +# 16664 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1972 "parsing/parser.mly" +# 2022 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -16725,13 +16675,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Ci.mk id cty ~virt ~params ~attrs ~loc ~text ~docs ) -# 16729 "parsing/parser.ml" +# 16679 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 16735 "parsing/parser.ml" +# 16685 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16747,9 +16697,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.class_type_declaration list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 16753 "parsing/parser.ml" +# 16703 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16820,9 +16770,9 @@ module Tables = struct let csig : (Parsetree.class_type) = Obj.magic csig in let _6 : unit = Obj.magic _6 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 16826 "parsing/parser.ml" +# 16776 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -16835,9 +16785,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 16841 "parsing/parser.ml" +# 16791 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -16847,24 +16797,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 16853 "parsing/parser.ml" +# 16803 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 16861 "parsing/parser.ml" +# 16811 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2011 "parsing/parser.mly" +# 2061 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -16872,13 +16822,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Ci.mk id csig ~virt ~params ~attrs ~loc ~text ~docs ) -# 16876 "parsing/parser.ml" +# 16826 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 16882 "parsing/parser.ml" +# 16832 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16894,9 +16844,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.module_binding list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 16900 "parsing/parser.ml" +# 16850 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16957,9 +16907,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 16963 "parsing/parser.ml" +# 16913 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -16969,24 +16919,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 16975 "parsing/parser.ml" +# 16925 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 16983 "parsing/parser.ml" +# 16933 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1363 "parsing/parser.mly" +# 1413 "parsing/parser.mly" ( let loc = make_loc _sloc in let attrs = attrs1 @ attrs2 in @@ -16994,13 +16944,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Mb.mk name body ~attrs ~loc ~text ~docs ) -# 16998 "parsing/parser.ml" +# 16948 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17004 "parsing/parser.ml" +# 16954 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17016,9 +16966,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.module_declaration list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17022 "parsing/parser.ml" +# 16972 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17086,9 +17036,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 17092 "parsing/parser.ml" +# 17042 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -17098,24 +17048,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 17104 "parsing/parser.ml" +# 17054 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 17112 "parsing/parser.ml" +# 17062 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1639 "parsing/parser.mly" +# 1689 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let docs = symbol_docs _sloc in @@ -17123,13 +17073,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Md.mk name mty ~attrs ~loc ~text ~docs ) -# 17127 "parsing/parser.ml" +# 17077 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17133 "parsing/parser.ml" +# 17083 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17145,9 +17095,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.attributes) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17151 "parsing/parser.ml" +# 17101 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17177,9 +17127,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.attributes) = -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17183 "parsing/parser.ml" +# 17133 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17195,9 +17145,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.type_declaration list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17201 "parsing/parser.ml" +# 17151 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17262,9 +17212,9 @@ module Tables = struct let xs_inlined1 : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) 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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 17268 "parsing/parser.ml" +# 17218 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -17277,29 +17227,29 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 17283 "parsing/parser.ml" +# 17233 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let cstrs = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 17292 "parsing/parser.ml" +# 17242 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 17297 "parsing/parser.ml" +# 17247 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 17303 "parsing/parser.ml" +# 17253 "parsing/parser.ml" in let id = @@ -17308,24 +17258,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 17314 "parsing/parser.ml" +# 17264 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 17322 "parsing/parser.ml" +# 17272 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2826 "parsing/parser.mly" +# 2876 "parsing/parser.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -17334,13 +17284,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text ) -# 17338 "parsing/parser.ml" +# 17288 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17344 "parsing/parser.ml" +# 17294 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17356,9 +17306,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.type_declaration list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17362 "parsing/parser.ml" +# 17312 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17430,9 +17380,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 17436 "parsing/parser.ml" +# 17386 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -17445,37 +17395,37 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 17451 "parsing/parser.ml" +# 17401 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cstrs = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 17460 "parsing/parser.ml" +# 17410 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 17465 "parsing/parser.ml" +# 17415 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 17471 "parsing/parser.ml" +# 17421 "parsing/parser.ml" in let kind_priv_manifest = let _1 = _1_inlined3 in -# 2872 "parsing/parser.mly" +# 2922 "parsing/parser.mly" ( _2 ) -# 17479 "parsing/parser.ml" +# 17429 "parsing/parser.ml" in let id = @@ -17484,24 +17434,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 17490 "parsing/parser.ml" +# 17440 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 17498 "parsing/parser.ml" +# 17448 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2826 "parsing/parser.mly" +# 2876 "parsing/parser.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -17510,13 +17460,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text ) -# 17514 "parsing/parser.ml" +# 17464 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17520 "parsing/parser.ml" +# 17470 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17532,9 +17482,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.attributes) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17538 "parsing/parser.ml" +# 17488 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17564,9 +17514,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.attributes) = -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17570 "parsing/parser.ml" +# 17520 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17582,9 +17532,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.signature_item list list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17588 "parsing/parser.ml" +# 17538 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17617,21 +17567,21 @@ module Tables = struct let _1 = let _startpos = _startpos__1_ in -# 802 "parsing/parser.mly" +# 823 "parsing/parser.mly" ( text_sig _startpos ) -# 17623 "parsing/parser.ml" +# 17573 "parsing/parser.ml" in -# 1501 "parsing/parser.mly" +# 1551 "parsing/parser.mly" ( _1 ) -# 17629 "parsing/parser.ml" +# 17579 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17635 "parsing/parser.ml" +# 17585 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17664,21 +17614,21 @@ module Tables = struct let _1 = let _startpos = _startpos__1_ in -# 800 "parsing/parser.mly" +# 821 "parsing/parser.mly" ( text_sig _startpos @ [_1] ) -# 17670 "parsing/parser.ml" +# 17620 "parsing/parser.ml" in -# 1501 "parsing/parser.mly" +# 1551 "parsing/parser.mly" ( _1 ) -# 17676 "parsing/parser.ml" +# 17626 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17682 "parsing/parser.ml" +# 17632 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17694,9 +17644,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.structure_item list list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17700 "parsing/parser.ml" +# 17650 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17729,40 +17679,40 @@ module Tables = struct let _1 = let ys = let items = -# 862 "parsing/parser.mly" +# 883 "parsing/parser.mly" ( [] ) -# 17735 "parsing/parser.ml" +# 17685 "parsing/parser.ml" in -# 1247 "parsing/parser.mly" +# 1297 "parsing/parser.mly" ( items ) -# 17740 "parsing/parser.ml" +# 17690 "parsing/parser.ml" in let xs = let _startpos = _startpos__1_ in -# 798 "parsing/parser.mly" +# 819 "parsing/parser.mly" ( text_str _startpos ) -# 17748 "parsing/parser.ml" +# 17698 "parsing/parser.ml" in -# 267 "menhir/standard.mly" +# 267 "" ( xs @ ys ) -# 17754 "parsing/parser.ml" +# 17704 "parsing/parser.ml" in -# 1263 "parsing/parser.mly" +# 1313 "parsing/parser.mly" ( _1 ) -# 17760 "parsing/parser.ml" +# 17710 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17766 "parsing/parser.ml" +# 17716 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17814,70 +17764,70 @@ module Tables = struct let _1 = let _1 = let attrs = -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 17820 "parsing/parser.ml" +# 17770 "parsing/parser.ml" in -# 1254 "parsing/parser.mly" +# 1304 "parsing/parser.mly" ( mkstrexp e attrs ) -# 17825 "parsing/parser.ml" +# 17775 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 796 "parsing/parser.mly" +# 817 "parsing/parser.mly" ( text_str _startpos @ [_1] ) -# 17833 "parsing/parser.ml" +# 17783 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 815 "parsing/parser.mly" +# 836 "parsing/parser.mly" ( mark_rhs_docs _startpos _endpos; _1 ) -# 17843 "parsing/parser.ml" +# 17793 "parsing/parser.ml" in -# 864 "parsing/parser.mly" +# 885 "parsing/parser.mly" ( x ) -# 17849 "parsing/parser.ml" +# 17799 "parsing/parser.ml" in -# 1247 "parsing/parser.mly" +# 1297 "parsing/parser.mly" ( items ) -# 17855 "parsing/parser.ml" +# 17805 "parsing/parser.ml" in let xs = let _startpos = _startpos__1_ in -# 798 "parsing/parser.mly" +# 819 "parsing/parser.mly" ( text_str _startpos ) -# 17863 "parsing/parser.ml" +# 17813 "parsing/parser.ml" in -# 267 "menhir/standard.mly" +# 267 "" ( xs @ ys ) -# 17869 "parsing/parser.ml" +# 17819 "parsing/parser.ml" in -# 1263 "parsing/parser.mly" +# 1313 "parsing/parser.mly" ( _1 ) -# 17875 "parsing/parser.ml" +# 17825 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17881 "parsing/parser.ml" +# 17831 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17910,21 +17860,21 @@ module Tables = struct let _1 = let _startpos = _startpos__1_ in -# 796 "parsing/parser.mly" +# 817 "parsing/parser.mly" ( text_str _startpos @ [_1] ) -# 17916 "parsing/parser.ml" +# 17866 "parsing/parser.ml" in -# 1263 "parsing/parser.mly" +# 1313 "parsing/parser.mly" ( _1 ) -# 17922 "parsing/parser.ml" +# 17872 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17928 "parsing/parser.ml" +# 17878 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17940,9 +17890,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.class_type_field list list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 17946 "parsing/parser.ml" +# 17896 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17974,15 +17924,15 @@ module Tables = struct let _v : (Parsetree.class_type_field list list) = let x = let _startpos = _startpos__1_ in -# 810 "parsing/parser.mly" +# 831 "parsing/parser.mly" ( text_csig _startpos @ [_1] ) -# 17980 "parsing/parser.ml" +# 17930 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 17986 "parsing/parser.ml" +# 17936 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17998,9 +17948,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.class_field list list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 18004 "parsing/parser.ml" +# 17954 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18032,15 +17982,15 @@ module Tables = struct let _v : (Parsetree.class_field list list) = let x = let _startpos = _startpos__1_ in -# 808 "parsing/parser.mly" +# 829 "parsing/parser.mly" ( text_cstr _startpos @ [_1] ) -# 18038 "parsing/parser.ml" +# 17988 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 18044 "parsing/parser.ml" +# 17994 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18056,9 +18006,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.structure_item list list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 18062 "parsing/parser.ml" +# 18012 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18090,15 +18040,15 @@ module Tables = struct let _v : (Parsetree.structure_item list list) = let x = let _startpos = _startpos__1_ in -# 796 "parsing/parser.mly" +# 817 "parsing/parser.mly" ( text_str _startpos @ [_1] ) -# 18096 "parsing/parser.ml" +# 18046 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 18102 "parsing/parser.ml" +# 18052 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18114,9 +18064,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.toplevel_phrase list list) = -# 211 "menhir/standard.mly" +# 211 "" ( [] ) -# 18120 "parsing/parser.ml" +# 18070 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18149,32 +18099,32 @@ module Tables = struct let _1 = let x = let _1 = -# 862 "parsing/parser.mly" +# 883 "parsing/parser.mly" ( [] ) -# 18155 "parsing/parser.ml" +# 18105 "parsing/parser.ml" in -# 1092 "parsing/parser.mly" +# 1113 "parsing/parser.mly" ( _1 ) -# 18160 "parsing/parser.ml" +# 18110 "parsing/parser.ml" in -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 18166 "parsing/parser.ml" +# 18116 "parsing/parser.ml" in -# 1104 "parsing/parser.mly" +# 1125 "parsing/parser.mly" ( _1 ) -# 18172 "parsing/parser.ml" +# 18122 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 18178 "parsing/parser.ml" +# 18128 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18226,58 +18176,58 @@ module Tables = struct let _1 = let _1 = let attrs = -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 18232 "parsing/parser.ml" +# 18182 "parsing/parser.ml" in -# 1254 "parsing/parser.mly" +# 1304 "parsing/parser.mly" ( mkstrexp e attrs ) -# 18237 "parsing/parser.ml" +# 18187 "parsing/parser.ml" in -# 806 "parsing/parser.mly" +# 827 "parsing/parser.mly" ( Ptop_def [_1] ) -# 18243 "parsing/parser.ml" +# 18193 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 804 "parsing/parser.mly" +# 825 "parsing/parser.mly" ( text_def _startpos @ [_1] ) -# 18251 "parsing/parser.ml" +# 18201 "parsing/parser.ml" in -# 864 "parsing/parser.mly" +# 885 "parsing/parser.mly" ( x ) -# 18257 "parsing/parser.ml" +# 18207 "parsing/parser.ml" in -# 1092 "parsing/parser.mly" +# 1113 "parsing/parser.mly" ( _1 ) -# 18263 "parsing/parser.ml" +# 18213 "parsing/parser.ml" in -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 18269 "parsing/parser.ml" +# 18219 "parsing/parser.ml" in -# 1104 "parsing/parser.mly" +# 1125 "parsing/parser.mly" ( _1 ) -# 18275 "parsing/parser.ml" +# 18225 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 18281 "parsing/parser.ml" +# 18231 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18309,27 +18259,27 @@ module Tables = struct let _v : (Parsetree.toplevel_phrase list list) = let x = let _1 = let _1 = -# 806 "parsing/parser.mly" +# 827 "parsing/parser.mly" ( Ptop_def [_1] ) -# 18315 "parsing/parser.ml" +# 18265 "parsing/parser.ml" in let _startpos = _startpos__1_ in -# 804 "parsing/parser.mly" +# 825 "parsing/parser.mly" ( text_def _startpos @ [_1] ) -# 18321 "parsing/parser.ml" +# 18271 "parsing/parser.ml" in -# 1104 "parsing/parser.mly" +# 1125 "parsing/parser.mly" ( _1 ) -# 18327 "parsing/parser.ml" +# 18277 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 18333 "parsing/parser.ml" +# 18283 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18364,29 +18314,29 @@ module Tables = struct let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 815 "parsing/parser.mly" +# 836 "parsing/parser.mly" ( mark_rhs_docs _startpos _endpos; _1 ) -# 18371 "parsing/parser.ml" +# 18321 "parsing/parser.ml" in let _startpos = _startpos__1_ in -# 804 "parsing/parser.mly" +# 825 "parsing/parser.mly" ( text_def _startpos @ [_1] ) -# 18378 "parsing/parser.ml" +# 18328 "parsing/parser.ml" in -# 1104 "parsing/parser.mly" +# 1125 "parsing/parser.mly" ( _1 ) -# 18384 "parsing/parser.ml" +# 18334 "parsing/parser.ml" in -# 213 "menhir/standard.mly" +# 213 "" ( x :: xs ) -# 18390 "parsing/parser.ml" +# 18340 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18423,9 +18373,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_opat_ in let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let _2 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 18429 "parsing/parser.ml" +# 18379 "parsing/parser.ml" in let x = let label = @@ -18433,9 +18383,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 18439 "parsing/parser.ml" +# 18389 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -18443,7 +18393,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2715 "parsing/parser.mly" +# 2765 "parsing/parser.mly" ( let pat = match opat with | None -> @@ -18454,13 +18404,13 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:_sloc pat octy ) -# 18458 "parsing/parser.ml" +# 18408 "parsing/parser.ml" in -# 1031 "parsing/parser.mly" +# 1052 "parsing/parser.mly" ( [x], None ) -# 18464 "parsing/parser.ml" +# 18414 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18504,9 +18454,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let _2 = -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 18510 "parsing/parser.ml" +# 18460 "parsing/parser.ml" in let x = let label = @@ -18514,9 +18464,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 18520 "parsing/parser.ml" +# 18470 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -18524,7 +18474,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2715 "parsing/parser.mly" +# 2765 "parsing/parser.mly" ( let pat = match opat with | None -> @@ -18535,13 +18485,13 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:_sloc pat octy ) -# 18539 "parsing/parser.ml" +# 18489 "parsing/parser.ml" in -# 1031 "parsing/parser.mly" +# 1052 "parsing/parser.mly" ( [x], None ) -# 18545 "parsing/parser.ml" +# 18495 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18604,9 +18554,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 18610 "parsing/parser.ml" +# 18560 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -18614,7 +18564,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2715 "parsing/parser.mly" +# 2765 "parsing/parser.mly" ( let pat = match opat with | None -> @@ -18625,13 +18575,13 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:_sloc pat octy ) -# 18629 "parsing/parser.ml" +# 18579 "parsing/parser.ml" in -# 1033 "parsing/parser.mly" +# 1054 "parsing/parser.mly" ( [x], Some y ) -# 18635 "parsing/parser.ml" +# 18585 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18687,9 +18637,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 18693 "parsing/parser.ml" +# 18643 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -18697,7 +18647,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2715 "parsing/parser.mly" +# 2765 "parsing/parser.mly" ( let pat = match opat with | None -> @@ -18708,14 +18658,14 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:_sloc pat octy ) -# 18712 "parsing/parser.ml" +# 18662 "parsing/parser.ml" in -# 1037 "parsing/parser.mly" +# 1058 "parsing/parser.mly" ( let xs, y = tail in x :: xs, y ) -# 18719 "parsing/parser.ml" +# 18669 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18752,9 +18702,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.case) = -# 2473 "parsing/parser.mly" +# 2523 "parsing/parser.mly" ( Exp.case _1 _3 ) -# 18758 "parsing/parser.ml" +# 18708 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18805,9 +18755,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.case) = -# 2475 "parsing/parser.mly" +# 2525 "parsing/parser.mly" ( Exp.case _1 ~guard:_3 _5 ) -# 18811 "parsing/parser.ml" +# 18761 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18845,9 +18795,9 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.case) = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2477 "parsing/parser.mly" +# 2527 "parsing/parser.mly" ( Exp.case _1 (Exp.unreachable ~loc:(make_loc _loc__3_) ()) ) -# 18851 "parsing/parser.ml" +# 18801 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18908,9 +18858,9 @@ module Tables = struct let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 18914 "parsing/parser.ml" +# 18864 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -18919,49 +18869,49 @@ module Tables = struct let _6 = let _1 = _1_inlined3 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 18925 "parsing/parser.ml" +# 18875 "parsing/parser.ml" in let _endpos__6_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 18934 "parsing/parser.ml" +# 18884 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3118 "parsing/parser.mly" +# 3168 "parsing/parser.mly" ( _1 ) -# 18943 "parsing/parser.ml" +# 18893 "parsing/parser.ml" in let _1 = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 18950 "parsing/parser.ml" +# 18900 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 18958 "parsing/parser.ml" +# 18908 "parsing/parser.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3328 "parsing/parser.mly" +# 3378 "parsing/parser.mly" ( let info = match rhs_info _endpos__4_ with | Some _ as info_before_semi -> info_before_semi @@ -18969,13 +18919,13 @@ module Tables = struct in let attrs = add_info_attrs info (_4 @ _6) in Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 ) -# 18973 "parsing/parser.ml" +# 18923 "parsing/parser.ml" in -# 3309 "parsing/parser.mly" +# 3359 "parsing/parser.mly" ( let (f, c) = tail in (head :: f, c) ) -# 18979 "parsing/parser.ml" +# 18929 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19016,15 +18966,15 @@ module Tables = struct let _symbolstartpos = _startpos_ty_ in let _sloc = (_symbolstartpos, _endpos) in -# 3339 "parsing/parser.mly" +# 3389 "parsing/parser.mly" ( Of.inherit_ ~loc:(make_loc _sloc) ty ) -# 19022 "parsing/parser.ml" +# 18972 "parsing/parser.ml" in -# 3309 "parsing/parser.mly" +# 3359 "parsing/parser.mly" ( let (f, c) = tail in (head :: f, c) ) -# 19028 "parsing/parser.ml" +# 18978 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19078,9 +19028,9 @@ module Tables = struct let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19084 "parsing/parser.ml" +# 19034 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -19089,49 +19039,49 @@ module Tables = struct let _6 = let _1 = _1_inlined3 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19095 "parsing/parser.ml" +# 19045 "parsing/parser.ml" in let _endpos__6_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19104 "parsing/parser.ml" +# 19054 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3118 "parsing/parser.mly" +# 3168 "parsing/parser.mly" ( _1 ) -# 19113 "parsing/parser.ml" +# 19063 "parsing/parser.ml" in let _1 = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19120 "parsing/parser.ml" +# 19070 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19128 "parsing/parser.ml" +# 19078 "parsing/parser.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3328 "parsing/parser.mly" +# 3378 "parsing/parser.mly" ( let info = match rhs_info _endpos__4_ with | Some _ as info_before_semi -> info_before_semi @@ -19139,13 +19089,13 @@ module Tables = struct in let attrs = add_info_attrs info (_4 @ _6) in Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 ) -# 19143 "parsing/parser.ml" +# 19093 "parsing/parser.ml" in -# 3312 "parsing/parser.mly" +# 3362 "parsing/parser.mly" ( [head], Closed ) -# 19149 "parsing/parser.ml" +# 19099 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19179,15 +19129,15 @@ module Tables = struct let _symbolstartpos = _startpos_ty_ in let _sloc = (_symbolstartpos, _endpos) in -# 3339 "parsing/parser.mly" +# 3389 "parsing/parser.mly" ( Of.inherit_ ~loc:(make_loc _sloc) ty ) -# 19185 "parsing/parser.ml" +# 19135 "parsing/parser.ml" in -# 3312 "parsing/parser.mly" +# 3362 "parsing/parser.mly" ( [head], Closed ) -# 19191 "parsing/parser.ml" +# 19141 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19227,9 +19177,9 @@ module Tables = struct let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19233 "parsing/parser.ml" +# 19183 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -19238,50 +19188,50 @@ module Tables = struct let _4 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19244 "parsing/parser.ml" +# 19194 "parsing/parser.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3118 "parsing/parser.mly" +# 3168 "parsing/parser.mly" ( _1 ) -# 19253 "parsing/parser.ml" +# 19203 "parsing/parser.ml" in let _1 = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19260 "parsing/parser.ml" +# 19210 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19268 "parsing/parser.ml" +# 19218 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3321 "parsing/parser.mly" +# 3371 "parsing/parser.mly" ( let info = symbol_info _endpos in let attrs = add_info_attrs info _4 in Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 ) -# 19279 "parsing/parser.ml" +# 19229 "parsing/parser.ml" in -# 3315 "parsing/parser.mly" +# 3365 "parsing/parser.mly" ( [head], Closed ) -# 19285 "parsing/parser.ml" +# 19235 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19308,15 +19258,15 @@ module Tables = struct let _symbolstartpos = _startpos_ty_ in let _sloc = (_symbolstartpos, _endpos) in -# 3339 "parsing/parser.mly" +# 3389 "parsing/parser.mly" ( Of.inherit_ ~loc:(make_loc _sloc) ty ) -# 19314 "parsing/parser.ml" +# 19264 "parsing/parser.ml" in -# 3315 "parsing/parser.mly" +# 3365 "parsing/parser.mly" ( [head], Closed ) -# 19320 "parsing/parser.ml" +# 19270 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19339,9 +19289,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.object_field list * Asttypes.closed_flag) = -# 3317 "parsing/parser.mly" +# 3367 "parsing/parser.mly" ( [], Open ) -# 19345 "parsing/parser.ml" +# 19295 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19386,9 +19336,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19392 "parsing/parser.ml" +# 19342 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let private_ : (Asttypes.private_flag) = Obj.magic private_ in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -19400,41 +19350,41 @@ module Tables = struct Parsetree.attributes) = let ty = let _1 = _1_inlined2 in -# 3114 "parsing/parser.mly" +# 3164 "parsing/parser.mly" ( _1 ) -# 19406 "parsing/parser.ml" +# 19356 "parsing/parser.ml" in let label = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19414 "parsing/parser.ml" +# 19364 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19422 "parsing/parser.ml" +# 19372 "parsing/parser.ml" in let attrs = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19428 "parsing/parser.ml" +# 19378 "parsing/parser.ml" in let _1 = -# 3568 "parsing/parser.mly" +# 3630 "parsing/parser.mly" ( Fresh ) -# 19433 "parsing/parser.ml" +# 19383 "parsing/parser.ml" in -# 1819 "parsing/parser.mly" +# 1869 "parsing/parser.mly" ( (label, private_, Cfk_virtual ty), attrs ) -# 19438 "parsing/parser.ml" +# 19388 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19472,9 +19422,9 @@ module Tables = struct } = _menhir_stack in let _5 : (Parsetree.expression) = Obj.magic _5 in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19478 "parsing/parser.ml" +# 19428 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -19486,36 +19436,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19492 "parsing/parser.ml" +# 19442 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19500 "parsing/parser.ml" +# 19450 "parsing/parser.ml" in let _2 = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19506 "parsing/parser.ml" +# 19456 "parsing/parser.ml" in let _1 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 19511 "parsing/parser.ml" +# 19461 "parsing/parser.ml" in -# 1821 "parsing/parser.mly" +# 1871 "parsing/parser.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 ) -# 19519 "parsing/parser.ml" +# 19469 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19559,9 +19509,9 @@ module Tables = struct } = _menhir_stack in let _5 : (Parsetree.expression) = Obj.magic _5 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19565 "parsing/parser.ml" +# 19515 "parsing/parser.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 @@ -19574,39 +19524,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19580 "parsing/parser.ml" +# 19530 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19588 "parsing/parser.ml" +# 19538 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19596 "parsing/parser.ml" +# 19546 "parsing/parser.ml" in let _1 = -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 19602 "parsing/parser.ml" +# 19552 "parsing/parser.ml" in -# 1821 "parsing/parser.mly" +# 1871 "parsing/parser.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 ) -# 19610 "parsing/parser.ml" +# 19560 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19665,9 +19615,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19671 "parsing/parser.ml" +# 19621 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -19679,45 +19629,45 @@ module Tables = struct Parsetree.attributes) = let _6 = let _1 = _1_inlined2 in -# 3114 "parsing/parser.mly" +# 3164 "parsing/parser.mly" ( _1 ) -# 19685 "parsing/parser.ml" +# 19635 "parsing/parser.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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19694 "parsing/parser.ml" +# 19644 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19702 "parsing/parser.ml" +# 19652 "parsing/parser.ml" in let _2 = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19708 "parsing/parser.ml" +# 19658 "parsing/parser.ml" in let _1 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 19713 "parsing/parser.ml" +# 19663 "parsing/parser.ml" in -# 1827 "parsing/parser.mly" +# 1877 "parsing/parser.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 ) -# 19721 "parsing/parser.ml" +# 19671 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19782,9 +19732,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19788 "parsing/parser.ml" +# 19738 "parsing/parser.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 @@ -19797,48 +19747,48 @@ module Tables = struct Parsetree.attributes) = let _6 = let _1 = _1_inlined3 in -# 3114 "parsing/parser.mly" +# 3164 "parsing/parser.mly" ( _1 ) -# 19803 "parsing/parser.ml" +# 19753 "parsing/parser.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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19812 "parsing/parser.ml" +# 19762 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19820 "parsing/parser.ml" +# 19770 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19828 "parsing/parser.ml" +# 19778 "parsing/parser.ml" in let _1 = -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 19834 "parsing/parser.ml" +# 19784 "parsing/parser.ml" in -# 1827 "parsing/parser.mly" +# 1877 "parsing/parser.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 ) -# 19842 "parsing/parser.ml" +# 19792 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19918,9 +19868,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 19924 "parsing/parser.ml" +# 19874 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -19930,38 +19880,38 @@ module Tables = struct let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag * Parsetree.class_field_kind) * Parsetree.attributes) = let _7 = -# 2364 "parsing/parser.mly" +# 2414 "parsing/parser.mly" ( xs ) -# 19936 "parsing/parser.ml" +# 19886 "parsing/parser.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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 19944 "parsing/parser.ml" +# 19894 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 19952 "parsing/parser.ml" +# 19902 "parsing/parser.ml" in let _startpos__4_ = _startpos__1_inlined1_ in let _2 = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 19959 "parsing/parser.ml" +# 19909 "parsing/parser.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in let _1 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 19965 "parsing/parser.ml" +# 19915 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in let _endpos = _endpos__11_ in @@ -19977,7 +19927,7 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 1833 "parsing/parser.mly" +# 1883 "parsing/parser.mly" ( let poly_exp_loc = (_startpos__7_, _endpos__11_) in let poly_exp = let exp, poly = @@ -19988,7 +19938,7 @@ module Tables = struct ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in (_4, _3, Cfk_concrete (_1, poly_exp)), _2 ) -# 19992 "parsing/parser.ml" +# 19942 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20074,9 +20024,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 20080 "parsing/parser.ml" +# 20030 "parsing/parser.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 @@ -20087,41 +20037,41 @@ module Tables = struct let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag * Parsetree.class_field_kind) * Parsetree.attributes) = let _7 = -# 2364 "parsing/parser.mly" +# 2414 "parsing/parser.mly" ( xs ) -# 20093 "parsing/parser.ml" +# 20043 "parsing/parser.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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 20101 "parsing/parser.ml" +# 20051 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 20109 "parsing/parser.ml" +# 20059 "parsing/parser.ml" in let _startpos__4_ = _startpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 20118 "parsing/parser.ml" +# 20068 "parsing/parser.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in let _1 = -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 20125 "parsing/parser.ml" +# 20075 "parsing/parser.ml" in let _endpos = _endpos__11_ in let _symbolstartpos = if _startpos__1_ != _endpos__1_ then @@ -20136,7 +20086,7 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 1833 "parsing/parser.mly" +# 1883 "parsing/parser.mly" ( let poly_exp_loc = (_startpos__7_, _endpos__11_) in let poly_exp = let exp, poly = @@ -20147,7 +20097,7 @@ module Tables = struct ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in (_4, _3, Cfk_concrete (_1, poly_exp)), _2 ) -# 20151 "parsing/parser.ml" +# 20101 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20166,17 +20116,636 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 688 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 20172 "parsing/parser.ml" +# 20122 "parsing/parser.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) = -# 3450 "parsing/parser.mly" - ( Lident _1 ) -# 20180 "parsing/parser.ml" +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20130 "parsing/parser.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 : ( +# 647 "parsing/parser.mly" + (string) +# 20163 "parsing/parser.ml" + ) = Obj.magic _3 in + let _2 : unit = 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__3_ in + let _v : (Longident.t) = +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20173 "parsing/parser.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 : ( +# 697 "parsing/parser.mly" + (string) +# 20194 "parsing/parser.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) = +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20202 "parsing/parser.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 : ( +# 697 "parsing/parser.mly" + (string) +# 20235 "parsing/parser.ml" + ) = Obj.magic _3 in + let _2 : unit = 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__3_ in + let _v : (Longident.t) = +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20245 "parsing/parser.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 : (Asttypes.label) = 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) = let _1 = +# 3527 "parsing/parser.mly" + ( _1 ) +# 20270 "parsing/parser.ml" + in + +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20275 "parsing/parser.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 : 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 : (Longident.t) = let _1 = + let _1 = +# 3470 "parsing/parser.mly" + ( "::" ) +# 20315 "parsing/parser.ml" + in + +# 3527 "parsing/parser.mly" + ( _1 ) +# 20320 "parsing/parser.ml" + + in + +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20326 "parsing/parser.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 : (Asttypes.label) = 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) = let _1 = +# 3527 "parsing/parser.mly" + ( _1 ) +# 20351 "parsing/parser.ml" + in + +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20356 "parsing/parser.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 : (Asttypes.label) = Obj.magic _1_inlined1 in + let _2 : unit = 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__1_inlined1_ in + let _v : (Longident.t) = let _3 = + let _1 = _1_inlined1 in + +# 3527 "parsing/parser.mly" + ( _1 ) +# 20397 "parsing/parser.ml" + + in + +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20403 "parsing/parser.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_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_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.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_inlined1 : unit = Obj.magic _2_inlined1 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _2 : unit = 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__3_ in + let _v : (Longident.t) = let _3 = + let (_2, _1) = (_2_inlined1, _1_inlined1) in + let _1 = +# 3470 "parsing/parser.mly" + ( "::" ) +# 20458 "parsing/parser.ml" + in + +# 3527 "parsing/parser.mly" + ( _1 ) +# 20463 "parsing/parser.ml" + + in + +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20469 "parsing/parser.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 : (Asttypes.label) = Obj.magic _1_inlined1 in + let _2 : unit = 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__1_inlined1_ in + let _v : (Longident.t) = let _3 = + let _1 = _1_inlined1 in + +# 3527 "parsing/parser.mly" + ( _1 ) +# 20510 "parsing/parser.ml" + + in + +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20516 "parsing/parser.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 : (Asttypes.label) = 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) = +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20541 "parsing/parser.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 : (Asttypes.label) = Obj.magic _3 in + let _2 : unit = 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__3_ in + let _v : (Longident.t) = +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20580 "parsing/parser.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 : ( +# 647 "parsing/parser.mly" + (string) +# 20601 "parsing/parser.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) = +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20609 "parsing/parser.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 : ( +# 647 "parsing/parser.mly" + (string) +# 20642 "parsing/parser.ml" + ) = Obj.magic _3 in + let _2 : unit = 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__3_ in + let _v : (Longident.t) = +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20652 "parsing/parser.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 : ( +# 697 "parsing/parser.mly" + (string) +# 20673 "parsing/parser.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) = +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20681 "parsing/parser.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 : ( +# 697 "parsing/parser.mly" + (string) +# 20714 "parsing/parser.ml" + ) = Obj.magic _3 in + let _2 : unit = 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__3_ in + let _v : (Longident.t) = +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20724 "parsing/parser.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 : (Asttypes.label) = 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) = +# 3490 "parsing/parser.mly" + ( Lident _1 ) +# 20749 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20206,20 +20775,41 @@ module Tables = struct }; }; } = _menhir_stack in - let _3 : ( -# 688 "parsing/parser.mly" - (string) -# 20213 "parsing/parser.ml" - ) = Obj.magic _3 in + let _3 : (Asttypes.label) = Obj.magic _3 in let _2 : unit = 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__3_ in let _v : (Longident.t) = -# 3451 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 20223 "parsing/parser.ml" +# 3491 "parsing/parser.mly" + ( Ldot(_1,_3) ) +# 20788 "parsing/parser.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 : (Longident.t) = 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) = +# 3506 "parsing/parser.mly" + ( _1 ) +# 20813 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20266,9 +20856,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3453 "parsing/parser.mly" +# 3508 "parsing/parser.mly" ( lapply ~loc:_sloc _1 _3 ) -# 20272 "parsing/parser.ml" +# 20862 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20306,9 +20896,9 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Longident.t) = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 3455 "parsing/parser.mly" +# 3510 "parsing/parser.mly" ( expecting _loc__3_ "module path" ) -# 20312 "parsing/parser.ml" +# 20902 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20326,61 +20916,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : ( -# 688 "parsing/parser.mly" - (string) -# 20333 "parsing/parser.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) = -# 3446 "parsing/parser.mly" - ( Lident _1 ) -# 20341 "parsing/parser.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 : ( -# 688 "parsing/parser.mly" - (string) -# 20374 "parsing/parser.ml" - ) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3447 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 20384 "parsing/parser.ml" +# 3503 "parsing/parser.mly" + ( _1 ) +# 20927 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20410,9 +20953,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_me_ in let _v : (Parsetree.module_expr) = -# 1323 "parsing/parser.mly" +# 1373 "parsing/parser.mly" ( me ) -# 20416 "parsing/parser.ml" +# 20959 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20457,24 +21000,24 @@ module Tables = struct let _endpos = _endpos_me_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1326 "parsing/parser.mly" +# 1376 "parsing/parser.mly" ( Pmod_constraint(me, mty) ) -# 20463 "parsing/parser.ml" +# 21006 "parsing/parser.ml" in let _endpos__1_ = _endpos_me_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 835 "parsing/parser.mly" +# 856 "parsing/parser.mly" ( mkmod ~loc:_sloc _1 ) -# 20472 "parsing/parser.ml" +# 21015 "parsing/parser.ml" in -# 1329 "parsing/parser.mly" +# 1379 "parsing/parser.mly" ( _1 ) -# 20478 "parsing/parser.ml" +# 21021 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20505,24 +21048,24 @@ module Tables = struct let _endpos = _endpos_body_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1328 "parsing/parser.mly" +# 1378 "parsing/parser.mly" ( Pmod_functor(arg, body) ) -# 20511 "parsing/parser.ml" +# 21054 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 835 "parsing/parser.mly" +# 856 "parsing/parser.mly" ( mkmod ~loc:_sloc _1 ) -# 20520 "parsing/parser.ml" +# 21063 "parsing/parser.ml" in -# 1329 "parsing/parser.mly" +# 1379 "parsing/parser.mly" ( _1 ) -# 20526 "parsing/parser.ml" +# 21069 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20552,9 +21095,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_mty_ in let _v : (Parsetree.module_type) = -# 1566 "parsing/parser.mly" +# 1616 "parsing/parser.mly" ( mty ) -# 20558 "parsing/parser.ml" +# 21101 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20585,24 +21128,24 @@ module Tables = struct let _endpos = _endpos_body_ in let _v : (Parsetree.module_type) = let _1 = let _1 = -# 1569 "parsing/parser.mly" +# 1619 "parsing/parser.mly" ( Pmty_functor(arg, body) ) -# 20591 "parsing/parser.ml" +# 21134 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 837 "parsing/parser.mly" +# 858 "parsing/parser.mly" ( mkmty ~loc:_sloc _1 ) -# 20600 "parsing/parser.ml" +# 21143 "parsing/parser.ml" in -# 1571 "parsing/parser.mly" +# 1621 "parsing/parser.mly" ( _1 ) -# 20606 "parsing/parser.ml" +# 21149 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20648,18 +21191,18 @@ module Tables = struct let _v : (Parsetree.module_expr) = let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 20654 "parsing/parser.ml" +# 21197 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1162 "parsing/parser.mly" +# 1212 "parsing/parser.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_structure s) ) -# 20663 "parsing/parser.ml" +# 21206 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20705,17 +21248,17 @@ module Tables = struct let _v : (Parsetree.module_expr) = let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 20711 "parsing/parser.ml" +# 21254 "parsing/parser.ml" in let _loc__4_ = (_startpos__4_, _endpos__4_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1164 "parsing/parser.mly" +# 1214 "parsing/parser.mly" ( unclosed "struct" _loc__1_ "end" _loc__4_ ) -# 20719 "parsing/parser.ml" +# 21262 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20768,30 +21311,30 @@ module Tables = struct let _v : (Parsetree.module_expr) = let args = let _1 = _1_inlined2 in -# 1128 "parsing/parser.mly" +# 1178 "parsing/parser.mly" ( _1 ) -# 20774 "parsing/parser.ml" +# 21317 "parsing/parser.ml" in let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 20782 "parsing/parser.ml" +# 21325 "parsing/parser.ml" in let _endpos = _endpos_me_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1166 "parsing/parser.mly" +# 1216 "parsing/parser.mly" ( wrap_mod_attrs ~loc:_sloc attrs ( List.fold_left (fun acc arg -> mkmod ~loc:_sloc (Pmod_functor (arg, acc)) ) me args ) ) -# 20795 "parsing/parser.ml" +# 21338 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20814,9 +21357,9 @@ module Tables = struct let _startpos = _startpos_me_ in let _endpos = _endpos_me_ in let _v : (Parsetree.module_expr) = -# 1172 "parsing/parser.mly" +# 1222 "parsing/parser.mly" ( me ) -# 20820 "parsing/parser.ml" +# 21363 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20846,9 +21389,9 @@ module Tables = struct let _startpos = _startpos_me_ in let _endpos = _endpos_attr_ in let _v : (Parsetree.module_expr) = -# 1174 "parsing/parser.mly" +# 1224 "parsing/parser.mly" ( Mod.attr me attr ) -# 20852 "parsing/parser.ml" +# 21395 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20877,30 +21420,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 20883 "parsing/parser.ml" +# 21426 "parsing/parser.ml" in -# 1178 "parsing/parser.mly" +# 1228 "parsing/parser.mly" ( Pmod_ident x ) -# 20889 "parsing/parser.ml" +# 21432 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 835 "parsing/parser.mly" +# 856 "parsing/parser.mly" ( mkmod ~loc:_sloc _1 ) -# 20898 "parsing/parser.ml" +# 21441 "parsing/parser.ml" in -# 1190 "parsing/parser.mly" +# 1240 "parsing/parser.mly" ( _1 ) -# 20904 "parsing/parser.ml" +# 21447 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20931,24 +21474,24 @@ module Tables = struct let _endpos = _endpos_me2_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1181 "parsing/parser.mly" +# 1231 "parsing/parser.mly" ( Pmod_apply(me1, me2) ) -# 20937 "parsing/parser.ml" +# 21480 "parsing/parser.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 -# 835 "parsing/parser.mly" +# 856 "parsing/parser.mly" ( mkmod ~loc:_sloc _1 ) -# 20946 "parsing/parser.ml" +# 21489 "parsing/parser.ml" in -# 1190 "parsing/parser.mly" +# 1240 "parsing/parser.mly" ( _1 ) -# 20952 "parsing/parser.ml" +# 21495 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20990,10 +21533,10 @@ module Tables = struct let _symbolstartpos = _startpos_me1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1184 "parsing/parser.mly" +# 1234 "parsing/parser.mly" ( (* TODO review mkmod location *) Pmod_apply(me1, mkmod ~loc:_sloc (Pmod_structure [])) ) -# 20997 "parsing/parser.ml" +# 21540 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_me1_) in @@ -21001,15 +21544,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 835 "parsing/parser.mly" +# 856 "parsing/parser.mly" ( mkmod ~loc:_sloc _1 ) -# 21007 "parsing/parser.ml" +# 21550 "parsing/parser.ml" in -# 1190 "parsing/parser.mly" +# 1240 "parsing/parser.mly" ( _1 ) -# 21013 "parsing/parser.ml" +# 21556 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21033,24 +21576,24 @@ module Tables = struct let _endpos = _endpos_ex_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1188 "parsing/parser.mly" +# 1238 "parsing/parser.mly" ( Pmod_extension ex ) -# 21039 "parsing/parser.ml" +# 21582 "parsing/parser.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 -# 835 "parsing/parser.mly" +# 856 "parsing/parser.mly" ( mkmod ~loc:_sloc _1 ) -# 21048 "parsing/parser.ml" +# 21591 "parsing/parser.ml" in -# 1190 "parsing/parser.mly" +# 1240 "parsing/parser.mly" ( _1 ) -# 21054 "parsing/parser.ml" +# 21597 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21069,17 +21612,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let x : ( -# 688 "parsing/parser.mly" +# 697 "parsing/parser.mly" (string) -# 21075 "parsing/parser.ml" +# 21618 "parsing/parser.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) = -# 1145 "parsing/parser.mly" +# 1195 "parsing/parser.mly" ( Some x ) -# 21083 "parsing/parser.ml" +# 21626 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21102,9 +21645,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string option) = -# 1148 "parsing/parser.mly" +# 1198 "parsing/parser.mly" ( None ) -# 21108 "parsing/parser.ml" +# 21651 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21162,9 +21705,9 @@ module Tables = struct let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 688 "parsing/parser.mly" +# 697 "parsing/parser.mly" (string) -# 21168 "parsing/parser.ml" +# 21711 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Asttypes.loc option) = Obj.magic ext in @@ -21175,9 +21718,9 @@ module Tables = struct let _v : (Parsetree.module_substitution * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 21181 "parsing/parser.ml" +# 21724 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -21187,9 +21730,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 21193 "parsing/parser.ml" +# 21736 "parsing/parser.ml" in let uid = @@ -21198,31 +21741,31 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 21204 "parsing/parser.ml" +# 21747 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21212 "parsing/parser.ml" +# 21755 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1601 "parsing/parser.mly" +# 1651 "parsing/parser.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 ) -# 21226 "parsing/parser.ml" +# 21769 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21273,9 +21816,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 688 "parsing/parser.mly" +# 697 "parsing/parser.mly" (string) -# 21279 "parsing/parser.ml" +# 21822 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _2 : (string Asttypes.loc option) = Obj.magic _2 in @@ -21289,24 +21832,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 21295 "parsing/parser.ml" +# 21838 "parsing/parser.ml" in let _3 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21303 "parsing/parser.ml" +# 21846 "parsing/parser.ml" in let _loc__6_ = (_startpos__6_, _endpos__6_) in -# 1608 "parsing/parser.mly" +# 1658 "parsing/parser.mly" ( expecting _loc__6_ "module path" ) -# 21310 "parsing/parser.ml" +# 21853 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21352,18 +21895,18 @@ module Tables = struct let _v : (Parsetree.module_type) = let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21358 "parsing/parser.ml" +# 21901 "parsing/parser.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1454 "parsing/parser.mly" +# 1504 "parsing/parser.mly" ( mkmty ~loc:_sloc ~attrs (Pmty_signature s) ) -# 21367 "parsing/parser.ml" +# 21910 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21409,17 +21952,17 @@ module Tables = struct let _v : (Parsetree.module_type) = let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21415 "parsing/parser.ml" +# 21958 "parsing/parser.ml" in let _loc__4_ = (_startpos__4_, _endpos__4_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1456 "parsing/parser.mly" +# 1506 "parsing/parser.mly" ( unclosed "sig" _loc__1_ "end" _loc__4_ ) -# 21423 "parsing/parser.ml" +# 21966 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21472,30 +22015,30 @@ module Tables = struct let _v : (Parsetree.module_type) = let args = let _1 = _1_inlined2 in -# 1128 "parsing/parser.mly" +# 1178 "parsing/parser.mly" ( _1 ) -# 21478 "parsing/parser.ml" +# 22021 "parsing/parser.ml" in let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21486 "parsing/parser.ml" +# 22029 "parsing/parser.ml" in let _endpos = _endpos_mty_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1460 "parsing/parser.mly" +# 1510 "parsing/parser.mly" ( wrap_mty_attrs ~loc:_sloc attrs ( List.fold_left (fun acc arg -> mkmty ~loc:_sloc (Pmty_functor (arg, acc)) ) mty args ) ) -# 21499 "parsing/parser.ml" +# 22042 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21548,18 +22091,18 @@ module Tables = struct let _v : (Parsetree.module_type) = let _4 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21554 "parsing/parser.ml" +# 22097 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1466 "parsing/parser.mly" +# 1516 "parsing/parser.mly" ( mkmty ~loc:_sloc ~attrs:_4 (Pmty_typeof _5) ) -# 21563 "parsing/parser.ml" +# 22106 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21596,9 +22139,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.module_type) = -# 1468 "parsing/parser.mly" +# 1518 "parsing/parser.mly" ( _2 ) -# 21602 "parsing/parser.ml" +# 22145 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21637,9 +22180,9 @@ module Tables = struct let _v : (Parsetree.module_type) = let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1470 "parsing/parser.mly" +# 1520 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__3_ ) -# 21643 "parsing/parser.ml" +# 22186 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21669,9 +22212,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.module_type) = -# 1472 "parsing/parser.mly" +# 1522 "parsing/parser.mly" ( Mty.attr _1 _2 ) -# 21675 "parsing/parser.ml" +# 22218 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21700,30 +22243,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 21706 "parsing/parser.ml" +# 22249 "parsing/parser.ml" in -# 1475 "parsing/parser.mly" +# 1525 "parsing/parser.mly" ( Pmty_ident _1 ) -# 21712 "parsing/parser.ml" +# 22255 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 837 "parsing/parser.mly" +# 858 "parsing/parser.mly" ( mkmty ~loc:_sloc _1 ) -# 21721 "parsing/parser.ml" +# 22264 "parsing/parser.ml" in -# 1486 "parsing/parser.mly" +# 1536 "parsing/parser.mly" ( _1 ) -# 21727 "parsing/parser.ml" +# 22270 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21761,24 +22304,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.module_type) = let _1 = let _1 = -# 1478 "parsing/parser.mly" +# 1528 "parsing/parser.mly" ( Pmty_functor(Named (mknoloc None, _1), _3) ) -# 21767 "parsing/parser.ml" +# 22310 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 837 "parsing/parser.mly" +# 858 "parsing/parser.mly" ( mkmty ~loc:_sloc _1 ) -# 21776 "parsing/parser.ml" +# 22319 "parsing/parser.ml" in -# 1486 "parsing/parser.mly" +# 1536 "parsing/parser.mly" ( _1 ) -# 21782 "parsing/parser.ml" +# 22325 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21818,20 +22361,20 @@ module Tables = struct let _1 = let _3 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 21824 "parsing/parser.ml" +# 22367 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 21829 "parsing/parser.ml" +# 22372 "parsing/parser.ml" in -# 1480 "parsing/parser.mly" +# 1530 "parsing/parser.mly" ( Pmty_with(_1, _3) ) -# 21835 "parsing/parser.ml" +# 22378 "parsing/parser.ml" in let _endpos__1_ = _endpos_xs_ in @@ -21839,15 +22382,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 837 "parsing/parser.mly" +# 858 "parsing/parser.mly" ( mkmty ~loc:_sloc _1 ) -# 21845 "parsing/parser.ml" +# 22388 "parsing/parser.ml" in -# 1486 "parsing/parser.mly" +# 1536 "parsing/parser.mly" ( _1 ) -# 21851 "parsing/parser.ml" +# 22394 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21871,23 +22414,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.module_type) = let _1 = let _1 = -# 1484 "parsing/parser.mly" +# 1534 "parsing/parser.mly" ( Pmty_extension _1 ) -# 21877 "parsing/parser.ml" +# 22420 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 837 "parsing/parser.mly" +# 858 "parsing/parser.mly" ( mkmty ~loc:_sloc _1 ) -# 21885 "parsing/parser.ml" +# 22428 "parsing/parser.ml" in -# 1486 "parsing/parser.mly" +# 1536 "parsing/parser.mly" ( _1 ) -# 21891 "parsing/parser.ml" +# 22434 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21954,9 +22497,9 @@ module Tables = struct let _v : (Parsetree.module_type_declaration * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 21960 "parsing/parser.ml" +# 22503 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -21966,31 +22509,31 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 21972 "parsing/parser.ml" +# 22515 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 21980 "parsing/parser.ml" +# 22523 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1400 "parsing/parser.mly" +# 1450 "parsing/parser.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 ) -# 21994 "parsing/parser.ml" +# 22537 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22008,53 +22551,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : (Asttypes.label) = 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) = -# 3458 "parsing/parser.mly" - ( Lident _1 ) -# 22019 "parsing/parser.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 : (Asttypes.label) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3459 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 22058 "parsing/parser.ml" +# 3513 "parsing/parser.mly" + ( _1 ) +# 22562 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22070,9 +22574,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.mutable_flag) = -# 3528 "parsing/parser.mly" +# 3590 "parsing/parser.mly" ( Immutable ) -# 22076 "parsing/parser.ml" +# 22580 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22095,9 +22599,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag) = -# 3529 "parsing/parser.mly" +# 3591 "parsing/parser.mly" ( Mutable ) -# 22101 "parsing/parser.ml" +# 22605 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22113,9 +22617,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3537 "parsing/parser.mly" +# 3599 "parsing/parser.mly" ( Immutable, Concrete ) -# 22119 "parsing/parser.ml" +# 22623 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22138,9 +22642,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3539 "parsing/parser.mly" +# 3601 "parsing/parser.mly" ( Mutable, Concrete ) -# 22144 "parsing/parser.ml" +# 22648 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22163,9 +22667,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3541 "parsing/parser.mly" +# 3603 "parsing/parser.mly" ( Immutable, Virtual ) -# 22169 "parsing/parser.ml" +# 22673 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22195,9 +22699,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3544 "parsing/parser.mly" +# 3606 "parsing/parser.mly" ( Mutable, Virtual ) -# 22201 "parsing/parser.ml" +# 22705 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22227,9 +22731,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3544 "parsing/parser.mly" +# 3606 "parsing/parser.mly" ( Mutable, Virtual ) -# 22233 "parsing/parser.ml" +# 22737 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22259,9 +22763,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.label) = -# 3501 "parsing/parser.mly" +# 3563 "parsing/parser.mly" ( _2 ) -# 22265 "parsing/parser.ml" +# 22769 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22280,9 +22784,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 22286 "parsing/parser.ml" +# 22790 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -22292,15 +22796,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 22298 "parsing/parser.ml" +# 22802 "parsing/parser.ml" in -# 221 "menhir/standard.mly" +# 221 "" ( [ x ] ) -# 22304 "parsing/parser.ml" +# 22808 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22326,9 +22830,9 @@ module Tables = struct } = _menhir_stack in let xs : (string Asttypes.loc list) = Obj.magic xs in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 22332 "parsing/parser.ml" +# 22836 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -22338,15 +22842,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 22344 "parsing/parser.ml" +# 22848 "parsing/parser.ml" in -# 223 "menhir/standard.mly" +# 223 "" ( x :: xs ) -# 22350 "parsing/parser.ml" +# 22854 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22365,22 +22869,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let s : ( -# 680 "parsing/parser.mly" - (string * string option) -# 22371 "parsing/parser.ml" +# 685 "parsing/parser.mly" + (string * Location.t * string option) +# 22875 "parsing/parser.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 = -# 3497 "parsing/parser.mly" - ( fst s ) -# 22379 "parsing/parser.ml" +# 3559 "parsing/parser.mly" + ( let body, _, _ = s in body ) +# 22883 "parsing/parser.ml" in -# 221 "menhir/standard.mly" +# 221 "" ( [ x ] ) -# 22384 "parsing/parser.ml" +# 22888 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22406,22 +22910,22 @@ module Tables = struct } = _menhir_stack in let xs : (string list) = Obj.magic xs in let s : ( -# 680 "parsing/parser.mly" - (string * string option) -# 22412 "parsing/parser.ml" +# 685 "parsing/parser.mly" + (string * Location.t * string option) +# 22916 "parsing/parser.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 = -# 3497 "parsing/parser.mly" - ( fst s ) -# 22420 "parsing/parser.ml" +# 3559 "parsing/parser.mly" + ( let body, _, _ = s in body ) +# 22924 "parsing/parser.ml" in -# 223 "menhir/standard.mly" +# 223 "" ( x :: xs ) -# 22425 "parsing/parser.ml" +# 22929 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22444,14 +22948,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 22450 "parsing/parser.ml" +# 22954 "parsing/parser.ml" in -# 2846 "parsing/parser.mly" +# 2896 "parsing/parser.mly" ( (Ptype_abstract, priv, Some ty) ) -# 22455 "parsing/parser.ml" +# 22959 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22481,14 +22985,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 22487 "parsing/parser.ml" +# 22991 "parsing/parser.ml" in -# 2846 "parsing/parser.mly" +# 2896 "parsing/parser.mly" ( (Ptype_abstract, priv, Some ty) ) -# 22492 "parsing/parser.ml" +# 22996 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22511,26 +23015,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 22517 "parsing/parser.ml" +# 23021 "parsing/parser.ml" in let oty = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 22523 "parsing/parser.ml" +# 23027 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22528 "parsing/parser.ml" +# 23032 "parsing/parser.ml" in -# 2850 "parsing/parser.mly" +# 2900 "parsing/parser.mly" ( (Ptype_variant cs, priv, oty) ) -# 22534 "parsing/parser.ml" +# 23038 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22560,26 +23064,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 22566 "parsing/parser.ml" +# 23070 "parsing/parser.ml" in let oty = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 22572 "parsing/parser.ml" +# 23076 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22577 "parsing/parser.ml" +# 23081 "parsing/parser.ml" in -# 2850 "parsing/parser.mly" +# 2900 "parsing/parser.mly" ( (Ptype_variant cs, priv, oty) ) -# 22583 "parsing/parser.ml" +# 23087 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22616,33 +23120,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 22622 "parsing/parser.ml" +# 23126 "parsing/parser.ml" in let oty = let _1 = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 22629 "parsing/parser.ml" +# 23133 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 22634 "parsing/parser.ml" +# 23138 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22640 "parsing/parser.ml" +# 23144 "parsing/parser.ml" in -# 2850 "parsing/parser.mly" +# 2900 "parsing/parser.mly" ( (Ptype_variant cs, priv, oty) ) -# 22646 "parsing/parser.ml" +# 23150 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22686,33 +23190,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 22692 "parsing/parser.ml" +# 23196 "parsing/parser.ml" in let oty = let _1 = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 22699 "parsing/parser.ml" +# 23203 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 22704 "parsing/parser.ml" +# 23208 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22710 "parsing/parser.ml" +# 23214 "parsing/parser.ml" in -# 2850 "parsing/parser.mly" +# 2900 "parsing/parser.mly" ( (Ptype_variant cs, priv, oty) ) -# 22716 "parsing/parser.ml" +# 23220 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22735,26 +23239,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 22741 "parsing/parser.ml" +# 23245 "parsing/parser.ml" in let oty = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 22747 "parsing/parser.ml" +# 23251 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22752 "parsing/parser.ml" +# 23256 "parsing/parser.ml" in -# 2854 "parsing/parser.mly" +# 2904 "parsing/parser.mly" ( (Ptype_open, priv, oty) ) -# 22758 "parsing/parser.ml" +# 23262 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22784,26 +23288,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 22790 "parsing/parser.ml" +# 23294 "parsing/parser.ml" in let oty = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 22796 "parsing/parser.ml" +# 23300 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22801 "parsing/parser.ml" +# 23305 "parsing/parser.ml" in -# 2854 "parsing/parser.mly" +# 2904 "parsing/parser.mly" ( (Ptype_open, priv, oty) ) -# 22807 "parsing/parser.ml" +# 23311 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22840,33 +23344,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 22846 "parsing/parser.ml" +# 23350 "parsing/parser.ml" in let oty = let _1 = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 22853 "parsing/parser.ml" +# 23357 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 22858 "parsing/parser.ml" +# 23362 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22864 "parsing/parser.ml" +# 23368 "parsing/parser.ml" in -# 2854 "parsing/parser.mly" +# 2904 "parsing/parser.mly" ( (Ptype_open, priv, oty) ) -# 22870 "parsing/parser.ml" +# 23374 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22910,33 +23414,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 22916 "parsing/parser.ml" +# 23420 "parsing/parser.ml" in let oty = let _1 = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 22923 "parsing/parser.ml" +# 23427 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 22928 "parsing/parser.ml" +# 23432 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22934 "parsing/parser.ml" +# 23438 "parsing/parser.ml" in -# 2854 "parsing/parser.mly" +# 2904 "parsing/parser.mly" ( (Ptype_open, priv, oty) ) -# 22940 "parsing/parser.ml" +# 23444 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22973,26 +23477,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 22979 "parsing/parser.ml" +# 23483 "parsing/parser.ml" in let oty = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 22985 "parsing/parser.ml" +# 23489 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 22990 "parsing/parser.ml" +# 23494 "parsing/parser.ml" in -# 2858 "parsing/parser.mly" +# 2908 "parsing/parser.mly" ( (Ptype_record ls, priv, oty) ) -# 22996 "parsing/parser.ml" +# 23500 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23036,26 +23540,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 23042 "parsing/parser.ml" +# 23546 "parsing/parser.ml" in let oty = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 23048 "parsing/parser.ml" +# 23552 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 23053 "parsing/parser.ml" +# 23557 "parsing/parser.ml" in -# 2858 "parsing/parser.mly" +# 2908 "parsing/parser.mly" ( (Ptype_record ls, priv, oty) ) -# 23059 "parsing/parser.ml" +# 23563 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23106,33 +23610,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 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 23112 "parsing/parser.ml" +# 23616 "parsing/parser.ml" in let oty = let _1 = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 23119 "parsing/parser.ml" +# 23623 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 23124 "parsing/parser.ml" +# 23628 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 23130 "parsing/parser.ml" +# 23634 "parsing/parser.ml" in -# 2858 "parsing/parser.mly" +# 2908 "parsing/parser.mly" ( (Ptype_record ls, priv, oty) ) -# 23136 "parsing/parser.ml" +# 23640 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23190,33 +23694,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 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 23196 "parsing/parser.ml" +# 23700 "parsing/parser.ml" in let oty = let _1 = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 23203 "parsing/parser.ml" +# 23707 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 23208 "parsing/parser.ml" +# 23712 "parsing/parser.ml" in -# 2862 "parsing/parser.mly" +# 2912 "parsing/parser.mly" ( _1 ) -# 23214 "parsing/parser.ml" +# 23718 "parsing/parser.ml" in -# 2858 "parsing/parser.mly" +# 2908 "parsing/parser.mly" ( (Ptype_record ls, priv, oty) ) -# 23220 "parsing/parser.ml" +# 23724 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23269,37 +23773,37 @@ module Tables = struct let _v : (Parsetree.open_declaration * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 23275 "parsing/parser.ml" +# 23779 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 23284 "parsing/parser.ml" +# 23788 "parsing/parser.ml" in let override = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 23290 "parsing/parser.ml" +# 23794 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1419 "parsing/parser.mly" +# 1469 "parsing/parser.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 ) -# 23303 "parsing/parser.ml" +# 23807 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23359,40 +23863,40 @@ module Tables = struct let _v : (Parsetree.open_declaration * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 23365 "parsing/parser.ml" +# 23869 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let attrs1 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 23374 "parsing/parser.ml" +# 23878 "parsing/parser.ml" in let override = let _1 = _1_inlined1 in -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 23382 "parsing/parser.ml" +# 23886 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1419 "parsing/parser.mly" +# 1469 "parsing/parser.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 ) -# 23396 "parsing/parser.ml" +# 23900 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23445,9 +23949,9 @@ module Tables = struct let _v : (Parsetree.open_description * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 23451 "parsing/parser.ml" +# 23955 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -23457,36 +23961,36 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 23463 "parsing/parser.ml" +# 23967 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 23471 "parsing/parser.ml" +# 23975 "parsing/parser.ml" in let override = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 23477 "parsing/parser.ml" +# 23981 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1434 "parsing/parser.mly" +# 1484 "parsing/parser.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 ) -# 23490 "parsing/parser.ml" +# 23994 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23546,9 +24050,9 @@ module Tables = struct let _v : (Parsetree.open_description * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 23552 "parsing/parser.ml" +# 24056 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -23558,39 +24062,39 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 23564 "parsing/parser.ml" +# 24068 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined2 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 23572 "parsing/parser.ml" +# 24076 "parsing/parser.ml" in let override = let _1 = _1_inlined1 in -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 23580 "parsing/parser.ml" +# 24084 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1434 "parsing/parser.mly" +# 1484 "parsing/parser.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 ) -# 23594 "parsing/parser.ml" +# 24098 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23609,17 +24113,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 666 "parsing/parser.mly" +# 671 "parsing/parser.mly" (string) -# 23615 "parsing/parser.ml" +# 24119 "parsing/parser.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) = -# 3376 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3429 "parsing/parser.mly" ( _1 ) -# 23623 "parsing/parser.ml" +# 24127 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23638,17 +24142,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 624 "parsing/parser.mly" +# 629 "parsing/parser.mly" (string) -# 23644 "parsing/parser.ml" +# 24148 "parsing/parser.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) = -# 3377 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3430 "parsing/parser.mly" ( _1 ) -# 23652 "parsing/parser.ml" +# 24156 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23667,17 +24171,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 625 "parsing/parser.mly" +# 630 "parsing/parser.mly" (string) -# 23673 "parsing/parser.ml" +# 24177 "parsing/parser.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) = -# 3378 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3431 "parsing/parser.mly" ( _1 ) -# 23681 "parsing/parser.ml" +# 24185 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23717,17 +24221,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 23723 "parsing/parser.ml" +# 24227 "parsing/parser.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) = -# 3379 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3432 "parsing/parser.mly" ( "."^ _1 ^"(" ^ _3 ^ ")" ) -# 23731 "parsing/parser.ml" +# 24235 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23774,17 +24278,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 23780 "parsing/parser.ml" +# 24284 "parsing/parser.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) = -# 3380 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3433 "parsing/parser.mly" ( "."^ _1 ^ "(" ^ _3 ^ ")<-" ) -# 23788 "parsing/parser.ml" +# 24292 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23824,17 +24328,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 23830 "parsing/parser.ml" +# 24334 "parsing/parser.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) = -# 3381 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3434 "parsing/parser.mly" ( "."^ _1 ^"[" ^ _3 ^ "]" ) -# 23838 "parsing/parser.ml" +# 24342 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23881,17 +24385,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 23887 "parsing/parser.ml" +# 24391 "parsing/parser.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) = -# 3382 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3435 "parsing/parser.mly" ( "."^ _1 ^ "[" ^ _3 ^ "]<-" ) -# 23895 "parsing/parser.ml" +# 24399 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23931,17 +24435,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 23937 "parsing/parser.ml" +# 24441 "parsing/parser.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) = -# 3383 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3436 "parsing/parser.mly" ( "."^ _1 ^"{" ^ _3 ^ "}" ) -# 23945 "parsing/parser.ml" +# 24449 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23988,17 +24492,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 23994 "parsing/parser.ml" +# 24498 "parsing/parser.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) = -# 3384 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3437 "parsing/parser.mly" ( "."^ _1 ^ "{" ^ _3 ^ "}<-" ) -# 24002 "parsing/parser.ml" +# 24506 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24017,17 +24521,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 677 "parsing/parser.mly" +# 682 "parsing/parser.mly" (string) -# 24023 "parsing/parser.ml" +# 24527 "parsing/parser.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) = -# 3385 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3438 "parsing/parser.mly" ( _1 ) -# 24031 "parsing/parser.ml" +# 24535 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24049,10 +24553,10 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (string) = -# 3386 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3439 "parsing/parser.mly" ( "!" ) -# 24056 "parsing/parser.ml" +# 24560 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24071,22 +24575,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 618 "parsing/parser.mly" +# 623 "parsing/parser.mly" (string) -# 24077 "parsing/parser.ml" +# 24581 "parsing/parser.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 = -# 3390 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3443 "parsing/parser.mly" ( op ) -# 24085 "parsing/parser.ml" +# 24589 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24090 "parsing/parser.ml" +# 24594 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24105,22 +24609,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 619 "parsing/parser.mly" +# 624 "parsing/parser.mly" (string) -# 24111 "parsing/parser.ml" +# 24615 "parsing/parser.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 = -# 3391 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3444 "parsing/parser.mly" ( op ) -# 24119 "parsing/parser.ml" +# 24623 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24124 "parsing/parser.ml" +# 24628 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24139,22 +24643,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 620 "parsing/parser.mly" +# 625 "parsing/parser.mly" (string) -# 24145 "parsing/parser.ml" +# 24649 "parsing/parser.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 = -# 3392 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3445 "parsing/parser.mly" ( op ) -# 24153 "parsing/parser.ml" +# 24657 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24158 "parsing/parser.ml" +# 24662 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24173,22 +24677,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 621 "parsing/parser.mly" +# 626 "parsing/parser.mly" (string) -# 24179 "parsing/parser.ml" +# 24683 "parsing/parser.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 = -# 3393 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3446 "parsing/parser.mly" ( op ) -# 24187 "parsing/parser.ml" +# 24691 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24192 "parsing/parser.ml" +# 24696 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24207,22 +24711,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 622 "parsing/parser.mly" +# 627 "parsing/parser.mly" (string) -# 24213 "parsing/parser.ml" +# 24717 "parsing/parser.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 = -# 3394 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3447 "parsing/parser.mly" ( op ) -# 24221 "parsing/parser.ml" +# 24725 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24226 "parsing/parser.ml" +# 24730 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24244,15 +24748,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 : (string) = let _1 = -# 3395 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3448 "parsing/parser.mly" ("+") -# 24251 "parsing/parser.ml" +# 24755 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24256 "parsing/parser.ml" +# 24760 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24274,15 +24778,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 : (string) = let _1 = -# 3396 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3449 "parsing/parser.mly" ("+.") -# 24281 "parsing/parser.ml" +# 24785 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24286 "parsing/parser.ml" +# 24790 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24304,15 +24808,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 : (string) = let _1 = -# 3397 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3450 "parsing/parser.mly" ("+=") -# 24311 "parsing/parser.ml" +# 24815 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24316 "parsing/parser.ml" +# 24820 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24334,15 +24838,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 : (string) = let _1 = -# 3398 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3451 "parsing/parser.mly" ("-") -# 24341 "parsing/parser.ml" +# 24845 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24346 "parsing/parser.ml" +# 24850 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24364,15 +24868,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 : (string) = let _1 = -# 3399 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3452 "parsing/parser.mly" ("-.") -# 24371 "parsing/parser.ml" +# 24875 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24376 "parsing/parser.ml" +# 24880 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24394,15 +24898,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 : (string) = let _1 = -# 3400 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3453 "parsing/parser.mly" ("*") -# 24401 "parsing/parser.ml" +# 24905 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24406 "parsing/parser.ml" +# 24910 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24424,15 +24928,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 : (string) = let _1 = -# 3401 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3454 "parsing/parser.mly" ("%") -# 24431 "parsing/parser.ml" +# 24935 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24436 "parsing/parser.ml" +# 24940 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24454,15 +24958,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 : (string) = let _1 = -# 3402 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3455 "parsing/parser.mly" ("=") -# 24461 "parsing/parser.ml" +# 24965 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24466 "parsing/parser.ml" +# 24970 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24484,15 +24988,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 : (string) = let _1 = -# 3403 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3456 "parsing/parser.mly" ("<") -# 24491 "parsing/parser.ml" +# 24995 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24496 "parsing/parser.ml" +# 25000 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24514,15 +25018,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 : (string) = let _1 = -# 3404 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3457 "parsing/parser.mly" (">") -# 24521 "parsing/parser.ml" +# 25025 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24526 "parsing/parser.ml" +# 25030 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24544,15 +25048,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 : (string) = let _1 = -# 3405 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3458 "parsing/parser.mly" ("or") -# 24551 "parsing/parser.ml" +# 25055 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24556 "parsing/parser.ml" +# 25060 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24574,15 +25078,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 : (string) = let _1 = -# 3406 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3459 "parsing/parser.mly" ("||") -# 24581 "parsing/parser.ml" +# 25085 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24586 "parsing/parser.ml" +# 25090 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24604,15 +25108,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 : (string) = let _1 = -# 3407 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3460 "parsing/parser.mly" ("&") -# 24611 "parsing/parser.ml" +# 25115 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24616 "parsing/parser.ml" +# 25120 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24634,15 +25138,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 : (string) = let _1 = -# 3408 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3461 "parsing/parser.mly" ("&&") -# 24641 "parsing/parser.ml" +# 25145 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24646 "parsing/parser.ml" +# 25150 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24664,15 +25168,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 : (string) = let _1 = -# 3409 "parsing/parser.mly" + let _v : (Asttypes.label) = let _1 = +# 3462 "parsing/parser.mly" (":=") -# 24671 "parsing/parser.ml" +# 25175 "parsing/parser.ml" in -# 3387 "parsing/parser.mly" +# 3440 "parsing/parser.mly" ( _1 ) -# 24676 "parsing/parser.ml" +# 25180 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24695,9 +25199,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (bool) = -# 3294 "parsing/parser.mly" +# 3344 "parsing/parser.mly" ( true ) -# 24701 "parsing/parser.ml" +# 25205 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24713,9 +25217,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (bool) = -# 3295 "parsing/parser.mly" +# 3345 "parsing/parser.mly" ( false ) -# 24719 "parsing/parser.ml" +# 25223 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24731,9 +25235,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (unit option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 24737 "parsing/parser.ml" +# 25241 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24756,9 +25260,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (unit option) = -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 24762 "parsing/parser.ml" +# 25266 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24774,9 +25278,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (unit option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 24780 "parsing/parser.ml" +# 25284 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24799,9 +25303,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (unit option) = -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 24805 "parsing/parser.ml" +# 25309 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24817,9 +25321,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (string Asttypes.loc option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 24823 "parsing/parser.ml" +# 25327 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24844,9 +25348,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 24850 "parsing/parser.ml" +# 25354 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -24859,21 +25363,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 24865 "parsing/parser.ml" +# 25369 "parsing/parser.ml" in -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 24871 "parsing/parser.ml" +# 25375 "parsing/parser.ml" in -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 24877 "parsing/parser.ml" +# 25381 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24889,9 +25393,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.core_type option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 24895 "parsing/parser.ml" +# 25399 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24921,14 +25425,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type option) = let x = -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 24927 "parsing/parser.ml" +# 25431 "parsing/parser.ml" in -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 24932 "parsing/parser.ml" +# 25436 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24944,9 +25448,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.expression option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 24950 "parsing/parser.ml" +# 25454 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24976,14 +25480,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : (Parsetree.expression option) = let x = -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 24982 "parsing/parser.ml" +# 25486 "parsing/parser.ml" in -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 24987 "parsing/parser.ml" +# 25491 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24999,9 +25503,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.module_type option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 25005 "parsing/parser.ml" +# 25509 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25031,14 +25535,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : (Parsetree.module_type option) = let x = -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 25037 "parsing/parser.ml" +# 25541 "parsing/parser.ml" in -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 25042 "parsing/parser.ml" +# 25546 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25054,9 +25558,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.pattern option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 25060 "parsing/parser.ml" +# 25564 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25086,14 +25590,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : (Parsetree.pattern option) = let x = -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 25092 "parsing/parser.ml" +# 25596 "parsing/parser.ml" in -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 25097 "parsing/parser.ml" +# 25601 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25109,9 +25613,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.expression option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 25115 "parsing/parser.ml" +# 25619 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25141,14 +25645,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : (Parsetree.expression option) = let x = -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 25147 "parsing/parser.ml" +# 25651 "parsing/parser.ml" in -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 25152 "parsing/parser.ml" +# 25656 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25164,9 +25668,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) = -# 114 "menhir/standard.mly" +# 114 "" ( None ) -# 25170 "parsing/parser.ml" +# 25674 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25189,9 +25693,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) = -# 116 "menhir/standard.mly" +# 116 "" ( Some x ) -# 25195 "parsing/parser.ml" +# 25699 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25210,17 +25714,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 659 "parsing/parser.mly" +# 664 "parsing/parser.mly" (string) -# 25216 "parsing/parser.ml" +# 25720 "parsing/parser.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) = -# 3583 "parsing/parser.mly" +# 3645 "parsing/parser.mly" ( _1 ) -# 25224 "parsing/parser.ml" +# 25728 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25252,18 +25756,18 @@ module Tables = struct } = _menhir_stack in let _3 : unit = Obj.magic _3 in let _2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 25258 "parsing/parser.ml" +# 25762 "parsing/parser.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) = -# 3584 "parsing/parser.mly" +# 3646 "parsing/parser.mly" ( _2 ) -# 25267 "parsing/parser.ml" +# 25771 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25317,9 +25821,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1199 "parsing/parser.mly" +# 1249 "parsing/parser.mly" ( mkmod ~loc:_sloc (Pmod_constraint(me, mty)) ) -# 25323 "parsing/parser.ml" +# 25827 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25372,9 +25876,9 @@ module Tables = struct let _v : (Parsetree.module_expr) = let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1201 "parsing/parser.mly" +# 1251 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__5_ ) -# 25378 "parsing/parser.ml" +# 25882 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25411,9 +25915,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.module_expr) = -# 1204 "parsing/parser.mly" +# 1254 "parsing/parser.mly" ( me (* TODO consider reloc *) ) -# 25417 "parsing/parser.ml" +# 25921 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25452,9 +25956,9 @@ module Tables = struct let _v : (Parsetree.module_expr) = let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1206 "parsing/parser.mly" +# 1256 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__3_ ) -# 25458 "parsing/parser.ml" +# 25962 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25505,25 +26009,25 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.module_expr) = let e = -# 1223 "parsing/parser.mly" +# 1273 "parsing/parser.mly" ( e ) -# 25511 "parsing/parser.ml" +# 26015 "parsing/parser.ml" in let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 25518 "parsing/parser.ml" +# 26022 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1210 "parsing/parser.mly" +# 1260 "parsing/parser.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 25527 "parsing/parser.ml" +# 26031 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25592,23 +26096,23 @@ module Tables = struct let ty = let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 25598 "parsing/parser.ml" +# 26102 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 25606 "parsing/parser.ml" +# 26110 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 25612 "parsing/parser.ml" +# 26116 "parsing/parser.ml" in let _endpos_ty_ = _endpos__1_ in @@ -25616,26 +26120,26 @@ module Tables = struct let _startpos = _startpos_e_ in let _loc = (_startpos, _endpos) in -# 1225 "parsing/parser.mly" +# 1275 "parsing/parser.mly" ( ghexp ~loc:_loc (Pexp_constraint (e, ty)) ) -# 25622 "parsing/parser.ml" +# 26126 "parsing/parser.ml" in let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 25630 "parsing/parser.ml" +# 26134 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1210 "parsing/parser.mly" +# 1260 "parsing/parser.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 25639 "parsing/parser.ml" +# 26143 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25719,72 +26223,72 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 25725 "parsing/parser.ml" +# 26229 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 25733 "parsing/parser.ml" +# 26237 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 25739 "parsing/parser.ml" +# 26243 "parsing/parser.ml" in let _endpos_ty2_ = _endpos__1_inlined1_ in let ty1 = let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 25748 "parsing/parser.ml" +# 26252 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 25756 "parsing/parser.ml" +# 26260 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 25762 "parsing/parser.ml" +# 26266 "parsing/parser.ml" in let _endpos = _endpos_ty2_ in let _startpos = _startpos_e_ in let _loc = (_startpos, _endpos) in -# 1227 "parsing/parser.mly" +# 1277 "parsing/parser.mly" ( ghexp ~loc:_loc (Pexp_coerce (e, Some ty1, ty2)) ) -# 25771 "parsing/parser.ml" +# 26275 "parsing/parser.ml" in let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 25779 "parsing/parser.ml" +# 26283 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1210 "parsing/parser.mly" +# 1260 "parsing/parser.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 25788 "parsing/parser.ml" +# 26292 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25853,23 +26357,23 @@ module Tables = struct let ty2 = let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 25859 "parsing/parser.ml" +# 26363 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 25867 "parsing/parser.ml" +# 26371 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 25873 "parsing/parser.ml" +# 26377 "parsing/parser.ml" in let _endpos_ty2_ = _endpos__1_ in @@ -25877,26 +26381,26 @@ module Tables = struct let _startpos = _startpos_e_ in let _loc = (_startpos, _endpos) in -# 1229 "parsing/parser.mly" +# 1279 "parsing/parser.mly" ( ghexp ~loc:_loc (Pexp_coerce (e, None, ty2)) ) -# 25883 "parsing/parser.ml" +# 26387 "parsing/parser.ml" in let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 25891 "parsing/parser.ml" +# 26395 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1210 "parsing/parser.mly" +# 1260 "parsing/parser.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 25900 "parsing/parser.ml" +# 26404 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25956,17 +26460,17 @@ module Tables = struct let _v : (Parsetree.module_expr) = let _3 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 25962 "parsing/parser.ml" +# 26466 "parsing/parser.ml" in let _loc__6_ = (_startpos__6_, _endpos__6_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1212 "parsing/parser.mly" +# 1262 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__6_ ) -# 25970 "parsing/parser.ml" +# 26474 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26026,17 +26530,17 @@ module Tables = struct let _v : (Parsetree.module_expr) = let _3 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 26032 "parsing/parser.ml" +# 26536 "parsing/parser.ml" in let _loc__6_ = (_startpos__6_, _endpos__6_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1214 "parsing/parser.mly" +# 1264 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__6_ ) -# 26040 "parsing/parser.ml" +# 26544 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26089,17 +26593,89 @@ module Tables = struct let _v : (Parsetree.module_expr) = let _3 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 26095 "parsing/parser.ml" +# 26599 "parsing/parser.ml" in let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1216 "parsing/parser.mly" +# 1266 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__5_ ) -# 26103 "parsing/parser.ml" +# 26607 "parsing/parser.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 : (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 : ( +# 801 "parsing/parser.mly" + (Longident.t) +# 26639 "parsing/parser.ml" + ) = +# 1170 "parsing/parser.mly" + ( _1 ) +# 26643 "parsing/parser.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 : (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 : ( +# 791 "parsing/parser.mly" + (Longident.t) +# 26675 "parsing/parser.ml" + ) = +# 1155 "parsing/parser.mly" + ( _1 ) +# 26679 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26129,13 +26705,13 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 776 "parsing/parser.mly" +# 785 "parsing/parser.mly" (Parsetree.core_type) -# 26135 "parsing/parser.ml" +# 26711 "parsing/parser.ml" ) = -# 1109 "parsing/parser.mly" +# 1130 "parsing/parser.mly" ( _1 ) -# 26139 "parsing/parser.ml" +# 26715 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26165,13 +26741,121 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 778 "parsing/parser.mly" +# 787 "parsing/parser.mly" (Parsetree.expression) -# 26171 "parsing/parser.ml" +# 26747 "parsing/parser.ml" + ) = +# 1135 "parsing/parser.mly" + ( _1 ) +# 26751 "parsing/parser.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 : (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 : ( +# 797 "parsing/parser.mly" + (Longident.t) +# 26783 "parsing/parser.ml" ) = -# 1114 "parsing/parser.mly" +# 1160 "parsing/parser.mly" ( _1 ) -# 26175 "parsing/parser.ml" +# 26787 "parsing/parser.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 : (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 : ( +# 799 "parsing/parser.mly" + (Longident.t) +# 26819 "parsing/parser.ml" + ) = +# 1165 "parsing/parser.mly" + ( _1 ) +# 26823 "parsing/parser.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 : (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 : ( +# 795 "parsing/parser.mly" + (Longident.t) +# 26855 "parsing/parser.ml" + ) = +# 1145 "parsing/parser.mly" + ( _1 ) +# 26859 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26201,13 +26885,49 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 780 "parsing/parser.mly" +# 789 "parsing/parser.mly" (Parsetree.pattern) -# 26207 "parsing/parser.ml" +# 26891 "parsing/parser.ml" + ) = +# 1140 "parsing/parser.mly" + ( _1 ) +# 26895 "parsing/parser.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 : (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 : ( +# 793 "parsing/parser.mly" + (Longident.t) +# 26927 "parsing/parser.ml" ) = -# 1119 "parsing/parser.mly" +# 1150 "parsing/parser.mly" ( _1 ) -# 26211 "parsing/parser.ml" +# 26931 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26249,15 +26969,15 @@ module Tables = struct let _loc__2_ = (_startpos__2_, _endpos__2_) in let _sloc = (_symbolstartpos, _endpos) in -# 2581 "parsing/parser.mly" +# 2631 "parsing/parser.mly" ( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) ) -# 26255 "parsing/parser.ml" +# 26975 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26261 "parsing/parser.ml" +# 26981 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26287,14 +27007,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = -# 2583 "parsing/parser.mly" +# 2633 "parsing/parser.mly" ( Pat.attr _1 _2 ) -# 26293 "parsing/parser.ml" +# 27013 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26298 "parsing/parser.ml" +# 27018 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26317,14 +27037,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = -# 2585 "parsing/parser.mly" +# 2635 "parsing/parser.mly" ( _1 ) -# 26323 "parsing/parser.ml" +# 27043 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26328 "parsing/parser.ml" +# 27048 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26354,7 +27074,7 @@ module Tables = struct }; }; } = _menhir_stack in - let _1_inlined1 : (string) = Obj.magic _1_inlined1 in + let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : (Parsetree.pattern) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -26369,15 +27089,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 26375 "parsing/parser.ml" +# 27095 "parsing/parser.ml" in -# 2588 "parsing/parser.mly" +# 2638 "parsing/parser.mly" ( Ppat_alias(_1, _3) ) -# 26381 "parsing/parser.ml" +# 27101 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -26385,21 +27105,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 26391 "parsing/parser.ml" +# 27111 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 26397 "parsing/parser.ml" +# 27117 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26403 "parsing/parser.ml" +# 27123 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26440,9 +27160,9 @@ module Tables = struct let _1 = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2590 "parsing/parser.mly" +# 2640 "parsing/parser.mly" ( expecting _loc__3_ "identifier" ) -# 26446 "parsing/parser.ml" +# 27166 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -26450,21 +27170,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 26456 "parsing/parser.ml" +# 27176 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 26462 "parsing/parser.ml" +# 27182 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26468 "parsing/parser.ml" +# 27188 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26489,29 +27209,29 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2592 "parsing/parser.mly" +# 2642 "parsing/parser.mly" ( Ppat_tuple(List.rev _1) ) -# 26495 "parsing/parser.ml" +# 27215 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 26503 "parsing/parser.ml" +# 27223 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 26509 "parsing/parser.ml" +# 27229 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26515 "parsing/parser.ml" +# 27235 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26552,9 +27272,9 @@ module Tables = struct let _1 = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2594 "parsing/parser.mly" +# 2644 "parsing/parser.mly" ( expecting _loc__3_ "pattern" ) -# 26558 "parsing/parser.ml" +# 27278 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -26562,21 +27282,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 26568 "parsing/parser.ml" +# 27288 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 26574 "parsing/parser.ml" +# 27294 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26580 "parsing/parser.ml" +# 27300 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26615,30 +27335,30 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2596 "parsing/parser.mly" +# 2646 "parsing/parser.mly" ( Ppat_or(_1, _3) ) -# 26621 "parsing/parser.ml" +# 27341 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 26630 "parsing/parser.ml" +# 27350 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 26636 "parsing/parser.ml" +# 27356 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26642 "parsing/parser.ml" +# 27362 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26679,9 +27399,9 @@ module Tables = struct let _1 = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2598 "parsing/parser.mly" +# 2648 "parsing/parser.mly" ( expecting _loc__3_ "pattern" ) -# 26685 "parsing/parser.ml" +# 27405 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -26689,21 +27409,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 26695 "parsing/parser.ml" +# 27415 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 26701 "parsing/parser.ml" +# 27421 "parsing/parser.ml" in -# 2569 "parsing/parser.mly" +# 2619 "parsing/parser.mly" ( _1 ) -# 26707 "parsing/parser.ml" +# 27427 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26751,24 +27471,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 26757 "parsing/parser.ml" +# 27477 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 26763 "parsing/parser.ml" +# 27483 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2571 "parsing/parser.mly" +# 2621 "parsing/parser.mly" ( mkpat_attrs ~loc:_sloc (Ppat_exception _3) _2) -# 26772 "parsing/parser.ml" +# 27492 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26805,9 +27525,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 2695 "parsing/parser.mly" +# 2745 "parsing/parser.mly" ( _3 :: _1 ) -# 26811 "parsing/parser.ml" +# 27531 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26844,9 +27564,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 2696 "parsing/parser.mly" +# 2746 "parsing/parser.mly" ( [_3; _1] ) -# 26850 "parsing/parser.ml" +# 27570 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26884,9 +27604,9 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2697 "parsing/parser.mly" +# 2747 "parsing/parser.mly" ( expecting _loc__3_ "pattern" ) -# 26890 "parsing/parser.ml" +# 27610 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26923,9 +27643,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 2695 "parsing/parser.mly" +# 2745 "parsing/parser.mly" ( _3 :: _1 ) -# 26929 "parsing/parser.ml" +# 27649 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26962,9 +27682,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 2696 "parsing/parser.mly" +# 2746 "parsing/parser.mly" ( [_3; _1] ) -# 26968 "parsing/parser.ml" +# 27688 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27002,9 +27722,9 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2697 "parsing/parser.mly" +# 2747 "parsing/parser.mly" ( expecting _loc__3_ "pattern" ) -# 27008 "parsing/parser.ml" +# 27728 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27027,9 +27747,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2604 "parsing/parser.mly" +# 2654 "parsing/parser.mly" ( _1 ) -# 27033 "parsing/parser.ml" +# 27753 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27065,15 +27785,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 27071 "parsing/parser.ml" +# 27791 "parsing/parser.ml" in -# 2607 "parsing/parser.mly" +# 2657 "parsing/parser.mly" ( Ppat_construct(_1, Some _2) ) -# 27077 "parsing/parser.ml" +# 27797 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in @@ -27081,15 +27801,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27087 "parsing/parser.ml" +# 27807 "parsing/parser.ml" in -# 2610 "parsing/parser.mly" +# 2660 "parsing/parser.mly" ( _1 ) -# 27093 "parsing/parser.ml" +# 27813 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27120,24 +27840,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2609 "parsing/parser.mly" +# 2659 "parsing/parser.mly" ( Ppat_variant(_1, Some _2) ) -# 27126 "parsing/parser.ml" +# 27846 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27135 "parsing/parser.ml" +# 27855 "parsing/parser.ml" in -# 2610 "parsing/parser.mly" +# 2660 "parsing/parser.mly" ( _1 ) -# 27141 "parsing/parser.ml" +# 27861 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27185,24 +27905,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 27191 "parsing/parser.ml" +# 27911 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 27197 "parsing/parser.ml" +# 27917 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2612 "parsing/parser.mly" +# 2662 "parsing/parser.mly" ( mkpat_attrs ~loc:_sloc (Ppat_lazy _3) _2) -# 27206 "parsing/parser.ml" +# 27926 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27244,15 +27964,15 @@ module Tables = struct let _loc__2_ = (_startpos__2_, _endpos__2_) in let _sloc = (_symbolstartpos, _endpos) in -# 2581 "parsing/parser.mly" +# 2631 "parsing/parser.mly" ( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) ) -# 27250 "parsing/parser.ml" +# 27970 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27256 "parsing/parser.ml" +# 27976 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27282,14 +28002,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = -# 2583 "parsing/parser.mly" +# 2633 "parsing/parser.mly" ( Pat.attr _1 _2 ) -# 27288 "parsing/parser.ml" +# 28008 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27293 "parsing/parser.ml" +# 28013 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27312,14 +28032,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = -# 2585 "parsing/parser.mly" +# 2635 "parsing/parser.mly" ( _1 ) -# 27318 "parsing/parser.ml" +# 28038 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27323 "parsing/parser.ml" +# 28043 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27349,7 +28069,7 @@ module Tables = struct }; }; } = _menhir_stack in - let _1_inlined1 : (string) = Obj.magic _1_inlined1 in + let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : (Parsetree.pattern) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -27364,15 +28084,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 27370 "parsing/parser.ml" +# 28090 "parsing/parser.ml" in -# 2588 "parsing/parser.mly" +# 2638 "parsing/parser.mly" ( Ppat_alias(_1, _3) ) -# 27376 "parsing/parser.ml" +# 28096 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -27380,21 +28100,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27386 "parsing/parser.ml" +# 28106 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 27392 "parsing/parser.ml" +# 28112 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27398 "parsing/parser.ml" +# 28118 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27435,9 +28155,9 @@ module Tables = struct let _1 = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2590 "parsing/parser.mly" +# 2640 "parsing/parser.mly" ( expecting _loc__3_ "identifier" ) -# 27441 "parsing/parser.ml" +# 28161 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -27445,21 +28165,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27451 "parsing/parser.ml" +# 28171 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 27457 "parsing/parser.ml" +# 28177 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27463 "parsing/parser.ml" +# 28183 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27484,29 +28204,29 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2592 "parsing/parser.mly" +# 2642 "parsing/parser.mly" ( Ppat_tuple(List.rev _1) ) -# 27490 "parsing/parser.ml" +# 28210 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27498 "parsing/parser.ml" +# 28218 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 27504 "parsing/parser.ml" +# 28224 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27510 "parsing/parser.ml" +# 28230 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27547,9 +28267,9 @@ module Tables = struct let _1 = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2594 "parsing/parser.mly" +# 2644 "parsing/parser.mly" ( expecting _loc__3_ "pattern" ) -# 27553 "parsing/parser.ml" +# 28273 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -27557,21 +28277,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27563 "parsing/parser.ml" +# 28283 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 27569 "parsing/parser.ml" +# 28289 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27575 "parsing/parser.ml" +# 28295 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27610,30 +28330,30 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2596 "parsing/parser.mly" +# 2646 "parsing/parser.mly" ( Ppat_or(_1, _3) ) -# 27616 "parsing/parser.ml" +# 28336 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27625 "parsing/parser.ml" +# 28345 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 27631 "parsing/parser.ml" +# 28351 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27637 "parsing/parser.ml" +# 28357 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27674,9 +28394,9 @@ module Tables = struct let _1 = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2598 "parsing/parser.mly" +# 2648 "parsing/parser.mly" ( expecting _loc__3_ "pattern" ) -# 27680 "parsing/parser.ml" +# 28400 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -27684,21 +28404,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27690 "parsing/parser.ml" +# 28410 "parsing/parser.ml" in -# 2599 "parsing/parser.mly" +# 2649 "parsing/parser.mly" ( _1 ) -# 27696 "parsing/parser.ml" +# 28416 "parsing/parser.ml" in -# 2576 "parsing/parser.mly" +# 2626 "parsing/parser.mly" ( _1 ) -# 27702 "parsing/parser.ml" +# 28422 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27717,9 +28437,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 27723 "parsing/parser.ml" +# 28443 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -27731,30 +28451,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 27737 "parsing/parser.ml" +# 28457 "parsing/parser.ml" in -# 2054 "parsing/parser.mly" +# 2104 "parsing/parser.mly" ( Ppat_var _1 ) -# 27743 "parsing/parser.ml" +# 28463 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27752 "parsing/parser.ml" +# 28472 "parsing/parser.ml" in -# 2056 "parsing/parser.mly" +# 2106 "parsing/parser.mly" ( _1 ) -# 27758 "parsing/parser.ml" +# 28478 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27778,23 +28498,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2055 "parsing/parser.mly" +# 2105 "parsing/parser.mly" ( Ppat_any ) -# 27784 "parsing/parser.ml" +# 28504 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 27792 "parsing/parser.ml" +# 28512 "parsing/parser.ml" in -# 2056 "parsing/parser.mly" +# 2106 "parsing/parser.mly" ( _1 ) -# 27798 "parsing/parser.ml" +# 28518 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27817,9 +28537,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.payload) = -# 3689 "parsing/parser.mly" +# 3755 "parsing/parser.mly" ( PStr _1 ) -# 27823 "parsing/parser.ml" +# 28543 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27849,9 +28569,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.payload) = -# 3690 "parsing/parser.mly" +# 3756 "parsing/parser.mly" ( PSig _2 ) -# 27855 "parsing/parser.ml" +# 28575 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27881,9 +28601,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.payload) = -# 3691 "parsing/parser.mly" +# 3757 "parsing/parser.mly" ( PTyp _2 ) -# 27887 "parsing/parser.ml" +# 28607 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27913,9 +28633,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.payload) = -# 3692 "parsing/parser.mly" +# 3758 "parsing/parser.mly" ( PPat (_2, None) ) -# 27919 "parsing/parser.ml" +# 28639 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27959,9 +28679,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.payload) = -# 3693 "parsing/parser.mly" +# 3759 "parsing/parser.mly" ( PPat (_2, Some _4) ) -# 27965 "parsing/parser.ml" +# 28685 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27984,9 +28704,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = -# 3108 "parsing/parser.mly" +# 3158 "parsing/parser.mly" ( _1 ) -# 27990 "parsing/parser.ml" +# 28710 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28027,26 +28747,26 @@ module Tables = struct let _1 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 28033 "parsing/parser.ml" +# 28753 "parsing/parser.ml" in -# 894 "parsing/parser.mly" +# 915 "parsing/parser.mly" ( xs ) -# 28038 "parsing/parser.ml" +# 28758 "parsing/parser.ml" in -# 3100 "parsing/parser.mly" +# 3150 "parsing/parser.mly" ( _1 ) -# 28044 "parsing/parser.ml" +# 28764 "parsing/parser.ml" in -# 3104 "parsing/parser.mly" +# 3154 "parsing/parser.mly" ( Ptyp_poly(_1, _3) ) -# 28050 "parsing/parser.ml" +# 28770 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_xs_) in @@ -28054,15 +28774,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 28060 "parsing/parser.ml" +# 28780 "parsing/parser.ml" in -# 3110 "parsing/parser.mly" +# 3160 "parsing/parser.mly" ( _1 ) -# 28066 "parsing/parser.ml" +# 28786 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28085,14 +28805,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 28091 "parsing/parser.ml" +# 28811 "parsing/parser.ml" in -# 3108 "parsing/parser.mly" +# 3158 "parsing/parser.mly" ( _1 ) -# 28096 "parsing/parser.ml" +# 28816 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28131,33 +28851,33 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let _3 = -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 28137 "parsing/parser.ml" +# 28857 "parsing/parser.ml" in let _1 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 28144 "parsing/parser.ml" +# 28864 "parsing/parser.ml" in -# 894 "parsing/parser.mly" +# 915 "parsing/parser.mly" ( xs ) -# 28149 "parsing/parser.ml" +# 28869 "parsing/parser.ml" in -# 3100 "parsing/parser.mly" +# 3150 "parsing/parser.mly" ( _1 ) -# 28155 "parsing/parser.ml" +# 28875 "parsing/parser.ml" in -# 3104 "parsing/parser.mly" +# 3154 "parsing/parser.mly" ( Ptyp_poly(_1, _3) ) -# 28161 "parsing/parser.ml" +# 28881 "parsing/parser.ml" in let _startpos__1_ = _startpos_xs_ in @@ -28165,15 +28885,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 28171 "parsing/parser.ml" +# 28891 "parsing/parser.ml" in -# 3110 "parsing/parser.mly" +# 3160 "parsing/parser.mly" ( _1 ) -# 28177 "parsing/parser.ml" +# 28897 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28220,9 +28940,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3656 "parsing/parser.mly" +# 3718 "parsing/parser.mly" ( Attr.mk ~loc:(make_loc _sloc) _2 _3 ) -# 28226 "parsing/parser.ml" +# 28946 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28293,7 +29013,7 @@ module Tables = struct let _7 : unit = Obj.magic _7 in let ty : (Parsetree.core_type) = Obj.magic ty in let _5 : unit = Obj.magic _5 in - let _1_inlined2 : (string) = Obj.magic _1_inlined2 in + let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Asttypes.loc option) = Obj.magic ext in let _1 : unit = Obj.magic _1 in @@ -28303,9 +29023,9 @@ module Tables = struct let _v : (Parsetree.value_description * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 28309 "parsing/parser.ml" +# 29029 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -28315,30 +29035,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 28321 "parsing/parser.ml" +# 29041 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 28329 "parsing/parser.ml" +# 29049 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2756 "parsing/parser.mly" +# 2806 "parsing/parser.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 ) -# 28342 "parsing/parser.ml" +# 29062 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28354,14 +29074,14 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.private_flag) = let _1 = -# 3524 "parsing/parser.mly" +# 3586 "parsing/parser.mly" ( Public ) -# 28360 "parsing/parser.ml" +# 29080 "parsing/parser.ml" in -# 3521 "parsing/parser.mly" +# 3583 "parsing/parser.mly" ( _1 ) -# 28365 "parsing/parser.ml" +# 29085 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28384,14 +29104,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag) = let _1 = -# 3525 "parsing/parser.mly" +# 3587 "parsing/parser.mly" ( Private ) -# 28390 "parsing/parser.ml" +# 29110 "parsing/parser.ml" in -# 3521 "parsing/parser.mly" +# 3583 "parsing/parser.mly" ( _1 ) -# 28395 "parsing/parser.ml" +# 29115 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28407,9 +29127,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3547 "parsing/parser.mly" +# 3609 "parsing/parser.mly" ( Public, Concrete ) -# 28413 "parsing/parser.ml" +# 29133 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28432,9 +29152,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3548 "parsing/parser.mly" +# 3610 "parsing/parser.mly" ( Private, Concrete ) -# 28438 "parsing/parser.ml" +# 29158 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28457,9 +29177,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3549 "parsing/parser.mly" +# 3611 "parsing/parser.mly" ( Public, Virtual ) -# 28463 "parsing/parser.ml" +# 29183 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28489,9 +29209,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3550 "parsing/parser.mly" +# 3612 "parsing/parser.mly" ( Private, Virtual ) -# 28495 "parsing/parser.ml" +# 29215 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28521,9 +29241,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3551 "parsing/parser.mly" +# 3613 "parsing/parser.mly" ( Private, Virtual ) -# 28527 "parsing/parser.ml" +# 29247 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28539,9 +29259,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.rec_flag) = -# 3504 "parsing/parser.mly" +# 3566 "parsing/parser.mly" ( Nonrecursive ) -# 28545 "parsing/parser.ml" +# 29265 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28564,9 +29284,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.rec_flag) = -# 3505 "parsing/parser.mly" +# 3567 "parsing/parser.mly" ( Recursive ) -# 28570 "parsing/parser.ml" +# 29290 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28590,14 +29310,14 @@ module Tables = struct let _endpos = _endpos_fields_ in let _v : (Parsetree.expression option * (Longident.t Asttypes.loc * Parsetree.expression) list) = let eo = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 28596 "parsing/parser.ml" +# 29316 "parsing/parser.ml" in -# 2501 "parsing/parser.mly" +# 2551 "parsing/parser.mly" ( eo, fields ) -# 28601 "parsing/parser.ml" +# 29321 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28636,20 +29356,20 @@ module Tables = struct let _v : (Parsetree.expression option * (Longident.t Asttypes.loc * Parsetree.expression) list) = let eo = let x = -# 191 "menhir/standard.mly" +# 191 "" ( x ) -# 28642 "parsing/parser.ml" +# 29362 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 28647 "parsing/parser.ml" +# 29367 "parsing/parser.ml" in -# 2501 "parsing/parser.mly" +# 2551 "parsing/parser.mly" ( eo, fields ) -# 28653 "parsing/parser.ml" +# 29373 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28674,17 +29394,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.constructor_declaration list) = let x = -# 2930 "parsing/parser.mly" +# 2980 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Type.constructor cid ~args ?res ~attrs ~loc ~info ) -# 28683 "parsing/parser.ml" +# 29403 "parsing/parser.ml" in -# 1004 "parsing/parser.mly" +# 1025 "parsing/parser.mly" ( [x] ) -# 28688 "parsing/parser.ml" +# 29408 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28709,17 +29429,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.constructor_declaration list) = let x = -# 2930 "parsing/parser.mly" +# 2980 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Type.constructor cid ~args ?res ~attrs ~loc ~info ) -# 28718 "parsing/parser.ml" +# 29438 "parsing/parser.ml" in -# 1007 "parsing/parser.mly" +# 1028 "parsing/parser.mly" ( [x] ) -# 28723 "parsing/parser.ml" +# 29443 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28751,17 +29471,17 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_d_ in let _v : (Parsetree.constructor_declaration list) = let x = -# 2930 "parsing/parser.mly" +# 2980 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Type.constructor cid ~args ?res ~attrs ~loc ~info ) -# 28760 "parsing/parser.ml" +# 29480 "parsing/parser.ml" in -# 1011 "parsing/parser.mly" +# 1032 "parsing/parser.mly" ( x :: xs ) -# 28765 "parsing/parser.ml" +# 29485 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28787,23 +29507,23 @@ module Tables = struct let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = let _1 = -# 3042 "parsing/parser.mly" +# 3092 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Te.decl cid ~args ?res ~attrs ~loc ~info ) -# 28796 "parsing/parser.ml" +# 29516 "parsing/parser.ml" in -# 3036 "parsing/parser.mly" +# 3086 "parsing/parser.mly" ( _1 ) -# 28801 "parsing/parser.ml" +# 29521 "parsing/parser.ml" in -# 1004 "parsing/parser.mly" +# 1025 "parsing/parser.mly" ( [x] ) -# 28807 "parsing/parser.ml" +# 29527 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28826,14 +29546,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3038 "parsing/parser.mly" +# 3088 "parsing/parser.mly" ( _1 ) -# 28832 "parsing/parser.ml" +# 29552 "parsing/parser.ml" in -# 1004 "parsing/parser.mly" +# 1025 "parsing/parser.mly" ( [x] ) -# 28837 "parsing/parser.ml" +# 29557 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28859,23 +29579,23 @@ module Tables = struct let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = let _1 = -# 3042 "parsing/parser.mly" +# 3092 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Te.decl cid ~args ?res ~attrs ~loc ~info ) -# 28868 "parsing/parser.ml" +# 29588 "parsing/parser.ml" in -# 3036 "parsing/parser.mly" +# 3086 "parsing/parser.mly" ( _1 ) -# 28873 "parsing/parser.ml" +# 29593 "parsing/parser.ml" in -# 1007 "parsing/parser.mly" +# 1028 "parsing/parser.mly" ( [x] ) -# 28879 "parsing/parser.ml" +# 29599 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28898,14 +29618,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3038 "parsing/parser.mly" +# 3088 "parsing/parser.mly" ( _1 ) -# 28904 "parsing/parser.ml" +# 29624 "parsing/parser.ml" in -# 1007 "parsing/parser.mly" +# 1028 "parsing/parser.mly" ( [x] ) -# 28909 "parsing/parser.ml" +# 29629 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28938,23 +29658,23 @@ module Tables = struct let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = let _1 = -# 3042 "parsing/parser.mly" +# 3092 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Te.decl cid ~args ?res ~attrs ~loc ~info ) -# 28947 "parsing/parser.ml" +# 29667 "parsing/parser.ml" in -# 3036 "parsing/parser.mly" +# 3086 "parsing/parser.mly" ( _1 ) -# 28952 "parsing/parser.ml" +# 29672 "parsing/parser.ml" in -# 1011 "parsing/parser.mly" +# 1032 "parsing/parser.mly" ( x :: xs ) -# 28958 "parsing/parser.ml" +# 29678 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28984,14 +29704,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos__1_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3038 "parsing/parser.mly" +# 3088 "parsing/parser.mly" ( _1 ) -# 28990 "parsing/parser.ml" +# 29710 "parsing/parser.ml" in -# 1011 "parsing/parser.mly" +# 1032 "parsing/parser.mly" ( x :: xs ) -# 28995 "parsing/parser.ml" +# 29715 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29016,17 +29736,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3042 "parsing/parser.mly" +# 3092 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Te.decl cid ~args ?res ~attrs ~loc ~info ) -# 29025 "parsing/parser.ml" +# 29745 "parsing/parser.ml" in -# 1004 "parsing/parser.mly" +# 1025 "parsing/parser.mly" ( [x] ) -# 29030 "parsing/parser.ml" +# 29750 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29051,17 +29771,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3042 "parsing/parser.mly" +# 3092 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Te.decl cid ~args ?res ~attrs ~loc ~info ) -# 29060 "parsing/parser.ml" +# 29780 "parsing/parser.ml" in -# 1007 "parsing/parser.mly" +# 1028 "parsing/parser.mly" ( [x] ) -# 29065 "parsing/parser.ml" +# 29785 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29093,17 +29813,17 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3042 "parsing/parser.mly" +# 3092 "parsing/parser.mly" ( let cid, args, res, attrs, loc, info = d in Te.decl cid ~args ?res ~attrs ~loc ~info ) -# 29102 "parsing/parser.ml" +# 29822 "parsing/parser.ml" in -# 1011 "parsing/parser.mly" +# 1032 "parsing/parser.mly" ( x :: xs ) -# 29107 "parsing/parser.ml" +# 29827 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29119,9 +29839,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = -# 870 "parsing/parser.mly" +# 891 "parsing/parser.mly" ( [] ) -# 29125 "parsing/parser.ml" +# 29845 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29178,21 +29898,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1934 "parsing/parser.mly" +# 1984 "parsing/parser.mly" ( _1, _3, make_loc _sloc ) -# 29184 "parsing/parser.ml" +# 29904 "parsing/parser.ml" in -# 183 "menhir/standard.mly" +# 183 "" ( x ) -# 29190 "parsing/parser.ml" +# 29910 "parsing/parser.ml" in -# 872 "parsing/parser.mly" +# 893 "parsing/parser.mly" ( x :: xs ) -# 29196 "parsing/parser.ml" +# 29916 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29215,9 +29935,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.functor_parameter list) = -# 884 "parsing/parser.mly" +# 905 "parsing/parser.mly" ( [ x ] ) -# 29221 "parsing/parser.ml" +# 29941 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29247,9 +29967,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.functor_parameter list) = -# 886 "parsing/parser.mly" +# 907 "parsing/parser.mly" ( x :: xs ) -# 29253 "parsing/parser.ml" +# 29973 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29272,9 +29992,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : ((Asttypes.arg_label * Parsetree.expression) list) = -# 884 "parsing/parser.mly" +# 905 "parsing/parser.mly" ( [ x ] ) -# 29278 "parsing/parser.ml" +# 29998 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29304,9 +30024,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : ((Asttypes.arg_label * Parsetree.expression) list) = -# 886 "parsing/parser.mly" +# 907 "parsing/parser.mly" ( x :: xs ) -# 29310 "parsing/parser.ml" +# 30030 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29329,9 +30049,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Asttypes.label list) = -# 884 "parsing/parser.mly" +# 905 "parsing/parser.mly" ( [ x ] ) -# 29335 "parsing/parser.ml" +# 30055 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29361,9 +30081,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Asttypes.label list) = -# 886 "parsing/parser.mly" +# 907 "parsing/parser.mly" ( x :: xs ) -# 29367 "parsing/parser.ml" +# 30087 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29399,21 +30119,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 29405 "parsing/parser.ml" +# 30125 "parsing/parser.ml" in -# 3096 "parsing/parser.mly" +# 3146 "parsing/parser.mly" ( _2 ) -# 29411 "parsing/parser.ml" +# 30131 "parsing/parser.ml" in -# 884 "parsing/parser.mly" +# 905 "parsing/parser.mly" ( [ x ] ) -# 29417 "parsing/parser.ml" +# 30137 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29456,21 +30176,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 29462 "parsing/parser.ml" +# 30182 "parsing/parser.ml" in -# 3096 "parsing/parser.mly" +# 3146 "parsing/parser.mly" ( _2 ) -# 29468 "parsing/parser.ml" +# 30188 "parsing/parser.ml" in -# 886 "parsing/parser.mly" +# 907 "parsing/parser.mly" ( x :: xs ) -# 29474 "parsing/parser.ml" +# 30194 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29493,14 +30213,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.case list) = let _1 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 29499 "parsing/parser.ml" +# 30219 "parsing/parser.ml" in -# 975 "parsing/parser.mly" +# 996 "parsing/parser.mly" ( [x] ) -# 29504 "parsing/parser.ml" +# 30224 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29532,15 +30252,15 @@ module Tables = struct let _v : (Parsetree.case list) = let _1 = let x = x_inlined1 in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 29538 "parsing/parser.ml" +# 30258 "parsing/parser.ml" in -# 975 "parsing/parser.mly" +# 996 "parsing/parser.mly" ( [x] ) -# 29544 "parsing/parser.ml" +# 30264 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29577,9 +30297,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.case list) = -# 979 "parsing/parser.mly" +# 1000 "parsing/parser.mly" ( x :: xs ) -# 29583 "parsing/parser.ml" +# 30303 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29603,20 +30323,20 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type list) = let xs = let x = -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 29609 "parsing/parser.ml" +# 30329 "parsing/parser.ml" in -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 29614 "parsing/parser.ml" +# 30334 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29620 "parsing/parser.ml" +# 30340 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29654,20 +30374,20 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type list) = let xs = let x = -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 29660 "parsing/parser.ml" +# 30380 "parsing/parser.ml" in -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 29665 "parsing/parser.ml" +# 30385 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29671 "parsing/parser.ml" +# 30391 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29690,14 +30410,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.with_constraint list) = let xs = -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 29696 "parsing/parser.ml" +# 30416 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29701 "parsing/parser.ml" +# 30421 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29734,14 +30454,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.with_constraint list) = let xs = -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 29740 "parsing/parser.ml" +# 30460 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29745 "parsing/parser.ml" +# 30465 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29764,14 +30484,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.row_field list) = let xs = -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 29770 "parsing/parser.ml" +# 30490 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29775 "parsing/parser.ml" +# 30495 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29808,14 +30528,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.row_field list) = let xs = -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 29814 "parsing/parser.ml" +# 30534 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29819 "parsing/parser.ml" +# 30539 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29838,14 +30558,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 29844 "parsing/parser.ml" +# 30564 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29849 "parsing/parser.ml" +# 30569 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29882,14 +30602,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 29888 "parsing/parser.ml" +# 30608 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29893 "parsing/parser.ml" +# 30613 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29912,14 +30632,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : ((Parsetree.core_type * Asttypes.variance) list) = let xs = -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 29918 "parsing/parser.ml" +# 30638 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29923 "parsing/parser.ml" +# 30643 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29956,14 +30676,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : ((Parsetree.core_type * Asttypes.variance) list) = let xs = -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 29962 "parsing/parser.ml" +# 30682 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29967 "parsing/parser.ml" +# 30687 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29986,14 +30706,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 910 "parsing/parser.mly" +# 931 "parsing/parser.mly" ( [ x ] ) -# 29992 "parsing/parser.ml" +# 30712 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 29997 "parsing/parser.ml" +# 30717 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30030,14 +30750,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 914 "parsing/parser.mly" +# 935 "parsing/parser.mly" ( x :: xs ) -# 30036 "parsing/parser.ml" +# 30756 "parsing/parser.ml" in -# 918 "parsing/parser.mly" +# 939 "parsing/parser.mly" ( xs ) -# 30041 "parsing/parser.ml" +# 30761 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30074,9 +30794,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = -# 941 "parsing/parser.mly" +# 962 "parsing/parser.mly" ( x :: xs ) -# 30080 "parsing/parser.ml" +# 30800 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30113,9 +30833,9 @@ module Tables = struct let _startpos = _startpos_x1_ in let _endpos = _endpos_x2_ in let _v : (Parsetree.core_type list) = -# 945 "parsing/parser.mly" +# 966 "parsing/parser.mly" ( [ x2; x1 ] ) -# 30119 "parsing/parser.ml" +# 30839 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30152,9 +30872,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.expression list) = -# 941 "parsing/parser.mly" +# 962 "parsing/parser.mly" ( x :: xs ) -# 30158 "parsing/parser.ml" +# 30878 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30191,9 +30911,9 @@ module Tables = struct let _startpos = _startpos_x1_ in let _endpos = _endpos_x2_ in let _v : (Parsetree.expression list) = -# 945 "parsing/parser.mly" +# 966 "parsing/parser.mly" ( [ x2; x1 ] ) -# 30197 "parsing/parser.ml" +# 30917 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30230,9 +30950,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = -# 941 "parsing/parser.mly" +# 962 "parsing/parser.mly" ( x :: xs ) -# 30236 "parsing/parser.ml" +# 30956 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30269,9 +30989,9 @@ module Tables = struct let _startpos = _startpos_x1_ in let _endpos = _endpos_x2_ in let _v : (Parsetree.core_type list) = -# 945 "parsing/parser.mly" +# 966 "parsing/parser.mly" ( [ x2; x1 ] ) -# 30275 "parsing/parser.ml" +# 30995 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30294,9 +31014,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.row_field) = -# 3279 "parsing/parser.mly" +# 3329 "parsing/parser.mly" ( _1 ) -# 30300 "parsing/parser.ml" +# 31020 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30322,9 +31042,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3281 "parsing/parser.mly" +# 3331 "parsing/parser.mly" ( Rf.inherit_ ~loc:(make_loc _sloc) _1 ) -# 30328 "parsing/parser.ml" +# 31048 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30347,14 +31067,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.expression list) = let _2 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 30353 "parsing/parser.ml" +# 31073 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30358 "parsing/parser.ml" +# 31078 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30386,15 +31106,15 @@ module Tables = struct let _v : (Parsetree.expression list) = let _2 = let x = x_inlined1 in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 30392 "parsing/parser.ml" +# 31112 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30398 "parsing/parser.ml" +# 31118 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30431,9 +31151,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.expression list) = -# 966 "parsing/parser.mly" +# 987 "parsing/parser.mly" ( x :: xs ) -# 30437 "parsing/parser.ml" +# 31157 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30459,32 +31179,32 @@ module Tables = struct } = _menhir_stack in let oe : (Parsetree.expression option) = Obj.magic oe in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 30465 "parsing/parser.ml" +# 31185 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos_oe_ in let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 30473 "parsing/parser.ml" +# 31193 "parsing/parser.ml" in let x = let label = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 30480 "parsing/parser.ml" +# 31200 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 30488 "parsing/parser.ml" +# 31208 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -30492,7 +31212,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2524 "parsing/parser.mly" +# 2574 "parsing/parser.mly" ( let e = match oe with | None -> @@ -30502,13 +31222,13 @@ module Tables = struct e in label, e ) -# 30506 "parsing/parser.ml" +# 31226 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30512 "parsing/parser.ml" +# 31232 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30541,32 +31261,32 @@ module Tables = struct let x : unit = Obj.magic x in let oe : (Parsetree.expression option) = Obj.magic oe in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 30547 "parsing/parser.ml" +# 31267 "parsing/parser.ml" ) = 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 : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 = -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 30555 "parsing/parser.ml" +# 31275 "parsing/parser.ml" in let x = let label = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 30562 "parsing/parser.ml" +# 31282 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 30570 "parsing/parser.ml" +# 31290 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -30574,7 +31294,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2524 "parsing/parser.mly" +# 2574 "parsing/parser.mly" ( let e = match oe with | None -> @@ -30584,13 +31304,13 @@ module Tables = struct e in label, e ) -# 30588 "parsing/parser.ml" +# 31308 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30594 "parsing/parser.ml" +# 31314 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30630,9 +31350,9 @@ module Tables = struct let _2 : unit = Obj.magic _2 in let oe : (Parsetree.expression option) = Obj.magic oe in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 30636 "parsing/parser.ml" +# 31356 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -30640,17 +31360,17 @@ module Tables = struct let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let x = let label = let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 30646 "parsing/parser.ml" +# 31366 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 30654 "parsing/parser.ml" +# 31374 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -30658,7 +31378,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2524 "parsing/parser.mly" +# 2574 "parsing/parser.mly" ( let e = match oe with | None -> @@ -30668,13 +31388,13 @@ module Tables = struct e in label, e ) -# 30672 "parsing/parser.ml" +# 31392 "parsing/parser.ml" in -# 966 "parsing/parser.mly" +# 987 "parsing/parser.mly" ( x :: xs ) -# 30678 "parsing/parser.ml" +# 31398 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30697,14 +31417,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.pattern list) = let _2 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 30703 "parsing/parser.ml" +# 31423 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30708 "parsing/parser.ml" +# 31428 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30736,15 +31456,15 @@ module Tables = struct let _v : (Parsetree.pattern list) = let _2 = let x = x_inlined1 in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 30742 "parsing/parser.ml" +# 31462 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30748 "parsing/parser.ml" +# 31468 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30781,9 +31501,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.pattern list) = -# 966 "parsing/parser.mly" +# 987 "parsing/parser.mly" ( x :: xs ) -# 30787 "parsing/parser.ml" +# 31507 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30820,9 +31540,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_eo_ in let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 30826 "parsing/parser.ml" +# 31546 "parsing/parser.ml" in let x = let label = @@ -30830,9 +31550,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 30836 "parsing/parser.ml" +# 31556 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -30840,7 +31560,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2507 "parsing/parser.mly" +# 2557 "parsing/parser.mly" ( let e = match eo with | None -> @@ -30850,13 +31570,13 @@ module Tables = struct e in label, mkexp_opt_constraint ~loc:_sloc e c ) -# 30854 "parsing/parser.ml" +# 31574 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30860 "parsing/parser.ml" +# 31580 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30900,9 +31620,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 = -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 30906 "parsing/parser.ml" +# 31626 "parsing/parser.ml" in let x = let label = @@ -30910,9 +31630,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 30916 "parsing/parser.ml" +# 31636 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -30920,7 +31640,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2507 "parsing/parser.mly" +# 2557 "parsing/parser.mly" ( let e = match eo with | None -> @@ -30930,13 +31650,13 @@ module Tables = struct e in label, mkexp_opt_constraint ~loc:_sloc e c ) -# 30934 "parsing/parser.ml" +# 31654 "parsing/parser.ml" in -# 962 "parsing/parser.mly" +# 983 "parsing/parser.mly" ( [x] ) -# 30940 "parsing/parser.ml" +# 31660 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30992,9 +31712,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 30998 "parsing/parser.ml" +# 31718 "parsing/parser.ml" in let _startpos_label_ = _startpos__1_ in @@ -31002,7 +31722,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2507 "parsing/parser.mly" +# 2557 "parsing/parser.mly" ( let e = match eo with | None -> @@ -31012,13 +31732,13 @@ module Tables = struct e in label, mkexp_opt_constraint ~loc:_sloc e c ) -# 31016 "parsing/parser.ml" +# 31736 "parsing/parser.ml" in -# 966 "parsing/parser.mly" +# 987 "parsing/parser.mly" ( x :: xs ) -# 31022 "parsing/parser.ml" +# 31742 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31041,9 +31761,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = -# 2023 "parsing/parser.mly" +# 2073 "parsing/parser.mly" ( _1 ) -# 31047 "parsing/parser.ml" +# 31767 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31073,9 +31793,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = -# 2024 "parsing/parser.mly" +# 2074 "parsing/parser.mly" ( _1 ) -# 31079 "parsing/parser.ml" +# 31799 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31113,24 +31833,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2026 "parsing/parser.mly" +# 2076 "parsing/parser.mly" ( Pexp_sequence(_1, _3) ) -# 31119 "parsing/parser.ml" +# 31839 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 31128 "parsing/parser.ml" +# 31848 "parsing/parser.ml" in -# 2027 "parsing/parser.mly" +# 2077 "parsing/parser.mly" ( _1 ) -# 31134 "parsing/parser.ml" +# 31854 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31184,11 +31904,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2029 "parsing/parser.mly" +# 2079 "parsing/parser.mly" ( let seq = mkexp ~loc:_sloc (Pexp_sequence (_1, _5)) in let payload = PStr [mkstrexp seq []] in mkexp ~loc:_sloc (Pexp_extension (_4, payload)) ) -# 31192 "parsing/parser.ml" +# 31912 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31245,7 +31965,7 @@ module Tables = struct let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in let args_res : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic args_res in - let _1_inlined2 : (string) = Obj.magic _1_inlined2 in + let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Asttypes.loc option) = Obj.magic ext in let _1 : unit = Obj.magic _1 in @@ -31255,18 +31975,18 @@ module Tables = struct let _v : (Parsetree.type_exception * string Asttypes.loc option) = let attrs = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 31261 "parsing/parser.ml" +# 31981 "parsing/parser.ml" in let _endpos_attrs_ = _endpos__1_inlined4_ in let attrs2 = let _1 = _1_inlined3 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 31270 "parsing/parser.ml" +# 31990 "parsing/parser.ml" in let id = @@ -31275,31 +31995,31 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 31281 "parsing/parser.ml" +# 32001 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 31289 "parsing/parser.ml" +# 32009 "parsing/parser.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2960 "parsing/parser.mly" +# 3010 "parsing/parser.mly" ( let args, res = args_res in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Te.mk_exception ~attrs (Te.decl id ~args ?res ~attrs:(attrs1 @ attrs2) ~loc ~docs) , ext ) -# 31303 "parsing/parser.ml" +# 32023 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31323,23 +32043,23 @@ module Tables = struct let _endpos = _endpos_xss_ in let _v : (Parsetree.signature) = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 31329 "parsing/parser.ml" +# 32049 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 785 "parsing/parser.mly" +# 806 "parsing/parser.mly" ( extra_sig _startpos _endpos _1 ) -# 31337 "parsing/parser.ml" +# 32057 "parsing/parser.ml" in -# 1492 "parsing/parser.mly" +# 1542 "parsing/parser.mly" ( _1 ) -# 31343 "parsing/parser.ml" +# 32063 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31371,9 +32091,9 @@ module Tables = struct let _v : (Parsetree.signature_item) = let _2 = let _1 = _1_inlined1 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 31377 "parsing/parser.ml" +# 32097 "parsing/parser.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -31381,10 +32101,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1507 "parsing/parser.mly" +# 1557 "parsing/parser.mly" ( let docs = symbol_docs _sloc in mksig ~loc:_sloc (Psig_extension (_1, (add_docs_attrs docs _2))) ) -# 31388 "parsing/parser.ml" +# 32108 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31408,23 +32128,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1511 "parsing/parser.mly" +# 1561 "parsing/parser.mly" ( Psig_attribute _1 ) -# 31414 "parsing/parser.ml" +# 32134 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 833 "parsing/parser.mly" +# 854 "parsing/parser.mly" ( mksig ~loc:_sloc _1 ) -# 31422 "parsing/parser.ml" +# 32142 "parsing/parser.ml" in -# 1513 "parsing/parser.mly" +# 1563 "parsing/parser.mly" ( _1 ) -# 31428 "parsing/parser.ml" +# 32148 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31448,23 +32168,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1516 "parsing/parser.mly" +# 1566 "parsing/parser.mly" ( psig_value _1 ) -# 31454 "parsing/parser.ml" +# 32174 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 31462 "parsing/parser.ml" +# 32182 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 31468 "parsing/parser.ml" +# 32188 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31488,23 +32208,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1518 "parsing/parser.mly" +# 1568 "parsing/parser.mly" ( psig_value _1 ) -# 31494 "parsing/parser.ml" +# 32214 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 31502 "parsing/parser.ml" +# 32222 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 31508 "parsing/parser.ml" +# 32228 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31539,26 +32259,26 @@ module Tables = struct let _1 = let _1 = let _1 = -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 31545 "parsing/parser.ml" +# 32265 "parsing/parser.ml" in -# 2792 "parsing/parser.mly" +# 2842 "parsing/parser.mly" ( _1 ) -# 31550 "parsing/parser.ml" +# 32270 "parsing/parser.ml" in -# 2775 "parsing/parser.mly" +# 2825 "parsing/parser.mly" ( _1 ) -# 31556 "parsing/parser.ml" +# 32276 "parsing/parser.ml" in -# 1520 "parsing/parser.mly" +# 1570 "parsing/parser.mly" ( psig_type _1 ) -# 31562 "parsing/parser.ml" +# 32282 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in @@ -31566,15 +32286,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 31572 "parsing/parser.ml" +# 32292 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 31578 "parsing/parser.ml" +# 32298 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31609,26 +32329,26 @@ module Tables = struct let _1 = let _1 = let _1 = -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 31615 "parsing/parser.ml" +# 32335 "parsing/parser.ml" in -# 2792 "parsing/parser.mly" +# 2842 "parsing/parser.mly" ( _1 ) -# 31620 "parsing/parser.ml" +# 32340 "parsing/parser.ml" in -# 2780 "parsing/parser.mly" +# 2830 "parsing/parser.mly" ( _1 ) -# 31626 "parsing/parser.ml" +# 32346 "parsing/parser.ml" in -# 1522 "parsing/parser.mly" +# 1572 "parsing/parser.mly" ( psig_typesubst _1 ) -# 31632 "parsing/parser.ml" +# 32352 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in @@ -31636,15 +32356,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 31642 "parsing/parser.ml" +# 32362 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 31648 "parsing/parser.ml" +# 32368 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31729,16 +32449,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 31735 "parsing/parser.ml" +# 32455 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let cs = -# 1015 "parsing/parser.mly" +# 1036 "parsing/parser.mly" ( List.rev xs ) -# 31742 "parsing/parser.ml" +# 32462 "parsing/parser.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in @@ -31746,46 +32466,46 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 31752 "parsing/parser.ml" +# 32472 "parsing/parser.ml" in let _4 = -# 3512 "parsing/parser.mly" +# 3574 "parsing/parser.mly" ( Recursive ) -# 31758 "parsing/parser.ml" +# 32478 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 31765 "parsing/parser.ml" +# 32485 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3029 "parsing/parser.mly" +# 3079 "parsing/parser.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 31777 "parsing/parser.ml" +# 32497 "parsing/parser.ml" in -# 3016 "parsing/parser.mly" +# 3066 "parsing/parser.mly" ( _1 ) -# 31783 "parsing/parser.ml" +# 32503 "parsing/parser.ml" in -# 1524 "parsing/parser.mly" +# 1574 "parsing/parser.mly" ( psig_typext _1 ) -# 31789 "parsing/parser.ml" +# 32509 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -31793,15 +32513,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 31799 "parsing/parser.ml" +# 32519 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 31805 "parsing/parser.ml" +# 32525 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31893,16 +32613,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 31899 "parsing/parser.ml" +# 32619 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cs = -# 1015 "parsing/parser.mly" +# 1036 "parsing/parser.mly" ( List.rev xs ) -# 31906 "parsing/parser.ml" +# 32626 "parsing/parser.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in @@ -31910,9 +32630,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 31916 "parsing/parser.ml" +# 32636 "parsing/parser.ml" in let _4 = @@ -31921,41 +32641,41 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3513 "parsing/parser.mly" +# 3575 "parsing/parser.mly" ( not_expecting _loc "nonrec flag" ) -# 31927 "parsing/parser.ml" +# 32647 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 31935 "parsing/parser.ml" +# 32655 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3029 "parsing/parser.mly" +# 3079 "parsing/parser.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 31947 "parsing/parser.ml" +# 32667 "parsing/parser.ml" in -# 3016 "parsing/parser.mly" +# 3066 "parsing/parser.mly" ( _1 ) -# 31953 "parsing/parser.ml" +# 32673 "parsing/parser.ml" in -# 1524 "parsing/parser.mly" +# 1574 "parsing/parser.mly" ( psig_typext _1 ) -# 31959 "parsing/parser.ml" +# 32679 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined4_ in @@ -31963,15 +32683,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 31969 "parsing/parser.ml" +# 32689 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 31975 "parsing/parser.ml" +# 32695 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31995,23 +32715,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1526 "parsing/parser.mly" +# 1576 "parsing/parser.mly" ( psig_exception _1 ) -# 32001 "parsing/parser.ml" +# 32721 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32009 "parsing/parser.ml" +# 32729 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32015 "parsing/parser.ml" +# 32735 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32074,9 +32794,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 32080 "parsing/parser.ml" +# 32800 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -32086,37 +32806,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 32092 "parsing/parser.ml" +# 32812 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 32100 "parsing/parser.ml" +# 32820 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1555 "parsing/parser.mly" +# 1605 "parsing/parser.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 ) -# 32114 "parsing/parser.ml" +# 32834 "parsing/parser.ml" in -# 1528 "parsing/parser.mly" +# 1578 "parsing/parser.mly" ( let (body, ext) = _1 in (Psig_module body, ext) ) -# 32120 "parsing/parser.ml" +# 32840 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -32124,15 +32844,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32130 "parsing/parser.ml" +# 32850 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32136 "parsing/parser.ml" +# 32856 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32202,9 +32922,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 32208 "parsing/parser.ml" +# 32928 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -32215,9 +32935,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 32221 "parsing/parser.ml" +# 32941 "parsing/parser.ml" in let (_endpos_id_, _startpos_id_) = (_endpos__1_, _startpos__1_) in @@ -32225,9 +32945,9 @@ module Tables = struct let _symbolstartpos = _startpos_id_ in let _sloc = (_symbolstartpos, _endpos) in -# 1591 "parsing/parser.mly" +# 1641 "parsing/parser.mly" ( Mty.alias ~loc:(make_loc _sloc) id ) -# 32231 "parsing/parser.ml" +# 32951 "parsing/parser.ml" in let name = @@ -32236,37 +32956,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 32242 "parsing/parser.ml" +# 32962 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 32250 "parsing/parser.ml" +# 32970 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1582 "parsing/parser.mly" +# 1632 "parsing/parser.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 ) -# 32264 "parsing/parser.ml" +# 32984 "parsing/parser.ml" in -# 1530 "parsing/parser.mly" +# 1580 "parsing/parser.mly" ( let (body, ext) = _1 in (Psig_module body, ext) ) -# 32270 "parsing/parser.ml" +# 32990 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined4_ in @@ -32274,15 +32994,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32280 "parsing/parser.ml" +# 33000 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32286 "parsing/parser.ml" +# 33006 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32306,23 +33026,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1532 "parsing/parser.mly" +# 1582 "parsing/parser.mly" ( let (body, ext) = _1 in (Psig_modsubst body, ext) ) -# 32312 "parsing/parser.ml" +# 33032 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32320 "parsing/parser.ml" +# 33040 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32326 "parsing/parser.ml" +# 33046 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32408,9 +33128,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 32414 "parsing/parser.ml" +# 33134 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -32420,49 +33140,49 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 32426 "parsing/parser.ml" +# 33146 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 32434 "parsing/parser.ml" +# 33154 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1625 "parsing/parser.mly" +# 1675 "parsing/parser.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 ) -# 32448 "parsing/parser.ml" +# 33168 "parsing/parser.ml" in -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 32454 "parsing/parser.ml" +# 33174 "parsing/parser.ml" in -# 1614 "parsing/parser.mly" +# 1664 "parsing/parser.mly" ( _1 ) -# 32460 "parsing/parser.ml" +# 33180 "parsing/parser.ml" in -# 1534 "parsing/parser.mly" +# 1584 "parsing/parser.mly" ( let (ext, l) = _1 in (Psig_recmodule l, ext) ) -# 32466 "parsing/parser.ml" +# 33186 "parsing/parser.ml" in let _endpos__1_ = _endpos_bs_ in @@ -32470,15 +33190,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32476 "parsing/parser.ml" +# 33196 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32482 "parsing/parser.ml" +# 33202 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32502,23 +33222,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1536 "parsing/parser.mly" +# 1586 "parsing/parser.mly" ( let (body, ext) = _1 in (Psig_modtype body, ext) ) -# 32508 "parsing/parser.ml" +# 33228 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32516 "parsing/parser.ml" +# 33236 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32522 "parsing/parser.ml" +# 33242 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32542,23 +33262,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1538 "parsing/parser.mly" +# 1588 "parsing/parser.mly" ( let (body, ext) = _1 in (Psig_open body, ext) ) -# 32548 "parsing/parser.ml" +# 33268 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32556 "parsing/parser.ml" +# 33276 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32562 "parsing/parser.ml" +# 33282 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32614,38 +33334,38 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 32620 "parsing/parser.ml" +# 33340 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 32629 "parsing/parser.ml" +# 33349 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1384 "parsing/parser.mly" +# 1434 "parsing/parser.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 ) -# 32643 "parsing/parser.ml" +# 33363 "parsing/parser.ml" in -# 1540 "parsing/parser.mly" +# 1590 "parsing/parser.mly" ( psig_include _1 ) -# 32649 "parsing/parser.ml" +# 33369 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined2_ in @@ -32653,15 +33373,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32659 "parsing/parser.ml" +# 33379 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32665 "parsing/parser.ml" +# 33385 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32738,9 +33458,9 @@ module Tables = struct let cty : (Parsetree.class_type) = Obj.magic cty in let _7 : unit = Obj.magic _7 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 32744 "parsing/parser.ml" +# 33464 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -32758,9 +33478,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 32764 "parsing/parser.ml" +# 33484 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -32770,24 +33490,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 32776 "parsing/parser.ml" +# 33496 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 32784 "parsing/parser.ml" +# 33504 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1955 "parsing/parser.mly" +# 2005 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -32795,25 +33515,25 @@ module Tables = struct ext, Ci.mk id cty ~virt ~params ~attrs ~loc ~docs ) -# 32799 "parsing/parser.ml" +# 33519 "parsing/parser.ml" in -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 32805 "parsing/parser.ml" +# 33525 "parsing/parser.ml" in -# 1943 "parsing/parser.mly" +# 1993 "parsing/parser.mly" ( _1 ) -# 32811 "parsing/parser.ml" +# 33531 "parsing/parser.ml" in -# 1542 "parsing/parser.mly" +# 1592 "parsing/parser.mly" ( let (ext, l) = _1 in (Psig_class l, ext) ) -# 32817 "parsing/parser.ml" +# 33537 "parsing/parser.ml" in let _endpos__1_ = _endpos_bs_ in @@ -32821,15 +33541,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32827 "parsing/parser.ml" +# 33547 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32833 "parsing/parser.ml" +# 33553 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32853,23 +33573,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1544 "parsing/parser.mly" +# 1594 "parsing/parser.mly" ( let (ext, l) = _1 in (Psig_class_type l, ext) ) -# 32859 "parsing/parser.ml" +# 33579 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 850 "parsing/parser.mly" +# 871 "parsing/parser.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32867 "parsing/parser.ml" +# 33587 "parsing/parser.ml" in -# 1546 "parsing/parser.mly" +# 1596 "parsing/parser.mly" ( _1 ) -# 32873 "parsing/parser.ml" +# 33593 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32892,9 +33612,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constant) = -# 3355 "parsing/parser.mly" +# 3405 "parsing/parser.mly" ( _1 ) -# 32898 "parsing/parser.ml" +# 33618 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32919,18 +33639,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 628 "parsing/parser.mly" +# 633 "parsing/parser.mly" (string * char option) -# 32925 "parsing/parser.ml" +# 33645 "parsing/parser.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) = -# 3356 "parsing/parser.mly" +# 3406 "parsing/parser.mly" ( let (n, m) = _2 in Pconst_integer("-" ^ n, m) ) -# 32934 "parsing/parser.ml" +# 33654 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32955,18 +33675,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 607 "parsing/parser.mly" +# 612 "parsing/parser.mly" (string * char option) -# 32961 "parsing/parser.ml" +# 33681 "parsing/parser.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) = -# 3357 "parsing/parser.mly" +# 3407 "parsing/parser.mly" ( let (f, m) = _2 in Pconst_float("-" ^ f, m) ) -# 32970 "parsing/parser.ml" +# 33690 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32991,18 +33711,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 628 "parsing/parser.mly" +# 633 "parsing/parser.mly" (string * char option) -# 32997 "parsing/parser.ml" +# 33717 "parsing/parser.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) = -# 3358 "parsing/parser.mly" +# 3408 "parsing/parser.mly" ( let (n, m) = _2 in Pconst_integer (n, m) ) -# 33006 "parsing/parser.ml" +# 33726 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33027,18 +33747,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 607 "parsing/parser.mly" +# 612 "parsing/parser.mly" (string * char option) -# 33033 "parsing/parser.ml" +# 33753 "parsing/parser.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) = -# 3359 "parsing/parser.mly" +# 3409 "parsing/parser.mly" ( let (f, m) = _2 in Pconst_float(f, m) ) -# 33042 "parsing/parser.ml" +# 33762 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33079,18 +33799,18 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 2707 "parsing/parser.mly" +# 2757 "parsing/parser.mly" ( let fields, closed = _1 in let closed = match closed with Some () -> Open | None -> Closed in fields, closed ) -# 33087 "parsing/parser.ml" +# 33807 "parsing/parser.ml" in -# 2678 "parsing/parser.mly" +# 2728 "parsing/parser.mly" ( let (fields, closed) = _2 in Ppat_record(fields, closed) ) -# 33094 "parsing/parser.ml" +# 33814 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -33098,15 +33818,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33104 "parsing/parser.ml" +# 33824 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33110 "parsing/parser.ml" +# 33830 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33147,19 +33867,19 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 2707 "parsing/parser.mly" +# 2757 "parsing/parser.mly" ( let fields, closed = _1 in let closed = match closed with Some () -> Open | None -> Closed in fields, closed ) -# 33155 "parsing/parser.ml" +# 33875 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2681 "parsing/parser.mly" +# 2731 "parsing/parser.mly" ( unclosed "{" _loc__1_ "}" _loc__3_ ) -# 33163 "parsing/parser.ml" +# 33883 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -33167,15 +33887,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33173 "parsing/parser.ml" +# 33893 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33179 "parsing/parser.ml" +# 33899 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33214,15 +33934,15 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _2 = -# 2701 "parsing/parser.mly" +# 2751 "parsing/parser.mly" ( ps ) -# 33220 "parsing/parser.ml" +# 33940 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2683 "parsing/parser.mly" +# 2733 "parsing/parser.mly" ( fst (mktailpat _loc__3_ _2) ) -# 33226 "parsing/parser.ml" +# 33946 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -33230,15 +33950,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33236 "parsing/parser.ml" +# 33956 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33242 "parsing/parser.ml" +# 33962 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33277,16 +33997,16 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _2 = -# 2701 "parsing/parser.mly" +# 2751 "parsing/parser.mly" ( ps ) -# 33283 "parsing/parser.ml" +# 34003 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2685 "parsing/parser.mly" +# 2735 "parsing/parser.mly" ( unclosed "[" _loc__1_ "]" _loc__3_ ) -# 33290 "parsing/parser.ml" +# 34010 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -33294,15 +34014,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33300 "parsing/parser.ml" +# 34020 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33306 "parsing/parser.ml" +# 34026 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33341,14 +34061,14 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _2 = -# 2701 "parsing/parser.mly" +# 2751 "parsing/parser.mly" ( ps ) -# 33347 "parsing/parser.ml" +# 34067 "parsing/parser.ml" in -# 2687 "parsing/parser.mly" +# 2737 "parsing/parser.mly" ( Ppat_array _2 ) -# 33352 "parsing/parser.ml" +# 34072 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -33356,15 +34076,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33362 "parsing/parser.ml" +# 34082 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33368 "parsing/parser.ml" +# 34088 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33395,24 +34115,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2689 "parsing/parser.mly" +# 2739 "parsing/parser.mly" ( Ppat_array [] ) -# 33401 "parsing/parser.ml" +# 34121 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33410 "parsing/parser.ml" +# 34130 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33416 "parsing/parser.ml" +# 34136 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33451,16 +34171,16 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _2 = -# 2701 "parsing/parser.mly" +# 2751 "parsing/parser.mly" ( ps ) -# 33457 "parsing/parser.ml" +# 34177 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2691 "parsing/parser.mly" +# 2741 "parsing/parser.mly" ( unclosed "[|" _loc__1_ "|]" _loc__3_ ) -# 33464 "parsing/parser.ml" +# 34184 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -33468,15 +34188,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 33474 "parsing/parser.ml" +# 34194 "parsing/parser.ml" in -# 2692 "parsing/parser.mly" +# 2742 "parsing/parser.mly" ( _1 ) -# 33480 "parsing/parser.ml" +# 34200 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33516,9 +34236,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2190 "parsing/parser.mly" +# 2240 "parsing/parser.mly" ( reloc_exp ~loc:_sloc _2 ) -# 33522 "parsing/parser.ml" +# 34242 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33557,9 +34277,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2192 "parsing/parser.mly" +# 2242 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__3_ ) -# 33563 "parsing/parser.ml" +# 34283 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33606,9 +34326,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2194 "parsing/parser.mly" +# 2244 "parsing/parser.mly" ( mkexp_constraint ~loc:_sloc _2 _3 ) -# 33612 "parsing/parser.ml" +# 34332 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33662,9 +34382,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2196 "parsing/parser.mly" +# 2246 "parsing/parser.mly" ( array_get ~loc:_sloc _1 _4 ) -# 33668 "parsing/parser.ml" +# 34388 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33717,9 +34437,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2198 "parsing/parser.mly" +# 2248 "parsing/parser.mly" ( unclosed "(" _loc__3_ ")" _loc__5_ ) -# 33723 "parsing/parser.ml" +# 34443 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33773,9 +34493,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2200 "parsing/parser.mly" +# 2250 "parsing/parser.mly" ( string_get ~loc:_sloc _1 _4 ) -# 33779 "parsing/parser.ml" +# 34499 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33828,9 +34548,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2202 "parsing/parser.mly" +# 2252 "parsing/parser.mly" ( unclosed "[" _loc__3_ "]" _loc__5_ ) -# 33834 "parsing/parser.ml" +# 34554 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33876,26 +34596,26 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 33882 "parsing/parser.ml" +# 34602 "parsing/parser.ml" ) = 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 _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 33891 "parsing/parser.ml" +# 34611 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2204 "parsing/parser.mly" +# 2254 "parsing/parser.mly" ( dotop_get ~loc:_sloc lident bracket _2 _1 _4 ) -# 33899 "parsing/parser.ml" +# 34619 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33941,25 +34661,25 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 33947 "parsing/parser.ml" +# 34667 "parsing/parser.ml" ) = 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 _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 33956 "parsing/parser.ml" +# 34676 "parsing/parser.ml" in let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2206 "parsing/parser.mly" +# 2256 "parsing/parser.mly" ( unclosed "[" _loc__3_ "]" _loc__5_ ) -# 33963 "parsing/parser.ml" +# 34683 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34005,26 +34725,26 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34011 "parsing/parser.ml" +# 34731 "parsing/parser.ml" ) = 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 _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34020 "parsing/parser.ml" +# 34740 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2208 "parsing/parser.mly" +# 2258 "parsing/parser.mly" ( dotop_get ~loc:_sloc lident paren _2 _1 _4 ) -# 34028 "parsing/parser.ml" +# 34748 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34070,25 +34790,25 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34076 "parsing/parser.ml" +# 34796 "parsing/parser.ml" ) = 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 _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34085 "parsing/parser.ml" +# 34805 "parsing/parser.ml" in let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2210 "parsing/parser.mly" +# 2260 "parsing/parser.mly" ( unclosed "(" _loc__3_ ")" _loc__5_ ) -# 34092 "parsing/parser.ml" +# 34812 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34134,26 +34854,26 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34140 "parsing/parser.ml" +# 34860 "parsing/parser.ml" ) = 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 _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34149 "parsing/parser.ml" +# 34869 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2212 "parsing/parser.mly" +# 2262 "parsing/parser.mly" ( dotop_get ~loc:_sloc lident brace _2 _1 _4 ) -# 34157 "parsing/parser.ml" +# 34877 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34199,9 +34919,9 @@ module Tables = struct let _4 : (Parsetree.expression) = Obj.magic _4 in let _3 : unit = Obj.magic _3 in let _2 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34205 "parsing/parser.ml" +# 34925 "parsing/parser.ml" ) = Obj.magic _2 in let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -34210,9 +34930,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2214 "parsing/parser.mly" +# 2264 "parsing/parser.mly" ( unclosed "{" _loc__3_ "}" _loc__5_ ) -# 34216 "parsing/parser.ml" +# 34936 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34270,9 +34990,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34276 "parsing/parser.ml" +# 34996 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -34281,17 +35001,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34287 "parsing/parser.ml" +# 35007 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2216 "parsing/parser.mly" +# 2266 "parsing/parser.mly" ( dotop_get ~loc:_sloc (ldot _3) bracket _4 _1 _6 ) -# 34295 "parsing/parser.ml" +# 35015 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34349,9 +35069,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34355 "parsing/parser.ml" +# 35075 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -34360,16 +35080,16 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34366 "parsing/parser.ml" +# 35086 "parsing/parser.ml" in let _loc__7_ = (_startpos__7_, _endpos__7_) in let _loc__5_ = (_startpos__5_, _endpos__5_) in -# 2219 "parsing/parser.mly" +# 2269 "parsing/parser.mly" ( unclosed "[" _loc__5_ "]" _loc__7_ ) -# 34373 "parsing/parser.ml" +# 35093 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34427,9 +35147,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34433 "parsing/parser.ml" +# 35153 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -34438,17 +35158,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34444 "parsing/parser.ml" +# 35164 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2221 "parsing/parser.mly" +# 2271 "parsing/parser.mly" ( dotop_get ~loc:_sloc (ldot _3) paren _4 _1 _6 ) -# 34452 "parsing/parser.ml" +# 35172 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34506,9 +35226,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34512 "parsing/parser.ml" +# 35232 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -34517,16 +35237,16 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34523 "parsing/parser.ml" +# 35243 "parsing/parser.ml" in let _loc__7_ = (_startpos__7_, _endpos__7_) in let _loc__5_ = (_startpos__5_, _endpos__5_) in -# 2224 "parsing/parser.mly" +# 2274 "parsing/parser.mly" ( unclosed "(" _loc__5_ ")" _loc__7_ ) -# 34530 "parsing/parser.ml" +# 35250 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34584,9 +35304,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34590 "parsing/parser.ml" +# 35310 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -34595,17 +35315,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34601 "parsing/parser.ml" +# 35321 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2226 "parsing/parser.mly" +# 2276 "parsing/parser.mly" ( dotop_get ~loc:_sloc (ldot _3) brace _4 _1 _6 ) -# 34609 "parsing/parser.ml" +# 35329 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34663,9 +35383,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _5 : unit = Obj.magic _5 in let _4 : ( -# 623 "parsing/parser.mly" +# 628 "parsing/parser.mly" (string) -# 34669 "parsing/parser.ml" +# 35389 "parsing/parser.ml" ) = Obj.magic _4 in let _3 : (Longident.t) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in @@ -34674,16 +35394,16 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _6 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 34680 "parsing/parser.ml" +# 35400 "parsing/parser.ml" in let _loc__7_ = (_startpos__7_, _endpos__7_) in let _loc__5_ = (_startpos__5_, _endpos__5_) in -# 2229 "parsing/parser.mly" +# 2279 "parsing/parser.mly" ( unclosed "{" _loc__5_ "}" _loc__7_ ) -# 34687 "parsing/parser.ml" +# 35407 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34737,9 +35457,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2231 "parsing/parser.mly" +# 2281 "parsing/parser.mly" ( bigarray_get ~loc:_sloc _1 _4 ) -# 34743 "parsing/parser.ml" +# 35463 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34792,9 +35512,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2233 "parsing/parser.mly" +# 2283 "parsing/parser.mly" ( unclosed "{" _loc__3_ "}" _loc__5_ ) -# 34798 "parsing/parser.ml" +# 35518 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34848,15 +35568,15 @@ module Tables = struct let attrs = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 34854 "parsing/parser.ml" +# 35574 "parsing/parser.ml" in -# 2242 "parsing/parser.mly" +# 2292 "parsing/parser.mly" ( e.pexp_desc, (ext, attrs @ e.pexp_attributes) ) -# 34860 "parsing/parser.ml" +# 35580 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -34864,10 +35584,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 34871 "parsing/parser.ml" +# 35591 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34916,24 +35636,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 34922 "parsing/parser.ml" +# 35642 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 34928 "parsing/parser.ml" +# 35648 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2244 "parsing/parser.mly" +# 2294 "parsing/parser.mly" ( Pexp_construct (mkloc (Lident "()") (make_loc _sloc), None), _2 ) -# 34937 "parsing/parser.ml" +# 35657 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -34941,10 +35661,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 34948 "parsing/parser.ml" +# 35668 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35000,23 +35720,23 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 35006 "parsing/parser.ml" +# 35726 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 35012 "parsing/parser.ml" +# 35732 "parsing/parser.ml" in let _loc__4_ = (_startpos__4_, _endpos__4_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2246 "parsing/parser.mly" +# 2296 "parsing/parser.mly" ( unclosed "begin" _loc__1_ "end" _loc__4_ ) -# 35020 "parsing/parser.ml" +# 35740 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -35024,10 +35744,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35031 "parsing/parser.ml" +# 35751 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35077,9 +35797,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 35083 "parsing/parser.ml" +# 35803 "parsing/parser.ml" in let _2 = @@ -35087,21 +35807,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 35093 "parsing/parser.ml" +# 35813 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 35099 "parsing/parser.ml" +# 35819 "parsing/parser.ml" in -# 2248 "parsing/parser.mly" +# 2298 "parsing/parser.mly" ( Pexp_new(_3), _2 ) -# 35105 "parsing/parser.ml" +# 35825 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -35109,10 +35829,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35116 "parsing/parser.ml" +# 35836 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35175,21 +35895,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 35181 "parsing/parser.ml" +# 35901 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 35187 "parsing/parser.ml" +# 35907 "parsing/parser.ml" in -# 2250 "parsing/parser.mly" +# 2300 "parsing/parser.mly" ( Pexp_pack _4, _3 ) -# 35193 "parsing/parser.ml" +# 35913 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -35197,10 +35917,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35204 "parsing/parser.ml" +# 35924 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35276,23 +35996,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 35282 "parsing/parser.ml" +# 36002 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 35290 "parsing/parser.ml" +# 36010 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 35296 "parsing/parser.ml" +# 36016 "parsing/parser.ml" in let _3 = @@ -35300,24 +36020,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 35306 "parsing/parser.ml" +# 36026 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 35312 "parsing/parser.ml" +# 36032 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2252 "parsing/parser.mly" +# 2302 "parsing/parser.mly" ( Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _4), _6), _3 ) -# 35321 "parsing/parser.ml" +# 36041 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -35325,10 +36045,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35332 "parsing/parser.ml" +# 36052 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35398,23 +36118,23 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 35404 "parsing/parser.ml" +# 36124 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 35410 "parsing/parser.ml" +# 36130 "parsing/parser.ml" in let _loc__6_ = (_startpos__6_, _endpos__6_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2254 "parsing/parser.mly" +# 2304 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__6_ ) -# 35418 "parsing/parser.ml" +# 36138 "parsing/parser.ml" in let _endpos__1_ = _endpos__6_ in @@ -35422,10 +36142,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2235 "parsing/parser.mly" +# 2285 "parsing/parser.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35429 "parsing/parser.ml" +# 36149 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35454,30 +36174,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 35460 "parsing/parser.ml" +# 36180 "parsing/parser.ml" in -# 2258 "parsing/parser.mly" +# 2308 "parsing/parser.mly" ( Pexp_ident (_1) ) -# 35466 "parsing/parser.ml" +# 36186 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35475 "parsing/parser.ml" +# 36195 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35481 "parsing/parser.ml" +# 36201 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35501,23 +36221,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2260 "parsing/parser.mly" +# 2310 "parsing/parser.mly" ( Pexp_constant _1 ) -# 35507 "parsing/parser.ml" +# 36227 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35515 "parsing/parser.ml" +# 36235 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35521 "parsing/parser.ml" +# 36241 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35546,30 +36266,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 35552 "parsing/parser.ml" +# 36272 "parsing/parser.ml" in -# 2262 "parsing/parser.mly" +# 2312 "parsing/parser.mly" ( Pexp_construct(_1, None) ) -# 35558 "parsing/parser.ml" +# 36278 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35567 "parsing/parser.ml" +# 36287 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35573 "parsing/parser.ml" +# 36293 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35593,23 +36313,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2264 "parsing/parser.mly" +# 2314 "parsing/parser.mly" ( Pexp_variant(_1, None) ) -# 35599 "parsing/parser.ml" +# 36319 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35607 "parsing/parser.ml" +# 36327 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35613 "parsing/parser.ml" +# 36333 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35635,9 +36355,9 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : ( -# 666 "parsing/parser.mly" +# 671 "parsing/parser.mly" (string) -# 35641 "parsing/parser.ml" +# 36361 "parsing/parser.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -35649,15 +36369,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 35655 "parsing/parser.ml" +# 36375 "parsing/parser.ml" in -# 2266 "parsing/parser.mly" +# 2316 "parsing/parser.mly" ( Pexp_apply(_1, [Nolabel,_2]) ) -# 35661 "parsing/parser.ml" +# 36381 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in @@ -35665,15 +36385,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35671 "parsing/parser.ml" +# 36391 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35677 "parsing/parser.ml" +# 36397 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35706,23 +36426,23 @@ module Tables = struct let _1 = let _1 = let _1 = -# 2267 "parsing/parser.mly" +# 2317 "parsing/parser.mly" ("!") -# 35712 "parsing/parser.ml" +# 36432 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 35720 "parsing/parser.ml" +# 36440 "parsing/parser.ml" in -# 2268 "parsing/parser.mly" +# 2318 "parsing/parser.mly" ( Pexp_apply(_1, [Nolabel,_2]) ) -# 35726 "parsing/parser.ml" +# 36446 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in @@ -35730,15 +36450,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35736 "parsing/parser.ml" +# 36456 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35742 "parsing/parser.ml" +# 36462 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35777,14 +36497,14 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2519 "parsing/parser.mly" +# 2569 "parsing/parser.mly" ( xs ) -# 35783 "parsing/parser.ml" +# 36503 "parsing/parser.ml" in -# 2270 "parsing/parser.mly" +# 2320 "parsing/parser.mly" ( Pexp_override _2 ) -# 35788 "parsing/parser.ml" +# 36508 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -35792,15 +36512,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35798 "parsing/parser.ml" +# 36518 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35804 "parsing/parser.ml" +# 36524 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35839,16 +36559,16 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2519 "parsing/parser.mly" +# 2569 "parsing/parser.mly" ( xs ) -# 35845 "parsing/parser.ml" +# 36565 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2272 "parsing/parser.mly" +# 2322 "parsing/parser.mly" ( unclosed "{<" _loc__1_ ">}" _loc__3_ ) -# 35852 "parsing/parser.ml" +# 36572 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -35856,15 +36576,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35862 "parsing/parser.ml" +# 36582 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35868 "parsing/parser.ml" +# 36588 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35895,24 +36615,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2274 "parsing/parser.mly" +# 2324 "parsing/parser.mly" ( Pexp_override [] ) -# 35901 "parsing/parser.ml" +# 36621 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35910 "parsing/parser.ml" +# 36630 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35916 "parsing/parser.ml" +# 36636 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35956,15 +36676,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 35962 "parsing/parser.ml" +# 36682 "parsing/parser.ml" in -# 2276 "parsing/parser.mly" +# 2326 "parsing/parser.mly" ( Pexp_field(_1, _3) ) -# 35968 "parsing/parser.ml" +# 36688 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -35972,15 +36692,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 35978 "parsing/parser.ml" +# 36698 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 35984 "parsing/parser.ml" +# 36704 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36038,24 +36758,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 36044 "parsing/parser.ml" +# 36764 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36053 "parsing/parser.ml" +# 36773 "parsing/parser.ml" in -# 2278 "parsing/parser.mly" +# 2328 "parsing/parser.mly" ( Pexp_open(od, _4) ) -# 36059 "parsing/parser.ml" +# 36779 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -36063,15 +36783,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36069 "parsing/parser.ml" +# 36789 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36075 "parsing/parser.ml" +# 36795 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36124,9 +36844,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2519 "parsing/parser.mly" +# 2569 "parsing/parser.mly" ( xs ) -# 36130 "parsing/parser.ml" +# 36850 "parsing/parser.ml" in let od = let _1 = @@ -36134,18 +36854,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 36140 "parsing/parser.ml" +# 36860 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36149 "parsing/parser.ml" +# 36869 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -36153,10 +36873,10 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2280 "parsing/parser.mly" +# 2330 "parsing/parser.mly" ( (* TODO: review the location of Pexp_override *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_override _4)) ) -# 36160 "parsing/parser.ml" +# 36880 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -36164,15 +36884,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36170 "parsing/parser.ml" +# 36890 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36176 "parsing/parser.ml" +# 36896 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36225,16 +36945,16 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2519 "parsing/parser.mly" +# 2569 "parsing/parser.mly" ( xs ) -# 36231 "parsing/parser.ml" +# 36951 "parsing/parser.ml" in let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2283 "parsing/parser.mly" +# 2333 "parsing/parser.mly" ( unclosed "{<" _loc__3_ ">}" _loc__5_ ) -# 36238 "parsing/parser.ml" +# 36958 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -36242,15 +36962,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36248 "parsing/parser.ml" +# 36968 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36254 "parsing/parser.ml" +# 36974 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36281,9 +37001,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 36287 "parsing/parser.ml" +# 37007 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : (Parsetree.expression) = Obj.magic _1 in @@ -36295,23 +37015,23 @@ module Tables = struct let _3 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 36301 "parsing/parser.ml" +# 37021 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 36309 "parsing/parser.ml" +# 37029 "parsing/parser.ml" in -# 2285 "parsing/parser.mly" +# 2335 "parsing/parser.mly" ( Pexp_send(_1, _3) ) -# 36315 "parsing/parser.ml" +# 37035 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -36319,15 +37039,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36325 "parsing/parser.ml" +# 37045 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36331 "parsing/parser.ml" +# 37051 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36359,9 +37079,9 @@ module Tables = struct } = _menhir_stack in let _3 : (Parsetree.expression) = Obj.magic _3 in let _1_inlined1 : ( -# 677 "parsing/parser.mly" +# 682 "parsing/parser.mly" (string) -# 36365 "parsing/parser.ml" +# 37085 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -36375,15 +37095,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 819 "parsing/parser.mly" +# 840 "parsing/parser.mly" ( mkoperator ~loc:_sloc _1 ) -# 36381 "parsing/parser.ml" +# 37101 "parsing/parser.ml" in -# 2287 "parsing/parser.mly" +# 2337 "parsing/parser.mly" ( mkinfix _1 _2 _3 ) -# 36387 "parsing/parser.ml" +# 37107 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -36391,15 +37111,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36397 "parsing/parser.ml" +# 37117 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36403 "parsing/parser.ml" +# 37123 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36423,23 +37143,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2289 "parsing/parser.mly" +# 2339 "parsing/parser.mly" ( Pexp_extension _1 ) -# 36429 "parsing/parser.ml" +# 37149 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36437 "parsing/parser.ml" +# 37157 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36443 "parsing/parser.ml" +# 37163 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36487,18 +37207,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 = -# 2290 "parsing/parser.mly" +# 2340 "parsing/parser.mly" (Lident "()") -# 36493 "parsing/parser.ml" +# 37213 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 36502 "parsing/parser.ml" +# 37222 "parsing/parser.ml" in let _endpos__3_ = _endpos__2_inlined1_ in @@ -36508,18 +37228,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 36514 "parsing/parser.ml" +# 37234 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36523 "parsing/parser.ml" +# 37243 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -36527,10 +37247,10 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2291 "parsing/parser.mly" +# 2341 "parsing/parser.mly" ( (* TODO: review the location of Pexp_construct *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_construct(_3, None))) ) -# 36534 "parsing/parser.ml" +# 37254 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -36538,15 +37258,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36544 "parsing/parser.ml" +# 37264 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36550 "parsing/parser.ml" +# 37270 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36601,9 +37321,9 @@ module Tables = struct let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2294 "parsing/parser.mly" +# 2344 "parsing/parser.mly" ( unclosed "(" _loc__3_ ")" _loc__5_ ) -# 36607 "parsing/parser.ml" +# 37327 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -36611,15 +37331,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36617 "parsing/parser.ml" +# 37337 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36623 "parsing/parser.ml" +# 37343 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36658,25 +37378,25 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2296 "parsing/parser.mly" +# 2346 "parsing/parser.mly" ( let (exten, fields) = _2 in Pexp_record(fields, exten) ) -# 36665 "parsing/parser.ml" +# 37385 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36674 "parsing/parser.ml" +# 37394 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36680 "parsing/parser.ml" +# 37400 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36718,9 +37438,9 @@ module Tables = struct let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2299 "parsing/parser.mly" +# 2349 "parsing/parser.mly" ( unclosed "{" _loc__1_ "}" _loc__3_ ) -# 36724 "parsing/parser.ml" +# 37444 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -36728,15 +37448,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36734 "parsing/parser.ml" +# 37454 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36740 "parsing/parser.ml" +# 37460 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36795,18 +37515,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 36801 "parsing/parser.ml" +# 37521 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36810 "parsing/parser.ml" +# 37530 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -36814,11 +37534,11 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2301 "parsing/parser.mly" +# 2351 "parsing/parser.mly" ( let (exten, fields) = _4 in (* TODO: review the location of Pexp_construct *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_record(fields, exten))) ) -# 36822 "parsing/parser.ml" +# 37542 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -36826,15 +37546,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36832 "parsing/parser.ml" +# 37552 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36838 "parsing/parser.ml" +# 37558 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36890,9 +37610,9 @@ module Tables = struct let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2305 "parsing/parser.mly" +# 2355 "parsing/parser.mly" ( unclosed "{" _loc__3_ "}" _loc__5_ ) -# 36896 "parsing/parser.ml" +# 37616 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -36900,15 +37620,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36906 "parsing/parser.ml" +# 37626 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36912 "parsing/parser.ml" +# 37632 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36947,14 +37667,14 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 36953 "parsing/parser.ml" +# 37673 "parsing/parser.ml" in -# 2307 "parsing/parser.mly" +# 2357 "parsing/parser.mly" ( Pexp_array(_2) ) -# 36958 "parsing/parser.ml" +# 37678 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -36962,15 +37682,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 36968 "parsing/parser.ml" +# 37688 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 36974 "parsing/parser.ml" +# 37694 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37009,16 +37729,16 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37015 "parsing/parser.ml" +# 37735 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2309 "parsing/parser.mly" +# 2359 "parsing/parser.mly" ( unclosed "[|" _loc__1_ "|]" _loc__3_ ) -# 37022 "parsing/parser.ml" +# 37742 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -37026,15 +37746,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37032 "parsing/parser.ml" +# 37752 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37038 "parsing/parser.ml" +# 37758 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37065,24 +37785,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2311 "parsing/parser.mly" +# 2361 "parsing/parser.mly" ( Pexp_array [] ) -# 37071 "parsing/parser.ml" +# 37791 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37080 "parsing/parser.ml" +# 37800 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37086 "parsing/parser.ml" +# 37806 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37135,9 +37855,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37141 "parsing/parser.ml" +# 37861 "parsing/parser.ml" in let od = let _1 = @@ -37145,18 +37865,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 37151 "parsing/parser.ml" +# 37871 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37160 "parsing/parser.ml" +# 37880 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -37164,10 +37884,10 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2313 "parsing/parser.mly" +# 2363 "parsing/parser.mly" ( (* TODO: review the location of Pexp_array *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_array(_4))) ) -# 37171 "parsing/parser.ml" +# 37891 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -37175,15 +37895,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37181 "parsing/parser.ml" +# 37901 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37187 "parsing/parser.ml" +# 37907 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37234,18 +37954,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 37240 "parsing/parser.ml" +# 37960 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37249 "parsing/parser.ml" +# 37969 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -37253,10 +37973,10 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2316 "parsing/parser.mly" +# 2366 "parsing/parser.mly" ( (* TODO: review the location of Pexp_array *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_array [])) ) -# 37260 "parsing/parser.ml" +# 37980 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -37264,15 +37984,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37270 "parsing/parser.ml" +# 37990 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37276 "parsing/parser.ml" +# 37996 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37325,16 +38045,16 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37331 "parsing/parser.ml" +# 38051 "parsing/parser.ml" in let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2320 "parsing/parser.mly" +# 2370 "parsing/parser.mly" ( unclosed "[|" _loc__3_ "|]" _loc__5_ ) -# 37338 "parsing/parser.ml" +# 38058 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -37342,15 +38062,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37348 "parsing/parser.ml" +# 38068 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37354 "parsing/parser.ml" +# 38074 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37389,15 +38109,15 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37395 "parsing/parser.ml" +# 38115 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2322 "parsing/parser.mly" +# 2372 "parsing/parser.mly" ( fst (mktailexp _loc__3_ _2) ) -# 37401 "parsing/parser.ml" +# 38121 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -37405,15 +38125,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37411 "parsing/parser.ml" +# 38131 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37417 "parsing/parser.ml" +# 38137 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37452,16 +38172,16 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37458 "parsing/parser.ml" +# 38178 "parsing/parser.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2324 "parsing/parser.mly" +# 2374 "parsing/parser.mly" ( unclosed "[" _loc__1_ "]" _loc__3_ ) -# 37465 "parsing/parser.ml" +# 38185 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -37469,15 +38189,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37475 "parsing/parser.ml" +# 38195 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37481 "parsing/parser.ml" +# 38201 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37530,9 +38250,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37536 "parsing/parser.ml" +# 38256 "parsing/parser.ml" in let od = let _1 = @@ -37540,18 +38260,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 37546 "parsing/parser.ml" +# 38266 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37555 "parsing/parser.ml" +# 38275 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -37560,13 +38280,13 @@ module Tables = struct let _loc__5_ = (_startpos__5_, _endpos__5_) in let _sloc = (_symbolstartpos, _endpos) in -# 2326 "parsing/parser.mly" +# 2376 "parsing/parser.mly" ( let list_exp = (* TODO: review the location of list_exp *) let tail_exp, _tail_loc = mktailexp _loc__5_ _4 in mkexp ~loc:_sloc tail_exp in Pexp_open(od, list_exp) ) -# 37570 "parsing/parser.ml" +# 38290 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -37574,15 +38294,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37580 "parsing/parser.ml" +# 38300 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37586 "parsing/parser.ml" +# 38306 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37630,18 +38350,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 = -# 2331 "parsing/parser.mly" +# 2381 "parsing/parser.mly" (Lident "[]") -# 37636 "parsing/parser.ml" +# 38356 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 37645 "parsing/parser.ml" +# 38365 "parsing/parser.ml" in let _endpos__3_ = _endpos__2_inlined1_ in @@ -37651,18 +38371,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 37657 "parsing/parser.ml" +# 38377 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37666 "parsing/parser.ml" +# 38386 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -37670,10 +38390,10 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2332 "parsing/parser.mly" +# 2382 "parsing/parser.mly" ( (* TODO: review the location of Pexp_construct *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_construct(_3, None))) ) -# 37677 "parsing/parser.ml" +# 38397 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -37681,15 +38401,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37687 "parsing/parser.ml" +# 38407 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37693 "parsing/parser.ml" +# 38413 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37742,16 +38462,16 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2536 "parsing/parser.mly" +# 2586 "parsing/parser.mly" ( es ) -# 37748 "parsing/parser.ml" +# 38468 "parsing/parser.ml" in let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2336 "parsing/parser.mly" +# 2386 "parsing/parser.mly" ( unclosed "[" _loc__3_ "]" _loc__5_ ) -# 37755 "parsing/parser.ml" +# 38475 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -37759,15 +38479,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37765 "parsing/parser.ml" +# 38485 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37771 "parsing/parser.ml" +# 38491 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37858,23 +38578,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 37864 "parsing/parser.ml" +# 38584 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 37872 "parsing/parser.ml" +# 38592 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 37878 "parsing/parser.ml" +# 38598 "parsing/parser.ml" in let _5 = @@ -37882,15 +38602,15 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 37888 "parsing/parser.ml" +# 38608 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 37894 "parsing/parser.ml" +# 38614 "parsing/parser.ml" in let od = @@ -37899,18 +38619,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 37905 "parsing/parser.ml" +# 38625 "parsing/parser.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1443 "parsing/parser.mly" +# 1493 "parsing/parser.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37914 "parsing/parser.ml" +# 38634 "parsing/parser.ml" in let _startpos_od_ = _startpos__1_ in @@ -37918,13 +38638,13 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2339 "parsing/parser.mly" +# 2389 "parsing/parser.mly" ( (* TODO: review the location of Pexp_constraint *) let modexp = mkexp_attrs ~loc:_sloc (Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _6), _8)) _5 in Pexp_open(od, modexp) ) -# 37928 "parsing/parser.ml" +# 38648 "parsing/parser.ml" in let _endpos__1_ = _endpos__9_ in @@ -37932,15 +38652,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 37938 "parsing/parser.ml" +# 38658 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 37944 "parsing/parser.ml" +# 38664 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38025,23 +38745,23 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 38031 "parsing/parser.ml" +# 38751 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 38037 "parsing/parser.ml" +# 38757 "parsing/parser.ml" in let _loc__8_ = (_startpos__8_, _endpos__8_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2346 "parsing/parser.mly" +# 2396 "parsing/parser.mly" ( unclosed "(" _loc__3_ ")" _loc__8_ ) -# 38045 "parsing/parser.ml" +# 38765 "parsing/parser.ml" in let _endpos__1_ = _endpos__8_ in @@ -38049,15 +38769,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 825 "parsing/parser.mly" +# 846 "parsing/parser.mly" ( mkexp ~loc:_sloc _1 ) -# 38055 "parsing/parser.ml" +# 38775 "parsing/parser.ml" in -# 2238 "parsing/parser.mly" +# 2288 "parsing/parser.mly" ( _1 ) -# 38061 "parsing/parser.ml" +# 38781 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38075,7 +38795,7 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : (string) = Obj.magic _1 in + let _1 : (Asttypes.label) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in @@ -38086,30 +38806,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38092 "parsing/parser.ml" +# 38812 "parsing/parser.ml" in -# 2616 "parsing/parser.mly" +# 2666 "parsing/parser.mly" ( Ppat_var (_1) ) -# 38098 "parsing/parser.ml" +# 38818 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38107 "parsing/parser.ml" +# 38827 "parsing/parser.ml" in -# 2617 "parsing/parser.mly" +# 2667 "parsing/parser.mly" ( _1 ) -# 38113 "parsing/parser.ml" +# 38833 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38132,9 +38852,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2618 "parsing/parser.mly" +# 2668 "parsing/parser.mly" ( _1 ) -# 38138 "parsing/parser.ml" +# 38858 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38174,9 +38894,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2623 "parsing/parser.mly" +# 2673 "parsing/parser.mly" ( reloc_pat ~loc:_sloc _2 ) -# 38180 "parsing/parser.ml" +# 38900 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38199,9 +38919,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2625 "parsing/parser.mly" +# 2675 "parsing/parser.mly" ( _1 ) -# 38205 "parsing/parser.ml" +# 38925 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38264,9 +38984,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38270 "parsing/parser.ml" +# 38990 "parsing/parser.ml" in let _3 = @@ -38274,24 +38994,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 38280 "parsing/parser.ml" +# 39000 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 38286 "parsing/parser.ml" +# 39006 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2627 "parsing/parser.mly" +# 2677 "parsing/parser.mly" ( mkpat_attrs ~loc:_sloc (Ppat_unpack _4) _3 ) -# 38295 "parsing/parser.ml" +# 39015 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38366,23 +39086,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined4_, _startpos__1_inlined4_, _1_inlined4) in let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 38372 "parsing/parser.ml" +# 39092 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 38380 "parsing/parser.ml" +# 39100 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 38386 "parsing/parser.ml" +# 39106 "parsing/parser.ml" in let _4 = @@ -38391,9 +39111,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38397 "parsing/parser.ml" +# 39117 "parsing/parser.ml" in let _3 = @@ -38401,26 +39121,26 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 38407 "parsing/parser.ml" +# 39127 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 38413 "parsing/parser.ml" +# 39133 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2629 "parsing/parser.mly" +# 2679 "parsing/parser.mly" ( mkpat_attrs ~loc:_sloc (Ppat_constraint(mkpat ~loc:_sloc (Ppat_unpack _4), _6)) _3 ) -# 38424 "parsing/parser.ml" +# 39144 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38444,23 +39164,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2637 "parsing/parser.mly" +# 2687 "parsing/parser.mly" ( Ppat_any ) -# 38450 "parsing/parser.ml" +# 39170 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38458 "parsing/parser.ml" +# 39178 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38464 "parsing/parser.ml" +# 39184 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38484,23 +39204,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2639 "parsing/parser.mly" +# 2689 "parsing/parser.mly" ( Ppat_constant _1 ) -# 38490 "parsing/parser.ml" +# 39210 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38498 "parsing/parser.ml" +# 39218 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38504 "parsing/parser.ml" +# 39224 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38538,24 +39258,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2641 "parsing/parser.mly" +# 2691 "parsing/parser.mly" ( Ppat_interval (_1, _3) ) -# 38544 "parsing/parser.ml" +# 39264 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38553 "parsing/parser.ml" +# 39273 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38559 "parsing/parser.ml" +# 39279 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38584,30 +39304,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38590 "parsing/parser.ml" +# 39310 "parsing/parser.ml" in -# 2643 "parsing/parser.mly" +# 2693 "parsing/parser.mly" ( Ppat_construct(_1, None) ) -# 38596 "parsing/parser.ml" +# 39316 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38605 "parsing/parser.ml" +# 39325 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38611 "parsing/parser.ml" +# 39331 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38631,23 +39351,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2645 "parsing/parser.mly" +# 2695 "parsing/parser.mly" ( Ppat_variant(_1, None) ) -# 38637 "parsing/parser.ml" +# 39357 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38645 "parsing/parser.ml" +# 39365 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38651 "parsing/parser.ml" +# 39371 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38684,15 +39404,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38690 "parsing/parser.ml" +# 39410 "parsing/parser.ml" in -# 2647 "parsing/parser.mly" +# 2697 "parsing/parser.mly" ( Ppat_type (_2) ) -# 38696 "parsing/parser.ml" +# 39416 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -38700,15 +39420,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38706 "parsing/parser.ml" +# 39426 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38712 "parsing/parser.ml" +# 39432 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38751,15 +39471,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38757 "parsing/parser.ml" +# 39477 "parsing/parser.ml" in -# 2649 "parsing/parser.mly" +# 2699 "parsing/parser.mly" ( Ppat_open(_1, _3) ) -# 38763 "parsing/parser.ml" +# 39483 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -38767,15 +39487,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38773 "parsing/parser.ml" +# 39493 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38779 "parsing/parser.ml" +# 39499 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38823,18 +39543,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 = -# 2650 "parsing/parser.mly" +# 2700 "parsing/parser.mly" (Lident "[]") -# 38829 "parsing/parser.ml" +# 39549 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38838 "parsing/parser.ml" +# 39558 "parsing/parser.ml" in let _endpos__3_ = _endpos__2_inlined1_ in @@ -38843,18 +39563,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38849 "parsing/parser.ml" +# 39569 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2651 "parsing/parser.mly" +# 2701 "parsing/parser.mly" ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) ) -# 38858 "parsing/parser.ml" +# 39578 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -38862,15 +39582,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38868 "parsing/parser.ml" +# 39588 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38874 "parsing/parser.ml" +# 39594 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38918,18 +39638,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 = -# 2652 "parsing/parser.mly" +# 2702 "parsing/parser.mly" (Lident "()") -# 38924 "parsing/parser.ml" +# 39644 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38933 "parsing/parser.ml" +# 39653 "parsing/parser.ml" in let _endpos__3_ = _endpos__2_inlined1_ in @@ -38938,18 +39658,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 38944 "parsing/parser.ml" +# 39664 "parsing/parser.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2653 "parsing/parser.mly" +# 2703 "parsing/parser.mly" ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) ) -# 38953 "parsing/parser.ml" +# 39673 "parsing/parser.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -38957,15 +39677,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 38963 "parsing/parser.ml" +# 39683 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 38969 "parsing/parser.ml" +# 39689 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39022,15 +39742,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 39028 "parsing/parser.ml" +# 39748 "parsing/parser.ml" in -# 2655 "parsing/parser.mly" +# 2705 "parsing/parser.mly" ( Ppat_open (_1, _4) ) -# 39034 "parsing/parser.ml" +# 39754 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -39038,15 +39758,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39044 "parsing/parser.ml" +# 39764 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39050 "parsing/parser.ml" +# 39770 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39101,9 +39821,9 @@ module Tables = struct let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2657 "parsing/parser.mly" +# 2707 "parsing/parser.mly" ( unclosed "(" _loc__3_ ")" _loc__5_ ) -# 39107 "parsing/parser.ml" +# 39827 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -39111,15 +39831,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39117 "parsing/parser.ml" +# 39837 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39123 "parsing/parser.ml" +# 39843 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39166,9 +39886,9 @@ module Tables = struct let _1 = let _loc__4_ = (_startpos__4_, _endpos__4_) in -# 2659 "parsing/parser.mly" +# 2709 "parsing/parser.mly" ( expecting _loc__4_ "pattern" ) -# 39172 "parsing/parser.ml" +# 39892 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -39176,15 +39896,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39182 "parsing/parser.ml" +# 39902 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39188 "parsing/parser.ml" +# 39908 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39225,9 +39945,9 @@ module Tables = struct let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2661 "parsing/parser.mly" +# 2711 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__3_ ) -# 39231 "parsing/parser.ml" +# 39951 "parsing/parser.ml" in let _endpos__1_ = _endpos__3_ in @@ -39235,15 +39955,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39241 "parsing/parser.ml" +# 39961 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39247 "parsing/parser.ml" +# 39967 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39295,24 +40015,24 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2663 "parsing/parser.mly" +# 2713 "parsing/parser.mly" ( Ppat_constraint(_2, _4) ) -# 39301 "parsing/parser.ml" +# 40021 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39310 "parsing/parser.ml" +# 40030 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39316 "parsing/parser.ml" +# 40036 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39367,9 +40087,9 @@ module Tables = struct let _loc__5_ = (_startpos__5_, _endpos__5_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2665 "parsing/parser.mly" +# 2715 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__5_ ) -# 39373 "parsing/parser.ml" +# 40093 "parsing/parser.ml" in let _endpos__1_ = _endpos__5_ in @@ -39377,15 +40097,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39383 "parsing/parser.ml" +# 40103 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39389 "parsing/parser.ml" +# 40109 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39432,9 +40152,9 @@ module Tables = struct let _1 = let _loc__4_ = (_startpos__4_, _endpos__4_) in -# 2667 "parsing/parser.mly" +# 2717 "parsing/parser.mly" ( expecting _loc__4_ "type" ) -# 39438 "parsing/parser.ml" +# 40158 "parsing/parser.ml" in let _endpos__1_ = _endpos__4_ in @@ -39442,15 +40162,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39448 "parsing/parser.ml" +# 40168 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39454 "parsing/parser.ml" +# 40174 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39527,23 +40247,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in let _1 = let _1 = -# 3270 "parsing/parser.mly" +# 3320 "parsing/parser.mly" ( Ptyp_package (package_type_of_module_type _1) ) -# 39533 "parsing/parser.ml" +# 40253 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 39541 "parsing/parser.ml" +# 40261 "parsing/parser.ml" in -# 3271 "parsing/parser.mly" +# 3321 "parsing/parser.mly" ( _1 ) -# 39547 "parsing/parser.ml" +# 40267 "parsing/parser.ml" in let _3 = @@ -39551,23 +40271,23 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 39557 "parsing/parser.ml" +# 40277 "parsing/parser.ml" in -# 3680 "parsing/parser.mly" +# 3742 "parsing/parser.mly" ( _1, _2 ) -# 39563 "parsing/parser.ml" +# 40283 "parsing/parser.ml" in let _loc__7_ = (_startpos__7_, _endpos__7_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2670 "parsing/parser.mly" +# 2720 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__7_ ) -# 39571 "parsing/parser.ml" +# 40291 "parsing/parser.ml" in let _endpos__1_ = _endpos__7_ in @@ -39575,15 +40295,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39581 "parsing/parser.ml" +# 40301 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39587 "parsing/parser.ml" +# 40307 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39607,23 +40327,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2672 "parsing/parser.mly" +# 2722 "parsing/parser.mly" ( Ppat_extension _1 ) -# 39613 "parsing/parser.ml" +# 40333 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 827 "parsing/parser.mly" +# 848 "parsing/parser.mly" ( mkpat ~loc:_sloc _1 ) -# 39621 "parsing/parser.ml" +# 40341 "parsing/parser.ml" in -# 2633 "parsing/parser.mly" +# 2683 "parsing/parser.mly" ( _1 ) -# 39627 "parsing/parser.ml" +# 40347 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39642,17 +40362,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 39648 "parsing/parser.ml" +# 40368 "parsing/parser.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) = -# 3590 "parsing/parser.mly" +# 3652 "parsing/parser.mly" ( _1 ) -# 39656 "parsing/parser.ml" +# 40376 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39671,17 +40391,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 688 "parsing/parser.mly" +# 697 "parsing/parser.mly" (string) -# 39677 "parsing/parser.ml" +# 40397 "parsing/parser.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) = -# 3591 "parsing/parser.mly" +# 3653 "parsing/parser.mly" ( _1 ) -# 39685 "parsing/parser.ml" +# 40405 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39704,9 +40424,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3592 "parsing/parser.mly" +# 3654 "parsing/parser.mly" ( "and" ) -# 39710 "parsing/parser.ml" +# 40430 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39729,9 +40449,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3593 "parsing/parser.mly" +# 3655 "parsing/parser.mly" ( "as" ) -# 39735 "parsing/parser.ml" +# 40455 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39754,9 +40474,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3594 "parsing/parser.mly" +# 3656 "parsing/parser.mly" ( "assert" ) -# 39760 "parsing/parser.ml" +# 40480 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39779,9 +40499,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3595 "parsing/parser.mly" +# 3657 "parsing/parser.mly" ( "begin" ) -# 39785 "parsing/parser.ml" +# 40505 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39804,9 +40524,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3596 "parsing/parser.mly" +# 3658 "parsing/parser.mly" ( "class" ) -# 39810 "parsing/parser.ml" +# 40530 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39829,9 +40549,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3597 "parsing/parser.mly" +# 3659 "parsing/parser.mly" ( "constraint" ) -# 39835 "parsing/parser.ml" +# 40555 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39854,9 +40574,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3598 "parsing/parser.mly" +# 3660 "parsing/parser.mly" ( "do" ) -# 39860 "parsing/parser.ml" +# 40580 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39879,9 +40599,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3599 "parsing/parser.mly" +# 3661 "parsing/parser.mly" ( "done" ) -# 39885 "parsing/parser.ml" +# 40605 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39904,9 +40624,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3600 "parsing/parser.mly" +# 3662 "parsing/parser.mly" ( "downto" ) -# 39910 "parsing/parser.ml" +# 40630 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39929,9 +40649,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3601 "parsing/parser.mly" +# 3663 "parsing/parser.mly" ( "else" ) -# 39935 "parsing/parser.ml" +# 40655 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39954,9 +40674,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3602 "parsing/parser.mly" +# 3664 "parsing/parser.mly" ( "end" ) -# 39960 "parsing/parser.ml" +# 40680 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39979,9 +40699,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3603 "parsing/parser.mly" +# 3665 "parsing/parser.mly" ( "exception" ) -# 39985 "parsing/parser.ml" +# 40705 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40004,9 +40724,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3604 "parsing/parser.mly" +# 3666 "parsing/parser.mly" ( "external" ) -# 40010 "parsing/parser.ml" +# 40730 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40029,9 +40749,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3605 "parsing/parser.mly" +# 3667 "parsing/parser.mly" ( "false" ) -# 40035 "parsing/parser.ml" +# 40755 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40054,9 +40774,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3606 "parsing/parser.mly" +# 3668 "parsing/parser.mly" ( "for" ) -# 40060 "parsing/parser.ml" +# 40780 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40079,9 +40799,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3607 "parsing/parser.mly" +# 3669 "parsing/parser.mly" ( "fun" ) -# 40085 "parsing/parser.ml" +# 40805 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40104,9 +40824,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3608 "parsing/parser.mly" +# 3670 "parsing/parser.mly" ( "function" ) -# 40110 "parsing/parser.ml" +# 40830 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40129,9 +40849,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3609 "parsing/parser.mly" +# 3671 "parsing/parser.mly" ( "functor" ) -# 40135 "parsing/parser.ml" +# 40855 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40154,9 +40874,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3610 "parsing/parser.mly" +# 3672 "parsing/parser.mly" ( "if" ) -# 40160 "parsing/parser.ml" +# 40880 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40179,9 +40899,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3611 "parsing/parser.mly" +# 3673 "parsing/parser.mly" ( "in" ) -# 40185 "parsing/parser.ml" +# 40905 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40204,9 +40924,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3612 "parsing/parser.mly" +# 3674 "parsing/parser.mly" ( "include" ) -# 40210 "parsing/parser.ml" +# 40930 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40229,9 +40949,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3613 "parsing/parser.mly" +# 3675 "parsing/parser.mly" ( "inherit" ) -# 40235 "parsing/parser.ml" +# 40955 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40254,9 +40974,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3614 "parsing/parser.mly" +# 3676 "parsing/parser.mly" ( "initializer" ) -# 40260 "parsing/parser.ml" +# 40980 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40279,9 +40999,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3615 "parsing/parser.mly" +# 3677 "parsing/parser.mly" ( "lazy" ) -# 40285 "parsing/parser.ml" +# 41005 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40304,9 +41024,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3616 "parsing/parser.mly" +# 3678 "parsing/parser.mly" ( "let" ) -# 40310 "parsing/parser.ml" +# 41030 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40329,9 +41049,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3617 "parsing/parser.mly" +# 3679 "parsing/parser.mly" ( "match" ) -# 40335 "parsing/parser.ml" +# 41055 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40354,9 +41074,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3618 "parsing/parser.mly" +# 3680 "parsing/parser.mly" ( "method" ) -# 40360 "parsing/parser.ml" +# 41080 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40379,9 +41099,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3619 "parsing/parser.mly" +# 3681 "parsing/parser.mly" ( "module" ) -# 40385 "parsing/parser.ml" +# 41105 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40404,9 +41124,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3620 "parsing/parser.mly" +# 3682 "parsing/parser.mly" ( "mutable" ) -# 40410 "parsing/parser.ml" +# 41130 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40429,9 +41149,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3621 "parsing/parser.mly" +# 3683 "parsing/parser.mly" ( "new" ) -# 40435 "parsing/parser.ml" +# 41155 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40454,9 +41174,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3622 "parsing/parser.mly" +# 3684 "parsing/parser.mly" ( "nonrec" ) -# 40460 "parsing/parser.ml" +# 41180 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40479,9 +41199,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3623 "parsing/parser.mly" +# 3685 "parsing/parser.mly" ( "object" ) -# 40485 "parsing/parser.ml" +# 41205 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40504,9 +41224,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3624 "parsing/parser.mly" +# 3686 "parsing/parser.mly" ( "of" ) -# 40510 "parsing/parser.ml" +# 41230 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40529,9 +41249,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3625 "parsing/parser.mly" +# 3687 "parsing/parser.mly" ( "open" ) -# 40535 "parsing/parser.ml" +# 41255 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40554,9 +41274,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3626 "parsing/parser.mly" +# 3688 "parsing/parser.mly" ( "or" ) -# 40560 "parsing/parser.ml" +# 41280 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40579,9 +41299,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3627 "parsing/parser.mly" +# 3689 "parsing/parser.mly" ( "private" ) -# 40585 "parsing/parser.ml" +# 41305 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40604,9 +41324,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3628 "parsing/parser.mly" +# 3690 "parsing/parser.mly" ( "rec" ) -# 40610 "parsing/parser.ml" +# 41330 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40629,9 +41349,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3629 "parsing/parser.mly" +# 3691 "parsing/parser.mly" ( "sig" ) -# 40635 "parsing/parser.ml" +# 41355 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40654,9 +41374,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3630 "parsing/parser.mly" +# 3692 "parsing/parser.mly" ( "struct" ) -# 40660 "parsing/parser.ml" +# 41380 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40679,9 +41399,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3631 "parsing/parser.mly" +# 3693 "parsing/parser.mly" ( "then" ) -# 40685 "parsing/parser.ml" +# 41405 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40704,9 +41424,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3632 "parsing/parser.mly" +# 3694 "parsing/parser.mly" ( "to" ) -# 40710 "parsing/parser.ml" +# 41430 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40729,9 +41449,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3633 "parsing/parser.mly" +# 3695 "parsing/parser.mly" ( "true" ) -# 40735 "parsing/parser.ml" +# 41455 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40754,9 +41474,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3634 "parsing/parser.mly" +# 3696 "parsing/parser.mly" ( "try" ) -# 40760 "parsing/parser.ml" +# 41480 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40779,9 +41499,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3635 "parsing/parser.mly" +# 3697 "parsing/parser.mly" ( "type" ) -# 40785 "parsing/parser.ml" +# 41505 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40804,9 +41524,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3636 "parsing/parser.mly" +# 3698 "parsing/parser.mly" ( "val" ) -# 40810 "parsing/parser.ml" +# 41530 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40829,9 +41549,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3637 "parsing/parser.mly" +# 3699 "parsing/parser.mly" ( "virtual" ) -# 40835 "parsing/parser.ml" +# 41555 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40854,9 +41574,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3638 "parsing/parser.mly" +# 3700 "parsing/parser.mly" ( "when" ) -# 40860 "parsing/parser.ml" +# 41580 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40879,9 +41599,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3639 "parsing/parser.mly" +# 3701 "parsing/parser.mly" ( "while" ) -# 40885 "parsing/parser.ml" +# 41605 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40904,9 +41624,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3640 "parsing/parser.mly" +# 3702 "parsing/parser.mly" ( "with" ) -# 40910 "parsing/parser.ml" +# 41630 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40929,9 +41649,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.type_exception * string Asttypes.loc option) = -# 2937 "parsing/parser.mly" +# 2987 "parsing/parser.mly" ( _1 ) -# 40935 "parsing/parser.ml" +# 41655 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40995,7 +41715,7 @@ module Tables = struct let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in let _5 : unit = Obj.magic _5 in - let _1_inlined2 : (string) = Obj.magic _1_inlined2 in + let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Asttypes.loc option) = Obj.magic ext in let _1 : unit = Obj.magic _1 in @@ -41005,18 +41725,18 @@ module Tables = struct let _v : (Parsetree.type_exception * string Asttypes.loc option) = let attrs = let _1 = _1_inlined5 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 41011 "parsing/parser.ml" +# 41731 "parsing/parser.ml" in let _endpos_attrs_ = _endpos__1_inlined5_ in let attrs2 = let _1 = _1_inlined4 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 41020 "parsing/parser.ml" +# 41740 "parsing/parser.ml" in let lid = @@ -41025,9 +41745,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 41031 "parsing/parser.ml" +# 41751 "parsing/parser.ml" in let id = @@ -41036,30 +41756,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 41042 "parsing/parser.ml" +# 41762 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 41050 "parsing/parser.ml" +# 41770 "parsing/parser.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2946 "parsing/parser.mly" +# 2996 "parsing/parser.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 ) -# 41063 "parsing/parser.ml" +# 41783 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41089,9 +41809,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = -# 2461 "parsing/parser.mly" +# 2511 "parsing/parser.mly" ( _2 ) -# 41095 "parsing/parser.ml" +# 41815 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41124,9 +41844,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2463 "parsing/parser.mly" +# 2513 "parsing/parser.mly" ( let (l, o, p) = _1 in ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) ) -# 41130 "parsing/parser.ml" +# 41850 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41177,17 +41897,17 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _3 = -# 2364 "parsing/parser.mly" +# 2414 "parsing/parser.mly" ( xs ) -# 41183 "parsing/parser.ml" +# 41903 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2465 "parsing/parser.mly" +# 2515 "parsing/parser.mly" ( mk_newtypes ~loc:_sloc _3 _5 ) -# 41191 "parsing/parser.ml" +# 41911 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41212,41 +41932,41 @@ module Tables = struct let _v : (Parsetree.structure) = let _1 = let _1 = let ys = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 41218 "parsing/parser.ml" +# 41938 "parsing/parser.ml" in let xs = let items = -# 862 "parsing/parser.mly" +# 883 "parsing/parser.mly" ( [] ) -# 41224 "parsing/parser.ml" +# 41944 "parsing/parser.ml" in -# 1247 "parsing/parser.mly" +# 1297 "parsing/parser.mly" ( items ) -# 41229 "parsing/parser.ml" +# 41949 "parsing/parser.ml" in -# 267 "menhir/standard.mly" +# 267 "" ( xs @ ys ) -# 41235 "parsing/parser.ml" +# 41955 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 784 "parsing/parser.mly" +# 805 "parsing/parser.mly" ( extra_str _startpos _endpos _1 ) -# 41244 "parsing/parser.ml" +# 41964 "parsing/parser.ml" in -# 1240 "parsing/parser.mly" +# 1290 "parsing/parser.mly" ( _1 ) -# 41250 "parsing/parser.ml" +# 41970 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41285,9 +42005,9 @@ module Tables = struct let _v : (Parsetree.structure) = let _1 = let _1 = let ys = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 41291 "parsing/parser.ml" +# 42011 "parsing/parser.ml" in let xs = let items = @@ -41295,65 +42015,65 @@ module Tables = struct let _1 = let _1 = let attrs = -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 41301 "parsing/parser.ml" +# 42021 "parsing/parser.ml" in -# 1254 "parsing/parser.mly" +# 1304 "parsing/parser.mly" ( mkstrexp e attrs ) -# 41306 "parsing/parser.ml" +# 42026 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 796 "parsing/parser.mly" +# 817 "parsing/parser.mly" ( text_str _startpos @ [_1] ) -# 41314 "parsing/parser.ml" +# 42034 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 815 "parsing/parser.mly" +# 836 "parsing/parser.mly" ( mark_rhs_docs _startpos _endpos; _1 ) -# 41324 "parsing/parser.ml" +# 42044 "parsing/parser.ml" in -# 864 "parsing/parser.mly" +# 885 "parsing/parser.mly" ( x ) -# 41330 "parsing/parser.ml" +# 42050 "parsing/parser.ml" in -# 1247 "parsing/parser.mly" +# 1297 "parsing/parser.mly" ( items ) -# 41336 "parsing/parser.ml" +# 42056 "parsing/parser.ml" in -# 267 "menhir/standard.mly" +# 267 "" ( xs @ ys ) -# 41342 "parsing/parser.ml" +# 42062 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 784 "parsing/parser.mly" +# 805 "parsing/parser.mly" ( extra_str _startpos _endpos _1 ) -# 41351 "parsing/parser.ml" +# 42071 "parsing/parser.ml" in -# 1240 "parsing/parser.mly" +# 1290 "parsing/parser.mly" ( _1 ) -# 41357 "parsing/parser.ml" +# 42077 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41379,9 +42099,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1269 "parsing/parser.mly" +# 1319 "parsing/parser.mly" ( val_of_let_bindings ~loc:_sloc _1 ) -# 41385 "parsing/parser.ml" +# 42105 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41415,9 +42135,9 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 41421 "parsing/parser.ml" +# 42141 "parsing/parser.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -41425,10 +42145,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1272 "parsing/parser.mly" +# 1322 "parsing/parser.mly" ( let docs = symbol_docs _sloc in Pstr_extension (_1, add_docs_attrs docs _2) ) -# 41432 "parsing/parser.ml" +# 42152 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -41436,15 +42156,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 831 "parsing/parser.mly" +# 852 "parsing/parser.mly" ( mkstr ~loc:_sloc _1 ) -# 41442 "parsing/parser.ml" +# 42162 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41448 "parsing/parser.ml" +# 42168 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41468,23 +42188,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1275 "parsing/parser.mly" +# 1325 "parsing/parser.mly" ( Pstr_attribute _1 ) -# 41474 "parsing/parser.ml" +# 42194 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 831 "parsing/parser.mly" +# 852 "parsing/parser.mly" ( mkstr ~loc:_sloc _1 ) -# 41482 "parsing/parser.ml" +# 42202 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41488 "parsing/parser.ml" +# 42208 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41508,23 +42228,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1279 "parsing/parser.mly" +# 1329 "parsing/parser.mly" ( pstr_primitive _1 ) -# 41514 "parsing/parser.ml" +# 42234 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41522 "parsing/parser.ml" +# 42242 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41528 "parsing/parser.ml" +# 42248 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41548,23 +42268,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1281 "parsing/parser.mly" +# 1331 "parsing/parser.mly" ( pstr_primitive _1 ) -# 41554 "parsing/parser.ml" +# 42274 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41562 "parsing/parser.ml" +# 42282 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41568 "parsing/parser.ml" +# 42288 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41599,26 +42319,26 @@ module Tables = struct let _1 = let _1 = let _1 = -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 41605 "parsing/parser.ml" +# 42325 "parsing/parser.ml" in -# 2792 "parsing/parser.mly" +# 2842 "parsing/parser.mly" ( _1 ) -# 41610 "parsing/parser.ml" +# 42330 "parsing/parser.ml" in -# 2775 "parsing/parser.mly" +# 2825 "parsing/parser.mly" ( _1 ) -# 41616 "parsing/parser.ml" +# 42336 "parsing/parser.ml" in -# 1283 "parsing/parser.mly" +# 1333 "parsing/parser.mly" ( pstr_type _1 ) -# 41622 "parsing/parser.ml" +# 42342 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in @@ -41626,15 +42346,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41632 "parsing/parser.ml" +# 42352 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41638 "parsing/parser.ml" +# 42358 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41719,16 +42439,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 41725 "parsing/parser.ml" +# 42445 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let cs = -# 1015 "parsing/parser.mly" +# 1036 "parsing/parser.mly" ( List.rev xs ) -# 41732 "parsing/parser.ml" +# 42452 "parsing/parser.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in @@ -41736,46 +42456,46 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 41742 "parsing/parser.ml" +# 42462 "parsing/parser.ml" in let _4 = -# 3512 "parsing/parser.mly" +# 3574 "parsing/parser.mly" ( Recursive ) -# 41748 "parsing/parser.ml" +# 42468 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 41755 "parsing/parser.ml" +# 42475 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3029 "parsing/parser.mly" +# 3079 "parsing/parser.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 41767 "parsing/parser.ml" +# 42487 "parsing/parser.ml" in -# 3012 "parsing/parser.mly" +# 3062 "parsing/parser.mly" ( _1 ) -# 41773 "parsing/parser.ml" +# 42493 "parsing/parser.ml" in -# 1285 "parsing/parser.mly" +# 1335 "parsing/parser.mly" ( pstr_typext _1 ) -# 41779 "parsing/parser.ml" +# 42499 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -41783,15 +42503,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41789 "parsing/parser.ml" +# 42509 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41795 "parsing/parser.ml" +# 42515 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41883,16 +42603,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 41889 "parsing/parser.ml" +# 42609 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cs = -# 1015 "parsing/parser.mly" +# 1036 "parsing/parser.mly" ( List.rev xs ) -# 41896 "parsing/parser.ml" +# 42616 "parsing/parser.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in @@ -41900,9 +42620,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 41906 "parsing/parser.ml" +# 42626 "parsing/parser.ml" in let _4 = @@ -41911,41 +42631,41 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3513 "parsing/parser.mly" +# 3575 "parsing/parser.mly" ( not_expecting _loc "nonrec flag" ) -# 41917 "parsing/parser.ml" +# 42637 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 41925 "parsing/parser.ml" +# 42645 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3029 "parsing/parser.mly" +# 3079 "parsing/parser.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 41937 "parsing/parser.ml" +# 42657 "parsing/parser.ml" in -# 3012 "parsing/parser.mly" +# 3062 "parsing/parser.mly" ( _1 ) -# 41943 "parsing/parser.ml" +# 42663 "parsing/parser.ml" in -# 1285 "parsing/parser.mly" +# 1335 "parsing/parser.mly" ( pstr_typext _1 ) -# 41949 "parsing/parser.ml" +# 42669 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined4_ in @@ -41953,15 +42673,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41959 "parsing/parser.ml" +# 42679 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 41965 "parsing/parser.ml" +# 42685 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41985,23 +42705,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1287 "parsing/parser.mly" +# 1337 "parsing/parser.mly" ( pstr_exception _1 ) -# 41991 "parsing/parser.ml" +# 42711 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41999 "parsing/parser.ml" +# 42719 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42005 "parsing/parser.ml" +# 42725 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42064,9 +42784,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 42070 "parsing/parser.ml" +# 42790 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -42076,36 +42796,36 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42082 "parsing/parser.ml" +# 42802 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 42090 "parsing/parser.ml" +# 42810 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1313 "parsing/parser.mly" +# 1363 "parsing/parser.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 ) -# 42103 "parsing/parser.ml" +# 42823 "parsing/parser.ml" in -# 1289 "parsing/parser.mly" +# 1339 "parsing/parser.mly" ( _1 ) -# 42109 "parsing/parser.ml" +# 42829 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -42113,15 +42833,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42119 "parsing/parser.ml" +# 42839 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42125 "parsing/parser.ml" +# 42845 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42200,9 +42920,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 42206 "parsing/parser.ml" +# 42926 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -42212,24 +42932,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42218 "parsing/parser.ml" +# 42938 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 42226 "parsing/parser.ml" +# 42946 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1347 "parsing/parser.mly" +# 1397 "parsing/parser.mly" ( let loc = make_loc _sloc in let attrs = attrs1 @ attrs2 in @@ -42237,25 +42957,25 @@ module Tables = struct ext, Mb.mk name body ~attrs ~loc ~docs ) -# 42241 "parsing/parser.ml" +# 42961 "parsing/parser.ml" in -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 42247 "parsing/parser.ml" +# 42967 "parsing/parser.ml" in -# 1335 "parsing/parser.mly" +# 1385 "parsing/parser.mly" ( _1 ) -# 42253 "parsing/parser.ml" +# 42973 "parsing/parser.ml" in -# 1291 "parsing/parser.mly" +# 1341 "parsing/parser.mly" ( pstr_recmodule _1 ) -# 42259 "parsing/parser.ml" +# 42979 "parsing/parser.ml" in let _endpos__1_ = _endpos_bs_ in @@ -42263,15 +42983,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42269 "parsing/parser.ml" +# 42989 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42275 "parsing/parser.ml" +# 42995 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42295,23 +43015,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1293 "parsing/parser.mly" +# 1343 "parsing/parser.mly" ( let (body, ext) = _1 in (Pstr_modtype body, ext) ) -# 42301 "parsing/parser.ml" +# 43021 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42309 "parsing/parser.ml" +# 43029 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42315 "parsing/parser.ml" +# 43035 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42335,23 +43055,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1295 "parsing/parser.mly" +# 1345 "parsing/parser.mly" ( let (body, ext) = _1 in (Pstr_open body, ext) ) -# 42341 "parsing/parser.ml" +# 43061 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42349 "parsing/parser.ml" +# 43069 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42355 "parsing/parser.ml" +# 43075 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42421,9 +43141,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 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 42427 "parsing/parser.ml" +# 43147 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -42441,9 +43161,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 42447 "parsing/parser.ml" +# 43167 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -42453,24 +43173,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42459 "parsing/parser.ml" +# 43179 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 42467 "parsing/parser.ml" +# 43187 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1665 "parsing/parser.mly" +# 1715 "parsing/parser.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -42478,25 +43198,25 @@ module Tables = struct ext, Ci.mk id body ~virt ~params ~attrs ~loc ~docs ) -# 42482 "parsing/parser.ml" +# 43202 "parsing/parser.ml" in -# 1023 "parsing/parser.mly" +# 1044 "parsing/parser.mly" ( let (x, b) = a in x, b :: bs ) -# 42488 "parsing/parser.ml" +# 43208 "parsing/parser.ml" in -# 1654 "parsing/parser.mly" +# 1704 "parsing/parser.mly" ( _1 ) -# 42494 "parsing/parser.ml" +# 43214 "parsing/parser.ml" in -# 1297 "parsing/parser.mly" +# 1347 "parsing/parser.mly" ( let (ext, l) = _1 in (Pstr_class l, ext) ) -# 42500 "parsing/parser.ml" +# 43220 "parsing/parser.ml" in let _endpos__1_ = _endpos_bs_ in @@ -42504,15 +43224,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42510 "parsing/parser.ml" +# 43230 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42516 "parsing/parser.ml" +# 43236 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42536,23 +43256,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1299 "parsing/parser.mly" +# 1349 "parsing/parser.mly" ( let (ext, l) = _1 in (Pstr_class_type l, ext) ) -# 42542 "parsing/parser.ml" +# 43262 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42550 "parsing/parser.ml" +# 43270 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42556 "parsing/parser.ml" +# 43276 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42608,38 +43328,38 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 42614 "parsing/parser.ml" +# 43334 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 42623 "parsing/parser.ml" +# 43343 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1384 "parsing/parser.mly" +# 1434 "parsing/parser.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 ) -# 42637 "parsing/parser.ml" +# 43357 "parsing/parser.ml" in -# 1301 "parsing/parser.mly" +# 1351 "parsing/parser.mly" ( pstr_include _1 ) -# 42643 "parsing/parser.ml" +# 43363 "parsing/parser.ml" in let _endpos__1_ = _endpos__1_inlined2_ in @@ -42647,15 +43367,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 848 "parsing/parser.mly" +# 869 "parsing/parser.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 42653 "parsing/parser.ml" +# 43373 "parsing/parser.ml" in -# 1303 "parsing/parser.mly" +# 1353 "parsing/parser.mly" ( _1 ) -# 42659 "parsing/parser.ml" +# 43379 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42678,9 +43398,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3575 "parsing/parser.mly" +# 3637 "parsing/parser.mly" ( "-" ) -# 42684 "parsing/parser.ml" +# 43404 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42703,9 +43423,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3576 "parsing/parser.mly" +# 3638 "parsing/parser.mly" ( "-." ) -# 42709 "parsing/parser.ml" +# 43429 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42758,29 +43478,29 @@ module Tables = struct let _v : (Parsetree.row_field) = let _5 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 42764 "parsing/parser.ml" +# 43484 "parsing/parser.ml" in let _endpos__5_ = _endpos__1_inlined1_ in let _4 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 42773 "parsing/parser.ml" +# 43493 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 42778 "parsing/parser.ml" +# 43498 "parsing/parser.ml" in -# 3299 "parsing/parser.mly" +# 3349 "parsing/parser.mly" ( _1 ) -# 42784 "parsing/parser.ml" +# 43504 "parsing/parser.ml" in let _1 = @@ -42788,20 +43508,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42794 "parsing/parser.ml" +# 43514 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3285 "parsing/parser.mly" +# 3335 "parsing/parser.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 ) -# 42805 "parsing/parser.ml" +# 43525 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42833,9 +43553,9 @@ module Tables = struct let _v : (Parsetree.row_field) = let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 42839 "parsing/parser.ml" +# 43559 "parsing/parser.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -42844,20 +43564,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42850 "parsing/parser.ml" +# 43570 "parsing/parser.ml" in let _endpos = _endpos__2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3289 "parsing/parser.mly" +# 3339 "parsing/parser.mly" ( let info = symbol_info _endpos in let attrs = add_info_attrs info _2 in Rf.tag ~loc:(make_loc _sloc) ~attrs _1 true [] ) -# 42861 "parsing/parser.ml" +# 43581 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42887,9 +43607,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.toplevel_phrase) = let arg = -# 124 "menhir/standard.mly" +# 124 "" ( None ) -# 42893 "parsing/parser.ml" +# 43613 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined1_ in let dir = @@ -42898,18 +43618,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42904 "parsing/parser.ml" +# 43624 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42913 "parsing/parser.ml" +# 43633 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42940,9 +43660,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : ( -# 680 "parsing/parser.mly" - (string * string option) -# 42946 "parsing/parser.ml" +# 685 "parsing/parser.mly" + (string * Location.t * string option) +# 43666 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in @@ -42953,23 +43673,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3479 "parsing/parser.mly" - ( let (s, _) = _1 in Pdir_string s ) -# 42959 "parsing/parser.ml" +# 3541 "parsing/parser.mly" + ( let (s, _, _) = _1 in Pdir_string s ) +# 43679 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 853 "parsing/parser.mly" +# 874 "parsing/parser.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42967 "parsing/parser.ml" +# 43687 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 42973 "parsing/parser.ml" +# 43693 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42979,18 +43699,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 42985 "parsing/parser.ml" +# 43705 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42994 "parsing/parser.ml" +# 43714 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43021,9 +43741,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : ( -# 628 "parsing/parser.mly" +# 633 "parsing/parser.mly" (string * char option) -# 43027 "parsing/parser.ml" +# 43747 "parsing/parser.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in @@ -43034,23 +43754,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3480 "parsing/parser.mly" +# 3542 "parsing/parser.mly" ( let (n, m) = _1 in Pdir_int (n ,m) ) -# 43040 "parsing/parser.ml" +# 43760 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 853 "parsing/parser.mly" +# 874 "parsing/parser.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 43048 "parsing/parser.ml" +# 43768 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 43054 "parsing/parser.ml" +# 43774 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -43060,18 +43780,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 43066 "parsing/parser.ml" +# 43786 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 43075 "parsing/parser.ml" +# 43795 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43111,23 +43831,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3481 "parsing/parser.mly" +# 3543 "parsing/parser.mly" ( Pdir_ident _1 ) -# 43117 "parsing/parser.ml" +# 43837 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 853 "parsing/parser.mly" +# 874 "parsing/parser.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 43125 "parsing/parser.ml" +# 43845 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 43131 "parsing/parser.ml" +# 43851 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -43137,18 +43857,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 43143 "parsing/parser.ml" +# 43863 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 43152 "parsing/parser.ml" +# 43872 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43188,23 +43908,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3482 "parsing/parser.mly" +# 3544 "parsing/parser.mly" ( Pdir_ident _1 ) -# 43194 "parsing/parser.ml" +# 43914 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 853 "parsing/parser.mly" +# 874 "parsing/parser.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 43202 "parsing/parser.ml" +# 43922 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 43208 "parsing/parser.ml" +# 43928 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -43214,18 +43934,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 43220 "parsing/parser.ml" +# 43940 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 43229 "parsing/parser.ml" +# 43949 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43265,23 +43985,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3483 "parsing/parser.mly" +# 3545 "parsing/parser.mly" ( Pdir_bool false ) -# 43271 "parsing/parser.ml" +# 43991 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 853 "parsing/parser.mly" +# 874 "parsing/parser.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 43279 "parsing/parser.ml" +# 43999 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 43285 "parsing/parser.ml" +# 44005 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -43291,18 +44011,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 43297 "parsing/parser.ml" +# 44017 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 43306 "parsing/parser.ml" +# 44026 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43342,23 +44062,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3484 "parsing/parser.mly" +# 3546 "parsing/parser.mly" ( Pdir_bool true ) -# 43348 "parsing/parser.ml" +# 44068 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 853 "parsing/parser.mly" +# 874 "parsing/parser.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 43356 "parsing/parser.ml" +# 44076 "parsing/parser.ml" in -# 126 "menhir/standard.mly" +# 126 "" ( Some x ) -# 43362 "parsing/parser.ml" +# 44082 "parsing/parser.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -43368,18 +44088,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 43374 "parsing/parser.ml" +# 44094 "parsing/parser.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3475 "parsing/parser.mly" +# 3537 "parsing/parser.mly" ( mk_directive ~loc:_sloc dir arg ) -# 43383 "parsing/parser.ml" +# 44103 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43416,44 +44136,44 @@ module Tables = struct let _startpos = _startpos_e_ in let _endpos = _endpos__2_ in let _v : ( -# 772 "parsing/parser.mly" +# 781 "parsing/parser.mly" (Parsetree.toplevel_phrase) -# 43422 "parsing/parser.ml" +# 44142 "parsing/parser.ml" ) = let _1 = let _1 = let _1 = let attrs = -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 43429 "parsing/parser.ml" +# 44149 "parsing/parser.ml" in -# 1254 "parsing/parser.mly" +# 1304 "parsing/parser.mly" ( mkstrexp e attrs ) -# 43434 "parsing/parser.ml" +# 44154 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 796 "parsing/parser.mly" +# 817 "parsing/parser.mly" ( text_str _startpos @ [_1] ) -# 43442 "parsing/parser.ml" +# 44162 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 784 "parsing/parser.mly" +# 805 "parsing/parser.mly" ( extra_str _startpos _endpos _1 ) -# 43451 "parsing/parser.ml" +# 44171 "parsing/parser.ml" in -# 1061 "parsing/parser.mly" +# 1082 "parsing/parser.mly" ( Ptop_def _1 ) -# 43457 "parsing/parser.ml" +# 44177 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43483,28 +44203,28 @@ module Tables = struct let _startpos = _startpos_xss_ in let _endpos = _endpos__2_ in let _v : ( -# 772 "parsing/parser.mly" +# 781 "parsing/parser.mly" (Parsetree.toplevel_phrase) -# 43489 "parsing/parser.ml" +# 44209 "parsing/parser.ml" ) = let _1 = let _1 = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 43494 "parsing/parser.ml" +# 44214 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 784 "parsing/parser.mly" +# 805 "parsing/parser.mly" ( extra_str _startpos _endpos _1 ) -# 43502 "parsing/parser.ml" +# 44222 "parsing/parser.ml" in -# 1065 "parsing/parser.mly" +# 1086 "parsing/parser.mly" ( Ptop_def _1 ) -# 43508 "parsing/parser.ml" +# 44228 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43534,13 +44254,13 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 772 "parsing/parser.mly" +# 781 "parsing/parser.mly" (Parsetree.toplevel_phrase) -# 43540 "parsing/parser.ml" +# 44260 "parsing/parser.ml" ) = -# 1069 "parsing/parser.mly" +# 1090 "parsing/parser.mly" ( _1 ) -# 43544 "parsing/parser.ml" +# 44264 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43563,13 +44283,13 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : ( -# 772 "parsing/parser.mly" +# 781 "parsing/parser.mly" (Parsetree.toplevel_phrase) -# 43569 "parsing/parser.ml" +# 44289 "parsing/parser.ml" ) = -# 1072 "parsing/parser.mly" +# 1093 "parsing/parser.mly" ( raise End_of_file ) -# 43573 "parsing/parser.ml" +# 44293 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43592,9 +44312,9 @@ module Tables = struct let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : (Parsetree.core_type) = -# 3191 "parsing/parser.mly" +# 3241 "parsing/parser.mly" ( ty ) -# 43598 "parsing/parser.ml" +# 44318 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43620,20 +44340,20 @@ module Tables = struct let _1 = let tys = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 43626 "parsing/parser.ml" +# 44346 "parsing/parser.ml" in -# 954 "parsing/parser.mly" +# 975 "parsing/parser.mly" ( xs ) -# 43631 "parsing/parser.ml" +# 44351 "parsing/parser.ml" in -# 3194 "parsing/parser.mly" +# 3244 "parsing/parser.mly" ( Ptyp_tuple tys ) -# 43637 "parsing/parser.ml" +# 44357 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in @@ -43641,15 +44361,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 43647 "parsing/parser.ml" +# 44367 "parsing/parser.ml" in -# 3196 "parsing/parser.mly" +# 3246 "parsing/parser.mly" ( _1 ) -# 43653 "parsing/parser.ml" +# 44373 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43679,9 +44399,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2539 "parsing/parser.mly" +# 2589 "parsing/parser.mly" ( (Some _2, None) ) -# 43685 "parsing/parser.ml" +# 44405 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43725,9 +44445,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2540 "parsing/parser.mly" +# 2590 "parsing/parser.mly" ( (Some _2, Some _4) ) -# 43731 "parsing/parser.ml" +# 44451 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43757,9 +44477,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2541 "parsing/parser.mly" +# 2591 "parsing/parser.mly" ( (None, Some _2) ) -# 43763 "parsing/parser.ml" +# 44483 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43789,9 +44509,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2542 "parsing/parser.mly" +# 2592 "parsing/parser.mly" ( syntax_error() ) -# 43795 "parsing/parser.ml" +# 44515 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43821,9 +44541,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2543 "parsing/parser.mly" +# 2593 "parsing/parser.mly" ( syntax_error() ) -# 43827 "parsing/parser.ml" +# 44547 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43839,9 +44559,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) = -# 2866 "parsing/parser.mly" +# 2916 "parsing/parser.mly" ( (Ptype_abstract, Public, None) ) -# 43845 "parsing/parser.ml" +# 44565 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43871,9 +44591,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) = -# 2868 "parsing/parser.mly" +# 2918 "parsing/parser.mly" ( _2 ) -# 43877 "parsing/parser.ml" +# 44597 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43891,61 +44611,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : ( -# 642 "parsing/parser.mly" - (string) -# 43898 "parsing/parser.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) = -# 3442 "parsing/parser.mly" - ( Lident _1 ) -# 43906 "parsing/parser.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 : ( -# 642 "parsing/parser.mly" - (string) -# 43939 "parsing/parser.ml" - ) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3443 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 43949 "parsing/parser.ml" +# 3500 "parsing/parser.mly" + ( _1 ) +# 44622 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43975,9 +44648,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type * Asttypes.variance) = -# 2883 "parsing/parser.mly" +# 2933 "parsing/parser.mly" ( _2, _1 ) -# 43981 "parsing/parser.ml" +# 44654 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43993,9 +44666,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : ((Parsetree.core_type * Asttypes.variance) list) = -# 2876 "parsing/parser.mly" +# 2926 "parsing/parser.mly" ( [] ) -# 43999 "parsing/parser.ml" +# 44672 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44018,9 +44691,9 @@ module Tables = struct let _startpos = _startpos_p_ in let _endpos = _endpos_p_ in let _v : ((Parsetree.core_type * Asttypes.variance) list) = -# 2878 "parsing/parser.mly" +# 2928 "parsing/parser.mly" ( [p] ) -# 44024 "parsing/parser.ml" +# 44697 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44058,20 +44731,20 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : ((Parsetree.core_type * Asttypes.variance) list) = let ps = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 44064 "parsing/parser.ml" +# 44737 "parsing/parser.ml" in -# 926 "parsing/parser.mly" +# 947 "parsing/parser.mly" ( xs ) -# 44069 "parsing/parser.ml" +# 44742 "parsing/parser.ml" in -# 2880 "parsing/parser.mly" +# 2930 "parsing/parser.mly" ( ps ) -# 44075 "parsing/parser.ml" +# 44748 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44102,24 +44775,24 @@ module Tables = struct let _endpos = _endpos_tyvar_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 2888 "parsing/parser.mly" +# 2938 "parsing/parser.mly" ( Ptyp_var tyvar ) -# 44108 "parsing/parser.ml" +# 44781 "parsing/parser.ml" in let _endpos__1_ = _endpos_tyvar_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 44117 "parsing/parser.ml" +# 44790 "parsing/parser.ml" in -# 2891 "parsing/parser.mly" +# 2941 "parsing/parser.mly" ( _1 ) -# 44123 "parsing/parser.ml" +# 44796 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44143,23 +44816,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 2890 "parsing/parser.mly" +# 2940 "parsing/parser.mly" ( Ptyp_any ) -# 44149 "parsing/parser.ml" +# 44822 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 829 "parsing/parser.mly" +# 850 "parsing/parser.mly" ( mktyp ~loc:_sloc _1 ) -# 44157 "parsing/parser.ml" +# 44830 "parsing/parser.ml" in -# 2891 "parsing/parser.mly" +# 2941 "parsing/parser.mly" ( _1 ) -# 44163 "parsing/parser.ml" +# 44836 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44175,9 +44848,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.variance) = -# 2895 "parsing/parser.mly" +# 2945 "parsing/parser.mly" ( Invariant ) -# 44181 "parsing/parser.ml" +# 44854 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44200,9 +44873,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance) = -# 2896 "parsing/parser.mly" +# 2946 "parsing/parser.mly" ( Covariant ) -# 44206 "parsing/parser.ml" +# 44879 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44225,9 +44898,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance) = -# 2897 "parsing/parser.mly" +# 2947 "parsing/parser.mly" ( Contravariant ) -# 44231 "parsing/parser.ml" +# 44904 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44257,47 +44930,47 @@ module Tables = struct let _startpos = _startpos_xss_ in let _endpos = _endpos__2_ in let _v : ( -# 774 "parsing/parser.mly" +# 783 "parsing/parser.mly" (Parsetree.toplevel_phrase list) -# 44263 "parsing/parser.ml" +# 44936 "parsing/parser.ml" ) = let _1 = let _1 = let ys = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 44269 "parsing/parser.ml" +# 44942 "parsing/parser.ml" in let xs = let _1 = -# 862 "parsing/parser.mly" +# 883 "parsing/parser.mly" ( [] ) -# 44275 "parsing/parser.ml" +# 44948 "parsing/parser.ml" in -# 1092 "parsing/parser.mly" +# 1113 "parsing/parser.mly" ( _1 ) -# 44280 "parsing/parser.ml" +# 44953 "parsing/parser.ml" in -# 267 "menhir/standard.mly" +# 267 "" ( xs @ ys ) -# 44286 "parsing/parser.ml" +# 44959 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 788 "parsing/parser.mly" +# 809 "parsing/parser.mly" ( extra_def _startpos _endpos _1 ) -# 44295 "parsing/parser.ml" +# 44968 "parsing/parser.ml" in -# 1085 "parsing/parser.mly" +# 1106 "parsing/parser.mly" ( _1 ) -# 44301 "parsing/parser.ml" +# 44974 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44341,15 +45014,15 @@ module Tables = struct let _startpos = _startpos_e_ in let _endpos = _endpos__2_ in let _v : ( -# 774 "parsing/parser.mly" +# 783 "parsing/parser.mly" (Parsetree.toplevel_phrase list) -# 44347 "parsing/parser.ml" +# 45020 "parsing/parser.ml" ) = let _1 = let _1 = let ys = -# 260 "menhir/standard.mly" +# 260 "" ( List.flatten xss ) -# 44353 "parsing/parser.ml" +# 45026 "parsing/parser.ml" in let xs = let _1 = @@ -44357,90 +45030,61 @@ module Tables = struct let _1 = let _1 = let attrs = -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 44363 "parsing/parser.ml" +# 45036 "parsing/parser.ml" in -# 1254 "parsing/parser.mly" +# 1304 "parsing/parser.mly" ( mkstrexp e attrs ) -# 44368 "parsing/parser.ml" +# 45041 "parsing/parser.ml" in -# 806 "parsing/parser.mly" +# 827 "parsing/parser.mly" ( Ptop_def [_1] ) -# 44374 "parsing/parser.ml" +# 45047 "parsing/parser.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 804 "parsing/parser.mly" +# 825 "parsing/parser.mly" ( text_def _startpos @ [_1] ) -# 44382 "parsing/parser.ml" +# 45055 "parsing/parser.ml" in -# 864 "parsing/parser.mly" +# 885 "parsing/parser.mly" ( x ) -# 44388 "parsing/parser.ml" +# 45061 "parsing/parser.ml" in -# 1092 "parsing/parser.mly" +# 1113 "parsing/parser.mly" ( _1 ) -# 44394 "parsing/parser.ml" +# 45067 "parsing/parser.ml" in -# 267 "menhir/standard.mly" +# 267 "" ( xs @ ys ) -# 44400 "parsing/parser.ml" +# 45073 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 788 "parsing/parser.mly" +# 809 "parsing/parser.mly" ( extra_def _startpos _endpos _1 ) -# 44409 "parsing/parser.ml" +# 45082 "parsing/parser.ml" in -# 1085 "parsing/parser.mly" +# 1106 "parsing/parser.mly" ( _1 ) -# 44415 "parsing/parser.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 : ( -# 642 "parsing/parser.mly" - (string) -# 44436 "parsing/parser.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) = -# 3369 "parsing/parser.mly" - ( _1 ) -# 44444 "parsing/parser.ml" +# 45088 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44471,15 +45115,15 @@ module Tables = struct }; } = _menhir_stack in let _3 : unit = Obj.magic _3 in - let _2 : (string) = Obj.magic _2 in + let _2 : (Asttypes.label) = 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) = -# 3370 "parsing/parser.mly" + let _v : (Asttypes.label) = +# 3419 "parsing/parser.mly" ( _2 ) -# 44483 "parsing/parser.ml" +# 45127 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44510,17 +45154,17 @@ module Tables = struct }; } = _menhir_stack in let _3 : unit = Obj.magic _3 in - let _2 : (string) = Obj.magic _2 in + let _2 : (Asttypes.label) = 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) = let _loc__3_ = (_startpos__3_, _endpos__3_) in + let _v : (Asttypes.label) = let _loc__3_ = (_startpos__3_, _endpos__3_) in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 3371 "parsing/parser.mly" +# 3420 "parsing/parser.mly" ( unclosed "(" _loc__1_ ")" _loc__3_ ) -# 44524 "parsing/parser.ml" +# 45168 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44549,11 +45193,11 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (string) = let _loc__2_ = (_startpos__2_, _endpos__2_) in + let _v : (Asttypes.label) = let _loc__2_ = (_startpos__2_, _endpos__2_) in -# 3372 "parsing/parser.mly" +# 3421 "parsing/parser.mly" ( expecting _loc__2_ "operator" ) -# 44557 "parsing/parser.ml" +# 45201 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44589,11 +45233,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 : (string) = let _loc__3_ = (_startpos__3_, _endpos__3_) in + let _v : (Asttypes.label) = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 3373 "parsing/parser.mly" +# 3422 "parsing/parser.mly" ( expecting _loc__3_ "module-expr" ) -# 44597 "parsing/parser.ml" +# 45241 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44611,14 +45255,18 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : (string) = Obj.magic _1 in + let _1 : ( +# 647 "parsing/parser.mly" + (string) +# 45262 "parsing/parser.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) = + let _v : (Asttypes.label) = # 3425 "parsing/parser.mly" - ( Lident _1 ) -# 44622 "parsing/parser.ml" + ( _1 ) +# 45270 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44630,34 +45278,45 @@ module Tables = struct (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; - }; - }; + 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 : (Asttypes.label) = 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.label) = +# 3426 "parsing/parser.mly" + ( _1 ) +# 45295 "parsing/parser.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 _3 : (string) = Obj.magic _3 in - let _2 : unit = 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__3_ in + let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3426 "parsing/parser.mly" - ( Ldot(_1, _3) ) -# 44661 "parsing/parser.ml" +# 3494 "parsing/parser.mly" + ( _1 ) +# 45320 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44702,9 +45361,9 @@ module Tables = struct let ty : (Parsetree.core_type) = Obj.magic ty in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 44708 "parsing/parser.ml" +# 45367 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let mutable_ : (Asttypes.mutable_flag) = Obj.magic mutable_ in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -44716,33 +45375,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 44722 "parsing/parser.ml" +# 45381 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 44730 "parsing/parser.ml" +# 45389 "parsing/parser.ml" in let attrs = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 44736 "parsing/parser.ml" +# 45395 "parsing/parser.ml" in let _1 = -# 3568 "parsing/parser.mly" +# 3630 "parsing/parser.mly" ( Fresh ) -# 44741 "parsing/parser.ml" +# 45400 "parsing/parser.ml" in -# 1805 "parsing/parser.mly" +# 1855 "parsing/parser.mly" ( (label, mutable_, Cfk_virtual ty), attrs ) -# 44746 "parsing/parser.ml" +# 45405 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44787,9 +45446,9 @@ module Tables = struct let _6 : (Parsetree.expression) = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 44793 "parsing/parser.ml" +# 45452 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -44801,33 +45460,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 44807 "parsing/parser.ml" +# 45466 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 44815 "parsing/parser.ml" +# 45474 "parsing/parser.ml" in let _2 = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 44821 "parsing/parser.ml" +# 45480 "parsing/parser.ml" in let _1 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 44826 "parsing/parser.ml" +# 45485 "parsing/parser.ml" in -# 1807 "parsing/parser.mly" +# 1857 "parsing/parser.mly" ( (_4, _3, Cfk_concrete (_1, _6)), _2 ) -# 44831 "parsing/parser.ml" +# 45490 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44878,9 +45537,9 @@ module Tables = struct let _6 : (Parsetree.expression) = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 44884 "parsing/parser.ml" +# 45543 "parsing/parser.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 @@ -44893,36 +45552,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 44899 "parsing/parser.ml" +# 45558 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 44907 "parsing/parser.ml" +# 45566 "parsing/parser.ml" in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 44915 "parsing/parser.ml" +# 45574 "parsing/parser.ml" in let _1 = -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 44921 "parsing/parser.ml" +# 45580 "parsing/parser.ml" in -# 1807 "parsing/parser.mly" +# 1857 "parsing/parser.mly" ( (_4, _3, Cfk_concrete (_1, _6)), _2 ) -# 44926 "parsing/parser.ml" +# 45585 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44974,9 +45633,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in let _1_inlined1 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 44980 "parsing/parser.ml" +# 45639 "parsing/parser.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -44988,30 +45647,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 44994 "parsing/parser.ml" +# 45653 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45002 "parsing/parser.ml" +# 45661 "parsing/parser.ml" in let _startpos__4_ = _startpos__1_inlined1_ in let _2 = -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 45009 "parsing/parser.ml" +# 45668 "parsing/parser.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in let _1 = -# 3571 "parsing/parser.mly" +# 3633 "parsing/parser.mly" ( Fresh ) -# 45015 "parsing/parser.ml" +# 45674 "parsing/parser.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in let _endpos = _endpos__7_ in @@ -45027,11 +45686,11 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 1810 "parsing/parser.mly" +# 1860 "parsing/parser.mly" ( let e = mkexp_constraint ~loc:_sloc _7 _5 in (_4, _3, Cfk_concrete (_1, e)), _2 ) -# 45035 "parsing/parser.ml" +# 45694 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45089,9 +45748,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in let _1_inlined2 : ( -# 642 "parsing/parser.mly" +# 647 "parsing/parser.mly" (string) -# 45095 "parsing/parser.ml" +# 45754 "parsing/parser.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 @@ -45104,33 +45763,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 = -# 3343 "parsing/parser.mly" +# 3393 "parsing/parser.mly" ( _1 ) -# 45110 "parsing/parser.ml" +# 45769 "parsing/parser.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45118 "parsing/parser.ml" +# 45777 "parsing/parser.ml" in let _startpos__4_ = _startpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 45127 "parsing/parser.ml" +# 45786 "parsing/parser.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in let _1 = -# 3572 "parsing/parser.mly" +# 3634 "parsing/parser.mly" ( Override ) -# 45134 "parsing/parser.ml" +# 45793 "parsing/parser.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = if _startpos__1_ != _endpos__1_ then @@ -45145,11 +45804,11 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 1810 "parsing/parser.mly" +# 1860 "parsing/parser.mly" ( let e = mkexp_constraint ~loc:_sloc _7 _5 in (_4, _3, Cfk_concrete (_1, e)), _2 ) -# 45153 "parsing/parser.ml" +# 45812 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45206,7 +45865,7 @@ module Tables = struct let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in let ty : (Parsetree.core_type) = Obj.magic ty in let _5 : unit = Obj.magic _5 in - let _1_inlined2 : (string) = Obj.magic _1_inlined2 in + let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Asttypes.loc option) = Obj.magic ext in let _1 : unit = Obj.magic _1 in @@ -45216,9 +45875,9 @@ module Tables = struct let _v : (Parsetree.value_description * string Asttypes.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 3665 "parsing/parser.mly" +# 3727 "parsing/parser.mly" ( _1 ) -# 45222 "parsing/parser.ml" +# 45881 "parsing/parser.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -45228,30 +45887,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45234 "parsing/parser.ml" +# 45893 "parsing/parser.ml" in let attrs1 = let _1 = _1_inlined1 in -# 3669 "parsing/parser.mly" +# 3731 "parsing/parser.mly" ( _1 ) -# 45242 "parsing/parser.ml" +# 45901 "parsing/parser.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2737 "parsing/parser.mly" +# 2787 "parsing/parser.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 ) -# 45255 "parsing/parser.ml" +# 45914 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45267,9 +45926,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.virtual_flag) = -# 3532 "parsing/parser.mly" +# 3594 "parsing/parser.mly" ( Concrete ) -# 45273 "parsing/parser.ml" +# 45932 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45292,9 +45951,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.virtual_flag) = -# 3533 "parsing/parser.mly" +# 3595 "parsing/parser.mly" ( Virtual ) -# 45298 "parsing/parser.ml" +# 45957 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45317,9 +45976,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag) = -# 3556 "parsing/parser.mly" +# 3618 "parsing/parser.mly" ( Immutable ) -# 45323 "parsing/parser.ml" +# 45982 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45349,9 +46008,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag) = -# 3557 "parsing/parser.mly" +# 3619 "parsing/parser.mly" ( Mutable ) -# 45355 "parsing/parser.ml" +# 46014 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45381,9 +46040,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag) = -# 3558 "parsing/parser.mly" +# 3620 "parsing/parser.mly" ( Mutable ) -# 45387 "parsing/parser.ml" +# 46046 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45406,9 +46065,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag) = -# 3563 "parsing/parser.mly" +# 3625 "parsing/parser.mly" ( Public ) -# 45412 "parsing/parser.ml" +# 46071 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45438,9 +46097,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag) = -# 3564 "parsing/parser.mly" +# 3626 "parsing/parser.mly" ( Private ) -# 45444 "parsing/parser.ml" +# 46103 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45470,9 +46129,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag) = -# 3565 "parsing/parser.mly" +# 3627 "parsing/parser.mly" ( Private ) -# 45476 "parsing/parser.ml" +# 46135 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45532,29 +46191,29 @@ module Tables = struct let _v : (Parsetree.with_constraint) = let _6 = let _1 = let xs = -# 253 "menhir/standard.mly" +# 253 "" ( List.rev xs ) -# 45538 "parsing/parser.ml" +# 46197 "parsing/parser.ml" in -# 876 "parsing/parser.mly" +# 897 "parsing/parser.mly" ( xs ) -# 45543 "parsing/parser.ml" +# 46202 "parsing/parser.ml" in -# 2837 "parsing/parser.mly" +# 2887 "parsing/parser.mly" ( _1 ) -# 45549 "parsing/parser.ml" +# 46208 "parsing/parser.ml" in let _endpos__6_ = _endpos_xs_ in let _5 = let _1 = _1_inlined2 in -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 45558 "parsing/parser.ml" +# 46217 "parsing/parser.ml" in let _3 = @@ -45563,16 +46222,16 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45569 "parsing/parser.ml" +# 46228 "parsing/parser.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3062 "parsing/parser.mly" +# 3112 "parsing/parser.mly" ( let lident = loc_last _3 in Pwith_type (_3, @@ -45582,7 +46241,7 @@ module Tables = struct ~manifest:_5 ~priv:_4 ~loc:(make_loc _sloc))) ) -# 45586 "parsing/parser.ml" +# 46245 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45635,9 +46294,9 @@ module Tables = struct let _v : (Parsetree.with_constraint) = let _5 = let _1 = _1_inlined2 in -# 3139 "parsing/parser.mly" +# 3189 "parsing/parser.mly" ( _1 ) -# 45641 "parsing/parser.ml" +# 46300 "parsing/parser.ml" in let _endpos__5_ = _endpos__1_inlined2_ in @@ -45647,16 +46306,16 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45653 "parsing/parser.ml" +# 46312 "parsing/parser.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3075 "parsing/parser.mly" +# 3125 "parsing/parser.mly" ( let lident = loc_last _3 in Pwith_typesubst (_3, @@ -45664,7 +46323,7 @@ module Tables = struct ~params:_2 ~manifest:_5 ~loc:(make_loc _sloc))) ) -# 45668 "parsing/parser.ml" +# 46327 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45713,9 +46372,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45719 "parsing/parser.ml" +# 46378 "parsing/parser.ml" in let _2 = @@ -45724,15 +46383,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45730 "parsing/parser.ml" +# 46389 "parsing/parser.ml" in -# 3083 "parsing/parser.mly" +# 3133 "parsing/parser.mly" ( Pwith_module (_2, _4) ) -# 45736 "parsing/parser.ml" +# 46395 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45781,9 +46440,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45787 "parsing/parser.ml" +# 46446 "parsing/parser.ml" in let _2 = @@ -45792,15 +46451,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 792 "parsing/parser.mly" +# 813 "parsing/parser.mly" ( mkrhs _1 _sloc ) -# 45798 "parsing/parser.ml" +# 46457 "parsing/parser.ml" in -# 3085 "parsing/parser.mly" +# 3135 "parsing/parser.mly" ( Pwith_modsubst (_2, _4) ) -# 45804 "parsing/parser.ml" +# 46463 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45823,9 +46482,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag) = -# 3088 "parsing/parser.mly" +# 3138 "parsing/parser.mly" ( Public ) -# 45829 "parsing/parser.ml" +# 46488 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45855,9 +46514,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag) = -# 3089 "parsing/parser.mly" +# 3139 "parsing/parser.mly" ( Private ) -# 45861 "parsing/parser.ml" +# 46520 "parsing/parser.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45885,126 +46544,222 @@ end let use_file = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1765 lexer lexbuf) : ( -# 774 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.entry 1802 lexer lexbuf) : ( +# 783 "parsing/parser.mly" (Parsetree.toplevel_phrase list) -# 45892 "parsing/parser.ml" +# 46551 "parsing/parser.ml" )) and toplevel_phrase = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1744 lexer lexbuf) : ( -# 772 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.entry 1782 lexer lexbuf) : ( +# 781 "parsing/parser.mly" (Parsetree.toplevel_phrase) -# 45900 "parsing/parser.ml" +# 46559 "parsing/parser.ml" + )) + +and parse_val_longident = + fun lexer lexbuf -> + (Obj.magic (MenhirInterpreter.entry 1776 lexer lexbuf) : ( +# 793 "parsing/parser.mly" + (Longident.t) +# 46567 "parsing/parser.ml" )) and parse_pattern = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1740 lexer lexbuf) : ( -# 780 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.entry 1772 lexer lexbuf) : ( +# 789 "parsing/parser.mly" (Parsetree.pattern) -# 45908 "parsing/parser.ml" +# 46575 "parsing/parser.ml" + )) + +and parse_mty_longident = + fun lexer lexbuf -> + (Obj.magic (MenhirInterpreter.entry 1768 lexer lexbuf) : ( +# 795 "parsing/parser.mly" + (Longident.t) +# 46583 "parsing/parser.ml" + )) + +and parse_mod_longident = + fun lexer lexbuf -> + (Obj.magic (MenhirInterpreter.entry 1764 lexer lexbuf) : ( +# 799 "parsing/parser.mly" + (Longident.t) +# 46591 "parsing/parser.ml" + )) + +and parse_mod_ext_longident = + fun lexer lexbuf -> + (Obj.magic (MenhirInterpreter.entry 1760 lexer lexbuf) : ( +# 797 "parsing/parser.mly" + (Longident.t) +# 46599 "parsing/parser.ml" )) and parse_expression = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1736 lexer lexbuf) : ( -# 778 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.entry 1756 lexer lexbuf) : ( +# 787 "parsing/parser.mly" (Parsetree.expression) -# 45916 "parsing/parser.ml" +# 46607 "parsing/parser.ml" )) and parse_core_type = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1732 lexer lexbuf) : ( -# 776 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.entry 1752 lexer lexbuf) : ( +# 785 "parsing/parser.mly" (Parsetree.core_type) -# 45924 "parsing/parser.ml" +# 46615 "parsing/parser.ml" + )) + +and parse_constr_longident = + fun lexer lexbuf -> + (Obj.magic (MenhirInterpreter.entry 1748 lexer lexbuf) : ( +# 791 "parsing/parser.mly" + (Longident.t) +# 46623 "parsing/parser.ml" + )) + +and parse_any_longident = + fun lexer lexbuf -> + (Obj.magic (MenhirInterpreter.entry 1730 lexer lexbuf) : ( +# 801 "parsing/parser.mly" + (Longident.t) +# 46631 "parsing/parser.ml" )) and interface = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1728 lexer lexbuf) : ( -# 770 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.entry 1726 lexer lexbuf) : ( +# 779 "parsing/parser.mly" (Parsetree.signature) -# 45932 "parsing/parser.ml" +# 46639 "parsing/parser.ml" )) and implementation = fun lexer lexbuf -> (Obj.magic (MenhirInterpreter.entry 0 lexer lexbuf) : ( -# 768 "parsing/parser.mly" +# 777 "parsing/parser.mly" (Parsetree.structure) -# 45940 "parsing/parser.ml" +# 46647 "parsing/parser.ml" )) module Incremental = struct let use_file = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1765 initial_position) : ( -# 774 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.start 1802 initial_position) : ( +# 783 "parsing/parser.mly" (Parsetree.toplevel_phrase list) -# 45950 "parsing/parser.ml" +# 46657 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) and toplevel_phrase = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1744 initial_position) : ( -# 772 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.start 1782 initial_position) : ( +# 781 "parsing/parser.mly" (Parsetree.toplevel_phrase) -# 45958 "parsing/parser.ml" +# 46665 "parsing/parser.ml" + ) MenhirInterpreter.checkpoint) + + and parse_val_longident = + fun initial_position -> + (Obj.magic (MenhirInterpreter.start 1776 initial_position) : ( +# 793 "parsing/parser.mly" + (Longident.t) +# 46673 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) and parse_pattern = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1740 initial_position) : ( -# 780 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.start 1772 initial_position) : ( +# 789 "parsing/parser.mly" (Parsetree.pattern) -# 45966 "parsing/parser.ml" +# 46681 "parsing/parser.ml" + ) MenhirInterpreter.checkpoint) + + and parse_mty_longident = + fun initial_position -> + (Obj.magic (MenhirInterpreter.start 1768 initial_position) : ( +# 795 "parsing/parser.mly" + (Longident.t) +# 46689 "parsing/parser.ml" + ) MenhirInterpreter.checkpoint) + + and parse_mod_longident = + fun initial_position -> + (Obj.magic (MenhirInterpreter.start 1764 initial_position) : ( +# 799 "parsing/parser.mly" + (Longident.t) +# 46697 "parsing/parser.ml" + ) MenhirInterpreter.checkpoint) + + and parse_mod_ext_longident = + fun initial_position -> + (Obj.magic (MenhirInterpreter.start 1760 initial_position) : ( +# 797 "parsing/parser.mly" + (Longident.t) +# 46705 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) and parse_expression = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1736 initial_position) : ( -# 778 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.start 1756 initial_position) : ( +# 787 "parsing/parser.mly" (Parsetree.expression) -# 45974 "parsing/parser.ml" +# 46713 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) and parse_core_type = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1732 initial_position) : ( -# 776 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.start 1752 initial_position) : ( +# 785 "parsing/parser.mly" (Parsetree.core_type) -# 45982 "parsing/parser.ml" +# 46721 "parsing/parser.ml" + ) MenhirInterpreter.checkpoint) + + and parse_constr_longident = + fun initial_position -> + (Obj.magic (MenhirInterpreter.start 1748 initial_position) : ( +# 791 "parsing/parser.mly" + (Longident.t) +# 46729 "parsing/parser.ml" + ) MenhirInterpreter.checkpoint) + + and parse_any_longident = + fun initial_position -> + (Obj.magic (MenhirInterpreter.start 1730 initial_position) : ( +# 801 "parsing/parser.mly" + (Longident.t) +# 46737 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) and interface = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1728 initial_position) : ( -# 770 "parsing/parser.mly" + (Obj.magic (MenhirInterpreter.start 1726 initial_position) : ( +# 779 "parsing/parser.mly" (Parsetree.signature) -# 45990 "parsing/parser.ml" +# 46745 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) and implementation = fun initial_position -> (Obj.magic (MenhirInterpreter.start 0 initial_position) : ( -# 768 "parsing/parser.mly" +# 777 "parsing/parser.mly" (Parsetree.structure) -# 45998 "parsing/parser.ml" +# 46753 "parsing/parser.ml" ) MenhirInterpreter.checkpoint) end -# 3695 "parsing/parser.mly" +# 3761 "parsing/parser.mly" -# 46006 "parsing/parser.ml" +# 46761 "parsing/parser.ml" -# 269 "menhir/standard.mly" +# 269 "" -# 46011 "parsing/parser.ml" +# 46766 "parsing/parser.ml" diff --git a/boot/menhir/parser.mli b/boot/menhir/parser.mli index ae740328..dd3f68ee 100644 --- a/boot/menhir/parser.mli +++ b/boot/menhir/parser.mli @@ -16,7 +16,7 @@ type token = | TILDE | THEN | STRUCT - | STRING of (string * string option) + | STRING of (string * Location.t * string option) | STAR | SIG | SEMISEMI @@ -25,6 +25,8 @@ type token = | REC | RBRACKET | RBRACE + | QUOTED_STRING_ITEM of (string * Location.t * string * Location.t * string option) + | QUOTED_STRING_EXPR of (string * Location.t * string * Location.t * string option) | QUOTE | QUESTION | PRIVATE @@ -134,12 +136,24 @@ val use_file: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.toplevel_p val toplevel_phrase: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.toplevel_phrase) +val parse_val_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t) + val parse_pattern: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.pattern) +val parse_mty_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t) + +val parse_mod_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t) + +val parse_mod_ext_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t) + val parse_expression: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.expression) val parse_core_type: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.core_type) +val parse_constr_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t) + +val parse_any_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t) + val interface: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.signature) val implementation: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.structure) @@ -161,12 +175,24 @@ module Incremental : sig val toplevel_phrase: Lexing.position -> (Parsetree.toplevel_phrase) MenhirInterpreter.checkpoint + val parse_val_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint + val parse_pattern: Lexing.position -> (Parsetree.pattern) MenhirInterpreter.checkpoint + val parse_mty_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint + + val parse_mod_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint + + val parse_mod_ext_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint + val parse_expression: Lexing.position -> (Parsetree.expression) MenhirInterpreter.checkpoint val parse_core_type: Lexing.position -> (Parsetree.core_type) MenhirInterpreter.checkpoint + val parse_constr_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint + + val parse_any_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint + val interface: Lexing.position -> (Parsetree.signature) MenhirInterpreter.checkpoint val implementation: Lexing.position -> (Parsetree.structure) MenhirInterpreter.checkpoint diff --git a/boot/ocamlc b/boot/ocamlc index 047bb008..13606009 100755 Binary files a/boot/ocamlc and b/boot/ocamlc differ diff --git a/boot/ocamllex b/boot/ocamllex index 462fe17b..c09dc74c 100755 Binary files a/boot/ocamllex and b/boot/ocamllex differ diff --git a/bytecomp/bytegen.ml b/bytecomp/bytegen.ml index 2bbb19a5..ca34b034 100644 --- a/bytecomp/bytegen.ml +++ b/bytecomp/bytegen.ml @@ -22,6 +22,7 @@ open Types open Lambda open Switch open Instruct +open Debuginfo.Scoped_location (**** Label generation ****) @@ -104,6 +105,34 @@ let rec is_tailcall = function | Kpop _ :: c -> is_tailcall c | _ -> false +(* Will this primitive result in an OCaml call which would benefit + from the tail call optimization? *) + +let preserve_tailcall_for_prim = function + Pidentity | Popaque | Pdirapply | Prevapply | Psequor | Psequand -> + true + | Pbytes_to_string | Pbytes_of_string | Pignore | Pgetglobal _ | Psetglobal _ + | Pmakeblock _ | Pfield _ | Pfield_computed | Psetfield _ + | Psetfield_computed _ | Pfloatfield _ | Psetfloatfield _ | Pduprecord _ + | Pccall _ | Praise _ | Pnot | Pnegint | Paddint | Psubint | Pmulint + | Pdivint _ | Pmodint _ | Pandint | Porint | Pxorint | Plslint | Plsrint + | Pasrint | Pintcomp _ | Poffsetint _ | Poffsetref _ | Pintoffloat + | Pfloatofint | Pnegfloat | Pabsfloat | Paddfloat | Psubfloat | Pmulfloat + | Pdivfloat | Pfloatcomp _ | Pstringlength | Pstringrefu | Pstringrefs + | Pcompare_ints | Pcompare_floats | Pcompare_bints _ + | Pbyteslength | Pbytesrefu | Pbytessetu | Pbytesrefs | Pbytessets + | Pmakearray _ | Pduparray _ | Parraylength _ | Parrayrefu _ | Parraysetu _ + | Parrayrefs _ | Parraysets _ | Pisint | Pisout | Pbintofint _ | Pintofbint _ + | Pcvtbint _ | Pnegbint _ | Paddbint _ | Psubbint _ | Pmulbint _ | Pdivbint _ + | Pmodbint _ | Pandbint _ | Porbint _ | Pxorbint _ | Plslbint _ | Plsrbint _ + | Pasrbint _ | Pbintcomp _ | Pbigarrayref _ | Pbigarrayset _ | Pbigarraydim _ + | Pstring_load_16 _ | Pstring_load_32 _ | Pstring_load_64 _ | Pbytes_load_16 _ + | Pbytes_load_32 _ | Pbytes_load_64 _ | Pbytes_set_16 _ | Pbytes_set_32 _ + | Pbytes_set_64 _ | Pbigstring_load_16 _ | Pbigstring_load_32 _ + | Pbigstring_load_64 _ | Pbigstring_set_16 _ | Pbigstring_set_32 _ + | Pbigstring_set_64 _ | Pctconst _ | Pbswap16 | Pbbswap _ | Pint_as_pointer -> + false + (* Add a Kpop N instruction in front of a continuation *) let rec add_pop n cont = @@ -200,15 +229,10 @@ let rec size_of_lambda env = function (**** Merging consecutive events ****) let copy_event ev kind info repr = - { ev_pos = 0; (* patched in emitcode *) - ev_module = ev.ev_module; - ev_loc = ev.ev_loc; + { ev with + ev_pos = 0; (* patched in emitcode *) ev_kind = kind; ev_info = info; - ev_typenv = ev.ev_typenv; - ev_typsubst = ev.ev_typsubst; - ev_compenv = ev.ev_compenv; - ev_stacksize = ev.ev_stacksize; ev_repr = repr } let merge_infos ev ev' = @@ -268,6 +292,33 @@ let add_event ev = Kevent ev' :: cont -> weaken_event (merge_events ev ev') cont | cont -> weaken_event ev cont +(* Pseudo events are ignored by the debugger. They are only used for + generating backtraces. + + We prefer adding this event here rather than in lambda generation + 1) there are many different situations where a Pmakeblock can + be generated + 2) we prefer inserting a pseudo event rather than an event after + to prevent the debugger to stop at every single allocation. *) +let add_pseudo_event loc modname c = + if !Clflags.debug then + let ev_defname = string_of_scoped_location loc in + let ev = + { ev_pos = 0; (* patched in emitcode *) + ev_module = modname; + ev_loc = to_location loc; + ev_defname; + ev_kind = Event_pseudo; + ev_info = Event_other; (* Dummy *) + ev_typenv = Env.Env_empty; (* Dummy *) + ev_typsubst = Subst.identity; (* Dummy *) + ev_compenv = empty_env; (* Dummy *) + ev_stacksize = 0; (* Dummy *) + ev_repr = Event_none } (* Dummy *) + in + add_event ev c + else c + (**** Compilation of a lambda expression ****) let try_blocks = ref [] (* list of stack size for each nested try block *) @@ -337,12 +388,13 @@ let comp_primitive p args = Pgetglobal id -> Kgetglobal id | Psetglobal id -> Ksetglobal id | Pintcomp cmp -> Kintcomp cmp - | Pmakeblock(tag, _mut, _) -> Kmakeblock(List.length args, tag) + | Pcompare_ints -> Kccall("caml_int_compare", 2) + | Pcompare_floats -> Kccall("caml_float_compare", 2) + | Pcompare_bints bi -> comp_bint_primitive bi "compare" args | Pfield n -> Kgetfield n | Pfield_computed -> Kgetvectitem | Psetfield(n, _ptr, _init) -> Ksetfield n | Psetfield_computed(_ptr, _init) -> Ksetvectitem - | Pfloatfield n -> Kgetfloatfield n | Psetfloatfield (n, _init) -> Ksetfloatfield n | Pduprecord _ -> Kccall("caml_obj_dup", 1) | Pccall p -> Kccall(p.prim_name, p.prim_arity) @@ -529,7 +581,8 @@ let rec comp_expr env exp sz cont = comp_args env args' (sz + 3) (getmethod :: Kapply nargs :: cont1) end - | Lfunction{params; body} -> (* assume kind = Curried *) + | Lfunction{params; body; loc} -> (* assume kind = Curried *) + let cont = add_pseudo_event loc !compunit_name cont in let lbl = new_label() in let fv = Ident.Set.elements(free_variables exp) in let to_compile = @@ -679,7 +732,8 @@ let rec comp_expr env exp sz cont = (Kpush:: Kconst (Const_base (Const_int n)):: Kaddint::cont) - | Lprim(Pmakearray (kind, _), args, _) -> + | Lprim(Pmakearray (kind, _), args, loc) -> + let cont = add_pseudo_event loc !compunit_name cont in begin match kind with Pintarray | Paddrarray -> comp_args env args sz (Kmakeblock(List.length args, 0) :: cont) @@ -723,6 +777,12 @@ let rec comp_expr env exp sz cont = | CFnge -> Kccall("caml_ge_float", 2) :: Kboolnot :: cont in comp_args env args sz cont + | Lprim(Pmakeblock(tag, _mut, _), args, loc) -> + let cont = add_pseudo_event loc !compunit_name cont in + comp_args env args sz (Kmakeblock(List.length args, tag) :: cont) + | Lprim(Pfloatfield n, args, loc) -> + let cont = add_pseudo_event loc !compunit_name cont in + comp_args env args sz (Kgetfloatfield n :: cont) | Lprim(p, args, _) -> comp_args env args sz (comp_primitive p args :: cont) | Lstaticcatch (body, (i, vars) , handler) -> @@ -860,11 +920,15 @@ let rec comp_expr env exp sz cont = fatal_error "Bytegen.comp_expr: assign" end | Levent(lam, lev) -> + let ev_defname = match lev.lev_loc with + | Loc_unknown -> "??" + | Loc_known { loc = _; scopes } -> string_of_scopes scopes in let event kind info = { ev_pos = 0; (* patched in emitcode *) ev_module = !compunit_name; - ev_loc = lev.lev_loc; + ev_loc = to_location lev.lev_loc; ev_kind = kind; + ev_defname; ev_info = info; ev_typenv = Env.summary lev.lev_env; ev_typsubst = Subst.identity; @@ -897,18 +961,27 @@ let rec comp_expr env exp sz cont = let c = comp_expr env lam sz cont in let ev = event Event_pseudo Event_other in add_event ev c - | Lev_after _ when is_tailcall cont -> (* don't destroy tail call opt *) - comp_expr env lam sz cont | Lev_after ty -> - let info = + let preserve_tailcall = match lam with - Lapply{ap_args = args} -> Event_return (List.length args) - | Lsend(_, _, _, args, _) -> Event_return (List.length args + 1) - | _ -> Event_other + | Lprim(prim, _, _) -> preserve_tailcall_for_prim prim + | _ -> true in - let ev = event (Event_after ty) info in - let cont1 = add_event ev cont in - comp_expr env lam sz cont1 + if preserve_tailcall && is_tailcall cont then + (* don't destroy tail call opt *) + comp_expr env lam sz cont + else begin + let info = + match lam with + Lapply{ap_args = args} -> Event_return (List.length args) + | Lsend(_, _, _, args, _) -> Event_return (List.length args + 1) + | Lprim(_,args,_) -> Event_return (List.length args) + | _ -> Event_other + in + let ev = event (Event_after ty) info in + let cont1 = add_event ev cont in + comp_expr env lam sz cont1 + end | Lev_module_definition _ -> comp_expr env lam sz cont end diff --git a/bytecomp/bytelink.ml b/bytecomp/bytelink.ml index d980054c..9a7a46ab 100644 --- a/bytecomp/bytelink.ml +++ b/bytecomp/bytelink.ml @@ -178,7 +178,11 @@ let check_consistency file_name cu = then Consistbl.set crc_interfaces name crc file_name else Consistbl.check crc_interfaces name crc file_name) cu.cu_imports - with Consistbl.Inconsistency(name, user, auth) -> + with Consistbl.Inconsistency { + unit_name = name; + inconsistent_source = user; + original_source = auth; + } -> raise(Error(Inconsistent_import(name, user, auth))) end; begin try @@ -572,9 +576,12 @@ let build_custom_runtime prim_name exec_name = [Printf.sprintf "-fdebug-prefix-map=%s=camlprim.c" prim_name] else [] in + let exitcode = + (Clflags.std_include_flag "-I" ^ " " ^ Config.bytecomp_c_libraries) + in Ccomp.call_linker Ccomp.Exe exec_name (debug_prefix_map @ [prim_name] @ List.rev !Clflags.ccobjs @ [runtime_lib]) - (Clflags.std_include_flag "-I" ^ " " ^ Config.bytecomp_c_libraries) + exitcode = 0 let append_bytecode bytecode_name exec_name = let oc = open_out_gen [Open_wronly; Open_append; Open_binary] 0 exec_name in @@ -706,7 +713,7 @@ let link objfiles output_name = else "-lcamlrun" ^ !Clflags.runtime_variant in Ccomp.call_linker mode output_name ([obj_file] @ List.rev !Clflags.ccobjs @ [runtime_lib]) - c_libs + c_libs = 0 ) then raise (Error Custom_runtime); end end; diff --git a/bytecomp/instruct.ml b/bytecomp/instruct.ml index 99163628..c684bedf 100644 --- a/bytecomp/instruct.ml +++ b/bytecomp/instruct.ml @@ -25,6 +25,7 @@ type debug_event = ev_module: string; (* Name of defining module *) ev_loc: Location.t; (* Location in source file *) ev_kind: debug_event_kind; (* Before/after event *) + ev_defname: string; (* Enclosing definition *) ev_info: debug_event_info; (* Extra information *) ev_typenv: Env.summary; (* Typing environment *) ev_typsubst: Subst.t; (* Substitution over types *) diff --git a/bytecomp/instruct.mli b/bytecomp/instruct.mli index 4c4e9f1c..e1cae776 100644 --- a/bytecomp/instruct.mli +++ b/bytecomp/instruct.mli @@ -37,12 +37,13 @@ type compilation_env = (* Debugging events *) -(* Warning: when you change these types, check runtime/backtrace.c *) +(* Warning: when you change these types, check runtime/backtrace_byt.c *) type debug_event = { mutable ev_pos: int; (* Position in bytecode *) ev_module: string; (* Name of defining module *) ev_loc: Location.t; (* Location in source file *) ev_kind: debug_event_kind; (* Before/after event *) + ev_defname: string; (* Enclosing definition *) ev_info: debug_event_info; (* Extra information *) ev_typenv: Env.summary; (* Typing environment *) ev_typsubst: Subst.t; (* Substitution over types *) diff --git a/bytecomp/symtable.ml b/bytecomp/symtable.ml index 8886ab47..dad4cafe 100644 --- a/bytecomp/symtable.ml +++ b/bytecomp/symtable.ml @@ -154,10 +154,11 @@ let init () = try List.assoc name Predef.builtin_values with Not_found -> fatal_error "Symtable.init" in let c = slot_for_setglobal id in - let cst = Const_block(Obj.object_tag, - [Const_base(Const_string (name, None)); - Const_base(Const_int (-i-1)) - ]) + let cst = Const_block + (Obj.object_tag, + [Const_base(Const_string (name, Location.none,None)); + Const_base(Const_int (-i-1)) + ]) in literal_table := (c, cst) :: !literal_table) Runtimedef.builtin_exceptions; @@ -216,7 +217,7 @@ let patch_object buff patchlist = let rec transl_const = function Const_base(Const_int i) -> Obj.repr i | Const_base(Const_char c) -> Obj.repr c - | Const_base(Const_string (s, _)) -> Obj.repr s + | Const_base(Const_string (s, _, _)) -> Obj.repr s | Const_base(Const_float f) -> Obj.repr (float_of_string f) | Const_base(Const_int32 i) -> Obj.repr i | Const_base(Const_int64 i) -> Obj.repr i diff --git a/compilerlibs/.gitignore b/compilerlibs/.gitignore deleted file mode 100644 index c1eda49d..00000000 --- a/compilerlibs/.gitignore +++ /dev/null @@ -1,7 +0,0 @@ -# This .gitignore is here to force git to create the compilerlibs directory -# because git doesn't create empty directories. -# The lines tell git to ignore everything in this directory except -# the .gitignore file itself. - -* -!.gitignore diff --git a/compilerlibs/Makefile.compilerlibs b/compilerlibs/Makefile.compilerlibs new file mode 100644 index 00000000..3acfaf8b --- /dev/null +++ b/compilerlibs/Makefile.compilerlibs @@ -0,0 +1,335 @@ +#************************************************************************** +#* * +#* OCaml * +#* * +#* Xavier Leroy, projet Cristal, INRIA Rocquencourt * +#* * +#* Copyright 1999 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. * +#* * +#************************************************************************** + +# Targets and dependencies for compilerlibs archives + +# This file is meant to be included from the root Makefile, not to be +# executed directly (this is why it is not simply named Makefile). + +# For each group of compilation units, we have a variable GROUP with +# only .cmo files, and a separate variable GROUP_CMI for .cmi files +# corresponding to the .mli-only modules only. These .cmi are not +# linked in the archive, but they are marked as dependencies to ensure +# that they are consistent with the interface digests in the archives. + +UTILS=utils/config.cmo utils/build_path_prefix_map.cmo utils/misc.cmo \ + utils/identifiable.cmo utils/numbers.cmo utils/arg_helper.cmo \ + utils/clflags.cmo utils/profile.cmo utils/load_path.cmo \ + utils/terminfo.cmo utils/ccomp.cmo utils/warnings.cmo \ + utils/consistbl.cmo utils/strongly_connected_components.cmo \ + utils/targetint.cmo utils/int_replace_polymorphic_compare.cmo \ + utils/domainstate.cmo +UTILS_CMI= + +PARSING=parsing/location.cmo parsing/longident.cmo \ + parsing/docstrings.cmo parsing/syntaxerr.cmo \ + parsing/ast_helper.cmo \ + parsing/pprintast.cmo \ + parsing/camlinternalMenhirLib.cmo parsing/parser.cmo \ + parsing/lexer.cmo parsing/parse.cmo parsing/printast.cmo \ + parsing/ast_mapper.cmo parsing/ast_iterator.cmo parsing/attr_helper.cmo \ + parsing/builtin_attributes.cmo parsing/ast_invariants.cmo parsing/depend.cmo +PARSING_CMI=\ + parsing/asttypes.cmi \ + parsing/parsetree.cmi + +TYPING=typing/ident.cmo typing/path.cmo \ + typing/primitive.cmo typing/type_immediacy.cmo typing/types.cmo \ + typing/btype.cmo typing/oprint.cmo \ + typing/subst.cmo typing/predef.cmo \ + typing/datarepr.cmo file_formats/cmi_format.cmo \ + typing/persistent_env.cmo typing/env.cmo \ + typing/typedtree.cmo typing/printtyped.cmo typing/ctype.cmo \ + typing/printtyp.cmo typing/includeclass.cmo \ + typing/mtype.cmo typing/envaux.cmo typing/includecore.cmo \ + typing/tast_iterator.cmo typing/tast_mapper.cmo typing/stypes.cmo \ + file_formats/cmt_format.cmo typing/cmt2annot.cmo typing/untypeast.cmo \ + typing/includemod.cmo typing/typetexp.cmo typing/printpat.cmo \ + typing/parmatch.cmo \ + typing/typedecl_properties.cmo typing/typedecl_variance.cmo \ + typing/typedecl_unboxed.cmo typing/typedecl_immediacy.cmo \ + typing/typedecl_separability.cmo \ + typing/typedecl.cmo typing/typeopt.cmo \ + typing/rec_check.cmo typing/typecore.cmo typing/typeclass.cmo \ + typing/typemod.cmo +TYPING_CMI=\ + typing/annot.cmi \ + typing/outcometree.cmi + +LAMBDA=lambda/debuginfo.cmo \ + lambda/lambda.cmo lambda/printlambda.cmo \ + lambda/switch.cmo lambda/matching.cmo \ + lambda/translobj.cmo lambda/translattribute.cmo \ + lambda/translprim.cmo lambda/translcore.cmo \ + lambda/translclass.cmo lambda/translmod.cmo \ + lambda/simplif.cmo lambda/runtimedef.cmo +LAMBDA_CMI= + +COMP=\ + bytecomp/meta.cmo bytecomp/opcodes.cmo \ + bytecomp/bytesections.cmo bytecomp/dll.cmo \ + bytecomp/symtable.cmo \ + driver/pparse.cmo driver/compenv.cmo \ + driver/main_args.cmo driver/compmisc.cmo \ + driver/makedepend.cmo \ + driver/compile_common.cmo +COMP_CMI=\ + file_formats/cmo_format.cmi \ + file_formats/cmx_format.cmi \ + file_formats/cmxs_format.cmi +# All file format descriptions (including cmx{,s}) are in the +# ocamlcommon library so that ocamlobjinfo can depend on them. + +COMMON_CMI=$(UTILS_CMI) $(PARSING_CMI) $(TYPING_CMI) $(LAMBDA_CMI) $(COMP_CMI) + +COMMON=$(UTILS) $(PARSING) $(TYPING) $(LAMBDA) $(COMP) + +BYTECOMP=bytecomp/instruct.cmo bytecomp/bytegen.cmo \ + bytecomp/printinstr.cmo bytecomp/emitcode.cmo \ + bytecomp/bytelink.cmo bytecomp/bytelibrarian.cmo bytecomp/bytepackager.cmo \ + driver/errors.cmo driver/compile.cmo +BYTECOMP_CMI= + +ARCH_SPECIFIC =\ + asmcomp/arch.ml asmcomp/proc.ml asmcomp/CSE.ml asmcomp/selection.ml \ + asmcomp/scheduling.ml asmcomp/reload.ml +ARCH_SPECIFIC_CMI= + +INTEL_ASM=\ + asmcomp/x86_proc.cmo \ + asmcomp/x86_dsl.cmo \ + asmcomp/x86_gas.cmo \ + asmcomp/x86_masm.cmo +INTEL_ASM_CMI=\ + asmcomp/x86_ast.cmi + +ARCH_SPECIFIC_ASMCOMP= +ifeq ($(ARCH),i386) +ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM) +ARCH_SPECIFIC_ASMCOMP_CMI=$(INTEL_ASM_CMI) +endif +ifeq ($(ARCH),amd64) +ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM) +ARCH_SPECIFIC_ASMCOMP_CMI=$(INTEL_ASM_CMI) +endif + +ASMCOMP=\ + $(ARCH_SPECIFIC_ASMCOMP) \ + asmcomp/arch.cmo \ + asmcomp/cmm.cmo asmcomp/printcmm.cmo \ + asmcomp/reg.cmo asmcomp/debug/reg_with_debug_info.cmo \ + asmcomp/debug/reg_availability_set.cmo \ + asmcomp/mach.cmo asmcomp/proc.cmo \ + asmcomp/afl_instrument.cmo \ + asmcomp/strmatch.cmo \ + asmcomp/cmmgen_state.cmo \ + asmcomp/cmm_helpers.cmo \ + asmcomp/cmmgen.cmo \ + asmcomp/interval.cmo \ + asmcomp/printmach.cmo asmcomp/selectgen.cmo \ + asmcomp/spacetime_profiling.cmo asmcomp/selection.cmo \ + asmcomp/comballoc.cmo \ + asmcomp/CSEgen.cmo asmcomp/CSE.cmo \ + asmcomp/liveness.cmo \ + asmcomp/spill.cmo asmcomp/split.cmo \ + asmcomp/interf.cmo asmcomp/coloring.cmo \ + asmcomp/linscan.cmo \ + asmcomp/reloadgen.cmo asmcomp/reload.cmo \ + asmcomp/deadcode.cmo \ + asmcomp/linear.cmo asmcomp/printlinear.cmo asmcomp/linearize.cmo \ + asmcomp/debug/available_regs.cmo \ + asmcomp/debug/compute_ranges_intf.cmo \ + asmcomp/debug/compute_ranges.cmo \ + asmcomp/schedgen.cmo asmcomp/scheduling.cmo \ + asmcomp/branch_relaxation_intf.cmo \ + asmcomp/branch_relaxation.cmo \ + asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \ + asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo \ + driver/opterrors.cmo driver/optcompile.cmo +ASMCOMP_CMI=$(ARCH_SPECIFIC_ASMCOMP_CMI) + +# Files under middle_end/ are not to reference files under asmcomp/. +# This ensures that the middle end can be linked (e.g. for objinfo) even when +# the native code compiler is not present for some particular target. + +MIDDLE_END_CLOSURE=\ + middle_end/closure/closure.cmo \ + middle_end/closure/closure_middle_end.cmo +MIDDLE_END_CLOSURE_CMI= + +# Owing to dependencies through [Compilenv], which would be +# difficult to remove, some of the lower parts of Flambda (anything that is +# saved in a .cmx file) have to be included in the [MIDDLE_END] stanza, below. +MIDDLE_END_FLAMBDA=\ + middle_end/flambda/import_approx.cmo \ + middle_end/flambda/lift_code.cmo \ + middle_end/flambda/closure_conversion_aux.cmo \ + middle_end/flambda/closure_conversion.cmo \ + middle_end/flambda/initialize_symbol_to_let_symbol.cmo \ + middle_end/flambda/lift_let_to_initialize_symbol.cmo \ + middle_end/flambda/find_recursive_functions.cmo \ + middle_end/flambda/invariant_params.cmo \ + middle_end/flambda/inconstant_idents.cmo \ + middle_end/flambda/alias_analysis.cmo \ + middle_end/flambda/lift_constants.cmo \ + middle_end/flambda/share_constants.cmo \ + middle_end/flambda/simplify_common.cmo \ + middle_end/flambda/remove_unused_arguments.cmo \ + middle_end/flambda/remove_unused_closure_vars.cmo \ + middle_end/flambda/remove_unused_program_constructs.cmo \ + middle_end/flambda/simplify_boxed_integer_ops.cmo \ + middle_end/flambda/simplify_primitives.cmo \ + middle_end/flambda/inlining_stats_types.cmo \ + middle_end/flambda/inlining_stats.cmo \ + middle_end/flambda/inline_and_simplify_aux.cmo \ + middle_end/flambda/remove_free_vars_equal_to_args.cmo \ + middle_end/flambda/extract_projections.cmo \ + middle_end/flambda/augment_specialised_args.cmo \ + middle_end/flambda/unbox_free_vars_of_closures.cmo \ + middle_end/flambda/unbox_specialised_args.cmo \ + middle_end/flambda/unbox_closures.cmo \ + middle_end/flambda/inlining_transforms.cmo \ + middle_end/flambda/inlining_decision.cmo \ + middle_end/flambda/inline_and_simplify.cmo \ + middle_end/flambda/ref_to_variables.cmo \ + middle_end/flambda/flambda_invariants.cmo \ + middle_end/flambda/traverse_for_exported_symbols.cmo \ + middle_end/flambda/build_export_info.cmo \ + middle_end/flambda/closure_offsets.cmo \ + middle_end/flambda/un_anf.cmo \ + middle_end/flambda/flambda_to_clambda.cmo \ + middle_end/flambda/flambda_middle_end.cmo +MIDDLE_END_FLAMBDA_CMI=\ + middle_end/flambda/inlining_decision_intf.cmi \ + middle_end/flambda/simplify_boxed_integer_ops_intf.cmi + +MIDDLE_END=\ + middle_end/internal_variable_names.cmo \ + middle_end/linkage_name.cmo \ + middle_end/compilation_unit.cmo \ + middle_end/variable.cmo \ + middle_end/flambda/base_types/closure_element.cmo \ + middle_end/flambda/base_types/closure_id.cmo \ + middle_end/symbol.cmo \ + middle_end/backend_var.cmo \ + middle_end/clambda_primitives.cmo \ + middle_end/printclambda_primitives.cmo \ + middle_end/clambda.cmo \ + middle_end/printclambda.cmo \ + middle_end/semantics_of_primitives.cmo \ + middle_end/convert_primitives.cmo \ + middle_end/flambda/base_types/id_types.cmo \ + middle_end/flambda/base_types/export_id.cmo \ + middle_end/flambda/base_types/tag.cmo \ + middle_end/flambda/base_types/mutable_variable.cmo \ + middle_end/flambda/base_types/set_of_closures_id.cmo \ + middle_end/flambda/base_types/set_of_closures_origin.cmo \ + middle_end/flambda/base_types/closure_origin.cmo \ + middle_end/flambda/base_types/var_within_closure.cmo \ + middle_end/flambda/base_types/static_exception.cmo \ + middle_end/flambda/pass_wrapper.cmo \ + middle_end/flambda/allocated_const.cmo \ + middle_end/flambda/parameter.cmo \ + middle_end/flambda/projection.cmo \ + middle_end/flambda/flambda.cmo \ + middle_end/flambda/flambda_iterators.cmo \ + middle_end/flambda/flambda_utils.cmo \ + middle_end/flambda/freshening.cmo \ + middle_end/flambda/effect_analysis.cmo \ + middle_end/flambda/inlining_cost.cmo \ + middle_end/flambda/simple_value_approx.cmo \ + middle_end/flambda/export_info.cmo \ + middle_end/flambda/export_info_for_pack.cmo \ + middle_end/compilenv.cmo \ + $(MIDDLE_END_CLOSURE) \ + $(MIDDLE_END_FLAMBDA) +MIDDLE_END_CMI=\ + middle_end/backend_intf.cmi \ + $(MIDDLE_END_CLOSURE_CMI) \ + $(MIDDLE_END_FLAMBDA_CMI) + +OPTCOMP=$(MIDDLE_END) $(ASMCOMP) +OPTCOMP_CMI=$(MIDDLE_END_CMI) $(ASMCOMP_CMI) + +TOPLEVEL=toplevel/genprintval.cmo toplevel/toploop.cmo \ + toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo +TOPLEVEL_CMI= + +OPTTOPLEVEL=toplevel/genprintval.cmo toplevel/opttoploop.cmo \ + toplevel/opttopdirs.cmo toplevel/opttopmain.cmo +OPTTOPLEVEL_CMI= + + +$(COMMON:.cmo=.cmx) $(BYTECOMP:.cmo=.cmx) $(OPTCOMP:.cmo=.cmx): ocamlopt +$(OPTTOPLEVEL:.cmo=.cmx): ocamlopt + + +compilerlibs/ocamlcommon.cma: $(COMMON_CMI) $(COMMON) + $(CAMLC) -a -linkall -o $@ $(COMMON) +partialclean:: + rm -f compilerlibs/ocamlcommon.cma + +compilerlibs/ocamlcommon.cmxa: $(COMMON_CMI) $(COMMON:.cmo=.cmx) + $(CAMLOPT) -a -linkall -o $@ $(COMMON:.cmo=.cmx) +partialclean:: + rm -f compilerlibs/ocamlcommon.cmxa \ + compilerlibs/ocamlcommon.a compilerlibs/ocamlcommon.lib + + +compilerlibs/ocamlbytecomp.cma: $(BYTECOMP_CMI) $(BYTECOMP) + $(CAMLC) -a -o $@ $(BYTECOMP) +partialclean:: + rm -f compilerlibs/ocamlbytecomp.cma + +compilerlibs/ocamlbytecomp.cmxa: $(BYTECOMP_CMI) $(BYTECOMP:.cmo=.cmx) + $(CAMLOPT) -a $(OCAML_NATDYNLINKOPTS) -o $@ $(BYTECOMP:.cmo=.cmx) +partialclean:: + rm -f compilerlibs/ocamlbytecomp.cmxa \ + compilerlibs/ocamlbytecomp.a compilerlibs/ocamlbytecomp.lib + + +compilerlibs/ocamlmiddleend.cma: $(MIDDLE_END_CMI) $(MIDDLE_END) + $(CAMLC) -a -o $@ $(MIDDLE_END) +compilerlibs/ocamlmiddleend.cmxa: $(MIDDLE_END_CMI) $(MIDDLE_END:%.cmo=%.cmx) + $(CAMLOPT) -a -o $@ $(MIDDLE_END:%.cmo=%.cmx) +partialclean:: + rm -f compilerlibs/ocamlmiddleend.cma \ + compilerlibs/ocamlmiddleend.cmxa \ + compilerlibs/ocamlmiddleend.a \ + compilerlibs/ocamlmiddleend.lib + + +compilerlibs/ocamloptcomp.cma: $(OPTCOMP_CMI) $(OPTCOMP) + $(CAMLC) -a -o $@ $(OPTCOMP) +partialclean:: + rm -f compilerlibs/ocamloptcomp.cma + +compilerlibs/ocamloptcomp.cmxa: $(OPTCOMP_CMI) $(OPTCOMP:.cmo=.cmx) + $(CAMLOPT) -a -o $@ $(OPTCOMP:.cmo=.cmx) +partialclean:: + rm -f compilerlibs/ocamloptcomp.cmxa \ + compilerlibs/ocamloptcomp.a compilerlibs/ocamloptcomp.lib + + +compilerlibs/ocamltoplevel.cma: $(TOPLEVEL_CMI) $(TOPLEVEL) + $(CAMLC) -a -o $@ $(TOPLEVEL) +partialclean:: + rm -f compilerlibs/ocamltoplevel.cma + +compilerlibs/ocamlopttoplevel.cmxa: $(OPTTOPLEVEL_CMI) $(OPTTOPLEVEL:.cmo=.cmx) + $(CAMLOPT) -a -o $@ $(OPTTOPLEVEL:.cmo=.cmx) +partialclean:: + rm -f compilerlibs/ocamlopttoplevel.cmxa \ + compilerlibs/ocamlopttoplevel.a compilerlibs/ocamlopttoplevel.lib diff --git a/configure b/configure index 2dbde09f..b6c44d22 100755 --- a/configure +++ b/configure @@ -56,7 +56,7 @@ if test -e '.git' ; then : fi fi # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for OCaml 4.10.1. +# Generated by GNU Autoconf 2.69 for OCaml 4.11.0. # # Report bugs to . # @@ -646,8 +646,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='OCaml' PACKAGE_TARNAME='ocaml' -PACKAGE_VERSION='4.10.1' -PACKAGE_STRING='OCaml 4.10.1' +PACKAGE_VERSION='4.11.0' +PACKAGE_STRING='OCaml 4.11.0' PACKAGE_BUGREPORT='caml-list@inria.fr' PACKAGE_URL='http://www.ocaml.org' @@ -777,6 +777,7 @@ rpath sharedlib_cflags asm_cfi_supported AS +endianness ASPP bfd_ldlibs bfd_ldflags @@ -784,12 +785,14 @@ bfd_cppflags x_libraries x_includes pthread_link +ocamltest ocamldoc with_camltex with_debugger as_has_debug_prefix_map cc_has_debug_prefix_map otherlibraries +has_monotonic_clock instrumented_runtime debug_runtime cmxs @@ -803,8 +806,6 @@ AR shebangscripts long_shebang iflexdir -ocamlopt_cppflags -ocamlopt_cflags ocamlc_cppflags ocamlc_cflags nativecclibs @@ -894,6 +895,7 @@ enable_str_lib enable_unix_lib enable_bigarray_lib enable_ocamldoc +enable_ocamltest enable_frame_pointers enable_naked_pointers enable_spacetime @@ -1480,7 +1482,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures OCaml 4.10.1 to adapt to many kinds of systems. +\`configure' configures OCaml 4.11.0 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1546,7 +1548,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of OCaml 4.10.1:";; + short | recursive ) echo "Configuration of OCaml 4.11.0:";; esac cat <<\_ACEOF @@ -1564,6 +1566,7 @@ Optional Features: --disable-unix-lib do not build the unix library --disable-bigarray-lib do not build the legacy separate bigarray library --disable-ocamldoc do not build the ocamldoc documentation system + --disable-ocamltest do not build the ocamltest driver --enable-frame-pointers use frame pointers in runtime and generated code --disable-naked-pointers do not allow naked pointers @@ -1708,7 +1711,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -OCaml configure 4.10.1 +OCaml configure 4.11.0 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -2371,7 +2374,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by OCaml $as_me 4.10.1, which was +It was created by OCaml $as_me 4.11.0, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -2720,8 +2723,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuring OCaml version 4.10.1" >&5 -$as_echo "$as_me: Configuring OCaml version 4.10.1" >&6;} +{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuring OCaml version 4.11.0" >&5 +$as_echo "$as_me: Configuring OCaml version 4.11.0" >&6;} # Configuration variables @@ -2745,8 +2748,6 @@ internal_cflags="" internal_cppflags="" ocamlc_cflags="" ocamlc_cppflags="" -ocamlopt_cflags="" -ocamlopt_cppflags="" oc_ldflags="" with_sharedlibs=true ostype="Unix" @@ -2756,6 +2757,8 @@ toolchain="cc" profinfo=false profinfo_width=0 extralibs= +instrumented_runtime=false +instrumented_runtime_ldlibs="" # Information about the package @@ -2797,7 +2800,7 @@ ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. -VERSION=4.10.1 +VERSION=4.11.0 # Note: This is present for the flexdll bootstrap where it exposed as the old @@ -2850,7 +2853,6 @@ VERSION=4.10.1 - # TODO: rename this variable @@ -2891,6 +2893,8 @@ VERSION=4.10.1 + + @@ -2900,6 +2904,8 @@ ac_config_files="$ac_config_files Makefile.common" ac_config_files="$ac_config_files Makefile.config" +ac_config_files="$ac_config_files tools/eventlog_metadata" + ac_config_headers="$ac_config_headers runtime/caml/m.h" ac_config_headers="$ac_config_headers runtime/caml/s.h" @@ -3137,6 +3143,12 @@ else fi +# Check whether --enable-ocamltest was given. +if test "${enable_ocamltest+set}" = set; then : + enableval=$enable_ocamltest; +fi + + # Check whether --enable-frame-pointers was given. if test "${enable_frame_pointers+set}" = set; then : enableval=$enable_frame_pointers; @@ -12461,14 +12473,15 @@ case $ocaml_cv_cc_vendor in #( msvc-*) : outputobj=-Fo; gcc_warnings="" ;; #( *) : - outputobj='-o $(EMPTY)'; case 4.10.1 in #( + outputobj='-o $(EMPTY)' + gcc_warnings='-Wall -Wdeclaration-after-statement' + case 4.11.0 in #( *+dev*) : - gcc_warnings="-Wall -Werror" ;; #( + gcc_warnings="$gcc_warnings -Werror" ;; #( *) : - gcc_warnings="-Wall" - ;; + ;; esac - ;; + ;; esac # We select high optimization levels, provided we can turn off: @@ -12488,40 +12501,51 @@ esac # in the macro itself, too case $host in #( *-*-mingw32) : - internal_cflags="-Wno-unused $gcc_warnings" - # TODO: see whether the code can be fixed to avoid -Wno-unused - common_cflags="-O -mms-bitfields" - internal_cppflags='-DUNICODE -D_UNICODE' - internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE=" - internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)" ;; #( + case $ocaml_cv_cc_vendor in #( + gcc-[01234]-*) : + as_fn_error $? "This version of Mingw GCC is too old. Please use GCC version 5 or above." "$LINENO" 5 ;; #( + gcc-*) : + internal_cflags="-Wno-unused $gcc_warnings \ +-fexcess-precision=standard" + # TODO: see whether the code can be fixed to avoid -Wno-unused + common_cflags="-O2 -fno-strict-aliasing -fwrapv -mms-bitfields" + internal_cppflags='-DUNICODE -D_UNICODE' + internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE=" + internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)" ;; #( + *) : + as_fn_error $? "Unsupported C compiler for a Mingw build" "$LINENO" 5 ;; +esac ;; #( *) : case $ocaml_cv_cc_vendor in #( clang-*) : common_cflags="-O2 -fno-strict-aliasing -fwrapv"; internal_cflags="$gcc_warnings -fno-common" ;; #( - gcc-012-*) : + gcc-[012]-*) : # Some versions known to miscompile OCaml, e,g, 2.7.2.1, some 2.96. # Plus: C99 support unknown. - as_fn_error $? "This version of GCC is too old. - Please use GCC version 4.2 or above." "$LINENO" 5 ;; #( - gcc-3-*|gcc-4-01) : + as_fn_error $? "This version of GCC is too old. Please use GCC version 4.2 or above." "$LINENO" 5 ;; #( + gcc-3-*|gcc-4-[01]) : # No -fwrapv option before GCC 3.4. # Known problems with -fwrapv fixed in 4.2 only. - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This version of GCC is rather old. - Reducing optimization level.\"" >&5 -$as_echo "$as_me: WARNING: This version of GCC is rather old. - Reducing optimization level.\"" >&2;}; + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This version of GCC is rather old. Reducing optimization level.\"" >&5 +$as_echo "$as_me: WARNING: This version of GCC is rather old. Reducing optimization level.\"" >&2;}; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Consider using GCC version 4.2 or above." >&5 $as_echo "$as_me: WARNING: Consider using GCC version 4.2 or above." >&2;}; common_cflags="-std=gnu99 -O"; internal_cflags="$gcc_warnings" ;; #( + gcc-4-[234]) : + # No -fexcess-precision option before GCC 4.5 + common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \ +-fno-builtin-memcmp"; + internal_cflags="$gcc_warnings" ;; #( gcc-4-*) : common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \ -fno-builtin-memcmp"; - internal_cflags="$gcc_warnings" ;; #( + internal_cflags="$gcc_warnings -fexcess-precision=standard" ;; #( gcc-*) : common_cflags="-O2 -fno-strict-aliasing -fwrapv"; - internal_cflags="$gcc_warnings -fno-common" ;; #( + internal_cflags="$gcc_warnings -fno-common \ +-fexcess-precision=standard" ;; #( msvc-*) : common_cflags="-nologo -O2 -Gy- -MD" common_cppflags="-D_CRT_SECURE_NO_DEPRECATE" @@ -13299,10 +13323,13 @@ fi $as_echo "$ac_cv_c_bigendian" >&6; } case $ac_cv_c_bigendian in #( yes) - $as_echo "#define ARCH_BIG_ENDIAN 1" >>confdefs.h -;; #( + + $as_echo "#define ARCH_BIG_ENDIAN 1" >>confdefs.h +, + endianness="be" + ;; #( no) - ;; #( + endianness="le" ;; #( universal) as_fn_error $? "unable to handle universal endianness" "$LINENO" 5 @@ -13382,6 +13409,41 @@ cat >>confdefs.h <<_ACEOF _ACEOF +# The cast to long int works around a bug in the HP C Compiler, +# see AC_CHECK_SIZEOF for more information. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking alignment of long long" >&5 +$as_echo_n "checking alignment of long long... " >&6; } +if ${ac_cv_alignof_long_long+:} false; then : + $as_echo_n "(cached) " >&6 +else + if ac_fn_c_compute_int "$LINENO" "(long int) offsetof (ac__type_alignof_, y)" "ac_cv_alignof_long_long" "$ac_includes_default +#ifndef offsetof +# define offsetof(type, member) ((char *) &((type *) 0)->member - (char *) 0) +#endif +typedef struct { char x; long long y; } ac__type_alignof_;"; then : + +else + if test "$ac_cv_type_long_long" = yes; then + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "cannot compute alignment of long long +See \`config.log' for more details" "$LINENO" 5; } + else + ac_cv_alignof_long_long=0 + fi +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_alignof_long_long" >&5 +$as_echo "$ac_cv_alignof_long_long" >&6; } + + + +cat >>confdefs.h <<_ACEOF +#define ALIGNOF_LONG_LONG $ac_cv_alignof_long_long +_ACEOF + + if ! $arch64; then : case $target_cpu in #( @@ -13392,9 +13454,16 @@ if ! $arch64; then : $as_echo "#define ARCH_ALIGN_DOUBLE 1" >>confdefs.h fi - if test "$ac_cv_alignof_long" -gt 4; then : - $as_echo "#define ARCH_ALIGN_LONG 1" >>confdefs.h + if test "x$ac_cv_sizeof_long" = "x8" && + test "$ac_cv_alignof_long" -gt 4; then : + $as_echo "#define ARCH_ALIGN_INT64 1" >>confdefs.h +else + if test "x$ac_cv_sizeof_long_long" = "x8" && + test "$ac_cv_alignof_long_long" -gt 4; then : + $as_echo "#define ARCH_ALIGN_INT64 1" >>confdefs.h + +fi fi ;; esac @@ -13509,6 +13578,8 @@ if test x"$enable_shared" != "xno"; then : natdynlink=true ;; #( aarch64-*-freebsd*) : natdynlink=true ;; #( + riscv*-*-linux*) : + natdynlink=true ;; #( *) : ;; esac @@ -13649,7 +13720,9 @@ fi; system=elf ;; #( aarch64-*-freebsd*) : arch=arm64; system=freebsd ;; #( x86_64-*-cygwin*) : - arch=amd64; system=cygwin + arch=amd64; system=cygwin ;; #( + riscv64-*-linux*) : + arch=riscv; model=riscv64; system=linux ;; #( *) : ;; @@ -13801,6 +13874,31 @@ if test $arch != "none" && $arch64 ; then : otherlibraries="$otherlibraries raw_spacetime_lib" fi +# Disable PIE at link time when ocamlopt does not produce position-independent +# code and the system produces PIE executables by default and demands PIC +# object files to do so. +# This issue does not affect amd64 (x86_64) and s390x (Z systems), +# since ocamlopt produces PIC object files by default. +# Currently the problem is known for Alpine Linux on platforms other +# than amd64 and s390x (issue #7562), and probably affects all Linux +# distributions that use the musl standard library and dynamic loader. +# Other systems have PIE by default but can cope with non-PIC object files, +# e.g. Ubuntu >= 17.10 for i386, which uses the glibc dynamic loader. + +case $arch in #( + amd64|s390x|none) : + # ocamlopt generates PIC code or doesn't generate code at all + ;; #( + *) : + case $host in #( + *-linux-musl) : + # Alpine and other musl-based Linux distributions + common_cflags="-no-pie $common_cflags" ;; #( + *) : + ;; +esac ;; +esac + # Assembler if test -n "$host_alias"; then : @@ -13858,7 +13956,7 @@ esac ;; #( *,dragonfly) : default_as="${toolpref}as" default_aspp="${toolpref}cc -c" ;; #( - amd64,*|arm,*|arm64,*|i386,*) : + amd64,*|arm,*|arm64,*|i386,*|riscv,*) : case $ocaml_cv_cc_vendor in #( clang-*) : default_as="${toolpref}clang -c -Wno-trigraphs" @@ -14031,21 +14129,93 @@ if test "x$ac_cv_func_issetugid" = xyes; then : fi -## clock_gettime, for the instrumented runtime +## Checking for monotonic clock source +## On Windows MSVC, QueryPerformanceCounter and QueryPerformanceFrequency +## are always available. +## On Unix platforms, we check for the appropriate POSIX feature-test macros. +## On MacOS clock_gettime's CLOCK_MONOTONIC flag is not actually monotonic. +## mach_timebase_info and mach_absolute_time are used instead. -## Note: on MinGW, configure finds a clock_gettime and thus the build -# system tries to build the instrumented runtime, which causes -# warnings. For the moment we simply disable it on MinGW -# but this would need to be further investigated case $host in #( - *-*-mingw32) : - instrumented_runtime=false ;; #( + *-*-windows) : + has_monotonic_clock=true ;; #( + *-apple-darwin*) : + + for ac_func in mach_timebase_info mach_absolute_time +do : + as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` +ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" +if eval test \"x\$"$as_ac_var"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 +_ACEOF + + has_monotonic_clock=true + $as_echo "#define HAS_MACH_ABSOLUTE_TIME 1" >>confdefs.h + + +else + has_monotonic_clock=false +fi +done + ;; #( *) : - if test "x$enable_instrumented_runtime" = "xno" ; then : - instrumented_runtime=false; instrumented_runtime_libs="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + #include + #include + int main(void) + { + #if !(defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK) \ + && _POSIX_MONOTONIC_CLOCK != (-1)) + #error "no monotonic clock source" + #endif + return 0; + } + +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + + has_monotonic_clock=true + $as_echo "#define HAS_POSIX_MONOTONIC_CLOCK 1" >>confdefs.h + + else + has_monotonic_clock=false +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5 + ;; +esac + +# The instrumented runtime is built by default +# if the proper clock source is found. +# If asked via --enable-instrumented-runtime, configuration fails if the proper +# clock source is missing. +if test "x$enable_instrumented_runtime" != "xno" ; then : + + case $host in #( + *-*-windows) : + instrumented_runtime=true ;; #( + *-apple-darwin*) : + + case $enable_instrumented_runtime,$has_monotonic_clock in #( + *,true) : + instrumented_runtime=true ;; #( + yes,false) : + + as_fn_error $? "Instrumented runtime support requested \ +but no proper monotonic clock source was found." "$LINENO" 5 + ;; #( + auto,false) : + instrumented_runtime=false + ;; #( + *) : + ;; +esac ;; #( + *) : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5 $as_echo_n "checking for library containing clock_gettime... " >&6; } if ${ac_cv_search_clock_gettime+:} false; then : $as_echo_n "(cached) " >&6 @@ -14103,24 +14273,40 @@ else has_clock_gettime=false fi - case $enable_instrumented_runtime,$has_clock_gettime in #( - *,true) : - instrumented_runtime=true - if test "x$ac_cv_search_clock_gettime" = "xnone required"; then : - instrumented_runtime_libs="" -else - instrumented_runtime_libs=$ac_cv_search_clock_gettime -fi ;; #( - auto,*) : + case $enable_instrumented_runtime,$has_clock_gettime,$has_monotonic_clock in #( + auto,false,*) : + instrumented_runtime=false ;; #( + auto,*,false) : instrumented_runtime=false ;; #( - yes,*) : - as_fn_error $? "the instrumented runtime can not be built" "$LINENO" 5 ;; #( + *,true,true) : + + instrumented_runtime=true + if test "x$ac_cv_search_clock_gettime" = "xnone required"; then : + instrumented_runtime_ldlibs="" +else + instrumented_runtime_ldlibs=$ac_cv_search_clock_gettime + +fi + ;; #( + yes,false,*) : + + as_fn_error $? "Instrumented runtime support requested \ +but clock_gettime is missing." "$LINENO" 5 + ;; #( + yes,*,false) : + + as_fn_error $? "Instrumented runtime support requested \ +but no proper monotonic clock source was found." "$LINENO" 5 + + ;; #( *) : ;; esac -fi ;; + ;; esac +fi + ## Sockets ## TODO: check whether the different libraries are really useful @@ -14131,6 +14317,9 @@ case $host in #( *-*-mingw32|*-pc-windows) : cclibs="$cclibs -lws2_32" sockets=true ;; #( + *-*-haiku) : + cclibs="$cclibs -lnetwork" + sockets=true ;; #( *) : ac_fn_c_check_func "$LINENO" "socket" "ac_cv_func_socket" @@ -14539,6 +14728,19 @@ if test "x$ac_cv_func_putenv" = xyes; then : fi +## setenv and unsetenv + +ac_fn_c_check_func "$LINENO" "setenv" "ac_cv_func_setenv" +if test "x$ac_cv_func_setenv" = xyes; then : + ac_fn_c_check_func "$LINENO" "unsetenv" "ac_cv_func_unsetenv" +if test "x$ac_cv_func_unsetenv" = xyes; then : + $as_echo "#define HAS_SETENV_UNSETENV 1" >>confdefs.h + +fi + +fi + + ## newlocale() and # Note: the detection fails on msvc so we hardcode the result # (should be debugged later) @@ -16691,6 +16893,13 @@ else ocamldoc=ocamldoc fi +case $enable_ocamltest,4.11.0 in #( + yes,*|,*+dev*) : + ocamltest='ocamltest' ;; #( + *) : + ocamltest='' ;; +esac + if test x"$enable_flambda" = "xyes"; then : flambda=true if test x"$enable_flambda_invariants" = "xyes"; then : @@ -16790,8 +16999,6 @@ oc_cflags="$common_cflags $internal_cflags" oc_cppflags="$common_cppflags $internal_cppflags" ocamlc_cflags="$common_cflags $sharedlib_cflags" ocamlc_cppflags="$common_cppflags" -ocamlopt_cflags="$common_cflags" -ocamlopt_cppflags="$common_cppflags" cclibs="$cclibs $mathlib" case $host in #( @@ -16802,7 +17009,7 @@ case $host in #( bytecclibs="advapi32.lib ws2_32.lib version.lib" nativecclibs="advapi32.lib ws2_32.lib version.lib" ;; #( *) : - bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_libs" + bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_ldlibs" nativecclibs="$cclibs $DLLIBS" ;; esac @@ -17403,7 +17610,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by OCaml $as_me 4.10.1, which was +This file was extended by OCaml $as_me 4.11.0, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -17470,7 +17677,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -OCaml config.status 4.10.1 +OCaml config.status 4.11.0 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" @@ -17882,6 +18089,7 @@ do case $ac_config_target in "Makefile.common") CONFIG_FILES="$CONFIG_FILES Makefile.common" ;; "Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;; + "tools/eventlog_metadata") CONFIG_FILES="$CONFIG_FILES tools/eventlog_metadata" ;; "runtime/caml/m.h") CONFIG_HEADERS="$CONFIG_HEADERS runtime/caml/m.h" ;; "runtime/caml/s.h") CONFIG_HEADERS="$CONFIG_HEADERS runtime/caml/s.h" ;; "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; diff --git a/configure.ac b/configure.ac index f0987d0a..aa5f26f2 100644 --- a/configure.ac +++ b/configure.ac @@ -47,8 +47,6 @@ internal_cflags="" internal_cppflags="" ocamlc_cflags="" ocamlc_cppflags="" -ocamlopt_cflags="" -ocamlopt_cppflags="" oc_ldflags="" with_sharedlibs=true ostype="Unix" @@ -58,6 +56,8 @@ toolchain="cc" profinfo=false profinfo_width=0 extralibs= +instrumented_runtime=false +instrumented_runtime_ldlibs="" # Information about the package @@ -108,8 +108,6 @@ AC_SUBST([bytecclibs]) AC_SUBST([nativecclibs]) AC_SUBST([ocamlc_cflags]) AC_SUBST([ocamlc_cppflags]) -AC_SUBST([ocamlopt_cflags]) -AC_SUBST([ocamlopt_cppflags]) AC_SUBST([iflexdir]) AC_SUBST([long_shebang]) AC_SUBST([shebangscripts]) @@ -123,12 +121,14 @@ AC_SUBST([natdynlinkopts]) AC_SUBST([cmxs]) AC_SUBST([debug_runtime]) AC_SUBST([instrumented_runtime]) +AC_SUBST([has_monotonic_clock]) AC_SUBST([otherlibraries]) AC_SUBST([cc_has_debug_prefix_map]) AC_SUBST([as_has_debug_prefix_map]) AC_SUBST([with_debugger]) # TODO: rename this variable AC_SUBST([with_camltex]) AC_SUBST([ocamldoc]) +AC_SUBST([ocamltest]) AC_SUBST([pthread_link]) AC_SUBST([x_includes]) AC_SUBST([x_libraries]) @@ -136,6 +136,7 @@ AC_SUBST([bfd_cppflags]) AC_SUBST([bfd_ldflags]) AC_SUBST([bfd_ldlibs]) AC_SUBST([ASPP]) +AC_SUBST([endianness]) AC_SUBST([AS]) AC_SUBST([asm_cfi_supported]) AC_SUBST([sharedlib_cflags]) @@ -171,6 +172,7 @@ AC_SUBST([stdlib_manpages]) AC_CONFIG_FILES([Makefile.common]) AC_CONFIG_FILES([Makefile.config]) +AC_CONFIG_FILES([tools/eventlog_metadata]) AC_CONFIG_HEADERS([runtime/caml/m.h]) AC_CONFIG_HEADERS([runtime/caml/s.h]) @@ -276,6 +278,10 @@ AC_ARG_ENABLE([ocamldoc], [], [ocamldoc=auto]) +AC_ARG_ENABLE([ocamltest], + [AS_HELP_STRING([--disable-ocamltest], + [do not build the ocamltest driver])]) + AC_ARG_ENABLE([frame-pointers], [AS_HELP_STRING([--enable-frame-pointers], [use frame pointers in runtime and generated code])]) @@ -525,12 +531,12 @@ AS_CASE([$ocaml_cv_cc_vendor], [outputobj='-o $(EMPTY)'; gcc_warnings="-qflag=i:i"], # all warnings enabled [msvc-*], [outputobj=-Fo; gcc_warnings=""], - [outputobj='-o $(EMPTY)'; AS_CASE([AC_PACKAGE_VERSION], + [outputobj='-o $(EMPTY)' + gcc_warnings='-Wall -Wdeclaration-after-statement' + AS_CASE([AC_PACKAGE_VERSION], [*+dev*], - [gcc_warnings="-Wall -Werror"], - [gcc_warnings="-Wall"] - )] -) + [gcc_warnings="$gcc_warnings -Werror"]) + ]) # We select high optimization levels, provided we can turn off: # - strict type-based aliasing analysis (too risky for the OCaml runtime) @@ -549,36 +555,49 @@ AS_CASE([$ocaml_cv_cc_vendor], # in the macro itself, too AS_CASE([$host], [*-*-mingw32], - [internal_cflags="-Wno-unused $gcc_warnings" - # TODO: see whether the code can be fixed to avoid -Wno-unused - common_cflags="-O -mms-bitfields" - internal_cppflags='-DUNICODE -D_UNICODE' - internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE=" - internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)"], + [AS_CASE([$ocaml_cv_cc_vendor], + [gcc-[[01234]]-*], + [AC_MSG_ERROR(m4_normalize([This version of Mingw GCC is too old. + Please use GCC version 5 or above.]))], + [gcc-*], + [internal_cflags="-Wno-unused $gcc_warnings \ +-fexcess-precision=standard" + # TODO: see whether the code can be fixed to avoid -Wno-unused + common_cflags="-O2 -fno-strict-aliasing -fwrapv -mms-bitfields" + internal_cppflags='-DUNICODE -D_UNICODE' + internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE=" + internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)"], + [AC_MSG_ERROR([Unsupported C compiler for a Mingw build])])], [AS_CASE([$ocaml_cv_cc_vendor], [clang-*], [common_cflags="-O2 -fno-strict-aliasing -fwrapv"; internal_cflags="$gcc_warnings -fno-common"], - [gcc-[012]-*], + [gcc-[[012]]-*], # Some versions known to miscompile OCaml, e,g, 2.7.2.1, some 2.96. # Plus: C99 support unknown. - [AC_MSG_ERROR([This version of GCC is too old. - Please use GCC version 4.2 or above.])], - [gcc-3-*|gcc-4-[01]], + [AC_MSG_ERROR(m4_normalize([This version of GCC is too old. + Please use GCC version 4.2 or above.]))], + [gcc-3-*|gcc-4-[[01]]], # No -fwrapv option before GCC 3.4. # Known problems with -fwrapv fixed in 4.2 only. - [AC_MSG_WARN([This version of GCC is rather old. - Reducing optimization level."]); + [AC_MSG_WARN(m4_normalize([This version of GCC is rather old. + Reducing optimization level."])); AC_MSG_WARN([Consider using GCC version 4.2 or above.]); common_cflags="-std=gnu99 -O"; internal_cflags="$gcc_warnings"], - [gcc-4-*], + [gcc-4-[[234]]], + # No -fexcess-precision option before GCC 4.5 [common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \ -fno-builtin-memcmp"; internal_cflags="$gcc_warnings"], + [gcc-4-*], + [common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \ +-fno-builtin-memcmp"; + internal_cflags="$gcc_warnings -fexcess-precision=standard"], [gcc-*], [common_cflags="-O2 -fno-strict-aliasing -fwrapv"; - internal_cflags="$gcc_warnings -fno-common"], + internal_cflags="$gcc_warnings -fno-common \ +-fexcess-precision=standard"], [msvc-*], [common_cflags="-nologo -O2 -Gy- -MD" common_cppflags="-D_CRT_SECURE_NO_DEPRECATE" @@ -744,22 +763,30 @@ AC_DEFINE_UNQUOTED([SIZEOF_LONGLONG], [$ac_cv_sizeof_long_long]) AC_MSG_NOTICE([Target is a $bits bits architecture]) AC_C_BIGENDIAN( - [AC_DEFINE([ARCH_BIG_ENDIAN], [1])], - [], + [ + AC_DEFINE([ARCH_BIG_ENDIAN], [1]), + [endianness="be"] + ], + [endianness="le"], [AC_MSG_ERROR([could not determine endianness.])], [AC_MSG_ERROR([unable to handle universal endianness])] ) AC_CHECK_ALIGNOF([double]) AC_CHECK_ALIGNOF([long]) +AC_CHECK_ALIGNOF([long long]) AS_IF([! $arch64], [AS_CASE([$target_cpu], [i686], [], [AS_IF([test "$ac_cv_alignof_double" -gt 4], [AC_DEFINE([ARCH_ALIGN_DOUBLE], [1])]) - AS_IF([test "$ac_cv_alignof_long" -gt 4], - [AC_DEFINE([ARCH_ALIGN_LONG], [1])]) + AS_IF([test "x$ac_cv_sizeof_long" = "x8" && + test "$ac_cv_alignof_long" -gt 4], + [AC_DEFINE([ARCH_ALIGN_INT64], [1])], + [AS_IF([test "x$ac_cv_sizeof_long_long" = "x8" && + test "$ac_cv_alignof_long_long" -gt 4], + [AC_DEFINE([ARCH_ALIGN_INT64], [1])])]) ])]) # Shared library support @@ -836,7 +863,8 @@ AS_IF([test x"$enable_shared" != "xno"], [arm*-*-freebsd*], [natdynlink=true], [earm*-*-netbsd*], [natdynlink=true], [aarch64-*-linux*], [natdynlink=true], - [aarch64-*-freebsd*], [natdynlink=true])]) + [aarch64-*-freebsd*], [natdynlink=true], + [riscv*-*-linux*], [natdynlink=true])]) # Try to work around the Skylake/Kaby Lake processor bug. AS_CASE(["$CC,$host"], @@ -929,7 +957,9 @@ AS_CASE([$host], [aarch64-*-freebsd*], [arch=arm64; system=freebsd], [x86_64-*-cygwin*], - [arch=amd64; system=cygwin] + [arch=amd64; system=cygwin], + [riscv64-*-linux*], + [arch=riscv; model=riscv64; system=linux] ) AS_IF([test x"$enable_native_compiler" = "xno"], @@ -964,6 +994,27 @@ AS_IF([test -z "$PARTIALLD"], AS_IF([test $arch != "none" && $arch64 ], [otherlibraries="$otherlibraries raw_spacetime_lib"]) +# Disable PIE at link time when ocamlopt does not produce position-independent +# code and the system produces PIE executables by default and demands PIC +# object files to do so. +# This issue does not affect amd64 (x86_64) and s390x (Z systems), +# since ocamlopt produces PIC object files by default. +# Currently the problem is known for Alpine Linux on platforms other +# than amd64 and s390x (issue #7562), and probably affects all Linux +# distributions that use the musl standard library and dynamic loader. +# Other systems have PIE by default but can cope with non-PIC object files, +# e.g. Ubuntu >= 17.10 for i386, which uses the glibc dynamic loader. + +AS_CASE([$arch], + [amd64|s390x|none], + # ocamlopt generates PIC code or doesn't generate code at all + [], + [AS_CASE([$host], + [*-linux-musl], + # Alpine and other musl-based Linux distributions + [common_cflags="-no-pie $common_cflags"], + [])]) + # Assembler AS_IF([test -n "$host_alias"], [toolpref="${host_alias}-"], [toolpref=""]) @@ -1012,7 +1063,7 @@ AS_CASE(["$arch,$system"], [*,dragonfly], [default_as="${toolpref}as" default_aspp="${toolpref}cc -c"], - [amd64,*|arm,*|arm64,*|i386,*], + [amd64,*|arm,*|arm64,*|i386,*|riscv,*], [AS_CASE([$ocaml_cv_cc_vendor], [clang-*], [default_as="${toolpref}clang -c -Wno-trigraphs" default_aspp="${toolpref}clang -c -Wno-trigraphs"], @@ -1078,30 +1129,91 @@ CPPFLAGS="$saved_CPPFLAGS" AC_CHECK_FUNC([issetugid], [AC_DEFINE([HAS_ISSETUGID])]) -## clock_gettime, for the instrumented runtime +## Checking for monotonic clock source +## On Windows MSVC, QueryPerformanceCounter and QueryPerformanceFrequency +## are always available. +## On Unix platforms, we check for the appropriate POSIX feature-test macros. +## On MacOS clock_gettime's CLOCK_MONOTONIC flag is not actually monotonic. +## mach_timebase_info and mach_absolute_time are used instead. -## Note: on MinGW, configure finds a clock_gettime and thus the build -# system tries to build the instrumented runtime, which causes -# warnings. For the moment we simply disable it on MinGW -# but this would need to be further investigated AS_CASE([$host], - [*-*-mingw32], [instrumented_runtime=false], - [AS_IF([test "x$enable_instrumented_runtime" = "xno" ], - [instrumented_runtime=false; instrumented_runtime_libs=""], + [*-*-windows], + [has_monotonic_clock=true], + [*-apple-darwin*], [ + AC_CHECK_FUNCS([mach_timebase_info mach_absolute_time], + [ + has_monotonic_clock=true + AC_DEFINE([HAS_MACH_ABSOLUTE_TIME]) + ], + [has_monotonic_clock=false])], + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ + #include + #include + int main(void) + { + #if !(defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK) \ + && _POSIX_MONOTONIC_CLOCK != (-1)) + #error "no monotonic clock source" + #endif + return 0; + } + ]])], [ - AC_SEARCH_LIBS([clock_gettime], [rt], - [has_clock_gettime=true], - [has_clock_gettime=false]) - AS_CASE([$enable_instrumented_runtime,$has_clock_gettime], + has_monotonic_clock=true + AC_DEFINE([HAS_POSIX_MONOTONIC_CLOCK]) + ], + [has_monotonic_clock=false]) + ] +) + +# The instrumented runtime is built by default +# if the proper clock source is found. +# If asked via --enable-instrumented-runtime, configuration fails if the proper +# clock source is missing. +AS_IF([test "x$enable_instrumented_runtime" != "xno" ], + [ + AS_CASE([$host], + [*-*-windows], + [instrumented_runtime=true], + [*-apple-darwin*], [ + AS_CASE([$enable_instrumented_runtime,$has_monotonic_clock], [*,true], - [instrumented_runtime=true - AS_IF([test "x$ac_cv_search_clock_gettime" = "xnone required"], - [instrumented_runtime_libs=""], - [instrumented_runtime_libs=$ac_cv_search_clock_gettime])], - [auto,*], - [instrumented_runtime=false], - [yes,*], - [AC_MSG_ERROR([the instrumented runtime can not be built])])])]) + [instrumented_runtime=true], + [yes,false], [ + AC_MSG_ERROR([Instrumented runtime support requested \ +but no proper monotonic clock source was found.]) + ], + [auto,false], + [instrumented_runtime=false] + )], + [AC_SEARCH_LIBS([clock_gettime], [rt], + [has_clock_gettime=true], + [has_clock_gettime=false]) + AS_CASE( + [$enable_instrumented_runtime,$has_clock_gettime,$has_monotonic_clock], + [auto,false,*], [instrumented_runtime=false], + [auto,*,false], [instrumented_runtime=false], + [*,true,true], + [ + instrumented_runtime=true + AS_IF([test "x$ac_cv_search_clock_gettime" = "xnone required"], + [instrumented_runtime_ldlibs=""], + [instrumented_runtime_ldlibs=$ac_cv_search_clock_gettime] + ) + ], + [yes,false,*], + [ + AC_MSG_ERROR([Instrumented runtime support requested \ +but clock_gettime is missing.]) + ], + [yes,*,false], + [ + AC_MSG_ERROR([Instrumented runtime support requested \ +but no proper monotonic clock source was found.]) + ] + )] + )] +) ## Sockets @@ -1113,6 +1225,9 @@ AS_CASE([$host], [*-*-mingw32|*-pc-windows], [cclibs="$cclibs -lws2_32" sockets=true], + [*-*-haiku], + [cclibs="$cclibs -lnetwork" + sockets=true], [ AC_CHECK_FUNC([socket]) AC_CHECK_FUNC([socketpair]) @@ -1279,6 +1394,11 @@ AS_CASE([$host], AC_CHECK_FUNC([putenv], [AC_DEFINE([HAS_PUTENV])]) +## setenv and unsetenv + +AC_CHECK_FUNC([setenv], + [AC_CHECK_FUNC([unsetenv], [AC_DEFINE([HAS_SETENV_UNSETENV])])]) + ## newlocale() and # Note: the detection fails on msvc so we hardcode the result # (should be debugged later) @@ -1677,6 +1797,10 @@ AS_IF([test x"$enable_ocamldoc" = "xno"], [ocamldoc=""], [ocamldoc=ocamldoc]) +AS_CASE([$enable_ocamltest,AC_PACKAGE_VERSION], + [yes,*|,*+dev*],[ocamltest='ocamltest'], + [ocamltest='']) + AS_IF([test x"$enable_flambda" = "xyes"], [flambda=true AS_IF([test x"$enable_flambda_invariants" = "xyes"], @@ -1740,8 +1864,6 @@ oc_cflags="$common_cflags $internal_cflags" oc_cppflags="$common_cppflags $internal_cppflags" ocamlc_cflags="$common_cflags $sharedlib_cflags" ocamlc_cppflags="$common_cppflags" -ocamlopt_cflags="$common_cflags" -ocamlopt_cppflags="$common_cppflags" cclibs="$cclibs $mathlib" AS_CASE([$host], @@ -1751,7 +1873,7 @@ AS_CASE([$host], [*-pc-windows], [bytecclibs="advapi32.lib ws2_32.lib version.lib" nativecclibs="advapi32.lib ws2_32.lib version.lib"], - [bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_libs" + [bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_ldlibs" nativecclibs="$cclibs $DLLIBS"]) AS_IF([test x"$libdir" = x'${exec_prefix}/lib'], diff --git a/debugger/.depend b/debugger/.depend index 5fdc17ea..1ba1295f 100644 --- a/debugger/.depend +++ b/debugger/.depend @@ -54,13 +54,11 @@ command_line.cmo : \ primitives.cmi \ pos.cmi \ parser_aux.cmi \ - parser.cmi \ parameters.cmi \ ../parsing/longident.cmi \ ../parsing/location.cmi \ loadprinter.cmi \ ../utils/load_path.cmi \ - lexer.cmi \ int64ops.cmi \ ../bytecomp/instruct.cmi \ input_handling.cmi \ @@ -70,6 +68,8 @@ command_line.cmo : \ eval.cmi \ ../typing/envaux.cmi \ ../typing/env.cmi \ + debugger_parser.cmi \ + debugger_lexer.cmi \ debugger_config.cmi \ debugcom.cmi \ ../typing/ctype.cmi \ @@ -92,13 +92,11 @@ command_line.cmx : \ primitives.cmx \ pos.cmx \ parser_aux.cmi \ - parser.cmx \ parameters.cmx \ ../parsing/longident.cmx \ ../parsing/location.cmx \ loadprinter.cmx \ ../utils/load_path.cmx \ - lexer.cmx \ int64ops.cmx \ ../bytecomp/instruct.cmx \ input_handling.cmx \ @@ -108,6 +106,8 @@ command_line.cmx : \ eval.cmx \ ../typing/envaux.cmx \ ../typing/env.cmx \ + debugger_parser.cmx \ + debugger_lexer.cmx \ debugger_config.cmx \ debugcom.cmx \ ../typing/ctype.cmx \ @@ -139,6 +139,31 @@ debugger_config.cmx : \ int64ops.cmx \ debugger_config.cmi debugger_config.cmi : +debugger_lexer.cmo : \ + debugger_parser.cmi \ + debugger_lexer.cmi +debugger_lexer.cmx : \ + debugger_parser.cmx \ + debugger_lexer.cmi +debugger_lexer.cmi : \ + debugger_parser.cmi +debugger_parser.cmo : \ + parser_aux.cmi \ + ../parsing/longident.cmi \ + int64ops.cmi \ + input_handling.cmi \ + debugcom.cmi \ + debugger_parser.cmi +debugger_parser.cmx : \ + parser_aux.cmi \ + ../parsing/longident.cmx \ + int64ops.cmx \ + input_handling.cmx \ + debugcom.cmx \ + debugger_parser.cmi +debugger_parser.cmi : \ + parser_aux.cmi \ + ../parsing/longident.cmi eval.cmo : \ ../typing/types.cmi \ ../bytecomp/symtable.cmi \ @@ -249,14 +274,6 @@ int64ops.cmo : \ int64ops.cmx : \ int64ops.cmi int64ops.cmi : -lexer.cmo : \ - parser.cmi \ - lexer.cmi -lexer.cmx : \ - parser.cmx \ - lexer.cmi -lexer.cmi : \ - parser.cmi loadprinter.cmo : \ ../typing/types.cmi \ ../bytecomp/symtable.cmi \ @@ -347,23 +364,6 @@ parameters.cmx : \ ../utils/config.cmx \ parameters.cmi parameters.cmi : -parser.cmo : \ - parser_aux.cmi \ - ../parsing/longident.cmi \ - int64ops.cmi \ - input_handling.cmi \ - debugcom.cmi \ - parser.cmi -parser.cmx : \ - parser_aux.cmi \ - ../parsing/longident.cmx \ - int64ops.cmx \ - input_handling.cmx \ - debugcom.cmx \ - parser.cmi -parser.cmi : \ - parser_aux.cmi \ - ../parsing/longident.cmi parser_aux.cmi : \ ../parsing/longident.cmi \ debugcom.cmi @@ -490,13 +490,13 @@ program_management.cmx : \ program_management.cmi : question.cmo : \ primitives.cmi \ - lexer.cmi \ input_handling.cmi \ + debugger_lexer.cmi \ question.cmi question.cmx : \ primitives.cmx \ - lexer.cmx \ input_handling.cmx \ + debugger_lexer.cmx \ question.cmi question.cmi : show_information.cmo : \ diff --git a/debugger/Makefile b/debugger/Makefile index 0d5037c0..9b8c11f0 100644 --- a/debugger/Makefile +++ b/debugger/Makefile @@ -15,8 +15,8 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common include $(ROOTDIR)/Makefile.best_binaries DYNLINKDIR=$(ROOTDIR)/otherlibs/dynlink @@ -39,55 +39,32 @@ DIRECTORIES=$(UNIXDIR) $(DYNLINKDIR) $(addprefix $(ROOTDIR)/,\ INCLUDES=$(addprefix -I ,$(DIRECTORIES)) -utils_modules := $(addprefix utils/,\ - config build_path_prefix_map misc identifiable numbers arg_helper clflags \ - consistbl warnings terminfo load_path) - -parsing_modules := $(addprefix parsing/,\ - location longident docstrings syntaxerr ast_helper ast_mapper ast_iterator \ - attr_helper builtin_attributes pprintast) - -typing_modules := $(addprefix typing/,\ - ident path type_immediacy types btype primitive typedtree subst predef \ - datarepr persistent_env env oprint ctype printtyp mtype envaux) - -file_formats_modules := $(addprefix file_formats/,\ - cmi_format) - -lambda_modules := $(addprefix lambda/,\ - runtimedef) - -bytecomp_modules := $(addprefix bytecomp/,\ - bytesections dll meta symtable opcodes) - -other_compiler_modules := toplevel/genprintval - -compiler_modules := $(addprefix $(ROOTDIR)/,\ - $(utils_modules) $(parsing_modules) $(file_formats_modules) \ - $(lambda_modules) \ - $(typing_modules) $(bytecomp_modules) $(other_compiler_modules)) +compiler_modules := $(ROOTDIR)/toplevel/genprintval debugger_modules := \ - int64ops primitives unix_tools debugger_config parameters lexer \ + int64ops primitives unix_tools debugger_config parameters debugger_lexer \ input_handling question debugcom exec source pos checkpoints events \ program_loading symbols breakpoints trap_barrier history printval \ show_source time_travel program_management frames eval \ - show_information loadprinter parser command_line main + show_information loadprinter debugger_parser command_line main all_modules := $(compiler_modules) $(debugger_modules) all_objects := $(addsuffix .cmo,$(all_modules)) +libraries = $(ROOTDIR)/compilerlibs/ocamlcommon.cma \ + $(UNIXDIR)/unix.cma $(DYNLINKDIR)/dynlink.cma + all: ocamldebug$(EXE) -ocamldebug$(EXE): $(UNIXDIR)/unix.cma $(DYNLINKDIR)/dynlink.cma $(all_objects) +ocamldebug$(EXE): $(libraries) $(all_objects) $(CAMLC) $(LINKFLAGS) -o $@ -linkall $^ install: $(INSTALL_PROG) ocamldebug$(EXE) "$(INSTALL_BINDIR)/ocamldebug$(EXE)" clean:: - rm -f ocamldebug$(EXE) + rm -f ocamldebug ocamldebug.exe rm -f *.cmo *.cmi .SUFFIXES: @@ -103,16 +80,16 @@ depend: beforedepend $(CAMLDEP) $(DEPFLAGS) $(DEPINCLUDES) *.mli *.ml \ | sed -e 's,$(UNIXDIR)/,$$(UNIXDIR)/,' > .depend -lexer.ml: lexer.mll +debugger_lexer.ml: debugger_lexer.mll $(CAMLLEX) $(OCAMLLEX_FLAGS) $< clean:: - rm -f lexer.ml -beforedepend:: lexer.ml + rm -f debugger_lexer.ml +beforedepend:: debugger_lexer.ml -parser.ml parser.mli: parser.mly - $(CAMLYACC) parser.mly +debugger_parser.ml debugger_parser.mli: debugger_parser.mly + $(CAMLYACC) debugger_parser.mly clean:: - rm -f parser.ml parser.mli -beforedepend:: parser.ml parser.mli + rm -f debugger_parser.ml debugger_parser.mli +beforedepend:: debugger_parser.ml debugger_parser.mli include .depend diff --git a/debugger/breakpoints.ml b/debugger/breakpoints.ml index f3755282..60059fcd 100644 --- a/debugger/breakpoints.ml +++ b/debugger/breakpoints.ml @@ -206,10 +206,4 @@ let exec_with_temporary_breakpoint pc funct = in Exec.protect (function () -> insert_position pc); temporary_breakpoint_position := Some pc; - try - funct (); - Exec.protect remove - with - x -> - Exec.protect remove; - raise x + Fun.protect ~finally:(fun () -> Exec.protect remove) funct diff --git a/debugger/command_line.ml b/debugger/command_line.ml index b9bc9d2f..3884c3aa 100644 --- a/debugger/command_line.ml +++ b/debugger/command_line.ml @@ -24,9 +24,9 @@ open Debugger_config open Types open Primitives open Unix_tools -open Parser +open Debugger_parser open Parser_aux -open Lexer +open Debugger_lexer open Input_handling open Question open Debugcom @@ -45,6 +45,8 @@ open Checkpoints open Frames open Printval +module Lexer = Debugger_lexer + (** Instructions, variables and infos lists. **) type dbg_instruction = { instr_name: string; (* Name of command *) @@ -208,7 +210,7 @@ let line_loop ppf line_buffer = done with | Exit -> - stop_user_input () + () (* | Sys_error s -> error ("System error: " ^ s) *) @@ -565,20 +567,17 @@ let instr_source ppf lexbuf = | Not_found -> error "Source file not found." | (Unix_error _) as x -> Unix_tools.report_error x; raise Toplevel in - try - interactif := false; - user_channel := io_chan; - line_loop ppf (Lexing.from_function read_user_input); + interactif := false; + user_channel := io_chan; + let loop () = + line_loop ppf (Lexing.from_function read_user_input) + and finally () = + stop_user_input (); close_io io_chan; interactif := old_state; user_channel := old_channel - with - | x -> - stop_user_input (); - close_io io_chan; - interactif := old_state; - user_channel := old_channel; - raise x + in + Fun.protect ~finally loop let instr_set = find_variable diff --git a/debugger/debugger_lexer.mli b/debugger/debugger_lexer.mli new file mode 100644 index 00000000..0c364d68 --- /dev/null +++ b/debugger/debugger_lexer.mli @@ -0,0 +1,22 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *) +(* OCaml port by John Malecki and Xavier Leroy *) +(* *) +(* Copyright 1996 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. *) +(* *) +(**************************************************************************) + +exception Int_overflow + +val line: Lexing.lexbuf -> string +val lexeme: Lexing.lexbuf -> Debugger_parser.token +val argument: Lexing.lexbuf -> Debugger_parser.token +val line_argument: Lexing.lexbuf -> Debugger_parser.token diff --git a/debugger/debugger_lexer.mll b/debugger/debugger_lexer.mll new file mode 100644 index 00000000..a1804272 --- /dev/null +++ b/debugger/debugger_lexer.mll @@ -0,0 +1,104 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *) +(* OCaml port by John Malecki and Xavier Leroy *) +(* *) +(* Copyright 1996 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 Debugger_parser + +exception Int_overflow + +} + +rule line = (* Read a whole line *) + parse + ([ ^ '\n' '\r' ]* as s) ('\n' | '\r' | "\r\n") + { s } + | [ ^ '\n' '\r' ]* + { Lexing.lexeme lexbuf } + | eof + { raise Exit } + +and argument = (* Read a raw argument *) + parse + [ ^ ' ' '\t' ]+ + { ARGUMENT (Lexing.lexeme lexbuf) } + | [' ' '\t']+ + { argument lexbuf } + | eof + { EOL } + | _ + { raise Parsing.Parse_error } + +and line_argument = + parse + _ * + { ARGUMENT (Lexing.lexeme lexbuf) } + | eof + { EOL } + +and lexeme = (* Read a lexeme *) + parse + [' ' '\t'] + + { lexeme lexbuf } + | ['a'-'z' '\223'-'\246' '\248'-'\255' '_'] + (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' + '\'' '0'-'9' ]) * + { LIDENT(Lexing.lexeme lexbuf) } + | ['A'-'Z' '\192'-'\214' '\216'-'\222' ] + (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' + '\'' '0'-'9' ]) * + { UIDENT(Lexing.lexeme lexbuf) } + | '"' [^ '"']* "\"" + { let s = Lexing.lexeme lexbuf in + LIDENT(String.sub s 1 (String.length s - 2)) } + | ['0'-'9']+ + | '0' ['x' 'X'] ['0'-'9' 'A'-'F' 'a'-'f']+ + | '0' ['o' 'O'] ['0'-'7']+ + | '0' ['b' 'B'] ['0'-'1']+ + { try INTEGER (Int64.of_string (Lexing.lexeme lexbuf)) + with Failure _ -> raise Int_overflow + } + | '*' + { STAR } + | "-" + { MINUS } + | "." + { DOT } + | "#" + { HASH } + | "@" + { AT } + | "$" + { DOLLAR } + | ":" + { COLON } + | "!" + { BANG } + | "(" + { LPAREN } + | ")" + { RPAREN } + | "[" + { LBRACKET } + | "]" + { RBRACKET } + | ['!' '?' '~' '=' '<' '>' '|' '&' '$' '@' '^' '+' '-' '*' '/' '%'] + ['!' '$' '%' '&' '*' '+' '-' '.' '/' ':' '<' '=' '>' '?' '@' '^' '|' '~'] * + { OPERATOR (Lexing.lexeme lexbuf) } + | eof + { EOL } + | _ + { raise Parsing.Parse_error } diff --git a/debugger/debugger_parser.mly b/debugger/debugger_parser.mly new file mode 100644 index 00000000..b8789d94 --- /dev/null +++ b/debugger/debugger_parser.mly @@ -0,0 +1,260 @@ +/**************************************************************************/ +/* */ +/* OCaml */ +/* */ +/* Jerome Vouillon, projet Cristal, INRIA Rocquencourt */ +/* OCaml port by John Malecki and Xavier Leroy */ +/* */ +/* Copyright 1996 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 Int64ops +open Input_handling +open Longident +open Parser_aux +open Debugcom + +%} + +%token ARGUMENT +%token LIDENT +%token UIDENT +%token OPERATOR +%token INTEGER +%token STAR /* * */ +%token MINUS /* - */ +%token DOT /* . */ +%token COLON /* : */ +%token HASH /* # */ +%token AT /* @ */ +%token DOLLAR /* $ */ +%token BANG /* ! */ +%token LPAREN /* ( */ +%token RPAREN /* ) */ +%token LBRACKET /* [ */ +%token RBRACKET /* ] */ +%token EOL + +%right DOT +%right BANG + +%start argument_list_eol +%type argument_list_eol + +%start argument_eol +%type argument_eol + +%start integer_list_eol +%type integer_list_eol + +%start integer_eol +%type integer_eol + +%start int64_eol +%type int64_eol + +%start integer +%type integer + +%start opt_integer_eol +%type opt_integer_eol + +%start opt_signed_integer_eol +%type opt_signed_integer_eol + +%start opt_signed_int64_eol +%type opt_signed_int64_eol + +%start identifier +%type identifier + +%start identifier_eol +%type identifier_eol + +%start identifier_or_eol +%type identifier_or_eol + +%start opt_identifier +%type opt_identifier + +%start opt_identifier_eol +%type opt_identifier_eol + +%start expression_list_eol +%type expression_list_eol + +%start break_argument_eol +%type break_argument_eol + +%start list_arguments_eol +%type list_arguments_eol + +%start end_of_line +%type end_of_line + +%start longident_eol +%type longident_eol + +%start opt_longident +%type opt_longident + +%start opt_longident_eol +%type opt_longident_eol + +%% + +/* Raw arguments */ + +argument_list_eol : + ARGUMENT argument_list_eol + { $1::$2 } + | end_of_line + { [] }; + +argument_eol : + ARGUMENT end_of_line + { $1 }; + +/* Integer */ + +integer_list_eol : + INTEGER integer_list_eol + { (to_int $1) :: $2 } + | end_of_line + { [] }; + +integer_eol : + INTEGER end_of_line + { to_int $1 }; + +int64_eol : + INTEGER end_of_line + { $1 }; + +integer : + INTEGER + { to_int $1 }; + +opt_integer_eol : + INTEGER end_of_line + { Some (to_int $1) } + | end_of_line + { None }; + +opt_int64_eol : + INTEGER end_of_line + { Some $1 } + | end_of_line + { None }; + +opt_signed_integer_eol : + MINUS integer_eol + { Some (- $2) } + | opt_integer_eol + { $1 }; + +opt_signed_int64_eol : + MINUS int64_eol + { Some (Int64.neg $2) } + | opt_int64_eol + { $1 }; + +/* Identifiers and long identifiers */ + +longident : + LIDENT { Lident $1 } + | module_path DOT LIDENT { Ldot($1, $3) } + | OPERATOR { Lident $1 } + | module_path DOT OPERATOR { Ldot($1, $3) } + | module_path DOT LPAREN OPERATOR RPAREN { Ldot($1, $4) } +; + +module_path : + UIDENT { Lident $1 } + | module_path DOT UIDENT { Ldot($1, $3) } +; + +longident_eol : + longident end_of_line { $1 }; + +opt_longident : + UIDENT { Some (Lident $1) } + | LIDENT { Some (Lident $1) } + | module_path DOT UIDENT { Some (Ldot($1, $3)) } + | { None }; + +opt_longident_eol : + opt_longident end_of_line { $1 }; + +identifier : + LIDENT { $1 } + | UIDENT { $1 }; + +identifier_eol : + identifier end_of_line { $1 }; + +identifier_or_eol : + identifier { Some $1 } + | end_of_line { None }; + +opt_identifier : + identifier { Some $1 } + | { None }; + +opt_identifier_eol : + opt_identifier end_of_line { $1 }; + +/* Expressions */ + +expression: + longident { E_ident $1 } + | STAR { E_result } + | DOLLAR INTEGER { E_name (to_int $2) } + | expression DOT INTEGER { E_item($1, (to_int $3)) } + | expression DOT LBRACKET INTEGER RBRACKET { E_item($1, (to_int $4)) } + | expression DOT LPAREN INTEGER RPAREN { E_item($1, (to_int $4)) } + | expression DOT LIDENT { E_field($1, $3) } + | BANG expression { E_field($2, "contents") } + | LPAREN expression RPAREN { $2 } +; + +/* Lists of expressions */ + +expression_list_eol : + expression expression_list_eol { $1::$2 } + | end_of_line { [] } +; + +/* Arguments for breakpoint */ + +break_argument_eol : + end_of_line { BA_none } + | integer_eol { BA_pc {frag = 0; pos = $1} } + | INTEGER COLON integer_eol { BA_pc {frag = to_int $1; + pos = $3} } + | expression end_of_line { BA_function $1 } + | AT opt_longident INTEGER opt_integer_eol { BA_pos1 ($2, (to_int $3), $4)} + | AT opt_longident HASH integer_eol { BA_pos2 ($2, $4) } +; + +/* Arguments for list */ + +list_arguments_eol : + opt_longident integer opt_integer_eol + { ($1, Some $2, $3) } + | opt_longident_eol + { ($1, None, None) }; + +/* End of line */ + +end_of_line : + EOL { stop_user_input () } +; diff --git a/debugger/input_handling.ml b/debugger/input_handling.ml index b043629b..5b43ba96 100644 --- a/debugger/input_handling.ml +++ b/debugger/input_handling.ml @@ -46,14 +46,8 @@ let current_controller file = let execute_with_other_controller controller file funct = let old_controller = current_controller file in change_controller file controller; - try - let result = funct () in - change_controller file old_controller; - result - with - x -> - change_controller file old_controller; - raise x + let finally () = change_controller file old_controller in + Fun.protect ~finally funct (*** The "Main Loop" ***) @@ -65,8 +59,11 @@ let exit_main_loop _ = (* Handle active files until `continue_main_loop' is false. *) let main_loop () = - let old_state = !continue_main_loop in - try + let finally = + let old_state = !continue_main_loop in + fun () -> continue_main_loop := old_state + in + Fun.protect ~finally @@ fun () -> continue_main_loop := true; while !continue_main_loop do try @@ -80,12 +77,7 @@ let main_loop () = input with Unix_error (EINTR, _, _) -> () - done; - continue_main_loop := old_state - with - x -> - continue_main_loop := old_state; - raise x + done (*** Managing user inputs ***) diff --git a/debugger/lexer.mli b/debugger/lexer.mli deleted file mode 100644 index 41424dd2..00000000 --- a/debugger/lexer.mli +++ /dev/null @@ -1,22 +0,0 @@ -(**************************************************************************) -(* *) -(* OCaml *) -(* *) -(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *) -(* OCaml port by John Malecki and Xavier Leroy *) -(* *) -(* Copyright 1996 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. *) -(* *) -(**************************************************************************) - -exception Int_overflow - -val line: Lexing.lexbuf -> string -val lexeme: Lexing.lexbuf -> Parser.token -val argument: Lexing.lexbuf -> Parser.token -val line_argument: Lexing.lexbuf -> Parser.token diff --git a/debugger/lexer.mll b/debugger/lexer.mll deleted file mode 100644 index f6744f79..00000000 --- a/debugger/lexer.mll +++ /dev/null @@ -1,104 +0,0 @@ -(**************************************************************************) -(* *) -(* OCaml *) -(* *) -(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *) -(* OCaml port by John Malecki and Xavier Leroy *) -(* *) -(* Copyright 1996 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 Parser - -exception Int_overflow - -} - -rule line = (* Read a whole line *) - parse - ([ ^ '\n' '\r' ]* as s) ('\n' | '\r' | "\r\n") - { s } - | [ ^ '\n' '\r' ]* - { Lexing.lexeme lexbuf } - | eof - { raise Exit } - -and argument = (* Read a raw argument *) - parse - [ ^ ' ' '\t' ]+ - { ARGUMENT (Lexing.lexeme lexbuf) } - | [' ' '\t']+ - { argument lexbuf } - | eof - { EOL } - | _ - { raise Parsing.Parse_error } - -and line_argument = - parse - _ * - { ARGUMENT (Lexing.lexeme lexbuf) } - | eof - { EOL } - -and lexeme = (* Read a lexeme *) - parse - [' ' '\t'] + - { lexeme lexbuf } - | ['a'-'z' '\223'-'\246' '\248'-'\255' '_'] - (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' - '\'' '0'-'9' ]) * - { LIDENT(Lexing.lexeme lexbuf) } - | ['A'-'Z' '\192'-'\214' '\216'-'\222' ] - (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' - '\'' '0'-'9' ]) * - { UIDENT(Lexing.lexeme lexbuf) } - | '"' [^ '"']* "\"" - { let s = Lexing.lexeme lexbuf in - LIDENT(String.sub s 1 (String.length s - 2)) } - | ['0'-'9']+ - | '0' ['x' 'X'] ['0'-'9' 'A'-'F' 'a'-'f']+ - | '0' ['o' 'O'] ['0'-'7']+ - | '0' ['b' 'B'] ['0'-'1']+ - { try INTEGER (Int64.of_string (Lexing.lexeme lexbuf)) - with Failure _ -> raise Int_overflow - } - | '*' - { STAR } - | "-" - { MINUS } - | "." - { DOT } - | "#" - { HASH } - | "@" - { AT } - | "$" - { DOLLAR } - | ":" - { COLON } - | "!" - { BANG } - | "(" - { LPAREN } - | ")" - { RPAREN } - | "[" - { LBRACKET } - | "]" - { RBRACKET } - | ['!' '?' '~' '=' '<' '>' '|' '&' '$' '@' '^' '+' '-' '*' '/' '%'] - ['!' '$' '%' '&' '*' '+' '-' '.' '/' ':' '<' '=' '>' '?' '@' '^' '|' '~'] * - { OPERATOR (Lexing.lexeme lexbuf) } - | eof - { EOL } - | _ - { raise Parsing.Parse_error } diff --git a/debugger/main.ml b/debugger/main.ml index 60bbdd2b..ec99786e 100644 --- a/debugger/main.ml +++ b/debugger/main.ml @@ -29,7 +29,7 @@ open Primitives let line_buffer = Lexing.from_function read_user_input -let loop ppf = line_loop ppf line_buffer +let loop ppf = line_loop ppf line_buffer; stop_user_input () let current_duration = ref (-1L) @@ -104,8 +104,7 @@ let rec protect ppf restart loop = restart ppf end) | x -> - kill_program (); - raise x + cleanup x kill_program let execute_file_if_any () = let buffer = Buffer.create 128 in @@ -131,7 +130,8 @@ let execute_file_if_any () = let len = Buffer.length buffer in if len > 0 then let commands = Buffer.sub buffer 0 (pred len) in - line_loop Format.std_formatter (Lexing.from_string commands) + line_loop Format.std_formatter (Lexing.from_string commands); + stop_user_input () let toplevel_loop () = interactif := false; @@ -246,4 +246,4 @@ let main () = exit 2 let _ = - Printexc.catch (Unix.handle_unix_error main) () + Unix.handle_unix_error main () diff --git a/debugger/parser.mly b/debugger/parser.mly deleted file mode 100644 index b8789d94..00000000 --- a/debugger/parser.mly +++ /dev/null @@ -1,260 +0,0 @@ -/**************************************************************************/ -/* */ -/* OCaml */ -/* */ -/* Jerome Vouillon, projet Cristal, INRIA Rocquencourt */ -/* OCaml port by John Malecki and Xavier Leroy */ -/* */ -/* Copyright 1996 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 Int64ops -open Input_handling -open Longident -open Parser_aux -open Debugcom - -%} - -%token ARGUMENT -%token LIDENT -%token UIDENT -%token OPERATOR -%token INTEGER -%token STAR /* * */ -%token MINUS /* - */ -%token DOT /* . */ -%token COLON /* : */ -%token HASH /* # */ -%token AT /* @ */ -%token DOLLAR /* $ */ -%token BANG /* ! */ -%token LPAREN /* ( */ -%token RPAREN /* ) */ -%token LBRACKET /* [ */ -%token RBRACKET /* ] */ -%token EOL - -%right DOT -%right BANG - -%start argument_list_eol -%type argument_list_eol - -%start argument_eol -%type argument_eol - -%start integer_list_eol -%type integer_list_eol - -%start integer_eol -%type integer_eol - -%start int64_eol -%type int64_eol - -%start integer -%type integer - -%start opt_integer_eol -%type opt_integer_eol - -%start opt_signed_integer_eol -%type opt_signed_integer_eol - -%start opt_signed_int64_eol -%type opt_signed_int64_eol - -%start identifier -%type identifier - -%start identifier_eol -%type identifier_eol - -%start identifier_or_eol -%type identifier_or_eol - -%start opt_identifier -%type opt_identifier - -%start opt_identifier_eol -%type opt_identifier_eol - -%start expression_list_eol -%type expression_list_eol - -%start break_argument_eol -%type break_argument_eol - -%start list_arguments_eol -%type list_arguments_eol - -%start end_of_line -%type end_of_line - -%start longident_eol -%type longident_eol - -%start opt_longident -%type opt_longident - -%start opt_longident_eol -%type opt_longident_eol - -%% - -/* Raw arguments */ - -argument_list_eol : - ARGUMENT argument_list_eol - { $1::$2 } - | end_of_line - { [] }; - -argument_eol : - ARGUMENT end_of_line - { $1 }; - -/* Integer */ - -integer_list_eol : - INTEGER integer_list_eol - { (to_int $1) :: $2 } - | end_of_line - { [] }; - -integer_eol : - INTEGER end_of_line - { to_int $1 }; - -int64_eol : - INTEGER end_of_line - { $1 }; - -integer : - INTEGER - { to_int $1 }; - -opt_integer_eol : - INTEGER end_of_line - { Some (to_int $1) } - | end_of_line - { None }; - -opt_int64_eol : - INTEGER end_of_line - { Some $1 } - | end_of_line - { None }; - -opt_signed_integer_eol : - MINUS integer_eol - { Some (- $2) } - | opt_integer_eol - { $1 }; - -opt_signed_int64_eol : - MINUS int64_eol - { Some (Int64.neg $2) } - | opt_int64_eol - { $1 }; - -/* Identifiers and long identifiers */ - -longident : - LIDENT { Lident $1 } - | module_path DOT LIDENT { Ldot($1, $3) } - | OPERATOR { Lident $1 } - | module_path DOT OPERATOR { Ldot($1, $3) } - | module_path DOT LPAREN OPERATOR RPAREN { Ldot($1, $4) } -; - -module_path : - UIDENT { Lident $1 } - | module_path DOT UIDENT { Ldot($1, $3) } -; - -longident_eol : - longident end_of_line { $1 }; - -opt_longident : - UIDENT { Some (Lident $1) } - | LIDENT { Some (Lident $1) } - | module_path DOT UIDENT { Some (Ldot($1, $3)) } - | { None }; - -opt_longident_eol : - opt_longident end_of_line { $1 }; - -identifier : - LIDENT { $1 } - | UIDENT { $1 }; - -identifier_eol : - identifier end_of_line { $1 }; - -identifier_or_eol : - identifier { Some $1 } - | end_of_line { None }; - -opt_identifier : - identifier { Some $1 } - | { None }; - -opt_identifier_eol : - opt_identifier end_of_line { $1 }; - -/* Expressions */ - -expression: - longident { E_ident $1 } - | STAR { E_result } - | DOLLAR INTEGER { E_name (to_int $2) } - | expression DOT INTEGER { E_item($1, (to_int $3)) } - | expression DOT LBRACKET INTEGER RBRACKET { E_item($1, (to_int $4)) } - | expression DOT LPAREN INTEGER RPAREN { E_item($1, (to_int $4)) } - | expression DOT LIDENT { E_field($1, $3) } - | BANG expression { E_field($2, "contents") } - | LPAREN expression RPAREN { $2 } -; - -/* Lists of expressions */ - -expression_list_eol : - expression expression_list_eol { $1::$2 } - | end_of_line { [] } -; - -/* Arguments for breakpoint */ - -break_argument_eol : - end_of_line { BA_none } - | integer_eol { BA_pc {frag = 0; pos = $1} } - | INTEGER COLON integer_eol { BA_pc {frag = to_int $1; - pos = $3} } - | expression end_of_line { BA_function $1 } - | AT opt_longident INTEGER opt_integer_eol { BA_pos1 ($2, (to_int $3), $4)} - | AT opt_longident HASH integer_eol { BA_pos2 ($2, $4) } -; - -/* Arguments for list */ - -list_arguments_eol : - opt_longident integer opt_integer_eol - { ($1, Some $2, $3) } - | opt_longident_eol - { ($1, None, None) }; - -/* End of line */ - -end_of_line : - EOL { stop_user_input () } -; diff --git a/debugger/primitives.ml b/debugger/primitives.ml index 7c1f900f..4cf2fb8d 100644 --- a/debugger/primitives.ml +++ b/debugger/primitives.ml @@ -19,6 +19,11 @@ (*** Miscellaneous ***) exception Out_of_range +let cleanup e f = + let bt = Printexc.get_raw_backtrace () in + let () = f () in + Printexc.raise_with_backtrace e bt + let nothing _ = () (*** Operations on lists. ***) diff --git a/debugger/primitives.mli b/debugger/primitives.mli index 76526cf9..8b03d8d2 100644 --- a/debugger/primitives.mli +++ b/debugger/primitives.mli @@ -22,6 +22,10 @@ val nothing : 'a -> unit (*** Types and exceptions. ***) exception Out_of_range +(* [cleanup e f x] runs evaluates [f x] and reraises [e] with its original + backtrace. If [f x] raises, then [e] is not raised. *) +val cleanup : exn -> (unit -> unit) -> 'a + (*** Operations on lists. ***) (* Remove an element from a list *) diff --git a/debugger/program_management.ml b/debugger/program_management.ml index 318e3f2c..74cc3db3 100644 --- a/debugger/program_management.ml +++ b/debugger/program_management.ml @@ -77,7 +77,7 @@ let open_connection address continue = connection := io_channel_of_descr sock; Input_handling.add_file !connection (accept_connection continue); connection_opened := true - with x -> close sock; raise x) + with x -> cleanup x @@ fun () -> close sock) with Failure _ -> raise Toplevel | (Unix_error _) as err -> report_error err; raise Toplevel @@ -157,6 +157,5 @@ let ensure_loaded () = prerr_endline "done." with x -> - kill_program(); - raise x + cleanup x kill_program end diff --git a/debugger/question.ml b/debugger/question.ml index 32daa640..ed294bea 100644 --- a/debugger/question.ml +++ b/debugger/question.ml @@ -15,12 +15,16 @@ open Input_handling open Primitives +module Lexer = Debugger_lexer (* Ask user a yes or no question. *) let yes_or_no message = if !interactif then - let old_prompt = !current_prompt in - try + let finally = + let old_prompt = !current_prompt in + fun () -> stop_user_input (); current_prompt := old_prompt + in + Fun.protect ~finally @@ fun () -> current_prompt := message ^ " ? (y or n) "; let answer = let rec ask () = @@ -28,23 +32,17 @@ let yes_or_no message = let line = string_trim (Lexer.line (Lexing.from_function read_user_input)) in - stop_user_input (); match (if String.length line > 0 then line.[0] else ' ') with 'y' -> true | 'n' -> false | _ -> + stop_user_input (); print_string "Please answer y or n."; print_newline (); ask () in ask () in - current_prompt := old_prompt; answer - with - x -> - current_prompt := old_prompt; - stop_user_input (); - raise x else false diff --git a/debugger/trap_barrier.ml b/debugger/trap_barrier.ml index 33dfb04f..0ae2b2c5 100644 --- a/debugger/trap_barrier.ml +++ b/debugger/trap_barrier.ml @@ -38,11 +38,5 @@ let update_trap_barrier () = (* Execute `funct' with a trap barrier. *) (* --- Used by `finish'. *) let exec_with_trap_barrier trap_barrier funct = - try - install_trap_barrier trap_barrier; - funct (); - remove_trap_barrier () - with - x -> - remove_trap_barrier (); - raise x + install_trap_barrier trap_barrier; + Fun.protect ~finally:remove_trap_barrier funct diff --git a/driver/compenv.ml b/driver/compenv.ml index 90f42d8c..8c960915 100644 --- a/driver/compenv.ml +++ b/driver/compenv.ml @@ -56,6 +56,7 @@ let first_ppx = ref [] let last_ppx = ref [] let first_objfiles = ref [] let last_objfiles = ref [] +let stop_early = ref false (* Check validity of module name *) let is_unit_name name = @@ -432,17 +433,15 @@ let read_one_param ppf position name v = | "stop-after" -> let module P = Clflags.Compiler_pass in - begin match P.of_string v with + let passes = P.available_pass_names ~native:!native_code in + begin match List.find_opt (String.equal v) passes with | None -> Printf.ksprintf (print_error ppf) "bad value %s for option \"stop-after\" (expected one of: %s)" - v (String.concat ", " P.pass_names) - | Some pass -> - Clflags.stop_after := Some pass; - begin match pass with - | P.Parsing | P.Typing -> - compile_only := true - end; + v (String.concat ", " passes) + | Some v -> + let pass = Option.get (P.of_string v) in + Clflags.stop_after := Some pass end | _ -> if not (List.mem name !can_discard) then begin @@ -672,3 +671,9 @@ let process_deferred_actions env = fatal "Option -a cannot be used with .cmxa input files."; List.iter (process_action env) (List.rev !deferred_actions); output_name := final_output_name; + stop_early := + !compile_only || + !print_types || + match !stop_after with + | None -> false + | Some p -> Clflags.Compiler_pass.is_compilation_pass p; diff --git a/driver/compenv.mli b/driver/compenv.mli index ddbdc818..2afbdfae 100644 --- a/driver/compenv.mli +++ b/driver/compenv.mli @@ -34,6 +34,8 @@ val get_objfiles : with_ocamlparam:bool -> string list val last_objfiles : string list ref val first_objfiles : string list ref +val stop_early : bool ref + type filename = string type readenv_position = diff --git a/driver/compile_common.ml b/driver/compile_common.ml index 601cfa83..82b5f006 100644 --- a/driver/compile_common.ml +++ b/driver/compile_common.ml @@ -68,7 +68,7 @@ let typecheck_intf info ast = Format.(fprintf std_formatter) "%a@." (Printtyp.printed_signature info.source_file) sg); - ignore (Includemod.signatures info.env sg sg); + ignore (Includemod.signatures info.env ~mark:Mark_both sg sg); Typecore.force_delayed_checks (); Warnings.check_fatal (); tsg @@ -101,15 +101,12 @@ let parse_impl i = |> print_if i.ppf_dump Clflags.dump_source Pprintast.structure let typecheck_impl i parsetree = - let always () = Stypes.dump (Some (annot i)) in - Misc.try_finally ~always (fun () -> - parsetree - |> Profile.(record typing) - (Typemod.type_implementation - i.source_file i.output_prefix i.module_name i.env) - |> print_if i.ppf_dump Clflags.dump_typedtree - Printtyped.implementation_with_coercion - ) + parsetree + |> Profile.(record typing) + (Typemod.type_implementation + i.source_file i.output_prefix i.module_name i.env) + |> print_if i.ppf_dump Clflags.dump_typedtree + Printtyped.implementation_with_coercion let implementation info ~backend = Profile.record_call info.source_file @@ fun () -> diff --git a/driver/compmisc.ml b/driver/compmisc.ml index 743df6c9..601d1269 100644 --- a/driver/compmisc.ml +++ b/driver/compmisc.ml @@ -42,6 +42,7 @@ let init_path ?(dir="") () = let initial_env () = Ident.reinit(); + Types.Uid.reinit(); let initially_opened_module = if !Clflags.nopervasives then None diff --git a/driver/main.ml b/driver/main.ml index adf66644..449d91c9 100644 --- a/driver/main.ml +++ b/driver/main.ml @@ -52,18 +52,21 @@ let main () = if List.length (List.filter (fun x -> !x) - [make_archive;make_package;compile_only;output_c_object]) + [make_archive;make_package;stop_early;output_c_object]) > 1 then begin let module P = Clflags.Compiler_pass in match !stop_after with | None -> fatal "Please specify at most one of -pack, -a, -c, -output-obj"; - | Some (P.Parsing | P.Typing) -> - Printf.ksprintf fatal - "Options -i and -stop-after (%s)\ - are incompatible with -pack, -a, -output-obj" - (String.concat "|" P.pass_names) + | Some ((P.Parsing | P.Typing) as p) -> + assert (P.is_compilation_pass p); + Printf.ksprintf fatal + "Options -i and -stop-after (%s) \ + are incompatible with -pack, -a, -output-obj" + (String.concat "|" + (Clflags.Compiler_pass.available_pass_names ~native:false)) + | Some P.Scheduling -> assert false (* native only *) end; if !make_archive then begin Compmisc.init_path (); @@ -82,7 +85,7 @@ let main () = revd (extracted_output)); Warnings.check_fatal (); end - else if not !compile_only && !objfiles <> [] then begin + else if not !stop_early && !objfiles <> [] then begin let target = if !output_c_object && not !output_complete_executable then let s = extract_output !output_name in diff --git a/driver/main_args.ml b/driver/main_args.ml index 8a6c1b83..5c28ded5 100644 --- a/driver/main_args.ml +++ b/driver/main_args.ml @@ -33,7 +33,7 @@ let mk_absname f = ;; let mk_annot f = - "-annot", Arg.Unit f, " Save information in .annot" + "-annot", Arg.Unit f, " (deprecated) Save information in .annot" ;; let mk_binannot f = @@ -106,8 +106,9 @@ let mk_function_sections f = "-function-sections", Arg.Unit err, " (option not available)" ;; -let mk_stop_after f = - "-stop-after", Arg.Symbol (Clflags.Compiler_pass.pass_names, f), +let mk_stop_after ~native f = + "-stop-after", + Arg.Symbol (Clflags.Compiler_pass.available_pass_names ~native, f), " Stop after the given compilation pass." ;; @@ -705,6 +706,14 @@ let mk_dunique_ids f = "-dunique-ids", Arg.Unit f, " (undocumented)" ;; +let mk_dno_locations f = + "-dno-locations", Arg.Unit f, " (undocumented)" +;; + +let mk_dlocations f = + "-dlocations", Arg.Unit f, " (undocumented)" +;; + let mk_dsource f = "-dsource", Arg.Unit f, " (undocumented)" ;; @@ -921,6 +930,9 @@ module type Core_options = sig val _dno_unique_ids : unit -> unit val _dunique_ids : unit -> unit + val _dno_locations : unit -> unit + val _dlocations : unit -> unit + val _dsource : unit -> unit val _dparsetree : unit -> unit val _dtypedtree : unit -> unit @@ -1141,7 +1153,7 @@ struct mk_dtypes F._annot; mk_for_pack_byt F._for_pack; mk_g_byt F._g; - mk_stop_after F._stop_after; + mk_stop_after ~native:false F._stop_after; mk_i F._i; mk_I F._I; mk_impl F._impl; @@ -1213,6 +1225,8 @@ struct mk_use_prims F._use_prims; mk_dno_unique_ids F._dno_unique_ids; mk_dunique_ids F._dunique_ids; + mk_dno_locations F._dno_locations; + mk_dlocations F._dlocations; mk_dsource F._dsource; mk_dparsetree F._dparsetree; mk_dtypedtree F._dtypedtree; @@ -1278,6 +1292,8 @@ struct mk_dno_unique_ids F._dno_unique_ids; mk_dunique_ids F._dunique_ids; + mk_dno_locations F._dno_locations; + mk_dlocations F._dlocations; mk_dsource F._dsource; mk_dparsetree F._dparsetree; mk_dtypedtree F._dtypedtree; @@ -1316,7 +1332,7 @@ struct mk_for_pack_opt F._for_pack; mk_g_opt F._g; mk_function_sections F._function_sections; - mk_stop_after F._stop_after; + mk_stop_after ~native:true F._stop_after; mk_i F._i; mk_I F._I; mk_impl F._impl; @@ -1405,6 +1421,8 @@ struct mk_match_context_rows F._match_context_rows; mk_dno_unique_ids F._dno_unique_ids; mk_dunique_ids F._dunique_ids; + mk_dno_locations F._dno_locations; + mk_dlocations F._dlocations; mk_dsource F._dsource; mk_dparsetree F._dparsetree; mk_dtypedtree F._dtypedtree; @@ -1677,12 +1695,14 @@ module Default = struct let _I dir = include_dirs := (dir :: (!include_dirs)) let _color = Misc.set_or_ignore color_reader.parse color let _dlambda = set dump_lambda - let _dno_unique_ids = clear unique_ids let _dparsetree = set dump_parsetree let _drawlambda = set dump_rawlambda let _dsource = set dump_source let _dtypedtree = set dump_typedtree let _dunique_ids = set unique_ids + let _dno_unique_ids = clear unique_ids + let _dlocations = set locations + let _dno_locations = clear locations let _error_style = Misc.set_or_ignore error_style_reader.parse error_style let _nopervasives = set nopervasives @@ -1813,11 +1833,7 @@ module Default = struct let _dump_into_file = set dump_into_file let _for_pack s = for_package := (Some s) let _g = set debug - let _i () = - print_types := true; - compile_only := true; - stop_after := (Some Compiler_pass.Typing); - () + let _i = set print_types let _impl = impl let _intf = intf let _intf_suffix s = Config.interface_suffix := s @@ -1839,9 +1855,11 @@ module Default = struct match P.of_string pass with | None -> () (* this should not occur as we use Arg.Symbol *) | Some pass -> - stop_after := (Some pass); - match pass with - | P.Parsing | P.Typing -> compile_only := true + match !stop_after with + | None -> stop_after := (Some pass) + | Some p -> + if not (p = pass) then + fatal "Please specify at most one -stop-after ." let _thread = set use_threads let _verbose = set verbose let _version () = print_version_string () diff --git a/driver/main_args.mli b/driver/main_args.mli index 56e03ba8..083a1827 100644 --- a/driver/main_args.mli +++ b/driver/main_args.mli @@ -60,6 +60,8 @@ module type Core_options = sig val _dno_unique_ids : unit -> unit val _dunique_ids : unit -> unit + val _dno_locations : unit -> unit + val _dlocations : unit -> unit val _dsource : unit -> unit val _dparsetree : unit -> unit val _dtypedtree : unit -> unit diff --git a/driver/makedepend.ml b/driver/makedepend.ml index 4942eab0..c4a7cabc 100644 --- a/driver/makedepend.ml +++ b/driver/makedepend.ml @@ -31,6 +31,7 @@ let bytecode_only = ref false let raw_dependencies = ref false let sort_files = ref false let all_dependencies = ref false +let nocwd = ref false let one_line = ref false let files = ref ([] : (string * file_kind * String.Set.t * string list) list) @@ -310,7 +311,12 @@ let read_parse_and_extract parse_function extract_function def ast_kind let bound_vars = List.fold_left (fun bv modname -> - Depend.open_module bv (Longident.parse modname)) + let lid = + let lexbuf = Lexing.from_string modname in + Location.init lexbuf + (Printf.sprintf "command line argument: -open %S" modname); + Parse.simple_module_path lexbuf in + Depend.open_module bv lid) !module_map ((* PR#7248 *) List.rev !Clflags.open_modules) in let r = extract_function bound_vars ast in @@ -401,10 +407,12 @@ let mli_file_dependencies source_file = let process_file_as process_fun def source_file = Compenv.readenv ppf (Before_compile source_file); load_path := []; + let cwd = if !nocwd then [] else [Filename.current_dir_name] in List.iter add_to_load_path ( (!Compenv.last_include_dirs @ !Clflags.include_dirs @ - !Compenv.first_include_dirs + !Compenv.first_include_dirs @ + cwd )); Location.input_name := source_file; try @@ -569,7 +577,6 @@ let print_version_num () = let main () = Clflags.classic := false; - add_to_list first_include_dirs Filename.current_dir_name; Compenv.readenv ppf Before_args; Clflags.reset_arguments (); (* reset arguments from ocamlc/ocamlopt *) Clflags.add_arguments __LOC__ [ @@ -586,6 +593,9 @@ let main () = " Dump the delayed dependency map for each map file"; "-I", Arg.String (add_to_list Clflags.include_dirs), " Add to the list of include directories"; + "-nocwd", Arg.Set nocwd, + " Do not add current working directory to \ + the list of include directories"; "-impl", Arg.String (file_dependencies_as ML), " Process as a .ml file"; "-intf", Arg.String (file_dependencies_as MLI), diff --git a/driver/optmain.ml b/driver/optmain.ml index f26631d7..d7ef1c48 100644 --- a/driver/optmain.ml +++ b/driver/optmain.ml @@ -69,10 +69,22 @@ let main () = if List.length (List.filter (fun x -> !x) [make_package; make_archive; shared; - compile_only; output_c_object]) > 1 + stop_early; output_c_object]) > 1 then - fatal "Please specify at most one of -pack, -a, -shared, -c, \ + begin + let module P = Clflags.Compiler_pass in + match !stop_after with + | None -> + fatal "Please specify at most one of -pack, -a, -shared, -c, \ -output-obj"; + | Some ((P.Parsing | P.Typing | P.Scheduling) as p) -> + assert (P.is_compilation_pass p); + Printf.ksprintf fatal + "Options -i and -stop-after (%s) \ + are incompatible with -pack, -a, -shared, -output-obj" + (String.concat "|" + (Clflags.Compiler_pass.available_pass_names ~native:true)) + end; if !make_archive then begin Compmisc.init_path (); let target = extract_output !output_name in @@ -96,7 +108,7 @@ let main () = (get_objfiles ~with_ocamlparam:false) target); Warnings.check_fatal (); end - else if not !compile_only && !objfiles <> [] then begin + else if not !stop_early && !objfiles <> [] then begin let target = if !output_c_object then let s = extract_output !output_name in diff --git a/dune b/dune index 653708c2..f80f6391 100644 --- a/dune +++ b/dune @@ -61,7 +61,7 @@ tast_iterator tast_mapper cmt_format untypeast includemod typetexp printpat parmatch stypes typedecl typeopt rec_check typecore typeclass typemod typedecl_variance typedecl_properties typedecl_immediacy - typedecl_unboxed + typedecl_unboxed typedecl_separability cmt2annot ; manual update: mli only files annot outcometree diff --git a/file_formats/cmi_format.ml b/file_formats/cmi_format.ml index a98520a8..eadf676e 100644 --- a/file_formats/cmi_format.ml +++ b/file_formats/cmi_format.ml @@ -28,17 +28,24 @@ type error = exception Error of error +(* these type abbreviations are not exported; + they are used to provide consistency across + input_value and output_value usage. *) +type signature = Types.signature_item list +type flags = pers_flags list +type header = modname * signature + type cmi_infos = { - cmi_name : Misc.modname; - cmi_sign : Types.signature_item list; + cmi_name : modname; + cmi_sign : signature; cmi_crcs : crcs; - cmi_flags : pers_flags list; + cmi_flags : flags; } let input_cmi ic = - let (name, sign) = input_value ic in - let crcs = input_value ic in - let flags = input_value ic in + let (name, sign) = (input_value ic : header) in + let crcs = (input_value ic : crcs) in + let flags = (input_value ic : flags) in { cmi_name = name; cmi_sign = sign; @@ -78,12 +85,12 @@ let read_cmi filename = let output_cmi 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); + output_value oc ((cmi.cmi_name, cmi.cmi_sign) : header); flush oc; let crc = Digest.file filename in let crcs = (cmi.cmi_name, Some crc) :: cmi.cmi_crcs in - output_value oc crcs; - output_value oc cmi.cmi_flags; + output_value oc (crcs : crcs); + output_value oc (cmi.cmi_flags : flags); crc (* Error report *) diff --git a/file_formats/cmo_format.mli b/file_formats/cmo_format.mli index d953a881..0952157b 100644 --- a/file_formats/cmo_format.mli +++ b/file_formats/cmo_format.mli @@ -53,6 +53,8 @@ type compilation_unit = type library = { lib_units: compilation_unit list; (* List of compilation units *) lib_custom: bool; (* Requires custom mode linking? *) + (* In the following fields the lists are reversed with respect to + how they end up being used on the command line. *) lib_ccobjs: string list; (* C object files needed for -custom *) lib_ccopts: string list; (* Extra opts to C compiler *) lib_dllibs: string list } (* DLLs needed *) diff --git a/file_formats/cmt_format.ml b/file_formats/cmt_format.ml index cf33fa3f..709509a7 100644 --- a/file_formats/cmt_format.ml +++ b/file_formats/cmt_format.ml @@ -39,7 +39,7 @@ and binary_part = | Partial_structure of structure | Partial_structure_item of structure_item | Partial_expression of expression -| Partial_pattern of pattern +| Partial_pattern : 'k pattern_category * 'k general_pattern -> binary_part | Partial_class_expr of class_expr | Partial_signature of signature | Partial_signature_item of signature_item @@ -81,7 +81,7 @@ let clear_part = function | Partial_structure_item s -> Partial_structure_item (cenv.structure_item cenv s) | Partial_expression e -> Partial_expression (cenv.expr cenv e) - | Partial_pattern p -> Partial_pattern (cenv.pat cenv p) + | Partial_pattern (category, p) -> Partial_pattern (category, cenv.pat cenv p) | Partial_class_expr ce -> Partial_class_expr (cenv.class_expr cenv ce) | Partial_signature s -> Partial_signature (cenv.signature cenv s) | Partial_signature_item s -> diff --git a/file_formats/cmt_format.mli b/file_formats/cmt_format.mli index 7649de7b..8a52c4b2 100644 --- a/file_formats/cmt_format.mli +++ b/file_formats/cmt_format.mli @@ -44,7 +44,7 @@ and binary_part = | Partial_structure of structure | Partial_structure_item of structure_item | Partial_expression of expression - | Partial_pattern of pattern + | Partial_pattern : 'k pattern_category * 'k general_pattern -> binary_part | Partial_class_expr of class_expr | Partial_signature of signature | Partial_signature_item of signature_item diff --git a/file_formats/cmx_format.mli b/file_formats/cmx_format.mli index 0efa32ee..91ad2d1f 100644 --- a/file_formats/cmx_format.mli +++ b/file_formats/cmx_format.mli @@ -52,5 +52,7 @@ type unit_infos = type library_infos = { lib_units: (unit_infos * Digest.t) list; (* List of unit infos w/ MD5s *) + (* In the following fields the lists are reversed with respect to + how they end up being used on the command line. *) lib_ccobjs: string list; (* C object files needed *) lib_ccopts: string list } (* Extra opts to C compiler *) diff --git a/lambda/debuginfo.ml b/lambda/debuginfo.ml index 7a339022..c1195d72 100644 --- a/lambda/debuginfo.ml +++ b/lambda/debuginfo.ml @@ -17,6 +17,85 @@ open! Int_replace_polymorphic_compare open Lexing open Location +module Scoped_location = struct + type scope_item = + | Sc_anonymous_function + | Sc_value_definition of string + | Sc_module_definition of string + | Sc_class_definition of string + | Sc_method_definition of string + + type scopes = scope_item list + + let add_parens_if_symbolic = function + | "" -> "" + | s -> + match s.[0] with + | 'a'..'z' | 'A'..'Z' | '_' | '0'..'9' -> s + | _ -> "(" ^ s ^ ")" + + let string_of_scope_item = function + | Sc_anonymous_function -> + "(fun)" + | Sc_value_definition name + | Sc_module_definition name + | Sc_class_definition name + | Sc_method_definition name -> + add_parens_if_symbolic name + + let string_of_scopes scopes = + let dot acc = + match acc with + | [] -> [] + | acc -> "." :: acc in + let rec to_strings acc = function + | [] -> acc + (* Collapse nested anonymous function scopes *) + | Sc_anonymous_function :: ((Sc_anonymous_function :: _) as rest) -> + to_strings acc rest + (* Use class#meth syntax for classes *) + | (Sc_method_definition _ as meth) :: + (Sc_class_definition _ as cls) :: rest -> + to_strings (string_of_scope_item cls :: "#" :: + string_of_scope_item meth :: dot acc) rest + | s :: rest -> + to_strings (string_of_scope_item s :: dot acc) rest in + match scopes with + | [] -> "" + | scopes -> String.concat "" (to_strings [] scopes) + + let enter_anonymous_function ~scopes = + Sc_anonymous_function :: scopes + let enter_value_definition ~scopes id = + Sc_value_definition (Ident.name id) :: scopes + let enter_module_definition ~scopes id = + Sc_module_definition (Ident.name id) :: scopes + let enter_class_definition ~scopes id = + Sc_class_definition (Ident.name id) :: scopes + let enter_method_definition ~scopes (m : Asttypes.label) = + Sc_method_definition m :: scopes + + type t = + | Loc_unknown + | Loc_known of + { loc : Location.t; + scopes : scopes; } + + let of_location ~scopes loc = + if Location.is_none loc then + Loc_unknown + else + Loc_known { loc; scopes } + + let to_location = function + | Loc_unknown -> Location.none + | Loc_known { loc; _ } -> loc + + let string_of_scoped_location = function + | Loc_unknown -> "??" + | Loc_known { loc = _; scopes } -> string_of_scopes scopes +end + type item = { dinfo_file: string; dinfo_line: int; @@ -25,10 +104,16 @@ type item = { dinfo_start_bol: int; dinfo_end_bol: int; dinfo_end_line: int; + dinfo_scopes: Scoped_location.scopes; } type t = item list +type alloc_dbginfo_item = + { alloc_words : int; + alloc_dbg : t } +type alloc_dbginfo = alloc_dbginfo_item list + let none = [] let is_none = function @@ -48,7 +133,7 @@ let to_string dbg = in "{" ^ String.concat ";" items ^ "}" -let item_from_location loc = +let item_from_location ~scopes loc = let valid_endpos = String.equal loc.loc_end.pos_fname loc.loc_start.pos_fname in { dinfo_file = loc.loc_start.pos_fname; @@ -65,10 +150,14 @@ let item_from_location loc = dinfo_end_line = if valid_endpos then loc.loc_end.pos_lnum else loc.loc_start.pos_lnum; + dinfo_scopes = scopes } -let from_location loc = - if loc == Location.none then [] else [item_from_location loc] +let from_location = function + | Scoped_location.Loc_unknown -> [] + | Scoped_location.Loc_known {scopes; loc} -> + assert (not (Location.is_none loc)); + [item_from_location ~scopes loc] let to_location = function | [] -> Location.none @@ -87,11 +176,7 @@ let to_location = function } in { loc_ghost = false; loc_start; loc_end; } -let inline loc t = - if loc == Location.none then t - else (item_from_location loc) :: t - -let concat dbg1 dbg2 = +let inline dbg1 dbg2 = dbg1 @ dbg2 (* CR-someday afrisch: FWIW, the current compare function does not seem very diff --git a/lambda/debuginfo.mli b/lambda/debuginfo.mli index 4dc5e599..4ce8d5f9 100644 --- a/lambda/debuginfo.mli +++ b/lambda/debuginfo.mli @@ -13,6 +13,35 @@ (* *) (**************************************************************************) +module Scoped_location : sig + type scope_item = + | Sc_anonymous_function + | Sc_value_definition of string + | Sc_module_definition of string + | Sc_class_definition of string + | Sc_method_definition of string + + type scopes = scope_item list + val string_of_scope_item : scope_item -> string + val string_of_scopes : scopes -> string + + val enter_anonymous_function : scopes:scopes -> scopes + val enter_value_definition : scopes:scopes -> Ident.t -> scopes + val enter_module_definition : scopes:scopes -> Ident.t -> scopes + val enter_class_definition : scopes:scopes -> Ident.t -> scopes + val enter_method_definition : scopes:scopes -> Asttypes.label -> scopes + + type t = + | Loc_unknown + | Loc_known of + { loc : Location.t; + scopes : scopes; } + + val of_location : scopes:scopes -> Location.t -> t + val to_location : t -> Location.t + val string_of_scoped_location : t -> string +end + type item = private { dinfo_file: string; dinfo_line: int; @@ -21,23 +50,33 @@ type item = private { dinfo_start_bol: int; dinfo_end_bol: int; dinfo_end_line: int; + dinfo_scopes: Scoped_location.scopes; } type t = item list +type alloc_dbginfo_item = + { alloc_words : int; + alloc_dbg : t } +(** Due to Comballoc, a single Ialloc instruction may combine several + unrelated allocations. Their Debuginfo.t (which may differ) are stored + as a list of alloc_dbginfo. This list is in order of increasing memory + address, which is the reverse of the original allocation order. Later + allocations are consed to the front of this list by Comballoc. *) + +type alloc_dbginfo = alloc_dbginfo_item list + val none : t val is_none : t -> bool val to_string : t -> string -val from_location : Location.t -> t +val from_location : Scoped_location.t -> t val to_location : t -> Location.t -val concat: t -> t -> t - -val inline: Location.t -> t -> t +val inline : t -> t -> t val compare : t -> t -> int diff --git a/lambda/lambda.ml b/lambda/lambda.ml index 0f9045c1..3a776bee 100644 --- a/lambda/lambda.ml +++ b/lambda/lambda.ml @@ -71,6 +71,7 @@ type primitive = | Pandint | Porint | Pxorint | Plslint | Plsrint | Pasrint | Pintcomp of integer_comparison + | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer | Poffsetint of int | Poffsetref of int (* Float operations *) @@ -214,6 +215,7 @@ type structured_constant = type inline_attribute = | Always_inline (* [@inline] or [@inline always] *) | Never_inline (* [@inline never] *) + | Hint_inline (* [@inlined hint] attribute *) | Unroll of int (* [@unroll x] *) | Default_inline (* no [@inline] attribute *) @@ -221,12 +223,14 @@ let equal_inline_attribute x y = match x, y with | Always_inline, Always_inline | Never_inline, Never_inline + | Hint_inline, Hint_inline | Default_inline, Default_inline -> true | Unroll u, Unroll v -> u = v - | (Always_inline | Never_inline | Unroll _ | Default_inline), _ -> + | (Always_inline | Never_inline + | Hint_inline | Unroll _ | Default_inline), _ -> false type specialise_attribute = @@ -271,6 +275,8 @@ type function_attribute = { stub: bool; } +type scoped_location = Debuginfo.Scoped_location.t + type lambda = Lvar of Ident.t | Lconst of structured_constant @@ -278,10 +284,10 @@ type lambda = | Lfunction of lfunction | Llet of let_kind * value_kind * Ident.t * lambda * lambda | Lletrec of (Ident.t * lambda) list * lambda - | Lprim of primitive * lambda list * Location.t - | Lswitch of lambda * lambda_switch * Location.t + | Lprim of primitive * lambda list * scoped_location + | Lswitch of lambda * lambda_switch * scoped_location | Lstringswitch of - lambda * (string * lambda) list * lambda option * Location.t + lambda * (string * lambda) list * lambda option * scoped_location | Lstaticraise of int * lambda list | Lstaticcatch of lambda * (int * (Ident.t * value_kind) list) * lambda | Ltrywith of lambda * Ident.t * lambda @@ -290,7 +296,7 @@ type lambda = | Lwhile of lambda * lambda | Lfor of Ident.t * lambda * lambda * direction_flag * lambda | Lassign of Ident.t * lambda - | Lsend of meth_kind * lambda * lambda * lambda list * Location.t + | Lsend of meth_kind * lambda * lambda * lambda list * scoped_location | Levent of lambda * lambda_event | Lifused of Ident.t * lambda @@ -300,12 +306,12 @@ and lfunction = return: value_kind; body: lambda; attr: function_attribute; (* specified with [@inline] attribute *) - loc: Location.t; } + loc: scoped_location; } and lambda_apply = { ap_func : lambda; ap_args : lambda list; - ap_loc : Location.t; + ap_loc : scoped_location; ap_should_be_tailcall : bool; ap_inlined : inline_attribute; ap_specialised : specialise_attribute; } @@ -318,7 +324,7 @@ and lambda_switch = sw_failaction : lambda option} and lambda_event = - { lev_loc: Location.t; + { lev_loc: scoped_location; lev_kind: lambda_event_kind; lev_repr: int ref option; lev_env: Env.t } @@ -381,7 +387,7 @@ let make_key e = | Lapply ap -> Lapply {ap with ap_func = tr_rec env ap.ap_func; ap_args = tr_recs env ap.ap_args; - ap_loc = Location.none} + ap_loc = Loc_unknown} | Llet (Alias,_k,x,ex,e) -> (* Ignore aliases -> substitute *) let ex = tr_rec env ex in tr_rec (Ident.add x ex env) e @@ -393,7 +399,7 @@ let make_key e = let y = make_key x in Llet (str,k,y,ex,tr_rec (Ident.add x (Lvar y) env) e) | Lprim (p,es,_) -> - Lprim (p,tr_recs env es, Location.none) + Lprim (p,tr_recs env es, Loc_unknown) | Lswitch (e,sw,loc) -> Lswitch (tr_rec env e,tr_sw env sw,loc) | Lstringswitch (e,sw,d,_) -> @@ -401,7 +407,7 @@ let make_key e = (tr_rec env e, List.map (fun (s,e) -> s,tr_rec env e) sw, tr_opt env d, - Location.none) + Loc_unknown) | Lstaticraise (i,es) -> Lstaticraise (i,tr_recs env es) | Lstaticcatch (e1,xs,e2) -> @@ -415,7 +421,7 @@ let make_key e = | Lassign (x,e) -> Lassign (x,tr_rec env e) | Lsend (m,e1,e2,es,_loc) -> - Lsend (m,tr_rec env e1,tr_rec env e2,tr_recs env es,Location.none) + Lsend (m,tr_rec env e1,tr_rec env e2,tr_recs env es,Loc_unknown) | Lifused (id,e) -> Lifused (id,tr_rec env e) | Lletrec _|Lfunction _ | Lfor _ | Lwhile _ @@ -657,7 +663,7 @@ let transl_prim mod_name name = let env = Env.add_persistent_structure pers Env.empty in let lid = Longident.Ldot (Longident.Lident mod_name, name) in match Env.find_value_by_name lid env with - | path, _ -> transl_value_path Location.none env path + | path, _ -> transl_value_path Loc_unknown env path | exception Not_found -> fatal_error ("Primitive " ^ name ^ " not found.") diff --git a/lambda/lambda.mli b/lambda/lambda.mli index 9c703afe..d1816981 100644 --- a/lambda/lambda.mli +++ b/lambda/lambda.mli @@ -76,6 +76,8 @@ type primitive = | Pandint | Porint | Pxorint | Plslint | Plsrint | Pasrint | Pintcomp of integer_comparison + (* Comparions that return int (not bool like above) for ordering *) + | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer | Poffsetint of int | Poffsetref of int (* Float operations *) @@ -204,6 +206,7 @@ type structured_constant = type inline_attribute = | Always_inline (* [@inline] or [@inline always] *) | Never_inline (* [@inline never] *) + | Hint_inline (* [@inline hint] *) | Unroll of int (* [@unroll x] *) | Default_inline (* no [@inline] attribute *) @@ -252,6 +255,8 @@ type function_attribute = { stub: bool; } +type scoped_location = Debuginfo.Scoped_location.t + type lambda = Lvar of Ident.t | Lconst of structured_constant @@ -259,12 +264,12 @@ type lambda = | Lfunction of lfunction | Llet of let_kind * value_kind * Ident.t * lambda * lambda | Lletrec of (Ident.t * lambda) list * lambda - | Lprim of primitive * lambda list * Location.t - | Lswitch of lambda * lambda_switch * Location.t + | Lprim of primitive * lambda list * scoped_location + | Lswitch of lambda * lambda_switch * scoped_location (* switch on strings, clauses are sorted by string order, strings are pairwise distinct *) | Lstringswitch of - lambda * (string * lambda) list * lambda option * Location.t + lambda * (string * lambda) list * lambda option * scoped_location | Lstaticraise of int * lambda list | Lstaticcatch of lambda * (int * (Ident.t * value_kind) list) * lambda | Ltrywith of lambda * Ident.t * lambda @@ -275,7 +280,7 @@ type lambda = | Lwhile of lambda * lambda | Lfor of Ident.t * lambda * lambda * direction_flag * lambda | Lassign of Ident.t * lambda - | Lsend of meth_kind * lambda * lambda * lambda list * Location.t + | Lsend of meth_kind * lambda * lambda * lambda list * scoped_location | Levent of lambda * lambda_event | Lifused of Ident.t * lambda @@ -285,12 +290,12 @@ and lfunction = return: value_kind; body: lambda; attr: function_attribute; (* specified with [@inline] attribute *) - loc : Location.t; } + loc : scoped_location; } and lambda_apply = { ap_func : lambda; ap_args : lambda list; - ap_loc : Location.t; + ap_loc : scoped_location; ap_should_be_tailcall : bool; (* true if [@tailcall] was specified *) ap_inlined : inline_attribute; (* specified with the [@inlined] attribute *) ap_specialised : specialise_attribute; } @@ -302,7 +307,7 @@ and lambda_switch = sw_blocks: (int * lambda) list; (* Tag block cases *) sw_failaction : lambda option} (* Action to take if failure *) and lambda_event = - { lev_loc: Location.t; + { lev_loc: scoped_location; lev_kind: lambda_event_kind; lev_repr: int ref option; lev_env: Env.t } @@ -363,10 +368,10 @@ val transl_prim: string -> string -> lambda val free_variables: lambda -> Ident.Set.t -val transl_module_path: Location.t -> Env.t -> Path.t -> lambda -val transl_value_path: Location.t -> Env.t -> Path.t -> lambda -val transl_extension_path: Location.t -> Env.t -> Path.t -> lambda -val transl_class_path: Location.t -> Env.t -> Path.t -> lambda +val transl_module_path: scoped_location -> Env.t -> Path.t -> lambda +val transl_value_path: scoped_location -> Env.t -> Path.t -> lambda +val transl_extension_path: scoped_location -> Env.t -> Path.t -> lambda +val transl_class_path: scoped_location -> Env.t -> Path.t -> lambda val make_sequence: ('a -> lambda) -> 'a list -> lambda diff --git a/lambda/matching.ml b/lambda/matching.ml index 20968a63..95f296f6 100644 --- a/lambda/matching.ml +++ b/lambda/matching.ml @@ -95,6 +95,7 @@ open Lambda open Parmatch open Printf open Printpat +open Debuginfo.Scoped_location let dbg = false @@ -139,6 +140,245 @@ let all_record_args lbls = Array.to_list t | _ -> fatal_error "Matching.all_record_args" +type 'a clause = 'a * lambda + +module Non_empty_clause = struct + type 'a t = ('a * Typedtree.pattern list) clause + + let of_initial = function + | [], _ -> assert false + | pat :: patl, act -> ((pat, patl), act) + + let map_head f ((p, patl), act) = ((f p, patl), act) +end + +type simple_view = + [ `Any + | `Constant of constant + | `Tuple of pattern list + | `Construct of Longident.t loc * constructor_description * pattern list + | `Variant of label * pattern option * row_desc ref + | `Record of + (Longident.t loc * label_description * pattern) list * closed_flag + | `Array of pattern list + | `Lazy of pattern ] + +type half_simple_view = + [ simple_view | `Or of pattern * pattern * row_desc option ] + +type general_view = + [ half_simple_view + | `Var of Ident.t * string loc + | `Alias of pattern * Ident.t * string loc ] + +module General : sig + type pattern = general_view pattern_data + + type clause = pattern Non_empty_clause.t + + val view : Typedtree.pattern -> pattern + + val erase : [< general_view ] pattern_data -> Typedtree.pattern +end = struct + type pattern = general_view pattern_data + + type clause = pattern Non_empty_clause.t + + let view_desc = function + | Tpat_any -> `Any + | Tpat_var (id, str) -> `Var (id, str) + | Tpat_alias (p, id, str) -> `Alias (p, id, str) + | Tpat_constant cst -> `Constant cst + | Tpat_tuple ps -> `Tuple ps + | Tpat_construct (cstr, cstr_descr, args) -> + `Construct (cstr, cstr_descr, args) + | Tpat_variant (cstr, arg, row_desc) -> `Variant (cstr, arg, row_desc) + | Tpat_record (fields, closed) -> `Record (fields, closed) + | Tpat_array ps -> `Array ps + | Tpat_or (p, q, row_desc) -> `Or (p, q, row_desc) + | Tpat_lazy p -> `Lazy p + + let view p : pattern = { p with pat_desc = view_desc p.pat_desc } + + let erase_desc = function + | `Any -> Tpat_any + | `Var (id, str) -> Tpat_var (id, str) + | `Alias (p, id, str) -> Tpat_alias (p, id, str) + | `Constant cst -> Tpat_constant cst + | `Tuple ps -> Tpat_tuple ps + | `Construct (cstr, cst_descr, args) -> + Tpat_construct (cstr, cst_descr, args) + | `Variant (cstr, arg, row_desc) -> Tpat_variant (cstr, arg, row_desc) + | `Record (fields, closed) -> Tpat_record (fields, closed) + | `Array ps -> Tpat_array ps + | `Or (p, q, row_desc) -> Tpat_or (p, q, row_desc) + | `Lazy p -> Tpat_lazy p + + let erase p = { p with pat_desc = erase_desc p.pat_desc } +end + +module Half_simple : sig + (** Half-simplified patterns are patterns where: + - records are expanded so that they possess all fields + - aliases are removed and replaced by bindings in actions. + + Or-patterns are not removed, they are only "half-simplified": + - aliases under or-patterns are kept + - or-patterns whose right-hand-side is subsumed by their lhs + are simplified to their lhs. + For instance: [(_ :: _ | 1 :: _)] is changed into [_ :: _] + - or-patterns whose left-hand-side is not simplified + are preserved: (p|q) is changed into (simpl(p)|simpl(q)) + {v + # match lazy (print_int 3; 3) with _ | lazy 2 -> ();; + - : unit = () + # match lazy (print_int 3; 3) with lazy 2 | _ -> ();; + 3- : unit = () + v} + + In particular, or-patterns may still occur in the leading column, + so this is only a "half-simplification". *) + + type pattern = half_simple_view pattern_data + + type clause = pattern Non_empty_clause.t + + val of_clause : arg:lambda -> General.clause -> clause +end = struct + type pattern = half_simple_view pattern_data + + type clause = pattern Non_empty_clause.t + + let rec simpl_under_orpat p = + match p.pat_desc with + | Tpat_any + | Tpat_var _ -> + p + | Tpat_alias (q, id, s) -> + { p with pat_desc = Tpat_alias (simpl_under_orpat q, id, s) } + | Tpat_or (p1, p2, o) -> + let p1, p2 = (simpl_under_orpat p1, simpl_under_orpat p2) in + if le_pat p1 p2 then + p1 + else + { p with pat_desc = Tpat_or (p1, p2, o) } + | Tpat_record (lbls, closed) -> + let all_lbls = all_record_args lbls in + { p with pat_desc = Tpat_record (all_lbls, closed) } + | _ -> p + + (* Explode or-patterns and turn aliases into bindings in actions *) + let of_clause ~arg cl = + let rec aux (((p, patl), action) : General.clause) : clause = + let continue p (view : general_view) : clause = + aux (({ p with pat_desc = view }, patl), action) + in + let stop p (view : half_simple_view) : clause = + (({ p with pat_desc = view }, patl), action) + in + match p.pat_desc with + | `Any -> stop p `Any + | `Var (id, s) -> continue p (`Alias (omega, id, s)) + | `Alias (p, id, _) -> + let k = Typeopt.value_kind p.pat_env p.pat_type in + aux + ( (General.view p, patl), + bind_with_value_kind Alias (id, k) arg action ) + | `Record ([], _) as view -> stop p view + | `Record (lbls, closed) -> + let full_view = `Record (all_record_args lbls, closed) in + stop p full_view + | `Or _ -> ( + let orpat = General.view (simpl_under_orpat (General.erase p)) in + match orpat.pat_desc with + | `Or _ as or_view -> stop orpat or_view + | other_view -> continue orpat other_view + ) + | ( `Constant _ | `Tuple _ | `Construct _ | `Variant _ | `Array _ + | `Lazy _ ) as view -> + stop p view + in + aux cl +end + +exception Cannot_flatten + +module Simple : sig + type pattern = simple_view pattern_data + + type clause = pattern Non_empty_clause.t + + val head : pattern -> Pattern_head.t + + val explode_or_pat : + Half_simple.pattern * Typedtree.pattern list -> + arg:Ident.t option -> + mk_action:(vars:Ident.t list -> lambda) -> + vars:Ident.t list -> + clause list -> + clause list +end = struct + type pattern = simple_view pattern_data + + type clause = pattern Non_empty_clause.t + + let head p = + fst (Pattern_head.deconstruct (General.erase (p :> General.pattern))) + + let alpha env (p : pattern) : pattern = + let alpha_pat env p = Typedtree.alpha_pat env p in + let pat_desc = + match p.pat_desc with + | `Any -> `Any + | `Constant cst -> `Constant cst + | `Tuple ps -> `Tuple (List.map (alpha_pat env) ps) + | `Construct (cstr, cst_descr, args) -> + `Construct (cstr, cst_descr, List.map (alpha_pat env) args) + | `Variant (cstr, argo, row_desc) -> + `Variant (cstr, Option.map (alpha_pat env) argo, row_desc) + | `Record (fields, closed) -> + let alpha_field env (lid, l, p) = (lid, l, alpha_pat env p) in + `Record (List.map (alpha_field env) fields, closed) + | `Array ps -> `Array (List.map (alpha_pat env) ps) + | `Lazy p -> `Lazy (alpha_pat env p) + in + { p with pat_desc } + + let mk_alpha_env arg aliases ids = + List.map + (fun id -> + ( id, + if List.mem id aliases then + match arg with + | Some v -> v + | _ -> raise Cannot_flatten + else + Ident.create_local (Ident.name id) )) + ids + + let explode_or_pat ((p : Half_simple.pattern), patl) ~arg ~mk_action ~vars + (rem : clause list) : clause list = + let rec explode p aliases rem = + let split_explode p aliases rem = explode (General.view p) aliases rem in + match p.pat_desc with + | `Or (p1, p2, _) -> + split_explode p1 aliases (split_explode p2 aliases rem) + | `Alias (p, id, _) -> split_explode p (id :: aliases) rem + | `Var (id, str) -> + explode + { p with pat_desc = `Alias (Parmatch.omega, id, str) } + aliases rem + | #simple_view as view -> + let env = mk_alpha_env arg aliases vars in + ( (alpha env { p with pat_desc = view }, patl), + mk_action ~vars:(List.map snd env) ) + :: rem + in + explode (p : Half_simple.pattern :> General.pattern) [] rem +end + +type initial_clause = pattern list clause + type matrix = pattern list list let add_omega_column pss = List.map (fun ps -> omega :: ps) pss @@ -249,76 +489,49 @@ end = struct let combine ctx = List.map Row.combine ctx - let ctx_matcher p = - let p = normalize_pat p in - match p.pat_desc with - | Tpat_construct (_, cstr, omegas) -> ( - fun q rem -> - match q.pat_desc with - | Tpat_construct (_, cstr', args) - (* NB: may_constr_equal considers (potential) constructor rebinding *) - when Types.may_equal_constr cstr cstr' -> - (p, args @ rem) - | Tpat_any -> (p, omegas @ rem) - | _ -> raise NoMatch - ) - | Tpat_constant cst -> ( - fun q rem -> - match q.pat_desc with - | Tpat_constant cst' when const_compare cst cst' = 0 -> (p, rem) - | Tpat_any -> (p, rem) - | _ -> raise NoMatch - ) - | Tpat_variant (lab, Some omega, _) -> ( - fun q rem -> - match q.pat_desc with - | Tpat_variant (lab', Some arg, _) when lab = lab' -> (p, arg :: rem) - | Tpat_any -> (p, omega :: rem) - | _ -> raise NoMatch - ) - | Tpat_variant (lab, None, _) -> ( - fun q rem -> - match q.pat_desc with - | Tpat_variant (lab', None, _) when lab = lab' -> (p, rem) - | Tpat_any -> (p, rem) - | _ -> raise NoMatch - ) - | Tpat_array omegas -> ( - let len = List.length omegas in - fun q rem -> - match q.pat_desc with - | Tpat_array args when List.length args = len -> (p, args @ rem) - | Tpat_any -> (p, omegas @ rem) - | _ -> raise NoMatch - ) - | Tpat_tuple omegas -> ( - let len = List.length omegas in - fun q rem -> - match q.pat_desc with - | Tpat_tuple args when List.length args = len -> (p, args @ rem) - | Tpat_any -> (p, omegas @ rem) - | _ -> raise NoMatch - ) - | Tpat_record (((_, lbl, _) :: _ as l), _) -> ( - (* Records are normalized *) - let len = Array.length lbl.lbl_all in - fun q rem -> - match q.pat_desc with - | Tpat_record (((_, lbl', _) :: _ as l'), _) - when Array.length lbl'.lbl_all = len -> - let l' = all_record_args l' in - (p, List.fold_right (fun (_, _, p) r -> p :: r) l' rem) - | Tpat_any -> (p, List.fold_right (fun (_, _, p) r -> p :: r) l rem) - | _ -> raise NoMatch - ) - | Tpat_lazy omega -> ( - fun q rem -> - match q.pat_desc with - | Tpat_lazy arg -> (p, arg :: rem) - | Tpat_any -> (p, omega :: rem) - | _ -> raise NoMatch - ) - | _ -> fatal_error "Matching.Context.matcher" + let ctx_matcher p q rem = + let rec expand_record p = + match p.pat_desc with + | Tpat_record (l, _) -> + { p with pat_desc = Tpat_record (all_record_args l, Closed) } + | Tpat_alias (p, _, _) -> expand_record p + | _ -> p + in + let ph, omegas = + let ph, p_args = Pattern_head.deconstruct (expand_record p) in + (ph, List.map (fun _ -> omega) p_args) + in + let qh, args = Pattern_head.deconstruct (expand_record q) in + let yes () = (p, args @ rem) in + let no () = raise NoMatch in + let yesif b = + if b then + yes () + else + no () + in + match (Pattern_head.desc ph, Pattern_head.desc qh) with + | Any, _ -> fatal_error "Matching.Context.matcher" + | _, Any -> (p, omegas @ rem) + | Construct cstr, Construct cstr' -> + (* NB: may_equal_constr considers (potential) constructor rebinding *) + yesif (Types.may_equal_constr cstr cstr') + | Construct _, _ -> no () + | Constant cst, Constant cst' -> yesif (const_compare cst cst' = 0) + | Constant _, _ -> no () + | Variant { tag; has_arg }, Variant { tag = tag'; has_arg = has_arg' } -> + yesif (tag = tag' && has_arg = has_arg') + | Variant _, _ -> no () + | Array n1, Array n2 -> yesif (n1 = n2) + | Array _, _ -> no () + | Tuple n1, Tuple n2 -> yesif (n1 = n2) + | Tuple _, _ -> no () + | Record l, Record l' -> + (* we called expand_record on both arguments so l, l' are full *) + yesif (List.length l = List.length l') + | Record _, _ -> no () + | Lazy, Lazy -> yes () + | Lazy, _ -> no () let specialize q ctx = let matcher = ctx_matcher q in @@ -623,8 +836,8 @@ end (* Pattern matching before any compilation *) -type pattern_matching = { - mutable cases : (pattern list * lambda) list; +type 'row pattern_matching = { + mutable cases : 'row list; args : (lambda * let_kind) list; (** args are not just Ident.t in at least the following cases: - when matching the arguments of a constructor, @@ -638,11 +851,11 @@ type handler = { provenance : matrix; exit : int; vars : (Ident.t * Lambda.value_kind) list; - pm : pattern_matching + pm : initial_clause pattern_matching } -type pm_or_compiled = { - body : pattern_matching; +type 'head_pat pm_or_compiled = { + body : 'head_pat Non_empty_clause.t pattern_matching; handlers : handler list; or_matrix : matrix } @@ -651,9 +864,9 @@ type pm_or_compiled = { mixture rule *) type pm_half_compiled = - | PmOr of pm_or_compiled + | PmOr of Simple.pattern pm_or_compiled | PmVar of { inside : pm_half_compiled } - | Pm of pattern_matching + | Pm of Simple.clause pattern_matching (* Only used inside the various split functions, we only keep [me] when we're done splitting / precompiling. *) @@ -666,6 +879,12 @@ type pm_half_compiled_info = { top_default : Default_environment.t } +let erase_cases f cases = + List.map (fun ((p, ps), act) -> (f p :: ps, act)) cases + +let erase_pm pm = + { pm with cases = erase_cases General.erase pm.cases } + let pretty_cases cases = List.iter (fun (ps, _l) -> @@ -681,13 +900,13 @@ let pretty_pm pm = let rec pretty_precompiled = function | Pm pm -> Format.eprintf "++++ PM ++++\n"; - pretty_pm pm + pretty_pm (erase_pm pm) | PmVar x -> Format.eprintf "++++ VAR ++++\n"; pretty_precompiled x.inside | PmOr x -> Format.eprintf "++++ OR ++++\n"; - pretty_pm x.body; + pretty_pm (erase_pm x.body); pretty_matrix Format.err_formatter x.or_matrix; List.iter (fun { exit = i; pm; _ } -> @@ -778,7 +997,7 @@ let same_actions = function None ) -let safe_before (ps, act_p) l = +let safe_before ((p, ps), act_p) l = (* Test for swapping two clauses *) let same_actions act1 act2 = match (make_key act1, make_key act2) with @@ -788,145 +1007,35 @@ let safe_before (ps, act_p) l = false in List.for_all - (fun (qs, act_q) -> same_actions act_p act_q || not (may_compats ps qs)) + (fun ((q, qs), act_q) -> + same_actions act_p act_q + || not (may_compats (General.erase p :: ps) (General.erase q :: qs))) l -(* - The half-simplify functions transforms the first column of the match - - records are expanded so that they possess all fields - - aliases are removed and replaced by bindings in actions. - - However or-patterns are only half-simplified, - - aliases under or-patterns are kept - - or-patterns whose right-hand-side is subsumed by their lhs - are simplified to their lhs. - For instance: [(_ :: _ | 1 :: _)] is changed into [_ :: _] - - or-patterns whose left-hand-side is not simplified - are preserved: (p|q) is changed into (simpl(p)|simpl(q)) - {v - # match lazy (print_int 3; 3) with _ | lazy 2 -> ();; - - : unit = () - # match lazy (print_int 3; 3) with lazy 2 | _ -> ();; - 3- : unit = () - v} - - In particular, or-patterns may still occur in the head of the output row, - so this is only a "half-simplification". -*) -let half_simplify_cases args cls = - let rec simpl_pat p = - match p.pat_desc with - | Tpat_any - | Tpat_var _ -> - p - | Tpat_alias (q, id, s) -> - { p with pat_desc = Tpat_alias (simpl_pat q, id, s) } - | Tpat_or (p1, p2, o) -> - let p1, p2 = (simpl_pat p1, simpl_pat p2) in - if le_pat p1 p2 then - p1 - else - { p with pat_desc = Tpat_or (p1, p2, o) } - | Tpat_record (lbls, closed) -> - let all_lbls = all_record_args lbls in - { p with pat_desc = Tpat_record (all_lbls, closed) } - | _ -> p - in - let rec simpl_clause cl = - match cl with - | [], _ -> assert false - | pat :: patl, action -> ( - match pat.pat_desc with - | Tpat_any -> cl - | Tpat_var (id, s) -> - let p = { pat with pat_desc = Tpat_alias (omega, id, s) } in - simpl_clause (p :: patl, action) - | Tpat_alias (p, id, _) -> - let arg = - match args with - | [] -> assert false - | (arg, _) :: _ -> arg - in - let k = Typeopt.value_kind pat.pat_env pat.pat_type in - simpl_clause - (p :: patl, bind_with_value_kind Alias (id, k) arg action) - | Tpat_record ([], _) -> (omega :: patl, action) - | Tpat_record (lbls, closed) -> - let all_lbls = all_record_args lbls in - let full_pat = - { pat with pat_desc = Tpat_record (all_lbls, closed) } - in - (full_pat :: patl, action) - | Tpat_or _ -> ( - let pat_simple = simpl_pat pat in - match pat_simple.pat_desc with - | Tpat_or _ -> (pat_simple :: patl, action) - | _ -> simpl_clause (pat_simple :: patl, action) - ) - | Tpat_constant _ - | Tpat_tuple _ - | Tpat_construct _ - | Tpat_variant _ - | Tpat_array _ - | Tpat_lazy _ - | Tpat_exception _ -> - cl - ) - in - List.map simpl_clause cls +let half_simplify_nonempty ~arg (cls : Typedtree.pattern Non_empty_clause.t) : + Half_simple.clause = + cls |> Non_empty_clause.map_head General.view |> Half_simple.of_clause ~arg + +let half_simplify_clause ~arg (cls : Typedtree.pattern list clause) = + cls |> Non_empty_clause.of_initial |> half_simplify_nonempty ~arg (* Once matchings are *fully* simplified, one can easily find their nature. *) let rec what_is_cases ~skip_any cases = match cases with - | [] -> omega - | ([], _) :: _ -> assert false - | (p :: _, _) :: rem -> ( - match p.pat_desc with - | Tpat_any when skip_any -> what_is_cases ~skip_any rem - | Tpat_var _ - | Tpat_or (_, _, _) - | Tpat_alias (_, _, _) -> - (* applies to simplified matchings only *) - assert false - | _ -> p + | [] -> Pattern_head.omega + | ((p, _), _) :: rem -> ( + let head = Simple.head p in + match Pattern_head.desc head with + | Any when skip_any -> what_is_cases ~skip_any rem + | _ -> head ) let what_is_first_case = what_is_cases ~skip_any:false let what_is_cases = what_is_cases ~skip_any:true -(* Or-pattern expansion, variables are a complication w.r.t. the article *) - -exception Cannot_flatten - -let mk_alpha_env arg aliases ids = - List.map - (fun id -> - ( id, - if List.mem id aliases then - match arg with - | Some v -> v - | _ -> raise Cannot_flatten - else - Ident.create_local (Ident.name id) )) - ids - -let rec explode_or_pat p arg patl mk_action vars aliases rem = - match p.pat_desc with - | Tpat_or (p1, p2, _) -> - explode_or_pat p1 arg patl mk_action vars aliases - (explode_or_pat p2 arg patl mk_action vars aliases rem) - | Tpat_alias (p, id, _) -> - explode_or_pat p arg patl mk_action vars (id :: aliases) rem - | Tpat_var (x, _) -> - let env = mk_alpha_env arg (x :: aliases) vars in - (omega :: patl, mk_action (List.map snd env)) :: rem - | _ -> - let env = mk_alpha_env arg aliases vars in - (alpha_pat env p :: patl, mk_action (List.map snd env)) :: rem - let pm_free_variables { cases } = List.fold_right (fun (_, act) r -> Ident.Set.union (free_variables act) r) @@ -937,91 +1046,39 @@ let pat_as_constr = function | { pat_desc = Tpat_construct (_, cstr, _) } -> cstr | _ -> fatal_error "Matching.pat_as_constr" -let group_const_int = function - | { pat_desc = Tpat_constant (Const_int _) } -> true - | _ -> false - -let group_const_char = function - | { pat_desc = Tpat_constant (Const_char _) } -> true - | _ -> false - -let group_const_string = function - | { pat_desc = Tpat_constant (Const_string _) } -> true - | _ -> false - -let group_const_float = function - | { pat_desc = Tpat_constant (Const_float _) } -> true - | _ -> false - -let group_const_int32 = function - | { pat_desc = Tpat_constant (Const_int32 _) } -> true - | _ -> false - -let group_const_int64 = function - | { pat_desc = Tpat_constant (Const_int64 _) } -> true - | _ -> false - -let group_const_nativeint = function - | { pat_desc = Tpat_constant (Const_nativeint _) } -> true - | _ -> false - -and group_constructor = function - | { pat_desc = Tpat_construct (_, _, _) } -> true - | _ -> false - -and group_same_constructor tag = function - | { pat_desc = Tpat_construct (_, cstr, _) } -> - Types.equal_tag tag cstr.cstr_tag - | _ -> false - -and group_variant = function - | { pat_desc = Tpat_variant (_, _, _) } -> true - | _ -> false - -and group_var = function - | { pat_desc = Tpat_any } -> true - | _ -> false - -and group_tuple = function - | { pat_desc = Tpat_tuple _ | Tpat_any } -> true - | _ -> false - -and group_record = function - | { pat_desc = Tpat_record _ | Tpat_any } -> true - | _ -> false - -and group_array = function - | { pat_desc = Tpat_array _ } -> true - | _ -> false - -and group_lazy = function - | { pat_desc = Tpat_lazy _ } -> true - | _ -> false - -let can_group p = - match p.pat_desc with - | Tpat_any -> group_var - | Tpat_constant (Const_int _) -> group_const_int - | Tpat_constant (Const_char _) -> group_const_char - | Tpat_constant (Const_string _) -> group_const_string - | Tpat_constant (Const_float _) -> group_const_float - | Tpat_constant (Const_int32 _) -> group_const_int32 - | Tpat_constant (Const_int64 _) -> group_const_int64 - | Tpat_constant (Const_nativeint _) -> group_const_nativeint - | Tpat_construct (_, { cstr_tag = Cstr_extension _ as t }, _) -> +let can_group discr pat = + match (Pattern_head.desc discr, Pattern_head.desc (Simple.head pat)) with + | Any, Any + | Constant (Const_int _), Constant (Const_int _) + | Constant (Const_char _), Constant (Const_char _) + | Constant (Const_string _), Constant (Const_string _) + | Constant (Const_float _), Constant (Const_float _) + | Constant (Const_int32 _), Constant (Const_int32 _) + | Constant (Const_int64 _), Constant (Const_int64 _) + | Constant (Const_nativeint _), Constant (Const_nativeint _) -> + true + | Construct { cstr_tag = Cstr_extension _ as discr_tag }, Construct pat_cstr + -> (* Extension constructors with distinct names may be equal thanks to constructor rebinding. So we need to produce a specialized submatrix for each syntactically-distinct constructor (with a threading of exits such that each submatrix falls back to the potentially-compatible submatrices below it). *) - group_same_constructor t - | Tpat_construct _ -> group_constructor - | Tpat_tuple _ -> group_tuple - | Tpat_record _ -> group_record - | Tpat_array _ -> group_array - | Tpat_variant (_, _, _) -> group_variant - | Tpat_lazy _ -> group_lazy - | _ -> fatal_error "Matching.can_group" + Types.equal_tag discr_tag pat_cstr.cstr_tag + | Construct _, Construct _ + | Tuple _, (Tuple _ | Any) + | Record _, (Record _ | Any) + | Array _, Array _ + | Variant _, Variant _ + | Lazy, Lazy -> + true + | ( _, + ( Any + | Constant + ( Const_int _ | Const_char _ | Const_string _ | Const_float _ + | Const_int32 _ | Const_int64 _ | Const_nativeint _ ) + | Construct _ | Tuple _ | Record _ | Array _ | Variant _ | Lazy ) ) -> + false let is_or p = match p.pat_desc with @@ -1037,12 +1094,17 @@ let rec omega_like p = | Tpat_or (p1, p2, _) -> omega_like p1 || omega_like p2 | _ -> false +let simple_omega_like p = + match Pattern_head.desc (Simple.head p) with + | Any -> true + | _ -> false + let equiv_pat p q = le_pat p q && le_pat q p let rec extract_equiv_head p l = match l with - | ((q :: _, _) as cl) :: rem -> - if equiv_pat p q then + | (((q, _), _) as cl) :: rem -> + if equiv_pat p (General.erase q) then let others, rem = extract_equiv_head p rem in (cl :: others, rem) else @@ -1074,9 +1136,10 @@ module Or_matrix = struct let safe_below_or_matrix l (q, qs) = List.for_all - (function - | ({ pat_desc = Tpat_or _ } as p) :: ps, act_p -> - disjoint p q || safe_below (ps, act_p) qs + (fun ((p, ps), act_p) -> + let p = General.erase p in + match p.pat_desc with + | Tpat_or _ -> disjoint p q || safe_below (ps, act_p) qs | _ -> true) l @@ -1086,25 +1149,21 @@ module Or_matrix = struct If neither are possible we add to the bottom of the No matrix. *) - let insert_or_append (p, ps, act) rev_ors rev_no = + let insert_or_append (head, ps, act) rev_ors rev_no = let safe_to_insert rem (p, ps) seen = let _, not_e = extract_equiv_head p rem in (* check append condition for head of O *) safe_below_or_matrix not_e (p, ps) && (* check insert condition for tail of O *) - List.for_all - (fun cl -> - match cl with - | q :: _, _ -> disjoint p q - | _ -> assert false) - seen + List.for_all (fun ((q, _), _) -> disjoint p (General.erase q)) seen in let rec attempt seen = function (* invariant: the new clause is safe to append at the end of [seen] (but maybe not [rem] yet) *) - | [] -> ((p :: ps, act) :: rev_ors, rev_no) - | ([], _act) :: _ -> assert false - | ((q :: qs, act_q) as cl) :: rem -> + | [] -> (((head, ps), act) :: rev_ors, rev_no) + | (((q, qs), act_q) as cl) :: rem -> + let p = General.erase head in + let q = General.erase q in if (not (is_or q)) || disjoint p q then attempt (cl :: seen) rem else if @@ -1114,21 +1173,22 @@ module Or_matrix = struct then (* attempt insertion, for equivalent orpats with no variables *) if safe_to_insert rem (p, ps) seen then - (List.rev_append seen ((p :: ps, act) :: cl :: rem), rev_no) + (List.rev_append seen (((head, ps), act) :: cl :: rem), rev_no) else (* fail to insert or append *) - (rev_ors, (p :: ps, act) :: rev_no) + (rev_ors, ((head, ps), act) :: rev_no) else if safe_below (qs, act_q) ps then attempt (cl :: seen) rem else - (rev_ors, (p :: ps, act) :: rev_no) + (rev_ors, ((head, ps), act) :: rev_no) in attempt [] rev_ors end (* Reconstruct default information from half_compiled pm list *) -let as_matrix cases = get_mins le_pats (List.map (fun (ps, _) -> ps) cases) +let as_matrix cases = + get_mins le_pats (List.map (fun ((p, ps), _) -> General.erase p :: ps) cases) (* Split a matching along the first column. @@ -1143,7 +1203,7 @@ let as_matrix cases = get_mins le_pats (List.map (fun (ps, _) -> ps) cases) Some precompilation of or-patterns and variable pattern occurs. Mostly this means that bindings are performed now, being replaced by let-bindings - in actions (cf. half_simplify_cases). + in actions (cf. Half_simple.of_clause). Additionally, if the match argument is a variable, matchings whose first column is made of variables only are split further @@ -1153,7 +1213,7 @@ let as_matrix cases = get_mins le_pats (List.map (fun (ps, _) -> ps) cases) Note: we assume that the first column of each pattern is coherent -- all patterns match values of the same type. This comes from the fact that - we make agressive splitting decisions, splitting pattern heads that + we make aggressive splitting decisions, splitting pattern heads that may be different into different submatrices; in particular, in a given submatrix the first column is formed of first arguments to the same constructor. @@ -1168,29 +1228,31 @@ let as_matrix cases = get_mins le_pats (List.map (fun (ps, _) -> ps) cases) in a leftmost column. Parmatch has to be more conservative because it splits less - agressively: submatrices will contain not just the arguments of + aggressively: submatrices will contain not just the arguments of a given pattern head, but also other lines that may be compatible with it, in particular those with a leftmost omega and those starting with an extension constructor that may be equal to it. *) -let rec split_or argo cls args def = - let cls = half_simplify_cases args cls in - let rec do_split rev_before rev_ors rev_no = function +let rec split_or argo (cls : Half_simple.clause list) args def = + let rec do_split (rev_before : Simple.clause list) rev_ors rev_no = function | [] -> cons_next (List.rev rev_before) (List.rev rev_ors) (List.rev rev_no) - | ((p :: ps, act) as cl) :: rem -> - if not (safe_before cl rev_no) then - do_split rev_before rev_ors (cl :: rev_no) rem - else if (not (is_or p)) && safe_before cl rev_ors then - do_split (cl :: rev_before) rev_ors rev_no rem - else - let rev_ors, rev_no = - Or_matrix.insert_or_append (p, ps, act) rev_ors rev_no - in - do_split rev_before rev_ors rev_no rem - | _ -> assert false + | cl :: rem when not (safe_before cl rev_no) -> + do_split rev_before rev_ors (cl :: rev_no) rem + | (((p, ps), act) as cl) :: rem -> ( + match p.pat_desc with + | #simple_view as view when safe_before cl rev_ors -> + do_split + ((({ p with pat_desc = view }, ps), act) :: rev_before) + rev_ors rev_no rem + | _ -> + let rev_ors, rev_no = + Or_matrix.insert_or_append (p, ps, act) rev_ors rev_no + in + do_split rev_before rev_ors rev_no rem + ) and cons_next yes yesor no = let def, nexts = match no with @@ -1222,12 +1284,12 @@ and split_no_or cls args def k = (where it is not always possible to syntactically decide whether two different heads match different values), but this is handled by the [can_group] function. *) - let rec split cls = + let rec split (cls : Simple.clause list) = let discr = what_is_first_case cls in collect discr [] [] cls and collect group_discr rev_yes rev_no = function - | ([], _) :: _ -> assert false - | [ ((ps, _) as cl) ] when rev_yes <> [] && List.for_all omega_like ps -> + | [ (((p, ps), _) as cl) ] + when rev_yes <> [] && simple_omega_like p && List.for_all omega_like ps -> (* This enables an extra division in some frequent cases: last row is made of variables only @@ -1239,7 +1301,7 @@ and split_no_or cls args def k = This optimisation is tested in the first part of testsuite/tests/basic/patmatch_split_no_or.ml *) collect group_discr rev_yes (cl :: rev_no) [] - | ((p :: _, _) as cl) :: rem -> + | (((p, _), _) as cl) :: rem -> if can_group group_discr p && safe_before cl rev_no then collect group_discr (cl :: rev_yes) rev_no rem else if should_split group_discr then ( @@ -1253,10 +1315,9 @@ and split_no_or cls args def k = insert_split group_discr yes no def k and insert_split group_discr yes no def k = let precompile_group = - if group_var group_discr then - precompile_var - else - do_not_precompile + match Pattern_head.desc group_discr with + | Any -> precompile_var + | _ -> do_not_precompile in match no with | [] -> precompile_group args yes def k @@ -1267,8 +1328,8 @@ and split_no_or cls args def k = (Default_environment.cons matrix idef def) ((idef, next) :: nexts) and should_split group_discr = - match group_discr.pat_desc with - | Tpat_construct (_, { cstr_tag = Cstr_extension _ }, _) -> + match Pattern_head.desc group_discr with + | Construct { cstr_tag = Cstr_extension _ } -> (* it is unlikely that we will raise anything, so we split now *) true | _ -> false @@ -1291,18 +1352,20 @@ and precompile_var args cls def k = do_not_precompile args cls def k | _ -> ( (* Precompile *) + let var_args = arg :: rargs in let var_cls = List.map - (fun (ps, act) -> - match ps with - | p :: ps -> - assert (group_var p); - (ps, act) - | _ -> assert false) + (fun ((p, ps), act) -> + assert (simple_omega_like p); + + (* we learned by pattern-matching on [args] + that [p::ps] has at least two arguments, + so [ps] must be non-empty *) + half_simplify_clause ~arg:(fst arg) (ps, act)) cls and var_def = Default_environment.pop_column def in let { me = first; matrix }, nexts = - split_or (Some v) var_cls (arg :: rargs) var_def + split_or (Some v) var_cls var_args var_def in (* Compute top information *) match nexts with @@ -1323,7 +1386,7 @@ and precompile_var args cls def k = (fun (mat, e) -> add_omega_column mat, e) top_default (* assuming it'd been bound. *) ]} - As we would be loosing information: [def] is more precise + As we would be losing information: [def] is more precise than [add_omega_column (pop_column def)]. *) List.fold_right (fun (e, pmh) -> @@ -1353,55 +1416,65 @@ and do_not_precompile args cls def k = }, k ) -and precompile_or argo cls ors args def k = +and precompile_or argo (cls : Simple.clause list) ors args def k = let rec do_cases = function - | (({ pat_desc = Tpat_or _ } as orp) :: patl, action) :: rem -> - let others, rem = extract_equiv_head orp rem in - let orpm = - { cases = - (patl, action) - :: List.map - (function - | _ :: ps, action -> (ps, action) - | _ -> assert false) - others; - args = - ( match args with - | _ :: r -> r - | _ -> assert false - ); - default = Default_environment.pop_compat orp def - } - in - let pm_fv = pm_free_variables orpm in - let vars = - (* bound variables of the or-pattern and used in the orpm actions *) - Typedtree.pat_bound_idents_full orp - |> List.filter (fun (id, _, _) -> Ident.Set.mem id pm_fv) - |> List.map (fun (id, _, ty) -> - (id, Typeopt.value_kind orp.pat_env ty)) - in - let or_num = next_raise_count () in - let new_patl = Parmatch.omega_list patl in - let mk_new_action vs = - Lstaticraise (or_num, List.map (fun v -> Lvar v) vs) - in - let rem_cases, rem_handlers = do_cases rem in - let cases = - explode_or_pat orp argo new_patl mk_new_action (List.map fst vars) [] - rem_cases - in - let handler = - { provenance = [ [ orp ] ]; exit = or_num; vars; pm = orpm } - in - (cases, handler :: rem_handlers) - | cl :: rem -> - let new_ord, new_to_catch = do_cases rem in - (cl :: new_ord, new_to_catch) | [] -> ([], []) + | ((p, patl), action) :: rem -> ( + match p.pat_desc with + | #simple_view as view -> + let new_ord, new_to_catch = do_cases rem in + ( (({ p with pat_desc = view }, patl), action) :: new_ord, + new_to_catch ) + | `Or _ -> + let orp = General.erase p in + let others, rem = extract_equiv_head orp rem in + let orpm = + { cases = + (patl, action) + :: List.map (fun ((_, ps), action) -> (ps, action)) others; + args = + ( match args with + | _ :: r -> r + | _ -> assert false + ); + default = Default_environment.pop_compat orp def + } + in + let pm_fv = pm_free_variables orpm in + let vars = + (* bound variables of the or-pattern and used in the orpm + actions *) + Typedtree.pat_bound_idents_full orp + |> List.filter (fun (id, _, _) -> Ident.Set.mem id pm_fv) + |> List.map (fun (id, _, ty) -> + (id, Typeopt.value_kind orp.pat_env ty)) + in + let or_num = next_raise_count () in + let new_patl = Parmatch.omega_list patl in + let mk_new_action ~vars = + Lstaticraise (or_num, List.map (fun v -> Lvar v) vars) + in + let rem_cases, rem_handlers = do_cases rem in + let cases = + Simple.explode_or_pat (p, new_patl) ~arg:argo + ~mk_action:mk_new_action ~vars:(List.map fst vars) rem_cases + in + let handler = + { provenance = [ [ orp ] ]; + exit = or_num; + vars; + pm = orpm + } + in + (cases, handler :: rem_handlers) + ) in let cases, handlers = do_cases ors in - let matrix = as_matrix (cls @ ors) + let matrix = + as_matrix + ((cls : Simple.clause list :> General.clause list) + @ (ors : Half_simple.clause list :> General.clause list) + ) and body = { cases = cls @ cases; args; default = def } in ( { me = PmOr { body; handlers; or_matrix = matrix }; matrix; @@ -1409,8 +1482,7 @@ and precompile_or argo cls ors args def k = }, k ) -let split_and_precompile argo pm = - let { me = next }, nexts = split_or argo pm.cases pm.args pm.default in +let dbg_split_and_precompile pm next nexts = if dbg && (nexts <> [] @@ -1421,14 +1493,33 @@ let split_and_precompile argo pm = ) then ( Format.eprintf "** SPLIT **\n"; - pretty_pm pm; + pretty_pm (erase_pm pm); pretty_precompiled_res next nexts - ); + ) + +let split_and_precompile_simplified pm = + let { me = next }, nexts = split_no_or pm.cases pm.args pm.default [] in + dbg_split_and_precompile pm next nexts; + (next, nexts) + +let split_and_precompile_half_simplified ~arg pm = + let { me = next }, nexts = split_or arg pm.cases pm.args pm.default in + dbg_split_and_precompile pm next nexts; (next, nexts) +let split_and_precompile ~arg_id ~arg_lambda pm = + let pm = + { pm with cases = List.map (half_simplify_clause ~arg:arg_lambda) pm.cases } + in + split_and_precompile_half_simplified ~arg:arg_id pm + (* General divide functions *) -type cell = { pm : pattern_matching; ctx : Context.t; discr : pattern } +type cell = { + pm : initial_clause pattern_matching; + ctx : Context.t; + discr : pattern +} (** a submatrix after specializing by discriminant pattern; [ctx] is the context shared by all rows. *) @@ -1450,14 +1541,13 @@ let add_in_div make_matching_fun eq_key key patl_action division = in { division with cells } -let divide make eq_key get_key get_args ctx (pm : pattern_matching) = - let add clause division = - match clause with - | [], _ -> assert false - | p :: patl, action -> - add_in_div (make p pm.default ctx) eq_key (get_key p) - (get_args p patl, action) - division +let divide make eq_key get_key get_args ctx + (pm : Simple.clause pattern_matching) = + let add ((p, patl), action) division = + let p = General.erase p in + add_in_div (make p pm.default ctx) eq_key (get_key p) + (get_args p patl, action) + division in List.fold_right add pm.cases { args = pm.args; cells = [] } @@ -1465,11 +1555,11 @@ let add_line patl_action pm = pm.cases <- patl_action :: pm.cases; pm -let divide_line make_ctx make get_args discr ctx (pm : pattern_matching) = - let add clause submatrix = - match clause with - | [], _ -> assert false - | p :: patl, action -> add_line (get_args p patl, action) submatrix +let divide_line make_ctx make get_args discr ctx + (pm : Simple.clause pattern_matching) = + let add ((p, patl), action) submatrix = + let p = General.erase p in + add_line (get_args p patl, action) submatrix in let pm = List.fold_right add pm.cases (make pm.default pm.args) in { pm; ctx = make_ctx ctx; discr } @@ -1602,9 +1692,9 @@ let matcher_constr cstr = match q.pat_desc with | Tpat_or (_, _, _) -> (* we cannot preserve the or-pattern as in the arity-1 case, - because we cannot express - (K (p1, .., pn) | K (q1, .. qn)) - as (p1 .. pn | q1 .. qn) *) + because we cannot express + (K (p1, .., pn) | K (q1, .. qn)) + as (p1 .. pn | q1 .. qn) *) raise OrPat | Tpat_construct (_, cstr', args) when Types.may_equal_constr cstr cstr' -> @@ -1613,7 +1703,7 @@ let matcher_constr cstr = | _ -> raise NoMatch ) -let make_constr_matching p def ctx = function +let make_constr_matching ~scopes p def ctx = function | [] -> fatal_error "Matching.make_constr_matching" | (arg, _mut) :: argl -> let cstr = pat_as_constr p in @@ -1624,10 +1714,12 @@ let make_constr_matching p def ctx = function match cstr.cstr_tag with | Cstr_constant _ | Cstr_block _ -> - make_field_args p.pat_loc Alias arg 0 (cstr.cstr_arity - 1) argl + make_field_args (of_location ~scopes p.pat_loc) + Alias arg 0 (cstr.cstr_arity - 1) argl | Cstr_unboxed -> (arg, Alias) :: argl | Cstr_extension _ -> - make_field_args p.pat_loc Alias arg 1 cstr.cstr_arity argl + make_field_args (of_location ~scopes p.pat_loc) + Alias arg 1 cstr.cstr_arity argl in { pm = { cases = []; @@ -1638,8 +1730,9 @@ let make_constr_matching p def ctx = function discr = normalize_pat p } -let divide_constructor ctx pm = - divide make_constr_matching ( = ) get_key_constr get_args_constr ctx pm +let divide_constructor ~scopes ctx pm = + divide (make_constr_matching ~scopes) ( = ) + get_key_constr get_args_constr ctx pm (* Matching against a variant *) @@ -1670,26 +1763,34 @@ let matcher_variant_nonconst lab p rem = | Tpat_any -> omega :: rem | _ -> raise NoMatch -let make_variant_matching_nonconst p lab def ctx = function +let make_variant_matching_nonconst ~scopes p lab def ctx = function | [] -> fatal_error "Matching.make_variant_matching_nonconst" | (arg, _mut) :: argl -> let def = Default_environment.specialize (matcher_variant_nonconst lab) def - and ctx = Context.specialize p ctx in + and ctx = Context.specialize p ctx + and loc = of_location ~scopes p.pat_loc in { pm = { cases = []; - args = (Lprim (Pfield 1, [ arg ], p.pat_loc), Alias) :: argl; + args = (Lprim (Pfield 1, [ arg ], loc), Alias) + :: argl; default = def }; ctx; discr = normalize_pat p } -let divide_variant row ctx { cases = cl; args; default = def } = +let divide_variant ~scopes row ctx { cases = cl; args; default = def } = let row = Btype.row_repr row in let rec divide = function - | (({ pat_desc = Tpat_variant (lab, pato, _) } as p) :: patl, action) - :: rem -> ( + | [] -> { args; cells = [] } + | ((p, patl), action) :: rem + -> ( + let lab, pato = match p.pat_desc with + | `Variant (lab, pato, _) -> lab, pato + | _ -> assert false + in + let p = General.erase p in let variants = divide rem in if try Btype.row_field_repr (List.assoc lab row.row_fields) = Rabsent @@ -1705,12 +1806,11 @@ let divide_variant row ctx { cases = cl; args; default = def } = ( = ) (Cstr_constant tag) (patl, action) variants | Some pat -> add_in_div - (make_variant_matching_nonconst p lab def ctx) + (make_variant_matching_nonconst ~scopes p lab def ctx) ( = ) (Cstr_block tag) (pat :: patl, action) variants ) - | _ -> { args; cells = [] } in divide cl @@ -1763,13 +1863,13 @@ let get_mod_field modname field = Env.add_persistent_structure mod_ident Env.initial_safe_string in match Env.open_pers_signature modname env with - | exception Not_found -> + | Error `Not_found -> fatal_error ("Module " ^ modname ^ " unavailable.") - | env -> ( + | Ok env -> ( match Env.find_value_by_name (Longident.Lident field) env with | exception Not_found -> fatal_error ("Primitive " ^ modname ^ "." ^ field ^ " not found.") - | path, _ -> transl_value_path Location.none env path + | path, _ -> transl_value_path Loc_unknown env path )) let code_force_lazy_block = get_mod_field "CamlinternalLazy" "force_lazy_block" @@ -1803,15 +1903,15 @@ let inline_lazy_force_cond arg loc = tag, Lprim (Pccall prim_obj_tag, [ varg ], loc), Lifthenelse - ( (* if (tag == Obj.forward_tag) then varg.(0) else ... *) - Lprim + (* if (tag == Obj.forward_tag) then varg.(0) else ... *) + ( Lprim ( Pintcomp Ceq, [ tag_var; Lconst (Const_base (Const_int Obj.forward_tag)) ], loc ), Lprim (Pfield 0, [ varg ], loc), Lifthenelse - ( (* if (tag == Obj.lazy_tag) then Lazy.force varg else ... *) - Lprim + (* if (tag == Obj.lazy_tag) then Lazy.force varg else ... *) + ( Lprim ( Pintcomp Ceq, [ tag_var; Lconst (Const_base (Const_int Obj.lazy_tag)) ], loc ), @@ -1886,7 +1986,7 @@ let make_lazy_matching def = function | [] -> fatal_error "Matching.make_lazy_matching" | (arg, _mut) :: argl -> { cases = []; - args = (inline_lazy_force arg Location.none, Strict) :: argl; + args = (inline_lazy_force arg Loc_unknown, Strict) :: argl; default = Default_environment.specialize matcher_lazy def } @@ -1924,9 +2024,9 @@ let make_tuple_matching loc arity def = function default = Default_environment.specialize (matcher_tuple arity) def } -let divide_tuple arity p ctx pm = +let divide_tuple ~scopes arity p ctx pm = divide_line (Context.specialize p) - (make_tuple_matching p.pat_loc arity) + (make_tuple_matching (of_location ~scopes p.pat_loc) arity) (get_args_tuple arity) p ctx pm (* Matching against a record pattern *) @@ -1984,10 +2084,10 @@ let make_record_matching loc all_labels def = function let def = Default_environment.specialize (matcher_record nfields) def in { cases = []; args = make_args 0; default = def } -let divide_record all_labels p ctx pm = +let divide_record ~scopes all_labels p ctx pm = let get_args = get_args_record (Array.length all_labels) in divide_line (Context.specialize p) - (make_record_matching p.pat_loc all_labels) + (make_record_matching (of_location ~scopes p.pat_loc) all_labels) get_args p ctx pm (* Matching against an array pattern *) @@ -2008,7 +2108,7 @@ let matcher_array len p rem = | Tpat_any -> Parmatch.omegas len @ rem | _ -> raise NoMatch -let make_array_matching kind p def ctx = function +let make_array_matching ~scopes kind p def ctx = function | [] -> fatal_error "Matching.make_array_matching" | (arg, _mut) :: argl -> let len = get_key_array p in @@ -2019,7 +2119,7 @@ let make_array_matching kind p def ctx = function ( Lprim ( Parrayrefu kind, [ arg; Lconst (Const_base (Const_int pos)) ], - p.pat_loc ), + (of_location ~scopes p.pat_loc) ), StrictOpt ) :: make_args (pos + 1) in @@ -2030,8 +2130,9 @@ let make_array_matching kind p def ctx = function discr = normalize_pat p } -let divide_array kind ctx pm = - divide (make_array_matching kind) ( = ) get_key_array get_args_array ctx pm +let divide_array ~scopes kind ctx pm = + divide (make_array_matching ~scopes kind) ( = ) + get_key_array get_args_array ctx pm (* Specific string test sequence @@ -2248,12 +2349,14 @@ module SArg = struct type act = Lambda.lambda - let make_prim p args = Lprim (p, args, Location.none) + type loc = Lambda.scoped_location + + let make_prim p args = Lprim (p, args, Loc_unknown) let make_offset arg n = match n with | 0 -> arg - | _ -> Lprim (Poffsetint n, [ arg ], Location.none) + | _ -> Lprim (Poffsetint n, [ arg ], Loc_unknown) let bind arg body = let newvar, newarg = @@ -2267,9 +2370,9 @@ module SArg = struct let make_const i = Lconst (Const_base (Const_int i)) - let make_isout h arg = Lprim (Pisout, [ h; arg ], Location.none) + let make_isout h arg = Lprim (Pisout, [ h; arg ], Loc_unknown) - let make_isin h arg = Lprim (Pnot, [ make_isout h arg ], Location.none) + let make_isin h arg = Lprim (Pnot, [ make_isout h arg ], Loc_unknown) let make_if cond ifso ifnot = Lifthenelse (cond, ifso, ifnot) @@ -2457,9 +2560,9 @@ let as_interval_nofail l = | (i, act) :: rem -> let act_index = (* In case there is some hole and that a switch is emitted, - action 0 will be used as the action of unreachable - cases (cf. switch.ml, make_switch). - Hence, this action will be shared *) + action 0 will be used as the action of unreachable + cases (cf. switch.ml, make_switch). + Hence, this action will be shared *) if some_hole rem then store.act_store_shared () act else @@ -2517,8 +2620,8 @@ let mk_failaction_neg partial ctx def = (Some (Lstaticraise (idef, [])), Jumps.singleton idef ctx) | None -> (* Act as Total, this means - If no appropriate default matrix exists, - then this switch cannot fail *) + If no appropriate default matrix exists, + then this switch cannot fail *) (None, Jumps.empty) ) | Total -> (None, Jumps.empty) @@ -2613,7 +2716,7 @@ let combine_constant loc arg cst partial ctx def List.map (fun (c, act) -> match c with - | Const_string (s, _) -> (s, act) + | Const_string (s, _, _) -> (s, act) | _ -> assert false) const_lambda_list in @@ -2668,7 +2771,7 @@ let split_extension_cases tag_lambda_list = in split_rec tag_lambda_list -let combine_constructor loc arg ex_pat cstr partial ctx def +let combine_constructor loc arg pat_env cstr partial ctx def (tag_lambda_list, total1, pats) = match cstr.cstr_tag with | Cstr_extension _ -> @@ -2694,7 +2797,7 @@ let combine_constructor loc arg ex_pat cstr partial ctx def let tests = List.fold_right (fun (path, act) rem -> - let ext = transl_extension_path loc ex_pat.pat_env path in + let ext = transl_extension_path loc pat_env path in Lifthenelse (Lprim (Pintcomp Ceq, [ Lvar tag; ext ], loc), act, rem)) nonconsts default @@ -2703,7 +2806,7 @@ let combine_constructor loc arg ex_pat cstr partial ctx def in List.fold_right (fun (path, act) rem -> - let ext = transl_extension_path loc ex_pat.pat_env path in + let ext = transl_extension_path loc pat_env path in Lifthenelse (Lprim (Pintcomp Ceq, [ arg; ext ], loc), act, rem)) consts nonconst_lambda in @@ -3045,7 +3148,7 @@ let rec comp_match_handlers comp_fun partial ctx first_match next_matchs = (* To find reasonable names for variables *) let rec name_pattern default = function - | (pat :: _, _) :: rem -> ( + | ((pat, _), _) :: rem -> ( match pat.pat_desc with | Tpat_var (id, _) -> id | Tpat_alias (_, id, _) -> id @@ -3071,37 +3174,61 @@ let arg_to_var arg cls = Output: a lambda term, a jump summary {..., exit number -> context, .. } *) -let rec compile_match repr partial ctx (m : pattern_matching) = - match m with - | { cases = []; args = [] } -> comp_exit ctx m - | { cases = ([], action) :: rem } -> +let rec compile_match ~scopes repr partial ctx + (m : initial_clause pattern_matching) = + match m.cases with + | ([], action) :: rem -> if is_guarded action then let lambda, total = - compile_match None partial ctx { m with cases = rem } + compile_match ~scopes None partial ctx { m with cases = rem } in (event_branch repr (patch_guarded lambda action), total) else (event_branch repr action, Jumps.empty) + | nonempty_cases -> + compile_match_nonempty ~scopes repr partial ctx + { m with cases = List.map Non_empty_clause.of_initial nonempty_cases } + +and compile_match_nonempty ~scopes repr partial ctx + (m : Typedtree.pattern Non_empty_clause.t pattern_matching) = + match m with + | { cases = []; args = [] } -> comp_exit ctx m | { args = (arg, str) :: argl } -> let v, newarg = arg_to_var arg m.cases in + let args = (newarg, Alias) :: argl in + let cases = List.map (half_simplify_nonempty ~arg:newarg) m.cases in + let m = { m with args; cases } in let first_match, rem = - split_and_precompile (Some v) { m with args = (newarg, Alias) :: argl } - in - let lam, total = - comp_match_handlers - (( if dbg then - do_compile_matching_pr - else - do_compile_matching - ) - repr) - partial ctx first_match rem - in - (bind_check str v arg lam, total) + split_and_precompile_half_simplified ~arg:(Some v) m in + combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem | _ -> assert false +and compile_match_simplified ~scopes repr partial ctx + (m : Simple.clause pattern_matching) = + match m with + | { cases = []; args = [] } -> comp_exit ctx m + | { args = ((Lvar v as arg), str) :: argl } -> + let args = (arg, Alias) :: argl in + let m = { m with args } in + let first_match, rem = split_and_precompile_simplified m in + combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem + | _ -> assert false + +and combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem = + let lam, total = + comp_match_handlers + (( if dbg then + do_compile_matching_pr ~scopes + else + do_compile_matching ~scopes + ) + repr) + partial ctx first_match rem + in + (bind_check str v arg lam, total) + (* verbose version of do_compile_matching, for debug *) -and do_compile_matching_pr repr partial ctx x = +and do_compile_matching_pr ~scopes repr partial ctx x = Format.eprintf "COMPILE: %s\nMATCH\n" ( match partial with | Partial -> "Partial" @@ -3110,12 +3237,12 @@ and do_compile_matching_pr repr partial ctx x = pretty_precompiled x; Format.eprintf "CTX\n"; Context.eprintf ctx; - let ((_, jumps) as r) = do_compile_matching repr partial ctx x in + let ((_, jumps) as r) = do_compile_matching ~scopes repr partial ctx x in Format.eprintf "JUMPS\n"; Jumps.eprintf jumps; r -and do_compile_matching repr partial ctx pmh = +and do_compile_matching ~scopes repr partial ctx pmh = match pmh with | Pm pm -> ( let arg = @@ -3131,61 +3258,66 @@ and do_compile_matching repr partial ctx pmh = *) assert false in - let pat = what_is_cases pm.cases in - match pat.pat_desc with - | Tpat_any -> - compile_no_test divide_var Context.rshift repr partial ctx pm - | Tpat_tuple patl -> - compile_no_test - (divide_tuple (List.length patl) (normalize_pat pat)) + let ph = what_is_cases pm.cases in + let pomega = Pattern_head.to_omega_pattern ph in + let ploc = Pattern_head.loc ph in + match Pattern_head.desc ph with + | Any -> + compile_no_test ~scopes divide_var Context.rshift repr partial ctx pm + | Tuple l -> + compile_no_test ~scopes (divide_tuple ~scopes l pomega) Context.combine repr partial ctx pm - | Tpat_record ((_, lbl, _) :: _, _) -> - compile_no_test - (divide_record lbl.lbl_all (normalize_pat pat)) + | Record [] -> assert false + | Record (lbl :: _) -> + compile_no_test ~scopes + (divide_record ~scopes lbl.lbl_all pomega) Context.combine repr partial ctx pm - | Tpat_constant cst -> + | Constant cst -> compile_test - (compile_match repr partial) + (compile_match ~scopes repr partial) partial divide_constant - (combine_constant pat.pat_loc arg cst partial) + (combine_constant (of_location ~scopes ploc) arg cst partial) ctx pm - | Tpat_construct (_, cstr, _) -> + | Construct cstr -> compile_test - (compile_match repr partial) - partial divide_constructor - (combine_constructor pat.pat_loc arg pat cstr partial) + (compile_match ~scopes repr partial) + partial (divide_constructor ~scopes) + (combine_constructor (of_location ~scopes ploc) arg + (Pattern_head.env ph) cstr partial) ctx pm - | Tpat_array _ -> - let kind = Typeopt.array_pattern_kind pat in + | Array _ -> + let kind = Typeopt.array_pattern_kind pomega in compile_test - (compile_match repr partial) - partial (divide_array kind) - (combine_array pat.pat_loc arg kind partial) + (compile_match ~scopes repr partial) + partial (divide_array ~scopes kind) + (combine_array (of_location ~scopes ploc) arg kind partial) ctx pm - | Tpat_lazy _ -> - compile_no_test - (divide_lazy (normalize_pat pat)) + | Lazy -> + compile_no_test ~scopes + (divide_lazy pomega) Context.combine repr partial ctx pm - | Tpat_variant (_, _, row) -> + | Variant { cstr_row = row } -> compile_test - (compile_match repr partial) - partial (divide_variant !row) - (combine_variant pat.pat_loc !row arg partial) + (compile_match ~scopes repr partial) + partial (divide_variant ~scopes !row) + (combine_variant (of_location ~scopes ploc) !row arg partial) ctx pm - | _ -> assert false ) | PmVar { inside = pmh } -> let lam, total = - do_compile_matching repr partial (Context.lshift ctx) pmh + do_compile_matching ~scopes repr partial (Context.lshift ctx) pmh in (lam, Jumps.map Context.rshift total) | PmOr { body; handlers } -> - let lam, total = compile_match repr partial ctx body in - compile_orhandlers (compile_match repr partial) lam total ctx handlers + let lam, total = + compile_match_simplified ~scopes repr partial ctx body in + compile_orhandlers (compile_match ~scopes repr partial) + lam total ctx handlers -and compile_no_test divide up_ctx repr partial ctx to_match = +and compile_no_test ~scopes divide up_ctx repr partial ctx to_match = let { pm = this_match; ctx = this_ctx } = divide ctx to_match in - let lambda, total = compile_match repr partial this_ctx this_match in + let lambda, total = + compile_match ~scopes repr partial this_ctx this_match in (lambda, Jumps.map up_ctx total) (* The entry points *) @@ -3208,7 +3340,8 @@ LM: I have generalized the patch, so as to also find mutable fields. *) -let is_lazy_pat p = match p.pat_desc with +let is_lazy_pat p = + match p.pat_desc with | Tpat_lazy _ -> true | Tpat_alias _ | Tpat_variant _ @@ -3221,10 +3354,8 @@ let is_lazy_pat p = match p.pat_desc with | Tpat_var _ | Tpat_any -> false - | Tpat_exception _ -> assert false -let has_lazy p = - Typedtree.exists_pattern is_lazy_pat p +let has_lazy p = Typedtree.exists_pattern is_lazy_pat p let is_record_with_mutable_field p = match p.pat_desc with @@ -3246,10 +3377,8 @@ let is_record_with_mutable_field p = | Tpat_var _ | Tpat_any -> false - | Tpat_exception _ -> assert false -let has_mutable p = - Typedtree.exists_pattern is_record_with_mutable_field p +let has_mutable p = Typedtree.exists_pattern is_record_with_mutable_field p (* Downgrade Total when 1. Matching accesses some mutable fields; @@ -3271,10 +3400,11 @@ let check_partial has_mutable has_lazy pat_act_list = function else Total -let check_partial_list = - check_partial (List.exists has_mutable) (List.exists has_lazy) +let check_partial_list pats_act_list = + check_partial (List.exists has_mutable) (List.exists has_lazy) pats_act_list -let check_partial = check_partial has_mutable has_lazy +let check_partial pat_act_list = + check_partial has_mutable has_lazy pat_act_list (* have toplevel handler when appropriate *) @@ -3284,7 +3414,7 @@ let check_total total lambda i handler_fun = else Lstaticcatch (lambda, (i, []), handler_fun ()) -let compile_matching repr handler_fun arg pat_act_list partial = +let compile_matching ~scopes repr handler_fun arg pat_act_list partial = let partial = check_partial pat_act_list partial in match partial with | Partial -> ( @@ -3296,7 +3426,8 @@ let compile_matching repr handler_fun arg pat_act_list partial = } in try - let lambda, total = compile_match repr partial (Context.start 1) pm in + let lambda, total = + compile_match ~scopes repr partial (Context.start 1) pm in check_total total lambda raise_num handler_fun with Unused -> assert false (* ; handler_fun() *) @@ -3308,15 +3439,18 @@ let compile_matching repr handler_fun arg pat_act_list partial = default = Default_environment.empty } in - let lambda, total = compile_match repr partial (Context.start 1) pm in + let lambda, total = + compile_match ~scopes repr partial (Context.start 1) pm in assert (Jumps.is_empty total); lambda -let partial_function loc () = +let partial_function ~scopes loc () = + let sloc = of_location ~scopes loc in let slot = - transl_extension_path loc Env.initial_safe_string Predef.path_match_failure + transl_extension_path sloc Env.initial_safe_string Predef.path_match_failure in - let fname, line, char = Location.get_pos_info loc.Location.loc_start in + let fname, line, char = + Location.get_pos_info loc.Location.loc_start in Lprim ( Praise Raise_regular, [ Lprim @@ -3325,26 +3459,28 @@ let partial_function loc () = Lconst (Const_block ( 0, - [ Const_base (Const_string (fname, None)); + [ Const_base (Const_string (fname, loc, None)); Const_base (Const_int line); Const_base (Const_int char) ] )) ], - loc ) + sloc ) ], - loc ) + sloc ) -let for_function loc repr param pat_act_list partial = - compile_matching repr (partial_function loc) param pat_act_list partial +let for_function ~scopes loc repr param pat_act_list partial = + let f () = partial_function ~scopes loc () in + compile_matching ~scopes repr f param pat_act_list partial (* In the following two cases, exhaustiveness info is not available! *) -let for_trywith param pat_act_list = - compile_matching None - (fun () -> Lprim (Praise Raise_reraise, [ param ], Location.none)) +let for_trywith ~scopes param pat_act_list = + compile_matching ~scopes None + (fun () -> Lprim (Praise Raise_reraise, [ param ], Loc_unknown)) param pat_act_list Partial -let simple_for_let loc param pat body = - compile_matching None (partial_function loc) param [ (pat, body) ] Partial +let simple_for_let ~scopes loc param pat body = + compile_matching ~scopes None (partial_function ~scopes loc) + param [ (pat, body) ] Partial (* Optimize binding of immediate tuples @@ -3404,8 +3540,28 @@ let rec map_return f = function | Ltrywith (l1, id, l2) -> Ltrywith (map_return f l1, id, map_return f l2) | Lstaticcatch (l1, b, l2) -> Lstaticcatch (map_return f l1, b, map_return f l2) + | Lswitch (s, sw, loc) -> + let map_cases cases = + List.map (fun (i, l) -> (i, map_return f l)) cases + in + Lswitch + ( s, + { sw with + sw_consts = map_cases sw.sw_consts; + sw_blocks = map_cases sw.sw_blocks; + sw_failaction = Option.map (map_return f) sw.sw_failaction + }, + loc ) + | Lstringswitch (s, cases, def, loc) -> + Lstringswitch + ( s, + List.map (fun (s, l) -> (s, map_return f l)) cases, + Option.map (map_return f) def, + loc ) | (Lstaticraise _ | Lprim (Praise _, _, _)) as l -> l - | l -> f l + | ( Lvar _ | Lconst _ | Lapply _ | Lfunction _ | Lsend _ | Lprim _ | Lwhile _ + | Lfor _ | Lassign _ | Lifused _ ) as l -> + f l (* The 'opt' reference indicates if the optimization is worthy. @@ -3422,7 +3578,7 @@ let rec map_return f = function can be costly (one unnecessary tuple allocation). *) -let assign_pat opt nraise catch_ids loc pat lam = +let assign_pat ~scopes opt nraise catch_ids loc pat lam = let rec collect acc pat lam = match (pat.pat_desc, lam) with | Tpat_tuple patl, Lprim (Pmakeblock _, lams, _) -> @@ -3434,7 +3590,7 @@ let assign_pat opt nraise catch_ids loc pat lam = List.fold_left2 collect_const acc patl scl | _ -> (* pattern idents will be bound in staticcatch (let body), so we - refresh them here to guarantee binders uniqueness *) + refresh them here to guarantee binders uniqueness *) let pat_ids = pat_bound_idents pat in let fresh_ids = List.map (fun id -> (id, Ident.rename id)) pat_ids in (fresh_ids, alpha_pat fresh_ids pat, lam) :: acc @@ -3453,10 +3609,11 @@ let assign_pat opt nraise catch_ids loc pat lam = let fresh_var id = Lvar (Ident.find_same id tbl) in Lstaticraise (nraise, List.map fresh_var catch_ids) in - let push_sublet code (_ids, pat, lam) = simple_for_let loc lam pat code in + let push_sublet code (_ids, pat, lam) = + simple_for_let ~scopes loc lam pat code in List.fold_left push_sublet exit rev_sublets -let for_let loc param pat body = +let for_let ~scopes loc param pat body = match pat.pat_desc with | Tpat_any -> (* This eliminates a useless variable (and stack slot in bytecode) @@ -3476,16 +3633,17 @@ let for_let loc param pat body = catch_ids in let ids = List.map (fun (id, _, _) -> id) catch_ids in - let bind = map_return (assign_pat opt nraise ids loc pat) param in + let bind = + map_return (assign_pat ~scopes opt nraise ids loc pat) param in if !opt then Lstaticcatch (bind, (nraise, ids_with_kinds), body) else - simple_for_let loc param pat body + simple_for_let ~scopes loc param pat body (* Handling of tupled functions and matchings *) (* Easy case since variables are available *) -let for_tupled_function loc paraml pats_act_list partial = +let for_tupled_function ~scopes loc paraml pats_act_list partial = let partial = check_partial_list pats_act_list partial in let raise_num = next_raise_count () in let omegas = [ List.map (fun _ -> omega) paraml ] in @@ -3497,10 +3655,11 @@ let for_tupled_function loc paraml pats_act_list partial = in try let lambda, total = - compile_match None partial (Context.start (List.length paraml)) pm + compile_match ~scopes None partial + (Context.start (List.length paraml)) pm in - check_total total lambda raise_num (partial_function loc) - with Unused -> partial_function loc () + check_total total lambda raise_num (partial_function ~scopes loc) + with Unused -> partial_function ~scopes loc () let flatten_pattern size p = match p.pat_desc with @@ -3510,10 +3669,13 @@ let flatten_pattern size p = let flatten_cases size cases = List.map - (fun (ps, action) -> - match ps with - | [ p ] -> (flatten_pattern size p, action) - | _ -> fatal_error "Matching.flatten_case") + (function + | (p, []), action -> ( + match flatten_pattern size (General.erase p) with + | p :: ps -> ((p, ps), action) + | [] -> assert false + ) + | _ -> fatal_error "Matching.flatten_hc_cases") cases let flatten_pm size args pm = @@ -3525,11 +3687,15 @@ let flatten_pm size args pm = let flatten_handler size handler = { handler with provenance = flatten_matrix size handler.provenance } +type pm_flattened = + | FPmOr of pattern pm_or_compiled + | FPm of pattern Non_empty_clause.t pattern_matching + let flatten_precompiled size args pmh = match pmh with - | Pm pm -> Pm (flatten_pm size args pm) + | Pm pm -> FPm (flatten_pm size args pm) | PmOr { body = b; handlers = hs; or_matrix = m } -> - PmOr + FPmOr { body = flatten_pm size args b; handlers = List.map (flatten_handler size) hs; or_matrix = flatten_matrix size m @@ -3541,18 +3707,17 @@ let flatten_precompiled size args pmh = Hence it needs a fourth argument, which it ignores *) -let compile_flattened repr partial ctx pmh = +let compile_flattened ~scopes repr partial ctx pmh = match pmh with - | Pm pm -> compile_match repr partial ctx pm - | PmOr { body = b; handlers = hs } -> - let lam, total = compile_match repr partial ctx b in - compile_orhandlers (compile_match repr partial) lam total ctx hs - | PmVar _ -> assert false + | FPm pm -> compile_match_nonempty ~scopes repr partial ctx pm + | FPmOr { body = b; handlers = hs } -> + let lam, total = compile_match_nonempty ~scopes repr partial ctx b in + compile_orhandlers (compile_match ~scopes repr partial) lam total ctx hs -let do_for_multiple_match loc paraml pat_act_list partial = +let do_for_multiple_match ~scopes loc paraml pat_act_list partial = let repr = None in let partial = check_partial pat_act_list partial in - let raise_num, pm1 = + let raise_num, arg, pm1 = let raise_num, default = match partial with | Partial -> @@ -3560,17 +3725,21 @@ let do_for_multiple_match loc paraml pat_act_list partial = (raise_num, Default_environment.(cons [ [ omega ] ] raise_num empty)) | Total -> (-1, Default_environment.empty) in + let loc = of_location ~scopes loc in + let arg = Lprim (Pmakeblock (0, Immutable, None), paraml, loc) in ( raise_num, + arg, { cases = List.map (fun (pat, act) -> ([ pat ], act)) pat_act_list; - args = - [ (Lprim (Pmakeblock (0, Immutable, None), paraml, loc), Strict) ]; + args = [ (arg, Strict) ]; default } ) in try try (* Once for checking that compilation is possible *) - let next, nexts = split_and_precompile None pm1 in + let next, nexts = + split_and_precompile ~arg_id:None ~arg_lambda:arg pm1 + in let size = List.length paraml and idl = List.map (fun _ -> Ident.create_local "*match*") paraml in let args = List.map (fun id -> (Lvar id, Alias)) idl in @@ -3579,20 +3748,23 @@ let do_for_multiple_match loc paraml pat_act_list partial = List.map (fun (e, pm) -> (e, flatten_precompiled size args pm)) nexts in let lam, total = - comp_match_handlers (compile_flattened repr) partial + comp_match_handlers (compile_flattened ~scopes repr) partial (Context.start size) flat_next flat_nexts in List.fold_right2 (bind Strict) idl paraml ( match partial with - | Partial -> check_total total lam raise_num (partial_function loc) + | Partial -> + check_total total lam raise_num (partial_function ~scopes loc) | Total -> assert (Jumps.is_empty total); lam ) with Cannot_flatten -> ( - let lambda, total = compile_match None partial (Context.start 1) pm1 in + let lambda, total = + compile_match ~scopes None partial (Context.start 1) pm1 in match partial with - | Partial -> check_total total lambda raise_num (partial_function loc) + | Partial -> + check_total total lambda raise_num (partial_function ~scopes loc) | Total -> assert (Jumps.is_empty total); lambda @@ -3614,8 +3786,8 @@ let bind_opt (v, eo) k = | None -> k | Some e -> Lambda.bind Strict v e k -let for_multiple_match loc paraml pat_act_list partial = +let for_multiple_match ~scopes loc paraml pat_act_list partial = let v_paraml = List.map param_to_var paraml in let paraml = List.map (fun (v, _) -> Lvar v) v_paraml in List.fold_right bind_opt v_paraml - (do_for_multiple_match loc paraml pat_act_list partial) + (do_for_multiple_match ~scopes loc paraml pat_act_list partial) diff --git a/lambda/matching.mli b/lambda/matching.mli index f29901bd..7b41a713 100644 --- a/lambda/matching.mli +++ b/lambda/matching.mli @@ -17,23 +17,30 @@ open Typedtree open Lambda - +open Debuginfo.Scoped_location (* Entry points to match compiler *) val for_function: - Location.t -> int ref option -> lambda -> (pattern * lambda) list -> - partial -> lambda + scopes:scopes -> Location.t -> + int ref option -> lambda -> (pattern * lambda) list -> partial -> + lambda val for_trywith: - lambda -> (pattern * lambda) list -> lambda + scopes:scopes -> + lambda -> (pattern * lambda) list -> + lambda val for_let: - Location.t -> lambda -> pattern -> lambda -> lambda + scopes:scopes -> Location.t -> + lambda -> pattern -> lambda -> + lambda val for_multiple_match: - Location.t -> lambda list -> (pattern * lambda) list -> partial -> + scopes:scopes -> Location.t -> + lambda list -> (pattern * lambda) list -> partial -> lambda val for_tupled_function: - Location.t -> Ident.t list -> (pattern list * lambda) list -> - partial -> lambda + scopes:scopes -> Location.t -> + Ident.t list -> (pattern list * lambda) list -> partial -> + lambda exception Cannot_flatten @@ -41,6 +48,7 @@ val flatten_pattern: int -> pattern -> pattern list (* Expand stringswitch to string test tree *) val expand_stringswitch: - Location.t -> lambda -> (string * lambda) list -> lambda option -> lambda + scoped_location -> lambda -> (string * lambda) list -> + lambda option -> lambda -val inline_lazy_force : lambda -> Location.t -> lambda +val inline_lazy_force : lambda -> scoped_location -> lambda diff --git a/lambda/printlambda.ml b/lambda/printlambda.ml index e4bb26a6..87340608 100644 --- a/lambda/printlambda.ml +++ b/lambda/printlambda.ml @@ -23,7 +23,7 @@ open Lambda let rec struct_const ppf = function | Const_base(Const_int n) -> fprintf ppf "%i" n | Const_base(Const_char c) -> fprintf ppf "%C" c - | Const_base(Const_string (s, _)) -> fprintf ppf "%S" s + | Const_base(Const_string (s, _, _)) -> fprintf ppf "%S" s | Const_immstring s -> fprintf ppf "#%S" s | Const_base(Const_float f) -> fprintf ppf "%s" f | Const_base(Const_int32 n) -> fprintf ppf "%lil" n @@ -218,6 +218,9 @@ let primitive ppf = function | Plsrint -> fprintf ppf "lsr" | Pasrint -> fprintf ppf "asr" | Pintcomp(cmp) -> integer_comparison ppf cmp + | Pcompare_ints -> fprintf ppf "compare_ints" + | Pcompare_floats -> fprintf ppf "compare_floats" + | Pcompare_bints bi -> fprintf ppf "compare_bints %s" (boxed_integer_name bi) | Poffsetint n -> fprintf ppf "%i+" n | Poffsetref n -> fprintf ppf "+:=%i"n | Pintoffloat -> fprintf ppf "int_of_float" @@ -377,6 +380,9 @@ let name_of_primitive = function | Plsrint -> "Plsrint" | Pasrint -> "Pasrint" | Pintcomp _ -> "Pintcomp" + | Pcompare_ints -> "Pcompare_ints" + | Pcompare_floats -> "Pcompare_floats" + | Pcompare_bints _ -> "Pcompare" | Poffsetint _ -> "Poffsetint" | Poffsetref _ -> "Poffsetref" | Pintoffloat -> "Pintoffloat" @@ -453,6 +459,7 @@ let function_attribute ppf { inline; specialise; local; is_a_functor; stub } = begin match inline with | Default_inline -> () | Always_inline -> fprintf ppf "always_inline@ " + | Hint_inline -> fprintf ppf "hint_inline@ " | Never_inline -> fprintf ppf "never_inline@ " | Unroll i -> fprintf ppf "unroll(%i)@ " i end; @@ -475,6 +482,7 @@ let apply_inlined_attribute ppf = function | Default_inline -> () | Always_inline -> fprintf ppf " always_inline" | Never_inline -> fprintf ppf " never_inline" + | Hint_inline -> fprintf ppf " hint_inline" | Unroll i -> fprintf ppf " never_inline(%i)" i let apply_specialised_attribute ppf = function @@ -625,13 +633,24 @@ let rec lam ppf = function | Lev_module_definition ident -> Format.asprintf "module-defn(%a)" Ident.print ident in - fprintf ppf "@[<2>(%s %s(%i)%s:%i-%i@ %a)@]" kind - ev.lev_loc.Location.loc_start.Lexing.pos_fname - ev.lev_loc.Location.loc_start.Lexing.pos_lnum - (if ev.lev_loc.Location.loc_ghost then "" else "") - ev.lev_loc.Location.loc_start.Lexing.pos_cnum - ev.lev_loc.Location.loc_end.Lexing.pos_cnum - lam expr + (* -dno-locations also hides the placement of debug events; + this is good for the readability of the resulting output (usually + the end-user goal when using -dno-locations), as it strongly + reduces the nesting level of subterms. *) + if not !Clflags.locations then lam ppf expr + else begin match ev.lev_loc with + | Loc_unknown -> + fprintf ppf "@[<2>(%s @ %a)@]" kind lam expr + | Loc_known {scopes; loc} -> + fprintf ppf "@[<2>(%s %s %s(%i)%s:%i-%i@ %a)@]" kind + (Debuginfo.Scoped_location.string_of_scopes scopes) + loc.Location.loc_start.Lexing.pos_fname + loc.Location.loc_start.Lexing.pos_lnum + (if loc.Location.loc_ghost then "" else "") + loc.Location.loc_start.Lexing.pos_cnum + loc.Location.loc_end.Lexing.pos_cnum + lam expr + end | Lifused(id, expr) -> fprintf ppf "@[<2>(ifused@ %a@ %a)@]" Ident.print id lam expr diff --git a/lambda/simplif.ml b/lambda/simplif.ml index 8cc7fe5e..b8a3415b 100644 --- a/lambda/simplif.ml +++ b/lambda/simplif.ml @@ -18,6 +18,7 @@ open Asttypes open Lambda +open Debuginfo.Scoped_location (* To transform let-bound references into variables *) @@ -600,12 +601,6 @@ let is_tail_native_heuristic : (int -> bool) ref = ref (fun _ -> true) let rec emit_tail_infos is_tail lambda = - let call_kind args = - if is_tail - && ((not !Clflags.native_code) - || (!is_tail_native_heuristic (List.length args))) - then Annot.Tail - else Annot.Stack in match lambda with | Lvar _ -> () | Lconst _ -> () @@ -613,11 +608,10 @@ let rec emit_tail_infos is_tail lambda = if ap.ap_should_be_tailcall && not is_tail && Warnings.is_active Warnings.Expect_tailcall - then Location.prerr_warning ap.ap_loc Warnings.Expect_tailcall; + then Location.prerr_warning (to_location ap.ap_loc) + Warnings.Expect_tailcall; emit_tail_infos false ap.ap_func; - list_emit_tail_infos false ap.ap_args; - if !Clflags.annotations then - Stypes.record (Stypes.An_call (ap.ap_loc, call_kind ap.ap_args)) + list_emit_tail_infos false ap.ap_args | Lfunction {body = lam} -> emit_tail_infos true lam | Llet (_str, _k, _, lam, body) -> @@ -671,12 +665,10 @@ let rec emit_tail_infos is_tail lambda = emit_tail_infos false body | Lassign (_, lam) -> emit_tail_infos false lam - | Lsend (_, meth, obj, args, loc) -> + | Lsend (_, meth, obj, args, _loc) -> emit_tail_infos false meth; emit_tail_infos false obj; - list_emit_tail_infos false args; - if !Clflags.annotations then - Stypes.record (Stypes.An_call (loc, call_kind (obj :: args))); + list_emit_tail_infos false args | Levent (lam, _) -> emit_tail_infos is_tail lam | Lifused (_, lam) -> @@ -716,7 +708,7 @@ let split_default_wrapper ~id:fun_id ~kind ~params ~return ~body ~attr ~loc = Lapply { ap_func = Lvar inner_id; ap_args = args; - ap_loc = Location.none; + ap_loc = Loc_unknown; ap_should_be_tailcall = false; ap_inlined = Default_inline; ap_specialised = Default_specialise; @@ -774,7 +766,7 @@ let simplify_local_functions lam = let current_scope = ref lam in let check_static lf = if lf.attr.local = Always_local then - Location.prerr_warning lf.loc + Location.prerr_warning (to_location lf.loc) (Warnings.Inlining_impossible "This function cannot be compiled into a static continuation") in @@ -782,7 +774,8 @@ let simplify_local_functions lam = | {local = Always_local; _} | {local = Default_local; inline = (Never_inline | Default_inline); _} -> true - | {local = Default_local; inline = (Always_inline | Unroll _); _} + | {local = Default_local; + inline = (Always_inline | Unroll _ | Hint_inline); _} | {local = Never_local; _} -> false in diff --git a/lambda/simplif.mli b/lambda/simplif.mli index d5ca210e..a8011a20 100644 --- a/lambda/simplif.mli +++ b/lambda/simplif.mli @@ -36,7 +36,7 @@ val split_default_wrapper -> return:Lambda.value_kind -> body:lambda -> attr:function_attribute - -> loc:Location.t + -> loc:Lambda.scoped_location -> (Ident.t * lambda) list (* To be filled by asmcomp/selectgen.ml *) diff --git a/lambda/switch.ml b/lambda/switch.ml index 36c7026f..032f0390 100644 --- a/lambda/switch.ml +++ b/lambda/switch.ml @@ -116,6 +116,7 @@ sig val geint : primitive val gtint : primitive type act + type loc val bind : act -> (act -> act) -> act val make_const : int -> act @@ -124,7 +125,7 @@ sig val make_isout : act -> act -> act val make_isin : act -> act -> act val make_if : act -> act -> act -> act - val make_switch : Location.t -> act -> int array -> act array -> act + val make_switch : loc -> act -> int array -> act array -> act val make_catch : act -> int * (act -> act) val make_exit : int -> act end diff --git a/lambda/switch.mli b/lambda/switch.mli index b4058c17..f71240b7 100644 --- a/lambda/switch.mli +++ b/lambda/switch.mli @@ -76,6 +76,8 @@ module type S = val gtint : primitive (* type of actions *) type act + (* type of source locations *) + type loc (* Various constructors, for making a binder, adding one integer, etc. *) @@ -89,8 +91,7 @@ module type S = (* construct an actual switch : make_switch arg cases acts NB: cases is in the value form *) - val make_switch : - Location.t -> act -> int array -> act array -> act + val make_switch : loc -> act -> int array -> act array -> act (* Build last minute sharing of action stuff *) val make_catch : act -> int * (act -> act) val make_exit : int -> act @@ -113,7 +114,7 @@ module Make : sig (* Standard entry point, sharing is tracked *) val zyva : - Location.t -> + Arg.loc -> (int * int) -> Arg.act -> (int * int * int) array -> diff --git a/lambda/translattribute.ml b/lambda/translattribute.ml index 1520a3b4..d2d48c84 100644 --- a/lambda/translattribute.ml +++ b/lambda/translattribute.ml @@ -122,6 +122,7 @@ let parse_inline_attribute attr = [ "never", Never_inline; "always", Always_inline; + "hint", Hint_inline; ] payload @@ -166,7 +167,7 @@ let get_local_attribute l = let check_local_inline loc attr = match attr.local, attr.inline with - | Always_local, (Always_inline | Unroll _) -> + | Always_local, (Always_inline | Hint_inline | Unroll _) -> Location.prerr_warning loc (Warnings.Duplicated_attribute "local/inline") | _ -> @@ -178,14 +179,14 @@ let add_inline_attribute expr loc attributes = | Lfunction({ attr = { stub = false } as attr } as funct), inline -> begin match attr.inline with | Default_inline -> () - | Always_inline | Never_inline | Unroll _ -> + | Always_inline | Hint_inline | Never_inline | Unroll _ -> Location.prerr_warning loc (Warnings.Duplicated_attribute "inline") end; let attr = { attr with inline } in check_local_inline loc attr; Lfunction { funct with attr = attr } - | expr, (Always_inline | Never_inline | Unroll _) -> + | expr, (Always_inline | Hint_inline | Never_inline | Unroll _) -> Location.prerr_warning loc (Warnings.Misplaced_attribute "inline"); expr @@ -249,7 +250,7 @@ let get_and_remove_inlined_attribute_on_module e = let inner_attr, me = get_and_remove me in let attr = match attr with - | Always_inline | Never_inline | Unroll _ -> attr + | Always_inline | Hint_inline | Never_inline | Unroll _ -> attr | Default_inline -> inner_attr in attr, Tmod_constraint (me, mt, mtc, mc) diff --git a/lambda/translclass.ml b/lambda/translclass.ml index 10b09066..1f39ea10 100644 --- a/lambda/translclass.ml +++ b/lambda/translclass.ml @@ -19,6 +19,7 @@ open Typedtree open Lambda open Translobj open Translcore +open Debuginfo.Scoped_location (* XXX Rajouter des evenements... | Add more events... *) @@ -38,7 +39,7 @@ let lfunction params body = Lfunction {kind = Curried; params; return = Pgenval; body; attr = default_function_attribute; - loc = Location.none} + loc = Loc_unknown} let lapply ap = match ap.ap_func with @@ -49,7 +50,7 @@ let lapply ap = let mkappl (func, args) = Lapply {ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=func; ap_args=args; ap_inlined=Default_inline; @@ -58,7 +59,7 @@ let mkappl (func, args) = let lsequence l1 l2 = if l2 = lambda_unit then l1 else Lsequence(l1, l2) -let lfield v i = Lprim(Pfield i, [Lvar v], Location.none) +let lfield v i = Lprim(Pfield i, [Lvar v], Loc_unknown) let transl_label l = share (Const_immstring l) @@ -67,9 +68,9 @@ let transl_meth_list lst = share (Const_block (0, List.map (fun lab -> Const_immstring lab) lst)) -let set_inst_var obj id expr = +let set_inst_var ~scopes obj id expr = Lprim(Psetfield_computed (Typeopt.maybe_pointer expr, Assignment), - [Lvar obj; Lvar id; transl_exp expr], Location.none) + [Lvar obj; Lvar id; transl_exp ~scopes expr], Loc_unknown) let transl_val tbl create name = mkappl (oo_prim (if create then "new_variable" else "get_variable"), @@ -121,7 +122,7 @@ let name_pattern default p = | Tpat_alias(_, id, _) -> id | _ -> Ident.create_local default -let rec build_object_init cl_table obj params inh_init obj_init cl = +let rec build_object_init ~scopes cl_table obj params inh_init obj_init cl = match cl.cl_desc with Tcl_ident (path, _, _) -> let obj_init = Ident.create_local "obj_init" in @@ -131,9 +132,10 @@ let rec build_object_init cl_table obj params inh_init obj_init cl = | Some envs -> [Lprim(Pfield (List.length inh_init + 1), [Lvar envs], - Location.none)] + Loc_unknown)] in - let path_lam = transl_class_path cl.cl_loc cl.cl_env path in + let loc = of_location ~scopes cl.cl_loc in + let path_lam = transl_class_path loc cl.cl_env path in ((envs, (path, path_lam, obj_init) :: inh_init), mkappl(Lvar obj_init, env @ [obj])) | Tcl_structure str -> @@ -144,12 +146,13 @@ let rec build_object_init cl_table obj params inh_init obj_init cl = match field.cf_desc with Tcf_inherit (_, cl, _, _, _) -> let (inh_init, obj_init') = - build_object_init cl_table (Lvar obj) [] inh_init + build_object_init ~scopes cl_table (Lvar obj) [] inh_init (fun _ -> lambda_unit) cl in (inh_init, lsequence obj_init' obj_init, true) | Tcf_val (_, _, id, Tcfk_concrete (_, exp), _) -> - (inh_init, lsequence (set_inst_var obj id exp) obj_init, + (inh_init, + lsequence (set_inst_var ~scopes obj id exp) obj_init, has_init) | Tcf_method _ | Tcf_val _ | Tcf_constraint _ | Tcf_attribute _-> (inh_init, obj_init, has_init) @@ -162,12 +165,13 @@ let rec build_object_init cl_table obj params inh_init obj_init cl = (inh_init, List.fold_right (fun (id, expr) rem -> - lsequence (Lifused (id, set_inst_var obj id expr)) rem) + lsequence (Lifused (id, set_inst_var ~scopes obj id expr)) rem) params obj_init, has_init)) | Tcl_fun (_, pat, vals, cl, partial) -> let (inh_init, obj_init) = - build_object_init cl_table obj (vals @ params) inh_init obj_init cl + build_object_init ~scopes cl_table obj (vals @ params) + inh_init obj_init cl in (inh_init, let build params rem = @@ -175,9 +179,9 @@ let rec build_object_init cl_table obj params inh_init obj_init cl = Lfunction {kind = Curried; params = (param, Pgenval)::params; return = Pgenval; attr = default_function_attribute; - loc = pat.pat_loc; - body = Matching.for_function - pat.pat_loc None (Lvar param) [pat, rem] partial} + loc = of_location ~scopes pat.pat_loc; + body = Matching.for_function ~scopes pat.pat_loc + None (Lvar param) [pat, rem] partial} in begin match obj_init with Lfunction {kind = Curried; params; body = rem} -> build params rem @@ -185,29 +189,32 @@ let rec build_object_init cl_table obj params inh_init obj_init cl = end) | Tcl_apply (cl, oexprs) -> let (inh_init, obj_init) = - build_object_init cl_table obj params inh_init obj_init cl + build_object_init ~scopes cl_table obj params inh_init obj_init cl in - (inh_init, transl_apply obj_init oexprs Location.none) + (inh_init, transl_apply ~scopes obj_init oexprs Loc_unknown) | Tcl_let (rec_flag, defs, vals, cl) -> let (inh_init, obj_init) = - build_object_init cl_table obj (vals @ params) inh_init obj_init cl + build_object_init ~scopes cl_table obj (vals @ params) + inh_init obj_init cl in - (inh_init, Translcore.transl_let rec_flag defs obj_init) + (inh_init, Translcore.transl_let ~scopes rec_flag defs obj_init) | Tcl_open (_, cl) | Tcl_constraint (cl, _, _, _, _) -> - build_object_init cl_table obj params inh_init obj_init cl + build_object_init ~scopes cl_table obj params inh_init obj_init cl -let rec build_object_init_0 cl_table params cl copy_env subst_env top ids = +let rec build_object_init_0 + ~scopes cl_table params cl copy_env subst_env top ids = match cl.cl_desc with Tcl_let (_rec_flag, _defs, vals, cl) -> - build_object_init_0 cl_table (vals@params) cl copy_env subst_env top ids + build_object_init_0 + ~scopes cl_table (vals@params) cl copy_env subst_env top ids | _ -> let self = Ident.create_local "self" in let env = Ident.create_local "env" in let obj = if ids = [] then lambda_unit else Lvar self in let envs = if top then None else Some env in let ((_,inh_init), obj_init) = - build_object_init cl_table obj params (envs,[]) copy_env cl in + build_object_init ~scopes cl_table obj params (envs,[]) copy_env cl in let obj_init = if ids = [] then obj_init else lfunction [self, Pgenval] obj_init in (inh_init, lfunction [env, Pgenval] (subst_env env inh_init obj_init)) @@ -245,7 +252,7 @@ let output_methods tbl methods lam = | _ -> lsequence (mkappl(oo_prim "set_methods", [Lvar tbl; Lprim(Pmakeblock(0,Immutable,None), - methods, Location.none)])) + methods, Loc_unknown)])) lam let rec ignore_cstrs cl = @@ -261,15 +268,15 @@ let rec index a = function let bind_id_as_val (id, _) = ("", id) -let rec build_class_init cla cstr super inh_init cl_init msubst top cl = +let rec build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl = match cl.cl_desc with | Tcl_ident _ -> begin match inh_init with | (_, path_lam, obj_init)::inh_init -> (inh_init, Llet (Strict, Pgenval, obj_init, - mkappl(Lprim(Pfield 1, [path_lam], Location.none), Lvar cla :: - if top then [Lprim(Pfield 3, [path_lam], Location.none)] + mkappl(Lprim(Pfield 1, [path_lam], Loc_unknown), Lvar cla :: + if top then [Lprim(Pfield 3, [path_lam], Loc_unknown)] else []), bind_super cla super cl_init)) | _ -> @@ -284,7 +291,7 @@ let rec build_class_init cla cstr super inh_init cl_init msubst top cl = Tcf_inherit (_, cl, _, vals, meths) -> let cl_init = output_methods cla methods cl_init in let inh_init, cl_init = - build_class_init cla false + build_class_init ~scopes cla false (vals, meths_super cla str.cstr_meths meths) inh_init cl_init msubst top cl in (inh_init, cl_init, [], values) @@ -298,7 +305,9 @@ let rec build_class_init cla cstr super inh_init cl_init msubst top cl = -> (inh_init, cl_init, methods, values) | Tcf_method (name, _, Tcfk_concrete (_, exp)) -> - let met_code = msubst true (transl_exp exp) in + let scopes = enter_method_definition ~scopes name.txt in + let met_code = + msubst true (transl_scoped_exp ~scopes exp) in let met_code = if !Clflags.native_code && List.length met_code = 1 then (* Force correct naming of method for profiles *) @@ -312,7 +321,8 @@ let rec build_class_init cla cstr super inh_init cl_init msubst top cl = | Tcf_initializer exp -> (inh_init, Lsequence(mkappl (oo_prim "add_initializer", - Lvar cla :: msubst false (transl_exp exp)), + Lvar cla :: msubst false + (transl_exp ~scopes exp)), cl_init), methods, values) | Tcf_attribute _ -> @@ -324,15 +334,15 @@ let rec build_class_init cla cstr super inh_init cl_init msubst top cl = (inh_init, bind_methods cla str.cstr_meths values cl_init) | Tcl_fun (_, _pat, vals, cl, _) -> let (inh_init, cl_init) = - build_class_init cla cstr super inh_init cl_init msubst top cl + build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl in let vals = List.map bind_id_as_val vals in (inh_init, transl_vals cla true StrictOpt vals cl_init) | Tcl_apply (cl, _exprs) -> - build_class_init cla cstr super inh_init cl_init msubst top cl + build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl | Tcl_let (_rec_flag, _defs, vals, cl) -> let (inh_init, cl_init) = - build_class_init cla cstr super inh_init cl_init msubst top cl + build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl in let vals = List.map bind_id_as_val vals in (inh_init, transl_vals cla true StrictOpt vals cl_init) @@ -373,7 +383,8 @@ let rec build_class_init cla cstr super inh_init cl_init msubst top cl = Llet(StrictOpt, Pgenval, obj_init, lfield inh 0, cl_init))) | _ -> let core cl_init = - build_class_init cla true super inh_init cl_init msubst top cl + build_class_init + ~scopes cla true super inh_init cl_init msubst top cl in if cstr then core cl_init else let (inh_init, cl_init) = @@ -384,14 +395,14 @@ let rec build_class_init cla cstr super inh_init cl_init msubst top cl = cl_init)) end | Tcl_open (_, cl) -> - build_class_init cla cstr super inh_init cl_init msubst top cl + build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl -let rec build_class_lets cl = +let rec build_class_lets ~scopes cl = match cl.cl_desc with Tcl_let (rec_flag, defs, _vals, cl') -> - let env, wrap = build_class_lets cl' in + let env, wrap = build_class_lets ~scopes cl' in (env, fun x -> - Translcore.transl_let rec_flag defs (wrap x)) + Translcore.transl_let ~scopes rec_flag defs (wrap x)) | _ -> (cl.cl_env, fun x -> x) @@ -411,39 +422,44 @@ let rec get_class_meths cl = | Writing classes should be cheap class c x y = d e f *) -let rec transl_class_rebind obj_init cl vf = +let rec transl_class_rebind ~scopes obj_init cl vf = match cl.cl_desc with Tcl_ident (path, _, _) -> if vf = Concrete then begin try if (Env.find_class path cl.cl_env).cty_new = None then raise Exit with Not_found -> raise Exit end; - let path_lam = transl_class_path cl.cl_loc cl.cl_env path in + let cl_loc = of_location ~scopes cl.cl_loc in + let path_lam = transl_class_path cl_loc cl.cl_env path in (path, path_lam, obj_init) | Tcl_fun (_, pat, _, cl, partial) -> - let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in + let path, path_lam, obj_init = + transl_class_rebind ~scopes obj_init cl vf in let build params rem = let param = name_pattern "param" pat in Lfunction {kind = Curried; params = (param, Pgenval)::params; return = Pgenval; attr = default_function_attribute; - loc = pat.pat_loc; - body = Matching.for_function - pat.pat_loc None (Lvar param) [pat, rem] partial} + loc = of_location ~scopes pat.pat_loc; + body = Matching.for_function ~scopes pat.pat_loc + None (Lvar param) [pat, rem] partial} in (path, path_lam, match obj_init with Lfunction {kind = Curried; params; body} -> build params body | rem -> build [] rem) | Tcl_apply (cl, oexprs) -> - let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in - (path, path_lam, transl_apply obj_init oexprs Location.none) + let path, path_lam, obj_init = + transl_class_rebind ~scopes obj_init cl vf in + (path, path_lam, transl_apply ~scopes obj_init oexprs Loc_unknown) | Tcl_let (rec_flag, defs, _vals, cl) -> - let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in - (path, path_lam, Translcore.transl_let rec_flag defs obj_init) + let path, path_lam, obj_init = + transl_class_rebind ~scopes obj_init cl vf in + (path, path_lam, Translcore.transl_let ~scopes rec_flag defs obj_init) | Tcl_structure _ -> raise Exit | Tcl_constraint (cl', _, _, _, _) -> - let path, path_lam, obj_init = transl_class_rebind obj_init cl' vf in + let path, path_lam, obj_init = + transl_class_rebind ~scopes obj_init cl' vf in let rec check_constraint = function Cty_constr(path', _, _) when Path.same path path' -> () | Cty_arrow (_, _, cty) -> check_constraint cty @@ -452,32 +468,34 @@ let rec transl_class_rebind obj_init cl vf = check_constraint cl.cl_type; (path, path_lam, obj_init) | Tcl_open (_, cl) -> - transl_class_rebind obj_init cl vf + transl_class_rebind ~scopes obj_init cl vf -let rec transl_class_rebind_0 (self:Ident.t) obj_init cl vf = +let rec transl_class_rebind_0 ~scopes (self:Ident.t) obj_init cl vf = match cl.cl_desc with Tcl_let (rec_flag, defs, _vals, cl) -> let path, path_lam, obj_init = - transl_class_rebind_0 self obj_init cl vf + transl_class_rebind_0 ~scopes self obj_init cl vf in - (path, path_lam, Translcore.transl_let rec_flag defs obj_init) + (path, path_lam, Translcore.transl_let ~scopes rec_flag defs obj_init) | _ -> - let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in + let path, path_lam, obj_init = + transl_class_rebind ~scopes obj_init cl vf in (path, path_lam, lfunction [self, Pgenval] obj_init) -let transl_class_rebind cl vf = +let transl_class_rebind ~scopes cl vf = try let obj_init = Ident.create_local "obj_init" and self = Ident.create_local "self" in let obj_init0 = lapply {ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=Lvar obj_init; ap_args=[Lvar self]; ap_inlined=Default_inline; ap_specialised=Default_specialise} in - let _, path_lam, obj_init' = transl_class_rebind_0 self obj_init0 cl vf in + let _, path_lam, obj_init' = + transl_class_rebind_0 ~scopes self obj_init0 cl vf in let id = (obj_init' = lfunction [self, Pgenval] obj_init0) in if id then path_lam else @@ -500,7 +518,7 @@ let transl_class_rebind cl vf = [mkappl(Lvar env_init, [Lvar envs])])))); lfield cla 2; lfield cla 3], - Location.none))) + Loc_unknown))) with Exit -> lambda_unit @@ -657,16 +675,17 @@ let free_methods l = | Levent _ | Lifused _ -> () in free l; !fv -let transl_class ids cl_id pub_meths cl vflag = +let transl_class ~scopes ids cl_id pub_meths cl vflag = (* First check if it is not only a rebind *) - let rebind = transl_class_rebind cl vflag in + let rebind = transl_class_rebind ~scopes cl vflag in if rebind <> lambda_unit then rebind else (* Prepare for heavy environment handling *) + let scopes = enter_class_definition ~scopes cl_id in let tables = Ident.create_local (Ident.name cl_id ^ "_tables") in let (top_env, req) = oo_add_class tables in let top = not req in - let cl_env, llets = build_class_lets cl in + let cl_env, llets = build_class_lets ~scopes cl in let new_ids = if top then [] else Env.diff top_env cl_env in let env2 = Ident.create_local "env" in let meth_ids = get_class_meths cl in @@ -711,7 +730,7 @@ let transl_class ids cl_id pub_meths cl vflag = Llet(Alias, Pgenval, env, Lprim(Pfield_computed, [Lvar self; Lvar env2], - Location.none), + Loc_unknown), body'))] end | _ -> assert false @@ -722,7 +741,7 @@ let transl_class ids cl_id pub_meths cl vflag = if top then lambda_unit else Lifused(env2, Lprim(Psetfield_computed (Pointer, Assignment), [Lvar self; Lvar env2; Lvar env1'], - Location.none)) + Loc_unknown)) and subst_env envs l lam = if top then lam else (* must be called only once! *) @@ -736,10 +755,10 @@ let transl_class ids cl_id pub_meths cl vflag = (* Now we start compiling the class *) let cla = Ident.create_local "class" in let (inh_init, obj_init) = - build_object_init_0 cla [] cl copy_env subst_env top ids in + build_object_init_0 ~scopes cla [] cl copy_env subst_env top ids in let inh_init' = List.rev inh_init in let (inh_init', cl_init) = - build_class_init cla true ([],[]) inh_init' obj_init msubst top cl + build_class_init ~scopes cla true ([],[]) inh_init' obj_init msubst top cl in assert (inh_init' = []); let table = Ident.create_local "table" @@ -772,7 +791,7 @@ let transl_class ids cl_id pub_meths cl vflag = and lclass lam = let cl_init = llets (Lfunction{kind = Curried; attr = default_function_attribute; - loc = Location.none; + loc = Loc_unknown; return = Pgenval; params = [cla, Pgenval]; body = cl_init}) in Llet(Strict, Pgenval, class_init, cl_init, lam (free_variables cl_init)) @@ -789,16 +808,16 @@ let transl_class ids cl_id pub_meths cl vflag = Lprim(Pmakeblock(0, Immutable, None), [mkappl (Lvar env_init, [lambda_unit]); Lvar class_init; Lvar env_init; lambda_unit], - Location.none)))) + Loc_unknown)))) and lbody_virt lenvs = Lprim(Pmakeblock(0, Immutable, None), [lambda_unit; Lfunction{kind = Curried; attr = default_function_attribute; - loc = Location.none; + loc = Loc_unknown; return = Pgenval; params = [cla, Pgenval]; body = cl_init}; lambda_unit; lenvs], - Location.none) + Loc_unknown) in (* Still easy: a class defined at toplevel *) if top && concrete then lclass lbody else @@ -816,21 +835,21 @@ let transl_class ids cl_id pub_meths cl vflag = if !new_ids_meths = [] then lambda_unit else Lprim(Pmakeblock(0, Immutable, None), List.map (fun id -> Lvar id) !new_ids_meths, - Location.none) in + Loc_unknown) in if !new_ids_init = [] then menv else Lprim(Pmakeblock(0, Immutable, None), menv :: List.map (fun id -> Lvar id) !new_ids_init, - Location.none) + Loc_unknown) and linh_envs = List.map - (fun (_, path_lam, _) -> Lprim(Pfield 3, [path_lam], Location.none)) + (fun (_, path_lam, _) -> Lprim(Pfield 3, [path_lam], Loc_unknown)) (List.rev inh_init) in let make_envs lam = Llet(StrictOpt, Pgenval, envs, (if linh_envs = [] then lenv else Lprim(Pmakeblock(0, Immutable, None), - lenv :: linh_envs, Location.none)), + lenv :: linh_envs, Loc_unknown)), lam) and def_ids cla lam = Llet(StrictOpt, Pgenval, env2, @@ -843,7 +862,7 @@ let transl_class ids cl_id pub_meths cl vflag = in let inh_keys = List.map - (fun (_, path_lam, _) -> Lprim(Pfield 1, [path_lam], Location.none)) + (fun (_, path_lam, _) -> Lprim(Pfield 1, [path_lam], Loc_unknown)) inh_paths in let lclass lam = @@ -851,18 +870,18 @@ let transl_class ids cl_id pub_meths cl vflag = Lfunction{kind = Curried; params = [cla, Pgenval]; return = Pgenval; attr = default_function_attribute; - loc = Location.none; + loc = Loc_unknown; body = def_ids cla cl_init}, lam) and lcache lam = if inh_keys = [] then Llet(Alias, Pgenval, cached, Lvar tables, lam) else Llet(Strict, Pgenval, cached, mkappl (oo_prim "lookup_tables", [Lvar tables; Lprim(Pmakeblock(0, Immutable, None), - inh_keys, Location.none)]), + inh_keys, Loc_unknown)]), lam) and lset cached i lam = Lprim(Psetfield(i, Pointer, Assignment), - [Lvar cached; lam], Location.none) + [Lvar cached; lam], Loc_unknown) in let ldirect () = ltable cla @@ -875,7 +894,7 @@ let transl_class ids cl_id pub_meths cl vflag = { kind = Curried; attr = default_function_attribute; - loc = Location.none; + loc = Loc_unknown; return = Pgenval; params = [cla, Pgenval]; body = def_ids cla cl_init; @@ -908,7 +927,7 @@ let transl_class ids cl_id pub_meths cl vflag = lfield cached 0; lenvs] else [lambda_unit; lfield cached 0; lambda_unit; lenvs]), - Location.none + Loc_unknown ))))) (* Wrapper for class compilation *) @@ -921,11 +940,12 @@ let transl_class ids cl_id pub_meths cl vflag = let vflag = vf in *) -let transl_class ids id pub_meths cl vf = - oo_wrap cl.cl_env false (transl_class ids id pub_meths cl) vf +let transl_class ~scopes ids id pub_meths cl vf = + oo_wrap cl.cl_env false (transl_class ~scopes ids id pub_meths cl) vf let () = - transl_object := (fun id meths cl -> transl_class [] id meths cl Concrete) + transl_object := (fun ~scopes id meths cl -> + transl_class ~scopes [] id meths cl Concrete) (* Error report *) diff --git a/lambda/translclass.mli b/lambda/translclass.mli index 4c4bed0f..f2c5c1d5 100644 --- a/lambda/translclass.mli +++ b/lambda/translclass.mli @@ -15,9 +15,10 @@ open Typedtree open Lambda +open Debuginfo.Scoped_location val transl_class : - Ident.t list -> Ident.t -> + scopes:scopes -> Ident.t list -> Ident.t -> string list -> class_expr -> Asttypes.virtual_flag -> lambda;; type error = Tags of string * string diff --git a/lambda/translcore.ml b/lambda/translcore.ml index fc88d055..5d479f3f 100644 --- a/lambda/translcore.ml +++ b/lambda/translcore.ml @@ -23,6 +23,7 @@ open Types open Typedtree open Typeopt open Lambda +open Debuginfo.Scoped_location type error = Free_super_var @@ -34,19 +35,20 @@ let use_dup_for_constant_arrays_bigger_than = 4 (* Forward declaration -- to be filled in by Translmod.transl_module *) let transl_module = - ref((fun _cc _rootpath _modl -> assert false) : - module_coercion -> Path.t option -> module_expr -> lambda) + ref((fun ~scopes:_ _cc _rootpath _modl -> assert false) : + scopes:scopes -> module_coercion -> Path.t option -> + module_expr -> lambda) let transl_object = - ref (fun _id _s _cl -> assert false : - Ident.t -> string list -> class_expr -> lambda) + ref (fun ~scopes:_ _id _s _cl -> assert false : + scopes:scopes -> Ident.t -> string list -> class_expr -> lambda) (* Compile an exception/extension definition *) let prim_fresh_oo_id = Pccall (Primitive.simple ~name:"caml_fresh_oo_id" ~arity:1 ~alloc:false) -let transl_extension_constructor env path ext = +let transl_extension_constructor ~scopes env path ext = let path = Printtyp.wrap_printing_env env ~error:true (fun () -> Option.map (Printtyp.rewrite_double_underscore_paths env) path) @@ -57,11 +59,11 @@ let transl_extension_constructor env path ext = | Some p, None -> Path.name p | Some p, Some pack -> Printf.sprintf "%s.%s" pack (Path.name p) in - let loc = ext.ext_loc in + let loc = of_location ~scopes ext.ext_loc in match ext.ext_kind with Text_decl _ -> Lprim (Pmakeblock (Obj.object_tag, Immutable, None), - [Lconst (Const_base (Const_string (name, None))); + [Lconst (Const_base (Const_string (name, ext.ext_loc, None))); Lprim (prim_fresh_oo_id, [Lconst (Const_base (Const_int 0))], loc)], loc) | Text_rebind(path, _lid) -> @@ -126,11 +128,16 @@ let rec push_defaults loc bindings cases partial = let param = Typecore.name_cases "param" cases in let desc = {val_type = pat.pat_type; val_kind = Val_reg; - val_attributes = []; Types.val_loc = Location.none; } + val_attributes = []; Types.val_loc = Location.none; + val_uid = Types.Uid.internal_not_actually_unique; } in let env = Env.add_value param desc exp.exp_env in let name = Ident.name param in let exp = + let cases = + let pure_case ({c_lhs; _} as case) = + {case with c_lhs = as_computation_pattern c_lhs} in + List.map pure_case cases in { exp with exp_loc = loc; exp_env = env; exp_desc = Texp_match ({exp with exp_type = pat.pat_type; exp_env = env; exp_desc = @@ -147,16 +154,18 @@ let rec push_defaults loc bindings cases partial = (* Insertion of debugging events *) -let event_before = Translprim.event_before +let event_before ~scopes exp lam = + Translprim.event_before (of_location ~scopes exp.exp_loc) exp lam -let event_after = Translprim.event_after +let event_after ~scopes exp lam = + Translprim.event_after (of_location ~scopes exp.exp_loc) exp lam -let event_function exp lam = +let event_function ~scopes exp lam = if !Clflags.debug && not !Clflags.native_code then let repr = Some (ref 0) in let (info, body) = lam repr in (info, - Levent(body, {lev_loc = exp.exp_loc; + Levent(body, {lev_loc = of_location ~scopes exp.exp_loc; lev_kind = Lev_function; lev_repr = repr; lev_env = exp.exp_env})) @@ -165,21 +174,23 @@ let event_function exp lam = (* Assertions *) -let assert_failed exp = +let assert_failed ~scopes exp = let slot = - transl_extension_path Location.none + transl_extension_path Loc_unknown Env.initial_safe_string Predef.path_assert_failure in + let loc = exp.exp_loc in let (fname, line, char) = - Location.get_pos_info exp.exp_loc.Location.loc_start + Location.get_pos_info loc.Location.loc_start in - Lprim(Praise Raise_regular, [event_after exp + let loc = of_location ~scopes exp.exp_loc in + Lprim(Praise Raise_regular, [event_after ~scopes exp (Lprim(Pmakeblock(0, Immutable, None), [slot; Lconst(Const_block(0, - [Const_base(Const_string (fname, None)); + [Const_base(Const_string (fname, exp.exp_loc, None)); Const_base(Const_int line); - Const_base(Const_int char)]))], exp.exp_loc))], exp.exp_loc) + Const_base(Const_int char)]))], loc))], loc) ;; let rec cut n l = @@ -202,12 +213,12 @@ let transl_ident loc env ty path desc = | Val_prim p -> Translprim.transl_primitive loc p env ty (Some path) | Val_anc _ -> - raise(Error(loc, Free_super_var)) + raise(Error(to_location loc, Free_super_var)) | Val_reg | Val_self _ -> transl_value_path loc env path | _ -> fatal_error "Translcore.transl_exp: bad Texp_ident" -let rec transl_exp e = +let rec transl_exp ~scopes e = List.iter (Translattribute.check_attribute e) e.exp_attributes; let eval_once = (* Whether classes for immediate objects must be cached *) @@ -215,30 +226,22 @@ let rec transl_exp e = Texp_function _ | Texp_for _ | Texp_while _ -> false | _ -> true in - if eval_once then transl_exp0 e else - Translobj.oo_wrap e.exp_env true transl_exp0 e + if eval_once then transl_exp0 ~scopes e else + Translobj.oo_wrap e.exp_env true (transl_exp0 ~scopes) e -and transl_exp0 e = +and transl_exp0 ~scopes e = match e.exp_desc with | Texp_ident(path, _, desc) -> - transl_ident e.exp_loc e.exp_env e.exp_type path desc + transl_ident (of_location ~scopes e.exp_loc) + e.exp_env e.exp_type path desc | Texp_constant cst -> Lconst(Const_base cst) | Texp_let(rec_flag, pat_expr_list, body) -> - transl_let rec_flag pat_expr_list (event_before body (transl_exp body)) + transl_let ~scopes rec_flag pat_expr_list + (event_before ~scopes body (transl_exp ~scopes body)) | Texp_function { arg_label = _; param; cases; partial; } -> - let ((kind, params, return), body) = - event_function e - (function repr -> - let pl = push_defaults e.exp_loc [] cases partial in - let return_kind = function_return_value_kind e.exp_env e.exp_type in - transl_function e.exp_loc return_kind !Clflags.native_code repr - partial param pl) - in - let attr = default_function_attribute in - let loc = e.exp_loc in - let lam = Lfunction{kind; params; return; body; attr; loc} in - Translattribute.add_function_attributes lam loc e.exp_attributes + let scopes = enter_anonymous_function ~scopes in + transl_function ~scopes e param cases partial | Texp_apply({ exp_desc = Texp_ident(path, _, {val_kind = Val_prim p}); exp_type = prim_type } as funct, oargs) when List.length oargs >= p.prim_arity @@ -247,11 +250,11 @@ and transl_exp0 e = let arg_exps = List.map (function _, Some x -> x | _ -> assert false) argl in - let args = transl_list arg_exps in + let args = transl_list ~scopes arg_exps in let prim_exp = if extra_args = [] then Some e else None in let lam = Translprim.transl_primitive_application - e.exp_loc p e.exp_env prim_type path + (of_location ~scopes e.exp_loc) p e.exp_env prim_type path prim_exp args arg_exps in if extra_args = [] then lam @@ -266,9 +269,9 @@ and transl_exp0 e = Translattribute.get_and_remove_specialised_attribute funct in let e = { e with exp_desc = Texp_apply(funct, oargs) } in - event_after e - (transl_apply ~should_be_tailcall ~inlined ~specialised - lam extra_args e.exp_loc) + event_after ~scopes e + (transl_apply ~scopes ~should_be_tailcall ~inlined ~specialised + lam extra_args (of_location ~scopes e.exp_loc)) end | Texp_apply(funct, oargs) -> let should_be_tailcall, funct = @@ -281,24 +284,26 @@ and transl_exp0 e = Translattribute.get_and_remove_specialised_attribute funct in let e = { e with exp_desc = Texp_apply(funct, oargs) } in - event_after e - (transl_apply ~should_be_tailcall ~inlined ~specialised - (transl_exp funct) oargs e.exp_loc) + event_after ~scopes e + (transl_apply ~scopes ~should_be_tailcall ~inlined ~specialised + (transl_exp ~scopes funct) oargs (of_location ~scopes e.exp_loc)) | Texp_match(arg, pat_expr_list, partial) -> - transl_match e arg pat_expr_list partial + transl_match ~scopes e arg pat_expr_list partial | Texp_try(body, pat_expr_list) -> let id = Typecore.name_cases "exn" pat_expr_list in - Ltrywith(transl_exp body, id, - Matching.for_trywith (Lvar id) (transl_cases_try pat_expr_list)) + Ltrywith(transl_exp ~scopes body, id, + Matching.for_trywith ~scopes (Lvar id) + (transl_cases_try ~scopes pat_expr_list)) | Texp_tuple el -> - let ll, shape = transl_list_with_shape el in + let ll, shape = transl_list_with_shape ~scopes el in begin try Lconst(Const_block(0, List.map extract_constant ll)) with Not_constant -> - Lprim(Pmakeblock(0, Immutable, Some shape), ll, e.exp_loc) + Lprim(Pmakeblock(0, Immutable, Some shape), ll, + (of_location ~scopes e.exp_loc)) end | Texp_construct(_, cstr, args) -> - let ll, shape = transl_list_with_shape args in + let ll, shape = transl_list_with_shape ~scopes args in if cstr.cstr_inlined <> None then begin match ll with | [x] -> x | _ -> assert false @@ -311,42 +316,49 @@ and transl_exp0 e = begin try Lconst(Const_block(n, List.map extract_constant ll)) with Not_constant -> - Lprim(Pmakeblock(n, Immutable, Some shape), ll, e.exp_loc) + Lprim(Pmakeblock(n, Immutable, Some shape), ll, + of_location ~scopes e.exp_loc) end | Cstr_extension(path, is_const) -> - let lam = transl_extension_path e.exp_loc e.exp_env path in + let lam = transl_extension_path + (of_location ~scopes e.exp_loc) e.exp_env path in if is_const then lam else Lprim(Pmakeblock(0, Immutable, Some (Pgenval :: shape)), - lam :: ll, e.exp_loc) + lam :: ll, of_location ~scopes e.exp_loc) end | Texp_extension_constructor (_, path) -> - transl_extension_path e.exp_loc e.exp_env path + transl_extension_path (of_location ~scopes e.exp_loc) e.exp_env path | Texp_variant(l, arg) -> let tag = Btype.hash_variant l in begin match arg with None -> Lconst(Const_pointer tag) | Some arg -> - let lam = transl_exp arg in + let lam = transl_exp ~scopes arg in try Lconst(Const_block(0, [Const_base(Const_int tag); extract_constant lam])) with Not_constant -> Lprim(Pmakeblock(0, Immutable, None), - [Lconst(Const_base(Const_int tag)); lam], e.exp_loc) + [Lconst(Const_base(Const_int tag)); lam], + of_location ~scopes e.exp_loc) end | Texp_record {fields; representation; extended_expression} -> - transl_record e.exp_loc e.exp_env fields representation - extended_expression + transl_record ~scopes e.exp_loc e.exp_env + fields representation extended_expression | Texp_field(arg, _, lbl) -> - let targ = transl_exp arg in + let targ = transl_exp ~scopes arg in begin match lbl.lbl_repres with Record_regular | Record_inlined _ -> - Lprim (Pfield lbl.lbl_pos, [targ], e.exp_loc) + Lprim (Pfield lbl.lbl_pos, [targ], + of_location ~scopes e.exp_loc) | Record_unboxed _ -> targ - | Record_float -> Lprim (Pfloatfield lbl.lbl_pos, [targ], e.exp_loc) + | Record_float -> + Lprim (Pfloatfield lbl.lbl_pos, [targ], + of_location ~scopes e.exp_loc) | Record_extension _ -> - Lprim (Pfield (lbl.lbl_pos + 1), [targ], e.exp_loc) + Lprim (Pfield (lbl.lbl_pos + 1), [targ], + of_location ~scopes e.exp_loc) end | Texp_setfield(arg, _, lbl, newval) -> let access = @@ -359,10 +371,11 @@ and transl_exp0 e = | Record_extension _ -> Psetfield (lbl.lbl_pos + 1, maybe_pointer newval, Assignment) in - Lprim(access, [transl_exp arg; transl_exp newval], e.exp_loc) + Lprim(access, [transl_exp ~scopes arg; transl_exp ~scopes newval], + of_location ~scopes e.exp_loc) | Texp_array expr_list -> let kind = array_kind e in - let ll = transl_list expr_list in + let ll = transl_list ~scopes expr_list in begin try (* For native code the decision as to which compilation strategy to use is made later. This enables the Flambda passes to lift certain @@ -387,9 +400,11 @@ and transl_exp0 e = When not [Pfloatarray], the exception propagates to the handler below. *) let imm_array = - Lprim (Pmakearray (kind, Immutable), ll, e.exp_loc) + Lprim (Pmakearray (kind, Immutable), ll, + of_location ~scopes e.exp_loc) in - Lprim (Pduparray (kind, Mutable), [imm_array], e.exp_loc) + Lprim (Pduparray (kind, Mutable), [imm_array], + of_location ~scopes e.exp_loc) | cl -> let imm_array = match kind with @@ -400,39 +415,45 @@ and transl_exp0 e = | Pgenarray -> raise Not_constant (* can this really happen? *) in - Lprim (Pduparray (kind, Mutable), [imm_array], e.exp_loc) + Lprim (Pduparray (kind, Mutable), [imm_array], + of_location ~scopes e.exp_loc) end with Not_constant -> - Lprim(Pmakearray (kind, Mutable), ll, e.exp_loc) + Lprim(Pmakearray (kind, Mutable), ll, + of_location ~scopes e.exp_loc) end | Texp_ifthenelse(cond, ifso, Some ifnot) -> - Lifthenelse(transl_exp cond, - event_before ifso (transl_exp ifso), - event_before ifnot (transl_exp ifnot)) + Lifthenelse(transl_exp ~scopes cond, + event_before ~scopes ifso (transl_exp ~scopes ifso), + event_before ~scopes ifnot (transl_exp ~scopes ifnot)) | Texp_ifthenelse(cond, ifso, None) -> - Lifthenelse(transl_exp cond, - event_before ifso (transl_exp ifso), + Lifthenelse(transl_exp ~scopes cond, + event_before ~scopes ifso (transl_exp ~scopes ifso), lambda_unit) | Texp_sequence(expr1, expr2) -> - Lsequence(transl_exp expr1, event_before expr2 (transl_exp expr2)) + Lsequence(transl_exp ~scopes expr1, + event_before ~scopes expr2 (transl_exp ~scopes expr2)) | Texp_while(cond, body) -> - Lwhile(transl_exp cond, event_before body (transl_exp body)) + Lwhile(transl_exp ~scopes cond, + event_before ~scopes body (transl_exp ~scopes body)) | Texp_for(param, _, low, high, dir, body) -> - Lfor(param, transl_exp low, transl_exp high, dir, - event_before body (transl_exp body)) - | Texp_send(_, _, Some exp) -> transl_exp exp + Lfor(param, transl_exp ~scopes low, transl_exp ~scopes high, dir, + event_before ~scopes body (transl_exp ~scopes body)) + | Texp_send(_, _, Some exp) -> transl_exp ~scopes exp | Texp_send(expr, met, None) -> - let obj = transl_exp expr in + let obj = transl_exp ~scopes expr in + let loc = of_location ~scopes e.exp_loc in let lam = match met with - Tmeth_val id -> Lsend (Self, Lvar id, obj, [], e.exp_loc) + Tmeth_val id -> Lsend (Self, Lvar id, obj, [], loc) | Tmeth_name nm -> let (tag, cache) = Translobj.meth obj nm in let kind = if cache = [] then Public else Cached in - Lsend (kind, tag, obj, cache, e.exp_loc) + Lsend (kind, tag, obj, cache, loc) in - event_after e lam + event_after ~scopes e lam | Texp_new (cl, {Location.loc=loc}, _) -> + let loc = of_location ~scopes loc in Lapply{ap_should_be_tailcall=false; ap_loc=loc; ap_func= @@ -441,57 +462,63 @@ and transl_exp0 e = ap_inlined=Default_inline; ap_specialised=Default_specialise} | Texp_instvar(path_self, path, _) -> - let self = transl_value_path e.exp_loc e.exp_env path_self in - let var = transl_value_path e.exp_loc e.exp_env path in - Lprim(Pfield_computed, [self; var], e.exp_loc) + let loc = of_location ~scopes e.exp_loc in + let self = transl_value_path loc e.exp_env path_self in + let var = transl_value_path loc e.exp_env path in + Lprim(Pfield_computed, [self; var], loc) | Texp_setinstvar(path_self, path, _, expr) -> - let self = transl_value_path e.exp_loc e.exp_env path_self in - let var = transl_value_path e.exp_loc e.exp_env path in - transl_setinstvar e.exp_loc self var expr + let loc = of_location ~scopes e.exp_loc in + let self = transl_value_path loc e.exp_env path_self in + let var = transl_value_path loc e.exp_env path in + transl_setinstvar ~scopes loc self var expr | Texp_override(path_self, modifs) -> - let self = transl_value_path e.exp_loc e.exp_env path_self in + let loc = of_location ~scopes e.exp_loc in + let self = transl_value_path loc e.exp_env path_self in let cpy = Ident.create_local "copy" in Llet(Strict, Pgenval, cpy, Lapply{ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=Translobj.oo_prim "copy"; ap_args=[self]; ap_inlined=Default_inline; ap_specialised=Default_specialise}, List.fold_right (fun (path, _, expr) rem -> - let var = transl_value_path e.exp_loc e.exp_env path in - Lsequence(transl_setinstvar Location.none + let var = transl_value_path loc e.exp_env path in + Lsequence(transl_setinstvar ~scopes Loc_unknown (Lvar cpy) var expr, rem)) modifs (Lvar cpy)) | Texp_letmodule(None, loc, Mp_present, modl, body) -> - let lam = !transl_module Tcoerce_none None modl in - Lsequence(Lprim(Pignore, [lam], loc.loc), transl_exp body) + let lam = !transl_module ~scopes Tcoerce_none None modl in + Lsequence(Lprim(Pignore, [lam], of_location ~scopes loc.loc), + transl_exp ~scopes body) | Texp_letmodule(Some id, loc, Mp_present, modl, body) -> let defining_expr = - Levent (!transl_module Tcoerce_none None modl, { - lev_loc = loc.loc; + let mod_scopes = enter_module_definition ~scopes id in + Levent (!transl_module ~scopes:mod_scopes Tcoerce_none None modl, { + lev_loc = of_location ~scopes loc.loc; lev_kind = Lev_module_definition id; lev_repr = None; lev_env = Env.empty; }) in - Llet(Strict, Pgenval, id, defining_expr, transl_exp body) + Llet(Strict, Pgenval, id, defining_expr, transl_exp ~scopes body) | Texp_letmodule(_, _, Mp_absent, _, body) -> - transl_exp body + transl_exp ~scopes body | Texp_letexception(cd, body) -> Llet(Strict, Pgenval, - cd.ext_id, transl_extension_constructor e.exp_env None cd, - transl_exp body) + cd.ext_id, transl_extension_constructor ~scopes e.exp_env None cd, + transl_exp ~scopes body) | Texp_pack modl -> - !transl_module Tcoerce_none None modl + !transl_module ~scopes Tcoerce_none None modl | Texp_assert {exp_desc=Texp_construct(_, {cstr_name="false"}, _)} -> - assert_failed e + assert_failed ~scopes e | Texp_assert (cond) -> if !Clflags.noassert then lambda_unit - else Lifthenelse (transl_exp cond, lambda_unit, assert_failed e) + else Lifthenelse (transl_exp ~scopes cond, lambda_unit, + assert_failed ~scopes e) | Texp_lazy e -> (* when e needs no computation (constants, identifiers, ...), we optimize the translation just as Lazy.lazy_from_val would @@ -500,13 +527,13 @@ and transl_exp0 e = | `Constant_or_function -> (* A constant expr (of type <> float if [Config.flat_float_array] is true) gets compiled as itself. *) - transl_exp e + transl_exp ~scopes e | `Float_that_cannot_be_shortcut -> (* We don't need to wrap with Popaque: this forward block will never be shortcutted since it points to a float and Config.flat_float_array is true. *) Lprim(Pmakeblock(Obj.forward_tag, Immutable, None), - [transl_exp e], e.exp_loc) + [transl_exp ~scopes e], of_location ~scopes e.exp_loc) | `Identifier `Forward_value -> (* CR-someday mshinwell: Consider adding a new primitive that expresses the construction of forward_tag blocks. @@ -516,24 +543,26 @@ and transl_exp0 e = value may subsequently turn into an immediate... *) Lprim (Popaque, [Lprim(Pmakeblock(Obj.forward_tag, Immutable, None), - [transl_exp e], e.exp_loc)], - e.exp_loc) + [transl_exp ~scopes e], + of_location ~scopes e.exp_loc)], + of_location ~scopes e.exp_loc) | `Identifier `Other -> - transl_exp e + transl_exp ~scopes e | `Other -> (* other cases compile to a lazy block holding a function *) let fn = Lfunction {kind = Curried; params= [Ident.create_local "param", Pgenval]; return = Pgenval; attr = default_function_attribute; - loc = e.exp_loc; - body = transl_exp e} in - Lprim(Pmakeblock(Config.lazy_tag, Mutable, None), [fn], e.exp_loc) + loc = of_location ~scopes e.exp_loc; + body = transl_exp ~scopes e} in + Lprim(Pmakeblock(Config.lazy_tag, Mutable, None), [fn], + of_location ~scopes e.exp_loc) end | Texp_object (cs, meths) -> let cty = cs.cstr_type in - let cl = Ident.create_local "class" in - !transl_object cl meths + let cl = Ident.create_local "object" in + !transl_object ~scopes cl meths { cl_desc = Tcl_structure cs; cl_loc = e.exp_loc; cl_type = Cty_signature cty; @@ -541,8 +570,8 @@ and transl_exp0 e = cl_attributes = []; } | Texp_letop{let_; ands; param; body; partial} -> - event_after e - (transl_letop e.exp_loc e.exp_env let_ ands param body partial) + event_after ~scopes e + (transl_letop ~scopes e.exp_loc e.exp_env let_ ands param body partial) | Texp_unreachable -> raise (Error (e.exp_loc, Unreachable_reached)) | Texp_open (od, e) -> @@ -552,18 +581,20 @@ and transl_exp0 e = But since [scan_used_globals] runs before Simplif, we need to do it. *) begin match od.open_bound_items with - | [] when pure = Alias -> transl_exp e + | [] when pure = Alias -> transl_exp ~scopes e | _ -> let oid = Ident.create_local "open" in let body, _ = List.fold_left (fun (body, pos) id -> Llet(Alias, Pgenval, id, - Lprim(Pfield pos, [Lvar oid], od.open_loc), body), + Lprim(Pfield pos, [Lvar oid], + of_location ~scopes od.open_loc), body), pos + 1 - ) (transl_exp e, 0) (bound_value_identifiers od.open_bound_items) + ) (transl_exp ~scopes e, 0) + (bound_value_identifiers od.open_bound_items) in Llet(pure, Pgenval, oid, - !transl_module Tcoerce_none None od.open_expr, body) + !transl_module ~scopes Tcoerce_none None od.open_expr, body) end and pure_module m = @@ -572,57 +603,58 @@ and pure_module m = | Tmod_constraint (m,_,_,_) -> pure_module m | _ -> Strict -and transl_list expr_list = - List.map transl_exp expr_list +and transl_list ~scopes expr_list = + List.map (transl_exp ~scopes) expr_list -and transl_list_with_shape expr_list = +and transl_list_with_shape ~scopes expr_list = let transl_with_shape e = let shape = Typeopt.value_kind e.exp_env e.exp_type in - transl_exp e, shape + transl_exp ~scopes e, shape in List.split (List.map transl_with_shape expr_list) -and transl_guard guard rhs = - let expr = event_before rhs (transl_exp rhs) in +and transl_guard ~scopes guard rhs = + let expr = event_before ~scopes rhs (transl_exp ~scopes rhs) in match guard with | None -> expr | Some cond -> - event_before cond (Lifthenelse(transl_exp cond, expr, staticfail)) + event_before ~scopes cond + (Lifthenelse(transl_exp ~scopes cond, expr, staticfail)) -and transl_case {c_lhs; c_guard; c_rhs} = - c_lhs, transl_guard c_guard c_rhs +and transl_case ~scopes {c_lhs; c_guard; c_rhs} = + c_lhs, transl_guard ~scopes c_guard c_rhs -and transl_cases cases = +and transl_cases ~scopes cases = let cases = List.filter (fun c -> c.c_rhs.exp_desc <> Texp_unreachable) cases in - List.map transl_case cases + List.map (transl_case ~scopes) cases -and transl_case_try {c_lhs; c_guard; c_rhs} = +and transl_case_try ~scopes {c_lhs; c_guard; c_rhs} = iter_exn_names Translprim.add_exception_ident c_lhs; Misc.try_finally - (fun () -> c_lhs, transl_guard c_guard c_rhs) + (fun () -> c_lhs, transl_guard ~scopes c_guard c_rhs) ~always:(fun () -> iter_exn_names Translprim.remove_exception_ident c_lhs) -and transl_cases_try cases = +and transl_cases_try ~scopes cases = let cases = List.filter (fun c -> c.c_rhs.exp_desc <> Texp_unreachable) cases in - List.map transl_case_try cases + List.map (transl_case_try ~scopes) cases -and transl_tupled_cases patl_expr_list = +and transl_tupled_cases ~scopes patl_expr_list = let patl_expr_list = List.filter (fun (_,_,e) -> e.exp_desc <> Texp_unreachable) patl_expr_list in - List.map (fun (patl, guard, expr) -> (patl, transl_guard guard expr)) + List.map (fun (patl, guard, expr) -> (patl, transl_guard ~scopes guard expr)) patl_expr_list -and transl_apply ?(should_be_tailcall=false) ?(inlined = Default_inline) +and transl_apply ~scopes ?(should_be_tailcall=false) ?(inlined = Default_inline) ?(specialised = Default_specialise) lam sargs loc = let lapply funct args = match funct with - Lsend(k, lmet, lobj, largs, loc) -> + Lsend(k, lmet, lobj, largs, _) -> Lsend(k, lmet, lobj, largs @ args, loc) - | Levent(Lsend(k, lmet, lobj, largs, loc), _) -> + | Levent(Lsend(k, lmet, lobj, largs, _), _) -> Lsend(k, lmet, lobj, largs @ args, loc) | Lapply ap -> Lapply {ap with ap_args = ap.ap_args @ args; ap_loc = loc} @@ -686,11 +718,13 @@ and transl_apply ?(should_be_tailcall=false) ?(inlined = Default_inline) lapply lam (List.rev_map fst args) in (build_apply lam [] (List.map (fun (l, x) -> - Option.map transl_exp x, Btype.is_optional l) + Option.map (transl_exp ~scopes) x, + Btype.is_optional l) sargs) : Lambda.lambda) -and transl_function loc return untuplify_fn repr partial (param:Ident.t) cases = +and transl_function0 + ~scopes loc return untuplify_fn repr partial (param:Ident.t) cases = match cases with [{c_lhs=pat; c_guard=None; c_rhs={exp_desc = Texp_function { arg_label = _; param = param'; cases; @@ -699,10 +733,12 @@ and transl_function loc return untuplify_fn repr partial (param:Ident.t) cases = let kind = value_kind pat.pat_env pat.pat_type in let return_kind = function_return_value_kind exp_env exp_type in let ((_, params, return), body) = - transl_function exp.exp_loc return_kind false repr partial' param' cases + transl_function0 ~scopes exp.exp_loc return_kind false + repr partial' param' cases in ((Curried, (param, kind) :: params, return), - Matching.for_function loc None (Lvar param) [pat, body] partial) + Matching.for_function ~scopes loc None (Lvar param) + [pat, body] partial) | {c_lhs={pat_desc = Tpat_tuple pl}} :: _ when untuplify_fn -> begin try let size = List.length pl in @@ -733,12 +769,12 @@ and transl_function loc return untuplify_fn repr partial (param:Ident.t) cases = in let params = List.map fst tparams in ((Tupled, tparams, return), - Matching.for_tupled_function loc params - (transl_tupled_cases pats_expr_list) partial) + Matching.for_tupled_function ~scopes loc params + (transl_tupled_cases ~scopes pats_expr_list) partial) with Matching.Cannot_flatten -> ((Curried, [param, Pgenval], return), - Matching.for_function loc repr (Lvar param) - (transl_cases cases) partial) + Matching.for_function ~scopes loc repr (Lvar param) + (transl_cases ~scopes cases) partial) end | {c_lhs=pat} :: other_cases -> let kind = @@ -750,13 +786,50 @@ and transl_function loc return untuplify_fn repr partial (param:Ident.t) cases = (value_kind pat.pat_env pat.pat_type) other_cases in ((Curried, [param, kind], return), - Matching.for_function loc repr (Lvar param) - (transl_cases cases) partial) + Matching.for_function ~scopes loc repr (Lvar param) + (transl_cases ~scopes cases) partial) | [] -> (* With Camlp4, a pattern matching might be empty *) ((Curried, [param, Pgenval], return), - Matching.for_function loc repr (Lvar param) - (transl_cases cases) partial) + Matching.for_function ~scopes loc repr (Lvar param) + (transl_cases ~scopes cases) partial) + +and transl_function ~scopes e param cases partial = + let ((kind, params, return), body) = + event_function ~scopes e + (function repr -> + let pl = push_defaults e.exp_loc [] cases partial in + let return_kind = function_return_value_kind e.exp_env e.exp_type in + transl_function0 ~scopes e.exp_loc return_kind !Clflags.native_code + repr partial param pl) + in + let attr = default_function_attribute in + let loc = of_location ~scopes e.exp_loc in + let lam = Lfunction{kind; params; return; body; attr; loc} in + Translattribute.add_function_attributes lam e.exp_loc e.exp_attributes + +(* Like transl_exp, but used when introducing a new scope. + Goes to some trouble to avoid introducing many new anonymous function + scopes, as `let f a b = ...` is desugared to several Pexp_fun *) +and transl_scoped_exp ~scopes expr = + match expr.exp_desc with + | Texp_function { arg_label = _; param; cases; partial } -> + transl_function ~scopes expr param cases partial + | _ -> + transl_exp ~scopes expr + +(* Calls transl_scoped_exp or transl_exp, according to whether a pattern + binding should introduce a new scope *) +and transl_bound_exp ~scopes ~in_structure pat expr = + let should_introduce_scope = + match expr.exp_desc with + | Texp_function _ -> true + | _ when in_structure -> true + | _ -> false in + match pat_bound_idents pat with + | (id :: _) when should_introduce_scope -> + transl_scoped_exp ~scopes:(enter_value_definition ~scopes id) expr + | _ -> transl_exp ~scopes expr (* Notice: transl_let consumes (ie compiles) its pat_expr_list argument, @@ -764,17 +837,18 @@ and transl_function loc return untuplify_fn repr partial (param:Ident.t) cases = This complication allows choosing any compilation order for the bindings and body of let constructs. *) -and transl_let rec_flag pat_expr_list = +and transl_let ~scopes ?(in_structure=false) rec_flag pat_expr_list = match rec_flag with Nonrecursive -> let rec transl = function [] -> fun body -> body | {vb_pat=pat; vb_expr=expr; vb_attributes=attr; vb_loc} :: rem -> - let lam = transl_exp expr in + let lam = transl_bound_exp ~scopes ~in_structure pat expr in let lam = Translattribute.add_function_attributes lam vb_loc attr in let mk_body = transl rem in - fun body -> Matching.for_let pat.pat_loc lam pat (mk_body body) + fun body -> + Matching.for_let ~scopes pat.pat_loc lam pat (mk_body body) in transl pat_expr_list | Recursive -> let idlist = @@ -784,8 +858,8 @@ and transl_let rec_flag pat_expr_list = | Tpat_alias ({pat_desc=Tpat_any}, id,_) -> id | _ -> assert false) pat_expr_list in - let transl_case {vb_expr=expr; vb_attributes; vb_loc} id = - let lam = transl_exp expr in + let transl_case {vb_expr=expr; vb_attributes; vb_loc; vb_pat} id = + let lam = transl_bound_exp ~scopes ~in_structure vb_pat expr in let lam = Translattribute.add_function_attributes lam vb_loc vb_attributes in @@ -793,11 +867,11 @@ and transl_let rec_flag pat_expr_list = let lam_bds = List.map2 transl_case pat_expr_list idlist in fun body -> Lletrec(lam_bds, body) -and transl_setinstvar loc self var expr = +and transl_setinstvar ~scopes loc self var expr = Lprim(Psetfield_computed (maybe_pointer expr, Assignment), - [self; var; transl_exp expr], loc) + [self; var; transl_exp ~scopes expr], loc) -and transl_record loc env fields repres opt_init_expr = +and transl_record ~scopes loc env fields repres opt_init_expr = let size = Array.length fields in (* Determine if there are "enough" fields (only relevant if this is a functional-style record update *) @@ -819,10 +893,12 @@ and transl_record loc env fields repres opt_init_expr = | Record_unboxed _ -> assert false | Record_extension _ -> Pfield (i + 1) | Record_float -> Pfloatfield i in - Lprim(access, [Lvar init_id], loc), field_kind + Lprim(access, [Lvar init_id], + of_location ~scopes loc), + field_kind | Overridden (_lid, expr) -> let field_kind = value_kind expr.exp_env expr.exp_type in - transl_exp expr, field_kind) + transl_exp ~scopes expr, field_kind) fields in let ll, shape = List.split (Array.to_list lv) in @@ -843,6 +919,7 @@ and transl_record loc env fields repres opt_init_expr = | Record_extension _ -> raise Not_constant with Not_constant -> + let loc = of_location ~scopes loc in match repres with Record_regular -> Lprim(Pmakeblock(0, mut, Some shape), ll, loc) @@ -858,7 +935,7 @@ and transl_record loc env fields repres opt_init_expr = begin match opt_init_expr with None -> lam | Some init_expr -> Llet(Strict, Pgenval, init_id, - transl_exp init_expr, lam) + transl_exp ~scopes init_expr, lam) end end else begin (* Take a shallow copy of the init record, then mutate the fields @@ -878,18 +955,21 @@ and transl_record loc env fields repres opt_init_expr = | Record_extension _ -> Psetfield(lbl.lbl_pos + 1, maybe_pointer expr, Assignment) in - Lsequence(Lprim(upd, [Lvar copy_id; transl_exp expr], loc), cont) + Lsequence(Lprim(upd, [Lvar copy_id; transl_exp ~scopes expr], + of_location ~scopes loc), + cont) in begin match opt_init_expr with None -> assert false | Some init_expr -> Llet(Strict, Pgenval, copy_id, - Lprim(Pduprecord (repres, size), [transl_exp init_expr], loc), + Lprim(Pduprecord (repres, size), [transl_exp ~scopes init_expr], + of_location ~scopes loc), Array.fold_left update_field (Lvar copy_id) fields) end end -and transl_match e arg pat_expr_list partial = +and transl_match ~scopes e arg pat_expr_list partial = let rewrite_case (val_cases, exn_cases, static_handlers as acc) ({ c_lhs; c_guard; c_rhs } as case) = if c_rhs.exp_desc = Texp_unreachable then acc else @@ -898,11 +978,11 @@ and transl_match e arg pat_expr_list partial = | None, None -> assert false | Some pv, None -> let val_case = - transl_case { case with c_lhs = pv } + transl_case ~scopes { case with c_lhs = pv } in val_case :: val_cases, exn_cases, static_handlers | None, Some pe -> - let exn_case = transl_case_try { case with c_lhs = pe } in + let exn_case = transl_case_try ~scopes { case with c_lhs = pe } in val_cases, exn_case :: exn_cases, static_handlers | Some pv, Some pe -> assert (c_guard = None); @@ -924,7 +1004,8 @@ and transl_match e arg pat_expr_list partial = iter_exn_names Translprim.add_exception_ident pe; let rhs = Misc.try_finally - (fun () -> event_before c_rhs (transl_exp c_rhs)) + (fun () -> event_before ~scopes c_rhs + (transl_exp ~scopes c_rhs)) ~always:(fun () -> iter_exn_names Translprim.remove_exception_ident pe) in @@ -941,7 +1022,7 @@ and transl_match e arg pat_expr_list partial = let static_exception_id = next_raise_count () in Lstaticcatch (Ltrywith (Lstaticraise (static_exception_id, body), id, - Matching.for_trywith (Lvar id) exn_cases), + Matching.for_trywith ~scopes (Lvar id) exn_cases), (static_exception_id, val_ids), handler) in @@ -949,7 +1030,8 @@ and transl_match e arg pat_expr_list partial = match arg, exn_cases with | {exp_desc = Texp_tuple argl}, [] -> assert (static_handlers = []); - Matching.for_multiple_match e.exp_loc (transl_list argl) val_cases partial + Matching.for_multiple_match ~scopes e.exp_loc + (transl_list ~scopes argl) val_cases partial | {exp_desc = Texp_tuple argl}, _ :: _ -> let val_ids = List.map @@ -960,36 +1042,39 @@ and transl_match e arg pat_expr_list partial = argl in let lvars = List.map (fun (id, _) -> Lvar id) val_ids in - static_catch (transl_list argl) val_ids - (Matching.for_multiple_match e.exp_loc lvars val_cases partial) + static_catch (transl_list ~scopes argl) val_ids + (Matching.for_multiple_match ~scopes e.exp_loc + lvars val_cases partial) | arg, [] -> assert (static_handlers = []); - Matching.for_function e.exp_loc None (transl_exp arg) val_cases partial + Matching.for_function ~scopes e.exp_loc + None (transl_exp ~scopes arg) val_cases partial | arg, _ :: _ -> - let val_id = Typecore.name_cases "val" pat_expr_list in + let val_id = Typecore.name_pattern "val" (List.map fst val_cases) in let k = Typeopt.value_kind arg.exp_env arg.exp_type in - static_catch [transl_exp arg] [val_id, k] - (Matching.for_function e.exp_loc None (Lvar val_id) val_cases partial) + static_catch [transl_exp ~scopes arg] [val_id, k] + (Matching.for_function ~scopes e.exp_loc + None (Lvar val_id) val_cases partial) in List.fold_left (fun body (static_exception_id, val_ids, handler) -> Lstaticcatch (body, (static_exception_id, val_ids), handler) ) classic static_handlers -and transl_letop loc env let_ ands param case partial = +and transl_letop ~scopes loc env let_ ands param case partial = let rec loop prev_lam = function | [] -> prev_lam | and_ :: rest -> let left_id = Ident.create_local "left" in let right_id = Ident.create_local "right" in let op = - transl_ident and_.bop_op_name.loc env + transl_ident (of_location ~scopes and_.bop_op_name.loc) env and_.bop_op_type and_.bop_op_path and_.bop_op_val in - let exp = transl_exp and_.bop_exp in + let exp = transl_exp ~scopes and_.bop_exp in let lam = bind Strict right_id exp (Lapply{ap_should_be_tailcall = false; - ap_loc = and_.bop_loc; + ap_loc = of_location ~scopes and_.bop_loc; ap_func = op; ap_args=[Lvar left_id; Lvar right_id]; ap_inlined=Default_inline; @@ -998,24 +1083,24 @@ and transl_letop loc env let_ ands param case partial = bind Strict left_id prev_lam (loop lam rest) in let op = - transl_ident let_.bop_op_name.loc env + transl_ident (of_location ~scopes let_.bop_op_name.loc) env let_.bop_op_type let_.bop_op_path let_.bop_op_val in - let exp = loop (transl_exp let_.bop_exp) ands in + let exp = loop (transl_exp ~scopes let_.bop_exp) ands in let func = let return_kind = value_kind case.c_rhs.exp_env case.c_rhs.exp_type in let (kind, params, return), body = - event_function case.c_rhs + event_function ~scopes case.c_rhs (function repr -> - transl_function case.c_rhs.exp_loc return_kind + transl_function0 ~scopes case.c_rhs.exp_loc return_kind !Clflags.native_code repr partial param [case]) in let attr = default_function_attribute in - let loc = case.c_rhs.exp_loc in + let loc = of_location ~scopes case.c_rhs.exp_loc in Lfunction{kind; params; return; body; attr; loc} in Lapply{ap_should_be_tailcall = false; - ap_loc = loc; + ap_loc = of_location ~scopes loc; ap_func = op; ap_args=[exp; func]; ap_inlined=Default_inline; diff --git a/lambda/translcore.mli b/lambda/translcore.mli index 7a27dbcb..61b1a1d2 100644 --- a/lambda/translcore.mli +++ b/lambda/translcore.mli @@ -19,20 +19,26 @@ open Asttypes open Typedtree open Lambda +open Debuginfo.Scoped_location val pure_module : module_expr -> let_kind -val transl_exp: expression -> lambda -val transl_apply: ?should_be_tailcall:bool +val transl_exp: scopes:scopes -> expression -> lambda +val transl_apply: scopes:scopes + -> ?should_be_tailcall:bool -> ?inlined:inline_attribute -> ?specialised:specialise_attribute -> lambda -> (arg_label * expression option) list - -> Location.t -> lambda -val transl_let: rec_flag -> value_binding list -> lambda -> lambda + -> scoped_location -> lambda +val transl_let: scopes:scopes -> ?in_structure:bool -> rec_flag + -> value_binding list -> lambda -> lambda -val transl_extension_constructor: Env.t -> Path.t option -> +val transl_extension_constructor: scopes:scopes -> + Env.t -> Path.t option -> extension_constructor -> lambda +val transl_scoped_exp : scopes:scopes -> expression -> lambda + type error = Free_super_var | Unreachable_reached @@ -45,6 +51,8 @@ val report_error: formatter -> error -> unit (* Forward declaration -- to be filled in by Translmod.transl_module *) val transl_module : - (module_coercion -> Path.t option -> module_expr -> lambda) ref + (scopes:scopes -> module_coercion -> Path.t option -> + module_expr -> lambda) ref val transl_object : - (Ident.t -> string list -> class_expr -> lambda) ref + (scopes:scopes -> Ident.t -> string list -> + class_expr -> lambda) ref diff --git a/lambda/translmod.ml b/lambda/translmod.ml index 5a617365..e578ee7e 100644 --- a/lambda/translmod.ml +++ b/lambda/translmod.ml @@ -25,6 +25,7 @@ open Lambda open Translobj open Translcore open Translclass +open Debuginfo.Scoped_location type unsafe_component = | Unsafe_module_binding @@ -61,11 +62,12 @@ let field_path path field = (* Compile type extensions *) -let transl_type_extension env rootpath tyext body = +let transl_type_extension ~scopes env rootpath tyext body = List.fold_right (fun ext body -> let lam = - transl_extension_constructor env (field_path rootpath ext.ext_id) ext + transl_extension_constructor ~scopes env + (field_path rootpath ext.ext_id) ext in Llet(Strict, Pgenval, ext.ext_id, lam, body)) tyext.tyext_constructors @@ -93,8 +95,8 @@ let rec apply_coercion loc strict restr arg = let param = Ident.create_local "funarg" in let carg = apply_coercion loc Alias cc_arg (Lvar param) in apply_coercion_result loc strict arg [param, Pgenval] [carg] cc_res - | Tcoerce_primitive { pc_loc; pc_desc; pc_env; pc_type; } -> - Translprim.transl_primitive pc_loc pc_desc pc_env pc_type None + | Tcoerce_primitive { pc_loc = _; pc_desc; pc_env; pc_type; } -> + Translprim.transl_primitive loc pc_desc pc_env pc_type None | Tcoerce_alias (env, path, cc) -> let lam = transl_module_path loc env path in name_lambda strict arg @@ -214,7 +216,7 @@ let mod_prim = Lambda.transl_prim "CamlinternalMod" let undefined_location loc = let (fname, line, char) = Location.get_pos_info loc.Location.loc_start in Lconst(Const_block(0, - [Const_base(Const_string (fname, None)); + [Const_base(Const_string (fname, loc, None)); Const_base(Const_int line); Const_base(Const_int char)])) @@ -287,7 +289,7 @@ type binding_status = type id_or_ignore_loc = | Id of Ident.t - | Ignore_loc of Location.t + | Ignore_loc of Lambda.scoped_location let extract_unsafe_cycle id status init cycle_start = let info i = match init.(i) with @@ -357,7 +359,7 @@ let eval_rec_bindings bindings cont = | (Id id, Some(loc, shape), _rhs) :: rem -> Llet(Strict, Pgenval, id, Lapply{ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=mod_prim "init_mod"; ap_args=[loc; shape]; ap_inlined=Default_inline; @@ -380,7 +382,7 @@ let eval_rec_bindings bindings cont = patch_forwards rem | (Id id, Some(_loc, shape), rhs) :: rem -> Lsequence(Lapply{ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=mod_prim "update_mod"; ap_args=[shape; Lvar id; rhs]; ap_inlined=Default_inline; @@ -389,14 +391,16 @@ let eval_rec_bindings bindings cont = in bind_inits bindings -let compile_recmodule compile_rhs bindings cont = +let compile_recmodule ~scopes compile_rhs bindings cont = eval_rec_bindings (reorder_rec_bindings (List.map (fun {mb_id=id; mb_name; mb_expr=modl; mb_loc=loc; _} -> let id_or_ignore_loc, shape = match id with - | None -> Ignore_loc mb_name.loc, Result.Error Unnamed + | None -> + let loc = of_location ~scopes mb_name.loc in + Ignore_loc loc, Result.Error Unnamed | Some id -> Id id, init_shape id modl in (id_or_ignore_loc, modl.mod_loc, shape, compile_rhs id modl loc)) @@ -405,12 +409,12 @@ let compile_recmodule compile_rhs bindings cont = (* Code to translate class entries in a structure *) -let transl_class_bindings cl_list = +let transl_class_bindings ~scopes cl_list = let ids = List.map (fun (ci, _) -> ci.ci_id_class) cl_list in (ids, List.map (fun ({ci_id_class=id; ci_expr=cl; ci_virt=vf}, meths) -> - (id, transl_class ids id meths cl vf)) + (id, transl_class ~scopes ids id meths cl vf)) cl_list) (* Compile one or more functors, merging curried functors to produce @@ -422,10 +426,10 @@ let transl_class_bindings cl_list = let merge_inline_attributes attr1 attr2 loc = match Lambda.merge_inline_attributes attr1 attr2 with | Some attr -> attr - | None -> raise (Error (loc, Conflicting_inline_attributes)) + | None -> raise (Error (to_location loc, Conflicting_inline_attributes)) -let merge_functors mexp coercion root_path = - let rec merge mexp coercion path acc inline_attribute = +let merge_functors ~scopes mexp coercion root_path = + let rec merge ~scopes mexp coercion path acc inline_attribute = let finished = acc, mexp, path, coercion, inline_attribute in match mexp.mod_desc with | Tmod_functor (param, body) -> @@ -439,7 +443,7 @@ let merge_functors mexp coercion root_path = arg_coercion, res_coercion | _ -> fatal_error "Translmod.merge_functors: bad coercion" in - let loc = mexp.mod_loc in + let loc = of_location ~scopes mexp.mod_loc in let path, param = match param with | Unit -> None, Ident.create_local "*" @@ -451,15 +455,15 @@ let merge_functors mexp coercion root_path = let inline_attribute = merge_inline_attributes inline_attribute inline_attribute' loc in - merge body res_coercion path ((param, loc, arg_coercion) :: acc) + merge ~scopes body res_coercion path ((param, loc, arg_coercion) :: acc) inline_attribute | _ -> finished in - merge mexp coercion root_path [] Default_inline + merge ~scopes mexp coercion root_path [] Default_inline -let rec compile_functor mexp coercion root_path loc = +let rec compile_functor ~scopes mexp coercion root_path loc = let functor_params_rev, body, body_path, res_coercion, inline_attribute = - merge_functors mexp coercion root_path + merge_functors ~scopes mexp coercion root_path in assert (List.length functor_params_rev >= 1); (* cf. [transl_module] *) let params, body = @@ -469,7 +473,7 @@ let rec compile_functor mexp coercion root_path loc = let params = (param', Pgenval) :: params in let body = Llet (Alias, Pgenval, param, arg, body) in params, body) - ([], transl_module res_coercion body_path body) + ([], transl_module ~scopes res_coercion body_path body) functor_params_rev in Lfunction { @@ -489,19 +493,19 @@ let rec compile_functor mexp coercion root_path loc = (* Compile a module expression *) -and transl_module cc rootpath mexp = +and transl_module ~scopes cc rootpath mexp = List.iter (Translattribute.check_attribute_on_module mexp) mexp.mod_attributes; - let loc = mexp.mod_loc in + let loc = of_location ~scopes mexp.mod_loc in match mexp.mod_desc with | Tmod_ident (path,_) -> apply_coercion loc Strict cc (transl_module_path loc mexp.mod_env path) | Tmod_structure str -> - fst (transl_struct loc [] cc rootpath str) + fst (transl_struct ~scopes loc [] cc rootpath str) | Tmod_functor _ -> oo_wrap mexp.mod_env true (fun () -> - compile_functor mexp cc rootpath loc) () + compile_functor ~scopes mexp cc rootpath loc) () | Tmod_apply(funct, arg, ccarg) -> let inlined_attribute, funct = Translattribute.get_and_remove_inlined_attribute_on_module funct @@ -510,22 +514,22 @@ and transl_module cc rootpath mexp = (apply_coercion loc Strict cc) (Lapply{ap_should_be_tailcall=false; ap_loc=loc; - ap_func=transl_module Tcoerce_none None funct; - ap_args=[transl_module ccarg None arg]; + ap_func=transl_module ~scopes Tcoerce_none None funct; + ap_args=[transl_module ~scopes ccarg None arg]; ap_inlined=inlined_attribute; ap_specialised=Default_specialise}) | Tmod_constraint(arg, _, _, ccarg) -> - transl_module (compose_coercions cc ccarg) rootpath arg + transl_module ~scopes (compose_coercions cc ccarg) rootpath arg | Tmod_unpack(arg, _) -> - apply_coercion loc Strict cc (Translcore.transl_exp arg) + apply_coercion loc Strict cc (Translcore.transl_exp ~scopes arg) -and transl_struct loc fields cc rootpath str = - transl_structure loc fields cc rootpath str.str_final_env str.str_items +and transl_struct ~scopes loc fields cc rootpath {str_final_env; str_items; _} = + transl_structure ~scopes loc fields cc rootpath str_final_env str_items (* The function transl_structure is called by the bytecode compiler. Some effort is made to compile in top to bottom order, in order to display warning by increasing locations. *) -and transl_structure loc fields cc rootpath final_env = function +and transl_structure ~scopes loc fields cc rootpath final_env = function [] -> let body, size = match cc with @@ -551,7 +555,8 @@ and transl_structure loc fields cc rootpath final_env = function (fun (pos, cc) -> match cc with Tcoerce_primitive p -> - Translprim.transl_primitive p.pc_loc + Translprim.transl_primitive + (of_location ~scopes p.pc_loc) p.pc_desc p.pc_env p.pc_type None | _ -> apply_coercion loc Strict cc (get_field pos)) pos_cc_list, loc) @@ -580,48 +585,53 @@ and transl_structure loc fields cc rootpath final_env = function match item.str_desc with | Tstr_eval (expr, _) -> let body, size = - transl_structure loc fields cc rootpath final_env rem + transl_structure ~scopes loc fields cc rootpath final_env rem in - Lsequence(transl_exp expr, body), size + Lsequence(transl_exp ~scopes expr, body), size | Tstr_value(rec_flag, pat_expr_list) -> (* Translate bindings first *) - let mk_lam_let = transl_let rec_flag pat_expr_list in + let mk_lam_let = + transl_let ~scopes ~in_structure:true rec_flag pat_expr_list in let ext_fields = List.rev_append (let_bound_idents pat_expr_list) fields in (* Then, translate remainder of struct *) let body, size = - transl_structure loc ext_fields cc rootpath final_env rem + transl_structure ~scopes loc ext_fields cc rootpath final_env rem in mk_lam_let body, size | Tstr_primitive descr -> record_primitive descr.val_val; - transl_structure loc fields cc rootpath final_env rem + transl_structure ~scopes loc fields cc rootpath final_env rem | Tstr_type _ -> - transl_structure loc fields cc rootpath final_env rem + transl_structure ~scopes loc fields cc rootpath final_env rem | Tstr_typext(tyext) -> let ids = List.map (fun ext -> ext.ext_id) tyext.tyext_constructors in let body, size = - transl_structure loc (List.rev_append ids fields) + transl_structure ~scopes loc (List.rev_append ids fields) cc rootpath final_env rem in - transl_type_extension item.str_env rootpath tyext body, size + transl_type_extension ~scopes item.str_env rootpath tyext body, size | Tstr_exception ext -> let id = ext.tyexn_constructor.ext_id in let path = field_path rootpath id in let body, size = - transl_structure loc (id :: fields) cc rootpath final_env rem + transl_structure ~scopes loc (id::fields) cc rootpath final_env rem in Llet(Strict, Pgenval, id, - transl_extension_constructor item.str_env + transl_extension_constructor ~scopes + item.str_env path ext.tyexn_constructor, body), size | Tstr_module ({mb_presence=Mp_present} as mb) -> let id = mb.mb_id in (* Translate module first *) + let subscopes = match id with + | None -> scopes + | Some id -> enter_module_definition ~scopes id in let module_body = - transl_module Tcoerce_none (Option.bind id (field_path rootpath)) - mb.mb_expr + transl_module ~scopes:subscopes Tcoerce_none + (Option.bind id (field_path rootpath)) mb.mb_expr in let module_body = Translattribute.add_inline_attribute module_body mb.mb_loc @@ -629,16 +639,18 @@ and transl_structure loc fields cc rootpath final_env = function in (* Translate remainder second *) let body, size = - transl_structure loc (cons_opt id fields) cc rootpath final_env rem + transl_structure ~scopes loc (cons_opt id fields) + cc rootpath final_env rem in begin match id with | None -> - Lsequence (Lprim(Pignore, [module_body], mb.mb_name.loc), body), + Lsequence (Lprim(Pignore, [module_body], + of_location ~scopes mb.mb_name.loc), body), size | Some id -> let module_body = Levent (module_body, { - lev_loc = mb.mb_loc; + lev_loc = of_location ~scopes mb.mb_loc; lev_kind = Lev_module_definition id; lev_repr = None; lev_env = Env.empty; @@ -647,25 +659,27 @@ and transl_structure loc fields cc rootpath final_env = function Llet(pure_module mb.mb_expr, Pgenval, id, module_body, body), size end | Tstr_module {mb_presence=Mp_absent} -> - transl_structure loc fields cc rootpath final_env rem + transl_structure ~scopes loc fields cc rootpath final_env rem | Tstr_recmodule bindings -> let ext_fields = List.rev_append (List.filter_map (fun mb -> mb.mb_id) bindings) fields in let body, size = - transl_structure loc ext_fields cc rootpath final_env rem + transl_structure ~scopes loc ext_fields cc rootpath final_env rem in let lam = - compile_recmodule (fun id modl loc -> + compile_recmodule ~scopes (fun id modl loc -> match id with - | None -> transl_module Tcoerce_none None modl + | None -> transl_module ~scopes Tcoerce_none None modl | Some id -> let module_body = - transl_module Tcoerce_none (field_path rootpath id) modl + transl_module + ~scopes:(enter_module_definition ~scopes id) + Tcoerce_none (field_path rootpath id) modl in Levent (module_body, { - lev_loc = loc; + lev_loc = of_location ~scopes loc; lev_kind = Lev_module_definition id; lev_repr = None; lev_env = Env.empty; @@ -674,9 +688,9 @@ and transl_structure loc fields cc rootpath final_env = function in lam, size | Tstr_class cl_list -> - let (ids, class_bindings) = transl_class_bindings cl_list in + let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in let body, size = - transl_structure loc (List.rev_append ids fields) + transl_structure ~scopes loc (List.rev_append ids fields) cc rootpath final_env rem in Lletrec(class_bindings, body), size @@ -686,18 +700,19 @@ and transl_structure loc fields cc rootpath final_env = function let mid = Ident.create_local "include" in let rec rebind_idents pos newfields = function [] -> - transl_structure loc newfields cc rootpath final_env rem + transl_structure ~scopes loc newfields cc rootpath final_env rem | id :: ids -> let body, size = rebind_idents (pos + 1) (id :: newfields) ids in Llet(Alias, Pgenval, id, - Lprim(Pfield pos, [Lvar mid], incl.incl_loc), body), + Lprim(Pfield pos, [Lvar mid], + of_location ~scopes incl.incl_loc), body), size in let body, size = rebind_idents 0 fields ids in Llet(pure_module modl, Pgenval, mid, - transl_module Tcoerce_none None modl, body), + transl_module ~scopes Tcoerce_none None modl, body), size | Tstr_open od -> @@ -708,29 +723,31 @@ and transl_structure loc fields cc rootpath final_env = function it. *) begin match od.open_bound_items with | [] when pure = Alias -> - transl_structure loc fields cc rootpath final_env rem + transl_structure ~scopes loc fields cc rootpath final_env rem | _ -> let ids = bound_value_identifiers od.open_bound_items in let mid = Ident.create_local "open" in let rec rebind_idents pos newfields = function - [] -> - transl_structure loc newfields cc rootpath final_env rem + [] -> transl_structure + ~scopes loc newfields cc rootpath final_env rem | id :: ids -> let body, size = rebind_idents (pos + 1) (id :: newfields) ids in Llet(Alias, Pgenval, id, - Lprim(Pfield pos, [Lvar mid], od.open_loc), body), + Lprim(Pfield pos, [Lvar mid], + of_location ~scopes od.open_loc), body), size in let body, size = rebind_idents 0 fields ids in Llet(pure, Pgenval, mid, - transl_module Tcoerce_none None od.open_expr, body), size + transl_module ~scopes Tcoerce_none None od.open_expr, body), + size end | Tstr_modtype _ | Tstr_class_type _ | Tstr_attribute _ -> - transl_structure loc fields cc rootpath final_env rem + transl_structure ~scopes loc fields cc rootpath final_env rem (* Update forward declaration in Translcore *) let _ = @@ -777,9 +794,10 @@ let transl_implementation_flambda module_name (str, cc) = primitive_declarations := []; Translprim.clear_used_primitives (); let module_id = Ident.create_persistent module_name in + let scopes = [Sc_module_definition module_name] in let body, size = Translobj.transl_label_init - (fun () -> transl_struct Location.none [] cc + (fun () -> transl_struct ~scopes Loc_unknown [] cc (global_path module_id) str) in { module_ident = module_id; @@ -793,7 +811,7 @@ let transl_implementation module_name (str, cc) = in let code = Lprim (Psetglobal implementation.module_ident, [implementation.code], - Location.none) + Loc_unknown) in { implementation with code } @@ -945,80 +963,89 @@ let field_of_str loc str = let ids = Array.of_list (defined_idents str.str_items) in fun (pos, cc) -> match cc with - | Tcoerce_primitive { pc_loc; pc_desc; pc_env; pc_type; } -> - Translprim.transl_primitive pc_loc pc_desc pc_env pc_type None + | Tcoerce_primitive { pc_loc = _; pc_desc; pc_env; pc_type; } -> + Translprim.transl_primitive loc pc_desc pc_env pc_type None | Tcoerce_alias (env, path, cc) -> let lam = transl_module_path loc env path in apply_coercion loc Alias cc lam | _ -> apply_coercion loc Strict cc (Lvar ids.(pos)) -let transl_store_structure glob map prims aliases str = +let transl_store_structure ~scopes glob map prims aliases str = let no_env_update _ _ env = env in - let rec transl_store rootpath subst cont = function + let rec transl_store ~scopes rootpath subst cont = function [] -> transl_store_subst := subst; Lambda.subst no_env_update subst cont | item :: rem -> match item.str_desc with | Tstr_eval (expr, _attrs) -> - Lsequence(Lambda.subst no_env_update subst (transl_exp expr), - transl_store rootpath subst cont rem) + Lsequence(Lambda.subst no_env_update subst + (transl_exp ~scopes expr), + transl_store ~scopes rootpath subst cont rem) | Tstr_value(rec_flag, pat_expr_list) -> let ids = let_bound_idents pat_expr_list in let lam = - transl_let rec_flag pat_expr_list - (store_idents Location.none ids) + transl_let ~scopes ~in_structure:true rec_flag pat_expr_list + (store_idents Loc_unknown ids) in Lsequence(Lambda.subst no_env_update subst lam, - transl_store rootpath + transl_store ~scopes rootpath (add_idents false ids subst) cont rem) | Tstr_primitive descr -> record_primitive descr.val_val; - transl_store rootpath subst cont rem + transl_store ~scopes rootpath subst cont rem | Tstr_type _ -> - transl_store rootpath subst cont rem + transl_store ~scopes rootpath subst cont rem | Tstr_typext(tyext) -> let ids = List.map (fun ext -> ext.ext_id) tyext.tyext_constructors in let lam = - transl_type_extension item.str_env rootpath tyext - (store_idents Location.none ids) + transl_type_extension ~scopes item.str_env rootpath tyext + (store_idents Loc_unknown ids) in Lsequence(Lambda.subst no_env_update subst lam, - transl_store rootpath + transl_store ~scopes rootpath (add_idents false ids subst) cont rem) | Tstr_exception ext -> let id = ext.tyexn_constructor.ext_id in let path = field_path rootpath id in + let loc = of_location ~scopes ext.tyexn_constructor.ext_loc in let lam = - transl_extension_constructor item.str_env + transl_extension_constructor ~scopes + item.str_env path ext.tyexn_constructor in Lsequence(Llet(Strict, Pgenval, id, Lambda.subst no_env_update subst lam, - store_ident ext.tyexn_constructor.ext_loc id), - transl_store rootpath + store_ident loc id), + transl_store ~scopes rootpath (add_ident false id subst) cont rem) | Tstr_module {mb_id=None; mb_name; mb_presence=Mp_present; mb_expr=modl; mb_loc=loc; mb_attributes} -> let lam = Translattribute.add_inline_attribute - (transl_module Tcoerce_none None modl) + (transl_module ~scopes Tcoerce_none None modl) loc mb_attributes in - Lsequence(Lprim(Pignore, [lam], mb_name.loc), - transl_store rootpath subst cont rem) + Lsequence( + Lprim(Pignore,[Lambda.subst no_env_update subst lam], + of_location ~scopes mb_name.loc), + transl_store ~scopes rootpath subst cont rem + ) | Tstr_module{mb_id=Some id;mb_loc=loc;mb_presence=Mp_present; mb_expr={mod_desc = Tmod_structure str} as mexp; mb_attributes} -> List.iter (Translattribute.check_attribute_on_module mexp) mb_attributes; + let loc = of_location ~scopes loc in let lam = - transl_store (field_path rootpath id) subst + transl_store + ~scopes:(enter_module_definition ~scopes id) + (field_path rootpath id) subst lambda_unit str.str_items in (* Careful: see next case *) @@ -1030,7 +1057,7 @@ let transl_store_structure glob map prims aliases str = List.map (fun id -> Lvar id) (defined_idents str.str_items), loc)), Lsequence(store_ident loc id, - transl_store rootpath + transl_store ~scopes rootpath (add_ident true id subst) cont rem))) | Tstr_module{ @@ -1045,8 +1072,11 @@ let transl_store_structure glob map prims aliases str = Includemod.print_coercion cc; *) List.iter (Translattribute.check_attribute_on_module mexp) mb_attributes; + let loc = of_location ~scopes loc in let lam = - transl_store (field_path rootpath id) subst + transl_store + ~scopes:(enter_module_definition ~scopes id) + (field_path rootpath id) subst lambda_unit str.str_items in (* Careful: see next case *) @@ -1058,7 +1088,7 @@ let transl_store_structure glob map prims aliases str = (Lprim(Pmakeblock(0, Immutable, None), List.map field map, loc)), Lsequence(store_ident loc id, - transl_store rootpath + transl_store ~scopes rootpath (add_ident true id subst) cont rem))) | Tstr_module @@ -1066,7 +1096,9 @@ let transl_store_structure glob map prims aliases str = mb_loc=loc; mb_attributes} -> let lam = Translattribute.add_inline_attribute - (transl_module Tcoerce_none (field_path rootpath id) modl) + (transl_module + ~scopes:(enter_module_definition ~scopes id) + Tcoerce_none (field_path rootpath id) modl) loc mb_attributes in (* Careful: the module value stored in the global may be different @@ -1076,29 +1108,35 @@ let transl_store_structure glob map prims aliases str = If not, we can use the value from the global (add_ident true adds id -> Pgetglobal... to subst). *) Llet(Strict, Pgenval, id, Lambda.subst no_env_update subst lam, - Lsequence(store_ident loc id, - transl_store rootpath (add_ident true id subst) + Lsequence(store_ident (of_location ~scopes loc) id, + transl_store ~scopes rootpath + (add_ident true id subst) cont rem)) | Tstr_module {mb_presence=Mp_absent} -> - transl_store rootpath subst cont rem + transl_store ~scopes rootpath subst cont rem | Tstr_recmodule bindings -> let ids = List.filter_map (fun mb -> mb.mb_id) bindings in - compile_recmodule + compile_recmodule ~scopes (fun id modl _loc -> Lambda.subst no_env_update subst - (transl_module Tcoerce_none - (Option.bind id (field_path rootpath)) modl)) + (match id with + | None -> + transl_module ~scopes Tcoerce_none None modl + | Some id -> + transl_module + ~scopes:(enter_module_definition ~scopes id) + Tcoerce_none (field_path rootpath id) modl)) bindings - (Lsequence(store_idents Location.none ids, - transl_store rootpath (add_idents true ids subst) - cont rem)) + (Lsequence(store_idents Loc_unknown ids, + transl_store ~scopes rootpath + (add_idents true ids subst) cont rem)) | Tstr_class cl_list -> - let (ids, class_bindings) = transl_class_bindings cl_list in + let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in let lam = - Lletrec(class_bindings, store_idents Location.none ids) + Lletrec(class_bindings, store_idents Loc_unknown ids) in Lsequence(Lambda.subst no_env_update subst lam, - transl_store rootpath (add_idents false ids subst) + transl_store ~scopes rootpath (add_idents false ids subst) cont rem) | Tstr_include{ @@ -1115,24 +1153,24 @@ let transl_store_structure glob map prims aliases str = (* Shouldn't we use mod_attributes instead of incl_attributes? Same question for the Tstr_module cases above, btw. *) let lam = - transl_store None subst lambda_unit str.str_items + transl_store ~scopes None subst lambda_unit str.str_items (* It is tempting to pass rootpath instead of None in order to give a more precise name to exceptions in the included structured, but this would introduce a difference of behavior compared to bytecode. *) in let subst = !transl_store_subst in - let field = field_of_str loc str in + let field = field_of_str (of_location ~scopes loc) str in let ids0 = bound_value_identifiers incl_type in let rec loop ids args = match ids, args with | [], [] -> - transl_store rootpath (add_idents true ids0 subst) + transl_store ~scopes rootpath (add_idents true ids0 subst) cont rem | id :: ids, arg :: args -> Llet(Alias, Pgenval, id, Lambda.subst no_env_update subst (field arg), - Lsequence(store_ident loc id, + Lsequence(store_ident (of_location ~scopes loc) id, loop ids args)) | _ -> assert false in @@ -1145,32 +1183,34 @@ let transl_store_structure glob map prims aliases str = let mid = Ident.create_local "include" in let loc = incl.incl_loc in let rec store_idents pos = function - | [] -> - transl_store rootpath (add_idents true ids subst) cont rem + | [] -> transl_store + ~scopes rootpath (add_idents true ids subst) cont rem | id :: idl -> - Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid], loc), - Lsequence(store_ident loc id, + Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid], + of_location ~scopes loc), + Lsequence(store_ident (of_location ~scopes loc) id, store_idents (pos + 1) idl)) in Llet(Strict, Pgenval, mid, Lambda.subst no_env_update subst - (transl_module Tcoerce_none None modl), + (transl_module ~scopes Tcoerce_none None modl), store_idents 0 ids) | Tstr_open od -> begin match od.open_expr.mod_desc with | Tmod_structure str -> let lam = - transl_store rootpath subst lambda_unit str.str_items + transl_store ~scopes rootpath subst lambda_unit str.str_items in + let loc = of_location ~scopes od.open_loc in let ids = Array.of_list (defined_idents str.str_items) in let ids0 = bound_value_identifiers od.open_bound_items in let subst = !transl_store_subst in let rec store_idents pos = function - | [] -> - transl_store rootpath (add_idents true ids0 subst) cont rem + | [] -> transl_store ~scopes rootpath + (add_idents true ids0 subst) cont rem | id :: idl -> Llet(Alias, Pgenval, id, Lvar ids.(pos), - Lsequence(store_ident od.open_loc id, + Lsequence(store_ident loc id, store_idents (pos + 1) idl)) in Lsequence(lam, Lambda.subst no_env_update subst @@ -1182,30 +1222,31 @@ let transl_store_structure glob map prims aliases str = But since [scan_used_globals] runs before Simplif, we need to do it. *) match od.open_bound_items with - | [] when pure = Alias -> transl_store rootpath subst cont rem + | [] when pure = Alias -> + transl_store ~scopes rootpath subst cont rem | _ -> let ids = bound_value_identifiers od.open_bound_items in let mid = Ident.create_local "open" in - let loc = od.open_loc in + let loc = of_location ~scopes od.open_loc in let rec store_idents pos = function - [] -> - transl_store rootpath (add_idents true ids subst) cont - rem + [] -> transl_store ~scopes rootpath + (add_idents true ids subst) cont rem | id :: idl -> Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid], loc), Lsequence(store_ident loc id, store_idents (pos + 1) idl)) in - Llet(pure, Pgenval, mid, - Lambda.subst no_env_update subst - (transl_module Tcoerce_none None od.open_expr), - store_idents 0 ids) + Llet( + pure, Pgenval, mid, + Lambda.subst no_env_update subst + (transl_module ~scopes Tcoerce_none None od.open_expr), + store_idents 0 ids) end | Tstr_modtype _ | Tstr_class_type _ | Tstr_attribute _ -> - transl_store rootpath subst cont rem + transl_store ~scopes rootpath subst cont rem and store_ident loc id = try @@ -1227,8 +1268,8 @@ let transl_store_structure glob map prims aliases str = Tcoerce_none -> Ident.Map.add id (Lprim(Pfield pos, - [Lprim(Pgetglobal glob, [], Location.none)], - Location.none)) + [Lprim(Pgetglobal glob, [], Loc_unknown)], + Loc_unknown)) subst | _ -> if may_coerce then subst else assert false @@ -1240,23 +1281,23 @@ let transl_store_structure glob map prims aliases str = and store_primitive (pos, prim) cont = Lsequence(Lprim(Psetfield(pos, Pointer, Root_initialization), - [Lprim(Pgetglobal glob, [], Location.none); - Translprim.transl_primitive Location.none + [Lprim(Pgetglobal glob, [], Loc_unknown); + Translprim.transl_primitive Loc_unknown prim.pc_desc prim.pc_env prim.pc_type None], - Location.none), + Loc_unknown), cont) and store_alias (pos, env, path, cc) = - let path_lam = transl_module_path Location.none env path in - let init_val = apply_coercion Location.none Strict cc path_lam in + let path_lam = transl_module_path Loc_unknown env path in + let init_val = apply_coercion Loc_unknown Strict cc path_lam in Lprim(Psetfield(pos, Pointer, Root_initialization), - [Lprim(Pgetglobal glob, [], Location.none); + [Lprim(Pgetglobal glob, [], Loc_unknown); init_val], - Location.none) + Loc_unknown) in let aliases = make_sequence store_alias aliases in List.fold_right store_primitive prims - (transl_store (global_path glob) !transl_store_subst aliases str) + (transl_store ~scopes (global_path glob) !transl_store_subst aliases str) (* Transform a coercion and the list of value identifiers defined by a toplevel structure into a table [id -> (pos, coercion)], @@ -1308,7 +1349,7 @@ let build_ident_map restr idlist more_ids = (* Compile an implementation using transl_store_structure (for the native-code compiler). *) -let transl_store_gen module_name ({ str_items = str }, restr) topl = +let transl_store_gen ~scopes module_name ({ str_items = str }, restr) topl = reset_labels (); primitive_declarations := []; Translprim.clear_used_primitives (); @@ -1318,25 +1359,29 @@ let transl_store_gen module_name ({ str_items = str }, restr) topl = let f = function | [ { str_desc = Tstr_eval (expr, _attrs) } ] when topl -> assert (size = 0); - Lambda.subst (fun _ _ env -> env) !transl_store_subst (transl_exp expr) - | str -> transl_store_structure module_id map prims aliases str + Lambda.subst (fun _ _ env -> env) !transl_store_subst + (transl_exp ~scopes expr) + | str -> transl_store_structure ~scopes module_id map prims aliases str in transl_store_label_init module_id size f str (*size, transl_label_init (transl_store_structure module_id map prims str)*) let transl_store_phrases module_name str = - transl_store_gen module_name (str,Tcoerce_none) true + let scopes = [Sc_module_definition module_name] in + transl_store_gen ~scopes module_name (str,Tcoerce_none) true let transl_store_implementation module_name (str, restr) = let s = !transl_store_subst in transl_store_subst := Ident.Map.empty; - let (i, code) = transl_store_gen module_name (str, restr) false in + let module_ident = Ident.create_persistent module_name in + let scopes = [Sc_module_definition module_name] in + let (i, code) = transl_store_gen ~scopes module_name (str, restr) false in transl_store_subst := s; { Lambda.main_module_block_size = i; code; (* module_ident is not used by closure, but this allow to share the type with the flambda version *) - module_ident = Ident.create_persistent module_name; + module_ident; required_globals = required_globals ~flambda:true code } (* Compile a toplevel phrase *) @@ -1357,21 +1402,23 @@ let toplevel_name id = let toploop_getvalue id = Lapply{ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=Lprim(Pfield toploop_getvalue_pos, - [Lprim(Pgetglobal toploop_ident, [], Location.none)], - Location.none); - ap_args=[Lconst(Const_base(Const_string (toplevel_name id, None)))]; + [Lprim(Pgetglobal toploop_ident, [], Loc_unknown)], + Loc_unknown); + ap_args=[Lconst(Const_base( + Const_string (toplevel_name id, Location.none,None)))]; ap_inlined=Default_inline; ap_specialised=Default_specialise} let toploop_setvalue id lam = Lapply{ap_should_be_tailcall=false; - ap_loc=Location.none; + ap_loc=Loc_unknown; ap_func=Lprim(Pfield toploop_setvalue_pos, - [Lprim(Pgetglobal toploop_ident, [], Location.none)], - Location.none); - ap_args=[Lconst(Const_base(Const_string (toplevel_name id, None))); + [Lprim(Pgetglobal toploop_ident, [], Loc_unknown)], + Loc_unknown); + ap_args=[Lconst(Const_base( + Const_string (toplevel_name id, Location.none, None))); lam]; ap_inlined=Default_inline; ap_specialised=Default_specialise} @@ -1383,7 +1430,7 @@ let close_toplevel_term (lam, ()) = toploop_getvalue id, l)) (free_variables lam) lam -let transl_toplevel_item item = +let transl_toplevel_item ~scopes item = match item.str_desc with Tstr_eval (expr, _) | Tstr_value(Nonrecursive, @@ -1392,10 +1439,10 @@ let transl_toplevel_item item = that Toploop can display the result of the expression. Otherwise, the normal compilation would result in a Lsequence returning unit. *) - transl_exp expr + transl_exp ~scopes expr | Tstr_value(rec_flag, pat_expr_list) -> let idents = let_bound_idents pat_expr_list in - transl_let rec_flag pat_expr_list + transl_let ~scopes ~in_structure:true rec_flag pat_expr_list (make_sequence toploop_setvalue_id idents) | Tstr_typext(tyext) -> let idents = @@ -1404,31 +1451,40 @@ let transl_toplevel_item item = (* we need to use unique name in case of multiple definitions of the same extension constructor in the toplevel *) List.iter set_toplevel_unique_name idents; - transl_type_extension item.str_env None tyext + transl_type_extension ~scopes item.str_env None tyext (make_sequence toploop_setvalue_id idents) | Tstr_exception ext -> set_toplevel_unique_name ext.tyexn_constructor.ext_id; toploop_setvalue ext.tyexn_constructor.ext_id - (transl_extension_constructor item.str_env None ext.tyexn_constructor) + (transl_extension_constructor ~scopes + item.str_env None ext.tyexn_constructor) | Tstr_module {mb_id=None; mb_presence=Mp_present; mb_expr=modl} -> - transl_module Tcoerce_none None modl + transl_module ~scopes Tcoerce_none None modl | Tstr_module {mb_id=Some id; mb_presence=Mp_present; mb_expr=modl} -> (* we need to use the unique name for the module because of issues with "open" (PR#8133) *) set_toplevel_unique_name id; - let lam = transl_module Tcoerce_none (Some(Pident id)) modl in + let lam = transl_module + ~scopes:(enter_module_definition ~scopes id) + Tcoerce_none (Some(Pident id)) modl in toploop_setvalue id lam | Tstr_recmodule bindings -> let idents = List.filter_map (fun mb -> mb.mb_id) bindings in - compile_recmodule + compile_recmodule ~scopes (fun id modl _loc -> - transl_module Tcoerce_none (Option.map (fun i -> Pident i) id) modl) + match id with + | None -> + transl_module ~scopes Tcoerce_none None modl + | Some id -> + transl_module + ~scopes:(enter_module_definition ~scopes id) + Tcoerce_none (Some (Pident id)) modl) bindings (make_sequence toploop_setvalue_id idents) | Tstr_class cl_list -> (* we need to use unique names for the classes because there might be a value named identically *) - let (ids, class_bindings) = transl_class_bindings cl_list in + let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in List.iter set_toplevel_unique_name ids; Lletrec(class_bindings, make_sequence toploop_setvalue_id ids) | Tstr_include incl -> @@ -1440,10 +1496,10 @@ let transl_toplevel_item item = lambda_unit | id :: ids -> Lsequence(toploop_setvalue id - (Lprim(Pfield pos, [Lvar mid], Location.none)), + (Lprim(Pfield pos, [Lvar mid], Loc_unknown)), set_idents (pos + 1) ids) in Llet(Strict, Pgenval, mid, - transl_module Tcoerce_none None modl, set_idents 0 ids) + transl_module ~scopes Tcoerce_none None modl, set_idents 0 ids) | Tstr_primitive descr -> record_primitive descr.val_val; lambda_unit @@ -1463,11 +1519,12 @@ let transl_toplevel_item item = lambda_unit | id :: ids -> Lsequence(toploop_setvalue id - (Lprim(Pfield pos, [Lvar mid], Location.none)), + (Lprim(Pfield pos, [Lvar mid], Loc_unknown)), set_idents (pos + 1) ids) in Llet(pure, Pgenval, mid, - transl_module Tcoerce_none None od.open_expr, set_idents 0 ids) + transl_module ~scopes Tcoerce_none None od.open_expr, + set_idents 0 ids) end | Tstr_modtype _ | Tstr_module {mb_presence=Mp_absent} @@ -1476,20 +1533,20 @@ let transl_toplevel_item item = | Tstr_attribute _ -> lambda_unit -let transl_toplevel_item_and_close itm = +let transl_toplevel_item_and_close ~scopes itm = close_toplevel_term - (transl_label_init (fun () -> transl_toplevel_item itm, ())) + (transl_label_init (fun () -> transl_toplevel_item ~scopes itm, ())) let transl_toplevel_definition str = reset_labels (); Translprim.clear_used_primitives (); - make_sequence transl_toplevel_item_and_close str.str_items + make_sequence (transl_toplevel_item_and_close ~scopes:[]) str.str_items (* Compile the initialization code for a packed library *) let get_component = function None -> Lconst const_unit - | Some id -> Lprim(Pgetglobal id, [], Location.none) + | Some id -> Lprim(Pgetglobal id, [], Loc_unknown) let transl_package_flambda component_names coercion = let size = @@ -1501,18 +1558,18 @@ let transl_package_flambda component_names coercion = | Tcoerce_alias _ -> assert false in size, - apply_coercion Location.none Strict coercion + apply_coercion Loc_unknown Strict coercion (Lprim(Pmakeblock(0, Immutable, None), List.map get_component component_names, - Location.none)) + Loc_unknown)) let transl_package component_names target_name coercion = let components = Lprim(Pmakeblock(0, Immutable, None), - List.map get_component component_names, Location.none) in + List.map get_component component_names, Loc_unknown) in Lprim(Psetglobal target_name, - [apply_coercion Location.none Strict coercion components], - Location.none) + [apply_coercion Loc_unknown Strict coercion components], + Loc_unknown) (* let components = match coercion with @@ -1540,26 +1597,26 @@ let transl_store_package component_names target_name coercion = make_sequence (fun pos id -> Lprim(Psetfield(pos, Pointer, Root_initialization), - [Lprim(Pgetglobal target_name, [], Location.none); + [Lprim(Pgetglobal target_name, [], Loc_unknown); get_component id], - Location.none)) + Loc_unknown)) 0 component_names) | Tcoerce_structure (pos_cc_list, _id_pos_list) -> let components = Lprim(Pmakeblock(0, Immutable, None), List.map get_component component_names, - Location.none) + Loc_unknown) in let blk = Ident.create_local "block" in (List.length pos_cc_list, Llet (Strict, Pgenval, blk, - apply_coercion Location.none Strict coercion components, + apply_coercion Loc_unknown Strict coercion components, make_sequence (fun pos _id -> Lprim(Psetfield(pos, Pointer, Root_initialization), - [Lprim(Pgetglobal target_name, [], Location.none); - Lprim(Pfield pos, [Lvar blk], Location.none)], - Location.none)) + [Lprim(Pgetglobal target_name, [], Loc_unknown); + Lprim(Pfield pos, [Lvar blk], Loc_unknown)], + Loc_unknown)) 0 pos_cc_list)) (* (* ignore id_pos_list as the ids are already bound *) diff --git a/lambda/translobj.ml b/lambda/translobj.ml index ce063538..d7f11bea 100644 --- a/lambda/translobj.ml +++ b/lambda/translobj.ml @@ -117,7 +117,7 @@ let transl_label_init_flambda f = Llet (Strict, Pgenval, method_cache_id, Lprim (Pccall prim_makearray, [int !method_count; int 0], - Location.none), + Loc_unknown), expr) in transl_label_init_general (fun () -> expr, size) @@ -126,19 +126,19 @@ let transl_store_label_init glob size f arg = assert(not Config.flambda); assert(!Clflags.native_code); method_cache := Lprim(Pfield size, - [Lprim(Pgetglobal glob, [], Location.none)], - Location.none); + [Lprim(Pgetglobal glob, [], Loc_unknown)], + Loc_unknown); let expr = f arg in let (size, expr) = if !method_count = 0 then (size, expr) else (size+1, Lsequence( Lprim(Psetfield(size, Pointer, Root_initialization), - [Lprim(Pgetglobal glob, [], Location.none); + [Lprim(Pgetglobal glob, [], Loc_unknown); Lprim (Pccall prim_makearray, [int !method_count; int 0], - Location.none)], - Location.none), + Loc_unknown)], + Loc_unknown), expr)) in let lam, size = transl_label_init_general (fun () -> (expr, size)) in @@ -180,7 +180,7 @@ let oo_wrap env req f x = Llet(StrictOpt, Pgenval, id, Lprim(Pmakeblock(0, Mutable, None), [lambda_unit; lambda_unit; lambda_unit], - Location.none), + Loc_unknown), lambda)) lambda !classes in diff --git a/lambda/translprim.ml b/lambda/translprim.ml index d56002b7..f4cb200e 100644 --- a/lambda/translprim.ml +++ b/lambda/translprim.ml @@ -22,6 +22,7 @@ open Types open Typedtree open Typeopt open Lambda +open Debuginfo.Scoped_location type error = | Unknown_builtin_primitive of string @@ -31,19 +32,19 @@ exception Error of Location.t * error (* Insertion of debugging events *) -let event_before exp lam = match lam with +let event_before loc exp lam = match lam with | Lstaticraise (_,_) -> lam | _ -> if !Clflags.debug && not !Clflags.native_code - then Levent(lam, {lev_loc = exp.exp_loc; + then Levent(lam, {lev_loc = loc; lev_kind = Lev_before; lev_repr = None; lev_env = exp.exp_env}) else lam -let event_after exp lam = +let event_after loc exp lam = if !Clflags.debug && not !Clflags.native_code - then Levent(lam, {lev_loc = exp.exp_loc; + then Levent(lam, {lev_loc = loc; lev_kind = Lev_after exp.exp_type; lev_repr = None; lev_env = exp.exp_env}) @@ -489,10 +490,6 @@ let specialize_primitive env ty ~has_constant_constructor prim = end | _ -> None -let unboxed_compare name native_repr = - Primitive.make ~name ~alloc:false ~native_name:(name^"_unboxed") - ~native_repr_args:[native_repr;native_repr] ~native_repr_res:Untagged_int - let caml_equal = Primitive.simple ~name:"caml_equal" ~arity:2 ~alloc:true let caml_string_equal = @@ -531,21 +528,10 @@ let caml_bytes_greaterthan = Primitive.simple ~name:"caml_bytes_greaterthan" ~arity:2 ~alloc: false let caml_compare = Primitive.simple ~name:"caml_compare" ~arity:2 ~alloc:true -let caml_int_compare = - (* Not unboxed since the comparison is done directly on tagged int *) - Primitive.simple ~name:"caml_int_compare" ~arity:2 ~alloc:false -let caml_float_compare = - unboxed_compare "caml_float_compare" Unboxed_float let caml_string_compare = Primitive.simple ~name:"caml_string_compare" ~arity:2 ~alloc:false let caml_bytes_compare = Primitive.simple ~name:"caml_bytes_compare" ~arity:2 ~alloc:false -let caml_nativeint_compare = - unboxed_compare "caml_nativeint_compare" (Unboxed_integer Pnativeint) -let caml_int32_compare = - unboxed_compare "caml_int32_compare" (Unboxed_integer Pint32) -let caml_int64_compare = - unboxed_compare "caml_int64_compare" (Unboxed_integer Pint64) let comparison_primitive comparison comparison_kind = match comparison, comparison_kind with @@ -598,15 +584,16 @@ let comparison_primitive comparison comparison_kind = | Greater_than, Compare_int32s -> Pbintcomp(Pint32, Cgt) | Greater_than, Compare_int64s -> Pbintcomp(Pint64, Cgt) | Compare, Compare_generic -> Pccall caml_compare - | Compare, Compare_ints -> Pccall caml_int_compare - | Compare, Compare_floats -> Pccall caml_float_compare + | Compare, Compare_ints -> Pcompare_ints + | Compare, Compare_floats -> Pcompare_floats | Compare, Compare_strings -> Pccall caml_string_compare | Compare, Compare_bytes -> Pccall caml_bytes_compare - | Compare, Compare_nativeints -> Pccall caml_nativeint_compare - | Compare, Compare_int32s -> Pccall caml_int32_compare - | Compare, Compare_int64s -> Pccall caml_int64_compare + | Compare, Compare_nativeints -> Pcompare_bints Pnativeint + | Compare, Compare_int32s -> Pcompare_bints Pint32 + | Compare, Compare_int64s -> Pcompare_bints Pint64 let lambda_of_loc kind loc = + let loc = to_location loc in let loc_start = loc.Location.loc_start in let (file, lnum, cnum) = Location.get_pos_info loc_start in let file = @@ -669,7 +656,7 @@ let lambda_of_prim prim_name prim loc args arg_exps = let arg = match arg_exps with | None -> arg - | Some [arg_exp] -> event_after arg_exp arg + | Some [arg_exp] -> event_after loc arg_exp arg | Some _ -> assert false in Lprim(Praise kind, [arg], loc) @@ -678,7 +665,7 @@ let lambda_of_prim prim_name prim loc args arg_exps = let raise_arg = match arg_exps with | None -> Lvar vexn - | Some [exn_exp; _] -> event_after exn_exp (Lvar vexn) + | Some [exn_exp; _] -> event_after loc exn_exp (Lvar vexn) | Some _ -> assert false in Llet(Strict, Pgenval, vexn, exn, @@ -687,7 +674,7 @@ let lambda_of_prim prim_name prim loc args arg_exps = loc), Lprim(Praise Raise_reraise, [raise_arg], loc))) | Lazy_force, [arg] -> - Matching.inline_lazy_force arg Location.none + Matching.inline_lazy_force arg Loc_unknown | Loc kind, [] -> lambda_of_loc kind loc | Loc kind, [arg] -> @@ -702,7 +689,7 @@ let lambda_of_prim prim_name prim loc args arg_exps = | (Raise _ | Raise_with_backtrace | Lazy_force | Loc _ | Primitive _ | Comparison _ | Send | Send_self | Send_cache), _ -> - raise(Error(loc, Wrong_arity_builtin_primitive prim_name)) + raise(Error(to_location loc, Wrong_arity_builtin_primitive prim_name)) let check_primitive_arity loc p = let prim = lookup_primitive loc p in @@ -723,7 +710,7 @@ let check_primitive_arity loc p = (* Eta-expand a primitive *) let transl_primitive loc p env ty path = - let prim = lookup_primitive_and_mark_used loc p env path in + let prim = lookup_primitive_and_mark_used (to_location loc) p env path in let has_constant_constructor = false in let prim = match specialize_primitive env ty ~has_constant_constructor prim with @@ -744,28 +731,53 @@ let transl_primitive loc p env ty path = params; return = Pgenval; attr = default_stub_attribute; - loc = loc; - body = body; } - -(* Determine if a primitive is a Pccall or will be turned later into - a C function call that may raise an exception *) -let primitive_is_ccall = function - | Pccall _ | Pstringrefs | Pbytesrefs | Pbytessets | Parrayrefs _ | - Parraysets _ | Pbigarrayref _ | Pbigarrayset _ | Pduprecord _ | Pdirapply | - Prevapply -> true - | _ -> false + loc; + body; } + +let lambda_primitive_needs_event_after = function + | Prevapply | Pdirapply (* PR#6920 *) + (* We add an event after any primitive resulting in a C call that + may raise an exception or allocate. These are places where we may + collect the call stack. *) + | Pduprecord _ | Pccall _ | Pfloatofint | Pnegfloat | Pabsfloat + | Paddfloat | Psubfloat | Pmulfloat | Pdivfloat | Pstringrefs | Pbytesrefs + | Pbytessets | Pmakearray (Pgenarray, _) | Pduparray _ + | Parrayrefu (Pgenarray | Pfloatarray) | Parraysetu (Pgenarray | Pfloatarray) + | Parrayrefs _ | Parraysets _ | Pbintofint _ | Pcvtbint _ | Pnegbint _ + | Paddbint _ | Psubbint _ | Pmulbint _ | Pdivbint _ | Pmodbint _ | Pandbint _ + | Porbint _ | Pxorbint _ | Plslbint _ | Plsrbint _ | Pasrbint _ | Pbintcomp _ + | Pcompare_bints _ + | Pbigarrayref _ | Pbigarrayset _ | Pbigarraydim _ | Pstring_load_16 _ + | Pstring_load_32 _ | Pstring_load_64 _ | Pbytes_load_16 _ | Pbytes_load_32 _ + | Pbytes_load_64 _ | Pbytes_set_16 _ | Pbytes_set_32 _ | Pbytes_set_64 _ + | Pbigstring_load_16 _ | Pbigstring_load_32 _ | Pbigstring_load_64 _ + | Pbigstring_set_16 _ | Pbigstring_set_32 _ | Pbigstring_set_64 _ + | Pbbswap _ -> true + + | Pidentity | Pbytes_to_string | Pbytes_of_string | Pignore | Psetglobal _ + | Pgetglobal _ | Pmakeblock _ | Pfield _ | Pfield_computed | Psetfield _ + | Psetfield_computed _ | Pfloatfield _ | Psetfloatfield _ | Praise _ + | Psequor | Psequand | Pnot | Pnegint | Paddint | Psubint | Pmulint + | Pdivint _ | Pmodint _ | Pandint | Porint | Pxorint | Plslint | Plsrint + | Pasrint | Pintcomp _ | Poffsetint _ | Poffsetref _ | Pintoffloat + | Pcompare_ints | Pcompare_floats + | Pfloatcomp _ | Pstringlength | Pstringrefu | Pbyteslength | Pbytesrefu + | Pbytessetu | Pmakearray ((Pintarray | Paddrarray | Pfloatarray), _) + | Parraylength _ | Parrayrefu _ | Parraysetu _ | Pisint | Pisout + | Pintofbint _ | Pctconst _ | Pbswap16 | Pint_as_pointer | Popaque -> false (* Determine if a primitive should be surrounded by an "after" debug event *) let primitive_needs_event_after = function - | Primitive (prim,_) -> primitive_is_ccall prim + | Primitive (prim,_) -> lambda_primitive_needs_event_after prim | External _ -> true | Comparison(comp, knd) -> - primitive_is_ccall (comparison_primitive comp knd) + lambda_primitive_needs_event_after (comparison_primitive comp knd) | Lazy_force | Send | Send_self | Send_cache -> true | Raise _ | Raise_with_backtrace | Loc _ -> false let transl_primitive_application loc p env ty path exp args arg_exps = - let prim = lookup_primitive_and_mark_used loc p env (Some path) in + let prim = + lookup_primitive_and_mark_used (to_location loc) p env (Some path) in let has_constant_constructor = match arg_exps with | [_; {exp_desc = Texp_construct(_, {cstr_tag = Cstr_constant _}, _)}] @@ -784,7 +796,7 @@ let transl_primitive_application loc p env ty path exp args arg_exps = if primitive_needs_event_after prim then begin match exp with | None -> lam - | Some exp -> event_after exp lam + | Some exp -> event_after loc exp lam end else begin lam end diff --git a/lambda/translprim.mli b/lambda/translprim.mli index abf0f7d5..aa437014 100644 --- a/lambda/translprim.mli +++ b/lambda/translprim.mli @@ -15,9 +15,11 @@ (* Insertion of debugging events *) -val event_before : Typedtree.expression -> Lambda.lambda -> Lambda.lambda +val event_before : Lambda.scoped_location -> Typedtree.expression + -> Lambda.lambda -> Lambda.lambda -val event_after : Typedtree.expression -> Lambda.lambda -> Lambda.lambda +val event_after : Lambda.scoped_location -> Typedtree.expression + -> Lambda.lambda -> Lambda.lambda (* Translation of primitives *) @@ -27,14 +29,15 @@ val remove_exception_ident : Ident.t -> unit val clear_used_primitives : unit -> unit val get_used_primitives: unit -> Path.t list -val check_primitive_arity : Location.t -> Primitive.description -> unit +val check_primitive_arity : + Location.t -> Primitive.description -> unit val transl_primitive : - Location.t -> Primitive.description -> Env.t -> + Lambda.scoped_location -> Primitive.description -> Env.t -> Types.type_expr -> Path.t option -> Lambda.lambda val transl_primitive_application : - Location.t -> Primitive.description -> Env.t -> + Lambda.scoped_location -> Primitive.description -> Env.t -> Types.type_expr -> Path.t -> Typedtree.expression option -> Lambda.lambda list -> Typedtree.expression list -> Lambda.lambda diff --git a/lex/Makefile b/lex/Makefile index edf6a0c2..5ee94e66 100644 --- a/lex/Makefile +++ b/lex/Makefile @@ -17,8 +17,8 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common CAMLYACC ?= $(ROOTDIR)/yacc/ocamlyacc @@ -50,7 +50,7 @@ ocamllex.opt: $(OBJS:.cmo=.cmx) clean:: rm -f ocamllex ocamllex.opt - rm -f *.cmo *.cmi *.cmx *.cmt *.cmti *.$(O) + rm -f *.cmo *.cmi *.cmx *.cmt *.cmti *.o *.obj parser.ml parser.mli: parser.mly $(CAMLYACC) $(YACCFLAGS) parser.mly diff --git a/lex/lexer.mll b/lex/lexer.mll index ac63aa08..15dbd511 100644 --- a/lex/lexer.mll +++ b/lex/lexer.mll @@ -127,6 +127,11 @@ let identbody = let backslash_escapes = ['\\' '\'' '"' 'n' 't' 'b' 'r' ' '] +let lowercase = ['a'-'z' '_'] +let ident = identstart identbody* +let extattrident = ident ('.' ident)* +let blank = [' ' '\009' '\012'] + rule main = parse [' ' '\013' '\009' '\012' ] + { main lexbuf } @@ -144,7 +149,7 @@ rule main = parse handle_lexical_error comment lexbuf; main lexbuf } | '_' { Tunderscore } - | identstart identbody * + | ident { match Lexing.lexeme lexbuf with "rule" -> Trule | "parse" -> Tparse @@ -270,7 +275,7 @@ and quoted_string delim = parse quoted_string delim lexbuf } | eof { raise (Lexical_error ("unterminated string", "", 0, 0)) } - | '|' (['a'-'z' '_'] * as delim') '}' + | '|' (lowercase* as delim') '}' { if delim <> delim' then quoted_string delim lexbuf } | _ @@ -293,7 +298,7 @@ and comment = parse string lexbuf; reset_string_buffer(); comment lexbuf } - | '{' (['a'-'z' '_'] * as delim) '|' + | '{' ('%' '%'? extattrident blank*)? (lowercase* as delim) "|" { quoted_string delim lexbuf; comment lexbuf } | "'" @@ -304,7 +309,7 @@ and comment = parse | '\010' { incr_loc lexbuf 0; comment lexbuf } - | identstart identbody * + | ident { comment lexbuf } | _ { comment lexbuf } @@ -321,7 +326,7 @@ and action = parse handle_lexical_error string lexbuf; reset_string_buffer(); action lexbuf } - | '{' (['a'-'z' '_'] * as delim) '|' + | '{' ('%' '%'? extattrident blank*)? (lowercase* as delim) "|" { quoted_string delim lexbuf; action lexbuf } | "'" @@ -336,7 +341,7 @@ and action = parse | '\010' { incr_loc lexbuf 0; action lexbuf } - | identstart identbody * + | ident { action lexbuf } | _ { action lexbuf } diff --git a/man/ocamlc.m b/man/ocamlc.m index 6b853009..3f2b387d 100644 --- a/man/ocamlc.m +++ b/man/ocamlc.m @@ -204,17 +204,9 @@ excluding the filename. Show absolute filenames in error messages. .TP .B \-annot -Dump detailed information about the compilation (types, bindings, -tail-calls, etc). The information for file -.IR src .ml -is put into file -.IR src .annot. -In case of a type error, dump all the information inferred by the -type-checker before the error. The -.IR src .annot -file can be used with the emacs commands given in -.B emacs/caml\-types.el -to display types and other annotations interactively. +Deprecated since 4.11. Please use +.BR \-bin-annot +instead. .TP .B \-bin\-annot Dump detailed information about the compilation (types, bindings, @@ -705,7 +697,7 @@ Enable, disable, or mark as fatal the warnings specified by the argument Each warning can be .IR enabled \ or\ disabled , and each warning can be -.IR fatal or +.IR fatal \ or .IR non-fatal . If a warning is disabled, it isn't displayed and doesn't affect compilation in any way (even if it is fatal). If a warning is enabled, @@ -798,7 +790,7 @@ function type and is ignored. \ \ \ Label omitted in function application. 7 -\ \ \ Method overridden without using the "method!" keyword +\ \ \ Method overridden without using the "method!" keyword. 8 \ \ \ Partial match: missing cases in pattern-matching. @@ -951,20 +943,23 @@ mutually recursive types. \ \ Unannotated unboxable type in primitive declaration. 62 -\ \ Type constraint on GADT type declaration +\ \ Type constraint on GADT type declaration. 63 -\ \ Erroneous printed signature +\ \ Erroneous printed signature. 64 -\ \ -unsafe used with a preprocessor returning a syntax tree +\ \ -unsafe used with a preprocessor returning a syntax tree. 65 -\ \ Type declaration defining a new '()' constructor +\ \ Type declaration defining a new '()' constructor. 66 \ \ Unused open! statement. +67 +\ \ Unused functor parameter. + The letters stand for the following sets of warnings. Any letter not mentioned here corresponds to the empty set. diff --git a/man/ocamldep.m b/man/ocamldep.m index dea9b93e..1c39e9d5 100644 --- a/man/ocamldep.m +++ b/man/ocamldep.m @@ -95,6 +95,9 @@ the same .B \-I options that are passed to the compiler. .TP +.B \-nocwd +Do not add current working directory to the list of include directories. +.TP .BI \-impl \ file Process .IR file diff --git a/man/ocamlopt.m b/man/ocamlopt.m index 5c1bc40e..b7f6bb81 100644 --- a/man/ocamlopt.m +++ b/man/ocamlopt.m @@ -167,17 +167,9 @@ excluding the filename. Show absolute filenames in error messages. .TP .B \-annot -Dump detailed information about the compilation (types, bindings, -tail-calls, etc). The information for file -.IR src .ml -is put into file -.IR src .annot. -In case of a type error, dump all the information inferred by the -type-checker before the error. The -.IR src .annot -file can be used with the emacs commands given in -.B emacs/caml\-types.el -to display types and other annotations interactively. +Deprecated since OCaml 4.11. Please use +.BR \-bin-annot +instead. .TP .B \-bin\-annot Dump detailed information about the compilation (types, bindings, @@ -736,6 +728,19 @@ Generate position-independent machine code. This is the default. .B \-fno\-PIC Generate position-dependent machine code. +.SH OPTIONS FOR THE POWER ARCHITECTURE + +The PowerPC code generator supports the following additional options: +.TP +.B \-flarge\-toc +Enables the PowerPC large model allowing the TOC (table of contents) to be +arbitrarily large. This is the default since 4.11. +.TP +.B \-fsmall\-toc +Enables the PowerPC small model allowing the TOC to be up to 64 kbytes per +compilation unit. Prior to 4.11 this was the default behaviour. +\end{options} + .SH OPTIONS FOR THE ARM ARCHITECTURE The ARM code generator supports the following additional options: .TP diff --git a/manual/README.md b/manual/README.md index bf7e3c51..f6640338 100644 --- a/manual/README.md +++ b/manual/README.md @@ -87,6 +87,7 @@ chapters (or sometimes sections) are mapped to a distinct `.etex` file: - Optimisation with Flambda: `flambda.etex` - Memory profiling with Spacetime: `spacetime-chapter.etex` - Fuzzing with afl-fuzz: `afl-fuzz.etex` + - Runtime tracing with the instrumented runtime: `instrumented-runtime.etex` Note that ocamlc,ocamlopt and the toplevel options overlap a lot. Consequently, these options are described together in the file diff --git a/manual/manual/allfiles.etex b/manual/manual/allfiles.etex index 2fb6f8e7..5c8aea8b 100644 --- a/manual/manual/allfiles.etex +++ b/manual/manual/allfiles.etex @@ -22,17 +22,16 @@ \cleardoublepage \setcounter{page}{1} - \begin{htmlonly} \begin{quote} \rule{}{} This manual is also available in -\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman.pdf}{PDF}. -\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman.txt}{plain text}, +\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman.pdf}{PDF}. +\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman.txt}{plain text}, as a -\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman-html.tar.gz}{bundle of HTML files}, +\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman-html.tar.gz}{bundle of HTML files}, and as a -\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman.info.tar.gz}{bundle of Emacs Info files}. +\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman.info.tar.gz}{bundle of Emacs Info files}. \rule{}{} \end{quote} \end{htmlonly} @@ -74,6 +73,7 @@ and as a \input{flambda.tex} \input{spacetime-chapter.tex} \input{afl-fuzz.tex} +\input{instrumented-runtime.tex} \part{The OCaml library} \label{p:library} diff --git a/manual/manual/cmds/Makefile b/manual/manual/cmds/Makefile index 6112a1af..b6522128 100644 --- a/manual/manual/cmds/Makefile +++ b/manual/manual/cmds/Makefile @@ -13,12 +13,12 @@ TRANSF = $(SET_LD_PATH) $(OCAMLRUN) $(TOOLS)/transf FILES = comp.tex top.tex runtime.tex native.tex lexyacc.tex intf-c.tex \ ocamldep.tex profil.tex debugger.tex browser.tex ocamldoc.tex \ warnings-help.tex ocamlbuild.tex flambda.tex spacetime-chapter.tex \ - afl-fuzz.tex unified-options.tex + afl-fuzz.tex instrumented-runtime.tex unified-options.tex WITH_TRANSF = top.tex intf-c.tex flambda.tex spacetime-chapter.tex \ afl-fuzz.tex lexyacc.tex debugger.tex -WITH_CAMLEXAMPLE = ocamldoc.tex +WITH_CAMLEXAMPLE = instrumented-runtime.tex ocamldoc.tex etex-files: $(FILES) diff --git a/manual/manual/cmds/debugger.etex b/manual/manual/cmds/debugger.etex index e9fc6dc0..d964a250 100644 --- a/manual/manual/cmds/debugger.etex +++ b/manual/manual/cmds/debugger.etex @@ -315,7 +315,7 @@ Set a breakpoint at code address \var{frag}":"\var{pc}. The integer \var{frag} is the identifier of a code fragment, a set of modules that have been loaded at once, either initially or with the "Dynlink" module. The integer \var{pc} is the instruction counter within this -code fragment. If \var{frag} is ommited, it defaults to 0, which is +code fragment. If \var{frag} is omitted, it defaults to 0, which is the code fragment of the program loaded initially. \item["delete "\optvar{breakpoint-numbers}] diff --git a/manual/manual/cmds/flambda.etex b/manual/manual/cmds/flambda.etex index 51782fc8..c5b2ac4a 100644 --- a/manual/manual/cmds/flambda.etex +++ b/manual/manual/cmds/flambda.etex @@ -727,7 +727,9 @@ to a function {\em application}, these direct the inliner likewise. These attributes at call sites override any other attribute that may be present on the corresponding declaration. {\machine{\@inlined}} with no argument is equivalent to -{\machine{\@inlined always}}. +{\machine{\@inlined always}}. {\machine{\@\@inlined hint}} is equivalent to +{\machine{\@\@inline always}} except that it will not trigger warning 55 if +the function application cannot be inlined. \end{options} For recursive functions the relevant attributes are: diff --git a/manual/manual/cmds/instrumented-runtime.etex b/manual/manual/cmds/instrumented-runtime.etex new file mode 100644 index 00000000..6826f7c7 --- /dev/null +++ b/manual/manual/cmds/instrumented-runtime.etex @@ -0,0 +1,315 @@ +\chapter{Runtime tracing with the instrumented runtime} +%HEVEA\cutname{instrumented-runtime.html} + +This chapter describes the OCaml instrumented runtime, a runtime variant +allowing the collection of events and metrics. + +Collected metrics include time spent executing the {\em garbage collector}. +The overall execution time of individual pauses are measured +down to the time spent in specific parts of the garbage collection. +Insight is also given on memory allocation and motion by recording +the size of allocated memory blocks, as well as value promotions from the +{\em minor heap} to the {\em major heap}. + +\section{s:instr-runtime-overview}{Overview} + +Once compiled and linked with the instrumented runtime, any OCaml program +can generate {\em trace files} that can then be read +and analyzed by users in order to understand specific runtime behaviors. + +The generated trace files are stored using the {\em Common Trace Format}, which +is a general purpose binary tracing format. +A complete trace consists of: +\begin{itemize} +\item a {\em metadata file}, part of the OCaml distribution +\item and a {\em trace file}, generated by the runtime\ + in the program being traced. +\end{itemize} + +For more information on the {\em Common Trace Format}, see +\href{https://diamon.org/ctf/}{https://diamon.org/ctf/}. + +\section{s:instr-runtime-enabling}{Enabling runtime instrumentation} + + +For the following examples, we will use the following example program: + +\begin{caml_example*}{verbatim} +module SMap = Map.Make(String) + +let s i = String.make 512 (Char.chr (i mod 256)) + +let clear map = SMap.fold (fun k _ m -> SMap.remove k m) map map + +let rec seq i = + if i = 0 then Seq.empty else fun () -> (Seq.Cons (i, seq (i - 1))) + +let () = + seq 1_000_000 + |> Seq.fold_left (fun m i -> SMap.add (s i) i m) SMap.empty + |> clear + |> ignore +\end{caml_example*} + +The next step is to compile and link the program with the instrumented runtime. +This can be done by using the "-runtime-variant" flag: + +\begin{verbatim} + ocamlopt -runtime-variant i program.ml -o program +\end{verbatim} + +Note that the instrumented runtime is an alternative runtime for OCaml +programs. It is only referenced during the linking stage of the final +executable. This means that the compilation stage does not need to be altered +to enable instrumentation. + +The resulting program can then be traced by running it with the environment +variable "OCAML_EVENTLOG_ENABLED": + +\begin{verbatim} + OCAML_EVENTLOG_ENABLED=1 ./program +\end{verbatim} + +During execution, a trace file will be generated in the +program's current working directory. + +\subsubsection*{sss:instr-runtime-build-more}{More build examples} + +When using the {\em dune} build system, this compiler invocation can be +replicated using the {\tt flags} {\tt stanza} when building an executable. + +\begin{verbatim} + (executable + (name program) + (flags "-runtime-variant=i")) +\end{verbatim} + +The instrumented runtime can also be used with the OCaml bytecode interpreter. +This can be done by either using the +"-runtime-variant=i" flag when linking the program with {\tt ocamlc}, or by running the generated +bytecode through {\tt ocamlruni}: + +\begin{verbatim} + ocamlc program.ml -o program.byte + OCAML_EVENTLOG_ENABLED=1 ocamlruni program.byte +\end{verbatim} + +See chapter~\ref{c:camlc} and chapter~\ref{c:runtime} for more information about +{\tt ocamlc} and {\tt ocamlrun}. + +\section{s:instr-runtime-read}{Reading traces} + +Traces generated by the instrumented runtime can be analyzed with tooling +available outside of the OCaml distribution. + +A complete trace consists of a {\em metadata file} and a {\em trace file}. +Two simple ways to work with the traces are the {\em eventlog-tools} and +{\em babeltrace} libraries. + +\subsection{ss:instr-runtime-tools}{eventlog-tools} +{\em eventlog-tools} is a library implementing a parser, as well as a +a set of tools that allows to perform basic format conversions and analysis. + +For more information about {\em eventlog-tools}, refer to the project's +main page: \href{https://github.com/ocaml-multicore/eventlog-tools}{https://github.com/ocaml-multicore/eventlog-tools} + +\subsection{ss:instr-runtime-babeltrace}{babeltrace} + +{\em babeltrace} is a C library, as well as a Python binding and set of tools +that serve as the reference implementation for the {\em Common Trace Format}. +The {\em babeltrace} command line utility allows for a basic rendering +of a trace's content, while the high level Python API can be used to +decode the trace and process them programmatically with libraries +such as {\em numpy} or {\em Jupyter}. + +Unlike {\em eventlog-tools}, which possesses a specific knowledge of +OCaml's {\em Common Trace Format} schema, it is required to provide +the OCaml {\em metadata} file to {\em babeltrace}. + +The metadata file is available in the OCaml installation. +Its location can be obtained using the following command: + +\begin{verbatim} + ocamlc -where +\end{verbatim} + +The {\em eventlog_metadata} file can be found at this path and +copied in the same directory as the generated trace file. +However, {\em babeltrace} expects the file to be named +{\tt metadata} in order to process the trace. +Thus, it will need to be renamed when copied to the trace's directory. + +Here is a naive decoder example, using {\em babeltrace}'s Python +library, and {\em Python 3.8}: + +\begin{verbatim} + +import subprocess +import shutil +import sys +import babeltrace as bt + +def print_event(ev): + print(ev['timestamp']) + print(ev['pid']) + if ev.name == "entry": + print('entry_event') + print(ev['phase']) + if ev.name == "exit": + print('exit_event') + print(ev['phase']) + if ev.name == "alloc": + print(ev['count']) + print(ev['bucket']) + if ev.name == "counter": + print(ev['count']) + print(ev['kind']) + if ev.name == "flush": + print("flush") + +def get_ocaml_dir(): + # Fetching OCaml's installation directory to extract the CTF metadata + ocamlc_where = subprocess.run(['ocamlc', '-where'], stdout=subprocess.PIPE) + ocaml_dir = ocamlc_where.stdout.decode('utf-8').rstrip('\n') + return(ocaml_dir) + +def main(): + trace_dir = sys.argv[1] + ocaml_dir = get_ocaml_dir() + metadata_path = ocaml_dir + "/eventlog_metadata" + # copying the metadata to the trace's directory, + # and renaming it to 'metadata'. + shutil.copyfile(metadata_path, trace_dir + "/metadata") + tr = bt.TraceCollection() + tr.add_trace(trace_dir, 'ctf') + for event in tr.events: + print_event(event) + +if __name__ == '__main__': + main() + +\end{verbatim} + +This script expect to receive as an argument the directory containing the +trace file. It will then copy the {\em CTF} metadata file to the trace's +directory, and then decode the trace, printing each event in the process. + +For more information on {\em babeltrace}, see the website at: +\href{https://babeltrace.org/}{https://babeltrace.org/} + +\section{s:instr-runtime-more}{Controlling instrumentation and limitations} + +\subsection{ss:instr-runtime-prefix}{Trace filename} + +The default trace filename is {\tt caml-\{PID\}.eventlog}, where {\tt \{PID\}} +is the process identifier of the traced program. + +This filename can also be specified using the +"OCAML_EVENTLOG_PREFIX" environment variable. +The given path will be suffixed with {\tt \{.PID\}.eventlog}. + +\begin{verbatim} + OCAML_EVENTLOG_PREFIX=/tmp/a_prefix OCAML_EVENTLOG_ENABLED=1 ./program +\end{verbatim} + +In this example, the trace will be available at path +{\tt /tmp/a_prefix.\{PID\}.eventlog}. + +Note that this will only affect the prefix of the trace file, there is no +option to specify the full effective file name. +This restriction is in place to make room for future improvements to the +instrumented runtime, where the single trace file per session design +may be replaced. + +For scripting purpose, matching against `\{PID\}`, as well as the +{\tt .eventlog} file extension should provide enough control over +the generated files. + +Note as well that parent directories in the given path will not be created +when opening the trace. The runtime assumes the path is +accessible for creating and writing the trace. The program will +fail to start if this requirement isn't met. + +\subsection{ss:instr-runtime-pause}{Pausing and resuming tracing} +Mechanisms are available to control event collection at runtime. + +"OCAML_EVENTLOG_ENABLED" can be set to the {\tt p} flag in order +to start the program with event collection paused. + +\begin{verbatim} + OCAML_EVENTLOG_ENABLED=p ./program +\end{verbatim} + +The program will have to start event collection explicitly. +Starting and stopping event collection programmatically can be done by calling +{\tt Gc.eventlog_resume} and {\tt Gc.eventlog_pause}) from within the program. +Refer to the {\stdmoduleref{Gc}} module documentation for more information. + +Running the program provided earlier with "OCAML_EVENTLOG_ENABLED=p" +will for example yield the following result. + +\begin{verbatim} +$ OCAML_EVENTLOG_ENABLED=p ./program +$ ocaml-eventlog-report caml-{PID}.eventlog +==== eventlog/flush +median flush time: 58ns +total flush time: 58ns +flush count: 1 +\end{verbatim} + +The resulting trace contains only one event payload, namely a {\em flush} event, +indicating how much time was spent flushing the trace file to disk. + +However, if the program is changed to include a call to +{\tt Gc.eventlog_resume}, events payloads can be seen again +in the trace file. + +\begin{caml_example*}{verbatim} + let () = + Gc.eventlog_resume(); + seq 1_000_000 + |> Seq.fold_left (fun m i -> SMap.add (s i) i m) SMap.empty + |> clear + |> ignore + +\end{caml_example*} + +The resulting trace will contain all events encountered during +the program's execution: + +\begin{verbatim} + $ ocaml-eventlog-report caml-{PID}.eventlog + [..omitted..] + ==== force_minor/alloc_small + 100.0K..200.0K: 174 + 20.0K..30.0K: 1 + 0..100: 1 + + ==== eventlog/flush + median flush time: 207.8us + total flush time: 938.1us + flush count: 5 +\end{verbatim} + +\subsection{ss:instr-runtime-limitations}{Limitations} + +The instrumented runtime does not support the {\tt fork} system call. +A child process forked from an instrumented program will not be traced. + +The instrumented runtime aims to provide insight into the runtime's execution +while maintaining a low overhead. +However, this overhead may become more noticeable depending on how a program +executes. +The instrumented runtime currently puts a strong emphasis on +tracing {\em garbage collection} events. This means that programs +with heavy garbage collection activity may be more susceptible to +tracing induced performance penalties. + +While providing an accurate estimate of potential performance loss is difficult, +test on various OCaml programs showed a total running time increase ranging +from 1\% to 8\%. + +For a program with an extended running time where the collection of only a +small sample of events is required, using the {\em eventlog_resume} and +{\em eventlog_pause} primitives may help relieve some of the +tracing induced performance impact. diff --git a/manual/manual/cmds/intf-c.etex b/manual/manual/cmds/intf-c.etex index e95b1801..d7174caa 100644 --- a/manual/manual/cmds/intf-c.etex +++ b/manual/manual/cmds/intf-c.etex @@ -296,10 +296,8 @@ containing the C code. The standard OCaml runtime system "ocamlrun" then loads dynamically these libraries, and resolves references to the required primitives, before executing the bytecode. -This facility is currently supported and known to work well under -Linux, MacOS~X, and Windows. It is supported, but not -fully tested yet, under FreeBSD, Tru64, Solaris and Irix. It is not -supported yet under other Unixes. +This facility is currently available on all platforms supported by +OCaml except Cygwin 64 bits. To dynamically link C code with OCaml code, the C code must first be compiled into a shared library (under Unix) or DLL (under Windows). @@ -436,11 +434,9 @@ defined in the include file "caml/mlvalues.h", along with macros to manipulate values of that type. An object of type "value" is either: \begin{itemize} \item an unboxed integer; -\item a pointer to a block inside the heap (such as the blocks -allocated through one of the \verb"caml_alloc_*" functions below); -\item a pointer to an object outside the heap (e.g., a pointer to a block -allocated by "malloc", or to a C variable). - %%% FIXME will change in 4.02.0 (?) +\item or a pointer to a block inside the heap, +allocated through one of the \verb"caml_alloc_*" functions described +in section~\ref{ss:c-block-allocation}. \end{itemize} \subsection{ss:c-int}{Integer values} @@ -479,21 +475,68 @@ floating-point numbers.} \subsection{ss:c-outside-head}{Pointers outside the heap} -Any word-aligned pointer to an address outside the heap can be safely -cast to and from the type "value". This includes pointers returned by -"malloc", and pointers to C variables (of size at least one word) -obtained with the \verb'&' operator. - %%% FIXME will change in 4.02.0 (?) - -Caution: if a pointer returned by "malloc" is cast to the type "value" -and returned to OCaml, explicit deallocation of the pointer using -"free" is potentially dangerous, because the pointer may still be -accessible from the OCaml world. Worse, the memory space deallocated -by "free" can later be reallocated as part of the OCaml heap; the -pointer, formerly pointing outside the OCaml heap, now points inside -the OCaml heap, and this can crash the garbage collector. To avoid -these problems, it is preferable to wrap the pointer in a OCaml block -with tag "Abstract_tag" or "Custom_tag". +In earlier versions of OCaml, it was possible to use +word-aligned pointers to addresses outside the heap as OCaml values, +just by casting the pointer to type "value". Starting with OCaml +4.11, this usage is deprecated and will stop being supported in OCaml 5.00. + +A correct way to manipulate pointers to out-of-heap blocks from +OCaml is to store those pointers in OCaml blocks with tag +"Abstract_tag" or "Custom_tag", then use the blocks as the OCaml +values. + +Here is an example of encapsulation of out-of-heap pointers of C type +"ty *" inside "Abstract_tag" blocks. Section~\ref{s:c-intf-example} +gives a more complete example using "Custom_tag" blocks. +\begin{verbatim} +/* Create an OCaml value encapsulating the pointer p */ +static value val_of_typtr(ty * p) +{ + value v = caml_alloc(1, Abstract_tag); + *((ty **) Data_abstract_val(v)) = p; + return v; +} + +/* Extract the pointer encapsulated in the given OCaml value */ +static ty * typtr_of_val(value v) +{ + return *((ty **) Data_abstract_val(v)); +} +\end{verbatim} +Alternatively, out-of-heap pointers can be treated as ``native'' +integers, that is, boxed 32-bit integers on a 32-bit platform and +boxed 64-bit integers on a 64-bit platform. +\begin{verbatim} +/* Create an OCaml value encapsulating the pointer p */ +static value val_of_typtr(ty * p) +{ + return caml_copy_nativeint((intnat) p); +} + +/* Extract the pointer encapsulated in the given OCaml value */ +static ty * typtr_of_val(value v) +{ + return (ty *) Nativeint_val(v); +} +\end{verbatim} +For pointers that are at least 2-aligned (the low bit is guaranteed to +be zero), we have yet another valid representation as an OCaml tagged +integer. +\begin{verbatim} +/* Create an OCaml value encapsulating the pointer p */ +static value val_of_typtr(ty * p) +{ + assert (((uintptr_t) p & 1) == 0); /* check correct alignment */ + return (value) p | 1; +} + +/* Extract the pointer encapsulated in the given OCaml value */ +static ty * typtr_of_val(value v) +{ + return (ty *) (v & ~1); +} +\end{verbatim} + \section{s:c-ocaml-datatype-repr}{Representation of OCaml data types} diff --git a/manual/manual/cmds/native.etex b/manual/manual/cmds/native.etex index a9b6bf7d..a923b81c 100644 --- a/manual/manual/cmds/native.etex +++ b/manual/manual/cmds/native.etex @@ -138,6 +138,17 @@ the default. \item["-fno-PIC"] Generate position-dependent machine code. \end{options} +\paragraph{Options for the PowerPC architecture} +The PowerPC code generator supports the following additional options: + +\begin{options} +\item["-flarge-toc"] Enables the PowerPC large model allowing the TOC (table of +contents) to be arbitrarily large. This is the default since 4.11. +\item["-fsmall-toc"] Enables the PowerPC small model allowing the TOC to be up +to 64 kbytes per compilation unit. Prior to 4.11 this was the default +behaviour. +\end{options} + \paragraph{Contextual control of command-line options} The compiler command line can be modified ``from the outside'' diff --git a/manual/manual/cmds/ocamldep.etex b/manual/manual/cmds/ocamldep.etex index 185543c8..93892b74 100644 --- a/manual/manual/cmds/ocamldep.etex +++ b/manual/manual/cmds/ocamldep.etex @@ -65,6 +65,9 @@ and no dependencies are generated. For programs that span multiple directories, it is recommended to pass "ocamldep" the same "-I" options that are passed to the compiler. +\item["-nocwd"] +Do not add current working directory to the list of include directories. + \item["-impl" \var{file}] Process \var{file} as a ".ml" file. diff --git a/manual/manual/cmds/runtime.etex b/manual/manual/cmds/runtime.etex index 0e93eb25..ebaf6a68 100644 --- a/manual/manual/cmds/runtime.etex +++ b/manual/manual/cmds/runtime.etex @@ -137,7 +137,9 @@ The following environment variables are also consulted: \item[o] ("space_overhead") The major GC speed setting. See the Gc module documentation for details. \item[O] ("max_overhead") The heap compaction trigger setting. - \item[l] ("stack_limit") The limit (in words) of the stack size. + \item[l] ("stack_limit") The limit (in words) of the stack size. This is only + relevant to the byte-code runtime, as the native code runtime uses the + operating system's stack. \item[v] ("verbose") What GC messages to print to stderr. This is a sum of values selected from the following: \begin{options} diff --git a/manual/manual/cmds/top.etex b/manual/manual/cmds/top.etex index ed9ac338..f8b3b1f2 100644 --- a/manual/manual/cmds/top.etex +++ b/manual/manual/cmds/top.etex @@ -198,6 +198,10 @@ will result in an ``unbound value "quit"'' error. they were typed on standard input. The reading of the file stops at the first error encountered. + \item["#use_output \""\var{command}"\";;"] + Execute a command and evaluate its output as if it had been captured + to a file and passed to "#use". + \item["#mod_use \""\var{file-name}"\";;"] Similar to "#use" but also wrap the code into a top-level module of the same name as capitalized file name without extensions, following diff --git a/manual/manual/cmds/unified-options.etex b/manual/manual/cmds/unified-options.etex index 68e0c0a6..fe636112 100644 --- a/manual/manual/cmds/unified-options.etex +++ b/manual/manual/cmds/unified-options.etex @@ -61,13 +61,7 @@ command line, unless the "-noautolink" option is given. Force error messages to show absolute paths for file names. \notop{\item["-annot"] -Dump detailed information about the compilation (types, bindings, -tail-calls, etc). The information for file \var{src}".ml" -is put into file \var{src}".annot". In case of a type error, dump -all the information inferred by the type-checker before the error. -The \var{src}".annot" file can be used with the emacs commands given in -"emacs/caml-types.el" to display types and other annotations -interactively. +Deprecated since OCaml 4.11. Please use "-bin-annot" instead. }%notop \item["-args" \var{filename}] @@ -375,6 +369,13 @@ each functor application generates new types in its result and applying the same functor twice to the same argument yields two incompatible structures. +\nat{% +\item["-no-float-const-prop"] +Deactivates the constant propagation for floating-point operations. +This option should be given if the program changes the float rounding +mode during its execution. +}%nat + \item["-noassert"] Do not compile assertion checks. Note that the special form "assert false" is always compiled because it is typed specially. diff --git a/manual/manual/foreword.etex b/manual/manual/foreword.etex index 70817510..c595abe6 100644 --- a/manual/manual/foreword.etex +++ b/manual/manual/foreword.etex @@ -27,7 +27,7 @@ this manual that are specific to one operating system are presented as shown below: \begin{unix} This is material specific to the Unix family of operating -systems, including Linux and \hbox{MacOS~X}. +systems, including Linux and macOS. \end{unix} \begin{windows} This is material specific to Microsoft Windows @@ -67,15 +67,13 @@ The OCaml documentation and user's manual is licensed under a \section*{availability}{Availability} \begin{latexonly} -The complete OCaml distribution can be accessed via the Web -sites \url{http://www.ocaml.org/} and \url{http://caml.inria.fr/}. -The former Web site contains a lot of additional information on OCaml. +The complete OCaml distribution can be accessed via the website +\url{https://ocaml.org/}. This site contains a lot of additional +information on OCaml. \end{latexonly} \begin{htmlonly} The complete OCaml distribution can be accessed via the -\href{http://www.ocaml.org/}{community Caml Web site} and the -\href{http://caml.inria.fr/}{older Caml Web site}. -The \href{http://www.ocaml.org/}{community Caml Web site} -contains a lot of additional information on OCaml. +\href{https://ocaml.org/}{ocaml.org website}. +This site contains a lot of additional information on OCaml. \end{htmlonly} diff --git a/manual/manual/library/core.etex b/manual/manual/library/core.etex index 3d981633..d30f0d4d 100644 --- a/manual/manual/library/core.etex +++ b/manual/manual/library/core.etex @@ -27,7 +27,7 @@ indexed at the end of this report. \section{s:stdlib-module}{Module {\tt Stdlib}: the initially opened module} \begin{links} \item \ahref{libref/Stdlib.html}{Module \texttt{Stdlib}: the initially opened module} -\item \ahref{libref/Pervasives.html}{Module \texttt{Pervasives}: deprecated alias for Stdlib} +\item Module \texttt{Pervasives}: deprecated alias for Stdlib \end{links} \else { diff --git a/manual/manual/macros.hva b/manual/manual/macros.hva index f98139ce..e0a323e0 100644 --- a/manual/manual/macros.hva +++ b/manual/manual/macros.hva @@ -109,7 +109,7 @@ \newstyle{div.ocaml .pre}{ white-space: pre; - font-family:mono; + font-family: monospace; } @@ -208,8 +208,6 @@ \def\versionspecific#1{\begin{quote}\textsf{#1:}\quad} \def\unix{\versionspecific{Unix}} \def\endunix{\end{quote}} -\def\macos{\versionspecific{MacOS~9}} -\def\endmacos{\end{quote}} \def\windows{\versionspecific{Windows}} \def\endwindows{\end{quote}} diff --git a/manual/manual/macros.tex b/manual/manual/macros.tex index 553e6dd5..728f50ee 100644 --- a/manual/manual/macros.tex +++ b/manual/manual/macros.tex @@ -70,8 +70,6 @@ \def\unix{\versionspecific{Unix}} \def\endunix{\end{description}} -%\def\macos{\versionspecific{MacOS 9}} -%\def\endmacos{\end{description}} \def\windows{\versionspecific{Windows}} \def\endwindows{\end{description}} diff --git a/manual/manual/manual.inf b/manual/manual/manual.inf index ed1f50fa..e506905f 100644 --- a/manual/manual/manual.inf +++ b/manual/manual/manual.inf @@ -66,8 +66,6 @@ \def\unix{\versionspecific{Unix}} \def\endunix{\end{quote}} -\def\macos{\versionspecific{MacOS}} -\def\endmacos{\end{quote}} \def\windows{\versionspecific{Windows}} \def\endwindows{\end{quote}} diff --git a/manual/manual/refman/expr.etex b/manual/manual/refman/expr.etex index 1a273733..c51827c0 100644 --- a/manual/manual/refman/expr.etex +++ b/manual/manual/refman/expr.etex @@ -63,24 +63,14 @@ expr: | 'try' expr 'with' pattern-matching | 'let' ['rec'] let-binding { 'and' let-binding } 'in' expr | "let" "exception" constr-decl "in" expr - | 'new' class-path - | 'object' class-body 'end' - | expr '#' method-name - | inst-var-name - | inst-var-name '<-' expr + | 'let' 'module' module-name { '(' module-name ':' module-type ')' } + [ ':' module-type ] \\ '=' module-expr 'in' expr | '(' expr ':>' typexpr ')' | '(' expr ':' typexpr ':>' typexpr ')' - | '{<' [ inst-var-name ['=' expr] { ';' inst-var-name ['=' expr] } [';'] ] '>}' | 'assert' expr | 'lazy' expr - | 'let' 'module' module-name { '(' module-name ':' module-type ')' } - [ ':' module-type ] \\ '=' module-expr 'in' expr - | "let" "open" module-path "in" expr - | module-path '.(' expr ')' - | module-path '.[' expr ']' - | module-path '.[|' expr '|]' - | module-path '.{' expr '}' - | module-path '.{<' expr '>}' + | local-open + | object-expr ; %BEGIN LATEX \end{syntax} \begin{syntax} @@ -111,6 +101,22 @@ parameter: | '?' '(' label-name [':' typexpr] ['=' expr] ')' | '?' label-name ':' pattern | '?' label-name ':' '(' pattern [':' typexpr] ['=' expr] ')' +; +local-open: + | "let" "open" module-path "in" expr + | module-path '.(' expr ')' + | module-path '.[' expr ']' + | module-path '.[|' expr '|]' + | module-path '.{' expr '}' + | module-path '.{<' expr '>}' +; +object-expr: + | 'new' class-path + | 'object' class-body 'end' + | expr '#' method-name + | inst-var-name + | inst-var-name '<-' expr + | '{<' [ inst-var-name ['=' expr] { ';' inst-var-name ['=' expr] } [';'] ] '>}' \end{syntax} See also the following language extensions: \hyperref[s:first-class-modules]{first-class modules}, diff --git a/manual/manual/refman/exten.etex b/manual/manual/refman/exten.etex index 0c012d0a..f894ae01 100644 --- a/manual/manual/refman/exten.etex +++ b/manual/manual/refman/exten.etex @@ -1501,7 +1501,7 @@ It is also possible to specify attributes using an infix syntax. For instance: \begin{verbatim} let[@foo] x = 2 in x + 1 === (let x = 2 [@@foo] in x + 1) -begin[@foo][@bar x] ... end === (begin ... end)[@foo][@@bar x] +begin[@foo][@bar x] ... end === (begin ... end)[@foo][@bar x] module[@foo] M = ... === module M = ... [@@foo] type[@foo] t = T === type t = T [@@foo] method[@foo] m = ... === method m = ... [@@foo] @@ -1512,7 +1512,7 @@ For "let", the attributes are applied to each bindings: \begin{verbatim} let[@foo] x = 2 and y = 3 in x + y === (let x = 2 [@@foo] and y = 3 in x + y) let[@foo] x = 2 -and[@bar] y = 3 in x + y === (let x = 2 [@@foo] and y = 3 [@bar] in x + y) +and[@bar] y = 3 in x + y === (let x = 2 [@@foo] and y = 3 [@@bar] in x + y) \end{verbatim} @@ -1807,10 +1807,18 @@ the attributes are considered to apply to the payload: fun%foo[@bar] x -> x + 1 === [%foo (fun x -> x + 1)[@bar ] ]; \end{verbatim} -Quoted strings "{|...|}" are particularly interesting for payloads -that embed foreign syntax fragments. Those fragments can be interpreted +Furthermore, quoted strings "{|...|}" can be combined with extension nodes +to embed foreign syntax fragments. Those fragments can be interpreted by a preprocessor and turned into OCaml code without requiring escaping -quotes. For instance, you can use "[%sql {|...|}]" to +quotes. A syntax shortcut is available for them: + +\begin{verbatim} +{%%foo|...|} === [%%foo{|...|}] +let x = {%foo|...|} === let x = [%foo{|...|}] +let y = {%foo bar|...|bar} === let y = [%foo{bar|...|bar}] +\end{verbatim} + +For instance, you can use "{%sql|...|}" to represent arbitrary SQL statements -- assuming you have a ppx-rewriter that recognizes the "%sql" extension. diff --git a/manual/manual/refman/types.etex b/manual/manual/refman/types.etex index d2602c6c..0983be69 100644 --- a/manual/manual/refman/types.etex +++ b/manual/manual/refman/types.etex @@ -16,7 +16,7 @@ typexpr: | polymorphic-variant-type | '<' ['..'] '>' | '<' method-type { ';' method-type } [';' || ';' '..'] '>' - | '#' class-path + | '#' classtype-path | typexpr '#' class-path | '(' typexpr { ',' typexpr } ')' '#' class-path ; @@ -215,17 +215,17 @@ literature) that stands for any number of extra method types. \subsubsection*{sss:typexpr-sharp-types}{\#-types} -The type @'#' class-path@ is a special kind of abbreviation. This +The type @'#' classtype-path@ is a special kind of abbreviation. This abbreviation unifies with the type of any object belonging to a subclass -of class @class-path@. +of the class type @classtype-path@. % It is handled in a special way as it usually hides a type variable (an ellipsis, representing the methods that may be added in a subclass). In particular, it vanishes when the ellipsis gets instantiated. % -Each type expression @'#' class-path@ defines a new type variable, so -type @'#' class-path '->' '#' class-path@ is usually not the same as -type @('#' class-path 'as' "'" ident) '->' "'" ident@. +Each type expression @'#' classtype-path@ defines a new type variable, so +type @'#' classtype-path '->' '#' classtype-path@ is usually not the same as +type @('#' classtype-path 'as' "'" ident) '->' "'" ident@. % Use of \#-types to abbreviate polymorphic variant types is deprecated. diff --git a/manual/manual/tutorials/coreexamples.etex b/manual/manual/tutorials/coreexamples.etex index 8f8c8c77..55726aba 100644 --- a/manual/manual/tutorials/coreexamples.etex +++ b/manual/manual/tutorials/coreexamples.etex @@ -941,15 +941,18 @@ source files created for use with OCaml compilers, but can be helpful to mark the end of a top-level expression unambiguously even when there are syntax errors. Here is a -sample standalone program to print Fibonacci numbers: +sample standalone program to print the greatest common divisor +(gcd) of two numbers: \begin{verbatim} -(* File fib.ml *) -let rec fib n = - if n < 2 then 1 else fib (n-1) + fib (n-2);; +(* File gcd.ml *) +let rec gcd a b = + if b = 0 then a + else gcd b (a mod b);; + let main () = - let arg = int_of_string Sys.argv.(1) in - print_int (fib arg); - print_newline (); + let a = int_of_string Sys.argv.(1) in + let b = int_of_string Sys.argv.(2) in + Printf.printf "%d\n" (gcd a b); exit 0;; main ();; \end{verbatim} @@ -958,11 +961,11 @@ parameters. "Sys.argv.(1)" is thus the first command-line parameter. The program above is compiled and executed with the following shell commands: \begin{verbatim} -$ ocamlc -o fib fib.ml -$ ./fib 10 -89 -$ ./fib 20 -10946 +$ ocamlc -o gcd gcd.ml +$ ./gcd 6 9 +3 +$ ./fib 7 11 +1 \end{verbatim} More complex standalone OCaml programs are typically composed of diff --git a/manual/tests/cross_reference_checker.ml b/manual/tests/cross_reference_checker.ml index c451e635..cdf7ed6d 100644 --- a/manual/tests/cross_reference_checker.ml +++ b/manual/tests/cross_reference_checker.ml @@ -141,7 +141,7 @@ module OCaml_refs = struct then None else begin match attr.attr_payload with | PStr [{pstr_desc= Pstr_eval - ({ pexp_desc = Pexp_constant Pconst_string (s,_) },_) } ] -> + ({ pexp_desc = Pexp_constant Pconst_string (s,_,_) },_) } ] -> Some s | _ -> print_error (Wrong_attribute_payload attr.attr_loc); Some "" (* triggers an error *) diff --git a/middle_end/backend_var.ml b/middle_end/backend_var.ml index 39af7f60..5f95d155 100644 --- a/middle_end/backend_var.ml +++ b/middle_end/backend_var.ml @@ -26,14 +26,16 @@ module Provenance = struct } let print ppf { module_path; location; original_ident; } = - Format.fprintf ppf "@[(\ - @[(module_path@ %a)@]@ \ - @[(location@ %a)@]@ \ - @[(original_ident@ %a)@]\ - )@]" - Path.print module_path - Debuginfo.print_compact location - Ident.print original_ident + let printf fmt = Format.fprintf ppf fmt in + printf "@[("; + printf "@[(module_path@ %a)@]@ " + Path.print module_path; + if !Clflags.locations then + printf "@[(location@ %a)@]@ " + Debuginfo.print_compact location; + printf "@[(original_ident@ %a)@]" + Ident.print original_ident; + printf ")@]" let create ~module_path ~location ~original_ident = { module_path; diff --git a/middle_end/clambda_primitives.ml b/middle_end/clambda_primitives.ml index a7c9798f..3dd05879 100644 --- a/middle_end/clambda_primitives.ml +++ b/middle_end/clambda_primitives.ml @@ -53,6 +53,7 @@ type primitive = | Pandint | Porint | Pxorint | Plslint | Plsrint | Pasrint | Pintcomp of integer_comparison + | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer | Poffsetint of int | Poffsetref of int (* Float operations *) diff --git a/middle_end/clambda_primitives.mli b/middle_end/clambda_primitives.mli index d534ca9c..a75cd048 100644 --- a/middle_end/clambda_primitives.mli +++ b/middle_end/clambda_primitives.mli @@ -53,6 +53,7 @@ type primitive = | Pandint | Porint | Pxorint | Plslint | Plsrint | Pasrint | Pintcomp of integer_comparison + | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer | Poffsetint of int | Poffsetref of int (* Float operations *) diff --git a/middle_end/closure/closure.ml b/middle_end/closure/closure.ml index ef657569..4ab57790 100644 --- a/middle_end/closure/closure.ml +++ b/middle_end/closure/closure.ml @@ -697,59 +697,86 @@ let rec substitute loc ((backend, fpc) as st) sb rn ulam = | Uunreachable -> Uunreachable -(* Perform an inline expansion *) +type env = { + backend : (module Backend_intf.S); + cenv : ulambda V.Map.t; + fenv : value_approximation V.Map.t; + mutable_vars : V.Set.t; +} + +(* Perform an inline expansion: + + If [f p = body], substitute [f a] by [let p = a in body]. -let is_simple_argument = function - | Uvar _ | Uconst _ -> true + Under certain conditions, further simplifications are possible (we use the + terminology of [Semantics_of_primitives], applied to terms of the Clambda + language): + + - [f a] is equivalent to [body[a/p]] if [a] has no effects and no coeffects. + However, we only want to do this rewriting if [body[a/p]] does not increase + the size of [body]. Since this is hard to decide in general, as an + approximation, only consider the case when [a] is an immutable variable or + a constant. + + - [f a] is equivalent to [body] if [p] does not occur in [body] and [a] has + only generative effects. + + - In general [f a] is equivalent to [a; body] if [p] does not occur in + [body]. +*) + +(* Approximates "no effects and no coeffects" *) +let is_substituable ~mutable_vars = function + | Uvar v -> not (V.Set.mem v mutable_vars) + | Uconst _ -> true | _ -> false -let no_effects = function +(* Approximates "only generative effects" *) +let is_erasable = function | Uclosure _ -> true | u -> is_pure u -let rec bind_params_rec loc fpc subst params args body = - match (params, args) with - ([], []) -> substitute loc fpc subst (Some Int.Map.empty) body - | (p1 :: pl, a1 :: al) -> - if is_simple_argument a1 then - bind_params_rec loc fpc (V.Map.add (VP.var p1) a1 subst) - pl al body - else begin - let p1' = VP.rename p1 in - let u1, u2 = - match VP.name p1, a1 with - | "*opt*", Uprim(P.Pmakeblock(0, Immutable, kind), [a], dbg) -> - a, Uprim(P.Pmakeblock(0, Immutable, kind), - [Uvar (VP.var p1')], dbg) - | _ -> - a1, Uvar (VP.var p1') - in - let body' = - bind_params_rec loc fpc (V.Map.add (VP.var p1) u2 subst) - pl al body in - if occurs_var (VP.var p1) body then - Ulet(Immutable, Pgenval, p1', u1, body') - else if no_effects a1 then body' - else Usequence(a1, body') - end - | (_, _) -> assert false - -let bind_params loc fpc params args body = +let bind_params { backend; mutable_vars; _ } loc fpc params args body = + let rec aux subst pl al body = + match (pl, al) with + ([], []) -> substitute (Debuginfo.from_location loc) (backend, fpc) + subst (Some Int.Map.empty) body + | (p1 :: pl, a1 :: al) -> + if is_substituable ~mutable_vars a1 then + aux (V.Map.add (VP.var p1) a1 subst) pl al body + else begin + let p1' = VP.rename p1 in + let u1, u2 = + match VP.name p1, a1 with + | "*opt*", Uprim(P.Pmakeblock(0, Immutable, kind), [a], dbg) -> + a, Uprim(P.Pmakeblock(0, Immutable, kind), + [Uvar (VP.var p1')], dbg) + | _ -> + a1, Uvar (VP.var p1') + in + let body' = aux (V.Map.add (VP.var p1) u2 subst) pl al body in + if occurs_var (VP.var p1) body then + Ulet(Immutable, Pgenval, p1', u1, body') + else if is_erasable a1 then body' + else Usequence(a1, body') + end + | (_, _) -> assert false + in (* Reverse parameters and arguments to preserve right-to-left evaluation order (PR#2910). *) - bind_params_rec loc fpc V.Map.empty (List.rev params) (List.rev args) body + aux V.Map.empty (List.rev params) (List.rev args) body (* Check if a lambda term is ``pure'', that is without side-effects *and* not containing function definitions *) let warning_if_forced_inline ~loc ~attribute warning = if attribute = Always_inline then - Location.prerr_warning loc + Location.prerr_warning (Debuginfo.Scoped_location.to_location loc) (Warnings.Inlining_impossible warning) (* Generate a direct application *) -let direct_apply ~backend fundesc ufunct uargs ~loc ~attribute = +let direct_apply env fundesc ufunct uargs ~loc ~attribute = let app_args = if fundesc.fun_closed then uargs else uargs @ [ufunct] in let app = @@ -760,7 +787,7 @@ let direct_apply ~backend fundesc ufunct uargs ~loc ~attribute = "Function information unavailable"; Udirect_apply(fundesc.fun_label, app_args, dbg) | Some(params, body), _ -> - bind_params loc (backend, fundesc.fun_float_const_prop) params app_args + bind_params env loc fundesc.fun_float_const_prop params app_args body in (* If ufunct can contain side-effects or function definitions, @@ -822,12 +849,6 @@ let excessive_function_nesting_depth = 5 exception NotClosed -type env = { - backend : (module Backend_intf.S); - cenv : ulambda V.Map.t; - fenv : value_approximation V.Map.t; -} - let close_approx_var { fenv; cenv } id = let approx = try V.Map.find id fenv with Not_found -> Value_unknown in match approx with @@ -839,7 +860,7 @@ let close_approx_var { fenv; cenv } id = let close_var env id = let (ulam, _app) = close_approx_var env id in ulam -let rec close ({ backend; fenv; cenv } as env) lam = +let rec close ({ backend; fenv; cenv ; mutable_vars } as env) lam = let module B = (val backend : Backend_intf.S) in match lam with | Lvar id -> @@ -862,7 +883,7 @@ let rec close ({ backend; fenv; cenv } as env) lam = str (Uconst_float_array (List.map float_of_string sl)) | Const_immstring s -> str (Uconst_string s) - | Const_base (Const_string (s, _)) -> + | Const_base (Const_string (s, _, _)) -> (* Strings (even literal ones) must be assumed to be mutable... except when OCaml has been configured with -safe-string. Passing -safe-string at compilation @@ -889,12 +910,12 @@ let rec close ({ backend; fenv; cenv } as env) lam = [Uprim(P.Pmakeblock _, uargs, _)]) when List.length uargs = - fundesc.fun_arity -> let app = - direct_apply ~backend ~loc ~attribute fundesc ufunct uargs in + direct_apply env ~loc ~attribute fundesc ufunct uargs in (app, strengthen_approx app approx_res) | ((ufunct, Value_closure(fundesc, approx_res)), uargs) when nargs = fundesc.fun_arity -> let app = - direct_apply ~backend ~loc ~attribute fundesc ufunct uargs in + direct_apply env ~loc ~attribute fundesc ufunct uargs in (app, strengthen_approx app approx_res) | ((ufunct, (Value_closure(fundesc, _) as fapprox)), uargs) @@ -917,7 +938,7 @@ let rec close ({ backend; fenv; cenv } as env) lam = in let funct_var = V.create_local "funct" in let fenv = V.Map.add funct_var fapprox fenv in - let (new_fun, approx) = close { backend; fenv; cenv } + let (new_fun, approx) = close { backend; fenv; cenv; mutable_vars } (Lfunction{ kind = Curried; return = Pgenval; @@ -947,7 +968,7 @@ let rec close ({ backend; fenv; cenv } as env) lam = let dbg = Debuginfo.from_location loc in warning_if_forced_inline ~loc ~attribute "Over-application"; let body = - Ugeneric_apply(direct_apply ~backend ~loc ~attribute + Ugeneric_apply(direct_apply env ~loc ~attribute fundesc ufunct first_args, rem_args, dbg) in @@ -973,14 +994,18 @@ let rec close ({ backend; fenv; cenv } as env) lam = let (ulam, alam) = close_named env id lam in begin match (str, alam) with (Variable, _) -> + let env = {env with mutable_vars = V.Set.add id env.mutable_vars} in let (ubody, abody) = close env body in (Ulet(Mutable, kind, VP.create id, ulam, ubody), abody) | (_, Value_const _) when str = Alias || is_pure ulam -> - close { backend; fenv = (V.Map.add id alam fenv); cenv } body + close { backend; fenv = (V.Map.add id alam fenv); cenv; mutable_vars } + body | (_, _) -> let (ubody, abody) = - close { backend; fenv = (V.Map.add id alam fenv); cenv } body + close + { backend; fenv = (V.Map.add id alam fenv); cenv; mutable_vars } + body in (Ulet(Immutable, kind, VP.create id, ulam, ubody), abody) end @@ -996,14 +1021,15 @@ let rec close ({ backend; fenv; cenv } as env) lam = List.fold_right (fun (id, _pos, approx) fenv -> V.Map.add id approx fenv) infos fenv in - let (ubody, approx) = close { backend; fenv = fenv_body; cenv } body in + let (ubody, approx) = + close { backend; fenv = fenv_body; cenv; mutable_vars } body in let sb = List.fold_right (fun (id, pos, _approx) sb -> V.Map.add id (Uoffset(Uvar clos_ident, pos)) sb) infos V.Map.empty in (Ulet(Immutable, Pgenval, VP.create clos_ident, clos, - substitute Location.none (backend, !Clflags.float_const_prop) sb + substitute Debuginfo.none (backend, !Clflags.float_const_prop) sb None ubody), approx) end else begin @@ -1015,7 +1041,8 @@ let rec close ({ backend; fenv; cenv } as env) lam = let (ulam, approx) = close_named env id lam in ((VP.create id, ulam) :: udefs, V.Map.add id approx fenv_body) in let (udefs, fenv_body) = clos_defs defs in - let (ubody, approx) = close { backend; fenv = fenv_body; cenv } body in + let (ubody, approx) = + close { backend; fenv = fenv_body; cenv; mutable_vars } body in (Uletrec(udefs, ubody), approx) end (* Compile-time constants *) @@ -1184,7 +1211,7 @@ and close_named env id = function (* Build a shared closure for a set of mutually recursive functions *) -and close_functions { backend; fenv; cenv } fun_defs = +and close_functions { backend; fenv; cenv; mutable_vars } fun_defs = let fun_defs = List.flatten (List.map @@ -1256,7 +1283,7 @@ and close_functions { backend; fenv; cenv } fun_defs = V.Map.add id (Uoffset(Uvar env_param, pos - env_pos)) env) uncurried_defs clos_offsets cenv_fv in let (ubody, approx) = - close { backend; fenv = fenv_rec; cenv = cenv_body } body + close { backend; fenv = fenv_rec; cenv = cenv_body; mutable_vars } body in if !useless_env && occurs_var env_param ubody then raise NotClosed; let fun_params = @@ -1291,7 +1318,7 @@ and close_functions { backend; fenv; cenv } fun_defs = in let magic_scale_constant = 8. in int_of_float (inline_threshold *. magic_scale_constant) + n - | Always_inline -> max_int + | Always_inline | Hint_inline -> max_int | Never_inline -> min_int | Unroll _ -> assert false in @@ -1328,7 +1355,9 @@ and close_functions { backend; fenv; cenv } fun_defs = with offsets and approximations. *) let (clos, infos) = List.split clos_info_list in let fv = if !useless_env then [] else fv in - (Uclosure(clos, List.map (close_var { backend; fenv; cenv }) fv), infos) + (Uclosure(clos, + List.map (close_var { backend; fenv; cenv; mutable_vars }) fv), + infos) (* Same, for one non-recursive function *) @@ -1459,7 +1488,8 @@ let intro ~backend ~size lam = global_approx := Array.init size (fun i -> Value_global_field (id, i)); Compilenv.set_global_approx(Value_tuple !global_approx); let (ulam, _approx) = - close { backend; fenv = V.Map.empty; cenv = V.Map.empty } lam + close { backend; fenv = V.Map.empty; + cenv = V.Map.empty; mutable_vars = V.Set.empty } lam in let opaque = !Clflags.opaque diff --git a/middle_end/convert_primitives.ml b/middle_end/convert_primitives.ml index 17d17ea8..4ea17739 100644 --- a/middle_end/convert_primitives.ml +++ b/middle_end/convert_primitives.ml @@ -54,6 +54,9 @@ let convert (prim : Lambda.primitive) : Clambda_primitives.primitive = | Plsrint -> Plsrint | Pasrint -> Pasrint | Pintcomp comp -> Pintcomp comp + | Pcompare_ints -> Pcompare_ints + | Pcompare_floats -> Pcompare_floats + | Pcompare_bints bi -> Pcompare_bints bi | Poffsetint offset -> Poffsetint offset | Poffsetref offset -> Poffsetref offset | Pintoffloat -> Pintoffloat diff --git a/middle_end/flambda/build_export_info.ml b/middle_end/flambda/build_export_info.ml index 67fea2db..2025fedd 100644 --- a/middle_end/flambda/build_export_info.ml +++ b/middle_end/flambda/build_export_info.ml @@ -688,9 +688,8 @@ let build_transient ~(backend : (module Backend_intf.S)) ~root_symbol:(Compilenv.current_unit_symbol ()) in let sets_of_closures = - Set_of_closures_id.Map.filter_map - function_declarations_map - ~f:(fun key (fun_decls : Simple_value_approx.function_declarations) -> + function_declarations_map |> Set_of_closures_id.Map.filter_map + (fun key (fun_decls : Simple_value_approx.function_declarations) -> if Set_of_closures_id.Set.mem key relevant_set_of_closures then Some fun_decls else if begin diff --git a/middle_end/flambda/closure_conversion.ml b/middle_end/flambda/closure_conversion.ml index a89d755e..31da98ac 100644 --- a/middle_end/flambda/closure_conversion.ml +++ b/middle_end/flambda/closure_conversion.ml @@ -115,7 +115,7 @@ let rec declare_const t (const : Lambda.structured_constant) match const with | Const_base (Const_int c) -> (Const (Int c), Names.const_int) | Const_base (Const_char c) -> (Const (Char c), Names.const_char) - | Const_base (Const_string (s, _)) -> + | Const_base (Const_string (s, _, _)) -> let const, name = if Config.safe_string then (Flambda.Allocated_const (Immutable_string s), diff --git a/middle_end/flambda/closure_conversion_aux.ml b/middle_end/flambda/closure_conversion_aux.ml index cfcaf34d..38566c30 100644 --- a/middle_end/flambda/closure_conversion_aux.ml +++ b/middle_end/flambda/closure_conversion_aux.ml @@ -91,7 +91,7 @@ module Function_decls = struct body : Lambda.lambda; free_idents_of_body : Ident.Set.t; attr : Lambda.function_attribute; - loc : Location.t; + loc : Lambda.scoped_location } let create ~let_rec_ident ~closure_bound_var ~kind ~params ~body diff --git a/middle_end/flambda/closure_conversion_aux.mli b/middle_end/flambda/closure_conversion_aux.mli index f16f05f0..633292ec 100644 --- a/middle_end/flambda/closure_conversion_aux.mli +++ b/middle_end/flambda/closure_conversion_aux.mli @@ -59,7 +59,7 @@ module Function_decls : sig -> params:Ident.t list -> body:Lambda.lambda -> attr:Lambda.function_attribute - -> loc:Location.t + -> loc:Lambda.scoped_location -> t val let_rec_ident : t -> Ident.t @@ -71,7 +71,7 @@ module Function_decls : sig val specialise : t -> Lambda.specialise_attribute val is_a_functor : t -> bool val stub : t -> bool - val loc : t -> Location.t + val loc : t -> Lambda.scoped_location (* Like [all_free_idents], but for just one function. *) val free_idents : t -> Ident.Set.t diff --git a/middle_end/flambda/flambda.ml b/middle_end/flambda/flambda.ml index 70adfcb9..2866c697 100644 --- a/middle_end/flambda/flambda.ml +++ b/middle_end/flambda/flambda.ml @@ -202,6 +202,7 @@ let rec lam ppf (flam : t) = match inline with | Always_inline -> fprintf ppf "" | Never_inline -> fprintf ppf "" + | Hint_inline -> fprintf ppf "" | Unroll i -> fprintf ppf "" i | Default_inline -> () in @@ -375,7 +376,7 @@ and print_function_declaration ppf var (f : function_declaration) = in let inline = match f.inline with - | Always_inline -> " *inline*" + | Always_inline | Hint_inline -> " *inline*" | Never_inline -> " *never_inline*" | Unroll _ -> " *unroll*" | Default_inline -> "" @@ -1024,10 +1025,12 @@ let create_function_declaration ~params ~body ~stub ~dbg : function_declaration = begin match stub, inline with | true, (Never_inline | Default_inline) - | false, (Never_inline | Default_inline | Always_inline | Unroll _) -> () - | true, (Always_inline | Unroll _) -> + | false, (Never_inline | Default_inline + | Always_inline | Hint_inline | Unroll _) -> () + | true, (Always_inline | Hint_inline | Unroll _) -> Misc.fatal_errorf - "Stubs may not be annotated as [Always_inline] or [Unroll]: %a" + "Stubs may not be annotated as [Always_inline], \ + [Hint_inline] or [Unroll]: %a" print body end; begin match stub, specialise with diff --git a/middle_end/flambda/flambda_middle_end.ml b/middle_end/flambda/flambda_middle_end.ml index 6330ff12..0675855f 100644 --- a/middle_end/flambda/flambda_middle_end.ml +++ b/middle_end/flambda/flambda_middle_end.ml @@ -169,7 +169,7 @@ let lambda_to_flambda ~ppf_dump ~prefixname ~backend ~size ~filename (* Check that there aren't any unused "always inline" attributes. *) Flambda_iterators.iter_apply_on_program flam ~f:(fun apply -> match apply.inline with - | Default_inline | Never_inline -> () + | Default_inline | Never_inline | Hint_inline -> () | Always_inline -> (* CR-someday mshinwell: consider a different error message if this triggers as a result of the propagation of a user's @@ -183,7 +183,7 @@ let lambda_to_flambda ~ppf_dump ~prefixname ~backend ~size ~filename | Unroll _ -> Location.prerr_warning (Debuginfo.to_location apply.dbg) (Warnings.Inlining_impossible - "[@unroll] attribute was not used on this function \ + "[@unrolled] attribute was not used on this function \ application (the optimizer did not know what function \ was being applied)")); if !Clflags.dump_flambda diff --git a/middle_end/flambda/inline_and_simplify.ml b/middle_end/flambda/inline_and_simplify.ml index b720ae4a..a4b3a568 100644 --- a/middle_end/flambda/inline_and_simplify.ml +++ b/middle_end/flambda/inline_and_simplify.ml @@ -798,9 +798,9 @@ and simplify_partial_application env r ~lhs_of_application on partial applications") | Unroll _ -> Location.prerr_warning (Debuginfo.to_location dbg) - (Warnings.Inlining_impossible "[@unroll] attributes may not be used \ + (Warnings.Inlining_impossible "[@unrolled] attributes may not be used \ on partial applications") - | Default_inline -> () + | Hint_inline | Default_inline -> () end; begin match (specialise_requested : Lambda.specialise_attribute) with | Always_specialise | Never_specialise -> diff --git a/middle_end/flambda/inline_and_simplify_aux.ml b/middle_end/flambda/inline_and_simplify_aux.ml index bb725e8c..ac29db17 100644 --- a/middle_end/flambda/inline_and_simplify_aux.ml +++ b/middle_end/flambda/inline_and_simplify_aux.ml @@ -407,7 +407,7 @@ module Env = struct { t with inlined_debuginfo = dbg } let add_inlined_debuginfo t ~dbg = - Debuginfo.concat t.inlined_debuginfo dbg + Debuginfo.inline t.inlined_debuginfo dbg end let initial_inlining_threshold ~round : Inlining_cost.Threshold.t = @@ -543,7 +543,7 @@ let keep_body_check ~is_classic_mode ~recursive = match fun_decl.inline with | Default_inline -> can_inline_non_rec_function fun_decl | Unroll factor -> factor > 0 - | Always_inline -> true + | Always_inline | Hint_inline -> true | Never_inline -> false end end @@ -573,8 +573,8 @@ let prepare_to_simplify_set_of_closures ~env set_of_closures.free_vars in let specialised_args = - Variable.Map.filter_map set_of_closures.specialised_args - ~f:(fun param (spec_to : Flambda.specialised_to) -> + set_of_closures.specialised_args |> Variable.Map.filter_map + (fun param (spec_to : Flambda.specialised_to) -> let keep = match only_for_function_decl with | None -> true diff --git a/middle_end/flambda/inlining_decision.ml b/middle_end/flambda/inlining_decision.ml index ca462a56..900b2562 100644 --- a/middle_end/flambda/inlining_decision.ml +++ b/middle_end/flambda/inlining_decision.ml @@ -63,11 +63,12 @@ let inline env r ~lhs_of_application (* Merge call site annotation and function annotation. The call site annotation takes precedence *) match (inline_requested : Lambda.inline_attribute) with - | Always_inline | Never_inline | Unroll _ -> inline_requested + | Always_inline | Hint_inline | Never_inline | Unroll _ -> + inline_requested | Default_inline -> function_body.inline in match inline_annotation with - | Always_inline -> false, true, false, env + | Always_inline | Hint_inline -> false, true, false, env | Never_inline -> false, false, true, env | Default_inline -> false, false, false, env | Unroll count -> @@ -493,7 +494,7 @@ let for_call_site ~env ~r ~(function_decls : A.function_declarations) | Some _ -> Default_inline | None -> inline_requested end - | Always_inline | Default_inline | Never_inline -> + | Always_inline | Hint_inline | Default_inline | Never_inline -> inline_requested in let original = diff --git a/middle_end/flambda/simple_value_approx.ml b/middle_end/flambda/simple_value_approx.ml index fcd8e4d7..d527674f 100644 --- a/middle_end/flambda/simple_value_approx.ml +++ b/middle_end/flambda/simple_value_approx.ml @@ -145,7 +145,7 @@ let print_function_declaration ppf var (f : function_declaration) = let is_a_functor = if b.is_a_functor then " *functor*" else "" in let inline = match b.inline with - | Always_inline -> " *inline*" + | Always_inline | Hint_inline -> " *inline*" | Never_inline -> " *never_inline*" | Unroll _ -> " *unroll*" | Default_inline -> "" diff --git a/middle_end/flambda/simplify_boxed_integer_ops.ml b/middle_end/flambda/simplify_boxed_integer_ops.ml index 1f95a1ec..f1a8fab8 100644 --- a/middle_end/flambda/simplify_boxed_integer_ops.ml +++ b/middle_end/flambda/simplify_boxed_integer_ops.ml @@ -79,6 +79,8 @@ end) : Simplify_boxed_integer_ops_intf.S with type t := I.t = struct | Pxorbint kind when equal_kind kind I.kind -> eval I.logxor | Pbintcomp (kind, c) when equal_kind kind I.kind -> S.const_integer_comparison_expr expr c n1 n2 + | Pcompare_bints kind when equal_kind kind I.kind -> + S.const_int_expr expr (I.compare n1 n2) | _ -> expr, A.value_unknown Other, C.Benefit.zero let simplify_binop_int (p : Clambda_primitives.primitive) diff --git a/middle_end/flambda/simplify_primitives.ml b/middle_end/flambda/simplify_primitives.ml index 349d2f40..a228fe82 100644 --- a/middle_end/flambda/simplify_primitives.ml +++ b/middle_end/flambda/simplify_primitives.ml @@ -150,7 +150,7 @@ let primitive (p : Clambda_primitives.primitive) (args, approxs) let a = f 1 let b = f 1 let c = a, a - let d = a, a + let d = b, b If [Share_constants] is run before [f] is completely inlined (assuming [f] always generates the same result; effects of [f] aren't in fact @@ -194,12 +194,14 @@ let primitive (p : Clambda_primitives.primitive) (args, approxs) | Plsrint when shift_precond -> S.const_int_expr expr (x lsr y) | Pasrint when shift_precond -> S.const_int_expr expr (x asr y) | Pintcomp cmp -> S.const_integer_comparison_expr expr cmp x y + | Pcompare_ints -> S.const_int_expr expr (compare x y) | Pisout -> S.const_bool_expr expr (y > x || y < 0) | _ -> expr, A.value_unknown Other, C.Benefit.zero end | [Value_char x; Value_char y] -> begin match p with | Pintcomp cmp -> S.const_integer_comparison_expr expr cmp x y + | Pcompare_ints -> S.const_int_expr expr (Char.compare x y) | _ -> expr, A.value_unknown Other, C.Benefit.zero end | [Value_constptr x] -> @@ -225,6 +227,7 @@ let primitive (p : Clambda_primitives.primitive) (args, approxs) | Pmulfloat -> S.const_float_expr expr (n1 *. n2) | Pdivfloat -> S.const_float_expr expr (n1 /. n2) | Pfloatcomp c -> S.const_float_comparison_expr expr c n1 n2 + | Pcompare_floats -> S.const_int_expr expr (Float.compare n1 n2) | _ -> expr, A.value_unknown Other, C.Benefit.zero end | [A.Value_boxed_int(A.Nativeint, n)] -> diff --git a/middle_end/flambda/un_anf.ml b/middle_end/flambda/un_anf.ml index c9a095b5..7ce8d299 100644 --- a/middle_end/flambda/un_anf.ml +++ b/middle_end/flambda/un_anf.ml @@ -33,8 +33,8 @@ module VP = Backend_var.With_provenance (b) it is never assigned to (using [Uassign]). *) type var_info = - { used : V.Set.t; - linear : V.Set.t; + { used_let_bound_vars : V.Set.t; + linear_let_bound_vars : V.Set.t; assigned : V.Set.t; closure_environment : V.Set.t; let_bound_vars_that_can_be_moved : V.Set.t; @@ -73,36 +73,74 @@ let closure_environment_var (ufunction:Clambda.ufunction) = (* closed function, no environment *) None +type var_uses = + | Zero + | One + | More_than_one + | Assigned + +type var = + { definition_depth : int; + uses : var_uses; } + +let incr_uses { definition_depth; uses } depth = + assert (definition_depth <= depth); + let uses = + match uses with + | Zero -> + if definition_depth < depth then More_than_one + else One + | One -> More_than_one + | More_than_one -> More_than_one + | Assigned -> Assigned + in + { definition_depth; uses } + +let assign_uses r = { r with uses = Assigned } + +let zero definition_depth = { definition_depth; uses = Zero } + +let add_definition t var depth = + V.Tbl.add t var (zero depth) + +let add_use t var depth = + match V.Tbl.find t var with + | info -> V.Tbl.replace t var (incr_uses info depth) + | exception Not_found -> () (* Variable is not let-bound *) + +let add_assignment t var = + match V.Tbl.find t var with + | info -> V.Tbl.replace t var (assign_uses info) + | exception Not_found -> + Misc.fatal_errorf + "make_var_info: Assigned variable %a not let-bound" + V.print var + let make_var_info (clam : Clambda.ulambda) : var_info = - let t : int V.Tbl.t = V.Tbl.create 42 in - let assigned_vars = ref V.Set.empty in + let t : var V.Tbl.t = V.Tbl.create 42 in let environment_vars = ref V.Set.empty in - let rec loop : Clambda.ulambda -> unit = function + let rec loop ~depth : Clambda.ulambda -> unit = function (* No underscores in the pattern match, to reduce the chance of failing to traverse some subexpression. *) - | Uvar var -> - begin match V.Tbl.find t var with - | n -> V.Tbl.replace t var (n + 1) - | exception Not_found -> V.Tbl.add t var 1 - end + | Uvar var -> add_use t var depth | Uconst const -> (* The only variables that might occur in [const] are those in constant closures---and those are all bound by such closures. It follows that [const] cannot contain any variables that are bound in the current scope, so we do not need to count them here. (The function bodies of the closures will be traversed when this function is called from - [Cmmgen.transl_function].) *) + [Flambda_to_clambda.to_clambda_closed_set_of_closures].) *) ignore_uconstant const | Udirect_apply (label, args, dbg) -> ignore_function_label label; - List.iter loop args; + List.iter (loop ~depth) args; ignore_debuginfo dbg | Ugeneric_apply (func, args, dbg) -> - loop func; - List.iter loop args; + loop ~depth func; + List.iter (loop ~depth) args; ignore_debuginfo dbg | Uclosure (functions, captured_variables) -> - List.iter loop captured_variables; + List.iter (loop ~depth) captured_variables; List.iter (fun ( { Clambda. label; arity; params; return; body; dbg; env; } as clos) -> (match closure_environment_var clos with @@ -114,104 +152,98 @@ let make_var_info (clam : Clambda.ulambda) : var_info = ignore_int arity; ignore_params_with_value_kind params; ignore_value_kind return; - loop body; + loop ~depth:(depth + 1) body; ignore_debuginfo dbg; ignore_var_option env) functions | Uoffset (expr, offset) -> - loop expr; + loop ~depth expr; ignore_int offset - | Ulet (_let_kind, _value_kind, _var, def, body) -> - loop def; - loop body + | Ulet (_let_kind, _value_kind, var, def, body) -> + add_definition t (VP.var var) depth; + loop ~depth def; + loop ~depth body | Uphantom_let (var, defining_expr_opt, body) -> ignore_var_with_provenance var; ignore_uphantom_defining_expr_option defining_expr_opt; - loop body + loop ~depth body | Uletrec (defs, body) -> List.iter (fun (var, def) -> ignore_var_with_provenance var; - loop def) + loop ~depth def) defs; - loop body + loop ~depth body | Uprim (prim, args, dbg) -> ignore_primitive prim; - List.iter loop args; + List.iter (loop ~depth) args; ignore_debuginfo dbg | Uswitch (cond, { us_index_consts; us_actions_consts; us_index_blocks; us_actions_blocks }, dbg) -> - loop cond; + loop ~depth cond; ignore_int_array us_index_consts; - Array.iter loop us_actions_consts; + Array.iter (loop ~depth) us_actions_consts; ignore_int_array us_index_blocks; - Array.iter loop us_actions_blocks; + Array.iter (loop ~depth) us_actions_blocks; ignore_debuginfo dbg | Ustringswitch (cond, branches, default) -> - loop cond; + loop ~depth cond; List.iter (fun (str, branch) -> ignore_string str; - loop branch) + loop ~depth branch) branches; - Option.iter loop default + Option.iter (loop ~depth) default | Ustaticfail (static_exn, args) -> ignore_int static_exn; - List.iter loop args + List.iter (loop ~depth) args | Ucatch (static_exn, vars, body, handler) -> ignore_int static_exn; ignore_params_with_value_kind vars; - loop body; - loop handler + loop ~depth body; + loop ~depth handler | Utrywith (body, var, handler) -> - loop body; + loop ~depth body; ignore_var_with_provenance var; - loop handler + loop ~depth handler | Uifthenelse (cond, ifso, ifnot) -> - loop cond; - loop ifso; - loop ifnot + loop ~depth cond; + loop ~depth ifso; + loop ~depth ifnot | Usequence (e1, e2) -> - loop e1; - loop e2 + loop ~depth e1; + loop ~depth e2 | Uwhile (cond, body) -> - loop cond; - loop body + loop ~depth:(depth + 1) cond; + loop ~depth:(depth + 1) body | Ufor (var, low, high, direction_flag, body) -> ignore_var_with_provenance var; - loop low; - loop high; + loop ~depth low; + loop ~depth high; ignore_direction_flag direction_flag; - loop body + loop ~depth:(depth + 1) body | Uassign (var, expr) -> - assigned_vars := V.Set.add var !assigned_vars; - loop expr + add_assignment t var; + loop ~depth expr | Usend (meth_kind, e1, e2, args, dbg) -> ignore_meth_kind meth_kind; - loop e1; - loop e2; - List.iter loop args; + loop ~depth e1; + loop ~depth e2; + List.iter (loop ~depth) args; ignore_debuginfo dbg | Uunreachable -> () in - loop clam; - let linear = - V.Tbl.fold (fun var n acc -> - assert (n >= 1); - if n = 1 && not (V.Set.mem var !assigned_vars) - then V.Set.add var acc - else acc) - t V.Set.empty - in - let assigned = !assigned_vars in - let used = - (* This doesn't work transitively and thus is somewhat restricted. In - particular, it does not allow us to get rid of useless chains of [let]s. - However it should be sufficient to remove the majority of unnecessary - [let] bindings that might hinder [Cmmgen]. *) - V.Tbl.fold (fun var _n acc -> V.Set.add var acc) - t assigned + loop ~depth:0 clam; + let linear_let_bound_vars, used_let_bound_vars, assigned = + V.Tbl.fold (fun var desc ((linear, used, assigned) as acc) -> + match desc.uses with + | Zero -> acc + | One -> (V.Set.add var linear, V.Set.add var used, assigned) + | More_than_one -> (linear, V.Set.add var used, assigned) + | Assigned -> (linear, V.Set.add var used, V.Set.add var assigned)) + t (V.Set.empty, V.Set.empty, V.Set.empty) in - { used; linear; assigned; closure_environment = !environment_vars; + { used_let_bound_vars; linear_let_bound_vars; assigned; + closure_environment = !environment_vars; let_bound_vars_that_can_be_moved = V.Set.empty; } @@ -243,8 +275,8 @@ let let_bound_vars_that_can_be_moved var_info (clam : Clambda.ulambda) = | let_bound_var::let_bound_vars, (Uvar arg)::args when V.same let_bound_var arg && not (V.Set.mem arg var_info.assigned) -> - assert (V.Set.mem arg var_info.used); - assert (V.Set.mem arg var_info.linear); + assert (V.Set.mem arg var_info.used_let_bound_vars); + assert (V.Set.mem arg var_info.linear_let_bound_vars); can_move := V.Set.add arg !can_move; loop let_bound_vars args | _::_, _::_ -> @@ -304,7 +336,7 @@ let let_bound_vars_that_can_be_moved var_info (clam : Clambda.ulambda) = loop body | _ -> loop def; - if V.Set.mem var var_info.linear then begin + if V.Set.mem var var_info.linear_let_bound_vars then begin let_stack := var::!let_stack end else begin (* If we encounter a non-linear [let]-binding then we must clear @@ -657,9 +689,11 @@ let rec un_anf_and_moveable var_info env (clam : Clambda.ulambda) un_anf_and_moveable var_info env def | Ulet (let_kind, value_kind, var, def, body) -> let def, def_moveable = un_anf_and_moveable var_info env def in - let is_linear = V.Set.mem (VP.var var) var_info.linear in - let is_used = V.Set.mem (VP.var var) var_info.used in - let is_assigned = V.Set.mem (VP.var var) var_info.assigned in + let is_linear = V.Set.mem (VP.var var) var_info.linear_let_bound_vars in + let is_used = V.Set.mem (VP.var var) var_info.used_let_bound_vars in + let is_assigned = + V.Set.mem (VP.var var) var_info.assigned + in let maybe_for_debugger (body, moveable) : Clambda.ulambda * moveable = if not !Clflags.debug_full then body, moveable diff --git a/middle_end/flambda/unbox_specialised_args.ml b/middle_end/flambda/unbox_specialised_args.ml index 70eb8760..20d69c1d 100644 --- a/middle_end/flambda/unbox_specialised_args.ml +++ b/middle_end/flambda/unbox_specialised_args.ml @@ -33,8 +33,8 @@ module Transform = struct what_to_specialise else let projections_by_function = - Variable.Map.filter_map set_of_closures.function_decls.funs - ~f:(fun _fun_var (function_decl : Flambda.function_declaration) -> + set_of_closures.function_decls.funs |> Variable.Map.filter_map + (fun _fun_var (function_decl : Flambda.function_declaration) -> if function_decl.stub then None else Some (Extract_projections.from_function_decl ~env diff --git a/middle_end/internal_variable_names.ml b/middle_end/internal_variable_names.ml index b87e73f7..d139dbb2 100644 --- a/middle_end/internal_variable_names.ml +++ b/middle_end/internal_variable_names.ml @@ -123,6 +123,9 @@ let pidentity = "Pidentity" let pignore = "Pignore" let pint_as_pointer = "Pint_as_pointer" let pintcomp = "Pintcomp" +let pcompare_ints = "Pcompare_ints" +let pcompare_floats = "Pcompare_floats" +let pcompare_bints = "Pcompare_bints" let pintofbint = "Pintofbint" let pintoffloat = "Pintoffloat" let pisint = "Pisint" @@ -222,6 +225,9 @@ let pidentity_arg = "Pidentity_arg" let pignore_arg = "Pignore_arg" let pint_as_pointer_arg = "Pint_as_pointer_arg" let pintcomp_arg = "Pintcomp_arg" +let pcompare_ints_arg = "Pcompare_ints_arg" +let pcompare_floats_arg = "Pcompare_floats_arg" +let pcompare_bints_arg = "Pcompare_bints_arg" let pintofbint_arg = "Pintofbint_arg" let pintoffloat_arg = "Pintoffloat_arg" let pisint_arg = "Pisint_arg" @@ -292,7 +298,8 @@ let unbox_free_vars_of_closures = "unbox_free_vars_of_closures" let unit = "unit" let zero = "zero" -let anon_fn_with_loc (loc: Location.t) = +let anon_fn_with_loc (sloc: Lambda.scoped_location) = + let loc = Debuginfo.Scoped_location.to_location sloc in let (file, line, startchar) = Location.get_pos_info loc.loc_start in let endchar = loc.loc_end.pos_cnum - loc.loc_start.pos_bol in let pp_chars ppf = @@ -337,6 +344,9 @@ let of_primitive : Lambda.primitive -> string = function | Plsrint -> plsrint | Pasrint -> pasrint | Pintcomp _ -> pintcomp + | Pcompare_ints -> pcompare_ints + | Pcompare_floats -> pcompare_floats + | Pcompare_bints _ -> pcompare_bints | Poffsetint _ -> poffsetint | Poffsetref _ -> poffsetref | Pintoffloat -> pintoffloat @@ -440,6 +450,9 @@ let of_primitive_arg : Lambda.primitive -> string = function | Plsrint -> plsrint_arg | Pasrint -> pasrint_arg | Pintcomp _ -> pintcomp_arg + | Pcompare_ints -> pcompare_ints_arg + | Pcompare_floats -> pcompare_floats_arg + | Pcompare_bints _ -> pcompare_bints_arg | Poffsetint _ -> poffsetint_arg | Poffsetref _ -> poffsetref_arg | Pintoffloat -> pintoffloat_arg diff --git a/middle_end/internal_variable_names.mli b/middle_end/internal_variable_names.mli index 11a8231e..455ad404 100644 --- a/middle_end/internal_variable_names.mli +++ b/middle_end/internal_variable_names.mli @@ -94,4 +94,4 @@ val of_primitive : Lambda.primitive -> t val of_primitive_arg : Lambda.primitive -> t -val anon_fn_with_loc : Location.t -> t +val anon_fn_with_loc : Lambda.scoped_location -> t diff --git a/middle_end/printclambda_primitives.ml b/middle_end/printclambda_primitives.ml index 3f627063..2e949891 100644 --- a/middle_end/printclambda_primitives.ml +++ b/middle_end/printclambda_primitives.ml @@ -120,6 +120,9 @@ let primitive ppf (prim:Clambda_primitives.primitive) = | Plsrint -> fprintf ppf "lsr" | Pasrint -> fprintf ppf "asr" | Pintcomp(cmp) -> Printlambda.integer_comparison ppf cmp + | Pcompare_ints -> fprintf ppf "compare_ints" + | Pcompare_floats -> fprintf ppf "compare_floats" + | Pcompare_bints bi -> fprintf ppf "compare_bints %s" (boxed_integer_name bi) | Poffsetint n -> fprintf ppf "%i+" n | Poffsetref n -> fprintf ppf "+:=%i"n | Pintoffloat -> fprintf ppf "int_of_float" diff --git a/middle_end/semantics_of_primitives.ml b/middle_end/semantics_of_primitives.ml index 2daf167e..47ed8c3e 100644 --- a/middle_end/semantics_of_primitives.ml +++ b/middle_end/semantics_of_primitives.ml @@ -47,6 +47,8 @@ let for_primitive (prim : Clambda_primitives.primitive) = | Plsrint | Pasrint | Pintcomp _ -> No_effects, No_coeffects + | Pcompare_ints | Pcompare_floats | Pcompare_bints _ + -> No_effects, No_coeffects | Pdivbint { is_safe = Unsafe } | Pmodbint { is_safe = Unsafe } | Pdivint Unsafe diff --git a/ocaml-variants.opam b/ocaml-variants.opam index ac81f897..693432ea 100644 --- a/ocaml-variants.opam +++ b/ocaml-variants.opam @@ -1,8 +1,8 @@ opam-version: "2.0" -version: "4.10.1" +version: "4.11.0" synopsis: "OCaml development version" depends: [ - "ocaml" {= "4.10.1" & post} + "ocaml" {= "4.11.0" & post} "base-unix" {post} "base-bigarray" {post} "base-threads" {post} diff --git a/ocamldoc/Makefile b/ocamldoc/Makefile index 4a6e0fc6..6b7093b6 100644 --- a/ocamldoc/Makefile +++ b/ocamldoc/Makefile @@ -15,8 +15,8 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common include $(ROOTDIR)/Makefile.best_binaries OCAMLRUN ?= $(ROOTDIR)/boot/ocamlrun @@ -185,14 +185,8 @@ LIBCMOFILES = $(CMOFILES) LIBCMXFILES = $(LIBCMOFILES:.cmo=.cmx) LIBCMIFILES = $(LIBCMOFILES:.cmo=.cmi) -ifeq "$(STDLIB_MANPAGES)" "true" -DOCS_TARGET = manpages -else -DOCS_TARGET = -endif - .PHONY: all -all: lib exe generators $(DOCS_TARGET) +all: lib exe generators .PHONY: exe exe: $(OCAMLDOC) @@ -511,12 +505,13 @@ odoc: .PHONY: clean clean: rm -f \#*\# - rm -f $(OCAMLDOC) $(OCAMLDOC_OPT) *.cma *.cmxa *.cmo *.cmi *.cmx *.cmt *.cmti *.$(A) *.$(O) + rm -f $(OCAMLDOC) $(OCAMLDOC_OPT) *.cma *.cmxa *.cmo *.cmi *.cmx *.cmt *.cmti *.a *.lib *.o *.obj rm -f odoc_parser.output odoc_text_parser.output rm -f odoc_lexer.ml odoc_text_lexer.ml odoc_see_lexer.ml odoc_ocamlhtml.ml rm -f odoc_parser.ml odoc_parser.mli odoc_text_parser.ml odoc_text_parser.mli rm -rf stdlib_man stdlib_html stdlib_texi stdlib_latex - rm -f generators/*.cm[taiox] generators/*.$(A) generators/*.$(O) generators/*.cmx[as] + rm -f generators/*.cm[taiox] generators/*.a generators/*.lib generators/*.o generators/*.obj \ + generators/*.cmx[as] .PHONY: depend depend: diff --git a/ocamldoc/Makefile.docfiles b/ocamldoc/Makefile.docfiles index 9b027426..8cf2fd10 100644 --- a/ocamldoc/Makefile.docfiles +++ b/ocamldoc/Makefile.docfiles @@ -15,8 +15,8 @@ # Define the lists of mli file used by ocamldoc to generate the stdlib # + otherlibs + compilerlibs documentation -include $(SRC)/Makefile.config -include $(SRC)/stdlib/StdlibModules +-include $(SRC)/Makefile.config +-include $(SRC)/stdlib/StdlibModules PARSING_MLIS := $(wildcard $(SRC)/parsing/*.mli) UTILS_MLIS := $(wildcard $(SRC)/utils/*.mli) STR_MLIS = $(addprefix $(SRC)/otherlibs/str/, str.mli) @@ -41,10 +41,8 @@ DOC_COMPILERLIBS_INCLUDES = $(addprefix -I $(SRC)/, $(DOC_COMPILERLIBS_DIRS)) DOC_ALL_INCLUDES = $(DOC_STDLIB_INCLUDES) $(DOC_COMPILERLIBS_INCLUDES) -STDLIB_MODS = $(STDLIB_MODULES:stdlib__%=%) - STDLIB_MOD_WP = $(filter-out stdlib__pervasives, $(STDLIB_MODULES)) -STDLIB_MLI0 = $(SRC)/stdlib/pervasives.ml $(STDLIB_MOD_WP:%=$(SRC)/stdlib/%.mli) +STDLIB_MLI0 = $(STDLIB_MOD_WP:%=$(SRC)/stdlib/%.mli) STDLIB_MLIS=\ $(STDLIB_MLI0:$(SRC)/stdlib/stdlib__%=$(SRC)/stdlib/%) \ $(STR_MLIS) \ diff --git a/ocamldoc/odoc_html.ml b/ocamldoc/odoc_html.ml index 8f1fe600..a035f785 100644 --- a/ocamldoc/odoc_html.ml +++ b/ocamldoc/odoc_html.ml @@ -2394,11 +2394,12 @@ class html = (** A method to create index files. *) method generate_elements_index : 'a. - 'a list -> - ('a -> Odoc_info.Name.t) -> - ('a -> Odoc_info.info option) -> - ('a -> string) -> string -> string -> unit = - fun elements name info target title simple_file -> + ?strip_libname:bool -> + 'a list -> + ('a -> Odoc_info.Name.t) -> + ('a -> Odoc_info.info option) -> + ('a -> string) -> string -> string -> unit = + fun ?(strip_libname=false) elements name info target title simple_file -> try let chanout = open_out (Filename.concat !Global.target_dir simple_file) in let b = new_buf () in @@ -2418,7 +2419,10 @@ class html = let f_ele e = let simple_name = Name.simple (name e) in let father_name = Name.father (name e) in - if father_name = "Stdlib" && father_name <> simple_name then + if strip_libname && + !Odoc_global.library_namespace <> "" && + father_name = !Odoc_global.library_namespace && + father_name <> simple_name then (* avoid duplicata *) () else begin @@ -2839,6 +2843,7 @@ class html = (** Generate the modules index in the file [index_modules.html]. *) method generate_modules_index _module_list = self#generate_elements_index + ~strip_libname:true self#list_modules (fun m -> m.m_name) (fun m -> m.m_info) diff --git a/ocamldoc/odoc_sig.ml b/ocamldoc/odoc_sig.ml index b695338e..e7cb90ab 100644 --- a/ocamldoc/odoc_sig.ml +++ b/ocamldoc/odoc_sig.ml @@ -413,7 +413,7 @@ module Analyser = { Typedtree.ld_id; ld_mutable; ld_type; ld_loc; ld_attributes } = get_field env comments @@ {Types.ld_id; ld_mutable; ld_type=ld_type.Typedtree.ctyp_type; - ld_loc; ld_attributes } in + ld_loc; ld_attributes; ld_uid=Types.Uid.internal_not_actually_unique} in let open Typedtree in function | Cstr_tuple l -> diff --git a/ocamltest/Makefile b/ocamltest/Makefile index 4218e6a9..eb7e7587 100644 --- a/ocamltest/Makefile +++ b/ocamltest/Makefile @@ -17,8 +17,8 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common include $(ROOTDIR)/Makefile.best_binaries ifeq "$(filter str,$(OTHERLIBRARIES))" "" @@ -202,19 +202,24 @@ all: ocamltest$(EXE) allopt: ocamltest.opt$(EXE) opt.opt: allopt -ocamltest$(EXE): $(bytecode_modules) - $(ocamlc_cmd) -custom ocamlcommon.cma ocamlbytecomp.cma -o $@ $^ +compdeps_names=ocamlcommon ocamlbytecomp +compdeps_paths=$(addprefix $(ROOTDIR)/compilerlibs/,$(compdeps_names)) +compdeps_byte=$(addsuffix .cma,$(compdeps_paths)) +compdeps_opt=$(addsuffix .cmxa,$(compdeps_paths)) -%.cmo: %.ml +ocamltest$(EXE): $(compdeps_byte) $(bytecode_modules) + $(ocamlc_cmd) -custom -o $@ $^ + +%.cmo: %.ml $(compdeps_byte) $(ocamlc) -c $< -ocamltest.opt$(EXE): $(native_modules) - $(ocamlopt_cmd) ocamlcommon.cmxa ocamlbytecomp.cmxa -o $@ $^ +ocamltest.opt$(EXE): $(compdeps_opt) $(native_modules) + $(ocamlopt_cmd) -o $@ $^ -%.cmx: %.ml +%.cmx: %.ml $(compdeps_opt) $(ocamlopt) -c $< -%.cmi: %.mli +%.cmi: %.mli $(compdeps_byte) $(ocamlc) -c $< %.ml %.mli: %.mly @@ -226,6 +231,7 @@ ocamltest.opt$(EXE): $(native_modules) ocamltest_config.ml: ocamltest_config.ml.in Makefile ../Makefile.config sed \ -e 's|@@AFL_INSTRUMENT@@|$(AFL_INSTRUMENT)|' \ + -e 's|@@RUNTIMEI@@|$(RUNTIMEI)|' \ -e 's|@@ARCH@@|$(ARCH)|' \ -e 's|@@SHARED_LIBRARIES@@|$(SUPPORTS_SHARED_LIBRARIES)|' \ -e 's|@@UNIX@@|$(unix)|' \ @@ -243,6 +249,7 @@ ocamltest_config.ml: ocamltest_config.ml.in Makefile ../Makefile.config -e 's|@@OCAMLDOC@@|$(WITH_OCAMLDOC)|' \ -e 's|@@OCAMLDEBUG@@|$(WITH_OCAMLDEBUG)|' \ -e 's|@@OBJEXT@@|$(O)|' \ + -e 's|@@ASMEXT@@|$(S)|' \ -e 's|@@NATIVE_DYNLINK@@|$(NATDYNLINK)|' \ -e 's|@@SHARED_LIBRARY_CFLAGS@@|$(SHAREDLIB_CFLAGS)|' \ -e 's|@@SHAREDOBJEXT@@|$(SO)|' \ @@ -260,14 +267,26 @@ ocamltest_config.ml: ocamltest_config.ml.in Makefile ../Makefile.config -e 's|@@FUNCTION_SECTIONS@@|$(FUNCTION_SECTIONS)|' \ $< > $@ +# Manual + +.PHONY: doc + +doc: ocamltest.html + +ocamltest.html: ocamltest.org + pandoc -s --toc -N -f org -t html -o $@ $< + .PHONY: clean clean: - rm -rf ocamltest$(EXE) ocamltest.opt$(EXE) - rm -rf $(o_files) $(ocaml_objects) + rm -rf ocamltest ocamltest.exe ocamltest.opt ocamltest.opt.exe + rm -rf $(c_files:.c=.o) $(c_files:.c=.obj) + rm -rf run_unix.o run_win32.o run_win32.obj + rm -rf $(ml_files:.ml=.o) $(ml_files:.ml=.obj) rm -rf $(cmi_files) rm -rf $(cmo_files) rm -rf $(cmx_files) rm -rf $(generated) + rm -f ocamltest.html ifneq "$(TOOLCHAIN)" "msvc" .PHONY: depend diff --git a/ocamltest/builtin_actions.ml b/ocamltest/builtin_actions.ml index 0cb4d925..99059c1c 100644 --- a/ocamltest/builtin_actions.ml +++ b/ocamltest/builtin_actions.ml @@ -62,6 +62,12 @@ let dumpenv = make (fun log env -> Environments.dump log env; (Result.pass, env)) +let hasinstrumentedruntime = make + "hasinstrumentedruntime" + (Actions_helpers.pass_or_skip (Ocamltest_config.has_instrumented_runtime) + "instrumented runtime available" + "instrumented runtime not available") + let hasunix = make "hasunix" (Actions_helpers.pass_or_skip (Ocamltest_config.libunix <> None) @@ -227,6 +233,7 @@ let _ = fail; cd; dumpenv; + hasinstrumentedruntime; hasunix; hassysthreads; hasstr; diff --git a/ocamltest/filecompare.ml b/ocamltest/filecompare.ml index d2e8c310..2e87d0ce 100644 --- a/ocamltest/filecompare.ml +++ b/ocamltest/filecompare.ml @@ -166,13 +166,12 @@ let check_file ?(tool = default_comparison_tool) files = let diff files = let temporary_file = Filename.temp_file "ocamltest" "diff" in - let diff_commandline = String.concat " " - [ - "diff -u"; - files.reference_filename; - files.output_filename; - "> " ^ temporary_file - ] in + let diff_commandline = + Filename.quote_command "diff" ~stdout:temporary_file + [ "-u"; + files.reference_filename; + files.output_filename ] + in let result = if (Sys.command diff_commandline) = 2 then Stdlib.Error "diff" else Ok (Sys.string_of_file temporary_file) diff --git a/ocamltest/main.ml b/ocamltest/main.ml index 2d75b0e4..9d952965 100644 --- a/ocamltest/main.ml +++ b/ocamltest/main.ml @@ -67,20 +67,41 @@ let tsl_block_of_file_safe test_filename = let print_usage () = Printf.printf "%s\n%!" Options.usage +type result_summary = No_failure | Some_failure +let join_summaries sa sb = + match sa, sb with + | Some_failure, _ | _, Some_failure -> Some_failure + | No_failure, No_failure -> No_failure + +let summary_of_result res = + let open Result in + match res.status with + | Pass -> No_failure + | Skip -> No_failure + | Fail -> Some_failure + let rec run_test log common_prefix path behavior = function Node (testenvspec, test, env_modifiers, subtrees) -> Printf.printf "%s %s (%s) => %!" common_prefix path test.Tests.test_name; - let (msg, b) = match behavior with - | Skip_all_tests -> "n/a", Skip_all_tests + let (msg, children_behavior, summary) = match behavior with + | Skip_all_tests -> "n/a", Skip_all_tests, No_failure | Run env -> let testenv0 = interprete_environment_statements env testenvspec in let testenv = List.fold_left apply_modifiers testenv0 env_modifiers in let (result, newenv) = Tests.run log testenv test in - let s = Result.string_of_result result in - if Result.is_pass result then (s, Run newenv) - else (s, Skip_all_tests) in + let msg = Result.string_of_result result in + let children_behavior = + if Result.is_pass result then Run newenv else Skip_all_tests in + let summary = summary_of_result result in + (msg, children_behavior, summary) in Printf.printf "%s\n%!" msg; - List.iteri (run_test_i log common_prefix path b) subtrees + join_summaries summary + (run_test_trees log common_prefix path children_behavior subtrees) + +and run_test_trees log common_prefix path behavior trees = + List.fold_left join_summaries No_failure + (List.mapi (run_test_i log common_prefix path behavior) trees) + and run_test_i log common_prefix path behavior i test_tree = let path_prefix = if path="" then "" else path ^ "." in let new_path = Printf.sprintf "%s%d" path_prefix (i+1) in @@ -133,9 +154,14 @@ let test_file test_filename = let hookname_prefix = Filename.concat test_source_directory test_prefix in let test_build_directory_prefix = get_test_build_directory_prefix test_directory in - ignore (Sys.command ("rm -rf " ^ test_build_directory_prefix)); + let clean_test_build_directory () = + ignore + (Sys.command + (Filename.quote_command "rm" ["-rf"; test_build_directory_prefix])) + in + clean_test_build_directory (); Sys.make_directory test_build_directory_prefix; - Sys.with_chdir test_build_directory_prefix + let summary = Sys.with_chdir test_build_directory_prefix (fun () -> let log = if !Options.log_to_stderr then stderr else begin @@ -172,14 +198,20 @@ let test_file test_filename = let initial_status = if skip_test then Skip_all_tests else Run rootenv in - List.iteri - (run_test_i log common_prefix "" initial_status) - test_trees; + let summary = + run_test_trees log common_prefix "" initial_status test_trees in Actions.clear_all_hooks(); - if not !Options.log_to_stderr then close_out log - ); + if not !Options.log_to_stderr then close_out log; + summary + ) in (* Restore current working directory *) - Sys.chdir cwd + Sys.chdir cwd; + begin match summary with + | Some_failure -> () + | No_failure -> + if not !Options.keep_test_dir_on_success then + clean_test_build_directory () + end let is_test s = match tsl_block_of_file s with diff --git a/ocamltest/ocaml_actions.ml b/ocamltest/ocaml_actions.ml index 4586ccee..8334c43a 100644 --- a/ocamltest/ocaml_actions.ml +++ b/ocamltest/ocaml_actions.ml @@ -1124,6 +1124,7 @@ let config_variables _log env = Ocaml_variables.shared_library_cflags, Ocamltest_config.shared_library_cflags; Ocaml_variables.objext, Ocamltest_config.objext; + Ocaml_variables.asmext, Ocamltest_config.asmext; Ocaml_variables.sharedobjext, Ocamltest_config.sharedobjext; Ocaml_variables.ocamlc_default_flags, Ocamltest_config.ocamlc_default_flags; diff --git a/ocamltest/ocaml_modifiers.ml b/ocamltest/ocaml_modifiers.ml index cfa4fbcf..c310cf36 100644 --- a/ocamltest/ocaml_modifiers.ml +++ b/ocamltest/ocaml_modifiers.ml @@ -97,15 +97,24 @@ let systhreads = let compilerlibs_subdirs = [ - "utils"; "parsing"; "toplevel"; "typing"; "bytecomp"; "compilerlibs"; - "file_formats"; "lambda"; + "asmcomp"; + "bytecomp"; + "compilerlibs"; + "driver"; + "file_formats"; + "lambda"; + "middle_end"; + "parsing"; + "toplevel"; + "typing"; + "utils"; ] let add_compiler_subdir subdir = Append (Ocaml_variables.directories, (wrap (compiler_subdir [subdir]))) -let ocamlcommon = - (Append (Ocaml_variables.libraries, wrap "ocamlcommon")) :: +let compilerlibs_archive archive = + (Append (Ocaml_variables.libraries, wrap archive)) :: (List.map add_compiler_subdir compilerlibs_subdirs) let debugger = [add_compiler_subdir "debugger"] @@ -117,7 +126,15 @@ let _ = register_modifiers "unix" unix; register_modifiers "dynlink" dynlink; register_modifiers "str" str; - register_modifiers "ocamlcommon" ocamlcommon; + List.iter + (fun archive -> register_modifiers archive (compilerlibs_archive archive)) + [ + "ocamlcommon"; + "ocamlbytecomp"; + "ocamlmiddleend"; + "ocamloptcomp"; + "ocamltoplevel"; + ]; register_modifiers "systhreads" systhreads; register_modifiers "latex" latex; register_modifiers "html" html; diff --git a/ocamltest/ocaml_variables.ml b/ocamltest/ocaml_variables.ml index bfe69d8a..b9515629 100644 --- a/ocamltest/ocaml_variables.ml +++ b/ocamltest/ocaml_variables.ml @@ -120,6 +120,9 @@ let nativecc_libs = make ("nativecc_libs", let objext = make ("objext", "Extension of object files") +let asmext = make ("asmext", + "Extension of assembly files") + let ocamlc_byte = make ("ocamlc_byte", "Path of the ocamlc.byte executable") @@ -254,6 +257,7 @@ let _ = List.iter register_variable modules; nativecc_libs; objext; + asmext; ocamlc_byte; ocamlopt_byte; ocamlrun; diff --git a/ocamltest/ocaml_variables.mli b/ocamltest/ocaml_variables.mli index 647fd4f1..89686de1 100644 --- a/ocamltest/ocaml_variables.mli +++ b/ocamltest/ocaml_variables.mli @@ -74,6 +74,7 @@ val nativecc_libs : Variables.t (** Libraries to link with for native code *) val objext : Variables.t +val asmext : Variables.t val ocamlc_byte : Variables.t val ocamlopt_byte : Variables.t diff --git a/ocamltest/ocamltest.org b/ocamltest/ocamltest.org new file mode 100644 index 00000000..20651fc7 --- /dev/null +++ b/ocamltest/ocamltest.org @@ -0,0 +1,745 @@ +#+STARTUP: showall + +#+title: The ocamltest reference manual +#+language: en + +#+HTML_HEAD: + +* Introduction + +This is =verbatim= and this is ~code~. + +** What is ocamltest + +ocamltest is a test-driver, that is, a program that can run tests and report +their results so that they can be used by a test infrastructure. + +Originally, the tool has been designed specifically to run the integration +tests of the OCaml compiler's test suite. However, it has been +designed with extensibility in mind and thus has a plugin +mechanism that makes it possible to extend it with other tests. + +** Design choices + +*** Programming language and external dependencies + +For a start, one may wonder in which language a test-driver for a compiler +should be written. It may indeed seem odd to write a test-driver for a +compiler in the language it compiles, since the compiler itself +is yet untested and thus not trustworthy. + +It can however be observed that the OCaml compiler is /bootstraped/, +meaning that it is itself written in OCaml. A newer version of the +compiler can thus be produced from an existing one and the (OCaml) +source code of that newer version. Practically, this means that the +compiler works at least well enough to recompile itself. This is why we +consider that it is okay to write a test-driver like ocamltest in OCaml, +as long as it uses only code that has been used to bootstrap the +compiler. In particular, this is why we prefer not to rely on any +external dependency, not even the libraries included in the compiler +distribution such as the =Unix= library. + +*** Test types + +As has been noted above, ocamltest has been developed to run the already +existing integration tests of the OCaml compiler's test suite, which +were previously run by a set of makefiles. This context explains +several design decisions which could otherwise seem rather arbitrary. + +For example, the reason why ocamltest has no support for running unit tests +is that there were no such tests in the OCaml compiler's test suite. + +Indeed, the OCaml compiler's test suite is composed mainly of complete +programs. In this context, the most current meaning of "testing" a program +is that the program needs to be compiled and executed. The test will +be considered successful if the program compiles as expected and, when run, +returns the expected value. + +Since this scenario is the most frequent one, it was of particular +importance to make writing tests of this form as simple as possible. + +However, not all tests fall into the previously described category, so it is +also necessary to support not only variations on the previous scenario +(compile but do not run, compile with certain options, etc.) but also +completely different tests, such as top-level tests, debugger tests, +etc. + +To fulfill these requirements and make it as easy as possible to turn a +program into a test, it has been chosen to design a Domain-Specific +Language (DSL) used to annotate the test program with a +=(* TEST *)= block at its top. This block specifies how the test +should be performed. + +** Outline of this document + +The next chapter explains through examples how to write simple tests. We +then introduce the key concepts used by ocamltest to provide a better +understanding of how it works and can be used to write more complex +tests. The two last chapters give an in-depth description of the +built-in tests and actions and of the tests and actions that are specific +to the OCaml compiler. + +* Writing simple tests + +This chapter is a tutorial. It explains how to write simple test +programs and also tries to give insights about how ocamltest works. These +insights will be deepened in chapter [[#concepts]] where ocamltest is +presented in a more abstract and conceptual way. + +We start by explaining how to set-up a proper environment for writing +tests. We then show how to turn the traditional "Hello, world!" program +into a test and explain how to run it with ocamltest. We continue +with a few variations on this test and conclude this chapter +with a few other useful tests. + +** Prerequisites for writing tests + +Writing tests requires that the sources of the OCaml compiler for which +one wants to write them are downloaded and compiled. The compiler +does not need to be installed, though. + +The sources can be downloaded either as an archive, or directly cloned +through git, which seems more appropriate in the context of writing ones +own tests. Refer to +=INSTALL.adoc= (and also to =README.win32.adoc= if you are on Windows) to +learn how to get the sources of the OCaml compiler and to compile them. + +In the remainder of this manual, we will assume that the sources of the +OCaml compiler have been extracted in the =${OCAMLSRCDIR}= directory (for +instance =${HOME}/src/ocaml=) and that you have successfully configured +and compiled them as described in =INSTALL.adoc= or =README.win32.adoc=, +according to your operating system. The tools and libraries necessary +for running tests should also be built. This can be achieved by running +the following command from =${OCAMLSRCDIR}=: +: make -C testsuite lib tools + +We will also assume that an =ocamltest= command is available in +your =PATH=. Although this is not strictly necessary, it is strongly +recommended that you set this up because this will simplify test +development a lot. This can be achieved e.g. by creating a symbolic +link to =${OCAMLSRCDIR}/ocamltest/ocamltest= (or its native +counterpart =${OCAMLSRCDIR}/ocamltest/ocamltest.opt=) in a directory that +is already in your =PATH=, like =~/bin=. + +** Testing the "Hello, world!" program with the default tests + +*** Turning "Hello, world!" into a useful test program + +Consider the following OCaml implementation of the classical "Hello, world!" +program written to a =hello.ml= file: + +: let _ = print_endline "Hello, world!" + +Now assume we would like to make sure that the OCaml compiler can +compile this program and that the resulting executable indeed prints the +expected output. Here are the required steps to turn the program +above into a test usable by ocamltest to verify this: + +1. First, we add a special comment at the very beginning of our =hello.ml= + file to make it explicit that it is a test: + #+begin_src + (* TEST *) + + let _ = print_endline "Hello, world!" + #+end_src + +2. We then need to say what the expected outputs are. In our case, we + expect that compiling the test produces no output at all and that its + execution produces one single line: + : Hello, world! + To let ocamltest know about this, we create a =hello.reference= file + containing the program's expected output -- the line mentioned + above. There is nothing special to do for silent compilations + since this is what is expected by default and a non-silent + compilation would actually cause a test failure. + +3. We can now ask ocamltest to run our test program with the + following command: + : ocamltest hello.ml + + Running this would produce an output similar to this one: + + #+begin_src + ... testing 'hello.ml' with 1 (native) => passed + ... testing 'hello.ml' with 2 (bytecode) => passed + #+end_src + + In addition to this output, it may be noticed that the previous + command has also created an =_ocamltest= directory whose content will + be examined in the next sub-section. + +4. Finally, there is one extra step required if we want our newly created + test to be run automatically as part of the OCaml compiler's test suite. + We need to move =hello.ml= and =hello.reference= to a directory (say + =newtest=) located somewhere + below =testsuite/tests= in the compiler's source tree and we + need to declare the test. This is done by appending the name of the + file containing the =(* TEST *)= comment to an =ocamltests= + (mark the final s) file located in the =newtest= directory, + alongside the other files relevant to the test. Once this is done, + the command + : make all + executed in the =testsuite= directory of the OCaml compiler' source + tree will run all the test suite, which now also includes our own test. + +*** What exactly is going on during the test + +The only thing we know from ocamltest's output when run on =hello.ml= is +that it is running two tests named =bytecode= and =native= and that the two of +them succeed. This can seem rather uninformative, and in a way it is, but +it has to be kept in mind that this information is the one passed by the +test-driver (ocamltest) to the test infrastructure. In that respect, +this is enough. For us users, though, it is not. That's why +ocamltest logs much more details about what is going on in a per-test +log file, which should be located in the =_ocamltest/hello/hello.log= file +found in the directory where =hello.ml= is. + +Before looking at this log file, notice that it has been created in a +test-specific directory. ocamltest creates such a directory for each +file it tests and makes sure every file produced as a result of +testing this file will be placed in this directory, either directly, or +in one of its sub-directories. The latter happens if the test has +to be compiled several times, with the same compiler and different +command-line options, or with different compilers. In particular, +in order to better understand what follows, it may be helpful to +remember that =OCaml= actually consists in not less than four compilers: +=ocamlc.byte= and =ocamlc.opt= which are the bytecode and native +flavors of the bytecode compiler and =ocamlopt.byte= and +=ocamlopt.opt= which are the bytecode and native flavors of the native +compiler. So, as we will see, ''testing the bytecode compiler'' +actually involves testing two compilers, and the same goes for ''testing +the native compiler''. + +Now that all this has been spelled out, let's examine the log file +produced by the test. Although it is too long to be reproduced here, +it is recommended to go through it quickly to get an idea of its +structure. Here is how it starts: + +#+begin_src +Specified modules: hello.ml +Source modules: hello.ml +#+end_src + +The first line lists the names of the modules the test consists of. The +second line is almost similar but if some modules had separate +interface files, they would be listed here, too, without the user +having to specify them in the list of modules (for each specified =.ml= +file, ocamltest looks whether a corresponding =.mli= file exists and, if +so, adds it to the list of files to consider). + +The rest of the log file can be split into two parts which are very +similar to each other: one for the =native= test and one for the =bytecode= +test. Among other things, we learn that each of these tests is composed +of nine actions. Before diving into the details of what each of these +actions does, let us take this opportunity to introduce a bit of +ocamltest terminology. An /action/ is anything that can =pass=, =skip= or +=fail=. A =test= is a sequence of such actions. Running +a test thus means running each of its actions, in sequence, until all the +actions have been run or one of them returns =pass= or =skip=. Whatever +the last run action returns, this value will be the result of the whole +test. + +To give concrete examples of actions, let's briefly go over the nine ones +involved in the =bytecode= test (those for the =native= test are +quite similar): + +1. =setup-ocamlc.byte-build-env=:: as its name suggests, this action + creates a build environment where a program can be compiled and + executed using the =ocamlc.byte= compiler. More precisely, this + involves creating a dedicated directory under the test-file specific + directory and populating it with the files required by subsequent actions. + Depending on what the underlying operating system supports, the files + will be either symlinked or copied from the test source directory. + +2. =ocamlc.byte=:: invokes the =ocamlc.byte= compiler in various ways. + Here, the test program is compiled and linked, but as we will see + later, different behaviors are possible depending on ocamltest + /variables/. + +3. =check-ocamlc.byte-output=:: this action compares the compiler's + output to a reference file, if one exists. As has been mentioned + earlier, the absence of such a reference file specifies that the + compiler's output is expected to be empty -- if it is not, this + causes a failure of this action and thus of the whole =bytecode= + test. + +4. =run=:: now that the program has been successfully compiled, it is + run with its standard output and error streams saved to a file. + + +5. =check-program-output=:: this time it is the output of the program + which is compared to a reference file, namely the =hello.reference= + file created earlier. So far this comparison succeeds, because the + output of the program is identical to the reference file but, as an + exercise, one may try to modify the reference file to see how this + causes the failure of this action and of the whole =bytecode= test. + + This action concludes the test of the =ocamlc.byte= compiler. We now + know that it is able to successfully compile our test program and that + the resulting executable runs as expected. The four remaining actions + are going to test the =ocamlc.opt= compiler in a similar but not + identical way: + +6. =setup-ocamlc.opt-build-env=:: this action is the counterpart of + action 1 for the =ocamlc.opt= compiler. + +7. =ocamlc.opt=:: like action 2, this action compiles the test program + but with the =ocamlc.opt= compiler. + +8. =check-ocamlc.opt-output=:: again, this action is similar to + action 3. + +9. =compare-bytecode-programs=:: here we make sure that the generated + executable is correct, but in a different way than for the + =ocamlc.byte= compiler. Rather than running it and checking its + output, we compare it to the one produced in action 2. Such a check + may seem strange, because what it requires is that =ocamlc.byte= and + =ocamlc.opt= produce exactly the same binary and not two binaries + than perform similarly when they are run, but it has proven useful in + the past and has permitted to detect a subtle bug in the compiler. + +** Customizing the default tests + +As has been briefly mentioned, the precise behavior of actions (and +thus of tests) may depend on /variables/ whose value can be adjusted in +the =(* TEST ... *)= blocks. In ocamltest, all the values of variables +are strings. Here are a few examples of things that can be achieved just +by defining the appropriate variables. The complete description of the +actions provided by ocamltest and the variables they use will be given +in chapters [[#builtins]] and [[#ocaml-specific]]. + +*** Passing flags to the compilers + +Assume our =hello.ml= example is modified as follows: + +#+begin_src +(* TEST *) + +open Format + +let _ = print_endline "Hello, world!" +#+end_src + +As may be verified, this program still passes the default tests. It is +however not as minimal as our previous version, because the =Format= +module is opened but not used. Fortunately, OCaml has a warning to +detect such unused =open= directives, namely warning 33, which is +disabled by default. We could thus add this version of =hello.ml= +to the test suite, not so much to verify that the program compiles and +runs as expected (we verified this already), but rather to make sure +the compiler does indeed trigger the expected warning. Here are the +required steps to achieve this: + +1. We slightly modify the test block in =hello.ml=, as follows: + #+begin_src + (* TEST + flags = "-w +33" + *) + #+end_src + +2. Since we now expect a non-empty output for the compilers, we need to + store the expected output in a file, namely =hello.compilers.output= + besides to =hello.ml= and =hello.reference=. To figure out what + this file shall contain, we can run ocamltest even before it + has been created. Of course, the action that checks compiler output + will fail, but in this way we will get the compiler's output + which we will just have to check (to + make sure it is what we expect) and to move to the reference file. + Thus, we do: + : $ ocamltest hello.ml + which fails, unsurprisingly, and shows us the paths to the file + containing the output produced by the compiler and the path to the + expected reference file. We also see what the compiler produced as + output but we can double-check that the output is what we expect as a + reference: + : $ cat _ocamltest/hello/ocamlc.byte/ocamlc.byte.output + which shows the warning we expect from the compiler. We can thus move + this file to the reference file: + : $ mv _ocamltest/hello/ocamlc.byte/ocamlc.byte.output hello.compilers.reference + and if we now run ocamltest again, all the tests pass. + +Two remarks are due. First, we have used the =flags= variable, to pass +extra flags to all the compilers. There are two other variables one can +use, namely =ocamlc_flags= and =ocamlopt_flags=, to pass flags to the +bytecode or native compilers. Second, in this test all the compilers +have the same output so one reference file is enough for all of them. +There are situations, though, where the compiler's output is +back-end-specific (it depends whether we compile to bytecode or to native +code) or even compiler-specific. ocamltest is clever enough to know how +to deal with such situations, provided that the reference files are +named appropriately. It will indeed first lookup the test source +directory for a compiler-specific reference file, e.g. +=hello.ocamlc.byte.reference=. If no such file exists, a +back-end-specific reference file is searched, e.g. +=hello.ocamlc.reference= for a compiler common to both =ocamlc.byte= and +=ocamlc.opt=. If this file does not exist either, ocamltest falls back +to looking for =hello.compilers.reference= as we have seen in this +example, the absence of which meaning that the compiler's output is +expected to be empty. + +*** Using an auxiliary module + +Let's start with our original =hello.ml= test program and extract the +greeting logic into a distinct =greet.ml= module: + +#+begin_src +let greet guest = Printf.printf "Hello, %s!\n" guest +#+end_src + +Let's also write an interface, =greet.mli=: + +#+begin_src +val greet : string -> unit +#+end_src + +Our =hello.ml= test program can then be rewritten as follows: + +#+begin_src +(* TEST +modules = "greet.ml" +*) + +let _ = Greet.greet "world" +#+end_src + +Provided that the =hello.compilers.reference= file previously to test +warnings is deleted, running ocamltest on =hello.ml= should work. It +will also be worth looking at the two first lines of the log file generated +while running the test. It says: + +#+begin_src +Specified modules: greet.ml hello.ml +Source modules: greet.mli greet.ml hello.ml +#+end_src + +The first line shows that the =modules= variable has been taken into +account. On the second line, it can be seen that the =greet.mli= file +appears, right before =greet.ml=. It is ocamltest that has added it, +because it has been recognized as an interface for one of the specified +modules. + +To sum up, if a test consists in several modules, it is enough to list +their implementations (except the one of the main test program which is +implicit) in the =modules= variable, in linking order. There is no need +to worry about their interfaces, which will be added automatically by +ocamltest, if they exist. + +*** Linking with a library + +Assume we want to use the following program to make sure regular +expressions as implemented by the =Str= library work as expected: + +#+begin_src +let hello_re = Str.regexp "^Hello, .+!$" + +let hello_str = "Hello, world!" + +let _ = + if not (Str.string_match hello_re hello_str 0) then + begin + Printf.eprintf "There is a problem!\n"; + exit 2 + end +#+end_src + +This test terminates silently if everything goes well and prints a +message on its standard error only if something goes wrong, which means +we won't have anything special to do so that ocamltest checks for an +empty output after the program has run. However, to be able to compile +and link this test, there are several things we need to do so that it +finds the =Str= library it uses. More precisely, we need to add the =-I= +option pointing to the right directory and, at link time, to give the +name of the appropriate library file. To make our life a bit simpler, +ocamltest has a few variables where directories and libraries can be +listed. Once they are there, it is ocamltest which will take care of +adding the =-I= option for each directory and for adding the right +library file depending on whether we are producing bytecode or native +programs. So, here is how the previous program can be annotated so that +it becomes a test: + +#+begin_src +(* TEST +directories += " ${ocamlsrcdir}/otherlibs/str " +libraries += " str " +*) +#+end_src + +With these annotations, it becomes possible to run =re.ml= as an +ocamltest test program and, doing so, one may notice that the two tests +pass. There are however a few other things worth pointing out here +regarding the ocamltest DSL. For a start, the notation =${variable}= +inside a string means to replace =variable= by its value, as happens in +many other languages, like the bash shell. Moreover, it is the first +time we meet the ~+=~ operator which concatenates a value to a variable. +More precisely, +: foo += "bar" +is equivalent to +: foo = "${foo}bar" +and not to +: foo = "${foo} bar" +as it may happen in other languages such as makefiles. + +In other words, the ~+=~ operator concatenates two strings without +inserting any implicit space between them as e.g. make would do. This is +because in some cases such a behavior is required and could not be +achieved if spaces were implicitly added, whereas with a literal +concatenation it is always possible to include spaces explicitly. This is +exactly what happens in the ocamltest annotation block above, where the +strings added to the =libraries= and =directories= variables are +surrounded by spaces. As should be clear to the reader by now, these +spaces are mandatory. Without them, the added values would be glued to +the last word of the variable and would thus be misinterpreted. + +Finally, one may notice that, although ocamltest does make it +possible to link a test program with a library, it does not really make +it easy or convenient to do so. In particular, what if we want to write +several, perhaps many test programs that need to be linked with =Str=? +Will we have to repeat these lines everywhere, thus creating code that +is going to be tedious to maintain? Well, fortunately not. Actually, +ocamltest has a much more elegant way to deal with such issues, namely +/environment modifiers/. As will be explained in chapter [[#concepts]], an +/environment modifier/ is an object that gathers several variable +definitions that can then be included in an ocamltest block at once. +Environment modifiers have to be defined in ocamltest itself and can +then be used with the =include= directive. For instance, the previous +test block is actually written as follows: + +#+begin_src +(* TEST +include str +*) +#+end_src + +*** Testing only on Unix systems + +So far, we have been able to fulfill our requirements just by assigning +the right values to variables and relying on the =bytecode= and =native= +tests ocaml runs by default. There are however situations where this is +not enough and where one needs the ability to run other tests. One +example of such a situation is when a test needs to be performed only on +one given operating system, e.g. because it uses a feature which is +present only on that operating system. On an other operating system, the +test should be skipped because it is irrelevant. To illustrate this, +here is how our original =hello.ml= test program should be annotated so +that it is run only on Unix platforms: + +#+begin_src +(* TEST +:* unix +:** bytecode +:** native +*) +#+end_src + +As can be understood from this example, lines starting with an asterisk +describe which tests should be executed. In addition, the number of +asterisks allows to specify the nesting level of each test or action. +Here for instance, =bytecode= and =native= are sub-tests that will be +run only if the =unix= test passes and will not be started if it fails +or skips. + +This way of describing the dependencies between tests has been inspired +by the syntax of org-mode. Each line starting with asterisks (thus lines +specifying which tests to run) can also be seen as a title. The whole +set of lines is like the outline of the test scenario. + +With this information in mind, it can be seen that the smallest test +block +: (* TEST *) +is actually equivalent to +#+begin_src +(* TEST +:* bytecode +:* native +*) +#+end_src + +One common error when designing tests is to believe that a block like +#+begin_src +(* TEST +:* unix +*) +#+end_src +means to execute the =unix= test that verifies that the OS is indeed +Unix and then to execute the default tests. This is actually not the +case. The only situation in which the default tests are considered is +when the test block contains absolutely no line starting with an +asterisk. As soon as there is a line starting with an asterisk, the +default tests are ignored completely and one needs to be totally +explicit about which tests to run. So the correct way to write the +erroneous block above is the use shown at the beginning of this section, +namely: +#+begin_src +(* TEST +:* unix +:** bytecode +:** native +*) +#+end_src + +The fact that the language is inspired by org-mode should also be +helpful in understanding the scope of variable assignments. Roughly +speaking: + +1. Variables defined at the root level are visible by all the tests and + sub-tests that follow their assignment. + +2. If a variable is defined just below a test line, then it is visible + by that test and all its sub-tests (unless its definition is + overridden) but not by tests at a nesting level whose depth is less or + equal than the one of the test in which the variable is defined. + +For instance, given the following block: +#+begin_src +(* TEST +foo = "abc" +:* test1 +bar = "def" +:** subtest1 +baz = "hij" +:** subtest2 +:* test2 +*) +#+end_src +- The definition of =foo= is visible in all the tests + +- The definition of =bar= is visible in all the tests except =test2=. + +- The definition of =baz= is visible only in =subtest1=. + +** Other useful tests + +This section introduces three tests provided by =ocamltest= and that can +be of particular interest. A complete list of available tests and +actions and their detailed descriptions are given in chapters +[[#builtins]] and [[#ocaml-specific]]. + +*** Testing the top-level: the =toplevel= and =expect= tests + +Two tests are provided to make sure that the OCaml top-level behaves as +expected: =toplevel= and =expect=. These tests are similar in that they +both allow to test how the OCaml top-level reacts to some user input, +but they are different in the way one specifies the expected output and +also in what they can test. The =toplevel= test behaves in a spirit +similar to the compiler tests described above, meaning that the expected +output has to be stored in its own, separate file. Since this test +invokes the real OCaml top-level, it is useful to test advanced features +like the behavior of the top-level when its input is a file rather than +a terminal, or similar things. In the expect test, on the contrary, +the input and the output it is expected to produce can be written in +the same file, close to each other. However, this test uses the OCaml +top-level as a library, rather than calling it as an external program. +So this test is actually not testing the complete real OCaml top-level, +but for testing language features it remains perfectly valid and is +actually what is needed in most of the cases. We thus give below an +example of an expect test and will describe the =toplevel= test in +chapter [[#ocaml-specific]]. + +So, here is a toy example of an =expect= test: + +#+begin_src +(* TEST +:* expect +*) + +type point = { x : int; y : int };; +[%%expect{| +type point = { x : int; y : int; } +|}];; +#+end_src + +The first line after the test block is the input phrase, while the line +that appears between =[%%expect{|= and =|}];;= is the corresponding +expected output. The =expect= test can also be used to test the output +in presence of the =-principal= command-line flag. In such cases, the +expected output should be written in a =|}, Principal{|= block (to be +improved). + +*** The =script= test + +It may happen that a needed test is not provided by ocamltest. Of +course, if it turns out that this test would be helpful to test several +source files, then the best solution is to add it to ocamltest itself. +Some tests are however so specific that it is easier to write them as +shell scripts. Such tests can be run by the =script= test, their name +being defined by the =script= variable. In this case, the script is run +in an environment where all the variables defined in ocamltest have been +exported. The script uses its exit status to report its result and can +write a response to a dedicated file to modify its environment or +explain why it failed or skipped, as will be explained in chapter +[[#builtins]]. For the moment, let's see how to use a script to "test" our +original =hello.ml= example. Our annotated program would look as +follows: + +#+begin_src +(* TEST +script = "${test_source_directory}/faketest.sh" +:* script +*) + +let _ = print_endline "Hello, world!" +#+end_src + +And here is =faketest.sh=, make sure it is executable: + +#+begin_src +#!/bin/sh +exit ${TEST_PASS} +#+end_src + +This should be enough for the following command to work: +: ocamltest hello.ml + +This of course tests nothing and a real test script should actually do +something before returning its result. Let's however see how we can +make the script test fail gracefully: + +#+begin_src +#!/bin/sh +echo Why should this pass in the first place > ${ocamltest_response} +exit ${TEST_FAIL} +#+end_src + +Running ocamltest on our =hello.ml= program again produces the following +output: +#+begin_src + ... testing 'hello.ml' with 1 (script) => failed (Why should this pass in the first place) +#+end_src + +* Key concepts + :PROPERTIES: + :CUSTOM_ID: concepts + :END: + +** Actions, hooks and tests + +** Semantics of a test block + +** Variables, environments and how they are inherited + +** Environment modifiers + +* Built-in actions and tests + :PROPERTIES: + :CUSTOM_ID: builtins + :END: + +* OCaml-specific actions and tests + :PROPERTIES: + :CUSTOM_ID: ocaml-specific + :END: + +# Things to document (requested by Leo on caml-devel) +# - the syntax of the DSL +# - the precise meaning of the stars +# - a clear definition of what "test" means in the context of the DSL +# - a list of the builtin "actions" +# - a list of which "actions" depend on which "variables" +# - what does "include" do? +# - what is the scoping of variables? + +# LocalWords: ocamltest OCaml DSL extensibility makefiles + +# Local Variables: +# ispell-local-dictionary: "english" +# End: diff --git a/ocamltest/ocamltest_config.ml.in b/ocamltest/ocamltest_config.ml.in index 2f7fb6d4..b42f9230 100644 --- a/ocamltest/ocamltest_config.ml.in +++ b/ocamltest/ocamltest_config.ml.in @@ -37,6 +37,8 @@ let str = @@STR@@ let objext = "@@OBJEXT@@" +let asmext = "@@ASMEXT@@" + let system = "@@SYSTEM@@" let c_preprocessor = "@@CPP@@" @@ -78,3 +80,5 @@ let nativecc_libs = "@@NATIVECCLIBS@@" let windows_unicode = @@WINDOWS_UNICODE@@ != 0 let function_sections = @@FUNCTION_SECTIONS@@ + +let has_instrumented_runtime = @@RUNTIMEI@@ diff --git a/ocamltest/ocamltest_config.mli b/ocamltest/ocamltest_config.mli index 91977929..a03c6b68 100644 --- a/ocamltest/ocamltest_config.mli +++ b/ocamltest/ocamltest_config.mli @@ -49,6 +49,9 @@ val str : bool val objext : string (** Extension of object files *) +val asmext : string +(** Extension of assembly files *) + val system : string (** The content of the SYSTEM Make variable *) @@ -109,3 +112,6 @@ val windows_unicode : bool val function_sections : bool (** Whether the compiler was configured to generate each function in a separate section *) + +val has_instrumented_runtime : bool +(** Whether the instrumented runtime is available *) diff --git a/ocamltest/ocamltest_stdlib.ml b/ocamltest/ocamltest_stdlib.ml index 2d667299..3b550101 100644 --- a/ocamltest/ocamltest_stdlib.ml +++ b/ocamltest/ocamltest_stdlib.ml @@ -102,8 +102,7 @@ module Sys = struct let mkdir dir = if not (Sys.file_exists dir) then - let quoted_dir = "\"" ^ dir ^ "\"" in - run_system_command ("mkdir " ^ quoted_dir) + run_system_command (Filename.quote_command "mkdir" [dir]) let rec make_directory dir = if Sys.file_exists dir then () diff --git a/ocamltest/options.ml b/ocamltest/options.ml index 24989c02..60bcdeb7 100644 --- a/ocamltest/options.ml +++ b/ocamltest/options.ml @@ -49,6 +49,8 @@ let log_to_stderr = ref false let promote = ref false +let keep_test_dir_on_success = ref false + let find_test_dirs = ref [] let list_tests = ref [] @@ -68,6 +70,8 @@ let commandline_options = " Find directories that contain tests (recursive)."); ("-list-tests", Arg.String (add_to_list list_tests), " List tests in given directory."); + ("-keep-test-dir-on-success", Arg.Set keep_test_dir_on_success, + " Keep the test directory (with the generated test artefacts) on success."); ] let files_to_test = ref [] diff --git a/ocamltest/options.mli b/ocamltest/options.mli index 4d64fdbd..2047f60a 100644 --- a/ocamltest/options.mli +++ b/ocamltest/options.mli @@ -26,3 +26,5 @@ val usage : string val find_test_dirs : string list ref val list_tests : string list ref + +val keep_test_dir_on_success : bool ref diff --git a/ocamltest/run_unix.c b/ocamltest/run_unix.c index 2db26d2d..2cfd6868 100644 --- a/ocamltest/run_unix.c +++ b/ocamltest/run_unix.c @@ -248,8 +248,8 @@ static int handle_process_termination( if (WIFEXITED(status)) return WEXITSTATUS(status); if ( !WIFSIGNALED(status) ) - error("Process %d neither terminated normally nor received a" \ - "signal!?", pid); + error("Process %lld neither terminated normally nor received a" \ + "signal!?", (long long) pid); /* From here we know that the process terminated due to a signal */ signal = WTERMSIG(status); @@ -258,8 +258,8 @@ static int handle_process_termination( #endif /* WCOREDUMP */ corestr = core ? "" : "no "; fprintf(stderr, - "Process %d got signal %d(%s), %score dumped\n", - pid, signal, strsignal(signal), corestr + "Process %lld got signal %d(%s), %score dumped\n", + (long long) pid, signal, strsignal(signal), corestr ); if (core) @@ -273,7 +273,7 @@ static int handle_process_termination( fprintf(stderr, "Out of memory while processing core file.\n"); else { snprintf(corefile, corefile_len, - "%s.%d.core", corefilename_prefix, pid); + "%s.%lld.core", corefilename_prefix, (long long) pid); if ( rename(COREFILENAME, corefile) == -1) fprintf(stderr, "The core file exists but could not be renamed.\n"); else diff --git a/otherlibs/Makefile b/otherlibs/Makefile index cc77536b..8342b402 100644 --- a/otherlibs/Makefile +++ b/otherlibs/Makefile @@ -14,8 +14,11 @@ #************************************************************************** ROOTDIR=.. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common + +OTHERLIBRARIES ?= bigarray dynlink raw_spacetime_lib str systhreads \ + unix win32unix # $1: target name to dispatch to all otherlibs/*/Makefile define dispatch_ diff --git a/otherlibs/Makefile.otherlibs.common b/otherlibs/Makefile.otherlibs.common index 49a146f6..2e0802de 100644 --- a/otherlibs/Makefile.otherlibs.common +++ b/otherlibs/Makefile.otherlibs.common @@ -16,8 +16,8 @@ # Common Makefile for otherlibs ROOTDIR=../.. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common include $(ROOTDIR)/Makefile.best_binaries CAMLRUN ?= $(ROOTDIR)/boot/ocamlrun diff --git a/otherlibs/dynlink/Makefile b/otherlibs/dynlink/Makefile index 1ec58124..fc41cd5f 100644 --- a/otherlibs/dynlink/Makefile +++ b/otherlibs/dynlink/Makefile @@ -21,14 +21,14 @@ ROOTDIR = ../.. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common include $(ROOTDIR)/Makefile.best_binaries CAMLRUN ?= $(ROOTDIR)/boot/ocamlrun -OCAMLC=$(BEST_OCAMLC) -nostdlib -I $(ROOTDIR)/stdlib -OCAMLOPT=$(BEST_OCAMLOPT) -nostdlib -I $(ROOTDIR)/stdlib +OCAMLC=$(BEST_OCAMLC) -g -nostdlib -I $(ROOTDIR)/stdlib +OCAMLOPT=$(BEST_OCAMLOPT) -g -nostdlib -I $(ROOTDIR)/stdlib # COMPFLAGS should be in sync with the toplevel Makefile's COMPFLAGS. COMPFLAGS=-strict-sequence -principal -absname -w +a-4-9-40-41-42-44-45-48-66 \ @@ -86,6 +86,7 @@ COMPILERLIBS_SOURCES=\ utils/terminfo.ml \ utils/warnings.ml \ utils/load_path.ml \ + utils/int_replace_polymorphic_compare.ml \ parsing/location.ml \ parsing/longident.ml \ parsing/docstrings.ml \ @@ -106,6 +107,7 @@ COMPILERLIBS_SOURCES=\ file_formats/cmi_format.ml \ typing/persistent_env.ml \ typing/env.ml \ + lambda/debuginfo.ml \ lambda/lambda.ml \ lambda/runtimedef.ml \ bytecomp/instruct.ml \ @@ -118,6 +120,7 @@ COMPILERLIBS_SOURCES=\ # Rules to make a local copy of the .ml and .mli files required. We also # provide .ml files for .mli-only modules---without this, such modules do # not seem to be located by the type checker inside bytecode packs. +# Note: .ml-only modules are not supported by the (.mli.cmi) rule below. $(LOCAL_SRC)/Makefile: $(LOCAL_SRC)/Makefile.copy-sources Makefile cp -f $< $@ @@ -169,15 +172,15 @@ COMPILERLIBS_COPIED_SOURCES_INTFS=\ COMPILERLIBS_CMO=$(COMPILERLIBS_COPIED_SOURCES:.ml=.cmo) COMPILERLIBS_CMX=$(COMPILERLIBS_COPIED_SOURCES:.ml=.cmx) -$(LOCAL_SRC)/%.cmi: +$(LOCAL_SRC)/%.cmi: $(LOCAL_SRC)/%.mli $(OCAMLC) -c -for-pack Dynlink_compilerlibs $(COMPFLAGS) \ -I $(LOCAL_SRC) -o $@ $(LOCAL_SRC)/$*.mli -$(LOCAL_SRC)/%.cmo: +$(LOCAL_SRC)/%.cmo: $(LOCAL_SRC)/%.ml $(OCAMLC) -c -for-pack Dynlink_compilerlibs $(COMPFLAGS) \ -I $(LOCAL_SRC) -o $@ $(LOCAL_SRC)/$*.ml -$(LOCAL_SRC)/%.cmx: +$(LOCAL_SRC)/%.cmx: $(LOCAL_SRC)/%.ml $(OCAMLOPT) -c -for-pack Dynlink_compilerlibs $(COMPFLAGS) \ $(OPTCOMPFLAGS) -I $(LOCAL_SRC) -o $@ $(LOCAL_SRC)/$*.ml @@ -252,11 +255,12 @@ installopt: partialclean: rm -f extract_crc *.cm[ioaxt] *.cmti *.cmxa \ byte/*.cm[iot] byte/*.cmti \ - native/*.cm[ixt] native/*.cmti native/*.$(O) \ - $(LOCAL_SRC)/*.cm[ioaxt] $(LOCAL_SRC)/*.cmti $(LOCAL_SRC)/*.$(O) + native/*.cm[ixt] native/*.cmti native/*.o native/*.obj \ + $(LOCAL_SRC)/*.cm[ioaxt] $(LOCAL_SRC)/*.cmti \ + $(LOCAL_SRC)/*.o $(LOCAL_SRC)/*.obj clean: partialclean - rm -f *.$(A) *.$(O) *.so *.dll dynlink_platform_intf.mli \ + rm -f *.a *.lib *.o *.obj *.so *.dll dynlink_platform_intf.mli \ $(LOCAL_SRC)/*.ml $(LOCAL_SRC)/*.mli $(LOCAL_SRC)/Makefile \ $(LOCAL_SRC)/.depend byte/dynlink.mli native/dynlink.mli diff --git a/otherlibs/dynlink/byte/dynlink.ml b/otherlibs/dynlink/byte/dynlink.ml index 9bb54320..e7d6c24c 100644 --- a/otherlibs/dynlink/byte/dynlink.ml +++ b/otherlibs/dynlink/byte/dynlink.ml @@ -134,7 +134,10 @@ module Bytecode = struct if priv then Symtable.hide_additions old_state; let _, clos = Meta.reify_bytecode code events (Some digest) in try ignore ((clos ()) : Obj.t) - with exn -> raise (DT.Error (Library's_module_initializers_failed exn)) + with exn -> + Printexc.raise_with_backtrace + (DT.Error (Library's_module_initializers_failed exn)) + (Printexc.get_raw_backtrace ()) let load ~filename:file_name ~priv:_ = let ic = open_in_bin file_name in diff --git a/otherlibs/dynlink/dynlink_compilerlibs/Makefile.copy-sources b/otherlibs/dynlink/dynlink_compilerlibs/Makefile.copy-sources index 4bd3bc59..7d2114f0 100644 --- a/otherlibs/dynlink/dynlink_compilerlibs/Makefile.copy-sources +++ b/otherlibs/dynlink/dynlink_compilerlibs/Makefile.copy-sources @@ -16,7 +16,7 @@ $(LOCAL_SRC)/.depend: $(COMPILERLIBS_COPIED_SOURCES) \ $(COMPILERLIBS_COPIED_SOURCES_INTFS) $(LOCAL_SRC)/Makefile - $(CAMLRUN) $(ROOTDIR)/ocamlc -depend -slash -I $(LOCAL_SRC) \ + $(BEST_OCAMLDEP) -slash -I $(LOCAL_SRC) \ $(COMPILERLIBS_COPIED_SOURCES) \ $(COMPILERLIBS_COPIED_SOURCES_INTFS) \ > $(LOCAL_SRC)/.depend diff --git a/otherlibs/dynlink/native/dynlink.ml b/otherlibs/dynlink/native/dynlink.ml index fda32112..a827e36d 100644 --- a/otherlibs/dynlink/native/dynlink.ml +++ b/otherlibs/dynlink/native/dynlink.ml @@ -82,7 +82,10 @@ module Native = struct let run handle ~unit_header ~priv:_ = List.iter (fun cu -> try ndl_run handle cu - with exn -> raise (DT.Error (Library's_module_initializers_failed exn))) + with exn -> + Printexc.raise_with_backtrace + (DT.Error (Library's_module_initializers_failed exn)) + (Printexc.get_raw_backtrace ())) (Unit_header.defined_symbols unit_header) let load ~filename ~priv = diff --git a/otherlibs/systhreads/Makefile b/otherlibs/systhreads/Makefile index 8c3853a7..173183ba 100644 --- a/otherlibs/systhreads/Makefile +++ b/otherlibs/systhreads/Makefile @@ -15,8 +15,8 @@ ROOTDIR=../.. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common include $(ROOTDIR)/Makefile.best_binaries OC_CFLAGS += $(SHAREDLIB_CFLAGS) @@ -111,7 +111,7 @@ partialclean: rm -f *.cm* clean: partialclean - rm -f dllthreads*$(EXT_DLL) *.$(A) *.$(O) + rm -f dllthreads*.so dllthreads*.dll *.a *.lib *.o *.obj INSTALL_THREADSLIBDIR=$(INSTALL_LIBDIR)/$(LIBNAME) diff --git a/otherlibs/systhreads/st_posix.h b/otherlibs/systhreads/st_posix.h index e7f618a4..17ed1514 100644 --- a/otherlibs/systhreads/st_posix.h +++ b/otherlibs/systhreads/st_posix.h @@ -31,12 +31,6 @@ #include #endif -#ifdef __GNUC__ -#define INLINE inline -#else -#define INLINE -#endif - typedef int st_retcode; #define SIGPREEMPTION SIGVTALRM @@ -71,7 +65,7 @@ static int st_thread_create(st_thread_id * res, /* Cleanup at thread exit */ -static INLINE void st_thread_cleanup(void) +Caml_inline void st_thread_cleanup(void) { return; } @@ -102,12 +96,12 @@ static int st_tls_newkey(st_tlskey * res) return pthread_key_create(res, NULL); } -static INLINE void * st_tls_get(st_tlskey k) +Caml_inline void * st_tls_get(st_tlskey k) { return pthread_getspecific(k); } -static INLINE void st_tls_set(st_tlskey k, void * v) +Caml_inline void st_tls_set(st_tlskey k, void * v) { pthread_setspecific(k, v); } @@ -153,7 +147,7 @@ static void st_masterlock_release(st_masterlock * m) } CAMLno_tsan /* This can be called for reading [waiters] without locking. */ -static INLINE int st_masterlock_waiters(st_masterlock * m) +Caml_inline int st_masterlock_waiters(st_masterlock * m) { return m->waiters; } @@ -167,7 +161,7 @@ static INLINE int st_masterlock_waiters(st_masterlock * m) off the lock to a waiter we know exists, it's safe, as they'll certainly re-wake us later. */ -static INLINE void st_thread_yield(st_masterlock * m) +Caml_inline void st_thread_yield(st_masterlock * m) { pthread_mutex_lock(&m->lock); /* We must hold the lock to call this. */ @@ -219,7 +213,7 @@ static int st_mutex_destroy(st_mutex m) return rc; } -static INLINE int st_mutex_lock(st_mutex m) +Caml_inline int st_mutex_lock(st_mutex m) { return pthread_mutex_lock(m); } @@ -227,12 +221,12 @@ static INLINE int st_mutex_lock(st_mutex m) #define PREVIOUSLY_UNLOCKED 0 #define ALREADY_LOCKED EBUSY -static INLINE int st_mutex_trylock(st_mutex m) +Caml_inline int st_mutex_trylock(st_mutex m) { return pthread_mutex_trylock(m); } -static INLINE int st_mutex_unlock(st_mutex m) +Caml_inline int st_mutex_unlock(st_mutex m) { return pthread_mutex_unlock(m); } @@ -260,17 +254,17 @@ static int st_condvar_destroy(st_condvar c) return rc; } -static INLINE int st_condvar_signal(st_condvar c) +Caml_inline int st_condvar_signal(st_condvar c) { return pthread_cond_signal(c); } -static INLINE int st_condvar_broadcast(st_condvar c) +Caml_inline int st_condvar_broadcast(st_condvar c) { return pthread_cond_broadcast(c); } -static INLINE int st_condvar_wait(st_condvar c, st_mutex m) +Caml_inline int st_condvar_wait(st_condvar c, st_mutex m) { return pthread_cond_wait(c, m); } diff --git a/otherlibs/systhreads/st_stubs.c b/otherlibs/systhreads/st_stubs.c index e46a67be..285466ed 100644 --- a/otherlibs/systhreads/st_stubs.c +++ b/otherlibs/systhreads/st_stubs.c @@ -101,7 +101,7 @@ struct caml_thread_struct { int backtrace_pos; /* Saved Caml_state->backtrace_pos */ backtrace_slot * backtrace_buffer; /* Saved Caml_state->backtrace_buffer */ value backtrace_last_exn; /* Saved Caml_state->backtrace_last_exn (root) */ - int memprof_suspended; /* Saved caml_memprof_suspended */ + struct caml_memprof_th_ctx memprof_ctx; }; typedef struct caml_thread_struct * caml_thread_t; @@ -172,7 +172,7 @@ static void caml_thread_scan_roots(scanning_action action) /* Saving and restoring runtime state in curr_thread */ -static inline void caml_thread_save_runtime_state(void) +Caml_inline void caml_thread_save_runtime_state(void) { #ifdef NATIVE_CODE curr_thread->top_of_stack = Caml_state->top_of_stack; @@ -198,10 +198,10 @@ static inline void caml_thread_save_runtime_state(void) curr_thread->backtrace_pos = Caml_state->backtrace_pos; curr_thread->backtrace_buffer = Caml_state->backtrace_buffer; curr_thread->backtrace_last_exn = Caml_state->backtrace_last_exn; - curr_thread->memprof_suspended = caml_memprof_suspended; + caml_memprof_save_th_ctx(&curr_thread->memprof_ctx); } -static inline void caml_thread_restore_runtime_state(void) +Caml_inline void caml_thread_restore_runtime_state(void) { #ifdef NATIVE_CODE Caml_state->top_of_stack = curr_thread->top_of_stack; @@ -227,7 +227,7 @@ static inline void caml_thread_restore_runtime_state(void) Caml_state->backtrace_pos = curr_thread->backtrace_pos; Caml_state->backtrace_buffer = curr_thread->backtrace_buffer; Caml_state->backtrace_last_exn = curr_thread->backtrace_last_exn; - caml_memprof_suspended = curr_thread->memprof_suspended; + caml_memprof_restore_th_ctx(&curr_thread->memprof_ctx); } /* Hooks for caml_enter_blocking_section and caml_leave_blocking_section */ @@ -380,7 +380,7 @@ static caml_thread_t caml_thread_new_info(void) th->backtrace_pos = 0; th->backtrace_buffer = NULL; th->backtrace_last_exn = Val_unit; - th->memprof_suspended = 0; + caml_memprof_init_th_ctx(&th->memprof_ctx); return th; } @@ -536,6 +536,8 @@ static void caml_thread_stop(void) curr_thread data to make sure that the cleanup logic below uses accurate information. */ caml_thread_save_runtime_state(); + /* Tell memprof that this thread is terminating. */ + caml_memprof_stop_th_ctx(&curr_thread->memprof_ctx); /* Signal that the thread has terminated */ caml_threadstatus_terminate(Terminated(curr_thread->descr)); /* Remove th from the doubly-linked list of threads and free its info block */ diff --git a/otherlibs/systhreads/st_win32.h b/otherlibs/systhreads/st_win32.h index fcc25290..ab4e2b59 100644 --- a/otherlibs/systhreads/st_win32.h +++ b/otherlibs/systhreads/st_win32.h @@ -24,8 +24,6 @@ #include -#define INLINE __inline - #if 1 #define TRACE(x) #define TRACE1(x,y) @@ -112,12 +110,12 @@ static DWORD st_tls_newkey(st_tlskey * res) return 0; } -static INLINE void * st_tls_get(st_tlskey k) +Caml_inline void * st_tls_get(st_tlskey k) { return TlsGetValue(k); } -static INLINE void st_tls_set(st_tlskey k, void * v) +Caml_inline void st_tls_set(st_tlskey k, void * v) { TlsSetValue(k, v); } @@ -133,27 +131,27 @@ static void st_masterlock_init(st_masterlock * m) EnterCriticalSection(m); } -static INLINE void st_masterlock_acquire(st_masterlock * m) +Caml_inline void st_masterlock_acquire(st_masterlock * m) { TRACE("st_masterlock_acquire"); EnterCriticalSection(m); TRACE("st_masterlock_acquire (done)"); } -static INLINE void st_masterlock_release(st_masterlock * m) +Caml_inline void st_masterlock_release(st_masterlock * m) { LeaveCriticalSection(m); TRACE("st_masterlock_released"); } -static INLINE int st_masterlock_waiters(st_masterlock * m) +Caml_inline int st_masterlock_waiters(st_masterlock * m) { return 1; /* info not maintained */ } /* Scheduling hints */ -static INLINE void st_thread_yield(st_masterlock * m) +Caml_inline void st_thread_yield(st_masterlock * m) { LeaveCriticalSection(m); Sleep(0); @@ -180,7 +178,7 @@ static DWORD st_mutex_destroy(st_mutex m) return 0; } -static INLINE DWORD st_mutex_lock(st_mutex m) +Caml_inline DWORD st_mutex_lock(st_mutex m) { TRACE1("st_mutex_lock", m); EnterCriticalSection(m); @@ -193,7 +191,7 @@ static INLINE DWORD st_mutex_lock(st_mutex m) #define PREVIOUSLY_UNLOCKED 0 #define ALREADY_LOCKED (1<<29) -static INLINE DWORD st_mutex_trylock(st_mutex m) +Caml_inline DWORD st_mutex_trylock(st_mutex m) { TRACE1("st_mutex_trylock", m); if (TryEnterCriticalSection(m)) { @@ -205,7 +203,7 @@ static INLINE DWORD st_mutex_trylock(st_mutex m) } } -static INLINE DWORD st_mutex_unlock(st_mutex m) +Caml_inline DWORD st_mutex_unlock(st_mutex m) { TRACE1("st_mutex_unlock", m); LeaveCriticalSection(m); diff --git a/otherlibs/unix/.depend b/otherlibs/unix/.depend index 6068960f..5c9eb799 100644 --- a/otherlibs/unix/.depend +++ b/otherlibs/unix/.depend @@ -170,7 +170,7 @@ fork.o: fork.c ../../runtime/caml/mlvalues.h ../../runtime/caml/config.h \ ../../runtime/caml/m.h ../../runtime/caml/s.h ../../runtime/caml/misc.h \ ../../runtime/caml/domain_state.h ../../runtime/caml/mlvalues.h \ ../../runtime/caml/domain_state.tbl ../../runtime/caml/debugger.h \ - unixsupport.h + ../../runtime/caml/eventlog.h unixsupport.h fsync.o: fsync.c ../../runtime/caml/mlvalues.h \ ../../runtime/caml/config.h ../../runtime/caml/m.h \ ../../runtime/caml/s.h ../../runtime/caml/misc.h \ diff --git a/otherlibs/unix/fork.c b/otherlibs/unix/fork.c index c8fef37c..a244a5cf 100644 --- a/otherlibs/unix/fork.c +++ b/otherlibs/unix/fork.c @@ -17,16 +17,27 @@ #include #include +#include #include "unixsupport.h" CAMLprim value unix_fork(value unit) { int ret; + + CAML_EV_FLUSH(); + ret = fork(); if (ret == -1) uerror("fork", Nothing); + + CAML_EVENTLOG_DO({ + if (ret == 0) + caml_eventlog_disable(); + }); + if (caml_debugger_in_use) if ((caml_debugger_fork_mode && ret == 0) || (!caml_debugger_fork_mode && ret != 0)) caml_debugger_cleanup_fork(); + return Val_int(ret); } diff --git a/otherlibs/unix/stat.c b/otherlibs/unix/stat.c index 48d4a6bd..69ad96ea 100644 --- a/otherlibs/unix/stat.c +++ b/otherlibs/unix/stat.c @@ -16,6 +16,7 @@ #define CAML_INTERNALS #include +#include #include #include #include @@ -47,18 +48,36 @@ static int file_kind_table[] = { S_IFREG, S_IFDIR, S_IFCHR, S_IFBLK, S_IFLNK, S_IFIFO, S_IFSOCK }; +/* Transform a (seconds, nanoseconds) time stamp (in the style of + struct timespec) to a number of seconds in floating-point. + Make sure the integer part of the result is always equal to [seconds] + (issue #9490). */ + +static double stat_timestamp(time_t sec, long nsec) +{ + /* The conversion of sec to FP is exact for the foreseeable future. + (It starts rounding when sec > 2^53, i.e. in 285 million years.) */ + double s = (double) sec; + /* The conversion of nsec to fraction of seconds can round. + Still, we have 0 <= n < 1.0. */ + double n = (double) nsec / 1e9; + /* The sum s + n can round up, hence s <= t + <= s + 1.0 */ + double t = s + n; + /* Detect the "round up to s + 1" case and decrease t so that + its integer part is s. */ + if (t == s + 1.0) t = nextafter(t, s); + return t; +} + static value stat_aux(int use_64, struct stat *buf) { CAMLparam0(); CAMLlocal5(atime, mtime, ctime, offset, v); #include "nanosecond_stat.h" - atime = caml_copy_double((double) buf->st_atime - + (NSEC(buf, a) / 1000000000.0)); - mtime = caml_copy_double((double) buf->st_mtime - + (NSEC(buf, m) / 1000000000.0)); - ctime = caml_copy_double((double) buf->st_ctime - + (NSEC(buf, c) / 1000000000.0)); + atime = caml_copy_double(stat_timestamp(buf->st_atime, NSEC(buf, a))); + mtime = caml_copy_double(stat_timestamp(buf->st_mtime, NSEC(buf, m))); + ctime = caml_copy_double(stat_timestamp(buf->st_ctime, NSEC(buf, c))); #undef NSEC offset = use_64 ? Val_file_offset(buf->st_size) : Val_int (buf->st_size); v = caml_alloc_small(12, 0); diff --git a/otherlibs/unix/unix.mli b/otherlibs/unix/unix.mli index 8ec4beab..ab23cf27 100644 --- a/otherlibs/unix/unix.mli +++ b/otherlibs/unix/unix.mli @@ -235,7 +235,7 @@ val system : string -> process_status its termination status. The string is interpreted by the shell [/bin/sh] (or the command interpreter [cmd.exe] on Windows) and therefore can contain redirections, quotes, variables, etc. - To properly quote whitespace and shell special characters occuring + To properly quote whitespace and shell special characters occurring in file names or command arguments, the use of {!Filename.quote_command} is recommended. The result [WEXITED 127] indicates that the shell couldn't be @@ -1324,7 +1324,7 @@ type socket_type = type sockaddr = ADDR_UNIX of string - | ADDR_INET of inet_addr * int + | ADDR_INET of inet_addr * int (**) (** The type of socket addresses. [ADDR_UNIX name] is a socket address in the Unix domain; [name] is a file name in the file system. [ADDR_INET(addr,port)] is a socket address in the Internet @@ -1389,7 +1389,7 @@ val getpeername : file_descr -> sockaddr type msg_flag = MSG_OOB | MSG_DONTROUTE - | MSG_PEEK + | MSG_PEEK (**) (** The flags for {!Unix.recv}, {!Unix.recvfrom}, {!Unix.send} and {!Unix.sendto}. *) diff --git a/otherlibs/unix/unixLabels.mli b/otherlibs/unix/unixLabels.mli index 16c066a1..6b4c9374 100644 --- a/otherlibs/unix/unixLabels.mli +++ b/otherlibs/unix/unixLabels.mli @@ -1071,7 +1071,7 @@ type socket_type = Unix.socket_type = type sockaddr = Unix.sockaddr = ADDR_UNIX of string - | ADDR_INET of inet_addr * int + | ADDR_INET of inet_addr * int (**) (** The type of socket addresses. [ADDR_UNIX name] is a socket address in the Unix domain; [name] is a file name in the file system. [ADDR_INET(addr,port)] is a socket address in the Internet @@ -1131,7 +1131,7 @@ val getpeername : file_descr -> sockaddr type msg_flag = Unix.msg_flag = MSG_OOB | MSG_DONTROUTE - | MSG_PEEK + | MSG_PEEK (**) (** The flags for {!UnixLabels.recv}, {!UnixLabels.recvfrom}, {!UnixLabels.send} and {!UnixLabels.sendto}. *) diff --git a/otherlibs/win32unix/stat.c b/otherlibs/win32unix/stat.c index 78e0d7a1..cafa8e3d 100644 --- a/otherlibs/win32unix/stat.c +++ b/otherlibs/win32unix/stat.c @@ -15,6 +15,14 @@ #define CAML_INTERNALS #include +#ifdef _MSC_VER +#include +#ifndef nextafter +#define nextafter _nextafter +#endif +#else +#include +#endif #include #include #include @@ -55,6 +63,34 @@ static int file_kind_table[] = { S_IFREG, S_IFDIR, S_IFCHR, S_IFBLK, S_IFLNK, S_IFIFO, S_IFSOCK }; +/* Transform a timestamp expressed in units of 100ns + to a number of seconds in floating-point. + Make sure the integer part of the result is always equal to + the timestamp divided by 10^7 (issue #9490). + Use the same algorithm as for the Unix implementation + (in ../unix/stat.c) in the hope of getting the same result + when the same file is accessed either from Windows or from Linux. + */ + +static double stat_timestamp(__time64_t tm) +{ + /* Split the timestamp into seconds and remaining 100ns units */ + __int64 sec = tm / 10000000; /* 10^7 */ + int n100sec = tm % 10000000; + /* The conversion of sec to FP is exact for the foreseeable future. + (It starts rounding when sec > 2^53, i.e. in 285 million years.) */ + double s = (double) sec; + /* The conversion of n100sec to fraction of seconds can round. + Still, we have 0 <= n100sec < 1.0. */ + double n = (double) n100sec / 1e7; + /* The sum s + n can round up, hence s <= t + <= s + 1.0 */ + double t = s + n; + /* Detect the "round up to s + 1" case and decrease t so that + its integer part is s. */ + if (t == s + 1.0) t = nextafter(t, s); + return t; +} + static value stat_aux(int use_64, __int64 st_ino, struct _stat64 *buf) { CAMLparam0 (); @@ -72,9 +108,9 @@ static value stat_aux(int use_64, __int64 st_ino, struct _stat64 *buf) Store_field (v, 7, Val_int (buf->st_rdev)); Store_field (v, 8, use_64 ? caml_copy_int64(buf->st_size) : Val_int (buf->st_size)); - Store_field (v, 9, caml_copy_double((double) buf->st_atime / 10000000.0)); - Store_field (v, 10, caml_copy_double((double) buf->st_mtime / 10000000.0)); - Store_field (v, 11, caml_copy_double((double) buf->st_ctime / 10000000.0)); + Store_field (v, 9, caml_copy_double(stat_timestamp(buf->st_atime))); + Store_field (v, 10, caml_copy_double(stat_timestamp(buf->st_mtime))); + Store_field (v, 11, caml_copy_double(stat_timestamp(buf->st_ctime))); CAMLreturn (v); } diff --git a/otherlibs/win32unix/unix.ml b/otherlibs/win32unix/unix.ml index a8329264..8d986544 100644 --- a/otherlibs/win32unix/unix.ml +++ b/otherlibs/win32unix/unix.ml @@ -103,6 +103,83 @@ let _ = Callback.register_exception "Unix.Unix_error" external error_message : error -> string = "unix_error_message" +let () = + Printexc.register_printer + (function + | Unix_error (e, s, s') -> + let msg = match e with + | E2BIG -> "E2BIG" + | EACCES -> "EACCES" + | EAGAIN -> "EAGAIN" + | EBADF -> "EBADF" + | EBUSY -> "EBUSY" + | ECHILD -> "ECHILD" + | EDEADLK -> "EDEADLK" + | EDOM -> "EDOM" + | EEXIST -> "EEXIST" + | EFAULT -> "EFAULT" + | EFBIG -> "EFBIG" + | EINTR -> "EINTR" + | EINVAL -> "EINVAL" + | EIO -> "EIO" + | EISDIR -> "EISDIR" + | EMFILE -> "EMFILE" + | EMLINK -> "EMLINK" + | ENAMETOOLONG -> "ENAMETOOLONG" + | ENFILE -> "ENFILE" + | ENODEV -> "ENODEV" + | ENOENT -> "ENOENT" + | ENOEXEC -> "ENOEXEC" + | ENOLCK -> "ENOLCK" + | ENOMEM -> "ENOMEM" + | ENOSPC -> "ENOSPC" + | ENOSYS -> "ENOSYS" + | ENOTDIR -> "ENOTDIR" + | ENOTEMPTY -> "ENOTEMPTY" + | ENOTTY -> "ENOTTY" + | ENXIO -> "ENXIO" + | EPERM -> "EPERM" + | EPIPE -> "EPIPE" + | ERANGE -> "ERANGE" + | EROFS -> "EROFS" + | ESPIPE -> "ESPIPE" + | ESRCH -> "ESRCH" + | EXDEV -> "EXDEV" + | EWOULDBLOCK -> "EWOULDBLOCK" + | EINPROGRESS -> "EINPROGRESS" + | EALREADY -> "EALREADY" + | ENOTSOCK -> "ENOTSOCK" + | EDESTADDRREQ -> "EDESTADDRREQ" + | EMSGSIZE -> "EMSGSIZE" + | EPROTOTYPE -> "EPROTOTYPE" + | ENOPROTOOPT -> "ENOPROTOOPT" + | EPROTONOSUPPORT -> "EPROTONOSUPPORT" + | ESOCKTNOSUPPORT -> "ESOCKTNOSUPPORT" + | EOPNOTSUPP -> "EOPNOTSUPP" + | EPFNOSUPPORT -> "EPFNOSUPPORT" + | EAFNOSUPPORT -> "EAFNOSUPPORT" + | EADDRINUSE -> "EADDRINUSE" + | EADDRNOTAVAIL -> "EADDRNOTAVAIL" + | ENETDOWN -> "ENETDOWN" + | ENETUNREACH -> "ENETUNREACH" + | ENETRESET -> "ENETRESET" + | ECONNABORTED -> "ECONNABORTED" + | ECONNRESET -> "ECONNRESET" + | ENOBUFS -> "ENOBUFS" + | EISCONN -> "EISCONN" + | ENOTCONN -> "ENOTCONN" + | ESHUTDOWN -> "ESHUTDOWN" + | ETOOMANYREFS -> "ETOOMANYREFS" + | ETIMEDOUT -> "ETIMEDOUT" + | ECONNREFUSED -> "ECONNREFUSED" + | EHOSTDOWN -> "EHOSTDOWN" + | EHOSTUNREACH -> "EHOSTUNREACH" + | ELOOP -> "ELOOP" + | EOVERFLOW -> "EOVERFLOW" + | EUNKNOWNERR x -> Printf.sprintf "EUNKNOWNERR %d" x in + Some (Printf.sprintf "Unix.Unix_error(Unix.%s, %S, %S)" msg s s') + | _ -> None) + let handle_unix_error f arg = try f arg @@ -138,10 +215,29 @@ type wait_flag = type file_descr -external execv : string -> string array -> 'a = "unix_execv" -external execve : string -> string array -> string array -> 'a = "unix_execve" -external execvp : string -> string array -> 'a = "unix_execvp" -external execvpe : string -> string array -> string array -> 'a = "unix_execvpe" +let maybe_quote f = + if String.contains f ' ' || + String.contains f '\"' || + String.contains f '\t' || + f = "" + then Filename.quote f + else f + +external sys_execv : string -> string array -> 'a = "unix_execv" +external sys_execve : + string -> string array -> string array -> 'a = "unix_execve" +external sys_execvp : string -> string array -> 'a = "unix_execvp" +external sys_execvpe : + string -> string array -> string array -> 'a = "unix_execvpe" + +let execv prog args = + sys_execv prog (Array.map maybe_quote args) +let execve prog args env = + sys_execve prog (Array.map maybe_quote args) env +let execvp prog args = + sys_execvp prog (Array.map maybe_quote args) +let execvpe prog args env = + sys_execvpe prog (Array.map maybe_quote args) env external waitpid : wait_flag list -> int -> int * process_status = "win_waitpid" @@ -858,13 +954,6 @@ external win_create_process : string -> string -> string option -> = "win_create_process" "win_create_process_native" let make_cmdline args = - let maybe_quote f = - if String.contains f ' ' || - String.contains f '\"' || - String.contains f '\t' || - f = "" - then Filename.quote f - else f in String.concat " " (List.map maybe_quote (Array.to_list args)) let make_process_env env = diff --git a/parsing/ast_helper.ml b/parsing/ast_helper.ml index e9e8dee0..2d51dda7 100644 --- a/parsing/ast_helper.ml +++ b/parsing/ast_helper.ml @@ -40,7 +40,8 @@ module Const = struct let nativeint ?(suffix='n') i = integer ~suffix (Nativeint.to_string i) let float ?suffix f = Pconst_float (f, suffix) let char c = Pconst_char c - let string ?quotation_delimiter s = Pconst_string (s, quotation_delimiter) + let string ?quotation_delimiter ?(loc= !default_loc) s = + Pconst_string (s, loc, quotation_delimiter) end module Attr = struct diff --git a/parsing/ast_helper.mli b/parsing/ast_helper.mli index 8bae9547..330f68ee 100644 --- a/parsing/ast_helper.mli +++ b/parsing/ast_helper.mli @@ -45,7 +45,8 @@ val with_default_loc: loc -> (unit -> 'a) -> 'a module Const : sig val char : char -> constant - val string : ?quotation_delimiter:string -> string -> constant + val string : + ?quotation_delimiter:string -> ?loc:Location.t -> string -> constant val integer : ?suffix:char -> string -> constant val int : ?suffix:char -> int -> constant val int32 : ?suffix:char -> int32 -> constant diff --git a/parsing/ast_invariants.ml b/parsing/ast_invariants.ml index 7ecdae96..23aa008c 100644 --- a/parsing/ast_invariants.ml +++ b/parsing/ast_invariants.ml @@ -47,7 +47,6 @@ let iterator = let loc = ty.ptyp_loc in match ty.ptyp_desc with | Ptyp_tuple ([] | [_]) -> invalid_tuple loc - | Ptyp_class (id, _) -> simple_longident id | Ptyp_package (_, cstrs) -> List.iter (fun (id, _) -> simple_longident id) cstrs | _ -> () diff --git a/parsing/ast_mapper.ml b/parsing/ast_mapper.ml index 174fe08f..dadf5eaa 100644 --- a/parsing/ast_mapper.ml +++ b/parsing/ast_mapper.ml @@ -42,6 +42,7 @@ type mapper = { class_type_declaration: mapper -> class_type_declaration -> class_type_declaration; class_type_field: mapper -> class_type_field -> class_type_field; + constant: mapper -> constant -> constant; constructor_declaration: mapper -> constructor_declaration -> constructor_declaration; expr: mapper -> expression -> expression; @@ -85,6 +86,19 @@ let map_opt f = function None -> None | Some x -> Some (f x) let map_loc sub {loc; txt} = {loc = sub.location sub loc; txt} +module C = struct + (* Constants *) + + let map sub c = match c with + | Pconst_integer _ + | Pconst_char _ + | Pconst_float _ + -> c + | Pconst_string (s, loc, quotation_delimiter) -> + let loc = sub.location sub loc in + Const.string ~loc ?quotation_delimiter s +end + module T = struct (* Type expressions for the core language *) @@ -369,7 +383,7 @@ module E = struct let attrs = sub.attributes sub attrs in match desc with | Pexp_ident x -> ident ~loc ~attrs (map_loc sub x) - | Pexp_constant x -> constant ~loc ~attrs x + | Pexp_constant x -> constant ~loc ~attrs (sub.constant sub x) | Pexp_let (r, vbs, e) -> let_ ~loc ~attrs r (List.map (sub.value_binding sub) vbs) (sub.expr sub e) @@ -463,7 +477,7 @@ module P = struct | Ppat_any -> any ~loc ~attrs () | Ppat_var s -> var ~loc ~attrs (map_loc sub s) | Ppat_alias (p, s) -> alias ~loc ~attrs (sub.pat sub p) (map_loc sub s) - | Ppat_constant c -> constant ~loc ~attrs c + | Ppat_constant c -> constant ~loc ~attrs (sub.constant sub c) | Ppat_interval (c1, c2) -> interval ~loc ~attrs c1 c2 | Ppat_tuple pl -> tuple ~loc ~attrs (List.map (sub.pat sub) pl) | Ppat_construct (l, p) -> @@ -557,6 +571,7 @@ end let default_mapper = { + constant = C.map; structure = (fun this l -> List.map (this.structure_item this) l); structure_item = M.map_structure_item; module_expr = M.map; @@ -731,16 +746,18 @@ let extension_of_error {kind; main; sub} = let str_of_pp pp_msg = Format.asprintf "%t" pp_msg in let extension_of_sub sub = { loc = sub.loc; txt = "ocaml.error" }, - PStr ([Str.eval (Exp.constant (Pconst_string (str_of_pp sub.txt, None)))]) + PStr ([Str.eval (Exp.constant + (Pconst_string (str_of_pp sub.txt, sub.loc, None)))]) in { loc = main.loc; txt = "ocaml.error" }, - PStr (Str.eval (Exp.constant (Pconst_string (str_of_pp main.txt, None))) :: + PStr (Str.eval (Exp.constant + (Pconst_string (str_of_pp main.txt, main.loc, None))) :: List.map (fun msg -> Str.extension (extension_of_sub msg)) sub) let attribute_of_warning loc s = Attr.mk {loc; txt = "ocaml.ppwarning" } - (PStr ([Str.eval ~loc (Exp.constant (Pconst_string (s, None)))])) + (PStr ([Str.eval ~loc (Exp.constant (Pconst_string (s, loc, None)))])) let cookies = ref String.Map.empty @@ -763,7 +780,7 @@ module PpxContext = struct let lid name = { txt = Lident name; loc = Location.none } - let make_string x = Exp.constant (Pconst_string (x, None)) + let make_string s = Exp.constant (Const.string s) let make_bool x = if x @@ -828,7 +845,7 @@ module PpxContext = struct let restore fields = let field name payload = let rec get_string = function - | { pexp_desc = Pexp_constant (Pconst_string (str, None)) } -> str + | { pexp_desc = Pexp_constant (Pconst_string (str, _, None)) } -> str | _ -> raise_errorf "Internal error: invalid [@@@ocaml.ppx.context \ { %s }] string syntax" name and get_bool pexp = diff --git a/parsing/ast_mapper.mli b/parsing/ast_mapper.mli index 80d70fcc..69f6b017 100644 --- a/parsing/ast_mapper.mli +++ b/parsing/ast_mapper.mli @@ -71,6 +71,7 @@ type mapper = { class_type_declaration: mapper -> class_type_declaration -> class_type_declaration; class_type_field: mapper -> class_type_field -> class_type_field; + constant: mapper -> constant -> constant; constructor_declaration: mapper -> constructor_declaration -> constructor_declaration; expr: mapper -> expression -> expression; diff --git a/parsing/asttypes.mli b/parsing/asttypes.mli index 150d9e5f..353d7776 100644 --- a/parsing/asttypes.mli +++ b/parsing/asttypes.mli @@ -23,7 +23,7 @@ type constant = Const_int of int | Const_char of char - | Const_string of string * string option + | Const_string of string * Location.t * string option | Const_float of string | Const_int32 of int32 | Const_int64 of int64 diff --git a/parsing/builtin_attributes.ml b/parsing/builtin_attributes.ml index e270d5a4..af495e90 100644 --- a/parsing/builtin_attributes.ml +++ b/parsing/builtin_attributes.ml @@ -17,7 +17,7 @@ open Asttypes open Parsetree let string_of_cst = function - | Pconst_string(s, _) -> Some s + | Pconst_string(s, _, _) -> Some s | _ -> None let string_of_payload = function @@ -36,7 +36,8 @@ let error_of_extension ext = (({txt = ("ocaml.error"|"error"); loc}, p), _)} -> begin match p with | PStr([{pstr_desc=Pstr_eval - ({pexp_desc=Pexp_constant(Pconst_string(msg,_))}, _)}]) -> + ({pexp_desc=Pexp_constant(Pconst_string(msg,_,_))}, _)} + ]) -> { Location.loc; txt = fun ppf -> Format.pp_print_text ppf msg } | _ -> { Location.loc; txt = fun ppf -> @@ -56,7 +57,7 @@ let error_of_extension ext = begin match p with | PStr [] -> raise Location.Already_displayed_error | PStr({pstr_desc=Pstr_eval - ({pexp_desc=Pexp_constant(Pconst_string(msg,_))}, _)}:: + ({pexp_desc=Pexp_constant(Pconst_string(msg,_,_))}, _)}:: inner) -> let sub = List.map (submessage_from loc txt) inner in Location.error_of_printer ~loc ~sub Format.pp_print_text msg @@ -72,7 +73,7 @@ let kind_and_message = function Pstr_eval ({pexp_desc=Pexp_apply ({pexp_desc=Pexp_ident{txt=Longident.Lident id}}, - [Nolabel,{pexp_desc=Pexp_constant (Pconst_string(s,_))}]) + [Nolabel,{pexp_desc=Pexp_constant (Pconst_string(s,_,_))}]) },_)}] -> Some (id, s) | PStr[ @@ -187,7 +188,7 @@ let warning_attribute ?(ppwarning = true) = let process_alert loc txt = function | PStr[{pstr_desc= Pstr_eval( - {pexp_desc=Pexp_constant(Pconst_string(s,_))}, + {pexp_desc=Pexp_constant(Pconst_string(s,_,_))}, _) }] -> begin try Warnings.parse_alert_option s @@ -216,7 +217,7 @@ let warning_attribute ?(ppwarning = true) = attr_payload = PStr [ { pstr_desc= - Pstr_eval({pexp_desc=Pexp_constant (Pconst_string (s, _))},_); + Pstr_eval({pexp_desc=Pexp_constant (Pconst_string (s, _, _))},_); pstr_loc } ]; } when ppwarning -> diff --git a/parsing/docstrings.ml b/parsing/docstrings.ml index 7e3a2bec..987365aa 100644 --- a/parsing/docstrings.ml +++ b/parsing/docstrings.ml @@ -89,18 +89,20 @@ let doc_loc = {txt = "ocaml.doc"; loc = Location.none} let docs_attr ds = let open Parsetree in + let body = ds.ds_body in + let loc = ds.ds_loc in let exp = - { pexp_desc = Pexp_constant (Pconst_string(ds.ds_body, None)); - pexp_loc = ds.ds_loc; + { pexp_desc = Pexp_constant (Pconst_string(body, loc, None)); + pexp_loc = loc; pexp_loc_stack = []; pexp_attributes = []; } in let item = - { pstr_desc = Pstr_eval (exp, []); pstr_loc = exp.pexp_loc } + { pstr_desc = Pstr_eval (exp, []); pstr_loc = loc } in { attr_name = doc_loc; attr_payload = PStr [item]; - attr_loc = Location.none } + attr_loc = loc } let add_docs_attrs docs attrs = let attrs = @@ -139,18 +141,20 @@ let text_loc = {txt = "ocaml.text"; loc = Location.none} let text_attr ds = let open Parsetree in + let body = ds.ds_body in + let loc = ds.ds_loc in let exp = - { pexp_desc = Pexp_constant (Pconst_string(ds.ds_body, None)); - pexp_loc = ds.ds_loc; + { pexp_desc = Pexp_constant (Pconst_string(body, loc, None)); + pexp_loc = loc; pexp_loc_stack = []; pexp_attributes = []; } in let item = - { pstr_desc = Pstr_eval (exp, []); pstr_loc = exp.pexp_loc } + { pstr_desc = Pstr_eval (exp, []); pstr_loc = loc } in { attr_name = text_loc; attr_payload = PStr [item]; - attr_loc = Location.none } + attr_loc = loc } let add_text_attrs dsl attrs = let fdsl = List.filter (function {ds_body=""} -> false| _ ->true) dsl in diff --git a/parsing/lexer.mll b/parsing/lexer.mll index 8d6411dc..6d68b59e 100644 --- a/parsing/lexer.mll +++ b/parsing/lexer.mll @@ -124,15 +124,37 @@ let store_escaped_char lexbuf c = let store_escaped_uchar lexbuf u = if in_comment () then store_lexeme lexbuf else store_string_utf_8_uchar u -let with_comment_buffer comment lexbuf = +let compute_quoted_string_idloc {Location.loc_start = orig_loc } shift id = + let id_start_pos = orig_loc.Lexing.pos_cnum + shift in + let loc_start = + Lexing.{orig_loc with pos_cnum = id_start_pos } + in + let loc_end = + Lexing.{orig_loc with pos_cnum = id_start_pos + String.length id} + in + {Location. loc_start ; loc_end ; loc_ghost = false } + +let wrap_string_lexer f lexbuf = + let loc_start = lexbuf.lex_curr_p in + reset_string_buffer(); + is_in_string := true; + let string_start = lexbuf.lex_start_p in + string_start_loc := Location.curr lexbuf; + let loc_end = f lexbuf in + is_in_string := false; + lexbuf.lex_start_p <- string_start; + let loc = Location.{loc_ghost= false; loc_start; loc_end} in + get_stored_string (), loc + +let wrap_comment_lexer comment lexbuf = let start_loc = Location.curr lexbuf in comment_start_loc := [start_loc]; reset_string_buffer (); let end_loc = comment lexbuf in let s = get_stored_string () in reset_string_buffer (); - let loc = { start_loc with Location.loc_end = end_loc.Location.loc_end } in - s, loc + s, + { start_loc with Location.loc_end = end_loc.Location.loc_end } let error lexbuf e = raise (Error(e, Location.curr lexbuf)) let error_loc loc e = raise (Error(e, loc)) @@ -316,6 +338,9 @@ let dotsymbolchar = let kwdopchar = ['$' '&' '*' '+' '-' '/' '<' '=' '>' '@' '^' '|'] +let ident = (lowercase | uppercase) identchar* +let extattrident = ident ('.' ident)* + let decimal_literal = ['0'-'9'] ['0'-'9' '_']* let hex_digit = @@ -389,23 +414,31 @@ rule token = parse | (float_literal | hex_float_literal | int_literal) identchar+ as invalid { error lexbuf (Invalid_literal invalid) } | "\"" - { reset_string_buffer(); - is_in_string := true; - let string_start = lexbuf.lex_start_p in - string_start_loc := Location.curr lexbuf; - string lexbuf; - is_in_string := false; - lexbuf.lex_start_p <- string_start; - STRING (get_stored_string(), None) } + { let s, loc = wrap_string_lexer string lexbuf in + STRING (s, loc, None) } | "{" (lowercase* as delim) "|" - { reset_string_buffer(); - is_in_string := true; - let string_start = lexbuf.lex_start_p in - string_start_loc := Location.curr lexbuf; - quoted_string delim lexbuf; - is_in_string := false; - lexbuf.lex_start_p <- string_start; - STRING (get_stored_string(), Some delim) } + { let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in + STRING (s, loc, Some delim) } + | "{%" (extattrident as id) "|" + { let orig_loc = Location.curr lexbuf in + let s, loc = wrap_string_lexer (quoted_string "") lexbuf in + let idloc = compute_quoted_string_idloc orig_loc 2 id in + QUOTED_STRING_EXPR (id, idloc, s, loc, Some "") } + | "{%" (extattrident as id) blank+ (lowercase* as delim) "|" + { let orig_loc = Location.curr lexbuf in + let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in + let idloc = compute_quoted_string_idloc orig_loc 2 id in + QUOTED_STRING_EXPR (id, idloc, s, loc, Some delim) } + | "{%%" (extattrident as id) "|" + { let orig_loc = Location.curr lexbuf in + let s, loc = wrap_string_lexer (quoted_string "") lexbuf in + let idloc = compute_quoted_string_idloc orig_loc 3 id in + QUOTED_STRING_ITEM (id, idloc, s, loc, Some "") } + | "{%%" (extattrident as id) blank+ (lowercase* as delim) "|" + { let orig_loc = Location.curr lexbuf in + let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in + let idloc = compute_quoted_string_idloc orig_loc 3 id in + QUOTED_STRING_ITEM (id, idloc, s, loc, Some delim) } | "\'" newline "\'" { update_loc lexbuf None 1 false 1; (* newline is ('\013'* '\010') *) @@ -423,10 +456,10 @@ rule token = parse | "\'" ("\\" _ as esc) { error lexbuf (Illegal_escape (esc, None)) } | "(*" - { let s, loc = with_comment_buffer comment lexbuf in + { let s, loc = wrap_comment_lexer comment lexbuf in COMMENT (s, loc) } | "(**" - { let s, loc = with_comment_buffer comment lexbuf in + { let s, loc = wrap_comment_lexer comment lexbuf in if !handle_docstrings then DOCSTRING (Docstrings.docstring s loc) else @@ -434,7 +467,7 @@ rule token = parse } | "(**" (('*'+) as stars) { let s, loc = - with_comment_buffer + wrap_comment_lexer (fun lexbuf -> store_string ("*" ^ stars); comment lexbuf) @@ -444,7 +477,7 @@ rule token = parse | "(*)" { if !print_warnings then Location.prerr_warning (Location.curr lexbuf) Warnings.Comment_start; - let s, loc = with_comment_buffer comment lexbuf in + let s, loc = wrap_comment_lexer comment lexbuf in COMMENT (s, loc) } | "(*" (('*'*) as stars) "*)" { if !handle_docstrings && stars="" then @@ -575,7 +608,7 @@ and comment = parse string_start_loc := Location.curr lexbuf; store_string_char '\"'; is_in_string := true; - begin try string lexbuf + let _loc = try string lexbuf with Error (Unterminated_string, str_start) -> match !comment_start_loc with | [] -> assert false @@ -583,16 +616,16 @@ and comment = parse let start = List.hd (List.rev !comment_start_loc) in comment_start_loc := []; error_loc loc (Unterminated_string_in_comment (start, str_start)) - end; + in is_in_string := false; store_string_char '\"'; comment lexbuf } - | "{" (lowercase* as delim) "|" + | "{" ('%' '%'? extattrident blank*)? (lowercase* as delim) "|" { string_start_loc := Location.curr lexbuf; store_lexeme lexbuf; is_in_string := true; - begin try quoted_string delim lexbuf + let _loc = try quoted_string delim lexbuf with Error (Unterminated_string, str_start) -> match !comment_start_loc with | [] -> assert false @@ -600,13 +633,12 @@ and comment = parse let start = List.hd (List.rev !comment_start_loc) in comment_start_loc := []; error_loc loc (Unterminated_string_in_comment (start, str_start)) - end; + in is_in_string := false; store_string_char '|'; store_string delim; store_string_char '}'; comment lexbuf } - | "\'\'" { store_lexeme lexbuf; comment lexbuf } | "\'" newline "\'" @@ -637,14 +669,14 @@ and comment = parse store_lexeme lexbuf; comment lexbuf } - | (lowercase | uppercase) identchar * + | ident { store_lexeme lexbuf; comment lexbuf } | _ { store_lexeme lexbuf; comment lexbuf } and string = parse '\"' - { () } + { lexbuf.lex_start_p } | '\\' newline ([' ' '\t'] * as space) { update_loc lexbuf None 1 false (String.length space); if in_comment () then store_lexeme lexbuf; @@ -701,7 +733,7 @@ and quoted_string delim = parse error_loc !string_start_loc Unterminated_string } | "|" (lowercase* as edelim) "}" { - if delim = edelim then () + if delim = edelim then lexbuf.lex_start_p else (store_lexeme lexbuf; quoted_string delim lexbuf) } | (_ as c) diff --git a/parsing/location.ml b/parsing/location.ml index c2d46dd6..aa596c85 100644 --- a/parsing/location.ml +++ b/parsing/location.ml @@ -24,6 +24,7 @@ let in_file name = ;; let none = in_file "_none_";; +let is_none l = (l = none);; let curr lexbuf = { loc_start = lexbuf.lex_start_p; diff --git a/parsing/location.mli b/parsing/location.mli index 784c9694..ecf39b21 100644 --- a/parsing/location.mli +++ b/parsing/location.mli @@ -38,6 +38,9 @@ type t = Warnings.loc = { 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. *) diff --git a/parsing/longident.ml b/parsing/longident.ml index 6f5d5398..eaafb02b 100644 --- a/parsing/longident.ml +++ b/parsing/longident.ml @@ -30,6 +30,7 @@ let last = function | Ldot(_, s) -> s | Lapply(_, _) -> Misc.fatal_error "Longident.last" + let rec split_at_dots s pos = try let dot = String.index_from s pos '.' in diff --git a/parsing/longident.mli b/parsing/longident.mli index b3079452..07086301 100644 --- a/parsing/longident.mli +++ b/parsing/longident.mli @@ -27,8 +27,34 @@ type t = val flatten: t -> string list val unflatten: string list -> t option +(** For a non-empty list [l], [unflatten l] is [Some lid] where [lid] is + the long identifier created by concatenating the elements of [l] + with [Ldot]. + [unflatten []] is [None]. +*) + val last: t -> string val parse: string -> t +[@@deprecated "this function may misparse its input,\n\ +use \"Parse.longident\" or \"Longident.unflatten\""] +(** + + This function is broken on identifiers that are not just "Word.Word.word"; + for example, it returns incorrect results on infix operators + and extended module paths. + + If you want to generate long identifiers that are a list of + dot-separated identifiers, the function {!unflatten} is safer and faster. + {!unflatten} is available since OCaml 4.06.0. + + If you want to parse any identifier correctly, use the long-identifiers + functions from the {!Parse} module, in particular {!Parse.longident}. + They are available since OCaml 4.11, and also provide proper + input-location support. + +*) + + (** To print a longident, see {!Pprintast.longident}, using {!Format.asprintf} to convert to a string. *) diff --git a/parsing/parse.ml b/parsing/parse.ml index e7455947..b0cee445 100644 --- a/parsing/parse.ml +++ b/parsing/parse.ml @@ -121,7 +121,13 @@ and core_type = wrap_menhir Parser.Incremental.parse_core_type and expression = wrap_menhir Parser.Incremental.parse_expression and pattern = wrap_menhir Parser.Incremental.parse_pattern - +let longident = wrap_menhir Parser.Incremental.parse_any_longident +let val_ident = wrap_menhir Parser.Incremental.parse_val_longident +let constr_ident= wrap_menhir Parser.Incremental.parse_constr_longident +let extended_module_path = + wrap_menhir Parser.Incremental.parse_mod_ext_longident +let simple_module_path = wrap_menhir Parser.Incremental.parse_mod_longident +let type_ident = wrap_menhir Parser.Incremental.parse_mty_longident (* Error reporting for Syntaxerr *) (* The code has been moved here so that one can reuse Pprintast.tyvar *) diff --git a/parsing/parse.mli b/parsing/parse.mli index eb8b0b0d..699e6bad 100644 --- a/parsing/parse.mli +++ b/parsing/parse.mli @@ -27,3 +27,82 @@ val use_file : Lexing.lexbuf -> Parsetree.toplevel_phrase list val core_type : Lexing.lexbuf -> Parsetree.core_type val expression : Lexing.lexbuf -> Parsetree.expression val pattern : Lexing.lexbuf -> Parsetree.pattern + +(** The functions below can be used to parse Longident safely. *) + +val longident: Lexing.lexbuf -> Longident.t +(** + The function [longident] is guaranted to parse all subclasses + of {!Longident.t} used in OCaml: values, constructors, simple or extended + module paths, and types or module types. + + However, this function accepts inputs which are not accepted by the + compiler, because they combine functor applications and infix operators. + In valid OCaml syntax, only value-level identifiers may end with infix + operators [Foo.( + )]. + Moreover, in value-level identifiers the module path [Foo] must be simple + ([M.N] rather than [F(X)]): functor applications may only appear in + type-level identifiers. + As a consequence, a path such as [F(X).( + )] is not a valid OCaml + identifier; but it is accepted by this function. +*) + +(** The next functions are specialized to a subclass of {!Longident.t} *) + +val val_ident: Lexing.lexbuf -> Longident.t +(** + This function parses a syntactically valid path for a value. For instance, + [x], [M.x], and [(+.)] are valid. Contrarily, [M.A], [F(X).x], and [true] + are rejected. + + Longident for OCaml's value cannot contain functor application. + The last component of the {!Longident.t} is not capitalized, + but can be an operator [A.Path.To.(.%.%.(;..)<-)] +*) + +val constr_ident: Lexing.lexbuf -> Longident.t +(** + This function parses a syntactically valid path for a variant constructor. + For instance, [A], [M.A] and [M.(::)] are valid, but both [M.a] + and [F(X).A] are rejected. + + Longident for OCaml's variant constructors cannot contain functor + application. + The last component of the {!Longident.t} is capitalized, + or it may be one the special constructors: [true],[false],[()],[[]],[(::)]. + Among those special constructors, only [(::)] can be prefixed by a module + path ([A.B.C.(::)]). +*) + + +val simple_module_path: Lexing.lexbuf -> Longident.t +(** + This function parses a syntactically valid path for a module. + For instance, [A], and [M.A] are valid, but both [M.a] + and [F(X).A] are rejected. + + Longident for OCaml's module cannot contain functor application. + The last component of the {!Longident.t} is capitalized. +*) + + +val extended_module_path: Lexing.lexbuf -> Longident.t +(** + This function parse syntactically valid path for an extended module. + For instance, [A.B] and [F(A).B] are valid. Contrarily, + [(.%())] or [[]] are both rejected. + + The last component of the {!Longident.t} is capitalized. + +*) + +val type_ident: Lexing.lexbuf -> Longident.t +(** + This function parse syntactically valid path for a type or a module type. + For instance, [A], [t], [M.t] and [F(X).t] are valid. Contrarily, + [(.%())] or [[]] are both rejected. + + In path for type and module types, only operators and special constructors + are rejected. + +*) diff --git a/parsing/parser.mly b/parsing/parser.mly index f6206179..12e18186 100644 --- a/parsing/parser.mly +++ b/parsing/parser.mly @@ -418,6 +418,11 @@ let wrap_sig_ext ~loc body ext = let wrap_mksig_ext ~loc (item, ext) = wrap_sig_ext ~loc (mksig ~loc item) ext +let mk_quotedext ~loc (id, idloc, str, strloc, delim) = + let exp_id = mkloc id idloc in + let e = ghexp ~loc (Pexp_constant (Pconst_string (str, strloc, delim))) in + (exp_id, PStr [mkstrexp e []]) + let text_str pos = Str.text (rhs_text pos) let text_sig pos = Sig.text (rhs_text pos) let text_cstr pos = Cf.text (rhs_text pos) @@ -677,7 +682,11 @@ let mk_directive ~loc name arg = %token HASHOP %token SIG %token STAR -%token STRING +%token STRING +%token + QUOTED_STRING_EXPR +%token + QUOTED_STRING_ITEM %token STRUCT %token THEN %token TILDE @@ -759,7 +768,7 @@ The precedences must be listed from low to high. %nonassoc BACKQUOTE BANG BEGIN CHAR FALSE FLOAT INT LBRACE LBRACELESS LBRACKET LBRACKETBAR LIDENT LPAREN NEW PREFIXOP STRING TRUE UIDENT - LBRACKETPERCENT + LBRACKETPERCENT QUOTED_STRING_EXPR /* Entry points */ @@ -778,6 +787,18 @@ The precedences must be listed from low to high. %type parse_expression %start parse_pattern %type parse_pattern +%start parse_constr_longident +%type parse_constr_longident +%start parse_val_longident +%type parse_val_longident +%start parse_mty_longident +%type parse_mty_longident +%start parse_mod_ext_longident +%type parse_mod_ext_longident +%start parse_mod_longident +%type parse_mod_longident +%start parse_any_longident +%type parse_any_longident %% /* macros */ @@ -1119,6 +1140,35 @@ parse_pattern: { $1 } ; +parse_mty_longident: + mty_longident EOF + { $1 } +; + +parse_val_longident: + val_longident EOF + { $1 } +; + +parse_constr_longident: + constr_longident EOF + { $1 } +; + +parse_mod_ext_longident: + mod_ext_longident EOF + { $1 } +; + +parse_mod_longident: + mod_longident EOF + { $1 } +; + +parse_any_longident: + any_longident EOF + { $1 } +; (* -------------------------------------------------------------------------- *) (* Functor arguments appear in module expressions and module types. *) @@ -3223,7 +3273,7 @@ atomic_type: { Ptyp_object ([], Closed) } | tys = actual_type_parameters HASH - cid = mkrhs(class_longident) + cid = mkrhs(clty_longident) { Ptyp_class(cid, tys) } | LBRACKET tag_field RBRACKET (* not row_field; see CONFLICTS *) @@ -3348,7 +3398,7 @@ meth_list: constant: | INT { let (n, m) = $1 in Pconst_integer (n, m) } | CHAR { Pconst_char $1 } - | STRING { let (s, d) = $1 in Pconst_string (s, d) } + | STRING { let (s, strloc, d) = $1 in Pconst_string (s, strloc, d) } | FLOAT { let (f, m) = $1 in Pconst_float (f, m) } ; signed_constant: @@ -3365,13 +3415,16 @@ ident: UIDENT { $1 } | LIDENT { $1 } ; -val_ident: - LIDENT { $1 } +val_extra_ident: | LPAREN operator RPAREN { $2 } | LPAREN operator error { unclosed "(" $loc($1) ")" $loc($3) } | LPAREN error { expecting $loc($2) "operator" } | LPAREN MODULE error { expecting $loc($3) "module-expr" } ; +val_ident: + LIDENT { $1 } + | val_extra_ident { $1 } +; operator: PREFIXOP { $1 } | LETOP { $1 } @@ -3412,59 +3465,68 @@ index_mod: | { "" } | SEMI DOTDOT { ";.." } ; -constr_ident: - UIDENT { $1 } + +%inline constr_extra_ident: + | LPAREN COLONCOLON RPAREN { "::" } +; +constr_extra_nonprefix_ident: | LBRACKET RBRACKET { "[]" } | LPAREN RPAREN { "()" } - | LPAREN COLONCOLON RPAREN { "::" } | FALSE { "false" } | TRUE { "true" } ; - -val_longident: - val_ident { Lident $1 } - | mod_longident DOT val_ident { Ldot($1, $3) } +constr_ident: + UIDENT { $1 } + | constr_extra_ident { $1 } + | constr_extra_nonprefix_ident { $1 } ; constr_longident: - mod_longident %prec below_DOT { $1 } - | mod_longident DOT LPAREN COLONCOLON RPAREN { Ldot($1,"::") } - | LBRACKET RBRACKET { Lident "[]" } - | LPAREN RPAREN { Lident "()" } - | LPAREN COLONCOLON RPAREN { Lident "::" } - | FALSE { Lident "false" } - | TRUE { Lident "true" } + mod_longident %prec below_DOT { $1 } /* A.B.x vs (A).B.x */ + | mod_longident DOT constr_extra_ident { Ldot($1,$3) } + | constr_extra_ident { Lident $1 } + | constr_extra_nonprefix_ident { Lident $1 } +; +mk_longident(prefix,final): + | final { Lident $1 } + | prefix DOT final { Ldot($1,$3) } +; +val_longident: + mk_longident(mod_longident, val_ident) { $1 } ; label_longident: - LIDENT { Lident $1 } - | mod_longident DOT LIDENT { Ldot($1, $3) } + mk_longident(mod_longident, LIDENT) { $1 } ; type_longident: - LIDENT { Lident $1 } - | mod_ext_longident DOT LIDENT { Ldot($1, $3) } + mk_longident(mod_ext_longident, LIDENT) { $1 } ; mod_longident: - UIDENT { Lident $1 } - | mod_longident DOT UIDENT { Ldot($1, $3) } + mk_longident(mod_longident, UIDENT) { $1 } ; mod_ext_longident: - UIDENT { Lident $1 } - | mod_ext_longident DOT UIDENT { Ldot($1, $3) } + mk_longident(mod_ext_longident, UIDENT) { $1 } | mod_ext_longident LPAREN mod_ext_longident RPAREN { lapply ~loc:$sloc $1 $3 } | mod_ext_longident LPAREN error { expecting $loc($3) "module path" } ; mty_longident: - ident { Lident $1 } - | mod_ext_longident DOT ident { Ldot($1, $3) } + mk_longident(mod_ext_longident,ident) { $1 } ; clty_longident: - LIDENT { Lident $1 } - | mod_ext_longident DOT LIDENT { Ldot($1, $3) } + mk_longident(mod_ext_longident,LIDENT) { $1 } ; class_longident: - LIDENT { Lident $1 } - | mod_longident DOT LIDENT { Ldot($1, $3) } + mk_longident(mod_longident,LIDENT) { $1 } +; + +/* For compiler-libs: parse all valid longidents and a little more: + final identifiers which are value specific are accepted even when + the path prefix is only valid for types: (e.g. F(X).(::)) */ +any_longident: + | mk_longident (mod_ext_longident, + ident | constr_extra_ident | val_extra_ident { $1 } + ) { $1 } + | constr_extra_nonprefix_ident { Lident $1 } ; /* Toplevel directives */ @@ -3476,7 +3538,7 @@ toplevel_directive: ; %inline toplevel_directive_argument: - | STRING { let (s, _) = $1 in Pdir_string s } + | STRING { let (s, _, _) = $1 in Pdir_string s } | INT { let (n, m) = $1 in Pdir_int (n ,m) } | val_longident { Pdir_ident $1 } | mod_longident { Pdir_ident $1 } @@ -3494,7 +3556,7 @@ toplevel_directive: %inline raw_string: s = STRING - { fst s } + { let body, _, _ = s in body } ; name_tag: @@ -3680,10 +3742,14 @@ ext: ext attributes { $1, $2 } ; extension: - LBRACKETPERCENT attr_id payload RBRACKET { ($2, $3) } + | LBRACKETPERCENT attr_id payload RBRACKET { ($2, $3) } + | QUOTED_STRING_EXPR + { mk_quotedext ~loc:$sloc $1 } ; item_extension: - LBRACKETPERCENTPERCENT attr_id payload RBRACKET { ($2, $3) } + | LBRACKETPERCENTPERCENT attr_id payload RBRACKET { ($2, $3) } + | QUOTED_STRING_ITEM + { mk_quotedext ~loc:$sloc $1 } ; payload: structure { PStr $1 } diff --git a/parsing/parsetree.mli b/parsing/parsetree.mli index 3f943210..0712f87c 100644 --- a/parsing/parsetree.mli +++ b/parsing/parsetree.mli @@ -31,9 +31,11 @@ type constant = *) | Pconst_char of char (* 'c' *) - | Pconst_string of string * string option + | Pconst_string of string * Location.t * string option (* "constant" {delim|other constant|delim} + + The location span the content of the string, without the delimiters. *) | Pconst_float of string * char option (* 3.4 2e5 1.4e-4 diff --git a/parsing/pprintast.ml b/parsing/pprintast.ml index 2555059f..d731bdff 100644 --- a/parsing/pprintast.ml +++ b/parsing/pprintast.ml @@ -221,9 +221,9 @@ let longident_loc f x = pp f "%a" longident x.txt let constant f = function | Pconst_char i -> pp f "%C" i - | Pconst_string (i, None) -> + | Pconst_string (i, _, None) -> pp f "%S" i - | Pconst_string (i, Some delim) -> + | Pconst_string (i, _, Some delim) -> pp f "{%s|%s|%s}" delim i delim | Pconst_integer (i, None) -> paren (first_is '-' i) (fun f -> pp f "%s") f i diff --git a/parsing/printast.ml b/parsing/printast.ml index 30a0eeb3..4e3ef2b2 100644 --- a/parsing/printast.ml +++ b/parsing/printast.ml @@ -28,10 +28,13 @@ let fmt_position with_name f l = ;; let fmt_location f loc = - let p_2nd_name = loc.loc_start.pos_fname <> loc.loc_end.pos_fname in - fprintf f "(%a..%a)" (fmt_position true) loc.loc_start - (fmt_position p_2nd_name) loc.loc_end; - if loc.loc_ghost then fprintf f " ghost"; + if not !Clflags.locations then () + else begin + let p_2nd_name = loc.loc_start.pos_fname <> loc.loc_end.pos_fname in + fprintf f "(%a..%a)" (fmt_position true) loc.loc_start + (fmt_position p_2nd_name) loc.loc_end; + if loc.loc_ghost then fprintf f " ghost"; + end ;; let rec fmt_longident_aux f x = @@ -64,9 +67,10 @@ 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_string (s, None) -> fprintf f "PConst_string(%S,None)" s; - | Pconst_string (s, Some delim) -> - fprintf f "PConst_string (%S,Some %S)" s delim; + | Pconst_string (s, strloc, None) -> + 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; ;; diff --git a/runtime/.depend b/runtime/.depend index 9f829455..9f5d2fdf 100644 --- a/runtime/.depend +++ b/runtime/.depend @@ -1,23 +1,115 @@ -afl_b.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ +interp_b.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ + caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ + caml/startup_aux.h caml/jumptbl.h +misc_b.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h +stacks_b.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +fix_code_b.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ + caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +startup_aux_b.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h + caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ + caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \ + caml/roots.h +startup_byt_b.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ + caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \ + caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \ + caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \ + caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \ + caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \ + caml/startup.h caml/startup_aux.h caml/version.h +freelist_b.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ + caml/mlvalues.h caml/eventlog.h +major_gc_b.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ + caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h +minor_gc_b.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_b.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h alloc_b.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ caml/stacks.h caml/memory.h caml/signals.h -array_b.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ +roots_byt_b.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ + caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \ + caml/eventlog.h +globroots_b.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_b.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +fail_byt_b.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h + caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/stacks.h caml/memory.h +signals_b.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ + caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ + caml/roots.h caml/finalise.h +signals_byt_b.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ + caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ + caml/signals.h caml/signals_machdep.h +printexc_b.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ + caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/memprof.h caml/roots.h caml/memory.h backtrace_byt_b.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ @@ -26,720 +118,304 @@ backtrace_byt_b.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_b.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_b.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +backtrace_b.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_b.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ - caml/stacks.h caml/memory.h -clambda_checks_b.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_b.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h compare_b.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ caml/mlvalues.h -custom_b.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ +ints_b.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/signals.h -debugger_b.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h caml/misc.h caml/mlvalues.h +eventlog_b.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ - caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ - caml/stacks.h caml/sys.h -domain_b.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h +floats_b.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h +str_b.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -dynlink_b.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_b.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_b.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h +io_b.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ + caml/signals.h caml/sys.h extern_b.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_b.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +intern_b.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_b.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h +sys_b.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ + caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ + caml/startup_aux.h +meta_b.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ caml/stacks.h caml/memory.h -fail_nat_b.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +parsing_b.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_b.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stacks.h caml/startup_aux.h +md5_b.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/mlvalues.h caml/io.h caml/reverse.h +obj_b.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ + caml/signals.h caml/spacetime.h caml/io.h caml/stack.h +lexing_b.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +callback_b.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ + caml/stacks.h caml/memory.h +debugger_b.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ + caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ + caml/stacks.h caml/sys.h +weak_b.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_b.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stack.h caml/roots.h caml/memory.h caml/callback.h + caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h finalise_b.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ caml/roots.h caml/signals.h -fix_code_b.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_b.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h -freelist_b.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_b.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \ - caml/startup_aux.h -globroots_b.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_b.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_b.$(O): instrtrace.c -intern_b.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h -interp_b.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ - caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ - caml/startup_aux.h caml/jumptbl.h -ints_b.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h -io_b.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/signals.h caml/sys.h -lexing_b.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_b.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -major_gc_b.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h -md5_b.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/io.h caml/reverse.h -memory_b.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_b.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_b.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h -minor_gc_b.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_b.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h -obj_b.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_b.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_b.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h -printexc_b.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ - caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/memprof.h caml/roots.h caml/memory.h -roots_byt_b.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_b.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h -signals_b.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ - caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ - caml/roots.h caml/finalise.h -signals_byt_b.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ - caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ - caml/signals.h caml/signals_machdep.h -signals_nat_b.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_b.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h -spacetime_nat_b.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ - caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ - caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -spacetime_snapshot_b.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \ - caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -stacks_b.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -startup_aux_b.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ - caml/osdeps.h caml/memory.h caml/startup_aux.h -startup_byt_b.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_b.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h -str_b.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h -sys_b.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ - caml/startup_aux.h -unix_b.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_b.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_b.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_bd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -alloc_bd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/stacks.h caml/memory.h caml/signals.h -array_bd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_bd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_bd.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ - caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ - caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ - caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ - caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_bd.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_bd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_bd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ - caml/stacks.h caml/memory.h -clambda_checks_bd.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_bd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h -compare_bd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h -custom_bd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +custom_b.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/signals.h -debugger_bd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ - caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ - caml/stacks.h caml/sys.h -domain_bd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -dynlink_bd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_bd.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h -extern_bd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_bd.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stacks.h caml/memory.h -fail_nat_bd.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_bd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ - caml/roots.h caml/signals.h -fix_code_bd.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/mlvalues.h caml/signals.h +dynlink_b.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_bd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h -freelist_bd.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_bd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \ - caml/startup_aux.h -globroots_bd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_bd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_bd.$(O): instrtrace.c caml/instrtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/instruct.h caml/misc.h caml/mlvalues.h \ - caml/opnames.h caml/prims.h caml/stacks.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/startup_aux.h -intern_bd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h -interp_bd.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ - caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ - caml/startup_aux.h -ints_bd.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/prims.h caml/signals.h +spacetime_byt_b.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/mlvalues.h +afl_b.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h -io_bd.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/domain.h +unix_b.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/signals.h caml/sys.h -lexing_bd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h +bigarray_b.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_bd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/signals.h +main_b.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h -major_gc_bd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h -md5_bd.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/io.h caml/reverse.h -memory_bd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_bd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ +memprof_b.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_bd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_b.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +win32_b.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h -minor_gc_bd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +instrtrace_b.$(O): instrtrace.c +interp_bd.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ + caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ + caml/startup_aux.h misc_bd.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ caml/version.h -obj_bd.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_bd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_bd.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h -printexc_bd.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ - caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/memprof.h caml/roots.h caml/memory.h -roots_byt_bd.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_bd.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h -signals_bd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ - caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ - caml/roots.h caml/finalise.h -signals_byt_bd.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ - caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ - caml/signals.h caml/signals_machdep.h -signals_nat_bd.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_bd.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h -spacetime_nat_bd.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ - caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ - caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -spacetime_snapshot_bd.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \ - caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h stacks_bd.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h +fix_code_bd.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ + caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h startup_aux_bd.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ - caml/osdeps.h caml/memory.h caml/startup_aux.h + caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \ + caml/roots.h startup_byt_bd.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_bd.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h -str_bd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \ + caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \ + caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \ + caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \ + caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \ + caml/startup.h caml/startup_aux.h caml/version.h +freelist_bd.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h -sys_bd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ - caml/startup_aux.h -unix_bd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ + caml/mlvalues.h caml/eventlog.h +major_gc_bd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_bd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_bd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_bi.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -alloc_bi.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ + caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h +minor_gc_bd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_bd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_bd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ caml/stacks.h caml/memory.h caml/signals.h -array_bi.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ +roots_byt_bd.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ + caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \ + caml/eventlog.h +globroots_bd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_bi.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +fail_byt_bd.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_bi.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ + caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/stacks.h caml/memory.h +signals_bd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ + caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ + caml/roots.h caml/finalise.h +signals_byt_bd.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ + caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ + caml/signals.h caml/signals_machdep.h +printexc_bd.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ + caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/memprof.h caml/roots.h caml/memory.h +backtrace_byt_bd.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ @@ -747,132 +423,196 @@ backtrace_byt_bi.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_bi.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_bi.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +backtrace_bd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_bi.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ - caml/stacks.h caml/memory.h -clambda_checks_bi.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_bi.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h -compare_bi.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +compare_bd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ caml/mlvalues.h -custom_bi.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ +ints_bd.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/signals.h -debugger_bi.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h caml/misc.h caml/mlvalues.h +eventlog_bd.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ - caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ - caml/stacks.h caml/sys.h -domain_bi.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h +floats_bd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h +str_bd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -dynlink_bi.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_bd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_bi.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h -extern_bi.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h +io_bd.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ + caml/signals.h caml/sys.h +extern_bd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_bi.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +intern_bd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_bd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h +sys_bd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ + caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ + caml/startup_aux.h +meta_bd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ caml/stacks.h caml/memory.h -fail_nat_bi.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +parsing_bd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_bd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stacks.h caml/startup_aux.h +md5_bd.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/mlvalues.h caml/io.h caml/reverse.h +obj_bd.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ + caml/signals.h caml/spacetime.h caml/io.h caml/stack.h +lexing_bd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +callback_bd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ + caml/stacks.h caml/memory.h +debugger_bd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ + caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ + caml/stacks.h caml/sys.h +weak_bd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_bd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_bi.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_bd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ caml/roots.h caml/signals.h -fix_code_bi.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_bi.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +custom_bd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h -freelist_bi.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/mlvalues.h caml/signals.h +dynlink_bd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_bi.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \ - caml/startup_aux.h -globroots_bi.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_bi.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_bi.$(O): instrtrace.c -intern_bi.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/prims.h caml/signals.h +spacetime_byt_bd.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/mlvalues.h +afl_bd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h +unix_bd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h +bigarray_bd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/signals.h +main_bd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h + caml/domain.h +memprof_bd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_bd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +win32_bd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +instrtrace_bd.$(O): instrtrace.c caml/instrtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/instruct.h caml/misc.h caml/mlvalues.h \ + caml/opnames.h caml/prims.h caml/stacks.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/startup_aux.h interp_bi.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ @@ -881,104 +621,91 @@ interp_bi.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ caml/startup_aux.h caml/jumptbl.h -ints_bi.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h -io_bi.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/signals.h caml/sys.h -lexing_bi.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_bi.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ +misc_bi.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h +stacks_bi.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +fix_code_bi.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ + caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +startup_aux_bi.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h + caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ + caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \ + caml/roots.h +startup_byt_bi.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ + caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \ + caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \ + caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \ + caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \ + caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \ + caml/startup.h caml/startup_aux.h caml/version.h +freelist_bi.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ + caml/mlvalues.h caml/eventlog.h major_gc_bi.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h -md5_bi.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/io.h caml/reverse.h -memory_bi.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_bi.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_bi.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h minor_gc_bi.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_bi.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h -obj_bi.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_bi.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_bi.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h -printexc_bi.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ - caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/memprof.h caml/roots.h caml/memory.h + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_bi.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_bi.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/stacks.h caml/memory.h caml/signals.h roots_byt_bi.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_bi.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h + caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \ + caml/eventlog.h +globroots_bi.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +fail_byt_bi.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/stacks.h caml/memory.h signals_bi.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ @@ -992,68 +719,77 @@ signals_byt_bi.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ caml/signals.h caml/signals_machdep.h -signals_nat_bi.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ +printexc_bi.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ + caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_bi.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h -spacetime_nat_bi.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ - caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ - caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -spacetime_snapshot_bi.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \ - caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -stacks_bi.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ + caml/memprof.h caml/roots.h caml/memory.h +backtrace_byt_bi.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ + caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ + caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ + caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ + caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h +backtrace_bi.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -startup_aux_bi.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ - caml/osdeps.h caml/memory.h caml/startup_aux.h -startup_byt_bi.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_bi.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +compare_bi.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h +ints_bi.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h + caml/domain.h caml/misc.h caml/mlvalues.h +eventlog_bi.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h +floats_bi.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h str_bi.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_bi.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h +io_bi.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ + caml/signals.h caml/sys.h +extern_bi.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ + caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +intern_bi.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_bi.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h sys_bi.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ @@ -1061,176 +797,127 @@ sys_bi.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ caml/startup_aux.h -unix_bi.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_bi.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_bi.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ +meta_bi.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_bpic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -alloc_bpic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/stacks.h caml/memory.h caml/signals.h -array_bpic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ + caml/stacks.h caml/memory.h +parsing_bi.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_bi.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stacks.h caml/startup_aux.h +md5_bi.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/mlvalues.h caml/io.h caml/reverse.h +obj_bi.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_bpic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_bpic.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ - caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ - caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ - caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ - caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_bpic.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_bpic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +lexing_bi.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_bpic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +callback_bi.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ caml/stacks.h caml/memory.h -clambda_checks_bpic.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_bpic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ +debugger_bi.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ + caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ + caml/stacks.h caml/sys.h +weak_bi.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_bi.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h -compare_bpic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h -custom_bpic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_bi.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ + caml/roots.h caml/signals.h +custom_bi.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/mlvalues.h caml/signals.h -debugger_bpic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ - caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ - caml/stacks.h caml/sys.h -domain_bpic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -dynlink_bpic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ +dynlink_bi.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_bpic.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ +spacetime_byt_bi.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/mlvalues.h +afl_bi.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h -extern_bpic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_bpic.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stacks.h caml/memory.h -fail_nat_bpic.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h +unix_bi.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h +bigarray_bi.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/signals.h +main_bi.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_bpic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ - caml/roots.h caml/signals.h -fix_code_bpic.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_bpic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h +memprof_bi.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_bi.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h -freelist_bpic.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_bpic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \ - caml/startup_aux.h -globroots_bpic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_bpic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_bpic.$(O): instrtrace.c -intern_bpic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ + caml/address_class.h caml/domain.h +win32_bi.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +instrtrace_bi.$(O): instrtrace.c interp_bpic.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ @@ -1239,104 +926,91 @@ interp_bpic.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ caml/startup_aux.h caml/jumptbl.h -ints_bpic.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h -io_bpic.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/signals.h caml/sys.h -lexing_bpic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_bpic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ +misc_bpic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h +stacks_bpic.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +fix_code_bpic.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ + caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +startup_aux_bpic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h + caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ + caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \ + caml/roots.h +startup_byt_bpic.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ + caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \ + caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \ + caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \ + caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \ + caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \ + caml/startup.h caml/startup_aux.h caml/version.h +freelist_bpic.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ + caml/mlvalues.h caml/eventlog.h major_gc_bpic.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h -md5_bpic.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h caml/io.h caml/reverse.h -memory_bpic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_bpic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_bpic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h minor_gc_bpic.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_bpic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h -obj_bpic.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_bpic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_bpic.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h -printexc_bpic.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ - caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/memprof.h caml/roots.h caml/memory.h + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_bpic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_bpic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/stacks.h caml/memory.h caml/signals.h roots_byt_bpic.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_bpic.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h + caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \ + caml/eventlog.h +globroots_bpic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +fail_byt_bpic.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/stacks.h caml/memory.h signals_bpic.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ @@ -1350,68 +1024,77 @@ signals_byt_bpic.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ caml/signals.h caml/signals_machdep.h -signals_nat_bpic.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ +printexc_bpic.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ + caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_bpic.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h -spacetime_nat_bpic.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ - caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ - caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -spacetime_snapshot_bpic.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \ - caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -stacks_bpic.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ + caml/memprof.h caml/roots.h caml/memory.h +backtrace_byt_bpic.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ + caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ + caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ + caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ + caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h +backtrace_bpic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -startup_aux_bpic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \ - caml/osdeps.h caml/memory.h caml/startup_aux.h -startup_byt_bpic.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_bpic.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +compare_bpic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h +ints_bpic.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h + caml/domain.h caml/misc.h caml/mlvalues.h +eventlog_bpic.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h +floats_bpic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h str_bpic.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_bpic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h +io_bpic.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ + caml/signals.h caml/sys.h +extern_bpic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ + caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +intern_bpic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_bpic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h sys_bpic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ @@ -1419,302 +1102,382 @@ sys_bpic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ caml/startup_aux.h -unix_bpic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_bpic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_bpic.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ +meta_bpic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_n.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -alloc_n.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/stacks.h caml/memory.h caml/signals.h -array_n.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_n.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ + caml/stacks.h caml/memory.h +parsing_bpic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_bpic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_n.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ - caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ - caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ - caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ - caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_n.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_n.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stacks.h caml/startup_aux.h +md5_bpic.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/mlvalues.h caml/io.h caml/reverse.h +obj_bpic.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ + caml/signals.h caml/spacetime.h caml/io.h caml/stack.h +lexing_bpic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_n.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +callback_bpic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h -clambda_checks_n.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_n.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \ + caml/stacks.h caml/memory.h +debugger_bpic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \ + caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \ + caml/stacks.h caml/sys.h +weak_bpic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_bpic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h -compare_n.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h -custom_n.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_bpic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ + caml/roots.h caml/signals.h +custom_bpic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/mlvalues.h caml/signals.h -debugger_n.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -domain_n.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -dynlink_n.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ +dynlink_bpic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_n.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ +spacetime_byt_bpic.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/mlvalues.h +afl_bpic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h -extern_n.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h +unix_bpic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h +bigarray_bpic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_n.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/signals.h +main_bpic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h +memprof_bpic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_bpic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +win32_bpic.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stacks.h caml/memory.h + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +instrtrace_bpic.$(O): instrtrace.c +startup_aux_n.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ + caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h +startup_nat_n.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ + caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \ + caml/startup_aux.h caml/sys.h +main_n.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h fail_nat_n.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_n.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ - caml/roots.h caml/signals.h -fix_code_n.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ +roots_nat_n.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ + caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_n.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \ + caml/eventlog.h +signals_n.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h + caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ + caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ + caml/roots.h caml/finalise.h +signals_nat_n.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ + signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ + caml/memprof.h caml/roots.h caml/finalise.h +misc_n.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h freelist_n.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_n.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \ - caml/startup_aux.h -globroots_n.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_n.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_n.$(O): instrtrace.c -intern_n.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h -interp_n.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ - caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ + caml/mlvalues.h caml/eventlog.h +major_gc_n.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ + caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h +minor_gc_n.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_n.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_n.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/stacks.h caml/memory.h caml/signals.h +compare_n.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ - caml/startup_aux.h caml/jumptbl.h + caml/mlvalues.h ints_n.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/misc.h caml/mlvalues.h +floats_n.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h +str_n.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_n.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h io_n.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ caml/signals.h caml/sys.h -lexing_n.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ +extern_n.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ + caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +intern_n.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_n.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h +sys_n.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ + caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ + caml/startup_aux.h +parsing_n.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_n.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_n.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -major_gc_n.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stack.h caml/startup_aux.h +eventlog_n.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h md5_n.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/mlvalues.h caml/io.h caml/reverse.h -memory_n.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_n.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_n.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h -minor_gc_n.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_n.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h obj_n.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_n.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_n.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h +lexing_n.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +unix_n.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h printexc_n.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/memprof.h caml/roots.h caml/memory.h -roots_byt_n.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_n.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ +callback_n.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h -signals_n.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/mlvalues.h +weak_n.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_n.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_n.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ + caml/roots.h caml/signals.h +custom_n.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ - caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ - caml/roots.h caml/finalise.h -signals_byt_n.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ - caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ - caml/signals.h caml/signals_machdep.h -signals_nat_n.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/domain.h caml/mlvalues.h caml/signals.h +globroots_n.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +backtrace_nat_n.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ + caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h caml/stack.h +backtrace_n.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +dynlink_nat_n.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_n.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h + caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ + caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h +debugger_n.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +meta_n.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ + caml/stacks.h caml/memory.h +dynlink_n.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/prims.h caml/signals.h +clambda_checks_n.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl spacetime_nat_n.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ @@ -1732,349 +1495,291 @@ spacetime_snapshot_n.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ - caml/stack.h -stacks_n.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -startup_aux_n.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ - caml/memory.h caml/startup_aux.h -startup_byt_n.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_n.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h -str_n.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h -sys_n.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ - caml/startup_aux.h -unix_n.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_n.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_n.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_nd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -alloc_nd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/stacks.h caml/memory.h caml/signals.h -array_nd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_nd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_nd.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ - caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ - caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ - caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ - caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_nd.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_nd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_nd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h -clambda_checks_nd.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_nd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h -compare_nd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h -custom_nd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ + caml/stack.h +afl_n.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/signals.h -debugger_nd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h +bigarray_n.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -domain_nd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/signals.h +memprof_n.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_n.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h -dynlink_nd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ +win32_n.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +startup_aux_nd.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ + caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h +startup_nat_nd.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ + caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_nd.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \ + caml/startup_aux.h caml/sys.h +main_nd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h -extern_nd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_nd.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stacks.h caml/memory.h + caml/domain.h fail_nat_nd.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_nd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ - caml/roots.h caml/signals.h -fix_code_nd.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ +roots_nat_nd.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ + caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_nd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \ + caml/eventlog.h +signals_nd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h + caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ + caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ + caml/roots.h caml/finalise.h +signals_nat_nd.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ + signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ + caml/memprof.h caml/roots.h caml/finalise.h +misc_nd.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h freelist_nd.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_nd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \ - caml/startup_aux.h -globroots_nd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_nd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_nd.$(O): instrtrace.c caml/instrtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/instruct.h caml/misc.h caml/mlvalues.h \ - caml/opnames.h caml/prims.h caml/stacks.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/startup_aux.h -intern_nd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h -interp_nd.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ - caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ + caml/mlvalues.h caml/eventlog.h +major_gc_nd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ + caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h +minor_gc_nd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_nd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_nd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/stacks.h caml/memory.h caml/signals.h +compare_nd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ - caml/startup_aux.h + caml/mlvalues.h ints_nd.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/misc.h caml/mlvalues.h +floats_nd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h +str_nd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_nd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h io_nd.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ caml/signals.h caml/sys.h -lexing_nd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ +extern_nd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_nd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ + caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ + caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +intern_nd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -major_gc_nd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_nd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h +sys_nd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ + caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ + caml/startup_aux.h +parsing_nd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_nd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stack.h caml/startup_aux.h +eventlog_nd.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h md5_nd.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/mlvalues.h caml/io.h caml/reverse.h -memory_nd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_nd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_nd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h -minor_gc_nd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_nd.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h obj_nd.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_nd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_nd.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h + caml/signals.h caml/spacetime.h caml/io.h caml/stack.h +lexing_nd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +unix_nd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h printexc_nd.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/memprof.h caml/roots.h caml/memory.h -roots_byt_nd.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_nd.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ +callback_nd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h -signals_nd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/mlvalues.h +weak_nd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_nd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_nd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ + caml/roots.h caml/signals.h +custom_nd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ - caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ - caml/roots.h caml/finalise.h -signals_byt_nd.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ - caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ - caml/signals.h caml/signals_machdep.h -signals_nat_nd.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/domain.h caml/mlvalues.h caml/signals.h +globroots_nd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +backtrace_nat_nd.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ + caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h caml/stack.h +backtrace_nd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +dynlink_nat_nd.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_nd.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h + caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ + caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h +debugger_nd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +meta_nd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ + caml/stacks.h caml/memory.h +dynlink_nd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/prims.h caml/signals.h +clambda_checks_nd.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl spacetime_nat_nd.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ @@ -2093,343 +1798,290 @@ spacetime_snapshot_nd.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ caml/stack.h -stacks_nd.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ +afl_nd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h +bigarray_nd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/signals.h +memprof_nd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_nd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h -startup_aux_nd.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ +win32_nd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +startup_aux_ni.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ - caml/memory.h caml/startup_aux.h -startup_byt_nd.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_nd.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ + caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h +startup_nat_ni.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h -str_nd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h -sys_nd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ - caml/startup_aux.h -unix_nd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_nd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_nd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_ni.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \ + caml/startup_aux.h caml/sys.h +main_ni.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h -alloc_ni.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/stacks.h caml/memory.h caml/signals.h -array_ni.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_ni.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +fail_nat_ni.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_ni.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ - caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ - caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ - caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ - caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_ni.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_ni.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ + caml/stack.h caml/roots.h caml/memory.h caml/callback.h +roots_nat_ni.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ + caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \ + caml/eventlog.h +signals_ni.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ - caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/signals.h -callback_ni.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ + caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ + caml/roots.h caml/finalise.h +signals_nat_ni.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h -clambda_checks_ni.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_ni.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ + signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ + caml/memprof.h caml/roots.h caml/finalise.h +misc_ni.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h +freelist_ni.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ + caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ + caml/mlvalues.h caml/eventlog.h +major_gc_ni.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h + caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ + caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h +minor_gc_ni.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_ni.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_ni.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/stacks.h caml/memory.h caml/signals.h compare_ni.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ caml/mlvalues.h -custom_ni.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ +ints_ni.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ + caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/signals.h -debugger_ni.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -domain_ni.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/domain.h caml/misc.h caml/mlvalues.h +floats_ni.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h +str_ni.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -dynlink_ni.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_ni.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_ni.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h +io_ni.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ + caml/signals.h caml/sys.h extern_ni.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_ni.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stacks.h caml/memory.h -fail_nat_ni.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +intern_ni.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_ni.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ - caml/roots.h caml/signals.h -fix_code_ni.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_ni.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h +sys_ni.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ + caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_ni.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h -freelist_ni.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h + caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ + caml/startup_aux.h +parsing_ni.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h gc_ctrl_ni.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \ - caml/startup_aux.h -globroots_ni.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_ni.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_ni.$(O): instrtrace.c -intern_ni.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h -interp_ni.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ - caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ - caml/startup_aux.h caml/jumptbl.h -ints_ni.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h -io_ni.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/signals.h caml/sys.h -lexing_ni.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stack.h caml/startup_aux.h +eventlog_ni.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_ni.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -major_gc_ni.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h md5_ni.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/mlvalues.h caml/io.h caml/reverse.h -memory_ni.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_ni.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_ni.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h -minor_gc_ni.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_ni.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h obj_ni.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_ni.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_ni.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h +lexing_ni.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +unix_ni.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h printexc_ni.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/memprof.h caml/roots.h caml/memory.h -roots_byt_ni.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_ni.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ +callback_ni.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h -signals_ni.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/mlvalues.h +weak_ni.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_ni.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_ni.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ + caml/roots.h caml/signals.h +custom_ni.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ - caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ - caml/roots.h caml/finalise.h -signals_byt_ni.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ - caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ - caml/signals.h caml/signals_machdep.h -signals_nat_ni.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_ni.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ + caml/domain.h caml/mlvalues.h caml/signals.h +globroots_ni.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +backtrace_nat_ni.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ + caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h caml/stack.h +backtrace_ni.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +dynlink_nat_ni.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ + caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h +debugger_ni.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +meta_ni.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ + caml/stacks.h caml/memory.h +dynlink_ni.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/prims.h caml/signals.h +clambda_checks_ni.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl spacetime_nat_ni.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ @@ -2448,343 +2100,290 @@ spacetime_snapshot_ni.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ caml/stack.h -stacks_ni.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -startup_aux_ni.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ - caml/memory.h caml/startup_aux.h -startup_byt_ni.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_ni.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h -str_ni.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h -sys_ni.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ - caml/startup_aux.h -unix_ni.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_ni.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h -win32_ni.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ - caml/sys.h caml/config.h -afl_npic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ +afl_ni.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h -alloc_npic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/stacks.h caml/memory.h caml/signals.h -array_npic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -backtrace_npic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ - caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h -backtrace_byt_npic.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ - caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \ - caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \ - caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \ - caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \ - caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h -backtrace_nat_npic.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ - caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/stack.h -bigarray_npic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ +bigarray_ni.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ caml/signals.h -callback_npic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/mlvalues.h -clambda_checks_npic.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl -compact_npic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ - caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h -compare_npic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ - caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h -custom_npic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/mlvalues.h caml/signals.h -debugger_npic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -domain_npic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ +memprof_ni.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_ni.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h -dynlink_npic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ +win32_ni.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \ + caml/sys.h caml/config.h +startup_aux_npic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ + caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h +startup_nat_npic.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ + caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ + caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/prims.h caml/signals.h -dynlink_nat_npic.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \ + caml/startup_aux.h caml/sys.h +main_npic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ - caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h -extern_npic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ - caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -fail_byt_npic.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \ + caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \ - caml/stacks.h caml/memory.h + caml/domain.h fail_nat_npic.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \ caml/stack.h caml/roots.h caml/memory.h caml/callback.h -finalise_npic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ - caml/roots.h caml/signals.h -fix_code_npic.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \ - caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ +roots_nat_npic.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ + caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ + caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/misc.h caml/mlvalues.h caml/reverse.h -floats_npic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \ + caml/eventlog.h +signals_npic.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h + caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ + caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ + caml/roots.h caml/finalise.h +signals_nat_npic.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ + signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ + caml/memprof.h caml/roots.h caml/finalise.h +misc_npic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ + caml/version.h freelist_npic.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \ - caml/mlvalues.h -gc_ctrl_npic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ - caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \ - caml/startup_aux.h -globroots_npic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ - caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ - caml/roots.h caml/memory.h caml/globroots.h caml/roots.h -hash_npic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h -instrtrace_npic.$(O): instrtrace.c -intern_npic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ - caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ - caml/misc.h caml/reverse.h caml/signals.h -interp_npic.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ - caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \ - caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \ + caml/mlvalues.h caml/eventlog.h +major_gc_npic.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ + caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ + caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h +minor_gc_npic.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ + caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \ + caml/eventlog.h +memory_npic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ + caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ + caml/memory.h caml/eventlog.h +alloc_npic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/stacks.h caml/memory.h caml/signals.h +compare_npic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ - caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \ - caml/startup_aux.h caml/jumptbl.h + caml/mlvalues.h ints_npic.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/misc.h caml/mlvalues.h +floats_npic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h +str_npic.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h +array_npic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h io_npic.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ caml/signals.h caml/sys.h -lexing_npic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ +extern_npic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h -main_npic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \ + caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \ + caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/misc.h caml/mlvalues.h caml/reverse.h +intern_npic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \ + caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h -major_gc_npic.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ - caml/signals.h caml/weak.h + caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \ + caml/misc.h caml/reverse.h caml/signals.h +hash_npic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ + caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h +sys_npic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ + caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ + caml/startup_aux.h +parsing_npic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ + caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/alloc.h +gc_ctrl_npic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \ + caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \ + caml/eventlog.h caml/stack.h caml/startup_aux.h +eventlog_npic.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/osdeps.h caml/memory.h md5_npic.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/mlvalues.h caml/io.h caml/reverse.h -memory_npic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \ - caml/memory.h -memprof_npic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ - caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ - caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ - caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ - caml/weak.h caml/stack.h caml/misc.h -meta_npic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ - caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ - caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ - caml/stacks.h caml/memory.h -minor_gc_npic.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \ - caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ - caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ - caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \ - caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h -misc_npic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ - caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \ - caml/version.h obj_npic.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h -parsing_npic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \ - caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ - caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/alloc.h -prims_npic.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \ - caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \ - caml/prims.h +lexing_npic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h +unix_npic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ + caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h printexc_npic.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ caml/memprof.h caml/roots.h caml/memory.h -roots_byt_npic.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h -roots_nat_npic.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \ - caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ +callback_npic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \ - caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h -signals_npic.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/mlvalues.h +weak_npic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ + caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ + caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h +compact_npic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \ + caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ + caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \ + caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \ + caml/memprof.h caml/eventlog.h +finalise_npic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \ + caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \ + caml/roots.h caml/signals.h +custom_npic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \ + caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \ - caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \ - caml/roots.h caml/finalise.h -signals_byt_npic.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \ - caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \ - caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \ - caml/signals.h caml/signals_machdep.h -signals_nat_npic.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \ + caml/domain.h caml/mlvalues.h caml/signals.h +globroots_npic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \ + caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \ + caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \ + caml/roots.h caml/memory.h caml/globroots.h caml/roots.h +backtrace_nat_npic.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \ + caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \ + caml/mlvalues.h caml/stack.h +backtrace_npic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \ + caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h +dynlink_nat_npic.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \ - signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \ - caml/memprof.h caml/roots.h caml/finalise.h -spacetime_byt_npic.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \ - caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/mlvalues.h + caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \ + caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h +debugger_npic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \ + caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h +meta_npic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \ + caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \ + caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \ + caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \ + caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \ + caml/stacks.h caml/memory.h +dynlink_npic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ + caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ + caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ + caml/memory.h caml/prims.h caml/signals.h +clambda_checks_npic.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \ + caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl spacetime_nat_npic.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \ caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \ caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \ @@ -2803,57 +2402,29 @@ spacetime_snapshot_npic.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \ caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \ caml/stack.h -stacks_npic.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h -startup_aux_npic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \ - caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \ - caml/memory.h caml/startup_aux.h -startup_byt_npic.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \ - caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \ - caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \ - caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \ - caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \ - caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \ - caml/startup_aux.h caml/version.h -startup_nat_npic.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \ - caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \ - caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \ - caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \ - caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \ +afl_npic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \ + caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \ - caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \ - caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h -str_npic.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h -sys_npic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \ - caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \ - caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \ - caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \ - caml/startup_aux.h -unix_npic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \ - caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ - caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ - caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \ - caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h -weak_npic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ - caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \ - caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \ + caml/domain.h +bigarray_npic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \ + caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \ - caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h + caml/signals.h +memprof_npic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \ + caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \ + caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \ + caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \ + caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \ + caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \ + caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \ + caml/eventlog.h +domain_npic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \ + caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ + caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \ + caml/address_class.h caml/domain.h win32_npic.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \ diff --git a/runtime/Makefile b/runtime/Makefile index b30f1205..744955c0 100644 --- a/runtime/Makefile +++ b/runtime/Makefile @@ -15,15 +15,15 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common # Lists of source files BYTECODE_C_SOURCES := $(addsuffix .c, \ interp misc stacks fix_code startup_aux startup_byt freelist major_gc \ minor_gc memory alloc roots_byt globroots fail_byt signals \ - signals_byt printexc backtrace_byt backtrace compare ints \ + signals_byt printexc backtrace_byt backtrace compare ints eventlog \ floats str array io extern intern hash sys meta parsing gc_ctrl md5 obj \ lexing callback debugger weak compact finalise custom dynlink \ spacetime_byt afl $(UNIX_OR_WIN32) bigarray main memprof domain) @@ -31,7 +31,7 @@ BYTECODE_C_SOURCES := $(addsuffix .c, \ NATIVE_C_SOURCES := $(addsuffix .c, \ startup_aux startup_nat main fail_nat roots_nat signals \ signals_nat misc freelist major_gc minor_gc memory alloc compare ints \ - floats str array io extern intern hash sys parsing gc_ctrl md5 obj \ + floats str array io extern intern hash sys parsing gc_ctrl eventlog md5 obj \ lexing $(UNIX_OR_WIN32) printexc callback weak compact finalise custom \ globroots backtrace_nat backtrace dynlink_nat debugger meta \ dynlink clambda_checks spacetime_nat spacetime_snapshot afl bigarray \ @@ -201,8 +201,10 @@ endif .PHONY: clean clean: - rm -f $(PROGRAMS) *.$(O) *.$(A) *.$(SO) ld.conf - rm -f primitives prims.c caml/opnames.h caml/jumptbl.h + rm -f *.o *.obj *.a *.lib *.so *.dll ld.conf + rm -f ocamlrun ocamlrund ocamlruni + rm -f ocamlrun.exe ocamlrund.exe ocamlruni.exe + rm -f primitives primitives.new prims.c caml/opnames.h caml/jumptbl.h rm -f caml/version.h domain_state*.inc .PHONY: distclean @@ -252,7 +254,7 @@ prims.c : primitives echo ' 0 };') > prims.c caml/opnames.h : caml/instruct.h - cat $^ | tr -d '\r' | \ + tr -d '\r' < $< | \ sed -e '/\/\*/d' \ -e '/^#/d' \ -e 's/enum /static char * names_of_/' \ @@ -261,7 +263,7 @@ caml/opnames.h : caml/instruct.h # caml/jumptbl.h is required only if you have GCC 2.0 or later caml/jumptbl.h : caml/instruct.h - cat $^ | tr -d '\r' | \ + tr -d '\r' < $< | \ sed -n -e '/^ /s/ \([A-Z]\)/ \&\&lbl_\1/gp' \ -e '/^}/q' > $@ @@ -382,24 +384,29 @@ depend: else NATIVE_DEP_CPPFLAGS := $(OC_CPPFLAGS) $(OC_NATIVE_CPPFLAGS) +BYTECODE_DEP_FILES := $(BYTECODE_C_SOURCES) $(other_files) instrtrace.c NATIVE_DEP_FILES := $(NATIVE_C_SOURCES) $(other_files) depend: *.c caml/opnames.h caml/jumptbl.h caml/version.h - $(CC) -MM $(OC_CPPFLAGS) *.c | \ + $(CC) -MM $(OC_CPPFLAGS) $(BYTECODE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_b.$$(O)/' > .depend - $(CC) -MM $(OC_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) *.c | \ + $(CC) -MM $(OC_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) \ + $(BYTECODE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_bd.$$(O)/' >> .depend - $(CC) -MM $(OC_CPPFLAGS) $(OC_INSTR_CPPFLAGS) *.c | \ + $(CC) -MM $(OC_CPPFLAGS) $(OC_INSTR_CPPFLAGS) \ + $(BYTECODE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_bi.$$(O)/' >> .depend - $(CC) -MM $(OC_CPPFLAGS) *.c | \ + $(CC) -MM $(OC_CPPFLAGS) $(BYTECODE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_bpic.$$(O)/' >> .depend - $(CC) -MM $(NATIVE_DEP_CPPFLAGS) *.c | \ + $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(NATIVE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_n.$$(O)/' >> .depend - $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) *.c | \ + $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) \ + $(NATIVE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_nd.$$(O)/' >> .depend - $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_INSTR_CPPFLAGS) *.c | \ + $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_INSTR_CPPFLAGS) \ + $(NATIVE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_ni.$$(O)/' >> .depend - $(CC) -MM $(NATIVE_DEP_CPPFLAGS) *.c | \ + $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(NATIVE_DEP_FILES) | \ sed -e 's/\([^.]*\)\.o/\1_npic.$$(O)/' >> .depend endif diff --git a/runtime/afl.c b/runtime/afl.c index 324a3c34..582449ef 100644 --- a/runtime/afl.c +++ b/runtime/afl.c @@ -75,10 +75,15 @@ static uint32_t afl_read() CAMLprim value caml_setup_afl(value unit) { + char* shm_id_str; + char* shm_id_end; + long int shm_id; + uint32_t startup_msg = 0; + if (afl_initialised) return Val_unit; afl_initialised = 1; - char* shm_id_str = caml_secure_getenv("__AFL_SHM_ID"); + shm_id_str = caml_secure_getenv("__AFL_SHM_ID"); if (shm_id_str == NULL) { /* Not running under afl-fuzz, continue as normal */ return Val_unit; @@ -87,8 +92,7 @@ CAMLprim value caml_setup_afl(value unit) /* if afl-fuzz is attached, we want it to know about uncaught exceptions */ caml_abort_on_uncaught_exn = 1; - char* shm_id_end; - long int shm_id = strtol(shm_id_str, &shm_id_end, 10); + shm_id = strtol(shm_id_str, &shm_id_end, 10); if (!(*shm_id_str != '\0' && *shm_id_end == '\0')) caml_fatal_error("afl-fuzz: bad shm id"); @@ -101,7 +105,6 @@ CAMLprim value caml_setup_afl(value unit) caml_afl_area_ptr[0] = 1; /* synchronise with afl-fuzz */ - uint32_t startup_msg = 0; if (write(FORKSRV_FD_WRITE, &startup_msg, 4) != 4) { /* initial write failed, so assume we're not meant to fork. afl-tmin uses this mode. */ @@ -121,16 +124,18 @@ CAMLprim value caml_setup_afl(value unit) /* As long as the child keeps raising SIGSTOP, we re-use the same process */ while (1) { + int status; + uint32_t was_killed; + afl_write((uint32_t)child_pid); - int status; /* WUNTRACED means wait until termination or SIGSTOP */ if (waitpid(child_pid, &status, WUNTRACED) < 0) caml_fatal_error("afl-fuzz: waitpid failed"); afl_write((uint32_t)status); - uint32_t was_killed = afl_read(); + was_killed = afl_read(); if (WIFSTOPPED(status)) { /* child stopped, waiting for another test case */ if (was_killed) { diff --git a/runtime/amd64.S b/runtime/amd64.S index 77a4f85a..056b39cd 100644 --- a/runtime/amd64.S +++ b/runtime/amd64.S @@ -159,15 +159,6 @@ movq GREL(dstlabel)(%rip), %r11 ; \ popq (%r11); CFI_ADJUST (-8) -/* Record lowest stack address and return address. Clobbers %rax. */ -#define RECORD_STACK_FRAME(OFFSET) \ - pushq %r11 ; CFI_ADJUST(8); \ - movq 8+OFFSET(%rsp), %rax ; \ - movq %rax, Caml_state(last_return_address) ; \ - leaq 16+OFFSET(%rsp), %rax ; \ - movq %rax, Caml_state(bottom_of_stack) ; \ - popq %r11; CFI_ADJUST(-8) - /* Load address of global [label] in register [dst]. */ #define LEA_VAR(label,dst) \ movq GREL(label)(%rip), dst @@ -197,12 +188,6 @@ #define POP_VAR(dstlabel) \ popq G(dstlabel)(%rip); CFI_ADJUST(-8) -#define RECORD_STACK_FRAME(OFFSET) \ - movq OFFSET(%rsp), %rax ; \ - movq %rax, Caml_state(last_return_address) ; \ - leaq 8+OFFSET(%rsp), %rax ; \ - movq %rax, Caml_state(bottom_of_stack) - #define LEA_VAR(label,dst) \ leaq G(label)(%rip), dst #endif @@ -328,12 +313,16 @@ G(caml_system__code_begin): FUNCTION(G(caml_call_gc)) CFI_STARTPROC - RECORD_STACK_FRAME(0) LBL(caml_call_gc): + /* Record lowest stack address and return address. */ + movq (%rsp), %r11 + movq %r11, Caml_state(last_return_address) + leaq 8(%rsp), %r11 + movq %r11, Caml_state(bottom_of_stack) /* Touch the stack to trigger a recoverable segfault if insufficient space remains */ subq $(STACK_PROBE_SIZE), %rsp; CFI_ADJUST(STACK_PROBE_SIZE); - movq %rax, 0(%rsp) + movq %r11, 0(%rsp) addq $(STACK_PROBE_SIZE), %rsp; CFI_ADJUST(-STACK_PROBE_SIZE); /* Build array of registers, save it into Caml_state->gc_regs */ #ifdef WITH_FRAME_POINTERS @@ -425,111 +414,39 @@ ENDFUNCTION(G(caml_call_gc)) FUNCTION(G(caml_alloc1)) CFI_STARTPROC -LBL(caml_alloc1): subq $16, %r15 cmpq Caml_state(young_limit), %r15 - jb LBL(100) + jb LBL(caml_call_gc) ret -LBL(100): - addq $16, %r15 - RECORD_STACK_FRAME(0) - ENTER_FUNCTION -/* subq $8, %rsp; CFI_ADJUST (8); */ - call LBL(caml_call_gc) -/* addq $8, %rsp; CFI_ADJUST (-8); */ - LEAVE_FUNCTION - jmp LBL(caml_alloc1) CFI_ENDPROC ENDFUNCTION(G(caml_alloc1)) FUNCTION(G(caml_alloc2)) CFI_STARTPROC -LBL(caml_alloc2): subq $24, %r15 cmpq Caml_state(young_limit), %r15 - jb LBL(101) + jb LBL(caml_call_gc) ret -LBL(101): - addq $24, %r15 - RECORD_STACK_FRAME(0) - ENTER_FUNCTION -/* subq $8, %rsp; CFI_ADJUST (8); */ - call LBL(caml_call_gc) -/* addq $8, %rsp; CFI_ADJUST (-8); */ - LEAVE_FUNCTION - jmp LBL(caml_alloc2) CFI_ENDPROC ENDFUNCTION(G(caml_alloc2)) FUNCTION(G(caml_alloc3)) CFI_STARTPROC -LBL(caml_alloc3): subq $32, %r15 cmpq Caml_state(young_limit), %r15 - jb LBL(102) + jb LBL(caml_call_gc) ret -LBL(102): - addq $32, %r15 - RECORD_STACK_FRAME(0) - ENTER_FUNCTION -/* subq $8, %rsp; CFI_ADJUST (8) */ - call LBL(caml_call_gc) -/* addq $8, %rsp; CFI_ADJUST (-8) */ - LEAVE_FUNCTION - jmp LBL(caml_alloc3) CFI_ENDPROC ENDFUNCTION(G(caml_alloc3)) FUNCTION(G(caml_allocN)) CFI_STARTPROC -LBL(caml_allocN): - pushq %rax; CFI_ADJUST(8) /* save desired size */ - subq %rax, %r15 cmpq Caml_state(young_limit), %r15 - jb LBL(103) - addq $8, %rsp; CFI_ADJUST (-8) /* drop desired size */ + jb LBL(caml_call_gc) ret -LBL(103): - addq 0(%rsp), %r15 - CFI_ADJUST(8) - RECORD_STACK_FRAME(8) -#ifdef WITH_FRAME_POINTERS - /* ensure 16 byte alignment by subq + enter using 16-bytes, PR#7417 */ - subq $8, %rsp; CFI_ADJUST (8) - ENTER_FUNCTION -#endif - call LBL(caml_call_gc) -#ifdef WITH_FRAME_POINTERS - /* ensure 16 byte alignment by leave + addq using 16-bytes PR#7417 */ - LEAVE_FUNCTION - addq $8, %rsp; CFI_ADJUST (-8) -#endif - popq %rax; CFI_ADJUST(-8) /* recover desired size */ - jmp LBL(caml_allocN) CFI_ENDPROC ENDFUNCTION(G(caml_allocN)) -/* Reset the allocation pointer and invoke the GC */ - -FUNCTION(G(caml_call_gc1)) -CFI_STARTPROC - addq $16, %r15 - jmp GCALL(caml_call_gc) -CFI_ENDPROC - -FUNCTION(G(caml_call_gc2)) -CFI_STARTPROC - addq $24, %r15 - jmp GCALL(caml_call_gc) -CFI_ENDPROC - -FUNCTION(G(caml_call_gc3)) -CFI_STARTPROC - addq $32, %r15 - jmp GCALL(caml_call_gc) -CFI_ENDPROC - - /* Call a C function from OCaml */ FUNCTION(G(caml_c_call)) diff --git a/runtime/amd64nt.asm b/runtime/amd64nt.asm index 10e75ca0..d34631ab 100644 --- a/runtime/amd64nt.asm +++ b/runtime/amd64nt.asm @@ -46,15 +46,14 @@ caml_system__code_begin: ALIGN 16 caml_call_gc: ; Record lowest stack address and return address - mov rax, [rsp] - Store_last_return_address rax - lea rax, [rsp+8] - Store_bottom_of_stack rax -L105: + mov r11, [rsp] + Store_last_return_address r11 + lea r11, [rsp+8] + Store_bottom_of_stack r11 ; Touch the stack to trigger a recoverable segfault ; if insufficient space remains sub rsp, 01000h - mov [rsp], rax + mov [rsp], r11 add rsp, 01000h ; Save young_ptr Store_young_ptr r15 @@ -139,92 +138,31 @@ ENDIF caml_alloc1: sub r15, 16 Cmp_young_limit r15 - jb L100 + jb caml_call_gc ret -L100: - add r15, 16 - mov rax, [rsp + 0] - Store_last_return_address rax - lea rax, [rsp + 8] - Store_bottom_of_stack rax - sub rsp, 8 - call L105 - add rsp, 8 - jmp caml_alloc1 PUBLIC caml_alloc2 ALIGN 16 caml_alloc2: sub r15, 24 Cmp_young_limit r15 - jb L101 + jb caml_call_gc ret -L101: - add r15, 24 - mov rax, [rsp + 0] - Store_last_return_address rax - lea rax, [rsp + 8] - Store_bottom_of_stack rax - sub rsp, 8 - call L105 - add rsp, 8 - jmp caml_alloc2 PUBLIC caml_alloc3 ALIGN 16 caml_alloc3: sub r15, 32 Cmp_young_limit r15 - jb L102 + jb caml_call_gc ret -L102: - add r15, 32 - mov rax, [rsp + 0] - Store_last_return_address rax - lea rax, [rsp + 8] - Store_bottom_of_stack rax - sub rsp, 8 - call L105 - add rsp, 8 - jmp caml_alloc3 PUBLIC caml_allocN ALIGN 16 caml_allocN: - sub r15, rax Cmp_young_limit r15 - jb L103 + jb caml_call_gc ret -L103: - add r15, rax - push rax ; save desired size - mov rax, [rsp + 8] - Store_last_return_address rax - lea rax, [rsp + 16] - Store_bottom_of_stack rax - call L105 - pop rax ; recover desired size - jmp caml_allocN - -; Reset the allocation pointer and invoke the GC - - PUBLIC caml_call_gc1 - ALIGN 16 -caml_call_gc1: - add r15, 16 - jmp caml_call_gc - - PUBLIC caml_call_gc2 - ALIGN 16 -caml_call_gc2: - add r15, 24 - jmp caml_call_gc - - PUBLIC caml_call_gc3 - ALIGN 16 -caml_call_gc3: - add r15, 32 - jmp caml_call_gc ; Call a C function from OCaml diff --git a/runtime/arm.S b/runtime/arm.S index 0f61a524..85ebb84e 100644 --- a/runtime/arm.S +++ b/runtime/arm.S @@ -137,9 +137,9 @@ caml_system__code_begin: FUNCTION(caml_call_gc) CFI_STARTPROC +.Lcaml_call_gc: /* Record return address */ str lr, Caml_state(last_return_address) -.Lcaml_call_gc: /* Record lowest stack address */ str sp, Caml_state(bottom_of_stack) #if defined(SYS_linux_eabihf) || defined(SYS_netbsd) @@ -176,81 +176,41 @@ FUNCTION(caml_call_gc) FUNCTION(caml_alloc1) CFI_STARTPROC -.Lcaml_alloc1: sub alloc_ptr, alloc_ptr, 8 ldr r7, Caml_state(young_limit) cmp alloc_ptr, r7 - bcc 1f + bcc .Lcaml_call_gc bx lr -1: add alloc_ptr, alloc_ptr, 8 - /* Record return address */ - str lr, Caml_state(last_return_address) - /* Call GC */ - bl .Lcaml_call_gc - /* Restore return address */ - ldr lr, Caml_state(last_return_address) - /* Try again */ - b .Lcaml_alloc1 CFI_ENDPROC .size caml_alloc1, .-caml_alloc1 FUNCTION(caml_alloc2) CFI_STARTPROC -.Lcaml_alloc2: sub alloc_ptr, alloc_ptr, 12 ldr r7, Caml_state(young_limit) cmp alloc_ptr, r7 - bcc 1f + bcc .Lcaml_call_gc bx lr -1: add alloc_ptr, alloc_ptr, 12 - /* Record return address */ - str lr, Caml_state(last_return_address) - /* Call GC */ - bl .Lcaml_call_gc - /* Restore return address */ - ldr lr, Caml_state(last_return_address) - /* Try again */ - b .Lcaml_alloc2 CFI_ENDPROC .size caml_alloc2, .-caml_alloc2 FUNCTION(caml_alloc3) CFI_STARTPROC -.Lcaml_alloc3: sub alloc_ptr, alloc_ptr, 16 ldr r7, Caml_state(young_limit) cmp alloc_ptr, r7 - bcc 1f + bcc .Lcaml_call_gc bx lr -1: add alloc_ptr, alloc_ptr, 16 - /* Record return address */ - str lr, Caml_state(last_return_address) - /* Call GC */ - bl .Lcaml_call_gc - /* Restore return address */ - ldr lr, Caml_state(last_return_address) - /* Try again */ - b .Lcaml_alloc3 CFI_ENDPROC .size caml_alloc3, .-caml_alloc3 FUNCTION(caml_allocN) CFI_STARTPROC -.Lcaml_allocN: sub alloc_ptr, alloc_ptr, r7 - ldr r12, Caml_state(young_limit) - cmp alloc_ptr, r12 - bcc 1f + ldr r7, Caml_state(young_limit) + cmp alloc_ptr, r7 + bcc .Lcaml_call_gc bx lr -1: add alloc_ptr, alloc_ptr, r7 - /* Record return address */ - str lr, Caml_state(last_return_address) - /* Call GC (preserves r7) */ - bl .Lcaml_call_gc - /* Restore return address */ - ldr lr, Caml_state(last_return_address) - /* Try again */ - b .Lcaml_allocN CFI_ENDPROC .size caml_allocN, .-caml_allocN diff --git a/runtime/arm64.S b/runtime/arm64.S index afcb3797..6bad4ce8 100644 --- a/runtime/arm64.S +++ b/runtime/arm64.S @@ -101,12 +101,12 @@ caml_system__code_begin: FUNCTION(caml_call_gc) CFI_STARTPROC +.Lcaml_call_gc: /* Record return address */ str x30, Caml_state(last_return_address) /* Record lowest stack address */ mov TMP, sp str TMP, Caml_state(bottom_of_stack) -.Lcaml_call_gc: /* Set up stack space, saving return address and frame pointer */ /* (2 regs RA/GP, 24 allocatable int regs, 24 caller-save float regs) * 8 */ CFI_OFFSET(29, -400) @@ -187,117 +187,37 @@ FUNCTION(caml_call_gc) FUNCTION(caml_alloc1) CFI_STARTPROC -1: sub ALLOC_PTR, ALLOC_PTR, #16 + sub ALLOC_PTR, ALLOC_PTR, #16 cmp ALLOC_PTR, ALLOC_LIMIT - b.lo 2f + b.lo .Lcaml_call_gc ret -2: add ALLOC_PTR, ALLOC_PTR, #16 - stp x29, x30, [sp, -16]! - CFI_ADJUST(16) - /* Record the lowest address of the caller's stack frame. This is the - address immediately above the pair of words (x29 and x30) we just - pushed. Those must not be included since otherwise the distance from - [Caml_state->bottom_of_stack] to the highest address in the caller's - stack frame won't match the frame size contained in the relevant - frame descriptor. */ - add x29, sp, #16 - str x29, Caml_state(bottom_of_stack) - add x29, sp, #0 - /* Record return address */ - str x30, Caml_state(last_return_address) - /* Call GC */ - bl .Lcaml_call_gc - /* Restore return address */ - ldp x29, x30, [sp], 16 - CFI_ADJUST(-16) - /* Try again */ - b 1b CFI_ENDPROC - .type caml_alloc1, %function .size caml_alloc1, .-caml_alloc1 - .align 2 - .globl caml_alloc2 -caml_alloc2: +FUNCTION(caml_alloc2) CFI_STARTPROC -1: sub ALLOC_PTR, ALLOC_PTR, #24 + sub ALLOC_PTR, ALLOC_PTR, #24 cmp ALLOC_PTR, ALLOC_LIMIT - b.lo 2f + b.lo .Lcaml_call_gc ret -2: add ALLOC_PTR, ALLOC_PTR, #24 - stp x29, x30, [sp, -16]! - CFI_ADJUST(16) - /* Record the lowest address of the caller's stack frame. - See comment above. */ - add x29, sp, #16 - str x29, Caml_state(bottom_of_stack) - add x29, sp, #0 - /* Record return address */ - str x30, Caml_state(last_return_address) - /* Call GC */ - bl .Lcaml_call_gc - /* Restore return address */ - ldp x29, x30, [sp], 16 - CFI_ADJUST(-16) - /* Try again */ - b 1b CFI_ENDPROC - .type caml_alloc2, %function .size caml_alloc2, .-caml_alloc2 FUNCTION(caml_alloc3) CFI_STARTPROC -1: sub ALLOC_PTR, ALLOC_PTR, #32 + sub ALLOC_PTR, ALLOC_PTR, #32 cmp ALLOC_PTR, ALLOC_LIMIT - b.lo 2f + b.lo .Lcaml_call_gc ret -2: add ALLOC_PTR, ALLOC_PTR, #32 - stp x29, x30, [sp, -16]! - CFI_ADJUST(16) - /* Record the lowest address of the caller's stack frame. - See comment above. */ - add x29, sp, #16 - str x29, Caml_state(bottom_of_stack) - add x29, sp, #0 - /* Record return address */ - str x30, Caml_state(last_return_address) - /* Call GC */ - bl .Lcaml_call_gc - /* Restore return address */ - ldp x29, x30, [sp], 16 - CFI_ADJUST(-16) - /* Try again */ - b 1b CFI_ENDPROC - .type caml_alloc3, %function .size caml_alloc3, .-caml_alloc3 - TEXT_SECTION(caml_allocN) - .align 2 - .globl caml_allocN -caml_allocN: +FUNCTION(caml_allocN) CFI_STARTPROC -1: sub ALLOC_PTR, ALLOC_PTR, ARG + sub ALLOC_PTR, ALLOC_PTR, ARG cmp ALLOC_PTR, ALLOC_LIMIT - b.lo 2f + b.lo .Lcaml_call_gc ret -2: add ALLOC_PTR, ALLOC_PTR, ARG - stp x29, x30, [sp, -16]! - CFI_ADJUST(16) - /* Record the lowest address of the caller's stack frame. - See comment above. */ - add x29, sp, #16 - str x29, Caml_state(bottom_of_stack) - add x29, sp, #0 - /* Record return address */ - str x30, Caml_state(last_return_address) - /* Call GC. This preserves ARG */ - bl .Lcaml_call_gc - /* Restore return address */ - ldp x29, x30, [sp], 16 - CFI_ADJUST(-16) - /* Try again */ - b 1b CFI_ENDPROC .size caml_allocN, .-caml_allocN diff --git a/runtime/array.c b/runtime/array.c index 64790423..37af6b7f 100644 --- a/runtime/array.c +++ b/runtime/array.c @@ -23,6 +23,7 @@ #include "caml/misc.h" #include "caml/mlvalues.h" #include "caml/signals.h" +#include "caml/eventlog.h" /* Why is caml/spacetime.h included conditionnally sometimes and not here ? */ #include "caml/spacetime.h" @@ -320,7 +321,7 @@ CAMLprim value caml_make_vect(value len, value init) if (Is_block(init) && Is_young(init)) { /* We don't want to create so many major-to-minor references, so [init] is moved to the major heap by doing a minor GC. */ - CAML_INSTR_INT ("force_minor/make_vect@", 1); + CAML_EV_COUNTER (EV_C_FORCE_MINOR_MAKE_VECT, 1); caml_minor_collection (); } CAMLassert(!(Is_block(init) && Is_young(init))); diff --git a/runtime/backtrace.c b/runtime/backtrace.c index 1967ef55..3e68a356 100644 --- a/runtime/backtrace.c +++ b/runtime/backtrace.c @@ -93,8 +93,8 @@ static void print_location(struct caml_loc_info * li, int index) if (! li->loc_valid) { fprintf(stderr, "%s unknown location%s\n", info, inlined); } else { - fprintf (stderr, "%s file \"%s\"%s, line %d, characters %d-%d\n", - info, li->loc_filename, inlined, li->loc_lnum, + fprintf (stderr, "%s %s in file \"%s\"%s, line %d, characters %d-%d\n", + info, li->loc_defname, li->loc_filename, inlined, li->loc_lnum, li->loc_startchr, li->loc_endchr); } } @@ -188,20 +188,22 @@ CAMLprim value caml_restore_raw_backtrace(value exn, value backtrace) static value caml_convert_debuginfo(debuginfo dbg) { CAMLparam0(); - CAMLlocal2(p, fname); + CAMLlocal3(p, fname, dname); struct caml_loc_info li; caml_debuginfo_location(dbg, &li); if (li.loc_valid) { fname = caml_copy_string(li.loc_filename); - p = caml_alloc_small(6, 0); + dname = caml_copy_string(li.loc_defname); + p = caml_alloc_small(7, 0); Field(p, 0) = Val_bool(li.loc_is_raise); Field(p, 1) = fname; Field(p, 2) = Val_int(li.loc_lnum); Field(p, 3) = Val_int(li.loc_startchr); Field(p, 4) = Val_int(li.loc_endchr); Field(p, 5) = Val_bool(li.loc_is_inlined); + Field(p, 6) = dname; } else { p = caml_alloc_small(1, 1); Field(p, 0) = Val_bool(li.loc_is_raise); @@ -325,12 +327,17 @@ CAMLprim value caml_get_exception_backtrace(value unit) CAMLreturn(res); } -CAMLprim value caml_get_current_callstack(value max_frames_value) { +CAMLprim value caml_get_current_callstack(value max_frames_value) +{ CAMLparam1(max_frames_value); CAMLlocal1(res); - - res = caml_alloc(caml_current_callstack_size(Long_val(max_frames_value)), 0); - caml_current_callstack_write(res); - + value* callstack = NULL; + intnat callstack_alloc_len = 0; + intnat callstack_len = + caml_collect_current_callstack(&callstack, &callstack_alloc_len, + Long_val(max_frames_value), -1); + res = caml_alloc(callstack_len, 0); + memcpy(Op_val(res), callstack, sizeof(value) * callstack_len); + caml_stat_free(callstack); CAMLreturn(res); } diff --git a/runtime/backtrace_byt.c b/runtime/backtrace_byt.c index 9760300d..28fe44c7 100644 --- a/runtime/backtrace_byt.c +++ b/runtime/backtrace_byt.c @@ -54,7 +54,8 @@ enum { EV_POS = 0, EV_MODULE = 1, EV_LOC = 2, - EV_KIND = 3 + EV_KIND = 3, + EV_DEFNAME = 4 }; /* Location of fields in the Location.t record. */ @@ -77,6 +78,7 @@ enum { struct ev_info { code_t ev_pc; char *ev_filename; + char *ev_defname; int ev_lnum; int ev_startchr; int ev_endchr; @@ -103,10 +105,37 @@ static struct debug_info *find_debug_info(code_t pc) static int cmp_ev_info(const void *a, const void *b) { - code_t pc_a = ((const struct ev_info*)a)->ev_pc; - code_t pc_b = ((const struct ev_info*)b)->ev_pc; + const struct ev_info* ev_a = a; + const struct ev_info* ev_b = b; + code_t pc_a = ev_a->ev_pc; + code_t pc_b = ev_b->ev_pc; + int num_a; + int num_b; + + /* Perform a full lexicographic comparison to make sure the resulting order is + the same under all implementations of qsort (which is not stable). */ + if (pc_a > pc_b) return 1; if (pc_a < pc_b) return -1; + + num_a = ev_a->ev_lnum; + num_b = ev_b->ev_lnum; + + if (num_a > num_b) return 1; + if (num_a < num_b) return -1; + + num_a = ev_a->ev_startchr; + num_b = ev_b->ev_startchr; + + if (num_a > num_b) return 1; + if (num_a < num_b) return -1; + + num_a = ev_a->ev_endchr; + num_b = ev_b->ev_endchr; + + if (num_a > num_b) return 1; + if (num_a < num_b) return -1; + return 0; } @@ -143,13 +172,20 @@ static struct ev_info *process_debug_events(code_t code_start, ev_start = Field(Field(ev, EV_LOC), LOC_START); { - uintnat fnsz = caml_string_length(Field(ev_start, POS_FNAME)) + 1; - events[j].ev_filename = (char*)caml_stat_alloc_noexc(fnsz); + const char *fname = String_val(Field(ev_start, POS_FNAME)); + events[j].ev_filename = caml_stat_strdup_noexc(fname); if(events[j].ev_filename == NULL) caml_fatal_error ("caml_add_debug_info: out of memory"); - memcpy(events[j].ev_filename, - String_val(Field(ev_start, POS_FNAME)), - fnsz); + } + + if (Is_block(Field(ev, EV_DEFNAME)) && + Tag_val(Field(ev, EV_DEFNAME)) == String_tag) { + const char *dname = String_val(Field(ev, EV_DEFNAME)); + events[j].ev_defname = caml_stat_strdup_noexc(dname); + if (events[j].ev_defname == NULL) + caml_fatal_error ("caml_add_debug_info: out of memory"); + } else { + events[j].ev_defname = ""; } events[j].ev_lnum = Int_val(Field(ev_start, POS_LNUM)); @@ -278,32 +314,38 @@ code_t caml_next_frame_pointer(value ** sp, value ** trsp) return NULL; } -intnat caml_current_callstack_size(intnat max_frames) +#define Default_callstack_size 32 +intnat caml_collect_current_callstack(value** ptrace, intnat* plen, + intnat max_frames, int alloc_idx) { - intnat trace_size; value * sp = Caml_state->extern_sp; value * trsp = Caml_state->trapsp; + intnat trace_pos = 0; + CAMLassert(alloc_idx == 0 || alloc_idx == -1); + + if (max_frames <= 0) return 0; + if (*plen == 0) { + value* trace = + caml_stat_alloc_noexc(Default_callstack_size * sizeof(value)); + if (trace == NULL) return 0; + *ptrace = trace; + *plen = Default_callstack_size; + } - for (trace_size = 0; trace_size < max_frames; trace_size++) { + while (trace_pos < max_frames) { code_t p = caml_next_frame_pointer(&sp, &trsp); if (p == NULL) break; + if (trace_pos == *plen) { + intnat new_len = *plen * 2; + value * trace = caml_stat_resize_noexc(*ptrace, new_len * sizeof(value)); + if (trace == NULL) break; + *ptrace = trace; + *plen = new_len; + } + (*ptrace)[trace_pos++] = Val_backtrace_slot(p); } - return trace_size; -} - -void caml_current_callstack_write(value trace) { - value * sp = Caml_state->extern_sp; - value * trsp = Caml_state->trapsp; - uintnat trace_pos, trace_size = Wosize_val(trace); - - for (trace_pos = 0; trace_pos < trace_size; trace_pos++) { - code_t p = caml_next_frame_pointer(&sp, &trsp); - CAMLassert(p != NULL); - /* [Val_backtrace_slot(...)] is always a long, no need to call - [caml_modify]. */ - Field(trace, trace_pos) = Val_backtrace_slot(p); - } + return trace_pos; } /* Read the debugging info contained in the current bytecode executable. */ @@ -431,6 +473,7 @@ void caml_debuginfo_location(debuginfo dbg, li->loc_valid = 1; li->loc_is_inlined = 0; li->loc_filename = event->ev_filename; + li->loc_defname = event->ev_defname; li->loc_lnum = event->ev_lnum; li->loc_startchr = event->ev_startchr; li->loc_endchr = event->ev_endchr; diff --git a/runtime/backtrace_nat.c b/runtime/backtrace_nat.c index 81cb6d8e..893ba15d 100644 --- a/runtime/backtrace_nat.c +++ b/runtime/backtrace_nat.c @@ -104,51 +104,115 @@ void caml_stash_backtrace(value exn, uintnat pc, char * sp, char * trapsp) } } -intnat caml_current_callstack_size(intnat max_frames) { - intnat trace_size = 0; +/* A backtrace_slot is either a debuginfo or a frame_descr* */ +#define Slot_is_debuginfo(s) ((uintnat)(s) & 2) +#define Debuginfo_slot(s) ((debuginfo)((uintnat)(s) - 2)) +#define Slot_debuginfo(d) ((backtrace_slot)((uintnat)(d) + 2)) +#define Frame_descr_slot(s) ((frame_descr*)(s)) +#define Slot_frame_descr(f) ((backtrace_slot)(f)) +static debuginfo debuginfo_extract(frame_descr* d, int alloc_idx); + +#define Default_callstack_size 32 +intnat caml_collect_current_callstack(value** ptrace, intnat* plen, + intnat max_frames, int alloc_idx) +{ uintnat pc = Caml_state->last_return_address; char * sp = Caml_state->bottom_of_stack; + intnat trace_pos = 0; - while (1) { - frame_descr * descr = caml_next_frame_descriptor(&pc, &sp); - if (descr == NULL) break; - if (trace_size >= max_frames) break; - ++trace_size; - - if (sp > Caml_state->top_of_stack) break; + if (max_frames <= 0) return 0; + if (*plen == 0) { + value* trace = + caml_stat_alloc_noexc(Default_callstack_size * sizeof(value)); + if (trace == NULL) return 0; + *ptrace = trace; + *plen = Default_callstack_size; } - return trace_size; -} - -void caml_current_callstack_write(value trace) { - uintnat pc = Caml_state->last_return_address; - char * sp = Caml_state->bottom_of_stack; - intnat trace_pos, trace_size = Wosize_val(trace); + if (alloc_idx >= 0) { + /* First frame has a Comballoc selector */ + frame_descr * descr = caml_next_frame_descriptor(&pc, &sp); + debuginfo info; + if (descr == NULL) return 0; + info = debuginfo_extract(descr, alloc_idx); + if (info != NULL) { + CAMLassert(((uintnat)info & 3) == 0); + (*ptrace)[trace_pos++] = Val_backtrace_slot(Slot_debuginfo(info)); + } else { + (*ptrace)[trace_pos++] = Val_backtrace_slot(Slot_frame_descr(descr)); + } + } - for (trace_pos = 0; trace_pos < trace_size; trace_pos++) { + while (trace_pos < max_frames) { frame_descr * descr = caml_next_frame_descriptor(&pc, &sp); - CAMLassert(descr != NULL); - /* [Val_backtrace_slot(...)] is always a long, no need to call - [caml_modify]. */ - Field(trace, trace_pos) = Val_backtrace_slot((backtrace_slot) descr); + if (descr == NULL) break; + CAMLassert(((uintnat)descr & 3) == 0); + if (trace_pos == *plen) { + intnat new_len = *plen * 2; + value * trace = caml_stat_resize_noexc(*ptrace, new_len * sizeof(value)); + if (trace == NULL) break; + *ptrace = trace; + *plen = new_len; + } + (*ptrace)[trace_pos++] = Val_backtrace_slot(Slot_frame_descr(descr)); } + + return trace_pos; } -debuginfo caml_debuginfo_extract(backtrace_slot slot) +static debuginfo debuginfo_extract(frame_descr* d, int alloc_idx) { - uintnat infoptr; - frame_descr * d = (frame_descr *)slot; + unsigned char* infoptr; + uint32_t debuginfo_offset; + + /* The special frames marking the top of an ML stack chunk are never + returned by caml_next_frame_descriptor, so should never reach here. */ + CAMLassert(d->frame_size != 0xffff); if ((d->frame_size & 1) == 0) { return NULL; } /* Recover debugging info */ - infoptr = ((uintnat) d + - sizeof(char *) + sizeof(short) + sizeof(short) + - sizeof(short) * d->num_live + sizeof(frame_descr *) - 1) - & -sizeof(frame_descr *); - return *((debuginfo*)infoptr); + infoptr = (unsigned char*)&d->live_ofs[d->num_live]; + if (d->frame_size & 2) { + CAMLassert(alloc_idx == -1 || (0 <= alloc_idx && alloc_idx < *infoptr)); + /* skip alloc_lengths */ + infoptr += *infoptr + 1; + /* align to 32 bits */ + infoptr = Align_to(infoptr, uint32_t); + /* select the right debug info for this allocation */ + if (alloc_idx != -1) { + infoptr += alloc_idx * sizeof(uint32_t); + if (*(uint32_t*)infoptr == 0) { + /* No debug info for this particular allocation */ + return NULL; + } + } else { + /* We don't care which alloc_idx we use, so use the first + that has debug info. (e.g. this is a backtrace through a + finaliser/signal handler triggered via a Comballoc alloc) */ + while (*(uint32_t*)infoptr == 0) { + infoptr += sizeof(uint32_t); + } + } + } else { + /* align to 32 bits */ + infoptr = Align_to(infoptr, uint32_t); + CAMLassert(alloc_idx == -1); + } + debuginfo_offset = *(uint32_t*)infoptr; + CAMLassert(debuginfo_offset != 0 && (debuginfo_offset & 3) == 0); + return (debuginfo)(infoptr + debuginfo_offset); +} + +debuginfo caml_debuginfo_extract(backtrace_slot slot) +{ + if (Slot_is_debuginfo(slot)) { + /* already a decoded debuginfo */ + return Debuginfo_slot(slot); + } else { + return debuginfo_extract(Frame_descr_slot(slot), -1); + } } debuginfo caml_debuginfo_next(debuginfo dbg) @@ -159,14 +223,26 @@ debuginfo caml_debuginfo_next(debuginfo dbg) return NULL; infoptr = dbg; - infoptr += 2; /* Two packed info fields */ - return *((debuginfo*)infoptr); + if ((infoptr[0] & 1) == 0) + /* No next debuginfo */ + return NULL; + else + /* Next debuginfo is after the two packed info fields */ + return (debuginfo*)(infoptr + 2); } +/* Multiple names may share the same filename, + so it is referenced as an offset instead of stored inline */ +struct name_info { + int32_t filename_offs; + char name[1]; +}; + /* Extract location information for the given frame descriptor */ void caml_debuginfo_location(debuginfo dbg, /*out*/ struct caml_loc_info * li) { uint32_t info1, info2; + struct name_info * name_info; /* If no debugging information available, print nothing. When everything is compiled with -g, this corresponds to @@ -180,20 +256,25 @@ void caml_debuginfo_location(debuginfo dbg, /*out*/ struct caml_loc_info * li) /* Recover debugging info */ info1 = ((uint32_t *)dbg)[0]; info2 = ((uint32_t *)dbg)[1]; + name_info = (struct name_info*)((char *) dbg + (info1 & 0x3FFFFFC)); /* Format of the two info words: - llllllllllllllllllll aaaaaaaa bbbbbbbbbb nnnnnnnnnnnnnnnnnnnnnnnn kk - 44 36 26 2 0 + llllllllllllllllllll aaaaaaaa bbbbbbbbbb ffffffffffffffffffffffff k n + 44 36 26 2 1 0 (32+12) (32+4) - k ( 2 bits): 0 if it's a call + n ( 1 bit ): 0 if this is the final debuginfo + 1 if there's another following this one + k ( 1 bit ): 0 if it's a call 1 if it's a raise - n (24 bits): offset (in 4-byte words) of file name relative to dbg + f (24 bits): offset (in 4-byte words) of file name relative to dbg l (20 bits): line number a ( 8 bits): beginning of character range b (10 bits): end of character range */ li->loc_valid = 1; - li->loc_is_raise = (info1 & 3) == 1; + li->loc_is_raise = (info1 & 2) == 2; li->loc_is_inlined = caml_debuginfo_next(dbg) != NULL; - li->loc_filename = (char *) dbg + (info1 & 0x3FFFFFC); + li->loc_defname = name_info->name; + li->loc_filename = + (char *)name_info + name_info->filename_offs; li->loc_lnum = info2 >> 12; li->loc_startchr = (info2 >> 4) & 0xFF; li->loc_endchr = ((info2 & 0xF) << 6) | (info1 >> 26); diff --git a/runtime/bigarray.c b/runtime/bigarray.c index 60733909..871b81ef 100644 --- a/runtime/bigarray.c +++ b/runtime/bigarray.c @@ -67,7 +67,7 @@ CAMLexport uintnat caml_ba_byte_size(struct caml_ba_array * b) /* Operation table for bigarrays */ CAMLexport struct custom_operations caml_ba_ops = { - "_bigarray", + "_bigarr02", caml_ba_finalize, caml_ba_compare, caml_ba_hash, @@ -374,11 +374,15 @@ CAMLexport void caml_ba_serialize(value v, /* Serialize header information */ caml_serialize_int_4(b->num_dims); caml_serialize_int_4(b->flags & (CAML_BA_KIND_MASK | CAML_BA_LAYOUT_MASK)); - /* On a 64-bit machine, if any of the dimensions is >= 2^32, - the size of the marshaled data will be >= 2^32 and - extern_value() will fail. So, it is safe to write the dimensions - as 32-bit unsigned integers. */ - for (i = 0; i < b->num_dims; i++) caml_serialize_int_4(b->dim[i]); + for (i = 0; i < b->num_dims; i++) { + intnat len = b->dim[i]; + if (len < 0xffff) { + caml_serialize_int_2(len); + } else { + caml_serialize_int_2(0xffff); + caml_serialize_int_8(len); + } + } /* Compute total number of elements */ num_elts = 1; for (i = 0; i < b->num_dims; i++) num_elts = num_elts * b->dim[i]; @@ -446,7 +450,11 @@ CAMLexport uintnat caml_ba_deserialize(void * dst) caml_deserialize_error("input_value: wrong number of bigarray dimensions"); b->flags = caml_deserialize_uint_4() | CAML_BA_MANAGED; b->proxy = NULL; - for (i = 0; i < b->num_dims; i++) b->dim[i] = caml_deserialize_uint_4(); + for (i = 0; i < b->num_dims; i++) { + intnat len = caml_deserialize_uint_2(); + if (len == 0xffff) len = caml_deserialize_uint_8(); + b->dim[i] = len; + } /* Compute total number of elements. Watch out for overflows (MPR#7765). */ num_elts = 1; for (i = 0; i < b->num_dims; i++) { diff --git a/runtime/caml/alloc.h b/runtime/caml/alloc.h index f3f490af..7e2be4b0 100644 --- a/runtime/caml/alloc.h +++ b/runtime/caml/alloc.h @@ -64,14 +64,14 @@ CAMLextern value caml_alloc_final (mlsize_t wosize, CAMLextern int caml_convert_flag_list (value, int *); /* Convenience functions to deal with unboxable types. */ -static inline value caml_alloc_unboxed (value arg) { return arg; } -static inline value caml_alloc_boxed (value arg) { +Caml_inline value caml_alloc_unboxed (value arg) { return arg; } +Caml_inline value caml_alloc_boxed (value arg) { value result = caml_alloc_small (1, 0); Field (result, 0) = arg; return result; } -static inline value caml_field_unboxed (value arg) { return arg; } -static inline value caml_field_boxed (value arg) { return Field (arg, 0); } +Caml_inline value caml_field_unboxed (value arg) { return arg; } +Caml_inline value caml_field_boxed (value arg) { return Field (arg, 0); } /* Unannotated unboxable types are boxed by default. (may change in the future) */ diff --git a/runtime/caml/backtrace_prim.h b/runtime/caml/backtrace_prim.h index 08c23604..cf9596d3 100644 --- a/runtime/caml/backtrace_prim.h +++ b/runtime/caml/backtrace_prim.h @@ -36,6 +36,7 @@ struct caml_loc_info { int loc_valid; int loc_is_raise; char * loc_filename; + char * loc_defname; int loc_lnum; int loc_startchr; int loc_endchr; @@ -43,7 +44,7 @@ struct caml_loc_info { }; /* When compiling with -g, backtrace slots have debug info associated. - * When a call is inlined in native mode, debuginfos form a linked list. + * When a call is inlined in native mode, debuginfos form a sequence. */ typedef void * debuginfo; @@ -90,28 +91,21 @@ value caml_remove_debug_info(code_t start); * It defines the [caml_stash_backtrace] function, which is called to quickly * fill the backtrace buffer by walking the stack when an exception is raised. * - * It also defines the two following functions, which makes it possible - * to store upto [max_frames_value] frames of the current call - * stack. This is not used in an exception-raising context, but only - * when the user requests to save the trace (hopefully less often), or - * the context of profiling. Instead of using a bounded buffer as - * [caml_stash_backtrace], we first traverse the stack to compute the - * right size, then allocate space for the trace. + * It also defines [caml_collect_current_callstack], which stores up + * to [max_frames] frames of the current call stack into the + * statically allocated buffer [*pbuffer] of length [*plen]. If the + * buffer is not long enough, it will be reallocated. The number of + * frames collected is returned. * - * The first function, [caml_current_callstack_size] computes the size - * (in words) of the needed buffer, while the second actually writes - * the call stack to the buffer as an object of type - * [raw_backtrace]. It should always be called with a buffer of the - * size predicted by [caml_current_callstack_size]. The reason we use - * two separated functions is to allow using either [caml_alloc] (for - * performance) or [caml_alloc_shr] (when we need to avoid a call to - * the GC, in memprof.c). + * The alloc_idx parameter is used to select between the backtraces of + * different allocation sites which were combined by Comballoc. + * Passing -1 here means the caller doesn't care which is chosen. * * We use `intnat` for max_frames because, were it only `int`, passing * `max_int` from the OCaml side would overflow on 64bits machines. */ -intnat caml_current_callstack_size(intnat max_frames); -void caml_current_callstack_write(value trace); +intnat caml_collect_current_callstack(value** pbuffer, intnat* plen, + intnat max_frames, int alloc_idx); #endif /* CAML_INTERNALS */ diff --git a/runtime/caml/config.h b/runtime/caml/config.h index d1f93bb9..b119bc34 100644 --- a/runtime/caml/config.h +++ b/runtime/caml/config.h @@ -34,7 +34,9 @@ #endif #if defined(_MSC_VER) && !defined(__cplusplus) -#define inline __inline +#define Caml_inline static __inline +#else +#define Caml_inline static inline #endif #include "s.h" @@ -120,6 +122,7 @@ typedef unsigned short uint16_t; #else #error "No 16-bit integer type available" #endif +typedef unsigned char uint8_t; #endif #if SIZEOF_PTR == SIZEOF_LONG diff --git a/runtime/caml/domain_state.h b/runtime/caml/domain_state.h index 798a461b..ee4613d6 100644 --- a/runtime/caml/domain_state.h +++ b/runtime/caml/domain_state.h @@ -18,6 +18,7 @@ #define CAML_STATE_H #include +#include #include "misc.h" #include "mlvalues.h" @@ -32,6 +33,7 @@ typedef struct { #endif #include "domain_state.tbl" #undef DOMAIN_STATE + CAMLalign(8) char end_of_domain_state; } caml_domain_state; enum { @@ -44,9 +46,8 @@ enum { /* Check that the structure was laid out without padding, since the runtime assumes this in computing offsets */ CAML_STATIC_ASSERT( - sizeof(caml_domain_state) == - (Domain_state_num_fields - ) * 8); + offsetof(caml_domain_state, end_of_domain_state) == + Domain_state_num_fields * 8); CAMLextern caml_domain_state* Caml_state; #ifdef CAML_NAME_SPACE diff --git a/runtime/caml/domain_state.tbl b/runtime/caml/domain_state.tbl index 80ac7875..ef838433 100644 --- a/runtime/caml/domain_state.tbl +++ b/runtime/caml/domain_state.tbl @@ -73,3 +73,10 @@ DOMAIN_STATE(intnat, stat_top_heap_wsz) DOMAIN_STATE(intnat, stat_compactions) DOMAIN_STATE(intnat, stat_heap_chunks) /* See gc_ctrl.c */ + +DOMAIN_STATE(uintnat, eventlog_startup_timestamp) +DOMAIN_STATE(uint32_t, eventlog_startup_pid) +DOMAIN_STATE(uintnat, eventlog_paused) +DOMAIN_STATE(uintnat, eventlog_enabled) +DOMAIN_STATE(FILE*, eventlog_out) +/* See eventlog.c */ diff --git a/runtime/caml/eventlog.h b/runtime/caml/eventlog.h new file mode 100644 index 00000000..3f2a4fca --- /dev/null +++ b/runtime/caml/eventlog.h @@ -0,0 +1,130 @@ +/**************************************************************************/ +/* */ +/* OCaml */ +/* */ +/* Stephen Dolan, University of Cambridge */ +/* Enguerrand Decorne, Tarides */ +/* */ +/* Copyright 2020 University of Cambridge */ +/* Copyright 2020 Tarides */ +/* */ +/* 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. */ +/* */ +/**************************************************************************/ + +#ifndef CAML_EVENTLOG_H +#define CAML_EVENTLOG_H + +typedef enum { + EV_ENTRY, + EV_EXIT, + EV_COUNTER, + EV_ALLOC, + EV_FLUSH +} ev_type; + +typedef enum { + EV_COMPACT_MAIN, + EV_COMPACT_RECOMPACT, + EV_EXPLICIT_GC_SET, + EV_EXPLICIT_GC_STAT, + EV_EXPLICIT_GC_MINOR, + EV_EXPLICIT_GC_MAJOR, + EV_EXPLICIT_GC_FULL_MAJOR, + EV_EXPLICIT_GC_COMPACT, + EV_MAJOR, + EV_MAJOR_ROOTS, + EV_MAJOR_SWEEP, + EV_MAJOR_MARK_ROOTS, + EV_MAJOR_MARK_MAIN, + EV_MAJOR_MARK_FINAL, + EV_MAJOR_MARK, + EV_MAJOR_MARK_GLOBAL_ROOTS_SLICE, + EV_MAJOR_ROOTS_GLOBAL, + EV_MAJOR_ROOTS_DYNAMIC_GLOBAL, + EV_MAJOR_ROOTS_LOCAL, + EV_MAJOR_ROOTS_C, + EV_MAJOR_ROOTS_FINALISED, + EV_MAJOR_ROOTS_MEMPROF, + EV_MAJOR_ROOTS_HOOK, + EV_MAJOR_CHECK_AND_COMPACT, + EV_MINOR, + EV_MINOR_LOCAL_ROOTS, + EV_MINOR_REF_TABLES, + EV_MINOR_COPY, + EV_MINOR_UPDATE_WEAK, + EV_MINOR_FINALIZED, + EV_EXPLICIT_GC_MAJOR_SLICE +} ev_gc_phase; + +typedef enum { + EV_C_ALLOC_JUMP, + EV_C_FORCE_MINOR_ALLOC_SMALL, + EV_C_FORCE_MINOR_MAKE_VECT, + EV_C_FORCE_MINOR_SET_MINOR_HEAP_SIZE, + EV_C_FORCE_MINOR_WEAK, + EV_C_FORCE_MINOR_MEMPROF, + EV_C_MAJOR_MARK_SLICE_REMAIN, + EV_C_MAJOR_MARK_SLICE_FIELDS, + EV_C_MAJOR_MARK_SLICE_POINTERS, + EV_C_MAJOR_WORK_EXTRA, + EV_C_MAJOR_WORK_MARK, + EV_C_MAJOR_WORK_SWEEP, + EV_C_MINOR_PROMOTED, + EV_C_REQUEST_MAJOR_ALLOC_SHR, + EV_C_REQUEST_MAJOR_ADJUST_GC_SPEED, + EV_C_REQUEST_MINOR_REALLOC_REF_TABLE, + EV_C_REQUEST_MINOR_REALLOC_EPHE_REF_TABLE, + EV_C_REQUEST_MINOR_REALLOC_CUSTOM_TABLE +} ev_gc_counter; + +#ifdef CAML_INSTR + +#define CAML_EVENTLOG_DO(f) if (Caml_state->eventlog_enabled &&\ + !Caml_state->eventlog_paused) f + +#define CAML_EVENTLOG_INIT() caml_eventlog_init() +#define CAML_EVENTLOG_DISABLE() caml_eventlog_disable() +#define CAML_EV_BEGIN(p) caml_ev_begin(p) +#define CAML_EV_END(p) caml_ev_end(p) +#define CAML_EV_COUNTER(c, v) caml_ev_counter(c, v) +#define CAML_EV_ALLOC(s) caml_ev_alloc(s) +#define CAML_EV_ALLOC_FLUSH() caml_ev_alloc_flush() +#define CAML_EV_FLUSH() caml_ev_flush() + +/* General note about the public API for the eventlog framework + The caml_ev_* functions are no-op when called with the eventlog framework + paused or disabled. + caml_eventlog_* functions on the other hand may introduce side effects + (such as write buffer flushes, or side effects in the eventlog internals.) + + All these functions should be called while holding the runtime lock. +*/ + +void caml_eventlog_init(void); +void caml_eventlog_disable(void); +void caml_ev_begin(ev_gc_phase phase); +void caml_ev_end(ev_gc_phase phase); +void caml_ev_counter(ev_gc_counter counter, uint64_t val); +void caml_ev_alloc(uint64_t size); +void caml_ev_alloc_flush(void); +void caml_ev_flush(void); + +#else + +#define CAML_EVENTLOG_DO(f) /**/ + +#define CAML_EVENTLOG_INIT() /**/ +#define CAML_EVENTLOG_DISABLE() /**/ +#define CAML_EV_BEGIN(p) /**/ +#define CAML_EV_END(p) /**/ +#define CAML_EV_COUNTER(c, v) /**/ +#define CAML_EV_ALLOC(S) /**/ +#define CAML_EV_ALLOC_FLUSH() /**/ +#define CAML_EV_FLUSH() /**/ + +#endif /*CAML_INSTR*/ + +#endif /*CAML_EVENTLOG_H*/ diff --git a/runtime/caml/exec.h b/runtime/caml/exec.h index 51627f79..c8b4ab37 100644 --- a/runtime/caml/exec.h +++ b/runtime/caml/exec.h @@ -60,7 +60,7 @@ struct exec_trailer { /* Magic number for this release */ -#define EXEC_MAGIC "Caml1999X027" +#define EXEC_MAGIC "Caml1999X028" #endif /* CAML_INTERNALS */ diff --git a/runtime/caml/freelist.h b/runtime/caml/freelist.h index 8ceae4a5..17ebf5ef 100644 --- a/runtime/caml/freelist.h +++ b/runtime/caml/freelist.h @@ -36,19 +36,19 @@ extern void (*caml_fl_p_make_free_blocks) extern void (*caml_fl_p_check) (void); #endif -static inline header_t *caml_fl_allocate (mlsize_t wo_sz) +Caml_inline header_t *caml_fl_allocate (mlsize_t wo_sz) { return (*caml_fl_p_allocate) (wo_sz); } -static inline void caml_fl_init_merge (void) +Caml_inline void caml_fl_init_merge (void) { (*caml_fl_p_init_merge) (); } -static inline header_t *caml_fl_merge_block (value bp, char *limit) +Caml_inline header_t *caml_fl_merge_block (value bp, char *limit) { return (*caml_fl_p_merge_block) (bp, limit); } -static inline void caml_fl_add_blocks (value bp) +Caml_inline void caml_fl_add_blocks (value bp) { (*caml_fl_p_add_blocks) (bp); } -static inline void caml_make_free_blocks +Caml_inline void caml_make_free_blocks (value *p, mlsize_t size, int do_merge, int color) { (*caml_fl_p_make_free_blocks) (p, size, do_merge, color); } @@ -56,7 +56,7 @@ extern void caml_set_allocation_policy (intnat); extern void caml_fl_reset_and_switch_policy (intnat); #ifdef DEBUG -static inline void caml_fl_check (void) +Caml_inline void caml_fl_check (void) { (*caml_fl_p_check) (); } #endif diff --git a/runtime/caml/m.h.in b/runtime/caml/m.h.in index 4299643a..b5a7205b 100644 --- a/runtime/caml/m.h.in +++ b/runtime/caml/m.h.in @@ -81,14 +81,6 @@ #undef WITH_SPACETIME #undef ENABLE_CALL_COUNTS -#undef NONSTANDARD_DIV_MOD - -/* Leave NONSTANDARD_DIV_MOD undefined if the C operators / and % implement - round-towards-zero semantics, as specified by ISO C 9x and implemented - by most contemporary processors. Otherwise, or if you don't know, - define NONSTANDARD_DIV_MOD: this will select a slower but correct - software emulation of division and modulus. */ - #undef ASM_CFI_SUPPORTED #undef WITH_FRAME_POINTERS diff --git a/runtime/caml/memory.h b/runtime/caml/memory.h index ad35a0b7..2669cfdf 100644 --- a/runtime/caml/memory.h +++ b/runtime/caml/memory.h @@ -214,7 +214,8 @@ enum caml_alloc_small_flags { CAML_FROM_C = 0, CAML_FROM_CAML = 2 }; -extern void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags); +extern void caml_alloc_small_dispatch (intnat wosize, int flags, + int nallocs, unsigned char* alloc_lens); // Do not call asynchronous callbacks from allocation functions #define Alloc_small_origin CAML_FROM_C #define Alloc_small_aux(result, wosize, tag, profinfo, track) do { \ @@ -224,12 +225,12 @@ extern void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags); Caml_state_field(young_ptr) -= Whsize_wosize (wosize); \ if (Caml_state_field(young_ptr) < Caml_state_field(young_limit)) { \ Setup_for_gc; \ - caml_alloc_small_dispatch((tag), (wosize), \ - (track) | Alloc_small_origin); \ + caml_alloc_small_dispatch((wosize), (track) | Alloc_small_origin, \ + 1, NULL); \ Restore_after_gc; \ } \ Hd_hp (Caml_state_field(young_ptr)) = \ - Make_header_with_profinfo ((wosize), (tag), Caml_black, profinfo); \ + Make_header_with_profinfo ((wosize), (tag), 0, profinfo); \ (result) = Val_hp (Caml_state_field(young_ptr)); \ DEBUG_clear ((result), (wosize)); \ }while(0) diff --git a/runtime/caml/memprof.h b/runtime/caml/memprof.h index c313f277..af311050 100644 --- a/runtime/caml/memprof.h +++ b/runtime/caml/memprof.h @@ -24,16 +24,31 @@ extern int caml_memprof_suspended; -extern value caml_memprof_handle_postponed_exn(); +extern value caml_memprof_handle_postponed_exn(void); extern void caml_memprof_track_alloc_shr(value block); -extern void caml_memprof_track_young(tag_t tag, uintnat wosize, int from_caml); +extern void caml_memprof_track_young(uintnat wosize, int from_caml, + int nallocs, unsigned char* alloc_lens); extern void caml_memprof_track_interned(header_t* block, header_t* blockend); extern void caml_memprof_renew_minor_sample(void); extern value* caml_memprof_young_trigger; -extern void caml_memprof_scan_roots(scanning_action f); +extern void caml_memprof_oldify_young_roots(void); +extern void caml_memprof_minor_update(void); +extern void caml_memprof_do_roots(scanning_action f); +extern void caml_memprof_update_clean_phase(void); +extern void caml_memprof_invert_tracked(void); + +extern void caml_memprof_shutdown(void); + +struct caml_memprof_th_ctx { + int suspended, callback_running; +}; +extern void caml_memprof_init_th_ctx(struct caml_memprof_th_ctx* ctx); +extern void caml_memprof_stop_th_ctx(struct caml_memprof_th_ctx* ctx); +extern void caml_memprof_save_th_ctx(struct caml_memprof_th_ctx* ctx); +extern void caml_memprof_restore_th_ctx(const struct caml_memprof_th_ctx* ctx); #endif diff --git a/runtime/caml/minor_gc.h b/runtime/caml/minor_gc.h index d2d6bcc2..20baa8d5 100644 --- a/runtime/caml/minor_gc.h +++ b/runtime/caml/minor_gc.h @@ -81,6 +81,12 @@ extern void caml_alloc_custom_table (struct caml_custom_table *, asize_t, asize_t); void caml_alloc_minor_tables (void); +/* Asserts that a word is a valid header for a young object */ +#define CAMLassert_young_header(hd) \ + CAMLassert(Wosize_hd(hd) > 0 && \ + Wosize_hd(hd) <= Max_young_wosize && \ + Color_hd(hd) == 0) + #define Oldify(p) do{ \ value __oldify__v__ = *p; \ if (Is_block (__oldify__v__) && Is_young (__oldify__v__)){ \ @@ -88,7 +94,7 @@ void caml_alloc_minor_tables (void); } \ }while(0) -static inline void add_to_ref_table (struct caml_ref_table *tbl, value *p) +Caml_inline void add_to_ref_table (struct caml_ref_table *tbl, value *p) { if (tbl->ptr >= tbl->limit){ CAMLassert (tbl->ptr == tbl->limit); @@ -97,7 +103,7 @@ static inline void add_to_ref_table (struct caml_ref_table *tbl, value *p) *tbl->ptr++ = p; } -static inline void add_to_ephe_ref_table (struct caml_ephe_ref_table *tbl, +Caml_inline void add_to_ephe_ref_table (struct caml_ephe_ref_table *tbl, value ar, mlsize_t offset) { struct caml_ephe_ref_elt *ephe_ref; @@ -111,7 +117,7 @@ static inline void add_to_ephe_ref_table (struct caml_ephe_ref_table *tbl, CAMLassert(ephe_ref->offset < Wosize_val(ephe_ref->ephe)); } -static inline void add_to_custom_table (struct caml_custom_table *tbl, value v, +Caml_inline void add_to_custom_table (struct caml_custom_table *tbl, value v, mlsize_t mem, mlsize_t max) { struct caml_custom_elt *elt; diff --git a/runtime/caml/misc.h b/runtime/caml/misc.h index 8eb09931..fcc06660 100644 --- a/runtime/caml/misc.h +++ b/runtime/caml/misc.h @@ -27,17 +27,12 @@ #include #include -#include #include /* Basic types and constants */ typedef size_t asize_t; -#ifndef NULL -#define NULL 0 -#endif - #if defined(__GNUC__) || defined(__clang__) /* Supported since at least GCC 3.1 */ #define CAMLdeprecated_typedef(name, type) \ @@ -101,7 +96,7 @@ CAMLdeprecated_typedef(addr, char *); /* we need to be able to compute the exact offset of each member. */ #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #define CAMLalign(n) _Alignas(n) -#elif defined(__cplusplus) && _MSC_VER >= 1900 +#elif defined(__cplusplus) && (__cplusplus >= 201103L || _MSC_VER >= 1900) #define CAMLalign(n) alignas(n) #elif defined(SUPPORTS_ALIGNED_ATTRIBUTE) #define CAMLalign(n) __attribute__((aligned(n))) @@ -216,7 +211,7 @@ CAMLnoreturn_end; If overflow is reported, this is the exact result modulo 2 to the word size. */ -static inline int caml_uadd_overflow(uintnat a, uintnat b, uintnat * res) +Caml_inline int caml_uadd_overflow(uintnat a, uintnat b, uintnat * res) { #if __GNUC__ >= 5 || Caml_has_builtin(__builtin_add_overflow) return __builtin_add_overflow(a, b, res); @@ -227,7 +222,7 @@ static inline int caml_uadd_overflow(uintnat a, uintnat b, uintnat * res) #endif } -static inline int caml_usub_overflow(uintnat a, uintnat b, uintnat * res) +Caml_inline int caml_usub_overflow(uintnat a, uintnat b, uintnat * res) { #if __GNUC__ >= 5 || Caml_has_builtin(__builtin_sub_overflow) return __builtin_sub_overflow(a, b, res); @@ -239,7 +234,7 @@ static inline int caml_usub_overflow(uintnat a, uintnat b, uintnat * res) } #if __GNUC__ >= 5 || Caml_has_builtin(__builtin_mul_overflow) -static inline int caml_umul_overflow(uintnat a, uintnat b, uintnat * res) +Caml_inline int caml_umul_overflow(uintnat a, uintnat b, uintnat * res) { return __builtin_mul_overflow(a, b, res); } @@ -408,107 +403,19 @@ extern void caml_set_fields (intnat v, uintnat, uintnat); /* snprintf emulation for Win32 */ -#if defined(_WIN32) && !defined(_UCRT) +#ifdef _WIN32 +#ifndef _UCRT extern int caml_snprintf(char * buf, size_t size, const char * format, ...); #define snprintf caml_snprintf #endif -#ifdef CAML_INSTR -/* Timers and counters for GC latency profiling (Linux-only) */ - -#include -#include - -extern intnat caml_instr_starttime, caml_instr_stoptime; - -struct caml_instr_block { - struct timespec ts[10]; - char *tag[10]; - int index; - struct caml_instr_block *next; -}; - -extern struct caml_instr_block *caml_instr_log; - -/* Declare a timer/counter name. [t] must be a new variable name. */ -#define CAML_INSTR_DECLARE(t) \ - struct caml_instr_block *t = NULL - -/* Allocate the data block for a given name. - [t] must have been declared with [CAML_INSTR_DECLARE]. */ -#define CAML_INSTR_ALLOC(t) do{ \ - if (Caml_state_field(stat_minor_collections) >= caml_instr_starttime \ - && Caml_state_field(stat_minor_collections) < caml_instr_stoptime){ \ - t = caml_stat_alloc_noexc (sizeof (struct caml_instr_block)); \ - t->index = 0; \ - t->tag[0] = ""; \ - t->next = caml_instr_log; \ - caml_instr_log = t; \ - } \ - }while(0) - -/* Allocate the data block and start the timer. - [t] must have been declared with [CAML_INSTR_DECLARE] - and allocated with [CAML_INSTR_ALLOC]. */ -#define CAML_INSTR_START(t, msg) do{ \ - if (t != NULL){ \ - t->tag[0] = msg; \ - clock_gettime (CLOCK_REALTIME, &(t->ts[0])); \ - } \ - }while(0) - -/* Declare a timer, allocate its data, and start it. - [t] must be a new variable name. */ -#define CAML_INSTR_SETUP(t, msg) \ - CAML_INSTR_DECLARE (t); \ - CAML_INSTR_ALLOC (t); \ - CAML_INSTR_START (t, msg) - -/* Record an intermediate time within a given timer. - [t] must have been declared, allocated, and started. */ -#define CAML_INSTR_TIME(t, msg) do{ \ - if (t != NULL){ \ - ++ t->index; \ - t->tag[t->index] = (msg); \ - clock_gettime (CLOCK_REALTIME, &(t->ts[t->index])); \ - } \ - }while(0) - -/* Record an integer data point. - If [msg] ends with # it will be interpreted as an integer-valued event. - If it ends with @ it will be interpreted as an event counter. -*/ -#define CAML_INSTR_INT(msg, data) do{ \ - CAML_INSTR_SETUP (__caml_tmp, ""); \ - if (__caml_tmp != NULL){ \ - __caml_tmp->index = 1; \ - __caml_tmp->tag[1] = msg; \ - __caml_tmp->ts[1].tv_sec = 0; \ - __caml_tmp->ts[1].tv_nsec = (data); \ - } \ - }while(0) - -/* This function is called at the start of the program to set up - the data for the above macros. -*/ -extern void caml_instr_init (void); - -/* This function is automatically called by the runtime to output - the collected data to the dump file. */ -extern void caml_instr_atexit (void); - -#else /* CAML_INSTR */ - -#define CAML_INSTR_DECLARE(t) /**/ -#define CAML_INSTR_ALLOC(t) /**/ -#define CAML_INSTR_START(t, name) /**/ -#define CAML_INSTR_SETUP(t, name) /**/ -#define CAML_INSTR_TIME(t, msg) /**/ -#define CAML_INSTR_INT(msg, c) /**/ -#define caml_instr_init() /**/ -#define caml_instr_atexit() /**/ - -#endif /* CAML_INSTR */ +extern int caml_snwprintf(wchar_t * buf, + size_t size, + const wchar_t * format, ...); +#define snprintf_os caml_snwprintf +#else +#define snprintf_os snprintf +#endif /* Macro used to deactivate thread and address sanitizers on some functions. */ @@ -541,8 +448,10 @@ int caml_find_code_fragment(char *pc, int *index, struct code_fragment **cf); /* The [backtrace_slot] type represents values stored in * [Caml_state->backtrace_buffer]. In bytecode, it is the same as a - * [code_t], in native code it as a [frame_descr *]. The difference - * doesn't matter for code outside [backtrace_{byt,nat}.c], + * [code_t], in native code it is either a [frame_descr *] or a [debuginfo], + * depending on the second-lowest bit. In any case, the lowest bit must + * be 0. + * The representation doesn't matter for code outside [backtrace_{byt,nat}.c], * so it is just exposed as a [void *]. */ typedef void * backtrace_slot; diff --git a/runtime/caml/mlvalues.h b/runtime/caml/mlvalues.h index 780c014e..487dd080 100644 --- a/runtime/caml/mlvalues.h +++ b/runtime/caml/mlvalues.h @@ -312,14 +312,14 @@ CAMLextern void caml_Store_double_val (value,double); #define Double_field(v,i) Double_flat_field(v,i) #define Store_double_field(v,i,d) Store_double_flat_field(v,i,d) #else - static inline double Double_field (value v, mlsize_t i) { + Caml_inline double Double_field (value v, mlsize_t i) { if (Tag_val (v) == Double_array_tag){ return Double_flat_field (v, i); }else{ return Double_array_field (v, i); } } - static inline void Store_double_field (value v, mlsize_t i, double d) { + Caml_inline void Store_double_field (value v, mlsize_t i, double d) { if (Tag_val (v) == Double_array_tag){ Store_double_flat_field (v, i, d); }else{ diff --git a/runtime/caml/s.h.in b/runtime/caml/s.h.in index b618309d..30d2d768 100644 --- a/runtime/caml/s.h.in +++ b/runtime/caml/s.h.in @@ -188,6 +188,10 @@ /* Define HAS_PUTENV if you have putenv(). */ +#undef HAS_SETENV_UNSETENV + +/* Define HAS_SETENV_UNSETENV if you have setenv() and unsetenv(). */ + #undef HAS_LOCALE_H /* Define HAS_LOCALE_H if you have the include file and the @@ -261,3 +265,7 @@ #undef HAS_BROKEN_PRINTF #undef HAS_STRERROR + +#undef HAS_POSIX_MONOTONIC_CLOCK + +#undef HAS_MACH_ABSOLUTE_TIME diff --git a/runtime/caml/stack.h b/runtime/caml/stack.h index 259f97ac..6b7df0e6 100644 --- a/runtime/caml/stack.h +++ b/runtime/caml/stack.h @@ -70,6 +70,11 @@ #define Callback_link(sp) ((struct caml_context *)((sp) + 16)) #endif +#ifdef TARGET_riscv +#define Saved_return_address(sp) *((intnat *)((sp) - 8)) +#define Callback_link(sp) ((struct caml_context *)((sp) + 16)) +#endif + /* Structure of OCaml callback contexts */ struct caml_context { @@ -87,9 +92,28 @@ typedef struct { uintnat retaddr; unsigned short frame_size; unsigned short num_live; - unsigned short live_ofs[1]; + unsigned short live_ofs[1 /* num_live */]; + /* + If frame_size & 2, then allocation info follows: + unsigned char num_allocs; + unsigned char alloc_lengths[num_alloc]; + + If frame_size & 1, then debug info follows: + uint32_t debug_info_offset[num_debug]; + + Debug info is stored as relative offsets to debuginfo structures. + num_debug is num_alloc if frame_size & 2, otherwise 1. */ } frame_descr; +/* Allocation lengths are encoded as 0-255, giving sizes 1-256 */ +#define Wosize_encoded_alloc_len(n) ((uintnat)(n) + 1) + +/* Used to compute offsets in frame tables. + ty must have power-of-2 size */ +#define Align_to(p, ty) \ + (void*)(((uintnat)(p) + sizeof(ty) - 1) & -sizeof(ty)) + + /* Hash table of frame descriptors */ extern frame_descr ** caml_frame_descriptors; diff --git a/runtime/caml/weak.h b/runtime/caml/weak.h index a6259764..a8f36ab1 100644 --- a/runtime/caml/weak.h +++ b/runtime/caml/weak.h @@ -161,16 +161,18 @@ extern value caml_ephe_none; /* In the header, in order to let major_gc.c and weak.c see the body of the function */ -static inline void caml_ephe_clean (value v){ +Caml_inline void caml_ephe_clean_partial (value v, + mlsize_t offset_start, + mlsize_t offset_end) { value child; int release_data = 0; - mlsize_t size, i; - header_t hd; + mlsize_t i; CAMLassert(caml_gc_phase == Phase_clean); + CAMLassert(2 <= offset_start + && offset_start <= offset_end + && offset_end <= Wosize_hd (Hd_val(v))); - hd = Hd_val (v); - size = Wosize_hd (hd); - for (i = 2; i < size; i++){ + for (i = offset_start; i < offset_end; i++){ child = Field (v, i); ephemeron_again: if (child != caml_ephe_none @@ -198,16 +200,28 @@ static inline void caml_ephe_clean (value v){ child = Field (v, 1); if(child != caml_ephe_none){ - if (release_data){ + if (release_data){ Field (v, 1) = caml_ephe_none; } else { - /* The mark phase must have marked it */ - CAMLassert( !(Is_block (child) && Is_in_heap (child) - && Is_white_val (child)) ); + /* If we scanned all the keys and the data field remains filled, + then the mark phase must have marked it */ + CAMLassert( !(offset_start == 2 && offset_end == Wosize_hd (Hd_val(v)) + && Is_block (child) && Is_in_heap (child) + && Is_white_val (child))); } } } +Caml_inline void caml_ephe_clean (value v) { + mlsize_t size; + header_t hd; + hd = Hd_val (v); + size = Wosize_hd (hd); + + caml_ephe_clean_partial(v, 2, size); +} + + #endif /* CAML_INTERNALS */ #ifdef __cplusplus diff --git a/runtime/compact.c b/runtime/compact.c index 4196776e..02aec46b 100644 --- a/runtime/compact.c +++ b/runtime/compact.c @@ -29,6 +29,8 @@ #include "caml/roots.h" #include "caml/weak.h" #include "caml/compact.h" +#include "caml/memprof.h" +#include "caml/eventlog.h" extern uintnat caml_percent_free; /* major_gc.c */ extern void caml_shrink_heap (char *); /* memory.c */ @@ -211,6 +213,8 @@ static void do_compaction (intnat new_allocation_policy) caml_do_roots (caml_invert_root, 1); /* The values to be finalised are not roots but should still be inverted */ caml_final_invert_finalisable_values (); + /* Idem for memprof tracked blocks */ + caml_memprof_invert_tracked (); ch = caml_heap_start; while (ch != NULL){ @@ -436,7 +440,6 @@ uintnat caml_percent_max; /* used in gc_ctrl.c and memory.c */ void caml_compact_heap (intnat new_allocation_policy) { uintnat target_wsz, live; - CAML_INSTR_SETUP(tmr, "compact"); CAMLassert (Caml_state->young_ptr == Caml_state->young_alloc_end); CAMLassert (Caml_state->ref_table->ptr == @@ -446,8 +449,9 @@ void caml_compact_heap (intnat new_allocation_policy) CAMLassert (Caml_state->custom_table->ptr == Caml_state->custom_table->base); + CAML_EV_BEGIN(EV_COMPACT_MAIN); do_compaction (new_allocation_policy); - CAML_INSTR_TIME (tmr, "compact/main"); + CAML_EV_END(EV_COMPACT_MAIN); /* Compaction may fail to shrink the heap to a reasonable size because it deals in complete chunks: if a very large chunk is at the beginning of the heap, everything gets moved to @@ -509,11 +513,12 @@ void caml_compact_heap (intnat new_allocation_policy) if (Caml_state->stat_heap_wsz > Caml_state->stat_top_heap_wsz){ Caml_state->stat_top_heap_wsz = Caml_state->stat_heap_wsz; } + CAML_EV_BEGIN(EV_COMPACT_RECOMPACT); do_compaction (-1); CAMLassert (Caml_state->stat_heap_chunks == 1); CAMLassert (Chunk_next (caml_heap_start) == NULL); CAMLassert (Caml_state->stat_heap_wsz == Wsize_bsize (Chunk_size (chunk))); - CAML_INSTR_TIME (tmr, "compact/recompact"); + CAML_EV_END(EV_COMPACT_RECOMPACT); } } diff --git a/runtime/debugger.c b/runtime/debugger.c index 6b471c1e..21a93737 100644 --- a/runtime/debugger.c +++ b/runtime/debugger.c @@ -53,6 +53,7 @@ void caml_debugger_cleanup_fork(void) #include #endif #include +#include #include #ifndef _WIN32 #include @@ -188,6 +189,15 @@ void caml_debugger_init(void) if (dbg_addr != NULL) caml_stat_free(dbg_addr); dbg_addr = address; + /* #8676: erase the CAML_DEBUG_SOCKET variable so that processes + created by the program being debugged do not try to connect with + the debugger. */ +#if defined(_WIN32) + _wputenv(L"CAML_DEBUG_SOCKET="); +#elif defined(HAS_SETENV_UNSETENV) + unsetenv("CAML_DEBUG_SOCKET"); +#endif + caml_ext_table_init(&breakpoints_table, 16); #ifdef _WIN32 diff --git a/runtime/domain.c b/runtime/domain.c index f1bc08e3..0850021f 100644 --- a/runtime/domain.c +++ b/runtime/domain.c @@ -80,4 +80,10 @@ void caml_init_domain () Caml_state->local_roots = NULL; Caml_state->requested_major_slice = 0; Caml_state->requested_minor_gc = 0; + + Caml_state->eventlog_enabled = 0; + Caml_state->eventlog_paused = 0; + Caml_state->eventlog_startup_pid = 0; + Caml_state->eventlog_startup_timestamp = 0; + Caml_state->eventlog_out = NULL; } diff --git a/runtime/eventlog.c b/runtime/eventlog.c new file mode 100644 index 00000000..6d3bd7ca --- /dev/null +++ b/runtime/eventlog.c @@ -0,0 +1,396 @@ +/**************************************************************************/ +/* */ +/* OCaml */ +/* */ +/* Stephen Dolan, University of Cambridge */ +/* Enguerrand Decorne, Tarides */ +/* */ +/* Copyright 2020 University of Cambridge */ +/* Copyright 2020 Tarides */ +/* */ +/* 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. */ +/* */ +/**************************************************************************/ + +#define CAML_INTERNALS +#include +#include +#include "caml/alloc.h" +#include "caml/eventlog.h" +#include "caml/misc.h" +#include "caml/memory.h" +#include "caml/osdeps.h" + + +#ifdef _WIN32 +#include +#include +#elif defined(HAS_UNISTD) +#include +#endif + +#ifdef HAS_MACH_ABSOLUTE_TIME +#include +#elif HAS_POSIX_MONOTONIC_CLOCK +#include +#endif + +#ifdef CAML_INSTR + +#define CTF_MAGIC 0xc1fc1fc1 +#define CAML_TRACE_VERSION 0x1 + +struct ctf_stream_header { + uint32_t magic; + uint16_t caml_trace_version; + uint16_t stream_id; +}; + +static struct ctf_stream_header header = { + CTF_MAGIC, + CAML_TRACE_VERSION, + 0 +}; + +#pragma pack(1) +struct ctf_event_header { + uint64_t timestamp; + uint32_t pid; + uint32_t id; +}; + +struct event { + struct ctf_event_header header; + uint16_t phase; /* for GC events */ + uint16_t counter_kind; /* misc counter name */ + uint8_t alloc_bucket; /* for alloc counters */ + uint64_t count; /* for misc counters */ +}; + +#define EVENT_BUF_SIZE 4096 +struct event_buffer { + uintnat ev_generated; + struct event events[EVENT_BUF_SIZE]; +}; + +static struct event_buffer* evbuf; + +static int64_t time_counter(void) +{ +#ifdef _WIN32 + static double clock_freq = 0; + static LARGE_INTEGER now; + + if (clock_freq == 0) { + LARGE_INTEGER f; + if (!QueryPerformanceFrequency(&f)) + return 0; + clock_freq = (1000000000.0 / f.QuadPart); + }; + + if (!QueryPerformanceCounter(&now)) + return 0; + return (int64_t)(now.QuadPart * clock_freq); + +#elif defined(HAS_MACH_ABSOLUTE_TIME) + static mach_timebase_info_data_t time_base = {0}; + + if (time_base.denom == 0) { + if (mach_timebase_info (&time_base) != KERN_SUCCESS) + return 0; + + if (time_base.denom == 0) + return 0; + } + + uint64_t now = mach_absolute_time (); + return (int64_t)((now * time_base.numer) / time_base.denom); + +#elif defined(HAS_POSIX_MONOTONIC_CLOCK) + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + return + (int64_t)t.tv_sec * (int64_t)1000000000 + + (int64_t)t.tv_nsec; + + +#endif +} + +static void setup_evbuf() +{ + CAMLassert(!evbuf); + evbuf = caml_stat_alloc_noexc(sizeof(*evbuf)); + + if (evbuf == NULL) + caml_fatal_error("eventlog: could not allocate event buffer"); + + evbuf->ev_generated = 0; +} + +#define OUTPUT_FILE_LEN 4096 +static void setup_eventlog_file() +{ + char_os output_file[OUTPUT_FILE_LEN]; + char_os *eventlog_filename = NULL; + + eventlog_filename = caml_secure_getenv(T("OCAML_EVENTLOG_PREFIX")); + + if (eventlog_filename) { + int ret = snprintf_os(output_file, OUTPUT_FILE_LEN, T("%s.%d.eventlog"), + eventlog_filename, Caml_state->eventlog_startup_pid); + if (ret > OUTPUT_FILE_LEN) + caml_fatal_error("eventlog: specified OCAML_EVENTLOG_PREFIX is too long"); + } else { + snprintf_os(output_file, OUTPUT_FILE_LEN, T("caml-%d.eventlog"), + Caml_state->eventlog_startup_pid); + } + + Caml_state->eventlog_out = fopen_os(output_file, T("wb")); + + if (Caml_state->eventlog_out) { + int ret = fwrite(&header, sizeof(struct ctf_stream_header), + 1, Caml_state->eventlog_out); + if (ret != 1) + caml_eventlog_disable(); + fflush(Caml_state->eventlog_out); + } else { + caml_fatal_error("eventlog: could not open trace for writing"); + } +} +#undef OUTPUT_FILE_LEN + +#define FWRITE_EV(item, size) \ + if (fwrite(item, size, 1, out) != 1) \ + goto fwrite_failure; + +static void flush_events(FILE* out, struct event_buffer* eb) +{ + uintnat i; + uint64_t flush_duration; + uintnat n = eb->ev_generated; + + struct ctf_event_header ev_flush; + ev_flush.id = EV_FLUSH; + ev_flush.timestamp = time_counter() - + Caml_state->eventlog_startup_timestamp; + ev_flush.pid = Caml_state->eventlog_startup_pid; + + for (i = 0; i < n; i++) { + struct event ev = eb->events[i]; + ev.header.pid = Caml_state->eventlog_startup_pid; + + FWRITE_EV(&ev.header, sizeof(struct ctf_event_header)); + + switch (ev.header.id) + { + case EV_ENTRY: + FWRITE_EV(&ev.phase, sizeof(uint16_t)); + break; + case EV_EXIT: + FWRITE_EV(&ev.phase, sizeof(uint16_t)); + break; + case EV_COUNTER: + FWRITE_EV(&ev.count, sizeof(uint64_t)); + FWRITE_EV(&ev.counter_kind, sizeof(uint16_t)); + break; + case EV_ALLOC: + FWRITE_EV(&ev.count, sizeof(uint64_t)); + FWRITE_EV(&ev.alloc_bucket, sizeof(uint8_t)); + break; + default: + break; + } + } + + flush_duration = + (time_counter() - Caml_state->eventlog_startup_timestamp) - + ev_flush.timestamp; + + FWRITE_EV(&ev_flush, sizeof(struct ctf_event_header)); + FWRITE_EV(&flush_duration, sizeof(uint64_t)); + + return; + + fwrite_failure: + /* on event flush failure, shut down eventlog. */ + if (caml_runtime_warnings_active()) + fprintf(stderr, + "[ocaml] error while writing trace file, disabling eventlog\n"); + caml_eventlog_disable(); + return; + +} + +static void teardown_eventlog(void) +{ + if (evbuf) { + if (Caml_state->eventlog_out) + flush_events(Caml_state->eventlog_out, evbuf); + caml_stat_free(evbuf); + evbuf = NULL; + } + if (Caml_state->eventlog_out) { + fclose(Caml_state->eventlog_out); + Caml_state->eventlog_out = NULL; + } +} + +void caml_eventlog_init() +{ + char_os *toggle = caml_secure_getenv(T("OCAML_EVENTLOG_ENABLED")); + + if (toggle != NULL) { + Caml_state->eventlog_enabled = 1; + if (*toggle == 'p') + Caml_state->eventlog_paused = 1; + }; + + if (!Caml_state->eventlog_enabled) return; + + Caml_state->eventlog_startup_timestamp = time_counter(); +#ifdef _WIN32 + Caml_state->eventlog_startup_pid = _getpid(); +#else + Caml_state->eventlog_startup_pid = getpid(); +#endif + + setup_eventlog_file(); + setup_evbuf(); + + atexit(&teardown_eventlog); +} + +static void post_event(ev_gc_phase phase, ev_gc_counter counter_kind, + uint8_t bucket, uint64_t count, ev_type ty) +{ + uintnat i; + struct event* ev; + + if (!Caml_state->eventlog_enabled) return; + if (Caml_state->eventlog_paused) return; + + i = evbuf->ev_generated; + CAMLassert(i <= EVENT_BUF_SIZE); + if (i == EVENT_BUF_SIZE) { + flush_events(Caml_state->eventlog_out, evbuf); + evbuf->ev_generated = 0; + i = 0; + } + ev = &evbuf->events[i]; + ev->header.id = ty; + ev->count = count; + ev->counter_kind = counter_kind; + ev->alloc_bucket = bucket; + ev->phase = phase; + ev->header.timestamp = time_counter() - + Caml_state->eventlog_startup_timestamp; + evbuf->ev_generated = i + 1; +} + +void caml_ev_begin(ev_gc_phase phase) +{ + post_event(phase, 0, 0, 0, EV_ENTRY); +} + +void caml_ev_end(ev_gc_phase phase) +{ + post_event(phase, 0, 0, 0, EV_EXIT); +} + +void caml_ev_counter(ev_gc_counter counter, uint64_t val) +{ + post_event(0, counter, 0, val, EV_COUNTER); +} + +static uint64_t alloc_buckets [20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + +/* This function records allocations in caml_alloc_shr_aux in given bucket sizes + These buckets are meant to be flushed explicitly by the caller through the + caml_ev_alloc_flush function. Until then the buckets are just updated until + flushed. +*/ +void caml_ev_alloc(uint64_t sz) +{ + if (!Caml_state->eventlog_enabled) return; + if (Caml_state->eventlog_paused) return; + + if (sz < 10) { + ++alloc_buckets[sz]; + } else if (sz < 100) { + ++alloc_buckets[sz/10 + 9]; + } else { + ++alloc_buckets[19]; + } +} + +/* Note that this function does not trigger an actual disk flush, it just + pushes events in the event buffer. +*/ +void caml_ev_alloc_flush() +{ + int i; + + if (!Caml_state->eventlog_enabled) return; + if (Caml_state->eventlog_paused) return; + + for (i = 1; i < 20; i++) { + if (alloc_buckets[i] != 0) { + post_event(0, 0, i, alloc_buckets[i], EV_ALLOC); + }; + alloc_buckets[i] = 0; + } +} + +void caml_ev_flush() +{ + if (!Caml_state->eventlog_enabled) return; + if (Caml_state->eventlog_paused) return; + + if (Caml_state->eventlog_out) { + if (evbuf) + flush_events(Caml_state->eventlog_out, evbuf); + fflush(Caml_state->eventlog_out); + }; +} + +void caml_eventlog_disable() +{ + Caml_state->eventlog_enabled = 0; + teardown_eventlog(); +} + +CAMLprim value caml_eventlog_resume(value v) +{ + CAMLassert(v == Val_unit); + if (Caml_state->eventlog_enabled) + Caml_state->eventlog_paused = 0; + return Val_unit; +} + +CAMLprim value caml_eventlog_pause(value v) +{ + CAMLassert(v == Val_unit); + if (Caml_state->eventlog_enabled) { + Caml_state->eventlog_paused = 1; + if (evbuf && Caml_state->eventlog_out) + flush_events(Caml_state->eventlog_out, evbuf); + }; + return Val_unit; +} + +#else + +CAMLprim value caml_eventlog_resume(value v) +{ + return Val_unit; +} + +CAMLprim value caml_eventlog_pause(value v) +{ + return Val_unit; +} + +#endif /*CAML_INSTR*/ diff --git a/runtime/extern.c b/runtime/extern.c index 5409d7b1..7613e280 100644 --- a/runtime/extern.c +++ b/runtime/extern.c @@ -48,23 +48,6 @@ enum { static int extern_flags; /* logical or of some of the flags above */ -/* Trail mechanism to undo forwarding pointers put inside objects */ - -struct trail_entry { - value obj; /* address of object + initial color in low 2 bits */ - value field0; /* initial contents of field 0 */ -}; - -struct trail_block { - struct trail_block * previous; - struct trail_entry entries[ENTRIES_PER_TRAIL_BLOCK]; -}; - -static struct trail_block extern_trail_first; -static struct trail_block * extern_trail_block; -static struct trail_entry * extern_trail_cur, * extern_trail_limit; - - /* Stack for pending values to marshal */ struct extern_item { value * v; mlsize_t count; }; @@ -78,6 +61,43 @@ static struct extern_item * extern_stack = extern_stack_init; static struct extern_item * extern_stack_limit = extern_stack_init + EXTERN_STACK_INIT_SIZE; +/* Hash table to record already-marshaled objects and their positions */ + +struct object_position { value obj; uintnat pos; }; + +/* The hash table uses open addressing, linear probing, and a redundant + representation: + - a bitvector [present] records which entries of the table are occupied; + - an array [entries] records (object, position) pairs for the entries + that are occupied. + The bitvector is much smaller than the array (1/128th on 64-bit + platforms, 1/64th on 32-bit platforms), so it has better locality, + making it faster to determine that an object is not in the table. + Also, it makes it faster to empty or initialize a table: only the + [present] bitvector needs to be filled with zeros, the [entries] + array can be left uninitialized. +*/ + +struct position_table { + int shift; + mlsize_t size; /* size == 1 << (wordsize - shift) */ + mlsize_t mask; /* mask == size - 1 */ + mlsize_t threshold; /* threshold == a fixed fraction of size */ + uintnat * present; /* [Bitvect_size(size)] */ + struct object_position * entries; /* [size] */ +}; + +#define Bits_word (8 * sizeof(uintnat)) +#define Bitvect_size(n) (((n) + Bits_word - 1) / Bits_word) + +#define POS_TABLE_INIT_SIZE_LOG2 8 +#define POS_TABLE_INIT_SIZE (1 << POS_TABLE_INIT_SIZE_LOG2) + +static uintnat pos_table_present_init[Bitvect_size(POS_TABLE_INIT_SIZE)]; +static struct object_position pos_table_entries_init[POS_TABLE_INIT_SIZE]; + +static struct position_table pos_table; + /* Forward declarations */ CAMLnoreturn_start @@ -96,7 +116,6 @@ CAMLnoreturn_start static void extern_stack_overflow(void) CAMLnoreturn_end; -static void extern_replay_trail(void); static void free_extern_output(void); /* Free the extern stack if needed */ @@ -132,68 +151,148 @@ static struct extern_item * extern_resize_stack(struct extern_item * sp) return newstack + sp_offset; } -/* Initialize the trail */ +/* Multiplicative Fibonacci hashing + (Knuth, TAOCP vol 3, section 6.4, page 518). + HASH_FACTOR is (sqrt(5) - 1) / 2 * 2^wordsize. */ +#ifdef ARCH_SIXTYFOUR +#define HASH_FACTOR 11400714819323198486UL +#else +#define HASH_FACTOR 2654435769UL +#endif +#define Hash(v) (((uintnat)(v) * HASH_FACTOR) >> pos_table.shift) + +/* When the table becomes 2/3 full, its size is increased. */ +#define Threshold(sz) (((sz) * 2) / 3) -static void init_extern_trail(void) +/* Initialize the position table */ + +static void extern_init_position_table(void) { - extern_trail_block = &extern_trail_first; - extern_trail_cur = extern_trail_block->entries; - extern_trail_limit = extern_trail_block->entries + ENTRIES_PER_TRAIL_BLOCK; + if (extern_flags & NO_SHARING) return; + pos_table.size = POS_TABLE_INIT_SIZE; + pos_table.shift = 8 * sizeof(value) - POS_TABLE_INIT_SIZE_LOG2; + pos_table.mask = POS_TABLE_INIT_SIZE - 1; + pos_table.threshold = Threshold(POS_TABLE_INIT_SIZE); + pos_table.present = pos_table_present_init; + pos_table.entries = pos_table_entries_init; + memset(pos_table_present_init, 0, sizeof(pos_table_present_init)); } -/* Replay the trail, undoing the in-place modifications - performed on objects */ +/* Free the position table */ -static void extern_replay_trail(void) +static void extern_free_position_table(void) { - struct trail_block * blk, * prevblk; - struct trail_entry * ent, * lim; + if (pos_table.present != pos_table_present_init) { + caml_stat_free(pos_table.present); + caml_stat_free(pos_table.entries); + /* Protect against repeated calls to extern_free_position_table */ + pos_table.present = pos_table_present_init; + } +} - blk = extern_trail_block; - lim = extern_trail_cur; - while (1) { - for (ent = &(blk->entries[0]); ent < lim; ent++) { - value obj = ent->obj; - color_t colornum = obj & 3; - obj = obj & ~3; - Hd_val(obj) = Coloredhd_hd(Hd_val(obj), colornum); - Field(obj, 0) = ent->field0; +/* Accessing bitvectors */ + +Caml_inline uintnat bitvect_test(uintnat * bv, uintnat i) +{ + return bv[i / Bits_word] & ((uintnat) 1 << (i & (Bits_word - 1))); +} + +Caml_inline void bitvect_set(uintnat * bv, uintnat i) +{ + bv[i / Bits_word] |= ((uintnat) 1 << (i & (Bits_word - 1))); +} + +/* Grow the position table */ + +static void extern_resize_position_table(void) +{ + mlsize_t new_size, new_byte_size; + int new_shift; + uintnat * new_present; + struct object_position * new_entries; + uintnat i, h; + struct position_table old = pos_table; + + /* Grow the table quickly (x 8) up to 10^6 entries, + more slowly (x 2) afterwards. */ + if (old.size < 1000000) { + new_size = 8 * old.size; + new_shift = old.shift - 3; + } else { + new_size = 2 * old.size; + new_shift = old.shift - 1; + } + if (new_size == 0 + || caml_umul_overflow(new_size, sizeof(struct object_position), + &new_byte_size)) + extern_out_of_memory(); + new_entries = caml_stat_alloc_noexc(new_byte_size); + if (new_entries == NULL) extern_out_of_memory(); + new_present = + caml_stat_calloc_noexc(Bitvect_size(new_size), sizeof(uintnat)); + if (new_present == NULL) { + caml_stat_free(new_entries); + extern_out_of_memory(); + } + pos_table.size = new_size; + pos_table.shift = new_shift; + pos_table.mask = new_size - 1; + pos_table.threshold = Threshold(new_size); + pos_table.present = new_present; + pos_table.entries = new_entries; + + /* Insert every entry of the old table in the new table */ + for (i = 0; i < old.size; i++) { + if (! bitvect_test(old.present, i)) continue; + h = Hash(old.entries[i].obj); + while (bitvect_test(new_present, h)) { + h = (h + 1) & pos_table.mask; } - if (blk == &extern_trail_first) break; - prevblk = blk->previous; - caml_stat_free(blk); - blk = prevblk; - lim = &(blk->entries[ENTRIES_PER_TRAIL_BLOCK]); + bitvect_set(new_present, h); + new_entries[h] = old.entries[i]; + } + + /* Free the old tables if not statically allocated */ + if (old.present != pos_table_present_init) { + caml_stat_free(old.present); + caml_stat_free(old.entries); } - /* Protect against a second call to extern_replay_trail */ - extern_trail_block = &extern_trail_first; - extern_trail_cur = extern_trail_block->entries; } -/* Set forwarding pointer on an object and add corresponding entry - to the trail. */ +/* Determine whether the given object [obj] is in the hash table. + If so, set [*pos_out] to its position in the output and return 1. + If not, set [*h_out] to the hash value appropriate for + [extern_record_location] and return 0. */ -static void extern_record_location(value obj) +Caml_inline int extern_lookup_position(value obj, + uintnat * pos_out, uintnat * h_out) { - header_t hdr; + uintnat h = Hash(obj); + while (1) { + if (! bitvect_test(pos_table.present, h)) { + *h_out = h; + return 0; + } + if (pos_table.entries[h].obj == obj) { + *pos_out = pos_table.entries[h].pos; + return 1; + } + h = (h + 1) & pos_table.mask; + } +} + +/* Record the output position for the given object [obj]. */ +/* The [h] parameter is the index in the hash table where the object + must be inserted. It was determined during lookup. */ +static void extern_record_location(value obj, uintnat h) +{ if (extern_flags & NO_SHARING) return; - if (extern_trail_cur == extern_trail_limit) { - struct trail_block * new_block = - caml_stat_alloc_noexc(sizeof(struct trail_block)); - if (new_block == NULL) extern_out_of_memory(); - new_block->previous = extern_trail_block; - extern_trail_block = new_block; - extern_trail_cur = extern_trail_block->entries; - extern_trail_limit = extern_trail_block->entries + ENTRIES_PER_TRAIL_BLOCK; - } - hdr = Hd_val(obj); - extern_trail_cur->obj = obj | Colornum_hd(hdr); - extern_trail_cur->field0 = Field(obj, 0); - extern_trail_cur++; - Hd_val(obj) = Bluehd_hd(hdr); - Field(obj, 0) = (value) obj_counter; + bitvect_set(pos_table.present, h); + pos_table.entries[h].obj = obj; + pos_table.entries[h].pos = obj_counter; obj_counter++; + if (obj_counter >= pos_table.threshold) extern_resize_position_table(); } /* To buffer the output */ @@ -231,13 +330,15 @@ static void free_extern_output(void) { struct output_block * blk, * nextblk; - if (extern_userprovided_output != NULL) return; - for (blk = extern_output_first; blk != NULL; blk = nextblk) { - nextblk = blk->next; - caml_stat_free(blk); + if (extern_userprovided_output == NULL) { + for (blk = extern_output_first; blk != NULL; blk = nextblk) { + nextblk = blk->next; + caml_stat_free(blk); + } + extern_output_first = NULL; } - extern_output_first = NULL; extern_free_stack(); + extern_free_position_table(); } static void grow_extern_output(intnat required) @@ -280,21 +381,18 @@ static intnat extern_output_length(void) static void extern_out_of_memory(void) { - extern_replay_trail(); free_extern_output(); caml_raise_out_of_memory(); } static void extern_invalid_argument(char *msg) { - extern_replay_trail(); free_extern_output(); caml_invalid_argument(msg); } static void extern_failwith(char *msg) { - extern_replay_trail(); free_extern_output(); caml_failwith(msg); } @@ -302,24 +400,23 @@ static void extern_failwith(char *msg) static void extern_stack_overflow(void) { caml_gc_message (0x04, "Stack overflow in marshaling value\n"); - extern_replay_trail(); free_extern_output(); caml_raise_out_of_memory(); } /* Conversion to big-endian */ -static inline void store16(char * dst, int n) +Caml_inline void store16(char * dst, int n) { dst[0] = n >> 8; dst[1] = n; } -static inline void store32(char * dst, intnat n) +Caml_inline void store32(char * dst, intnat n) { dst[0] = n >> 24; dst[1] = n >> 16; dst[2] = n >> 8; dst[3] = n; } -static inline void store64(char * dst, int64_t n) +Caml_inline void store64(char * dst, int64_t n) { dst[0] = n >> 56; dst[1] = n >> 48; dst[2] = n >> 40; dst[3] = n >> 32; dst[4] = n >> 24; dst[5] = n >> 16; dst[6] = n >> 8; dst[7] = n; @@ -327,7 +424,7 @@ static inline void store64(char * dst, int64_t n) /* Write characters, integers, and blocks in the output buffer */ -static inline void write(int c) +Caml_inline void write(int c) { if (extern_ptr >= extern_limit) grow_extern_output(1); *extern_ptr++ = c; @@ -340,7 +437,7 @@ static void writeblock(const char * data, intnat len) extern_ptr += len; } -static inline void writeblock_float8(const double * data, intnat ndoubles) +Caml_inline void writeblock_float8(const double * data, intnat ndoubles) { #if ARCH_FLOAT_ENDIANNESS == 0x01234567 || ARCH_FLOAT_ENDIANNESS == 0x76543210 writeblock((const char *) data, ndoubles * 8); @@ -391,6 +488,10 @@ static void extern_rec(value v) { struct code_fragment * cf; struct extern_item * sp; + uintnat h = 0; + uintnat pos = 0; + + extern_init_position_table(); sp = extern_stack; while(1) { @@ -447,21 +548,23 @@ static void extern_rec(value v) } goto next_item; } - /* Check if already seen */ - if (Color_hd(hd) == Caml_blue) { - uintnat d = obj_counter - (uintnat) Field(v, 0); - if (d < 0x100) { - writecode8(CODE_SHARED8, d); - } else if (d < 0x10000) { - writecode16(CODE_SHARED16, d); + /* Check if object already seen */ + if (! (extern_flags & NO_SHARING)) { + if (extern_lookup_position(v, &pos, &h)) { + uintnat d = obj_counter - pos; + if (d < 0x100) { + writecode8(CODE_SHARED8, d); + } else if (d < 0x10000) { + writecode16(CODE_SHARED16, d); #ifdef ARCH_SIXTYFOUR - } else if (d >= (uintnat)1 << 32) { - writecode64(CODE_SHARED64, d); + } else if (d >= (uintnat)1 << 32) { + writecode64(CODE_SHARED64, d); #endif - } else { - writecode32(CODE_SHARED32, d); + } else { + writecode32(CODE_SHARED32, d); + } + goto next_item; } - goto next_item; } /* Output the contents of the object */ @@ -488,7 +591,7 @@ static void extern_rec(value v) writeblock(String_val(v), len); size_32 += 1 + (len + 4) / 4; size_64 += 1 + (len + 8) / 8; - extern_record_location(v); + extern_record_location(v, h); break; } case Double_tag: { @@ -498,7 +601,7 @@ static void extern_rec(value v) writeblock_float8((double *) v, 1); size_32 += 1 + 2; size_64 += 1 + 1; - extern_record_location(v); + extern_record_location(v, h); break; } case Double_array_tag: { @@ -524,7 +627,7 @@ static void extern_rec(value v) writeblock_float8((double *) v, nfloats); size_32 += 1 + nfloats * 2; size_64 += 1 + nfloats; - extern_record_location(v); + extern_record_location(v, h); break; } case Abstract_tag: @@ -568,7 +671,7 @@ static void extern_rec(value v) } size_32 += 2 + ((sz_32 + 3) >> 2); /* header + ops + data */ size_64 += 2 + ((sz_64 + 7) >> 3); - extern_record_location(v); + extern_record_location(v, h); break; } default: { @@ -596,7 +699,7 @@ static void extern_rec(value v) size_32 += 1 + sz; size_64 += 1 + sz; field0 = Field(v, 0); - extern_record_location(v); + extern_record_location(v, h); /* Remember that we still have to serialize fields 1 ... sz - 1 */ if (sz > 1) { sp++; @@ -627,6 +730,7 @@ static void extern_rec(value v) if (sp == extern_stack) { /* We are done. Cleanup the stack and leave the function */ extern_free_stack(); + extern_free_position_table(); return; } v = *((sp->v)++); @@ -645,7 +749,6 @@ static intnat extern_value(value v, value flags, /* Parse flag list */ extern_flags = caml_convert_flag_list(flags, extern_flag_values); /* Initializations */ - init_extern_trail(); obj_counter = 0; size_32 = 0; size_64 = 0; @@ -653,8 +756,6 @@ static intnat extern_value(value v, value flags, extern_rec(v); /* Record end of output */ close_extern_output(); - /* Undo the modifications done on externed blocks */ - extern_replay_trail(); /* Write the header */ res_len = extern_output_length(); #ifdef ARCH_SIXTYFOUR @@ -793,7 +894,7 @@ CAMLexport void caml_output_value_to_malloc(value v, value flags, int header_len; intnat data_len; char * res; - struct output_block * blk; + struct output_block * blk, * nextblk; init_extern_output(); data_len = extern_value(v, flags, header, &header_len); @@ -803,12 +904,13 @@ CAMLexport void caml_output_value_to_malloc(value v, value flags, *len = header_len + data_len; memcpy(res, header, header_len); res += header_len; - for (blk = extern_output_first; blk != NULL; blk = blk->next) { + for (blk = extern_output_first; blk != NULL; blk = nextblk) { intnat n = blk->end - blk->data; memcpy(res, blk->data, n); res += n; + nextblk = blk->next; + caml_stat_free(blk); } - free_extern_output(); } /* Functions for writing user-defined marshallers */ diff --git a/runtime/fail_byt.c b/runtime/fail_byt.c index a8acdf0e..b2e8d8b7 100644 --- a/runtime/fail_byt.c +++ b/runtime/fail_byt.c @@ -105,7 +105,7 @@ static void check_global_data_param(char const *exception_name, char const *msg) } } -static inline value caml_get_failwith_tag (char const *msg) +Caml_inline value caml_get_failwith_tag (char const *msg) { check_global_data_param("Failure", msg); return Field(caml_global_data, FAILURE_EXN); @@ -124,7 +124,7 @@ CAMLexport void caml_failwith_value (value msg) CAMLnoreturn; } -static inline value caml_get_invalid_argument_tag (char const *msg) +Caml_inline value caml_get_invalid_argument_tag (char const *msg) { check_global_data_param("Invalid_argument", msg); return Field(caml_global_data, INVALID_EXN); diff --git a/runtime/floats.c b/runtime/floats.c index aba01a99..c8176502 100644 --- a/runtime/floats.c +++ b/runtime/floats.c @@ -982,7 +982,8 @@ intnat caml_float_compare_unboxed(double f, double g) /* This branchless implementation is from GPR#164. Note that [f == f] if and only if f is not NaN. We expand each subresult of the expression to - avoid sign-extension on 64bit. GPR#2250. */ + avoid sign-extension on 64bit. GPR#2250. + See also translation of Pcompare_floats in asmcomp/cmmgen.ml */ intnat res = (intnat)(f > g) - (intnat)(f < g) + (intnat)(f == f) - (intnat)(g == g); return res; diff --git a/runtime/freelist.c b/runtime/freelist.c index 97392403..363adaaf 100644 --- a/runtime/freelist.c +++ b/runtime/freelist.c @@ -31,6 +31,7 @@ #include "caml/major_gc.h" #include "caml/misc.h" #include "caml/mlvalues.h" +#include "caml/eventlog.h" /*************** declarations common to all policies ******************/ @@ -50,47 +51,21 @@ value caml_fl_merge = Val_NULL; /* Current insertion pointer. Managed #define Next_small(v) Field ((v), 0) /* Next in memory order */ -static inline value Next_in_mem (value v) { +Caml_inline value Next_in_mem (value v) { return (value) &Field ((v), Whsize_val (v)); } #ifdef CAML_INSTR -static uintnat instr_size [20] = - {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; -static char *instr_name [20] = { - NULL, - "alloc01@", - "alloc02@", - "alloc03@", - "alloc04@", - "alloc05@", - "alloc06@", - "alloc07@", - "alloc08@", - "alloc09@", - "alloc10-19@", - "alloc20-29@", - "alloc30-39@", - "alloc40-49@", - "alloc50-59@", - "alloc60-69@", - "alloc70-79@", - "alloc80-89@", - "alloc90-99@", - "alloc_large@", -}; -uintnat caml_instr_alloc_jump = 0; -/* number of pointers followed to allocate from the free set */ - -#define INSTR_alloc_jump(n) (caml_instr_alloc_jump += (n)) -#else +/* number of pointers followed to allocate from the free set */ +uintnat caml_instr_alloc_jump = 0; -#define INSTR_alloc_jump(n) ((void)0) +#define EV_ALLOC_JUMP(n) (caml_instr_alloc_jump += (n)) #endif /*CAML_INSTR*/ + /********************* next-fit allocation policy *********************/ /* The free-list is kept sorted by increasing addresses. @@ -179,15 +154,6 @@ static header_t *nf_allocate (mlsize_t wo_sz) value cur = Val_NULL, prev; CAMLassert (sizeof (char *) == sizeof (value)); CAMLassert (wo_sz >= 1); -#ifdef CAML_INSTR - if (wo_sz < 10){ - ++instr_size[wo_sz]; - }else if (wo_sz < 100){ - ++instr_size[wo_sz/10 + 9]; - }else{ - ++instr_size[19]; - } -#endif /* CAML_INSTR */ CAMLassert (nf_prev != Val_NULL); /* Search from [nf_prev] to the end of the list. */ @@ -200,9 +166,7 @@ static header_t *nf_allocate (mlsize_t wo_sz) } prev = cur; cur = Next_small (prev); -#ifdef CAML_INSTR - ++ caml_instr_alloc_jump; -#endif + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); } nf_last = prev; /* Search from the start of the list to [nf_prev]. */ @@ -214,9 +178,7 @@ static header_t *nf_allocate (mlsize_t wo_sz) } prev = cur; cur = Next_small (prev); -#ifdef CAML_INSTR - ++ caml_instr_alloc_jump; -#endif + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); } /* No suitable block was found. */ return NULL; @@ -232,13 +194,7 @@ static header_t *nf_last_fragment; static void nf_init_merge (void) { -#ifdef CAML_INSTR - int i; - for (i = 1; i < 20; i++){ - CAML_INSTR_INT (instr_name[i], instr_size[i]); - instr_size[i] = 0; - } -#endif /* CAML_INSTR */ + CAML_EV_ALLOC_FLUSH(); nf_last_fragment = NULL; caml_fl_merge = Nf_head; #ifdef DEBUG @@ -510,15 +466,6 @@ static header_t *ff_allocate (mlsize_t wo_sz) mlsize_t sz, prevsz; CAMLassert (sizeof (char *) == sizeof (value)); CAMLassert (wo_sz >= 1); -#ifdef CAML_INSTR - if (wo_sz < 10){ - ++instr_size[wo_sz]; - }else if (wo_sz < 100){ - ++instr_size[wo_sz/10 + 9]; - }else{ - ++instr_size[19]; - } -#endif /* CAML_INSTR */ /* Search in the flp array. */ for (i = 0; i < flp_size; i++){ @@ -670,13 +617,7 @@ static header_t *ff_last_fragment; static void ff_init_merge (void) { -#ifdef CAML_INSTR - int i; - for (i = 1; i < 20; i++){ - CAML_INSTR_INT (instr_name[i], instr_size[i]); - instr_size[i] = 0; - } -#endif /* CAML_INSTR */ + CAML_EV_ALLOC_FLUSH(); ff_last_fragment = NULL; caml_fl_merge = Ff_head; #ifdef DEBUG @@ -887,9 +828,9 @@ static int bf_small_map = 0; /* Small free blocks have only one pointer to the next block. Large free blocks have 5 fields: tree fields: - - node flag - - left son - - right son + - isnode flag + - left child + - right child list fields: - next - prev @@ -902,7 +843,7 @@ typedef struct large_free_block { struct large_free_block *next; } large_free_block; -static inline mlsize_t bf_large_wosize (struct large_free_block *n) { +Caml_inline mlsize_t bf_large_wosize (struct large_free_block *n) { return Wosize_val((value)(n)); } @@ -921,7 +862,7 @@ static struct large_free_block *bf_large_least; #include #elif defined(HAS_BITSCANFORWARD) #include -static inline int ffs (int x) +Caml_inline int ffs (int x) { unsigned long index; unsigned char result; @@ -929,7 +870,7 @@ static inline int ffs (int x) return result ? (int) index + 1 : 0; } #else -static inline int ffs (int x) +Caml_inline int ffs (int x) { /* adapted from Hacker's Delight */ int bnz, b0, b1, b2, b3, b4; @@ -946,11 +887,11 @@ static inline int ffs (int x) #endif /* HAS_FFS or HAS_BITSCANFORWARD */ /* Indexing starts at 1 because that's the minimum block size. */ -static inline void set_map (int index) +Caml_inline void set_map (int index) { bf_small_map |= (1 << (index - 1)); } -static inline void unset_map (int index) +Caml_inline void unset_map (int index) { bf_small_map &= ~(1 << (index - 1)); } @@ -1008,7 +949,7 @@ static void bf_check (void) }else{ CAMLassert (caml_gc_phase != Phase_sweep || caml_fl_merge == Val_NULL - || Val_bp (bf_small_fl[i].merge) < caml_fl_merge); + || bf_small_fl[i].merge < &Next_small(caml_fl_merge)); } CAMLassert (*bf_small_fl[i].merge == Val_NULL || Color_val (*bf_small_fl[i].merge) == Caml_blue); @@ -1076,7 +1017,7 @@ static large_free_block **bf_search (mlsize_t wosz) while (1){ cur = *p; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (cur == NULL) break; cursz = bf_large_wosize (cur); if (cursz == wosz){ @@ -1091,7 +1032,7 @@ static large_free_block **bf_search (mlsize_t wosz) return p; } -/* Search for the least node that is large enough to accomodate the given +/* Search for the least node that is large enough to accommodate the given size. Return in [next_lower] an upper bound on either the size of the next-lower node in the tree, or BF_NUM_SMALL if there is no such node. */ @@ -1105,7 +1046,7 @@ static large_free_block **bf_search_best (mlsize_t wosz, mlsize_t *next_lower) while (1){ cur = *p; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (cur == NULL){ *next_lower = lowsz; break; @@ -1150,7 +1091,7 @@ static void bf_splay (mlsize_t wosz) if (xsz > wosz){ /* zig */ y = x->left; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (y == NULL) break; if (bf_large_wosize (y) > wosz){ /* zig-zig: rotate right */ @@ -1158,7 +1099,7 @@ static void bf_splay (mlsize_t wosz) y->right = x; x = y; y = x->left; - INSTR_alloc_jump (2); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2)); if (y == NULL) break; } /* link right */ @@ -1169,7 +1110,7 @@ static void bf_splay (mlsize_t wosz) CAMLassert (xsz < wosz); /* zag */ y = x->right; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (y == NULL) break; if (bf_large_wosize (y) < wosz){ /* zag-zag : rotate left */ @@ -1177,7 +1118,7 @@ static void bf_splay (mlsize_t wosz) y->left = x; x = y; y = x->right; - INSTR_alloc_jump (2); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2)); if (y == NULL) break; } /* link left */ @@ -1191,7 +1132,7 @@ static void bf_splay (mlsize_t wosz) *right_bottom = x->right; x->left = left_top; x->right = right_top; - INSTR_alloc_jump (2); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2)); bf_large_tree = x; } @@ -1207,19 +1148,19 @@ static void bf_splay_least (large_free_block **p) large_free_block **right_bottom = &right_top; x = *p; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); CAMLassert (x != NULL); while (1){ /* We are always in the zig case. */ y = x->left; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (y == NULL) break; /* And in the zig-zig case. rotate right */ x->left = y->right; y->right = x; x = y; y = x->left; - INSTR_alloc_jump (2); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2)); if (y == NULL) break; /* link right */ *right_bottom = x; @@ -1229,7 +1170,7 @@ static void bf_splay_least (large_free_block **p) /* reassemble the tree */ CAMLassert (x->left == NULL); *right_bottom = x->right; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); x->right = right_top; *p = x; } @@ -1241,12 +1182,12 @@ static void bf_remove_node (large_free_block **p) large_free_block *l, *r; x = *p; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (x == NULL) return; if (x == bf_large_least) bf_large_least = NULL; l = x->left; r = x->right; - INSTR_alloc_jump (2); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2)); if (l == NULL){ *p = r; }else if (r == NULL){ @@ -1267,7 +1208,7 @@ static void bf_insert_block (large_free_block *n) mlsize_t sz = bf_large_wosize (n); large_free_block **p = bf_search (sz); large_free_block *x = *p; - INSTR_alloc_jump (1); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1)); if (bf_large_least != NULL){ mlsize_t least_sz = bf_large_wosize (bf_large_least); @@ -1299,7 +1240,7 @@ static void bf_insert_block (large_free_block *n) n->next = x; x->prev->next = n; x->prev = n; - INSTR_alloc_jump (2); + CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2)); bf_splay (sz); } } @@ -1568,16 +1509,6 @@ static header_t *bf_allocate (mlsize_t wosz) CAMLassert (sizeof (char *) == sizeof (value)); CAMLassert (wosz >= 1); -#ifdef CAML_INSTR - if (wosz < 10){ - ++instr_size[wosz]; - }else if (wosz < 100){ - ++instr_size[wosz/10 + 9]; - }else{ - ++instr_size[19]; - } -#endif /* CAML_INSTR */ - if (wosz <= BF_NUM_SMALL){ if (bf_small_fl[wosz].free != Val_NULL){ /* fast path: allocate from the corresponding free list */ @@ -1635,12 +1566,7 @@ static void bf_init_merge (void) { mlsize_t i; -#ifdef CAML_INSTR - for (i = 1; i < 20; i++){ - CAML_INSTR_INT (instr_name[i], instr_size[i]); - instr_size[i] = 0; - } -#endif /* CAML_INSTR */ + CAML_EV_ALLOC_FLUSH(); caml_fl_merge = Val_NULL; diff --git a/runtime/gc_ctrl.c b/runtime/gc_ctrl.c index e444b9c5..956cbcbb 100644 --- a/runtime/gc_ctrl.c +++ b/runtime/gc_ctrl.c @@ -30,6 +30,7 @@ #include "caml/misc.h" #include "caml/mlvalues.h" #include "caml/signals.h" +#include "caml/eventlog.h" #ifdef NATIVE_CODE #include "caml/stack.h" #else @@ -267,10 +268,10 @@ void caml_heap_check (void) CAMLprim value caml_gc_stat(value v) { value result; - CAML_INSTR_SETUP (tmr, ""); + CAML_EV_BEGIN(EV_EXPLICIT_GC_STAT); CAMLassert (v == Val_unit); result = heap_stats (1); - CAML_INSTR_TIME (tmr, "explicit/gc_stat"); + CAML_EV_END(EV_EXPLICIT_GC_STAT); return result; } @@ -422,7 +423,7 @@ CAMLprim value caml_gc_set(value v) asize_t newminwsz; uintnat newpolicy; uintnat new_custom_maj, new_custom_min, new_custom_sz; - CAML_INSTR_SETUP (tmr, ""); + CAML_EV_BEGIN(EV_EXPLICIT_GC_SET); caml_verb_gc = Long_val (Field (v, 3)); @@ -514,7 +515,7 @@ CAMLprim value caml_gc_set(value v) ARCH_SIZET_PRINTF_FORMAT "uk words\n", newminwsz / 1024); caml_set_minor_heap_size (Bsize_wsize (newminwsz)); } - CAML_INSTR_TIME (tmr, "explicit/gc_set"); + CAML_EV_END(EV_EXPLICIT_GC_SET); /* The compaction may have triggered some finalizers that we need to call. */ caml_process_pending_actions(); @@ -524,12 +525,15 @@ CAMLprim value caml_gc_set(value v) CAMLprim value caml_gc_minor(value v) { - CAML_INSTR_SETUP (tmr, ""); + value exn; + + CAML_EV_BEGIN(EV_EXPLICIT_GC_MINOR); CAMLassert (v == Val_unit); caml_request_minor_gc (); // call the gc and call finalisers - caml_process_pending_actions(); - CAML_INSTR_TIME (tmr, "explicit/gc_minor"); + exn = caml_process_pending_actions_exn(); + CAML_EV_END(EV_EXPLICIT_GC_MINOR); + caml_raise_if_exception(exn); return Val_unit; } @@ -550,60 +554,76 @@ static void test_and_compact (void) CAMLprim value caml_gc_major(value v) { - CAML_INSTR_SETUP (tmr, ""); + value exn; + + CAML_EV_BEGIN(EV_EXPLICIT_GC_MAJOR); CAMLassert (v == Val_unit); caml_gc_message (0x1, "Major GC cycle requested\n"); caml_empty_minor_heap (); caml_finish_major_cycle (); test_and_compact (); // call finalisers - caml_process_pending_actions(); - CAML_INSTR_TIME (tmr, "explicit/gc_major"); + exn = caml_process_pending_actions_exn(); + CAML_EV_END(EV_EXPLICIT_GC_MAJOR); + caml_raise_if_exception(exn); return Val_unit; } CAMLprim value caml_gc_full_major(value v) { - CAML_INSTR_SETUP (tmr, ""); + value exn; + + CAML_EV_BEGIN(EV_EXPLICIT_GC_FULL_MAJOR); CAMLassert (v == Val_unit); caml_gc_message (0x1, "Full major GC cycle requested\n"); caml_empty_minor_heap (); caml_finish_major_cycle (); // call finalisers - caml_process_pending_actions(); + exn = caml_process_pending_actions_exn(); + if (Is_exception_result(exn)) goto cleanup; caml_empty_minor_heap (); caml_finish_major_cycle (); test_and_compact (); // call finalisers - caml_process_pending_actions(); - CAML_INSTR_TIME (tmr, "explicit/gc_full_major"); + exn = caml_process_pending_actions_exn(); + +cleanup: + CAML_EV_END(EV_EXPLICIT_GC_FULL_MAJOR); + caml_raise_if_exception(exn); + return Val_unit; } CAMLprim value caml_gc_major_slice (value v) { - CAML_INSTR_SETUP (tmr, ""); + CAML_EV_BEGIN(EV_EXPLICIT_GC_MAJOR_SLICE); CAMLassert (Is_long (v)); caml_major_collection_slice (Long_val (v)); - CAML_INSTR_TIME (tmr, "explicit/gc_major_slice"); + CAML_EV_END(EV_EXPLICIT_GC_MAJOR_SLICE); return Val_long (0); } CAMLprim value caml_gc_compaction(value v) { - CAML_INSTR_SETUP (tmr, ""); + value exn; + + CAML_EV_BEGIN(EV_EXPLICIT_GC_COMPACT); CAMLassert (v == Val_unit); caml_gc_message (0x10, "Heap compaction requested\n"); caml_empty_minor_heap (); caml_finish_major_cycle (); // call finalisers - caml_process_pending_actions(); + exn = caml_process_pending_actions_exn(); + if (Is_exception_result(exn)) goto cleanup; caml_empty_minor_heap (); caml_finish_major_cycle (); caml_compact_heap (-1); // call finalisers - caml_process_pending_actions(); - CAML_INSTR_TIME (tmr, "explicit/gc_compact"); + exn = caml_process_pending_actions_exn(); + + cleanup: + CAML_EV_END(EV_EXPLICIT_GC_COMPACT); + caml_raise_if_exception(exn); return Val_unit; } @@ -645,7 +665,6 @@ void caml_init_gc (uintnat minor_size, uintnat major_size, major_bsize = Bsize_wsize(major_size); major_bsize = ((major_bsize + Page_size - 1) >> Page_log) << Page_log; - caml_instr_init (); if (caml_page_table_initialize(Bsize_wsize(minor_size) + major_bsize)){ caml_fatal_error ("cannot initialize page table"); } diff --git a/runtime/gen_primitives.sh b/runtime/gen_primitives.sh index a157bae4..8816ccb4 100755 --- a/runtime/gen_primitives.sh +++ b/runtime/gen_primitives.sh @@ -24,7 +24,8 @@ export LC_ALL=C for prim in \ alloc array compare extern floats gc_ctrl hash intern interp ints io \ lexing md5 meta memprof obj parsing signals str sys callback weak \ - finalise stacks dynlink backtrace_byt backtrace spacetime_byt afl bigarray + finalise stacks dynlink backtrace_byt backtrace spacetime_byt afl \ + bigarray eventlog do sed -n -e 's/^CAMLprim value \([a-z0-9_][a-z0-9_]*\).*/\1/p' "$prim.c" done diff --git a/runtime/i386.S b/runtime/i386.S index b8a614d4..e3b8cc2e 100644 --- a/runtime/i386.S +++ b/runtime/i386.S @@ -113,15 +113,13 @@ G(caml_system__code_begin): FUNCTION(caml_call_gc) CFI_STARTPROC +LBL(caml_call_gc): /* Record lowest stack address and return address */ - pushl %ebx; CFI_ADJUST(4) movl G(Caml_state), %ebx - movl 4(%esp), %eax + movl (%esp), %eax movl %eax, CAML_STATE(last_return_address, %ebx) - leal 8(%esp), %eax + leal 4(%esp), %eax movl %eax, CAML_STATE(bottom_of_stack, %ebx) - popl %ebx; CFI_ADJUST(-4) -LBL(105): #if !defined(SYS_mingw) && !defined(SYS_cygwin) /* Touch the stack to trigger a recoverable segfault if insufficient space remains */ @@ -137,7 +135,6 @@ LBL(105): pushl %ecx; CFI_ADJUST(4) pushl %ebx; CFI_ADJUST(4) pushl %eax; CFI_ADJUST(4) - movl G(Caml_state), %ebx movl %esp, CAML_STATE(gc_regs, %ebx) /* MacOSX note: 16-alignment of stack preserved at this point */ /* Call the garbage collector */ @@ -150,108 +147,58 @@ LBL(105): popl %esi; CFI_ADJUST(-4) popl %edi; CFI_ADJUST(-4) popl %ebp; CFI_ADJUST(-4) - /* Return to caller */ + /* Return to caller. Returns young_ptr in %eax. */ + movl CAML_STATE(young_ptr, %ebx), %eax ret CFI_ENDPROC ENDFUNCTION(caml_call_gc) FUNCTION(caml_alloc1) CFI_STARTPROC - pushl %ebx; CFI_ADJUST(4) movl G(Caml_state), %ebx movl CAML_STATE(young_ptr, %ebx), %eax subl $8, %eax - cmpl CAML_STATE(young_limit, %ebx), %eax - jb LBL(100) movl %eax, CAML_STATE(young_ptr, %ebx) - popl %ebx; CFI_ADJUST(-4) + cmpl CAML_STATE(young_limit, %ebx), %eax + jb LBL(caml_call_gc) ret -LBL(100): - movl 4(%esp), %eax - movl %eax, CAML_STATE(last_return_address, %ebx) - leal 8(%esp), %eax - movl %eax, CAML_STATE(bottom_of_stack, %ebx) - popl %ebx; CFI_ADJUST(-4) - ALIGN_STACK(12) - call LBL(105) - UNDO_ALIGN_STACK(12) - jmp G(caml_alloc1) CFI_ENDPROC ENDFUNCTION(caml_alloc1) FUNCTION(caml_alloc2) CFI_STARTPROC - pushl %ebx; CFI_ADJUST(4) movl G(Caml_state), %ebx movl CAML_STATE(young_ptr, %ebx), %eax subl $12, %eax - cmpl CAML_STATE(young_limit, %ebx), %eax - jb LBL(101) movl %eax, CAML_STATE(young_ptr, %ebx) - popl %ebx; CFI_ADJUST(-4) + cmpl CAML_STATE(young_limit, %ebx), %eax + jb LBL(caml_call_gc) ret -LBL(101): - movl 4(%esp), %eax - movl %eax, CAML_STATE(last_return_address, %ebx) - leal 8(%esp), %eax - movl %eax, CAML_STATE(bottom_of_stack, %ebx) - popl %ebx; CFI_ADJUST(-4) - ALIGN_STACK(12) - call LBL(105) - UNDO_ALIGN_STACK(12) - jmp G(caml_alloc2) CFI_ENDPROC ENDFUNCTION(caml_alloc2) FUNCTION(caml_alloc3) CFI_STARTPROC - pushl %ebx; CFI_ADJUST(4) movl G(Caml_state), %ebx movl CAML_STATE(young_ptr, %ebx), %eax subl $16, %eax - cmpl CAML_STATE(young_limit, %ebx), %eax - jb LBL(102) movl %eax, CAML_STATE(young_ptr, %ebx) - popl %ebx; CFI_ADJUST(-4) + cmpl CAML_STATE(young_limit, %ebx), %eax + jb LBL(caml_call_gc) ret -LBL(102): - movl 4(%esp), %eax - movl %eax, CAML_STATE(last_return_address, %ebx) - leal 8(%esp), %eax - movl %eax, CAML_STATE(bottom_of_stack, %ebx) - popl %ebx; CFI_ADJUST(-4) - ALIGN_STACK(12) - call LBL(105) - UNDO_ALIGN_STACK(12) - jmp G(caml_alloc3) CFI_ENDPROC ENDFUNCTION(caml_alloc3) FUNCTION(caml_allocN) CFI_STARTPROC - pushl %eax; CFI_ADJUST(4) /* saved desired size */ - pushl %ebx; CFI_ADJUST(4) movl G(Caml_state), %ebx /* eax = size - Caml_state->young_ptr */ subl CAML_STATE(young_ptr, %ebx), %eax negl %eax /* eax = Caml_state->young_ptr - size */ - cmpl CAML_STATE(young_limit, %ebx), %eax - jb LBL(103) movl %eax, CAML_STATE(young_ptr, %ebx) - popl %ebx; CFI_ADJUST(-4) - addl $4, %esp; CFI_ADJUST(-4) /* drop desired size */ + cmpl CAML_STATE(young_limit, %ebx), %eax + jb LBL(caml_call_gc) ret -LBL(103): - movl 8(%esp), %eax - movl %eax, CAML_STATE(last_return_address, %ebx) - leal 12(%esp), %eax - movl %eax, CAML_STATE(bottom_of_stack, %ebx) - popl %ebx; CFI_ADJUST(-4) - ALIGN_STACK(8) - call LBL(105) - UNDO_ALIGN_STACK(8) - popl %eax; CFI_ADJUST(-4) /* recover desired size */ - jmp G(caml_allocN) CFI_ENDPROC ENDFUNCTION(caml_allocN) diff --git a/runtime/i386nt.asm b/runtime/i386nt.asm index 557994e2..548aa9dc 100644 --- a/runtime/i386nt.asm +++ b/runtime/i386nt.asm @@ -39,22 +39,19 @@ INCLUDE domain_state32.inc _caml_call_gc: ; Record lowest stack address and return address - push ebx ; make a tmp reg mov ebx, _Caml_state - mov eax, [esp+4] + mov eax, [esp] Store_last_return_address ebx, eax - lea eax, [esp+8] + lea eax, [esp+4] Store_bottom_of_stack ebx, eax - pop ebx ; Save all regs used by the code generator -L105: push ebp + push ebp push edi push esi push edx push ecx push ebx push eax - mov ebx, _Caml_state Store_gc_regs ebx, esp ; Call the garbage collector call _caml_garbage_collection @@ -66,88 +63,49 @@ L105: push ebp pop esi pop edi pop ebp - ; Return to caller + ; Return to caller. Returns young_ptr in eax + Load_young_ptr ebx, eax ret ALIGN 4 _caml_alloc1: - push ebx ; make a tmp reg mov ebx, _Caml_state Load_young_ptr ebx, eax sub eax, 8 - Cmp_young_limit ebx, eax - jb L100 Store_young_ptr ebx, eax - pop ebx + Cmp_young_limit ebx, eax + jb _caml_call_gc ret -L100: mov eax, [esp + 4] - Store_last_return_address ebx, eax - lea eax, [esp+8] - Store_bottom_of_stack ebx, eax - pop ebx - call L105 - jmp _caml_alloc1 ALIGN 4 _caml_alloc2: - push ebx ; make a tmp reg mov ebx, _Caml_state Load_young_ptr ebx, eax sub eax, 12 - Cmp_young_limit ebx, eax - jb L101 Store_young_ptr ebx, eax - pop ebx + Cmp_young_limit ebx, eax + jb _caml_call_gc ret -L101: mov eax, [esp+4] - Store_last_return_address ebx, eax - lea eax, [esp+8] - Store_bottom_of_stack ebx, eax - pop ebx - call L105 - jmp _caml_alloc2 ALIGN 4 _caml_alloc3: - push ebx ; make a tmp reg mov ebx, _Caml_state Load_young_ptr ebx, eax sub eax, 16 - Cmp_young_limit ebx, eax - jb L102 Store_young_ptr ebx, eax - pop ebx + Cmp_young_limit ebx, eax + jb _caml_call_gc ret -L102: mov eax, [esp+4] - Store_last_return_address ebx, eax - lea eax, [esp+8] - Store_bottom_of_stack ebx, eax - pop ebx - call L105 - jmp _caml_alloc3 - ALIGN 4 _caml_allocN: - push eax ; Save desired size - push ebx ; Make a tmp reg mov ebx, _Caml_state Sub_young_ptr ebx, eax ; eax = size - young_ptr neg eax ; eax = young_ptr - size - Cmp_young_limit ebx, eax - jb L103 Store_young_ptr ebx, eax - pop ebx - add esp, 4 ; drop desired size + Cmp_young_limit ebx, eax + jb _caml_call_gc ret -L103: mov eax, [esp+8] - Store_last_return_address ebx, eax - lea eax, [esp+12] - Store_bottom_of_stack ebx, eax - pop ebx - call L105 - pop eax ; recover desired size - jmp _caml_allocN ; Call a C function from OCaml diff --git a/runtime/intern.c b/runtime/intern.c index 7e0d4fd3..5d7d3817 100644 --- a/runtime/intern.c +++ b/runtime/intern.c @@ -77,27 +77,27 @@ CAMLnoreturn_end; static void intern_free_stack(void); -static inline unsigned char read8u(void) +Caml_inline unsigned char read8u(void) { return *intern_src++; } -static inline signed char read8s(void) +Caml_inline signed char read8s(void) { return *intern_src++; } -static inline uint16_t read16u(void) +Caml_inline uint16_t read16u(void) { uint16_t res = (intern_src[0] << 8) + intern_src[1]; intern_src += 2; return res; } -static inline int16_t read16s(void) +Caml_inline int16_t read16s(void) { int16_t res = (intern_src[0] << 8) + intern_src[1]; intern_src += 2; return res; } -static inline uint32_t read32u(void) +Caml_inline uint32_t read32u(void) { uint32_t res = ((uint32_t)(intern_src[0]) << 24) + (intern_src[1] << 16) @@ -106,7 +106,7 @@ static inline uint32_t read32u(void) return res; } -static inline int32_t read32s(void) +Caml_inline int32_t read32s(void) { int32_t res = ((uint32_t)(intern_src[0]) << 24) + (intern_src[1] << 16) @@ -132,7 +132,7 @@ static uintnat read64u(void) } #endif -static inline void readblock(void * dest, intnat len) +Caml_inline void readblock(void * dest, intnat len) { memcpy(dest, intern_src, len); intern_src += len; diff --git a/runtime/interp.c b/runtime/interp.c index 6bee2b0e..443dc2e7 100644 --- a/runtime/interp.c +++ b/runtime/interp.c @@ -71,9 +71,10 @@ sp is a local copy of the global variable Caml_state->extern_sp. */ // Do call asynchronous callbacks from allocation functions #define Alloc_small_origin CAML_FROM_CAML #define Setup_for_gc \ - { sp -= 2; sp[0] = accu; sp[1] = env; Caml_state->extern_sp = sp; } + { sp -= 3; sp[0] = accu; sp[1] = env; sp[2] = (value)pc; \ + Caml_state->extern_sp = sp; } #define Restore_after_gc \ - { accu = sp[0]; env = sp[1]; sp += 2; } + { sp = Caml_state->extern_sp; accu = sp[0]; env = sp[1]; sp += 3; } /* We store [pc+1] in the stack so that, in case of an exception, the first backtrace slot points to the event following the C call @@ -108,7 +109,11 @@ sp is a local copy of the global variable Caml_state->extern_sp. */ sp[0] = accu; sp[1] = (value)(pc - 1); \ sp[2] = env; sp[3] = Val_long(extra_args); \ Caml_state->extern_sp = sp; } -#define Restore_after_debugger { sp += 4; } +#define Restore_after_debugger \ + { CAMLassert(sp == Caml_state->extern_sp); \ + CAMLassert(sp[0] == accu); \ + CAMLassert(sp[2] == env); \ + sp += 4; } #ifdef THREADED_CODE #define Restart_curr_instr \ @@ -742,10 +747,9 @@ value caml_interprete(code_t prog, asize_t prog_size) Instruct(GETFIELD): accu = Field(accu, *pc); pc++; Next; Instruct(GETFLOATFIELD): { - double d = Double_flat_field(accu, *pc); + double d = Double_flat_field(accu, *pc++); Alloc_small(accu, Double_wosize, Double_tag); Store_double_val(accu, d); - pc++; Next; } diff --git a/runtime/major_gc.c b/runtime/major_gc.c index a723c40e..5e4f06bc 100644 --- a/runtime/major_gc.c +++ b/runtime/major_gc.c @@ -32,6 +32,8 @@ #include "caml/roots.h" #include "caml/signals.h" #include "caml/weak.h" +#include "caml/memprof.h" +#include "caml/eventlog.h" #if defined (NATIVE_CODE) && defined (NO_NAKED_POINTERS) #define NATIVE_CODE_AND_NO_NAKED_POINTERS @@ -40,7 +42,7 @@ #endif #ifdef _MSC_VER -static inline double fmin(double a, double b) { +Caml_inline double fmin(double a, double b) { return (a < b) ? a : b; } #endif @@ -87,7 +89,7 @@ int caml_gc_subphase; /* Subphase_{mark_roots,mark_main,mark_final} */ - the ephemerons in (3) are in an unknown state and must be checked At the end of mark phase, (3) is empty and ephe_list_pure is true. - The ephemeron in (1) and (2) will be cleaned (white keys and datas + The ephemeron in (1) and (2) will be cleaned (white keys and data replaced by none or the ephemeron is removed from the list if it is white) in clean phase. @@ -210,13 +212,6 @@ static void start_cycle (void) static value current_value = 0; static mlsize_t current_index = 0; -/* For instrumentation */ -#ifdef CAML_INSTR -#define INSTR(x) x -#else -#define INSTR(x) /**/ -#endif - static void init_sweep_phase(void) { /* Phase_clean is done. */ @@ -232,9 +227,9 @@ static void init_sweep_phase(void) } /* auxiliary function of mark_slice */ -static inline value* mark_slice_darken(value *gray_vals_ptr, - value v, mlsize_t i, - int in_ephemeron, int *slice_pointers) +Caml_inline value* mark_slice_darken(value *gray_vals_ptr, + value v, mlsize_t i, + int in_ephemeron, int *slice_pointers) { value child; header_t chd; @@ -253,7 +248,7 @@ static inline value* mark_slice_darken(value *gray_vals_ptr, #else if (Is_block (child) && Is_in_heap (child)) { #endif - INSTR (++ *slice_pointers;) + CAML_EVENTLOG_DO (++ *slice_pointers); chd = Hd_val (child); if (Tag_hd (chd) == Forward_tag){ value f = Forward_val (child); @@ -389,9 +384,9 @@ static void mark_slice (intnat work) header_t hd; mlsize_t size, i, start, end; /* [start] is a local copy of [current_index] */ #ifdef CAML_INSTR - int slice_fields = 0; -#endif - int slice_pointers = 0; /** gcc removes it when not in CAML_INSTR */ + int slice_fields = 0; /** eventlog counters */ +#endif /*CAML_INSTR*/ + int slice_pointers = 0; caml_gc_message (0x40, "Marking %"ARCH_INTNAT_PRINTF_FORMAT"d words\n", work); caml_gc_message (0x40, "Subphase = %d\n", caml_gc_subphase); @@ -413,9 +408,11 @@ static void mark_slice (intnat work) start = size < start ? size : start; end = size < end ? size : end; CAMLassert (end >= start); - INSTR (slice_fields += end - start;) - INSTR (if (size > end) - CAML_INSTR_INT ("major/mark/slice/remain", size - end);) + CAML_EVENTLOG_DO({ + slice_fields += end - start; + if (size > end) + CAML_EV_COUNTER (EV_C_MAJOR_MARK_SLICE_REMAIN, size - end); + }); for (i = start; i < end; i++){ gray_vals_ptr = mark_slice_darken(gray_vals_ptr,v,i, /*in_ephemeron=*/ 0, @@ -463,9 +460,11 @@ static void mark_slice (intnat work) markhp = chunk; limit = chunk + Chunk_size (chunk); } else if (caml_gc_subphase == Subphase_mark_roots) { + CAML_EV_BEGIN(EV_MAJOR_MARK_ROOTS); gray_vals_cur = gray_vals_ptr; work = caml_darken_all_roots_slice (work); gray_vals_ptr = gray_vals_cur; + CAML_EV_END(EV_MAJOR_MARK_ROOTS); if (work > 0){ caml_gc_subphase = Subphase_mark_main; } @@ -481,6 +480,7 @@ static void mark_slice (intnat work) case Subphase_mark_main: { /* Subphase_mark_main is done. Mark finalised values. */ + CAML_EV_BEGIN(EV_MAJOR_MARK_MAIN); gray_vals_cur = gray_vals_ptr; caml_final_update_mark_phase (); gray_vals_ptr = gray_vals_cur; @@ -490,14 +490,17 @@ static void mark_slice (intnat work) } /* Complete the marking */ ephes_to_check = ephes_checked_if_pure; + CAML_EV_END(EV_MAJOR_MARK_MAIN); caml_gc_subphase = Subphase_mark_final; } break; case Subphase_mark_final: { /** The set of unreachable value will not change anymore for this cycle. Start clean phase. */ + CAML_EV_BEGIN(EV_MAJOR_MARK_FINAL); caml_gc_phase = Phase_clean; caml_final_update_clean_phase (); + caml_memprof_update_clean_phase (); if (caml_ephe_list_head != (value) NULL){ /* Initialise the clean phase. */ ephes_to_check = &caml_ephe_list_head; @@ -505,7 +508,8 @@ static void mark_slice (intnat work) /* Initialise the sweep phase. */ init_sweep_phase(); } - work = 0; + work = 0; + CAML_EV_END(EV_MAJOR_MARK_FINAL); } break; default: CAMLassert (0); @@ -515,8 +519,8 @@ static void mark_slice (intnat work) gray_vals_cur = gray_vals_ptr; current_value = v; current_index = start; - INSTR (CAML_INSTR_INT ("major/mark/slice/fields#", slice_fields);) - INSTR (CAML_INSTR_INT ("major/mark/slice/pointers#", slice_pointers);) + CAML_EV_COUNTER(EV_C_MAJOR_MARK_SLICE_FIELDS, slice_fields); + CAML_EV_COUNTER(EV_C_MAJOR_MARK_SLICE_POINTERS, slice_pointers); } /* Clean ephemerons */ @@ -590,26 +594,6 @@ static void sweep_slice (intnat work) } } -#ifdef CAML_INSTR -static char *mark_slice_name[] = { - /* 0 */ NULL, - /* 1 */ NULL, - /* 2 */ NULL, - /* 3 */ NULL, - /* 4 */ NULL, - /* 5 */ NULL, - /* 6 */ NULL, - /* 7 */ NULL, - /* 8 */ NULL, - /* 9 */ NULL, - /* 10 */ "major/mark_roots", - /* 11 */ "major/mark_main", - /* 12 */ "major/mark_weak1", - /* 13 */ "major/mark_weak2", - /* 14 */ "major/mark_final", -}; -#endif - /* The main entry point for the major GC. Called about once for each minor GC. [howmuch] is the amount of work to do: -1 if the GC is triggered automatically @@ -680,7 +664,6 @@ void caml_major_collection_slice (intnat howmuch) */ if (caml_major_slice_begin_hook != NULL) (*caml_major_slice_begin_hook) (); - CAML_INSTR_SETUP (tmr, "major"); p = (double) caml_allocated_words * 3.0 * (100 + caml_percent_free) / Caml_state->stat_heap_wsz / caml_percent_free / 2.0; @@ -698,7 +681,8 @@ void caml_major_collection_slice (intnat howmuch) p_backlog = p - 0.3; p = 0.3; } - CAML_INSTR_INT ("major/work/extra#", + + CAML_EV_COUNTER (EV_C_MAJOR_WORK_EXTRA, (uintnat) (caml_extra_heap_resources * 1000000)); caml_gc_message (0x40, "ordered work = %" @@ -766,8 +750,9 @@ void caml_major_collection_slice (intnat howmuch) if (Caml_state->young_ptr == Caml_state->young_alloc_end){ /* We can only start a major GC cycle if the minor allocation arena is empty, otherwise we'd have to treat it as a set of roots. */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS); start_cycle (); - CAML_INSTR_TIME (tmr, "major/roots"); + CAML_EV_END(EV_MAJOR_ROOTS); } p = 0; goto finished; @@ -788,24 +773,27 @@ void caml_major_collection_slice (intnat howmuch) caml_gc_message (0x40, "computed work = %" ARCH_INTNAT_PRINTF_FORMAT "d words\n", computed_work); if (caml_gc_phase == Phase_mark){ - CAML_INSTR_INT ("major/work/mark#", computed_work); + CAML_EV_COUNTER (EV_C_MAJOR_WORK_MARK, computed_work); + CAML_EV_BEGIN(EV_MAJOR_MARK); mark_slice (computed_work); - CAML_INSTR_TIME (tmr, mark_slice_name[caml_gc_subphase]); + CAML_EV_END(EV_MAJOR_MARK); caml_gc_message (0x02, "!"); }else if (caml_gc_phase == Phase_clean){ clean_slice (computed_work); caml_gc_message (0x02, "%%"); }else{ CAMLassert (caml_gc_phase == Phase_sweep); - CAML_INSTR_INT ("major/work/sweep#", computed_work); + CAML_EV_COUNTER (EV_C_MAJOR_WORK_SWEEP, computed_work); + CAML_EV_BEGIN(EV_MAJOR_SWEEP); sweep_slice (computed_work); - CAML_INSTR_TIME (tmr, "major/sweep"); + CAML_EV_END(EV_MAJOR_SWEEP); caml_gc_message (0x02, "$"); } if (caml_gc_phase == Phase_idle){ + CAML_EV_BEGIN(EV_MAJOR_CHECK_AND_COMPACT); caml_compact_heap_maybe (); - CAML_INSTR_TIME (tmr, "major/check_and_compact"); + CAML_EV_END(EV_MAJOR_CHECK_AND_COMPACT); } finished: diff --git a/runtime/memory.c b/runtime/memory.c index 0c3f151a..6eb454b7 100644 --- a/runtime/memory.c +++ b/runtime/memory.c @@ -33,6 +33,7 @@ #include "caml/mlvalues.h" #include "caml/signals.h" #include "caml/memprof.h" +#include "caml/eventlog.h" int caml_huge_fallback_count = 0; /* Number of times that mmapping big pages fails and we fell back to small @@ -467,8 +468,8 @@ color_t caml_allocation_color (void *hp) } } -static inline value caml_alloc_shr_aux (mlsize_t wosize, tag_t tag, int track, - int raise_oom, uintnat profinfo) +Caml_inline value caml_alloc_shr_aux (mlsize_t wosize, tag_t tag, int track, + int raise_oom, uintnat profinfo) { header_t *hp; value *new_block; @@ -479,6 +480,7 @@ static inline value caml_alloc_shr_aux (mlsize_t wosize, tag_t tag, int track, else return 0; } + CAML_EV_ALLOC(wosize); hp = caml_fl_allocate (wosize); if (hp == NULL){ new_block = expand_heap (wosize); @@ -511,7 +513,7 @@ static inline value caml_alloc_shr_aux (mlsize_t wosize, tag_t tag, int track, profinfo)); caml_allocated_words += Whsize_wosize (wosize); if (caml_allocated_words > Caml_state->minor_heap_wsz){ - CAML_INSTR_INT ("request_major/alloc_shr@", 1); + CAML_EV_COUNTER (EV_C_REQUEST_MAJOR_ALLOC_SHR, 1); caml_request_major_slice (); } #ifdef DEBUG @@ -618,7 +620,7 @@ CAMLexport void caml_adjust_gc_speed (mlsize_t res, mlsize_t max) if (res > max) res = max; caml_extra_heap_resources += (double) res / (double) max; if (caml_extra_heap_resources > 1.0){ - CAML_INSTR_INT ("request_major/adjust_gc_speed_1@", 1); + CAML_EV_COUNTER (EV_C_REQUEST_MAJOR_ADJUST_GC_SPEED, 1); caml_extra_heap_resources = 1.0; caml_request_major_slice (); } @@ -664,7 +666,7 @@ CAMLexport CAMLweakdef void caml_modify (value *fp, value val) major GC treats it as an additional root. The logic implemented below is duplicated in caml_array_fill to - avoid repated calls to caml_modify and repeated tests on the + avoid repeated calls to caml_modify and repeated tests on the values. Don't forget to update caml_array_fill if the logic below changes! */ @@ -883,6 +885,8 @@ CAMLexport void caml_stat_free(caml_stat_block b) /* [sz] is a number of bytes */ CAMLexport caml_stat_block caml_stat_resize_noexc(caml_stat_block b, asize_t sz) { + if(b == NULL) + return caml_stat_alloc_noexc(sz); /* Backward compatibility mode */ if (pool == NULL) return realloc(b, sz); diff --git a/runtime/memprof.c b/runtime/memprof.c index 4aba3ef9..aead07a0 100644 --- a/runtime/memprof.c +++ b/runtime/memprof.c @@ -28,8 +28,13 @@ #include "caml/weak.h" #include "caml/stack.h" #include "caml/misc.h" +#include "caml/compact.h" +#include "caml/printexc.h" +#include "caml/eventlog.h" -static uint32_t mt_state[624]; +#define MT_STATE_SIZE 624 + +static uint32_t mt_state[MT_STATE_SIZE]; static uint32_t mt_index; /* [lambda] is the mean number of samples for each allocated word (including @@ -40,9 +45,27 @@ static double lambda = 0; Dummy if [lambda = 0]. */ static double one_log1m_lambda; +/* [caml_memprof_suspended] is used for masking memprof callbacks when + a callback is running or when an uncaught exception handler is + called. */ int caml_memprof_suspended = 0; -static intnat callstack_size = 0; -static value memprof_callback = Val_unit; + +/* [callback_running] is used to trigger a fatal error whenever + [Thread.exit] is called from a callback. */ +static int callback_running = 0; + +static intnat callstack_size; + +/* accessors for the OCaml type [Gc.Memprof.tracker], + which is the type of the [tracker] global below. */ +#define Alloc_minor(tracker) (Field(tracker, 0)) +#define Alloc_major(tracker) (Field(tracker, 1)) +#define Promote(tracker) (Field(tracker, 2)) +#define Dealloc_minor(tracker) (Field(tracker, 3)) +#define Dealloc_major(tracker) (Field(tracker, 4)) + +static value tracker; + /* Pointer to the word following the next sample in the minor heap. Equals [Caml_state->young_alloc_start] if no sampling is planned in @@ -54,6 +77,13 @@ value* caml_memprof_young_trigger; /* Whether memprof has been initialized. */ static int init = 0; +/* Whether memprof is started. */ +static int started = 0; + +/* Buffer used to compute backtraces */ +static value* callstack_buffer = NULL; +static intnat callstack_buffer_len = 0; + /**** Statistical sampling ****/ static double mt_generate_uniform(void) @@ -62,17 +92,18 @@ static double mt_generate_uniform(void) uint32_t y; /* Mersenne twister PRNG */ - if (mt_index == 624) { - for(i = 0; i < 227; i++) { + if (mt_index == MT_STATE_SIZE) { + for (i = 0; i < 227; i++) { y = (mt_state[i] & 0x80000000) + (mt_state[i+1] & 0x7fffffff); mt_state[i] = mt_state[i+397] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df); } - for(i = 227; i < 623; i++) { + for (i = 227; i < MT_STATE_SIZE - 1; i++) { y = (mt_state[i] & 0x80000000) + (mt_state[i+1] & 0x7fffffff); mt_state[i] = mt_state[i-227] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df); } - y = (mt_state[623] & 0x80000000) + (mt_state[0] & 0x7fffffff); - mt_state[623] = mt_state[396] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df); + y = (mt_state[MT_STATE_SIZE - 1] & 0x80000000) + (mt_state[0] & 0x7fffffff); + mt_state[MT_STATE_SIZE - 1] = + mt_state[396] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df); mt_index = 0; } @@ -88,21 +119,22 @@ static double mt_generate_uniform(void) } /* Simulate a geometric variable of parameter [lambda]. - The result is clipped in [1..Max_long] - Requires [lambda > 0]. */ -static uintnat mt_generate_geom() + The result is clipped in [1..Max_long] */ +static uintnat mt_generate_geom(void) { + double res; + CAMLassert(lambda > 0.); /* We use the float versions of exp/log, since these functions are significantly faster, and we really don't need much precision here. The entropy contained in [next_mt_generate_geom] is anyway bounded by the entropy provided by [mt_generate_uniform], which is 32bits. */ - double res = 1 + logf(mt_generate_uniform()) * one_log1m_lambda; + res = 1 + logf(mt_generate_uniform()) * one_log1m_lambda; if (res > Max_long) return Max_long; return (uintnat)res; } -static uintnat next_mt_generate_binom; +static uintnat next_mt_generate_geom; /* Simulate a binomial variable of parameters [len] and [lambda]. This sampling algorithm has running time linear with [len * lambda]. We could use more a involved algorithm, but this should @@ -113,263 +145,452 @@ static uintnat next_mt_generate_binom; If needed, we could use algorithm BTRS from the paper: Hormann, Wolfgang. "The generation of binomial random variates." Journal of statistical computation and simulation 46.1-2 (1993), pp101-110. - - Requires [lambda > 0] and [len < Max_long]. */ static uintnat mt_generate_binom(uintnat len) { uintnat res; - for(res = 0; next_mt_generate_binom < len; res++) - next_mt_generate_binom += mt_generate_geom(); - next_mt_generate_binom -= len; + CAMLassert(lambda > 0. && len < Max_long); + for (res = 0; next_mt_generate_geom < len; res++) + next_mt_generate_geom += mt_generate_geom(); + next_mt_generate_geom -= len; return res; } -/**** Interface with the OCaml code. ****/ - -static void purge_postponed_queue(void); +/**** Capturing the call stack *****/ -CAMLprim value caml_memprof_set(value v) +/* This function is called in, e.g., [caml_alloc_shr], which + guarantees that the GC is not called. Clients may use it in a + context where the heap is in an invalid state, or when the roots + are not properly registered. Therefore, we do not use [caml_alloc], + which may call the GC, but prefer using [caml_alloc_shr], which + gives this guarantee. The return value is either a valid callstack + or 0 in out-of-memory scenarios. */ +static value capture_callstack_postponed() { - CAMLparam1(v); - double l = Double_val(Field(v, 0)); - intnat sz = Long_val(Field(v, 1)); + value res; + intnat callstack_len = + caml_collect_current_callstack(&callstack_buffer, &callstack_buffer_len, + callstack_size, -1); + if (callstack_len == 0) + return Atom(0); + res = caml_alloc_shr_no_track_noexc(callstack_len, 0); + if (res == 0) + return Atom(0); + memcpy(Op_val(res), callstack_buffer, sizeof(value) * callstack_len); + if (callstack_buffer_len > 256 && callstack_buffer_len > callstack_len * 8) { + caml_stat_free(callstack_buffer); + callstack_buffer = NULL; + callstack_buffer_len = 0; + } + return res; +} - if (sz < 0 || !(l >= 0.) || l > 1.) /* Checks that [l] is not NAN. */ - caml_invalid_argument("caml_memprof_set"); +/* In this version, we are allowed to call the GC, so we use + [caml_alloc], which is more efficient since it uses the minor + heap. + Should be called with [caml_memprof_suspended == 1] */ +static value capture_callstack(int alloc_idx) +{ + value res; + intnat callstack_len = + caml_collect_current_callstack(&callstack_buffer, &callstack_buffer_len, + callstack_size, alloc_idx); + CAMLassert(caml_memprof_suspended); + res = caml_alloc(callstack_len, 0); + memcpy(Op_val(res), callstack_buffer, sizeof(value) * callstack_len); + if (callstack_buffer_len > 256 && callstack_buffer_len > callstack_len * 8) { + caml_stat_free(callstack_buffer); + callstack_buffer = NULL; + callstack_buffer_len = 0; + } + return res; +} - /* This call to [caml_memprof_set] may stop sampling or change the - callback. We have to make sure that the postponed queue is empty - before continuing. */ - if (!caml_memprof_suspended) - caml_raise_if_exception(caml_memprof_handle_postponed_exn()); - else - /* But if we are currently running a callback, there is nothing - else we can do than purging the queue. */ - purge_postponed_queue(); +/**** Data structures for tracked blocks. ****/ - if (!init) { - int i; - init = 1; +struct tracked { + /* Memory block being sampled. This is a weak GC root. */ + value block; - mt_index = 624; - mt_state[0] = 42; - for(i = 1; i < 624; i++) - mt_state[i] = 0x6c078965 * (mt_state[i-1] ^ (mt_state[i-1] >> 30)) + i; + /* Number of samples in this block. */ + uintnat n_samples; - caml_register_generational_global_root(&memprof_callback); - } + /* The size of this block. */ + uintnat wosize; - lambda = l; - if (l > 0) { - one_log1m_lambda = l == 1 ? 0 : 1/caml_log1p(-l); - next_mt_generate_binom = mt_generate_geom(); - } + /* The value returned by the previous callback for this block, or + the callstack if the alloc callback has not been called yet. + This is a strong GC root. */ + value user_data; - caml_memprof_renew_minor_sample(); + /* Whether this block has been initially allocated in the minor heap. */ + unsigned int alloc_young : 1; - callstack_size = sz; + /* Whether this block comes from unmarshalling. */ + unsigned int unmarshalled : 1; - caml_modify_generational_global_root(&memprof_callback, Field(v, 2)); + /* Whether this block has been promoted. Implies [alloc_young]. */ + unsigned int promoted : 1; - CAMLreturn(Val_unit); -} + /* Whether this block has been deallocated. */ + unsigned int deallocated : 1; -/* Cf. Gc.Memprof.alloc_kind */ -enum ml_alloc_kind { - Minor = Val_long(0), - Major = Val_long(1), - Unmarshalled = Val_long(2) -}; + /* Whether the allocation callback has been called. */ + unsigned int cb_alloc_called : 1; -/* When we call do_callback_exn, we suspend/resume sampling. In order - to avoid a systematic unnecessary polling after each memprof - callback, we do not call [caml_set_action_pending] when resuming. - Therefore, any call to [do_callback_exn] has to also make sure the - postponed queue will be handled fully at some point. */ -static value do_callback_exn(tag_t tag, uintnat wosize, uintnat occurrences, - value callstack, enum ml_alloc_kind cb_kind) -{ - CAMLparam1(callstack); - CAMLlocal1(sample_info); - value res; /* Not a root, can be an exception result. */ - CAMLassert(occurrences > 0 && !caml_memprof_suspended); + /* Whether the promotion callback has been called. */ + unsigned int cb_promote_called : 1; - caml_memprof_suspended = 1; + /* Whether the deallocation callback has been called. */ + unsigned int cb_dealloc_called : 1; - sample_info = caml_alloc_small(5, 0); - Field(sample_info, 0) = Val_long(occurrences); - Field(sample_info, 1) = cb_kind; - Field(sample_info, 2) = Val_long(tag); - Field(sample_info, 3) = Val_long(wosize); - Field(sample_info, 4) = callstack; + /* Whether this entry is deleted. */ + unsigned int deleted : 1; - res = caml_callback_exn(memprof_callback, sample_info); + /* Whether a callback is currently running for this entry. */ + unsigned int callback_running : 1; - caml_memprof_suspended = 0; + /* Pointer to the [t_idx] variable in the [run_callback] frame which + is currently running the callback for this entry. This is needed + to make [run_callback] reetrant, in the case it is called + simultaneously by several threads. */ + uintnat* idx_ptr; +}; - CAMLreturn(res); +/* During the alloc callback for a minor allocation, the block being + sampled is not yet allocated. Instead, we place in the block field + a value computed with the following macro: */ +#define Placeholder_magic 0x04200000 +#define Placeholder_offs(offset) (Val_long(offset + Placeholder_magic)) +#define Offs_placeholder(block) (Long_val(block) & 0xFFFF) +#define Is_placeholder(block) \ + (Is_long(block) && (Long_val(block) & ~(uintnat)0xFFFF) == Placeholder_magic) + +/* When an entry is deleted, its index is replaced by that integer. */ +#define Invalid_index (~(uintnat)0) + + +static struct tracking_state { + struct tracked* entries; + /* The allocated capacity of the entries array */ + uintnat alloc_len; + /* The number of active entries. (len <= alloc_len) */ + uintnat len; + /* Before this position, the [block] and [user_data] fields point to + the major heap (young <= len). */ + uintnat young; + /* There are no pending callbacks before this position (callback <= len). */ + uintnat callback; + /* There are no blocks to be deleted before this position */ + uintnat delete; +} trackst; + +#define MIN_TRACKST_ALLOC_LEN 128 + + +/* Reallocate the [trackst] array if it is either too small or too + large. + Returns 1 if reallocation succeeded --[trackst.alloc_len] is at + least [trackst.len]--, and 0 otherwise. */ +static int realloc_trackst(void) { + uintnat new_alloc_len; + struct tracked* new_entries; + if (trackst.len <= trackst.alloc_len && + (4*trackst.len >= trackst.alloc_len || + trackst.alloc_len == MIN_TRACKST_ALLOC_LEN)) + return 1; + new_alloc_len = trackst.len * 2; + if (new_alloc_len < MIN_TRACKST_ALLOC_LEN) + new_alloc_len = MIN_TRACKST_ALLOC_LEN; + new_entries = caml_stat_resize_noexc(trackst.entries, + new_alloc_len * sizeof(struct tracked)); + if (new_entries == NULL) return 0; + trackst.entries = new_entries; + trackst.alloc_len = new_alloc_len; + return 1; } -/**** Capturing the call stack *****/ - -/* This function is called for postponed blocks, so it guarantees - that the GC is not called. */ -static value capture_callstack_postponed(void) +Caml_inline uintnat new_tracked(uintnat n_samples, uintnat wosize, + int is_unmarshalled, int is_young, + value block, value user_data) { - value res; - uintnat wosize = caml_current_callstack_size(callstack_size); - /* We do not use [caml_alloc] to make sure the GC will not get called. */ - if (wosize == 0) return Atom (0); - res = caml_alloc_shr_no_track_noexc(wosize, 0); - if (res != 0) caml_current_callstack_write(res); - return res; + struct tracked *t; + trackst.len++; + if (!realloc_trackst()) { + trackst.len--; + return Invalid_index; + } + t = &trackst.entries[trackst.len - 1]; + t->block = block; + t->n_samples = n_samples; + t->wosize = wosize; + t->user_data = user_data; + t->idx_ptr = NULL; + t->alloc_young = is_young; + t->unmarshalled = is_unmarshalled; + t->promoted = 0; + t->deallocated = 0; + t->cb_alloc_called = t->cb_promote_called = t->cb_dealloc_called = 0; + t->deleted = 0; + t->callback_running = 0; + return trackst.len - 1; } -static value capture_callstack(void) +static void mark_deleted(uintnat t_idx) { + struct tracked* t = &trackst.entries[t_idx]; + t->deleted = 1; + t->user_data = Val_unit; + t->block = Val_unit; + if (t_idx < trackst.delete) trackst.delete = t_idx; + CAMLassert(t->idx_ptr == NULL); +} + +/* The return value is an exception or [Val_unit] iff [*t_idx] is set to + [Invalid_index]. In this case, the entry is deleted. + Otherwise, the return value is a [Some(...)] block. */ +Caml_inline value run_callback_exn(uintnat *t_idx, value cb, value param) { + struct tracked* t = &trackst.entries[*t_idx]; value res; - uintnat wosize = caml_current_callstack_size(callstack_size); - CAMLassert(!caml_memprof_suspended); - caml_memprof_suspended = 1; /* => no samples in the call stack. */ - res = caml_alloc(wosize, 0); - caml_memprof_suspended = 0; - caml_current_callstack_write(res); + CAMLassert(!t->callback_running && t->idx_ptr == NULL); + CAMLassert(lambda > 0.); + + callback_running = t->callback_running = 1; + t->idx_ptr = t_idx; + res = caml_callback_exn(cb, param); + callback_running = 0; + /* The call above can modify [*t_idx] and thus invalidate [t]. */ + if (*t_idx == Invalid_index) { + /* Make sure this entry has not been removed by [caml_memprof_set] */ + return Val_unit; + } + t = &trackst.entries[*t_idx]; + t->idx_ptr = NULL; + t->callback_running = 0; + if (Is_exception_result(res) || res == Val_unit) { + /* Callback raised an exception or returned None or (), discard + this entry. */ + mark_deleted(*t_idx); + *t_idx = Invalid_index; + } return res; } -/**** Handling postponed sampled blocks. ****/ -/* When allocating in from C code, we cannot call the callback, - because the [caml_alloc_***] are guaranteed not to do so. These - functions make it possible to register a sampled block in a - todo-list so that the callback call is performed when possible. */ -/* Note: the shorter the delay is, the better, because the block is - linked to a root during the delay, so that the reachability - properties of the sampled block are artificially modified. */ - -#define POSTPONED_DEFAULT_QUEUE_SIZE 128 -static struct postponed_block { - value block; - value callstack; - uintnat occurrences; - enum ml_alloc_kind kind; -} default_postponed_queue[POSTPONED_DEFAULT_QUEUE_SIZE], - *postponed_queue = default_postponed_queue, - *postponed_queue_end = default_postponed_queue + POSTPONED_DEFAULT_QUEUE_SIZE, - *postponed_tl = default_postponed_queue, /* Pointer to next pop */ - *postponed_hd = default_postponed_queue; /* Pointer to next push */ - -static struct postponed_block* postponed_next(struct postponed_block* p) +/* Run all the needed callbacks for a given entry. + In case of a thread context switch during a callback, this can be + called in a reetrant way. + If [*t_idx] equals [trackst.callback], then this function + increments [trackst.callback]. + The index of the entry may change. It is set to [Invalid_index] if + the entry is discarded. + Returns: + - An exception result if the callback raised an exception + - Val_long(0) == Val_unit == None otherwise + */ +static value handle_entry_callbacks_exn(uintnat* t_idx) { - p++; - if (p == postponed_queue_end) return postponed_queue; - else return p; -} + value sample_info, res, user_data; /* No need to make these roots */ + struct tracked* t = &trackst.entries[*t_idx]; + if (*t_idx == trackst.callback) trackst.callback++; + + if (t->deleted || t->callback_running) return Val_unit; + + if (!t->cb_alloc_called) { + t->cb_alloc_called = 1; + CAMLassert(Is_block(t->block) + || Is_placeholder(t->block) + || t->deallocated); + sample_info = caml_alloc_small(4, 0); + Field(sample_info, 0) = Val_long(t->n_samples); + Field(sample_info, 1) = Val_long(t->wosize); + Field(sample_info, 2) = Val_long(t->unmarshalled); + Field(sample_info, 3) = t->user_data; + t->user_data = Val_unit; + res = run_callback_exn(t_idx, + t->alloc_young ? Alloc_minor(tracker) : Alloc_major(tracker), + sample_info); + if (*t_idx == Invalid_index) + return res; + CAMLassert(!Is_exception_result(res) && Is_block(res) && Tag_val(res) == 0 + && Wosize_val(res) == 1); + t = &trackst.entries[*t_idx]; + t->user_data = Field(res, 0); + if (Is_block(t->user_data) && Is_young(t->user_data) && + *t_idx < trackst.young) + trackst.young = *t_idx; + } -static void purge_postponed_queue(void) -{ - if (postponed_queue != default_postponed_queue) { - caml_stat_free(postponed_queue); - postponed_queue = default_postponed_queue; - postponed_queue_end = postponed_queue + POSTPONED_DEFAULT_QUEUE_SIZE; + if (t->promoted && !t->cb_promote_called) { + t->cb_promote_called = 1; + user_data = t->user_data; + t->user_data = Val_unit; + res = run_callback_exn(t_idx, Promote(tracker), user_data); + if (*t_idx == Invalid_index) + return res; + CAMLassert(!Is_exception_result(res) && Is_block(res) && Tag_val(res) == 0 + && Wosize_val(res) == 1); + t = &trackst.entries[*t_idx]; + t->user_data = Field(res, 0); + if (Is_block(t->user_data) && Is_young(t->user_data) && + *t_idx < trackst.young) + trackst.young = *t_idx; + } + + if (t->deallocated && !t->cb_dealloc_called) { + value cb = (t->promoted || !t->alloc_young) ? + Dealloc_major(tracker) : Dealloc_minor(tracker); + t->cb_dealloc_called = 1; + user_data = t->user_data; + t->user_data = Val_unit; + res = run_callback_exn(t_idx, cb, user_data); + /* [t] is invalid, but we do no longer use it. */ + CAMLassert(*t_idx == Invalid_index); + CAMLassert(Is_exception_result(res) || res == Val_unit); + return res; } - postponed_hd = postponed_tl = postponed_queue; + + return Val_unit; } -/* This function does not call the GC. This is important since it is - called when allocating a block using [caml_alloc_shr]: The new - block is allocated, but not yet initialized, so that the heap - invariants are broken. */ -static void register_postponed_callback(value block, uintnat occurrences, - enum ml_alloc_kind kind, - value* callstack) +/* Remove any deleted entries, updating callback and young */ +static void flush_deleted(void) { - struct postponed_block* new_hd; - if (occurrences == 0) return; - if (*callstack == 0) *callstack = capture_callstack_postponed(); - if (*callstack == 0) return; /* OOM */ - - new_hd = postponed_next(postponed_hd); - if (new_hd == postponed_tl) { - /* Queue is full, reallocate it. (We always leave one free slot in - order to be able to distinguish the 100% full and the empty - states). */ - uintnat sz = 2 * (postponed_queue_end - postponed_queue); - struct postponed_block* new_queue = - caml_stat_alloc_noexc(sz * sizeof(struct postponed_block)); - if (new_queue == NULL) return; - new_hd = new_queue; - while (postponed_tl != postponed_hd) { - *new_hd = *postponed_tl; - new_hd++; - postponed_tl = postponed_next(postponed_tl); + uintnat i = trackst.delete, j = i; + while (i < trackst.len) { + if (!trackst.entries[i].deleted) { + if (trackst.entries[i].idx_ptr != NULL) + *trackst.entries[i].idx_ptr = j; + trackst.entries[j] = trackst.entries[i]; + j++; } - if (postponed_queue != default_postponed_queue) - caml_stat_free(postponed_queue); - postponed_tl = postponed_queue = new_queue; - postponed_hd = new_hd; - postponed_queue_end = postponed_queue + sz; - new_hd++; + i++; + if (trackst.young == i) trackst.young = j; + if (trackst.callback == i) trackst.callback = j; } + trackst.delete = trackst.len = j; + CAMLassert(trackst.callback <= trackst.len); + CAMLassert(trackst.young <= trackst.len); + realloc_trackst(); +} - postponed_hd->block = block; - postponed_hd->callstack = *callstack; - postponed_hd->occurrences = occurrences; - postponed_hd->kind = kind; - postponed_hd = new_hd; - - if (!caml_memprof_suspended) caml_set_action_pending(); +static void check_action_pending(void) { + if (!caml_memprof_suspended && trackst.callback < trackst.len) + caml_set_action_pending(); } +/* In case of a thread context switch during a callback, this can be + called in a reetrant way. */ value caml_memprof_handle_postponed_exn(void) { - CAMLparam0(); - CAMLlocal1(block); - value ephe; - - if (caml_memprof_suspended) - CAMLreturn(Val_unit); - - while (postponed_tl != postponed_hd) { - struct postponed_block pb = *postponed_tl; - block = pb.block; /* pb.block is not a root! */ - postponed_tl = postponed_next(postponed_tl); - if (postponed_tl == postponed_hd) purge_postponed_queue(); - - /* If using threads, this call can trigger reentrant calls to - [caml_memprof_handle_postponed] even though we set - [caml_memprof_suspended]. */ - ephe = do_callback_exn(Tag_val(block), Wosize_val(block), - pb.occurrences, pb.callstack, pb.kind); + value res = Val_unit; + if (caml_memprof_suspended) return res; + caml_memprof_suspended = 1; + while (trackst.callback < trackst.len) { + uintnat i = trackst.callback; + res = handle_entry_callbacks_exn(&i); + if (Is_exception_result(res)) break; + } + caml_memprof_suspended = 0; + check_action_pending(); /* Needed in case of an exception */ + flush_deleted(); + return res; +} - if (Is_exception_result(ephe)) CAMLreturn(ephe); +void caml_memprof_oldify_young_roots(void) +{ + uintnat i; + /* This loop should always have a small number of iteration (when + compared to the size of the minor heap), because the young + pointer should always be close to the end of the array. Indeed, + it is only moved back when returning from a callback triggered by + allocation or promotion, which can only happen for blocks + allocated recently, which are close to the end of the trackst + array. */ + for (i = trackst.young; i < trackst.len; i++) + caml_oldify_one(trackst.entries[i].user_data, + &trackst.entries[i].user_data); +} - if (Is_block(ephe)) caml_ephemeron_set_key(Field(ephe, 0), 0, block); +void caml_memprof_minor_update(void) +{ + uintnat i; + /* See comment in [caml_memprof_oldify_young_roots] for the number + of iterations of this loop. */ + for (i = trackst.young; i < trackst.len; i++) { + struct tracked *t = &trackst.entries[i]; + CAMLassert(Is_block(t->block) || t->deleted || t->deallocated || + Is_placeholder(t->block)); + if (Is_block(t->block) && Is_young(t->block)) { + if (Hd_val(t->block) == 0) { + /* Block has been promoted */ + t->block = Field(t->block, 0); + t->promoted = 1; + } else { + /* Block is dead */ + CAMLassert_young_header(Hd_val(t->block)); + t->block = Val_unit; + t->deallocated = 1; + } + } } + if (trackst.callback > trackst.young) { + trackst.callback = trackst.young; + check_action_pending(); + } + trackst.young = trackst.len; +} - CAMLreturn(Val_unit); +void caml_memprof_do_roots(scanning_action f) +{ + uintnat i; + for (i = 0; i < trackst.len; i++) + f(trackst.entries[i].user_data, &trackst.entries[i].user_data); } -/* We don't expect these roots to live long. No need to have a special - case for young roots. */ -void caml_memprof_scan_roots(scanning_action f) { - struct postponed_block* p; - for(p = postponed_tl; p != postponed_hd; p = postponed_next(p)) { - f(p->block, &p->block); - f(p->callstack, &p->callstack); +void caml_memprof_update_clean_phase(void) +{ + uintnat i; + for (i = 0; i < trackst.len; i++) { + struct tracked *t = &trackst.entries[i]; + if (Is_block(t->block) && !Is_young(t->block)) { + CAMLassert(Is_in_heap(t->block)); + CAMLassert(!t->alloc_young || t->promoted); + if (Is_white_val(t->block)) { + t->block = Val_unit; + t->deallocated = 1; + } + } } + trackst.callback = 0; + check_action_pending(); +} + +void caml_memprof_invert_tracked(void) +{ + uintnat i; + for (i = 0; i < trackst.len; i++) + caml_invert_root(trackst.entries[i].block, &trackst.entries[i].block); } /**** Sampling procedures ****/ void caml_memprof_track_alloc_shr(value block) { + uintnat n_samples; value callstack = 0; CAMLassert(Is_in_heap(block)); + /* This test also makes sure memprof is initialized. */ if (lambda == 0 || caml_memprof_suspended) return; - register_postponed_callback( - block, mt_generate_binom(Whsize_val(block)), Major, &callstack); + + n_samples = mt_generate_binom(Whsize_val(block)); + if (n_samples == 0) return; + + callstack = capture_callstack_postponed(); + if (callstack == 0) return; + + new_tracked(n_samples, Wosize_val(block), 0, 0, block, callstack); + check_action_pending(); } /* Shifts the next sample in the minor heap by [n] words. Essentially, @@ -397,7 +618,7 @@ void caml_memprof_renew_minor_sample(void) caml_memprof_young_trigger = Caml_state->young_alloc_start; else { uintnat geom = mt_generate_geom(); - if(Caml_state->young_ptr - Caml_state->young_alloc_start < geom) + if (Caml_state->young_ptr - Caml_state->young_alloc_start < geom) /* No trigger in the current minor heap. */ caml_memprof_young_trigger = Caml_state->young_alloc_start; caml_memprof_young_trigger = Caml_state->young_ptr - (geom - 1); @@ -409,16 +630,22 @@ void caml_memprof_renew_minor_sample(void) /* Called when exceeding the threshold for the next sample in the minor heap, from the C code (the handling is different when called from natively compiled OCaml code). */ -void caml_memprof_track_young(tag_t tag, uintnat wosize, int from_caml) +void caml_memprof_track_young(uintnat wosize, int from_caml, + int nallocs, unsigned char* encoded_alloc_lens) { - CAMLparam0(); - CAMLlocal2(ephe, callstack); uintnat whsize = Whsize_wosize(wosize); - uintnat occurrences; + value callstack, res = Val_unit; + int alloc_idx = 0, i, allocs_sampled = 0, has_delete = 0; + intnat alloc_ofs, trigger_ofs; + /* usually, only one allocation is sampled, even when the block contains + multiple combined allocations. So, we delay allocating the full + sampled_allocs array until we discover we actually need two entries */ + uintnat first_idx, *idx_tab = &first_idx; + double saved_lambda = lambda; if (caml_memprof_suspended) { caml_memprof_renew_minor_sample(); - CAMLreturn0; + return; } /* If [lambda == 0], then [caml_memprof_young_trigger] should be @@ -427,101 +654,324 @@ void caml_memprof_track_young(tag_t tag, uintnat wosize, int from_caml) caml_memprof_young_trigger], which is contradictory. */ CAMLassert(lambda > 0); - occurrences = - mt_generate_binom(caml_memprof_young_trigger - 1 - - Caml_state->young_ptr) + 1; - if (!from_caml) { - value callstack = 0; - register_postponed_callback(Val_hp(Caml_state->young_ptr), occurrences, - Minor, &callstack); + unsigned n_samples = 1 + + mt_generate_binom(caml_memprof_young_trigger - 1 - Caml_state->young_ptr); + CAMLassert(encoded_alloc_lens == NULL); /* No Comballoc in C! */ caml_memprof_renew_minor_sample(); - CAMLreturn0; + + callstack = capture_callstack_postponed(); + if (callstack == 0) return; + + new_tracked(n_samples, wosize, + 0, 1, Val_hp(Caml_state->young_ptr), callstack); + check_action_pending(); + return; } - /* We need to call the callback for this sampled block. Since the + /* We need to call the callbacks for this sampled block. Since each callback can potentially allocate, the sampled block will *not* be the one pointed to by [caml_memprof_young_trigger]. Instead, we remember that we need to sample the next allocated word, call the callback and use as a sample the block which will be allocated right after the callback. */ - /* Restore the minor heap in a valid state for calling the callback. + CAMLassert(Caml_state->young_ptr < caml_memprof_young_trigger && + caml_memprof_young_trigger <= Caml_state->young_ptr + whsize); + trigger_ofs = caml_memprof_young_trigger - Caml_state->young_ptr; + alloc_ofs = whsize; + + /* Restore the minor heap in a valid state for calling the callbacks. We should not call the GC before these two instructions. */ Caml_state->young_ptr += whsize; caml_memprof_renew_minor_sample(); + caml_memprof_suspended = 1; - /* Empty the queue to make sure callbacks are called in the right - order. */ - caml_raise_if_exception(caml_memprof_handle_postponed_exn()); + /* Perform the sampling of the block in the set of Comballoc'd + blocks, insert them in the entries array, and run the + callbacks. */ + for (alloc_idx = nallocs - 1; alloc_idx >= 0; alloc_idx--) { + unsigned alloc_wosz = encoded_alloc_lens == NULL ? wosize : + Wosize_encoded_alloc_len(encoded_alloc_lens[alloc_idx]); + unsigned n_samples = 0; + alloc_ofs -= Whsize_wosize(alloc_wosz); + while (alloc_ofs < trigger_ofs) { + n_samples++; + trigger_ofs -= mt_generate_geom(); + } + if (n_samples > 0) { + uintnat *idx_ptr, t_idx; + + callstack = capture_callstack(alloc_idx); + t_idx = new_tracked(n_samples, alloc_wosz, + 0, 1, Placeholder_offs(alloc_ofs), callstack); + if (t_idx == Invalid_index) continue; + res = handle_entry_callbacks_exn(&t_idx); + if (t_idx == Invalid_index) { + has_delete = 1; + if (saved_lambda != lambda) { + /* [lambda] changed during the callback. We need to refresh + [trigger_ofs]. */ + saved_lambda = lambda; + trigger_ofs = lambda == 0. ? 0 : alloc_ofs - (mt_generate_geom() - 1); + } + } + if (Is_exception_result(res)) break; + if (t_idx == Invalid_index) continue; + + if (allocs_sampled == 1) { + /* Found a second sampled allocation! Allocate a buffer for them */ + idx_tab = caml_stat_alloc_noexc(sizeof(uintnat) * nallocs); + if (idx_tab == NULL) { + alloc_ofs = 0; + idx_tab = &first_idx; + break; + } + idx_tab[0] = first_idx; + if (idx_tab[0] != Invalid_index) + trackst.entries[idx_tab[0]].idx_ptr = &idx_tab[0]; + } + + /* Usually, trackst.entries[...].idx_ptr is owned by the thread + running a callback for the entry, if any. Here, we take ownership + of idx_ptr until the end of the function. + + This does not conflict with the usual use of idx_ptr because no + callbacks can run on this entry until the end of the function: + the allocation callback has already run and the other callbacks + do not run on Placeholder values */ + idx_ptr = &idx_tab[allocs_sampled]; + *idx_ptr = t_idx; + trackst.entries[*idx_ptr].idx_ptr = idx_ptr; + allocs_sampled++; + } + } - callstack = capture_callstack(); - ephe = caml_raise_if_exception(do_callback_exn(tag, wosize, occurrences, - callstack, Minor)); + CAMLassert(alloc_ofs == 0 || Is_exception_result(res)); + CAMLassert(allocs_sampled <= nallocs); + caml_memprof_suspended = 0; + check_action_pending(); + /* We need to call [check_action_pending] since we + reset [caml_memprof_suspended] to 0 (a GC collection may have + triggered some new callback). + + We need to make sure that the action pending flag is not set + systematically, which is to be expected, since [new_tracked] + created a new block without updating + [trackst.callback]. Fortunately, [handle_entry_callback_exn] + increments [trackst.callback] if it is equal to [t_idx]. */ + + /* This condition happens either in the case of an exception or if + one of the callbacks returned [None]. If these cases happen + frequently, then we need to call [flush_deleted] somewhere to + prevent a leak. */ + if (has_delete) + flush_deleted(); + + if (Is_exception_result(res)) { + for (i = 0; i < allocs_sampled; i++) + if (idx_tab[i] != Invalid_index) { + struct tracked* t = &trackst.entries[idx_tab[i]]; + /* The allocations are cancelled because of the exception, + but this callback has already been called. We simulate a + deallocation. */ + t->block = Val_unit; + t->deallocated = 1; + if (trackst.callback > idx_tab[i]) { + trackst.callback = idx_tab[i]; + check_action_pending(); + } + } + if (idx_tab != &first_idx) caml_stat_free(idx_tab); + caml_raise(Extract_exception(res)); + } /* We can now restore the minor heap in the state needed by [Alloc_small_aux]. */ if (Caml_state->young_ptr - whsize < Caml_state->young_trigger) { - CAML_INSTR_INT ("force_minor/memprof@", 1); + CAML_EV_COUNTER(EV_C_FORCE_MINOR_MEMPROF, 1); caml_gc_dispatch(); } - /* Re-allocate the block in the minor heap. We should not call the + /* Re-allocate the blocks in the minor heap. We should not call the GC after this. */ Caml_state->young_ptr -= whsize; /* Make sure this block is not going to be sampled again. */ shift_sample(whsize); - /* Write the ephemeron if not [None]. */ - if (Is_block(ephe)) { - /* Subtlety: we are actually writing the ephemeron with an invalid - (uninitialized) block. This is correct for two reasons: - - The logic of [caml_ephemeron_set_key] never inspects the content of - the block. In only checks that the block is young. - - The allocation and initialization happens right after returning - from [caml_memprof_track_young]. */ - caml_ephemeron_set_key(Field(ephe, 0), 0, Val_hp(Caml_state->young_ptr)); + for (i = 0; i < allocs_sampled; i++) { + if (idx_tab[i] != Invalid_index) { + /* If the execution of the callback has succeeded, then we start the + tracking of this block.. + + Subtlety: we are actually writing [t->block] with an invalid + (uninitialized) block. This is correct because the allocation + and initialization happens right after returning from + [caml_memprof_track_young]. */ + struct tracked *t = &trackst.entries[idx_tab[i]]; + t->block = Val_hp(Caml_state->young_ptr + Offs_placeholder(t->block)); + t->idx_ptr = NULL; + CAMLassert(t->cb_alloc_called); + if (idx_tab[i] < trackst.young) trackst.young = idx_tab[i]; + } } + if (idx_tab != &first_idx) caml_stat_free(idx_tab); /* /!\ Since the heap is in an invalid state before initialization, very little heap operations are allowed until then. */ - CAMLreturn0; + return; } void caml_memprof_track_interned(header_t* block, header_t* blockend) { header_t *p; value callstack = 0; + int is_young = Is_young(Val_hp(block)); - if(lambda == 0 || caml_memprof_suspended) + if (lambda == 0 || caml_memprof_suspended) return; - /* We have to select the sampled blocks before sampling them, - because sampling may trigger GC, and then blocks can escape from - [block, blockend[. So we use the postponing machinery for - selecting blocks. [intern.c] will call [check_urgent_gc] which - will call [caml_memprof_handle_postponed] in turn. */ p = block; - while(1) { + while (1) { uintnat next_sample = mt_generate_geom(); header_t *next_sample_p, *next_p; - if(next_sample > blockend - p) + if (next_sample > blockend - p) break; /* [next_sample_p] is the block *following* the next sampled block! */ next_sample_p = p + next_sample; - while(1) { + while (1) { next_p = p + Whsize_hp(p); - if(next_p >= next_sample_p) break; + if (next_p >= next_sample_p) break; p = next_p; } - register_postponed_callback( - Val_hp(p), mt_generate_binom(next_p - next_sample_p) + 1, - Unmarshalled, &callstack); - + if (callstack == 0) callstack = capture_callstack_postponed(); + if (callstack == 0) break; /* OOM */ + new_tracked(mt_generate_binom(next_p - next_sample_p) + 1, + Wosize_hp(p), 1, is_young, Val_hp(p), callstack); p = next_p; } + check_action_pending(); +} + +/**** Interface with the OCaml code. ****/ + +static void caml_memprof_init(void) { + uintnat i; + + init = 1; + + mt_index = MT_STATE_SIZE; + mt_state[0] = 42; + for (i = 1; i < MT_STATE_SIZE; i++) + mt_state[i] = 0x6c078965 * (mt_state[i-1] ^ (mt_state[i-1] >> 30)) + i; +} + +void caml_memprof_shutdown(void) { + init = 0; + started = 0; + lambda = 0.; + caml_memprof_suspended = 0; + trackst.len = 0; + trackst.callback = trackst.young = trackst.delete = 0; + caml_stat_free(trackst.entries); + trackst.entries = NULL; + trackst.alloc_len = 0; + caml_stat_free(callstack_buffer); + callstack_buffer = NULL; + callstack_buffer_len = 0; +} + +CAMLprim value caml_memprof_start(value lv, value szv, value tracker_param) +{ + CAMLparam3(lv, szv, tracker_param); + + double l = Double_val(lv); + intnat sz = Long_val(szv); + + if (started) caml_failwith("Gc.Memprof.start: already started."); + + if (sz < 0 || !(l >= 0.) || l > 1.) /* Checks that [l] is not NAN. */ + caml_invalid_argument("Gc.Memprof.start"); + + if (!init) caml_memprof_init(); + + lambda = l; + if (l > 0) { + one_log1m_lambda = l == 1 ? 0 : 1/caml_log1p(-l); + next_mt_generate_geom = mt_generate_geom(); + } + + caml_memprof_renew_minor_sample(); + + callstack_size = sz; + started = 1; + + tracker = tracker_param; + caml_register_generational_global_root(&tracker); + + CAMLreturn(Val_unit); +} + +CAMLprim value caml_memprof_stop(value unit) +{ + uintnat i; + + if (!started) caml_failwith("Gc.Memprof.stop: not started."); + + /* This call to [caml_memprof_stop] will discard all the previously + tracked blocks. We try one last time to call the postponed + callbacks. */ + caml_raise_if_exception(caml_memprof_handle_postponed_exn()); + + /* Discard the tracked blocks. */ + for (i = 0; i < trackst.len; i++) + if (trackst.entries[i].idx_ptr != NULL) + *trackst.entries[i].idx_ptr = Invalid_index; + trackst.len = 0; + trackst.callback = trackst.young = trackst.delete = 0; + caml_stat_free(trackst.entries); + trackst.entries = NULL; + trackst.alloc_len = 0; + + lambda = 0; + caml_memprof_renew_minor_sample(); + started = 0; + + caml_remove_generational_global_root(&tracker); + + caml_stat_free(callstack_buffer); + callstack_buffer = NULL; + callstack_buffer_len = 0; + + return Val_unit; +} + +/**** Interface with systhread. ****/ + +void caml_memprof_init_th_ctx(struct caml_memprof_th_ctx* ctx) { + ctx->suspended = 0; + ctx->callback_running = 0; +} + +void caml_memprof_stop_th_ctx(struct caml_memprof_th_ctx* ctx) { + /* Make sure that no memprof callback is being executed in this + thread. If so, memprof data structures may have pointers to the + thread's stack. */ + if(ctx->callback_running) + caml_fatal_error("Thread.exit called from a memprof callback."); +} + +void caml_memprof_save_th_ctx(struct caml_memprof_th_ctx* ctx) { + ctx->suspended = caml_memprof_suspended; + ctx->callback_running = callback_running; +} + +void caml_memprof_restore_th_ctx(const struct caml_memprof_th_ctx* ctx) { + caml_memprof_suspended = ctx->suspended; + callback_running = ctx->callback_running; + check_action_pending(); } diff --git a/runtime/minor_gc.c b/runtime/minor_gc.c index e4dacfc5..b8661bc7 100644 --- a/runtime/minor_gc.c +++ b/runtime/minor_gc.c @@ -31,6 +31,10 @@ #include "caml/signals.h" #include "caml/weak.h" #include "caml/memprof.h" +#ifdef WITH_SPACETIME +#include "caml/spacetime.h" +#endif +#include "caml/eventlog.h" /* Pointers into the minor heap. [Caml_state->young_base] @@ -145,7 +149,7 @@ void caml_set_minor_heap_size (asize_t bsz) CAMLassert (bsz % Page_size == 0); CAMLassert (bsz % sizeof (value) == 0); if (Caml_state->young_ptr != Caml_state->young_alloc_end){ - CAML_INSTR_INT ("force_minor/set_minor_heap_size@", 1); + CAML_EV_COUNTER (EV_C_FORCE_MINOR_SET_MINOR_HEAP_SIZE, 1); Caml_state->requested_minor_gc = 0; Caml_state->young_trigger = Caml_state->young_alloc_mid; caml_update_young_limit(); @@ -199,6 +203,7 @@ void caml_oldify_one (value v, value *p) if (hd == 0){ /* If already forwarded */ *p = Field (v, 0); /* then forward pointer is first field. */ }else{ + CAMLassert_young_header(hd); tag = Tag_hd (hd); if (tag < Infix_tag){ value field0; @@ -273,7 +278,7 @@ void caml_oldify_one (value v, value *p) } /* Test if the ephemeron is alive, everything outside minor heap is alive */ -static inline int ephe_check_alive_data(struct caml_ephe_ref_elt *re){ +Caml_inline int ephe_check_alive_data(struct caml_ephe_ref_elt *re){ mlsize_t i; value child; for (i = CAML_EPHE_FIRST_KEY; i < Wosize_val(re->ephe); i++){ @@ -352,20 +357,23 @@ void caml_empty_minor_heap (void) struct caml_ephe_ref_elt *re; if (Caml_state->young_ptr != Caml_state->young_alloc_end){ + CAMLassert_young_header(*(header_t*)Caml_state->young_ptr); if (caml_minor_gc_begin_hook != NULL) (*caml_minor_gc_begin_hook) (); - CAML_INSTR_SETUP (tmr, "minor"); prev_alloc_words = caml_allocated_words; Caml_state->in_minor_collection = 1; caml_gc_message (0x02, "<"); + CAML_EV_BEGIN(EV_MINOR_LOCAL_ROOTS); caml_oldify_local_roots(); - CAML_INSTR_TIME (tmr, "minor/local_roots"); + CAML_EV_END(EV_MINOR_LOCAL_ROOTS); + CAML_EV_BEGIN(EV_MINOR_REF_TABLES); for (r = Caml_state->ref_table->base; r < Caml_state->ref_table->ptr; r++) { caml_oldify_one (**r, *r); } - CAML_INSTR_TIME (tmr, "minor/ref_table"); + CAML_EV_END(EV_MINOR_REF_TABLES); + CAML_EV_BEGIN(EV_MINOR_COPY); caml_oldify_mopup (); - CAML_INSTR_TIME (tmr, "minor/copy"); + CAML_EV_END(EV_MINOR_COPY); /* Update the ephemerons */ for (re = Caml_state->ephe_ref_table->base; re < Caml_state->ephe_ref_table->ptr; re++){ @@ -384,7 +392,10 @@ void caml_empty_minor_heap (void) } } /* Update the OCaml finalise_last values */ + CAML_EV_BEGIN(EV_MINOR_UPDATE_WEAK); caml_final_update_minor_roots(); + /* Trigger memprofs callbacks for blocks in the minor heap. */ + caml_memprof_minor_update(); /* Run custom block finalisation of dead minor values */ for (elt = Caml_state->custom_table->base; elt < Caml_state->custom_table->ptr; elt++){ @@ -398,7 +409,8 @@ void caml_empty_minor_heap (void) if (final_fun != NULL) final_fun(v); } } - CAML_INSTR_TIME (tmr, "minor/update_weak"); + CAML_EV_END(EV_MINOR_UPDATE_WEAK); + CAML_EV_BEGIN(EV_MINOR_FINALIZED); Caml_state->stat_minor_words += Caml_state->young_alloc_end - Caml_state->young_ptr; caml_gc_clock += @@ -412,9 +424,10 @@ void caml_empty_minor_heap (void) caml_gc_message (0x02, ">"); Caml_state->in_minor_collection = 0; caml_final_empty_young (); - CAML_INSTR_TIME (tmr, "minor/finalized"); + CAML_EV_END(EV_MINOR_FINALIZED); Caml_state->stat_promoted_words += caml_allocated_words - prev_alloc_words; - CAML_INSTR_INT ("minor/promoted#", caml_allocated_words - prev_alloc_words); + CAML_EV_COUNTER (EV_C_MINOR_PROMOTED, + caml_allocated_words - prev_alloc_words); ++ Caml_state->stat_minor_collections; caml_memprof_renew_minor_sample(); if (caml_minor_gc_end_hook != NULL) (*caml_minor_gc_end_hook) (); @@ -435,7 +448,7 @@ void caml_empty_minor_heap (void) #ifdef CAML_INSTR extern uintnat caml_instr_alloc_jump; -#endif +#endif /*CAML_INSTR*/ /* Do a minor collection or a slice of major collection, call finalisation functions, etc. @@ -445,24 +458,29 @@ extern uintnat caml_instr_alloc_jump; CAMLexport void caml_gc_dispatch (void) { value *trigger = Caml_state->young_trigger; /* save old value of trigger */ -#ifdef CAML_INSTR - CAML_INSTR_SETUP(tmr, "dispatch"); - CAML_INSTR_TIME (tmr, "overhead"); - CAML_INSTR_INT ("alloc/jump#", caml_instr_alloc_jump); - caml_instr_alloc_jump = 0; -#endif + + CAML_EVENTLOG_DO({ + CAML_EV_COUNTER(EV_C_ALLOC_JUMP, caml_instr_alloc_jump); + caml_instr_alloc_jump = 0; + }); if (trigger == Caml_state->young_alloc_start || Caml_state->requested_minor_gc) { /* The minor heap is full, we must do a minor collection. */ /* reset the pointers first because the end hooks might allocate */ + CAML_EV_BEGIN(EV_MINOR); Caml_state->requested_minor_gc = 0; Caml_state->young_trigger = Caml_state->young_alloc_mid; caml_update_young_limit(); caml_empty_minor_heap (); /* The minor heap is empty, we can start a major collection. */ - if (caml_gc_phase == Phase_idle) caml_major_collection_slice (-1); - CAML_INSTR_TIME (tmr, "dispatch/minor"); + CAML_EV_END(EV_MINOR); + if (caml_gc_phase == Phase_idle) + { + CAML_EV_BEGIN(EV_MAJOR); + caml_major_collection_slice (-1); + CAML_EV_END(EV_MAJOR); + } } if (trigger != Caml_state->young_alloc_start || Caml_state->requested_major_slice) { @@ -470,15 +488,17 @@ CAMLexport void caml_gc_dispatch (void) Caml_state->requested_major_slice = 0; Caml_state->young_trigger = Caml_state->young_alloc_start; caml_update_young_limit(); + CAML_EV_BEGIN(EV_MAJOR); caml_major_collection_slice (-1); - CAML_INSTR_TIME (tmr, "dispatch/major"); + CAML_EV_END(EV_MAJOR); } } -/* Called by [Alloc_small] when [Caml_state->young_ptr] reaches +/* Called by young allocations when [Caml_state->young_ptr] reaches [Caml_state->young_limit]. We may have to either call memprof or the gc. */ -void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags) +void caml_alloc_small_dispatch (intnat wosize, int flags, + int nallocs, unsigned char* encoded_alloc_lens) { intnat whsize = Whsize_wosize (wosize); @@ -507,8 +527,13 @@ void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags) /* If not, then empty the minor heap, and check again for async callbacks. */ - CAML_INSTR_INT ("force_minor/alloc_small@", 1); + CAML_EV_COUNTER (EV_C_FORCE_MINOR_ALLOC_SMALL, 1); caml_gc_dispatch (); +#if defined(NATIVE_CODE) && defined(WITH_SPACETIME) + if (caml_young_ptr == caml_young_alloc_end) { + caml_spacetime_automatic_snapshot(); + } +#endif } /* Re-do the allocation: we now have enough space in the minor heap. */ @@ -517,7 +542,8 @@ void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags) /* Check if the allocated block has been sampled by memprof. */ if(Caml_state->young_ptr < caml_memprof_young_trigger){ if(flags & CAML_DO_TRACK) { - caml_memprof_track_young(tag, wosize, flags & CAML_FROM_CAML); + caml_memprof_track_young(wosize, flags & CAML_FROM_CAML, + nallocs, encoded_alloc_lens); /* Until the allocation actually takes place, the heap is in an invalid state (see comments in [caml_memprof_track_young]). Hence, very little heap operations are allowed before the actual allocation. @@ -543,7 +569,6 @@ CAMLexport value caml_check_urgent_gc (value extra_root) { if (Caml_state->requested_major_slice || Caml_state->requested_minor_gc){ CAMLparam1 (extra_root); - CAML_INSTR_INT ("force_minor/check_urgent_gc@", 1); caml_gc_dispatch(); CAMLdrop; } @@ -552,7 +577,8 @@ CAMLexport value caml_check_urgent_gc (value extra_root) static void realloc_generic_table (struct generic_table *tbl, asize_t element_size, - char * msg_intr_int, char *msg_threshold, char *msg_growing, char *msg_error) + ev_gc_counter ev_counter_name, + char *msg_threshold, char *msg_growing, char *msg_error) { CAMLassert (tbl->ptr == tbl->limit); CAMLassert (tbl->limit <= tbl->end); @@ -562,7 +588,7 @@ static void realloc_generic_table alloc_generic_table (tbl, Caml_state->minor_heap_wsz / 8, 256, element_size); }else if (tbl->limit == tbl->threshold){ - CAML_INSTR_INT (msg_intr_int, 1); + CAML_EV_COUNTER (ev_counter_name, 1); caml_gc_message (0x08, msg_threshold, 0); tbl->limit = tbl->end; caml_request_minor_gc (); @@ -589,7 +615,7 @@ void caml_realloc_ref_table (struct caml_ref_table *tbl) { realloc_generic_table ((struct generic_table *) tbl, sizeof (value *), - "request_minor/realloc_ref_table@", + EV_C_REQUEST_MINOR_REALLOC_REF_TABLE, "ref_table threshold crossed\n", "Growing ref_table to %" ARCH_INTNAT_PRINTF_FORMAT "dk bytes\n", "ref_table overflow"); @@ -599,7 +625,7 @@ void caml_realloc_ephe_ref_table (struct caml_ephe_ref_table *tbl) { realloc_generic_table ((struct generic_table *) tbl, sizeof (struct caml_ephe_ref_elt), - "request_minor/realloc_ephe_ref_table@", + EV_C_REQUEST_MINOR_REALLOC_EPHE_REF_TABLE, "ephe_ref_table threshold crossed\n", "Growing ephe_ref_table to %" ARCH_INTNAT_PRINTF_FORMAT "dk bytes\n", "ephe_ref_table overflow"); @@ -609,7 +635,7 @@ void caml_realloc_custom_table (struct caml_custom_table *tbl) { realloc_generic_table ((struct generic_table *) tbl, sizeof (struct caml_custom_elt), - "request_minor/realloc_custom_table@", + EV_C_REQUEST_MINOR_REALLOC_CUSTOM_TABLE, "custom_table threshold crossed\n", "Growing custom_table to %" ARCH_INTNAT_PRINTF_FORMAT "dk bytes\n", "custom_table overflow"); diff --git a/runtime/misc.c b/runtime/misc.c index c1534bc5..8aa0d090 100644 --- a/runtime/misc.c +++ b/runtime/misc.c @@ -206,89 +206,6 @@ int caml_runtime_warnings_active(void) return 1; } -#ifdef CAML_INSTR -/* Timers for profiling GC and allocation (experimental, Linux-only) */ - -#include -#include -#include - -struct caml_instr_block *caml_instr_log = NULL; -intnat caml_instr_starttime, caml_instr_stoptime; - -#define Get_time(p,i) ((p)->ts[(i)].tv_nsec + 1000000000 * (p)->ts[(i)].tv_sec) - -void caml_instr_init (void) -{ - char *s; - - caml_instr_starttime = 0; - s = caml_secure_getenv ("OCAML_INSTR_START"); - if (s != NULL) caml_instr_starttime = atol (s); - caml_instr_stoptime = LONG_MAX; - s = caml_secure_getenv ("OCAML_INSTR_STOP"); - if (s != NULL) caml_instr_stoptime = atol (s); -} - -void caml_instr_atexit (void) -{ - int i; - struct caml_instr_block *p, *prev, *next; - FILE *f = NULL; - char *fname; - - fname = caml_secure_getenv ("OCAML_INSTR_FILE"); - if (fname != NULL){ - char *mode = "a"; - char buf [1000]; - char *name = fname; - - if (name[0] == '@'){ - snprintf (buf, sizeof(buf), "%s.%lld", - name + 1, (long long) (getpid ())); - name = buf; - } - if (name[0] == '+'){ - mode = "a"; - name = name + 1; - }else if (name [0] == '>' || name[0] == '-'){ - mode = "w"; - name = name + 1; - } - f = fopen (name, mode); - } - - if (f != NULL){ - /* reverse the list */ - prev = NULL; - p = caml_instr_log; - while (p != NULL){ - next = p->next; - p->next = prev; - prev = p; - p = next; - } - caml_instr_log = prev; - fprintf (f, "==== OCAML INSTRUMENTATION DATA %s\n", OCAML_VERSION_STRING); - for (p = caml_instr_log; p != NULL; p = p->next){ - for (i = 0; i < p->index; i++){ - fprintf (f, "@@ %19ld %19ld %s\n", - (long) Get_time (p, i), - (long) Get_time(p, i+1), - p->tag[i+1]); - } - if (p->tag[0][0] != '\000'){ - fprintf (f, "@@ %19ld %19ld %s\n", - (long) Get_time (p, 0), - (long) Get_time(p, p->index), - p->tag[0]); - } - } - fclose (f); - } -} -#endif /* CAML_INSTR */ - int caml_find_code_fragment(char *pc, int *index, struct code_fragment **cf) { struct code_fragment *cfi; diff --git a/runtime/obj.c b/runtime/obj.c index d73595dc..20fe1e8e 100644 --- a/runtime/obj.c +++ b/runtime/obj.c @@ -153,6 +153,7 @@ CAMLprim value caml_obj_truncate (value v, value newsize) header_t hd = Hd_val (v); tag_t tag = Tag_hd (hd); color_t color = Color_hd (hd); + color_t frag_color = Is_young(v) ? 0 : Caml_black; mlsize_t wosize = Wosize_hd (hd); mlsize_t i; @@ -177,7 +178,7 @@ CAMLprim value caml_obj_truncate (value v, value newsize) look like a pointer because there may be some references to it in ref_table. */ Field (v, new_wosize) = - Make_header (Wosize_whsize (wosize-new_wosize), Abstract_tag, Caml_black); + Make_header (Wosize_whsize (wosize-new_wosize), Abstract_tag, frag_color); Hd_val (v) = Make_header_with_profinfo (new_wosize, tag, color, Profinfo_val(v)); return Val_unit; diff --git a/runtime/power.S b/runtime/power.S index 94983a6e..1933a10e 100644 --- a/runtime/power.S +++ b/runtime/power.S @@ -301,9 +301,8 @@ FUNCTION(caml_call_gc) lfdu 29, 8(11) lfdu 30, 8(11) lfdu 31, 8(11) - /* Return to caller, restarting the allocation */ + /* Return to caller, resuming the allocation */ lg 11, Caml_state(last_return_address) - addi 11, 11, -16 /* Restart the allocation (4 instructions) */ mtlr 11 /* For PPC64: restore the TOC that the caller saved at the usual place */ #ifdef TOC_SAVE @@ -411,8 +410,6 @@ FUNCTION(caml_raise_exception) /* Branch to handler */ bctr .L121: - li 0, 0 - stg 0, Caml_state(backtrace_pos) mr 27, 3 /* preserve exn bucket in callee-save reg */ /* arg1: exception bucket, already in r3 */ lg 4, Caml_state(last_return_address) /* arg2: PC of raise */ diff --git a/runtime/riscv.S b/runtime/riscv.S new file mode 100644 index 00000000..48e690e4 --- /dev/null +++ b/runtime/riscv.S @@ -0,0 +1,423 @@ +/**************************************************************************/ +/* */ +/* OCaml */ +/* */ +/* Nicolas Ojeda Bar */ +/* */ +/* Copyright 2016 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. */ +/* */ +/**************************************************************************/ + +/* Asm part of the runtime system, RISC-V processor, 64-bit mode */ +/* Must be preprocessed by cpp */ + +#define ARG_DOMAIN_STATE_PTR t0 +#define DOMAIN_STATE_PTR s0 +#define TRAP_PTR s1 +#define ALLOC_PTR s10 +#define ALLOC_LIMIT s11 +#define TMP t1 +#define ARG t2 + +#define STORE sd +#define LOAD ld + + .set domain_curr_field, 0 +#define DOMAIN_STATE(c_type, name) \ + .equ domain_field_caml_##name, domain_curr_field ; \ + .set domain_curr_field, domain_curr_field + 1 +#include "../runtime/caml/domain_state.tbl" +#undef DOMAIN_STATE + +#define Caml_state(var) (8*domain_field_caml_##var)(s0) + +#define FUNCTION(name) \ + .align 2; \ + .globl name; \ + .type name, @function; \ +name: + +#if defined(__PIC__) + .option pic +#define PLT(r) r@plt +#else + .option nopic +#define PLT(r) r +#endif + + .section .text +/* Invoke the garbage collector. */ + + .globl caml_system__code_begin +caml_system__code_begin: + +FUNCTION(caml_call_gc) +.Lcaml_call_gc: + /* Record return address */ + STORE ra, Caml_state(last_return_address) + /* Record lowest stack address */ + STORE sp, Caml_state(bottom_of_stack) + /* Set up stack space, saving return address */ + /* (1 reg for RA, 1 reg for FP, 21 allocatable int regs, + 20 caller-save float regs) * 8 */ + /* + 1 for alignment */ + addi sp, sp, -0x160 + STORE ra, 0x8(sp) + STORE s0, 0x0(sp) + /* Save allocatable integer registers on the stack, + in the order given in proc.ml */ + STORE a0, 0x10(sp) + STORE a1, 0x18(sp) + STORE a2, 0x20(sp) + STORE a3, 0x28(sp) + STORE a4, 0x30(sp) + STORE a5, 0x38(sp) + STORE a6, 0x40(sp) + STORE a7, 0x48(sp) + STORE s2, 0x50(sp) + STORE s3, 0x58(sp) + STORE s4, 0x60(sp) + STORE s5, 0x68(sp) + STORE s6, 0x70(sp) + STORE s7, 0x78(sp) + STORE s8, 0x80(sp) + STORE s9, 0x88(sp) + STORE t2, 0x90(sp) + STORE t3, 0x98(sp) + STORE t4, 0xa0(sp) + STORE t5, 0xa8(sp) + STORE t6, 0xb0(sp) + /* Save caller-save floating-point registers on the stack + (callee-saves are preserved by caml_garbage_collection) */ + fsd ft0, 0xb8(sp) + fsd ft1, 0xc0(sp) + fsd ft2, 0xc8(sp) + fsd ft3, 0xd0(sp) + fsd ft4, 0xd8(sp) + fsd ft5, 0xe0(sp) + fsd ft6, 0xe8(sp) + fsd ft7, 0xf0(sp) + fsd fa0, 0xf8(sp) + fsd fa1, 0x100(sp) + fsd fa2, 0x108(sp) + fsd fa3, 0x110(sp) + fsd fa4, 0x118(sp) + fsd fa5, 0x120(sp) + fsd fa6, 0x128(sp) + fsd fa7, 0x130(sp) + fsd ft8, 0x138(sp) + fsd ft9, 0x140(sp) + fsd ft9, 0x148(sp) + fsd ft10, 0x150(sp) + fsd ft11, 0x158(sp) + /* Store pointer to saved integer registers in caml_gc_regs */ + addi TMP, sp, 0x10 + STORE TMP, Caml_state(gc_regs) + /* Save current allocation pointer for debugging purposes */ + STORE ALLOC_PTR, Caml_state(young_ptr) + /* Save trap pointer in case an exception is raised during GC */ + STORE TRAP_PTR, Caml_state(exception_pointer) + /* Call the garbage collector */ + call PLT(caml_garbage_collection) + /* Restore registers */ + LOAD a0, 0x10(sp) + LOAD a1, 0x18(sp) + LOAD a2, 0x20(sp) + LOAD a3, 0x28(sp) + LOAD a4, 0x30(sp) + LOAD a5, 0x38(sp) + LOAD a6, 0x40(sp) + LOAD a7, 0x48(sp) + LOAD s2, 0x50(sp) + LOAD s3, 0x58(sp) + LOAD s4, 0x60(sp) + LOAD s5, 0x68(sp) + LOAD s6, 0x70(sp) + LOAD s7, 0x78(sp) + LOAD s8, 0x80(sp) + LOAD s9, 0x88(sp) + LOAD t2, 0x90(sp) + LOAD t3, 0x98(sp) + LOAD t4, 0xa0(sp) + LOAD t5, 0xa8(sp) + LOAD t6, 0xb0(sp) + fld ft0, 0xb8(sp) + fld ft1, 0xc0(sp) + fld ft2, 0xc8(sp) + fld ft3, 0xd0(sp) + fld ft4, 0xd8(sp) + fld ft5, 0xe0(sp) + fld ft6, 0xe8(sp) + fld ft7, 0xf0(sp) + fld fa0, 0xf8(sp) + fld fa1, 0x100(sp) + fld fa2, 0x108(sp) + fld fa3, 0x110(sp) + fld fa4, 0x118(sp) + fld fa5, 0x120(sp) + fld fa6, 0x128(sp) + fld fa7, 0x130(sp) + fld ft8, 0x138(sp) + fld ft9, 0x140(sp) + fld ft9, 0x148(sp) + fld ft10, 0x150(sp) + fld ft11, 0x158(sp) + /* Reload new allocation pointer and allocation limit */ + LOAD ALLOC_PTR, Caml_state(young_ptr) + LOAD ALLOC_LIMIT, Caml_state(young_limit) + /* Free stack space and return to caller */ + LOAD ra, 0x8(sp) + LOAD s0, 0x0(sp) + addi sp, sp, 0x160 + ret + .size caml_call_gc, .-caml_call_gc + +/* Call a C function from OCaml */ +/* Function to call is in ARG */ + +FUNCTION(caml_c_call) + /* Preserve return address in callee-save register s2 */ + mv s2, ra + /* Record lowest stack address and return address */ + STORE ra, Caml_state(last_return_address) + STORE sp, Caml_state(bottom_of_stack) + /* Make the exception handler alloc ptr available to the C code */ + STORE ALLOC_PTR, Caml_state(young_ptr) + STORE TRAP_PTR, Caml_state(exception_pointer) + /* Call the function */ + jalr ARG + /* Reload alloc ptr and alloc limit */ + LOAD ALLOC_PTR, Caml_state(young_ptr) + LOAD ALLOC_LIMIT, Caml_state(young_limit) + /* Return */ + jr s2 + .size caml_c_call, .-caml_c_call + +/* Raise an exception from OCaml */ +FUNCTION(caml_raise_exn) + /* Test if backtrace is active */ + LOAD TMP, Caml_state(backtrace_active) + bnez TMP, 2f +1: /* Cut stack at current trap handler */ + mv sp, TRAP_PTR + /* Pop previous handler and jump to it */ + LOAD TMP, 8(sp) + LOAD TRAP_PTR, 0(sp) + addi sp, sp, 16 + jr TMP +2: /* Preserve exception bucket in callee-save register s2 */ + mv s2, a0 + /* Stash the backtrace */ + mv a1, ra + mv a2, sp + mv a3, TRAP_PTR + call PLT(caml_stash_backtrace) + /* Restore exception bucket and raise */ + mv a0, s2 + j 1b + .size caml_raise_exn, .-caml_raise_exn + + .globl caml_reraise_exn + .type caml_reraise_exn, @function + +/* Raise an exception from C */ + +FUNCTION(caml_raise_exception) + mv DOMAIN_STATE_PTR, a0 + mv a0, a1 + LOAD TRAP_PTR, Caml_state(exception_pointer) + LOAD ALLOC_PTR, Caml_state(young_ptr) + LOAD ALLOC_LIMIT, Caml_state(young_limit) + LOAD TMP, Caml_state(backtrace_active) + bnez TMP, 2f +1: /* Cut stack at current trap handler */ + mv sp, TRAP_PTR + LOAD TMP, 8(sp) + LOAD TRAP_PTR, 0(sp) + addi sp, sp, 16 + jr TMP +2: /* Preserve exception bucket in callee-save register s2 */ + mv s2, a0 + LOAD a1, Caml_state(last_return_address) + LOAD a2, Caml_state(bottom_of_stack) + mv a3, TRAP_PTR + call PLT(caml_stash_backtrace) + mv a0, s2 + j 1b + .size caml_raise_exception, .-caml_raise_exception + +/* Start the OCaml program */ + +FUNCTION(caml_start_program) + mv ARG_DOMAIN_STATE_PTR, a0 + la ARG, caml_program + /* Code shared with caml_callback* */ + /* Address of OCaml code to call is in ARG */ + /* Arguments to the OCaml code are in a0 ... a7 */ +.Ljump_to_caml: + /* Set up stack frame and save callee-save registers */ + addi sp, sp, -0xd0 + STORE ra, 0xc0(sp) + STORE s0, 0x0(sp) + STORE s1, 0x8(sp) + STORE s2, 0x10(sp) + STORE s3, 0x18(sp) + STORE s4, 0x20(sp) + STORE s5, 0x28(sp) + STORE s6, 0x30(sp) + STORE s7, 0x38(sp) + STORE s8, 0x40(sp) + STORE s9, 0x48(sp) + STORE s10, 0x50(sp) + STORE s11, 0x58(sp) + fsd fs0, 0x60(sp) + fsd fs1, 0x68(sp) + fsd fs2, 0x70(sp) + fsd fs3, 0x78(sp) + fsd fs4, 0x80(sp) + fsd fs5, 0x88(sp) + fsd fs6, 0x90(sp) + fsd fs7, 0x98(sp) + fsd fs8, 0xa0(sp) + fsd fs9, 0xa8(sp) + fsd fs10, 0xb0(sp) + fsd fs11, 0xb8(sp) + addi sp, sp, -32 + /* Load domain state pointer from argument */ + mv DOMAIN_STATE_PTR, ARG_DOMAIN_STATE_PTR + /* Setup a callback link on the stack */ + LOAD TMP, Caml_state(bottom_of_stack) + STORE TMP, 0(sp) + LOAD TMP, Caml_state(last_return_address) + STORE TMP, 8(sp) + LOAD TMP, Caml_state(gc_regs) + STORE TMP, 16(sp) + /* set up a trap frame */ + addi sp, sp, -16 + LOAD TMP, Caml_state(exception_pointer) + STORE TMP, 0(sp) + lla TMP, .Ltrap_handler + STORE TMP, 8(sp) + mv TRAP_PTR, sp + LOAD ALLOC_PTR, Caml_state(young_ptr) + LOAD ALLOC_LIMIT, Caml_state(young_limit) + STORE x0, Caml_state(last_return_address) + jalr ARG +.Lcaml_retaddr: /* pop trap frame, restoring caml_exception_pointer */ + LOAD TMP, 0(sp) + STORE TMP, Caml_state(exception_pointer) + addi sp, sp, 16 +.Lreturn_result: /* pop callback link, restoring global variables */ + LOAD TMP, 0(sp) + STORE TMP, Caml_state(bottom_of_stack) + LOAD TMP, 8(sp) + STORE TMP, Caml_state(last_return_address) + LOAD TMP, 16(sp) + STORE TMP, Caml_state(gc_regs) + addi sp, sp, 32 + /* Update allocation pointer */ + STORE ALLOC_PTR, Caml_state(young_ptr) + /* reload callee-save registers and return */ + LOAD ra, 0xc0(sp) + LOAD s0, 0x0(sp) + LOAD s1, 0x8(sp) + LOAD s2, 0x10(sp) + LOAD s3, 0x18(sp) + LOAD s4, 0x20(sp) + LOAD s5, 0x28(sp) + LOAD s6, 0x30(sp) + LOAD s7, 0x38(sp) + LOAD s8, 0x40(sp) + LOAD s9, 0x48(sp) + LOAD s10, 0x50(sp) + LOAD s11, 0x58(sp) + fld fs0, 0x60(sp) + fld fs1, 0x68(sp) + fld fs2, 0x70(sp) + fld fs3, 0x78(sp) + fld fs4, 0x80(sp) + fld fs5, 0x88(sp) + fld fs6, 0x90(sp) + fld fs7, 0x98(sp) + fld fs8, 0xa0(sp) + fld fs9, 0xa8(sp) + fld fs10, 0xb0(sp) + fld fs11, 0xb8(sp) + addi sp, sp, 0xd0 + ret + .type .Lcaml_retaddr, @function + .size .Lcaml_retaddr, .-.Lcaml_retaddr + .size caml_start_program, .-caml_start_program + + .align 2 +.Ltrap_handler: + STORE TRAP_PTR, Caml_state(exception_pointer) + ori a0, a0, 2 + j .Lreturn_result + .type .Ltrap_handler, @function + .size .Ltrap_handler, .-.Ltrap_handler + +/* Callback from C to OCaml */ + +FUNCTION(caml_callback_asm) + /* Initial shuffling of arguments */ + /* a0 = Caml_state, a1 = closure, (a2) = args */ + mv ARG_DOMAIN_STATE_PTR, a0 + LOAD a0, 0(a2) /* a0 = first arg */ + /* a1 = closure environment */ + LOAD ARG, 0(a1) /* code pointer */ + j .Ljump_to_caml + .size caml_callback_asm, .-caml_callback_asm + +FUNCTION(caml_callback2_asm) + /* Initial shuffling of arguments */ + /* a0 = Caml_state, a1 = closure, (a2) = args */ + mv ARG_DOMAIN_STATE_PTR, a0 + mv TMP, a1 + LOAD a0, 0(a2) + LOAD a1, 8(a2) + mv a2, TMP + la ARG, caml_apply2 + j .Ljump_to_caml + .size caml_callback2_asm, .-caml_callback2_asm + +FUNCTION(caml_callback3_asm) + /* Initial shuffling of arguments */ + /* a0 = Caml_state, a1 = closure, (a2) = args */ + mv ARG_DOMAIN_STATE_PTR, a0 + mv a3, a1 + LOAD a0, 0(a2) + LOAD a1, 8(a2) + LOAD a2, 16(a2) + la ARG, caml_apply3 + j .Ljump_to_caml + .size caml_callback3_asm, .-caml_callback3_asm + +FUNCTION(caml_ml_array_bound_error) + /* Load address of [caml_array_bound_error] in ARG */ + la ARG, caml_array_bound_error + /* Call that function */ + tail caml_c_call + .size caml_ml_array_bound_error, .-caml_ml_array_bound_error + + .globl caml_system__code_end +caml_system__code_end: + +/* GC roots for callback */ + + .section .data + .align 3 + .globl caml_system__frametable + .type caml_system__frametable, @object +caml_system__frametable: + .quad 1 /* one descriptor */ + .quad .Lcaml_retaddr /* return address into callback */ + .short -1 /* negative frame size => use callback link */ + .short 0 /* no roots */ + .align 3 + .size caml_system__frametable, .-caml_system__frametable diff --git a/runtime/roots_byt.c b/runtime/roots_byt.c index a0b6e624..bd549f14 100644 --- a/runtime/roots_byt.c +++ b/runtime/roots_byt.c @@ -27,6 +27,7 @@ #include "caml/roots.h" #include "caml/stacks.h" #include "caml/memprof.h" +#include "caml/eventlog.h" CAMLexport void (*caml_scan_roots_hook) (scanning_action f) = NULL; @@ -58,7 +59,7 @@ void caml_oldify_local_roots (void) /* Finalised values */ caml_final_oldify_young_roots (); /* Memprof */ - caml_memprof_scan_roots (&caml_oldify_one); + caml_memprof_oldify_young_roots (); /* Hook */ if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(&caml_oldify_one); } @@ -81,26 +82,31 @@ intnat caml_darken_all_roots_slice (intnat work) ignored and [caml_darken_all_roots_slice] does nothing. */ void caml_do_roots (scanning_action f, int do_globals) { - CAML_INSTR_SETUP (tmr, "major_roots"); /* Global variables */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_GLOBAL); f(caml_global_data, &caml_global_data); - CAML_INSTR_TIME (tmr, "major_roots/global"); + CAML_EV_END(EV_MAJOR_ROOTS_GLOBAL); /* The stack and the local C roots */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_LOCAL); caml_do_local_roots(f, Caml_state->extern_sp, Caml_state->stack_high, Caml_state->local_roots); - CAML_INSTR_TIME (tmr, "major_roots/local"); + CAML_EV_END(EV_MAJOR_ROOTS_LOCAL); /* Global C roots */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_C); caml_scan_global_roots(f); - CAML_INSTR_TIME (tmr, "major_roots/C"); + CAML_EV_END(EV_MAJOR_ROOTS_C); /* Finalised values */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_FINALISED); caml_final_do_roots (f); - CAML_INSTR_TIME (tmr, "major_roots/finalised"); + CAML_EV_END(EV_MAJOR_ROOTS_FINALISED); /* Memprof */ - caml_memprof_scan_roots (f); - CAML_INSTR_TIME (tmr, "major_roots/memprof"); + CAML_EV_BEGIN(EV_MAJOR_ROOTS_MEMPROF); + caml_memprof_do_roots (f); + CAML_EV_END(EV_MAJOR_ROOTS_MEMPROF); /* Hook */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_HOOK); if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(f); - CAML_INSTR_TIME (tmr, "major_roots/hook"); + CAML_EV_END(EV_MAJOR_ROOTS_HOOK); } CAMLexport void caml_do_local_roots (scanning_action f, value *stack_low, diff --git a/runtime/roots_nat.c b/runtime/roots_nat.c index d8feb1bd..ec66e2db 100644 --- a/runtime/roots_nat.c +++ b/runtime/roots_nat.c @@ -27,6 +27,7 @@ #include "caml/stack.h" #include "caml/roots.h" #include "caml/memprof.h" +#include "caml/eventlog.h" #include #include @@ -78,14 +79,24 @@ static link* frametables_list_tail(link *list) { } static frame_descr * next_frame_descr(frame_descr * d) { - uintnat nextd; - nextd = - ((uintnat)d + - sizeof(char *) + sizeof(short) + sizeof(short) + - sizeof(short) * d->num_live + sizeof(frame_descr *) - 1) - & -sizeof(frame_descr *); - if (d->frame_size & 1) nextd += sizeof(void *); /* pointer to debuginfo */ - return((frame_descr *) nextd); + unsigned char num_allocs = 0, *p; + CAMLassert(d->retaddr >= 4096); + /* Skip to end of live_ofs */ + p = (unsigned char*)&d->live_ofs[d->num_live]; + /* Skip alloc_lengths if present */ + if (d->frame_size & 2) { + num_allocs = *p; + p += num_allocs + 1; + } + /* Skip debug info if present */ + if (d->frame_size & 1) { + /* Align to 32 bits */ + p = Align_to(p, uint32_t); + p += sizeof(uint32_t) * (d->frame_size & 2 ? num_allocs : 1); + } + /* Align to word size */ + p = Align_to(p, void*); + return ((frame_descr*) p); } static void fill_hashtable(link *frametables) { @@ -324,7 +335,7 @@ void caml_oldify_local_roots (void) /* Finalised values */ caml_final_oldify_young_roots (); /* Memprof */ - caml_memprof_scan_roots (&caml_oldify_one); + caml_memprof_oldify_young_roots (); /* Hook */ if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(&caml_oldify_one); } @@ -351,7 +362,7 @@ intnat caml_darken_all_roots_slice (intnat work) static int do_resume = 0; static mlsize_t roots_count = 0; intnat remaining_work = work; - CAML_INSTR_SETUP (tmr, ""); + CAML_EV_BEGIN(EV_MAJOR_MARK_GLOBAL_ROOTS_SLICE); /* If the loop was started in a previous call, resume it. */ if (do_resume) goto resume; @@ -381,7 +392,7 @@ intnat caml_darken_all_roots_slice (intnat work) suspend: /* Do this in both cases. */ - CAML_INSTR_TIME (tmr, "major/mark/global_roots_slice"); + CAML_EV_END(EV_MAJOR_MARK_GLOBAL_ROOTS_SLICE); return remaining_work; } @@ -390,8 +401,8 @@ void caml_do_roots (scanning_action f, int do_globals) int i, j; value * glob; link *lnk; - CAML_INSTR_SETUP (tmr, "major_roots"); + CAML_EV_BEGIN(EV_MAJOR_ROOTS_DYNAMIC_GLOBAL); if (do_globals){ /* The global roots */ for (i = 0; caml_globals[i] != 0; i++) { @@ -409,24 +420,29 @@ void caml_do_roots (scanning_action f, int do_globals) } } } - CAML_INSTR_TIME (tmr, "major_roots/dynamic_global"); + CAML_EV_END(EV_MAJOR_ROOTS_DYNAMIC_GLOBAL); /* The stack and local roots */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_LOCAL); caml_do_local_roots(f, Caml_state->bottom_of_stack, Caml_state->last_return_address, Caml_state->gc_regs, Caml_state->local_roots); - CAML_INSTR_TIME (tmr, "major_roots/local"); + CAML_EV_END(EV_MAJOR_ROOTS_LOCAL); /* Global C roots */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_C); caml_scan_global_roots(f); - CAML_INSTR_TIME (tmr, "major_roots/C"); + CAML_EV_END(EV_MAJOR_ROOTS_C); /* Finalised values */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_FINALISED); caml_final_do_roots (f); - CAML_INSTR_TIME (tmr, "major_roots/finalised"); + CAML_EV_END(EV_MAJOR_ROOTS_FINALISED); /* Memprof */ - caml_memprof_scan_roots (f); - CAML_INSTR_TIME (tmr, "major_roots/memprof"); + CAML_EV_BEGIN(EV_MAJOR_ROOTS_MEMPROF); + caml_memprof_do_roots (f); + CAML_EV_END(EV_MAJOR_ROOTS_MEMPROF); /* Hook */ + CAML_EV_BEGIN(EV_MAJOR_ROOTS_HOOK); if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(f); - CAML_INSTR_TIME (tmr, "major_roots/hook"); + CAML_EV_END(EV_MAJOR_ROOTS_HOOK); } void caml_do_local_roots(scanning_action f, char * bottom_of_stack, diff --git a/runtime/s390x.S b/runtime/s390x.S index 0ae3f82a..aab63e9b 100644 --- a/runtime/s390x.S +++ b/runtime/s390x.S @@ -183,8 +183,6 @@ caml_raise_exception: /* Branch to handler */ br %r1; .L112: - lgfi %r0, 0 - stg %r0, Caml_state(backtrace_pos) ldgr %f15,%r2 /* preserve exn bucket in callee-save reg */ /* arg1: exception bucket, already in r2 */ lg %r3, Caml_state(last_return_address) /* arg2: PC of raise */ diff --git a/runtime/signals.c b/runtime/signals.c index 10e3b1ed..57bb3fc7 100644 --- a/runtime/signals.c +++ b/runtime/signals.c @@ -325,7 +325,7 @@ exception: } CAMLno_tsan /* The access to [caml_something_to_do] is not synchronized. */ -static inline value process_pending_actions_with_root_exn(value extra_root) +Caml_inline value process_pending_actions_with_root_exn(value extra_root) { if (caml_something_to_do) { CAMLparam1(extra_root); diff --git a/runtime/signals_nat.c b/runtime/signals_nat.c index 01729839..fc5a77f8 100644 --- a/runtime/signals_nat.c +++ b/runtime/signals_nat.c @@ -69,29 +69,33 @@ extern char caml_system__code_begin, caml_system__code_end; void caml_garbage_collection(void) { - /* TEMPORARY: if we have just sampled an allocation in native mode, - we simply renew the sample to ignore it. Otherwise, renewing now - will not have any effect on the sampling distribution, because of - the memorylessness of the Bernoulli process. - - FIXME: if the sampling rate is 1, this leads to infinite loop, - because we are using a binomial distribution in [memprof.c]. This - will go away when the sampling of natively allocated blocks will - be correctly implemented. - */ - caml_memprof_renew_minor_sample(); - if (Caml_state->requested_major_slice || Caml_state->requested_minor_gc || - Caml_state->young_ptr - Caml_state->young_trigger < Max_young_whsize){ - caml_gc_dispatch (); + frame_descr* d; + intnat allocsz = 0, i, nallocs; + unsigned char* alloc_len; + + { /* Find the frame descriptor for the current allocation */ + uintnat h = Hash_retaddr(Caml_state->last_return_address); + while (1) { + d = caml_frame_descriptors[h]; + if (d->retaddr == Caml_state->last_return_address) break; + h = (h + 1) & caml_frame_descriptors_mask; + } + /* Must be an allocation frame */ + CAMLassert(d && d->frame_size != 0xFFFF && (d->frame_size & 2)); } -#ifdef WITH_SPACETIME - if (Caml_state->young_ptr == Caml_state->young_alloc_end) { - caml_spacetime_automatic_snapshot(); + /* Compute the total allocation size at this point, + including allocations combined by Comballoc */ + alloc_len = (unsigned char*)(&d->live_ofs[d->num_live]); + nallocs = *alloc_len++; + for (i = 0; i < nallocs; i++) { + allocsz += Whsize_wosize(Wosize_encoded_alloc_len(alloc_len[i])); } -#endif + /* We have computed whsize (including header), but need wosize (without) */ + allocsz -= 1; - caml_raise_if_exception(caml_do_pending_actions_exn()); + caml_alloc_small_dispatch(allocsz, CAML_DO_TRACK | CAML_FROM_CAML, + nallocs, alloc_len); } DECLARE_SIGNAL_HANDLER(handle_signal) diff --git a/runtime/spacetime_nat.c b/runtime/spacetime_nat.c index 1dce654b..7e85e96e 100644 --- a/runtime/spacetime_nat.c +++ b/runtime/spacetime_nat.c @@ -109,10 +109,8 @@ static const uintnat chunk_size = 1024 * 1024; #ifdef _WIN32 #define strdup_os wcsdup -#define snprintf_os _snwprintf #else #define strdup_os strdup -#define snprintf_os snprintf #endif static void reinitialise_free_node_block(void) diff --git a/runtime/startup_aux.c b/runtime/startup_aux.c index d265ac69..5db9f480 100644 --- a/runtime/startup_aux.c +++ b/runtime/startup_aux.c @@ -28,6 +28,7 @@ #endif #include "caml/osdeps.h" #include "caml/startup_aux.h" +#include "caml/memprof.h" #ifdef _WIN32 @@ -189,6 +190,7 @@ CAMLexport void caml_shutdown(void) call_registered_value("Pervasives.do_at_exit"); call_registered_value("Thread.at_shutdown"); caml_finalise_heap(); + caml_memprof_shutdown(); caml_free_locale(); #ifndef NATIVE_CODE caml_free_shared_libs(); diff --git a/runtime/startup_byt.c b/runtime/startup_byt.c index 3fcad7db..60ffea77 100644 --- a/runtime/startup_byt.c +++ b/runtime/startup_byt.c @@ -35,6 +35,7 @@ #include "caml/debugger.h" #include "caml/domain.h" #include "caml/dynlink.h" +#include "caml/eventlog.h" #include "caml/exec.h" #include "caml/fail.h" #include "caml/fix_code.h" @@ -70,6 +71,17 @@ static char magicstr[EXEC_MAGIC_LENGTH+1]; static int print_magic = 0; +/* Print the specified error message followed by an end-of-line and exit */ +static void error(char *msg, ...) +{ + va_list ap; + va_start(ap, msg); + vfprintf (stderr, msg, ap); + va_end(ap); + fprintf(stderr, "\n"); + exit(127); +} + /* Read the trailer of a bytecode file */ static void fixup_endianness_trailer(uint32_t * p) @@ -301,8 +313,7 @@ static int parse_command_line(char_os **argv) exit(0); break; default: - fprintf(stderr, "unknown option %s", caml_stat_strdup_of_os(argv[i])); - exit(127); + error("unknown option %s", caml_stat_strdup_of_os(argv[i])); } } return i; @@ -345,6 +356,7 @@ CAMLexport void caml_main(char_os **argv) caml_verb_gc = 0x3F; #endif caml_parse_ocamlrunparam(); + CAML_EVENTLOG_INIT(); #ifdef DEBUG caml_gc_message (-1, "### OCaml runtime: debug mode ###\n"); #endif @@ -382,31 +394,27 @@ CAMLexport void caml_main(char_os **argv) if (fd < 0) { pos = parse_command_line(argv); if (argv[pos] == 0) { - fprintf(stderr, "no bytecode file specified"); - exit(127); + error("no bytecode file specified"); } exe_name = argv[pos]; fd = caml_attempt_open(&exe_name, &trail, 1); switch(fd) { case FILE_NOT_FOUND: - fprintf(stderr, "cannot find file '%s'", + error("cannot find file '%s'", caml_stat_strdup_of_os(argv[pos])); - exit(127); break; case BAD_BYTECODE: - fprintf(stderr, + error( "the file '%s' is not a bytecode executable file", caml_stat_strdup_of_os(exe_name)); - exit(127); break; case WRONG_MAGIC: - fprintf(stderr, + error( "the file '%s' has not the right magic number: "\ "expected %s, got %s", caml_stat_strdup_of_os(exe_name), EXEC_MAGIC, magicstr); - exit(127); break; } } @@ -487,6 +495,7 @@ CAMLexport value caml_startup_code_exn( caml_verb_gc = 0x3F; #endif caml_parse_ocamlrunparam(); + CAML_EVENTLOG_INIT(); #ifdef DEBUG caml_gc_message (-1, "### OCaml runtime: debug mode ###\n"); #endif diff --git a/runtime/startup_nat.c b/runtime/startup_nat.c index 91ff81b3..725598f6 100644 --- a/runtime/startup_nat.c +++ b/runtime/startup_nat.c @@ -24,6 +24,7 @@ #include "caml/custom.h" #include "caml/debugger.h" #include "caml/domain.h" +#include "caml/eventlog.h" #include "caml/fail.h" #include "caml/freelist.h" #include "caml/gc.h" @@ -116,6 +117,7 @@ value caml_startup_common(char_os **argv, int pooling) caml_verb_gc = 0x3F; #endif caml_parse_ocamlrunparam(); + CAML_EVENTLOG_INIT(); #ifdef DEBUG caml_gc_message (-1, "### OCaml runtime: debug mode ###\n"); #endif diff --git a/runtime/sys.c b/runtime/sys.c index ab4704e5..4da107a9 100644 --- a/runtime/sys.c +++ b/runtime/sys.c @@ -151,7 +151,6 @@ CAMLprim value caml_sys_exit(value retcode_v) #ifndef NATIVE_CODE caml_debugger(PROGRAM_EXIT, Val_unit); #endif - caml_instr_atexit (); if (caml_cleanup_on_exit) caml_shutdown(); #ifdef _WIN32 diff --git a/runtime/weak.c b/runtime/weak.c index 9fda2166..85315263 100644 --- a/runtime/weak.c +++ b/runtime/weak.c @@ -27,6 +27,7 @@ #include "caml/weak.h" #include "caml/minor_gc.h" #include "caml/signals.h" +#include "caml/eventlog.h" value caml_ephe_list_head = 0; @@ -61,7 +62,7 @@ CAMLexport mlsize_t caml_ephemeron_num_keys(value eph) /** The minor heap is considered alive. */ #if defined (NATIVE_CODE) && defined (NO_NAKED_POINTERS) /** Outside minor and major heap, x must be black. */ -static inline int Is_Dead_during_clean(value x) +Caml_inline int Is_Dead_during_clean(value x) { CAMLassert (x != caml_ephe_none); CAMLassert (caml_gc_phase == Phase_clean); @@ -70,20 +71,20 @@ static inline int Is_Dead_during_clean(value x) /** The minor heap doesn't have to be marked, outside they should already be black */ -static inline int Must_be_Marked_during_mark(value x) +Caml_inline int Must_be_Marked_during_mark(value x) { CAMLassert (x != caml_ephe_none); CAMLassert (caml_gc_phase == Phase_mark); return Is_block (x) && !Is_young (x); } #else -static inline int Is_Dead_during_clean(value x) +Caml_inline int Is_Dead_during_clean(value x) { CAMLassert (x != caml_ephe_none); CAMLassert (caml_gc_phase == Phase_clean); return Is_block (x) && Is_in_heap (x) && Is_white_val(x); } -static inline int Must_be_Marked_during_mark(value x) +Caml_inline int Must_be_Marked_during_mark(value x) { CAMLassert (x != caml_ephe_none); CAMLassert (caml_gc_phase == Phase_mark); @@ -170,7 +171,7 @@ static void do_check_key_clean(value ar, mlsize_t offset) /* If we are in Phase_clean we need to do as if the key is empty when it will be cleaned during this phase */ -static inline int is_ephe_key_none(value ar, mlsize_t offset) +Caml_inline int is_ephe_key_none(value ar, mlsize_t offset) { value elt = Field (ar, offset); if (elt == caml_ephe_none){ @@ -355,7 +356,7 @@ CAMLprim value caml_ephe_get_data (value ar) } -static inline void copy_value(value src, value dst) +Caml_inline void copy_value(value src, value dst) { if (Tag_val (src) < No_scan_tag){ mlsize_t i; @@ -408,7 +409,7 @@ CAMLexport int caml_ephemeron_get_key_copy(value ar, mlsize_t offset, CAMLassert(loop < 10); if(8 == loop){ /** One minor gc must be enough */ elt = Val_unit; - CAML_INSTR_INT ("force_minor/weak@", 1); + CAML_EV_COUNTER (EV_C_FORCE_MINOR_WEAK, 1); caml_minor_collection (); } else { /* cases where loop is between 0 to 7 and where loop is equal to 9 */ @@ -463,7 +464,7 @@ CAMLexport int caml_ephemeron_get_data_copy (value ar, value *data) CAMLassert(loop < 10); if(8 == loop){ /** One minor gc must be enough */ elt = Val_unit; - CAML_INSTR_INT ("force_minor/weak@", 1); + CAML_EV_COUNTER (EV_C_FORCE_MINOR_WEAK, 1); caml_minor_collection (); } else { /* cases where loop is between 0 to 7 and where loop is equal to 9 */ @@ -530,8 +531,12 @@ CAMLexport void caml_ephemeron_blit_key(value ars, mlsize_t offset_s, offset_d += CAML_EPHE_FIRST_KEY; if (caml_gc_phase == Phase_clean){ - caml_ephe_clean(ars); - caml_ephe_clean(ard); + caml_ephe_clean_partial(ars, offset_s, offset_s + length); + /* We don't need to clean the keys that are about to be overwritten, + except where cleaning them could result in releasing the data, + which can't happen if data is already released. */ + if (Field (ard, CAML_EPHE_DATA_OFFSET) != caml_ephe_none) + caml_ephe_clean_partial(ard, offset_d, offset_d + length); } if (offset_d < offset_s){ for (i = 0; i < length; i++){ diff --git a/runtime/win32.c b/runtime/win32.c index 059e8eb0..9c5f7fc2 100644 --- a/runtime/win32.c +++ b/runtime/win32.c @@ -683,33 +683,41 @@ wchar_t * caml_executable_name(void) /* snprintf emulation */ -#if defined(_WIN32) && !defined(_UCRT) -int caml_snprintf(char * buf, size_t size, const char * format, ...) -{ - int len; - va_list args; - - if (size > 0) { - va_start(args, format); - len = _vsnprintf(buf, size, format, args); - va_end(args); - if (len >= 0 && len < size) { - /* [len] characters were stored in [buf], - a null-terminator was appended. */ - return len; - } - /* [size] characters were stored in [buf], without null termination. - Put a null terminator, truncating the output. */ - buf[size - 1] = 0; - } - /* Compute the actual length of output, excluding null terminator */ - va_start(args, format); - len = _vscprintf(format, args); - va_end(args); - return len; +#define CAML_SNPRINTF(_vsnprintf, _vscprintf) \ +{ \ + int len; \ + va_list args; \ +\ + if (size > 0) { \ + va_start(args, format); \ + len = _vsnprintf(buf, size, format, args); \ + va_end(args); \ + if (len >= 0 && len < size) { \ + /* [len] characters were stored in [buf], \ + a null-terminator was appended. */ \ + return len; \ + } \ + /* [size] characters were stored in [buf], without null termination. \ + Put a null terminator, truncating the output. */ \ + buf[size - 1] = 0; \ + } \ + /* Compute the actual length of output, excluding null terminator */ \ + va_start(args, format); \ + len = _vscprintf(format, args); \ + va_end(args); \ + return len; \ } + +#ifndef _UCRT +int caml_snprintf(char * buf, size_t size, const char * format, ...) +CAML_SNPRINTF(_vsnprintf, _vscprintf) #endif +int caml_snwprintf(wchar_t * buf, size_t size, const wchar_t * format, ...) +CAML_SNPRINTF(_vsnwprintf, _vscwprintf) + +#undef CAML_SNPRINTF + wchar_t *caml_secure_getenv (wchar_t const *var) { /* Win32 doesn't have a notion of setuid bit, so getenv is safe. */ @@ -888,7 +896,7 @@ CAMLexport value caml_copy_string_of_utf16(const wchar_t *s) return v; } -CAMLexport inline wchar_t* caml_stat_strdup_to_utf16(const char *s) +CAMLexport wchar_t* caml_stat_strdup_to_utf16(const char *s) { wchar_t * ws; int retcode; diff --git a/stdlib/.depend b/stdlib/.depend index 458c478a..2c167666 100644 --- a/stdlib/.depend +++ b/stdlib/.depend @@ -276,13 +276,16 @@ stdlib__gc.cmo : \ stdlib__sys.cmi \ stdlib__string.cmi \ stdlib__printf.cmi \ + stdlib__printexc.cmi \ stdlib__gc.cmi stdlib__gc.cmx : \ stdlib__sys.cmx \ stdlib__string.cmx \ stdlib__printf.cmx \ + stdlib__printexc.cmx \ stdlib__gc.cmi -stdlib__gc.cmi : +stdlib__gc.cmi : \ + stdlib__printexc.cmi stdlib__genlex.cmo : \ stdlib__string.cmi \ stdlib__stream.cmi \ diff --git a/stdlib/HACKING.adoc b/stdlib/HACKING.adoc index af8358b2..c29a513a 100644 --- a/stdlib/HACKING.adoc +++ b/stdlib/HACKING.adoc @@ -17,7 +17,7 @@ To add a new module, you must: the same style as the rest of the code, in particular the alphabetical ordering and whitespace alignment of module aliases. -* Add `$(P)module_name` to the definition of `STDLIB_MODULES` in +* Add `module_name` to the definition of `STDLIB_MODS` in `stdlib/StdlibModules`. You must keep the list sorted in dependency order. * Run `make alldepend` to update all the `.depend` files. These files are not diff --git a/stdlib/Makefile b/stdlib/Makefile index 5cd25f24..0b92fe1e 100644 --- a/stdlib/Makefile +++ b/stdlib/Makefile @@ -15,8 +15,8 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common TARGET_BINDIR ?= $(BINDIR) @@ -35,9 +35,6 @@ DEPFLAGS=-slash OC_CPPFLAGS += -I$(ROOTDIR)/runtime -# Object file prefix -P=stdlib__ - include StdlibModules OBJS=$(addsuffix .cmo,$(STDLIB_MODULES)) @@ -241,7 +238,7 @@ $(OBJS:.cmo=.cmx) std_exit.cmx: stdlib.cmi $(OTHERS:.cmo=.cmx) std_exit.cmx: stdlib.cmx clean:: - rm -f *.cm* *.$(O) *.$(A) *.odoc + rm -f *.cm* *.o *.obj *.a *.lib *.odoc rm -f camlheader* include .depend diff --git a/stdlib/StdlibModules b/stdlib/StdlibModules index 928d509c..cb21a671 100644 --- a/stdlib/StdlibModules +++ b/stdlib/StdlibModules @@ -16,70 +16,27 @@ #************************************************************************** # This file lists all standard library modules. -# It is used in particular to know what to expunge in toplevels. +# It is used by: +# 1. stdlib/Makefile when building stdlib.cma +# 2. Makefile to expunge the toplevels +# 3. ocamldoc/Makefile.docfiles to compute all documentation files +# which need to be generated for the stdlib -P ?= stdlib__ +# add stdlib__ as prefix to a module except for internal modules +# and the stdlib module itself +define add_stdlib_prefix + $(or $(filter stdlib camlinternal%,$1), stdlib__$1) +endef # Modules should be listed in dependency order. +STDLIB_MODS=\ + camlinternalFormatBasics stdlib pervasives seq option result bool char uchar \ + sys list bytes string unit marshal obj array float int int32 int64 nativeint \ + lexing parsing set map stack queue camlinternalLazy lazy stream buffer \ + camlinternalFormat printf arg printexc fun gc digest random hashtbl weak \ + format scanf callback camlinternalOO oo camlinternalMod genlex ephemeron \ + filename complex arrayLabels listLabels bytesLabels stringLabels moreLabels \ + stdLabels spacetime bigarray STDLIB_MODULES=\ - camlinternalFormatBasics \ - stdlib \ - $(P)pervasives \ - $(P)seq \ - $(P)option \ - $(P)result \ - $(P)bool \ - $(P)char \ - $(P)uchar \ - $(P)sys \ - $(P)list \ - $(P)bytes \ - $(P)string \ - $(P)unit \ - $(P)marshal \ - $(P)obj \ - $(P)array \ - $(P)float \ - $(P)int \ - $(P)int32 \ - $(P)int64 \ - $(P)nativeint \ - $(P)lexing \ - $(P)parsing \ - $(P)set \ - $(P)map \ - $(P)stack \ - $(P)queue \ - camlinternalLazy \ - $(P)lazy \ - $(P)stream \ - $(P)buffer \ - camlinternalFormat \ - $(P)printf \ - $(P)arg \ - $(P)printexc \ - $(P)fun \ - $(P)gc \ - $(P)digest \ - $(P)random \ - $(P)hashtbl \ - $(P)weak \ - $(P)format \ - $(P)scanf \ - $(P)callback \ - camlinternalOO \ - $(P)oo \ - camlinternalMod \ - $(P)genlex \ - $(P)ephemeron \ - $(P)filename \ - $(P)complex \ - $(P)arrayLabels \ - $(P)listLabels \ - $(P)bytesLabels \ - $(P)stringLabels \ - $(P)moreLabels \ - $(P)stdLabels \ - $(P)spacetime \ - $(P)bigarray + $(foreach module, $(STDLIB_MODS), $(call add_stdlib_prefix,$(module))) diff --git a/stdlib/array.ml b/stdlib/array.ml index 19ceab10..9e8122ba 100644 --- a/stdlib/array.ml +++ b/stdlib/array.ml @@ -187,6 +187,26 @@ let for_all p a = else false in loop 0 +let for_all2 p l1 l2 = + let n1 = length l1 + and n2 = length l2 in + if n1 <> n2 then invalid_arg "Array.for_all2" + else let rec loop i = + if i = n1 then true + else if p (unsafe_get l1 i) (unsafe_get l2 i) then loop (succ i) + else false in + loop 0 + +let exists2 p l1 l2 = + let n1 = length l1 + and n2 = length l2 in + if n1 <> n2 then invalid_arg "Array.exists2" + else let rec loop i = + if i = n1 then false + else if p (unsafe_get l1 i) (unsafe_get l2 i) then true + else loop (succ i) in + loop 0 + let mem x a = let n = length a in let rec loop i = diff --git a/stdlib/array.mli b/stdlib/array.mli index 6e3d4053..9a08d666 100644 --- a/stdlib/array.mli +++ b/stdlib/array.mli @@ -26,16 +26,14 @@ external get : 'a array -> int -> 'a = "%array_safe_get" The first element has number 0. The last element has number [Array.length a - 1]. You can also write [a.(n)] instead of [Array.get a n]. - - Raise [Invalid_argument] + @raise Invalid_argument if [n] is outside the range 0 to [(Array.length a - 1)]. *) external set : 'a array -> int -> 'a -> unit = "%array_safe_set" (** [Array.set a n x] modifies array [a] in place, replacing element number [n] with [x]. You can also write [a.(n) <- x] instead of [Array.set a n x]. - - Raise [Invalid_argument] + @raise Invalid_argument if [n] is outside the range 0 to [Array.length a - 1]. *) external make : int -> 'a -> 'a array = "caml_make_vect" @@ -46,8 +44,7 @@ external make : int -> 'a -> 'a array = "caml_make_vect" Consequently, if [x] is mutable, it is shared among all elements of the array, and modifying [x] through one of the array entries will modify all other entries at the same time. - - Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length]. + @raise Invalid_argument if [n < 0] or [n > Sys.max_array_length]. If the value of [x] is a floating-point number, then the maximum size is only [Sys.max_array_length / 2].*) @@ -69,8 +66,7 @@ val init : int -> (int -> 'a) -> 'a array with element number [i] initialized to the result of [f i]. In other terms, [Array.init n f] tabulates the results of [f] applied to the integers [0] to [n-1]. - - Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length]. + @raise Invalid_argument if [n < 0] or [n > Sys.max_array_length]. If the return type of [f] is [float], then the maximum size is only [Sys.max_array_length / 2].*) @@ -81,8 +77,7 @@ val make_matrix : int -> int -> 'a -> 'a array array are initially physically equal to [e]. The element ([x,y]) of a matrix [m] is accessed with the notation [m.(x).(y)]. - - Raise [Invalid_argument] if [dimx] or [dimy] is negative or + @raise Invalid_argument if [dimx] or [dimy] is negative or greater than {!Sys.max_array_length}. If the value of [e] is a floating-point number, then the maximum size is only [Sys.max_array_length / 2]. *) @@ -94,8 +89,7 @@ val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array (** [Array.append v1 v2] returns a fresh array containing the concatenation of the arrays [v1] and [v2]. - - Raise [Invalid_argument] if + @raise Invalid_argument if [Array.length v1 + Array.length v2 > Sys.max_array_length]. *) val concat : 'a array list -> 'a array @@ -105,8 +99,7 @@ val sub : 'a array -> int -> int -> 'a array (** [Array.sub a start len] returns a fresh array of length [len], containing the elements number [start] to [start + len - 1] of array [a]. - - Raise [Invalid_argument] if [start] and [len] do not + @raise Invalid_argument if [start] and [len] do not designate a valid subarray of [a]; that is, if [start < 0], or [len < 0], or [start + len > Array.length a]. *) @@ -117,8 +110,7 @@ val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit (** [Array.fill a ofs len x] modifies the array [a] in place, storing [x] in elements number [ofs] to [ofs + len - 1]. - - Raise [Invalid_argument] if [ofs] and [len] do not + @raise Invalid_argument if [ofs] and [len] do not designate a valid subarray of [a]. *) val blit : 'a array -> int -> 'a array -> int -> int -> unit @@ -127,8 +119,7 @@ val blit : 'a array -> int -> 'a array -> int -> int -> unit starting at element number [o2]. It works correctly even if [v1] and [v2] are the same array, and the source and destination chunks overlap. - - Raise [Invalid_argument] if [o1] and [len] do not + @raise Invalid_argument if [o1] and [len] do not designate a valid subarray of [v1], or if [o2] and [len] do not designate a valid subarray of [v2]. *) @@ -138,8 +129,7 @@ val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array (** [Array.of_list l] returns a fresh array containing the elements of [l]. - - Raise [Invalid_argument] if the length of [l] is greater than + @raise Invalid_argument if the length of [l] is greater than [Sys.max_array_length].*) @@ -183,14 +173,14 @@ val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit (** [Array.iter2 f a b] applies function [f] to all the elements of [a] and [b]. - Raise [Invalid_argument] if the arrays are not the same size. + @raise Invalid_argument if the arrays are not the same size. @since 4.03.0 *) val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array (** [Array.map2 f a b] applies function [f] to all the elements of [a] and [b], and builds an array with the results returned by [f]: [[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]]. - Raise [Invalid_argument] if the arrays are not the same size. + @raise Invalid_argument if the arrays are not the same size. @since 4.03.0 *) @@ -209,6 +199,16 @@ val exists : ('a -> bool) -> 'a array -> bool [(p a1) || (p a2) || ... || (p an)]. @since 4.03.0 *) +val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool +(** Same as {!Array.for_all}, but for a two-argument predicate. + @raise Invalid_argument if the two arrays have different lengths. + @since 4.11.0 *) + +val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool +(** Same as {!Array.exists}, but for a two-argument predicate. + @raise Invalid_argument if the two arrays have different lengths. + @since 4.11.0 *) + val mem : 'a -> 'a array -> bool (** [mem a l] is true if and only if [a] is structurally equal to an element of [l] (i.e. there is an [x] in [l] such that diff --git a/stdlib/arrayLabels.mli b/stdlib/arrayLabels.mli index 6d940282..a83a3ea4 100644 --- a/stdlib/arrayLabels.mli +++ b/stdlib/arrayLabels.mli @@ -202,6 +202,16 @@ val for_all : f:('a -> bool) -> 'a array -> bool [(f a1) && (f a2) && ... && (f an)]. @since 4.03.0 *) +val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool +(** Same as {!ArrayLabels.for_all}, but for a two-argument predicate. + @raise Invalid_argument if the two arrays have different lengths. + @since 4.11.0 *) + +val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool +(** Same as {!ArrayLabels.exists}, but for a two-argument predicate. + @raise Invalid_argument if the two arrays have different lengths. + @since 4.11.0 *) + val mem : 'a -> set:'a array -> bool (** [mem x ~set] is true if and only if [x] is equal to an element of [set]. diff --git a/stdlib/bigarray.mli b/stdlib/bigarray.mli index ea26f66f..a474d559 100644 --- a/stdlib/bigarray.mli +++ b/stdlib/bigarray.mli @@ -310,7 +310,7 @@ module Genarray : Bigarray [a]. The first dimension corresponds to [n = 0]; the second dimension corresponds to [n = 1]; the last dimension, to [n = Genarray.num_dims a - 1]. - Raise [Invalid_argument] if [n] is less than 0 or greater or equal than + @raise Invalid_argument if [n] is less than 0 or greater or equal than [Genarray.num_dims a]. *) external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = "caml_ba_kind" @@ -347,14 +347,16 @@ module Genarray : and strictly less than the corresponding dimensions of [a]. If [a] has Fortran layout, the coordinates must be greater or equal than 1 and less or equal than the corresponding dimensions of [a]. - Raise [Invalid_argument] if the array [a] does not have exactly [N] - dimensions, or if the coordinates are outside the array bounds. If [N > 3], alternate syntax is provided: you can write [a.{i1, i2, ..., iN}] instead of [Genarray.get a [|i1; ...; iN|]]. (The syntax [a.{...}] with one, two or three coordinates is reserved for accessing one-, two- and three-dimensional arrays - as described below.) *) + as described below.) + + @raise Invalid_argument if the array [a] does not have exactly [N] + dimensions, or if the coordinates are outside the array bounds. + *) external set: ('a, 'b, 'c) t -> int array -> 'a -> unit = "caml_ba_set_generic" @@ -389,7 +391,7 @@ module Genarray : array [a]. [Genarray.sub_left] applies only to Bigarrays in C layout. - Raise [Invalid_argument] if [ofs] and [len] do not designate + @raise Invalid_argument if [ofs] and [len] do not designate a valid sub-array of [a], that is, if [ofs < 0], or [len < 0], or [ofs + len > Genarray.nth_dim a 0]. *) @@ -409,7 +411,7 @@ module Genarray : array [a]. [Genarray.sub_right] applies only to Bigarrays in Fortran layout. - Raise [Invalid_argument] if [ofs] and [len] do not designate + @raise Invalid_argument if [ofs] and [len] do not designate a valid sub-array of [a], that is, if [ofs < 1], or [len < 0], or [ofs + len > Genarray.nth_dim a (Genarray.num_dims a - 1)]. *) @@ -428,7 +430,7 @@ module Genarray : the original array share the same storage space. [Genarray.slice_left] applies only to Bigarrays in C layout. - Raise [Invalid_argument] if [M >= N], or if [[|i1; ... ; iM|]] + @raise Invalid_argument if [M >= N], or if [[|i1; ... ; iM|]] is outside the bounds of [a]. *) external slice_right: @@ -446,7 +448,7 @@ module Genarray : the original array share the same storage space. [Genarray.slice_right] applies only to Bigarrays in Fortran layout. - Raise [Invalid_argument] if [M >= N], or if [[|i1; ... ; iM|]] + @raise Invalid_argument if [M >= N], or if [[|i1; ... ; iM|]] is outside the bounds of [a]. *) external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit @@ -904,23 +906,27 @@ external genarray_of_array3 : val array0_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.t (** Return the zero-dimensional Bigarray corresponding to the given - generic Bigarray. Raise [Invalid_argument] if the generic Bigarray + generic Bigarray. + @raise Invalid_argument if the generic Bigarray does not have exactly zero dimension. @since 4.05.0 *) val array1_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.t (** Return the one-dimensional Bigarray corresponding to the given - generic Bigarray. Raise [Invalid_argument] if the generic Bigarray + generic Bigarray. + @raise Invalid_argument if the generic Bigarray does not have exactly one dimension. *) val array2_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.t (** Return the two-dimensional Bigarray corresponding to the given - generic Bigarray. Raise [Invalid_argument] if the generic Bigarray + generic Bigarray. + @raise Invalid_argument if the generic Bigarray does not have exactly two dimensions. *) val array3_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.t (** Return the three-dimensional Bigarray corresponding to the given - generic Bigarray. Raise [Invalid_argument] if the generic Bigarray + generic Bigarray. + @raise Invalid_argument if the generic Bigarray does not have exactly three dimensions. *) diff --git a/stdlib/bool.ml b/stdlib/bool.ml index 8ce03004..5086f06b 100644 --- a/stdlib/bool.ml +++ b/stdlib/bool.ml @@ -20,7 +20,7 @@ external ( && ) : bool -> bool -> bool = "%sequand" external ( || ) : bool -> bool -> bool = "%sequor" let equal : bool -> bool -> bool = ( = ) let compare : bool -> bool -> int = Stdlib.compare -let to_int = function false -> 0 | true -> 1 +external to_int : bool -> int = "%identity" let to_float = function false -> 0. | true -> 1. (* diff --git a/stdlib/buffer.mli b/stdlib/buffer.mli index 83b96c71..c316a43e 100644 --- a/stdlib/buffer.mli +++ b/stdlib/buffer.mli @@ -50,23 +50,22 @@ val to_bytes : t -> bytes val sub : t -> int -> int -> string (** [Buffer.sub b off len] returns a copy of [len] bytes from the current contents of the buffer [b], starting at offset [off]. - - Raise [Invalid_argument] if [srcoff] and [len] do not designate a valid + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [b]. *) val blit : t -> int -> bytes -> int -> int -> unit (** [Buffer.blit src srcoff dst dstoff len] copies [len] characters from the current contents of the buffer [src], starting at offset [srcoff] to [dst], starting at character [dstoff]. - - Raise [Invalid_argument] if [srcoff] and [len] do not designate a valid + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [src], or if [dstoff] and [len] do not designate a valid range of [dst]. @since 3.11.2 *) val nth : t -> int -> char -(** Get the n-th character of the buffer. Raise [Invalid_argument] if +(** Get the n-th character of the buffer. + @raise Invalid_argument if index out of bounds *) val length : t -> int @@ -134,7 +133,7 @@ val add_substitute : t -> (string -> string) -> string -> unit matching parentheses or curly brackets. An escaped [$] character is a [$] that immediately follows a backslash character; it then stands for a plain [$]. - Raise [Not_found] if the closing character of a parenthesized variable + @raise Not_found if the closing character of a parenthesized variable cannot be found. *) val add_buffer : t -> t -> unit @@ -144,7 +143,7 @@ val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit (** [add_channel b ic n] reads at most [n] characters from the input channel [ic] and stores them at the end of buffer [b]. - Raise [End_of_file] if the channel contains fewer than [n] + @raise End_of_file if the channel contains fewer than [n] characters. In this case, the characters are still added to the buffer, so as to avoid loss of data. *) @@ -155,7 +154,7 @@ val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit (** [truncate b len] truncates the length of [b] to [len] Note: the internal byte sequence is not shortened. - Raise [Invalid_argument] if [len < 0] or [len > length b]. + @raise Invalid_argument if [len < 0] or [len > length b]. @since 4.05.0 *) (** {1 Iterators} *) diff --git a/stdlib/bytes.mli b/stdlib/bytes.mli index 08b5fd54..abf3e90c 100644 --- a/stdlib/bytes.mli +++ b/stdlib/bytes.mli @@ -47,33 +47,28 @@ external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" (** [get s n] returns the byte at index [n] in argument [s]. - - Raise [Invalid_argument] if [n] is not a valid index in [s]. *) + @raise Invalid_argument if [n] is not a valid index in [s]. *) external set : bytes -> int -> char -> unit = "%bytes_safe_set" (** [set s n c] modifies [s] in place, replacing the byte at index [n] with [c]. - - Raise [Invalid_argument] if [n] is not a valid index in [s]. *) + @raise Invalid_argument if [n] is not a valid index in [s]. *) external create : int -> bytes = "caml_create_bytes" (** [create n] returns a new byte sequence of length [n]. The sequence is uninitialized and contains arbitrary bytes. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val make : int -> char -> bytes (** [make n c] returns a new byte sequence of length [n], filled with the byte [c]. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val init : int -> (int -> char) -> bytes (** [Bytes.init n f] returns a fresh byte sequence of length [n], with character [i] initialized to the result of [f i] (in increasing index order). - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val empty : bytes (** A byte sequence of size 0. *) @@ -94,8 +89,7 @@ val sub : bytes -> int -> int -> bytes (** [sub s start len] returns a new byte sequence of length [len], containing the subsequence of [s] that starts at position [start] and has length [len]. - - Raise [Invalid_argument] if [start] and [len] do not designate a + @raise Invalid_argument if [start] and [len] do not designate a valid range of [s]. *) val sub_string : bytes -> int -> int -> string @@ -107,15 +101,13 @@ val extend : bytes -> int -> int -> bytes [right] uninitialized bytes appended to it. If [left] or [right] is negative, then bytes are removed (instead of appended) from the corresponding side of [s]. - - Raise [Invalid_argument] if the result length is negative or + @raise Invalid_argument if the result length is negative or longer than {!Sys.max_string_length} bytes. *) val fill : bytes -> int -> int -> char -> unit (** [fill s start len c] modifies [s] in place, replacing [len] characters with [c], starting at [start]. - - Raise [Invalid_argument] if [start] and [len] do not designate a + @raise Invalid_argument if [start] and [len] do not designate a valid range of [s]. *) val blit : bytes -> int -> bytes -> int -> int -> unit @@ -124,8 +116,7 @@ val blit : bytes -> int -> bytes -> int -> int -> unit index [dstoff]. It works correctly even if [src] and [dst] are the same byte sequence, and the source and destination intervals overlap. - - Raise [Invalid_argument] if [srcoff] and [len] do not + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [src], or if [dstoff] and [len] do not designate a valid range of [dst]. *) @@ -133,8 +124,7 @@ val blit_string : string -> int -> bytes -> int -> int -> unit (** [blit_string src srcoff dst dstoff len] copies [len] bytes from string [src], starting at index [srcoff], to byte sequence [dst], starting at index [dstoff]. - - Raise [Invalid_argument] if [srcoff] and [len] do not + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [src], or if [dstoff] and [len] do not designate a valid range of [dst]. *) @@ -142,15 +132,13 @@ val concat : bytes -> bytes list -> bytes (** [concat sep sl] concatenates the list of byte sequences [sl], inserting the separator byte sequence [sep] between each, and returns the result as a new byte sequence. - - Raise [Invalid_argument] if the result is longer than + @raise Invalid_argument if the result is longer than {!Sys.max_string_length} bytes. *) val cat : bytes -> bytes -> bytes (** [cat s1 s2] concatenates [s1] and [s2] and returns the result - as new byte sequence. - - Raise [Invalid_argument] if the result is longer than + as a new byte sequence. + @raise Invalid_argument if the result is longer than {!Sys.max_string_length} bytes. *) val iter : (char -> unit) -> bytes -> unit @@ -183,15 +171,13 @@ val escaped : bytes -> bytes by escape sequences, following the lexical conventions of OCaml. All characters outside the ASCII printable range (32..126) are escaped, as well as backslash and double-quote. - - Raise [Invalid_argument] if the result is longer than + @raise Invalid_argument if the result is longer than {!Sys.max_string_length} bytes. *) val index : bytes -> char -> int (** [index s c] returns the index of the first occurrence of byte [c] in [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val index_opt: bytes -> char -> int option (** [index_opt s c] returns the index of the first occurrence of byte [c] @@ -201,8 +187,7 @@ val index_opt: bytes -> char -> int option val rindex : bytes -> char -> int (** [rindex s c] returns the index of the last occurrence of byte [c] in [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val rindex_opt: bytes -> char -> int option (** [rindex_opt s c] returns the index of the last occurrence of byte [c] @@ -213,34 +198,30 @@ val index_from : bytes -> int -> char -> int (** [index_from s i c] returns the index of the first occurrence of byte [c] in [s] after position [i]. [Bytes.index s c] is equivalent to [Bytes.index_from s 0 c]. - - Raise [Invalid_argument] if [i] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] after position [i]. *) + @raise Invalid_argument if [i] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] after position [i]. *) val index_from_opt: bytes -> int -> char -> int option (** [index_from_opt s i c] returns the index of the first occurrence of byte [c] in [s] after position [i] or [None] if [c] does not occur in [s] after position [i]. [Bytes.index_opt s c] is equivalent to [Bytes.index_from_opt s 0 c]. - - Raise [Invalid_argument] if [i] is not a valid position in [s]. + @raise Invalid_argument if [i] is not a valid position in [s]. @since 4.05 *) val rindex_from : bytes -> int -> char -> int (** [rindex_from s i c] returns the index of the last occurrence of byte [c] in [s] before position [i+1]. [rindex s c] is equivalent to [rindex_from s (Bytes.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *) + @raise Invalid_argument if [i+1] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] before position [i+1]. *) val rindex_from_opt: bytes -> int -> char -> int option (** [rindex_from_opt s i c] returns the index of the last occurrence of byte [c] in [s] before position [i+1] or [None] if [c] does not occur in [s] before position [i+1]. [rindex_opt s c] is equivalent to [rindex_from s (Bytes.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. + @raise Invalid_argument if [i+1] is not a valid position in [s]. @since 4.05 *) val contains : bytes -> char -> bool @@ -250,14 +231,12 @@ val contains_from : bytes -> int -> char -> bool (** [contains_from s start c] tests if byte [c] appears in [s] after position [start]. [contains s c] is equivalent to [contains_from s 0 c]. - - Raise [Invalid_argument] if [start] is not a valid position in [s]. *) + @raise Invalid_argument if [start] is not a valid position in [s]. *) val rcontains_from : bytes -> int -> char -> bool (** [rcontains_from s stop c] tests if byte [c] appears in [s] before position [stop+1]. - - Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid + @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid position in [s]. *) val uppercase : bytes -> bytes diff --git a/stdlib/bytesLabels.mli b/stdlib/bytesLabels.mli index 9cd02dc8..e4f85d37 100644 --- a/stdlib/bytesLabels.mli +++ b/stdlib/bytesLabels.mli @@ -31,33 +31,28 @@ external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" (** [get s n] returns the byte at index [n] in argument [s]. - - Raise [Invalid_argument] if [n] is not a valid index in [s]. *) + @raise Invalid_argument if [n] is not a valid index in [s]. *) external set : bytes -> int -> char -> unit = "%bytes_safe_set" (** [set s n c] modifies [s] in place, replacing the byte at index [n] with [c]. - - Raise [Invalid_argument] if [n] is not a valid index in [s]. *) + @raise Invalid_argument if [n] is not a valid index in [s]. *) external create : int -> bytes = "caml_create_bytes" (** [create n] returns a new byte sequence of length [n]. The sequence is uninitialized and contains arbitrary bytes. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val make : int -> char -> bytes (** [make n c] returns a new byte sequence of length [n], filled with the byte [c]. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val init : int -> f:(int -> char) -> bytes (** [init n f] returns a fresh byte sequence of length [n], with character [i] initialized to the result of [f i]. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val empty : bytes (** A byte sequence of size 0. *) @@ -78,8 +73,7 @@ val sub : bytes -> pos:int -> len:int -> bytes (** [sub s start len] returns a new byte sequence of length [len], containing the subsequence of [s] that starts at position [start] and has length [len]. - - Raise [Invalid_argument] if [start] and [len] do not designate a + @raise Invalid_argument if [start] and [len] do not designate a valid range of [s]. *) val sub_string : bytes -> pos:int -> len:int -> string @@ -91,16 +85,14 @@ val extend : bytes -> left:int -> right:int -> bytes [right] uninitialized bytes appended to it. If [left] or [right] is negative, then bytes are removed (instead of appended) from the corresponding side of [s]. - - Raise [Invalid_argument] if the result length is negative or + @raise Invalid_argument if the result length is negative or longer than {!Sys.max_string_length} bytes. @since 4.05.0 *) val fill : bytes -> pos:int -> len:int -> char -> unit (** [fill s start len c] modifies [s] in place, replacing [len] characters with [c], starting at [start]. - - Raise [Invalid_argument] if [start] and [len] do not designate a + @raise Invalid_argument if [start] and [len] do not designate a valid range of [s]. *) val blit : @@ -111,8 +103,7 @@ val blit : index [dstoff]. It works correctly even if [src] and [dst] are the same byte sequence, and the source and destination intervals overlap. - - Raise [Invalid_argument] if [srcoff] and [len] do not + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [src], or if [dstoff] and [len] do not designate a valid range of [dst]. *) @@ -122,8 +113,7 @@ val blit_string : (** [blit src srcoff dst dstoff len] copies [len] bytes from string [src], starting at index [srcoff], to byte sequence [dst], starting at index [dstoff]. - - Raise [Invalid_argument] if [srcoff] and [len] do not + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [src], or if [dstoff] and [len] do not designate a valid range of [dst]. @since 4.05.0 *) @@ -135,9 +125,8 @@ val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes (** [cat s1 s2] concatenates [s1] and [s2] and returns the result - as new byte sequence. - - Raise [Invalid_argument] if the result is longer than + as new byte sequence. + @raise Invalid_argument if the result is longer than {!Sys.max_string_length} bytes. @since 4.05.0 *) @@ -173,8 +162,7 @@ val escaped : bytes -> bytes val index : bytes -> char -> int (** [index s c] returns the index of the first occurrence of byte [c] in [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val index_opt: bytes -> char -> int option (** [index_opt s c] returns the index of the first occurrence of byte [c] @@ -184,8 +172,7 @@ val index_opt: bytes -> char -> int option val rindex : bytes -> char -> int (** [rindex s c] returns the index of the last occurrence of byte [c] in [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val rindex_opt: bytes -> char -> int option (** [rindex_opt s c] returns the index of the last occurrence of byte [c] @@ -196,34 +183,30 @@ val index_from : bytes -> int -> char -> int (** [index_from s i c] returns the index of the first occurrence of byte [c] in [s] after position [i]. [Bytes.index s c] is equivalent to [Bytes.index_from s 0 c]. - - Raise [Invalid_argument] if [i] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] after position [i]. *) + @raise Invalid_argument if [i] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] after position [i]. *) val index_from_opt: bytes -> int -> char -> int option (** [index_from _opts i c] returns the index of the first occurrence of byte [c] in [s] after position [i] or [None] if [c] does not occur in [s] after position [i]. [Bytes.index_opt s c] is equivalent to [Bytes.index_from_opt s 0 c]. - - Raise [Invalid_argument] if [i] is not a valid position in [s]. + @raise Invalid_argument if [i] is not a valid position in [s]. @since 4.05 *) val rindex_from : bytes -> int -> char -> int (** [rindex_from s i c] returns the index of the last occurrence of byte [c] in [s] before position [i+1]. [rindex s c] is equivalent to [rindex_from s (Bytes.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *) + @raise Invalid_argument if [i+1] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] before position [i+1]. *) val rindex_from_opt: bytes -> int -> char -> int option (** [rindex_from_opt s i c] returns the index of the last occurrence of byte [c] in [s] before position [i+1] or [None] if [c] does not occur in [s] before position [i+1]. [rindex_opt s c] is equivalent to [rindex_from s (Bytes.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. + @raise Invalid_argument if [i+1] is not a valid position in [s]. @since 4.05 *) val contains : bytes -> char -> bool @@ -233,14 +216,12 @@ val contains_from : bytes -> int -> char -> bool (** [contains_from s start c] tests if byte [c] appears in [s] after position [start]. [contains s c] is equivalent to [contains_from s 0 c]. - - Raise [Invalid_argument] if [start] is not a valid position in [s]. *) + @raise Invalid_argument if [start] is not a valid position in [s]. *) val rcontains_from : bytes -> int -> char -> bool (** [rcontains_from s stop c] tests if byte [c] appears in [s] before position [stop+1]. - - Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid + @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid position in [s]. *) val uppercase : bytes -> bytes diff --git a/stdlib/camlinternalMod.ml b/stdlib/camlinternalMod.ml index c56d22ef..bfc3b12a 100644 --- a/stdlib/camlinternalMod.ml +++ b/stdlib/camlinternalMod.ml @@ -51,12 +51,16 @@ let rec init_mod loc shape = let rec update_mod shape o n = match shape with | Function -> - (* The optimisation below is invalid on bytecode since - the RESTART instruction checks the length of closures. - See PR#4008 *) - if Sys.backend_type = Sys.Native - && Obj.tag n = Obj.closure_tag - && Obj.size n <= Obj.size o + (* In bytecode, the RESTART instruction checks the size of closures. + Hence, the optimized case [overwrite o n] is valid only if [o] and + [n] have the same size. (See PR#4008.) + In native code, the size of closures does not matter, so overwriting + is possible so long as the size of [n] is no greater than that of [o]. + *) + if Obj.tag n = Obj.closure_tag + && (Obj.size n = Obj.size o + || (Sys.backend_type = Sys.Native + && Obj.size n <= Obj.size o)) then begin overwrite o n end else overwrite o (Obj.repr (fun x -> (Obj.obj n : _ -> _) x)) | Lazy -> diff --git a/stdlib/char.ml b/stdlib/char.ml index fb7660d0..052949d0 100644 --- a/stdlib/char.ml +++ b/stdlib/char.ml @@ -46,29 +46,27 @@ let escaped = function bytes_unsafe_set s 3 (unsafe_chr (48 + n mod 10)); unsafe_to_string s -let lowercase c = - if (c >= 'A' && c <= 'Z') - || (c >= '\192' && c <= '\214') - || (c >= '\216' && c <= '\222') - then unsafe_chr(code c + 32) - else c +let lowercase = function + | 'A' .. 'Z' + | '\192' .. '\214' + | '\216' .. '\222' as c -> + unsafe_chr(code c + 32) + | c -> c -let uppercase c = - if (c >= 'a' && c <= 'z') - || (c >= '\224' && c <= '\246') - || (c >= '\248' && c <= '\254') - then unsafe_chr(code c - 32) - else c +let uppercase = function + | 'a' .. 'z' + | '\224' .. '\246' + | '\248' .. '\254' as c -> + unsafe_chr(code c - 32) + | c -> c -let lowercase_ascii c = - if (c >= 'A' && c <= 'Z') - then unsafe_chr(code c + 32) - else c +let lowercase_ascii = function + | 'A' .. 'Z' as c -> unsafe_chr(code c + 32) + | c -> c -let uppercase_ascii c = - if (c >= 'a' && c <= 'z') - then unsafe_chr(code c - 32) - else c +let uppercase_ascii = function + | 'a' .. 'z' as c -> unsafe_chr(code c - 32) + | c -> c type t = char diff --git a/stdlib/char.mli b/stdlib/char.mli index aaa627e4..233208c3 100644 --- a/stdlib/char.mli +++ b/stdlib/char.mli @@ -20,7 +20,7 @@ external code : char -> int = "%identity" val chr : int -> char (** Return the character with the given ASCII code. - Raise [Invalid_argument "Char.chr"] if the argument is + @raise Invalid_argument if the argument is outside the range 0--255. *) val escaped : char -> string diff --git a/stdlib/digest.mli b/stdlib/digest.mli index 9f9fd534..c69b41a5 100644 --- a/stdlib/digest.mli +++ b/stdlib/digest.mli @@ -74,11 +74,11 @@ val input : in_channel -> t val to_hex : t -> string (** Return the printable hexadecimal representation of the given digest. - Raise [Invalid_argument] if the argument is not exactly 16 bytes. + @raise Invalid_argument if the argument is not exactly 16 bytes. *) val from_hex : string -> t (** Convert a hexadecimal representation back into the corresponding digest. - Raise [Invalid_argument] if the argument is not exactly 32 hexadecimal + @raise Invalid_argument if the argument is not exactly 32 hexadecimal characters. @since 4.00.0 *) diff --git a/stdlib/ephemeron.mli b/stdlib/ephemeron.mli index 66a3e9ac..434115e9 100644 --- a/stdlib/ephemeron.mli +++ b/stdlib/ephemeron.mli @@ -13,27 +13,27 @@ (* *) (**************************************************************************) -(** Ephemerons and weak hash table *) +(** Ephemerons and weak hash tables *) -(** Ephemerons and weak hash table are useful when one wants to cache +(** Ephemerons and weak hash tables are useful when one wants to cache or memorize the computation of a function, as long as the arguments and the function are used, without creating memory leaks by continuously keeping old computation results that are not useful anymore because one argument or the function is freed. An implementation using {!Hashtbl.t} is not suitable because all - associations would keep in memory the arguments and the result. + associations would keep the arguments and the result in memory. Ephemerons can also be used for "adding" a field to an arbitrary - boxed ocaml value: you can attach an information to a value + boxed OCaml value: you can attach some information to a value created by an external library without memory leaks. Ephemerons hold some keys and one or no data. They are all boxed - ocaml values. The keys of an ephemeron have the same behavior - than weak pointers according to the garbage collector. In fact - ocaml weak pointers are implemented as ephemerons without data. + OCaml values. The keys of an ephemeron have the same behavior + as weak pointers according to the garbage collector. In fact + OCaml weak pointers are implemented as ephemerons without data. The keys and data of an ephemeron are said to be full if they - point to a value, empty if the value have never been set, have + point to a value, or empty if the value has never been set, has been unset, or was erased by the GC. In the function that accesses the keys or data these two states are represented by the [option] type. @@ -60,7 +60,7 @@ {!Marshal} module. Ephemerons are defined in a language agnostic way in this paper: - B. Hayes, Ephemerons: a New Finalization Mechanism, OOPSLA'9 + B. Hayes, Ephemerons: A New Finalization Mechanism, OOPSLA'97 @since 4.03.0 *) diff --git a/stdlib/filename.mli b/stdlib/filename.mli index 1e77c0d8..9f99d2c5 100644 --- a/stdlib/filename.mli +++ b/stdlib/filename.mli @@ -135,7 +135,7 @@ val temp_file : ?temp_dir: string -> string -> string -> string (readable and writable only by the file owner). The file is guaranteed to be different from any other file that existed when [temp_file] was called. - Raise [Sys_error] if the file could not be created. + @raise Sys_error if the file could not be created. @before 3.11.2 no ?temp_dir optional argument *) @@ -221,6 +221,5 @@ val quote_command : if any are quoted using {!Filename.quote}, then concatenated. Under Win32, additional quoting is performed as required by the [cmd.exe] shell that is called by {!Sys.command}. - - Raise [Failure] if the command cannot be escaped on the current platform. + @raise Failure if the command cannot be escaped on the current platform. *) diff --git a/stdlib/float.mli b/stdlib/float.mli index f82947b1..51263be7 100644 --- a/stdlib/float.mli +++ b/stdlib/float.mli @@ -157,7 +157,7 @@ external of_string : string -> float = "caml_float_of_string" and is ignored. Depending on the execution platforms, other representations of floating-point numbers can be accepted, but should not be relied upon. - Raise [Failure "float_of_string"] if the given string is not a valid + @raise Failure if the given string is not a valid representation of a float. *) val of_string_opt: string -> float option @@ -398,54 +398,47 @@ module Array : sig val get : t -> int -> float (** [get a n] returns the element number [n] of floatarray [a]. - - Raise [Invalid_argument] if [n] is outside the range 0 to + @raise Invalid_argument if [n] is outside the range 0 to [(length a - 1)]. *) val set : t -> int -> float -> unit (** [set a n x] modifies floatarray [a] in place, replacing element number [n] with [x]. - - Raise [Invalid_argument] if [n] is outside the range 0 to + @raise Invalid_argument if [n] is outside the range 0 to [(length a - 1)]. *) val make : int -> float -> t (** [make n x] returns a fresh floatarray of length [n], initialized with [x]. - - Raise [Invalid_argument] if [n < 0] or [n > Sys.max_floatarray_length]. *) + @raise Invalid_argument if [n < 0] or [n > Sys.max_floatarray_length]. *) val create : int -> t (** [create n] returns a fresh floatarray of length [n], with uninitialized data. - - Raise [Invalid_argument] if [n < 0] or [n > Sys.max_floatarray_length]. *) + @raise Invalid_argument if [n < 0] or [n > Sys.max_floatarray_length]. *) val init : int -> (int -> float) -> t (** [init n f] returns a fresh floatarray of length [n], - with element number [i] initialized to the result of [f i]. - In other terms, [init n f] tabulates the results of [f] - applied to the integers [0] to [n-1]. - - Raise [Invalid_argument] if [n < 0] or [n > Sys.max_floatarray_length]. *) + with element number [i] initialized to the result of [f i]. + In other terms, [init n f] tabulates the results of [f] + applied to the integers [0] to [n-1]. + @raise Invalid_argument if [n < 0] or [n > Sys.max_floatarray_length]. *) val append : t -> t -> t (** [append v1 v2] returns a fresh floatarray containing the - concatenation of the floatarrays [v1] and [v2]. - - Raise [Invalid_argument] if - [length v1 + length v2 > Sys.max_floatarray_length]. *) + concatenation of the floatarrays [v1] and [v2]. + @raise Invalid_argument if + [length v1 + length v2 > Sys.max_floatarray_length]. *) val concat : t list -> t (** Same as {!append}, but concatenates a list of floatarrays. *) val sub : t -> int -> int -> t (** [sub a start len] returns a fresh floatarray of length [len], - containing the elements number [start] to [start + len - 1] - of floatarray [a]. - - Raise [Invalid_argument] if [start] and [len] do not - designate a valid subarray of [a]; that is, if - [start < 0], or [len < 0], or [start + len > length a]. *) + containing the elements number [start] to [start + len - 1] + of floatarray [a]. + @raise Invalid_argument if [start] and [len] do not + designate a valid subarray of [a]; that is, if + [start < 0], or [len < 0], or [start + len > length a]. *) val copy : t -> t (** [copy a] returns a copy of [a], that is, a fresh floatarray @@ -453,10 +446,9 @@ module Array : sig val fill : t -> int -> int -> float -> unit (** [fill a ofs len x] modifies the floatarray [a] in place, - storing [x] in elements number [ofs] to [ofs + len - 1]. - - Raise [Invalid_argument] if [ofs] and [len] do not - designate a valid subarray of [a]. *) + storing [x] in elements number [ofs] to [ofs + len - 1]. + @raise Invalid_argument if [ofs] and [len] do not + designate a valid subarray of [a]. *) val blit : t -> int -> t -> int -> int -> unit (** [blit v1 o1 v2 o2 len] copies [len] elements @@ -464,8 +456,7 @@ module Array : sig starting at element number [o2]. It works correctly even if [v1] and [v2] are the same floatarray, and the source and destination chunks overlap. - - Raise [Invalid_argument] if [o1] and [len] do not + @raise Invalid_argument if [o1] and [len] do not designate a valid subarray of [v1], or if [o2] and [len] do not designate a valid subarray of [v2]. *) @@ -475,8 +466,7 @@ module Array : sig val of_list : float list -> t (** [of_list l] returns a fresh floatarray containing the elements of [l]. - - Raise [Invalid_argument] if the length of [l] is greater than + @raise Invalid_argument if the length of [l] is greater than [Sys.max_floatarray_length].*) (** {2 Iterators} *) @@ -515,13 +505,13 @@ module Array : sig val iter2 : (float -> float -> unit) -> t -> t -> unit (** [Array.iter2 f a b] applies function [f] to all the elements of [a] and [b]. - Raise [Invalid_argument] if the floatarrays are not the same size. *) + @raise Invalid_argument if the floatarrays are not the same size. *) val map2 : (float -> float -> float) -> t -> t -> t (** [map2 f a b] applies function [f] to all the elements of [a] and [b], and builds a floatarray with the results returned by [f]: [[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|]]. - Raise [Invalid_argument] if the floatarrays are not the same size. *) + @raise Invalid_argument if the floatarrays are not the same size. *) (** {2 Array scanning} *) diff --git a/stdlib/format.ml b/stdlib/format.ml index 369c50c3..2ed7bc6d 100644 --- a/stdlib/format.ml +++ b/stdlib/format.ml @@ -815,29 +815,48 @@ let pp_set_margin state n = (** Geometry functions and types *) type geometry = { max_indent:int; margin: int} +let validate_geometry {margin; max_indent} = + if max_indent < 2 then + Error "max_indent < 2" + else if margin <= max_indent then + Error "margin <= max_indent" + else Ok () + let check_geometry geometry = - geometry.max_indent > 1 - && geometry.margin > geometry.max_indent + match validate_geometry geometry with + | Ok () -> true + | Error _ -> false let pp_get_margin state () = state.pp_margin +let pp_set_full_geometry state {margin; max_indent} = + pp_set_margin state margin; + pp_set_max_indent state max_indent; + () + let pp_set_geometry state ~max_indent ~margin = - if max_indent < 2 then - raise (Invalid_argument "Format.pp_set_geometry: max_indent < 2") - else if margin <= max_indent then - raise (Invalid_argument "Format.pp_set_geometry: margin <= max_indent") - else - pp_set_margin state margin; pp_set_max_indent state max_indent + let geometry = { max_indent; margin } in + match validate_geometry geometry with + | Error msg -> + raise (Invalid_argument ("Format.pp_set_geometry: " ^ msg)) + | Ok () -> + pp_set_full_geometry state geometry let pp_safe_set_geometry state ~max_indent ~margin = - if check_geometry {max_indent;margin} then - pp_set_geometry state ~max_indent ~margin - else - () + let geometry = { max_indent; margin } in + match validate_geometry geometry with + | Error _msg -> + () + | Ok () -> + pp_set_full_geometry state geometry let pp_get_geometry state () = { margin = pp_get_margin state (); max_indent = pp_get_max_indent state () } +let pp_update_geometry state update = + let geometry = pp_get_geometry state () in + pp_set_full_geometry state (update geometry) + (* Setting a formatter basic output functions. *) let pp_set_formatter_out_functions state { out_string = f; @@ -1123,6 +1142,7 @@ and get_max_indent = pp_get_max_indent std_formatter and set_geometry = pp_set_geometry std_formatter and safe_set_geometry = pp_safe_set_geometry std_formatter and get_geometry = pp_get_geometry std_formatter +and update_geometry = pp_update_geometry std_formatter and set_max_boxes = pp_set_max_boxes std_formatter and get_max_boxes = pp_get_max_boxes std_formatter diff --git a/stdlib/format.mli b/stdlib/format.mli index 44ae07cd..00aae365 100644 --- a/stdlib/format.mli +++ b/stdlib/format.mli @@ -133,6 +133,10 @@ type formatter not rule the policy of inner boxes. For instance, if a vertical box is nested in an horizontal box, all break hints within the vertical box will split the line. + + Moreover, opening a box after the {{!maxindent}maximum indentation limit} + splits the line whether or not the box would end up fitting on the line. + *) val pp_open_box : formatter -> int -> unit @@ -146,7 +150,8 @@ val open_box : int -> unit A break hint splits the line if there is no more room on the line to print the remainder of the box. - Within this box, the pretty-printer emphasizes the box structure: a break + Within this box, the pretty-printer emphasizes the box structure: + if a structural box does not fit fully on a simple line, a break hint also splits the line if the splitting ``moves to the left'' (i.e. the new line gets an indentation smaller than the one of the current line). @@ -398,6 +403,8 @@ val set_margin : int -> unit (** [pp_set_margin ppf d] sets the right margin to [d] (in characters): the pretty-printer splits lines that overflow the right margin according to the break hints given. + Setting the margin to [d] means that the formatting engine aims at + printing at most [d-1] characters per line. Nothing happens if [d] is smaller than 2. If [d] is too large, the right margin is set to the maximum admissible value (which is greater than [10 ^ 9]). @@ -413,7 +420,7 @@ val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int (** Returns the position of the right margin. *) -(** {1 Maximum indentation limit} *) +(** {1:maxindent Maximum indentation limit} *) val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit @@ -439,6 +446,10 @@ val set_max_indent : int -> unit ["123456789"] and ["123456789A"] . Note also that vertical boxes never fit on a line whereas horizontal boxes always fully fit on the current line. + Opening a box may split a line whereas the contents may have fit. + If this behavior is problematic, it can be curtailed by setting the maximum + indentation limit to [margin - 1]. Note that setting the maximum indentation + limit to [margin] is invalid. Nothing happens if [d] is smaller than 2. @@ -488,6 +499,19 @@ val safe_set_geometry : max_indent:int -> margin:int -> unit @since 4.08.0 *) +(** + [pp_update_geometry ppf (fun geo -> { geo with ... })] lets you + update a formatter's geometry in a way that is robust to extension + of the [geometry] record with new fields. + + Raises an invalid argument exception if the returned geometry + does not satisfy {!check_geometry}. + + @since 4.11.0 +*) +val pp_update_geometry : formatter -> (geometry -> geometry) -> unit +val update_geometry : (geometry -> geometry) -> unit + val pp_get_geometry: formatter -> unit -> geometry val get_geometry: unit -> geometry (** Return the current geometry of the formatter diff --git a/stdlib/fun.ml b/stdlib/fun.ml index 247f107e..d8bb0165 100644 --- a/stdlib/fun.ml +++ b/stdlib/fun.ml @@ -20,6 +20,10 @@ let negate p v = not (p v) exception Finally_raised of exn +let () = Printexc.register_printer @@ function +| Finally_raised exn -> Some ("Fun.Finally_raised: " ^ Printexc.to_string exn) +| _ -> None + let protect ~(finally : unit -> unit) work = let finally_no_exn () = try finally () with e -> diff --git a/stdlib/gc.ml b/stdlib/gc.ml index 692b4f0b..9a5c004e 100644 --- a/stdlib/gc.ml +++ b/stdlib/gc.ml @@ -63,6 +63,8 @@ external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket" [@@noalloc] external get_credit : unit -> int = "caml_get_major_credit" [@@noalloc] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" +external eventlog_pause : unit -> unit = "caml_eventlog_pause" +external eventlog_resume : unit -> unit = "caml_eventlog_resume" open Printf @@ -118,3 +120,40 @@ let create_alarm f = let delete_alarm a = a := false + +module Memprof = + struct + type allocation = + { n_samples : int; + size : int; + unmarshalled : bool; + callstack : Printexc.raw_backtrace } + + type ('minor, 'major) tracker = { + alloc_minor: allocation -> 'minor option; + alloc_major: allocation -> 'major option; + promote: 'minor -> 'major option; + dealloc_minor: 'minor -> unit; + dealloc_major: 'major -> unit; + } + + let null_tracker = { + alloc_minor = (fun _ -> None); + alloc_major = (fun _ -> None); + promote = (fun _ -> None); + dealloc_minor = (fun _ -> ()); + dealloc_major = (fun _ -> ()); + } + + external c_start : + float -> int -> ('minor, 'major) tracker -> unit + = "caml_memprof_start" + + let start + ~sampling_rate + ?(callstack_size = max_int) + tracker = + c_start sampling_rate callstack_size tracker + + external stop : unit -> unit = "caml_memprof_stop" + end diff --git a/stdlib/gc.mli b/stdlib/gc.mli index 0ba8ef41..567e4d78 100644 --- a/stdlib/gc.mli +++ b/stdlib/gc.mli @@ -304,7 +304,7 @@ external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket" [@@noalloc] (** [get_bucket n] returns the current size of the [n]-th future bucket of the GC smoothing system. The unit is one millionth of a full GC. - Raise [Invalid_argument] if [n] is negative, return 0 if n is larger + @raise Invalid_argument if [n] is negative, return 0 if n is larger than the smoothing window. @since 4.03.0 *) @@ -420,4 +420,124 @@ val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit (** [delete_alarm a] will stop the calls to the function associated - to [a]. Calling [delete_alarm a] again has no effect. *) + to [a]. Calling [delete_alarm a] again has no effect. *) + +external eventlog_pause : unit -> unit = "caml_eventlog_pause" +(** [eventlog_pause ()] will pause the collection of traces in the + runtime. + Traces are collected if the program is linked to the instrumented runtime + and started with the environment variable OCAML_EVENTLOG_ENABLED. + Events are flushed to disk after pausing, and no new events will be + recorded until [eventlog_resume] is called. *) + +external eventlog_resume : unit -> unit = "caml_eventlog_resume" +(** [eventlog_resume ()] will resume the collection of traces in the + runtime. + Traces are collected if the program is linked to the instrumented runtime + and started with the environment variable OCAML_EVENTLOG_ENABLED. + This call can be used after calling [eventlog_pause], or if the program + was started with OCAML_EVENTLOG_ENABLED=p. (which pauses the collection of + traces before the first event.) *) + + +(** [Memprof] is a sampling engine for allocated memory words. Every + allocated word has a probability of being sampled equal to a + configurable sampling rate. Once a block is sampled, it becomes + tracked. A tracked block triggers a user-defined callback as soon + as it is allocated, promoted or deallocated. + + Since blocks are composed of several words, a block can potentially + be sampled several times. If a block is sampled several times, then + each of the callback is called once for each event of this block: + the multiplicity is given in the [n_samples] field of the + [allocation] structure. + + This engine makes it possible to implement a low-overhead memory + profiler as an OCaml library. + + Note: this API is EXPERIMENTAL. It may change without prior + notice. *) +module Memprof : + sig + type allocation = private + { n_samples : int; + (** The number of samples in this block (>= 1). *) + + size : int; + (** The size of the block, in words, excluding the header. *) + + unmarshalled : bool; + (** Whether the block comes from unmarshalling. *) + + callstack : Printexc.raw_backtrace + (** The callstack for the allocation. *) + } + (** The type of metadata associated with allocations. This is the + type of records passed to the callback triggered by the + sampling of an allocation. *) + + type ('minor, 'major) tracker = { + alloc_minor: allocation -> 'minor option; + alloc_major: allocation -> 'major option; + promote: 'minor -> 'major option; + dealloc_minor: 'minor -> unit; + dealloc_major: 'major -> unit; + } + (** + A [('minor, 'major) tracker] describes how memprof should track + sampled blocks over their lifetime, keeping a user-defined piece + of metadata for each of them: ['minor] is the type of metadata + to keep for minor blocks, and ['major] the type of metadata + for major blocks. + + If an allocation-tracking or promotion-tracking function returns [None], + memprof stops tracking the corresponding value. + *) + + val null_tracker: ('minor, 'major) tracker + (** Default callbacks simply return [None] or [()] *) + + val start : + sampling_rate:float -> + ?callstack_size:int -> + ('minor, 'major) tracker -> + unit + (** Start the sampling with the given parameters. Fails if + sampling is already active. + + The parameter [sampling_rate] is the sampling rate in samples + per word (including headers). Usually, with cheap callbacks, a + rate of 1e-4 has no visible effect on performance, and 1e-3 + causes the program to run a few percent slower + + The parameter [callstack_size] is the length of the callstack + recorded at every sample. Its default is [max_int]. + + The parameter [tracker] determines how to track sampled blocks + over their lifetime in the minor and major heap. + + Sampling is temporarily disabled when calling a callback + for the current thread. So they do not need to be reentrant if + the program is single-threaded. However, if threads are used, + it is possible that a context switch occurs during a callback, + in this case the callback functions must be reentrant. + + Note that the callback can be postponed slightly after the + actual event. The callstack passed to the callback is always + accurate, but the program state may have evolved. + + Calling [Thread.exit] in a callback is currently unsafe and can + result in undefined behavior. *) + + val stop : unit -> unit + (** Stop the sampling. Fails if sampling is not active. + + This function does not allocate memory, but tries to run the + postponed callbacks for already allocated memory blocks (of + course, these callbacks may allocate). + + All the already tracked blocks are discarded. + + Calling [stop] when a callback is running can lead to + callbacks not being called even though some events happened. *) +end diff --git a/stdlib/int32.mli b/stdlib/int32.mli index a6bdb572..a80258c8 100644 --- a/stdlib/int32.mli +++ b/stdlib/int32.mli @@ -56,9 +56,10 @@ external mul : int32 -> int32 -> int32 = "%int32_mul" (** Multiplication. *) external div : int32 -> int32 -> int32 = "%int32_div" -(** Integer division. Raise [Division_by_zero] if the second - argument is zero. This division rounds the real quotient of - its arguments towards zero, as specified for {!Stdlib.(/)}. *) +(** Integer division. This division rounds the real quotient of + its arguments towards zero, as specified for {!Stdlib.(/)}. + @raise Division_by_zero if the second + argument is zero. *) val unsigned_div : int32 -> int32 -> int32 (** Same as {!div}, except that arguments and result are interpreted as {e @@ -167,7 +168,7 @@ external of_string : string -> int32 = "caml_int32_of_string" The [_] (underscore) character can appear anywhere in the string and is ignored. - Raise [Failure "Int32.of_string"] if the given string is not + @raise Failure if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type [int32]. *) diff --git a/stdlib/int64.mli b/stdlib/int64.mli index 732cc008..07f51fb1 100644 --- a/stdlib/int64.mli +++ b/stdlib/int64.mli @@ -56,7 +56,8 @@ external mul : int64 -> int64 -> int64 = "%int64_mul" (** Multiplication. *) external div : int64 -> int64 -> int64 = "%int64_div" -(** Integer division. Raise [Division_by_zero] if the second +(** Integer division. + @raise Division_by_zero if the second argument is zero. This division rounds the real quotient of its arguments towards zero, as specified for {!Stdlib.(/)}. *) @@ -187,7 +188,7 @@ external of_string : string -> int64 = "caml_int64_of_string" The [_] (underscore) character can appear anywhere in the string and is ignored. - Raise [Failure "Int64.of_string"] if the given string is not + @raise Failure if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type [int64]. *) diff --git a/stdlib/lazy.mli b/stdlib/lazy.mli index 93b890e2..b71e21bb 100644 --- a/stdlib/lazy.mli +++ b/stdlib/lazy.mli @@ -63,7 +63,7 @@ external force : 'a t -> 'a = "%lazy_force" If [x] has already been forced, [Lazy.force x] returns the same value again without recomputing it. If it raised an exception, the same exception is raised again. - Raise {!Undefined} if the forcing of [x] tries to force [x] itself + @raise Undefined if the forcing of [x] tries to force [x] itself recursively. *) @@ -71,10 +71,11 @@ val force_val : 'a t -> 'a (** [force_val x] forces the suspension [x] and returns its result. If [x] has already been forced, [force_val x] returns the same value again without recomputing it. - Raise {!Undefined} if the forcing of [x] tries to force [x] itself - recursively. + If the computation of [x] raises an exception, it is unspecified whether [force_val x] raises the same exception or {!Undefined}. + @raise Undefined if the forcing of [x] tries to force [x] itself + recursively. *) val from_fun : (unit -> 'a) -> 'a t diff --git a/stdlib/lexing.ml b/stdlib/lexing.ml index ccca743c..265ee270 100644 --- a/stdlib/lexing.ml +++ b/stdlib/lexing.ml @@ -179,6 +179,13 @@ let from_string ?(with_positions = true) s = lex_curr_p = if with_positions then zero_pos else dummy_pos; } +let set_position lexbuf position = + lexbuf.lex_curr_p <- {position with pos_fname = lexbuf.lex_curr_p.pos_fname}; + lexbuf.lex_abs_pos <- position.pos_cnum + +let set_filename lexbuf fname = + lexbuf.lex_curr_p <- {lexbuf.lex_curr_p with pos_fname = fname} + let with_positions lexbuf = lexbuf.lex_curr_p != dummy_pos let lexeme lexbuf = diff --git a/stdlib/lexing.mli b/stdlib/lexing.mli index 0a511535..0dfe6656 100644 --- a/stdlib/lexing.mli +++ b/stdlib/lexing.mli @@ -108,6 +108,16 @@ val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf starting at index 0, and return the number of bytes provided. A return value of 0 means end of input. *) +val set_position : lexbuf -> position -> unit +(** Set the initial tracked input position for [lexbuf] to a custom value. + Ignores [pos_fname]. See {!set_filename} for changing this field. + @since 4.11 *) + +val set_filename: lexbuf -> string -> unit +(** Set filename in the initial tracked position to [file] in + [lexbuf]. + @since 4.11 *) + val with_positions : lexbuf -> bool (** Tell whether the lexer buffer keeps track of position fields [lex_curr_p] / [lex_start_p], as determined by the corresponding diff --git a/stdlib/list.ml b/stdlib/list.ml index 2b9e545b..a624f3b4 100644 --- a/stdlib/list.ml +++ b/stdlib/list.ml @@ -244,6 +244,13 @@ let find_all p = let filter = find_all +let filteri p l = + let rec aux i acc = function + | [] -> rev acc + | x::l -> aux (i + 1) (if p i x then x::acc else acc) l + in + aux 0 [] l + let filter_map f = let rec aux accu = function | [] -> rev accu @@ -262,6 +269,14 @@ let concat_map f l = aux f (rev_append xs acc) l in aux f [] l +let fold_left_map f accu l = + let rec aux accu l_accu = function + | [] -> accu, rev l_accu + | x :: l -> + let accu, x = f accu x in + aux accu (x :: l_accu) l in + aux accu [] l + let partition p l = let rec part yes no = function | [] -> (rev yes, rev no) diff --git a/stdlib/list.mli b/stdlib/list.mli index b7b6a89b..77714f1f 100644 --- a/stdlib/list.mli +++ b/stdlib/list.mli @@ -52,24 +52,24 @@ val cons : 'a -> 'a list -> 'a list *) val hd : 'a list -> 'a -(** Return the first element of the given list. Raise - [Failure "hd"] if the list is empty. *) +(** Return the first element of the given list. + @raise Failure if the list is empty. *) val tl : 'a list -> 'a list -(** Return the given list without its first element. Raise - [Failure "tl"] if the list is empty. *) +(** Return the given list without its first element. + @raise Failure if the list is empty. *) val nth: 'a list -> int -> 'a (** Return the [n]-th element of the given list. The first element (head of the list) is at position 0. - Raise [Failure "nth"] if the list is too short. - Raise [Invalid_argument "List.nth"] if [n] is negative. *) + @raise Failure if the list is too short. + @raise Invalid_argument if [n] is negative. *) val nth_opt: 'a list -> int -> 'a option (** Return the [n]-th element of the given list. The first element (head of the list) is at position 0. Return [None] if the list is too short. - Raise [Invalid_argument "List.nth"] if [n] is negative. + @raise Invalid_argument if [n] is negative. @since 4.05 *) @@ -148,6 +148,12 @@ val concat_map : ('a -> 'b list) -> 'a list -> 'b list @since 4.10.0 *) +val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list +(** [fold_left_map] is a combination of [fold_left] and [map] that threads an + accumulator through calls to [f] + @since 4.11.0 +*) + val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a (** [List.fold_left f a [b1; ...; bn]] is [f (... (f (f a b1) b2) ...) bn]. *) @@ -163,13 +169,13 @@ val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit (** [List.iter2 f [a1; ...; an] [b1; ...; bn]] calls in turn [f a1 b1; ...; f an bn]. - Raise [Invalid_argument] if the two lists are determined + @raise Invalid_argument if the two lists are determined to have different lengths. *) val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** [List.map2 f [a1; ...; an] [b1; ...; bn]] is [[f a1 b1; ...; f an bn]]. - Raise [Invalid_argument] if the two lists are determined + @raise Invalid_argument if the two lists are determined to have different lengths. Not tail-recursive. *) val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list @@ -180,13 +186,13 @@ val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a (** [List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]] is [f (... (f (f a b1 c1) b2 c2) ...) bn cn]. - Raise [Invalid_argument] if the two lists are determined + @raise Invalid_argument if the two lists are determined to have different lengths. *) val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c (** [List.fold_right2 f [a1; ...; an] [b1; ...; bn] c] is [f a1 b1 (f a2 b2 (... (f an bn c) ...))]. - Raise [Invalid_argument] if the two lists are determined + @raise Invalid_argument if the two lists are determined to have different lengths. Not tail-recursive. *) @@ -196,21 +202,23 @@ val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool (** [for_all p [a1; ...; an]] checks if all elements of the list satisfy the predicate [p]. That is, it returns - [(p a1) && (p a2) && ... && (p an)]. *) + [(p a1) && (p a2) && ... && (p an)] for a non-empty list and + [true] if the list is empty. *) val exists : ('a -> bool) -> 'a list -> bool (** [exists p [a1; ...; an]] checks if at least one element of the list satisfies the predicate [p]. That is, it returns - [(p a1) || (p a2) || ... || (p an)]. *) + [(p a1) || (p a2) || ... || (p an)] for a non-empty list and + [false] if the list is empty. *) val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Same as {!List.for_all}, but for a two-argument predicate. - Raise [Invalid_argument] if the two lists are determined + @raise Invalid_argument if the two lists are determined to have different lengths. *) val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Same as {!List.exists}, but for a two-argument predicate. - Raise [Invalid_argument] if the two lists are determined + @raise Invalid_argument if the two lists are determined to have different lengths. *) val mem : 'a -> 'a list -> bool @@ -228,7 +236,7 @@ val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a (** [find p l] returns the first element of the list [l] that satisfies the predicate [p]. - Raise [Not_found] if there is no value that satisfies [p] in the + @raise Not_found if there is no value that satisfies [p] in the list [l]. *) val find_opt: ('a -> bool) -> 'a list -> 'a option @@ -252,6 +260,13 @@ val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list (** [find_all] is another name for {!List.filter}. *) +val filteri : (int -> 'a -> bool) -> 'a list -> 'a list +(** Same as {!List.filter}, but the predicate is applied to the index of + the element as first argument (counting from 0), and the element + itself as second argument. + @since 4.11.0 +*) + val partition : ('a -> bool) -> 'a list -> 'a list * 'a list (** [partition p l] returns a pair of lists [(l1, l2)], where [l1] is the list of all the elements of [l] that @@ -268,7 +283,7 @@ val assoc : 'a -> ('a * 'b) list -> 'b pairs [l]. That is, [assoc a [ ...; (a,b); ...] = b] if [(a,b)] is the leftmost binding of [a] in list [l]. - Raise [Not_found] if there is no value associated with [a] in the + @raise Not_found if there is no value associated with [a] in the list [l]. *) val assoc_opt: 'a -> ('a * 'b) list -> 'b option @@ -320,7 +335,7 @@ val combine : 'a list -> 'b list -> ('a * 'b) list (** Transform a pair of lists into a list of pairs: [combine [a1; ...; an] [b1; ...; bn]] is [[(a1,b1); ...; (an,bn)]]. - Raise [Invalid_argument] if the two lists + @raise Invalid_argument if the two lists have different lengths. Not tail-recursive. *) diff --git a/stdlib/listLabels.mli b/stdlib/listLabels.mli index 7004d789..c98eaeef 100644 --- a/stdlib/listLabels.mli +++ b/stdlib/listLabels.mli @@ -14,7 +14,8 @@ (**************************************************************************) type 'a t = 'a list = [] | (::) of 'a * 'a list (**) -(** An alias for the type of lists. *) +(** An alias for the type of lists. + *) (** List operations. @@ -36,14 +37,17 @@ type 'a t = 'a list = [] | (::) of 'a * 'a list (**) open StdLabels let seq len = List.init ~f:(function i -> i) ~len - ]} *) + ]} + *) val length : 'a list -> int -(** Return the length (number of elements) of the given list. *) +(** Return the length (number of elements) of the given list. + *) val hd : 'a list -> 'a -(** Return the first element of the given list. Raise - [Failure "hd"] if the list is empty. *) +(** Return the first element of the given list. + @raise Failure if the list is empty. + *) val compare_lengths : 'a list -> 'b list -> int (** Compare the lengths of two lists. [compare_lengths l1 l2] is @@ -57,60 +61,66 @@ val compare_length_with : 'a list -> len:int -> int equivalent to [compare (length l) n], except that the computation stops after at most [n] iterations on the list. @since 4.05.0 -*) + *) val cons : 'a -> 'a list -> 'a list (** [cons x xs] is [x :: xs] @since 4.05.0 -*) + *) val tl : 'a list -> 'a list -(** Return the given list without its first element. Raise - [Failure "tl"] if the list is empty. *) +(** Return the given list without its first element. + @raise Failure if the list is empty. + *) val nth : 'a list -> int -> 'a (** Return the [n]-th element of the given list. The first element (head of the list) is at position 0. - Raise [Failure "nth"] if the list is too short. - Raise [Invalid_argument "List.nth"] if [n] is negative. *) + @raise Failure if the list is too short. + @raise Invalid_argument if [n] is negative. + *) val nth_opt: 'a list -> int -> 'a option (** Return the [n]-th element of the given list. The first element (head of the list) is at position 0. Return [None] if the list is too short. - Raise [Invalid_argument "List.nth"] if [n] is negative. + @raise Invalid_argument if [n] is negative. @since 4.05 -*) + *) val rev : 'a list -> 'a list -(** List reversal. *) +(** List reversal. + *) val init : len:int -> f:(int -> 'a) -> 'a list (** [List.init len f] is [f 0; f 1; ...; f (len-1)], evaluated left to right. - @raise Invalid_argument if [len < 0]. @since 4.06.0 -*) + *) val append : 'a list -> 'a list -> 'a list -(** Catenate two lists. Same function as the infix operator [@]. - Not tail-recursive (length of the first argument). The [@] - operator is not tail-recursive either. *) +(** Catenate two lists. Same function as the infix operator [@]. + Not tail-recursive (length of the first argument). The [@] + operator is not tail-recursive either. + *) val rev_append : 'a list -> 'a list -> 'a list (** [List.rev_append l1 l2] reverses [l1] and concatenates it with [l2]. This is equivalent to [(]{!List.rev}[ l1) @ l2], but [rev_append] is - tail-recursive and more efficient. *) + tail-recursive and more efficient. + *) val concat : 'a list list -> 'a list -(** Concatenate a list of lists. The elements of the argument are all +(** Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result. Not tail-recursive - (length of the argument + length of the longest sub-list). *) + (length of the argument + length of the longest sub-list). + *) val flatten : 'a list list -> 'a list -(** Same as [concat]. Not tail-recursive - (length of the argument + length of the longest sub-list). *) +(** Same as [concat]. Not tail-recursive + (length of the argument + length of the longest sub-list). + *) (** {1 Iterators} *) @@ -119,38 +129,41 @@ val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit (** [List.iter f [a1; ...; an]] applies function [f] in turn to [a1; ...; an]. It is equivalent to - [begin f a1; f a2; ...; f an; () end]. *) + [begin f a1; f a2; ...; f an; () end]. + *) val iteri : f:(int -> 'a -> unit) -> 'a list -> unit (** Same as {!List.iter}, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. @since 4.00.0 -*) + *) val map : f:('a -> 'b) -> 'a list -> 'b list (** [List.map f [a1; ...; an]] applies function [f] to [a1, ..., an], and builds the list [[f a1; ...; f an]] - with the results returned by [f]. Not tail-recursive. *) + with the results returned by [f]. Not tail-recursive. + *) val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list (** Same as {!List.map}, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument. @since 4.00.0 -*) + *) val rev_map : f:('a -> 'b) -> 'a list -> 'b list (** [List.rev_map f l] gives the same result as {!List.rev}[ (]{!List.map}[ f l)], but is tail-recursive and - more efficient. *) + more efficient. + *) val filter_map : f:('a -> 'b option) -> 'a list -> 'b list (** [filter_map f l] applies [f] to every element of [l], filters out the [None] elements and returns the list of the arguments of the [Some] elements. @since 4.08.0 -*) + *) val concat_map : f:('a -> 'b list) -> 'a list -> 'b list (** [List.concat_map f l] gives the same result as @@ -159,13 +172,22 @@ val concat_map : f:('a -> 'b list) -> 'a list -> 'b list @since 4.10.0 *) +val fold_left_map : + f:('a -> 'b -> 'a * 'c) -> init:'a -> 'b list -> 'a * 'c list +(** [fold_left_map] is a combination of [fold_left] and [map] hat threads an + accumulator through calls to [f] + @since 4.11.0 +*) + val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a (** [List.fold_left f a [b1; ...; bn]] is - [f (... (f (f a b1) b2) ...) bn]. *) + [f (... (f (f a b1) b2) ...) bn]. + *) val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b (** [List.fold_right f [a1; ...; an] b] is - [f a1 (f a2 (... (f an b) ...))]. Not tail-recursive. *) + [f a1 (f a2 (... (f an b) ...))]. Not tail-recursive. + *) (** {1 Iterators on two lists} *) @@ -174,33 +196,38 @@ val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit (** [List.iter2 f [a1; ...; an] [b1; ...; bn]] calls in turn [f a1 b1; ...; f an bn]. - Raise [Invalid_argument] if the two lists are determined - to have different lengths. *) + @raise Invalid_argument if the two lists are determined + to have different lengths. + *) val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** [List.map2 f [a1; ...; an] [b1; ...; bn]] is [[f a1 b1; ...; f an bn]]. - Raise [Invalid_argument] if the two lists are determined - to have different lengths. Not tail-recursive. *) + @raise Invalid_argument if the two lists are determined + to have different lengths. Not tail-recursive. + *) val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** [List.rev_map2 f l1 l2] gives the same result as {!List.rev}[ (]{!List.map2}[ f l1 l2)], but is tail-recursive and - more efficient. *) + more efficient. + *) val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a (** [List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]] is [f (... (f (f a b1 c1) b2 c2) ...) bn cn]. - Raise [Invalid_argument] if the two lists are determined - to have different lengths. *) + @raise Invalid_argument if the two lists are determined + to have different lengths. + *) val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c (** [List.fold_right2 f [a1; ...; an] [b1; ...; bn] c] is [f a1 b1 (f a2 b2 (... (f an bn c) ...))]. - Raise [Invalid_argument] if the two lists are determined - to have different lengths. Not tail-recursive. *) + @raise Invalid_argument if the two lists are determined + to have different lengths. Not tail-recursive. + *) (** {1 List scanning} *) @@ -209,30 +236,36 @@ val fold_right2 : val for_all : f:('a -> bool) -> 'a list -> bool (** [for_all p [a1; ...; an]] checks if all elements of the list satisfy the predicate [p]. That is, it returns - [(p a1) && (p a2) && ... && (p an)]. *) + [(p a1) && (p a2) && ... && (p an)]. + *) val exists : f:('a -> bool) -> 'a list -> bool (** [exists p [a1; ...; an]] checks if at least one element of the list satisfies the predicate [p]. That is, it returns - [(p a1) || (p a2) || ... || (p an)]. *) + [(p a1) || (p a2) || ... || (p an)]. + *) val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Same as {!List.for_all}, but for a two-argument predicate. - Raise [Invalid_argument] if the two lists are determined - to have different lengths. *) + @raise Invalid_argument if the two lists are determined + to have different lengths. + *) val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Same as {!List.exists}, but for a two-argument predicate. - Raise [Invalid_argument] if the two lists are determined - to have different lengths. *) + @raise Invalid_argument if the two lists are determined + to have different lengths. + *) val mem : 'a -> set:'a list -> bool (** [mem a l] is true if and only if [a] is equal - to an element of [l]. *) + to an element of [l]. + *) val memq : 'a -> set:'a list -> bool (** Same as {!List.mem}, but uses physical equality instead of structural - equality to compare list elements. *) + equality to compare list elements. + *) (** {1 List searching} *) @@ -241,15 +274,17 @@ val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a (** [find p l] returns the first element of the list [l] that satisfies the predicate [p]. - Raise [Not_found] if there is no value that satisfies [p] in the - list [l]. *) + @raise Not_found if there is no value that satisfies [p] in the + list [l]. + *) val find_opt: f:('a -> bool) -> 'a list -> 'a option (** [find p l] returns the first element of the list [l] that satisfies the predicate [p]. Returns [None] if there is no value that satisfies [p] in the list [l]. - @since 4.05 *) + @since 4.05 + *) val find_map: f:('a -> 'b option) -> 'a list -> 'b option (** [find_map f l] applies [f] to the elements of [l] in order, @@ -260,18 +295,28 @@ val find_map: f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list (** [filter p l] returns all the elements of the list [l] - that satisfy the predicate [p]. The order of the elements - in the input list is preserved. *) + that satisfy the predicate [p]. The order of the elements + in the input list is preserved. + *) val find_all : f:('a -> bool) -> 'a list -> 'a list -(** [find_all] is another name for {!List.filter}. *) +(** [find_all] is another name for {!List.filter}. + *) + +val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list +(** Same as {!List.filter}, but the predicate is applied to the index of + the element as first argument (counting from 0), and the element + itself as second argument. + @since 4.11.0 +*) val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list (** [partition p l] returns a pair of lists [(l1, l2)], where [l1] is the list of all the elements of [l] that satisfy the predicate [p], and [l2] is the list of all the elements of [l] that do not satisfy [p]. - The order of the elements in the input list is preserved. *) + The order of the elements in the input list is preserved. + *) (** {1 Association lists} *) @@ -282,8 +327,9 @@ val assoc : 'a -> ('a * 'b) list -> 'b pairs [l]. That is, [assoc a [ ...; (a,b); ...] = b] if [(a,b)] is the leftmost binding of [a] in list [l]. - Raise [Not_found] if there is no value associated with [a] in the - list [l]. *) + @raise Not_found if there is no value associated with [a] in the + list [l]. + *) val assoc_opt: 'a -> ('a * 'b) list -> 'b option (** [assoc_opt a l] returns the value associated with key [a] in the list of @@ -293,33 +339,39 @@ val assoc_opt: 'a -> ('a * 'b) list -> 'b option Returns [None] if there is no value associated with [a] in the list [l]. @since 4.05 -*) + *) val assq : 'a -> ('a * 'b) list -> 'b (** Same as {!List.assoc}, but uses physical equality instead of - structural equality to compare keys. *) + structural equality to compare keys. + *) val assq_opt: 'a -> ('a * 'b) list -> 'b option (** Same as {!List.assoc_opt}, but uses physical equality instead of structural equality to compare keys. - @since 4.05.0 *) + @since 4.05.0 + *) val mem_assoc : 'a -> map:('a * 'b) list -> bool (** Same as {!List.assoc}, but simply return true if a binding exists, - and false if no bindings exist for the given key. *) + and false if no bindings exist for the given key. + *) val mem_assq : 'a -> map:('a * 'b) list -> bool (** Same as {!List.mem_assoc}, but uses physical equality instead of - structural equality to compare keys. *) + structural equality to compare keys. + *) val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list (** [remove_assoc a l] returns the list of pairs [l] without the first pair with key [a], if any. - Not tail-recursive. *) + Not tail-recursive. + *) val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list (** Same as {!List.remove_assoc}, but uses physical equality instead - of structural equality to compare keys. Not tail-recursive. *) + of structural equality to compare keys. Not tail-recursive. + *) (** {1 Lists of pairs} *) @@ -329,14 +381,15 @@ val split : ('a * 'b) list -> 'a list * 'b list (** Transform a list of pairs into a pair of lists: [split [(a1,b1); ...; (an,bn)]] is [([a1; ...; an], [b1; ...; bn])]. Not tail-recursive. -*) + *) val combine : 'a list -> 'b list -> ('a * 'b) list (** Transform a pair of lists into a list of pairs: [combine [a1; ...; an] [b1; ...; bn]] is [[(a1,b1); ...; (an,bn)]]. - Raise [Invalid_argument] if the two lists - have different lengths. Not tail-recursive. *) + @raise Invalid_argument if the two lists + have different lengths. Not tail-recursive. + *) (** {1 Sorting} *) @@ -344,10 +397,10 @@ val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Sort a list in increasing order according to a comparison - function. The comparison function must return 0 if its arguments + function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see Array.sort for - a complete specification). For example, + a complete specification). For example, {!Stdlib.compare} is a suitable comparison function. The resulting list is sorted in increasing order. [List.sort] is guaranteed to run in constant heap space @@ -356,7 +409,7 @@ val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space. -*) + *) val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Same as {!List.sort}, but the sorting algorithm is guaranteed to @@ -365,15 +418,17 @@ val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space. -*) + *) val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Same as {!List.sort} or {!List.stable_sort}, whichever is - faster on typical input. *) + faster on typical input. + *) val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Same as {!List.sort}, but also remove duplicates. - @since 4.03.0 *) + @since 4.03.0 + *) val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list (** Merge two lists: @@ -383,14 +438,16 @@ val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list If several elements compare equal, the elements of [l1] will be before the elements of [l2]. Not tail-recursive (sum of the lengths of the arguments). -*) + *) (** {1 Iterators} *) val to_seq : 'a list -> 'a Seq.t (** Iterate on the list - @since 4.07 *) + @since 4.07 + *) val of_seq : 'a Seq.t -> 'a list (** Create a list from the iterator - @since 4.07 *) + @since 4.07 + *) diff --git a/stdlib/map.ml b/stdlib/map.ml index 0883ba10..479f2646 100644 --- a/stdlib/map.ml +++ b/stdlib/map.ml @@ -40,6 +40,7 @@ module type S = val for_all: (key -> 'a -> bool) -> 'a t -> bool val exists: (key -> 'a -> bool) -> 'a t -> bool val filter: (key -> 'a -> bool) -> 'a t -> 'a t + val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t val cardinal: 'a t -> int val bindings: 'a t -> (key * 'a) list @@ -425,6 +426,18 @@ module Make(Ord: OrderedType) = struct if pvd then if l==l' && r==r' then m else join l' v d r' else concat l' r' + let rec filter_map f = function + Empty -> Empty + | Node {l; v; d; r} -> + (* call [f] in the expected left-to-right order *) + let l' = filter_map f l in + let fvd = f v d in + let r' = filter_map f r in + begin match fvd with + | Some d' -> join l' v d' r' + | None -> concat l' r' + end + let rec partition p = function Empty -> (Empty, Empty) | Node {l; v; d; r} -> diff --git a/stdlib/map.mli b/stdlib/map.mli index 2dc955ab..6ec8249a 100644 --- a/stdlib/map.mli +++ b/stdlib/map.mli @@ -114,17 +114,17 @@ module type S = val merge: (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t - (** [merge f m1 m2] computes a map whose keys is a subset of keys of [m1] - and of [m2]. The presence of each such binding, and the corresponding - value, is determined with the function [f]. + (** [merge f m1 m2] computes a map whose keys are a subset of the keys of + [m1] and of [m2]. The presence of each such binding, and the + corresponding value, is determined with the function [f]. In terms of the [find_opt] operation, we have - [find_opt x (merge f m1 m2) = f (find_opt x m1) (find_opt x m2)] - for any key [x], provided that [f None None = None]. + [find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2)] + for any key [x], provided that [f x None None = None]. @since 3.12.0 *) val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t - (** [union f m1 m2] computes a map whose keys is the union of keys + (** [union f m1 m2] computes a map whose keys are a subset of the keys of [m1] and of [m2]. When the same binding is defined in both arguments, the function [f] is used to combine them. This is a special case of [merge]: [union f m1 m2] is equivalent @@ -172,18 +172,38 @@ module type S = val filter: (key -> 'a -> bool) -> 'a t -> 'a t (** [filter p m] returns the map with all the bindings in [m] - that satisfy predicate [p]. If [p] satisfies every binding in [m], + that satisfy predicate [p]. If every binding in [m] satisfies [p], [m] is returned unchanged (the result of the function is then physically equal to [m]) @since 3.12.0 @before 4.03 Physical equality was not ensured. *) + val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t + (** [filter_map f m] applies the function [f] to every binding of + [m], and builds a map from the results. For each binding + [(k, v)] in the input map: + - if [f k v] is [None] then [k] is not in the result, + - if [f k v] is [Some v'] then the binding [(k, v')] + is in the output map. + + For example, the following function on maps whose values are lists + {[ + filter_map + (fun _k li -> match li with [] -> None | _::tl -> Some tl) + m + ]} + drops all bindings of [m] whose value is an empty list, and pops + the first element of each value that is non-empty. + + @since 4.11.0 + *) + val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t (** [partition p m] returns a pair of maps [(m1, m2)], where - [m1] contains all the bindings of [s] that satisfy the + [m1] contains all the bindings of [m] that satisfy the predicate [p], and [m2] is the map with all the bindings of - [s] that do not satisfy [p]. + [m] that do not satisfy [p]. @since 3.12.0 *) @@ -252,12 +272,12 @@ module type S = *) val find: key -> 'a t -> 'a - (** [find x m] returns the current binding of [x] in [m], - or raises [Not_found] if no such binding exists. *) + (** [find x m] returns the current value of [x] in [m], + or raises [Not_found] if no binding for [x] exists. *) val find_opt: key -> 'a t -> 'a option - (** [find_opt x m] returns [Some v] if the current binding of [x] - in [m] is [v], or [None] if no such binding exists. + (** [find_opt x m] returns [Some v] if the current value of [x] + in [m] is [v], or [None] if no binding for [x] exists. @since 4.05 *) diff --git a/stdlib/moreLabels.mli b/stdlib/moreLabels.mli index 08bc0f4d..eae749c7 100644 --- a/stdlib/moreLabels.mli +++ b/stdlib/moreLabels.mli @@ -152,6 +152,7 @@ module Map : sig val for_all: f:(key -> 'a -> bool) -> 'a t -> bool val exists: f:(key -> 'a -> bool) -> 'a t -> bool val filter: f:(key -> 'a -> bool) -> 'a t -> 'a t + val filter_map: f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition: f:(key -> 'a -> bool) -> 'a t -> 'a t * 'a t val cardinal: 'a t -> int val bindings: 'a t -> (key * 'a) list @@ -205,6 +206,7 @@ module Set : sig val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t + val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> t * t val cardinal : t -> int val elements : t -> elt list diff --git a/stdlib/nativeint.mli b/stdlib/nativeint.mli index c338142a..fdf24eb8 100644 --- a/stdlib/nativeint.mli +++ b/stdlib/nativeint.mli @@ -59,9 +59,11 @@ external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" (** Multiplication. *) external div : nativeint -> nativeint -> nativeint = "%nativeint_div" -(** Integer division. Raise [Division_by_zero] if the second - argument is zero. This division rounds the real quotient of - its arguments towards zero, as specified for {!Stdlib.(/)}. *) +(** Integer division. This division rounds the real quotient of + its arguments towards zero, as specified for {!Stdlib.(/)}. + + @raise Division_by_zero if the second + argument is zero. *) val unsigned_div : nativeint -> nativeint -> nativeint (** Same as {!div}, except that arguments and result are interpreted as {e @@ -193,7 +195,7 @@ external of_string : string -> nativeint = "caml_nativeint_of_string" it is converted to the signed integer [Int64.min_int + input - Nativeint.max_int - 1]. - Raise [Failure "Nativeint.of_string"] if the given string is not + @raise Failure if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type [nativeint]. *) diff --git a/stdlib/printexc.ml b/stdlib/printexc.ml index 13d9ebee..8b6822d1 100644 --- a/stdlib/printexc.ml +++ b/stdlib/printexc.ml @@ -108,6 +108,7 @@ type backtrace_slot = start_char : int; end_char : int; is_inline : bool; + defname : string; } | Unknown_location of { is_raise : bool @@ -116,7 +117,7 @@ type backtrace_slot = (* to avoid warning *) let _ = [Known_location { is_raise = false; filename = ""; line_number = 0; start_char = 0; end_char = 0; - is_inline = false }; + is_inline = false; defname = "" }; Unknown_location { is_raise = false }] external convert_raw_backtrace_slot: @@ -143,8 +144,8 @@ let format_backtrace_slot pos slot = else Some (sprintf "%s unknown location" (info false)) | Known_location l -> - Some (sprintf "%s file \"%s\"%s, line %d, characters %d-%d" - (info l.is_raise) l.filename + Some (sprintf "%s %s in file \"%s\"%s, line %d, characters %d-%d" + (info l.is_raise) l.defname l.filename (if l.is_inline then " (inlined)" else "") l.line_number l.start_char l.end_char) @@ -208,6 +209,11 @@ let backtrace_slot_location = function end_char = l.end_char; } +let backtrace_slot_defname = function + | Unknown_location _ + | Known_location { defname = "" } -> None + | Known_location l -> Some l.defname + let backtrace_slots raw_backtrace = (* The documentation of this function guarantees that Some is returned only if a part of the trace is usable. This gives us @@ -234,6 +240,7 @@ module Slot = struct let is_raise = backtrace_slot_is_raise let is_inline = backtrace_slot_is_inline let location = backtrace_slot_location + let name = backtrace_slot_defname end external raw_backtrace_length : @@ -270,10 +277,14 @@ let exn_slot_name x = let slot = exn_slot x in (Obj.obj (Obj.field slot 0) : string) +let default_uncaught_exception_handler exn raw_backtrace = + eprintf "Fatal error: exception %s\n" (to_string exn); + print_raw_backtrace stderr raw_backtrace; + flush stderr -let uncaught_exception_handler = ref None +let uncaught_exception_handler = ref default_uncaught_exception_handler -let set_uncaught_exception_handler fn = uncaught_exception_handler := Some fn +let set_uncaught_exception_handler fn = uncaught_exception_handler := fn let empty_backtrace : raw_backtrace = Obj.obj (Obj.new_block Obj.abstract_tag 0) @@ -294,22 +305,16 @@ let handle_uncaught_exception' exn debugger_in_use = try_get_raw_backtrace () in (try Stdlib.do_at_exit () with _ -> ()); - match !uncaught_exception_handler with - | None -> - eprintf "Fatal error: exception %s\n" (to_string exn); - print_raw_backtrace stderr raw_backtrace; - flush stderr - | Some handler -> - try - handler exn raw_backtrace - with exn' -> - let raw_backtrace' = try_get_raw_backtrace () in - eprintf "Fatal error: exception %s\n" (to_string exn); - print_raw_backtrace stderr raw_backtrace; - eprintf "Fatal error in uncaught exception handler: exception %s\n" - (to_string exn'); - print_raw_backtrace stderr raw_backtrace'; - flush stderr + try + !uncaught_exception_handler exn raw_backtrace + with exn' -> + let raw_backtrace' = try_get_raw_backtrace () in + eprintf "Fatal error: exception %s\n" (to_string exn); + print_raw_backtrace stderr raw_backtrace; + eprintf "Fatal error in uncaught exception handler: exception %s\n" + (to_string exn'); + print_raw_backtrace stderr raw_backtrace'; + flush stderr with | Out_of_memory -> prerr_endline diff --git a/stdlib/printexc.mli b/stdlib/printexc.mli index c15b783d..585c4a69 100644 --- a/stdlib/printexc.mli +++ b/stdlib/printexc.mli @@ -168,10 +168,17 @@ external get_callstack: int -> raw_backtrace = "caml_get_current_callstack" (** {1 Uncaught exceptions} *) +val default_uncaught_exception_handler: exn -> raw_backtrace -> unit +(** [Printexc.default_uncaught_exception_handler] prints the exception and + backtrace on standard error output. + + @since 4.11 +*) + val set_uncaught_exception_handler: (exn -> raw_backtrace -> unit) -> unit (** [Printexc.set_uncaught_exception_handler fn] registers [fn] as the handler - for uncaught exceptions. The default handler prints the exception and - backtrace on standard error output. + for uncaught exceptions. The default handler is + {!Printexc.default_uncaught_exception_handler}. Note that when [fn] is called all the functions registered with {!Stdlib.at_exit} have already been called. Because of this you must @@ -262,6 +269,16 @@ module Slot : sig @since 4.02 *) + val name : t -> string option + (** [name slot] returns the name of the function or definition + enclosing the location referred to by the slot. + + [name slot] returns None if the name is unavailable, which + may happen for the same reasons as [location] returning None. + + @since 4.11 + *) + val format : int -> t -> string option (** [format pos slot] returns the string representation of [slot] as [raw_backtrace_to_string] would format it, assuming it is the diff --git a/stdlib/printf.ml b/stdlib/printf.ml index 814e82d1..af32fd1d 100644 --- a/stdlib/printf.ml +++ b/stdlib/printf.ml @@ -22,10 +22,12 @@ let kbprintf k b (Format (fmt, _)) = make_printf (fun acc -> bufput_acc b acc; k b) End_of_acc fmt let ikfprintf k oc (Format (fmt, _)) = make_iprintf k oc fmt +let ikbprintf = ikfprintf let fprintf oc fmt = kfprintf ignore oc fmt let bprintf b fmt = kbprintf ignore b fmt let ifprintf oc fmt = ikfprintf ignore oc fmt +let ibprintf b fmt = ikbprintf ignore b fmt let printf fmt = fprintf stdout fmt let eprintf fmt = fprintf stderr fmt diff --git a/stdlib/printf.mli b/stdlib/printf.mli index 8ecb819e..470af847 100644 --- a/stdlib/printf.mli +++ b/stdlib/printf.mli @@ -147,6 +147,12 @@ val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a @since 3.10.0 *) +val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a +(** Same as {!Printf.bprintf}, but does not print anything. + Useful to ignore some material when conditionally printing. + @since 4.11.0 +*) + (** Formatted output functions with continuations. *) val kfprintf : (out_channel -> 'd) -> out_channel -> @@ -175,6 +181,13 @@ val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> @since 3.10.0 *) +val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> + ('a, Buffer.t, unit, 'd) format4 -> 'a +(** Same as [kbprintf] above, but does not print anything. + Useful to ignore some material when conditionally printing. + @since 4.11.0 +*) + (** Deprecated *) val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a diff --git a/stdlib/scanf.mli b/stdlib/scanf.mli index 5f48632e..865ca8d1 100644 --- a/stdlib/scanf.mli +++ b/stdlib/scanf.mli @@ -498,7 +498,7 @@ val bscanf_format : (** [bscanf_format ic fmt f] reads a format string token from the formatted input channel [ic], according to the given format string [fmt], and applies [f] to the resulting format string value. - Raise {!Scan_failure} if the format string value read does not have the + @raise Scan_failure if the format string value read does not have the same type as [fmt]. @since 3.09.0 *) @@ -515,7 +515,7 @@ val format_from_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 (** [format_from_string s fmt] converts a string argument to a format string, according to the given format string [fmt]. - Raise {!Scan_failure} if [s], considered as a format string, does not + @raise Scan_failure if [s], considered as a format string, does not have the same type as [fmt]. @since 3.10.0 *) @@ -529,7 +529,7 @@ val unescaped : string -> string Always return a copy of the argument, even if there is no escape sequence in the argument. - Raise {!Scan_failure} if [s] is not properly escaped (i.e. [s] has invalid + @raise Scan_failure if [s] is not properly escaped (i.e. [s] has invalid escape sequences or special characters that are not properly escaped). For instance, [Scanf.unescaped "\""] will fail. @since 4.00.0 diff --git a/stdlib/seq.ml b/stdlib/seq.ml index ccdbfde4..88ac7935 100644 --- a/stdlib/seq.ml +++ b/stdlib/seq.ml @@ -25,6 +25,13 @@ let empty () = Nil let return x () = Cons (x, empty) +let cons x next () = Cons (x, next) + +let rec append seq1 seq2 () = + match seq1() with + | Nil -> seq2() + | Cons (x, next) -> Cons (x, append next seq2) + let rec map f seq () = match seq() with | Nil -> Nil | Cons (x, next) -> Cons (f x, map f next) @@ -71,3 +78,8 @@ let iter f seq = aux next in aux seq + +let rec unfold f u () = + match f u with + | None -> Nil + | Some (x, u') -> Cons (x, unfold f u') diff --git a/stdlib/seq.mli b/stdlib/seq.mli index e1b04779..8f730318 100644 --- a/stdlib/seq.mli +++ b/stdlib/seq.mli @@ -33,7 +33,7 @@ type 'a t = unit -> 'a node and +'a node = | Nil - | Cons of 'a * 'a t + | Cons of 'a * 'a t (**) (** A fully-evaluated list node, either empty or containing an element and a delayed tail. *) @@ -43,6 +43,14 @@ val empty : 'a t val return : 'a -> 'a t (** The singleton sequence containing only the given element. *) +val cons : 'a -> 'a t -> 'a t +(** [cons x xs] is the sequence containing the element [x] followed by + the sequence [xs] @since 4.11 *) + +val append : 'a t -> 'a t -> 'a t +(** [append xs ys] is the sequence [xs] followed by the sequence [ys] + @since 4.11 *) + val map : ('a -> 'b) -> 'a t -> 'b t (** [map f seq] returns a new sequence whose elements are the elements of [seq], transformed by [f]. @@ -80,3 +88,12 @@ val iter : ('a -> unit) -> 'a t -> unit (** Iterate on the sequence, calling the (imperative) function on every element. The traversal happens immediately and will not terminate on infinite sequences. *) + +val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t +(** Build a sequence from a step function and an initial value. + [unfold f u] returns [empty] if [f u] returns [None], + or [fun () -> Cons (x, unfold f y)] if [f u] returns [Some (x, y)]. + + For example, [unfold (function [] -> None | h::t -> Some (h,t)) l] + is equivalent to [List.to_seq l]. + @since 4.11 *) diff --git a/stdlib/set.ml b/stdlib/set.ml index 6c8fdce8..d8b8a459 100644 --- a/stdlib/set.ml +++ b/stdlib/set.ml @@ -44,6 +44,7 @@ module type S = val for_all: (elt -> bool) -> t -> bool val exists: (elt -> bool) -> t -> bool val filter: (elt -> bool) -> t -> t + val filter_map: (elt -> elt option) -> t -> t val partition: (elt -> bool) -> t -> t * t val cardinal: t -> int val elements: t -> elt list @@ -530,6 +531,27 @@ module Make(Ord: OrderedType) = if l == l' && v == v' && r == r' then t else try_join l' v' r' + let try_concat t1 t2 = + match (t1, t2) with + (Empty, t) -> t + | (t, Empty) -> t + | (_, _) -> try_join t1 (min_elt t2) (remove_min_elt t2) + + let rec filter_map f = function + | Empty -> Empty + | Node{l; v; r} as t -> + (* enforce left-to-right evaluation order *) + let l' = filter_map f l in + let v' = f v in + let r' = filter_map f r in + begin match v' with + | Some v' -> + if l == l' && v == v' && r == r' then t + else try_join l' v' r' + | None -> + try_concat l' r' + end + let of_sorted_list l = let rec sub n l = match n, l with diff --git a/stdlib/set.mli b/stdlib/set.mli index dd712809..91e39238 100644 --- a/stdlib/set.mli +++ b/stdlib/set.mli @@ -154,6 +154,22 @@ module type S = physically equal to [s]). @before 4.03 Physical equality was not ensured.*) + val filter_map: (elt -> elt option) -> t -> t + (** [filter_map f s] returns the set of all [v] such that + [f x = Some v] for some element [x] of [s]. + + For example, + {[filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) s]} + is the set of halves of the even elements of [s]. + + If no element of [s] is changed or dropped by [f] (if + [f x = Some x] for each element [x]), then + [s] is returned unchanged: the result of the function + is then physically equal to [s]. + + @since 4.11.0 + *) + val partition: (elt -> bool) -> t -> t * t (** [partition p s] returns a pair of sets [(s1, s2)], where [s1] is the set of all the elements of [s] that satisfy the diff --git a/stdlib/stdlib.mli b/stdlib/stdlib.mli index 737e37d9..c16acb51 100644 --- a/stdlib/stdlib.mli +++ b/stdlib/stdlib.mli @@ -355,12 +355,13 @@ external ( * ) : int -> int -> int = "%mulint" external ( / ) : int -> int -> int = "%divint" (** Integer division. - Raise [Division_by_zero] if the second argument is 0. Integer division rounds the real quotient of its arguments towards zero. More precisely, if [x >= 0] and [y > 0], [x / y] is the greatest integer less than or equal to the real quotient of [x] by [y]. Moreover, [(- x) / y = x / (- y) = - (x / y)]. Left-associative operator, see {!Ocaml_operators} for more information. + + @raise Division_by_zero if the second argument is 0. *) external ( mod ) : int -> int -> int = "%modint" @@ -370,8 +371,9 @@ external ( mod ) : int -> int -> int = "%modint" [abs(x mod y) <= abs(y) - 1]. If [y = 0], [x mod y] raises [Division_by_zero]. Note that [x mod y] is negative only if [x < 0]. - Raise [Division_by_zero] if [y] is zero. Left-associative operator, see {!Ocaml_operators} for more information. + + @raise Division_by_zero if [y] is zero. *) val abs : int -> int @@ -676,7 +678,7 @@ external int_of_char : char -> int = "%identity" val char_of_int : int -> char (** Return the character with the given ASCII code. - Raise [Invalid_argument "char_of_int"] if the argument is + @raise Invalid_argument if the argument is outside the range 0--255. *) @@ -952,7 +954,7 @@ val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit (** [output oc buf pos len] writes [len] characters from byte sequence [buf], starting at offset [pos], to the given output channel [oc]. - Raise [Invalid_argument "output"] if [pos] and [len] do not + @raise Invalid_argument if [pos] and [len] do not designate a valid range of [buf]. *) val output_substring : out_channel -> string -> int -> int -> unit @@ -1040,13 +1042,13 @@ val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char (** Read one character from the given input channel. - Raise [End_of_file] if there are no more characters to read. *) + @raise End_of_file if there are no more characters to read. *) val input_line : in_channel -> string (** Read characters from the given input channel, until a newline character is encountered. Return the string of all characters read, without the newline character at the end. - Raise [End_of_file] if the end of the file is reached + @raise End_of_file if the end of the file is reached at the beginning of line. *) val input : in_channel -> bytes -> int -> int -> int @@ -1069,27 +1071,27 @@ val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit (** [really_input ic buf pos len] reads [len] characters from channel [ic], storing them in byte sequence [buf], starting at character number [pos]. - Raise [End_of_file] if the end of file is reached before [len] + @raise End_of_file if the end of file is reached before [len] characters have been read. - Raise [Invalid_argument "really_input"] if + @raise Invalid_argument if [pos] and [len] do not designate a valid range of [buf]. *) val really_input_string : in_channel -> int -> string (** [really_input_string ic len] reads [len] characters from channel [ic] and returns them in a new string. - Raise [End_of_file] if the end of file is reached before [len] + @raise End_of_file if the end of file is reached before [len] characters have been read. @since 4.02.0 *) val input_byte : in_channel -> int (** Same as {!Stdlib.input_char}, but return the 8-bit integer representing the character. - Raise [End_of_file] if an end of file was reached. *) + @raise End_of_file if an end of file was reached. *) val input_binary_int : in_channel -> int (** Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See {!Stdlib.output_binary_int}. - Raise [End_of_file] if an end of file was reached while reading the + @raise End_of_file if an end of file was reached while reading the integer. *) val input_value : in_channel -> 'a diff --git a/stdlib/stream.mli b/stdlib/stream.mli index e52bab89..93c2c315 100644 --- a/stdlib/stream.mli +++ b/stdlib/stream.mli @@ -67,7 +67,8 @@ val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a (** Return the first element of the stream and remove it from the - stream. Raise {!Stream.Failure} if the stream is empty. *) + stream. + @raise Stream.Failure if the stream is empty. *) val empty : 'a t -> unit (** Return [()] if the stream is empty, else raise {!Stream.Failure}. *) diff --git a/stdlib/string.mli b/stdlib/string.mli index a38c8123..82dda271 100644 --- a/stdlib/string.mli +++ b/stdlib/string.mli @@ -52,8 +52,7 @@ external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" (** [String.get s n] returns the character at index [n] in string [s]. You can also write [s.[n]] instead of [String.get s n]. - - Raise [Invalid_argument] if [n] not a valid index in [s]. *) + @raise Invalid_argument if [n] not a valid index in [s]. *) external set : bytes -> int -> char -> unit = "%string_safe_set" @@ -61,8 +60,7 @@ external set : bytes -> int -> char -> unit = "%string_safe_set" (** [String.set s n c] modifies byte sequence [s] in place, replacing the byte at index [n] with [c]. You can also write [s.[n] <- c] instead of [String.set s n c]. - - Raise [Invalid_argument] if [n] is not a valid index in [s]. + @raise Invalid_argument if [n] is not a valid index in [s]. @deprecated This is a deprecated alias of {!Bytes.set}.[ ] *) @@ -70,24 +68,21 @@ external create : int -> bytes = "caml_create_string" [@@ocaml.deprecated "Use Bytes.create instead."] (** [String.create n] returns a fresh byte sequence of length [n]. The sequence is uninitialized and contains arbitrary bytes. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. @deprecated This is a deprecated alias of {!Bytes.create}.[ ] *) val make : int -> char -> string (** [String.make n c] returns a fresh string of length [n], filled with the character [c]. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val init : int -> (int -> char) -> string (** [String.init n f] returns a string of length [n], with character [i] initialized to the result of [f i] (called in increasing index order). - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. - + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. @since 4.02.0 *) @@ -101,16 +96,14 @@ val sub : string -> int -> int -> string (** [String.sub s start len] returns a fresh string of length [len], containing the substring of [s] that starts at position [start] and has length [len]. - - Raise [Invalid_argument] if [start] and [len] do not + @raise Invalid_argument if [start] and [len] do not designate a valid substring of [s]. *) val fill : bytes -> int -> int -> char -> unit [@@ocaml.deprecated "Use Bytes.fill instead."] (** [String.fill s start len c] modifies byte sequence [s] in place, replacing [len] bytes with [c], starting at [start]. - - Raise [Invalid_argument] if [start] and [len] do not + @raise Invalid_argument if [start] and [len] do not designate a valid range of [s]. @deprecated This is a deprecated alias of {!Bytes.fill}.[ ] *) @@ -121,8 +114,7 @@ val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string (** [String.concat sep sl] concatenates the list of strings [sl], inserting the separator string [sep] between each. - - Raise [Invalid_argument] if the result is longer than + @raise Invalid_argument if the result is longer than {!Sys.max_string_length} bytes. *) val iter : (char -> unit) -> string -> unit @@ -165,8 +157,7 @@ val escaped : string -> string If there is no special character in the argument that needs escaping, return the original string itself, not a copy. - - Raise [Invalid_argument] if the result is longer than + @raise Invalid_argument if the result is longer than {!Sys.max_string_length} bytes. The function {!Scanf.unescaped} is a left inverse of [escaped], @@ -176,8 +167,7 @@ val escaped : string -> string val index : string -> char -> int (** [String.index s c] returns the index of the first occurrence of character [c] in string [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val index_opt: string -> char -> int option (** [String.index_opt s c] returns the index of the first @@ -188,8 +178,7 @@ val index_opt: string -> char -> int option val rindex : string -> char -> int (** [String.rindex s c] returns the index of the last occurrence of character [c] in string [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val rindex_opt: string -> char -> int option (** [String.rindex_opt s c] returns the index of the last occurrence @@ -201,9 +190,8 @@ val index_from : string -> int -> char -> int (** [String.index_from s i c] returns the index of the first occurrence of character [c] in string [s] after position [i]. [String.index s c] is equivalent to [String.index_from s 0 c]. - - Raise [Invalid_argument] if [i] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] after position [i]. *) + @raise Invalid_argument if [i] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] after position [i]. *) val index_from_opt: string -> int -> char -> int option (** [String.index_from_opt s i c] returns the index of the @@ -211,7 +199,7 @@ val index_from_opt: string -> int -> char -> int option or [None] if [c] does not occur in [s] after position [i]. [String.index_opt s c] is equivalent to [String.index_from_opt s 0 c]. - Raise [Invalid_argument] if [i] is not a valid position in [s]. + @raise Invalid_argument if [i] is not a valid position in [s]. @since 4.05 *) @@ -221,9 +209,8 @@ val rindex_from : string -> int -> char -> int last occurrence of character [c] in string [s] before position [i+1]. [String.rindex s c] is equivalent to [String.rindex_from s (String.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *) + @raise Invalid_argument if [i+1] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] before position [i+1]. *) val rindex_from_opt: string -> int -> char -> int option (** [String.rindex_from_opt s i c] returns the index of the @@ -232,8 +219,7 @@ val rindex_from_opt: string -> int -> char -> int option [String.rindex_opt s c] is equivalent to [String.rindex_from_opt s (String.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. + @raise Invalid_argument if [i+1] is not a valid position in [s]. @since 4.05 *) @@ -247,14 +233,12 @@ val contains_from : string -> int -> char -> bool appears in [s] after position [start]. [String.contains s c] is equivalent to [String.contains_from s 0 c]. - - Raise [Invalid_argument] if [start] is not a valid position in [s]. *) + @raise Invalid_argument if [start] is not a valid position in [s]. *) val rcontains_from : string -> int -> char -> bool (** [String.rcontains_from s stop c] tests if character [c] appears in [s] before position [stop+1]. - - Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid + @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid position in [s]. *) val uppercase : string -> string diff --git a/stdlib/stringLabels.mli b/stdlib/stringLabels.mli index 29126b73..ca4289df 100644 --- a/stdlib/stringLabels.mli +++ b/stdlib/stringLabels.mli @@ -30,16 +30,14 @@ external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" (** [String.get s n] returns the character at index [n] in string [s]. You can also write [s.[n]] instead of [String.get s n]. - - Raise [Invalid_argument] if [n] not a valid index in [s]. *) + @raise Invalid_argument if [n] not a valid index in [s]. *) external set : bytes -> int -> char -> unit = "%string_safe_set" [@@ocaml.deprecated "Use BytesLabels.set instead."] (** [String.set s n c] modifies byte sequence [s] in place, replacing the byte at index [n] with [c]. You can also write [s.[n] <- c] instead of [String.set s n c]. - - Raise [Invalid_argument] if [n] is not a valid index in [s]. + @raise Invalid_argument if [n] is not a valid index in [s]. @deprecated This is a deprecated alias of {!BytesLabels.set}. *) @@ -47,22 +45,19 @@ external create : int -> bytes = "caml_create_string" [@@ocaml.deprecated "Use BytesLabels.create instead."] (** [String.create n] returns a fresh byte sequence of length [n]. The sequence is uninitialized and contains arbitrary bytes. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. @deprecated This is a deprecated alias of {!BytesLabels.create}. *) val make : int -> char -> string (** [String.make n c] returns a fresh string of length [n], filled with the character [c]. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *) + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *) val init : int -> f:(int -> char) -> string (** [init n f] returns a string of length [n], with character [i] initialized to the result of [f i]. - - Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. + @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. @since 4.02.0 *) val copy : string -> string [@@ocaml.deprecated] @@ -72,16 +67,14 @@ val sub : string -> pos:int -> len:int -> string (** [String.sub s start len] returns a fresh string of length [len], containing the substring of [s] that starts at position [start] and has length [len]. - - Raise [Invalid_argument] if [start] and [len] do not + @raise Invalid_argument if [start] and [len] do not designate a valid substring of [s]. *) val fill : bytes -> pos:int -> len:int -> char -> unit [@@ocaml.deprecated "Use BytesLabels.fill instead."] (** [String.fill s start len c] modifies byte sequence [s] in place, replacing [len] bytes by [c], starting at [start]. - - Raise [Invalid_argument] if [start] and [len] do not + @raise Invalid_argument if [start] and [len] do not designate a valid substring of [s]. @deprecated This is a deprecated alias of {!BytesLabels.fill}. *) @@ -92,8 +85,7 @@ val blit : (** [String.blit src srcoff dst dstoff len] copies [len] bytes from the string [src], starting at index [srcoff], to byte sequence [dst], starting at character number [dstoff]. - - Raise [Invalid_argument] if [srcoff] and [len] do not + @raise Invalid_argument if [srcoff] and [len] do not designate a valid range of [src], or if [dstoff] and [len] do not designate a valid range of [dst]. *) @@ -142,8 +134,7 @@ val escaped : string -> string val index : string -> char -> int (** [String.index s c] returns the index of the first occurrence of character [c] in string [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val index_opt: string -> char -> int option (** [String.index_opt s c] returns the index of the first @@ -154,8 +145,7 @@ val index_opt: string -> char -> int option val rindex : string -> char -> int (** [String.rindex s c] returns the index of the last occurrence of character [c] in string [s]. - - Raise [Not_found] if [c] does not occur in [s]. *) + @raise Not_found if [c] does not occur in [s]. *) val rindex_opt: string -> char -> int option (** [String.rindex_opt s c] returns the index of the last occurrence @@ -167,9 +157,8 @@ val index_from : string -> int -> char -> int (** [String.index_from s i c] returns the index of the first occurrence of character [c] in string [s] after position [i]. [String.index s c] is equivalent to [String.index_from s 0 c]. - - Raise [Invalid_argument] if [i] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] after position [i]. *) + @raise Invalid_argument if [i] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] after position [i]. *) val index_from_opt: string -> int -> char -> int option (** [String.index_from_opt s i c] returns the index of the @@ -177,7 +166,7 @@ val index_from_opt: string -> int -> char -> int option or [None] if [c] does not occur in [s] after position [i]. [String.index_opt s c] is equivalent to [String.index_from_opt s 0 c]. - Raise [Invalid_argument] if [i] is not a valid position in [s]. + @raise Invalid_argument if [i] is not a valid position in [s]. @since 4.05 *) @@ -187,9 +176,8 @@ val rindex_from : string -> int -> char -> int last occurrence of character [c] in string [s] before position [i+1]. [String.rindex s c] is equivalent to [String.rindex_from s (String.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. - Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *) + @raise Invalid_argument if [i+1] is not a valid position in [s]. + @raise Not_found if [c] does not occur in [s] before position [i+1]. *) val rindex_from_opt: string -> int -> char -> int option (** [String.rindex_from_opt s i c] returns the index of the @@ -198,8 +186,7 @@ val rindex_from_opt: string -> int -> char -> int option [String.rindex_opt s c] is equivalent to [String.rindex_from_opt s (String.length s - 1) c]. - - Raise [Invalid_argument] if [i+1] is not a valid position in [s]. + @raise Invalid_argument if [i+1] is not a valid position in [s]. @since 4.05 *) @@ -213,14 +200,12 @@ val contains_from : string -> int -> char -> bool appears in [s] after position [start]. [String.contains s c] is equivalent to [String.contains_from s 0 c]. - - Raise [Invalid_argument] if [start] is not a valid position in [s]. *) + @raise Invalid_argument if [start] is not a valid position in [s]. *) val rcontains_from : string -> int -> char -> bool (** [String.rcontains_from s stop c] tests if character [c] appears in [s] before position [stop+1]. - - Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid + @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid position in [s]. *) val uppercase : string -> string diff --git a/stdlib/sys.mli b/stdlib/sys.mli index 0be4ed1a..368baa0f 100644 --- a/stdlib/sys.mli +++ b/stdlib/sys.mli @@ -38,7 +38,7 @@ external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" (** Returns [true] if the given name refers to a directory, [false] if it refers to another kind of file. - Raise [Sys_error] if no file exists with the given name. + @raise Sys_error if no file exists with the given name. @since 3.10.0 *) @@ -57,7 +57,8 @@ external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" (** Return the value associated to a variable in the process - environment. Raise [Not_found] if the variable is unbound. *) + environment. + @raise Not_found if the variable is unbound. *) val getenv_opt: string -> string option (** Return the value associated to a variable in the process @@ -77,7 +78,7 @@ external command : string -> int = "caml_sys_system_command" such as file redirections [>] and [<], which will be honored by the shell. - Conversely, whitespace or special shell characters occuring in + Conversely, whitespace or special shell characters occurring in command names or in their arguments must be quoted or escaped so that the shell does not interpret them. The quoting rules vary between the POSIX shell and the Windows shell. @@ -320,10 +321,12 @@ val catch_break : bool -> unit val ocaml_version : string (** [ocaml_version] is the version of OCaml. - It is a string of the form ["major.minor[.patchlevel][+additional-info]"], + It is a string of the form + ["major.minor[.patchlevel][(+|~)additional-info]"], where [major], [minor], and [patchlevel] are integers, and - [additional-info] is an arbitrary string. The [[.patchlevel]] and - [[+additional-info]] parts may be absent. *) + [additional-info] is an arbitrary string. + The [[.patchlevel]] part is absent for versions anterior to 3.08.0. + The [[(+|~)additional-info]] part may be absent. *) val enable_runtime_warnings: bool -> unit diff --git a/stdlib/unit.mli b/stdlib/unit.mli index 8c7cb211..e71f279a 100644 --- a/stdlib/unit.mli +++ b/stdlib/unit.mli @@ -19,7 +19,7 @@ (** {1:unit The unit type} *) -type t = unit = () +type t = unit = () (**) (** The unit type. The constructor [()] is included here so that it has a path, diff --git a/stdlib/weak.mli b/stdlib/weak.mli index a1f304c4..878e590a 100644 --- a/stdlib/weak.mli +++ b/stdlib/weak.mli @@ -39,7 +39,8 @@ type 'a t val create : int -> 'a t (** [Weak.create n] returns a new weak array of length [n]. - All the pointers are initially empty. Raise [Invalid_argument] + All the pointers are initially empty. + @raise Invalid_argument if [n] is not comprised between zero and {!Obj.Ephemeron.max_ephe_length} (limits included).*) @@ -51,13 +52,13 @@ val set : 'a t -> int -> 'a option -> unit (** [Weak.set ar n (Some el)] sets the [n]th cell of [ar] to be a (full) pointer to [el]; [Weak.set ar n None] sets the [n]th cell of [ar] to empty. - Raise [Invalid_argument "Weak.set"] if [n] is not in the range + @raise Invalid_argument if [n] is not in the range 0 to {!Weak.length}[ a - 1].*) val get : 'a t -> int -> 'a option (** [Weak.get ar n] returns None if the [n]th cell of [ar] is empty, [Some x] (where [x] is the value) if it is full. - Raise [Invalid_argument "Weak.get"] if [n] is not in the range + @raise Invalid_argument if [n] is not in the range 0 to {!Weak.length}[ a - 1].*) val get_copy : 'a t -> int -> 'a option @@ -68,7 +69,7 @@ val get_copy : 'a t -> int -> 'a option difference with [get] is that [get_copy] does not prevent the incremental GC from erasing the value in its current cycle ([get] may delay the erasure to the next GC cycle). - Raise [Invalid_argument "Weak.get"] if [n] is not in the range + @raise Invalid_argument if [n] is not in the range 0 to {!Weak.length}[ a - 1]. If the element is a custom block it is not copied. @@ -83,14 +84,15 @@ val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit (** [Weak.fill ar ofs len el] sets to [el] all pointers of [ar] from - [ofs] to [ofs + len - 1]. Raise [Invalid_argument "Weak.fill"] + [ofs] to [ofs + len - 1]. + @raise Invalid_argument if [ofs] and [len] do not designate a valid subarray of [a].*) val blit : 'a t -> int -> 'a t -> int -> int -> unit (** [Weak.blit ar1 off1 ar2 off2 len] copies [len] weak pointers from [ar1] (starting at [off1]) to [ar2] (starting at [off2]). It works correctly even if [ar1] and [ar2] are the same. - Raise [Invalid_argument "Weak.blit"] if [off1] and [len] do + @raise Invalid_argument if [off1] and [len] do not designate a valid subarray of [ar1], or if [off2] and [len] do not designate a valid subarray of [ar2].*) @@ -142,7 +144,7 @@ module type S = sig val find : t -> data -> data (** [find t x] returns an instance of [x] found in [t]. - Raise [Not_found] if there is no such element. *) + @raise Not_found if there is no such element. *) val find_opt: t -> data -> data option (** [find_opt t x] returns an instance of [x] found in [t] diff --git a/testsuite/Makefile b/testsuite/Makefile index 9d7d6dc7..5cd2d6df 100644 --- a/testsuite/Makefile +++ b/testsuite/Makefile @@ -13,6 +13,8 @@ #* * #************************************************************************** +.NOTPARALLEL: + BASEDIR := $(shell pwd) NO_PRINT=`$(MAKE) empty --no-print-directory >/dev/null 2>&1 \ && echo --no-print-directory` @@ -62,6 +64,29 @@ else $(ocamltest_program) endif +# PROMOTE is only meant to be used internally in recursive calls; +# users should call the 'promote' target explicitly. +PROMOTE = +ifeq "$(PROMOTE)" "" + OCAMLTEST_PROMOTE_FLAG := +else + OCAMLTEST_PROMOTE_FLAG := -promote +endif + +# KEEP_TEST_DIR_ON_SUCCESS should be set by the user (to a non-empty value) +# if they want to pass the -keep-test-dir-on-success option to ocamltest, +# to preserve test data of succesful tests. +KEEP_TEST_DIR_ON_SUCCESS ?= +ifeq "$(KEEP_TEST_DIR_ON_SUCCESS)" "" + OCAMLTEST_KEEP_TEST_DIR_ON_SUCCESS_FLAG := +else + OCAMLTEST_KEEP_TEST_DIR_ON_SUCCESS_FLAG := -keep-test-dir-on-success +endif + +OCAMLTESTFLAGS := \ + $(OCAMLTEST_PROMOTE_FLAG) \ + $(OCAMLTEST_KEEP_TEST_DIR_ON_SUCCESS_FLAG) + .PHONY: default default: @echo "Available targets:" @@ -95,7 +120,7 @@ new-without-report: lib tools $(ocamltest) -find-test-dirs tests | while read dir; do \ echo Running tests from \'$$dir\' ... ; \ $(MAKE) exec-ocamltest DIR=$$dir \ - OCAMLTESTENV="" OCAMLTESTFLAGS=""; \ + OCAMLTESTENV=""; \ done || echo outer loop >> $(failstamp)) 2>&1 | tee -a $(TESTLOG) @$(MAKE) check-failstamp @@ -190,8 +215,7 @@ exec-one: @if $(ocamltest) -list-tests $(DIR) >/dev/null 2>&1; then \ echo "Running tests from '$$DIR' ..."; \ $(MAKE) exec-ocamltest DIR=$(DIR) \ - OCAMLTESTENV="OCAMLTESTDIR=$(OCAMLTESTDIR_CYGPATH)" \ - OCAMLTESTFLAGS=""; \ + OCAMLTESTENV="OCAMLTESTDIR=$(OCAMLTESTDIR_CYGPATH)"; \ else \ for dir in $(DIR)/*; do \ if [ -d $$dir ]; then \ @@ -236,7 +260,7 @@ promote: @if $(ocamltest) -list-tests $(DIR) >/dev/null 2>&1; then \ $(MAKE) exec-ocamltest DIR=$(DIR) \ OCAMLTESTENV="OCAMLTESTDIR=$(OCAMLTESTDIR_CYGPATH)" \ - OCAMLTESTFLAGS="-promote"; \ + PROMOTE="true"; \ else \ cd $(DIR) && $(MAKE) TERM=dumb BASEDIR=$(BASEDIR) promote; \ fi diff --git a/testsuite/lib/Makefile b/testsuite/lib/Makefile index 982d021f..740a9ca8 100644 --- a/testsuite/lib/Makefile +++ b/testsuite/lib/Makefile @@ -13,6 +13,8 @@ #* * #************************************************************************** +.NOTPARALLEL: + TOPDIR = ../.. COMPFLAGS ?= RUNTIME_VARIANT ?= @@ -47,4 +49,4 @@ testing.cmo : testing.cmi .PHONY: clean clean: - rm -f *.cm* *.$(O) *.$(A) + rm -f *.cm* *.o *.obj *.a *.lib diff --git a/testsuite/tests/array-functions/test.ml b/testsuite/tests/array-functions/test.ml index c7f101ed..272b1c58 100644 --- a/testsuite/tests/array-functions/test.ml +++ b/testsuite/tests/array-functions/test.ml @@ -126,6 +126,101 @@ let () = assert (Array.for_all (fun _ -> true) a); ;; +let does_raise3 f a b c = + try + ignore (f a b c); + false + with _ -> + true + +let () = + let a = [|1;2;3;4;5;6;7;8;9|] + and b = [|1;2;3;4;5;6;7;8;9|] in + assert (Array.exists2 (fun a b -> a = b) a b); + assert (Array.exists2 (fun a b -> a - b = 0) a b); + assert (Array.exists2 (fun a b -> a = 1 && b = 1) a b); + assert (Array.exists2 (fun a b -> a = 2 && b = 2) a b); + assert (Array.exists2 (fun a b -> a = 3 && b = 3) a b); + assert (Array.exists2 (fun a b -> a = 4 && b = 4) a b); + assert (Array.exists2 (fun a b -> a = 5 && b = 5) a b); + assert (Array.exists2 (fun a b -> a = 6 && b = 6) a b); + assert (Array.exists2 (fun a b -> a = 7 && b = 7) a b); + assert (Array.exists2 (fun a b -> a = 8 && b = 8) a b); + assert (Array.exists2 (fun a b -> a = 9 && b = 9) a b); + assert (not (Array.exists2 (fun a b -> a <> b) a b)); +;; + +let () = + let a = [|1|] + and b = [|1;2|] in + assert (does_raise3 Array.exists2 (fun a b -> a = b) a b); + assert (does_raise3 Array.exists2 (fun _ _ -> true) a b); + assert (does_raise3 Array.exists2 (fun _ _ -> false) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 1 && b = 1) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 2 && b = 2) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 3 && b = 3) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 4 && b = 4) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 5 && b = 5) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 6 && b = 6) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 7 && b = 7) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 8 && b = 8) a b); + assert (does_raise3 Array.exists2 (fun a b -> a = 9 && b = 9) a b); +;; + +let () = + assert (Array.exists2 (=) [|1;2;3|] [|3;2;1|]); + assert (not (Array.exists2 (<>) [|1;2;3|] [|1;2;3|])); + assert (does_raise3 Array.exists2 (=) [|1;2|] [|3|]); + let f = Array.create_float 10 in + let g = Array.create_float 10 in + Array.fill f 0 10 1.0; + Array.fill g 0 10 1.0; + assert (Array.exists2 (fun a b -> a = 1.0 && b = 1.0) f g); +;; + +let () = + let a = [|1;2;3;4;5;6;7;8;9|] + and b = [|1;2;3;4;5;6;7;8;9|] in + assert (Array.for_all2 (fun a b -> a = b) a b); + assert (Array.for_all2 (fun a b -> a - b = 0) a b); + assert (Array.for_all2 (fun a b -> a > 0 && b > 0) a b); + assert (Array.for_all2 (fun a b -> a < 10 && b < 10) a b); + assert (Array.for_all2 (fun a b -> if a = 1 then b = 1 else b <> 1) a b); + assert (Array.for_all2 (fun a b -> if a = 2 then b = 2 else b <> 2) a b); + assert (Array.for_all2 (fun a b -> if a = 3 then b = 3 else b <> 3) a b); + assert (Array.for_all2 (fun a b -> if a = 4 then b = 4 else b <> 4) a b); + assert (Array.for_all2 (fun a b -> if a = 5 then b = 5 else b <> 5) a b); + assert (Array.for_all2 (fun a b -> if a = 6 then b = 6 else b <> 6) a b); + assert (Array.for_all2 (fun a b -> if a = 7 then b = 7 else b <> 7) a b); + assert (Array.for_all2 (fun a b -> if a = 8 then b = 8 else b <> 8) a b); + assert (Array.for_all2 (fun a b -> if a = 9 then b = 9 else b <> 9) a b); + assert (not (Array.for_all2 (fun a b -> a <> b) a b)); +;; + +let () = + let a = [|1|] + and b = [|1;2|] in + assert (does_raise3 Array.for_all2 (fun a b -> a = b) a b); + assert (does_raise3 Array.for_all2 (fun _ _ -> true) a b); + assert (does_raise3 Array.for_all2 (fun _ _ -> false) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 1 && b = 1) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 2 && b = 2) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 3 && b = 3) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 4 && b = 4) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 5 && b = 5) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 6 && b = 6) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 7 && b = 7) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 8 && b = 8) a b); + assert (does_raise3 Array.for_all2 (fun a b -> a = 9 && b = 9) a b); +;; + +let () = + assert (not (Array.for_all2 (=) [|1;2;3|] [|3;2;1|])); + assert (Array.for_all2 (=) [|1;2;3|] [|1;2;3|]); + assert (not (Array.for_all2 (<>) [|1;2;3|] [|3;2;1|])); + assert (does_raise3 Array.for_all2 (=) [|1;2;3|] [|1;2;3;4|]); + assert (does_raise3 Array.for_all2 (=) [|1;2|] [||]); +;; let () = let a = [|1;2;3;4;5;6;7;8;9|] in diff --git a/testsuite/tests/asmcomp/0001-test.compilers.reference b/testsuite/tests/asmcomp/0001-test.compilers.reference new file mode 100644 index 00000000..c2c5166b --- /dev/null +++ b/testsuite/tests/asmcomp/0001-test.compilers.reference @@ -0,0 +1,2 @@ +File "0001-test.ml", line 1: +Warning 24: bad source file name: "0001-test" is not a valid module name. diff --git a/testsuite/tests/asmcomp/0001-test.ml b/testsuite/tests/asmcomp/0001-test.ml new file mode 100644 index 00000000..bffd6f1c --- /dev/null +++ b/testsuite/tests/asmcomp/0001-test.ml @@ -0,0 +1 @@ +(* TEST *) diff --git a/testsuite/tests/asmcomp/compare.ml b/testsuite/tests/asmcomp/compare.ml new file mode 100644 index 00000000..b51116e3 --- /dev/null +++ b/testsuite/tests/asmcomp/compare.ml @@ -0,0 +1,10 @@ +(* TEST + * native +*) +let[@inline never] float () = print_string "hello\n"; 42. +let[@inline never] f () = compare (float ()) 0.5;; +let _ = f () + +let[@inline never] myint () = print_string "bye\n"; 42 +let[@inline never] g () = compare (myint ()) 5;; +let _ = g () diff --git a/testsuite/tests/asmcomp/compare.reference b/testsuite/tests/asmcomp/compare.reference new file mode 100644 index 00000000..410ca140 --- /dev/null +++ b/testsuite/tests/asmcomp/compare.reference @@ -0,0 +1,2 @@ +hello +bye diff --git a/testsuite/tests/asmgen/arith.cmm b/testsuite/tests/asmgen/arith.cmm index fad3f29f..4d26aac1 100644 --- a/testsuite/tests/asmgen/arith.cmm +++ b/testsuite/tests/asmgen/arith.cmm @@ -171,12 +171,12 @@ arguments = "mainarith.c" (seq (checkbound y 5) (addraset r 90 1)) (addraset r 90 0)) - (addraset r 91 (let res 1 (if (==f f g) [] (assign res 0)) res)) - (addraset r 92 (let res 1 (if (!=f f g) [] (assign res 0)) res)) - (addraset r 93 (let res 1 (if (f f g) [] (assign res 0)) res)) - (addraset r 95 (let res 1 (if (<=f f g) [] (assign res 0)) res)) - (addraset r 96 (let res 1 (if (>=f f g) [] (assign res 0)) res)) + (addraset r 91 (letmut res int 1 (if (==f f g) [] (assign res 0)) res)) + (addraset r 92 (letmut res int 1 (if (!=f f g) [] (assign res 0)) res)) + (addraset r 93 (letmut res int 1 (if (f f g) [] (assign res 0)) res)) + (addraset r 95 (letmut res int 1 (if (<=f f g) [] (assign res 0)) res)) + (addraset r 96 (letmut res int 1 (if (>=f f g) [] (assign res 0)) res)) (addraset r 97 (==f (+f f 1.0) (+f g 1.0))) (addraset r 98 (!=f (+f f 1.0) (+f g 1.0))) diff --git a/testsuite/tests/asmgen/mainarith.c b/testsuite/tests/asmgen/mainarith.c index cdba6a9d..354ab02d 100644 --- a/testsuite/tests/asmgen/mainarith.c +++ b/testsuite/tests/asmgen/mainarith.c @@ -32,6 +32,7 @@ intnat R[200]; double D[40]; intnat X, Y; double F, G; +volatile double H; #define INTTEST(arg,res) \ { intnat result = (res); \ @@ -48,7 +49,9 @@ double F, G; #arg, #res, F, G, arg, result); \ } #define FLOATTEST(arg,res) \ - { double result = (res); \ + { double result; \ + H = (res); \ + result = H; \ if (arg < result || arg > result) \ printf("Failed test \"%s == %s\" for F=%.15g and G=%.15g: "\ "result %.15g, expected %.15g\n", \ diff --git a/testsuite/tests/asmgen/quicksort.cmm b/testsuite/tests/asmgen/quicksort.cmm index 80320505..5ac97a41 100644 --- a/testsuite/tests/asmgen/quicksort.cmm +++ b/testsuite/tests/asmgen/quicksort.cmm @@ -21,9 +21,9 @@ arguments = "-DSORT -DFUN=quicksort main.c" (function "quicksort" (lo: int hi: int a: val) (if (< lo hi) - (let (i lo - j hi - pivot (addraref a hi)) + (letmut (i int lo + j int hi + pivot int (addraref a hi)) (while (< i j) (catch (while 1 diff --git a/testsuite/tests/asmgen/quicksort2.cmm b/testsuite/tests/asmgen/quicksort2.cmm index 4e5a6c68..b5822eca 100644 --- a/testsuite/tests/asmgen/quicksort2.cmm +++ b/testsuite/tests/asmgen/quicksort2.cmm @@ -24,9 +24,9 @@ arguments = "-DSORT -DFUN=quicksort main.c" (function "quick" (lo: int hi: int a: val cmp: val) (if (< lo hi) - (let (i lo - j hi - pivot (intaref a hi)) + (letmut (i int lo + j int hi + pivot int (intaref a hi)) (while (< i j) (catch (while 1 diff --git a/testsuite/tests/asmgen/soli.cmm b/testsuite/tests/asmgen/soli.cmm index cd0822b1..93be3aab 100644 --- a/testsuite/tests/asmgen/soli.cmm +++ b/testsuite/tests/asmgen/soli.cmm @@ -51,13 +51,13 @@ arguments = "-DUNIT_INT -DFUN=solitaire main.c" (if (== (mod (load int "counter") 500) 0) (extcall "printf_int" "format" (load int "counter") unit) []) - (let i 1 + (letmut i int 1 (while (<= i 7) - (let j 1 + (letmut j int 1 (while (<= j 7) (if (== (intaref (addraref "board" i) j) 2) (seq - (let k 0 + (letmut k int 0 (while (<= k 3) (let (d1 (intaref (addraref "dir" k) 0) d2 (intaref (addraref "dir" k) 1) @@ -93,9 +93,9 @@ arguments = "-DUNIT_INT -DFUN=solitaire main.c" ("format_newline": string "\n\000") (function "print_board" () - (let i 0 + (letmut i int 0 (while (< i 9) - (let j 0 + (letmut j int 0 (while (< j 9) (switch 3 (intaref (addraref "board" i) j) case 0: diff --git a/testsuite/tests/asmgen/tagged-integr.cmm b/testsuite/tests/asmgen/tagged-integr.cmm index c2781efe..8903405f 100644 --- a/testsuite/tests/asmgen/tagged-integr.cmm +++ b/testsuite/tests/asmgen/tagged-integr.cmm @@ -31,7 +31,7 @@ arguments = "-DINT_FLOAT -DFUN=test main.c" r)) (function "integr" (f: val low: val high: val n: int) - (let (h "h" x "x" s "s" i n) + (letmut (h val "h" x val "x" s val "s" i int n) (store float h (/f (-f (load float high) (load float low)) (floatofint n))) (store float x (load float low)) (store float s 0.0) diff --git a/testsuite/tests/asmgen/tagged-quicksort.cmm b/testsuite/tests/asmgen/tagged-quicksort.cmm index f2255148..631dd6aa 100644 --- a/testsuite/tests/asmgen/tagged-quicksort.cmm +++ b/testsuite/tests/asmgen/tagged-quicksort.cmm @@ -21,9 +21,9 @@ arguments = "-DSORT -DFUN=quicksort main.c" (function "quick" (lo: int hi: int a: val) (if (< lo hi) - (let (i lo - j hi - pivot (addraref a (>>s hi 1))) + (letmut (i int lo + j int hi + pivot int (addraref a (>>s hi 1))) (while (< i j) (catch (while 1 diff --git a/testsuite/tests/backtrace/backtrace.byte.reference b/testsuite/tests/backtrace/backtrace.byte.reference deleted file mode 100644 index 224f5fd9..00000000 --- a/testsuite/tests/backtrace/backtrace.byte.reference +++ /dev/null @@ -1,26 +0,0 @@ -a -b -Fatal error: exception Backtrace.Error("b") -Raised at file "backtrace.ml", line 16, characters 21-32 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 20, characters 4-11 -Re-raised at file "backtrace.ml", line 22, characters 68-71 -Called from file "backtrace.ml", line 27, characters 9-25 -Fatal error: exception Backtrace.Error("c") -Raised at file "backtrace.ml", line 23, characters 26-37 -Called from file "backtrace.ml", line 27, characters 9-25 -Fatal error: exception Backtrace.Error("d") -Raised at file "backtrace.ml", line 16, characters 21-32 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 20, characters 4-11 -Called from file "backtrace.ml", line 27, characters 9-25 -Fatal error: exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace.ml", line 27, characters 12-24 diff --git a/testsuite/tests/backtrace/backtrace.ml b/testsuite/tests/backtrace/backtrace.ml index 6ef8b37c..02a9343e 100644 --- a/testsuite/tests/backtrace/backtrace.ml +++ b/testsuite/tests/backtrace/backtrace.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference = "${test_source_directory}/backtrace.byte.reference" - * native - reference = "${test_source_directory}/backtrace.opt.reference" - compare_programs = "false" + compare_programs = "false" *) (* A test for stack backtraces *) diff --git a/testsuite/tests/backtrace/backtrace.opt.reference b/testsuite/tests/backtrace/backtrace.opt.reference deleted file mode 100644 index 42ed7662..00000000 --- a/testsuite/tests/backtrace/backtrace.opt.reference +++ /dev/null @@ -1,26 +0,0 @@ -a -b -Fatal error: exception Backtrace.Error("b") -Raised at file "backtrace.ml", line 16, characters 16-32 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 20, characters 4-11 -Re-raised at file "backtrace.ml", line 22, characters 62-71 -Called from file "backtrace.ml", line 27, characters 9-25 -Fatal error: exception Backtrace.Error("c") -Raised at file "backtrace.ml", line 23, characters 20-37 -Called from file "backtrace.ml", line 27, characters 9-25 -Fatal error: exception Backtrace.Error("d") -Raised at file "backtrace.ml", line 16, characters 16-32 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 16, characters 42-53 -Called from file "backtrace.ml", line 20, characters 4-11 -Called from file "backtrace.ml", line 27, characters 9-25 -Fatal error: exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace.ml", line 27, characters 12-24 diff --git a/testsuite/tests/backtrace/backtrace.reference b/testsuite/tests/backtrace/backtrace.reference new file mode 100644 index 00000000..ad4e1fa4 --- /dev/null +++ b/testsuite/tests/backtrace/backtrace.reference @@ -0,0 +1,26 @@ +a +b +Fatal error: exception Backtrace.Error("b") +Raised at Backtrace.f in file "backtrace.ml", line 12, characters 16-32 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.g in file "backtrace.ml", line 16, characters 4-11 +Re-raised at Backtrace.g in file "backtrace.ml", line 18, characters 62-71 +Called from Backtrace in file "backtrace.ml", line 23, characters 9-25 +Fatal error: exception Backtrace.Error("c") +Raised at Backtrace.g in file "backtrace.ml", line 19, characters 20-37 +Called from Backtrace in file "backtrace.ml", line 23, characters 9-25 +Fatal error: exception Backtrace.Error("d") +Raised at Backtrace.f in file "backtrace.ml", line 12, characters 16-32 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53 +Called from Backtrace.g in file "backtrace.ml", line 16, characters 4-11 +Called from Backtrace in file "backtrace.ml", line 23, characters 9-25 +Fatal error: exception Invalid_argument("index out of bounds") +Raised by primitive operation at Backtrace in file "backtrace.ml", line 23, characters 12-24 diff --git a/testsuite/tests/backtrace/backtrace2.byte.reference b/testsuite/tests/backtrace/backtrace2.byte.reference deleted file mode 100644 index 635eb09a..00000000 --- a/testsuite/tests/backtrace/backtrace2.byte.reference +++ /dev/null @@ -1,58 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace2.Error("b") -Raised at file "backtrace2.ml", line 17, characters 23-34 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 22, characters 4-11 -Re-raised at file "backtrace2.ml", line 24, characters 68-71 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Backtrace2.Error("c") -Raised at file "backtrace2.ml", line 25, characters 26-37 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Backtrace2.Error("d") -Raised at file "backtrace2.ml", line 17, characters 23-34 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 22, characters 4-11 -Called from file "backtrace2.ml", line 67, characters 11-23 -e -Uncaught exception Backtrace2.Error("e") -Raised at file "backtrace2.ml", line 31, characters 56-59 -Called from file "backtrace2.ml", line 67, characters 11-23 -f -Uncaught exception Backtrace2.Error("f") -Raised at file "backtrace2.ml", line 37, characters 68-71 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace2.ml", line 67, characters 14-22 -test_Not_found -Uncaught exception Not_found -Raised at file "hashtbl.ml", line 537, characters 19-28 -Called from file "backtrace2.ml", line 48, characters 9-42 -Re-raised at file "backtrace2.ml", line 48, characters 67-70 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Not_found -Raised at file "backtrace2.ml", line 52, characters 24-33 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "camlinternalLazy.ml", line 31, characters 17-27 -Re-raised at file "camlinternalLazy.ml", line 36, characters 10-11 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Not_found -Raised at file "hashtbl.ml", line 537, characters 19-28 -Called from file "backtrace2.ml", line 55, characters 8-41 -Re-raised at file "camlinternalLazy.ml", line 35, characters 62-63 -Called from file "camlinternalLazy.ml", line 31, characters 17-27 -Re-raised at file "camlinternalLazy.ml", line 36, characters 10-11 -Called from file "backtrace2.ml", line 67, characters 11-23 diff --git a/testsuite/tests/backtrace/backtrace2.ml b/testsuite/tests/backtrace/backtrace2.ml index 13c85f42..5b620866 100644 --- a/testsuite/tests/backtrace/backtrace2.ml +++ b/testsuite/tests/backtrace/backtrace2.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference = "${test_source_directory}/backtrace2.byte.reference" - * native - reference = "${test_source_directory}/backtrace2.opt.reference" - compare_programs = "false" + compare_programs = "false" *) (* A test for stack backtraces *) diff --git a/testsuite/tests/backtrace/backtrace2.opt.reference b/testsuite/tests/backtrace/backtrace2.opt.reference deleted file mode 100644 index e81e2807..00000000 --- a/testsuite/tests/backtrace/backtrace2.opt.reference +++ /dev/null @@ -1,58 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace2.Error("b") -Raised at file "backtrace2.ml", line 17, characters 18-34 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 22, characters 4-11 -Re-raised at file "backtrace2.ml", line 24, characters 62-71 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Backtrace2.Error("c") -Raised at file "backtrace2.ml", line 25, characters 20-37 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Backtrace2.Error("d") -Raised at file "backtrace2.ml", line 17, characters 18-34 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 17, characters 44-55 -Called from file "backtrace2.ml", line 22, characters 4-11 -Called from file "backtrace2.ml", line 67, characters 11-23 -e -Uncaught exception Backtrace2.Error("e") -Raised at file "backtrace2.ml", line 31, characters 50-59 -Called from file "backtrace2.ml", line 67, characters 11-23 -f -Uncaught exception Backtrace2.Error("f") -Raised at file "backtrace2.ml", line 37, characters 62-71 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace2.ml", line 67, characters 14-22 -test_Not_found -Uncaught exception Not_found -Raised at file "hashtbl.ml", line 537, characters 13-28 -Called from file "backtrace2.ml", line 48, characters 9-42 -Re-raised at file "backtrace2.ml", line 48, characters 61-70 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Not_found -Raised at file "backtrace2.ml", line 52, characters 18-33 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "backtrace2.ml", line 52, characters 43-52 -Called from file "camlinternalLazy.ml", line 31, characters 17-27 -Re-raised at file "camlinternalLazy.ml", line 36, characters 4-11 -Called from file "backtrace2.ml", line 67, characters 11-23 -Uncaught exception Not_found -Raised at file "hashtbl.ml", line 537, characters 13-28 -Called from file "backtrace2.ml", line 55, characters 8-41 -Re-raised at file "camlinternalLazy.ml", line 35, characters 56-63 -Called from file "camlinternalLazy.ml", line 31, characters 17-27 -Re-raised at file "camlinternalLazy.ml", line 36, characters 4-11 -Called from file "backtrace2.ml", line 67, characters 11-23 diff --git a/testsuite/tests/backtrace/backtrace2.reference b/testsuite/tests/backtrace/backtrace2.reference new file mode 100644 index 00000000..22666a7a --- /dev/null +++ b/testsuite/tests/backtrace/backtrace2.reference @@ -0,0 +1,58 @@ +a +No exception +b +Uncaught exception Backtrace2.Error("b") +Raised at Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 18-34 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error in file "backtrace2.ml", line 18, characters 4-11 +Re-raised at Backtrace2.test_Error in file "backtrace2.ml", line 20, characters 62-71 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +Uncaught exception Backtrace2.Error("c") +Raised at Backtrace2.test_Error in file "backtrace2.ml", line 21, characters 20-37 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +Uncaught exception Backtrace2.Error("d") +Raised at Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 18-34 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55 +Called from Backtrace2.test_Error in file "backtrace2.ml", line 18, characters 4-11 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +e +Uncaught exception Backtrace2.Error("e") +Raised at Backtrace2.test_Error in file "backtrace2.ml", line 27, characters 50-59 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +f +Uncaught exception Backtrace2.Error("f") +Raised at Backtrace2.test_Error in file "backtrace2.ml", line 33, characters 62-71 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +Uncaught exception Invalid_argument("index out of bounds") +Raised by primitive operation at Backtrace2.run in file "backtrace2.ml", line 63, characters 14-22 +test_Not_found +Uncaught exception Not_found +Raised at Stdlib__hashtbl.find in file "hashtbl.ml", line 537, characters 13-28 +Called from Backtrace2.test_Not_found in file "backtrace2.ml", line 44, characters 9-42 +Re-raised at Backtrace2.test_Not_found in file "backtrace2.ml", line 44, characters 61-70 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +Uncaught exception Not_found +Raised at Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 18-33 +Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52 +Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52 +Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52 +Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52 +Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52 +Called from CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 31, characters 17-27 +Re-raised at CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 36, characters 4-11 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 +Uncaught exception Not_found +Raised at Stdlib__hashtbl.find in file "hashtbl.ml", line 537, characters 13-28 +Called from Backtrace2.test_lazy.exception_raised_internally in file "backtrace2.ml", line 51, characters 8-41 +Re-raised at CamlinternalLazy.force_lazy_block.(fun) in file "camlinternalLazy.ml", line 35, characters 56-63 +Called from CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 31, characters 17-27 +Re-raised at CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 36, characters 4-11 +Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23 diff --git a/testsuite/tests/backtrace/backtrace3.byte.reference b/testsuite/tests/backtrace/backtrace3.byte.reference deleted file mode 100644 index c667cacb..00000000 --- a/testsuite/tests/backtrace/backtrace3.byte.reference +++ /dev/null @@ -1,66 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace3.Error("b") -Raised at file "backtrace3.ml", line 16, characters 21-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 29, characters 47-50 -Called from file "backtrace3.ml", line 54, characters 11-23 -c -Uncaught exception Backtrace3.Error("c") -Raised at file "backtrace3.ml", line 33, characters 47-58 -Called from file "backtrace3.ml", line 54, characters 11-23 -d -Uncaught exception Backtrace3.Error("d") -Raised at file "backtrace3.ml", line 16, characters 21-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 36, characters 47-50 -Called from file "backtrace3.ml", line 54, characters 11-23 -e -Uncaught exception Backtrace3.Error("e") -Raised at file "backtrace3.ml", line 16, characters 21-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 39, characters 47-51 -Called from file "backtrace3.ml", line 54, characters 11-23 -f -Uncaught exception Backtrace3.Error("f") -Raised at file "backtrace3.ml", line 16, characters 21-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 44, characters 51-54 -Called from file "backtrace3.ml", line 54, characters 11-23 -g -Uncaught exception Backtrace3.Error("g") -Raised at file "backtrace3.ml", line 16, characters 21-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 47, characters 51-55 -Called from file "backtrace3.ml", line 54, characters 11-23 -Uncaught exception Backtrace3.Error("h") -Raised at file "backtrace3.ml", line 50, characters 16-17 -Called from file "backtrace3.ml", line 54, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace3.ml", line 54, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace3.ml b/testsuite/tests/backtrace/backtrace3.ml index 14b7d33d..5f81bb85 100644 --- a/testsuite/tests/backtrace/backtrace3.ml +++ b/testsuite/tests/backtrace/backtrace3.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference = "${test_source_directory}/backtrace3.byte.reference" - * native - reference = "${test_source_directory}/backtrace3.opt.reference" - compare_programs = "false" + compare_programs = "false" *) (* A test for stack backtraces *) diff --git a/testsuite/tests/backtrace/backtrace3.opt.reference b/testsuite/tests/backtrace/backtrace3.opt.reference deleted file mode 100644 index 87740918..00000000 --- a/testsuite/tests/backtrace/backtrace3.opt.reference +++ /dev/null @@ -1,66 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace3.Error("b") -Raised at file "backtrace3.ml", line 16, characters 16-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 29, characters 41-50 -Called from file "backtrace3.ml", line 54, characters 11-23 -c -Uncaught exception Backtrace3.Error("c") -Raised at file "backtrace3.ml", line 33, characters 41-58 -Called from file "backtrace3.ml", line 54, characters 11-23 -d -Uncaught exception Backtrace3.Error("d") -Raised at file "backtrace3.ml", line 16, characters 16-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 36, characters 41-50 -Called from file "backtrace3.ml", line 54, characters 11-23 -e -Uncaught exception Backtrace3.Error("e") -Raised at file "backtrace3.ml", line 16, characters 16-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 39, characters 41-51 -Called from file "backtrace3.ml", line 54, characters 11-23 -f -Uncaught exception Backtrace3.Error("f") -Raised at file "backtrace3.ml", line 16, characters 16-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 44, characters 45-54 -Called from file "backtrace3.ml", line 54, characters 11-23 -g -Uncaught exception Backtrace3.Error("g") -Raised at file "backtrace3.ml", line 16, characters 16-32 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 16, characters 42-53 -Called from file "backtrace3.ml", line 20, characters 4-11 -Re-raised at file "backtrace3.ml", line 47, characters 45-55 -Called from file "backtrace3.ml", line 54, characters 11-23 -Uncaught exception Backtrace3.Error("h") -Raised at file "backtrace3.ml", line 50, characters 10-17 -Called from file "backtrace3.ml", line 54, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace3.ml", line 54, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace3.reference b/testsuite/tests/backtrace/backtrace3.reference new file mode 100644 index 00000000..b8b0456d --- /dev/null +++ b/testsuite/tests/backtrace/backtrace3.reference @@ -0,0 +1,66 @@ +a +No exception +b +Uncaught exception Backtrace3.Error("b") +Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11 +Re-raised at Backtrace3.g in file "backtrace3.ml", line 25, characters 41-50 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +c +Uncaught exception Backtrace3.Error("c") +Raised at Backtrace3.g in file "backtrace3.ml", line 29, characters 41-58 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +d +Uncaught exception Backtrace3.Error("d") +Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11 +Re-raised at Backtrace3.g in file "backtrace3.ml", line 32, characters 41-50 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +e +Uncaught exception Backtrace3.Error("e") +Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11 +Re-raised at Backtrace3.g in file "backtrace3.ml", line 35, characters 41-51 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +f +Uncaught exception Backtrace3.Error("f") +Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11 +Re-raised at Backtrace3.g in file "backtrace3.ml", line 40, characters 45-54 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +g +Uncaught exception Backtrace3.Error("g") +Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53 +Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11 +Re-raised at Backtrace3.g in file "backtrace3.ml", line 43, characters 45-55 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +Uncaught exception Backtrace3.Error("h") +Raised at Backtrace3.g in file "backtrace3.ml", line 46, characters 10-17 +Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23 +Uncaught exception Invalid_argument("index out of bounds") +Raised by primitive operation at Backtrace3.run in file "backtrace3.ml", line 50, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace_deprecated.byte.reference b/testsuite/tests/backtrace/backtrace_deprecated.byte.reference deleted file mode 100644 index 57158d35..00000000 --- a/testsuite/tests/backtrace/backtrace_deprecated.byte.reference +++ /dev/null @@ -1,27 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace_deprecated.Error("b") -Raised at file "backtrace_deprecated.ml", line 19, characters 21-32 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 23, characters 4-11 -Re-raised at file "backtrace_deprecated.ml", line 25, characters 68-71 -Called from file "backtrace_deprecated.ml", line 30, characters 11-23 -Uncaught exception Backtrace_deprecated.Error("c") -Raised at file "backtrace_deprecated.ml", line 26, characters 26-37 -Called from file "backtrace_deprecated.ml", line 30, characters 11-23 -Uncaught exception Backtrace_deprecated.Error("d") -Raised at file "backtrace_deprecated.ml", line 19, characters 21-32 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 23, characters 4-11 -Called from file "backtrace_deprecated.ml", line 30, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace_deprecated.ml", line 30, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace_deprecated.ml b/testsuite/tests/backtrace/backtrace_deprecated.ml index 8d34b6cf..5840112b 100644 --- a/testsuite/tests/backtrace/backtrace_deprecated.ml +++ b/testsuite/tests/backtrace/backtrace_deprecated.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference = "${test_source_directory}/backtrace_deprecated.byte.reference" - * native - reference = "${test_source_directory}/backtrace_deprecated.opt.reference" - compare_programs = "false" + compare_programs = "false" *) (* A test for stack backtraces *) diff --git a/testsuite/tests/backtrace/backtrace_deprecated.opt.reference b/testsuite/tests/backtrace/backtrace_deprecated.opt.reference deleted file mode 100644 index 61c47df2..00000000 --- a/testsuite/tests/backtrace/backtrace_deprecated.opt.reference +++ /dev/null @@ -1,27 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace_deprecated.Error("b") -Raised at file "backtrace_deprecated.ml", line 19, characters 16-32 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 23, characters 4-11 -Re-raised at file "backtrace_deprecated.ml", line 25, characters 62-71 -Called from file "backtrace_deprecated.ml", line 30, characters 11-23 -Uncaught exception Backtrace_deprecated.Error("c") -Raised at file "backtrace_deprecated.ml", line 26, characters 20-37 -Called from file "backtrace_deprecated.ml", line 30, characters 11-23 -Uncaught exception Backtrace_deprecated.Error("d") -Raised at file "backtrace_deprecated.ml", line 19, characters 16-32 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 19, characters 42-53 -Called from file "backtrace_deprecated.ml", line 23, characters 4-11 -Called from file "backtrace_deprecated.ml", line 30, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace_deprecated.ml", line 30, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace_deprecated.reference b/testsuite/tests/backtrace/backtrace_deprecated.reference new file mode 100644 index 00000000..bbfd0205 --- /dev/null +++ b/testsuite/tests/backtrace/backtrace_deprecated.reference @@ -0,0 +1,27 @@ +a +No exception +b +Uncaught exception Backtrace_deprecated.Error("b") +Raised at Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 16-32 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 19, characters 4-11 +Re-raised at Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 21, characters 62-71 +Called from Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 11-23 +Uncaught exception Backtrace_deprecated.Error("c") +Raised at Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 22, characters 20-37 +Called from Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 11-23 +Uncaught exception Backtrace_deprecated.Error("d") +Raised at Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 16-32 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53 +Called from Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 19, characters 4-11 +Called from Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 11-23 +Uncaught exception Invalid_argument("index out of bounds") +Raised by primitive operation at Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace_or_exception.byte.reference b/testsuite/tests/backtrace/backtrace_or_exception.byte.reference deleted file mode 100644 index 81ff030c..00000000 --- a/testsuite/tests/backtrace/backtrace_or_exception.byte.reference +++ /dev/null @@ -1,14 +0,0 @@ -exception Backtrace_or_exception.Exn -Raised at file "backtrace_or_exception.ml", line 24, characters 10-13 -Called from file "backtrace_or_exception.ml", line 44, characters 6-10 ---------------------------- -exception Backtrace_or_exception.Exn -Raised at file "backtrace_or_exception.ml", line 15, characters 10-13 -Called from file "backtrace_or_exception.ml", line 28, characters 8-44 -Re-raised at file "backtrace_or_exception.ml", line 31, characters 10-13 -Called from file "backtrace_or_exception.ml", line 44, characters 6-10 ---------------------------- -exception Backtrace_or_exception.Exn -Raised at file "backtrace_or_exception.ml", line 40, characters 12-15 -Called from file "backtrace_or_exception.ml", line 44, characters 6-10 ---------------------------- diff --git a/testsuite/tests/backtrace/backtrace_or_exception.ml b/testsuite/tests/backtrace/backtrace_or_exception.ml index 8b6fb0f1..cdb10cdd 100644 --- a/testsuite/tests/backtrace/backtrace_or_exception.ml +++ b/testsuite/tests/backtrace/backtrace_or_exception.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference="${test_source_directory}/backtrace_or_exception.byte.reference" - * native - reference = "${test_source_directory}/backtrace_or_exception.opt.reference" - compare_programs = "false" + compare_programs = "false" *) exception Exn diff --git a/testsuite/tests/backtrace/backtrace_or_exception.opt.reference b/testsuite/tests/backtrace/backtrace_or_exception.opt.reference deleted file mode 100644 index d3f8b666..00000000 --- a/testsuite/tests/backtrace/backtrace_or_exception.opt.reference +++ /dev/null @@ -1,14 +0,0 @@ -exception Backtrace_or_exception.Exn -Raised at file "backtrace_or_exception.ml", line 24, characters 4-13 -Called from file "backtrace_or_exception.ml", line 44, characters 6-10 ---------------------------- -exception Backtrace_or_exception.Exn -Raised at file "backtrace_or_exception.ml", line 15, characters 4-13 -Called from file "backtrace_or_exception.ml", line 28, characters 8-44 -Re-raised at file "backtrace_or_exception.ml", line 31, characters 4-13 -Called from file "backtrace_or_exception.ml", line 44, characters 6-10 ---------------------------- -exception Backtrace_or_exception.Exn -Raised at file "backtrace_or_exception.ml", line 40, characters 6-15 -Called from file "backtrace_or_exception.ml", line 44, characters 6-10 ---------------------------- diff --git a/testsuite/tests/backtrace/backtrace_or_exception.reference b/testsuite/tests/backtrace/backtrace_or_exception.reference new file mode 100644 index 00000000..53baeb40 --- /dev/null +++ b/testsuite/tests/backtrace/backtrace_or_exception.reference @@ -0,0 +1,14 @@ +exception Backtrace_or_exception.Exn +Raised at Backtrace_or_exception.without_reraise in file "backtrace_or_exception.ml", line 20, characters 4-13 +Called from Backtrace_or_exception.run in file "backtrace_or_exception.ml", line 40, characters 6-10 +--------------------------- +exception Backtrace_or_exception.Exn +Raised at Backtrace_or_exception.return_exn in file "backtrace_or_exception.ml", line 11, characters 4-13 +Called from Backtrace_or_exception.with_reraise in file "backtrace_or_exception.ml", line 24, characters 8-44 +Re-raised at Backtrace_or_exception.with_reraise in file "backtrace_or_exception.ml", line 27, characters 4-13 +Called from Backtrace_or_exception.run in file "backtrace_or_exception.ml", line 40, characters 6-10 +--------------------------- +exception Backtrace_or_exception.Exn +Raised at Backtrace_or_exception.trickier in file "backtrace_or_exception.ml", line 36, characters 6-15 +Called from Backtrace_or_exception.run in file "backtrace_or_exception.ml", line 40, characters 6-10 +--------------------------- diff --git a/testsuite/tests/backtrace/backtrace_slots.byte.reference b/testsuite/tests/backtrace/backtrace_slots.byte.reference deleted file mode 100644 index ce4358b5..00000000 --- a/testsuite/tests/backtrace/backtrace_slots.byte.reference +++ /dev/null @@ -1,27 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace_slots.Error("b") -Raised at file "backtrace_slots.ml", line 45, characters 21-32 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 49, characters 4-11 -Re-raised at file "backtrace_slots.ml", line 51, characters 68-71 -Called from file "backtrace_slots.ml", line 56, characters 11-23 -Uncaught exception Backtrace_slots.Error("c") -Raised at file "backtrace_slots.ml", line 52, characters 26-37 -Called from file "backtrace_slots.ml", line 56, characters 11-23 -Uncaught exception Backtrace_slots.Error("d") -Raised at file "backtrace_slots.ml", line 45, characters 21-32 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 49, characters 4-11 -Called from file "backtrace_slots.ml", line 56, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace_slots.ml", line 56, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace_slots.ml b/testsuite/tests/backtrace/backtrace_slots.ml index 15bbb1ef..2d9cc20d 100644 --- a/testsuite/tests/backtrace/backtrace_slots.ml +++ b/testsuite/tests/backtrace/backtrace_slots.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference = "${test_source_directory}/backtrace_slots.byte.reference" - * native - reference = "${test_source_directory}/backtrace_slots.opt.reference" - compare_programs = "false" + compare_programs = "false" *) (* A test for stack backtraces *) diff --git a/testsuite/tests/backtrace/backtrace_slots.opt.reference b/testsuite/tests/backtrace/backtrace_slots.opt.reference deleted file mode 100644 index 2d3c55fb..00000000 --- a/testsuite/tests/backtrace/backtrace_slots.opt.reference +++ /dev/null @@ -1,27 +0,0 @@ -a -No exception -b -Uncaught exception Backtrace_slots.Error("b") -Raised at file "backtrace_slots.ml", line 45, characters 16-32 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 49, characters 4-11 -Re-raised at file "backtrace_slots.ml", line 51, characters 62-71 -Called from file "backtrace_slots.ml", line 56, characters 11-23 -Uncaught exception Backtrace_slots.Error("c") -Raised at file "backtrace_slots.ml", line 52, characters 20-37 -Called from file "backtrace_slots.ml", line 56, characters 11-23 -Uncaught exception Backtrace_slots.Error("d") -Raised at file "backtrace_slots.ml", line 45, characters 16-32 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 45, characters 42-53 -Called from file "backtrace_slots.ml", line 49, characters 4-11 -Called from file "backtrace_slots.ml", line 56, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "backtrace_slots.ml", line 56, characters 14-22 diff --git a/testsuite/tests/backtrace/backtrace_slots.reference b/testsuite/tests/backtrace/backtrace_slots.reference new file mode 100644 index 00000000..a012b5cf --- /dev/null +++ b/testsuite/tests/backtrace/backtrace_slots.reference @@ -0,0 +1,27 @@ +a +No exception +b +Uncaught exception Backtrace_slots.Error("b") +Raised at Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 16-32 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.g in file "backtrace_slots.ml", line 45, characters 4-11 +Re-raised at Backtrace_slots.g in file "backtrace_slots.ml", line 47, characters 62-71 +Called from Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 11-23 +Uncaught exception Backtrace_slots.Error("c") +Raised at Backtrace_slots.g in file "backtrace_slots.ml", line 48, characters 20-37 +Called from Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 11-23 +Uncaught exception Backtrace_slots.Error("d") +Raised at Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 16-32 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53 +Called from Backtrace_slots.g in file "backtrace_slots.ml", line 45, characters 4-11 +Called from Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 11-23 +Uncaught exception Invalid_argument("index out of bounds") +Raised by primitive operation at Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 14-22 diff --git a/testsuite/tests/backtrace/callstack.ml b/testsuite/tests/backtrace/callstack.ml index a9311ab4..fc39ec1a 100644 --- a/testsuite/tests/backtrace/callstack.ml +++ b/testsuite/tests/backtrace/callstack.ml @@ -4,21 +4,29 @@ include systhreads compare_programs = "false" ** no-flambda - reference = "${test_source_directory}/callstack.reference" *** native *** bytecode *) + let[@inline never] f0 () = Printexc.print_raw_backtrace stdout (Printexc.get_callstack 100); () let[@inline never] f1 () = f0 (); () let[@inline never] f2 () = f1 (); () let[@inline never] f3 () = f2 (); () + let () = Printf.printf "main thread:\n" let () = f3 () -let () = Printf.printf "new thread:\n" -let () = Thread.join (Thread.create f3 ()) +let () = Printf.printf "from finalizer:\n" let () = Gc.finalise (fun _ -> f0 ()) [|1|]; Gc.full_major (); () + +(* We run this last, because the initialization of the thread library + starts the "tick thread", which periodically send a signal for + thread preemption. If the preempion occurs exactly when the + finalizer above runs, then a new row for [Thread.yield] appears in + the callstack, which breaks the test. *) +let () = Printf.printf "new thread:\n" +let () = Thread.join (Thread.create f3 ()) diff --git a/testsuite/tests/backtrace/callstack.reference b/testsuite/tests/backtrace/callstack.reference index 3f70887e..e6c202d4 100644 --- a/testsuite/tests/backtrace/callstack.reference +++ b/testsuite/tests/backtrace/callstack.reference @@ -1,14 +1,15 @@ main thread: -Raised by primitive operation at file "callstack.ml", line 12, characters 38-66 -Called from file "callstack.ml", line 13, characters 27-32 -Called from file "callstack.ml", line 14, characters 27-32 -Called from file "callstack.ml", line 15, characters 27-32 -Called from file "callstack.ml", line 17, characters 9-14 +Raised by primitive operation at Callstack.f0 in file "callstack.ml", line 12, characters 38-66 +Called from Callstack.f1 in file "callstack.ml", line 13, characters 27-32 +Called from Callstack.f2 in file "callstack.ml", line 14, characters 27-32 +Called from Callstack.f3 in file "callstack.ml", line 15, characters 27-32 +Called from Callstack in file "callstack.ml", line 18, characters 9-14 +from finalizer: +Raised by primitive operation at Callstack.f0 in file "callstack.ml", line 12, characters 38-66 +Called from Callstack in file "callstack.ml", line 23, characters 2-18 new thread: -Raised by primitive operation at file "callstack.ml", line 12, characters 38-66 -Called from file "callstack.ml", line 13, characters 27-32 -Called from file "callstack.ml", line 14, characters 27-32 -Called from file "callstack.ml", line 15, characters 27-32 -Called from file "thread.ml", line 39, characters 8-14 -Raised by primitive operation at file "callstack.ml", line 12, characters 38-66 -Called from file "callstack.ml", line 23, characters 2-18 +Raised by primitive operation at Callstack.f0 in file "callstack.ml", line 12, characters 38-66 +Called from Callstack.f1 in file "callstack.ml", line 13, characters 27-32 +Called from Callstack.f2 in file "callstack.ml", line 14, characters 27-32 +Called from Callstack.f3 in file "callstack.ml", line 15, characters 27-32 +Called from Thread.create.(fun) in file "thread.ml", line 39, characters 8-14 diff --git a/testsuite/tests/backtrace/event_after_prim.ml b/testsuite/tests/backtrace/event_after_prim.ml new file mode 100644 index 00000000..f57b00bb --- /dev/null +++ b/testsuite/tests/backtrace/event_after_prim.ml @@ -0,0 +1,14 @@ +(* TEST + flags = "-g" + compare_programs = "false" *) + +let f n b = + let arr = Array.make n 42 in + if b then (arr, [| |]) else ([| |], arr) + +let () = + Printexc.record_backtrace true; + match Sys.opaque_identity f (-1) true with + | _ -> assert false + | exception _ -> + Printexc.print_backtrace stdout diff --git a/testsuite/tests/backtrace/event_after_prim.reference b/testsuite/tests/backtrace/event_after_prim.reference new file mode 100644 index 00000000..0678173c --- /dev/null +++ b/testsuite/tests/backtrace/event_after_prim.reference @@ -0,0 +1,2 @@ +Raised by primitive operation at Event_after_prim.f in file "event_after_prim.ml", line 6, characters 12-27 +Called from Event_after_prim in file "event_after_prim.ml", line 11, characters 8-39 diff --git a/testsuite/tests/backtrace/inline_test.byte.reference b/testsuite/tests/backtrace/inline_test.byte.reference deleted file mode 100644 index ba14898e..00000000 --- a/testsuite/tests/backtrace/inline_test.byte.reference +++ /dev/null @@ -1,15 +0,0 @@ -inline_test.ml -line 19 -characters 8-24 -inline_test.ml -line 22 -characters 2-5 -inline_test.ml -line 25 -characters 12-17 -inline_test.ml -line 28 -characters 5-8 -inline_test.ml -line 32 -characters 2-6 diff --git a/testsuite/tests/backtrace/inline_test.ml b/testsuite/tests/backtrace/inline_test.ml index 83f06bf6..756dc148 100644 --- a/testsuite/tests/backtrace/inline_test.ml +++ b/testsuite/tests/backtrace/inline_test.ml @@ -2,14 +2,11 @@ flags = "-g" ocamlrunparam += ",b=1" * bytecode - reference = "${test_source_directory}/inline_test.byte.reference" * native - reference = "${test_source_directory}/inline_test.opt.reference" compare_programs = "false" * native ocamlopt_flags = "-O3" compiler_directory_suffix = ".O3" - reference = "${test_source_directory}/inline_test.opt.reference" compare_programs = "false" *) diff --git a/testsuite/tests/backtrace/inline_test.opt.reference b/testsuite/tests/backtrace/inline_test.opt.reference deleted file mode 100644 index 2ee096e0..00000000 --- a/testsuite/tests/backtrace/inline_test.opt.reference +++ /dev/null @@ -1,15 +0,0 @@ -inline_test.ml -line 19 -characters 2-24 -inline_test.ml -line 22 -characters 2-5 -inline_test.ml -line 25 -characters 12-17 -inline_test.ml -line 28 -characters 5-8 -inline_test.ml -line 32 -characters 2-6 diff --git a/testsuite/tests/backtrace/inline_test.reference b/testsuite/tests/backtrace/inline_test.reference new file mode 100644 index 00000000..556ef2fc --- /dev/null +++ b/testsuite/tests/backtrace/inline_test.reference @@ -0,0 +1,15 @@ +inline_test.ml +line 16 +characters 2-24 +inline_test.ml +line 19 +characters 2-5 +inline_test.ml +line 22 +characters 12-17 +inline_test.ml +line 25 +characters 5-8 +inline_test.ml +line 29 +characters 2-6 diff --git a/testsuite/tests/backtrace/inline_traversal_test.byte.reference b/testsuite/tests/backtrace/inline_traversal_test.byte.reference deleted file mode 100644 index dfb7c0d6..00000000 --- a/testsuite/tests/backtrace/inline_traversal_test.byte.reference +++ /dev/null @@ -1,5 +0,0 @@ -inline_traversal_test.ml:19 -inline_traversal_test.ml:22 -inline_traversal_test.ml:25 -inline_traversal_test.ml:28 -inline_traversal_test.ml:33 diff --git a/testsuite/tests/backtrace/inline_traversal_test.ml b/testsuite/tests/backtrace/inline_traversal_test.ml index c28e849f..c4393bc9 100644 --- a/testsuite/tests/backtrace/inline_traversal_test.ml +++ b/testsuite/tests/backtrace/inline_traversal_test.ml @@ -2,14 +2,11 @@ flags = "-g" ocamlrunparam += ",b=1" * bytecode - reference = "${test_source_directory}/inline_traversal_test.byte.reference" * native - reference = "${test_source_directory}/inline_traversal_test.opt.reference" compare_programs = "false" * native ocamlopt_flags = "-O3" compiler_directory_suffix = ".O3" - reference = "${test_source_directory}/inline_traversal_test.opt.reference" compare_programs = "false" *) diff --git a/testsuite/tests/backtrace/inline_traversal_test.opt.reference b/testsuite/tests/backtrace/inline_traversal_test.opt.reference deleted file mode 100644 index dfb7c0d6..00000000 --- a/testsuite/tests/backtrace/inline_traversal_test.opt.reference +++ /dev/null @@ -1,5 +0,0 @@ -inline_traversal_test.ml:19 -inline_traversal_test.ml:22 -inline_traversal_test.ml:25 -inline_traversal_test.ml:28 -inline_traversal_test.ml:33 diff --git a/testsuite/tests/backtrace/inline_traversal_test.reference b/testsuite/tests/backtrace/inline_traversal_test.reference new file mode 100644 index 00000000..8dcdf455 --- /dev/null +++ b/testsuite/tests/backtrace/inline_traversal_test.reference @@ -0,0 +1,5 @@ +inline_traversal_test.ml:16 +inline_traversal_test.ml:19 +inline_traversal_test.ml:22 +inline_traversal_test.ml:25 +inline_traversal_test.ml:30 diff --git a/testsuite/tests/backtrace/methods.ml b/testsuite/tests/backtrace/methods.ml new file mode 100644 index 00000000..0ea147c1 --- /dev/null +++ b/testsuite/tests/backtrace/methods.ml @@ -0,0 +1,28 @@ +(* TEST + flags = "-g" + compare_programs = "false" *) + +let[@inline never] id x = Sys.opaque_identity x + +class foo = object (self) + val other = new bar "asdf" + method go : unit = + id (other#go 1 2 3) +end +and bar _v = object (self) + method go _ _ _ : unit = + id (self#bang) + method bang : unit = + raise Exit +end + +let () = + Printexc.record_backtrace true; + let obj = object (self) + method meth : unit = + id ((new foo)#go) + end in + match obj#meth with + | _ -> assert false + | exception Exit -> + Printexc.print_backtrace stdout diff --git a/testsuite/tests/backtrace/methods.reference b/testsuite/tests/backtrace/methods.reference new file mode 100644 index 00000000..f6420ee6 --- /dev/null +++ b/testsuite/tests/backtrace/methods.reference @@ -0,0 +1,5 @@ +Raised at Methods.bar#bang in file "methods.ml", line 16, characters 4-14 +Called from Methods.bar#go in file "methods.ml", line 14, characters 7-18 +Called from Methods.foo#go in file "methods.ml", line 10, characters 7-23 +Called from Methods.object#meth in file "methods.ml", line 23, characters 9-23 +Called from Methods in file "methods.ml", line 25, characters 8-16 diff --git a/testsuite/tests/backtrace/names.ml b/testsuite/tests/backtrace/names.ml new file mode 100644 index 00000000..ff4af583 --- /dev/null +++ b/testsuite/tests/backtrace/names.ml @@ -0,0 +1,124 @@ +(* TEST + flags = "-g" + compare_programs = "false" + *) + + +let id x = Sys.opaque_identity x + +let[@inline never] bang () = raise Exit + + +let[@inline never] fn_multi _ _ f = f 42 + 1 + +let[@inline never] fn_function = function + | f -> f 42 + 1 + +let[@inline never] fn_poly : 'a . 'a -> ('a -> int) -> int = fun x f -> + f x + 1 + +module Mod1 = struct + module Nested = struct + let[@inline never] apply f = f 42 + 1 + end +end + +let[@inline never] anon f = + let fn = id (fun () -> f 42 + 1) in + fn () + +let[@inline never] double_anon f = + let fn = id (fun () -> + let fn = id (fun () -> + f 42 + 1) in + fn ()) in + fn () + +let[@inline never] local f = + let[@inline never] inner () = f 42 + 1 in + (id inner) () + 1 + +let[@inline never] double_local f = + let inner1 () = + let inner2 () = f 42 + 1 in + (id inner2) () + 1 in + (id inner1) () + 1 + +let local_no_arg = + let inner f = f 42 + 1 in + fun[@inline never] f -> (id inner) f + 1 + +let[@inline never] curried () = + let inner () f = f 42 in + id (inner ()) + +let[@inline never] local_module f = + let module N = struct + let[@inline never] foo () = + f 42 + 1 + let r = ref 0 let () = r := id (id foo ()) + end in + !N.r + +module Functor (X : sig end) = struct + let[@inline never] fn f = f 42 + 1 +end +module Inst = Functor (struct end) + +module rec Rec1 : sig + val fn : (int -> int) -> int +end = struct + module M = Rec2 (struct end) + let[@inline never] fn f = M.fn f + 1 +end +and Rec2 : functor (X : sig end) -> sig + val fn : (int -> int) -> int +end = functor (X : sig end) -> struct + let[@inline never] fn f = f 42 + 1 +end + +let[@inline never] (+@+) n f = f 42 + 1 + +class klass = object (self) + val other = new klass2 "asdf" + method meth f : int = + other#othermeth 1 1 f 1 + 1 +end +and klass2 _v = object (self) + method othermeth _ _ f _ = + (id (fun g -> g 42 + 1) f) + 1 +end + +let inline_object f = + let obj = object (self) + method meth : int = + self#othermeth 1 f 1 + 1 + method othermeth _ _ _ = + f 42 + 1 + end in + obj#meth + +let () = + Printexc.record_backtrace true; + match + fn_multi 1 1 @@ fun _ -> + fn_function @@ fun _ -> + fn_poly 42 @@ fun _ -> + Mod1.Nested.apply @@ fun _ -> + anon @@ fun _ -> + double_anon @@ fun _ -> + local @@ fun _ -> + double_local @@ fun _ -> + local_no_arg @@ fun _ -> + curried () @@ fun _ -> + local_module @@ fun _ -> + Inst.fn @@ fun _ -> + Rec1.fn @@ fun _ -> + 42 +@+ fun _ -> + (new klass)#meth @@ fun _ -> + inline_object @@ fun _ -> + bang () + with + | _ -> assert false + | exception Exit -> + Printexc.print_backtrace stdout diff --git a/testsuite/tests/backtrace/names.reference b/testsuite/tests/backtrace/names.reference new file mode 100644 index 00000000..8ded55a4 --- /dev/null +++ b/testsuite/tests/backtrace/names.reference @@ -0,0 +1,26 @@ +Raised at Names.bang in file "names.ml", line 9, characters 29-39 +Called from Names.inline_object.object#othermeth in file "names.ml", line 97, characters 6-10 +Called from Names.inline_object.object#meth in file "names.ml", line 95, characters 6-26 +Called from Names.klass2#othermeth.(fun) in file "names.ml", line 89, characters 18-22 +Called from Names.klass2#othermeth in file "names.ml", line 89, characters 4-30 +Called from Names.klass#meth in file "names.ml", line 85, characters 4-27 +Called from Names.(+@+) in file "names.ml", line 80, characters 31-35 +Called from Names.Rec2.fn in file "names.ml", line 77, characters 28-32 +Called from Names.Rec1.fn in file "names.ml", line 72, characters 28-34 +Called from Names.Functor.fn in file "names.ml", line 64, characters 28-32 +Called from Names.local_module.N.foo in file "names.ml", line 58, characters 6-10 +Called from Names.local_module.N in file "names.ml", line 59, characters 38-49 +Called from Names.local_no_arg.inner in file "names.ml", line 48, characters 16-20 +Called from Names.local_no_arg.(fun) in file "names.ml", line 49, characters 26-38 +Called from Names.double_local.inner1.inner2 in file "names.ml", line 43, characters 20-24 +Called from Names.double_local.inner1 in file "names.ml", line 44, characters 4-18 +Called from Names.double_local in file "names.ml", line 45, characters 2-16 +Called from Names.local.inner in file "names.ml", line 38, characters 32-36 +Called from Names.local in file "names.ml", line 39, characters 2-15 +Called from Names.double_anon.(fun) in file "names.ml", line 33, characters 6-10 +Called from Names.anon.(fun) in file "names.ml", line 27, characters 25-29 +Called from Names.Mod1.Nested.apply in file "names.ml", line 22, characters 33-37 +Called from Names.fn_poly in file "names.ml", line 18, characters 2-5 +Called from Names.fn_function in file "names.ml", line 15, characters 9-13 +Called from Names.fn_multi in file "names.ml", line 12, characters 36-40 +Called from Names in file "names.ml", line 104, characters 4-445 diff --git a/testsuite/tests/backtrace/pr6920_why_at.byte.reference b/testsuite/tests/backtrace/pr6920_why_at.byte.reference deleted file mode 100644 index 5fdde076..00000000 --- a/testsuite/tests/backtrace/pr6920_why_at.byte.reference +++ /dev/null @@ -1,4 +0,0 @@ -Fatal error: exception Stdlib.Exit -Raised at file "pr6920_why_at.ml", line 13, characters 41-45 -Called from file "pr6920_why_at.ml", line 15, characters 2-11 -Called from file "pr6920_why_at.ml", line 21, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_at.ml b/testsuite/tests/backtrace/pr6920_why_at.ml index 83e78475..4b955667 100644 --- a/testsuite/tests/backtrace/pr6920_why_at.ml +++ b/testsuite/tests/backtrace/pr6920_why_at.ml @@ -3,11 +3,7 @@ ocamlrunparam += ",b=1" ocamlopt_flags = "-inline 0" exit_status = "2" - * bytecode - reference = "${test_source_directory}/pr6920_why_at.byte.reference" - * native - reference = "${test_source_directory}/pr6920_why_at.opt.reference" - compare_programs = "false" + compare_programs = "false" *) let why : unit -> unit = fun () -> raise Exit [@@inline never] diff --git a/testsuite/tests/backtrace/pr6920_why_at.opt.reference b/testsuite/tests/backtrace/pr6920_why_at.opt.reference deleted file mode 100644 index 076f29ae..00000000 --- a/testsuite/tests/backtrace/pr6920_why_at.opt.reference +++ /dev/null @@ -1,4 +0,0 @@ -Fatal error: exception Stdlib.Exit -Raised at file "pr6920_why_at.ml", line 13, characters 35-45 -Called from file "pr6920_why_at.ml", line 15, characters 2-11 -Called from file "pr6920_why_at.ml", line 21, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_at.reference b/testsuite/tests/backtrace/pr6920_why_at.reference new file mode 100644 index 00000000..5f71d817 --- /dev/null +++ b/testsuite/tests/backtrace/pr6920_why_at.reference @@ -0,0 +1,4 @@ +Fatal error: exception Stdlib.Exit +Raised at Pr6920_why_at.why in file "pr6920_why_at.ml", line 9, characters 35-45 +Called from Pr6920_why_at.f in file "pr6920_why_at.ml", line 11, characters 2-11 +Called from Pr6920_why_at in file "pr6920_why_at.ml", line 17, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference b/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference deleted file mode 100644 index f967fa7a..00000000 --- a/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference +++ /dev/null @@ -1,4 +0,0 @@ -Fatal error: exception Stdlib.Exit -Raised at file "pr6920_why_swallow.ml", line 13, characters 41-45 -Called from file "pr6920_why_swallow.ml", line 16, characters 4-13 -Called from file "pr6920_why_swallow.ml", line 23, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_swallow.ml b/testsuite/tests/backtrace/pr6920_why_swallow.ml index 11b5badb..b67e034d 100644 --- a/testsuite/tests/backtrace/pr6920_why_swallow.ml +++ b/testsuite/tests/backtrace/pr6920_why_swallow.ml @@ -3,11 +3,7 @@ ocamlrunparam += ",b=1" ocamlopt_flags = "-inline 0" exit_status = "2" - * bytecode - reference = "${test_source_directory}/pr6920_why_swallow.byte.reference" - * native - reference = "${test_source_directory}/pr6920_why_swallow.opt.reference" - compare_programs = "false" + compare_programs = "false" *) let why : unit -> unit = fun () -> raise Exit [@@inline never] diff --git a/testsuite/tests/backtrace/pr6920_why_swallow.opt.reference b/testsuite/tests/backtrace/pr6920_why_swallow.opt.reference deleted file mode 100644 index 48b4b05a..00000000 --- a/testsuite/tests/backtrace/pr6920_why_swallow.opt.reference +++ /dev/null @@ -1,4 +0,0 @@ -Fatal error: exception Stdlib.Exit -Raised at file "pr6920_why_swallow.ml", line 13, characters 35-45 -Called from file "pr6920_why_swallow.ml", line 16, characters 4-13 -Called from file "pr6920_why_swallow.ml", line 23, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_swallow.reference b/testsuite/tests/backtrace/pr6920_why_swallow.reference new file mode 100644 index 00000000..dda5d39d --- /dev/null +++ b/testsuite/tests/backtrace/pr6920_why_swallow.reference @@ -0,0 +1,4 @@ +Fatal error: exception Stdlib.Exit +Raised at Pr6920_why_swallow.why in file "pr6920_why_swallow.ml", line 9, characters 35-45 +Called from Pr6920_why_swallow.f in file "pr6920_why_swallow.ml", line 12, characters 4-13 +Called from Pr6920_why_swallow in file "pr6920_why_swallow.ml", line 19, characters 2-6 diff --git a/testsuite/tests/backtrace/raw_backtrace.byte.reference b/testsuite/tests/backtrace/raw_backtrace.byte.reference deleted file mode 100644 index 59c565cd..00000000 --- a/testsuite/tests/backtrace/raw_backtrace.byte.reference +++ /dev/null @@ -1,49 +0,0 @@ -a -No exception -b -Uncaught exception Raw_backtrace.Error("b") -Raised at file "raw_backtrace.ml", line 16, characters 21-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Re-raised at file "raw_backtrace.ml", line 27, characters 68-71 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -Uncaught exception Raw_backtrace.Error("c") -Raised at file "raw_backtrace.ml", line 28, characters 26-37 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -Uncaught exception Raw_backtrace.Error("d") -Raised at file "raw_backtrace.ml", line 16, characters 21-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -e -Uncaught exception Raw_backtrace.Error("e") -Raised at file "raw_backtrace.ml", line 16, characters 21-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Re-raised at file "raw_backtrace.ml", line 34, characters 39-42 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -f -Uncaught exception Raw_backtrace.Localized(_) -Raised at file "raw_backtrace.ml", line 16, characters 21-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Re-raised at file "raw_backtrace.ml", line 38, characters 39-54 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "raw_backtrace.ml", line 42, characters 14-22 diff --git a/testsuite/tests/backtrace/raw_backtrace.ml b/testsuite/tests/backtrace/raw_backtrace.ml index 824447e7..f200c797 100644 --- a/testsuite/tests/backtrace/raw_backtrace.ml +++ b/testsuite/tests/backtrace/raw_backtrace.ml @@ -1,11 +1,7 @@ (* TEST flags = "-g" ocamlrunparam += ",b=1" - * bytecode - reference = "${test_source_directory}/raw_backtrace.byte.reference" - * native - reference = "${test_source_directory}/raw_backtrace.opt.reference" - compare_programs = "false" + compare_programs = "false" *) (* A test for stack backtraces *) diff --git a/testsuite/tests/backtrace/raw_backtrace.opt.reference b/testsuite/tests/backtrace/raw_backtrace.opt.reference deleted file mode 100644 index e170838c..00000000 --- a/testsuite/tests/backtrace/raw_backtrace.opt.reference +++ /dev/null @@ -1,49 +0,0 @@ -a -No exception -b -Uncaught exception Raw_backtrace.Error("b") -Raised at file "raw_backtrace.ml", line 16, characters 16-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Re-raised at file "raw_backtrace.ml", line 27, characters 62-71 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -Uncaught exception Raw_backtrace.Error("c") -Raised at file "raw_backtrace.ml", line 28, characters 20-37 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -Uncaught exception Raw_backtrace.Error("d") -Raised at file "raw_backtrace.ml", line 16, characters 16-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -e -Uncaught exception Raw_backtrace.Error("e") -Raised at file "raw_backtrace.ml", line 16, characters 16-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Re-raised at file "raw_backtrace.ml", line 34, characters 9-45 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -f -Uncaught exception Raw_backtrace.Localized(_) -Raised at file "raw_backtrace.ml", line 16, characters 16-32 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 16, characters 42-53 -Called from file "raw_backtrace.ml", line 25, characters 4-11 -Re-raised at file "raw_backtrace.ml", line 38, characters 9-57 -Called from file "raw_backtrace.ml", line 42, characters 11-23 -Uncaught exception Invalid_argument("index out of bounds") -Raised by primitive operation at file "raw_backtrace.ml", line 42, characters 14-22 diff --git a/testsuite/tests/backtrace/raw_backtrace.reference b/testsuite/tests/backtrace/raw_backtrace.reference new file mode 100644 index 00000000..5416fa72 --- /dev/null +++ b/testsuite/tests/backtrace/raw_backtrace.reference @@ -0,0 +1,49 @@ +a +No exception +b +Uncaught exception Raw_backtrace.Error("b") +Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11 +Re-raised at Raw_backtrace.g in file "raw_backtrace.ml", line 23, characters 62-71 +Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23 +Uncaught exception Raw_backtrace.Error("c") +Raised at Raw_backtrace.g in file "raw_backtrace.ml", line 24, characters 20-37 +Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23 +Uncaught exception Raw_backtrace.Error("d") +Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11 +Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23 +e +Uncaught exception Raw_backtrace.Error("e") +Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11 +Re-raised at Raw_backtrace.g in file "raw_backtrace.ml", line 30, characters 9-45 +Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23 +f +Uncaught exception Raw_backtrace.Localized(_) +Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53 +Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11 +Re-raised at Raw_backtrace.g in file "raw_backtrace.ml", line 34, characters 9-57 +Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23 +Uncaught exception Invalid_argument("index out of bounds") +Raised by primitive operation at Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 14-22 diff --git a/testsuite/tests/basic-modules/anonymous.ml b/testsuite/tests/basic-modules/anonymous.ml index dd8546c3..20e67cca 100644 --- a/testsuite/tests/basic-modules/anonymous.ml +++ b/testsuite/tests/basic-modules/anonymous.ml @@ -41,3 +41,15 @@ end module type S let f (module _ : S) = () + +type re = { mutable cell : string; } + +let s = { cell = "" } + +module _ = struct + let () = s.cell <- "Hello World!" +end + +let drop _ = () + +let () = drop s.cell diff --git a/testsuite/tests/basic-modules/anonymous.ocamlc.reference b/testsuite/tests/basic-modules/anonymous.ocamlc.reference index f048af85..aba92cbd 100644 --- a/testsuite/tests/basic-modules/anonymous.ocamlc.reference +++ b/testsuite/tests/basic-modules/anonymous.ocamlc.reference @@ -9,8 +9,15 @@ [0: [0]])) (seq (ignore (let (x = [0: 4 2]) (makeblock 0 x))) (apply (field 1 (global CamlinternalMod!)) [0: [0]] A - (module-defn(A) anonymous.ml(23):567-608 A)) + (module-defn(A) Anonymous anonymous.ml(23):567-608 A)) (apply (field 1 (global CamlinternalMod!)) [0: [0]] B - (module-defn(B) anonymous.ml(33):703-773 + (module-defn(B) Anonymous anonymous.ml(33):703-773 (let (x = [0: "foo" "bar"]) (makeblock 0)))) - (let (f = (function param 0a)) (makeblock 0 A B f)))))) + (let (f = (function param 0a) s = (makemutable 0 "")) + (seq + (ignore + (let (*match* = (setfield_ptr 0 s "Hello World!")) + (makeblock 0))) + (let + (drop = (function param 0a) *match* = (apply drop (field 0 s))) + (makeblock 0 A B f s drop)))))))) diff --git a/testsuite/tests/basic-modules/anonymous.ocamlopt.flambda.reference b/testsuite/tests/basic-modules/anonymous.ocamlopt.flambda.reference index 2d5daff4..6f9a7cba 100644 --- a/testsuite/tests/basic-modules/anonymous.ocamlopt.flambda.reference +++ b/testsuite/tests/basic-modules/anonymous.ocamlopt.flambda.reference @@ -8,8 +8,14 @@ [0: [0]])) (seq (ignore (let (x = [0: 4 2]) (makeblock 0 x))) (apply (field 1 (global CamlinternalMod!)) [0: [0]] A - (module-defn(A) anonymous.ml(23):567-608 A)) + (module-defn(A) Anonymous anonymous.ml(23):567-608 A)) (apply (field 1 (global CamlinternalMod!)) [0: [0]] B - (module-defn(B) anonymous.ml(33):703-773 + (module-defn(B) Anonymous anonymous.ml(33):703-773 (let (x = [0: "foo" "bar"]) (makeblock 0)))) - (let (f = (function param 0a)) (makeblock 0 A B f))))) + (let (f = (function param 0a) s = (makemutable 0 "")) + (seq + (ignore + (let (*match* = (setfield_ptr 0 s "Hello World!")) (makeblock 0))) + (let + (drop = (function param 0a) *match* = (apply drop (field 0 s))) + (makeblock 0 A B f s drop))))))) diff --git a/testsuite/tests/basic-modules/anonymous.ocamlopt.reference b/testsuite/tests/basic-modules/anonymous.ocamlopt.reference index 5b12141e..6d29841f 100644 --- a/testsuite/tests/basic-modules/anonymous.ocamlopt.reference +++ b/testsuite/tests/basic-modules/anonymous.ocamlopt.reference @@ -14,4 +14,18 @@ (setfield_ptr(root-init) 1 (global Anonymous!) B) (let (f = (function param 0a)) (setfield_ptr(root-init) 2 (global Anonymous!) f)) + (let (s = (makemutable 0 "")) + (setfield_ptr(root-init) 3 (global Anonymous!) s)) + (ignore + (let + (*match* = + (setfield_ptr 0 (field 3 (global Anonymous!)) "Hello World!")) + (makeblock 0))) + (let (drop = (function param 0a)) + (setfield_ptr(root-init) 4 (global Anonymous!) drop)) + (let + (*match* = + (apply (field 4 (global Anonymous!)) + (field 0 (field 3 (global Anonymous!))))) + 0a) 0a))) diff --git a/testsuite/tests/basic-more/pr7683.ml b/testsuite/tests/basic-more/pr7683.ml new file mode 100644 index 00000000..ad9bb904 --- /dev/null +++ b/testsuite/tests/basic-more/pr7683.ml @@ -0,0 +1,10 @@ +(* TEST *) + +let f () n () = + n + +let g () = + let r = ref 0 in + f (incr r) !r (incr r) + +let () = print_int (g ()) diff --git a/testsuite/tests/basic-more/pr7683.reference b/testsuite/tests/basic-more/pr7683.reference new file mode 100644 index 00000000..56a6051c --- /dev/null +++ b/testsuite/tests/basic-more/pr7683.reference @@ -0,0 +1 @@ +1 \ No newline at end of file diff --git a/testsuite/tests/basic/tuple_match.ml b/testsuite/tests/basic/tuple_match.ml new file mode 100644 index 00000000..147a62a7 --- /dev/null +++ b/testsuite/tests/basic/tuple_match.ml @@ -0,0 +1,56 @@ +(* TEST *) + +let[@inline never] small_match n x = + let (left, right) = match x with + | 0 -> n, 42 + | 1 -> 42, n + | _ -> assert false in + left - right + +let[@inline never] big_match n x = + let (left, right) = match x with + | 0 -> n, 42 + | 1 -> 42, n + | 2 -> 42-n, 0 + | 3 -> 0, 42-n + | 4 -> n/2, n/2 + | 5 -> n, n + | _ -> assert false in + left - right + +let[@inline never] string_match n x = + let (left, right) = match x with + | "0" -> n, 42 + | "1" -> 42, n + | "2" -> 42-n, 0 + | "3" -> 0, 42-n + | "4" -> n/2, n/2 + | "5" -> n, n + | _ -> assert false in + left - right + + + + +let printf = Printf.printf + +let test f n i = + let mw_overhead = + let a = Gc.minor_words () in + let b = Gc.minor_words () in + b -. a in + let mw = Gc.minor_words () in + let k = f n i in + assert (k = 0); + let mw' = Gc.minor_words () in + let delta = int_of_float (mw' -. mw -. mw_overhead) in + printf "allocated %d words\n" delta + +let () = + let n = 42 in + printf "small_match:\n"; + for i = 0 to 1 do test small_match n i done; + printf "big_match:\n"; + for i = 0 to 5 do test big_match n i done; + printf "string_match:\n"; + for i = 0 to 5 do test string_match n (string_of_int i) done diff --git a/testsuite/tests/basic/tuple_match.reference b/testsuite/tests/basic/tuple_match.reference new file mode 100644 index 00000000..fc2235d3 --- /dev/null +++ b/testsuite/tests/basic/tuple_match.reference @@ -0,0 +1,17 @@ +small_match: +allocated 0 words +allocated 0 words +big_match: +allocated 0 words +allocated 0 words +allocated 0 words +allocated 0 words +allocated 0 words +allocated 0 words +string_match: +allocated 0 words +allocated 0 words +allocated 0 words +allocated 0 words +allocated 0 words +allocated 0 words diff --git a/testsuite/tests/compatibility/stub.c b/testsuite/tests/compatibility/stub.c index cbe39bb4..1bf4b4c8 100644 --- a/testsuite/tests/compatibility/stub.c +++ b/testsuite/tests/compatibility/stub.c @@ -1,3 +1,5 @@ +#include + #include #include #include diff --git a/testsuite/tests/compiler-libs/test_longident.ml b/testsuite/tests/compiler-libs/test_longident.ml index 917a4805..33bf09ff 100644 --- a/testsuite/tests/compiler-libs/test_longident.ml +++ b/testsuite/tests/compiler-libs/test_longident.ml @@ -3,8 +3,10 @@ include ocamlcommon * expect *) +[@@@alert "-deprecated"] module L = Longident + [%%expect {| module L = Longident |}] @@ -56,32 +58,113 @@ let last_dot_apply = L.last val last_dot_apply : string = "foo" |}];; +type parse_result = { flat: L.t; spec:L.t; any_is_correct:bool } +let test specialized s = + let spec = specialized (Lexing.from_string s) in + { flat = L.parse s; + spec; + any_is_correct = Parse.longident (Lexing.from_string s) = spec; + } + let parse_empty = L.parse "" +let parse_empty_val = Parse.longident (Lexing.from_string "") [%%expect {| +type parse_result = { flat : L.t; spec : L.t; any_is_correct : bool; } +val test : (Lexing.lexbuf -> L.t) -> string -> parse_result = val parse_empty : L.t = L.Lident "" +Exception: +Syntaxerr.Error + (Syntaxerr.Other + {Location.loc_start = + {Lexing.pos_fname = ""; pos_lnum = 1; pos_bol = 0; pos_cnum = 0}; + loc_end = + {Lexing.pos_fname = ""; pos_lnum = 1; pos_bol = 0; pos_cnum = 0}; + loc_ghost = false}). |}] -let parse_ident = L.parse "foo" +let parse_ident = test Parse.val_ident "foo" [%%expect {| -val parse_ident : L.t = L.Lident "foo" +val parse_ident : parse_result = + {flat = L.Lident "foo"; spec = L.Lident "foo"; any_is_correct = true} |}] -let parse_dot = L.parse "M.foo" +let parse_dot = test Parse.val_ident "M.foo" [%%expect {| -val parse_dot : L.t = L.Ldot (L.Lident "M", "foo") +val parse_dot : parse_result = + {flat = L.Ldot (L.Lident "M", "foo"); spec = L.Ldot (L.Lident "M", "foo"); + any_is_correct = true} |}] -let parse_path = L.parse "M.N.foo" +let parse_path = test Parse.val_ident "M.N.foo" [%%expect {| -val parse_path : L.t = L.Ldot (L.Ldot (L.Lident "M", "N"), "foo") +val parse_path : parse_result = + {flat = L.Ldot (L.Ldot (L.Lident "M", "N"), "foo"); + spec = L.Ldot (L.Ldot (L.Lident "M", "N"), "foo"); any_is_correct = true} |}] -let parse_complex = L.parse "M.F(M.N).N.foo" +let parse_complex = test Parse.type_ident "M.F(M.N).N.foo" (* the result below is a known misbehavior of Longident.parse - which does not handle applications properly. Fixing it - would be nice, but we soo no convenient way to do it without - introducing unpleasant dependencies. *) + which does not handle applications properly. *) +[%%expect {| +val parse_complex : parse_result = + {flat = + L.Ldot (L.Ldot (L.Ldot (L.Ldot (L.Lident "M", "F(M"), "N)"), "N"), "foo"); + spec = + L.Ldot + (L.Ldot + (L.Lapply (L.Ldot (L.Lident "M", "F"), L.Ldot (L.Lident "M", "N")), + "N"), + "foo"); + any_is_correct = true} +|}] + +let parse_op = test Parse.val_ident "M.(.%.()<-)" +(* the result below is another known misbehavior of Longident.parse. *) +[%%expect {| +val parse_op : parse_result = + {flat = L.Ldot (L.Ldot (L.Ldot (L.Lident "M", "("), "%"), "()<-)"); + spec = L.Ldot (L.Lident "M", ".%.()<-"); any_is_correct = true} +|}] + + +let parse_let_op = test Parse.val_ident "M.(let+*!)" [%%expect {| -val parse_complex : L.t = - L.Ldot (L.Ldot (L.Ldot (L.Ldot (L.Lident "M", "F(M"), "N)"), "N"), "foo") +val parse_let_op : parse_result = + {flat = L.Ldot (L.Lident "M", "(let+*!)"); + spec = L.Ldot (L.Lident "M", "let+*!"); any_is_correct = true} +|}] + +let constr = test Parse.constr_ident "true" +[%%expect{| +val constr : parse_result = + {flat = L.Lident "true"; spec = L.Lident "true"; any_is_correct = true} +|}] + +let prefix_constr = test Parse.constr_ident "A.B.C.(::)" +[%%expect{| +val prefix_constr : parse_result = + {flat = L.Ldot (L.Ldot (L.Ldot (L.Lident "A", "B"), "C"), "(::)"); + spec = L.Ldot (L.Ldot (L.Ldot (L.Lident "A", "B"), "C"), "::"); + any_is_correct = true} +|}] + + + +let mod_ext = test Parse.extended_module_path "A.F(B.C(X)).G(Y).D" +[%%expect{| +val mod_ext : parse_result = + {flat = + L.Ldot (L.Ldot (L.Ldot (L.Ldot (L.Lident "A", "F(B"), "C(X))"), "G(Y)"), + "D"); + spec = + L.Ldot + (L.Lapply + (L.Ldot + (L.Lapply (L.Ldot (L.Lident "A", "F"), + L.Lapply (L.Ldot (L.Lident "B", "C"), L.Lident "X")), + "G"), + L.Lident "Y"), + "D"); + any_is_correct = true} |}] + let string_of_longident lid = Format.asprintf "%a" Pprintast.longident lid [%%expect{| val string_of_longident : Longident.t -> string = @@ -90,15 +173,15 @@ let str_empty = string_of_longident parse_empty [%%expect {| val str_empty : string = "" |}] -let str_ident = string_of_longident parse_ident +let str_ident = string_of_longident parse_ident.flat [%%expect {| val str_ident : string = "foo" |}] -let str_dot = string_of_longident parse_dot +let str_dot = string_of_longident parse_dot.flat [%%expect {| val str_dot : string = "M.foo" |}] -let str_path = string_of_longident parse_path +let str_path = string_of_longident parse_path.flat [%%expect {| val str_path : string = "M.N.foo" |}] diff --git a/testsuite/tests/formatting/test_locations.dlocations.ocamlc.reference b/testsuite/tests/formatting/test_locations.dlocations.ocamlc.reference new file mode 100644 index 00000000..d5b96eb9 --- /dev/null +++ b/testsuite/tests/formatting/test_locations.dlocations.ocamlc.reference @@ -0,0 +1,176 @@ +[ + structure_item (test_locations.ml[42,1260+0]..[44,1298+34]) + Pstr_value Rec + [ + + pattern (test_locations.ml[42,1260+8]..[42,1260+11]) + Ppat_var "fib" (test_locations.ml[42,1260+8]..[42,1260+11]) + expression (test_locations.ml[42,1260+14]..[44,1298+34]) + Pexp_function + [ + + pattern (test_locations.ml[43,1283+4]..[43,1283+9]) + Ppat_or + pattern (test_locations.ml[43,1283+4]..[43,1283+5]) + Ppat_constant PConst_int (0,None) + pattern (test_locations.ml[43,1283+8]..[43,1283+9]) + Ppat_constant PConst_int (1,None) + expression (test_locations.ml[43,1283+13]..[43,1283+14]) + Pexp_constant PConst_int (1,None) + + pattern (test_locations.ml[44,1298+4]..[44,1298+5]) + Ppat_var "n" (test_locations.ml[44,1298+4]..[44,1298+5]) + expression (test_locations.ml[44,1298+9]..[44,1298+34]) + Pexp_apply + expression (test_locations.ml[44,1298+21]..[44,1298+22]) + Pexp_ident "+" (test_locations.ml[44,1298+21]..[44,1298+22]) + [ + + Nolabel + expression (test_locations.ml[44,1298+9]..[44,1298+20]) + Pexp_apply + expression (test_locations.ml[44,1298+9]..[44,1298+12]) + Pexp_ident "fib" (test_locations.ml[44,1298+9]..[44,1298+12]) + [ + + Nolabel + expression (test_locations.ml[44,1298+13]..[44,1298+20]) + Pexp_apply + expression (test_locations.ml[44,1298+16]..[44,1298+17]) + Pexp_ident "-" (test_locations.ml[44,1298+16]..[44,1298+17]) + [ + + Nolabel + expression (test_locations.ml[44,1298+14]..[44,1298+15]) + Pexp_ident "n" (test_locations.ml[44,1298+14]..[44,1298+15]) + + Nolabel + expression (test_locations.ml[44,1298+18]..[44,1298+19]) + Pexp_constant PConst_int (1,None) + ] + ] + + Nolabel + expression (test_locations.ml[44,1298+23]..[44,1298+34]) + Pexp_apply + expression (test_locations.ml[44,1298+23]..[44,1298+26]) + Pexp_ident "fib" (test_locations.ml[44,1298+23]..[44,1298+26]) + [ + + Nolabel + expression (test_locations.ml[44,1298+27]..[44,1298+34]) + Pexp_apply + expression (test_locations.ml[44,1298+30]..[44,1298+31]) + Pexp_ident "-" (test_locations.ml[44,1298+30]..[44,1298+31]) + [ + + Nolabel + expression (test_locations.ml[44,1298+28]..[44,1298+29]) + Pexp_ident "n" (test_locations.ml[44,1298+28]..[44,1298+29]) + + Nolabel + expression (test_locations.ml[44,1298+32]..[44,1298+33]) + Pexp_constant PConst_int (2,None) + ] + ] + ] + ] + ] +] + +let rec fib = function | 0|1 -> 1 | n -> (fib (n - 1)) + (fib (n - 2)) +[ + structure_item (test_locations.ml[42,1260+0]..test_locations.ml[44,1298+34]) + Tstr_value Rec + [ + + pattern (test_locations.ml[42,1260+8]..test_locations.ml[42,1260+11]) + Tpat_var "fib/80" + expression (test_locations.ml[42,1260+14]..test_locations.ml[44,1298+34]) + Texp_function + Nolabel + [ + + pattern (test_locations.ml[43,1283+4]..test_locations.ml[43,1283+9]) + Tpat_or + pattern (test_locations.ml[43,1283+4]..test_locations.ml[43,1283+5]) + Tpat_constant Const_int 0 + pattern (test_locations.ml[43,1283+8]..test_locations.ml[43,1283+9]) + Tpat_constant Const_int 1 + expression (test_locations.ml[43,1283+13]..test_locations.ml[43,1283+14]) + Texp_constant Const_int 1 + + pattern (test_locations.ml[44,1298+4]..test_locations.ml[44,1298+5]) + Tpat_var "n/81" + expression (test_locations.ml[44,1298+9]..test_locations.ml[44,1298+34]) + Texp_apply + expression (test_locations.ml[44,1298+21]..test_locations.ml[44,1298+22]) + Texp_ident "Stdlib!.+" + [ + + Nolabel + expression (test_locations.ml[44,1298+9]..test_locations.ml[44,1298+20]) + Texp_apply + expression (test_locations.ml[44,1298+9]..test_locations.ml[44,1298+12]) + Texp_ident "fib/80" + [ + + Nolabel + expression (test_locations.ml[44,1298+13]..test_locations.ml[44,1298+20]) + Texp_apply + expression (test_locations.ml[44,1298+16]..test_locations.ml[44,1298+17]) + Texp_ident "Stdlib!.-" + [ + + Nolabel + expression (test_locations.ml[44,1298+14]..test_locations.ml[44,1298+15]) + Texp_ident "n/81" + + Nolabel + expression (test_locations.ml[44,1298+18]..test_locations.ml[44,1298+19]) + Texp_constant Const_int 1 + ] + ] + + Nolabel + expression (test_locations.ml[44,1298+23]..test_locations.ml[44,1298+34]) + Texp_apply + expression (test_locations.ml[44,1298+23]..test_locations.ml[44,1298+26]) + Texp_ident "fib/80" + [ + + Nolabel + expression (test_locations.ml[44,1298+27]..test_locations.ml[44,1298+34]) + Texp_apply + expression (test_locations.ml[44,1298+30]..test_locations.ml[44,1298+31]) + Texp_ident "Stdlib!.-" + [ + + Nolabel + expression (test_locations.ml[44,1298+28]..test_locations.ml[44,1298+29]) + Texp_ident "n/81" + + Nolabel + expression (test_locations.ml[44,1298+32]..test_locations.ml[44,1298+33]) + Texp_constant Const_int 2 + ] + ] + ] + ] + ] +] + +(setglobal Test_locations! + (letrec + (fib/80 + (function n/81[int] : int + (funct-body Test_locations.fib test_locations.ml(42):1274-1332 + (if (isout 1 n/81) + (before Test_locations.fib test_locations.ml(44):1307-1332 + (+ + (after Test_locations.fib test_locations.ml(44):1307-1318 + (apply fib/80 (- n/81 1))) + (after Test_locations.fib test_locations.ml(44):1321-1332 + (apply fib/80 (- n/81 2))))) + (before Test_locations.fib test_locations.ml(43):1296-1297 1))))) + (pseudo (makeblock 0 fib/80)))) diff --git a/testsuite/tests/formatting/test_locations.dlocations.ocamlopt.clambda.reference b/testsuite/tests/formatting/test_locations.dlocations.ocamlopt.clambda.reference new file mode 100644 index 00000000..04e12174 --- /dev/null +++ b/testsuite/tests/formatting/test_locations.dlocations.ocamlopt.clambda.reference @@ -0,0 +1,31 @@ + +cmm: +(data) +(data + int 3063 + "camlTest_locations__1": + addr "camlTest_locations__fib_80" + int 3) +(data int 1792 global "camlTest_locations" "camlTest_locations": int 1) +(data + global "camlTest_locations__gc_roots" + "camlTest_locations__gc_roots": + addr "camlTest_locations" + int 0) +(function{test_locations.ml:42,14-72} camlTest_locations__fib_80 (n/81: val) + (if ( + pattern + Ppat_var "fib" + expression + Pexp_function + [ + + pattern + Ppat_or + pattern + Ppat_constant PConst_int (0,None) + pattern + Ppat_constant PConst_int (1,None) + expression + Pexp_constant PConst_int (1,None) + + pattern + Ppat_var "n" + expression + Pexp_apply + expression + Pexp_ident "+" + [ + + Nolabel + expression + Pexp_apply + expression + Pexp_ident "fib" + [ + + Nolabel + expression + Pexp_apply + expression + Pexp_ident "-" + [ + + Nolabel + expression + Pexp_ident "n" + + Nolabel + expression + Pexp_constant PConst_int (1,None) + ] + ] + + Nolabel + expression + Pexp_apply + expression + Pexp_ident "fib" + [ + + Nolabel + expression + Pexp_apply + expression + Pexp_ident "-" + [ + + Nolabel + expression + Pexp_ident "n" + + Nolabel + expression + Pexp_constant PConst_int (2,None) + ] + ] + ] + ] + ] +] + +let rec fib = function | 0|1 -> 1 | n -> (fib (n - 1)) + (fib (n - 2)) +[ + structure_item + Tstr_value Rec + [ + + pattern + Tpat_var "fib/80" + expression + Texp_function + Nolabel + [ + + pattern + Tpat_or + pattern + Tpat_constant Const_int 0 + pattern + Tpat_constant Const_int 1 + expression + Texp_constant Const_int 1 + + pattern + Tpat_var "n/81" + expression + Texp_apply + expression + Texp_ident "Stdlib!.+" + [ + + Nolabel + expression + Texp_apply + expression + Texp_ident "fib/80" + [ + + Nolabel + expression + Texp_apply + expression + Texp_ident "Stdlib!.-" + [ + + Nolabel + expression + Texp_ident "n/81" + + Nolabel + expression + Texp_constant Const_int 1 + ] + ] + + Nolabel + expression + Texp_apply + expression + Texp_ident "fib/80" + [ + + Nolabel + expression + Texp_apply + expression + Texp_ident "Stdlib!.-" + [ + + Nolabel + expression + Texp_ident "n/81" + + Nolabel + expression + Texp_constant Const_int 2 + ] + ] + ] + ] + ] +] + +(setglobal Test_locations! + (letrec + (fib/80 + (function n/81[int] : int + (if (isout 1 n/81) + (+ (apply fib/80 (- n/81 1)) (apply fib/80 (- n/81 2))) 1))) + (makeblock 0 fib/80))) diff --git a/testsuite/tests/formatting/test_locations.dno-locations.ocamlopt.clambda.reference b/testsuite/tests/formatting/test_locations.dno-locations.ocamlopt.clambda.reference new file mode 100644 index 00000000..983555b6 --- /dev/null +++ b/testsuite/tests/formatting/test_locations.dno-locations.ocamlopt.clambda.reference @@ -0,0 +1,28 @@ + +cmm: +(data) +(data + int 3063 + "camlTest_locations__1": + addr "camlTest_locations__fib_80" + int 3) +(data int 1792 global "camlTest_locations" "camlTest_locations": int 1) +(data + global "camlTest_locations__gc_roots" + "camlTest_locations__gc_roots": + addr "camlTest_locations" + int 0) +(function camlTest_locations__fib_80 (n/81: val) + (if ( 1 + | n -> fib (n - 1) + fib (n - 2) +;; diff --git a/testsuite/tests/functors/functors.compilers.reference b/testsuite/tests/functors/functors.compilers.reference index ef88efdb..a3ae39de 100644 --- a/testsuite/tests/functors/functors.compilers.reference +++ b/testsuite/tests/functors/functors.compilers.reference @@ -1,14 +1,14 @@ (setglobal Functors! (let (O = - (module-defn(O) functors.ml(12):184-279 + (module-defn(O) Functors functors.ml(12):184-279 (function X is_a_functor always_inline (let (cow = (function x[int] : int (apply (field 0 X) x)) sheep = (function x[int] : int (+ 1 (apply cow x)))) (makeblock 0 cow sheep)))) F = - (module-defn(F) functors.ml(17):281-392 + (module-defn(F) Functors functors.ml(17):281-392 (function X Y is_a_functor always_inline (let (cow = @@ -17,7 +17,7 @@ sheep = (function x[int] : int (+ 1 (apply cow x)))) (makeblock 0 cow sheep)))) F1 = - (module-defn(F1) functors.ml(31):516-632 + (module-defn(F1) Functors functors.ml(31):516-632 (function X Y is_a_functor always_inline (let (sheep = @@ -25,7 +25,7 @@ (+ 1 (apply (field 0 Y) (apply (field 0 X) x))))) (makeblock 0 sheep)))) F2 = - (module-defn(F2) functors.ml(36):634-784 + (module-defn(F2) Functors functors.ml(36):634-784 (function X Y is_a_functor always_inline (let (X =a (makeblock 0 (field 1 X)) @@ -35,10 +35,10 @@ (+ 1 (apply (field 0 Y) (apply (field 0 X) x))))) (makeblock 0 sheep)))) M = - (module-defn(M) functors.ml(41):786-970 + (module-defn(M) Functors functors.ml(41):786-970 (let (F = - (module-defn(F) functors.ml(44):849-966 + (module-defn(F) Functors.M functors.ml(44):849-966 (function X Y is_a_functor always_inline (let (cow = diff --git a/testsuite/tests/generalized-open/accepted_expect.ml b/testsuite/tests/generalized-open/accepted_expect.ml index ba526cb8..d4b5ddcb 100644 --- a/testsuite/tests/generalized-open/accepted_expect.ml +++ b/testsuite/tests/generalized-open/accepted_expect.ml @@ -4,6 +4,49 @@ open Set.Make(String);; [%%expect{| +type elt = String.t +type t = Set.Make(String).t +val empty : t = +val is_empty : t -> bool = +val mem : elt -> t -> bool = +val add : elt -> t -> t = +val singleton : elt -> t = +val remove : elt -> t -> t = +val union : t -> t -> t = +val inter : t -> t -> t = +val disjoint : t -> t -> bool = +val diff : t -> t -> t = +val compare : t -> t -> int = +val equal : t -> t -> bool = +val subset : t -> t -> bool = +val iter : (elt -> unit) -> t -> unit = +val map : (elt -> elt) -> t -> t = +val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a = +val for_all : (elt -> bool) -> t -> bool = +val exists : (elt -> bool) -> t -> bool = +val filter : (elt -> bool) -> t -> t = +val filter_map : (elt -> elt option) -> t -> t = +val partition : (elt -> bool) -> t -> t * t = +val cardinal : t -> int = +val elements : t -> elt list = +val min_elt : t -> elt = +val min_elt_opt : t -> elt option = +val max_elt : t -> elt = +val max_elt_opt : t -> elt option = +val choose : t -> elt = +val choose_opt : t -> elt option = +val split : elt -> t -> t * bool * t = +val find : elt -> t -> elt = +val find_opt : elt -> t -> elt option = +val find_first : (elt -> bool) -> t -> elt = +val find_first_opt : (elt -> bool) -> t -> elt option = +val find_last : (elt -> bool) -> t -> elt = +val find_last_opt : (elt -> bool) -> t -> elt option = +val of_list : elt list -> t = +val to_seq_from : elt -> t -> elt Seq.t = +val to_seq : t -> elt Seq.t = +val add_seq : elt Seq.t -> t -> t = +val of_seq : elt Seq.t -> t = |}] let e = empty;; @@ -15,6 +58,7 @@ open struct let x = singleton "hidden" end;; [%%expect{| +val x : t = |}];; elements (union x (of_list ["a"; "b"]));; @@ -49,6 +93,7 @@ val hd : 'a -> unit = open (List : sig val map : ('a -> 'b) -> 'a list -> 'b list end);; [%%expect{| +val map : ('a -> 'b) -> 'a list -> 'b list = |}] let l = map succ [0;1;2;3] diff --git a/testsuite/tests/generalized-open/gpr1506.ml b/testsuite/tests/generalized-open/gpr1506.ml index 112d5f29..3cbd819f 100644 --- a/testsuite/tests/generalized-open/gpr1506.ml +++ b/testsuite/tests/generalized-open/gpr1506.ml @@ -87,6 +87,9 @@ open struct let current () = !counter end [%%expect{| +val inc : unit -> unit = +val dec : unit -> unit = +val current : unit -> int = |}] let () = diff --git a/testsuite/tests/instrumented-runtime/main.ml b/testsuite/tests/instrumented-runtime/main.ml new file mode 100644 index 00000000..ebee4a6e --- /dev/null +++ b/testsuite/tests/instrumented-runtime/main.ml @@ -0,0 +1,11 @@ +(* TEST + * hasinstrumentedruntime + ** native + flags = "-runtime-variant=i" +*) + +(* Test if the instrumented runtime is in working condition *) + +let _ = + Gc.eventlog_pause (); + Gc.eventlog_resume() diff --git a/testsuite/tests/instrumented-runtime/main.run b/testsuite/tests/instrumented-runtime/main.run new file mode 100644 index 00000000..430dd231 --- /dev/null +++ b/testsuite/tests/instrumented-runtime/main.run @@ -0,0 +1,35 @@ +#!/bin/sh + +export OCAML_EVENTLOG_ENABLED=1 +export OCAML_EVENTLOG_PREFIX=${program} + +if [ "${os_type}" = "Win32" ] ; then + program=$(cygpath "$program") +fi + +rm -f "${program}"*.eventlog* +${program} > ${output} & + +pid=$! +wait $pid + +ls "${program}".*.eventlog | grep '\.[0-9][0-9]*\.eventlog$' | \ +while IFS= read -r file; do + touch ${program}.eventlogs + if [ ! -e "${program}.eventlog" ] ; then + touch ${program}.eventlog + else + rm -f ${program}.eventlog + break + fi +done + +if [ -f "${program}.eventlog" ]; then + exit ${TEST_PASS} +elif [ -f "${program}.eventlogs" ]; then + echo 'too many runtime traces found!' > ${ocamltest_response} + exit ${TEST_FAIL} +else + echo 'instrumented runtime trace not found!' > ${ocamltest_response} + exit ${TEST_FAIL} +fi diff --git a/testsuite/tests/letrec-check/basic.ml b/testsuite/tests/letrec-check/basic.ml index ffdb56d1..59521280 100644 --- a/testsuite/tests/letrec-check/basic.ml +++ b/testsuite/tests/letrec-check/basic.ml @@ -112,10 +112,13 @@ val x : 'a option -> unit = val y : 'a list -> unit = |}];; -(* this is accepted as all fields are overridden *) +(* used to be accepted, see PR#7696 *) let rec x = { x with contents = 3 } [@ocaml.warning "-23"];; [%%expect{| -val x : int ref = {contents = 3} +Line 1, characters 12-35: +1 | let rec x = { x with contents = 3 } [@ocaml.warning "-23"];; + ^^^^^^^^^^^^^^^^^^^^^^^ +Error: This kind of expression is not allowed as right-hand side of `let rec' |}];; (* this is rejected as `c` will be dereferenced during the copy, diff --git a/testsuite/tests/lib-dynlink-initializers/test10_main.byte.reference b/testsuite/tests/lib-dynlink-initializers/test10_main.byte.reference new file mode 100755 index 00000000..97ec42cd --- /dev/null +++ b/testsuite/tests/lib-dynlink-initializers/test10_main.byte.reference @@ -0,0 +1,12 @@ +Error: Failure("Plugin error") +Raised at Stdlib.failwith in file "stdlib.ml", line 29, characters 17-33 +Called from Test10_plugin.g in file "test10_plugin.ml", line 3, characters 2-21 +Called from Test10_plugin.f in file "test10_plugin.ml", line 6, characters 2-6 +Called from Test10_plugin in file "test10_plugin.ml", line 10, characters 2-6 +Called from Dynlink.Bytecode.run in file "otherlibs/dynlink/dynlink.ml", line 137, characters 16-25 +Re-raised at Dynlink.Bytecode.run in file "otherlibs/dynlink/dynlink.ml", line 139, characters 6-137 +Called from Dynlink_common.Make.load.(fun) in file "otherlibs/dynlink/dynlink_common.ml", line 344, characters 13-44 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 342, characters 8-240 +Re-raised at Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 352, characters 8-17 +Called from Test10_main in file "test10_main.ml", line 51, characters 13-69 diff --git a/testsuite/tests/lib-dynlink-initializers/test10_main.ml b/testsuite/tests/lib-dynlink-initializers/test10_main.ml new file mode 100644 index 00000000..8dd92a70 --- /dev/null +++ b/testsuite/tests/lib-dynlink-initializers/test10_main.ml @@ -0,0 +1,57 @@ +(* TEST + +include dynlink + +files = "test10_plugin.ml" +flags += "-g" + +libraries = "" + +* no-flambda +** shared-libraries +*** setup-ocamlc.byte-build-env +**** ocamlc.byte +module = "test10_main.ml" +**** ocamlc.byte +module = "test10_plugin.ml" +**** ocamlc.byte +program = "${test_build_directory}/test10.byte" +libraries = "dynlink" +all_modules = "test10_main.cmo" +***** run +****** check-program-output +reference = "${test_source_directory}/test10_main.byte.reference" + +*** native-dynlink +**** setup-ocamlopt.byte-build-env +***** ocamlopt.byte +module = "test10_main.ml" +***** ocamlopt.byte +program = "test10_plugin.cmxs" +flags = "-shared" +all_modules = "test10_plugin.ml" +***** ocamlopt.byte +program = "${test_build_directory}/test10.exe" +libraries = "dynlink" +all_modules = "test10_main.cmx" +****** run +******* check-program-output +reference = "${test_source_directory}/test10_main.native.reference" +*) + +(* Check that a module in the main program whose initializer has not + executed completely cannot be depended upon by a shared library being + loaded. *) + +let () = + Printexc.record_backtrace true; + try + if Dynlink.is_native then begin + Dynlink.loadfile "test10_plugin.cmxs" + end else begin + Dynlink.loadfile "test10_plugin.cmo" + end + with + | Dynlink.Error (Dynlink.Library's_module_initializers_failed exn) -> + Printf.eprintf "Error: %s\n%!" (Printexc.to_string exn); + Printexc.print_backtrace stderr diff --git a/testsuite/tests/lib-dynlink-initializers/test10_main.native.reference b/testsuite/tests/lib-dynlink-initializers/test10_main.native.reference new file mode 100755 index 00000000..364eb760 --- /dev/null +++ b/testsuite/tests/lib-dynlink-initializers/test10_main.native.reference @@ -0,0 +1,14 @@ +Error: Failure("Plugin error") +Raised at Stdlib.failwith in file "stdlib.ml", line 29, characters 17-33 +Called from Test10_plugin.g in file "test10_plugin.ml", line 2, characters 15-38 +Called from Test10_plugin in file "test10_plugin.ml", line 10, characters 2-6 +Called from Dynlink.Native.run.(fun) in file "otherlibs/dynlink/native/dynlink.ml", line 85, characters 12-29 +Called from Dynlink.Native.run.(fun) in file "otherlibs/dynlink/native/dynlink.ml", line 85, characters 12-29 +Re-raised at Dynlink.Native.run.(fun) in file "otherlibs/dynlink/native/dynlink.ml", line 87, characters 10-149 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Dynlink_common.Make.load.(fun) in file "otherlibs/dynlink/dynlink_common.ml", line 344, characters 13-44 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 342, characters 8-240 +Re-raised at Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 352, characters 8-17 +Called from Dynlink_common.Make.loadfile in file "otherlibs/dynlink/dynlink_common.ml" (inlined), line 354, characters 26-45 +Called from Test10_main in file "test10_main.ml", line 49, characters 30-87 diff --git a/testsuite/tests/lib-dynlink-initializers/test10_plugin.ml b/testsuite/tests/lib-dynlink-initializers/test10_plugin.ml new file mode 100644 index 00000000..6e7a3093 --- /dev/null +++ b/testsuite/tests/lib-dynlink-initializers/test10_plugin.ml @@ -0,0 +1,11 @@ +let g () = + if true then failwith "Plugin error"; + print_endline "xxx" + +let f () = + g (); + print_endline "xxx" + +let () = + f (); + print_endline "xxx" diff --git a/testsuite/tests/lib-int64/issue9460.ml b/testsuite/tests/lib-int64/issue9460.ml new file mode 100644 index 00000000..aacbe618 --- /dev/null +++ b/testsuite/tests/lib-int64/issue9460.ml @@ -0,0 +1,37 @@ +(* TEST +*) + +(* See https://github.com/ocaml/ocaml/issues/9460 + This test comes from Richard Jones + at + https://github.com/libguestfs/libnbd/blob/0475bfe04a527051c0a37af59a733c4c8554e427/ocaml/tests/test_400_pread.ml#L21-L36 +*) +let test_result = + let b = Bytes.create 16 in + for i = 0 to 16/8-1 do + let i64 = ref (Int64.of_int (i*8)) in + for j = 0 to 7 do + let c = Int64.shift_right_logical !i64 56 in + let c = Int64.to_int c in + let c = Char.chr c in + Bytes.unsafe_set b (i*8+j) c; + i64 := Int64.shift_left !i64 8 + done + done; + (Bytes.to_string b) ;; + +let expected = + "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008" + +let () = + assert (test_result = expected) + +(* Reproduction case by Jeremy Yallop in + https://github.com/ocaml/ocaml/pull/9463#issuecomment-615831765 +*) +let () = + let x = ref Int64.max_int in + assert (!x = Int64.max_int) + +let () = + print_endline "OK" diff --git a/testsuite/tests/lib-int64/issue9460.reference b/testsuite/tests/lib-int64/issue9460.reference new file mode 100644 index 00000000..d86bac9d --- /dev/null +++ b/testsuite/tests/lib-int64/issue9460.reference @@ -0,0 +1 @@ +OK diff --git a/testsuite/tests/lib-list/test.ml b/testsuite/tests/lib-list/test.ml index 5efdbccf..d0b75e6a 100644 --- a/testsuite/tests/lib-list/test.ml +++ b/testsuite/tests/lib-list/test.ml @@ -10,6 +10,7 @@ let string_of_even_opt x = (* Standard test case *) let () = let l = List.init 10 (fun x -> x) in + let sl = List.init 10 string_of_int in assert (List.exists (fun a -> a < 10) l); assert (List.exists (fun a -> a > 0) l); assert (List.exists (fun a -> a = 0) l); @@ -33,6 +34,8 @@ let () = assert (List.find_map (f ~limit:30) l = None); end; + assert (List.filteri (fun i _ -> i < 2) (List.rev l) = [9; 8]); + assert (List.compare_lengths [] [] = 0); assert (List.compare_lengths [1;2] ['a';'b'] = 0); assert (List.compare_lengths [] [1;2] < 0); @@ -53,6 +56,11 @@ let () = assert ( let count = ref 0 in List.concat_map (fun i -> incr count; [i; !count]) [1; 5] = [1; 1; 5; 2]); + assert (List.fold_left_map (fun a b -> a + b, b) 0 l = (45, l)); + assert (List.fold_left_map (fun a b -> assert false) 0 [] = (0, [])); + assert ( + let f a b = a + b, string_of_int b in + List.fold_left_map f 0 l = (45, sl)); () ;; diff --git a/testsuite/tests/lib-marshal/marshal_bigarray.ml b/testsuite/tests/lib-marshal/marshal_bigarray.ml new file mode 100644 index 00000000..71d8310d --- /dev/null +++ b/testsuite/tests/lib-marshal/marshal_bigarray.ml @@ -0,0 +1,14 @@ +(* TEST *) + +let () = + let small = 0xfffe and large = 0xffff in + let marshalled dim = + let ba = Bigarray.(Array1.create int8_unsigned c_layout dim) in + Marshal.to_string ba [] + in + (* Bigarray dimension marshalling scheme: use an extra 8 bytes + to marshal dimensions >=0xffff to avoid overflow *) + assert + (((String.length (marshalled large) - String.length (marshalled small)) + - (large - small)) + = 8) diff --git a/testsuite/tests/lib-marshal/marshal_bigarray.reference b/testsuite/tests/lib-marshal/marshal_bigarray.reference new file mode 100644 index 00000000..e69de29b diff --git a/testsuite/tests/lib-seq/test.ml b/testsuite/tests/lib-seq/test.ml index 1392b0d1..96c9d3d6 100644 --- a/testsuite/tests/lib-seq/test.ml +++ b/testsuite/tests/lib-seq/test.ml @@ -13,6 +13,19 @@ let () = () ;; +(* unfold *) +let () = + let range first last = + let step i = if i > last then None + else Some (i, succ i) in + Seq.unfold step first + in + begin + assert ([1;2;3] = List.of_seq (range 1 3)); + assert ([] = List.of_seq (range 1 0)); + end +;; + (* MPR 7820 *) let () = assert diff --git a/testsuite/tests/lib-set/testmap.ml b/testsuite/tests/lib-set/testmap.ml index 0be0410b..500f00b0 100644 --- a/testsuite/tests/lib-set/testmap.ml +++ b/testsuite/tests/lib-set/testmap.ml @@ -75,6 +75,11 @@ let test x v s1 s2 = (let p x y = x >= 3 && x <= 6 in M.bindings(M.filter p s1) = List.filter (uncurry p) (M.bindings s1)); + checkbool "filter_map" + (let f x y = if x >= 3 && x <= 6 then Some (2 * x) else None in + let f_on_pair (x, y) = Option.map (fun v -> (x, v)) (f x y) in + M.bindings(M.filter_map f s1) = List.filter_map f_on_pair (M.bindings s1)); + checkbool "partition" (let p x y = x >= 3 && x <= 6 in let (st,sf) = M.partition p s1 diff --git a/testsuite/tests/lib-set/testset.ml b/testsuite/tests/lib-set/testset.ml index b998875e..36d450eb 100644 --- a/testsuite/tests/lib-set/testset.ml +++ b/testsuite/tests/lib-set/testset.ml @@ -89,6 +89,14 @@ let test x s1 s2 = (let p x = x >= 3 && x <= 6 in S.elements(S.filter p s1) = List.filter p (S.elements s1)); + checkbool "filter_map" + (let f x = if x >= 3 && x <= 6 then Some (2 * x) else None in + S.elements(S.filter_map f s1) = List.filter_map f (S.elements s1)); + + checkbool "filter_map(==)" + (let f x = Some x in + S.filter_map f s1 == s1); + checkbool "partition" (let p x = x >= 3 && x <= 6 in let (st,sf) = S.partition p s1 diff --git a/testsuite/tests/lib-unix/common/test_unix_cmdline.ml b/testsuite/tests/lib-unix/common/test_unix_cmdline.ml index 3dffec3b..a51c118a 100644 --- a/testsuite/tests/lib-unix/common/test_unix_cmdline.ml +++ b/testsuite/tests/lib-unix/common/test_unix_cmdline.ml @@ -50,6 +50,9 @@ let run args = let _, exit = waitpid [] pid in assert (exit = WEXITED 0) +let exec args = + execv ("./" ^ prog_name) (Array.of_list (prog_name :: args)) + let () = List.iter run [ @@ -60,4 +63,14 @@ let () = [" \\ \\ \\\\\\"]; [" \"hola \""]; ["a\tb"]; - ] + ]; + Printf.printf "-- execv\n%!"; + exec [ + ""; + "a"; "b"; "c.txt@!"; + "\""; + " "; " a "; " \" \\\" "; + " \\ \\ \\\\\\"; + " \"hola \""; + "a\tb" + ] diff --git a/testsuite/tests/lib-unix/common/test_unix_cmdline.reference b/testsuite/tests/lib-unix/common/test_unix_cmdline.reference index 7d2f2c2a..b494a297 100644 --- a/testsuite/tests/lib-unix/common/test_unix_cmdline.reference +++ b/testsuite/tests/lib-unix/common/test_unix_cmdline.reference @@ -11,3 +11,15 @@ " \\ \\ \\\\\\" -> " \\ \\ \\\\\\" [OK] " \"hola \"" -> " \"hola \"" [OK] "a\tb" -> "a\tb" [OK] +-- execv + +a +b +c.txt@! +" + + a + " \" + \ \ \\\ + "hola " +a b diff --git a/testsuite/tests/misc/exotic.ml b/testsuite/tests/misc/exotic.ml new file mode 100644 index 00000000..33674cb4 --- /dev/null +++ b/testsuite/tests/misc/exotic.ml @@ -0,0 +1,59 @@ +(* TEST + flags = "-I ${ocamlsrcdir}/utils" + * expect +*) + +(* Strict-sequence can change the behavior of programs *) + +(* The two examples below were proposed by Jeremy Yallop in + https://github.com/ocaml/ocaml/pull/1971 . + Note that those tests are here to record this behavior and not to enshrine it. +*) + +[@@@warning "-10-18-8-5"];; +type t = A | () and b = B : _ -> b;; +[%%expect{| +type t = A | () +and b = B : 'a -> b +|}];; + +Clflags.strict_sequence := false ;; +let f (g : 'a) = g; Format.printf "%b@." (B (() : 'a) = B A) in f ();; +[%%expect {| +- : unit = () +false +- : unit = () +|}] +;; + +Clflags.strict_sequence := true ;; +let f (g : 'a) = g; Format.printf "%b@." (B (() : 'a) = B A) in f ();; +[%%expect {| +- : unit = () +true +- : unit = () +|}] +;; + +Clflags.strict_sequence := false;; +let f () = let g ~y = (raise Not_found : 'a) in + if false then ((assert false : 'a); g ()) else g () +let _ = Format.printf "%b@." (try f (); false with Not_found -> true) +[%%expect {| +- : unit = () +val f : t -> y:'a -> 'b = +false +- : unit = () +|}] +;; + +Clflags.strict_sequence := true ;; +let f () = let g ~y = (raise Not_found : 'a) in + if false then ((assert false : 'a); g ()) else g () +let _ = Format.printf "%b@." (try f (); false with Not_found -> true) +[%%expect {| +- : unit = () +val f : t -> unit = +true +- : unit = () +|}] diff --git a/testsuite/tests/parsing/change_start_loc.ml b/testsuite/tests/parsing/change_start_loc.ml new file mode 100644 index 00000000..2e5604ce --- /dev/null +++ b/testsuite/tests/parsing/change_start_loc.ml @@ -0,0 +1,32 @@ +(* TEST +flags = "-I ${ocamlsrcdir}/parsing -I ${ocamlsrcdir}/toplevel" +include ocamlcommon +*) +let position = Lexing.{ (* This corresponds to File "file.ml", line 100, character 10 *) + pos_fname = "------should not appear------"; + pos_lnum = 100; + pos_bol = 1000; + pos_cnum = 1010; +} + +(* We need to show, that just changing lex_curr_p is not enough. + See wrong columns in output for 'Incomplete version'. *) +let set_position_incomplete lexbuf position = + let open Lexing in + lexbuf.lex_curr_p <- {position with pos_fname = lexbuf.lex_curr_p.pos_fname} + +(* "Testing framework" *) +let print_error_in_parse set_position_variant = + try + let _ = + let lexbuf = Lexing.from_string ")f x" in (* contains error in chars 0-1, line 0 *) + set_position_variant lexbuf position; + Lexing.set_filename lexbuf "file.ml"; (* also testing set_filename *) + Parse.expression lexbuf in () + with e -> Location.report_exception Format.std_formatter e + +let _ = + print_string "Incomplete version:\n"; + print_error_in_parse set_position_incomplete; + print_string "Good version:\n"; + print_error_in_parse Lexing.set_position diff --git a/testsuite/tests/parsing/change_start_loc.reference b/testsuite/tests/parsing/change_start_loc.reference new file mode 100644 index 00000000..43506af6 --- /dev/null +++ b/testsuite/tests/parsing/change_start_loc.reference @@ -0,0 +1,6 @@ +Incomplete version: +File "file.ml", line 100, characters 10--999: +Error: Syntax error +Good version: +File "file.ml", line 100, characters 10-11: +Error: Syntax error diff --git a/testsuite/tests/parsing/extensions.compilers.reference b/testsuite/tests/parsing/extensions.compilers.reference index 7b5f952c..31850eb2 100644 --- a/testsuite/tests/parsing/extensions.compilers.reference +++ b/testsuite/tests/parsing/extensions.compilers.reference @@ -59,7 +59,7 @@ structure_item (extensions.ml[10,176+40]..[10,176+45]) Pstr_eval expression (extensions.ml[10,176+40]..[10,176+45]) - Pexp_constant PConst_string("foo",None) + Pexp_constant PConst_string("foo",(extensions.ml[10,176+41]..[10,176+44]),None) ] ] structure_item (extensions.ml[12,224+0]..[12,224+26]) diff --git a/testsuite/tests/parsing/quotedextensions.compilers.reference b/testsuite/tests/parsing/quotedextensions.compilers.reference new file mode 100644 index 00000000..4f84877f --- /dev/null +++ b/testsuite/tests/parsing/quotedextensions.compilers.reference @@ -0,0 +1,115 @@ +[ + structure_item (quotedextensions.ml[10,170+0]..[10,170+23]) + Pstr_extension "M.foo" + [ + structure_item (quotedextensions.ml[10,170+0]..[10,170+23]) ghost + Pstr_eval + expression (quotedextensions.ml[10,170+0]..[10,170+23]) ghost + Pexp_constant PConst_string (" {x} ",(quotedextensions.ml[10,170+9]..[10,170+21]),Some "") + ] + structure_item (quotedextensions.ml[11,194+0]..[11,194+32]) + Pstr_extension "M.foo" + [ + structure_item (quotedextensions.ml[11,194+0]..[11,194+32]) ghost + Pstr_eval + expression (quotedextensions.ml[11,194+0]..[11,194+32]) ghost + Pexp_constant PConst_string (" {|x|} ",(quotedextensions.ml[11,194+13]..[11,194+27]),Some "bar") + ] + structure_item (quotedextensions.ml[14,245+0]..[17,326+3]) + Pstr_modtype "S" (quotedextensions.ml[14,245+12]..[14,245+13]) + module_type (quotedextensions.ml[14,245+16]..[17,326+3]) + Pmty_signature + [ + signature_item (quotedextensions.ml[15,265+2]..[15,265+25]) + Psig_extension "M.foo" + [ + structure_item (quotedextensions.ml[15,265+2]..[15,265+25]) ghost + Pstr_eval + expression (quotedextensions.ml[15,265+2]..[15,265+25]) ghost + Pexp_constant PConst_string (" {x} ",(quotedextensions.ml[15,265+11]..[15,265+23]),Some "") + ] + signature_item (quotedextensions.ml[16,291+2]..[16,291+34]) + Psig_extension "M.foo" + [ + structure_item (quotedextensions.ml[16,291+2]..[16,291+34]) ghost + Pstr_eval + expression (quotedextensions.ml[16,291+2]..[16,291+34]) ghost + Pexp_constant PConst_string (" {|x|} ",(quotedextensions.ml[16,291+15]..[16,291+29]),Some "bar") + ] + ] + structure_item (quotedextensions.ml[20,363+0]..[22,417+26]) + Pstr_value Nonrec + [ + + pattern (quotedextensions.ml[20,363+4]..[21,390+26]) ghost + Ppat_constraint + pattern (quotedextensions.ml[20,363+4]..[20,363+26]) + Ppat_extension "M.foo" + [ + structure_item (quotedextensions.ml[20,363+4]..[20,363+26]) ghost + Pstr_eval + expression (quotedextensions.ml[20,363+4]..[20,363+26]) ghost + Pexp_constant PConst_string (" {x} ",(quotedextensions.ml[20,363+12]..[20,363+24]),Some "") + ] + core_type (quotedextensions.ml[21,390+4]..[21,390+26]) + Ptyp_extension "M.foo" + [ + structure_item (quotedextensions.ml[21,390+4]..[21,390+26]) ghost + Pstr_eval + expression (quotedextensions.ml[21,390+4]..[21,390+26]) ghost + Pexp_constant PConst_string (" {x} ",(quotedextensions.ml[21,390+12]..[21,390+24]),Some "") + ] + expression (quotedextensions.ml[22,417+4]..[22,417+26]) + Pexp_extension "M.foo" + [ + structure_item (quotedextensions.ml[22,417+4]..[22,417+26]) ghost + Pstr_eval + expression (quotedextensions.ml[22,417+4]..[22,417+26]) ghost + Pexp_constant PConst_string (" {x} ",(quotedextensions.ml[22,417+12]..[22,417+24]),Some "") + ] + ] + structure_item (quotedextensions.ml[23,444+0]..[25,516+35]) + Pstr_value Nonrec + [ + + pattern (quotedextensions.ml[23,444+4]..[24,480+35]) ghost + Ppat_constraint + pattern (quotedextensions.ml[23,444+4]..[23,444+35]) + Ppat_extension "M.foo" + [ + structure_item (quotedextensions.ml[23,444+4]..[23,444+35]) ghost + Pstr_eval + expression (quotedextensions.ml[23,444+4]..[23,444+35]) ghost + Pexp_constant PConst_string (" {|x|} ",(quotedextensions.ml[23,444+16]..[23,444+30]),Some "bar") + ] + core_type (quotedextensions.ml[24,480+4]..[24,480+35]) + Ptyp_extension "M.foo" + [ + structure_item (quotedextensions.ml[24,480+4]..[24,480+35]) ghost + Pstr_eval + expression (quotedextensions.ml[24,480+4]..[24,480+35]) ghost + Pexp_constant PConst_string (" {|x|} ",(quotedextensions.ml[24,480+16]..[24,480+30]),Some "bar") + ] + expression (quotedextensions.ml[25,516+4]..[25,516+35]) + Pexp_extension "M.foo" + [ + structure_item (quotedextensions.ml[25,516+4]..[25,516+35]) ghost + Pstr_eval + expression (quotedextensions.ml[25,516+4]..[25,516+35]) ghost + Pexp_constant PConst_string (" {|x|} ",(quotedextensions.ml[25,516+16]..[25,516+30]),Some "bar") + ] + ] + structure_item (quotedextensions.ml[28,569+0]..[32,605+2]) + Pstr_extension "M.foo" + [ + structure_item (quotedextensions.ml[28,569+0]..[32,605+2]) ghost + Pstr_eval + expression (quotedextensions.ml[28,569+0]..[32,605+2]) ghost + Pexp_constant PConst_string ("\n \n {x}\n \n",(quotedextensions.ml[28,569+9]..[32,605+0]),Some "") + ] +] + +File "quotedextensions.ml", line 10, characters 3-8: +10 | {%%M.foo| {x} |} + ^^^^^ +Error: Uninterpreted extension 'M.foo'. diff --git a/testsuite/tests/parsing/quotedextensions.ml b/testsuite/tests/parsing/quotedextensions.ml new file mode 100644 index 00000000..f725f5a1 --- /dev/null +++ b/testsuite/tests/parsing/quotedextensions.ml @@ -0,0 +1,42 @@ +(* TEST + flags = "-dparsetree" + ocamlc_byte_exit_status = "2" + * setup-ocamlc.byte-build-env + ** ocamlc.byte + *** check-ocamlc.byte-output +*) + +(* Structures *) +{%%M.foo| {x} |} +{%%M.foo bar| {|x|} |bar} + +(* Signatures *) +module type S = sig + {%%M.foo| {x} |} + {%%M.foo bar| {|x|} |bar} +end + +(* Expressions/Pattern/Types *) +let {%M.foo| {x} |} + : {%M.foo| {x} |} + = {%M.foo| {x} |} +let {%M.foo bar| {|x|} |bar} + : {%M.foo bar| {|x|} |bar} + = {%M.foo bar| {|x|} |bar} + +(* Multiline *) +{%%M.foo| + + {x} + +|} + +(* Double quotes inside quoted strings inside comments *) +(* {|"|}, and *) +(* [%foo {|"|}], and *) +(* {%foo|"|} should be valid inside comments *) + +(* Comment delimiters inside quoted strings inside comments: *) +(* {|*)|}, and *) +(* [%foo {bar|*)|bar}], and *) +(* {%foo bar|*)|bar} should be valid inside comments *) diff --git a/testsuite/tests/regression/pr1580/pr1580.ml b/testsuite/tests/regression/pr1580/pr1580.ml new file mode 100644 index 00000000..bbe76848 --- /dev/null +++ b/testsuite/tests/regression/pr1580/pr1580.ml @@ -0,0 +1,56 @@ +(* TEST *) + +(* This function uses a ref initially holding an immediate (None), + which is later mutated to hold a pointer (Some ...). Despite + initially holding an immediate, the register used must be marked + in the frametable. + + This was previously done by distinguishing Const_pointer (values + like None from a type that also contains pointers) from Const_int + (values like 0 from a type that contains no pointers), but is + now done by preserving typing information about the ref. *) + +let no_magic b = + let r = ref None in + for i = 1 to 10 do + let z = if b then !r else None in + Gc.minor (); + r := Some (String.make i '.'); + (match z with None -> () | Some s -> print_endline s) + done + + +(* This version is the same, except uses Obj.magic 0 instead of None. + This segfaulted when the Const_pointer / Const_int distinction + was used for register typing, as Obj.magic 0 is a Const_int *) + +let light_magic b = + let none = (Obj.magic 0 : string option) in + let r = ref none in + for i = 1 to 10 do + let z = if b then !r else none in + Gc.minor (); + r := Some (String.make i '.'); + (match z with None -> () | Some s -> print_endline s) + done + + +(* This version stores references to heap values inside an `int ref`, + which is eliminated and the resulting register is not marked in + the frametable. This is not expected to work, segfaults on all + versions, and is included here only to document what not to do. *) + +let dark_magic b = + let none = 0 in + let r = ref 0 in + for i = 1 to 10 do + let z : string option = Obj.magic (if b then !r else none) in + Gc.minor (); + r := Obj.magic (Some (String.make i '.')); + (match z with None -> () | Some s -> print_endline s) + done + + +let () = + Sys.opaque_identity no_magic true; + Sys.opaque_identity light_magic true diff --git a/testsuite/tests/regression/pr1580/pr1580.reference b/testsuite/tests/regression/pr1580/pr1580.reference new file mode 100644 index 00000000..51e38e53 --- /dev/null +++ b/testsuite/tests/regression/pr1580/pr1580.reference @@ -0,0 +1,18 @@ +. +.. +... +.... +..... +...... +....... +........ +......... +. +.. +... +.... +..... +...... +....... +........ +......... diff --git a/testsuite/tests/regression/pr3612/pr3612.ml b/testsuite/tests/regression/pr3612/pr3612.ml index 7d536318..c2ca8dbb 100644 --- a/testsuite/tests/regression/pr3612/pr3612.ml +++ b/testsuite/tests/regression/pr3612/pr3612.ml @@ -6,7 +6,7 @@ type t external test_alloc : unit -> t = "caml_test_pr3612_alloc" external get_counter : unit -> int = "caml_test_pr3612_counter" -(* The number of deserialized blocs minus the number of freed blocs *) +(* The number of deserialized blocks minus the number of freed blocks *) external init : unit -> unit = "caml_test_pr3612_init" diff --git a/testsuite/tests/regression/pr7718/pr7718.ml b/testsuite/tests/regression/pr7718/pr7718.ml new file mode 100644 index 00000000..ac4397da --- /dev/null +++ b/testsuite/tests/regression/pr7718/pr7718.ml @@ -0,0 +1,37 @@ +(* TEST *) + +let go () = + Gc.full_major (); + for i = 1 to 10_000 do + let rec b = + let x = (b, b) in + (* Force the above allocation to be live across a GC, + by allocating a large enough object that the allocations + cannot be combined. *) + let x = [| x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; + x |] in + let _y = ref x in + 42 in + ignore (Sys.opaque_identity b); + () + done; + () + +let _ = + let _ = go () in + print_endline "ok" diff --git a/testsuite/tests/regression/pr7718/pr7718.reference b/testsuite/tests/regression/pr7718/pr7718.reference new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/testsuite/tests/regression/pr7718/pr7718.reference @@ -0,0 +1 @@ +ok diff --git a/testsuite/tests/regression/pr9443/pr9443.ml b/testsuite/tests/regression/pr9443/pr9443.ml new file mode 100644 index 00000000..8a72cd08 --- /dev/null +++ b/testsuite/tests/regression/pr9443/pr9443.ml @@ -0,0 +1,11 @@ +(* TEST *) + +(* Test tail call optimisation with an elided mutable cell *) +let rec loop n = + if n = 0 then () else begin + let last = ref 0 in + last := 0; + loop (n-1) + end + +let () = loop 1_000_000 diff --git a/testsuite/tests/reproducibility/cmis_on_file_system.ml b/testsuite/tests/reproducibility/cmis_on_file_system.ml new file mode 100644 index 00000000..188fed77 --- /dev/null +++ b/testsuite/tests/reproducibility/cmis_on_file_system.ml @@ -0,0 +1,26 @@ +(* TEST + files = "cmis_on_file_system.ml cmis_on_file_system_companion.mli" + * setup-ocamlc.byte-build-env + ** ocamlc.byte + compile_only = "true" + module = "cmis_on_file_system.ml" + flags="-bin-annot" + *** script + script= "mv cmis_on_file_system.cmt lone.cmt" + **** ocamlc.byte + module = "cmis_on_file_system_companion.mli" + compile_only="true" + ***** ocamlc.byte + compile_only = "true" + flags="-bin-annot" + module="cmis_on_file_system.ml" + ****** compare-native-programs + program="cmis_on_file_system.cmt" + program2="lone.cmt" +*) + + +(** Test that we are not recording the cmis present on the file system + at a given point in time *) +type t = int +let () = () diff --git a/testsuite/tests/reproducibility/cmis_on_file_system_companion.mli b/testsuite/tests/reproducibility/cmis_on_file_system_companion.mli new file mode 100644 index 00000000..e69de29b diff --git a/testsuite/tests/statmemprof/arrays_in_major.ml b/testsuite/tests/statmemprof/arrays_in_major.ml new file mode 100644 index 00000000..f3c5b8a6 --- /dev/null +++ b/testsuite/tests/statmemprof/arrays_in_major.ml @@ -0,0 +1,148 @@ +(* TEST + flags = "-g" + compare_programs = "false" +*) + +open Gc.Memprof + +let root = ref [] +let[@inline never] allocate_arrays lo hi cnt keep = + assert (lo >= 300); (* Will be allocated in major heap. *) + for j = 0 to cnt-1 do + for i = lo to hi do + root := Array.make i 0 :: !root + done; + if not keep then root := [] + done + +let check_nosample () = + Printf.printf "check_nosample\n%!"; + let alloc _ = + Printf.printf "Callback called with sampling_rate = 0\n"; + assert(false) + in + start ~callstack_size:10 ~sampling_rate:0. + { null_tracker with alloc_minor = alloc; alloc_major = alloc; }; + allocate_arrays 300 3000 1 false; + stop () + +let () = check_nosample () + +let check_counts_full_major force_promote = + Printf.printf "check_counts_full_major\n%!"; + let nalloc_minor = ref 0 in + let nalloc_major = ref 0 in + let enable = ref true in + let npromote = ref 0 in + let ndealloc_minor = ref 0 in + let ndealloc_major = ref 0 in + start ~callstack_size:10 ~sampling_rate:0.01 + { + alloc_minor = (fun _ -> + if not !enable then None + else Some (incr nalloc_minor) + ); + alloc_major = (fun _ -> + if not !enable then None + else Some (incr nalloc_major) + ); + promote = (fun _ -> + Some (incr npromote) + ); + dealloc_minor = (fun _ -> + incr ndealloc_minor + ); + dealloc_major = (fun _ -> + incr ndealloc_major + ); + }; + allocate_arrays 300 3000 1 true; + enable := false; + assert (!ndealloc_minor = 0 && !ndealloc_major = 0); + if force_promote then begin + Gc.full_major (); + assert (!ndealloc_minor = 0 && !ndealloc_major = 0 && + !npromote = !nalloc_minor); + root := []; + Gc.full_major (); + assert (!ndealloc_minor = 0 && + !ndealloc_major = !nalloc_minor + !nalloc_major); + end else begin + root := []; + Gc.minor (); + Gc.full_major (); + Gc.full_major (); + assert (!nalloc_minor = !ndealloc_minor + !npromote && + !ndealloc_major = !npromote + !nalloc_major) + end; + stop () + +let () = + check_counts_full_major false; + check_counts_full_major true + +let check_no_nested () = + Printf.printf "check_no_nested\n%!"; + let in_callback = ref false in + let cb _ = + assert (not !in_callback); + in_callback := true; + allocate_arrays 300 300 100 false; + in_callback := false; + () + in + let cb' _ = cb (); Some () in + start ~callstack_size:10 ~sampling_rate:1. + { + alloc_minor = cb'; + alloc_major = cb'; + promote = cb'; + dealloc_minor = cb; + dealloc_major = cb; + }; + allocate_arrays 300 300 100 false; + stop () + +let () = check_no_nested () + +let check_distrib lo hi cnt rate = + Printf.printf "check_distrib %d %d %d %f\n%!" lo hi cnt rate; + let smp = ref 0 in + start ~callstack_size:10 ~sampling_rate:rate + { null_tracker with + alloc_major = (fun info -> + assert (info.size >= lo && info.size <= hi); + assert (info.n_samples > 0); + assert (not info.unmarshalled); + smp := !smp + info.n_samples; + None + ); + }; + allocate_arrays lo hi cnt false; + stop (); + + (* The probability distribution of the number of samples follows a + binomial distribution of parameters tot_alloc and rate. Given + that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., > + 100), this distribution is approximately equal to a normal + distribution. We compute a 1e-8 confidence interval for !smp + using quantiles of the normal distribution, and check that we are + in this confidence interval. *) + let tot_alloc = cnt*(lo+hi+2)*(hi-lo+1)/2 in + assert (float tot_alloc *. rate > 100. && + float tot_alloc *. (1. -. rate) > 100.); + let mean = float tot_alloc *. rate in + let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in + (* This assertion has probability to fail close to 1e-8. *) + assert (abs_float (mean -. float !smp) <= stddev *. 5.7) + +let () = + check_distrib 300 3000 3 0.00001; + check_distrib 300 3000 1 0.0001; + check_distrib 300 3000 1 0.01; + check_distrib 300 3000 1 0.9; + check_distrib 300 300 100000 0.1; + check_distrib 300000 300000 30 0.1 + +let () = + Printf.printf "OK !\n" diff --git a/testsuite/tests/statmemprof/arrays_in_major.reference b/testsuite/tests/statmemprof/arrays_in_major.reference new file mode 100644 index 00000000..1f34ad8e --- /dev/null +++ b/testsuite/tests/statmemprof/arrays_in_major.reference @@ -0,0 +1,11 @@ +check_nosample +check_counts_full_major +check_counts_full_major +check_no_nested +check_distrib 300 3000 3 0.000010 +check_distrib 300 3000 1 0.000100 +check_distrib 300 3000 1 0.010000 +check_distrib 300 3000 1 0.900000 +check_distrib 300 300 100000 0.100000 +check_distrib 300000 300000 30 0.100000 +OK ! diff --git a/testsuite/tests/statmemprof/arrays_in_minor.ml b/testsuite/tests/statmemprof/arrays_in_minor.ml new file mode 100644 index 00000000..ec6131f1 --- /dev/null +++ b/testsuite/tests/statmemprof/arrays_in_minor.ml @@ -0,0 +1,162 @@ +(* TEST + flags = "-g" + compare_programs = "false" +*) + +open Gc.Memprof + +let roots = Array.make 1000000 [||] +let roots_pos = ref 0 +let add_root r = + roots.(!roots_pos) <- r; + incr roots_pos +let clear_roots () = + Array.fill roots 0 !roots_pos [||]; + roots_pos := 0 + +let[@inline never] allocate_arrays lo hi cnt keep = + assert (0 < lo && hi <= 250); (* Fits in minor heap. *) + for j = 0 to cnt-1 do + for i = lo to hi do + add_root (Array.make i 0) + done; + if not keep then clear_roots () + done + +let check_nosample () = + Printf.printf "check_nosample\n%!"; + let alloc _ = + Printf.printf "Callback called with sampling_rate = 0\n"; + assert(false) + in + start ~callstack_size:10 ~sampling_rate:0. + { null_tracker with alloc_minor = alloc; alloc_major = alloc }; + allocate_arrays 1 250 100 false; + stop () + +let () = check_nosample () + +let check_counts_full_major force_promote = + Printf.printf "check_counts_full_major\n%!"; + let nalloc_minor = ref 0 in + let enable = ref true in + let promotes_allowed = ref true in + let npromote = ref 0 in + let ndealloc_minor = ref 0 in + let ndealloc_major = ref 0 in + start ~callstack_size:10 ~sampling_rate:0.01 + { + alloc_minor = (fun info -> + if !enable then begin + incr nalloc_minor; if !nalloc_minor mod 100 = 0 then Gc.minor (); + Some (ref 42) + end else begin + allocate_arrays 1 250 1 true; + None + end); + alloc_major = (fun _ -> assert false); + promote = (fun k -> + assert (!k = 42 && !promotes_allowed); + incr npromote; if !npromote mod 1097 = 0 then Gc.minor (); + Some (ref 17)); + dealloc_minor = (fun k -> + assert (!k = 42); + incr ndealloc_minor); + dealloc_major = (fun r -> + assert (!r = 17); + incr ndealloc_major); + }; + allocate_arrays 1 250 100 true; + enable := false; + assert (!ndealloc_minor = 0 && !ndealloc_major = 0); + if force_promote then begin + Gc.full_major (); + promotes_allowed := false; + allocate_arrays 1 250 10 true; + Gc.full_major (); + assert (!ndealloc_minor = 0 && !ndealloc_major = 0 && + !npromote = !nalloc_minor); + clear_roots (); + Gc.full_major (); + assert (!ndealloc_minor = 0 && !ndealloc_major = !nalloc_minor); + end else begin + clear_roots (); + Gc.minor (); + Gc.full_major (); + Gc.full_major (); + assert (!nalloc_minor = !ndealloc_minor + !npromote && + !ndealloc_major = !npromote) + end; + stop () + +let () = + check_counts_full_major false; + check_counts_full_major true + +let check_no_nested () = + Printf.printf "check_no_nested\n%!"; + let in_callback = ref false in + let cb _ = + assert (not !in_callback); + in_callback := true; + allocate_arrays 1 100 10 false; + ignore (Array.to_list (Array.make 1000 0)); + in_callback := false; + () + in + let cb' _ = cb (); Some () in + start ~callstack_size:10 ~sampling_rate:1. + { + alloc_minor = cb'; + alloc_major = cb'; + promote = cb'; + dealloc_minor = cb; + dealloc_major = cb; + }; + allocate_arrays 1 250 5 false; + stop () + +let () = check_no_nested () + +let check_distrib lo hi cnt rate = + Printf.printf "check_distrib %d %d %d %f\n%!" lo hi cnt rate; + let smp = ref 0 in + start ~callstack_size:10 ~sampling_rate:rate + { null_tracker with + alloc_major = (fun _ -> assert false); + alloc_minor = (fun info -> + assert (info.size >= lo && info.size <= hi); + assert (info.n_samples > 0); + assert (not info.unmarshalled); + smp := !smp + info.n_samples; + None + ); + }; + allocate_arrays lo hi cnt false; + stop (); + + (* The probability distribution of the number of samples follows a + binomial distribution of parameters tot_alloc and rate. Given + that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., > + 100), this distribution is approximately equal to a normal + distribution. We compute a 1e-8 confidence interval for !smp + using quantiles of the normal distribution, and check that we are + in this confidence interval. *) + let tot_alloc = cnt*(lo+hi+2)*(hi-lo+1)/2 in + assert (float tot_alloc *. rate > 100. && + float tot_alloc *. (1. -. rate) > 100.); + let mean = float tot_alloc *. rate in + let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in + (* This assertion has probability to fail close to 1e-8. *) + assert (abs_float (mean -. float !smp) <= stddev *. 5.7) + +let () = + check_distrib 1 250 1000 0.00001; + check_distrib 1 250 1000 0.0001; + check_distrib 1 250 1000 0.01; + check_distrib 1 250 1000 0.9; + check_distrib 1 1 10000000 0.01; + check_distrib 250 250 100000 0.1 + +let () = + Printf.printf "OK !\n" diff --git a/testsuite/tests/statmemprof/arrays_in_minor.reference b/testsuite/tests/statmemprof/arrays_in_minor.reference new file mode 100644 index 00000000..1dad9193 --- /dev/null +++ b/testsuite/tests/statmemprof/arrays_in_minor.reference @@ -0,0 +1,11 @@ +check_nosample +check_counts_full_major +check_counts_full_major +check_no_nested +check_distrib 1 250 1000 0.000010 +check_distrib 1 250 1000 0.000100 +check_distrib 1 250 1000 0.010000 +check_distrib 1 250 1000 0.900000 +check_distrib 1 1 10000000 0.010000 +check_distrib 250 250 100000 0.100000 +OK ! diff --git a/testsuite/tests/statmemprof/blocking_in_callback.ml b/testsuite/tests/statmemprof/blocking_in_callback.ml new file mode 100644 index 00000000..d5e8d2ce --- /dev/null +++ b/testsuite/tests/statmemprof/blocking_in_callback.ml @@ -0,0 +1,69 @@ +(* TEST +* hassysthreads +include systhreads +** bytecode +** native +*) + +let cnt = ref 0 +let alloc_num = ref 0 +let alloc_tot = 100000 + +let (rd1, wr1) = Unix.pipe () +let (rd2, wr2) = Unix.pipe () + +let main_thread = Thread.self () +let cb_main = ref 0 and cb_other = ref 0 +let stopped = ref false +let minor_alloc_callback _ = + if !stopped then + None + else begin + let do_stop = !cb_main + !cb_other >= alloc_tot in + if do_stop then stopped := true; + let t = Thread.self () in + if t == main_thread then begin + incr cb_main; + assert (Unix.write wr2 (Bytes.make 1 'a') 0 1 = 1); + if not do_stop then + assert (Unix.read rd1 (Bytes.make 1 'a') 0 1 = 1) + end else begin + incr cb_other; + assert (Unix.write wr1 (Bytes.make 1 'a') 0 1 = 1); + if not do_stop then + assert (Unix.read rd2 (Bytes.make 1 'a') 0 1 = 1) + end; + Some () + end + +let mut = Mutex.create () +let () = Mutex.lock mut + +let rec go () = + Mutex.lock mut; + Mutex.unlock mut; + if !alloc_num < alloc_tot then begin + alloc_num := !alloc_num + 1; + Sys.opaque_identity (Bytes.make (Random.int 300) 'a') |> ignore; + go () + end else begin + cnt := !cnt + 1; + if !cnt < 2 then begin + Gc.minor (); (* check for callbacks *) + Thread.yield (); + go () + end else begin + Gc.minor () (* check for callbacks *) + end + end + +let () = + let t = Thread.create go () in + Gc.Memprof.(start ~callstack_size:10 ~sampling_rate:1. + { null_tracker with alloc_minor = minor_alloc_callback; }); + Mutex.unlock mut; + go (); + Thread.join t; + Gc.Memprof.stop (); + assert (abs (!cb_main - !cb_other) <= 1); + assert (!cb_main + !cb_other >= alloc_tot) diff --git a/testsuite/tests/statmemprof/callstacks.flat-float-array.reference b/testsuite/tests/statmemprof/callstacks.flat-float-array.reference new file mode 100644 index 00000000..7efb00ae --- /dev/null +++ b/testsuite/tests/statmemprof/callstacks.flat-float-array.reference @@ -0,0 +1,74 @@ +----------- +Raised by primitive operation at Callstacks.alloc_list_literal in file "callstacks.ml", line 19, characters 30-53 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_pair in file "callstacks.ml", line 22, characters 30-76 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_record in file "callstacks.ml", line 27, characters 12-66 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_some in file "callstacks.ml", line 30, characters 30-60 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_array_literal in file "callstacks.ml", line 33, characters 30-55 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_float_array_literal in file "callstacks.ml", line 37, characters 12-62 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.do_alloc_unknown_array_literal in file "callstacks.ml", line 40, characters 22-27 +Called from Callstacks.alloc_unknown_array_literal in file "callstacks.ml", line 42, characters 30-65 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_small_array in file "callstacks.ml", line 45, characters 30-69 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_large_array in file "callstacks.ml", line 48, characters 30-73 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_closure.(fun) in file "callstacks.ml", line 52, characters 30-43 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.get0 in file "callstacks.ml", line 55, characters 28-33 +Called from Callstacks.getfloatfield in file "callstacks.ml", line 57, characters 30-47 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Stdlib__marshal.from_bytes in file "marshal.ml", line 61, characters 9-35 +Called from Callstacks.alloc_unmarshal in file "callstacks.ml", line 63, characters 12-87 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_ref in file "callstacks.ml", line 66, characters 30-59 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.prod_floats in file "callstacks.ml", line 69, characters 37-43 +Called from Callstacks.alloc_boxedfloat in file "callstacks.ml", line 71, characters 30-49 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 diff --git a/testsuite/tests/statmemprof/callstacks.ml b/testsuite/tests/statmemprof/callstacks.ml new file mode 100644 index 00000000..758d01dc --- /dev/null +++ b/testsuite/tests/statmemprof/callstacks.ml @@ -0,0 +1,100 @@ +(* TEST + flags = "-g -w -5" + compare_programs = "false" + + * flat-float-array + reference = "${test_source_directory}/callstacks.flat-float-array.reference" + ** native + ** bytecode + + * no-flat-float-array + reference = "${test_source_directory}/callstacks.no-flat-float-array.reference" + ** native + ** bytecode +*) + +open Gc.Memprof + +let alloc_list_literal () = + ignore (Sys.opaque_identity [Sys.opaque_identity 1]) + +let alloc_pair () = + ignore (Sys.opaque_identity (Sys.opaque_identity 1, Sys.opaque_identity 2)) + +type record = { a : int; b : int } +let alloc_record () = + ignore (Sys.opaque_identity + {a = Sys.opaque_identity 1; b = Sys.opaque_identity 2}) + +let alloc_some () = + ignore (Sys.opaque_identity (Some (Sys.opaque_identity 2))) + +let alloc_array_literal () = + ignore (Sys.opaque_identity [|Sys.opaque_identity 1|]) + +let alloc_float_array_literal () = + ignore (Sys.opaque_identity + [|Sys.opaque_identity 1.; Sys.opaque_identity 2.|]) + +let[@inline never] do_alloc_unknown_array_literal x = + Sys.opaque_identity [|x|] +let alloc_unknown_array_literal () = + ignore (Sys.opaque_identity (do_alloc_unknown_array_literal 1.)) + +let alloc_small_array () = + ignore (Sys.opaque_identity (Array.make 10 (Sys.opaque_identity 1))) + +let alloc_large_array () = + ignore (Sys.opaque_identity (Array.make 100000 (Sys.opaque_identity 1))) + +let alloc_closure () = + let x = Sys.opaque_identity 1 in + ignore (Sys.opaque_identity (fun () -> x)) + +let floatarray = [| 1.; 2. |] +let[@inline never] get0 a = a.(0) +let getfloatfield () = + ignore (Sys.opaque_identity (get0 floatarray)) + +let marshalled = + Marshal.to_string [Sys.opaque_identity 1] [] +let alloc_unmarshal () = + ignore (Sys.opaque_identity + ((Marshal.from_string [@inlined never]) (Sys.opaque_identity marshalled) 0)) + +let alloc_ref () = + ignore (Sys.opaque_identity (ref (Sys.opaque_identity 1))) + +let fl = 1. +let[@inline never] prod_floats a b = a *. b +let alloc_boxedfloat () = + ignore (Sys.opaque_identity (prod_floats fl fl)) + +let allocators = + [alloc_list_literal; alloc_pair; alloc_record; alloc_some; + alloc_array_literal; alloc_float_array_literal; alloc_unknown_array_literal; + alloc_small_array; alloc_large_array; alloc_closure; + getfloatfield; alloc_unmarshal; alloc_ref; alloc_boxedfloat] + +let test alloc = + Printf.printf "-----------\n%!"; + let callstack = ref None in + start ~callstack_size:10 ~sampling_rate:1. + { null_tracker with + alloc_minor = (fun info -> + callstack := Some info.callstack; + None + ); + alloc_major = (fun info -> + callstack := Some info.callstack; + None + ); + }; + alloc (); + stop (); + match !callstack with + | None -> Printf.printf "No callstack\n%!"; + | Some cs -> Printexc.print_raw_backtrace stdout cs + +let () = + List.iter test allocators diff --git a/testsuite/tests/statmemprof/callstacks.no-flat-float-array.reference b/testsuite/tests/statmemprof/callstacks.no-flat-float-array.reference new file mode 100644 index 00000000..789f5341 --- /dev/null +++ b/testsuite/tests/statmemprof/callstacks.no-flat-float-array.reference @@ -0,0 +1,70 @@ +----------- +Raised by primitive operation at Callstacks.alloc_list_literal in file "callstacks.ml", line 19, characters 30-53 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_pair in file "callstacks.ml", line 22, characters 30-76 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_record in file "callstacks.ml", line 27, characters 12-66 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_some in file "callstacks.ml", line 30, characters 30-60 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_array_literal in file "callstacks.ml", line 33, characters 30-55 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_float_array_literal in file "callstacks.ml", line 37, characters 12-62 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.do_alloc_unknown_array_literal in file "callstacks.ml", line 40, characters 22-27 +Called from Callstacks.alloc_unknown_array_literal in file "callstacks.ml", line 42, characters 30-65 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_small_array in file "callstacks.ml", line 45, characters 30-69 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_large_array in file "callstacks.ml", line 48, characters 30-73 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_closure.(fun) in file "callstacks.ml", line 52, characters 30-43 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +No callstack +----------- +Raised by primitive operation at Stdlib__marshal.from_bytes in file "marshal.ml", line 61, characters 9-35 +Called from Callstacks.alloc_unmarshal in file "callstacks.ml", line 63, characters 12-87 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.alloc_ref in file "callstacks.ml", line 66, characters 30-59 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 +----------- +Raised by primitive operation at Callstacks.prod_floats in file "callstacks.ml", line 69, characters 37-43 +Called from Callstacks.alloc_boxedfloat in file "callstacks.ml", line 71, characters 30-49 +Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Callstacks in file "callstacks.ml", line 100, characters 2-27 diff --git a/testsuite/tests/statmemprof/comballoc.byte.reference b/testsuite/tests/statmemprof/comballoc.byte.reference new file mode 100644 index 00000000..31dce2d0 --- /dev/null +++ b/testsuite/tests/statmemprof/comballoc.byte.reference @@ -0,0 +1,49 @@ +2: 0.42 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +3: 0.42 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +4: 0.42 true +Raised by primitive operation at Comballoc.f4 in file "comballoc.ml", line 12, characters 11-20 +Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +2: 0.01 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +3: 0.01 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +4: 0.01 true +Raised by primitive operation at Comballoc.f4 in file "comballoc.ml", line 12, characters 11-20 +Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +2: 0.83 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +3: 0.83 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +4: 0.83 true +Raised by primitive operation at Comballoc.f4 in file "comballoc.ml", line 12, characters 11-20 +Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +OK diff --git a/testsuite/tests/statmemprof/comballoc.ml b/testsuite/tests/statmemprof/comballoc.ml new file mode 100644 index 00000000..716883d8 --- /dev/null +++ b/testsuite/tests/statmemprof/comballoc.ml @@ -0,0 +1,92 @@ +(* TEST + flags = "-g" + * bytecode + reference = "${test_source_directory}/comballoc.byte.reference" + * native + reference = "${test_source_directory}/comballoc.opt.reference" + compare_programs = "false" +*) + +open Gc.Memprof + +let f4 n = (n,n,n,n) + +let[@inline never] f n = + (n, (n, n, f4 n)) + +let test sampling_rate = + let allocs = Array.make 257 0 in + let deallocs = Array.make 257 0 in + let promotes = Array.make 257 0 in + let callstacks = Array.make 257 None in + start ~callstack_size:10 ~sampling_rate + { null_tracker with + alloc_minor = (fun info -> + allocs.(info.size) <- allocs.(info.size) + info.n_samples; + begin match callstacks.(info.size) with + | None -> callstacks.(info.size) <- Some info.callstack + | Some s -> assert (s = info.callstack) + end; + Some (info.size, info.n_samples)); + dealloc_minor = (fun (sz,n) -> + deallocs.(sz) <- deallocs.(sz) + n); + promote = (fun (sz,n) -> + promotes.(sz) <- promotes.(sz) + n; + None); + }; + let iter = 100_000 in + let arr = Array.make iter (0,0,0,0) in + for i = 0 to Array.length arr - 1 do + let (_, (_, _, x)) = Sys.opaque_identity f i in + arr.(i) <- x; + done; + Gc.minor (); + stop (); + ignore (Sys.opaque_identity arr); + for i = 0 to 256 do + assert (deallocs.(i) + promotes.(i) = allocs.(i)); + if allocs.(i) > 0 then begin + let total = (i + 1) * iter in + (* allocs.(i) / total is + Binomial(total, rate) / total + which is approx. + Normal(total * rate, total * rate*(1-rate)) / total + which is + Normal(1, rate*(1-rate) / total) + which has stddev sqrt(rate*(1-rate)/total) + which is less than 10^-3 for the values here. + So, an error of 0.005 (enough to make %.2f print differently) + is a 5-sigma event, with probability less than 3*10^-7 *) + Printf.printf "%d: %.2f %b\n" i + (float_of_int allocs.(i) /. float_of_int total) + (promotes.(i) > 1000); + (match callstacks.(i) with + | Some s -> Printexc.print_raw_backtrace stdout s + | None -> assert false) + end + done + +let () = + List.iter test [0.42; 0.01; 0.83] + + +let no_callback_after_stop trigger = + let stopped = ref false in + let cnt = ref 0 in + start ~callstack_size:0 ~sampling_rate:1. + { null_tracker with + alloc_minor = (fun info -> + assert(not !stopped); + incr cnt; + if !cnt > trigger then begin + stop (); + stopped := true + end; + None); + }; + for i = 0 to 1000 do ignore (Sys.opaque_identity f i) done; + assert !stopped + +let () = + for i = 0 to 1000 do no_callback_after_stop i done; + Printf.printf "OK\n" diff --git a/testsuite/tests/statmemprof/comballoc.opt.reference b/testsuite/tests/statmemprof/comballoc.opt.reference new file mode 100644 index 00000000..9fbeb6a7 --- /dev/null +++ b/testsuite/tests/statmemprof/comballoc.opt.reference @@ -0,0 +1,49 @@ +2: 0.42 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +3: 0.42 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +4: 0.42 true +Raised by primitive operation at Comballoc.f4 in file "comballoc.ml" (inlined), line 12, characters 11-20 +Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +2: 0.01 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +3: 0.01 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +4: 0.01 true +Raised by primitive operation at Comballoc.f4 in file "comballoc.ml" (inlined), line 12, characters 11-20 +Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +2: 0.83 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +3: 0.83 false +Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +4: 0.83 true +Raised by primitive operation at Comballoc.f4 in file "comballoc.ml" (inlined), line 12, characters 11-20 +Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17 +Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48 +Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15 +Called from Comballoc in file "comballoc.ml", line 70, characters 2-35 +OK diff --git a/testsuite/tests/statmemprof/exception_callback.ml b/testsuite/tests/statmemprof/exception_callback.ml new file mode 100644 index 00000000..55dd5e55 --- /dev/null +++ b/testsuite/tests/statmemprof/exception_callback.ml @@ -0,0 +1,23 @@ +(* TEST + exit_status = "2" +*) + +open Gc.Memprof + +let alloc_tracker on_alloc = + { null_tracker with + alloc_minor = (fun info -> on_alloc info; None); + alloc_major = (fun info -> on_alloc info; None); + } + +(* We don't want to print the backtrace. We just want to make sure the + exception is printed. + This also makes sure [Printexc] is loaded, otherwise we don't use + its uncaught exception handler. *) +let _ = Printexc.record_backtrace false + +let _ = + start ~callstack_size:10 ~sampling_rate:1. + (alloc_tracker (fun _ -> failwith "callback failed")); + ignore (Sys.opaque_identity (Array.make 200 0)); + stop () diff --git a/testsuite/tests/statmemprof/exception_callback.reference b/testsuite/tests/statmemprof/exception_callback.reference new file mode 100644 index 00000000..6371f824 --- /dev/null +++ b/testsuite/tests/statmemprof/exception_callback.reference @@ -0,0 +1 @@ +Fatal error: exception Failure("callback failed") diff --git a/testsuite/tests/statmemprof/exception_callback_minor.ml b/testsuite/tests/statmemprof/exception_callback_minor.ml new file mode 100644 index 00000000..f5141232 --- /dev/null +++ b/testsuite/tests/statmemprof/exception_callback_minor.ml @@ -0,0 +1,20 @@ +(* TEST + exit_status = "2" +*) + +open Gc.Memprof + +(* We don't want to print the backtrace. We just want to make sure the + exception is printed. + This also makes sure [Printexc] is loaded, otherwise we don't use + its uncaught exception handler. *) +let _ = Printexc.record_backtrace false + +let _ = + start ~callstack_size:10 ~sampling_rate:1. + { null_tracker with + alloc_minor = (fun _ -> assert false); + alloc_major = (fun _ -> assert false); + }; + ignore (Sys.opaque_identity (ref (ref 42))); + stop () diff --git a/testsuite/tests/statmemprof/exception_callback_minor.reference b/testsuite/tests/statmemprof/exception_callback_minor.reference new file mode 100644 index 00000000..af75fbbe --- /dev/null +++ b/testsuite/tests/statmemprof/exception_callback_minor.reference @@ -0,0 +1 @@ +Fatal error: exception File "exception_callback_minor.ml", line 16, characters 30-36: Assertion failed diff --git a/testsuite/tests/statmemprof/intern.ml b/testsuite/tests/statmemprof/intern.ml new file mode 100644 index 00000000..5a5ff558 --- /dev/null +++ b/testsuite/tests/statmemprof/intern.ml @@ -0,0 +1,173 @@ +(* TEST + flags = "-g" + * bytecode + * native + compare_programs = "false" +*) + +open Gc.Memprof + +let alloc_tracker on_alloc = + { null_tracker with + alloc_minor = (fun info -> on_alloc info; None); + alloc_major = (fun info -> on_alloc info; None); + } + +type t = I of int | II of int * int | Cons of t +let rec t_of_len = function + | len when len <= 1 -> assert false + | 2 -> I 1 + | 3 -> II (2, 3) + | len -> Cons (t_of_len (len - 2)) + +let marshalled_data = Hashtbl.create 17 +let[@inline never] get_marshalled_data len : t = + Marshal.from_string (Hashtbl.find marshalled_data len) 0 +let precompute_marshalled_data lo hi = + for len = lo to hi do + if not (Hashtbl.mem marshalled_data len) then + Hashtbl.add marshalled_data len (Marshal.to_string (t_of_len len) []) + done + +let root = ref [] +let[@inline never] do_intern lo hi cnt keep = + for j = 0 to cnt-1 do + for i = lo to hi do + root := get_marshalled_data i :: !root + done; + if not keep then root := [] + done + +let check_nosample () = + Printf.printf "check_nosample\n%!"; + precompute_marshalled_data 2 3000; + let fail_on_alloc _ = + Printf.printf "Callback called with sampling_rate = 0\n"; + assert(false) + in + start ~callstack_size:10 ~sampling_rate:0. (alloc_tracker fail_on_alloc); + do_intern 2 3000 1 false; + stop () + +let () = check_nosample () + +let check_counts_full_major force_promote = + Printf.printf "check_counts_full_major\n%!"; + precompute_marshalled_data 2 3000; + let nalloc_minor = ref 0 in + let nalloc_major = ref 0 in + let enable = ref true in + let npromote = ref 0 in + let ndealloc_minor = ref 0 in + let ndealloc_major = ref 0 in + start ~callstack_size:10 ~sampling_rate:0.01 + { + alloc_minor = (fun _ -> + if not !enable then None + else Some (incr nalloc_minor) + ); + alloc_major = (fun _ -> + if not !enable then None + else Some (incr nalloc_major) + ); + promote = (fun _ -> + Some (incr npromote) + ); + dealloc_minor = (fun _ -> + incr ndealloc_minor + ); + dealloc_major = (fun _ -> + incr ndealloc_major + ); + }; + do_intern 2 3000 1 true; + enable := false; + assert (!ndealloc_minor = 0 && !ndealloc_major = 0); + if force_promote then begin + Gc.full_major (); + assert (!ndealloc_minor = 0 && !ndealloc_major = 0 && + !npromote = !nalloc_minor); + root := []; + Gc.full_major (); + assert (!ndealloc_minor = 0 && + !ndealloc_major = !nalloc_minor + !nalloc_major); + end else begin + root := []; + Gc.minor (); + Gc.full_major (); + Gc.full_major (); + assert (!nalloc_minor = !ndealloc_minor + !npromote && + !ndealloc_major = !npromote + !nalloc_major) + end; + stop () + +let () = + check_counts_full_major false; + check_counts_full_major true + +let check_no_nested () = + Printf.printf "check_no_nested\n%!"; + precompute_marshalled_data 2 300; + let in_callback = ref false in + let cb _ = + assert (not !in_callback); + in_callback := true; + do_intern 100 200 1 false; + in_callback := false; + () + in + let cb' _ = cb (); Some () in + start ~callstack_size:10 ~sampling_rate:1. + { + alloc_minor = cb'; + alloc_major = cb'; + promote = cb'; + dealloc_minor = cb; + dealloc_major = cb; + }; + do_intern 100 200 1 false; + stop () + +let () = check_no_nested () + +let check_distrib lo hi cnt rate = + Printf.printf "check_distrib %d %d %d %f\n%!" lo hi cnt rate; + precompute_marshalled_data lo hi; + let smp = ref 0 in + let alloc info = + (* We also allocate the list constructor in the minor heap, + so we filter that out. *) + if info.unmarshalled then begin + assert (info.size = 1 || info.size = 2); + assert (info.n_samples > 0); + smp := !smp + info.n_samples + end; + in + start ~callstack_size:10 ~sampling_rate:rate (alloc_tracker alloc); + do_intern lo hi cnt false; + stop (); + + (* The probability distribution of the number of samples follows a + binomial distribution of parameters tot_alloc and rate. Given + that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., > + 100), this distribution is approximately equal to a normal + distribution. We compute a 1e-8 confidence interval for !smp + using quantiles of the normal distribution, and check that we are + in this confidence interval. *) + let tot_alloc = cnt*(lo+hi)*(hi-lo+1)/2 in + assert (float tot_alloc *. rate > 100. && + float tot_alloc *. (1. -. rate) > 100.); + let mean = float tot_alloc *. rate in + let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in + (* This assertion has probability to fail close to 1e-8. *) + assert (abs_float (mean -. float !smp) <= stddev *. 5.7) + +let () = + check_distrib 2 3000 3 0.00001; + check_distrib 2 3000 1 0.0001; + check_distrib 2 2000 1 0.01; + check_distrib 2 2000 1 0.9; + check_distrib 300000 300000 20 0.1 + +let () = + Printf.printf "OK !\n" diff --git a/testsuite/tests/statmemprof/intern.reference b/testsuite/tests/statmemprof/intern.reference new file mode 100644 index 00000000..d83e8d6d --- /dev/null +++ b/testsuite/tests/statmemprof/intern.reference @@ -0,0 +1,10 @@ +check_nosample +check_counts_full_major +check_counts_full_major +check_no_nested +check_distrib 2 3000 3 0.000010 +check_distrib 2 3000 1 0.000100 +check_distrib 2 2000 1 0.010000 +check_distrib 2 2000 1 0.900000 +check_distrib 300000 300000 20 0.100000 +OK ! diff --git a/testsuite/tests/statmemprof/lists_in_minor.ml b/testsuite/tests/statmemprof/lists_in_minor.ml new file mode 100644 index 00000000..7a3736a2 --- /dev/null +++ b/testsuite/tests/statmemprof/lists_in_minor.ml @@ -0,0 +1,60 @@ +(* TEST + flags = "-g" + * bytecode + * native + compare_programs = "false" +*) + +open Gc.Memprof + +let rec allocate_list accu = function + | 0 -> accu + | n -> allocate_list (n::accu) (n-1) + +let[@inline never] allocate_lists len cnt = + for j = 0 to cnt-1 do + ignore (allocate_list [] len) + done + +let check_distrib len cnt rate = + Printf.printf "check_distrib %d %d %f\n%!" len cnt rate; + let smp = ref 0 in + start ~callstack_size:10 ~sampling_rate:rate + { null_tracker with + alloc_major = (fun _ -> assert false); + alloc_minor = (fun info -> + assert (info.size = 2); + assert (info.n_samples > 0); + assert (not info.unmarshalled); + smp := !smp + info.n_samples; + None); + }; + allocate_lists len cnt; + stop (); + + (* The probability distribution of the number of samples follows a + binomial distribution of parameters tot_alloc and rate. Given + that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., > + 100), this distribution is approximately equal to a normal + distribution. We compute a 1e-8 confidence interval for !smp + using quantiles of the normal distribution, and check that we are + in this confidence interval. *) + let tot_alloc = cnt*len*3 in + assert (float tot_alloc *. rate > 100. && + float tot_alloc *. (1. -. rate) > 100.); + let mean = float tot_alloc *. rate in + let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in + (* This assertion has probability to fail close to 1e-8. *) + assert (abs_float (mean -. float !smp) <= stddev *. 5.7) + +let () = + check_distrib 10 1000000 0.01; + check_distrib 1000000 10 0.00001; + check_distrib 1000000 10 0.0001; + check_distrib 1000000 10 0.001; + check_distrib 1000000 10 0.01; + check_distrib 100000 10 0.1; + check_distrib 100000 10 0.9 + +let () = + Printf.printf "OK !\n" diff --git a/testsuite/tests/statmemprof/lists_in_minor.reference b/testsuite/tests/statmemprof/lists_in_minor.reference new file mode 100644 index 00000000..11cfe0ca --- /dev/null +++ b/testsuite/tests/statmemprof/lists_in_minor.reference @@ -0,0 +1,8 @@ +check_distrib 10 1000000 0.010000 +check_distrib 1000000 10 0.000010 +check_distrib 1000000 10 0.000100 +check_distrib 1000000 10 0.001000 +check_distrib 1000000 10 0.010000 +check_distrib 100000 10 0.100000 +check_distrib 100000 10 0.900000 +OK ! diff --git a/testsuite/tests/statmemprof/minor_no_postpone.ml b/testsuite/tests/statmemprof/minor_no_postpone.ml new file mode 100644 index 00000000..9d9ecd79 --- /dev/null +++ b/testsuite/tests/statmemprof/minor_no_postpone.ml @@ -0,0 +1,36 @@ +(* TEST + modules = "minor_no_postpone_stub.c" +*) + +open Gc.Memprof + +let notify_minor ref_ok ref_done = + { null_tracker with + alloc_minor = (fun _ -> + assert !ref_ok; + ref_done := true; + None); + } + +let () = + let callback_ok = ref true in + let callback_done = ref false in + start ~callstack_size:0 ~sampling_rate:1. + (notify_minor callback_ok callback_done); + ignore (Sys.opaque_identity (ref 0)); + assert(!callback_done); + callback_ok := false; + stop () + +external alloc_stub : unit -> unit ref = "alloc_stub" + +let () = + let callback_ok = ref false in + let callback_done = ref false in + start ~callstack_size:0 ~sampling_rate:1. + (notify_minor callback_ok callback_done); + ignore (Sys.opaque_identity (alloc_stub ())); + assert(not !callback_done); + callback_ok := true; + stop (); + assert(!callback_done) diff --git a/testsuite/tests/statmemprof/minor_no_postpone_stub.c b/testsuite/tests/statmemprof/minor_no_postpone_stub.c new file mode 100644 index 00000000..5df6cc51 --- /dev/null +++ b/testsuite/tests/statmemprof/minor_no_postpone_stub.c @@ -0,0 +1,5 @@ +#include "caml/alloc.h" + +value alloc_stub(value v) { + return caml_alloc(1, 0); +} diff --git a/testsuite/tests/statmemprof/thread_exit_in_callback.ml b/testsuite/tests/statmemprof/thread_exit_in_callback.ml new file mode 100644 index 00000000..97c1a3ae --- /dev/null +++ b/testsuite/tests/statmemprof/thread_exit_in_callback.ml @@ -0,0 +1,18 @@ +(* TEST +modules = "thread_exit_in_callback_stub.c" +exit_status = "42" +* hassysthreads +include systhreads +** bytecode +** native +*) + +(* We cannot tell Ocamltest that this program is supposed to stop with + a fatal error. Instead, we install a fatal error hook and call exit(42) *) +external install_fatal_error_hook : unit -> unit = "install_fatal_error_hook" + +let _ = + install_fatal_error_hook (); + Gc.Memprof.(start ~callstack_size:10 ~sampling_rate:1. + { null_tracker with alloc_minor = fun _ -> Thread.exit (); None }); + ignore (Sys.opaque_identity (ref 1)) diff --git a/testsuite/tests/statmemprof/thread_exit_in_callback.reference b/testsuite/tests/statmemprof/thread_exit_in_callback.reference new file mode 100644 index 00000000..4d745f0c --- /dev/null +++ b/testsuite/tests/statmemprof/thread_exit_in_callback.reference @@ -0,0 +1 @@ +Fatal error hook: Thread.exit called from a memprof callback. diff --git a/testsuite/tests/statmemprof/thread_exit_in_callback_stub.c b/testsuite/tests/statmemprof/thread_exit_in_callback_stub.c new file mode 100644 index 00000000..91ed43cc --- /dev/null +++ b/testsuite/tests/statmemprof/thread_exit_in_callback_stub.c @@ -0,0 +1,16 @@ +#include +#include "caml/misc.h" +#include "caml/mlvalues.h" + +void fatal_error_hook_exit_3 (char *msg, va_list args) { + fprintf(stderr, "Fatal error hook: "); + vfprintf(stderr, msg, args); + fprintf(stderr, "\n"); + exit(42); +} + + +value install_fatal_error_hook (value unit) { + caml_fatal_error_hook = fatal_error_hook_exit_3; + return Val_unit; +} diff --git a/testsuite/tests/tool-lexyacc/chars.mll b/testsuite/tests/tool-lexyacc/chars.mll index 119a0f7e..b91f2618 100644 --- a/testsuite/tests/tool-lexyacc/chars.mll +++ b/testsuite/tests/tool-lexyacc/chars.mll @@ -14,3 +14,4 @@ rule token = parse | 'c' { f1 "\u{1F42B}" } | 'd' { f1 {|}|} } | 'e' { (* " *) } (* " *) } + | 'f' { (* {%foo bar| *) } (* |bar} *) } diff --git a/testsuite/tests/tool-lexyacc/grammar.mly b/testsuite/tests/tool-lexyacc/grammar.mly index 24a06c5e..7247eca5 100644 --- a/testsuite/tests/tool-lexyacc/grammar.mly +++ b/testsuite/tests/tool-lexyacc/grammar.mly @@ -8,6 +8,11 @@ open Gram_aux let () = let f' = ignore in f' '"' + +(* test {|*)|}, {%foo|*)|} and {%%f.oo bar|*)|bar} *) +(* test {%foo {%| *) + +let () = ignore {foo||foo} %} %token Tident diff --git a/testsuite/tests/tool-ocamlc-open/tool-ocamlc-open-error.compilers.reference b/testsuite/tests/tool-ocamlc-open/tool-ocamlc-open-error.compilers.reference new file mode 100644 index 00000000..4c75c9fe --- /dev/null +++ b/testsuite/tests/tool-ocamlc-open/tool-ocamlc-open-error.compilers.reference @@ -0,0 +1,4 @@ +File "tool-ocamlc-open-error.ml", line 1: +Warning 24: bad source file name: "Tool-ocamlc-open-error" is not a valid module name. +File "command line argument: -open "F("", line 1, characters 1-2: +Error: Syntax error diff --git a/testsuite/tests/tool-ocamlc-open/tool-ocamlc-open-error.ml b/testsuite/tests/tool-ocamlc-open/tool-ocamlc-open-error.ml new file mode 100644 index 00000000..e965ca43 --- /dev/null +++ b/testsuite/tests/tool-ocamlc-open/tool-ocamlc-open-error.ml @@ -0,0 +1,7 @@ +(* TEST +* setup-ocamlc.byte-build-env +** ocamlc.byte +flags = "-open F(" +ocamlc_byte_exit_status = "2" +*** check-ocamlc.byte-output +*) diff --git a/testsuite/tests/tool-ocamlc-stop-after/stop_after_parsing_impl.compilers.reference b/testsuite/tests/tool-ocamlc-stop-after/stop_after_parsing_impl.compilers.reference index 8cac2daa..0e9c1703 100644 --- a/testsuite/tests/tool-ocamlc-stop-after/stop_after_parsing_impl.compilers.reference +++ b/testsuite/tests/tool-ocamlc-stop-after/stop_after_parsing_impl.compilers.reference @@ -24,7 +24,7 @@ Nolabel expression (stop_after_parsing_impl.ml[12,306+13]..[12,306+19]) - Pexp_constant PConst_string("true",None) + Pexp_constant PConst_string("true",(stop_after_parsing_impl.ml[12,306+14]..[12,306+18]),None) ] Nolabel diff --git a/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.compilers.reference b/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.compilers.reference new file mode 100644 index 00000000..b41ebd0a --- /dev/null +++ b/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.compilers.reference @@ -0,0 +1 @@ +wrong argument 'scheduling'; option '-stop-after' expects one of: parsing typing. diff --git a/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.ml b/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.ml new file mode 100644 index 00000000..c5eae2bb --- /dev/null +++ b/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.ml @@ -0,0 +1,14 @@ +(* TEST +* setup-ocamlc.byte-build-env +compiler_output = "compiler-output.raw" +** ocamlc.byte + flags = "-stop-after scheduling" + ocamlc_byte_exit_status = "2" +*** script + script = "sh ${test_source_directory}/stop_after_scheduling.sh" + output = "compiler-output" +**** check-ocamlc.byte-output +compiler_output = "compiler-output" +*) + +(* this file is just a test driver, the test does not contain real OCaml code *) diff --git a/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.sh b/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.sh new file mode 100755 index 00000000..bf711391 --- /dev/null +++ b/testsuite/tests/tool-ocamlc-stop-after/stop_after_scheduling.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +grep "wrong argument 'scheduling'" compiler-output.raw | grep "stop-after" | sed 's/^.*: wrong argument/wrong argument/' diff --git a/testsuite/tests/tool-ocamldep-modalias/Makefile.build b/testsuite/tests/tool-ocamldep-modalias/Makefile.build index a28f99d4..1020369f 100644 --- a/testsuite/tests/tool-ocamldep-modalias/Makefile.build +++ b/testsuite/tests/tool-ocamldep-modalias/Makefile.build @@ -5,6 +5,8 @@ # will not necessarily be ran by GNU make # The same holds for $< and $@ +.NOTPARALLEL: + SOURCES = A.ml B.ml C.ml D.ml OBJECTS = lib.cmo $(SOURCES:%.ml=Lib%.cmo) NOBJECTS = $(OBJECTS:%.cmo=%.cmx) diff --git a/testsuite/tests/tool-ocamldep-modalias/Makefile.build2 b/testsuite/tests/tool-ocamldep-modalias/Makefile.build2 index e9b1d690..087a1b20 100644 --- a/testsuite/tests/tool-ocamldep-modalias/Makefile.build2 +++ b/testsuite/tests/tool-ocamldep-modalias/Makefile.build2 @@ -5,6 +5,8 @@ # will not necessarily be ran by GNU make # The same holds for $< and $@ +.NOTPARALLEL: + SOURCES = A.ml B.ml C.ml OBJECTS = $(SOURCES:%.ml=Lib%.cmo) NOBJECTS = $(OBJECTS:%.cmo=%.cmx) diff --git a/testsuite/tests/tool-ocamlopt-stop-after/stop_after_scheduling.ml b/testsuite/tests/tool-ocamlopt-stop-after/stop_after_scheduling.ml new file mode 100644 index 00000000..dfa97ffd --- /dev/null +++ b/testsuite/tests/tool-ocamlopt-stop-after/stop_after_scheduling.ml @@ -0,0 +1,12 @@ +(* TEST + * native-compiler + ** setup-ocamlopt.byte-build-env + *** ocamlopt.byte + flags = "-stop-after scheduling -S" + ocamlopt_byte_exit_status = "0" + **** check-ocamlopt.byte-output + ***** script + script = "sh ${test_source_directory}/stop_after_scheduling.sh" +*) + +(* this file is just a test driver, the test does not contain real OCaml code *) diff --git a/testsuite/tests/tool-ocamlopt-stop-after/stop_after_scheduling.sh b/testsuite/tests/tool-ocamlopt-stop-after/stop_after_scheduling.sh new file mode 100755 index 00000000..ae04153b --- /dev/null +++ b/testsuite/tests/tool-ocamlopt-stop-after/stop_after_scheduling.sh @@ -0,0 +1,24 @@ +#!/bin/sh + +set -e + +asm=stop_after_scheduling.${asmext} +obj=stop_after_scheduling.${objext} +cmx=stop_after_scheduling.cmx + +# Check that cmx is generated but asm and obj are not +if [ -e "$asm" ] ; then + echo "unexpected $asm found" > ${ocamltest_response} + test_result=${TEST_FAIL} +else if [ -e "$obj" ] ; then + echo "unexpected $obj found" > ${ocamltest_response} + test_result=${TEST_FAIL} + else if [ -e "$cmx" ] ; then + test_result=${TEST_PASS} + else + echo "not found expected $cmx" > ${ocamltest_response} + test_result=${TEST_FAIL} + fi + fi +fi +exit ${test_result} diff --git a/testsuite/tests/tool-toplevel/known-bugs/broken_rec_in_show.ml b/testsuite/tests/tool-toplevel/known-bugs/broken_rec_in_show.ml new file mode 100644 index 00000000..f4c3f497 --- /dev/null +++ b/testsuite/tests/tool-toplevel/known-bugs/broken_rec_in_show.ml @@ -0,0 +1,47 @@ +(* TEST + * expect +*) + +(* This is a known-bug file for use of 'rec' by the '#show' command, + to record known regressions from #7453 and #9094 *) + +type t = T of t;; +[%%expect{| +type t = T of t +|}] +#show t;; +(* this output is INCORRECT, it should not use nonrec *) +[%%expect{| +type nonrec t = T of t +|}];; + +type nonrec s = Foo of t;; +[%%expect{| +type nonrec s = Foo of t +|}];; +#show s;; +(* this output is CORRECT, it uses nonrec *) +[%%expect{| +type nonrec s = Foo of t +|}];; + + + +module M : sig type t val x : t end = struct type t = int let x = 0 end;; +[%%expect{| +module M : sig type t val x : t end +|}];; +(* this output is CORRECT, it does not use 'rec' *) +[%%expect{| +|}];; + +module rec M : sig type t val x : M.t end = struct type t = int let x = 0 end;; +(* this output is strange, it is surprising to use M/2 here. *) +[%%expect{| +module rec M : sig type t val x : M/2.t end +|}];; +#show_module M;; +(* this output is INCORRECT, it should use 'rec' *) +[%%expect{| +module M : sig type t val x : M.t end +|}];; diff --git a/testsuite/tests/tool-toplevel/mod.ml b/testsuite/tests/tool-toplevel/mod.ml new file mode 100644 index 00000000..cd298427 --- /dev/null +++ b/testsuite/tests/tool-toplevel/mod.ml @@ -0,0 +1 @@ +let answer = 42 diff --git a/testsuite/tests/tool-toplevel/mod_use.ml b/testsuite/tests/tool-toplevel/mod_use.ml new file mode 100644 index 00000000..e068ffc3 --- /dev/null +++ b/testsuite/tests/tool-toplevel/mod_use.ml @@ -0,0 +1,9 @@ +(* TEST + files = "mod.ml" + * expect +*) + +#mod_use "mod.ml" +[%%expect {| +module Mod : sig val answer : int end +|}];; diff --git a/testsuite/tests/tool-toplevel/pr6468.compilers.reference b/testsuite/tests/tool-toplevel/pr6468.compilers.reference index a716651e..2f942ec6 100644 --- a/testsuite/tests/tool-toplevel/pr6468.compilers.reference +++ b/testsuite/tests/tool-toplevel/pr6468.compilers.reference @@ -6,7 +6,7 @@ Line 1, characters 11-15: Warning 21: this statement never returns (or has an unsound type.) val g : unit -> int = Exception: Not_found. -Raised at file "//toplevel//", line 2, characters 17-26 -Called from file "//toplevel//", line 1, characters 11-15 -Called from file "toplevel/toploop.ml", line 212, characters 17-27 +Raised at f in file "//toplevel//", line 2, characters 11-26 +Called from g in file "//toplevel//", line 1, characters 11-15 +Called from Toploop.load_lambda in file "toplevel/toploop.ml", line 212, characters 17-27 diff --git a/testsuite/tests/tool-toplevel/show.ml b/testsuite/tests/tool-toplevel/show.ml new file mode 100644 index 00000000..6c000120 --- /dev/null +++ b/testsuite/tests/tool-toplevel/show.ml @@ -0,0 +1,106 @@ +(* TEST + * expect +*) + +(* this is a set of tests to test the #show functionality + * of toplevel *) + +#show Foo;; +[%%expect {| +Unknown element. +|}];; + +module type S = sig type t val x : t end;; +module M : S = struct type t = int let x = 3 end;; + +[%%expect {| +module type S = sig type t val x : t end +module M : S +|}];; + +#show M;; +[%%expect {| +module M : S +|}];; + +#show S;; +[%%expect {| +module type S = sig type t val x : t end +|}];; + +#show Invalid_argument;; +[%%expect {| +exception Invalid_argument of string +|}];; + +#show Some;; +[%%expect {| +type 'a option = None | Some of 'a +|}];; + +#show option;; +[%%expect {| +type nonrec 'a option = None | Some of 'a +|}];; + +#show Open_binary;; +[%%expect {| +type Stdlib.open_flag = + Open_rdonly + | Open_wronly + | Open_append + | Open_creat + | Open_trunc + | Open_excl + | Open_binary + | Open_text + | Open_nonblock +|}];; + +#show open_flag;; +[%%expect {| +type nonrec open_flag = + Open_rdonly + | Open_wronly + | Open_append + | Open_creat + | Open_trunc + | Open_excl + | Open_binary + | Open_text + | Open_nonblock +|}];; + +type extensible = ..;; +type extensible += A | B of int;; +[%%expect {| +type extensible = .. +type extensible += A | B of int +|}];; + +#show A;; +[%%expect {| +type extensible += A +|}];; + +#show B;; +[%%expect {| +type extensible += B of int +|}];; + +#show extensible;; +[%%expect {| +type nonrec extensible = .. +|}];; + +type 'a t = ..;; +type _ t += A : int t;; +[%%expect{| +type 'a t = .. +type _ t += A : int t +|}];; + +#show A;; +[%%expect{| +type 'a t += A : int t +|}];; diff --git a/testsuite/tests/tool-toplevel/show_short_paths.ml b/testsuite/tests/tool-toplevel/show_short_paths.ml new file mode 100644 index 00000000..c0c50de2 --- /dev/null +++ b/testsuite/tests/tool-toplevel/show_short_paths.ml @@ -0,0 +1,19 @@ +(* TEST + flags = " -short-paths " + * expect +*) + +(* This is currently just a regression test for the bug + reported here: https://github.com/ocaml/ocaml/issues/9828 *) + +#show list;; +[%%expect {| +type nonrec 'a list = [] | (::) of 'a * 'a list +|}];; + +type 'a t;; +#show t;; +[%%expect {| +type 'a t +type nonrec 'a t +|}];; diff --git a/testsuite/tests/tool-toplevel/use_command.ml b/testsuite/tests/tool-toplevel/use_command.ml new file mode 100644 index 00000000..7bb9d8fa --- /dev/null +++ b/testsuite/tests/tool-toplevel/use_command.ml @@ -0,0 +1,25 @@ +(* TEST + * expect +*) + +(* Test a success case *) +#use_output {|echo let x = 42|} +[%%expect {| +val x : int = 42 +|}];; + +(* When the command fails *) +#use_output {|false|} +[%%expect {| +Command exited with code 1. +|}];; + +(* When the code is invalid *) +#use_output {|echo 1 :: x|} +[%%expect {| +File "(command-output)", line 1, characters 5-6: +1 | 1 :: x + ^ +Error: This expression has type int but an expression was expected of type + int list +|}];; diff --git a/testsuite/tests/translprim/comparison_table.compilers.reference b/testsuite/tests/translprim/comparison_table.compilers.reference index fdee1671..a9a7cce9 100644 --- a/testsuite/tests/translprim/comparison_table.compilers.reference +++ b/testsuite/tests/translprim/comparison_table.compilers.reference @@ -1,16 +1,16 @@ (setglobal Comparison_table! (let (gen_cmp = (function x y : int (caml_compare x y)) - int_cmp = (function x[int] y[int] : int (caml_int_compare x y)) - bool_cmp = (function x y : int (caml_int_compare x y)) - intlike_cmp = (function x y : int (caml_int_compare x y)) - float_cmp = (function x[float] y[float] : int (caml_float_compare x y)) + int_cmp = (function x[int] y[int] : int (compare_ints x y)) + bool_cmp = (function x y : int (compare_ints x y)) + intlike_cmp = (function x y : int (compare_ints x y)) + float_cmp = (function x[float] y[float] : int (compare_floats x y)) string_cmp = (function x y : int (caml_string_compare x y)) - int32_cmp = (function x[int32] y[int32] : int (caml_int32_compare x y)) - int64_cmp = (function x[int64] y[int64] : int (caml_int64_compare x y)) + int32_cmp = (function x[int32] y[int32] : int (compare_bints int32 x y)) + int64_cmp = (function x[int64] y[int64] : int (compare_bints int64 x y)) nativeint_cmp = (function x[nativeint] y[nativeint] : int - (caml_nativeint_compare x y)) + (compare_bints nativeint x y)) gen_eq = (function x y (caml_equal x y)) int_eq = (function x[int] y[int] (== x y)) bool_eq = (function x y (== x y)) @@ -66,16 +66,18 @@ int64_ge = (function x[int64] y[int64] (Int64.>= x y)) nativeint_ge = (function x[nativeint] y[nativeint] (Nativeint.>= x y)) eta_gen_cmp = (function prim prim stub (caml_compare prim prim)) - eta_int_cmp = (function prim prim stub (caml_int_compare prim prim)) - eta_bool_cmp = (function prim prim stub (caml_int_compare prim prim)) - eta_intlike_cmp = (function prim prim stub (caml_int_compare prim prim)) - eta_float_cmp = (function prim prim stub (caml_float_compare prim prim)) + eta_int_cmp = (function prim prim stub (compare_ints prim prim)) + eta_bool_cmp = (function prim prim stub (compare_ints prim prim)) + eta_intlike_cmp = (function prim prim stub (compare_ints prim prim)) + eta_float_cmp = (function prim prim stub (compare_floats prim prim)) eta_string_cmp = (function prim prim stub (caml_string_compare prim prim)) - eta_int32_cmp = (function prim prim stub (caml_int32_compare prim prim)) - eta_int64_cmp = (function prim prim stub (caml_int64_compare prim prim)) + eta_int32_cmp = + (function prim prim stub (compare_bints int32 prim prim)) + eta_int64_cmp = + (function prim prim stub (compare_bints int64 prim prim)) eta_nativeint_cmp = - (function prim prim stub (caml_nativeint_compare prim prim)) + (function prim prim stub (compare_bints nativeint prim prim)) eta_gen_eq = (function prim prim stub (caml_equal prim prim)) eta_int_eq = (function prim prim stub (== prim prim)) eta_bool_eq = (function prim prim stub (== prim prim)) diff --git a/testsuite/tests/translprim/module_coercion.compilers.flat.reference b/testsuite/tests/translprim/module_coercion.compilers.flat.reference index 3327f360..34715159 100644 --- a/testsuite/tests/translprim/module_coercion.compilers.flat.reference +++ b/testsuite/tests/translprim/module_coercion.compilers.flat.reference @@ -1,35 +1,38 @@ (setglobal Module_coercion! - (let (M = (module-defn(M) module_coercion.ml(15):436-1135 (makeblock 0))) + (let + (M = + (module-defn(M) Module_coercion module_coercion.ml(15):436-1135 + (makeblock 0))) (makeblock 0 M - (module-defn(M_int) module_coercion.ml(46):1552-1591 + (module-defn(M_int) Module_coercion module_coercion.ml(46):1552-1591 (makeblock 0 (function prim stub (array.length[int] prim)) (function prim prim stub (array.get[int] prim prim)) (function prim prim stub (array.unsafe_get[int] prim prim)) (function prim prim prim stub (array.set[int] prim prim prim)) (function prim prim prim stub (array.unsafe_set[int] prim prim prim)) - (function prim prim stub (caml_int_compare prim prim)) + (function prim prim stub (compare_ints prim prim)) (function prim prim stub (== prim prim)) (function prim prim stub (!= prim prim)) (function prim prim stub (< prim prim)) (function prim prim stub (> prim prim)) (function prim prim stub (<= prim prim)) (function prim prim stub (>= prim prim)))) - (module-defn(M_float) module_coercion.ml(47):1594-1637 + (module-defn(M_float) Module_coercion module_coercion.ml(47):1594-1637 (makeblock 0 (function prim stub (array.length[float] prim)) (function prim prim stub (array.get[float] prim prim)) (function prim prim stub (array.unsafe_get[float] prim prim)) (function prim prim prim stub (array.set[float] prim prim prim)) (function prim prim prim stub (array.unsafe_set[float] prim prim prim)) - (function prim prim stub (caml_float_compare prim prim)) + (function prim prim stub (compare_floats prim prim)) (function prim prim stub (==. prim prim)) (function prim prim stub (!=. prim prim)) (function prim prim stub (<. prim prim)) (function prim prim stub (>. prim prim)) (function prim prim stub (<=. prim prim)) (function prim prim stub (>=. prim prim)))) - (module-defn(M_string) module_coercion.ml(48):1640-1685 + (module-defn(M_string) Module_coercion module_coercion.ml(48):1640-1685 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) @@ -43,42 +46,42 @@ (function prim prim stub (caml_string_greaterthan prim prim)) (function prim prim stub (caml_string_lessequal prim prim)) (function prim prim stub (caml_string_greaterequal prim prim)))) - (module-defn(M_int32) module_coercion.ml(49):1688-1731 + (module-defn(M_int32) Module_coercion module_coercion.ml(49):1688-1731 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_int32_compare prim prim)) + (function prim prim stub (compare_bints int32 prim prim)) (function prim prim stub (Int32.== prim prim)) (function prim prim stub (Int32.!= prim prim)) (function prim prim stub (Int32.< prim prim)) (function prim prim stub (Int32.> prim prim)) (function prim prim stub (Int32.<= prim prim)) (function prim prim stub (Int32.>= prim prim)))) - (module-defn(M_int64) module_coercion.ml(50):1734-1777 + (module-defn(M_int64) Module_coercion module_coercion.ml(50):1734-1777 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_int64_compare prim prim)) + (function prim prim stub (compare_bints int64 prim prim)) (function prim prim stub (Int64.== prim prim)) (function prim prim stub (Int64.!= prim prim)) (function prim prim stub (Int64.< prim prim)) (function prim prim stub (Int64.> prim prim)) (function prim prim stub (Int64.<= prim prim)) (function prim prim stub (Int64.>= prim prim)))) - (module-defn(M_nativeint) module_coercion.ml(51):1780-1831 + (module-defn(M_nativeint) Module_coercion module_coercion.ml(51):1780-1831 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_nativeint_compare prim prim)) + (function prim prim stub (compare_bints nativeint prim prim)) (function prim prim stub (Nativeint.== prim prim)) (function prim prim stub (Nativeint.!= prim prim)) (function prim prim stub (Nativeint.< prim prim)) diff --git a/testsuite/tests/translprim/module_coercion.compilers.no-flat.reference b/testsuite/tests/translprim/module_coercion.compilers.no-flat.reference index 877e9df5..e435b275 100644 --- a/testsuite/tests/translprim/module_coercion.compilers.no-flat.reference +++ b/testsuite/tests/translprim/module_coercion.compilers.no-flat.reference @@ -1,35 +1,38 @@ (setglobal Module_coercion! - (let (M = (module-defn(M) module_coercion.ml(15):436-1135 (makeblock 0))) + (let + (M = + (module-defn(M) Module_coercion module_coercion.ml(15):436-1135 + (makeblock 0))) (makeblock 0 M - (module-defn(M_int) module_coercion.ml(46):1552-1591 + (module-defn(M_int) Module_coercion module_coercion.ml(46):1552-1591 (makeblock 0 (function prim stub (array.length[int] prim)) (function prim prim stub (array.get[int] prim prim)) (function prim prim stub (array.unsafe_get[int] prim prim)) (function prim prim prim stub (array.set[int] prim prim prim)) (function prim prim prim stub (array.unsafe_set[int] prim prim prim)) - (function prim prim stub (caml_int_compare prim prim)) + (function prim prim stub (compare_ints prim prim)) (function prim prim stub (== prim prim)) (function prim prim stub (!= prim prim)) (function prim prim stub (< prim prim)) (function prim prim stub (> prim prim)) (function prim prim stub (<= prim prim)) (function prim prim stub (>= prim prim)))) - (module-defn(M_float) module_coercion.ml(47):1594-1637 + (module-defn(M_float) Module_coercion module_coercion.ml(47):1594-1637 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_float_compare prim prim)) + (function prim prim stub (compare_floats prim prim)) (function prim prim stub (==. prim prim)) (function prim prim stub (!=. prim prim)) (function prim prim stub (<. prim prim)) (function prim prim stub (>. prim prim)) (function prim prim stub (<=. prim prim)) (function prim prim stub (>=. prim prim)))) - (module-defn(M_string) module_coercion.ml(48):1640-1685 + (module-defn(M_string) Module_coercion module_coercion.ml(48):1640-1685 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) @@ -43,42 +46,42 @@ (function prim prim stub (caml_string_greaterthan prim prim)) (function prim prim stub (caml_string_lessequal prim prim)) (function prim prim stub (caml_string_greaterequal prim prim)))) - (module-defn(M_int32) module_coercion.ml(49):1688-1731 + (module-defn(M_int32) Module_coercion module_coercion.ml(49):1688-1731 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_int32_compare prim prim)) + (function prim prim stub (compare_bints int32 prim prim)) (function prim prim stub (Int32.== prim prim)) (function prim prim stub (Int32.!= prim prim)) (function prim prim stub (Int32.< prim prim)) (function prim prim stub (Int32.> prim prim)) (function prim prim stub (Int32.<= prim prim)) (function prim prim stub (Int32.>= prim prim)))) - (module-defn(M_int64) module_coercion.ml(50):1734-1777 + (module-defn(M_int64) Module_coercion module_coercion.ml(50):1734-1777 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_int64_compare prim prim)) + (function prim prim stub (compare_bints int64 prim prim)) (function prim prim stub (Int64.== prim prim)) (function prim prim stub (Int64.!= prim prim)) (function prim prim stub (Int64.< prim prim)) (function prim prim stub (Int64.> prim prim)) (function prim prim stub (Int64.<= prim prim)) (function prim prim stub (Int64.>= prim prim)))) - (module-defn(M_nativeint) module_coercion.ml(51):1780-1831 + (module-defn(M_nativeint) Module_coercion module_coercion.ml(51):1780-1831 (makeblock 0 (function prim stub (array.length[addr] prim)) (function prim prim stub (array.get[addr] prim prim)) (function prim prim stub (array.unsafe_get[addr] prim prim)) (function prim prim prim stub (array.set[addr] prim prim prim)) (function prim prim prim stub (array.unsafe_set[addr] prim prim prim)) - (function prim prim stub (caml_nativeint_compare prim prim)) + (function prim prim stub (compare_bints nativeint prim prim)) (function prim prim stub (Nativeint.== prim prim)) (function prim prim stub (Nativeint.!= prim prim)) (function prim prim stub (Nativeint.< prim prim)) diff --git a/testsuite/tests/typing-extensions/disambiguation.ml b/testsuite/tests/typing-extensions/disambiguation.ml new file mode 100644 index 00000000..feae4c71 --- /dev/null +++ b/testsuite/tests/typing-extensions/disambiguation.ml @@ -0,0 +1,248 @@ +(* TEST + * expect +*) +(** Test type-directed disambiguation and spellchecker hints *) + +type t = .. +type t += Alpha | Aleph + +module M = struct + type w = .. + type w += Alpha | Beta ;; + type t += Beth +end;; + +module F(X:sig end) = struct type u = .. type t += Gamma type u += Gamme end;; +module X = struct end;; +[%%expect {| +type t = .. +type t += Alpha | Aleph +module M : sig type w = .. type w += Alpha | Beta type t += Beth end +module F : + functor (X : sig end) -> + sig type u = .. type t += Gamma type u += Gamme end +module X : sig end +|}] + +let x: t = Alph;; +[%%expect {| +Line 1, characters 11-15: +1 | let x: t = Alph;; + ^^^^ +Error: This variant expression is expected to have type t + The constructor Alph does not belong to type t +Hint: Did you mean Aleph or Alpha? +|}] + +open M;; +let y : w = Alha;; +[%%expect {| +Line 2, characters 12-16: +2 | let y : w = Alha;; + ^^^^ +Error: This variant expression is expected to have type M.w + The constructor Alha does not belong to type M.w +Hint: Did you mean Alpha? +|}] + +let z: t = Bet;; +[%%expect {| +Line 1, characters 11-14: +1 | let z: t = Bet;; + ^^^ +Error: This variant expression is expected to have type t + The constructor Bet does not belong to type t +Hint: Did you mean Beth? +|}] + + +module N = F(X);; +open N +let g = (Gamm:t);; +[%%expect {| +module N : sig type u = F(X).u = .. type t += Gamma type u += Gamme end +Line 3, characters 9-13: +3 | let g = (Gamm:t);; + ^^^^ +Error: This variant expression is expected to have type t + The constructor Gamm does not belong to type t +Hint: Did you mean Gamma? +|}];; + +raise Not_Found;; +[%%expect {| +Line 1, characters 6-15: +1 | raise Not_Found;; + ^^^^^^^^^ +Error: This variant expression is expected to have type exn + The constructor Not_Found does not belong to type exn +Hint: Did you mean Not_found? +|}] + +(** Aliasing *) +type r = ..;; +module M = struct + type t = r = .. + type s = t = .. + module N = struct + type u = s = .. + type u += Foo + end +end +open M.N;; + +type exn += Foo;; + +let x : r = Foo;; +[%%expect {| +type r = .. +module M : + sig + type t = r = .. + type s = t = .. + module N : sig type u = s = .. type u += Foo end + end +type exn += Foo +val x : r = M.N.Foo +|}] + +(** Closed open extensible type support *) + +module M : sig + type t = private .. + type t += Aleph +end = struct + type t = .. + type t += Aleph +end;; +open M;; + +type exn += Aleph ;; +[%%expect {| +module M : sig type t = private .. type t += Aleph end +type exn += Aleph +|}] + +let x : t = Aleph;; +[%%expect {| +val x : M.t = M.Aleph +|}] + +module F(X: sig type t = .. end ) = struct type X.t+= Beth end +module X = struct type t = .. end +module FX = F(X) open FX +type exn += Beth;; +let x : X.t = Beth;; +[%%expect {| +module F : functor (X : sig type t = .. end) -> sig type X.t += Beth end +module X : sig type t = .. end +module FX : sig type X.t += Beth end +type exn += Beth +val x : X.t = +|}] + +(** Aliasing *) + +type x = .. +type x += Alpha +module P = struct type p = x end + +let x: P.p = Alha;; +[%%expect {| +type x = .. +type x += Alpha +module P : sig type p = x end +Line 7, characters 13-17: +7 | let x: P.p = Alha;; + ^^^^ +Error: This variant expression is expected to have type P.p + The constructor Alha does not belong to type x +Hint: Did you mean Alpha? +|}] + +module M = struct type t = .. type t += T end +module N = struct type s = M.t end +let y: N.s = T ;; +[%%expect {| +module M : sig type t = .. type t += T end +module N : sig type s = M.t end +Line 3, characters 13-14: +3 | let y: N.s = T ;; + ^ +Error: This variant expression is expected to have type N.s + The constructor T does not belong to type M.t +|}] + +(** Pattern matching *) +type x = .. +type x += A | B +type u = A | B +module M = struct type y = .. type y+= A|B end +open M +let f: x -> int = function A -> 1 | B -> 2 | _ -> 0;; +[%%expect {| +type x = .. +type x += A | B +type u = A | B +module M : sig type y = .. type y += A | B end +val f : x -> int = +|}] + +(** Local exception *) +let x = + let exception Local in + raise Locl;; +[%%expect {| +Line 3, characters 8-12: +3 | raise Locl;; + ^^^^ +Error: This variant expression is expected to have type exn + The constructor Locl does not belong to type exn +Hint: Did you mean Local? +|}] + +let x = + let exception Local in + let module M = struct type t = .. type t+= Local end in + let open M in + (Local:exn);; +[%%expect{| +val x : exn = Local +|} +] + +(** Path capture *) +module M = struct type t = .. type t += T end +open M +let f = (=) M.T +module M = struct type t = .. type t += S end +open M +let y = f T ;; +[%%expect {| +module M : sig type t = .. type t += T end +val f : M.t -> bool = +module M : sig type t = .. type t += S end +val y : bool = true +|}] + +(** Amniguity warning *) +[@@@warning "+41"];; +type a = Unique +type t = .. +type t += Unique +module M = struct type s = .. type s+= Unique end open M +type b = Unique +let x = Unique;; +[%%expect {| +type a = Unique +type t = .. +type t += Unique +module M : sig type s = .. type s += Unique end +type b = Unique +Line 7, characters 8-14: +7 | let x = Unique;; + ^^^^^^ +Warning 41: Unique belongs to several types: b M.s t a +The first one was selected. Please disambiguate if this is wrong. +val x : b = Unique +|}] diff --git a/testsuite/tests/typing-extensions/extensions.ml b/testsuite/tests/typing-extensions/extensions.ml index c7c82467..0c5dbf55 100644 --- a/testsuite/tests/typing-extensions/extensions.ml +++ b/testsuite/tests/typing-extensions/extensions.ml @@ -668,6 +668,19 @@ let y = x (* Prints Bar and part of Foo (which has been shadowed) *) val y : exn * exn = (Foo (3, _), Bar (Some 5)) |}] +module Empty = struct end +module F(X:sig end) = struct + type t = .. + type t += A +end +let x = let open F(Empty) in (A:F(Empty).t) (* A is not printed *) +[%%expect {| +module Empty : sig end +module F : functor (X : sig end) -> sig type t = .. type t += A end +val x : F(Empty).t = +|}] + + (* Test Obj functions *) type foo = .. diff --git a/testsuite/tests/typing-gadts/or_patterns.ml b/testsuite/tests/typing-gadts/or_patterns.ml index 1cc64034..6fc7f8c2 100644 --- a/testsuite/tests/typing-gadts/or_patterns.ml +++ b/testsuite/tests/typing-gadts/or_patterns.ml @@ -281,13 +281,7 @@ let simple_merged_annotated_under_poly_variant (type a) (pair : a t * a) = ;; [%%expect{| -Line 3, characters 19-20: -3 | | `Foo ( IntLit, 3 - ^ -Error: This pattern matches values of type int - but a pattern was expected which matches values of type a = int - This instance of int is ambiguous: - it would escape the scope of its equation +val simple_merged_annotated_under_poly_variant : 'a t * 'a -> unit = |}] let simple_merged_annotated_under_poly_variant_annotated (type a) pair = diff --git a/testsuite/tests/typing-gadts/pr7520.ml b/testsuite/tests/typing-gadts/pr7520.ml new file mode 100644 index 00000000..b4bfe2f4 --- /dev/null +++ b/testsuite/tests/typing-gadts/pr7520.ml @@ -0,0 +1,13 @@ +(* TEST + * expect +*) + +type ('a, 'b) eq = Refl : ('a, 'a) eq +type empty = (int, string) eq + +let f = function `Foo (_ : empty) -> . +[%%expect{| +type ('a, 'b) eq = Refl : ('a, 'a) eq +type empty = (int, string) eq +val f : [< `Foo of empty ] -> 'a = +|}] diff --git a/testsuite/tests/typing-gadts/test.ml b/testsuite/tests/typing-gadts/test.ml index be41c367..a91f685e 100644 --- a/testsuite/tests/typing-gadts/test.ml +++ b/testsuite/tests/typing-gadts/test.ml @@ -817,8 +817,9 @@ Lines 1-2, characters 4-15: 1 | ....f : type a b. (a,b) eq -> [< `A of a | `B] -> [< `A of b | `B] = 2 | fun Eq o -> o.............. Error: This definition has type - ('a, 'b) eq -> ([< `A of 'b & 'a | `B ] as 'c) -> 'c - which is less general than 'a0 'b0. ('a0, 'b0) eq -> 'c -> 'c + 'c. ('d, 'c) eq -> ([< `A of 'c & 'f & 'd | `B ] as 'e) -> 'e + which is less general than + 'a 'b. ('a, 'b) eq -> ([< `A of 'b & 'h | `B ] as 'g) -> 'g |}];; let f : type a b. (a,b) eq -> [`A of a | `B] -> [`A of b | `B] = diff --git a/testsuite/tests/typing-implicit_unpack/implicit_unpack.ml b/testsuite/tests/typing-implicit_unpack/implicit_unpack.ml index bd256f2c..04334d66 100644 --- a/testsuite/tests/typing-implicit_unpack/implicit_unpack.ml +++ b/testsuite/tests/typing-implicit_unpack/implicit_unpack.ml @@ -321,6 +321,7 @@ module type MapT = val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t + val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list @@ -372,6 +373,7 @@ module SSMap : val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t + val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list diff --git a/testsuite/tests/typing-misc-bugs/gadt_declaration_check.ml b/testsuite/tests/typing-misc-bugs/gadt_declaration_check.ml new file mode 100644 index 00000000..432a502f --- /dev/null +++ b/testsuite/tests/typing-misc-bugs/gadt_declaration_check.ml @@ -0,0 +1,19 @@ +(* TEST + * expect +*) +type foo = Foo;; +[%%expect{| +type foo = Foo +|}];; + +(* this should fail with an error message, + not an uncaught exception (as it did temporarily + during the development of typedecl_separability) *) +type bar = Bar : foo;; +[%%expect{| +Line 1, characters 17-20: +1 | type bar = Bar : foo;; + ^^^ +Error: Constraints are not satisfied in this type. + Type foo should be an instance of bar +|}];; diff --git a/testsuite/tests/typing-misc/constraints.ml b/testsuite/tests/typing-misc/constraints.ml index 213de4e7..0fe7387a 100644 --- a/testsuite/tests/typing-misc/constraints.ml +++ b/testsuite/tests/typing-misc/constraints.ml @@ -21,7 +21,12 @@ type 'a t = [`A of 'a t t];; (* fails *) Line 1, characters 0-26: 1 | type 'a t = [`A of 'a t t];; (* fails *) ^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of t, type 'a t t should be 'a t +Error: This recursive type is not regular. + The type constructor t is defined as + type 'a t + but it is used as + 'a t t. + All uses need to match the definition for the recursive type to be regular. |}];; type 'a t = [`A of 'a t t] constraint 'a = 'a t;; (* fails since 4.04 *) [%%expect{| diff --git a/testsuite/tests/typing-misc/empty_variant.ml b/testsuite/tests/typing-misc/empty_variant.ml index 74a0713c..40a81602 100644 --- a/testsuite/tests/typing-misc/empty_variant.ml +++ b/testsuite/tests/typing-misc/empty_variant.ml @@ -29,3 +29,51 @@ let f : t option -> int = function None -> 3 [%%expect{| val f : t option -> int = |}] + +type nothing = | +type ('a, 'b, 'c) t = | A of 'a | B of 'b | C of 'c +module Runner : sig + val ac : f:((unit, _, unit) t -> unit) -> unit +end = struct + let ac ~f = + f (A ()); + f (C ()); + ;; +end + +let f () = + Runner.ac + ~f:(fun (abc : (_,nothing,_) t) -> + let value = + match abc with + | A _ -> 1 + in + Printf.printf "%i\n" value + ) +[%%expect{| +type nothing = | +type ('a, 'b, 'c) t = A of 'a | B of 'b | C of 'c +module Runner : sig val ac : f:((unit, 'a, unit) t -> unit) -> unit end +Lines 16-17, characters 8-18: +16 | ........match abc with +17 | | A _ -> 1 +Warning 8: this pattern-matching is not exhaustive. +Here is an example of a case that is not matched: +C () +val f : unit -> unit = +|}] + +type nothing = | +type 'b t = A | B of 'b | C +let g (x:nothing t) = match x with A -> () +[%%expect{| +type nothing = | +type 'b t = A | B of 'b | C +Line 3, characters 22-42: +3 | let g (x:nothing t) = match x with A -> () + ^^^^^^^^^^^^^^^^^^^^ +Warning 8: this pattern-matching is not exhaustive. +Here is an example of a case that is not matched: +C +val g : nothing t -> unit = +|}] diff --git a/testsuite/tests/typing-misc/labels.ml b/testsuite/tests/typing-misc/labels.ml index 3289ea39..5192f411 100644 --- a/testsuite/tests/typing-misc/labels.ml +++ b/testsuite/tests/typing-misc/labels.ml @@ -33,3 +33,60 @@ Line 1, characters 4-23: Error: This function should have type unit -> unit but its first argument is labelled ?opt |}];; + + +(* More examples *) + +let f g = ignore (g ?x:(Some 2) ()); g ~x:3 () ;; +[%%expect{| +Line 1, characters 37-38: +1 | let f g = ignore (g ?x:(Some 2) ()); g ~x:3 () ;; + ^ +Error: This function is applied to arguments + in an order different from other calls. + This is only allowed when the real type is known. +|}];; + +let f g = let _ = g ?x:(Some 2) () in g ~x:3 () ;; +[%%expect{| +Line 1, characters 38-39: +1 | let f g = let _ = g ?x:(Some 2) () in g ~x:3 () ;; + ^ +Error: This function is applied to arguments + in an order different from other calls. + This is only allowed when the real type is known. +|}];; + +(* principality warning *) +let f g = ignore (g : ?x:int -> unit -> int); g ~x:3 () ;; +[%%expect{| +val f : (?x:int -> unit -> int) -> int = +|}, Principal{| +Line 1, characters 51-52: +1 | let f g = ignore (g : ?x:int -> unit -> int); g ~x:3 () ;; + ^ +Warning 18: using an optional argument here is not principal. +val f : (?x:int -> unit -> int) -> int = +|}];; + +let f g = ignore (g : ?x:int -> unit -> int); g ();; +[%%expect{| +val f : (?x:int -> unit -> int) -> int = +|}, Principal{| +Line 1, characters 46-47: +1 | let f g = ignore (g : ?x:int -> unit -> int); g ();; + ^ +Warning 19: eliminated optional argument without principality. +val f : (?x:int -> unit -> int) -> int = +|}];; + +let f g = ignore (g : x:int -> unit -> int); g ();; +[%%expect{| +val f : (x:int -> unit -> int) -> x:int -> int = +|}, Principal{| +Line 1, characters 45-46: +1 | let f g = ignore (g : x:int -> unit -> int); g ();; + ^ +Warning 19: commuted an argument without principality. +val f : (x:int -> unit -> int) -> x:int -> int = +|}];; diff --git a/testsuite/tests/typing-misc/polyvars.ml b/testsuite/tests/typing-misc/polyvars.ml index 3f287b3f..52bc178f 100644 --- a/testsuite/tests/typing-misc/polyvars.ml +++ b/testsuite/tests/typing-misc/polyvars.ml @@ -176,3 +176,24 @@ Error: This expression has type t but an expression was expected of type [ `A ] The first variant type is private, it may not allow the tag(s) `A |}] + + +(** Check that the non-regularity error message is robust to permutation *) + +type ('a,'b,'c,'d,'e) a = [ `A of ('d,'a,'e,'c,'b) b ] +and ('a,'b,'c,'d,'e) b = [ `B of ('c,'d,'e,'a,'b) c ] +and ('a,'b,'c,'d,'e) c = [ `C of ('a,'b,'c,'d,'e) a ] +[%%expect {| +Line 3, characters 0-54: +3 | type ('a,'b,'c,'d,'e) a = [ `A of ('d,'a,'e,'c,'b) b ] + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Error: This recursive type is not regular. + The type constructor a is defined as + type ('a, 'b, 'c, 'd, 'e) a + but it is used as + ('e, 'c, 'b, 'd, 'a) a + after the following expansion(s): + ('d, 'a, 'e, 'c, 'b) b = [ `B of ('e, 'c, 'b, 'd, 'a) c ], + ('e, 'c, 'b, 'd, 'a) c = [ `C of ('e, 'c, 'b, 'd, 'a) a ] + All uses need to match the definition for the recursive type to be regular. +|}] diff --git a/testsuite/tests/typing-misc/records.ml b/testsuite/tests/typing-misc/records.ml index a5a9f7b1..d11f1b4e 100644 --- a/testsuite/tests/typing-misc/records.ml +++ b/testsuite/tests/typing-misc/records.ml @@ -165,6 +165,17 @@ Error: This expression has type string t Type string is not compatible with type int |}] +(* PR#7696 *) +let r = { (assert false) with contents = 1 } ;; +[%%expect{| +Line 1, characters 8-44: +1 | let r = { (assert false) with contents = 1 } ;; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Warning 23: all the fields are explicitly listed in this record: +the 'with' clause is useless. +Exception: Assert_failure ("", 1, 10). +|}] + (* reexport *) type ('a,'b) def = { x:int } constraint 'b = [> `A] diff --git a/testsuite/tests/typing-misc/typecore_nolabel_errors.ml b/testsuite/tests/typing-misc/typecore_nolabel_errors.ml index 0efcd8d0..6a3ba99b 100644 --- a/testsuite/tests/typing-misc/typecore_nolabel_errors.ml +++ b/testsuite/tests/typing-misc/typecore_nolabel_errors.ml @@ -37,6 +37,7 @@ Line 2, characters 13-17: Error: The function applied to this argument has type ?x:'a -> a:'b -> ?y:'c -> z:'d -> unit This argument cannot be applied with label ?y + Since OCaml 4.11, optional arguments do not commute when -nolabels is given |}] let f (g: ?x:_ -> _) = g ~y:None ?x:None; g ?x:None () @@ -47,4 +48,89 @@ Line 1, characters 28-32: ^^^^ Error: The function applied to this argument has type ?x:'a -> 'b This argument cannot be applied with label ~y + Since OCaml 4.11, optional arguments do not commute when -nolabels is given |}] + +(** Show that optional arguments can be commuted, to some degree. *) + +let f i ?(a=0) ?(b=0) ?(c=0) ~x j = + i + a + b + c + x + j +;; +[%%expect{| +val f : int -> ?a:int -> ?b:int -> ?c:int -> x:int -> int -> int = +|}] +;; + +(* [a], [b] and [c] can be commuted without issues *) + +f 3 ~c:2 ~a:1 ~b:0 ~x:4 5;; +[%%expect{| +Line 1, characters 7-8: +1 | f 3 ~c:2 ~a:1 ~b:0 ~x:4 5;; + ^ +Error: The function applied to this argument has type + ?a:int -> ?b:int -> ?c:int -> x:int -> int -> int +This argument cannot be applied with label ~c + Since OCaml 4.11, optional arguments do not commute when -nolabels is given +|}] +;; + +(* Now, for all of the following, the error appears on the first non optional + argument, but compare the reported function types: *) + +f 3 ~a:1 ~b:2 5 ~c:0 ~x:4;; +[%%expect{| +Line 1, characters 14-15: +1 | f 3 ~a:1 ~b:2 5 ~c:0 ~x:4;; + ^ +Error: The function applied to this argument has type + ?c:int -> x:int -> int -> int +This argument cannot be applied without label + Since OCaml 4.11, optional arguments do not commute when -nolabels is given +|}] +;; + +f 3 ~a:1 ~c:2 5 ~b:0 ~x:4;; +[%%expect{| +Line 1, characters 12-13: +1 | f 3 ~a:1 ~c:2 5 ~b:0 ~x:4;; + ^ +Error: The function applied to this argument has type + ?b:int -> ?c:int -> x:int -> int -> int +This argument cannot be applied with label ~c + Since OCaml 4.11, optional arguments do not commute when -nolabels is given +|}] +;; + +f 3 ~b:1 ~c:2 5 ~a:0 ~x:4;; +[%%expect{| +Line 1, characters 7-8: +1 | f 3 ~b:1 ~c:2 5 ~a:0 ~x:4;; + ^ +Error: The function applied to this argument has type + ?a:int -> ?b:int -> ?c:int -> x:int -> int -> int +This argument cannot be applied with label ~b + Since OCaml 4.11, optional arguments do not commute when -nolabels is given +|}] +;; + +(* Example given by Jacques when reviewing + https://github.com/ocaml/ocaml/pull/9411 *) + +let f ?x ?y () = ();; +[%%expect{| +val f : ?x:'a -> ?y:'b -> unit -> unit = +|}] +;; + +f ~y:3;; +[%%expect{| +Line 1, characters 5-6: +1 | f ~y:3;; + ^ +Error: The function applied to this argument has type + ?x:'a -> ?y:'b -> unit -> unit +This argument cannot be applied with label ~y + Since OCaml 4.11, optional arguments do not commute when -nolabels is given +|}] +;; diff --git a/testsuite/tests/typing-missing-cmi-3/middle.ml b/testsuite/tests/typing-missing-cmi-3/middle.ml index 9b2bee40..cc4b1322 100644 --- a/testsuite/tests/typing-missing-cmi-3/middle.ml +++ b/testsuite/tests/typing-missing-cmi-3/middle.ml @@ -1 +1,5 @@ type 'a t = 'a Original.t = T + +let f: (module Original.T with type t = int) -> unit = fun _ -> () +let x = (module struct type t end: Original.T ) +let g: (module Original.T) -> unit = fun _ -> () diff --git a/testsuite/tests/typing-missing-cmi-3/ocamltest b/testsuite/tests/typing-missing-cmi-3/ocamltest deleted file mode 100644 index b38a63fe..00000000 --- a/testsuite/tests/typing-missing-cmi-3/ocamltest +++ /dev/null @@ -1 +0,0 @@ -user.ml diff --git a/testsuite/tests/typing-missing-cmi-3/original.ml b/testsuite/tests/typing-missing-cmi-3/original.ml index 534a5fac..04c6c5e9 100644 --- a/testsuite/tests/typing-missing-cmi-3/original.ml +++ b/testsuite/tests/typing-missing-cmi-3/original.ml @@ -1 +1,2 @@ type 'a t = T +module type T = sig type t end diff --git a/testsuite/tests/typing-missing-cmi-3/user.ml b/testsuite/tests/typing-missing-cmi-3/user.ml index c75821b5..aacd19f7 100644 --- a/testsuite/tests/typing-missing-cmi-3/user.ml +++ b/testsuite/tests/typing-missing-cmi-3/user.ml @@ -8,11 +8,40 @@ module = "original.ml" module = "middle.ml" **** script script = "rm -f original.cmi" -***** ocamlc.byte -module = "user.ml" +***** expect *) +#directory "ocamlc.byte";; +#load "middle.cmo" + let x:'a. 'a Middle.t = let _r = ref 0 in Middle.T +[%%expect {| +val x : 'a Middle.t = Middle.T +|}] + + +let () = Middle.(g x) +[%%expect {| +|}] + +let () = Middle.(f x) +[%%expect {| +Line 1, characters 19-20: +1 | let () = Middle.(f x) + ^ +Error: This expression has type (module Original.T) + but an expression was expected of type + (module Original.T with type t = int) +|}] + +let () = Middle.f (module struct end) +[%%expect {| +Line 1, characters 26-36: +1 | let () = Middle.f (module struct end) + ^^^^^^^^^^ +Error: Signature mismatch: + Modules do not match: sig end is not included in Original.T +|}] diff --git a/testsuite/tests/typing-modules-bugs/pr9695_bad.compilers.reference b/testsuite/tests/typing-modules-bugs/pr9695_bad.compilers.reference new file mode 100644 index 00000000..d52aba54 --- /dev/null +++ b/testsuite/tests/typing-modules-bugs/pr9695_bad.compilers.reference @@ -0,0 +1,4 @@ +File "pr9695_bad.ml", line 10, characters 18-19: +10 | let () = let open A in x + ^ +Error: This is an alias for module MissingModule, which is missing diff --git a/testsuite/tests/typing-modules-bugs/pr9695_bad.ml b/testsuite/tests/typing-modules-bugs/pr9695_bad.ml new file mode 100644 index 00000000..191248a2 --- /dev/null +++ b/testsuite/tests/typing-modules-bugs/pr9695_bad.ml @@ -0,0 +1,10 @@ +(* TEST +flags = " -w a -no-alias-deps" +ocamlc_byte_exit_status = "2" +* setup-ocamlc.byte-build-env +** ocamlc.byte +*** check-ocamlc.byte-output +*) + +module A = MissingModule +let () = let open A in x diff --git a/testsuite/tests/typing-modules/aliases.ml b/testsuite/tests/typing-modules/aliases.ml index 2f2cfd24..aac8c2a0 100644 --- a/testsuite/tests/typing-modules/aliases.ml +++ b/testsuite/tests/typing-modules/aliases.ml @@ -298,6 +298,7 @@ module StringSet : val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t + val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> t * t val cardinal : t -> int val elements : t -> elt list @@ -343,6 +344,7 @@ module SSet : val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t + val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> t * t val cardinal : t -> int val elements : t -> elt list @@ -420,6 +422,7 @@ module A : val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t + val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> t * t val cardinal : t -> int val elements : t -> elt list @@ -532,6 +535,7 @@ module SInt : val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t + val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> t * t val cardinal : t -> int val elements : t -> elt list diff --git a/testsuite/tests/typing-modules/illegal_permutation.ml b/testsuite/tests/typing-modules/illegal_permutation.ml index 66ebb251..5a5998da 100644 --- a/testsuite/tests/typing-modules/illegal_permutation.ml +++ b/testsuite/tests/typing-modules/illegal_permutation.ml @@ -78,8 +78,7 @@ Error: Signature mismatch: At position module type x = Illegal permutation of runtime components in a module type. For example, - the extension constructor "Three" - and the value "one" are not in the same order + the exception "Three" and the value "one" are not in the same order in the expected and actual module types. |}] @@ -322,8 +321,7 @@ Error: Signature mismatch: At position module type x = Illegal permutation of runtime components in a module type. For example, - the extension constructor "B" - and the extension constructor "A" are not in the same order + the exception "B" and the exception "A" are not in the same order in the expected and actual module types. |}] diff --git a/testsuite/tests/typing-modules/merge_constraint.ml b/testsuite/tests/typing-modules/merge_constraint.ml new file mode 100644 index 00000000..a26bf835 --- /dev/null +++ b/testsuite/tests/typing-modules/merge_constraint.ml @@ -0,0 +1,248 @@ +(* TEST + * expect *) + +(* #9623 *) + +module RhsScopeCheck = struct + module type Sig1 = sig + type t + type u = t + end + + (* A scoping error here is intentional: + with-constraints "with = " + have their evaluated in the current + typing environment, not within the signature + that they are constraining. [t] is unbound + in the current environment, so [with u = t] + must be rejected. *) + module type Check1 = Sig1 + with type u = t +end +[%%expect{| +Line 15, characters 18-19: +15 | with type u = t + ^ +Error: Unbound type constructor t +|}] + + +module VarianceEnv = struct + module type Sig = sig + type +'a abstract + type +'a user = Foo of 'a abstract + end + + module type Problem = sig + include Sig + module M : Sig + with type 'a abstract = 'a abstract + and type 'a user = 'a user + + (* the variance annotation of [+'a foo] should be accepted, which + would not be the case if the with-constraint [and type 'a + user = 'a user] had its variance type-checked in the wrong typing + environment: see #9624 *) + type +'a foo = 'a M.user + end +end +[%%expect{| +module VarianceEnv : + sig + module type Sig = + sig type +'a abstract type 'a user = Foo of 'a abstract end + module type Problem = + sig + type +'a abstract + type 'a user = Foo of 'a abstract + module M : + sig + type 'a abstract = 'a abstract + type 'a user = 'a user = Foo of 'a abstract + end + type 'a foo = 'a M.user + end + end +|}] + +module UnboxedEnv = struct + module type Sig = sig + type 'a ind = 'a * int + type t = T : 'e ind -> t [@@unboxed] + end + + module type Problem = sig + include Sig + module type ReboundSig = Sig + with type 'a ind = 'a ind + and type t = t + (* the with-definition [and type t = t] above should be accepted, + which would not be the case if its definition had separability + checked in the wrong typing environment: see #9624 *) + end +end +[%%expect{| +module UnboxedEnv : + sig + module type Sig = + sig type 'a ind = 'a * int type t = T : 'e ind -> t [@@unboxed] end + module type Problem = + sig + type 'a ind = 'a * int + type t = T : 'e ind -> t [@@unboxed] + module type ReboundSig = + sig + type 'a ind = 'a ind + type t = t/2 = T : 'a ind -> t/1 [@@unboxed] + end + end + end +|}] + +(* We can also have environment issues when unifying type parameters; + regression test contributed by Jacques Garrigue in #9623. *) +module ParamsUnificationEnv = struct + module type Sig = + sig type 'a u = 'a list type +'a t constraint 'a = 'b u end + type +'a t = 'b constraint 'a = 'b list + module type Sig2 = Sig with type +'a t = 'a t +end +[%%expect{| +module ParamsUnificationEnv : + sig + module type Sig = + sig type 'a u = 'a list type +'a t constraint 'a = 'b u end + type +'a t = 'b constraint 'a = 'b list + module type Sig2 = + sig type 'a u = 'a list type +'a t = 'a t constraint 'a = 'b u end + end +|}] + + +(* The construction of the "signature environment" was also broken + in earlier versions of the code. Regression test by Leo White in #9623. *) +module CorrectEnvConstructionTest = struct + module type Sig = sig + type +'a user = Foo of 'a abstract + and +'a abstract + end + + module type Problem = sig + include Sig + module M : Sig + with type 'a abstract = 'a abstract + and type 'a user = 'a user + type +'a foo = 'a M.user + end +end +[%%expect{| +module CorrectEnvConstructionTest : + sig + module type Sig = + sig type 'a user = Foo of 'a abstract and +'a abstract end + module type Problem = + sig + type 'a user = Foo of 'a abstract + and +'a abstract + module M : + sig + type 'a user = 'a user = Foo of 'a abstract + and 'a abstract = 'a abstract + end + type 'a foo = 'a M.user + end + end +|}] + +(* #9640 *) + +module type Packet_type = sig + type t +end +module type Unpacked_header = sig + module Packet_type : Packet_type + type t + val f : t -> Packet_type.t -> unit +end +module type Header = sig + module Packet_type : Packet_type + module Unpacked : Unpacked_header with module Packet_type := Packet_type +end +module type S = sig + module Packet_type : Packet_type + module Header : Header with module Packet_type = Packet_type +end +[%%expect{| +module type Packet_type = sig type t end +module type Unpacked_header = + sig + module Packet_type : Packet_type + type t + val f : t -> Packet_type.t -> unit + end +module type Header = + sig + module Packet_type : Packet_type + module Unpacked : sig type t val f : t -> Packet_type.t -> unit end + end +module type S = + sig + module Packet_type : Packet_type + module Header : + sig + module Packet_type : sig type t = Packet_type.t end + module Unpacked : sig type t val f : t -> Packet_type.t -> unit end + end + end +|}] +module type Iobuf_packet = sig + module Make (Header : Header) () : + S + with module Packet_type = Header.Packet_type + with module Header.Unpacked = Header.Unpacked +end +[%%expect{| +module type Iobuf_packet = + sig + module Make : + functor (Header : Header) () -> + sig + module Packet_type : sig type t = Header.Packet_type.t end + module Header : + sig + module Packet_type : sig type t = Packet_type.t end + module Unpacked : + sig + type t = Header.Unpacked.t + val f : t -> Header.Packet_type.t -> unit + end + end + end + end +|}] + +(* Simpler example by @gasche *) +module type S = sig + type t + type u = t +end +module type Pack = sig + module M : S +end +[%%expect{| +module type S = sig type t type u = t end +module type Pack = sig module M : S end +|}] +module type Weird = sig + module M : S + module P : Pack + with type M.t = M.t + with type M.u = M.u +end +[%%expect{| +module type Weird = + sig + module M : S + module P : sig module M : sig type t = M.t type u = M.u end end + end +|}] diff --git a/testsuite/tests/typing-modules/pr7818.ml b/testsuite/tests/typing-modules/pr7818.ml index 0fafb581..62ed82fa 100644 --- a/testsuite/tests/typing-modules/pr7818.ml +++ b/testsuite/tests/typing-modules/pr7818.ml @@ -254,6 +254,7 @@ module MkT : val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t + val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> t * t val cardinal : t -> int val elements : t -> elt list @@ -315,9 +316,9 @@ module type S' = end module Asc : sig type t = int val compare : int -> int -> int end module Desc : sig type t = int val compare : int -> int -> int end -Line 15, characters 16-64: +Line 15, characters 0-69: 15 | module rec M1 : S' with module Term0 := Asc and module T := Desc = M1;; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This variant or record definition does not match that of type M.t Constructors do not match: E of (MkT(M.T).t, MkT(M.T).t) eq diff --git a/testsuite/tests/typing-modules/pr7851.ml b/testsuite/tests/typing-modules/pr7851.ml index 856fb0b7..bcd3281b 100644 --- a/testsuite/tests/typing-modules/pr7851.ml +++ b/testsuite/tests/typing-modules/pr7851.ml @@ -23,9 +23,9 @@ module type S = sig type x type y type t = E of x type u = t = E of y end module rec M1 : S with type x = int and type y = bool = M1;; [%%expect{| -Line 1, characters 16-53: +Line 1, characters 0-58: 1 | module rec M1 : S with type x = int and type y = bool = M1;; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This variant or record definition does not match that of type M1.t Constructors do not match: E of M1.x @@ -75,9 +75,9 @@ let (E eq : M1.u) = (E Eq : M1.t);; let cast : type a b. (a,b) eq -> a -> b = fun Eq x -> x;; cast eq 3;; [%%expect{| -Line 1, characters 16-53: +Line 1, characters 0-58: 1 | module rec M1 : S with type x = int and type y = bool = M1;; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This variant or record definition does not match that of type M1.t Constructors do not match: E of (M1.x, M1.x) eq diff --git a/testsuite/tests/typing-modules/pr9384.ml b/testsuite/tests/typing-modules/pr9384.ml new file mode 100644 index 00000000..941bdadf --- /dev/null +++ b/testsuite/tests/typing-modules/pr9384.ml @@ -0,0 +1,46 @@ +(* TEST + * expect +*) + +module M : sig + type 'a t := [< `A ] as 'a + val f : 'a -> 'a t +end = struct + let f x = x +end;; +[%%expect{| +Line 2, characters 2-28: +2 | type 'a t := [< `A ] as 'a + ^^^^^^^^^^^^^^^^^^^^^^^^^^ +Error: Destructive substitutions are not supported for constrained + types (other than when replacing a type constructor with + a type constructor with the same arguments). +|}] + +type foo = { foo : 'a. ([< `A] as 'a) -> 'a } + +module Foo (X : sig type 'a t := [< `A ] as 'a type foo2 = foo = { foo : 'a. 'a t -> 'a t } end) = struct + let f { X.foo } = foo +end;; +[%%expect{| +type foo = { foo : 'a. ([< `A ] as 'a) -> 'a; } +Line 3, characters 20-46: +3 | module Foo (X : sig type 'a t := [< `A ] as 'a type foo2 = foo = { foo : 'a. 'a t -> 'a t } end) = struct + ^^^^^^^^^^^^^^^^^^^^^^^^^^ +Error: Destructive substitutions are not supported for constrained + types (other than when replacing a type constructor with + a type constructor with the same arguments). +|}] + +type bar = { bar : 'a. ([< `A] as 'a) -> 'a } + +module Bar (X : sig type 'a t := 'a type bar2 = bar = { bar : 'a. ([< `A] as 'a) t -> 'a t } end) = struct + let f { X.bar } = bar +end;; +[%%expect{| +type bar = { bar : 'a. ([< `A ] as 'a) -> 'a; } +module Bar : + functor + (X : sig type bar2 = bar = { bar : 'a. ([< `A ] as 'a) -> 'a; } end) -> + sig val f : X.bar2 -> ([< `A ] as 'a) -> 'a end +|}] diff --git a/testsuite/tests/typing-modules/pr9695.ml b/testsuite/tests/typing-modules/pr9695.ml new file mode 100644 index 00000000..ad025fea --- /dev/null +++ b/testsuite/tests/typing-modules/pr9695.ml @@ -0,0 +1,12 @@ +(* TEST + * expect +*) + +module Test (S : sig module type S end) (M : S.S) = + struct open M (* should not succeed silently *) end +[%%expect{| +Line 2, characters 14-15: +2 | struct open M (* should not succeed silently *) end + ^ +Error: This module is not a structure; it has type S.S +|}] diff --git a/testsuite/tests/typing-modules/recursive.ml b/testsuite/tests/typing-modules/recursive.ml index 5a198f71..8e6cdb17 100644 --- a/testsuite/tests/typing-modules/recursive.ml +++ b/testsuite/tests/typing-modules/recursive.ml @@ -6,8 +6,8 @@ module rec T : sig type t = T.t end = T;; [%%expect{| -Line 1, characters 15-35: +Line 1, characters 0-39: 1 | module rec T : sig type t = T.t end = T;; - ^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The type abbreviation T.t is cyclic |}] diff --git a/testsuite/tests/typing-objects/Tests.ml b/testsuite/tests/typing-objects/Tests.ml index 45e1ab8d..82a2bbc9 100644 --- a/testsuite/tests/typing-objects/Tests.ml +++ b/testsuite/tests/typing-objects/Tests.ml @@ -66,6 +66,21 @@ and ['a] d : unit -> object constraint 'a = int #c end |}];; (* class ['a] c : unit -> object constraint 'a = int end and ['a] d : unit -> object constraint 'a = int #c end *) +(* Class type constraint *) +module F(X:sig type t end) = struct + class type ['a] c = object + method m: 'a -> X.t + end +end +class ['a] c = object + constraint 'a = 'a #F(Int).c +end +[%%expect {| +module F : + functor (X : sig type t end) -> + sig class type ['a] c = object method m : 'a -> X.t end end +class ['a] c : object constraint 'a = < m : 'a -> Int.t; .. > end +|}] (* Self as parameter *) class ['a] c (x : 'a) = object (self : 'b) @@ -179,7 +194,14 @@ and 'a d = ;; Line 1, characters 0-32: 1 | type 'a c = ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of d, type int c should be 'a c +Error: This recursive type is not regular. + The type constructor c is defined as + type 'a c + but it is used as + int c + after the following expansion(s): + 'a d = < f : int c > + All uses need to match the definition for the recursive type to be regular. |}];; type 'a c = and 'a d = ;; diff --git a/testsuite/tests/typing-poly/poly.ml b/testsuite/tests/typing-poly/poly.ml index 00310526..88930a59 100644 --- a/testsuite/tests/typing-poly/poly.ml +++ b/testsuite/tests/typing-poly/poly.ml @@ -972,7 +972,14 @@ type 'a u = < m : 'a v > and 'a v = 'a list u;; Line 1, characters 0-24: 1 | type 'a u = < m : 'a v > and 'a v = 'a list u;; ^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of v, type 'a list u should be 'a u +Error: This recursive type is not regular. + The type constructor u is defined as + type 'a u + but it is used as + 'a list u + after the following expansion(s): + 'a v = 'a list u + All uses need to match the definition for the recursive type to be regular. |}];; (* PR#8198: Ctype.matches *) @@ -1338,11 +1345,13 @@ val f : 'a -> int = val g : 'a -> int = type 'a t = Leaf of 'a | Node of ('a * 'a) t val depth : 'a t -> int = -Line 6, characters 2-42: -6 | function Leaf _ -> 1 | Node x -> 1 + d x - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: This definition has type 'a t -> int which is less general than - 'a0. 'a0 t -> int +val depth : 'a t -> int = +val d : ('a * 'a) t -> int = +Line 9, characters 2-46: +9 | function Leaf x -> x | Node x -> 1 + depth x;; (* fails *) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Error: This definition has type int t -> int which is less general than + 'a. 'a t -> int |}];; (* compare with records (should be the same) *) @@ -1449,7 +1458,12 @@ type 'x t = < f : 'y. 'y t >;; Line 1, characters 0-28: 1 | type 'x t = < f : 'y. 'y t >;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of t, type 'y t should be 'x t +Error: This recursive type is not regular. + The type constructor t is defined as + type 'x t + but it is used as + 'y t. + All uses need to match the definition for the recursive type to be regular. |}];; (* PR#6056, PR#6057 *) @@ -1766,3 +1780,75 @@ class c : object method m : ?x:int -> unit -> int method n : int end class d : object method m : ?x:int -> unit -> int method n : int method n' : int end |}] + +(* #1132 *) +let rec foo : 'a . 'a -> 'd = fun x -> x +[%%expect{| +Line 1, characters 30-40: +1 | let rec foo : 'a . 'a -> 'd = fun x -> x + ^^^^^^^^^^ +Error: This definition has type 'b -> 'b which is less general than + 'a. 'a -> 'c +|}] + +(* #7741 *) +type 'a s = S + +class type ['x] c = object + method x : 'x list +end +[%%expect{| +type 'a s = S +class type ['x] c = object method x : 'x list end +|}] + +let x : 'a c = object + method x : 'b . 'b s list = [S] +end +[%%expect{| +Lines 1-3, characters 15-3: +1 | ...............object +2 | method x : 'b . 'b s list = [S] +3 | end +Error: This expression has type < x : 'b. 'b s list > + but an expression was expected of type 'a c + The method x has type 'b. 'b s list, but the expected method type was + 'a list + The universal variable 'b would escape its scope +|}] + +type u = < m : 'a. 'a s list * (< m : 'b. 'a s list * 'c > as 'c) > +type v = < m : 'a. 'a s list * 'c > as 'c +[%%expect{| +type u = < m : 'a. 'a s list * (< m : 'a s list * 'b > as 'b) > +type v = < m : 'a. 'a s list * 'b > as 'b +|}] +let f (x : u) = (x : v) +[%%expect{| +Line 1, characters 17-18: +1 | let f (x : u) = (x : v) + ^ +Error: This expression has type u but an expression was expected of type v + The method m has type 'a s list * < m : 'b > as 'b, + but the expected method type was 'a. 'a s list * < m : 'a. 'b > as 'b + The universal variable 'a would escape its scope +|}] + +type 'a s = private int +[%%expect{| +type 'a s = private int +|}] +let x : 'a c = object + method x : 'b . 'b s list = [] +end +[%%expect{| +Lines 1-3, characters 15-3: +1 | ...............object +2 | method x : 'b . 'b s list = [] +3 | end +Error: This expression has type < x : 'b. 'b s list > + but an expression was expected of type 'a c + The method x has type 'b. 'b s list, but the expected method type was + 'a list + The universal variable 'b would escape its scope +|}] diff --git a/testsuite/tests/typing-poly/pr9603.ml b/testsuite/tests/typing-poly/pr9603.ml new file mode 100644 index 00000000..382b1c2b --- /dev/null +++ b/testsuite/tests/typing-poly/pr9603.ml @@ -0,0 +1,48 @@ +(* TEST + * expect +*) + +type 'p pair = 'a * 'b constraint 'p = < left:'a; right:'b> + +(* New in 4.11 *) +let error: 'left 'right. + pair -> pair = + fun (x,y) -> (y,x) +[%%expect{| +type 'c pair = 'a * 'b constraint 'c = < left : 'a; right : 'b > +val error : + < left : 'left; right : 'right > pair -> + < left : 'right; right : 'left > pair = +|}] + +(* Known problem with polymorphic methods *) +let foo : + < m : 'left 'right. pair > + -> < m : 'left 'right. pair > += fun x -> x + +[%%expect{| +Line 4, characters 11-12: +4 | = fun x -> x + ^ +Error: This expression has type + < m : 'left 'right. < left : 'left; right : 'right > pair > + but an expression was expected of type + < m : 'left 'right. < left : 'left; right : 'right > pair > + Type < left : 'left; right : 'right > pair = 'a * 'b + is not compatible with type < left : 'left0; right : 'right0 > pair + The method left has type 'a, but the expected method type was 'left + The universal variable 'left would escape its scope +|}, Principal{| +Line 4, characters 6-7: +4 | = fun x -> x + ^ +Error: This pattern matches values of type + < m : 'left 'right. < left : 'left; right : 'right > pair > + but a pattern was expected which matches values of type + < m : 'left 'right. < left : 'left; right : 'right > pair > + Type < left : 'left; right : 'right > pair = 'a * 'b + is not compatible with type < left : 'left0; right : 'right0 > pair + The method left has type 'a, but the expected method type was 'left + The universal variable 'left would escape its scope +|}] diff --git a/testsuite/tests/typing-polyvariants-bugs/pr7817_bad.ml b/testsuite/tests/typing-polyvariants-bugs/pr7817_bad.ml new file mode 100644 index 00000000..85d82c92 --- /dev/null +++ b/testsuite/tests/typing-polyvariants-bugs/pr7817_bad.ml @@ -0,0 +1,29 @@ +(* TEST + * expect +*) + +let r = ref None + +module M : sig + val write : ([< `A of string | `B of int ] -> unit) +end = struct + let write x = + match x with `A _ | `B _ -> r := Some x +end +[%%expect{| +val r : '_weak1 option ref = {contents = None} +Lines 5-8, characters 6-3: +5 | ......struct +6 | let write x = +7 | match x with `A _ | `B _ -> r := Some x +8 | end +Error: Signature mismatch: + Modules do not match: + sig val write : _[< `A of '_weak2 | `B of '_weak3 ] -> unit end + is not included in + sig val write : [< `A of string | `B of int ] -> unit end + Values do not match: + val write : _[< `A of '_weak2 | `B of '_weak3 ] -> unit + is not included in + val write : [< `A of string | `B of int ] -> unit +|}] diff --git a/testsuite/tests/typing-recmod/pr9494.ml b/testsuite/tests/typing-recmod/pr9494.ml new file mode 100644 index 00000000..41fda6aa --- /dev/null +++ b/testsuite/tests/typing-recmod/pr9494.ml @@ -0,0 +1,38 @@ +(* TEST +*) + +(* PR#9494 *) + +(* Additional test cases from Vincent Laviron: *) + +(* Looping version *) +module rec M1 : sig + val f : unit -> unit + val g : unit -> unit +end = struct + let f = M1.g + let g () = M1.f () +end + +(* Alias chain *) +module rec M2 : sig + val f : unit -> unit + val g : unit -> unit +end = struct + let f = M2.g + let g = M2.f +end + +(* Original test case from the issue: *) + +module rec Id : sig + type t = {id : int} + val compare : t -> t -> int +end = Id (* error here: undefined compare function *) + +module IdSet = Set.Make(Id) + +let _ = try + let basic_set = IdSet.singleton {id = 0} in + IdSet.mem {id = 1} basic_set (* diverge here *) +with e -> print_endline @@ Printexc.to_string e; false diff --git a/testsuite/tests/typing-recmod/pr9494.reference b/testsuite/tests/typing-recmod/pr9494.reference new file mode 100644 index 00000000..f9982e6b --- /dev/null +++ b/testsuite/tests/typing-recmod/pr9494.reference @@ -0,0 +1 @@ +File "pr9494.ml", line 31, characters 6-12: Undefined recursive module diff --git a/testsuite/tests/typing-recmod/t01bad.compilers.reference b/testsuite/tests/typing-recmod/t01bad.compilers.reference index 4601e424..5da0bcdc 100644 --- a/testsuite/tests/typing-recmod/t01bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t01bad.compilers.reference @@ -1,4 +1,4 @@ -File "t01bad.ml", line 10, characters 15-35: +File "t01bad.ml", line 10, characters 0-61: 10 | module rec A : sig type t = A.t end = struct type t = A.t end;; - ^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The type abbreviation A.t is cyclic diff --git a/testsuite/tests/typing-recmod/t02bad.compilers.reference b/testsuite/tests/typing-recmod/t02bad.compilers.reference index 5236cc2c..ef3f6ed8 100644 --- a/testsuite/tests/typing-recmod/t02bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t02bad.compilers.reference @@ -1,5 +1,5 @@ -File "t02bad.ml", line 10, characters 15-35: +File "t02bad.ml", line 10, characters 0-61: 10 | module rec A : sig type t = B.t end = struct type t = B.t end - ^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The definition of A.t contains a cycle: B.t diff --git a/testsuite/tests/typing-recmod/t04bad.compilers.reference b/testsuite/tests/typing-recmod/t04bad.compilers.reference index 9c6f0a26..525dd301 100644 --- a/testsuite/tests/typing-recmod/t04bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t04bad.compilers.reference @@ -1,5 +1,5 @@ -File "t04bad.ml", line 10, characters 15-41: +File "t04bad.ml", line 10, characters 0-73: 10 | module rec A : sig type t = int * A.t end = struct type t = int * A.t end;; - ^^^^^^^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The definition of A.t contains a cycle: int * A.t diff --git a/testsuite/tests/typing-recmod/t05bad.compilers.reference b/testsuite/tests/typing-recmod/t05bad.compilers.reference index f94582ae..3daf0ab2 100644 --- a/testsuite/tests/typing-recmod/t05bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t05bad.compilers.reference @@ -1,5 +1,5 @@ -File "t05bad.ml", line 10, characters 15-42: +File "t05bad.ml", line 10, characters 0-75: 10 | module rec A : sig type t = B.t -> int end = struct type t = B.t -> int end - ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The definition of A.t contains a cycle: B.t -> int diff --git a/testsuite/tests/typing-recmod/t07bad.compilers.reference b/testsuite/tests/typing-recmod/t07bad.compilers.reference index 2fa8fc53..78fa7b85 100644 --- a/testsuite/tests/typing-recmod/t07bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t07bad.compilers.reference @@ -1,4 +1,9 @@ -File "t07bad.ml", line 10, characters 15-51: +File "t07bad.ml", lines 10-11, characters 0-54: 10 | module rec A : sig type 'a t = end - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of A.t, type 'a list A.t should be 'a A.t +11 | = struct type 'a t = end.. +Error: This recursive type is not regular. + The type constructor A.t is defined as + type 'a A.t + but it is used as + 'a list A.t. + All uses need to match the definition for the recursive type to be regular. diff --git a/testsuite/tests/typing-recmod/t08bad.compilers.reference b/testsuite/tests/typing-recmod/t08bad.compilers.reference index 2a8a0fdd..b85c1968 100644 --- a/testsuite/tests/typing-recmod/t08bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t08bad.compilers.reference @@ -1,4 +1,11 @@ -File "t08bad.ml", line 10, characters 15-68: +File "t08bad.ml", lines 10-11, characters 0-71: 10 | module rec A : sig type 'a t = end - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of B.t, type 'a array A.t should be 'a A.t +11 | = struct type 'a t = end +Error: This recursive type is not regular. + The type constructor A.t is defined as + type 'a A.t + but it is used as + 'a array A.t + after the following expansion(s): + 'a array B.t = 'a array A.t + All uses need to match the definition for the recursive type to be regular. diff --git a/testsuite/tests/typing-recmod/t09bad.compilers.reference b/testsuite/tests/typing-recmod/t09bad.compilers.reference index 26521d10..f630daa1 100644 --- a/testsuite/tests/typing-recmod/t09bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t09bad.compilers.reference @@ -1,4 +1,11 @@ -File "t09bad.ml", line 10, characters 15-41: +File "t09bad.ml", lines 10-11, characters 0-44: 10 | module rec A : sig type 'a t = 'a B.t end - ^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of B.t, type 'a array A.t should be 'a A.t +11 | = struct type 'a t = 'a B.t end +Error: This recursive type is not regular. + The type constructor A.t is defined as + type 'a A.t + but it is used as + 'a array A.t + after the following expansion(s): + 'a B.t = < m : 'a list A.t; n : 'a array A.t > + All uses need to match the definition for the recursive type to be regular. diff --git a/testsuite/tests/typing-recmod/t11bad.compilers.reference b/testsuite/tests/typing-recmod/t11bad.compilers.reference index bdde1398..360bc743 100644 --- a/testsuite/tests/typing-recmod/t11bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t11bad.compilers.reference @@ -1,4 +1,9 @@ -File "t11bad.ml", line 12, characters 15-52: -12 | and B : sig type 'a t = end - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: In the definition of B.t, type 'a array B.t should be 'a B.t +File "t11bad.ml", lines 12-13, characters 7-55: +12 | .......and B : sig type 'a t = end +13 | = struct type 'a t = end.. +Error: This recursive type is not regular. + The type constructor B.t is defined as + type 'a B.t + but it is used as + 'a array B.t. + All uses need to match the definition for the recursive type to be regular. diff --git a/testsuite/tests/typing-recmod/t12bad.compilers.reference b/testsuite/tests/typing-recmod/t12bad.compilers.reference index 6b531a1b..b1adf92f 100644 --- a/testsuite/tests/typing-recmod/t12bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t12bad.compilers.reference @@ -1,7 +1,17 @@ -File "t12bad.ml", lines 11-15, characters 4-7: -11 | ....sig +File "t12bad.ml", lines 10-21, characters 0-7: +10 | module rec M : +11 | sig 12 | class ['a] c : 'a -> object 13 | method map : ('a -> 'b) -> 'b M.c 14 | end -15 | end -Error: In the definition of M.c, type 'b M.c should be 'a M.c +... +18 | method map : 'b. ('a -> 'b) -> 'b M.c +19 | = fun f -> new M.c (f x) +20 | end +21 | end.. +Error: This recursive type is not regular. + The type constructor M.c is defined as + type 'a M.c + but it is used as + 'b M.c. + All uses need to match the definition for the recursive type to be regular. diff --git a/testsuite/tests/typing-recmod/t14bad.compilers.reference b/testsuite/tests/typing-recmod/t14bad.compilers.reference index 260384b0..8197a02f 100644 --- a/testsuite/tests/typing-recmod/t14bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t14bad.compilers.reference @@ -1,5 +1,5 @@ -File "t14bad.ml", line 23, characters 17-39: +File "t14bad.ml", line 23, characters 2-43: 23 | module rec U : T with type D.t = U'.t = U - ^^^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The definition of U.D.t contains a cycle: U'.t diff --git a/testsuite/tests/typing-recmod/t15bad.compilers.reference b/testsuite/tests/typing-recmod/t15bad.compilers.reference index 73706a57..82f0dc09 100644 --- a/testsuite/tests/typing-recmod/t15bad.compilers.reference +++ b/testsuite/tests/typing-recmod/t15bad.compilers.reference @@ -1,4 +1,4 @@ -File "t15bad.ml", line 11, characters 15-35: +File "t15bad.ml", line 11, characters 0-61: 11 | module rec M : S' with type t = M.t = struct type t = M.t end;; - ^^^^^^^^^^^^^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: The type abbreviation M.t is cyclic diff --git a/testsuite/tests/typing-short-paths/errors.ml b/testsuite/tests/typing-short-paths/errors.ml new file mode 100644 index 00000000..2f08791d --- /dev/null +++ b/testsuite/tests/typing-short-paths/errors.ml @@ -0,0 +1,36 @@ +(* TEST + flags = " -short-paths " + * expect +*) + +module M = struct type t = T end + +type t = M.t + +let x : M.t = S +[%%expect {| +module M : sig type t = T end +type t = M.t +Line 5, characters 14-15: +5 | let x : M.t = S + ^ +Error: This variant expression is expected to have type t + The constructor S does not belong to type t +|}] + +module M = struct + class c = object method foo = 3 end +end + +type c = M.c + +let () = (new M.c)#bar +[%%expect {| +module M : sig class c : object method foo : int end end +type c = M.c +Line 7, characters 9-18: +7 | let () = (new M.c)#bar + ^^^^^^^^^ +Error: This expression has type c + It has no method bar +|}] diff --git a/testsuite/tests/typing-short-paths/short-paths.compilers.reference b/testsuite/tests/typing-short-paths/short-paths.compilers.reference index 47f15b3d..1619e340 100644 --- a/testsuite/tests/typing-short-paths/short-paths.compilers.reference +++ b/testsuite/tests/typing-short-paths/short-paths.compilers.reference @@ -34,6 +34,7 @@ module Core : val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t + val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t val cardinal : 'a t -> key val bindings : 'a t -> (key * 'a) list diff --git a/testsuite/tests/typing-sigsubst/sig_local_aliases.ml b/testsuite/tests/typing-sigsubst/sig_local_aliases.ml index 3142a6aa..096312ad 100644 --- a/testsuite/tests/typing-sigsubst/sig_local_aliases.ml +++ b/testsuite/tests/typing-sigsubst/sig_local_aliases.ml @@ -101,3 +101,23 @@ Line 3, characters 11-12: ^ Error: Unbound type constructor t |}] + +type ('a, 'b) foo = Foo + +type 'a s = 'b list constraint 'a = (int, 'b) foo + +module type S = sig + type 'a t := 'a s * bool + type 'a bar = (int, 'a) foo + val x : string bar t +end +[%%expect{| +type ('a, 'b) foo = Foo +type 'a s = 'b list constraint 'a = (int, 'b) foo +Line 6, characters 2-26: +6 | type 'a t := 'a s * bool + ^^^^^^^^^^^^^^^^^^^^^^^^ +Error: Destructive substitutions are not supported for constrained + types (other than when replacing a type constructor with + a type constructor with the same arguments). +|}] diff --git a/testsuite/tests/typing-sigsubst/sigsubst.ml b/testsuite/tests/typing-sigsubst/sigsubst.ml index 6f9da636..b2b835e9 100644 --- a/testsuite/tests/typing-sigsubst/sigsubst.ml +++ b/testsuite/tests/typing-sigsubst/sigsubst.ml @@ -39,25 +39,15 @@ module type Sunderscore = sig type (_, 'a) t = int * 'a end |}] -(* Valid substitutions in a recursive module may fail due to the ordering of - the modules. *) - +(* Valid substitutions in a recursive module used to fail + due to the ordering of the modules. This is fixed since #9623. *) module type S0 = sig module rec M : sig type t = M2.t end and M2 : sig type t = int end end with type M.t = int [%%expect {| -Lines 1-4, characters 17-23: -1 | .................sig -2 | module rec M : sig type t = M2.t end -3 | and M2 : sig type t = int end -4 | end with type M.t = int -Error: In this `with' constraint, the new definition of M.t - does not match its original definition in the constrained signature: - Type declarations do not match: - type t = int - is not included in - type t = M2.t +module type S0 = + sig module rec M : sig type t = int end and M2 : sig type t = int end end |}] diff --git a/testsuite/tests/typing-sigsubst/test_locations.compilers.reference b/testsuite/tests/typing-sigsubst/test_locations.compilers.reference index 86afba67..c3155381 100644 --- a/testsuite/tests/typing-sigsubst/test_locations.compilers.reference +++ b/testsuite/tests/typing-sigsubst/test_locations.compilers.reference @@ -2,14 +2,7 @@ File "test_loc_type_eq.ml", line 1, characters 49-76: 1 | module M : Test_functor.S with type elt = unit = Test_functor.Apply (String) ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: Signature mismatch: - Modules do not match: - sig - type elt = String.t - type t = Test_functor.Apply(String).t - val create : elt -> t - end - is not included in - sig type elt = unit type t val create : elt -> t end + ... Type declarations do not match: type elt = String.t is not included in diff --git a/testsuite/tests/typing-unboxed-types/test.ml b/testsuite/tests/typing-unboxed-types/test.ml index ce79acd4..5e81a3d7 100644 --- a/testsuite/tests/typing-unboxed-types/test.ml +++ b/testsuite/tests/typing-unboxed-types/test.ml @@ -88,7 +88,7 @@ Line 1, characters 0-56: 1 | type t9 = K of { j : string; l : int } [@@ocaml.unboxed];; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - its constructor has more than one argument. + its constructor has more than one field. |}];; (* let rec must be rejected *) @@ -352,3 +352,26 @@ type u = U : 'a t -> u [@@unboxed];; type 'a t [@@immediate] type u = U : 'a t -> u [@@unboxed] |}];; + +(* This could not be accepted without using a fixpoint to check unboxed declarations + (GPR#2188) *) +type ('a, 'b) t = K : 'c -> (bool, 'c) t [@@unboxed] +and t1 = T1 : (bool, int) t -> t1 [@@unboxed] +[%%expect{| +type ('a, 'b) t = K : 'c -> (bool, 'c) t [@@unboxed] +and t1 = T1 : (bool, int) t -> t1 [@@unboxed] +|}];; + +(* This real-world example of recursive declaration comes from Markus Mottl + -- see MPR#7361 *) +type ('a, 'kind) tree = + | Root : { mutable value : 'a; mutable rank : int } -> ('a, [ `root ]) tree + | Inner : { mutable parent : 'a node } -> ('a, [ `inner ]) tree +and 'a node = Node : ('a, _) tree -> 'a node [@@ocaml.unboxed] +[%%expect{| +type ('a, 'kind) tree = + Root : { mutable value : 'a; mutable rank : int; + } -> ('a, [ `root ]) tree + | Inner : { mutable parent : 'a node; } -> ('a, [ `inner ]) tree +and 'a node = Node : ('a, 'b) tree -> 'a node [@@unboxed] +|}];; diff --git a/testsuite/tests/typing-unboxed-types/test_flat.ml b/testsuite/tests/typing-unboxed-types/test_flat.ml index a2c04fe8..c093efe1 100644 --- a/testsuite/tests/typing-unboxed-types/test_flat.ml +++ b/testsuite/tests/typing-unboxed-types/test_flat.ml @@ -5,14 +5,15 @@ (* should fail *) type 'a abs;; -type t16 = A : _ abs -> t16 [@@ocaml.unboxed];; +type t16 = A : 'a abs -> t16 [@@ocaml.unboxed];; [%%expect{| type 'a abs -Line 2, characters 0-45: -2 | type t16 = A : _ abs -> t16 [@@ocaml.unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 2, characters 0-46: +2 | type t16 = A : 'a abs -> t16 [@@ocaml.unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; @@ -23,34 +24,37 @@ Line 1, characters 0-50: 1 | type t18 = A : _ list abs -> t18 [@@ocaml.unboxed];; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of an unnamed existential variable. You should annotate it with [@@ocaml.boxed]. |}];; (* regression test for PR#7511 (wrong determination of unboxability for GADTs) *) type 'a s = S : 'a -> 'a s [@@unboxed];; -type t = T : _ s -> t [@@unboxed];; +type t = T : 'a s -> t [@@unboxed];; [%%expect{| type 'a s = S : 'a -> 'a s [@@unboxed] -Line 2, characters 0-33: -2 | type t = T : _ s -> t [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 2, characters 0-34: +2 | type t = T : 'a s -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; (* regression test for GPR#1133 (follow-up to PR#7511) *) type 'a s = S : 'a -> 'a option s [@@unboxed];; -type t = T : _ s -> t [@@unboxed];; +type t = T : 'a s -> t [@@unboxed];; [%%expect{| type 'a s = S : 'a -> 'a option s [@@unboxed] -Line 2, characters 0-33: -2 | type t = T : _ s -> t [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 2, characters 0-34: +2 | type t = T : 'a s -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; @@ -74,23 +78,26 @@ Line 1, characters 0-45: 1 | type t = T : (unit -> _) M.r -> t [@@unboxed];; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of an unnamed existential variable. You should annotate it with [@@ocaml.boxed]. |}];; +(* accept *) type 'a s = S : (unit -> 'a) M.r -> 'a option s [@@unboxed];; [%%expect{| type 'a s = S : (unit -> 'a) M.r -> 'a option s [@@unboxed] |}];; (* reject *) -type t = T : _ s -> t [@@unboxed];; +type t = T : 'a s -> t [@@unboxed];; [%%expect{| -Line 1, characters 0-33: -1 | type t = T : _ s -> t [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 1, characters 0-34: +1 | type t = T : 'a s -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; @@ -100,44 +107,73 @@ type 'a t = T : 'a s -> 'a t [@@unboxed];; type 'a t = T : 'a s -> 'a t [@@unboxed] |}];; +(* Even without constraints, we need to mark abstract types as Deepsep: + unboxed GADTs can introduce equations that do not appear in the signature + (see GPR#2188) *) +module N : sig + type 'a r + val inj : 'b -> (unit -> 'b) r +end = struct + type _ r = K : 'b -> (unit -> 'b) r [@@unboxed] + let inj x = K x +end;; +[%%expect{| +module N : sig type 'a r val inj : 'b -> (unit -> 'b) r end +|}];; + +(* reject *) +type t = T : (unit -> _) N.r -> t [@@unboxed];; +[%%expect{| +Line 1, characters 0-45: +1 | type t = T : (unit -> _) N.r -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Error: This type cannot be unboxed because + it might contain both float and non-float values, + depending on the instantiation of an unnamed existential variable. + You should annotate it with [@@ocaml.boxed]. +|}];; + +(* accept *) +type 'a s = S : (unit -> 'a) N.r -> 'a option s [@@unboxed];; +[%%expect{| +type 'a s = S : (unit -> 'a) N.r -> 'a option s [@@unboxed] +|}];; (* Another corner case from GPR#1133 *) type _ s = S : 'a t -> _ s [@@unboxed] and _ t = T : 'a -> 'a s t ;; [%%expect{| -Line 1, characters 0-39: -1 | type _ s = S : 'a t -> _ s [@@unboxed] - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: This type cannot be unboxed because - it might contain both float and non-float values. - You should annotate it with [@@ocaml.boxed]. +type _ s = S : 'a t -> 'b s [@@unboxed] +and _ t = T : 'a -> 'a s t |}];; (* regression test for PR#7511 (wrong determination of unboxability for GADTs) *) type 'a s = S : 'a -> 'a s [@@unboxed];; -type t = T : _ s -> t [@@unboxed];; +type t = T : 'a s -> t [@@unboxed];; [%%expect{| type 'a s = S : 'a -> 'a s [@@unboxed] -Line 2, characters 0-33: -2 | type t = T : _ s -> t [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 2, characters 0-34: +2 | type t = T : 'a s -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; (* regression test for GPR#1133 (follow-up to PR#7511) *) type 'a s = S : 'a -> 'a option s [@@unboxed];; -type t = T : _ s -> t [@@unboxed];; +type t = T : 'a s -> t [@@unboxed];; [%%expect{| type 'a s = S : 'a -> 'a option s [@@unboxed] -Line 2, characters 0-33: -2 | type t = T : _ s -> t [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 2, characters 0-34: +2 | type t = T : 'a s -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; @@ -161,7 +197,8 @@ Line 1, characters 0-45: 1 | type t = T : (unit -> _) M.r -> t [@@unboxed];; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of an unnamed existential variable. You should annotate it with [@@ocaml.boxed]. |}];; @@ -171,13 +208,14 @@ type 'a s = S : (unit -> 'a) M.r -> 'a option s [@@unboxed] |}];; (* reject *) -type t = T : _ s -> t [@@unboxed];; +type t = T : 'a s -> t [@@unboxed];; [%%expect{| -Line 1, characters 0-33: -1 | type t = T : _ s -> t [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Line 1, characters 0-34: +1 | type t = T : 'a s -> t [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; @@ -193,10 +231,85 @@ type _ s = S : 'a t -> _ s [@@unboxed] and _ t = T : 'a -> 'a s t ;; [%%expect{| -Line 1, characters 0-39: -1 | type _ s = S : 'a t -> _ s [@@unboxed] - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +type _ s = S : 'a t -> 'b s [@@unboxed] +and _ t = T : 'a -> 'a s t +|}];; + +(* GPR#2188: non-principality examples. + One of the two declarations [valid1] and [valid2] below will fail, + depending on the order in which GADT equality constraints + are processed by our implementation. + The previous unfolding implementation would accept both. + + We decided to specify that, if two parameters are equal to each other, + then we would use the more constrained mode (Sep rather than Ind) for the + first/leftmost parameter, and Ind for the second one. With a left-to-right + reading of parameters, this corresponds to considering that the equality + is on the second parameter, equal to a parameter already seen, rather than + an equality on a not-yet-seen parameter. + + In the example below, almost_eq will thus get the mode signature + (Sep, Ind) rather than (Ind, Sep). +*) +type (_, _) almost_eq = Almost_refl : 'a -> ('a, 'a) almost_eq [@@unboxed] +[%%expect{| +type (_, _) almost_eq = Almost_refl : 'a -> ('a, 'a) almost_eq [@@unboxed] +|}];; + + +type valid1 = Any : ('a, int) almost_eq -> valid1 [@@unboxed];; +[%%expect{| +Line 1, characters 0-61: +1 | type valid1 = Any : ('a, int) almost_eq -> valid1 [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Error: This type cannot be unboxed because + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. + You should annotate it with [@@ocaml.boxed]. +|}];; +type valid2 = Any : (int, 'a) almost_eq -> valid2 [@@unboxed];; +[%%expect{| +type valid2 = Any : (int, 'a) almost_eq -> valid2 [@@unboxed] +|}];; + +(* rejected: equivalent to (exits 'a. 'a) *) +type danger = Any : ('a, 'a) almost_eq -> danger [@@unboxed];; +[%%expect{| +Line 1, characters 0-60: +1 | type danger = Any : ('a, 'a) almost_eq -> danger [@@unboxed];; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error: This type cannot be unboxed because - it might contain both float and non-float values. + it might contain both float and non-float values, + depending on the instantiation of the existential variable 'a. You should annotate it with [@@ocaml.boxed]. |}];; + + +(* GPR#2188: handling of cyclic types *) +type 'a stream = unit -> [ `Cons of 'a * 'a stream ];; +type safe = Any : 'a stream -> safe;; +[%%expect{| +type 'a stream = unit -> [ `Cons of 'a * 'a stream ] +type safe = Any : 'a stream -> safe +|}];; + +type 'a infinite_full_tree = unit -> [ `Node of 'a * ('a * 'a) stream ];; +type safe_again = Any : 'a stream -> safe_again;; +[%%expect{| +type 'a infinite_full_tree = unit -> [ `Node of 'a * ('a * 'a) stream ] +type safe_again = Any : 'a stream -> safe_again +|}];; + +(** Note: there are no tests of rejected cyclic types, because + the type declarations that would be required to check these cases + (unproductive cycles in the type declaration) are already rejected by the + type-checker, before separability checking. See below *) +type 'a id = Id of 'a [@@unboxed] +type cycle = cycle id +[%%expect{| +type 'a id = Id of 'a [@@unboxed] +Line 2, characters 0-21: +2 | type cycle = cycle id + ^^^^^^^^^^^^^^^^^^^^^ +Error: The type abbreviation cycle is cyclic +|}];; diff --git a/testsuite/tests/typing-unboxed/test.ml b/testsuite/tests/typing-unboxed/test.ml index 03edd525..741ac3d9 100644 --- a/testsuite/tests/typing-unboxed/test.ml +++ b/testsuite/tests/typing-unboxed/test.ml @@ -468,3 +468,16 @@ external idub : iub -> iub = "%identity";; type iub = I of int [@@unboxed] external idub : iub -> iub = "%identity" |}];; + +(* #9607: separability was not computed on with-constraints *) +module type T = sig type 'k t end +module M : T with type 'k t = string = struct + type 'k t = string +end +type t = T : 'k M.t -> t [@@unboxed] + +[%%expect{| +module type T = sig type 'k t end +module M : sig type 'k t = string end +type t = T : 'k M.t -> t [@@unboxed] +|}];; diff --git a/testsuite/tests/typing-unboxed/test.ocaml.reference b/testsuite/tests/typing-unboxed/test.ocaml.reference deleted file mode 100644 index e476a629..00000000 --- a/testsuite/tests/typing-unboxed/test.ocaml.reference +++ /dev/null @@ -1,191 +0,0 @@ -external a : (int [@untagged]) -> unit = "a" "a_nat" -external b : (int32 [@unboxed]) -> unit = "b" "b_nat" -external c : (int64 [@unboxed]) -> unit = "c" "c_nat" -external d : (nativeint [@unboxed]) -> unit = "d" "d_nat" -external e : (float [@unboxed]) -> unit = "e" "e_nat" -type t = private int -external f : (t [@untagged]) -> unit = "f" "f_nat" -module M : - sig - external a : int -> (int [@untagged]) = "a" "a_nat" - external b : (int [@untagged]) -> int = "b" "b_nat" - end -Line 12, characters 2-71: - external f : (int32 [@unboxed]) -> (int32 [@unboxed]) = "f" "noalloc" - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -Line 4, characters 2-61: - external a : float -> float = "a" "noalloc" "a_nat" "float" - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Alert deprecated: [@@unboxed] + [@@noalloc] should be used instead of "float" -Line 5, characters 2-53: - external b : float -> float = "b" "noalloc" "b_nat" - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Alert deprecated: [@@noalloc] should be used instead of "noalloc" -Line 6, characters 2-51: - external c : float -> float = "c" "c_nat" "float" - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Alert deprecated: [@@unboxed] + [@@noalloc] should be used instead of "float" -Line 7, characters 2-45: - external d : float -> float = "d" "noalloc" - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Alert deprecated: [@@noalloc] should be used instead of "noalloc" -Line 15, characters 6-70: - ......struct - external f : int -> (int [@untagged]) = "f" "f_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : int -> (int [@untagged]) = "f" "f_nat" end - is not included in - sig external f : int -> int = "f" "f_nat" end - Values do not match: - external f : int -> (int [@untagged]) = "f" "f_nat" - is not included in - external f : int -> int = "f" "f_nat" -Line 4, characters 6-70: - ......struct - external f : (int [@untagged]) -> int = "f" "f_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : (int [@untagged]) -> int = "f" "f_nat" end - is not included in - sig external f : int -> int = "a" "a_nat" end - Values do not match: - external f : (int [@untagged]) -> int = "f" "f_nat" - is not included in - external f : int -> int = "a" "a_nat" -Line 4, characters 6-73: - ......struct - external f : float -> (float [@unboxed]) = "f" "f_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : float -> (float [@unboxed]) = "f" "f_nat" end - is not included in - sig external f : float -> float = "f" "f_nat" end - Values do not match: - external f : float -> (float [@unboxed]) = "f" "f_nat" - is not included in - external f : float -> float = "f" "f_nat" -Line 4, characters 6-73: - ......struct - external f : (float [@unboxed]) -> float = "f" "f_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : (float [@unboxed]) -> float = "f" "f_nat" end - is not included in - sig external f : float -> float = "a" "a_nat" end - Values do not match: - external f : (float [@unboxed]) -> float = "f" "f_nat" - is not included in - external f : float -> float = "a" "a_nat" -Line 6, characters 6-56: - ......struct - external f : int -> int = "f" "f_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : int -> int = "f" "f_nat" end - is not included in - sig external f : int -> (int [@untagged]) = "f" "f_nat" end - Values do not match: - external f : int -> int = "f" "f_nat" - is not included in - external f : int -> (int [@untagged]) = "f" "f_nat" -Line 4, characters 6-56: - ......struct - external f : int -> int = "a" "a_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : int -> int = "a" "a_nat" end - is not included in - sig external f : (int [@untagged]) -> int = "f" "f_nat" end - Values do not match: - external f : int -> int = "a" "a_nat" - is not included in - external f : (int [@untagged]) -> int = "f" "f_nat" -Line 4, characters 6-60: - ......struct - external f : float -> float = "f" "f_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : float -> float = "f" "f_nat" end - is not included in - sig external f : float -> (float [@unboxed]) = "f" "f_nat" end - Values do not match: - external f : float -> float = "f" "f_nat" - is not included in - external f : float -> (float [@unboxed]) = "f" "f_nat" -Line 4, characters 6-60: - ......struct - external f : float -> float = "a" "a_nat" - end.. -Error: Signature mismatch: - Modules do not match: - sig external f : float -> float = "a" "a_nat" end - is not included in - sig external f : (float [@unboxed]) -> float = "f" "f_nat" end - Values do not match: - external f : float -> float = "a" "a_nat" - is not included in - external f : (float [@unboxed]) -> float = "f" "f_nat" -Line 4, characters 14-19: - external g : (float [@untagged]) -> float = "g" "g_nat";; - ^^^^^ -Error: Don't know how to untag this type. Only int can be untagged -Line 1, characters 14-17: - external h : (int [@unboxed]) -> float = "h" "h_nat";; - ^^^ -Error: Don't know how to unbox this type. Only float, int32, int64 and nativeint can be unboxed -Line 3, characters 13-25: - external i : int -> float [@unboxed] = "i" "i_nat";; - ^^^^^^^^^^^^ -Error: Don't know how to unbox this type. Only float, int32, int64 and nativeint can be unboxed -Line 3, characters 21-26: - external j : int -> (float [@unboxed]) * float = "j" "j_nat";; - ^^^^^ -Error: The attribute '@unboxed' should be attached to a direct argument or result of the primitive, it should not occur deeply into its type -external k : int -> float = "k" "k_nat" -Line 4, characters 0-61: - external l : float -> float = "l" "l_nat" "float" [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: Cannot use "float" in conjunction with [@unboxed]/[@untagged] -Line 1, characters 0-62: - external m : (float [@unboxed]) -> float = "m" "m_nat" "float";; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: Cannot use "float" in conjunction with [@unboxed]/[@untagged] -Line 1, characters 0-55: - external n : float -> float = "n" "noalloc" [@@noalloc];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: Cannot use "noalloc" in conjunction with [@@noalloc] -Line 3, characters 0-45: - external o : (float[@unboxed]) -> float = "o";; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -Line 1, characters 0-45: - external p : float -> (float[@unboxed]) = "p";; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -Line 1, characters 0-44: - external q : (int[@untagged]) -> float = "q";; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -Line 1, characters 0-42: - external r : int -> (int[@untagged]) = "r";; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -Line 1, characters 0-42: - external s : int -> int = "s" [@@untagged];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -Line 1, characters 0-45: - external t : float -> float = "t" [@@unboxed];; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present -type 'a b = B of 'a b b [@@unboxed] - diff --git a/testsuite/tests/typing-warnings/exhaustiveness.ml b/testsuite/tests/typing-warnings/exhaustiveness.ml index e2eaeb11..1ed1aefc 100644 --- a/testsuite/tests/typing-warnings/exhaustiveness.ml +++ b/testsuite/tests/typing-warnings/exhaustiveness.ml @@ -149,7 +149,7 @@ Line 1, characters 8-47: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Warning 8: this pattern-matching is not exhaustive. Here is an example of a case that is not matched: -{left=Box 0; right=Box 0} +({left=Box 0; right=Box 0}|{left=Box 1; right=Box _}) val f : int box pair -> unit = |}] diff --git a/testsuite/tests/typing-warnings/pr9244.ml b/testsuite/tests/typing-warnings/pr9244.ml new file mode 100644 index 00000000..01b9d08e --- /dev/null +++ b/testsuite/tests/typing-warnings/pr9244.ml @@ -0,0 +1,55 @@ +(* TEST + flags = " -w A " + * expect +*) + +module type U = sig end +[%%expect {| +module type U = sig end +|}] + +module M : sig + module F2 (_ : U) : U +end = struct + module X = struct + let x = 13 + end + + module F1 (_ : U) = X + module F2 (M : U) = F1 (M) +end +[%%expect {| +Line 5, characters 8-9: +5 | let x = 13 + ^ +Warning 32: unused value x. +module M : sig module F2 : U -> U end +|}] + +module N : sig + module F2 (_ : U) : U +end = struct + module X = struct + let x = 13 + end + + module F1 (_ : U) = X + module F2 (_ : U) = F1 (struct end) +end +[%%expect {| +Line 5, characters 8-9: +5 | let x = 13 + ^ +Warning 32: unused value x. +module N : sig module F2 : U -> U end +|}] + + +module F (X : sig type t type s end) = struct type t = X.t end +[%%expect {| +Line 1, characters 25-31: +1 | module F (X : sig type t type s end) = struct type t = X.t end + ^^^^^^ +Warning 34: unused type s. +module F : functor (X : sig type t type s end) -> sig type t = X.t end +|}] diff --git a/testsuite/tests/typing-warnings/records.ml b/testsuite/tests/typing-warnings/records.ml index 5771dbe3..ed7ff7e7 100644 --- a/testsuite/tests/typing-warnings/records.ml +++ b/testsuite/tests/typing-warnings/records.ml @@ -268,6 +268,11 @@ module F3 = struct let r = {x=true;z='z'} end;; (* fail for missing label *) [%%expect{| +Line 3, characters 11-12: +3 | let r = {x=true;z='z'} + ^ +Warning 42: this use of x relies on type-directed disambiguation, +it will not compile with OCaml 4.00 or earlier. Line 3, characters 10-24: 3 | let r = {x=true;z='z'} ^^^^^^^^^^^^^^ @@ -646,3 +651,22 @@ Error: This pattern matches values of type [? `Key of v ] but a pattern was expected which matches values of type u Types for tag `Key are incompatible |}] + +(** no candidates after filtering; + This caused a temporary trunk regression identified by Florian Angeletti + while reviewing #9196 + *) +module M = struct + type t = { x:int; y:int} +end +type u = { a:int } +let _ = ( { M.x=0 } : u );; +[%%expect{| +module M : sig type t = { x : int; y : int; } end +type u = { a : int; } +Line 5, characters 12-15: +5 | let _ = ( { M.x=0 } : u );; + ^^^ +Error: The field M.x belongs to the record type M.t + but a field was expected belonging to the record type u +|}] diff --git a/testsuite/tests/typing-warnings/unused_recmodule.ml b/testsuite/tests/typing-warnings/unused_recmodule.ml new file mode 100644 index 00000000..78ce42ef --- /dev/null +++ b/testsuite/tests/typing-warnings/unused_recmodule.ml @@ -0,0 +1,31 @@ +(* TEST + * expect +*) + +[@@@ocaml.warning "+a"] + +module M : sig end = struct + module rec Foo : sig + type t + val create : Bar.t -> t + end = struct + type t = unit + + let create _ = () + end + + and Bar : sig + type t + end = struct + type t = unit + end + + let _ = Foo.create +end;; +[%%expect{| +Line 14, characters 4-10: +14 | type t + ^^^^^^ +Warning 34: unused type t. +module M : sig end +|}];; diff --git a/testsuite/tests/unwind/check-linker-version.sh b/testsuite/tests/unwind/check-linker-version.sh old mode 100644 new mode 100755 index 0b15681e..f1120da7 --- a/testsuite/tests/unwind/check-linker-version.sh +++ b/testsuite/tests/unwind/check-linker-version.sh @@ -10,7 +10,7 @@ elif [[ $LDVER -lt 224 ]]; then echo "ld version is $LDVER, only 224 or above are supported"; test_result=${TEST_SKIP}; else - test_reslut=${TEST_PASS}; + test_result=${TEST_PASS}; fi exit ${TEST_RESULT} diff --git a/testsuite/tests/utils/magic_number.ml b/testsuite/tests/utils/magic_number.ml new file mode 100644 index 00000000..a443e253 --- /dev/null +++ b/testsuite/tests/utils/magic_number.ml @@ -0,0 +1,38 @@ +(* TEST +include config +binary_modules = "config build_path_prefix_map misc" +* bytecode +*) + +open Misc +open Magic_number + +(* sanity checking: the magic number at a given kind can be parsed back *) +let error kind test = + fatal_errorf + "Internal compiler error (%s): there is a magic number mismatch on kind %s" + test + (string_of_kind kind) + +let check_raw_kind kind = + let valid = + match parse_kind (raw_kind kind) with + | None -> false + | Some kind_roundtrip -> + kind_roundtrip = kind + in + if not valid then error kind "raw_kind" + +let check_current_raw kind = + let valid = + match parse (current_raw kind) with + | Error _ -> false + | Ok magic -> + magic.kind = kind + && raw magic = current_raw kind + in + if not valid then error kind "current_raw" + +let () = + all_kinds + |> List.iter (fun kind -> check_raw_kind kind; check_current_raw kind) diff --git a/testsuite/tests/warnings/w47_inline.compilers.reference b/testsuite/tests/warnings/w47_inline.compilers.reference index 7c9bed8e..c9048adc 100644 --- a/testsuite/tests/warnings/w47_inline.compilers.reference +++ b/testsuite/tests/warnings/w47_inline.compilers.reference @@ -10,27 +10,27 @@ File "w47_inline.ml", line 15, characters 23-29: 15 | let d = (fun x -> x) [@inline malformed attribute] (* rejected *) ^^^^^^ Warning 47: illegal payload for attribute 'inline'. -It must be either 'never', 'always' or empty +It must be either 'never', 'always', 'hint' or empty File "w47_inline.ml", line 16, characters 23-29: 16 | let e = (fun x -> x) [@inline malformed_attribute] (* rejected *) ^^^^^^ Warning 47: illegal payload for attribute 'inline'. -It must be either 'never', 'always' or empty +It must be either 'never', 'always', 'hint' or empty File "w47_inline.ml", line 17, characters 23-29: 17 | let f = (fun x -> x) [@inline : malformed_attribute] (* rejected *) ^^^^^^ Warning 47: illegal payload for attribute 'inline'. -It must be either 'never', 'always' or empty +It must be either 'never', 'always', 'hint' or empty File "w47_inline.ml", line 18, characters 23-29: 18 | let g = (fun x -> x) [@inline ? malformed_attribute] (* rejected *) ^^^^^^ Warning 47: illegal payload for attribute 'inline'. -It must be either 'never', 'always' or empty +It must be either 'never', 'always', 'hint' or empty File "w47_inline.ml", line 23, characters 15-22: 23 | let k x = (a [@inlined malformed]) x (* rejected *) ^^^^^^^ Warning 47: illegal payload for attribute 'inlined'. -It must be either 'never', 'always' or empty +It must be either 'never', 'always', 'hint' or empty File "w47_inline.ml", line 31, characters 7-12: 31 | let[@local malformed] f3 x = x (* bad payload *) in ^^^^^ diff --git a/testsuite/tests/warnings/w55.flambda.reference b/testsuite/tests/warnings/w55.flambda.reference index b7175390..16012145 100644 --- a/testsuite/tests/warnings/w55.flambda.reference +++ b/testsuite/tests/warnings/w55.flambda.reference @@ -3,7 +3,7 @@ File "w55.ml", line 33, characters 10-26: ^^^^^^^^^^^^^^^^ Warning 55: Cannot inline: [@inlined] attributes may not be used on partial applications File "w55.ml", line 29, characters 10-27: -29 | let i x = (!h [@inlined]) x +29 | let i x = (!r [@inlined]) x ^^^^^^^^^^^^^^^^^ Warning 55: Cannot inline: [@inlined] attribute was not used on this function application (the optimizer did not know what function was being applied) File "w55.ml", line 39, characters 12-30: diff --git a/testsuite/tests/warnings/w55.ml b/testsuite/tests/warnings/w55.ml index 6013ced4..67fecee7 100644 --- a/testsuite/tests/warnings/w55.ml +++ b/testsuite/tests/warnings/w55.ml @@ -24,9 +24,9 @@ let f = (fun x -> x + 1) [@inline never] let g x = (f [@inlined]) x -let h = ref f +let r = ref f -let i x = (!h [@inlined]) x +let i x = (!r [@inlined]) x let j x y = x + y @@ -40,3 +40,13 @@ let b x y = (a [@inlined]) x y let c x = x + 1 [@@inline never] let d x = (c [@inlined]) x + +let g' x = (f [@inlined hint]) x + +let i' x = (!r [@inlined hint]) x + +let h' x = (j [@inlined hint]) x + +let b' x y = (a [@inlined hint]) x y + +let d' x = (c [@inlined hint]) x diff --git a/testsuite/tests/warnings/w55.native.reference b/testsuite/tests/warnings/w55.native.reference index 03e5ea4e..9ffb78f0 100644 --- a/testsuite/tests/warnings/w55.native.reference +++ b/testsuite/tests/warnings/w55.native.reference @@ -3,7 +3,7 @@ File "w55.ml", line 25, characters 10-26: ^^^^^^^^^^^^^^^^ Warning 55: Cannot inline: Function information unavailable File "w55.ml", line 29, characters 10-27: -29 | let i x = (!h [@inlined]) x +29 | let i x = (!r [@inlined]) x ^^^^^^^^^^^^^^^^^ Warning 55: Cannot inline: Unknown function File "w55.ml", line 33, characters 10-26: diff --git a/testsuite/tools/Makefile b/testsuite/tools/Makefile index 7166c2dc..a34116db 100644 --- a/testsuite/tools/Makefile +++ b/testsuite/tools/Makefile @@ -12,6 +12,8 @@ #* * #************************************************************************** +.NOTPARALLEL: + TOPDIR = ../.. COMPILERLIBSDIR = $(TOPDIR)/compilerlibs @@ -93,6 +95,6 @@ asmgen_i386.obj: asmgen_i386nt.asm .PHONY: clean clean: - rm -f *.cm* *.$(O) - rm -f $(tools) + rm -f *.cm* *.o *.obj + rm -f expect_test expect_test.exe codegen codegen.exe rm -f parsecmm.ml parsecmm.mli lexcmm.ml diff --git a/testsuite/tools/asmgen_riscv.S b/testsuite/tools/asmgen_riscv.S new file mode 100644 index 00000000..efb30a80 --- /dev/null +++ b/testsuite/tools/asmgen_riscv.S @@ -0,0 +1,89 @@ +/**************************************************************************/ +/* */ +/* OCaml */ +/* */ +/* Nicolas Ojeda Bar */ +/* */ +/* Copyright 2019 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. */ +/* */ +/**************************************************************************/ + +#define STORE sd +#define LOAD ld + + .globl call_gen_code + .align 2 +call_gen_code: + /* Set up stack frame and save callee-save registers */ + ADDI sp, sp, -208 + STORE ra, 192(sp) + STORE s0, 0(sp) + STORE s1, 8(sp) + STORE s2, 16(sp) + STORE s3, 24(sp) + STORE s4, 32(sp) + STORE s5, 40(sp) + STORE s6, 48(sp) + STORE s7, 56(sp) + STORE s8, 64(sp) + STORE s9, 72(sp) + STORE s10, 80(sp) + STORE s11, 88(sp) + fsd fs0, 96(sp) + fsd fs1, 104(sp) + fsd fs2, 112(sp) + fsd fs3, 120(sp) + fsd fs4, 128(sp) + fsd fs5, 136(sp) + fsd fs6, 144(sp) + fsd fs7, 152(sp) + fsd fs8, 160(sp) + fsd fs9, 168(sp) + fsd fs10, 176(sp) + fsd fs11, 184(sp) + /* Shuffle arguments */ + mv t0, a0 + mv a0, a1 + mv a1, a2 + mv a2, a3 + mv a3, a4 + /* Call generated asm */ + jalr t0 + /* Reload callee-save registers and return address */ + LOAD ra, 192(sp) + LOAD s0, 0(sp) + LOAD s1, 8(sp) + LOAD s2, 16(sp) + LOAD s3, 24(sp) + LOAD s4, 32(sp) + LOAD s5, 40(sp) + LOAD s6, 48(sp) + LOAD s7, 56(sp) + LOAD s8, 64(sp) + LOAD s9, 72(sp) + LOAD s10, 80(sp) + LOAD s11, 88(sp) + fld fs0, 96(sp) + fld fs1, 104(sp) + fld fs2, 112(sp) + fld fs3, 120(sp) + fld fs4, 128(sp) + fld fs5, 136(sp) + fld fs6, 144(sp) + fld fs7, 152(sp) + fld fs8, 160(sp) + fld fs9, 168(sp) + fld fs10, 176(sp) + fld fs11, 184(sp) + addi sp, sp, 208 + ret + + .globl caml_c_call + .align 2 +caml_c_call: + jr t2 diff --git a/testsuite/tools/expect_test.ml b/testsuite/tools/expect_test.ml index 2f180247..fed821fc 100644 --- a/testsuite/tools/expect_test.ml +++ b/testsuite/tools/expect_test.ml @@ -66,7 +66,7 @@ let match_expect_extension (ext : Parsetree.extension) = in let string_constant (e : Parsetree.expression) = match e.pexp_desc with - | Pexp_constant (Pconst_string (str, Some tag)) -> + | Pexp_constant (Pconst_string (str, _, Some tag)) -> { str; tag } | _ -> invalid_payload () in diff --git a/testsuite/tools/lexcmm.mll b/testsuite/tools/lexcmm.mll index 5cfbe5a5..fa5ecd1d 100644 --- a/testsuite/tools/lexcmm.mll +++ b/testsuite/tools/lexcmm.mll @@ -58,6 +58,7 @@ let keyword_table = "intoffloat", INTOFFLOAT; "string", KSTRING; "let", LET; + "letmut", LETMUT; "load", LOAD; "mod", MODI; "mulh", MULH; diff --git a/testsuite/tools/parsecmm.mly b/testsuite/tools/parsecmm.mly index bb24f512..aa254da8 100644 --- a/testsuite/tools/parsecmm.mly +++ b/testsuite/tools/parsecmm.mly @@ -26,6 +26,13 @@ let rec make_letdef def body = unbind_ident id; Clet(id, def, make_letdef rem body) +let rec make_letmutdef def body = + match def with + [] -> body + | (id, ty, def) :: rem -> + unbind_ident id; + Clet_mut(id, ty, def, make_letmutdef rem body) + let make_switch n selector caselist = let index = Array.make n 0 in let casev = Array.of_list caselist in @@ -105,6 +112,7 @@ let access_array base numelt size = %token LEF %token LEI %token LET +%token LETMUT %token LOAD %token LOCATION %token LPAREN @@ -207,6 +215,7 @@ expr: | IDENT { Cvar(find_ident $1) } | LBRACKET RBRACKET { Ctuple [] } | LPAREN LET letdef sequence RPAREN { make_letdef $3 $4 } + | LPAREN LETMUT letmutdef sequence RPAREN { make_letmutdef $3 $4 } | LPAREN ASSIGN IDENT expr RPAREN { Cassign(find_ident $3, $4) } | LPAREN APPLY location expr exprlist machtype RPAREN { Cop(Capply $6, $4 :: List.rev $5, debuginfo ?loc:$3 ()) } @@ -289,6 +298,17 @@ letdefmult: oneletdef: IDENT expr { (bind_ident $1, $2) } ; +letmutdef: + oneletmutdef { [$1] } + | LPAREN letmutdefmult RPAREN { $2 } +; +letmutdefmult: + /**/ { [] } + | oneletmutdef letmutdefmult { $1 :: $2 } +; +oneletmutdef: + IDENT machtype expr { (bind_ident $1, $2, $3) } +; chunk: UNSIGNED BYTE { Byte_unsigned } | SIGNED BYTE { Byte_signed } diff --git a/testsuite/tools/parsecmmaux.ml b/testsuite/tools/parsecmmaux.ml index c2fb7565..89d8b2a3 100644 --- a/testsuite/tools/parsecmmaux.ml +++ b/testsuite/tools/parsecmmaux.ml @@ -55,4 +55,4 @@ let report_error = function prerr_string "Unbound identifier "; prerr_string s; prerr_endline "." let debuginfo ?(loc=Location.symbol_rloc ()) () = - Debuginfo.(from_location loc) + Debuginfo.(from_location (Scoped_location.of_location ~scopes:[] loc)) diff --git a/tools/.depend b/tools/.depend index a4d18f4b..109cb1f3 100644 --- a/tools/.depend +++ b/tools/.depend @@ -28,40 +28,6 @@ cmpbyt.cmo : \ ../bytecomp/bytesections.cmi cmpbyt.cmx : \ ../bytecomp/bytesections.cmx -cmt2annot.cmo : \ - ../typing/untypeast.cmi \ - ../typing/types.cmi \ - ../typing/typedtree.cmi \ - ../typing/tast_iterator.cmi \ - ../typing/stypes.cmi \ - ../parsing/pprintast.cmi \ - ../typing/path.cmi \ - ../typing/oprint.cmi \ - ../parsing/location.cmi \ - ../utils/load_path.cmi \ - ../typing/ident.cmi \ - ../typing/envaux.cmi \ - ../typing/env.cmi \ - ../file_formats/cmt_format.cmi \ - ../parsing/asttypes.cmi \ - ../typing/annot.cmi -cmt2annot.cmx : \ - ../typing/untypeast.cmx \ - ../typing/types.cmx \ - ../typing/typedtree.cmx \ - ../typing/tast_iterator.cmx \ - ../typing/stypes.cmx \ - ../parsing/pprintast.cmx \ - ../typing/path.cmx \ - ../typing/oprint.cmx \ - ../parsing/location.cmx \ - ../utils/load_path.cmx \ - ../typing/ident.cmx \ - ../typing/envaux.cmx \ - ../typing/env.cmx \ - ../file_formats/cmt_format.cmx \ - ../parsing/asttypes.cmi \ - ../typing/annot.cmi cvt_emit.cmo : cvt_emit.cmx : dumpobj.cmo : \ @@ -202,17 +168,29 @@ profiling.cmx : \ profiling.cmi profiling.cmi : read_cmt.cmo : \ + ../typing/untypeast.cmi \ + ../typing/stypes.cmi \ + ../parsing/pprintast.cmi \ ../parsing/location.cmi \ + ../utils/load_path.cmi \ + ../typing/envaux.cmi \ ../driver/compmisc.cmi \ ../file_formats/cmt_format.cmi \ - cmt2annot.cmo \ - ../utils/clflags.cmi + ../typing/cmt2annot.cmo \ + ../utils/clflags.cmi \ + ../typing/annot.cmi read_cmt.cmx : \ + ../typing/untypeast.cmx \ + ../typing/stypes.cmx \ + ../parsing/pprintast.cmx \ ../parsing/location.cmx \ + ../utils/load_path.cmx \ + ../typing/envaux.cmx \ ../driver/compmisc.cmx \ ../file_formats/cmt_format.cmx \ - cmt2annot.cmx \ - ../utils/clflags.cmx + ../typing/cmt2annot.cmx \ + ../utils/clflags.cmx \ + ../typing/annot.cmi stripdebug.cmo : \ ../utils/misc.cmi \ ../bytecomp/bytesections.cmi diff --git a/tools/Makefile b/tools/Makefile index 0a7b31b1..dbad0b74 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -16,8 +16,8 @@ MAKEFLAGS := -r -R ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common ifeq ($(SYSTEM),unix) override define shellquote @@ -229,7 +229,7 @@ READ_CMT= \ $(ROOTDIR)/compilerlibs/ocamlcommon.cma \ $(ROOTDIR)/compilerlibs/ocamlbytecomp.cma \ \ - cmt2annot.cmo read_cmt.cmo + read_cmt.cmo # Reading cmt files $(call byte_and_opt,read_cmt,$(READ_CMT),) @@ -311,12 +311,19 @@ lintapidiff.opt: INCLUDES+= -I $(ROOTDIR)/otherlibs/str lintapidiff.opt: $(LINTAPIDIFF) $(CAMLOPT_CMD) $(LINKFLAGS) -I $(ROOTDIR) -o $@ $(LINTAPIDIFF) clean:: - rm -f -- lintapidiff.opt lintapidiff.cm? lintapidiff.o + rm -f -- lintapidiff.opt lintapidiff.cm? lintapidiff.o lintapidiff.obj clean:: - rm -f "objinfo_helper$(EXE)" "objinfo_helper$(EXE).manifest" + rm -f "objinfo_helper" "objinfo_helper.manifest" + rm -f "objinfo_helper.exe" "objinfo_helper.exe.manifest" +# Eventlog metadata file + +install:: + $(INSTALL_DATA) \ + eventlog_metadata \ + "$(INSTALL_LIBDIR)" # Copy a bytecode executable, stripping debug info @@ -334,13 +341,6 @@ CMPBYT=$(ROOTDIR)/compilerlibs/ocamlcommon.cma \ $(call byte_and_opt,cmpbyt,$(CMPBYT),) -ifeq "$(RUNTIMEI)" "true" -install:: - $(INSTALL_PROG) \ - ocaml-instr-graph ocaml-instr-report \ - "$(INSTALL_BINDIR)/" -endif - CAMLTEX= $(ROOTDIR)/compilerlibs/ocamlcommon.cma \ $(ROOTDIR)/compilerlibs/ocamlbytecomp.cma \ $(ROOTDIR)/compilerlibs/ocamltoplevel.cma \ diff --git a/tools/autogen b/tools/autogen new file mode 100755 index 00000000..8c85c2cb --- /dev/null +++ b/tools/autogen @@ -0,0 +1,40 @@ +#!/bin/sh -e +#************************************************************************** +#* * +#* OCaml * +#* * +#* David Allsopp, MetaStack Solutions Ltd. * +#* * +#* Copyright 2019 MetaStack Solutions Ltd. * +#* * +#* 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. * +#* * +#************************************************************************** + +# Remove the autom4te.cache directory to make sure we start in a clean state +rm -rf autom4te.cache + +autoconf --force --warnings=all,error + +# Allow pre-processing of configure arguments for Git check-outs +# The sed call removes dra27's copyright on the whole configure script... +sed -e '/^#[^!]/d' tools/git-dev-options.sh > configure.tmp + +# Some distros have the 2013 --runstatedir patch to autoconf (see +# http://git.savannah.gnu.org/cgit/autoconf.git/commit/?id=a197431414088a417b407b9b20583b2e8f7363bd +# in the GNU autoconf repo), and some don't, so ensure its effects are +# removed for CI consistency... +# POSIX Notes +# - sed -i without a backup file is not portable, hence configure.tmp +# - GNU sed's /../,+8d becomes /../{N;..;d;} (and the last ; is important) +sed -e '/^runstatedir/d' \ + -e '/-runstatedir /{N;N;N;N;N;N;N;N;d;}' \ + -e '/--runstatedir=DIR/d' \ + -e 's/ runstatedir//' \ + -e '1d' \ + configure >> configure.tmp + +mv -f configure.tmp configure +chmod +x configure diff --git a/tools/check-symbol-names b/tools/check-symbol-names index 83d8d0cf..048eb5d1 100755 --- a/tools/check-symbol-names +++ b/tools/check-symbol-names @@ -18,13 +18,23 @@ set -o pipefail [ -z "$*" ] && { echo "Usage: $0 libfoo.a" 1>&2; exit 2; } -nm -A -P "$@" | awk ' +nm -A -P "$@" | LC_ALL=C awk ' # ignore caml_foo, camlFoo_bar, _caml_foo, _camlFoo_bar $2 ~ /^(_?caml[_A-Z])/ { next } # ignore local and undefined symbols -$3 ~ /^[rbdtsU]$/ { next } +$3 ~ /^[a-zU]$/ { next } # ignore "main", which should be externally linked $2 ~ /^_?main$/ { next } +$2 ~ /^_?wmain$/ { next } +# Caml_state escapes the prefixing rule for now +$2 ~ /^_?Caml_state$/ { next } +# for x86 PIC mode +$2 ~ /^__x86.get_pc_thunk./ { next } +# for mingw32 +$2 ~ /^.debug_/ { next } +# windows unicode support +$2 ~ /^_win_multi_byte_to_wide_char$/ { next } +$2 ~ /^_win_wide_char_to_multi_byte$/ { next } # print the rest { found=1; print $1 " " $2 " " $3 } # fail if there were any results diff --git a/tools/ci/appveyor/appveyor_build.cmd b/tools/ci/appveyor/appveyor_build.cmd index e2c42547..15d2d58f 100644 --- a/tools/ci/appveyor/appveyor_build.cmd +++ b/tools/ci/appveyor/appveyor_build.cmd @@ -20,7 +20,31 @@ @rem Do not call setlocal! @echo off -goto %1 +if "%1" neq "install" goto %1 +setlocal enabledelayedexpansion +echo AppVeyor Environment +for %%K in (ACCOUNT_NAME ACS_DEPLOYMENT_UPGRADE_MODE API_URL + ARTIFACT_UPLOAD_TIMEOUT BUILD_FOLDER BUILD_ID BUILD_NUMBER + BUILD_VERSION BUILD_WORKER_IMAGE BUILD_WORKER_IMAGE + CACHE_ENTRY_UPLOAD_DOWNLOAD_TIMEOUT CACHE_SKIP_RESTORE + CACHE_SKIP_SAVE FILE_DOWNLOAD_TIMEOUT FORCED_BUILD + IGNORE_COMMIT_FILTERING_ON_TAG JOB_ID JOB_NAME JOB_NUMBER PROJECT_ID + PROJECT_NAME PROJECT_SLUG PULL_REQUEST_HEAD_COMMIT + PULL_REQUEST_HEAD_REPO_BRANCH PULL_REQUEST_HEAD_REPO_NAME + PULL_REQUEST_NUMBER PULL_REQUEST_TITLE RE_BUILD REPO_BRANCH + REPO_COMMIT_AUTHOR REPO_COMMIT_AUTHOR_EMAIL REPO_COMMIT + REPO_COMMIT_MESSAGE REPO_COMMIT_MESSAGE_EXTENDED + REPO_COMMIT_TIMESTAMP REPO_NAME REPO_PROVIDER REPO_SCM + REPOSITORY_SHALLOW_CLONE_TIMEOUT REPO_TAG_NAME REPO_TAG + RE_RUN_INCOMPLETE SAVE_CACHE_ON_ERROR SCHEDULED_BUILD + SKIP_FINALIZE_ON_EXIT APPVEYOR URL WAP_ARTIFACT_NAME + WAP_SKIP_ACLS) do echo APPVEYOR_%%K=!APPVEYOR_%%K! +echo CI=%CI% +echo CONFIGURATION=%CONFIGURATION% +echo PLATFORM=%PLATFORM% +endlocal + +goto install goto :EOF diff --git a/tools/ci/appveyor/appveyor_build.sh b/tools/ci/appveyor/appveyor_build.sh index bc8e0355..2275fc5c 100644 --- a/tools/ci/appveyor/appveyor_build.sh +++ b/tools/ci/appveyor/appveyor_build.sh @@ -17,11 +17,21 @@ set -e BUILD_PID=0 +# This must correspond with the entry in appveyor.yml +CACHE_DIRECTORY=/cygdrive/c/projects/cache + +if [[ -z $APPVEYOR_PULL_REQUEST_HEAD_COMMIT ]] ; then + MAKE="make -j" +else + MAKE=make +fi + function run { + if [[ $1 = "--show" ]] ; then SHOW_CMD='true'; shift; else SHOW_CMD=''; fi NAME=$1 shift echo "-=-=- $NAME -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" - "$@" + if [[ -n $SHOW_CMD ]]; then (set -x; "$@"); else "$@"; fi CODE=$? if [[ $CODE -ne 0 ]] ; then echo "-=-=- $NAME failed! -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" @@ -56,7 +66,12 @@ function set_configuration { ;; esac - ./configure $build $host --prefix="$2" + mkdir -p "$CACHE_DIRECTORY" + ./configure --cache-file="$CACHE_DIRECTORY/config.cache-$1" \ + $build $host --prefix="$2" --enable-ocamltest || ( \ + rm -f "$CACHE_DIRECTORY/config.cache-$1" ; \ + ./configure --cache-file="$CACHE_DIRECTORY/config.cache-$1" \ + $build $host --prefix="$2" --enable-ocamltest ) FILE=$(pwd | cygpath -f - -m)/Makefile.config echo "Edit $FILE to turn C compiler warnings into errors" @@ -93,29 +108,52 @@ case "$1" in set_configuration msvc "$OCAMLROOT-msvc32" -WX - run 'make world' make world - run 'make runtimeopt' make runtimeopt - run 'make -C otherlibs/systhreads libthreadsnat.lib' \ - make -C otherlibs/systhreads libthreadsnat.lib + run "$MAKE world" $MAKE world + run "$MAKE runtimeopt" $MAKE runtimeopt + run "$MAKE -C otherlibs/systhreads libthreadsnat.lib" \ + $MAKE -C otherlibs/systhreads libthreadsnat.lib exit 0 ;; test) FULL_BUILD_PREFIX="$APPVEYOR_BUILD_FOLDER/../$BUILD_PREFIX" run 'ocamlc.opt -version' "$FULL_BUILD_PREFIX-$PORT/ocamlc.opt" -version - run "test $PORT" make -C "$FULL_BUILD_PREFIX-$PORT" tests - run "install $PORT" make -C "$FULL_BUILD_PREFIX-$PORT" install + if [[ $PORT = 'mingw32' ]] ; then + run "Check runtime symbols" \ + "$FULL_BUILD_PREFIX-$PORT/tools/check-symbol-names" \ + $FULL_BUILD_PREFIX-$PORT/runtime/*.a + fi + run "test $PORT" $MAKE -C "$FULL_BUILD_PREFIX-$PORT" tests + run "install $PORT" $MAKE -C "$FULL_BUILD_PREFIX-$PORT" install if [[ $PORT = 'msvc64' ]] ; then - run 'check_all_arches' make -C "$FULL_BUILD_PREFIX-$PORT" check_all_arches + run "$MAKE check_all_arches" \ + $MAKE -C "$FULL_BUILD_PREFIX-$PORT" check_all_arches + cd "$FULL_BUILD_PREFIX-$PORT" + # Ensure that .gitignore is up-to-date - this will fail if any untracked + # or altered files exist. We revert the change from the bootstrap (that + # would have failed the build earlier if necessary) + git checkout -- boot/ocamlc boot/ocamllex + # Remove the FlexDLL sources placed earlier in the process + rm -rf "flexdll-$FLEXDLL_VERSION" + run --show "Check tree is tracked" test -z "$(git status --porcelain)" + # check that the `distclean` target definitely cleans the tree + run "$MAKE distclean" $MAKE distclean + # Check the working tree is clean + run --show "Check tree is tracked" test -z "$(git status --porcelain)" + # Check that there are no ignored files + run --show "Check tree is clean" \ + test -z "$(git ls-files --others -i --exclude-standard)" fi ;; *) cd "$APPVEYOR_BUILD_FOLDER/../$BUILD_PREFIX-$PORT" if [[ $PORT = 'msvc64' ]] ; then + # Ensure that make distclean can be run from an empty tree + run "$MAKE distclean" $MAKE distclean tar -xzf "$APPVEYOR_BUILD_FOLDER/flexdll.tar.gz" cd "flexdll-$FLEXDLL_VERSION" - make MSVC_DETECT=0 CHAINS=msvc64 support + $MAKE MSVC_DETECT=0 CHAINS=msvc64 support cp flexdll*_msvc64.obj "$OCAMLROOT/bin/flexdll/" cd .. fi @@ -135,16 +173,17 @@ case "$1" in # For an explanation of the sed command, see # https://github.com/appveyor/ci/issues/1824 script --quiet --return --command \ - "make -C ../$BUILD_PREFIX-mingw32 flexdll world.opt" \ + "$MAKE -C ../$BUILD_PREFIX-mingw32 flexdll && "\ +"$MAKE -C ../$BUILD_PREFIX-mingw32 world.opt" \ "../$BUILD_PREFIX-mingw32/build.log" | sed -e 's/\d027\[K//g' \ -e 's/\d027\[m/\d027[0m/g' \ -e 's/\d027\[01\([m;]\)/\d027[1\1/g' else - run 'make world' make world - run 'make bootstrap' make bootstrap - run 'make opt' make opt - run 'make opt.opt' make opt.opt + run "$MAKE world" $MAKE world + run "$MAKE bootstrap" $MAKE bootstrap + run "$MAKE opt" $MAKE opt + run "$MAKE opt.opt" $MAKE opt.opt fi ;; diff --git a/tools/ci/inria/bootstrap b/tools/ci/inria/bootstrap index a33b6b3a..6e993a14 100755 --- a/tools/ci/inria/bootstrap +++ b/tools/ci/inria/bootstrap @@ -125,7 +125,7 @@ set -ex # default values make=make instdir="$HOME/ocaml-tmp-install" -confoptions="${OCAML_CONFIGURE_OPTIONS}" +confoptions="--enable-ocamltest ${OCAML_CONFIGURE_OPTIONS}" make_native=true cleanup=false check_make_alldepend=false diff --git a/tools/ci/inria/dune-build b/tools/ci/inria/dune-build new file mode 100755 index 00000000..6c95220a --- /dev/null +++ b/tools/ci/inria/dune-build @@ -0,0 +1,25 @@ +#!/bin/sh + +#************************************************************************** +#* * +#* OCaml * +#* * +#* Xavier Leroy, projet Cambium, INRIA Paris-Rocquencourt * +#* * +#* Copyright 2020 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. * +#* * +#************************************************************************** + +# Test the Dune-based build + +set -ex +eval $(opam env) +export LC_ALL=C +git clean -q -f -d -x +./configure +dune build -j2 @libs diff --git a/tools/ci/inria/extra-checks b/tools/ci/inria/extra-checks index 9e2afc4a..3e686478 100755 --- a/tools/ci/inria/extra-checks +++ b/tools/ci/inria/extra-checks @@ -107,13 +107,16 @@ else fi # A tool that make error backtrace nicer -# Need to pick the one that matches clang-6.0 and is named "llvm-symbolizer" -# (/usr/bin/llvm-symbolizer-6.0 doesn't work, that would be too easy) -export ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer +# Need to pick the one that matches clang-9 and is named "llvm-symbolizer" +# (/usr/bin/llvm-symbolizer-9 doesn't work, that would be too easy) +export ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-9/bin/llvm-symbolizer export TSAN_SYMBOLIZER_PATH="$ASAN_SYMBOLIZER_PATH" ######################################################################### +# Cleanup repository +git clean -q -f -d -x + # Ensure that the repo still passes the check-typo script if [ ! -x tools/check-typo ] ; then error "tools/check-typo does not appear to be executable?" @@ -124,8 +127,6 @@ tools/check-typo echo "======== old school build ==========" -git clean -q -f -d -x - instdir="$HOME/ocaml-tmp-install-$$" ./configure --prefix "$instdir" @@ -141,15 +142,15 @@ rm -rf "$instdir" ######################################################################### -echo "======== clang 6.0, address sanitizer, UB sanitizer ==========" +echo "======== clang 9, address sanitizer, UB sanitizer ==========" git clean -q -f -d -x -# Use clang 6.0 +# Use clang 9 # We cannot give the sanitizer options as part of -cc because # then various autoconfiguration tests fail. # Instead, we'll fix OC_CFLAGS a posteriori. -./configure CC=clang-6.0 +./configure CC=clang-9 --disable-stdlib-manpages # These are the undefined behaviors we want to check # Others occur on purpose e.g. signed arithmetic overflow @@ -190,17 +191,17 @@ make $jobs world.opt # occurs. # We already use sigaltstack for stack overflow detection. Our use -# interracts with ASAN's. Hence, we tell ASAN not to use it. +# interacts with ASAN's. Hence, we tell ASAN not to use it. ASAN_OPTIONS="detect_leaks=0,use_sigaltstack=0" $run_testsuite ######################################################################### -echo "======== clang 6.0, thread sanitizer ==========" +echo "======== clang 9, thread sanitizer ==========" git clean -q -f -d -x -./configure CC=clang-6.0 +./configure CC=clang-9 --disable-stdlib-manpages # Select thread sanitizer # Don't optimize too much to get better backtraces of errors @@ -234,7 +235,7 @@ TSAN_OPTIONS="die_after_fork=0" $run_testsuite # # Instead, we'll fix OC_CFLAGS a posteriori. # # Memory sanitizer doesn't like the static data generated by ocamlopt, # # hence build bytecode only -# ./configure CC=clang-6.0 --disable-native-compiler +# ./configure CC=clang-9 --disable-native-compiler # # Select memory sanitizer # # Don't optimize at all to get better backtraces of errors diff --git a/tools/ci/inria/main b/tools/ci/inria/main index ca190321..99fb4667 100755 --- a/tools/ci/inria/main +++ b/tools/ci/inria/main @@ -125,7 +125,7 @@ host='' conffile=Makefile.config make=make instdir="$HOME/ocaml-tmp-install" -confoptions="${OCAML_CONFIGURE_OPTIONS}" +confoptions="--enable-ocamltest ${OCAML_CONFIGURE_OPTIONS}" make_native=true cleanup=false check_make_alldepend=false diff --git a/tools/ci/travis/travis-ci.sh b/tools/ci/travis/travis-ci.sh index 5aa1143a..410c63d3 100755 --- a/tools/ci/travis/travis-ci.sh +++ b/tools/ci/travis/travis-ci.sh @@ -90,6 +90,9 @@ request can be merged. ------------------------------------------------------------------------ EOF + # Ensure that make distclean can be run from an empty tree + $MAKE distclean + if [ "$MIN_BUILD" = "1" ] ; then configure_flags="\ --prefix=$PREFIX \ @@ -102,11 +105,13 @@ EOF --disable-bigarray-lib \ --disable-ocamldoc \ --disable-native-compiler \ + --enable-ocamltest \ $CONFIG_ARG" else configure_flags="\ --prefix=$PREFIX \ --enable-flambda-invariants \ + --enable-ocamltest \ $CONFIG_ARG" fi case $XARCH in @@ -136,6 +141,8 @@ EOF $MAKE world.opt $MAKE ocamlnat fi + echo Ensuring that all names are prefixed in the runtime + ./tools/check-symbol-names runtime/*.a cd testsuite echo Running the testsuite with the normal runtime $MAKE all @@ -157,8 +164,18 @@ EOF # we would need to redo (small parts of) world.opt afterwards to # use the compiler again $MAKE check_all_arches + # Ensure that .gitignore is up-to-date - this will fail if any untreacked or + # altered files exist. + test -z "$(git status --porcelain)" # check that the 'clean' target also works $MAKE clean + $MAKE -C manual clean + # check that the `distclean` target definitely cleans the tree + $MAKE distclean + # Check the working tree is clean + test -z "$(git status --porcelain)" + # Check that there are no ignored files + test -z "$(git ls-files --others -i --exclude-standard)" } CheckChangesModified () { @@ -277,10 +294,10 @@ CheckTypoTree () { echo 'Verifying that configure.ac generates configure' git checkout "$1" mv configure configure.ref - ./autogen + make configure if ! diff -q configure configure.ref >/dev/null ; then echo "configure.ac no longer generates configure, \ -please run ./autogen and commit" +please run rm configure ; make configure and commit" exit 1 fi fi diff --git a/tools/cmt2annot.ml b/tools/cmt2annot.ml deleted file mode 100644 index e0e4f849..00000000 --- a/tools/cmt2annot.ml +++ /dev/null @@ -1,257 +0,0 @@ -(**************************************************************************) -(* *) -(* OCaml *) -(* *) -(* Fabrice Le Fessant, INRIA Saclay *) -(* *) -(* Copyright 2012 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. *) -(* *) -(**************************************************************************) - -(* Generate an .annot file from a .cmt file. *) - -open Asttypes -open Typedtree -open Tast_iterator - -let variables_iterator scope = - let super = default_iterator in - let pat sub p = - begin match p.pat_desc with - | Tpat_var (id, _) | Tpat_alias (_, id, _) -> - Stypes.record (Stypes.An_ident (p.pat_loc, - Ident.name id, - Annot.Idef scope)) - | _ -> () - end; - super.pat sub p - in - {super with pat} - -let bind_variables scope = - let iter = variables_iterator scope in - fun p -> iter.pat iter p - -let bind_bindings scope bindings = - let o = bind_variables scope in - List.iter (fun x -> o x.vb_pat) bindings - -let bind_cases l = - List.iter - (fun {c_lhs; c_guard; c_rhs} -> - let loc = - let open Location in - match c_guard with - | None -> c_rhs.exp_loc - | Some g -> {c_rhs.exp_loc with loc_start=g.exp_loc.loc_start} - in - bind_variables loc c_lhs - ) - l - -let record_module_binding scope mb = - Stypes.record (Stypes.An_ident - (mb.mb_name.loc, - Option.value mb.mb_name.txt ~default:"_", - Annot.Idef scope)) - -let rec iterator ~scope rebuild_env = - let super = default_iterator in - let class_expr sub node = - Stypes.record (Stypes.Ti_class node); - super.class_expr sub node - - and module_expr _sub node = - Stypes.record (Stypes.Ti_mod node); - super.module_expr (iterator ~scope:node.mod_loc rebuild_env) node - - and expr sub exp = - begin match exp.exp_desc with - | Texp_ident (path, _, _) -> - let full_name = Path.name ~paren:Oprint.parenthesized_ident path in - let env = - if rebuild_env then - try - Env.env_of_only_summary Envaux.env_from_summary exp.exp_env - with Envaux.Error err -> - Format.eprintf "%a@." Envaux.report_error err; - exit 2 - else - exp.exp_env - in - let annot = - try - let desc = Env.find_value path env in - let dloc = desc.Types.val_loc in - if dloc.Location.loc_ghost then Annot.Iref_external - else Annot.Iref_internal dloc - with Not_found -> - Annot.Iref_external - in - Stypes.record - (Stypes.An_ident (exp.exp_loc, full_name , annot)) - | Texp_let (Recursive, bindings, _) -> - bind_bindings exp.exp_loc bindings - | Texp_let (Nonrecursive, bindings, body) -> - bind_bindings body.exp_loc bindings - | Texp_match (_, f1, _) -> - bind_cases f1 - | Texp_function { cases = f; } - | Texp_try (_, f) -> - bind_cases f - | Texp_letmodule (_, modname, _, _, body ) -> - Stypes.record (Stypes.An_ident - (modname.loc,Option.value ~default:"_" modname.txt, - Annot.Idef body.exp_loc)) - | _ -> () - end; - Stypes.record (Stypes.Ti_expr exp); - super.expr sub exp - - and pat sub p = - Stypes.record (Stypes.Ti_pat p); - super.pat sub p - in - - let structure_item_rem sub str rem = - let open Location in - let loc = str.str_loc in - begin match str.str_desc with - | Tstr_value (rec_flag, bindings) -> - let doit loc_start = bind_bindings {scope with loc_start} bindings in - begin match rec_flag, rem with - | Recursive, _ -> doit loc.loc_start - | Nonrecursive, [] -> doit loc.loc_end - | Nonrecursive, {str_loc = loc2} :: _ -> doit loc2.loc_start - end - | Tstr_module mb -> - record_module_binding - { scope with Location.loc_start = loc.loc_end } mb - | Tstr_recmodule mbs -> - List.iter (record_module_binding - { scope with Location.loc_start = loc.loc_start }) mbs - | _ -> - () - end; - Stypes.record_phrase loc; - super.structure_item sub str - in - let structure_item sub s = - (* This will be used for Partial_structure_item. - We don't have here the location of the "next" item, - this will give a slightly different scope for the non-recursive - binding case. *) - structure_item_rem sub s [] - in - let structure sub l = - let rec loop = function - | str :: rem -> structure_item_rem sub str rem; loop rem - | [] -> () - in - loop l.str_items - in - {super with class_expr; module_expr; expr; pat; structure_item; structure} - -let binary_part iter x = - let open Cmt_format in - match x with - | Partial_structure x -> iter.structure iter x - | Partial_structure_item x -> iter.structure_item iter x - | Partial_expression x -> iter.expr iter x - | Partial_pattern x -> iter.pat iter x - | Partial_class_expr x -> iter.class_expr iter x - | Partial_signature x -> iter.signature iter x - | Partial_signature_item x -> iter.signature_item iter x - | Partial_module_type x -> iter.module_type iter x - -(* Save cmt information as faked annotations, attached to - Location.none, on top of the .annot file. Only when -save-cmt-info is - provided to ocaml_cmt. -*) -let record_cmt_info cmt = - let location_none = { - Location.none with Location.loc_ghost = false } - in - let location_file file = { - Location.none with - Location.loc_start = { - Location.none.Location.loc_start with - Lexing.pos_fname = file }} - in - let record_info name value = - let ident = Printf.sprintf ".%s" name in - Stypes.record (Stypes.An_ident (location_none, ident, - Annot.Idef (location_file value))) - in - let open Cmt_format in - (* record in reverse order to get them in correct order... *) - List.iter (fun dir -> record_info "include" dir) (List.rev cmt.cmt_loadpath); - record_info "chdir" cmt.cmt_builddir; - (match cmt.cmt_sourcefile with - None -> () | Some file -> record_info "source" file) - -let gen_annot ?(save_cmt_info=false) target_filename filename cmt = - let open Cmt_format in - Envaux.reset_cache (); - List.iter Load_path.add_dir (List.rev cmt.cmt_loadpath); - let target_filename = - match target_filename with - | None -> Some (filename ^ ".annot") - | Some "-" -> None - | Some _ -> target_filename - in - if save_cmt_info then record_cmt_info cmt; - let iter = iterator ~scope:Location.none cmt.cmt_use_summaries in - match cmt.cmt_annots with - | Implementation typedtree -> - iter.structure iter typedtree; - Stypes.dump target_filename - | Interface _ -> - Printf.eprintf "Cannot generate annotations for interface file\n%!"; - exit 2 - | Partial_implementation parts -> - Array.iter (binary_part iter) parts; - Stypes.dump target_filename - | Packed _ -> - Printf.fprintf stderr "Packed files not yet supported\n%!"; - Stypes.dump target_filename - | Partial_interface _ -> - Printf.fprintf stderr "File was generated with an error\n%!"; - exit 2 - -let gen_ml target_filename filename cmt = - let (printer, ext) = - match cmt.Cmt_format.cmt_annots with - | Cmt_format.Implementation typedtree -> - (fun ppf -> Pprintast.structure ppf - (Untypeast.untype_structure typedtree)), - ".ml" - | Cmt_format.Interface typedtree -> - (fun ppf -> Pprintast.signature ppf - (Untypeast.untype_signature typedtree)), - ".mli" - | _ -> - Printf.fprintf stderr "File was generated with an error\n%!"; - exit 2 - in - let target_filename = match target_filename with - None -> Some (filename ^ ext) - | Some "-" -> None - | Some _ -> target_filename - in - let oc = match target_filename with - None -> None - | Some filename -> Some (open_out filename) in - let ppf = match oc with - None -> Format.std_formatter - | Some oc -> Format.formatter_of_out_channel oc in - printer ppf; - Format.pp_print_flush ppf (); - match oc with - None -> flush stdout - | Some oc -> close_out oc diff --git a/tools/dumpobj.ml b/tools/dumpobj.ml index 0b8b1653..a1fce610 100644 --- a/tools/dumpobj.ml +++ b/tools/dumpobj.ml @@ -86,7 +86,7 @@ let print_float f = let rec print_struct_const = function Const_base(Const_int i) -> printf "%d" i | Const_base(Const_float f) -> print_float f - | Const_base(Const_string (s, _)) -> printf "%S" s + | Const_base(Const_string (s, _, _)) -> printf "%S" s | Const_immstring s -> printf "%S" s | Const_base(Const_char c) -> printf "%C" c | Const_base(Const_int32 i) -> printf "%ldl" i diff --git a/tools/eventlog_metadata.in b/tools/eventlog_metadata.in new file mode 100644 index 00000000..f39364ed --- /dev/null +++ b/tools/eventlog_metadata.in @@ -0,0 +1,216 @@ +/* CTF 1.8 */ + +typealias integer {size = 8;} := uint8_t; +typealias integer {size = 16;} := uint16_t; +typealias integer {size = 32;} := uint32_t; +typealias integer {size = 64;} := uint64_t; + +clock { + name = tracing_clock; + freq = 1000000000; /* tick = 1 ns */ +}; + +typealias integer { + size = 64; + map = clock.tracing_clock.value; +} := tracing_clock_int_t; + + +/* + +Main trace description, +major and minor refers to the CTF version being used. + +The packet header must contain at the very least +a stream id and the CTF magic number. +We only use one stream for now, and CTF magic number is 0xc1fc1fc1. + +We add an extra field ocaml_trace_version to enable simpler transition if we add +or remove metrics in the future. + +*/ +trace { + major = 1; + minor = 8; + byte_order = @endianness@; + packet.header := struct { + uint32_t magic; /* required: must contain CTF magic number */ + uint16_t ocaml_trace_version; /* our own trace format versioning */ + uint16_t stream_id; /* required, although we have only one. */ + }; +}; + +/* + +We use only one stream at the moment. +Each event payload must contain a header with a timestamp and a pid. +The id field refers to the various event kinds defined further down this file. + +*/ +stream { + id = 0; + event.header := struct { /* for each event */ + tracing_clock_int_t timestamp; + uint32_t pid; + uint32_t id; + }; +}; + +/* + +These enumerations are mostly following the instrumented runtime datapoints. +gc_phase aims to track the entry and exit time of each of the following events +during collection. + +*/ +enum gc_phase : uint16_t { + "compact/main" = 0, + "compact/recompact", + "explicit/gc_set", + "explicit/gc_stat", + "explicit/gc_minor", + "explicit/gc_major", + "explicit/gc_full_major", + "explicit/gc_compact", + "major", + "major/roots", + "major/sweep", + "major/mark/roots", + "major/mark/main", + "major/mark/final", + "major/mark", + "major/mark/global_roots_slice", + "major_roots/global", + "major_roots/dynamic_global", + "major_roots/local", + "major_roots/C", + "major_roots/finalised", + "major_roots/memprof", + "major_roots/hook", + "major/check_and_compact", + "minor", + "minor/local_roots", + "minor/ref_tables", + "minor/copy", + "minor/update_weak", + "minor/finalized", + "explicit/gc_major_slice" +}; + +/* + +Miscellaneous GC counters + +*/ +enum gc_counter : uint16_t { + "alloc_jump", + "force_minor/alloc_small", + "force_minor/make_vect", + "force_minor/set_minor_heap_size", + "force_minor/weak", + "force_minor/memprof", + "major/mark/slice/remain", + "major/mark/slice/fields", + "major/mark/slice/pointers", + "major/work/extra", + "major/work/mark", + "major/work/sweep", + "minor/promoted", + "request_major/alloc_shr", + "request_major/adjust_gc_speed", + "request_minor/realloc_ref_table", + "request_minor/realloc_ephe_ref_table", + "request_minor/realloc_custom_table" +}; + +/* + +Block allocation counters, per size buckets. + +*/ +enum alloc_bucket : uint8_t { + "alloc 01" = 1, + "alloc 02", + "alloc 03", + "alloc 04", + "alloc 05", + "alloc 06", + "alloc 07", + "alloc 08", + "alloc 09", + "alloc 10-19", + "alloc 20-29", + "alloc 30-39", + "alloc 40-49", + "alloc 50-59", + "alloc 60-69", + "alloc 70-79", + "alloc 80-89", + "alloc 90-99", + "alloc large" +}; + +/* + +Each event is comprised of the previously defined event.header +and the fields defined here. + +An entry event marks the start of a gc phase. + +*/ +event { + id = 0; + name = "entry"; + stream_id = 0; + fields := struct { + enum gc_phase phase; + }; +}; + +/* + +exit counterparts to entry events + +*/ +event { + id = 1; + name = "exit"; + stream_id = 0; + fields := struct { + enum gc_phase phase; + }; +}; + +event { + id = 2; + name = "counter"; + stream_id = 0; + fields := struct { + uint64_t count; + enum gc_counter kind; + }; +}; + +event { + id = 3; + name = "alloc"; + stream_id = 0; + fields := struct { + uint64_t count; + enum alloc_bucket bucket; + }; +}; + +/* + Flush events are used to track the time spent by the tracing runtime flushing + data to disk, useful to remove flushing overhead for other runtime mesurements + in the trace. +*/ +event { + id = 4; + name = "flush"; + stream_id = 0; + fields := struct { + tracing_clock_int_t duration; + }; +}; diff --git a/tools/make-version-header.sh b/tools/make-version-header.sh index fe4549d2..b91fba6c 100755 --- a/tools/make-version-header.sh +++ b/tools/make-version-header.sh @@ -41,7 +41,7 @@ esac major="`echo "$version" | sed -n -e '1s/^\([0-9]*\)\..*/\1/p'`" minor="`echo "$version" | sed -n -e '1s/^[0-9]*\.0*\([0-9]*\).*/\1/p'`" patchlvl="`echo "$version" | sed -n -e '1s/^[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/p'`" -suffix="`echo "$version" | sed -n -e '1s/^[^+]*+\(.*\)/\1/p'`" +suffix="`echo "$version" | sed -n -e '1s/^[^+~]*[+~]\(.*\)/\1/p'`" echo "#define OCAML_VERSION_MAJOR $major" printf '#define OCAML_VERSION_MINOR %d\n' "$minor" diff --git a/tools/objinfo.ml b/tools/objinfo.ml index 40826f48..d2a01995 100644 --- a/tools/objinfo.ml +++ b/tools/objinfo.ml @@ -20,7 +20,6 @@ open Printf open Misc -open Config open Cmo_format (* Command line options to prevent printing approximation, @@ -30,6 +29,8 @@ let no_approx = ref false let no_code = ref false let no_crc = ref false +module Magic_number = Misc.Magic_number + let input_stringlist ic len = let get_string_list sect len = let rec fold s e acc = @@ -86,10 +87,10 @@ let print_cma_infos (lib : Cmo_format.library) = (* PR#4949: print in linking order *) List.iter print_spaced_string (List.rev lib.lib_ccobjs); printf "\nExtra C options:"; - List.iter print_spaced_string lib.lib_ccopts; + List.iter print_spaced_string (List.rev lib.lib_ccopts); printf "\n"; print_string "Extra dynamically-loaded libraries:"; - List.iter print_spaced_string lib.lib_dllibs; + List.iter print_spaced_string (List.rev lib.lib_dllibs); printf "\n"; List.iter print_cmo_infos lib.lib_units @@ -178,7 +179,7 @@ let print_cmxa_infos (lib : Cmx_format.library_infos) = printf "Extra C object files:"; List.iter print_spaced_string (List.rev lib.lib_ccobjs); printf "\nExtra C options:"; - List.iter print_spaced_string lib.lib_ccopts; + List.iter print_spaced_string (List.rev lib.lib_ccopts); printf "\n"; List.iter print_cmx_infos lib.lib_units @@ -242,90 +243,154 @@ let dump_byte ic = ) toc -let read_dyn_header filename ic = +let find_dyn_offset filename = let helper = Filename.concat Config.standard_library "objinfo_helper" in let tempfile = Filename.temp_file "objinfo" ".out" in - try - try_finally - ~always:(fun () -> remove_file tempfile) + match + Fun.protect + ~finally:(fun () -> remove_file tempfile) (fun () -> - let rc = Sys.command (sprintf "%s %s > %s" - (Filename.quote helper) - (Filename.quote filename) - tempfile) in + let rc = + Sys.command + (Filename.quote_command helper ~stdout:tempfile [filename]) + in if rc <> 0 then failwith "cannot read"; let tc = Scanf.Scanning.from_file tempfile in - try_finally - ~always:(fun () -> Scanf.Scanning.close_in tc) + Fun.protect + ~finally:(fun () -> Scanf.Scanning.close_in tc) (fun () -> - let ofs = Scanf.bscanf tc "%Ld" (fun x -> x) in - LargeFile.seek_in ic ofs; - Some(input_value ic : dynheader))) - with Failure _ | Sys_error _ -> None + Scanf.bscanf tc "%Ld" (fun x -> x))) + with + | offset -> Some offset + | exception (Failure _ | Sys_error _) -> None + +let exit_err msg = print_endline msg; exit 2 +let exit_errf fmt = Printf.ksprintf exit_err fmt + +let exit_magic_msg msg = + exit_errf + "Wrong magic number:\n\ + this tool only supports object files produced by compiler version\n\ + \t%s\n\ + %s" + Sys.ocaml_version msg + +let exit_magic_error ~expected_kind err = + exit_magic_msg Magic_number.(match err with + | Parse_error err -> explain_parse_error expected_kind err + | Unexpected_error err -> explain_unexpected_error err) + +(* assume that 'ic' is already positioned at the right place + depending on the format (usually right after the magic number, + but Exec and Cmxs differ) *) +let dump_obj_by_kind filename ic obj_kind = + let open Magic_number in + match obj_kind with + | Cmo -> + let cu_pos = input_binary_int ic in + seek_in ic cu_pos; + let cu = (input_value ic : compilation_unit) in + close_in ic; + print_cmo_infos cu + | Cma -> + let toc_pos = input_binary_int ic in + seek_in ic toc_pos; + let toc = (input_value ic : library) in + close_in ic; + print_cma_infos toc + | Cmi | Cmt -> + close_in ic; + let cmi, cmt = Cmt_format.read filename in + begin match cmi with + | None -> () + | Some cmi -> + print_cmi_infos cmi.Cmi_format.cmi_name cmi.Cmi_format.cmi_crcs + end; + begin match cmt with + | None -> () + | Some cmt -> print_cmt_infos cmt + end + | Cmx _config -> + let ui = (input_value ic : unit_infos) in + let crc = Digest.input ic in + close_in ic; + print_cmx_infos (ui, crc) + | Cmxa _config -> + let li = (input_value ic : library_infos) in + close_in ic; + print_cmxa_infos li + | Exec -> + (* no assumptions on [ic] position, + [dump_byte] will seek at the right place *) + dump_byte ic; + close_in ic + | Cmxs -> + (* we assume we are at the offset of the dynamic information, + as returned by [find_dyn_offset]. *) + let header = (input_value ic : dynheader) in + close_in ic; + print_cmxs_infos header; + | Ast_impl | Ast_intf -> + exit_errf "The object file type %S \ + is currently unsupported by this tool." + (human_name_of_kind obj_kind) let dump_obj filename = - printf "File %s\n" filename; - let ic = open_in_bin filename in - let len_magic_number = String.length cmo_magic_number in - let magic_number = really_input_string ic len_magic_number in - if magic_number = cmo_magic_number then begin - let cu_pos = input_binary_int ic in - seek_in ic cu_pos; - let cu = (input_value ic : compilation_unit) in - close_in ic; - print_cmo_infos cu - end else if magic_number = cma_magic_number then begin - let toc_pos = input_binary_int ic in - seek_in ic toc_pos; - let toc = (input_value ic : library) in - close_in ic; - print_cma_infos toc - end else if magic_number = cmi_magic_number || - magic_number = cmt_magic_number then begin - close_in ic; - let cmi, cmt = Cmt_format.read filename in - begin match cmi with - | None -> () - | Some cmi -> - print_cmi_infos cmi.Cmi_format.cmi_name cmi.Cmi_format.cmi_crcs - end; - begin match cmt with - | None -> () - | Some cmt -> print_cmt_infos cmt - end - end else if magic_number = cmx_magic_number then begin - let ui = (input_value ic : unit_infos) in - let crc = Digest.input ic in - close_in ic; - print_cmx_infos (ui, crc) - end else if magic_number = cmxa_magic_number then begin - let li = (input_value ic : library_infos) in - close_in ic; - print_cmxa_infos li - end else begin - let pos_trailer = in_channel_length ic - len_magic_number in + let open Magic_number in + let dump_standard ic = + match read_current_info ~expected_kind:None ic with + | Error ((Unexpected_error _) as err) -> + exit_magic_error ~expected_kind:None err + | Ok { kind; version = _ } -> + dump_obj_by_kind filename ic kind; + Ok () + | Error (Parse_error head_error) -> + Error head_error + and dump_exec ic = + let pos_trailer = in_channel_length ic - Magic_number.magic_length in let _ = seek_in ic pos_trailer in - let magic_number = really_input_string ic len_magic_number in - if magic_number = Config.exec_magic_number then begin - dump_byte ic; - close_in ic - end else if Filename.check_suffix filename ".cmxs" then begin - flush stdout; - match read_dyn_header filename ic with + let expected_kind = Some Exec in + match read_current_info ~expected_kind ic with + | Error ((Unexpected_error _) as err) -> + exit_magic_error ~expected_kind err + | Ok _ -> + dump_obj_by_kind filename ic Exec; + Ok () + | Error (Parse_error _) -> + Error () + and dump_cmxs ic = + flush stdout; + match find_dyn_offset filename with | None -> - printf "Unable to read info on file %s\n" filename; - exit 2 - | Some header -> - if header.dynu_magic = Config.cmxs_magic_number then - print_cmxs_infos header - else begin - printf "Wrong magic number\n"; exit 2 - end; - close_in ic - end else begin - printf "Not an OCaml object file\n"; exit 2 - end - end + exit_errf "Unable to read info on %s %s." + (human_name_of_kind Cmxs) filename + | Some offset -> + LargeFile.seek_in ic offset; + let header = (input_value ic : dynheader) in + let expected_kind = Some Cmxs in + match parse header.dynu_magic with + | Error err -> + exit_magic_error ~expected_kind (Parse_error err) + | Ok info -> + match check_current Cmxs info with + | Error err -> + exit_magic_error ~expected_kind (Unexpected_error err) + | Ok () -> + LargeFile.seek_in ic offset; + dump_obj_by_kind filename ic Cmxs; + () + in + printf "File %s\n" filename; + let ic = open_in_bin filename in + match dump_standard ic with + | Ok () -> () + | Error head_error -> + match dump_exec ic with + | Ok () -> () + | Error () -> + if Filename.check_suffix filename ".cmxs" + then dump_cmxs ic + else exit_magic_error ~expected_kind:None (Parse_error head_error) let arg_list = [ "-no-approx", Arg.Set no_approx, diff --git a/tools/ocaml-instr-graph b/tools/ocaml-instr-graph deleted file mode 100755 index edf2d363..00000000 --- a/tools/ocaml-instr-graph +++ /dev/null @@ -1,116 +0,0 @@ -#!/usr/bin/env bash - -#************************************************************************** -#* * -#* OCaml * -#* * -#* Damien Doligez, Jane Street Group, LLC * -#* * -#* Copyright 2015 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. * -#* * -#************************************************************************** - -# Use this script on OCAML_INSTR_FILE files - -default_curves=major,minor,coll,dispatch - -usage () { - echo 'usage: ocaml-instr-graph file [options]' - echo ' options:' - echo " -d names plot the data for names (default: $default_curves)" - echo ' -t title set the graph title' - echo ' -m n clip the values to n (default 1G)' - echo ' -rt n set the range for times to 0..n' - echo ' -rn n set the range for counts to 0..n' - echo ' -from t start at time t' - echo ' -to t stop at time t' - echo ' -help display this help message and exit' -} - -datafile= -curves=, -title= -titleset=false -max=1000000000 -ranget= -rangen= -from=0 -to=1e19 - -while [[ $# > 0 ]]; do - case $1 in - -d) curves=$curves$2,; shift 2;; - -t) title=$2; titleset=true; shift 2;; - -m) max=$2; shift 2;; - -rt) ranget="set yrange [0:$2]"; shift 2;; - -rn) rangen="set y2range [0:$2]"; shift 2;; - -from) from=$2; shift 2;; - -to) to=$2; shift 2;; - -help) usage; exit 0;; - *) datafile=$1; shift 1;; - esac -done - -if [[ "$curves" = , ]]; then - curves=,$default_curves, -fi - -if ! $titleset; then - title=$datafile -fi - -tmpfile=/tmp/ocaml-instr-graph.$$ - -rm -f $tmpfile-* - -awk -v curves="$curves" -v clip=$max -v tmpfile="$tmpfile" -v from=$from \ - -v to=$to ' - function output (filename){ - time = ($2 - starttime) / 1e9; - if (time < from || time >= to) return; - if (index(curves, "," filename ",") != 0){ - gsub (/\//,":",filename); - if (filename ~ /#/){ - point = $3; - }else{ - point = ($3 - $2) / 1000; - } - if (point > clip) point = clip; - printf ("%.6f %.3f\n", time, point) >> tmpfile "-" filename; - } - } - BEGIN {starttime = 9e18;} - $1 != "@@" { next; } - $2 < starttime { starttime = $2 } - { output($4); } -' $datafile - -( echo set title \"$title\" - echo set key left top - echo set ytics nomirror - echo 'set format y "%gus"' - echo "$ranget" - echo "$rangen" - echo set y2tics nomirror - echo 'set format x "%gs"' - printf "plot " - for curve in ${curves//,/ }; do - f=$tmpfile-${curve//\//:} - if [ -f $f ]; then - case $f in - *#) printf "\"%s\" using 1:2 axes x1y2 title '%s', " "$f" \ - "$curve" - ;; - *) printf "\"%s\" using 1:2 title '%s', " "$f" "$curve";; - esac - fi - done - printf "\n" -) | gnuplot -p - -rm -f $tmpfile-* diff --git a/tools/ocaml-instr-report b/tools/ocaml-instr-report deleted file mode 100755 index bac4f6ba..00000000 --- a/tools/ocaml-instr-report +++ /dev/null @@ -1,162 +0,0 @@ -#!/bin/awk -f - -#************************************************************************** -#* * -#* OCaml * -#* * -#* Damien Doligez, Jane Street Group, LLC * -#* * -#* Copyright 2014 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. * -#* * -#************************************************************************** - -# usage: -# ocaml-instr-report { file ... } -# generate a report from the data files (or stdin if no file is given) - -function short(n, kind, i, r){ - for (i = 0; i < 5; i++){ - if (n < 1000) break; - n /= 1000; - } - r = sprintf ("%f", n); - if (index(r, ".") == 3){ - r = substr(r, 1, 2); - }else{ - r = substr(r, 1, 3); - } - return sprintf("%s%s", r, units[kind,i]); -} - -function add(limit){ - lim[nscales] = limit; - scale["t",nscales] = short(limit, "t"); - scale["n",nscales] = short(limit, "n"); - ++ nscales; -} - -# kind is "t" (for timer) or "n" (for number) -# events are simply a special kind of timer - -BEGIN { - units["t",0] = "ns"; - units["t",1] = "us"; - units["t",2] = "ms"; - units["t",3] = "s"; - units["t",4] = "ks"; - units["t",5] = "Ms"; - - units["n",0] = ""; - units["n",1] = "k"; - units["n",2] = "M"; - units["n",3] = "G"; - units["n",4] = "T"; - units["n",5] = "P"; - - nscales=0; - add(0); - for (mul = 100; mul < 10000000000; mul *= 10){ - add(mul); - add(2.2 * mul); - add(4.7 * mul); - } -} - -function store(value, tag) { - ++ total[tag]; - for (i = 0; i < nscales; i++){ - if (value <= lim[i]){ - ++ bin[tag, lim[i]]; - val[tag, lim[i]] = value; - return; - } - } - ++ bin[tag, "off-scale"]; - val[tag, "off-scale"] = value; -} - -$1 == "@@" && $4 ~ /@/ { total[$4] += $3; } - -$1 == "@@" && $4 ~ /#/ { store($3, $4); } - -$1 == "@@" { store($3 - $2, $4); } - -function display(n, val, kind, i) { - graph_width = 35; - - if (n > 0){ - for (i = 0; i < log (n) / log (2); i++){ - printf("#"); - } - if (n == 1){ - printf(" %-6d", n); - printf ("%-*s", graph_width - 7 - i, - sprintf("(%s)", short(val, kind))); - }else{ - printf(" %-*d", graph_width - 1 - i, n); - } - }else{ - printf("%*s", graph_width, ""); - } -} - -END { - n = asorti(total,tags); - total_alloc = 0; - for (i = 1; i <= n; i++){ - t = tags[i]; - if (t ~ /^alloc/) total_alloc += total[t]; - } - for (i = 1; i <= n; i++){ - t = tags[i]; - if (t ~ /#/){ - kind = "n"; # number - }else if (t ~ /@/){ - kind = "e"; # event - }else{ - kind = "t"; # timer - } - if (kind == "e"){ - printf ("==== %-12s:%9d", t, total[t]); - if (t ~ /^alloc/){ - cumul += total[t] / total_alloc; - printf(" (%6.2f%%)", cumul * 100); - } - printf ("\n"); - continue; - }else{ - printf ("==== %s: %d\n", t, total[t]); - } - num = bin[t,0]; - found = num; - if (num == total[t] && kind == "t"){ - /* nothing */ - }else if (num > 0){ - printf (" 0: "); - display(bin[t,0], val[t, 0], kind); - printf ("%6.2f%%\n", found * 100 / total[t]); - } - for (j = 1; j < nscales; j++){ - if (found == total[t]) break; - num = bin [t, lim[j]]; - found += num; - if (found > 0){ - printf ("%5s..%-5s: ", scale[kind,j-1], scale[kind,j]); - display(num, val[t, lim[j]], kind); - printf ("%6.2f%%\n", found * 100 / total[t]); - } - } - num = bin[t, "off-scale"]; - if (num != 0){ - printf (" off scale : "); - display(bin[t, "off-scale"], val[t, "off-scale"]); - printf ("\n"); - } - printf ("====\n"); - } -} diff --git a/tools/read_cmt.ml b/tools/read_cmt.ml index 0e3cfbc2..ae6b97fd 100644 --- a/tools/read_cmt.ml +++ b/tools/read_cmt.ml @@ -97,6 +97,64 @@ let print_info cmt = end; () +let generate_ml target_filename filename cmt = + let (printer, ext) = + match cmt.Cmt_format.cmt_annots with + | Cmt_format.Implementation typedtree -> + (fun ppf -> Pprintast.structure ppf + (Untypeast.untype_structure typedtree)), + ".ml" + | Cmt_format.Interface typedtree -> + (fun ppf -> Pprintast.signature ppf + (Untypeast.untype_signature typedtree)), + ".mli" + | _ -> + Printf.fprintf stderr "File was generated with an error\n%!"; + exit 2 + in + let target_filename = match target_filename with + None -> Some (filename ^ ext) + | Some "-" -> None + | Some _ -> target_filename + in + let oc = match target_filename with + None -> None + | Some filename -> Some (open_out filename) in + let ppf = match oc with + None -> Format.std_formatter + | Some oc -> Format.formatter_of_out_channel oc in + printer ppf; + Format.pp_print_flush ppf (); + match oc with + None -> flush stdout + | Some oc -> close_out oc + +(* Save cmt information as faked annotations, attached to + Location.none, on top of the .annot file. Only when -save-cmt-info is + provided to ocaml_cmt. +*) +let record_cmt_info cmt = + let location_none = { + Location.none with Location.loc_ghost = false } + in + let location_file file = { + Location.none with + Location.loc_start = { + Location.none.Location.loc_start with + Lexing.pos_fname = file }} + in + let record_info name value = + let ident = Printf.sprintf ".%s" name in + Stypes.record (Stypes.An_ident (location_none, ident, + Annot.Idef (location_file value))) + in + let open Cmt_format in + (* record in reverse order to get them in correct order... *) + List.iter (fun dir -> record_info "include" dir) (List.rev cmt.cmt_loadpath); + record_info "chdir" cmt.cmt_builddir; + (match cmt.cmt_sourcefile with + None -> () | Some file -> record_info "source" file) + let main () = Clflags.annotations := true; @@ -105,12 +163,25 @@ let main () = Filename.check_suffix filename ".cmt" || Filename.check_suffix filename ".cmti" then begin + let open Cmt_format in Compmisc.init_path (); - let cmt = Cmt_format.read_cmt filename in - if !gen_annot then - Cmt2annot.gen_annot ~save_cmt_info: !save_cmt_info - !target_filename filename cmt; - if !gen_ml then Cmt2annot.gen_ml !target_filename filename cmt; + let cmt = read_cmt filename in + if !gen_annot then begin + if !save_cmt_info then record_cmt_info cmt; + let target_filename = + match !target_filename with + | None -> Some (filename ^ ".annot") + | Some "-" -> None + | Some _ as x -> x + in + Envaux.reset_cache (); + List.iter Load_path.add_dir (List.rev cmt.cmt_loadpath); + Cmt2annot.gen_annot target_filename + ~sourcefile:cmt.cmt_sourcefile + ~use_summaries:cmt.cmt_use_summaries + cmt.cmt_annots + end; + if !gen_ml then generate_ml !target_filename filename cmt; if !print_info_arg || not (!gen_ml || !gen_annot) then print_info cmt; end else begin Printf.fprintf stderr diff --git a/tools/release-checklist b/tools/release-checklist index 4da54b40..aab3d95d 100644 --- a/tools/release-checklist +++ b/tools/release-checklist @@ -14,8 +14,9 @@ release". ## A few days in advance -Send a mail on caml-devel to warn Gabriel (to make a pass on Changes) -and the OCamlLabs folks (for OPAM testing). +Send a mail on caml-devel to warn Gabriel (to make a pass on Changes; +see the "Changes curation" appendix for more details) and the +OCamlLabs folks (for OPAM testing). ## 0: release environment setup @@ -106,7 +107,7 @@ make tests # 4.07.0+dev8-2018-06-19 => 4.07.0+dev9-2018-06-26 # for production releases: check and change the Changes header # (remove "next version" and add a date) -./autogen +make -B configure git commit -a -m "last commit before tagging $VERSION" # update VERSION with the new release; for example, @@ -114,7 +115,7 @@ git commit -a -m "last commit before tagging $VERSION" # Update ocaml-variants.opam with new version. # Update \year in manual/manual/macros.hva rm -r autom4te.cache -./autogen +make -B configure make coreboot -j5 make coreboot -j5 # must say "Fixpoint reached, bootstrap succeeded." git commit -m "release $VERSION" -a @@ -126,12 +127,50 @@ git tag -m "release $VERSION" $VERSION # 4.07.0+rc2 => 4.07.0+dev10-2018-06-26 # Revert ocaml-variants.opam to its "trunk" version. rm -r autom4te.cache -./autogen +make -B configure git commit -m "increment version number after tagging $VERSION" VERSION configure ocaml-variants.opam git push git push --tags ``` +## 5-bis: Alternative for branching + +This needs to be more tested, tread with care. +``` +# at this point, the VERSION file contains N+devD +# increment it into N+dev(D+1); for example, +# 4.07.0+dev0-2018-06-19 => 4.07.0+dev1-2018-06-26 +# Rename the "Working version" header in Changes +# to "OCaml $BRANCH" +make -B configure +git commit -a -m "last commit before branching $BRANCH" +git branch $BRANCH + +# update VERSION with the new future branch, +# 4.07.0+dev1-2018-06-26 => 4.08.0+dev0-2018-06-30 +# Update ocaml-variants.opam with new version. +make -B configure +# Add a "Working version" section" to Changes +# Add common subsections in Changes, see Changelog. +git commit -m "first commit after branching $VERSION" -a +git push + +# Switch to the new branch +git checkout $VERSION +# increment VERSION, for instance +# 4.07.0+dev1-2018-06-26 => 4.07.0+dev2-2018-06-30 +make -B configure +git commit -m "first commit on branch $VERSION" -a +git push $VERSION +``` + +Adjust github branch settings: + +Go to + https://github.com/ocaml/ocaml/settings/branches +and add a rule for protecting the new branch +(copy the rights from the previous version) + ## 5.1: create the release on github (only for a production release) open https://github.com/ocaml/ocaml/releases @@ -139,6 +178,16 @@ open https://github.com/ocaml/ocaml/releases # for a minor release, the description is: Bug fixes. See [detailed list of changes](https://github.com/ocaml/ocaml/blob/$MAJOR.$MINOR/Changes). +## 5.3: Inria CI (for a new release branch) + +Add the new release branch to the Inria CI list. +Remove the oldest branch from this list. + +## 5.4 new badge in README.adoc (for a new release branch) + +Add a badge for the new branch in README.adoc. +Remove any badge that tracks a version older than Debian stable. + ## 6: create OPAM packages @@ -149,6 +198,18 @@ Do not forget to add/update the checksum field for the tarballs in the "url" section of the opam files. Use opam-lint before sending the pull request. +## 6.1 Update OPAM dev packages after branching + +Create a new ocaml/ocaml.$NEXT/opam file. +Copy the opam dev files from ocaml-variants/ocaml-variants.$VERSION+trunk* +into ocaml-variants/ocaml-variants.$NEXT+trunk+* . +Update the version in those opam files. + +Update the synopsis and "src" field in the opam $VERSION packages. +The "src" field should point to + src: "https://github.com/ocaml/ocaml/archive/$VERSION.tar.gz" +The synopsis should be "latest $VERSION development(,...)". + ## 7: build the release archives ``` @@ -286,7 +347,7 @@ See the email announce templates at the end of this file. -# Announces +# Appendix ## Announcing a production release: @@ -386,3 +447,148 @@ Happy hacking, -- Damien Doligez for the OCaml team. ``` + +## Changelog template for a new version + +A list of common subsection for the "Changes" file: + +``` +### Language features + +### Runtime system: + +### Code generation and optimizations: + +### Standard library: + +### Other libraries: + +### Tools: + +### Manual and documentation: + +### Compiler user-interface and warnings: + +### Internal/compiler-libs changes: + +### Build system: + +### Bug fixes: +``` + + +## Changes curation + +Here is the process that Gabriel uses to curate the Changes entries of +a release in preparation. Feel free to take care of it if you wish. + +(In theory it would be possible to maintain the Changes in excellent + shape so that no curation would be necessary. In practice it is less + work and less friction to tolerate imperfect Changes entries, and + curate them before the release.) + +### Synchronizing the trunk Changes with release branches + +The Changes entries of a release branch or past release should be +exactly included in the trunk Changes, in the section of this release +(or release branch). Use an interactive diffing tool (for example +"meld") to compare and synchronize the Changes files of trunk and +release branches. + +Here are typical forms of divergence and their usual solutions: + +- A change entry is present in a different section in two branches. + (Typically: in the XX.YY section of the XX.YY release branch, + but in the trunk section of the trunk branch.) + + This usually happens when the PR is written for a given branch + first, and then cherry-picked in an older maintenance branch, but + the cherry-picker forgets to move the Change entry in the first + branch. + + Fix: ensure that the entry is in the same section on all branches, + by putting it in the "smallest" version -- assuming that all bigger + versions also contain this cange. + +- A change entry is present in a given section, but the change is not + present in the corresponding release branch. + + There are two common causes for this with radically different solutions: + + + If a PR is merged a long time after they were submitted, the merge + may put their Changes entry in the section of an older release, + while it should go in trunk. + + Fix: in trunk, move the entry to the trunk section. + + + Sometimes the author of a PR against trunk intends it to be + cherry-picked in an older release branch, and places it in the + corresponding Changes entry, but we forget to cherry-pick. + + Fix: cherry-pick the PR in the appropriate branch. + + Reading the PR discussion is often enough to distinguish between the + two cases, but one should be careful before cherry-picking in + a branch (for an active release branch, check with the release + manager(s)). + +Figuring out the status of a given Changes entry often requires +checking the git log for trunk and branches. Grepping for the PR +number often suffices (note: when you cherry-pick a PR in a release +branch, please target the merge commit to ensure the PR number is +present in the log), or parts of the commit message text. + +### Ensure each entry is in the appropriate section + +(of course) + +### Fill more details in unclear Changes entries + +Expert users want to learn about the changes in the new release. We +want to avoid forcing them to read the tortuous PR discussion, by +giving enough details in the Changes entry. + +In particular, for language changes, showing a small example of +concrete syntax of the new feature is very useful, and giving a few +words of explanations helps. + +Compare for example + + - #8820: quoted string extensions + (Gabriel Radanne, Leo White and Gabriel Scherer, + request by Bikal Lem) + +with + + - #8820: quoted extensions: {%foo|...|} is lighter syntax for + [%foo {||}], and {%foo bar|...|bar} for [%foo {bar|...|bar}]. + (Gabriel Radanne, Leo White and Gabriel Scherer, + request by Bikal Lem) + +This is also important for changes that break compatibility; users +will scrutinize them with more care, so please give clear information on +what breaks and, possibly, recommended update methods. + +Having enough details is also useful when you will grep the Changes +later to know when a given change was introduced (knowing what to grep +can be difficult). + +### Ordering of Changes entries + +In the past, we would order Changes entries numerically (this would +also correspond to a chronological order). Since 4.09 Gabriel is +trying to order them by importance (being an exciting/notable feature +for a large number of users). What is the best ordering of sections, +and the best entry ordering within a section, to put the most +important changes first? This is guesswork of course, and we commonly +have a long tail of "not so important PRs" in each section which don't +need to be ordered with respect to each other -- one may break two +lines just before this long tail. + +The ordering of sections depends on the nature of the changes within +the release; some releases have an exciting "Runtime" section, many +release don't. Usually "Language features" is among the first, and +"Bug fixes" is the very last (who cares about bugs, right?). + +If some entries feel very anecdotal, consider moving them to the Bug +Fixes section. diff --git a/toplevel/genprintval.ml b/toplevel/genprintval.ml index b8650375..27ee2425 100644 --- a/toplevel/genprintval.ml +++ b/toplevel/genprintval.ml @@ -547,10 +547,15 @@ module Make(O : OBJ)(EVP : EVALPATH with type valu = O.t) = struct else O.field bucket 0 in let name = (O.obj(O.field slot 0) : string) in - let lid = Longident.parse name in try (* Attempt to recover the constructor description for the exn from its name *) + let lid = + try Parse.longident (Lexing.from_string name) with + (* The syntactic class for extension constructor names + is an extended form of constructor "Longident.t"s + that also includes module application (e.g [F(X).A]) *) + | Syntaxerr.Error _ | Lexer.Error _ -> raise Not_found in let cstr = Env.find_constructor_by_name lid env in let path = match cstr.cstr_tag with diff --git a/toplevel/opttopdirs.ml b/toplevel/opttopdirs.ml index 967c236c..b8e1c012 100644 --- a/toplevel/opttopdirs.ml +++ b/toplevel/opttopdirs.ml @@ -115,8 +115,11 @@ let _ = Hashtbl.add directive_table "load" (Directive_string (dir_load std_out)) (* Load commands from a file *) let dir_use ppf name = ignore(Opttoploop.use_file ppf name) +let dir_use_output ppf name = ignore(Opttoploop.use_output ppf name) let _ = Hashtbl.add directive_table "use" (Directive_string (dir_use std_out)) +let _ = Hashtbl.add directive_table "use_output" + (Directive_string (dir_use_output std_out)) (* Install, remove a printer *) diff --git a/toplevel/opttopdirs.mli b/toplevel/opttopdirs.mli index 01d13569..e7043352 100644 --- a/toplevel/opttopdirs.mli +++ b/toplevel/opttopdirs.mli @@ -23,6 +23,7 @@ val dir_remove_directory : string -> unit val dir_cd : string -> unit val dir_load : formatter -> string -> unit val dir_use : formatter -> string -> unit +val dir_use_output : formatter -> string -> unit val dir_install_printer : formatter -> Longident.t -> unit val dir_remove_printer : formatter -> Longident.t -> unit diff --git a/toplevel/opttoploop.ml b/toplevel/opttoploop.ml index c74f2147..6c5e10b3 100644 --- a/toplevel/opttoploop.ml +++ b/toplevel/opttoploop.ml @@ -83,8 +83,8 @@ let close_phrase lam = let glb, pos = toplevel_value id in let glob = Lprim (Pfield pos, - [Lprim (Pgetglobal glb, [], Location.none)], - Location.none) + [Lprim (Pgetglobal glb, [], Loc_unknown)], + Loc_unknown) in Llet(Strict, Pgenval, id, glob, l) ) (free_variables lam) lam @@ -335,8 +335,7 @@ let execute_phrase print_outcome ppf phr = let (str, sg, names, newenv) = Typemod.type_toplevel_phrase oldenv sstr in if !Clflags.dump_typedtree then Printtyped.implementation ppf str; let sg' = Typemod.Signature_names.simplify newenv names sg in - (* Why is this done? *) - ignore (Includemod.signatures oldenv sg sg'); + ignore (Includemod.signatures oldenv ~mark:Mark_positive sg sg'); Typecore.force_delayed_checks (); let module_ident, res, required_globals, size = if Config.flambda then @@ -360,7 +359,7 @@ let execute_phrase print_outcome ppf phr = | Result _ -> if Config.flambda then (* CR-someday trefis: *) - () + Env.register_import_as_opaque (Ident.name module_ident) else Compilenv.record_global_approx_toplevel (); if print_outcome then @@ -449,43 +448,66 @@ let preprocess_phrase ppf phr = if !Clflags.dump_source then Pprintast.top_phrase ppf phr; phr -let use_file ppf wrap_mod name = - try - let (filename, ic, must_close) = - if name = "" then - ("(stdin)", stdin, false) - else begin - let filename = Load_path.find name in - let ic = open_in_bin filename in - (filename, ic, true) - end - in - let lb = Lexing.from_channel ic in - Location.init lb filename; - (* Skip initial #! line if any *) - Lexer.skip_hash_bang lb; - let success = - protect_refs [ R (Location.input_name, filename) ] (fun () -> - try - List.iter - (fun ph -> - let ph = preprocess_phrase ppf ph in - if not (execute_phrase !use_print_results ppf ph) then raise Exit) - (if wrap_mod then - parse_mod_use_file name lb - else - !parse_use_file lb); - true - with - | Exit -> false - | Sys.Break -> fprintf ppf "Interrupted.@."; false - | x -> Location.report_exception ppf x; false) in - if must_close then close_in ic; - success - with Not_found -> fprintf ppf "Cannot find file %s.@." name; false - -let mod_use_file ppf name = use_file ppf true name -let use_file ppf name = use_file ppf false name +let use_channel ppf ~wrap_in_module ic name filename = + let lb = Lexing.from_channel ic in + Location.init lb filename; + (* Skip initial #! line if any *) + Lexer.skip_hash_bang lb; + let success = + protect_refs [ R (Location.input_name, filename) ] (fun () -> + try + List.iter + (fun ph -> + let ph = preprocess_phrase ppf ph in + if not (execute_phrase !use_print_results ppf ph) then raise Exit) + (if wrap_in_module then + parse_mod_use_file name lb + else + !parse_use_file lb); + true + with + | Exit -> false + | Sys.Break -> fprintf ppf "Interrupted.@."; false + | x -> Location.report_exception ppf x; false) in + success + +let use_output ppf command = + let fn = Filename.temp_file "ocaml" "_toploop.ml" in + Misc.try_finally ~always:(fun () -> + try Sys.remove fn with Sys_error _ -> ()) + (fun () -> + match + Printf.ksprintf Sys.command "%s > %s" + command + (Filename.quote fn) + with + | 0 -> + let ic = open_in_bin fn in + Misc.try_finally ~always:(fun () -> close_in ic) + (fun () -> + use_channel ppf ~wrap_in_module:false ic "" "(command-output)") + | n -> + fprintf ppf "Command exited with code %d.@." n; + false) + +let use_file ppf ~wrap_in_module name = + match name with + | "" -> + use_channel ppf ~wrap_in_module stdin name "(stdin)" + | _ -> + match Load_path.find name with + | filename -> + let ic = open_in_bin filename in + Misc.try_finally ~always:(fun () -> close_in ic) + (fun () -> use_channel ppf ~wrap_in_module ic name filename) + | exception Not_found -> + fprintf ppf "Cannot find file %s.@." name; + false + +let mod_use_file ppf name = + use_file ppf ~wrap_in_module:true name +let use_file ppf name = + use_file ppf ~wrap_in_module:false name let use_silently ppf name = protect_refs [ R (use_print_results, false) ] (fun () -> use_file ppf name) diff --git a/toplevel/opttoploop.mli b/toplevel/opttoploop.mli index a9a15d50..8345ec29 100644 --- a/toplevel/opttoploop.mli +++ b/toplevel/opttoploop.mli @@ -55,6 +55,7 @@ val preprocess_phrase : (* Preprocess the given toplevel phrase using regular and ppx preprocessors. Return the updated phrase. *) val use_file : formatter -> string -> bool +val use_output : formatter -> string -> bool val use_silently : formatter -> string -> bool val mod_use_file : formatter -> string -> bool (* Read and execute commands from a file. diff --git a/toplevel/topdirs.ml b/toplevel/topdirs.ml index f4526692..530a927f 100644 --- a/toplevel/topdirs.ml +++ b/toplevel/topdirs.ml @@ -119,7 +119,11 @@ exception Load_failed let check_consistency ppf filename cu = try Env.import_crcs ~source:filename cu.cu_imports - with Persistent_env.Consistbl.Inconsistency(name, user, auth) -> + with Persistent_env.Consistbl.Inconsistency { + unit_name = name; + inconsistent_source = user; + original_source = auth; + } -> fprintf ppf "@[The files %s@ and %s@ \ disagree over interface %s@]@." user auth name; @@ -236,6 +240,7 @@ let load_file = load_file false (* Load commands from a file *) let dir_use ppf name = ignore(Toploop.use_file ppf name) +let dir_use_output ppf name = ignore(Toploop.use_output ppf name) let dir_mod_use ppf name = ignore(Toploop.mod_use_file ppf name) let _ = add_directive "use" (Directive_string (dir_use std_out)) @@ -244,6 +249,13 @@ let _ = add_directive "use" (Directive_string (dir_use std_out)) doc = "Read, compile and execute source phrases from the given file."; } +let _ = add_directive "use_output" (Directive_string (dir_use_output std_out)) + { + section = section_run; + doc = "Execute a command and read, compile and execute source phrases \ + from its output."; + } + let _ = add_directive "mod_use" (Directive_string (dir_mod_use std_out)) { section = section_run; @@ -251,7 +263,6 @@ let _ = add_directive "mod_use" (Directive_string (dir_mod_use std_out)) wraps the contents in a module."; } - (* Install, remove a printer *) let filter_arrow ty = @@ -549,11 +560,63 @@ let () = ) "Print the signature of the corresponding type constructor." +(* Each registered show_prim function is called in turn + * and any output produced is sent to std_out. + * Two show_prim functions are needed for constructors, + * one for exception constructors and another for + * non-exception constructors (normal and extensible variants). *) +let is_exception_constructor env type_expr = + Ctype.equal env true [type_expr] [Predef.type_exn] + +let is_extension_constructor = function + | Cstr_extension _ -> true + | _ -> false + +let () = + (* This show_prim function will only show constructor types + * that are not also exception types. *) + reg_show_prim "show_constructor" + (fun env loc id lid -> + let desc = Env.lookup_constructor ~loc Env.Positive lid env in + if is_exception_constructor env desc.cstr_res then + raise Not_found; + let path = + match Ctype.repr desc.cstr_res with + | {desc=Tconstr(path, _, _)} -> path + | _ -> raise Not_found + in + let type_decl = Env.find_type path env in + if is_extension_constructor desc.cstr_tag then + let ret_type = + if desc.cstr_generalized then Some desc.cstr_res + else None + in + let ext = + { ext_type_path = path; + ext_type_params = type_decl.type_params; + ext_args = Cstr_tuple desc.cstr_args; + ext_ret_type = ret_type; + ext_private = Asttypes.Public; + ext_loc = desc.cstr_loc; + ext_attributes = desc.cstr_attributes; + ext_uid = desc.cstr_uid; } + in + [Sig_typext (id, ext, Text_first, Exported)] + else + (* make up a fake Ident.t as type_decl : Types.type_declaration + * does not have an Ident.t yet. Ident.create_presistent is a + * good choice because it has no side-effects. + * *) + let type_id = Ident.create_persistent (Path.name path) in + [ Sig_type (type_id, type_decl, Trec_first, Exported) ] + ) + "Print the signature of the corresponding value constructor." + let () = reg_show_prim "show_exception" (fun env loc id lid -> let desc = Env.lookup_constructor ~loc Env.Positive lid env in - if not (Ctype.equal env true [desc.cstr_res] [Predef.type_exn]) then + if not (is_exception_constructor env desc.cstr_res) then raise Not_found; let ret_type = if desc.cstr_generalized then Some Predef.type_exn @@ -565,8 +628,10 @@ let () = ext_args = Cstr_tuple desc.cstr_args; ext_ret_type = ret_type; ext_private = Asttypes.Public; - Types.ext_loc = desc.cstr_loc; - Types.ext_attributes = desc.cstr_attributes; } + ext_loc = desc.cstr_loc; + ext_attributes = desc.cstr_attributes; + ext_uid = desc.cstr_uid; + } in [Sig_typext (id, ext, Text_exception, Exported)] ) diff --git a/toplevel/topdirs.mli b/toplevel/topdirs.mli index 1cdc2fa2..77d36600 100644 --- a/toplevel/topdirs.mli +++ b/toplevel/topdirs.mli @@ -23,6 +23,7 @@ val dir_remove_directory : string -> unit val dir_cd : string -> unit val dir_load : formatter -> string -> unit val dir_use : formatter -> string -> unit +val dir_use_output : formatter -> string -> unit val dir_install_printer : formatter -> Longident.t -> unit val dir_remove_printer : formatter -> Longident.t -> unit val dir_trace : formatter -> Longident.t -> unit diff --git a/toplevel/toploop.ml b/toplevel/toploop.ml index 93d6a70f..f2b3845a 100644 --- a/toplevel/toploop.ml +++ b/toplevel/toploop.ml @@ -275,7 +275,7 @@ let execute_phrase print_outcome ppf phr = let (str, sg, sn, newenv) = Typemod.type_toplevel_phrase oldenv sstr in if !Clflags.dump_typedtree then Printtyped.implementation ppf str; let sg' = Typemod.Signature_names.simplify newenv sn sg in - ignore (Includemod.signatures oldenv sg sg'); + ignore (Includemod.signatures ~mark:Mark_positive oldenv sg sg'); Typecore.force_delayed_checks (); let lam = Translmod.transl_toplevel_definition str in Warnings.check_fatal (); @@ -394,46 +394,67 @@ let preprocess_phrase ppf phr = if !Clflags.dump_source then Pprintast.top_phrase ppf phr; phr -let use_file ppf wrap_mod name = - try - let (filename, ic, must_close) = - if name = "" then - ("(stdin)", stdin, false) - else begin - let filename = Load_path.find name in - let ic = open_in_bin filename in - (filename, ic, true) - end - in - let lb = Lexing.from_channel ic in - Warnings.reset_fatal (); - Location.init lb filename; - (* Skip initial #! line if any *) - Lexer.skip_hash_bang lb; - let success = - protect_refs [ R (Location.input_name, filename); - R (Location.input_lexbuf, Some lb); ] - (fun () -> - try - List.iter - (fun ph -> - let ph = preprocess_phrase ppf ph in - if not (execute_phrase !use_print_results ppf ph) then raise Exit) - (if wrap_mod then - parse_mod_use_file name lb - else - !parse_use_file lb); - true - with - | Exit -> false - | Sys.Break -> fprintf ppf "Interrupted.@."; false - | x -> Location.report_exception ppf x; false) in - if must_close then close_in ic; - success - with Not_found -> fprintf ppf "Cannot find file %s.@." name; false - -let mod_use_file ppf name = use_file ppf true name -let use_file ppf name = use_file ppf false name +let use_channel ppf ~wrap_in_module ic name filename = + let lb = Lexing.from_channel ic in + Warnings.reset_fatal (); + Location.init lb filename; + (* Skip initial #! line if any *) + Lexer.skip_hash_bang lb; + protect_refs [ R (Location.input_name, filename); + R (Location.input_lexbuf, Some lb); ] + (fun () -> + try + List.iter + (fun ph -> + let ph = preprocess_phrase ppf ph in + if not (execute_phrase !use_print_results ppf ph) then raise Exit) + (if wrap_in_module then + parse_mod_use_file name lb + else + !parse_use_file lb); + true + with + | Exit -> false + | Sys.Break -> fprintf ppf "Interrupted.@."; false + | x -> Location.report_exception ppf x; false) + +let use_output ppf command = + let fn = Filename.temp_file "ocaml" "_toploop.ml" in + Misc.try_finally ~always:(fun () -> + try Sys.remove fn with Sys_error _ -> ()) + (fun () -> + match + Printf.ksprintf Sys.command "%s > %s" + command + (Filename.quote fn) + with + | 0 -> + let ic = open_in_bin fn in + Misc.try_finally ~always:(fun () -> close_in ic) + (fun () -> + use_channel ppf ~wrap_in_module:false ic "" "(command-output)") + | n -> + fprintf ppf "Command exited with code %d.@." n; + false) + +let use_file ppf ~wrap_in_module name = + match name with + | "" -> + use_channel ppf ~wrap_in_module stdin name "(stdin)" + | _ -> + match Load_path.find name with + | filename -> + let ic = open_in_bin filename in + Misc.try_finally ~always:(fun () -> close_in ic) + (fun () -> use_channel ppf ~wrap_in_module ic name filename) + | exception Not_found -> + fprintf ppf "Cannot find file %s.@." name; + false + +let mod_use_file ppf name = + use_file ppf ~wrap_in_module:true name +let use_file ppf name = + use_file ppf ~wrap_in_module:false name let use_silently ppf name = protect_refs [ R (use_print_results, false) ] (fun () -> use_file ppf name) diff --git a/toplevel/toploop.mli b/toplevel/toploop.mli index b78de712..45a43bc3 100644 --- a/toplevel/toploop.mli +++ b/toplevel/toploop.mli @@ -75,6 +75,7 @@ val preprocess_phrase : (* Preprocess the given toplevel phrase using regular and ppx preprocessors. Return the updated phrase. *) val use_file : formatter -> string -> bool +val use_output : formatter -> string -> bool val use_silently : formatter -> string -> bool val mod_use_file : formatter -> string -> bool (* Read and execute commands from a file. diff --git a/typing/TODO.md b/typing/TODO.md index ebd0f999..c1151161 100644 --- a/typing/TODO.md +++ b/typing/TODO.md @@ -79,9 +79,6 @@ consensus for all of them. - Track "string literals" in the type-checker, which often act as magic "internal" names which should be avoided. -- Get rid of -annot. - (see Nicolas' PR) - - Consider storing warning settings (+other context) as part of `Env.t`? - Parse attributes understood (e.g. the deprecated attribute) by the diff --git a/typing/btype.ml b/typing/btype.ml index f3c3dd2a..bec31496 100644 --- a/typing/btype.ml +++ b/typing/btype.ml @@ -691,10 +691,12 @@ let prefixed_label_name = function | Optional s -> "?" ^ s let rec extract_label_aux hd l = function - [] -> raise Not_found + | [] -> None | (l',t as p) :: ls -> - if label_name l' = l then (l', t, List.rev hd, ls) - else extract_label_aux (p::hd) l ls + if label_name l' = l then + Some (l', t, hd <> [], List.rev_append hd ls) + else + extract_label_aux (p::hd) l ls let extract_label l ls = extract_label_aux [] l ls diff --git a/typing/btype.mli b/typing/btype.mli index 6fe22127..7c215ed9 100644 --- a/typing/btype.mli +++ b/typing/btype.mli @@ -205,8 +205,11 @@ val prefixed_label_name : arg_label -> label val extract_label : label -> (arg_label * 'a) list -> - arg_label * 'a * (arg_label * 'a) list * (arg_label * 'a) list - (* actual label, value, before list, after list *) + (arg_label * 'a * bool * (arg_label * 'a) list) option +(* actual label, + value, + whether (label, value) was at the head of the list, + list without the extracted (label, value) *) (**** Utilities for backtracking ****) diff --git a/typing/cmt2annot.ml b/typing/cmt2annot.ml new file mode 100644 index 00000000..40ee752e --- /dev/null +++ b/typing/cmt2annot.ml @@ -0,0 +1,184 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Fabrice Le Fessant, INRIA Saclay *) +(* *) +(* Copyright 2012 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. *) +(* *) +(**************************************************************************) + +(* Generate an .annot file from a .cmt file. *) + +open Asttypes +open Typedtree +open Tast_iterator + +let variables_iterator scope = + let super = default_iterator in + let pat sub (type k) (p : k general_pattern) = + begin match p.pat_desc with + | Tpat_var (id, _) | Tpat_alias (_, id, _) -> + Stypes.record (Stypes.An_ident (p.pat_loc, + Ident.name id, + Annot.Idef scope)) + | _ -> () + end; + super.pat sub p + in + {super with pat} + +let bind_variables scope = + let iter = variables_iterator scope in + fun p -> iter.pat iter p + +let bind_bindings scope bindings = + let o = bind_variables scope in + List.iter (fun x -> o x.vb_pat) bindings + +let bind_cases l = + List.iter + (fun {c_lhs; c_guard; c_rhs} -> + let loc = + let open Location in + match c_guard with + | None -> c_rhs.exp_loc + | Some g -> {c_rhs.exp_loc with loc_start=g.exp_loc.loc_start} + in + bind_variables loc c_lhs + ) + l + +let record_module_binding scope mb = + Stypes.record (Stypes.An_ident + (mb.mb_name.loc, + Option.value mb.mb_name.txt ~default:"_", + Annot.Idef scope)) + +let rec iterator ~scope rebuild_env = + let super = default_iterator in + let class_expr sub node = + Stypes.record (Stypes.Ti_class node); + super.class_expr sub node + + and module_expr _sub node = + Stypes.record (Stypes.Ti_mod node); + super.module_expr (iterator ~scope:node.mod_loc rebuild_env) node + + and expr sub exp = + begin match exp.exp_desc with + | Texp_ident (path, _, _) -> + let full_name = Path.name ~paren:Oprint.parenthesized_ident path in + let env = + if rebuild_env then + Env.env_of_only_summary Envaux.env_from_summary exp.exp_env + else + exp.exp_env + in + let annot = + try + let desc = Env.find_value path env in + let dloc = desc.Types.val_loc in + if dloc.Location.loc_ghost then Annot.Iref_external + else Annot.Iref_internal dloc + with Not_found -> + Annot.Iref_external + in + Stypes.record + (Stypes.An_ident (exp.exp_loc, full_name , annot)) + | Texp_let (Recursive, bindings, _) -> + bind_bindings exp.exp_loc bindings + | Texp_let (Nonrecursive, bindings, body) -> + bind_bindings body.exp_loc bindings + | Texp_match (_, f1, _) -> + bind_cases f1 + | Texp_function { cases = f; } + | Texp_try (_, f) -> + bind_cases f + | Texp_letmodule (_, modname, _, _, body ) -> + Stypes.record (Stypes.An_ident + (modname.loc,Option.value ~default:"_" modname.txt, + Annot.Idef body.exp_loc)) + | _ -> () + end; + Stypes.record (Stypes.Ti_expr exp); + super.expr sub exp + + and pat sub (type k) (p : k general_pattern) = + Stypes.record (Stypes.Ti_pat (classify_pattern p, p)); + super.pat sub p + in + + let structure_item_rem sub str rem = + let open Location in + let loc = str.str_loc in + begin match str.str_desc with + | Tstr_value (rec_flag, bindings) -> + let doit loc_start = bind_bindings {scope with loc_start} bindings in + begin match rec_flag, rem with + | Recursive, _ -> doit loc.loc_start + | Nonrecursive, [] -> doit loc.loc_end + | Nonrecursive, {str_loc = loc2} :: _ -> doit loc2.loc_start + end + | Tstr_module mb -> + record_module_binding + { scope with Location.loc_start = loc.loc_end } mb + | Tstr_recmodule mbs -> + List.iter (record_module_binding + { scope with Location.loc_start = loc.loc_start }) mbs + | _ -> + () + end; + Stypes.record_phrase loc; + super.structure_item sub str + in + let structure_item sub s = + (* This will be used for Partial_structure_item. + We don't have here the location of the "next" item, + this will give a slightly different scope for the non-recursive + binding case. *) + structure_item_rem sub s [] + in + let structure sub l = + let rec loop = function + | str :: rem -> structure_item_rem sub str rem; loop rem + | [] -> () + in + loop l.str_items + in + {super with class_expr; module_expr; expr; pat; structure_item; structure} + +let binary_part iter x = + let open Cmt_format in + match x with + | Partial_structure x -> iter.structure iter x + | Partial_structure_item x -> iter.structure_item iter x + | Partial_expression x -> iter.expr iter x + | Partial_pattern (_, x) -> iter.pat iter x + | Partial_class_expr x -> iter.class_expr iter x + | Partial_signature x -> iter.signature iter x + | Partial_signature_item x -> iter.signature_item iter x + | Partial_module_type x -> iter.module_type iter x + +let gen_annot target_filename ~sourcefile ~use_summaries annots = + let open Cmt_format in + let scope = + match sourcefile with + | None -> Location.none + | Some s -> Location.in_file s + in + let iter = iterator ~scope use_summaries in + match annots with + | Implementation typedtree -> + iter.structure iter typedtree; + Stypes.dump target_filename + | Partial_implementation parts -> + Array.iter (binary_part iter) parts; + Stypes.dump target_filename + | Interface _ | Packed _ | Partial_interface _ -> + () diff --git a/typing/ctype.ml b/typing/ctype.ml index 7f7e66bb..10330976 100644 --- a/typing/ctype.ml +++ b/typing/ctype.ml @@ -533,6 +533,26 @@ 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 + 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 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 + and only returns a [variable list]. + *) let rec free_vars_rec real ty = let ty = repr ty in if ty.level >= lowest_level then begin @@ -1235,12 +1255,14 @@ let new_declaration expansion_scope manifest = type_private = Public; type_manifest = manifest; type_variance = []; + type_separability = []; type_is_newtype = true; type_expansion_scope = expansion_scope; type_loc = Location.none; type_attributes = []; type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } let existential_name cstr ty = match repr ty with @@ -1386,7 +1408,9 @@ let rec copy_sep cleanup_scope fixed free bound visited ty = match ty.desc with Tarrow _ | Ttuple _ | Tvariant _ | Tconstr _ | Tobject _ | Tpackage _ -> (ty,(t,bound)) :: visited - | _ -> visited in + | Tvar _ | Tfield _ | Tnil | Tpoly _ | Tunivar _ | Tlink _ | Tsubst _ -> + visited + in let copy_rec = copy_sep cleanup_scope fixed free bound visited in t.desc <- begin match ty.desc with @@ -1396,7 +1420,7 @@ let rec copy_sep cleanup_scope fixed free bound visited ty = (* We shall really check the level on the row variable *) let keep = is_Tvar more && more.level <> generic_level in let more' = copy_rec more in - let fixed' = fixed && is_Tvar (repr more') in + let fixed' = fixed && (is_Tvar more || is_Tunivar more) in let row = copy_row copy_rec fixed' row keep more' in Tvariant row | Tpoly (t1, tl) -> @@ -1891,8 +1915,14 @@ let occur_univar env ty = let td = Env.find_type p env in List.iter2 (fun t v -> - if Variance.(mem May_pos v || mem May_neg v) - then occur_rec bound t) + (* The null variance only occurs in type abbreviations and + corresponds to type variables that do not occur in the + definition (expansion would erase them completely). + The type-checker consistently ignores type expressions + in this position. Physical expansion, as done in `occur`, + would be costly here, since we need to check inside + object and variant types too. *) + if not Variance.(eq v null) then occur_rec bound t) tl td.type_variance with Not_found -> List.iter (occur_rec bound) tl @@ -1939,8 +1969,8 @@ let univars_escape env univar_pairs vl ty = begin try let td = Env.find_type p env in List.iter2 - (fun t v -> - if Variance.(mem May_pos v || mem May_neg v) then occur t) + (* see occur_univar *) + (fun t v -> if not Variance.(eq v null) then occur t) tl td.type_variance with Not_found -> List.iter occur tl @@ -1971,32 +2001,35 @@ let enter_poly env univar_pairs t1 tl1 t2 tl2 f = let univar_pairs = ref [] -(* assumption: [ty] is fully generalized. *) -let reify_univars ty = - let rec subst_univar scope vars ty = +(**** Instantiate a generic type into a poly type ***) + +let polyfy env ty vars = + let subst_univar scope ty = let ty = repr ty in - if ty.level >= lowest_level then begin - ty.level <- pivot_level - ty.level; - match ty.desc with - | Tvar name -> - For_copy.save_desc scope ty ty.desc; - let t = newty2 ty.level (Tunivar name) in - vars := t :: !vars; - ty.desc <- Tsubst t - | _ -> - iter_type_expr (subst_univar scope vars) ty - end - in - let vars = ref [] in - let ty = - For_copy.with_scope (fun scope -> - subst_univar scope vars ty; - unmark_type ty; - copy scope ty - ) + match ty.desc with + | Tvar name when ty.level = generic_level -> + For_copy.save_desc scope ty ty.desc; + let t = newty (Tunivar name) in + ty.desc <- Tsubst t; + Some t + | _ -> None in - newty2 ty.level (Tpoly(repr ty, !vars)) + (* 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 + let ty = newty2 ty.level (Tpoly(repr ty, vars')) in + let complete = List.length vars = List.length vars' in + ty, complete + ) +(* assumption: [ty] is fully generalized. *) +let reify_univars env ty = + let vars = free_variables ty in + let ty, _ = polyfy env ty vars in + ty (*****************) (* Unification *) @@ -2473,15 +2506,6 @@ let unify_package env unify_list lv1 p1 n1 tl1 lv2 p2 n2 tl2 = (* force unification in Reither when one side has a non-conjunctive type *) let rigid_variants = ref false -(* drop not force unification in Reither, even in fixed case - (not sound, only use it when checking exhaustiveness) *) -let passive_variants = ref false -let with_passive_variants f x = - if !passive_variants then f x else - match passive_variants := true; f x with - | r -> passive_variants := false; r - | exception e -> passive_variants := false; raise e - let unify_eq t1 t2 = t1 == t2 || match !umode with @@ -2830,7 +2854,8 @@ and unify_row env row1 row2 = end; let fixed1 = fixed_explanation row1 and fixed2 = fixed_explanation row2 in let more = match fixed1, fixed2 with - | Some _, _ -> rm1 + | Some _, Some _ -> if rm2.level < rm1.level then rm2 else rm1 + | Some _, None -> rm1 | None, Some _ -> rm2 | None, None -> newty2 (min rm1.level rm2.level) (Tvar None) in @@ -2901,7 +2926,7 @@ and unify_row env row1 row2 = set_more row1 r2; List.iter (fun (l,f1,f2) -> - try unify_row_field env fixed1 fixed2 more l f1 f2 + try unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 with Unify trace -> raise Trace.( Unify( Variant (Incompatible_types_for l) :: trace )) ) @@ -2914,7 +2939,7 @@ and unify_row env row1 row2 = set_type_desc rm1 md1; set_type_desc rm2 md2; raise exn end -and unify_row_field env fixed1 fixed2 more l f1 f2 = +and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 = let f1 = row_field_repr f1 and f2 = row_field_repr f2 in let if_not_fixed (pos,fixed) f = match fixed with @@ -2940,7 +2965,6 @@ and unify_row_field env fixed1 fixed2 more l f1 f2 = List.iter2 (unify env) tl1 tl2 end else let redo = - not !passive_variants && (m1 || m2 || either_fixed || !rigid_variants && (List.length tl1 = 1 || List.length tl2 = 1)) && begin match tl1 @ tl2 with [] -> false @@ -2949,13 +2973,13 @@ and unify_row_field env fixed1 fixed2 more l f1 f2 = List.iter (unify env t1) tl; !e1 <> None || !e2 <> None end in - if redo then unify_row_field env fixed1 fixed2 more l f1 f2 else + if redo then unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 else let tl1 = List.map repr tl1 and tl2 = List.map repr tl2 in let rec remq tl = function [] -> [] | ty :: tl' -> if List.memq ty tl then remq tl tl' else ty :: remq tl tl' in - let tl2' = remq tl2 tl1 and tl1' = remq tl1 tl2 in + let tl1' = remq tl2 tl1 and tl2' = remq tl1 tl2 in (* PR#6744 *) let split_univars = List.partition @@ -2966,19 +2990,23 @@ and unify_row_field env fixed1 fixed2 more l f1 f2 = [], [] -> () | (tu1::tlu1), _ :: _ -> (* Attempt to merge all the types containing univars *) - if not !passive_variants then List.iter (unify env tu1) (tlu1@tlu2) | (tu::_, []) | ([], tu::_) -> occur_univar !env tu end; (* Is this handling of levels really principal? *) List.iter (fun ty -> - let rm = repr more in + let rm = repr rm2 in + update_level !env rm.level ty; + update_scope rm.scope ty; + ) tl1'; + List.iter (fun ty -> + let rm = repr rm1 in update_level !env rm.level ty; update_scope rm.scope ty; - ) (tl1' @ tl2'); + ) tl2'; let e = ref None in - let f1' = Reither(c1 || c2, tl1', m1 || m2, e) - and f2' = Reither(c1 || c2, tl2', m1 || m2, e) in + let f1' = Reither(c1 || c2, tl2', m1 || m2, e) + and f2' = Reither(c1 || c2, tl1', m1 || m2, e) in set_row_field e1 f1'; set_row_field e2 f2'; | Reither(_, _, false, e1), Rabsent -> if_not_fixed first (fun () -> set_row_field e1 f2) @@ -2988,7 +3016,7 @@ and unify_row_field env fixed1 fixed2 more l f1 f2 = | Reither(false, tl, _, e1), Rpresent(Some t2) -> if_not_fixed first (fun () -> set_row_field e1 f2; - let rm = repr more in + let rm = repr rm1 in update_level !env rm.level t2; update_scope rm.scope t2; (try List.iter (fun t1 -> unify env t1 t2) tl @@ -2997,7 +3025,7 @@ and unify_row_field env fixed1 fixed2 more l f1 f2 = | Rpresent(Some t1), Reither(false, tl, _, e2) -> if_not_fixed second (fun () -> set_row_field e2 f1; - let rm = repr more in + let rm = repr rm2 in update_level !env rm.level t1; update_scope rm.scope t1; (try List.iter (unify env t1) tl @@ -3165,11 +3193,7 @@ let moregen_occur env level ty = if ty.level > level then begin if is_Tvar ty && ty.level >= generic_level - 1 then raise Occur; ty.level <- pivot_level - ty.level; - match ty.desc with - Tvariant row when static_row row -> - iter_row occur row - | _ -> - iter_type_expr occur ty + iter_type_expr occur ty end in begin try @@ -3975,7 +3999,8 @@ let rec build_subtype env visited loops posi level t = (t, Unchanged) else (t, Unchanged) - | Tarrow(l, t1, t2, _) -> + | Tarrow(l, t1, t2, com) -> + assert (com = Cok); if memq_warn t visited then (t, Unchanged) else let visited = t :: visited in let (t1', c1) = build_subtype env visited loops (not posi) level t1 in @@ -4641,12 +4666,14 @@ let nondep_type_decl env mid is_covariant decl = type_manifest = tm; type_private = priv; type_variance = decl.type_variance; + type_separability = decl.type_separability; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = decl.type_loc; type_attributes = decl.type_attributes; type_immediate = decl.type_immediate; type_unboxed = decl.type_unboxed; + type_uid = decl.type_uid; } with Nondep_cannot_erase _ as exn -> clear_hash (); @@ -4683,6 +4710,7 @@ let nondep_extension_constructor env ids ext = ext_private = ext.ext_private; ext_attributes = ext.ext_attributes; ext_loc = ext.ext_loc; + ext_uid = ext.ext_uid; } with Nondep_cannot_erase _ as exn -> clear_hash (); @@ -4726,6 +4754,7 @@ let nondep_class_declaration env ids decl = end; cty_loc = decl.cty_loc; cty_attributes = decl.cty_attributes; + cty_uid = decl.cty_uid; } in clear_hash (); @@ -4740,6 +4769,7 @@ let nondep_cltype_declaration env ids decl = clty_path = decl.clty_path; clty_loc = decl.clty_loc; clty_attributes = decl.clty_attributes; + clty_uid = decl.clty_uid; } in clear_hash (); diff --git a/typing/ctype.mli b/typing/ctype.mli index 2a4aa8c5..05fb78ce 100644 --- a/typing/ctype.mli +++ b/typing/ctype.mli @@ -207,6 +207,7 @@ val instance_poly: ?keep_names:bool -> 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 (* Same, for a label *) @@ -241,8 +242,6 @@ val unify_gadt: val unify_var: Env.t -> type_expr -> type_expr -> unit (* Same as [unify], but allow free univars when first type is a variable. *) -val with_passive_variants: ('a -> 'b) -> ('a -> 'b) - (* Call [f] in passive_variants mode, for exhaustiveness check. *) val filter_arrow: Env.t -> type_expr -> arg_label -> type_expr * type_expr (* A special case of unification (with l:'a -> 'b). *) val filter_method: Env.t -> string -> private_flag -> type_expr -> type_expr @@ -265,7 +264,7 @@ val matches: Env.t -> type_expr -> type_expr -> bool (* Same as [moregeneral false], implemented using the two above functions and backtracking. Ignore levels *) -val reify_univars : Types.type_expr -> Types.type_expr +val reify_univars : Env.t -> Types.type_expr -> Types.type_expr (* Replaces all the variables of a type by a univar. *) type class_match_failure = diff --git a/typing/datarepr.ml b/typing/datarepr.ml index 61d79bac..818d60ad 100644 --- a/typing/datarepr.ml +++ b/typing/datarepr.ml @@ -65,7 +65,7 @@ let constructor_existentials cd_args cd_res = in (tyl, existentials) -let constructor_args priv cd_args cd_res path rep = +let constructor_args ~current_unit priv cd_args cd_res path rep = let tyl, existentials = constructor_existentials cd_args cd_res in match cd_args with | Cstr_tuple l -> existentials, l, None @@ -77,27 +77,30 @@ let constructor_args priv cd_args cd_res path rep = | Record_unboxed _ -> unboxed_true_default_false | _ -> unboxed_false_default_false in + let arity = List.length type_params in let tdecl = { type_params; - type_arity = List.length type_params; + type_arity = arity; type_kind = Type_record (lbls, rep); type_private = priv; type_manifest = None; type_variance = List.map (fun _ -> Variance.full) type_params; + type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = Location.none; type_attributes = []; type_immediate = Unknown; type_unboxed; + type_uid = Uid.mk ~current_unit; } in existentials, [ newgenconstr path type_params ], Some tdecl -let constructor_descrs ty_path decl cstrs = +let constructor_descrs ~current_unit ty_path decl cstrs = let ty_res = newgenconstr ty_path decl.type_params in let num_consts = ref 0 and num_nonconsts = ref 0 and num_normal = ref 0 in List.iter @@ -107,7 +110,7 @@ let constructor_descrs ty_path decl cstrs = cstrs; let rec describe_constructors idx_const idx_nonconst = function [] -> [] - | {cd_id; cd_args; cd_res; cd_loc; cd_attributes} :: rem -> + | {cd_id; cd_args; cd_res; cd_loc; cd_attributes; cd_uid} :: rem -> let ty_res = match cd_res with | Some ty_res' -> ty_res' @@ -129,7 +132,7 @@ let constructor_descrs ty_path decl cstrs = then Record_unboxed true else Record_inlined idx_nonconst in - constructor_args decl.type_private cd_args cd_res + constructor_args ~current_unit decl.type_private cd_args cd_res (Path.Pdot (ty_path, cstr_name)) representation in let cstr = @@ -147,18 +150,19 @@ let constructor_descrs ty_path decl cstrs = cstr_loc = cd_loc; cstr_attributes = cd_attributes; cstr_inlined; + cstr_uid = cd_uid; } in (cd_id, cstr) :: descr_rem in describe_constructors 0 0 cstrs -let extension_descr path_ext ext = +let extension_descr ~current_unit path_ext ext = let ty_res = match ext.ext_ret_type with Some type_ret -> type_ret | None -> newgenconstr ext.ext_type_path ext.ext_type_params in let existentials, cstr_args, cstr_inlined = - constructor_args ext.ext_private ext.ext_args ext.ext_ret_type + constructor_args ~current_unit ext.ext_private ext.ext_args ext.ext_ret_type path_ext (Record_extension path_ext) in { cstr_name = Path.last path_ext; @@ -175,6 +179,7 @@ let extension_descr path_ext ext = cstr_loc = ext.ext_loc; cstr_attributes = ext.ext_attributes; cstr_inlined; + cstr_uid = ext.ext_uid; } let none = {desc = Ttuple []; level = -1; scope = Btype.generic_level; id = -1} @@ -185,6 +190,7 @@ let dummy_label = lbl_private = Public; lbl_loc = Location.none; lbl_attributes = []; + lbl_uid = Uid.internal_not_actually_unique; } let label_descrs ty_res lbls repres priv = @@ -203,6 +209,7 @@ let label_descrs ty_res lbls repres priv = lbl_private = priv; lbl_loc = l.ld_loc; lbl_attributes = l.ld_attributes; + lbl_uid = l.ld_uid; } in all_labels.(num) <- lbl; (l.ld_id, lbl) :: describe_labels (num+1) rest in @@ -225,9 +232,9 @@ let rec find_constr tag num_const num_nonconst = function let find_constr_by_tag tag cstrlist = find_constr tag 0 0 cstrlist -let constructors_of_type ty_path decl = +let constructors_of_type ~current_unit ty_path decl = match decl.type_kind with - | Type_variant cstrs -> constructor_descrs ty_path decl cstrs + | Type_variant cstrs -> constructor_descrs ~current_unit ty_path decl cstrs | Type_record _ | Type_abstract | Type_open -> [] let labels_of_type ty_path decl = diff --git a/typing/datarepr.mli b/typing/datarepr.mli index 30dc1f1f..e3962e3a 100644 --- a/typing/datarepr.mli +++ b/typing/datarepr.mli @@ -19,13 +19,14 @@ open Types val extension_descr: - Path.t -> extension_constructor -> constructor_description + current_unit:string -> Path.t -> extension_constructor -> + constructor_description val labels_of_type: Path.t -> type_declaration -> (Ident.t * label_description) list val constructors_of_type: - Path.t -> type_declaration -> + current_unit:string -> Path.t -> type_declaration -> (Ident.t * constructor_description) list diff --git a/typing/env.ml b/typing/env.ml index 31e60414..9abbd089 100644 --- a/typing/env.ml +++ b/typing/env.ml @@ -27,16 +27,17 @@ module String = Misc.Stdlib.String let add_delayed_check_forward = ref (fun _ -> assert false) -let value_declarations : ((string * Location.t), (unit -> unit)) Hashtbl.t = - Hashtbl.create 16 - (* This table is used to usage of value declarations. A declaration is - identified with its name and location. The callback attached to a - declaration is called whenever the value is used explicitly - (lookup_value) or implicitly (inclusion test between signatures, - cf Includemod.value_descriptions). *) - -let type_declarations = Hashtbl.create 16 -let module_declarations = Hashtbl.create 16 +type 'a usage_tbl = ('a -> unit) Types.Uid.Tbl.t +(** This table is used to track usage of value declarations. + A declaration is identified by its uid. + The callback attached to a declaration is called whenever the value (or + type, or ...) is used explicitly (lookup_value, ...) or implicitly + (inclusion test between signatures, cf Includemod.value_descriptions, ...). +*) + +let value_declarations : unit usage_tbl = Types.Uid.Tbl.create 16 +let type_declarations : unit usage_tbl = Types.Uid.Tbl.create 16 +let module_declarations : unit usage_tbl = Types.Uid.Tbl.create 16 type constructor_usage = Positive | Pattern | Privatize type constructor_usages = @@ -45,22 +46,25 @@ type constructor_usages = mutable cu_pattern: bool; mutable cu_privatize: bool; } -let add_constructor_usage priv cu usage = - match priv with - | Asttypes.Private -> cu.cu_positive <- true - | Asttypes.Public -> begin - match usage with - | Positive -> cu.cu_positive <- true - | Pattern -> cu.cu_pattern <- true - | Privatize -> cu.cu_privatize <- true - end +let add_constructor_usage ~rebind priv cu usage = + let private_or_rebind = + match priv with + | Asttypes.Private -> true + | Asttypes.Public -> rebind + in + if private_or_rebind then begin + cu.cu_positive <- true + end else begin + match usage with + | Positive -> cu.cu_positive <- true + | Pattern -> cu.cu_pattern <- true + | Privatize -> cu.cu_privatize <- true + end let constructor_usages () = {cu_positive = false; cu_pattern = false; cu_privatize = false} -let used_constructors : - (string * Location.t * string, (constructor_usage -> unit)) Hashtbl.t - = Hashtbl.create 16 +let used_constructors : constructor_usage usage_tbl = Types.Uid.Tbl.create 16 (** Map indexed by the name of module components. *) module NameMap = String.Map @@ -407,7 +411,7 @@ and module_declaration_lazy = and module_components = { alerts: alerts; - loc: Location.t; + uid: Uid.t; comps: (components_maker, (module_components_repr, module_components_failure) result) @@ -648,7 +652,8 @@ let strengthen = aliasable:bool -> t -> module_type -> Path.t -> module_type) let md md_type = - {md_type; md_attributes=[]; md_loc=Location.none} + {md_type; md_attributes=[]; md_loc=Location.none + ;md_uid = Uid.internal_not_actually_unique} (* Print addresses *) @@ -696,17 +701,24 @@ let find_name_module ~mark name tbl = let add_persistent_structure id env = if not (Ident.persistent id) then invalid_arg "Env.add_persistent_structure"; if not (Current_unit_name.is_name_of id) then + let summary = + match + IdTbl.find_name wrap_module ~mark:false (Ident.name id) env.modules + with + | exception Not_found | _, Mod_persistent -> env.summary + | _ -> Env_persistent (env.summary, id) + in { env with modules = IdTbl.add id Mod_persistent env.modules; - summary = Env_persistent (env.summary, id); + summary } else env -let components_of_module ~alerts ~loc env fs ps path addr mty = +let components_of_module ~alerts ~uid env fs ps path addr mty = { alerts; - loc; + uid; comps = EnvLazy.create { cm_env = env; cm_freshening_subst = fs; @@ -728,8 +740,13 @@ let sign_of_cmi ~freshen { Persistent_env.Persistent_signature.cmi; _ } = Misc.Stdlib.String.Map.empty flags in - let loc = Location.none in - let md = md (Mty_signature sign) in + let md = + { md_type = Mty_signature sign; + md_loc = Location.none; + md_attributes = []; + md_uid = Uid.of_compilation_unit_id id; + } + in let mda_address = EnvLazy.create_forced (Aident id) in let mda_declaration = EnvLazy.create (Subst.identity, Subst.Make_local, md) @@ -738,7 +755,7 @@ let sign_of_cmi ~freshen { Persistent_env.Persistent_signature.cmi; _ } = let freshening_subst = if freshen then (Some Subst.identity) else None in - components_of_module ~alerts ~loc + components_of_module ~alerts ~uid:md.md_uid empty freshening_subst Subst.identity path mda_address (Mty_signature sign) in @@ -778,11 +795,14 @@ let crc_of_unit name = let is_imported_opaque modname = Persistent_env.is_imported_opaque persistent_env modname +let register_import_as_opaque modname = + Persistent_env.register_import_as_opaque persistent_env modname + let reset_declaration_caches () = - Hashtbl.clear value_declarations; - Hashtbl.clear type_declarations; - Hashtbl.clear module_declarations; - Hashtbl.clear used_constructors; + Types.Uid.Tbl.clear value_declarations; + Types.Uid.Tbl.clear type_declarations; + Types.Uid.Tbl.clear module_declarations; + Types.Uid.Tbl.clear used_constructors; () let reset_cache () = @@ -832,6 +852,10 @@ let modtype_of_functor_appl fcomp p1 p2 = Hashtbl.add fcomp.fcomp_subst_cache p2 mty; mty +let check_functor_appl ~errors ~loc env p1 f arg p2 md = + if not (Hashtbl.mem f.fcomp_cache p2) then + !check_functor_application ~errors ~loc env md.md_type p2 arg p1 + (* Lookup by identifier *) let find_ident_module id env = @@ -1118,6 +1142,15 @@ let normalize_type_path oloc env path = | Papply _ -> assert false +let rec normalize_modtype_path env path = + let path = normalize_path_prefix None env path in + expand_modtype_path env path + +and expand_modtype_path env path = + match (find_modtype path env).mtd_type with + | Some (Mty_ident path) -> normalize_modtype_path env path + | _ | exception Not_found -> path + let find_module path env = find_module ~alias:false path env @@ -1490,7 +1523,10 @@ let rec components_of_module_maker Datarepr.set_row_name final_decl (Subst.type_path prefixing_sub (Path.Pident id)); let constructors = - List.map snd (Datarepr.constructors_of_type path final_decl) in + List.map snd + (Datarepr.constructors_of_type ~current_unit:(get_unit_name ()) + path final_decl) + in let labels = List.map snd (Datarepr.labels_of_type path final_decl) in let tda = @@ -1512,7 +1548,10 @@ let rec components_of_module_maker env := store_type_infos id fresh_decl !env | Sig_typext(id, ext, _, _) -> let ext' = Subst.extension_constructor sub ext in - let descr = Datarepr.extension_descr path ext' in + let descr = + Datarepr.extension_descr ~current_unit:(get_unit_name ()) path + ext' + in let addr = next_address () in let cda = { cda_description = descr; cda_address = Some addr } in c.comp_constrs <- add_to_tbl (Ident.name id) cda c.comp_constrs @@ -1537,7 +1576,7 @@ let rec components_of_module_maker Builtin_attributes.alerts_of_attrs md.md_attributes in let comps = - components_of_module ~alerts ~loc:md.md_loc !env freshening_sub + components_of_module ~alerts ~uid:md.md_uid !env freshening_sub prefixing_sub path addr md.md_type in let mda = @@ -1597,13 +1636,15 @@ let rec components_of_module_maker (* Insertion of bindings by identifier + path *) -and check_usage loc id warn tbl = - if not loc.Location.loc_ghost && Warnings.is_active (warn "") then begin +and check_usage loc id uid warn tbl = + if not loc.Location.loc_ghost && + Uid.for_actual_declaration uid && + Warnings.is_active (warn "") + then begin let name = Ident.name id in - let key = (name, loc) in - if Hashtbl.mem tbl key then () + if Types.Uid.Tbl.mem tbl uid then () else let used = ref false in - Hashtbl.add tbl key (fun () -> used := true); + Types.Uid.Tbl.add tbl uid (fun () -> used := true); if not (name = "" || name.[0] = '_' || name.[0] = '#') then !add_delayed_check_forward @@ -1622,7 +1663,9 @@ and check_value_name name loc = and store_value ?check id addr decl env = check_value_name (Ident.name id) decl.val_loc; - Option.iter (fun f -> check_usage decl.val_loc id f value_declarations) check; + Option.iter + (fun f -> check_usage decl.val_loc id decl.val_uid f value_declarations) + check; let vda = { vda_description = decl; vda_address = addr } in { env with values = IdTbl.add id (Val_bound vda) env.values; @@ -1631,10 +1674,14 @@ and store_value ?check id addr decl env = and store_type ~check id info env = let loc = info.type_loc in if check then - check_usage loc id (fun s -> Warnings.Unused_type_declaration s) + check_usage loc id info.type_uid + (fun s -> Warnings.Unused_type_declaration s) type_declarations; let path = Pident id in - let constructors = Datarepr.constructors_of_type path info in + let constructors = + Datarepr.constructors_of_type path info + ~current_unit:(get_unit_name ()) + in let labels = Datarepr.labels_of_type path info in let descrs = (List.map snd constructors, List.map snd labels) in let tda = { tda_declaration = info; tda_descriptions = descrs } in @@ -1647,10 +1694,11 @@ and store_type ~check id info env = begin fun (_, cstr) -> let name = cstr.cstr_name in let loc = cstr.cstr_loc in - let k = (ty_name, loc, name) in - if not (Hashtbl.mem used_constructors k) then + let k = cstr.cstr_uid in + if not (Types.Uid.Tbl.mem used_constructors k) then let used = constructor_usages () in - Hashtbl.add used_constructors k (add_constructor_usage priv used); + Types.Uid.Tbl.add used_constructors k + (add_constructor_usage ~rebind:false priv used); if not (ty_name = "" || ty_name.[0] = '_') then !add_delayed_check_forward (fun () -> @@ -1686,21 +1734,23 @@ and store_type_infos id info env = types = IdTbl.add id tda env.types; summary = Env_type(env.summary, id, info) } -and store_extension ~check id addr ext env = +and store_extension ~check ~rebind id addr ext env = let loc = ext.ext_loc in - let cstr = Datarepr.extension_descr (Pident id) ext in + let cstr = + Datarepr.extension_descr ~current_unit:(get_unit_name ()) (Pident id) ext + in let cda = { cda_description = cstr; cda_address = Some addr } in if check && not loc.Location.loc_ghost && Warnings.is_active (Warnings.Unused_extension ("", false, false, false)) then begin let priv = ext.ext_private in let is_exception = Path.same ext.ext_type_path Predef.path_exn in - let ty_name = Path.last ext.ext_type_path in let name = cstr.cstr_name in - let k = (ty_name, loc, name) in - if not (Hashtbl.mem used_constructors k) then begin + let k = cstr.cstr_uid in + if not (Types.Uid.Tbl.mem used_constructors k) then begin let used = constructor_usages () in - Hashtbl.add used_constructors k (add_constructor_usage priv used); + Types.Uid.Tbl.add used_constructors k + (add_constructor_usage ~rebind priv used); !add_delayed_check_forward (fun () -> if not (is_in_signature env) && not used.cu_positive then @@ -1717,7 +1767,8 @@ and store_extension ~check id addr ext env = and store_module ~check ~freshening_sub id addr presence md env = let loc = md.md_loc in - Option.iter (fun f -> check_usage loc id f module_declarations) check; + Option.iter + (fun f -> check_usage loc id md.md_uid f module_declarations) check; let alerts = Builtin_attributes.alerts_of_attrs md.md_attributes in let module_decl_lazy = match freshening_sub with @@ -1725,7 +1776,7 @@ and store_module ~check ~freshening_sub id addr presence md env = | Some s -> EnvLazy.create (s, Subst.Rescope (Ident.scope id), md) in let comps = - components_of_module ~alerts ~loc:md.md_loc + components_of_module ~alerts ~uid:md.md_uid env freshening_sub Subst.identity (Pident id) addr md.md_type in let mda = @@ -1776,7 +1827,7 @@ let components_of_functor_appl ~loc f env p1 p2 = ("the signature of " ^ Path.name p) mty; let comps = components_of_module ~alerts:Misc.Stdlib.String.Map.empty - ~loc:Location.none + ~uid:Uid.internal_not_actually_unique (*???*) env None Subst.identity p addr mty in @@ -1803,9 +1854,9 @@ let add_value ?check id desc env = let add_type ~check id info env = store_type ~check id info env -and add_extension ~check id ext env = +and add_extension ~check ~rebind id ext env = let addr = extension_declaration_address env id ext in - store_extension ~check id addr ext env + store_extension ~check ~rebind id addr ext env and add_module_declaration ?(arg=false) ~check id presence md env = let check = @@ -1851,10 +1902,10 @@ let enter_type ~scope name info env = let env = store_type ~check:true id info env in (id, env) -let enter_extension ~scope name ext env = +let enter_extension ~scope ~rebind name ext env = let id = Ident.create_scoped ~scope name in let addr = extension_declaration_address env id ext in - let env = store_extension ~check:true id addr ext env in + let env = store_extension ~check:true ~rebind id addr ext env in (id, env) let enter_module_declaration ~scope ?arg s presence md env = @@ -1886,7 +1937,8 @@ let add_item comp env = match comp with Sig_value(id, decl, _) -> add_value id decl env | Sig_type(id, decl, _, _) -> add_type ~check:false id decl env - | Sig_typext(id, ext, _, _) -> add_extension ~check:false id ext env + | Sig_typext(id, ext, _, _) -> + add_extension ~check:false ~rebind:false id ext env | Sig_module(id, presence, md, _, _) -> add_module_declaration ~check:false id presence md env | Sig_modtype(id, decl, _) -> add_modtype id decl env @@ -1959,19 +2011,22 @@ let add_components slot root env0 comps = modules; } -let open_signature slot root env0 = - match get_components (find_module_components root env0) with - | Functor_comps _ -> None - | Structure_comps comps -> - Some (add_components slot root env0 comps) +let open_signature slot root env0 : (_,_) result = + match get_components_res (find_module_components root env0) with + | Error _ -> Error `Not_found + | exception Not_found -> Error `Not_found + | Ok (Functor_comps _) -> Error `Functor + | Ok (Structure_comps comps) -> + Ok (add_components slot root env0 comps) (* Open a signature from a file *) let open_pers_signature name env = match open_signature None (Pident(Ident.create_persistent name)) env with - | Some env -> env - | None -> assert false (* a compilation unit cannot refer to a functor *) + | (Ok _ | Error `Not_found as res) -> res + | Error `Functor -> assert false + (* a compilation unit cannot refer to a functor *) let open_signature ?(used_slot = ref false) @@ -2081,46 +2136,40 @@ let save_signature_with_imports ~alerts sg modname filename imports = let (initial_safe_string, initial_unsafe_string) = Predef.build_initial_env (add_type ~check:false) - (add_extension ~check:false) + (add_extension ~check:false ~rebind:false) empty (* Tracking usage *) -let mark_module_used name loc = - match Hashtbl.find module_declarations (name, loc) with +let mark_module_used uid = + match Types.Uid.Tbl.find module_declarations uid with | mark -> mark () | exception Not_found -> () -let mark_modtype_used _name _mtd = () +let mark_modtype_used _uid = () -let mark_value_used name vd = - match Hashtbl.find value_declarations (name, vd.val_loc) with +let mark_value_used uid = + match Types.Uid.Tbl.find value_declarations uid with | mark -> mark () | exception Not_found -> () -let mark_type_used name td = - match Hashtbl.find type_declarations (name, td.type_loc) with +let mark_type_used uid = + match Types.Uid.Tbl.find type_declarations uid with | mark -> mark () | exception Not_found -> () let mark_type_path_used env path = match find_type path env with - | decl -> mark_type_used (Path.last path) decl + | decl -> mark_type_used decl.type_uid | exception Not_found -> () -let mark_constructor_used usage ty_name cd = - let name = Ident.name cd.cd_id in - let loc = cd.cd_loc in - let k = (ty_name, loc, name) in - match Hashtbl.find used_constructors k with +let mark_constructor_used usage cd = + match Types.Uid.Tbl.find used_constructors cd.cd_uid with | mark -> mark usage | exception Not_found -> () -let mark_extension_used usage name ext = - let ty_name = Path.last ext.ext_type_path in - let loc = ext.ext_loc in - let k = (ty_name, loc, name) in - match Hashtbl.find used_constructors k with +let mark_extension_used usage ext = + match Types.Uid.Tbl.find used_constructors ext.ext_uid with | mark -> mark usage | exception Not_found -> () @@ -2131,9 +2180,7 @@ let mark_constructor_description_used usage env cstr = | _ -> assert false in mark_type_path_used env ty_path; - let ty_name = Path.last ty_path in - let k = (ty_name, cstr.cstr_loc, cstr.cstr_name) in - match Hashtbl.find used_constructors k with + match Types.Uid.Tbl.find used_constructors cstr.cstr_uid with | mark -> mark usage | exception Not_found -> () @@ -2145,37 +2192,26 @@ let mark_label_description_used () env lbl = in mark_type_path_used env ty_path -let mark_class_used name cty = - match Hashtbl.find type_declarations (name, cty.cty_loc) with +let mark_class_used uid = + match Types.Uid.Tbl.find type_declarations uid with | mark -> mark () | exception Not_found -> () -let mark_cltype_used name clty = - match Hashtbl.find type_declarations (name, clty.clty_loc) with +let mark_cltype_used uid = + match Types.Uid.Tbl.find type_declarations uid with | mark -> mark () | exception Not_found -> () -let set_value_used_callback name vd callback = - let key = (name, vd.val_loc) in - try - let old = Hashtbl.find value_declarations key in - Hashtbl.replace value_declarations key (fun () -> old (); callback ()) - (* this is to support cases like: - let x = let x = 1 in x in x - where the two declarations have the same location - (e.g. resulting from Camlp4 expansion of grammar entries) *) - with Not_found -> - Hashtbl.add value_declarations key callback - -let set_type_used_callback name td callback = - let loc = td.type_loc in - if loc.Location.loc_ghost then () - else let key = (name, loc) in - let old = - try Hashtbl.find type_declarations key - with Not_found -> ignore - in - Hashtbl.replace type_declarations key (fun () -> callback old) +let set_value_used_callback vd callback = + Types.Uid.Tbl.add value_declarations vd.val_uid callback + +let set_type_used_callback td callback = + if Uid.for_actual_declaration td.type_uid then + let old = + try Types.Uid.Tbl.find type_declarations td.type_uid + with Not_found -> ignore + in + Types.Uid.Tbl.replace type_declarations td.type_uid (fun () -> callback old) (* Lookup by name *) @@ -2208,10 +2244,10 @@ let report_value_unbound ~errors ~loc env reason lid = in may_lookup_error errors loc env (Unbound_value(lid, hint)) -let use_module ~use ~loc name path mda = +let use_module ~use ~loc path mda = if use then begin let comps = mda.mda_components in - mark_module_used name comps.loc; + mark_module_used comps.uid; Misc.Stdlib.String.Map.iter (fun kind message -> let message = if message = "" then "" else "\n" ^ message in @@ -2221,40 +2257,40 @@ let use_module ~use ~loc name path mda = comps.alerts end -let use_value ~use ~loc name path vda = +let use_value ~use ~loc path vda = if use then begin let desc = vda.vda_description in - mark_value_used name desc; + mark_value_used desc.val_uid; Builtin_attributes.check_alerts loc desc.val_attributes (Path.name path) end -let use_type ~use ~loc name path tda = +let use_type ~use ~loc path tda = if use then begin let decl = tda.tda_declaration in - mark_type_used name decl; + mark_type_used decl.type_uid; Builtin_attributes.check_alerts loc decl.type_attributes (Path.name path) end -let use_modtype ~use ~loc name path desc = +let use_modtype ~use ~loc path desc = if use then begin - mark_modtype_used name desc; + mark_modtype_used desc.mtd_uid; Builtin_attributes.check_alerts loc desc.mtd_attributes (Path.name path) end -let use_class ~use ~loc name path clda = +let use_class ~use ~loc path clda = if use then begin let desc = clda.clda_declaration in - mark_class_used name desc; + mark_class_used desc.cty_uid; Builtin_attributes.check_alerts loc desc.cty_attributes (Path.name path) end -let use_cltype ~use ~loc name path desc = +let use_cltype ~use ~loc path desc = if use then begin - mark_cltype_used name desc; + mark_cltype_used desc.clty_uid; Builtin_attributes.check_alerts loc desc.clty_attributes (Path.name path) end @@ -2287,7 +2323,7 @@ let lookup_ident_module (type a) (load : a load) ~errors ~use ~loc s env = in match data with | Mod_local mda -> begin - use_module ~use ~loc s path mda; + use_module ~use ~loc path mda; match load with | Load -> path, (mda : a) | Don't_load -> path, (() : a) @@ -2302,7 +2338,7 @@ let lookup_ident_module (type a) (load : a load) ~errors ~use ~loc s env = | Load -> begin match find_pers_mod s with | mda -> - use_module ~use ~loc s path mda; + use_module ~use ~loc path mda; path, (mda : a) | exception Not_found -> may_lookup_error errors loc env (Unbound_module (Lident s)) @@ -2312,7 +2348,7 @@ let lookup_ident_module (type a) (load : a load) ~errors ~use ~loc s env = let lookup_ident_value ~errors ~use ~loc name env = match IdTbl.find_name wrap_value ~mark:use name env.values with | (path, Val_bound vda) -> - use_value ~use ~loc name path vda; + use_value ~use ~loc path vda; path, vda.vda_description | (_, Val_unbound reason) -> report_value_unbound ~errors ~loc env reason (Lident name) @@ -2322,7 +2358,7 @@ let lookup_ident_value ~errors ~use ~loc name env = let lookup_ident_type ~errors ~use ~loc s env = match IdTbl.find_name wrap_identity ~mark:use s env.types with | (path, data) as res -> - use_type ~use ~loc s path data; + use_type ~use ~loc path data; res | exception Not_found -> may_lookup_error errors loc env (Unbound_type (Lident s)) @@ -2330,7 +2366,7 @@ let lookup_ident_type ~errors ~use ~loc s env = let lookup_ident_modtype ~errors ~use ~loc s env = match IdTbl.find_name wrap_identity ~mark:use s env.modtypes with | (path, data) as res -> - use_modtype ~use ~loc s path data; + use_modtype ~use ~loc path data; res | exception Not_found -> may_lookup_error errors loc env (Unbound_modtype (Lident s)) @@ -2338,7 +2374,7 @@ let lookup_ident_modtype ~errors ~use ~loc s env = let lookup_ident_class ~errors ~use ~loc s env = match IdTbl.find_name wrap_identity ~mark:use s env.classes with | (path, clda) -> - use_class ~use ~loc s path clda; + use_class ~use ~loc path clda; path, clda.clda_declaration | exception Not_found -> may_lookup_error errors loc env (Unbound_class (Lident s)) @@ -2346,7 +2382,7 @@ let lookup_ident_class ~errors ~use ~loc s env = let lookup_ident_cltype ~errors ~use ~loc s env = match IdTbl.find_name wrap_identity ~mark:use s env.cltypes with | (path, data) as res -> - use_cltype ~use ~loc s path data; + use_cltype ~use ~loc path data; res | exception Not_found -> may_lookup_error errors loc env (Unbound_cltype (Lident s)) @@ -2365,23 +2401,10 @@ let lookup_all_ident_labels ~errors ~use ~loc s env = lbls end -(* Drop all extension constructors *) -let drop_exts cstrs = - List.filter (fun (cda, _) -> not (is_ext cda)) cstrs - -(* Only keep the latest extension constructor *) -let rec filter_shadowed_constructors cstrs = - match cstrs with - | (cda, _) as hd :: tl -> - if is_ext cda then hd :: drop_exts tl - else hd :: filter_shadowed_constructors tl - | [] -> [] - let lookup_all_ident_constructors ~errors ~use ~loc usage s env = match TycompTbl.find_all ~mark:use s env.constrs with | [] -> may_lookup_error errors loc env (Unbound_constructor (Lident s)) | cstrs -> - let cstrs = filter_shadowed_constructors cstrs in List.map (fun (cda, use_fn) -> let use_fn () = @@ -2402,7 +2425,7 @@ let rec lookup_module_components ~errors ~use ~loc lid env = | Lapply(l1, l2) -> let p1, f, arg = lookup_functor_components ~errors ~use ~loc l1 env in let p2, md = lookup_module ~errors ~use ~loc l2 env in - !check_functor_application ~errors ~loc env md.md_type p2 arg p1; + check_functor_appl ~errors ~loc env p1 f arg p2 md; let comps = !components_of_functor_appl' ~loc f env p1 p2 in (Papply(p1, p2), comps) @@ -2446,7 +2469,7 @@ and lookup_module ~errors ~use ~loc lid env = | Lapply(l1, l2) -> let p1, fc, arg = lookup_functor_components ~errors ~use ~loc l1 env in let p2, md2 = lookup_module ~errors ~use ~loc l2 env in - !check_functor_application ~errors ~loc env md2.md_type p2 arg p1; + check_functor_appl ~errors ~loc env p1 fc arg p2 md2; let md = md (modtype_of_functor_appl fc p1 p2) in Papply(p1, p2), md @@ -2455,7 +2478,7 @@ and lookup_dot_module ~errors ~use ~loc l s env = match NameMap.find s comps.comp_modules with | mda -> let path = Pdot(p, s) in - use_module ~use ~loc s path mda; + use_module ~use ~loc path mda; (path, mda) | exception Not_found -> may_lookup_error errors loc env (Unbound_module (Ldot(l, s))) @@ -2467,7 +2490,7 @@ let lookup_dot_value ~errors ~use ~loc l s env = match NameMap.find s comps.comp_values with | vda -> let path = Pdot(path, s) in - use_value ~use ~loc s path vda; + use_value ~use ~loc path vda; (path, vda.vda_description) | exception Not_found -> may_lookup_error errors loc env (Unbound_value (Ldot(l, s), No_hint)) @@ -2477,7 +2500,7 @@ let lookup_dot_type ~errors ~use ~loc l s env = match NameMap.find s comps.comp_types with | tda -> let path = Pdot(p, s) in - use_type ~use ~loc s path tda; + use_type ~use ~loc path tda; (path, tda) | exception Not_found -> may_lookup_error errors loc env (Unbound_type (Ldot(l, s))) @@ -2487,7 +2510,7 @@ let lookup_dot_modtype ~errors ~use ~loc l s env = match NameMap.find s comps.comp_modtypes with | desc -> let path = Pdot(p, s) in - use_modtype ~use ~loc s path desc; + use_modtype ~use ~loc path desc; (path, desc) | exception Not_found -> may_lookup_error errors loc env (Unbound_modtype (Ldot(l, s))) @@ -2497,7 +2520,7 @@ let lookup_dot_class ~errors ~use ~loc l s env = match NameMap.find s comps.comp_classes with | clda -> let path = Pdot(p, s) in - use_class ~use ~loc s path clda; + use_class ~use ~loc path clda; (path, clda.clda_declaration) | exception Not_found -> may_lookup_error errors loc env (Unbound_class (Ldot(l, s))) @@ -2507,7 +2530,7 @@ let lookup_dot_cltype ~errors ~use ~loc l s env = match NameMap.find s comps.comp_cltypes with | desc -> let path = Pdot(p, s) in - use_cltype ~use ~loc s path desc; + use_cltype ~use ~loc path desc; (path, desc) | exception Not_found -> may_lookup_error errors loc env (Unbound_cltype (Ldot(l, s))) @@ -2553,9 +2576,9 @@ let lookup_module_path ~errors ~use ~loc ~load lid env : Path.t = fst (lookup_ident_module Load ~errors ~use ~loc s env) | Ldot(l, s) -> fst (lookup_dot_module ~errors ~use ~loc l s env) | Lapply(l1, l2) -> - let (p1, _, arg) = lookup_functor_components ~errors ~use ~loc l1 env in + let (p1, f, arg) = lookup_functor_components ~errors ~use ~loc l1 env in let p2, md2 = lookup_module ~errors ~use ~loc l2 env in - !check_functor_application ~errors ~loc env md2.md_type p2 arg p1; + check_functor_appl ~errors ~loc env p1 f arg p2 md2; Papply(p1, p2) let lookup_value ~errors ~use ~loc lid env = @@ -2726,7 +2749,7 @@ let lookup_instance_variable ?(use=true) ~loc name env = let desc = vda.vda_description in match desc.val_kind with | Val_ivar(mut, cl_num) -> - use_value ~use ~loc name path vda; + use_value ~use ~loc path vda; path, mut, cl_num, desc.val_type | _ -> lookup_error loc env (Not_an_instance_variable name) diff --git a/typing/env.mli b/typing/env.mli index 214ed233..e43a5efd 100644 --- a/typing/env.mli +++ b/typing/env.mli @@ -119,6 +119,8 @@ 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_modtype_path: t -> Path.t -> Path.t +(* Normalize a module type path *) val reset_required_globals: unit -> unit val get_required_globals: unit -> Ident.t list @@ -127,15 +129,15 @@ val add_required_global: Ident.t -> unit val has_local_constraints: t -> bool (* Mark definitions as used *) -val mark_value_used: string -> value_description -> unit -val mark_module_used: string -> Location.t -> unit -val mark_type_used: string -> type_declaration -> unit +val mark_value_used: Uid.t -> unit +val mark_module_used: Uid.t -> unit +val mark_type_used: Uid.t -> unit type constructor_usage = Positive | Pattern | Privatize val mark_constructor_used: - constructor_usage -> string -> constructor_declaration -> unit + constructor_usage -> constructor_declaration -> unit val mark_extension_used: - constructor_usage -> string -> extension_constructor -> unit + constructor_usage -> extension_constructor -> unit (* Lookup by long identifiers *) @@ -263,7 +265,8 @@ 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_extension: check:bool -> Ident.t -> extension_constructor -> t -> t +val add_extension: + check:bool -> rebind:bool -> Ident.t -> extension_constructor -> t -> t val add_module: ?arg:bool -> Ident.t -> module_presence -> module_type -> t -> t val add_module_declaration: ?arg:bool -> check:bool -> Ident.t -> @@ -304,9 +307,9 @@ val open_signature: ?used_slot:bool ref -> ?loc:Location.t -> ?toplevel:bool -> Asttypes.override_flag -> Path.t -> - t -> t option + t -> (t, [`Not_found | `Functor]) result -val open_pers_signature: string -> t -> t +val open_pers_signature: string -> t -> (t, [`Not_found]) result (* Insertion by name *) @@ -315,7 +318,8 @@ val enter_value: string -> value_description -> t -> Ident.t * t val enter_type: scope:int -> string -> type_declaration -> t -> Ident.t * t val enter_extension: - scope:int -> string -> extension_constructor -> t -> Ident.t * t + scope:int -> rebind:bool -> string -> + extension_constructor -> t -> Ident.t * t val enter_module: scope:int -> ?arg:bool -> string -> module_presence -> module_type -> t -> Ident.t * t @@ -368,9 +372,12 @@ val imports: unit -> crcs (* may raise Persistent_env.Consistbl.Inconsistency *) val import_crcs: source:string -> crcs -> unit -(* [is_imported_opaque md] returns true if [md] is an opaque imported module *) +(* [is_imported_opaque md] returns true if [md] is an opaque imported module *) val is_imported_opaque: modname -> bool +(* [register_import_as_opaque md] registers [md] as an opaque imported module *) +val register_import_as_opaque: modname -> unit + (* Summaries -- compact representation of an environment, to be exported in debugging information. *) @@ -403,9 +410,9 @@ val in_signature: bool -> t -> t val is_in_signature: t -> bool val set_value_used_callback: - string -> value_description -> (unit -> unit) -> unit + value_description -> (unit -> unit) -> unit val set_type_used_callback: - string -> type_declaration -> ((unit -> unit) -> unit) -> unit + type_declaration -> ((unit -> unit) -> unit) -> unit (* Forward declaration to break mutual recursion with Includemod. *) val check_functor_application: @@ -426,6 +433,13 @@ val print_longident: (Format.formatter -> Longident.t -> unit) ref (* Forward declaration to break mutual recursion with Printtyp. *) val print_path: (Format.formatter -> Path.t -> unit) ref + +(** Folds *) + +val fold_constructors: + (constructor_description -> 'a -> 'a) -> + Longident.t option -> t -> 'a -> 'a + (** Utilities *) val scrape_alias: t -> module_type -> module_type val check_value_name: string -> Location.t -> unit diff --git a/typing/envaux.ml b/typing/envaux.ml index 2d3a02bc..a0bbbc26 100644 --- a/typing/envaux.ml +++ b/typing/envaux.ml @@ -44,7 +44,7 @@ let rec env_from_summary sum subst = (Subst.type_declaration subst desc) (env_from_summary s subst) | Env_extension(s, id, desc) -> - Env.add_extension ~check:false id + Env.add_extension ~check:false ~rebind:false id (Subst.extension_constructor subst desc) (env_from_summary s subst) | Env_module(s, id, pres, desc) -> @@ -64,9 +64,9 @@ let rec env_from_summary sum subst = let env = env_from_summary s subst in let path' = Subst.module_path subst path in begin match Env.open_signature Asttypes.Override path' env with - | Some env -> env - | None -> assert false - | exception Not_found -> raise (Error (Module_not_found path')) + | Ok env -> env + | Error `Functor -> assert false + | Error `Not_found -> raise (Error (Module_not_found path')) end | Env_functor_arg(Env_module(s, id, pres, desc), id') when Ident.same id id' -> @@ -106,3 +106,10 @@ open Format let report_error ppf = function | Module_not_found p -> fprintf ppf "@[Cannot find module %a@].@." Printtyp.path p + +let () = + Location.register_error_of_exn + (function + | Error err -> Some (Location.error_of_printer_file report_error err) + | _ -> None + ) diff --git a/typing/ident.ml b/typing/ident.ml index b10b3dec..6296398b 100644 --- a/typing/ident.ml +++ b/typing/ident.ml @@ -93,13 +93,16 @@ let equal i1 i2 = | _ -> false -let same i1 i2 = i1 = i2 - (* Possibly more efficient version (with a real compiler, at least): - if i1.stamp <> 0 - then i1.stamp = i2.stamp - else i2.stamp = 0 && i1.name = i2.name *) - -let compare i1 i2 = Stdlib.compare i1 i2 +let same i1 i2 = + match i1, i2 with + | Local { stamp = s1; _ }, Local { stamp = s2; _ } + | Scoped { stamp = s1; _ }, Scoped { stamp = s2; _ } + | Predef { stamp = s1; _ }, Predef { stamp = s2 } -> + s1 = s2 + | Global name1, Global name2 -> + name1 = name2 + | _ -> + false let stamp = function | Local { stamp; _ } @@ -197,7 +200,7 @@ let rec add id data = function Empty -> Node(Empty, {ident = id; data = data; previous = None}, Empty, 1) | Node(l, k, r, h) -> - let c = compare (name id) (name k.ident) in + let c = String.compare (name id) (name k.ident) in if c = 0 then Node(l, {ident = id; data = data; previous = Some k}, r, h) else if c < 0 then @@ -227,7 +230,7 @@ let rec remove id = function Empty -> Empty | (Node (l, k, r, h) as m) -> - let c = compare (name id) (name k.ident) in + let c = String.compare (name id) (name k.ident) in if c = 0 then match k.previous with | None -> merge l r @@ -247,7 +250,7 @@ let rec find_same id = function Empty -> raise Not_found | Node(l, k, r, _) -> - let c = compare (name id) (name k.ident) in + let c = String.compare (name id) (name k.ident) in if c = 0 then if same id k.ident then k.data @@ -259,7 +262,7 @@ let rec find_name n = function Empty -> raise Not_found | Node(l, k, r, _) -> - let c = compare n (name k.ident) in + let c = String.compare n (name k.ident) in if c = 0 then k.ident, k.data else @@ -273,7 +276,7 @@ let rec find_all n = function Empty -> [] | Node(l, k, r, _) -> - let c = compare n (name k.ident) in + let c = String.compare n (name k.ident) in if c = 0 then (k.ident, k.data) :: get_all k.previous else diff --git a/typing/includecore.ml b/typing/includecore.ml index 87f02b8c..5325d97d 100644 --- a/typing/includecore.ml +++ b/typing/includecore.ml @@ -419,18 +419,15 @@ let type_declarations ?(equality = false) ~loc env ~mark name (_, Type_abstract) -> None | (Type_variant cstrs1, Type_variant cstrs2) -> if mark then begin - let mark usage name cstrs = - List.iter - (fun cstr -> - Env.mark_constructor_used usage name cstr) - cstrs + let mark usage cstrs = + List.iter (Env.mark_constructor_used usage) cstrs in let usage = if decl2.type_private = Public then Env.Positive else Env.Privatize in - mark usage name cstrs1; - if equality then mark Env.Positive (Path.name path) cstrs2 + mark usage cstrs1; + if equality then mark Env.Positive cstrs2 end; Option.map (fun var_err -> Variant_mismatch var_err) @@ -487,7 +484,7 @@ let extension_constructors ~loc env ~mark id ext1 ext2 = if ext2.ext_private = Public then Env.Positive else Env.Privatize in - Env.mark_extension_used usage (Ident.name id) ext1 + Env.mark_extension_used usage ext1 end; let ty1 = Btype.newgenty (Tconstr(ext1.ext_type_path, ext1.ext_type_params, ref Mnil)) diff --git a/typing/includemod.ml b/typing/includemod.ml index d92b0fe0..e2e63ecb 100644 --- a/typing/includemod.ml +++ b/typing/includemod.ml @@ -75,7 +75,7 @@ let mark_positive = function let value_descriptions ~loc env ~mark cxt subst id vd1 vd2 = Cmt_format.record_value_dependency vd1 vd2; if mark_positive mark then - Env.mark_value_used (Ident.name id) vd1; + Env.mark_value_used vd1.val_uid; let vd2 = Subst.value_description subst vd2 in try Includecore.value_descriptions ~loc env (Ident.name id) vd1 vd2 @@ -87,7 +87,7 @@ let value_descriptions ~loc env ~mark cxt subst id vd1 vd2 = let type_declarations ~loc env ~mark ?old_env:_ cxt subst id decl1 decl2 = let mark = mark_positive mark in if mark then - Env.mark_type_used (Ident.name id) decl1; + Env.mark_type_used decl1.type_uid; let decl2 = Subst.type_declaration subst decl2 in match Includecore.type_declarations ~loc env ~mark @@ -128,33 +128,22 @@ let class_declarations ~old_env:_ env cxt subst id decl1 decl2 = exception Dont_match -let may_expand_module_path env path = - try ignore (Env.find_modtype_expansion path env); true - with Not_found -> false - -let expand_module_path env cxt path = +let try_expand_modtype_path env path = try Env.find_modtype_expansion path env - with Not_found -> - raise(Error[cxt, env, Unbound_modtype_path path]) + with Not_found -> raise Dont_match let expand_module_alias env cxt path = try (Env.find_module path env).md_type with Not_found -> raise(Error[cxt, env, Unbound_module_path path]) -(* -let rec normalize_module_path env cxt path = - match expand_module_alias env cxt path with - Mty_alias path' -> normalize_module_path env cxt path' - | _ -> path -*) - (* Extract name, kind and ident from a signature item *) type field_desc = Field_value of string | Field_type of string + | Field_exception of string | Field_typext of string | Field_module of string | Field_modtype of string @@ -164,6 +153,7 @@ type field_desc = let kind_of_field_desc = function | Field_value _ -> "value" | Field_type _ -> "type" + | Field_exception _ -> "exception" | Field_typext _ -> "extension constructor" | Field_module _ -> "module" | Field_modtype _ -> "module type" @@ -181,7 +171,13 @@ module FieldMap = Map.Make(struct let item_ident_name = function Sig_value(id, d, _) -> (id, d.val_loc, Field_value(Ident.name id)) | Sig_type(id, d, _, _) -> (id, d.type_loc, Field_type(Ident.name id)) - | Sig_typext(id, d, _, _) -> (id, d.ext_loc, Field_typext(Ident.name id)) + | Sig_typext(id, d, _, _) -> + let kind = + if Path.same d.ext_type_path Predef.path_exn + then Field_exception(Ident.name id) + else Field_typext(Ident.name id) + in + (id, d.ext_loc, kind) | Sig_module(id, _, d, _, _) -> (id, d.md_loc, Field_module(Ident.name id)) | Sig_modtype(id, d, _) -> (id, d.mtd_loc, Field_modtype(Ident.name id)) | Sig_class(id, d, _, _) -> (id, d.cty_loc, Field_class(Ident.name id)) @@ -235,6 +231,18 @@ and print_coercion3 ppf (i, n, c) = (* Simplify a structure coercion *) +let equal_module_paths env p1 subst p2 = + Path.same p1 p2 + || Path.same (Env.normalize_module_path None env p1) + (Env.normalize_module_path None env + (Subst.module_path subst p2)) + +let equal_modtype_paths env p1 subst p2 = + Path.same p1 p2 + || Path.same (Env.normalize_modtype_path env p1) + (Env.normalize_modtype_path env + (Subst.modtype_path subst p2)) + let simplify_structure_coercion cc id_pos_list = let rec is_identity_coercion pos = function | [] -> @@ -267,34 +275,37 @@ let rec modtypes ~loc env ~mark cxt subst mty1 mty2 = and try_modtypes ~loc env ~mark cxt subst mty1 mty2 = match mty1, mty2 with - | Mty_alias p1, Mty_alias p2 -> + | (Mty_alias p1, Mty_alias p2) -> if Env.is_functor_arg p2 env then raise (Error[cxt, env, Invalid_module_alias p2]); - if not (Path.same p1 p2) then begin - let p1 = Env.normalize_module_path None env p1 - and p2 = Env.normalize_module_path None env - (Subst.module_path subst p2) - in - if not (Path.same p1 p2) then raise Dont_match - end; + if not (equal_module_paths env p1 subst p2) then + raise Dont_match; Tcoerce_none - | (Mty_alias p1, _) -> begin + | (Mty_alias p1, _) -> let p1 = try Env.normalize_module_path (Some Location.none) env p1 with Env.Error (Env.Missing_module (_, _, path)) -> raise (Error[cxt, env, Unbound_module_path path]) in - let mty1 = - Mtype.strengthen ~aliasable:true env - (expand_module_alias env cxt p1) p1 - in - modtypes ~loc env ~mark cxt subst mty1 mty2 - end - | (Mty_ident p1, _) when may_expand_module_path env p1 -> + let mty1 = expand_module_alias env cxt p1 in + strengthened_modtypes ~loc ~aliasable:true env ~mark cxt + subst mty1 p1 mty2 + | (Mty_ident p1, Mty_ident p2) -> + let p1 = Env.normalize_modtype_path env p1 in + let p2 = Env.normalize_modtype_path env (Subst.modtype_path subst p2) in + if Path.same p1 p2 then Tcoerce_none + else + try_modtypes ~loc env ~mark cxt subst + (try_expand_modtype_path env p1) + (try_expand_modtype_path env p2) + | (Mty_ident p1, _) -> + let p1 = Env.normalize_modtype_path env p1 in try_modtypes ~loc env ~mark cxt subst - (expand_module_path env cxt p1) mty2 - | (_, Mty_ident _) -> - try_modtypes2 ~loc env ~mark cxt mty1 (Subst.modtype Keep subst mty2) + (try_expand_modtype_path env p1) mty2 + | (_, Mty_ident p2) -> + let p2 = Env.normalize_modtype_path env (Subst.modtype_path subst p2) in + try_modtypes ~loc env ~mark cxt subst mty1 + (try_expand_modtype_path env p2) | (Mty_signature sig1, Mty_signature sig2) -> signatures ~loc env ~mark cxt subst sig1 sig2 | (Mty_functor(Unit, res1), Mty_functor(Unit, res2)) -> @@ -330,18 +341,21 @@ and try_modtypes ~loc env ~mark cxt subst mty1 mty2 = | (_, _) -> raise Dont_match -and try_modtypes2 ~loc env ~mark cxt mty1 mty2 = - (* mty2 is an identifier *) - match (mty1, mty2) with - (Mty_ident p1, Mty_ident p2) - when Path.same (Env.normalize_path_prefix None env p1) - (Env.normalize_path_prefix None env p2) -> +and strengthened_modtypes ~loc ~aliasable env ~mark cxt subst mty1 path1 mty2 = + match mty1, mty2 with + | Mty_ident p1, Mty_ident p2 when equal_modtype_paths env p1 subst p2 -> Tcoerce_none - | (_, Mty_ident p2) when may_expand_module_path env p2 -> - try_modtypes ~loc env ~mark cxt Subst.identity - mty1 (expand_module_path env cxt p2) - | (_, _) -> - raise Dont_match + | _, _ -> + let mty1 = Mtype.strengthen ~aliasable env mty1 path1 in + modtypes ~loc env ~mark cxt subst mty1 mty2 + +and strengthened_module_decl ~loc ~aliasable env ~mark cxt subst md1 path1 md2 = + match md1.md_type, md2.md_type with + | Mty_ident p1, Mty_ident p2 when equal_modtype_paths env p1 subst p2 -> + Tcoerce_none + | _, _ -> + let md1 = Mtype.strengthen_decl ~aliasable env md1 path1 in + modtypes ~loc env ~mark cxt subst md1.md_type md2.md_type (* Inclusion between signatures *) @@ -501,9 +515,9 @@ and module_declarations ~loc env ~mark cxt subst id1 md1 md2 = (Ident.name id1); let p1 = Path.Pident id1 in if mark_positive mark then - Env.mark_module_used (Ident.name id1) md1.md_loc; - modtypes ~loc env ~mark (Module id1::cxt) subst - (Mtype.strengthen ~aliasable:true env md1.md_type p1) md2.md_type + Env.mark_module_used md1.md_uid; + strengthened_modtypes ~loc ~aliasable:true env ~mark (Module id1::cxt) subst + md1.md_type p1 md2.md_type (* Inclusion between module type specifications *) @@ -550,8 +564,9 @@ let can_alias env path = let check_modtype_inclusion ~loc env mty1 path1 mty2 = let aliasable = can_alias env path1 in - ignore(modtypes ~loc env ~mark:Mark_both [] Subst.identity - (Mtype.strengthen ~aliasable env mty1 path1) mty2) + ignore + (strengthened_modtypes ~loc ~aliasable env ~mark:Mark_both [] + Subst.identity mty1 path1 mty2) let () = Env.check_functor_application := @@ -567,7 +582,7 @@ let () = (* Check that an implementation of a compilation unit meets its interface. *) -let compunit env ?(mark=Mark_both) impl_name impl_sig intf_name intf_sig = +let compunit env ~mark impl_name impl_sig intf_name intf_sig = try signatures ~loc:(Location.in_file impl_name) env ~mark [] Subst.identity impl_sig intf_sig @@ -577,12 +592,16 @@ let compunit env ?(mark=Mark_both) impl_name impl_sig intf_name intf_sig = (* Hide the context and substitution parameters to the outside world *) -let modtypes ~loc env ?(mark=Mark_both) mty1 mty2 = +let modtypes ~loc env ~mark mty1 mty2 = modtypes ~loc env ~mark [] Subst.identity mty1 mty2 -let signatures env ?(mark=Mark_both) sig1 sig2 = +let signatures env ~mark sig1 sig2 = signatures ~loc:Location.none env ~mark [] Subst.identity sig1 sig2 -let type_declarations ~loc env ?(mark=Mark_both) id decl1 decl2 = +let type_declarations ~loc env ~mark id decl1 decl2 = type_declarations ~loc env ~mark [] Subst.identity id decl1 decl2 +let strengthened_module_decl ~loc ~aliasable env ~mark + md1 path1 md2 = + strengthened_module_decl ~loc ~aliasable env ~mark [] Subst.identity + md1 path1 md2 (* let modtypes env m1 m2 = diff --git a/typing/includemod.mli b/typing/includemod.mli index 4de7eee1..855b7863 100644 --- a/typing/includemod.mli +++ b/typing/includemod.mli @@ -32,9 +32,13 @@ type mark = (** Do not mark definitions used from either argument *) val modtypes: - loc:Location.t -> Env.t -> ?mark:mark -> + loc:Location.t -> Env.t -> mark:mark -> module_type -> module_type -> module_coercion +val strengthened_module_decl: + loc:Location.t -> aliasable:bool -> Env.t -> mark:mark -> + module_declaration -> Path.t -> module_declaration -> module_coercion + val check_modtype_inclusion : loc:Location.t -> Env.t -> Types.module_type -> Path.t -> Types.module_type -> unit @@ -42,15 +46,15 @@ val check_modtype_inclusion : functor application F(M) is well typed, where mty2 is the type of the argument of F and path1/mty1 is the path/unstrenghened type of M. *) -val signatures: Env.t -> ?mark:mark -> +val signatures: Env.t -> mark:mark -> signature -> signature -> module_coercion val compunit: - Env.t -> ?mark:mark -> string -> signature -> + Env.t -> mark:mark -> string -> signature -> string -> signature -> module_coercion val type_declarations: - loc:Location.t -> Env.t -> ?mark:mark -> + loc:Location.t -> Env.t -> mark:mark -> Ident.t -> type_declaration -> type_declaration -> unit val print_coercion: formatter -> module_coercion -> unit diff --git a/typing/mtype.ml b/typing/mtype.ml index 38894e13..edb4e1b7 100644 --- a/typing/mtype.ml +++ b/typing/mtype.ml @@ -213,7 +213,7 @@ and nondep_sig_item env va ids = function with Ctype.Nondep_cannot_erase _ as exn -> match va with Co -> Sig_modtype(id, {mtd_type=None; mtd_loc=Location.none; - mtd_attributes=[]}, vis) + mtd_attributes=[]; mtd_uid = d.mtd_uid}, vis) | _ -> raise exn end | Sig_class(id, d, rs, vis) -> @@ -240,11 +240,11 @@ let enrich_typedecl env p id decl = decl else let orig_ty = - Ctype.reify_univars + Ctype.reify_univars env (Btype.newgenty(Tconstr(p, orig_decl.type_params, ref Mnil))) in let new_ty = - Ctype.reify_univars + Ctype.reify_univars env (Btype.newgenty(Tconstr(Pident id, decl.type_params, ref Mnil))) in let env = Env.add_type ~check:false id decl env in diff --git a/typing/parmatch.ml b/typing/parmatch.ml index 6ca3ebe7..1209ef8c 100644 --- a/typing/parmatch.ml +++ b/typing/parmatch.ml @@ -141,8 +141,6 @@ end = struct | Tpat_lazy p -> Lazy, [p] | Tpat_or _ -> invalid_arg "Parmatch.Pattern_head.deconstruct: (P | Q)" - | Tpat_exception _ -> - invalid_arg "Parmatch.Pattern_head.deconstruct: (exception P)" in let desc, pats = deconstruct_desc q.pat_desc in { desc; typ = q.pat_type; loc = q.pat_loc; @@ -395,11 +393,11 @@ let const_compare x y = match x,y with | Const_float f1, Const_float f2 -> Stdlib.compare (float_of_string f1) (float_of_string f2) - | Const_string (s1, _), Const_string (s2, _) -> + | Const_string (s1, _, _), Const_string (s2, _, _) -> String.compare s1 s2 | (Const_int _ |Const_char _ - |Const_string (_, _) + |Const_string (_, _, _) |Const_float _ |Const_int32 _ |Const_int64 _ @@ -976,7 +974,7 @@ let complete_tags nconsts nconstrs tags = (* build a pattern from a constructor description *) let pat_of_constr ex_pat cstr = {ex_pat with pat_desc = - Tpat_construct (mknoloc (Longident.Lident "?pat_of_constr?"), + Tpat_construct (mknoloc (Longident.Lident cstr.cstr_name), cstr, omegas cstr.cstr_arity)} let orify x y = make_pat (Tpat_or (x, y, None)) x.pat_type x.pat_env @@ -997,7 +995,8 @@ let pats_of_type ?(always=false) env ty = match ty'.desc with | Tconstr (path, _, _) -> begin try match (Env.find_type path env).type_kind with - | Type_variant cl when always || List.length cl = 1 || + | Type_variant cl when always || List.length cl <= 1 || + (* Only explode when all constructors are GADTs *) List.for_all (fun cd -> cd.Types.cd_res <> None) cl -> let cstrs = fst (Env.find_type_descrs path env) in List.map (pat_of_constr (make_pat Tpat_any ty env)) cstrs @@ -1005,7 +1004,7 @@ let pats_of_type ?(always=false) env ty = let labels = snd (Env.find_type_descrs path env) in let fields = List.map (fun ld -> - mknoloc (Longident.Lident "?pat_of_label?"), ld, omega) + mknoloc (Longident.Lident ld.lbl_name), ld, omega) labels in [make_pat (Tpat_record (fields, Closed)) ty env] @@ -1193,9 +1192,11 @@ let build_other ext env = 0n Nativeint.succ d env | Constant Const_string _ -> build_other_constant - (function Constant(Const_string (s, _)) -> String.length s + (function Constant(Const_string (s, _, _)) -> String.length s | _ -> assert false) - (function i -> Tpat_constant(Const_string(String.make i '*', None))) + (function i -> + Tpat_constant + (Const_string(String.make i '*',Location.none,None))) 0 succ d env | Constant Const_float _ -> build_other_constant @@ -1229,8 +1230,6 @@ let rec has_instance p = match p.pat_desc with | Tpat_record (lps,_) -> has_instances (List.map (fun (_,_,x) -> x) lps) | Tpat_lazy p -> has_instance p - | Tpat_exception _ -> assert false - and has_instances = function | [] -> true @@ -1955,10 +1954,15 @@ and lubs ps qs = match ps,qs with (* Apply pressure to variants *) let pressure_variants tdefs patl = + ignore (pressure_variants + (Some tdefs) + (List.map (fun p -> [p; omega]) patl)) + +let pressure_variants_in_computation_pattern tdefs patl = let add_row pss p_opt = match p_opt with | None -> pss - | Some p -> [p; omega] :: pss + | Some p -> p :: pss in let val_pss, exn_pss = List.fold_right (fun pat (vpss, epss)-> @@ -1966,8 +1970,8 @@ let pressure_variants tdefs patl = add_row vpss vp, add_row epss ep ) patl ([], []) in - ignore (pressure_variants (Some tdefs) val_pss); - ignore (pressure_variants (Some tdefs) exn_pss) + pressure_variants tdefs val_pss; + pressure_variants tdefs exn_pss (*****************************) (* Utilities for diagnostics *) @@ -2055,8 +2059,6 @@ module Conv = struct mkpat (Ppat_array (List.map loop lst)) | Tpat_lazy p -> mkpat (Ppat_lazy (loop p)) - | Tpat_exception _ -> - assert false in let ps = loop typed in (ps, constrs, labels) @@ -2071,14 +2073,27 @@ let contains_extension pat = | _ -> false) pat -(* Build an untyped or-pattern from its expected type *) +(* 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 - | [] -> raise Empty - | [{pat_desc = Tpat_any}] -> - (Conv.mkpat Parsetree.Ppat_any, Hashtbl.create 0, Hashtbl.create 0) + | [] -> 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 -> - Conv.conv (orify_many pats) + let (ppat, constrs, labels) = Conv.conv (orify_many pats) in + PT_pattern (PE_gadt_cases, ppat, constrs, labels) let do_check_partial ~pred loc casel pss = match pss with | [] -> @@ -2182,7 +2197,6 @@ let rec collect_paths_from_pat r p = match p.pat_desc with | Tpat_lazy p -> collect_paths_from_pat r p -| Tpat_exception _ -> assert false (* @@ -2314,7 +2328,6 @@ let inactive ~partial pat = ldps | Tpat_or (p,q,_) -> loop p && loop q - | Tpat_exception _ -> assert false in loop pat end diff --git a/typing/parmatch.mli b/typing/parmatch.mli index e7778fdf..e6952be7 100644 --- a/typing/parmatch.mli +++ b/typing/parmatch.mli @@ -28,6 +28,48 @@ val omegas : int -> pattern list val omega_list : 'a list -> pattern list (** [List.map (fun _ -> omega)] *) +module Pattern_head : sig + type desc = + | Any + | Construct of constructor_description + | Constant of constant + | Tuple of int + | Record of label_description list + | Variant of + { tag: label; has_arg: bool; + cstr_row: row_desc ref; + type_row : unit -> row_desc; } + (* the row of the type may evolve if [close_variant] is called, + hence the (unit -> ...) delay *) + | Array of int + | Lazy + + type t + + val desc : t -> desc + val env : t -> Env.t + val loc : t -> Location.t + val typ : t -> Types.type_expr + + (** [deconstruct p] returns the head of [p] and the list of sub patterns. + + @raises [Invalid_arg _] if [p] is an or- or an exception-pattern. *) + val deconstruct : pattern -> t * pattern list + + (** reconstructs a pattern, putting wildcards as sub-patterns. *) + val to_omega_pattern : t -> pattern + + val make + : loc:Location.t + -> typ:Types.type_expr + -> env:Env.t + -> desc + -> t + + val omega : t + +end + val normalize_pat : pattern -> pattern (** Keep only the "head" of a pattern: all arguments are replaced by [omega], so are variables. *) @@ -82,15 +124,33 @@ val pat_of_constr : pattern -> constructor_description -> pattern val complete_constrs : pattern -> constructor_tag list -> constructor_description list -(** [ppat_of_type] builds an untyped or-pattern from its expected type. - May raise [Empty] when [type_expr] is an empty variant *) -val ppat_of_type : - Env.t -> type_expr -> - Parsetree.pattern * - (string, constructor_description) Hashtbl.t * - (string, label_description) Hashtbl.t +(** [ppat_of_type] builds an untyped pattern from its expected type, + for explosion of wildcard patterns in Typecore.type_pat. -val pressure_variants: Env.t -> pattern list -> unit + There are four interesting cases: + - the type is empty ([PT_empty]) + - no further explosion is necessary ([PT_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]). + *) +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 pressure_variants: + Env.t -> pattern list -> unit +val pressure_variants_in_computation_pattern: + Env.t -> computation general_pattern list -> unit (** [check_partial pred loc caselist] and [check_unused refute pred caselist] are called with a function [pred] which will be given counter-example @@ -103,13 +163,13 @@ val check_partial: ((string, constructor_description) Hashtbl.t -> (string, label_description) Hashtbl.t -> Parsetree.pattern -> pattern option) -> - Location.t -> case list -> partial + Location.t -> value case list -> partial val check_unused: (bool -> (string, constructor_description) Hashtbl.t -> (string, label_description) Hashtbl.t -> Parsetree.pattern -> pattern option) -> - case list -> unit + value case list -> unit (* Irrefutability tests *) val irrefutable : pattern -> bool @@ -121,7 +181,7 @@ val irrefutable : pattern -> bool val inactive : partial:partial -> pattern -> bool (* Ambiguous bindings *) -val check_ambiguous_bindings : case list -> unit +val check_ambiguous_bindings : value case list -> unit (* The tag used for open polymorphic variant types with an abstract row *) val some_private_tag : label diff --git a/typing/persistent_env.ml b/typing/persistent_env.ml index 9b747668..1931f5f3 100644 --- a/typing/persistent_env.ml +++ b/typing/persistent_env.ml @@ -104,7 +104,7 @@ let clear_missing {persistent_structures; _} = let add_import {imported_units; _} s = imported_units := String.Set.add s !imported_units -let add_imported_opaque {imported_opaque_units; _} s = +let register_import_as_opaque {imported_opaque_units; _} s = imported_opaque_units := String.Set.add s !imported_opaque_units let find_in_cache {persistent_structures; _} s = @@ -125,7 +125,11 @@ let import_crcs penv ~source crcs = let check_consistency penv ps = try import_crcs penv ~source:ps.ps_filename ps.ps_crcs - with Consistbl.Inconsistency(name, source, auth) -> + with Consistbl.Inconsistency { + unit_name = name; + inconsistent_source = source; + original_source = auth; + } -> error (Inconsistent_import(name, auth, source)) let can_load_cmis penv = @@ -160,7 +164,7 @@ let save_pers_struct penv crc ps pm = | Rectypes -> () | Alerts _ -> () | Unsafe_string -> () - | Opaque -> add_imported_opaque penv modname) + | Opaque -> register_import_as_opaque penv modname) ps.ps_flags; Consistbl.set crc_units modname crc ps.ps_filename; add_import penv modname @@ -186,7 +190,7 @@ let acknowledge_pers_struct penv check modname pers_sig pm = if Config.safe_string then error (Depend_on_unsafe_string_unit(ps.ps_name)); | Alerts _ -> () - | Opaque -> add_imported_opaque penv modname) + | Opaque -> register_import_as_opaque penv modname) ps.ps_flags; if check then check_consistency penv ps; let {persistent_structures; _} = penv in diff --git a/typing/persistent_env.mli b/typing/persistent_env.mli index d04034ef..ac3109c3 100644 --- a/typing/persistent_env.mli +++ b/typing/persistent_env.mli @@ -77,6 +77,10 @@ val is_imported : 'a t -> modname -> bool in [penv] as an opaque module *) val is_imported_opaque : 'a t -> modname -> bool +(* [register_import_as_opaque penv md] registers [md] in [penv] as an + opaque module *) +val register_import_as_opaque : 'a t -> modname -> unit + val make_cmi : 'a t -> modname -> Types.signature -> alerts -> Cmi_format.cmi_infos diff --git a/typing/predef.ml b/typing/predef.ml index 24f51dec..786d1dc2 100644 --- a/typing/predef.ml +++ b/typing/predef.ml @@ -116,23 +116,6 @@ let path_match_failure = Pident ident_match_failure and path_assert_failure = Pident ident_assert_failure and path_undefined_recursive_module = Pident ident_undefined_recursive_module -let decl_abstr = - {type_params = []; - type_arity = 0; - type_kind = Type_abstract; - type_loc = Location.none; - type_private = Asttypes.Public; - type_manifest = None; - type_variance = []; - type_is_newtype = false; - type_expansion_scope = lowest_level; - type_attributes = []; - type_immediate = Unknown; - type_unboxed = unboxed_false_default_false; - } - -let decl_abstr_imm = {decl_abstr with type_immediate = Always} - let cstr id args = { cd_id = id; @@ -140,6 +123,7 @@ let cstr id args = cd_res = None; cd_loc = Location.none; cd_attributes = []; + cd_uid = Uid.of_predef_id id; } let ident_false = ident_create "false" @@ -149,47 +133,52 @@ and ident_nil = ident_create "[]" and ident_cons = ident_create "::" and ident_none = ident_create "None" and ident_some = ident_create "Some" -let common_initial_env add_type add_extension empty_env = - let decl_bool = - {decl_abstr with - type_kind = Type_variant([cstr ident_false []; cstr ident_true []]); - type_immediate = Always} - and decl_unit = - {decl_abstr with - type_kind = Type_variant([cstr ident_void []]); - type_immediate = Always} - and decl_exn = - {decl_abstr with - type_kind = Type_open} - and decl_array = - let tvar = newgenvar() in - {decl_abstr with - type_params = [tvar]; - type_arity = 1; - type_variance = [Variance.full]} - and decl_list = - let tvar = newgenvar() in - {decl_abstr with - type_params = [tvar]; - type_arity = 1; - type_kind = - Type_variant([cstr ident_nil []; cstr ident_cons [tvar; type_list tvar]]); - type_variance = [Variance.covariant]} - and decl_option = - let tvar = newgenvar() in - {decl_abstr with - type_params = [tvar]; - type_arity = 1; - type_kind = Type_variant([cstr ident_none []; cstr ident_some [tvar]]); - type_variance = [Variance.covariant]} - and decl_lazy_t = - let tvar = newgenvar() in - {decl_abstr with - type_params = [tvar]; - type_arity = 1; - type_variance = [Variance.covariant]} + +let mk_add_type add_type type_ident + ?manifest ?(immediate=Type_immediacy.Unknown) ?(kind=Type_abstract) env = + let decl = + {type_params = []; + type_arity = 0; + type_kind = kind; + type_loc = Location.none; + type_private = Asttypes.Public; + type_manifest = manifest; + type_variance = []; + type_separability = []; + type_is_newtype = false; + type_expansion_scope = lowest_level; + type_attributes = []; + type_immediate = immediate; + type_unboxed = unboxed_false_default_false; + type_uid = Uid.of_predef_id type_ident; + } in + add_type type_ident decl env +let common_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 = + let param = newgenvar () in + let decl = + {type_params = [param]; + type_arity = 1; + type_kind = kind param; + type_loc = Location.none; + type_private = Asttypes.Public; + type_manifest = None; + type_variance = [variance]; + type_separability = [separability]; + type_is_newtype = false; + type_expansion_scope = lowest_level; + type_attributes = []; + type_immediate = Unknown; + type_unboxed = unboxed_false_default_false; + type_uid = Uid.of_predef_id type_ident; + } + in + add_type type_ident decl env + in let add_extension id l = add_extension id { ext_type_path = path_exn; @@ -200,7 +189,9 @@ let common_initial_env add_type add_extension empty_env = ext_loc = Location.none; ext_attributes = [Ast_helper.Attr.mk (Location.mknoloc "ocaml.warn_on_literal_pattern") - (Parsetree.PStr [])] } + (Parsetree.PStr [])]; + ext_uid = Uid.of_predef_id id; + } in add_extension ident_match_failure [newgenty (Ttuple[type_string; type_int; type_int])] ( @@ -217,29 +208,40 @@ let common_initial_env add_type add_extension empty_env = [newgenty (Ttuple[type_string; type_int; type_int])] ( add_extension ident_undefined_recursive_module [newgenty (Ttuple[type_string; type_int; type_int])] ( - add_type ident_int64 decl_abstr ( - add_type ident_int32 decl_abstr ( - add_type ident_nativeint decl_abstr ( - add_type ident_lazy_t decl_lazy_t ( - add_type ident_option decl_option ( - add_type ident_list decl_list ( - add_type ident_array decl_array ( - add_type ident_exn decl_exn ( - add_type ident_unit decl_unit ( - add_type ident_bool decl_bool ( - add_type ident_float decl_abstr ( - add_type ident_string decl_abstr ( - add_type ident_char decl_abstr_imm ( - add_type ident_int decl_abstr_imm ( - add_type ident_extension_constructor decl_abstr ( - add_type ident_floatarray decl_abstr ( + add_type ident_int64 ( + add_type ident_int32 ( + add_type ident_nativeint ( + add_type1 ident_lazy_t ~variance:Variance.covariant + ~separability:Separability.Ind ( + add_type1 ident_option ~variance:Variance.covariant + ~separability:Separability.Ind + ~kind:(fun tvar -> + Type_variant([cstr ident_none []; cstr ident_some [tvar]]) + ) ( + add_type1 ident_list ~variance:Variance.covariant + ~separability:Separability.Ind + ~kind:(fun tvar -> + Type_variant([cstr ident_nil []; cstr ident_cons [tvar; type_list tvar]]) + ) ( + add_type1 ident_array ~variance:Variance.full ~separability:Separability.Ind ( + add_type ident_exn ~kind:Type_open ( + add_type ident_unit ~immediate:Always + ~kind:(Type_variant([cstr ident_void []])) ( + add_type ident_bool ~immediate:Always + ~kind:(Type_variant([cstr ident_false []; cstr ident_true []])) ( + add_type ident_float ( + add_type ident_string ( + add_type ident_char ~immediate:Always ( + add_type ident_int ~immediate:Always ( + add_type ident_extension_constructor ( + add_type ident_floatarray ( empty_env)))))))))))))))))))))))))))) let build_initial_env add_type add_exception empty_env = let common = common_initial_env add_type add_exception empty_env in - let safe_string = add_type ident_bytes decl_abstr common in - let decl_bytes_unsafe = {decl_abstr with type_manifest = Some type_string} in - let unsafe_string = add_type ident_bytes decl_bytes_unsafe common 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 = diff --git a/typing/printpat.ml b/typing/printpat.ml index 03cd0cd7..43a18649 100644 --- a/typing/printpat.ml +++ b/typing/printpat.ml @@ -27,25 +27,28 @@ let is_cons = function let pretty_const c = match c with | Const_int i -> Printf.sprintf "%d" i | Const_char c -> Printf.sprintf "%C" c -| Const_string (s, _) -> Printf.sprintf "%S" s +| Const_string (s, _, _) -> Printf.sprintf "%S" s | Const_float f -> Printf.sprintf "%s" f | Const_int32 i -> Printf.sprintf "%ldl" i | Const_int64 i -> Printf.sprintf "%LdL" i | Const_nativeint i -> Printf.sprintf "%ndn" i -let rec pretty_val ppf v = +let pretty_extra ppf (cstr, _loc, _attrs) pretty_rest rest = + match cstr with + | Tpat_unpack -> + fprintf ppf "@[(module %a)@]" pretty_rest rest + | Tpat_constraint _ -> + fprintf ppf "@[(%a : _)@]" pretty_rest rest + | Tpat_type _ -> + fprintf ppf "@[(# %a)@]" pretty_rest rest + | Tpat_open _ -> + fprintf ppf "@[(# %a)@]" pretty_rest rest + +let rec pretty_val : type k . _ -> k general_pattern -> _ = fun ppf v -> match v.pat_extra with - (cstr, _loc, _attrs) :: rem -> - begin match cstr with - | Tpat_unpack -> - fprintf ppf "@[(module %a)@]" pretty_val { v with pat_extra = rem } - | Tpat_constraint _ -> - fprintf ppf "@[(%a : _)@]" pretty_val { v with pat_extra = rem } - | Tpat_type _ -> - fprintf ppf "@[(# %a)@]" pretty_val { v with pat_extra = rem } - | Tpat_open _ -> - fprintf ppf "@[(# %a)@]" pretty_val { v with pat_extra = rem } - end + | extra :: rem -> + pretty_extra ppf extra + pretty_val { v with pat_extra = rem } | [] -> match v.pat_desc with | Tpat_any -> fprintf ppf "_" @@ -89,12 +92,14 @@ let rec pretty_val ppf v = fprintf ppf "@[[| %a |]@]" (pretty_vals " ;") vs | Tpat_lazy v -> fprintf ppf "@[<2>lazy@ %a@]" pretty_arg v - | Tpat_exception v -> - fprintf ppf "@[<2>exception@ %a@]" pretty_arg v | Tpat_alias (v, x,_) -> fprintf ppf "@[(%a@ as %a)@]" pretty_val v Ident.print x - | Tpat_or (v,w,_) -> - fprintf ppf "@[(%a|@,%a)@]" pretty_or v pretty_or w + | Tpat_value v -> + fprintf ppf "%a" pretty_val (v :> pattern) + | Tpat_exception v -> + fprintf ppf "@[<2>exception@ %a@]" pretty_arg v + | Tpat_or _ -> + fprintf ppf "@[(%a)@]" pretty_or v and pretty_car ppf v = match v.pat_desc with | Tpat_construct (_,cstr, [_ ; _]) @@ -113,10 +118,11 @@ and pretty_arg ppf v = match v.pat_desc with | Tpat_variant (_, Some _, _) -> fprintf ppf "(%a)" pretty_val v | _ -> pretty_val ppf v -and pretty_or ppf v = match v.pat_desc with -| Tpat_or (v,w,_) -> - fprintf ppf "%a|@,%a" pretty_or v pretty_or w -| _ -> pretty_val ppf v +and pretty_or : type k . _ -> k general_pattern -> _ = fun ppf v -> + match v.pat_desc with + | Tpat_or (v,w,_) -> + fprintf ppf "%a|@,%a" pretty_or v pretty_or w + | _ -> pretty_val ppf v and pretty_vals sep ppf = function | [] -> () @@ -135,12 +141,11 @@ and pretty_lvals ppf = function 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 ()) -type matrix = pattern list list +type 'k matrix = 'k general_pattern list list let pretty_line fmt = List.iter (fun p -> @@ -149,7 +154,7 @@ let pretty_line fmt = Format.fprintf fmt ">"; ) -let pretty_matrix fmt (pss : matrix) = +let pretty_matrix fmt (pss : 'k matrix) = Format.fprintf fmt "begin matrix\n" ; List.iter (fun ps -> pretty_line fmt ps ; diff --git a/typing/printpat.mli b/typing/printpat.mli index 48292bf8..1865a2ab 100644 --- a/typing/printpat.mli +++ b/typing/printpat.mli @@ -15,8 +15,13 @@ -val pretty_const : Asttypes.constant -> string -val top_pretty : Format.formatter -> Typedtree.pattern -> unit -val pretty_pat : Typedtree.pattern -> unit -val pretty_line : Format.formatter -> Typedtree.pattern list -> unit -val pretty_matrix : Format.formatter -> Typedtree.pattern list list -> unit +val pretty_const + : Asttypes.constant -> string +val top_pretty + : Format.formatter -> 'k Typedtree.general_pattern -> unit +val pretty_pat + : 'k Typedtree.general_pattern -> unit +val pretty_line + : Format.formatter -> 'k Typedtree.general_pattern list -> unit +val pretty_matrix + : Format.formatter -> 'k Typedtree.general_pattern list list -> unit diff --git a/typing/printtyp.ml b/typing/printtyp.ml index 0c7821a7..5cdd914f 100644 --- a/typing/printtyp.ml +++ b/typing/printtyp.ml @@ -46,6 +46,12 @@ end (* printing environment for path shortening and naming *) let printing_env = ref Env.empty + +(* When printing, it is important to only observe the + current printing environment, without reading any new + 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 = @@ -79,10 +85,11 @@ module Namespace = struct let pp ppf x = Format.pp_print_string ppf (show x) + (** The two functions below should never access the filesystem, + and thus use {!in_printing_env} rather than directly + accessing the printing environment *) let lookup = - let to_lookup f lid = - fst @@ f (Lident lid) !printing_env - in + 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 @@ -92,15 +99,14 @@ module Namespace = struct | Other -> fun _ -> raise Not_found let location namespace id = - let env = !printing_env in let path = Path.Pident id in try Some ( match namespace with - | Type -> (Env.find_type path env).type_loc - | Module -> (Env.find_module path env).md_loc - | Module_type -> (Env.find_modtype path env).mtd_loc - | Class -> (Env.find_class path env).cty_loc - | Class_type -> (Env.find_cltype path env).clty_loc + | 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 ) with Not_found -> None @@ -330,7 +336,7 @@ let ident_stdlib = Ident.create_persistent "Stdlib" let non_shadowed_pervasive = function | Pdot(Pident id, s) as path -> Ident.same id ident_stdlib && - (match Env.find_type_by_name (Lident s) !printing_env with + (match in_printing_env (Env.find_type_by_name (Lident s)) with | (path', _) -> Path.same path path' | exception Not_found -> true) | _ -> false @@ -942,20 +948,18 @@ let rec tree_of_typexp sch ty = let name_gen = if non_gen then new_weak_name ty else new_name in Otyp_var (non_gen, name_of_type name_gen ty) | Tarrow(l, ty1, ty2, _) -> - let pr_arrow l ty1 ty2 = - let lab = - if !print_labels || is_optional l then string_of_label l else "" - in - let t1 = - if is_optional l then - match (repr ty1).desc with - | Tconstr(path, [ty], _) - when Path.same path Predef.path_option -> - tree_of_typexp sch ty - | _ -> Otyp_stuff "" - else tree_of_typexp sch ty1 in - Otyp_arrow (lab, t1, tree_of_typexp sch ty2) in - pr_arrow l ty1 ty2 + let lab = + if !print_labels || is_optional l then string_of_label l else "" + in + let t1 = + if is_optional l then + match (repr ty1).desc with + | Tconstr(path, [ty], _) + when Path.same path Predef.path_option -> + tree_of_typexp sch ty + | _ -> Otyp_stuff "" + else tree_of_typexp sch ty1 in + Otyp_arrow (lab, t1, tree_of_typexp sch ty2) | Ttuple tyl -> Otyp_tuple (tree_of_typlist sch tyl) | Tconstr(p, tyl, _abbrev) -> @@ -1113,6 +1117,12 @@ and type_sch ppf ty = typexp true ppf ty and type_scheme ppf ty = reset_and_mark_loops ty; typexp true ppf ty +let type_path ppf p = + let (p', s) = best_type_path p in + let p = if (s = Id) then p' else p in + let t = tree_of_path Type p in + !Oprint.out_ident ppf t + (* Maxence *) let type_scheme_max ?(b_reset_names=true) ppf ty = if b_reset_names then reset_names () ; @@ -1572,13 +1582,21 @@ let filter_rem_sig item rem = ([], rem) let dummy = - { type_params = []; type_arity = 0; type_kind = Type_abstract; - type_private = Public; type_manifest = None; type_variance = []; - type_is_newtype = false; type_expansion_scope = Btype.lowest_level; + { + type_params = []; + type_arity = 0; + type_kind = Type_abstract; + type_private = Public; + type_manifest = None; + type_variance = []; + type_separability = []; + type_is_newtype = false; + type_expansion_scope = Btype.lowest_level; type_loc = Location.none; type_attributes = []; type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = Uid.internal_not_actually_unique; } let hide ids env = List.fold_right diff --git a/typing/printtyp.mli b/typing/printtyp.mli index 1bd7fbdb..fba02c6f 100644 --- a/typing/printtyp.mli +++ b/typing/printtyp.mli @@ -25,6 +25,10 @@ val tree_of_path: Path.t -> out_ident val path: formatter -> Path.t -> unit val string_of_path: Path.t -> string +val type_path: formatter -> Path.t -> unit +(** Print a type path taking account of [-short-paths]. + Calls should be within [wrap_printing_env]. *) + module Out_name: sig val create: string -> out_name val print: out_name -> string @@ -88,7 +92,6 @@ module Conflicts: sig val reset: unit -> unit end - val reset: unit -> unit val mark_loops: type_expr -> unit val reset_and_mark_loops: type_expr -> unit diff --git a/typing/printtyped.ml b/typing/printtyped.ml index a637eaf8..15aa0972 100644 --- a/typing/printtyped.ml +++ b/typing/printtyped.ml @@ -27,8 +27,11 @@ let fmt_position f l = ;; 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"; + if not !Clflags.locations then () + else begin + 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 = @@ -61,9 +64,10 @@ 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_string (s, None) -> fprintf f "Const_string(%S,None)" s; - | Const_string (s, Some delim) -> - fprintf f "Const_string (%S,Some %S)" s delim; + | Const_string (s, strloc, None) -> + 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; @@ -222,27 +226,13 @@ and package_with i ppf (s, t) = line i ppf "with type %a\n" fmt_longident s; core_type i ppf t -and pattern i ppf x = +and pattern : type k . _ -> _ -> k general_pattern -> unit = fun i ppf x -> line i ppf "pattern %a\n" fmt_location x.pat_loc; attributes i ppf x.pat_attributes; let i = i+1 in match x.pat_extra with - | (Tpat_unpack, _, attrs) :: rem -> - line i ppf "Tpat_unpack\n"; - attributes i ppf attrs; - pattern i ppf { x with pat_extra = rem } - | (Tpat_constraint cty, _, attrs) :: rem -> - line i ppf "Tpat_constraint\n"; - attributes i ppf attrs; - core_type i ppf cty; - pattern i ppf { x with pat_extra = rem } - | (Tpat_type (id, _), _, attrs) :: rem -> - line i ppf "Tpat_type %a\n" fmt_path id; - attributes i ppf attrs; - pattern i ppf { x with pat_extra = rem } - | (Tpat_open (id,_,_), _, attrs)::rem -> - line i ppf "Tpat_open \"%a\"\n" fmt_path id; - attributes i ppf attrs; + | extra :: rem -> + pattern_extra i ppf extra; pattern i ppf { x with pat_extra = rem } | [] -> match x.pat_desc with @@ -267,16 +257,35 @@ and pattern i ppf x = | Tpat_array (l) -> line i ppf "Tpat_array\n"; list i pattern ppf l; - | Tpat_or (p1, p2, _) -> - line i ppf "Tpat_or\n"; - pattern i ppf p1; - pattern i ppf p2; | Tpat_lazy p -> line i ppf "Tpat_lazy\n"; pattern i ppf p; | Tpat_exception p -> line i ppf "Tpat_exception\n"; pattern i ppf p; + | Tpat_value p -> + line i ppf "Tpat_value\n"; + pattern i ppf (p :> pattern); + | Tpat_or (p1, p2, _) -> + line i ppf "Tpat_or\n"; + pattern i ppf p1; + pattern i ppf p2; + +and pattern_extra i ppf (extra_pat, _, attrs) = + match extra_pat with + | Tpat_unpack -> + line i ppf "Tpat_extra_unpack\n"; + attributes i ppf attrs; + | Tpat_constraint cty -> + line i ppf "Tpat_extra_constraint\n"; + attributes i ppf attrs; + core_type i ppf cty; + | Tpat_type (id, _) -> + line i ppf "Tpat_extra_type %a\n" fmt_path id; + attributes i ppf attrs; + | Tpat_open (id,_,_) -> + line i ppf "Tpat_extra_open \"%a\"\n" fmt_path id; + attributes i ppf attrs; and expression_extra i ppf x attrs = match x with @@ -881,7 +890,9 @@ and longident_x_pattern i ppf (li, _, p) = line i ppf "%a\n" fmt_longident li; pattern (i+1) ppf p; -and case i ppf {c_lhs; c_guard; c_rhs} = +and case + : type k . _ -> _ -> k case -> unit + = fun i ppf {c_lhs; c_guard; c_rhs} -> line i ppf "\n"; pattern (i+1) ppf c_lhs; begin match c_guard with diff --git a/typing/rec_check.ml b/typing/rec_check.ml index 5b224f94..1248484c 100644 --- a/typing/rec_check.ml +++ b/typing/rec_check.ml @@ -761,7 +761,7 @@ let rec expression : Typedtree.expression -> term_judg = ] | Texp_override (pth, fields) -> (* - G |- pth : m (Gi |- ei : m[Derefence])^i + G |- pth : m (Gi |- ei : m[Dereference])^i ---------------------------------------------------- G + sum(Gi)^i |- {< (xi = ei)^i >} (at path pth) : m @@ -1144,8 +1144,9 @@ and value_bindings : rec_flag -> Typedtree.value_binding list -> bind_judg = m' is the mode under which the scrutinee of p (the value matched against p) is placed. *) -and case : Typedtree.case -> mode -> Env.t * mode = - fun { Typedtree.c_lhs; c_guard; c_rhs } -> +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 @@ -1165,7 +1166,7 @@ and case : Typedtree.case -> mode -> Env.t * mode = m is the mode under which the scrutinee of p is placed. *) -and pattern : pattern -> Env.t -> mode = fun pat env -> +and pattern : type k . k general_pattern -> Env.t -> mode = fun pat env -> (* mp := | Dereference if p is destructuring | Guard otherwise @@ -1184,7 +1185,7 @@ and pattern : pattern -> Env.t -> mode = fun pat env -> in Mode.join m_pat m_env -and is_destructuring_pattern : Typedtree.pattern -> bool = +and is_destructuring_pattern : type k . k general_pattern -> bool = fun pat -> match pat.pat_desc with | Tpat_any -> false | Tpat_var (_, _) -> false @@ -1195,10 +1196,11 @@ and is_destructuring_pattern : Typedtree.pattern -> bool = | Tpat_variant _ -> true | Tpat_record (_, _) -> true | Tpat_array _ -> true - | Tpat_or (l,r,_) -> - is_destructuring_pattern l || is_destructuring_pattern r | 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 = let ty = expression expr Return in diff --git a/typing/stypes.ml b/typing/stypes.ml index 5e6ef97d..dfbcc991 100644 --- a/typing/stypes.ml +++ b/typing/stypes.ml @@ -30,7 +30,7 @@ open Typedtree;; let output_int oc i = output_string oc (Int.to_string i) type annotation = - | Ti_pat of pattern + | Ti_pat : 'k pattern_category * 'k general_pattern -> annotation | Ti_expr of expression | Ti_class of class_expr | Ti_mod of module_expr @@ -40,7 +40,7 @@ type annotation = let get_location ti = match ti with - Ti_pat p -> p.pat_loc + | Ti_pat (_, p) -> p.pat_loc | Ti_expr e -> e.exp_loc | Ti_class c -> c.cl_loc | Ti_mod m -> m.mod_loc @@ -149,8 +149,8 @@ let print_ident_annot pp str k = let print_info pp prev_loc ti = match ti with | Ti_class _ | Ti_mod _ -> prev_loc - | Ti_pat {pat_loc = loc; pat_type = typ; pat_env = env} - | Ti_expr {exp_loc = loc; exp_type = typ; exp_env = env} -> + | Ti_pat (_, {pat_loc = loc; pat_type = typ; pat_env = env}) + | Ti_expr {exp_loc = loc; exp_type = typ; exp_env = env} -> if loc <> prev_loc then begin print_location pp loc; output_char pp '\n' diff --git a/typing/stypes.mli b/typing/stypes.mli index 46df1ce6..fda575fc 100644 --- a/typing/stypes.mli +++ b/typing/stypes.mli @@ -20,7 +20,7 @@ open Typedtree;; type annotation = - | Ti_pat of pattern + | Ti_pat : 'k pattern_category * 'k general_pattern -> annotation | Ti_expr of expression | Ti_class of class_expr | Ti_mod of module_expr diff --git a/typing/subst.ml b/typing/subst.ml index 5ae3d1b4..9d209b2f 100644 --- a/typing/subst.ml +++ b/typing/subst.ml @@ -189,7 +189,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 } -> - (!ctype_apply_env_empty params body args).desc + Tlink (!ctype_apply_env_empty params body args) end | Tpackage(p, n, tl) -> Tpackage(modtype_path s p, n, List.map (typexp copy_scope s) tl) @@ -263,6 +263,7 @@ let label_declaration copy_scope s l = ld_type = typexp copy_scope s l.ld_type; ld_loc = loc s l.ld_loc; ld_attributes = attrs s l.ld_attributes; + ld_uid = l.ld_uid; } let constructor_arguments copy_scope s = function @@ -278,6 +279,7 @@ let constructor_declaration copy_scope s c = cd_res = Option.map (typexp copy_scope s) c.cd_res; cd_loc = loc s c.cd_loc; cd_attributes = attrs s c.cd_attributes; + cd_uid = c.cd_uid; } let type_declaration' copy_scope s decl = @@ -300,12 +302,14 @@ let type_declaration' copy_scope s decl = end; type_private = decl.type_private; type_variance = decl.type_variance; + type_separability = decl.type_separability; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = loc s decl.type_loc; type_attributes = attrs s decl.type_attributes; type_immediate = decl.type_immediate; type_unboxed = decl.type_unboxed; + type_uid = decl.type_uid; } let type_declaration s decl = @@ -346,6 +350,7 @@ let class_declaration' copy_scope s decl = end; cty_loc = loc s decl.cty_loc; cty_attributes = attrs s decl.cty_attributes; + cty_uid = decl.cty_uid; } let class_declaration s decl = @@ -358,6 +363,7 @@ let cltype_declaration' copy_scope s decl = clty_path = type_path s decl.clty_path; clty_loc = loc s decl.clty_loc; clty_attributes = attrs s decl.clty_attributes; + clty_uid = decl.clty_uid; } let cltype_declaration s decl = @@ -371,6 +377,7 @@ let value_description' copy_scope s descr = val_kind = descr.val_kind; val_loc = loc s descr.val_loc; val_attributes = attrs s descr.val_attributes; + val_uid = descr.val_uid; } let value_description s descr = @@ -383,7 +390,9 @@ let extension_constructor' copy_scope s ext = ext_ret_type = Option.map (typexp copy_scope s) ext.ext_ret_type; ext_private = ext.ext_private; ext_attributes = attrs s ext.ext_attributes; - ext_loc = if s.for_saving then Location.none else ext.ext_loc; } + ext_loc = if s.for_saving then Location.none else ext.ext_loc; + ext_uid = ext.ext_uid; + } let extension_constructor s ext = For_copy.with_scope @@ -497,14 +506,16 @@ and signature_item' copy_scope scoping s comp = | Sig_class_type(id, d, rs, vis) -> Sig_class_type(id, cltype_declaration' copy_scope s d, rs, vis) -and signature_item s comp = - For_copy.with_scope (fun copy_scope -> signature_item' copy_scope s comp) +and signature_item scoping s comp = + For_copy.with_scope + (fun copy_scope -> signature_item' copy_scope scoping s comp) and module_declaration scoping s decl = { md_type = modtype scoping s decl.md_type; md_attributes = attrs s decl.md_attributes; md_loc = loc s decl.md_loc; + md_uid = decl.md_uid; } and modtype_declaration scoping s decl = @@ -512,6 +523,7 @@ and modtype_declaration scoping s decl = mtd_type = Option.map (modtype scoping s) decl.mtd_type; mtd_attributes = attrs s decl.mtd_attributes; mtd_loc = loc s decl.mtd_loc; + mtd_uid = decl.mtd_uid; } @@ -527,9 +539,10 @@ let merge_path_maps f m1 m2 = let type_replacement s = function | Path p -> Path (type_path s p) | Type_function { params; body } -> - let params = List.map (type_expr s) params in - let body = type_expr s body in - Type_function { params; body } + For_copy.with_scope (fun copy_scope -> + let params = List.map (typexp copy_scope s) params in + let body = typexp copy_scope s body in + Type_function { params; body }) (* Composition of substitutions: apply (compose s1 s2) x = apply s2 (apply s1 x) *) diff --git a/typing/subst.mli b/typing/subst.mli index f0b1a8be..67c01536 100644 --- a/typing/subst.mli +++ b/typing/subst.mli @@ -45,6 +45,7 @@ val reset_for_saving: unit -> unit val module_path: t -> Path.t -> Path.t val type_path: t -> Path.t -> Path.t +val modtype_path: t -> Path.t -> Path.t val type_expr: t -> type_expr -> type_expr val class_type: t -> class_type -> class_type diff --git a/typing/tast_iterator.ml b/typing/tast_iterator.ml index a6a2e440..db63fc0b 100644 --- a/typing/tast_iterator.ml +++ b/typing/tast_iterator.ml @@ -19,8 +19,7 @@ open Typedtree type iterator = { binding_op: iterator -> binding_op -> unit; - case: iterator -> case -> unit; - cases: iterator -> case list -> unit; + case: 'k . iterator -> 'k case -> unit; class_declaration: iterator -> class_declaration -> unit; class_description: iterator -> class_description -> unit; class_expr: iterator -> class_expr -> unit; @@ -41,7 +40,7 @@ type iterator = module_type: iterator -> module_type -> unit; module_type_declaration: iterator -> module_type_declaration -> unit; package_type: iterator -> package_type -> unit; - pat: iterator -> pattern -> unit; + pat: 'k . iterator -> 'k general_pattern -> unit; row_field: iterator -> row_field -> unit; object_field: iterator -> object_field -> unit; open_declaration: iterator -> open_declaration -> unit; @@ -149,15 +148,17 @@ let extension_constructor sub {ext_kind; _} = Option.iter (sub.typ sub) cto | Text_rebind _ -> () -let pat sub {pat_extra; pat_desc; pat_env; _} = - let extra = function - | Tpat_type _ -> () - | Tpat_unpack -> () - | Tpat_open (_, _, env) -> sub.env sub env - | Tpat_constraint ct -> sub.typ sub ct - in +let pat_extra sub (e, _loc, _attrs) = match e with + | Tpat_type _ -> () + | Tpat_unpack -> () + | Tpat_open (_, _, env) -> 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; _} -> sub.env sub pat_env; - List.iter (fun (e, _, _) -> extra e) pat_extra; + List.iter (pat_extra sub) extra; match pat_desc with | Tpat_any -> () | Tpat_var _ -> () @@ -167,12 +168,13 @@ let pat sub {pat_extra; pat_desc; pat_env; _} = | Tpat_variant (_, po, _) -> Option.iter (sub.pat sub) po | Tpat_record (l, _) -> List.iter (fun (_, _, i) -> sub.pat sub i) l | Tpat_array l -> List.iter (sub.pat sub) l - | Tpat_or (p1, p2, _) -> - sub.pat sub p1; - sub.pat sub p2 | Tpat_alias (p, _, _) -> sub.pat sub p | Tpat_lazy p -> sub.pat sub p + | Tpat_value p -> sub.pat sub (p :> pattern) | Tpat_exception p -> sub.pat sub p + | Tpat_or (p1, p2, _) -> + sub.pat sub p1; + sub.pat sub p2 let expr sub {exp_extra; exp_desc; exp_env; _} = let extra = function @@ -191,16 +193,17 @@ let expr sub {exp_extra; exp_desc; exp_env; _} = | Texp_let (rec_flag, list, exp) -> sub.value_bindings sub (rec_flag, list); sub.expr sub exp - | Texp_function {cases; _} -> sub.cases sub cases + | Texp_function {cases; _} -> + List.iter (sub.case sub) cases | Texp_apply (exp, list) -> sub.expr sub exp; List.iter (fun (_, o) -> Option.iter (sub.expr sub) o) list | Texp_match (exp, cases, _) -> sub.expr sub exp; - sub.cases sub cases + List.iter (sub.case sub) cases | Texp_try (exp, cases) -> sub.expr sub exp; - sub.cases sub cases + 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_variant (_, expo) -> Option.iter (sub.expr sub) expo @@ -450,8 +453,6 @@ let class_field sub {cf_desc; _} = match cf_desc with let value_bindings sub (_, list) = List.iter (sub.value_binding sub) list -let cases sub l = List.iter (sub.case sub) l - let case sub {c_lhs; c_guard; c_rhs} = sub.pat sub c_lhs; Option.iter (sub.expr sub) c_guard; @@ -467,7 +468,6 @@ let default_iterator = { binding_op; case; - cases; class_declaration; class_description; class_expr; diff --git a/typing/tast_iterator.mli b/typing/tast_iterator.mli index dc6f56f4..e126128e 100644 --- a/typing/tast_iterator.mli +++ b/typing/tast_iterator.mli @@ -23,8 +23,7 @@ open Typedtree type iterator = { binding_op: iterator -> binding_op -> unit; - case: iterator -> case -> unit; - cases: iterator -> case list -> unit; + case: 'k . iterator -> 'k case -> unit; class_declaration: iterator -> class_declaration -> unit; class_description: iterator -> class_description -> unit; class_expr: iterator -> class_expr -> unit; @@ -45,7 +44,7 @@ type iterator = module_type: iterator -> module_type -> unit; module_type_declaration: iterator -> module_type_declaration -> unit; package_type: iterator -> package_type -> unit; - pat: iterator -> pattern -> unit; + pat: 'k . iterator -> 'k general_pattern -> unit; row_field: iterator -> row_field -> unit; object_field: iterator -> object_field -> unit; open_declaration: iterator -> open_declaration -> unit; diff --git a/typing/tast_mapper.ml b/typing/tast_mapper.ml index c288345e..d8ceee1d 100644 --- a/typing/tast_mapper.ml +++ b/typing/tast_mapper.ml @@ -22,8 +22,7 @@ open Typedtree type mapper = { binding_op: mapper -> binding_op -> binding_op; - case: mapper -> case -> case; - cases: mapper -> case list -> case list; + case: 'k . mapper -> 'k case -> 'k case; class_declaration: mapper -> class_declaration -> class_declaration; class_description: mapper -> class_description -> class_description; class_expr: mapper -> class_expr -> class_expr; @@ -47,7 +46,7 @@ type mapper = module_type_declaration: mapper -> module_type_declaration -> module_type_declaration; package_type: mapper -> package_type -> package_type; - pat: mapper -> pattern -> pattern; + pat: 'k . mapper -> 'k general_pattern -> 'k general_pattern; row_field: mapper -> row_field -> row_field; object_field: mapper -> object_field -> object_field; open_declaration: mapper -> open_declaration -> open_declaration; @@ -195,20 +194,22 @@ let extension_constructor sub x = in {x with ext_kind} -let pat sub x = - let extra = function - | Tpat_type _ - | Tpat_unpack as d -> d - | Tpat_open (path,loc,env) -> Tpat_open (path, loc, sub.env sub env) - | Tpat_constraint ct -> Tpat_constraint (sub.typ sub ct) - in +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_constraint ct -> Tpat_constraint (sub.typ sub ct) + +let pat + : type k . mapper -> k general_pattern -> k general_pattern + = fun sub x -> let pat_env = sub.env sub x.pat_env in - let pat_extra = List.map (tuple3 extra id id) x.pat_extra in - let pat_desc = + let pat_extra = List.map (tuple3 (pat_extra sub) id id) x.pat_extra in + let pat_desc : k pattern_desc = match x.pat_desc with | Tpat_any | Tpat_var _ - | Tpat_constant _ as d -> d + | Tpat_constant _ -> x.pat_desc | Tpat_tuple l -> Tpat_tuple (List.map (sub.pat sub) l) | Tpat_construct (loc, cd, l) -> Tpat_construct (loc, cd, List.map (sub.pat sub) l) @@ -217,11 +218,14 @@ let pat sub x = | Tpat_record (l, closed) -> Tpat_record (List.map (tuple3 id id (sub.pat sub)) l, closed) | Tpat_array l -> Tpat_array (List.map (sub.pat sub) l) - | Tpat_or (p1, p2, rd) -> - Tpat_or (sub.pat sub p1, sub.pat sub p2, rd) | Tpat_alias (p, id, s) -> Tpat_alias (sub.pat sub p, id, s) | Tpat_lazy p -> Tpat_lazy (sub.pat sub p) - | Tpat_exception p -> Tpat_exception (sub.pat sub p) + | Tpat_value p -> + (as_computation_pattern (sub.pat sub (p :> pattern))).pat_desc + | Tpat_exception p -> + Tpat_exception (sub.pat sub p) + | 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} @@ -244,8 +248,8 @@ let expr sub x = 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; } -> - Texp_function { arg_label; param; cases = sub.cases sub cases; - partial; } + let cases = List.map (sub.case sub) cases in + Texp_function { arg_label; param; cases; partial; } | Texp_apply (exp, list) -> Texp_apply ( sub.expr sub exp, @@ -254,13 +258,13 @@ let expr sub x = | Texp_match (exp, cases, p) -> Texp_match ( sub.expr sub exp, - sub.cases sub cases, + List.map (sub.case sub) cases, p ) | Texp_try (exp, cases) -> Texp_try ( sub.expr sub exp, - sub.cases sub cases + List.map (sub.case sub) cases ) | Texp_tuple list -> Texp_tuple (List.map (sub.expr sub) list) @@ -678,10 +682,9 @@ let class_field sub x = let value_bindings sub (rec_flag, list) = (rec_flag, List.map (sub.value_binding sub) list) -let cases sub l = - List.map (sub.case sub) l - -let case sub {c_lhs; c_guard; c_rhs} = +let case + : type k . mapper -> k case -> k case + = fun sub {c_lhs; c_guard; c_rhs} -> { c_lhs = sub.pat sub c_lhs; c_guard = Option.map (sub.expr sub) c_guard; @@ -699,7 +702,6 @@ let default = { binding_op; case; - cases; class_declaration; class_description; class_expr; diff --git a/typing/tast_mapper.mli b/typing/tast_mapper.mli index 467f203e..ea6543d0 100644 --- a/typing/tast_mapper.mli +++ b/typing/tast_mapper.mli @@ -21,8 +21,7 @@ open Typedtree type mapper = { binding_op: mapper -> binding_op -> binding_op; - case: mapper -> case -> case; - cases: mapper -> case list -> case list; + case: 'k . mapper -> 'k case -> 'k case; class_declaration: mapper -> class_declaration -> class_declaration; class_description: mapper -> class_description -> class_description; class_expr: mapper -> class_expr -> class_expr; @@ -46,7 +45,7 @@ type mapper = module_type_declaration: mapper -> module_type_declaration -> module_type_declaration; package_type: mapper -> package_type -> package_type; - pat: mapper -> pattern -> pattern; + pat: 'k . mapper -> 'k general_pattern -> 'k general_pattern; row_field: mapper -> row_field -> row_field; object_field: mapper -> object_field -> object_field; open_declaration: mapper -> open_declaration -> open_declaration; diff --git a/typing/typeclass.ml b/typing/typeclass.ml index ce6b6812..31d4bc89 100644 --- a/typing/typeclass.ml +++ b/typing/typeclass.ml @@ -64,6 +64,8 @@ type 'a full_class = { req: 'a Typedtree.class_infos; } +type class_env = { val_env : Env.t; met_env : Env.t; par_env : Env.t } + type error = Unconsistent_constraint of Ctype.Unification_trace.t | Field_type_mismatch of string * string * Ctype.Unification_trace.t @@ -247,7 +249,6 @@ let rec limited_generalize rv = (* Record a class type *) let rc node = Cmt_format.add_saved_type (Cmt_format.Partial_class_expr node); - Stypes.record (Stypes.Ti_class node); (* moved to genannot *) node @@ -257,18 +258,22 @@ let rc node = (* Enter a value in the method environment only *) -let enter_met_env ?check loc lab kind unbound_kind ty val_env met_env par_env = +let enter_met_env ?check loc lab kind unbound_kind ty class_env = + let {val_env; met_env; par_env} = class_env in let val_env = Env.enter_unbound_value lab unbound_kind val_env in let par_env = Env.enter_unbound_value lab unbound_kind par_env in let (id, met_env) = Env.enter_value ?check lab {val_type = ty; val_kind = kind; - val_attributes = []; Types.val_loc = loc} met_env + val_attributes = []; Types.val_loc = loc; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } met_env in - (id, val_env, met_env, par_env) + let class_env = {val_env; met_env; par_env} in + (id,class_env ) (* Enter an instance variable in the environment *) -let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc = +let enter_val cl_num vars inh lab mut virt ty class_env loc = + let val_env = class_env.val_env in let (id, virt) = try let (id, mut', virt', ty') = Vars.find lab !vars in @@ -283,11 +288,11 @@ let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc = Field_type_mismatch("instance variable", lab, tr))) | Not_found -> None, virt in - let (id, _, _, _) as result = - match id with Some id -> (id, val_env, met_env, par_env) + let (id, _) as result = + match id with Some id -> (id, class_env) | None -> enter_met_env Location.none lab (Val_ivar (mut, cl_num)) - Val_unbound_instance_variable ty val_env met_env par_env + Val_unbound_instance_variable ty class_env in vars := Vars.add lab (id, mut, virt, ty) !vars; result @@ -591,12 +596,13 @@ let rec class_field self_loc cl_num self_type meths vars arg cf = (fun () -> class_field_aux self_loc cl_num self_type meths vars arg cf) and class_field_aux self_loc cl_num self_type meths vars - (val_env, met_env, par_env, fields, concr_meths, warn_vals, inher, + (class_env, fields, concr_meths, warn_vals, inher, local_meths, local_vals) cf = let loc = cf.pcf_loc in let mkcf desc = { cf_desc = desc; cf_loc = loc; cf_attributes = cf.pcf_attributes } in + let {val_env; met_env; par_env} = class_env in match cf.pcf_desc with Pcf_inherit (ovf, sparent, super) -> let parent = class_expr cl_num val_env par_env sparent in @@ -610,16 +616,16 @@ and class_field_aux self_loc cl_num self_type meths vars sparent.pcl_loc parent.cl_type in (* Variables *) - let (val_env, met_env, par_env, inh_vars) = + let (class_env, inh_vars) = Vars.fold - (fun lab info (val_env, met_env, par_env, inh_vars) -> + (fun lab info (class_env, inh_vars) -> let mut, vr, ty = info in - let (id, val_env, met_env, par_env) = - enter_val cl_num vars true lab mut vr ty val_env met_env par_env - sparent.pcl_loc + let (id, class_env) = + enter_val cl_num vars true lab mut vr ty class_env + sparent.pcl_loc ; in - (val_env, met_env, par_env, (lab, id) :: inh_vars)) - cl_sig.csig_vars (val_env, met_env, par_env, []) + (class_env, (lab, id) :: inh_vars)) + cl_sig.csig_vars (class_env, []) in (* Inherited concrete methods *) let inh_meths = @@ -627,19 +633,19 @@ and class_field_aux self_loc cl_num self_type meths vars cl_sig.csig_concr [] in (* Super *) - let (val_env, met_env, par_env,super) = + let (class_env,super) = match super with None -> - (val_env, met_env, par_env,None) + (class_env,None) | Some {txt=name} -> - let (_id, val_env, met_env, par_env) = + let (_id, class_env) = enter_met_env ~check:(fun s -> Warnings.Unused_ancestor s) sparent.pcl_loc name (Val_anc (inh_meths, cl_num)) - Val_unbound_ancestor self_type val_env met_env par_env + Val_unbound_ancestor self_type class_env in - (val_env, met_env, par_env,Some name) + (class_env,Some name) in - (val_env, met_env, par_env, + (class_env, lazy (mkcf (Tcf_inherit (ovf, parent, super, inh_vars, inh_meths))) :: fields, concr_meths, warn_vals, inher, local_meths, local_vals) @@ -652,13 +658,13 @@ and class_field_aux self_loc cl_num self_type meths vars Ctype.end_def (); Ctype.generalize_structure ty end; - let (id, val_env, met_env', par_env) = + let (id, class_env') = enter_val cl_num vars false lab.txt mut Virtual ty - val_env met_env par_env loc + class_env loc in - (val_env, met_env', par_env, + (class_env', lazy (mkcf (Tcf_val (lab, mut, id, Tcfk_virtual cty, - met_env == met_env'))) + met_env == class_env'.met_env))) :: fields, concr_meths, warn_vals, inher, local_meths, local_vals) @@ -680,20 +686,20 @@ and class_field_aux self_loc cl_num self_type meths vars Ctype.end_def (); Ctype.generalize_structure exp.exp_type end; - let (id, val_env, met_env', par_env) = + let (id, class_env') = enter_val cl_num vars false lab.txt mut Concrete exp.exp_type - val_env met_env par_env loc + class_env loc in - (val_env, met_env', par_env, + (class_env', lazy (mkcf (Tcf_val (lab, mut, id, - Tcfk_concrete (ovf, exp), met_env == met_env'))) + Tcfk_concrete (ovf, exp), met_env == class_env'.met_env))) :: fields, concr_meths, Concr.add lab.txt warn_vals, inher, local_meths, Concr.add lab.txt local_vals) | Pcf_method (lab, priv, Cfk_virtual sty) -> let cty = virtual_method val_env meths self_type lab.txt priv sty loc in - (val_env, met_env, par_env, + (class_env, lazy (mkcf(Tcf_method (lab, priv, Tcfk_virtual cty))) ::fields, concr_meths, warn_vals, inher, local_meths, local_vals) @@ -760,13 +766,13 @@ and class_field_aux self_loc cl_num self_type meths vars mkcf (Tcf_method (lab, priv, Tcfk_concrete (ovf, texp))) ) in - (val_env, met_env, par_env, field::fields, + (class_env, field::fields, Concr.add lab.txt concr_meths, warn_vals, inher, Concr.add lab.txt local_meths, local_vals) | Pcf_constraint (sty, sty') -> let (cty, cty') = type_constraint val_env sty sty' loc in - (val_env, met_env, par_env, + (class_env, lazy (mkcf (Tcf_constraint (cty, cty'))) :: fields, concr_meths, warn_vals, inher, local_meths, local_vals) @@ -786,11 +792,11 @@ and class_field_aux self_loc cl_num self_type meths vars Ctype.end_def (); mkcf (Tcf_initializer texp) end in - (val_env, met_env, par_env, field::fields, concr_meths, warn_vals, + (class_env, field::fields, concr_meths, warn_vals, inher, local_meths, local_vals) | Pcf_attribute x -> Builtin_attributes.warning_attribute x; - (val_env, met_env, par_env, + (class_env, lazy (mkcf (Tcf_attribute x)) :: fields, concr_meths, warn_vals, inher, local_meths, local_vals) | Pcf_extension ext -> @@ -827,7 +833,7 @@ and class_structure cl_num final val_env met_env loc let private_self = if final then Ctype.newvar () else self_type in (* Self binder *) - let (pat, meths, vars, val_env, meth_env, par_env) = + let (pat, meths, vars, val_env, met_env, par_env) = type_self_pattern cl_num private_self val_env met_env par_env spat in let public_self = pat.pat_type in @@ -855,11 +861,12 @@ and class_structure cl_num final val_env met_env loc end; (* Typing of class fields *) - let (_, _, _, fields, concr_meths, _, inher, _local_meths, _local_vals) = + let class_env = {val_env; met_env; par_env} in + let (_, fields, concr_meths, _, inher, _local_meths, _local_vals) = Builtin_attributes.warning_scope [] (fun () -> List.fold_left (class_field self_loc cl_num self_type meths vars) - (val_env, meth_env, par_env, [], Concr.empty, Concr.empty, [], + ( class_env,[], Concr.empty, Concr.empty, [], Concr.empty, Concr.empty) str ) @@ -1023,7 +1030,8 @@ and class_expr_aux cl_num val_env met_env scl = in if !Clflags.principal then begin Ctype.end_def (); - iter_pattern (fun {pat_type=ty} -> Ctype.generalize_structure ty) pat + let gen {pat_type = ty} = Ctype.generalize_structure ty in + iter_pattern gen pat end; let pv = List.map @@ -1093,61 +1101,62 @@ and class_expr_aux cl_num val_env met_env scl = true end in - let rec type_args args omitted ty_fun ty_fun0 sargs more_sargs = + let rec type_args args omitted ty_fun ty_fun0 sargs = match ty_fun, ty_fun0 with | Cty_arrow (l, ty, ty_fun), Cty_arrow (_, ty0, ty_fun0) - when sargs <> [] || more_sargs <> [] -> + when sargs <> [] -> let name = Btype.label_name l and optional = Btype.is_optional l in - let sargs, more_sargs, arg = - if ignore_labels && not (Btype.is_optional l) then begin - match sargs, more_sargs with - (l', sarg0)::_, _ -> - raise(Error(sarg0.pexp_loc, val_env, Apply_wrong_label l')) - | _, (l', sarg0)::more_sargs -> - if l <> l' && l' <> Nolabel then - raise(Error(sarg0.pexp_loc, val_env, - Apply_wrong_label l')) - else ([], more_sargs, - Some (type_argument val_env sarg0 ty ty0)) - | _ -> - assert false - end else try - let (l', sarg0, sargs, more_sargs) = - try - let (l', sarg0, sargs1, sargs2) = - Btype.extract_label name sargs - in (l', sarg0, sargs1 @ sargs2, more_sargs) - with Not_found -> - let (l', sarg0, sargs1, sargs2) = - Btype.extract_label name more_sargs - in (l', sarg0, sargs @ sargs1, sargs2) - in - if not optional && Btype.is_optional l' then - Location.prerr_warning sarg0.pexp_loc - (Warnings.Nonoptional_label (Printtyp.string_of_label l)); - sargs, more_sargs, + let use_arg sarg l' = + Some ( if not optional || Btype.is_optional l' then - Some (type_argument val_env sarg0 ty ty0) + type_argument val_env sarg ty ty0 else let ty' = extract_option_type val_env ty and ty0' = extract_option_type val_env ty0 in - let arg = type_argument val_env sarg0 ty' ty0' in - Some (option_some val_env arg) - with Not_found -> - sargs, more_sargs, - if Btype.is_optional l - && (List.mem_assoc Nolabel sargs - || List.mem_assoc Nolabel more_sargs) - then - Some (option_none val_env ty0 Location.none) - else None + let arg = type_argument val_env sarg ty' ty0' in + option_some val_env arg + ) + in + let eliminate_optional_arg () = + Some (option_none val_env ty0 Location.none) + in + let remaining_sargs, arg = + if ignore_labels then begin + match sargs with + | [] -> assert false + | (l', sarg) :: remaining_sargs -> + if name = Btype.label_name l' || + (not optional && l' = Nolabel) + then + (remaining_sargs, use_arg sarg l') + else if + optional && + not (List.exists (fun (l, _) -> name = Btype.label_name l) + remaining_sargs) + then + (sargs, eliminate_optional_arg ()) + else + raise(Error(sarg.pexp_loc, val_env, Apply_wrong_label l')) + end else + match Btype.extract_label name sargs with + | Some (l', sarg, _, remaining_sargs) -> + if not optional && Btype.is_optional l' then + Location.prerr_warning sarg.pexp_loc + (Warnings.Nonoptional_label + (Printtyp.string_of_label l)); + remaining_sargs, use_arg sarg l' + | None -> + sargs, + if Btype.is_optional l && List.mem_assoc Nolabel sargs then + eliminate_optional_arg () + else + None in let omitted = if arg = None then (l,ty0) :: omitted else omitted in - type_args ((l,arg)::args) omitted ty_fun ty_fun0 - sargs more_sargs + type_args ((l,arg)::args) omitted ty_fun ty_fun0 remaining_sargs | _ -> - match sargs @ more_sargs with + match sargs with (l, sarg0)::_ -> if omitted <> [] then raise(Error(sarg0.pexp_loc, val_env, Apply_wrong_label l)) @@ -1161,10 +1170,7 @@ and class_expr_aux cl_num val_env met_env scl = in let (args, cty) = let (_, ty_fun0) = Ctype.instance_class [] cl.cl_type in - if ignore_labels then - type_args [] [] cl.cl_type ty_fun0 [] sargs - else - type_args [] [] cl.cl_type ty_fun0 sargs [] + type_args [] [] cl.cl_type ty_fun0 sargs in rc {cl_desc = Tcl_apply (cl, args); cl_loc = scl.pcl_loc; @@ -1198,6 +1204,7 @@ and class_expr_aux cl_num val_env met_env scl = cl_num); val_attributes = []; Types.val_loc = vd.Types.val_loc; + val_uid = vd.val_uid; } in let id' = Ident.create_local (Ident.name id) in @@ -1290,7 +1297,7 @@ let rec approx_description ct = (*******************************) -let temp_abbrev loc env id arity = +let temp_abbrev loc env id arity uid = let params = ref [] in for _i = 1 to arity do params := Ctype.newvar () :: !params @@ -1304,23 +1311,25 @@ let temp_abbrev loc env id arity = type_private = Public; type_manifest = Some ty; type_variance = Misc.replicate_list Variance.full arity; + type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = loc; type_attributes = []; (* or keep attrs from the class decl? *) type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = uid; } env in (!params, ty, env) let initial_env define_class approx - (res, env) (cl, id, ty_id, obj_id, cl_id) = + (res, env) (cl, id, ty_id, obj_id, cl_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 in - let (cl_params, cl_ty, env) = temp_abbrev cl.pci_loc env cl_id arity 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 (* Temporary type for the class constructor *) let constr_type = approx cl.pci_expr in @@ -1344,6 +1353,7 @@ let initial_env define_class approx end; cty_loc = Location.none; cty_attributes = []; + cty_uid = uid; } in let env = @@ -1354,6 +1364,7 @@ let initial_env define_class approx clty_path = unbound_class; clty_loc = Location.none; clty_attributes = []; + clty_uid = uid; } ( if define_class then @@ -1484,6 +1495,7 @@ let class_infos define_class kind clty_path = Path.Pident obj_id; clty_loc = cl.pci_loc; clty_attributes = cl.pci_attributes; + clty_uid = dummy_class.cty_uid; } and clty = {cty_params = params; cty_type = typ; @@ -1496,6 +1508,7 @@ let class_infos define_class kind end; cty_loc = cl.pci_loc; cty_attributes = cl.pci_attributes; + cty_uid = dummy_class.cty_uid; } in dummy_class.cty_type <- typ; @@ -1533,6 +1546,7 @@ let class_infos define_class kind clty_path = Path.Pident obj_id; clty_loc = cl.pci_loc; clty_attributes = cl.pci_attributes; + clty_uid = dummy_class.cty_uid; } and clty = {cty_params = params'; cty_type = typ'; @@ -1545,21 +1559,26 @@ let class_infos define_class kind end; cty_loc = cl.pci_loc; cty_attributes = cl.pci_attributes; + cty_uid = dummy_class.cty_uid; } in let obj_abbr = - {type_params = obj_params; - type_arity = List.length obj_params; + let arity = List.length obj_params in + { + type_params = obj_params; + type_arity = arity; type_kind = Type_abstract; type_private = Public; type_manifest = Some obj_ty; type_variance = List.map (fun _ -> Variance.full) obj_params; + 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 = unboxed_false_default_false; + type_uid = dummy_class.cty_uid; } in let (cl_params, cl_ty) = @@ -1568,18 +1587,22 @@ let class_infos define_class kind Ctype.hide_private_methods cl_ty; Ctype.set_object_name obj_id (Ctype.row_variable cl_ty) cl_params cl_ty; let cl_abbr = - {type_params = cl_params; - type_arity = List.length cl_params; + let arity = List.length cl_params in + { + type_params = cl_params; + type_arity = arity; type_kind = Type_abstract; type_private = Public; type_manifest = Some cl_ty; type_variance = List.map (fun _ -> Variance.full) cl_params; + 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 = unboxed_false_default_false; + type_uid = dummy_class.cty_uid; } in ((cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, cl_id, cl_abbr, ci_params, @@ -1736,7 +1759,9 @@ 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))) + Ident.create_scoped ~scope ("#" ^ cl.pci_name.txt), + Uid.mk ~current_unit:(Env.get_unit_name ()) + )) cls in Ctype.begin_class_def (); diff --git a/typing/typecore.ml b/typing/typecore.ml index 9ff5ed42..995ee91a 100644 --- a/typing/typecore.ml +++ b/typing/typecore.ml @@ -40,6 +40,25 @@ type type_expected = { explanation: type_forcing_context option; } +module Datatype_kind = struct + type t = Record | Variant + + let type_name = function + | Record -> "record" + | Variant -> "variant" + + let label_name = function + | Record -> "field" + | Variant -> "constructor" +end + +type wrong_name = { + type_path: Path.t; + kind: Datatype_kind.t; + name: string loc; + valid_names: string list; +} + type existential_restriction = | At_toplevel (** no existential types at the toplevel *) | In_group (** nor with let ... and ... *) @@ -52,7 +71,8 @@ type existential_restriction = type error = | Constructor_arity_mismatch of Longident.t * int * int | Label_mismatch of Longident.t * Ctype.Unification_trace.t - | Pattern_type_clash of Ctype.Unification_trace.t * pattern_desc option + | Pattern_type_clash : + Ctype.Unification_trace.t * _ pattern_desc option -> error | Or_pattern_type_clash of Ident.t * Ctype.Unification_trace.t | Multiply_bound_variable of string | Orpat_vars of Ident.t * Ident.t list @@ -60,14 +80,13 @@ type error = Ctype.Unification_trace.t * type_forcing_context option * expression_desc option | Apply_non_function of type_expr - | Apply_wrong_label of arg_label * type_expr + | Apply_wrong_label of arg_label * type_expr * bool | Label_multiply_defined of string | Label_missing of Ident.t list | Label_not_mutable of Longident.t - | Wrong_name of - string * type_expected * string * Path.t * string * string list + | Wrong_name of string * type_expected * wrong_name | Name_type_mismatch of - string * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list + Datatype_kind.t * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list | Invalid_format of string | Undefined_method of type_expr * string * string list option | Undefined_inherited_method of string * string list @@ -107,7 +126,6 @@ type error = | Illegal_letrec_pat | Illegal_letrec_expr | Illegal_class_expr - | Empty_pattern | Letop_type_clash of string * Ctype.Unification_trace.t | Andop_type_clash of string * Ctype.Unification_trace.t | Bindings_type_clash of Ctype.Unification_trace.t @@ -154,12 +172,14 @@ let type_object = *) let re node = Cmt_format.add_saved_type (Cmt_format.Partial_expression node); - Stypes.record (Stypes.Ti_expr node); node ;; let rp node = - Cmt_format.add_saved_type (Cmt_format.Partial_pattern node); - Stypes.record (Stypes.Ti_pat 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 ;; @@ -210,7 +230,7 @@ let constant : Parsetree.constant -> (Asttypes.constant, error) result = end | Pconst_integer (i,Some c) -> Error (Unknown_literal (i, c)) | Pconst_char c -> Ok (Const_char c) - | Pconst_string (s,d) -> Ok (Const_string (s,d)) + | Pconst_string (s,loc,d) -> Ok (Const_string (s,loc,d)) | Pconst_float (f,None)-> Ok (Const_float f) | Pconst_float (f,Some c) -> Error (Unknown_literal (f, c)) @@ -302,39 +322,43 @@ let unify_pat ?refine env pat expected_ty = (* Creating new conjunctive types is not allowed when typing patterns *) (* make all Reither present in open variants *) -let finalize_variant pat = - match pat.pat_desc with - Tpat_variant(tag, opat, r) -> - let row = - match expand_head pat.pat_env pat.pat_type with - {desc = Tvariant row} -> r := row; row_repr row - | _ -> assert false - in - begin match row_field tag row with - | Rabsent -> () (* assert false *) - | Reither (true, [], _, e) when not row.row_closed -> - set_row_field e (Rpresent None) - | Reither (false, ty::tl, _, e) when not row.row_closed -> - set_row_field e (Rpresent (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) - end - | Reither (c, _l, true, e) when not (row_fixed row) -> - set_row_field e (Reither (c, [], false, ref None)) - | _ -> () - end; - (* Force check of well-formedness WHY? *) - (* unify_pat pat.pat_env pat - (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false; - row_bound=(); row_fixed=false; row_name=None})); *) +let finalize_variant pat tag opat r = + let row = + match expand_head pat.pat_env pat.pat_type with + {desc = Tvariant row} -> r := row; row_repr row + | _ -> assert false + in + begin match row_field tag row with + | Rabsent -> () (* assert false *) + | Reither (true, [], _, e) when not row.row_closed -> + set_row_field e (Rpresent None) + | Reither (false, ty::tl, _, e) when not row.row_closed -> + set_row_field e (Rpresent (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) + end + | Reither (c, _l, true, e) when not (row_fixed row) -> + set_row_field e (Reither (c, [], false, ref None)) | _ -> () + end + (* Force check of well-formedness WHY? *) + (* unify_pat pat.pat_env pat + (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false; + row_bound=(); row_fixed=false; row_name=None})); *) let has_variants p = - exists_pattern - (function {pat_desc=Tpat_variant _} -> true | _ -> false) - p + exists_general_pattern + { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with + | (Tpat_variant _) -> true + | _ -> false } p + +let finalize_variants p = + iter_general_pattern + { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with + | Tpat_variant(tag, opat, r) -> + finalize_variant p tag opat r + | _ -> () } p (* pattern environment *) type pattern_variable = @@ -390,11 +414,6 @@ let enter_variable ?(is_module=false) ?(is_as_variable=false) loc name ty if not !allow_modules then raise (Error (loc, Env.empty, Modules_not_allowed)); module_variables := (name, loc) :: !module_variables - end else begin - (* moved to genannot *) - Option.iter - (fun s -> Stypes.record (Stypes.An_ident (name.loc, name.txt, s))) - !pattern_scope end; id @@ -489,7 +508,7 @@ let rec build_as_type env p = newty (Tvariant{row with row_closed=false; row_more=newvar()}) end | Tpat_any | Tpat_var _ | Tpat_constant _ - | Tpat_array _ | Tpat_lazy _ | Tpat_exception _ -> p.pat_type + | Tpat_array _ | Tpat_lazy _ -> p.pat_type let build_or_pat env loc lid = let path, decl = Env.lookup_type ~loc:lid.loc lid.txt env in @@ -575,41 +594,49 @@ let compare_type_path env tpath1 tpath2 = Path.same (expand_path env tpath1) (expand_path env tpath2) (* Records *) -let label_of_kind kind = - if kind = "record" then "field" else "constructor" +exception Wrong_name_disambiguation of Env.t * wrong_name + +let get_constr_type_path ty = + match (repr ty).desc with + | Tconstr(p, _, _) -> p + | _ -> assert false module NameChoice(Name : sig type t type usage - val type_kind: string + val kind: Datatype_kind.t val get_name: t -> string val get_type: t -> type_expr val lookup_all_from_type: Location.t -> usage -> Path.t -> Env.t -> (t * (unit -> unit)) list + + (** Some names (for example the fields of inline records) are not + in the typing environment -- they behave as structural labels + rather than nominal labels.*) val in_env: t -> bool end) = struct open Name - let get_type_path d = - match (repr (get_type d)).desc with - | Tconstr(p, _, _) -> p - | _ -> assert false + let get_type_path d = get_constr_type_path (get_type d) - let lookup_from_type env tpath usage lid = - let descrs = lookup_all_from_type lid.loc usage tpath env in + let lookup_from_type env type_path usage lid = + let descrs = lookup_all_from_type lid.loc usage type_path env in match lid.txt with - | Longident.Lident s -> begin + | Longident.Lident name -> begin match - List.find (fun (nd, _) -> get_name nd = s) descrs + List.find (fun (nd, _) -> get_name nd = name) descrs with | descr, use -> use (); descr | exception Not_found -> - let names = List.map (fun (nd, _) -> get_name nd) descrs in - raise (Error (lid.loc, env, - Wrong_name ("", mk_expected (newvar ()), - type_kind, tpath, s, names))) + let valid_names = List.map (fun (nd, _) -> get_name nd) descrs in + raise (Wrong_name_disambiguation (env, { + type_path; + name = { lid with txt = name }; + kind; + valid_names; + })) end | _ -> raise Not_found @@ -640,103 +667,164 @@ end) = struct in List.find check_type lbls - let disambiguate ?(warn=Location.prerr_warning) ?scope - usage lid env opath lbls = - let scope = match scope with None -> lbls | Some l -> l in - let lbl = match opath with - None -> - begin match lbls with - | (Error(loc', env', err) : _ result) -> - Env.lookup_error loc' env' err - | Ok [] -> assert false + (* warn if there are several distinct candidates in scope *) + let warn_if_ambiguous warn lid env lbl rest = + Printtyp.Conflicts.reset (); + let paths = ambiguous_types env lbl rest in + let expansion = + Format.asprintf "%t" Printtyp.Conflicts.print_explanations in + if paths <> [] then + warn lid.loc + (Warnings.Ambiguous_name ([Longident.last lid.txt], + paths, false, expansion)) + + (* a non-principal type was used for disambiguation *) + let warn_non_principal warn lid = + let name = Datatype_kind.label_name kind in + warn lid.loc + (Warnings.Not_principal + ("this type-based " ^ name ^ " disambiguation")) + + (* we selected a name out of the lexical scope *) + let warn_out_of_scope warn lid env tpath = + let path_s = + Printtyp.wrap_printing_env ~error:true env + (fun () -> Printtyp.string_of_path tpath) in + warn lid.loc + (Warnings.Name_out_of_scope (path_s, [Longident.last lid.txt], false)) + + (* warn if the selected name is not the last introduced in scope + -- in these cases the resolution is different from pre-disambiguation OCaml + (this warning is not enabled by default, it is specifically for people + wishing to write backward-compatible code). + *) + let warn_if_disambiguated_name warn lid lbl scope = + match scope with + | Ok ((lab1,_) :: _) when lab1 == lbl -> () + | _ -> + warn lid.loc + (Warnings.Disambiguated_name (get_name lbl)) + + let force_error : ('a, _) result -> 'a = function + | Ok lbls -> lbls + | Error (loc', env', err) -> + Env.lookup_error loc' env' err + + type candidate = t * (unit -> unit) + type nonempty_candidate_filter = + candidate list -> (candidate list, candidate list) result + (** This type is used for candidate filtering functions. + Filtering typically proceeds in several passes, filtering + candidates through increasingly precise conditions. + + We assume that the input list is non-empty, and the output is one of + - [Ok result] for a non-empty list [result] of valid candidates + - [Error candidates] with there are no valid candidates, + and [candidates] is a non-empty subset of the input, typically + the result of the last non-empty filtering step. + *) + + (** [disambiguate] selects a concrete description for [lid] using + some contextual information: + - An optional [expected_type]. + - A list of candidates labels in the current lexical scope, + [candidates_in_scope], that is actually at the type + [(label_descr list, lookup_error) result] so that the + lookup error is only raised when necessary. + - A filtering criterion on candidates in scope [filter_candidates], + representing extra contextual information that can help + candidate selection (see [disambiguate_label_by_ids]). + *) + let disambiguate + ?(warn=Location.prerr_warning) + ?(filter : nonempty_candidate_filter = Result.ok) + usage lid env + expected_type + candidates_in_scope = + let lbl = match expected_type with + | None -> + (* no expected type => no disambiguation *) + begin match filter (force_error candidates_in_scope) with + | Ok [] | Error [] -> assert false + | Error((lbl, _use) :: _rest) -> lbl (* will fail later *) | Ok((lbl, use) :: rest) -> use (); - Printtyp.Conflicts.reset (); - let paths = ambiguous_types env lbl rest in - let expansion = - Format.asprintf "%t" Printtyp.Conflicts.print_explanations in - if paths <> [] then - warn lid.loc - (Warnings.Ambiguous_name ([Longident.last lid.txt], - paths, false, expansion)); + warn_if_ambiguous warn lid env lbl rest; lbl end - | Some(tpath0, tpath, pr) -> - let warn_pr () = - let label = label_of_kind type_kind in - warn lid.loc - (Warnings.Not_principal - ("this type-based " ^ label ^ " disambiguation")) - in - try - let lbl, use = disambiguate_by_type env tpath scope in + | Some(tpath0, tpath, principal) -> + (* If [expected_type] is available, the candidate selected + will correspond to the type-based resolution. + There are two reasons to still check the lexical scope: + - for warning purposes + - for extension types, the type environment does not contain + a list of constructors, so using only type-based selection + would fail. + *) + (* note that [disambiguate_by_type] does not + force [candidates_in_scope]: we just skip this case if there + are no candidates in scope *) + begin match disambiguate_by_type env tpath candidates_in_scope with + | lbl, use -> use (); - if not pr then begin + if not principal then begin (* Check if non-principal type is affecting result *) - match lbls with - | (Error _ : _ result) | Ok [] -> warn_pr () + match (candidates_in_scope : _ result) with + | Error _ -> warn_non_principal warn lid + | Ok lbls -> + match filter lbls with + | Error _ -> warn_non_principal warn lid + | Ok [] -> assert false | Ok ((lbl', _use') :: rest) -> - let lbl_tpath = get_type_path lbl' in - if not (compare_type_path env tpath lbl_tpath) then warn_pr () - else - Printtyp.Conflicts.reset (); - let paths = ambiguous_types env lbl rest in - let expansion = - Format.asprintf "%t" - Printtyp.Conflicts.print_explanations in - if paths <> [] then - warn lid.loc - (Warnings.Ambiguous_name ([Longident.last lid.txt], - paths, false, expansion)) + let lbl_tpath = get_type_path lbl' in + (* no principality warning if the non-principal + type-based selection corresponds to the last + definition in scope *) + if not (compare_type_path env tpath lbl_tpath) + then warn_non_principal warn lid + else warn_if_ambiguous warn lid env lbl rest; end; lbl - with Not_found -> try - let lbl = lookup_from_type env tpath usage lid in - if in_env lbl then - begin - let s = - Printtyp.wrap_printing_env ~error:true env - (fun () -> Printtyp.string_of_path tpath) in - warn lid.loc - (Warnings.Name_out_of_scope (s, [Longident.last lid.txt], false)); - end; - if not pr then warn_pr (); + | exception Not_found -> + (* look outside the lexical scope *) + match lookup_from_type env tpath usage lid with + | lbl -> + (* warn only on nominal labels; + structural labels cannot be qualified anyway *) + if in_env lbl then warn_out_of_scope warn lid env tpath; + if not principal then warn_non_principal warn lid; lbl - with Not_found -> - match lbls with - | (Error(loc', env', err) : _ result) -> - Env.lookup_error loc' env' err - | Ok lbls -> - let tp = (tpath0, expand_path env tpath) in - let tpl = - List.map - (fun (lbl, _) -> - let tp0 = get_type_path lbl in - let tp = expand_path env tp0 in - (tp0, tp)) - lbls - in - raise (Error (lid.loc, env, - Name_type_mismatch (type_kind, lid.txt, tp, tpl))) + | exception Not_found -> + match filter (force_error candidates_in_scope) with + | Ok lbls | Error lbls -> + let tp = (tpath0, expand_path env tpath) in + let tpl = + List.map + (fun (lbl, _) -> + let tp0 = get_type_path lbl in + let tp = expand_path env tp0 in + (tp0, tp)) + lbls + in + raise (Error (lid.loc, env, + Name_type_mismatch (kind, lid.txt, tp, tpl))); + end in + (* warn only on nominal labels *) if in_env lbl then - begin match scope with - | Ok ((lab1,_)::_) when lab1 == lbl -> () - | _ -> - Location.prerr_warning lid.loc - (Warnings.Disambiguated_name(get_name lbl)) - end; + warn_if_disambiguated_name warn lid lbl candidates_in_scope; lbl end -let wrap_disambiguate kind ty f x = - try f x with Error (loc, env, Wrong_name ("",_,tk,tp,name,valid_names)) -> - raise (Error (loc, env, Wrong_name (kind,ty,tk,tp,name,valid_names))) +let wrap_disambiguate msg ty f x = + try f x with + | Wrong_name_disambiguation (env, wrong_name) -> + raise (Error (wrong_name.name.loc, env, Wrong_name (msg, ty, wrong_name))) module Label = NameChoice (struct type t = label_description type usage = unit - let type_kind = "record" + let kind = Datatype_kind.Record let get_name lbl = lbl.lbl_name let get_type lbl = lbl.lbl_res let lookup_all_from_type loc () path env = @@ -747,7 +835,16 @@ module Label = NameChoice (struct | Record_unboxed true | Record_inlined _ | Record_extension _ -> false end) -let disambiguate_label_by_ids keep closed ids labels = +(* In record-construction expressions and patterns, we have many labels + at once; find a candidate type in the intersection of the candidates + of each label. In the [closed] expression case, this candidate must + contain exactly all the labels. + + If our successive refinements result in an empty list, + return [Error] with the last non-empty list of candidates + for use in error messages. +*) +let disambiguate_label_by_ids closed ids labels : (_, _) result = let check_ids (lbl, _) = let lbls = Hashtbl.create 8 in Array.iter (fun lbl -> Hashtbl.add lbls lbl.lbl_name ()) lbl.lbl_all; @@ -755,13 +852,16 @@ let disambiguate_label_by_ids keep closed ids labels = and check_closed (lbl, _) = (not closed || List.length ids = Array.length lbl.lbl_all) in - let labels' = List.filter check_ids labels in - if keep && labels' = [] then (false, labels) else - let labels'' = List.filter check_closed labels' in - if keep && labels'' = [] then (false, labels') else (true, labels'') + match List.filter check_ids labels with + | [] -> Error labels + | labels -> + match List.filter check_closed labels with + | [] -> Error labels + | labels -> + Ok labels (* Only issue warnings once per record constructor/pattern *) -let disambiguate_lid_a_list loc closed env opath lid_a_list = +let disambiguate_lid_a_list loc closed env expected_type lid_a_list = let ids = List.map (fun (lid, _) -> Longident.last lid.txt) lid_a_list in let w_pr = ref false and w_amb = ref [] and w_scope = ref [] and w_scope_ty = ref "" in @@ -775,32 +875,10 @@ let disambiguate_lid_a_list loc closed env opath lid_a_list = | _ -> Location.prerr_warning loc msg in let process_label lid = - (* Strategy for each field: - * collect all the labels in scope for that name - * if the type is known and principal, just eventually warn - if the real label was not in scope - * fail if there is no known type and no label found - * otherwise use other fields to reduce the list of candidates - * if there is no known type reduce it incrementally, so that - there is still at least one candidate (for error message) - * if the reduced list is valid, call Label.disambiguate - *) let scope = Env.lookup_all_labels ~loc:lid.loc lid.txt env in - match opath, scope with - | None, Error(loc, env, err) -> - Env.lookup_error loc env err - | Some _, Error _ -> - Label.disambiguate () lid env opath scope ~warn ~scope - | _, Ok lbls -> - let (ok, lbls) = - match opath with - | Some (_, _, true) -> - (true, lbls) (* disambiguate only checks scope *) - | _ -> disambiguate_label_by_ids (opath=None) closed ids lbls - in - if ok then Label.disambiguate () lid env opath (Ok lbls) ~warn ~scope - else fst (List.hd lbls) (* will fail later *) - in + let filter : Label.nonempty_candidate_filter = + disambiguate_label_by_ids closed ids in + Label.disambiguate ~warn ~filter () 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 !w_pr then @@ -837,7 +915,8 @@ 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 type_lbl_a opath lid_a_list k = +let type_label_a_list + ?labels loc closed env type_lbl_a expected_type lid_a_list k = let lbl_a_list = match lid_a_list, labels with ({txt=Longident.Lident s}, _)::_, Some labels when Hashtbl.mem labels s -> @@ -859,7 +938,7 @@ let type_label_a_list ?labels loc closed env type_lbl_a opath lid_a_list k = | _ -> lid_a) lid_a_list in - disambiguate_lid_a_list loc closed env opath lid_a_list + disambiguate_lid_a_list loc closed env expected_type lid_a_list in (* Invariant: records are sorted in the typed tree *) let lbl_a_list = @@ -902,11 +981,25 @@ let check_recordpat_labels loc lbl_pat_list closed = module Constructor = NameChoice (struct type t = constructor_description type usage = Env.constructor_usage - let type_kind = "variant" + let kind = Datatype_kind.Variant let get_name cstr = cstr.cstr_name let get_type cstr = cstr.cstr_res let lookup_all_from_type loc usage path env = - Env.lookup_all_constructors_from_type ~loc usage path env + match Env.lookup_all_constructors_from_type ~loc usage path env with + | _ :: _ as x -> x + | [] -> + match (Env.find_type path env).type_kind with + | Type_open -> + (* Extension constructors cannot be found by looking at the type + declaration. + We scan the whole environment to get an accurate spellchecking + hint in the subsequent error message *) + let filter lbl = + compare_type_path env + path (get_constr_type_path @@ get_type lbl) in + let add_valid x acc = if filter x then (x,ignore)::acc else acc in + Env.fold_constructors add_valid None env [] + | _ -> [] let in_env _ = true end) @@ -928,8 +1021,8 @@ let unify_head_only ~refine loc env ty constr = 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 half_typed_case = - { typed_pat: pattern; +type 'case_pattern half_typed_case = + { typed_pat: 'case_pattern; pat_type_for_unif: type_expr; untyped_case: Parsetree.case; branch_env: Env.t; @@ -1028,7 +1121,9 @@ and counter_example_checking_info = { (** 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 @@ -1070,29 +1165,37 @@ and splitting_mode = | Refine_or of { inside_nonsplit_or: bool; } (** Only backtrack when needed. - [Refine_or] tries another approach for refining or-pattern. + [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. + 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. + 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. - *) + 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], to jump - back to the parent or-pattern in the [Refine_or] strategy. +(** 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 - 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 +type abort_reason = Adds_constraints | Empty (** Remember current typing state for backtracking. No variable information, as we only backtrack on @@ -1116,8 +1219,9 @@ let set_state s env = let rec find_valid_alternative f pat = match pat.ppat_desc with | Ppat_or(p1,p2) -> - (try find_valid_alternative f p1 - with Error _ -> find_valid_alternative f p2) + (try find_valid_alternative f p1 with + | Empty_branch | Error _ -> find_valid_alternative f p2 + ) | _ -> f pat let no_explosion = function @@ -1140,27 +1244,93 @@ let enter_nonsplit_or mode = match mode with Refine_or {inside_nonsplit_or = true} in Counter_example { info with splitting_mode } -let rec type_pat ?(exception_allowed=false) ~no_existentials ~mode - ~env sp expected_ty k = +(** The typedtree has two distinct syntactic categories for patterns, + "value" patterns, matching on values, and "computation" patterns + that match on the effect of a computation -- typically, exception + patterns (exception p). + + On the other hand, the parsetree has an unstructured representation + where all categories of patterns are mixed together. The + decomposition according to the value/computation structure has to + happen during type-checking. + + We don't want to duplicate the type-checking logic in two different + functions, depending on the kind of pattern to be produced. In + particular, there are both value and computation or-patterns, and + the type-checking logic for or-patterns is horribly complex; having + it in two different places would be twice as horirble. + + The solution is to pass a GADT tag to [type_pat] to indicate whether + a value or computation pattern is expected. This way, there is a single + place where [Ppat_or] nodes are type-checked, the checking logic is shared, + and only at the end do we inspect the tag to decide to produce a value + or computation pattern. +*) +let pure + : type k . k pattern_category -> value general_pattern -> k general_pattern + = fun category pat -> + match category with + | Value -> pat + | Computation -> as_computation_pattern pat + +let only_impure + : type k . k pattern_category -> + computation general_pattern -> k general_pattern + = fun category pat -> + match category with + | Value -> + (* LATER: this exception could be renamed/generalized *) + raise (Error (pat.pat_loc, pat.pat_env, + Exception_pattern_disallowed)) + | Computation -> pat + +let as_comp_pattern + : type k . k pattern_category -> + k general_pattern -> computation general_pattern + = fun category pat -> + match category with + | 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. *) +let rec type_pat + : 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 -> Builtin_attributes.warning_scope sp.ppat_attributes (fun () -> - type_pat_aux ~exception_allowed ~no_existentials ~mode + type_pat_aux category ~no_existentials ~mode ~env sp expected_ty k ) -and type_pat_aux ~exception_allowed ~no_existentials ~mode - ~env sp expected_ty k = - let type_pat ?(exception_allowed=false) ?(mode=mode) ?(env=env) = - type_pat ~exception_allowed ~no_existentials ~mode ~env +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 in let loc = sp.ppat_loc in let refine = match mode with Normal -> false | Counter_example _ -> true in - let rup k x = - if mode = Normal then (ignore (rp x)); + let unif (x : pattern) : pattern = unify_pat ~refine env x (instance expected_ty); - k x + x in - let rp k x : pattern = if mode = Normal then k (rp x) else k 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 @@ -1169,7 +1339,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode in match sp.ppat_desc with Ppat_any -> - let k' d = rp k { + let k' d = rvp k { pat_desc = d; pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; @@ -1181,20 +1351,22 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode | Counter_example {explosion_fuel; _} when explosion_fuel <= 0 -> k' Tpat_any | Counter_example ({explosion_fuel; _} as info) -> - begin match Parmatch.ppat_of_type !env expected_ty with - | exception Parmatch.Empty -> raise (Error (loc, !env, Empty_pattern)) - | (sp, constrs, labels) -> - if sp.ppat_desc = Parsetree.Ppat_any then k' Tpat_any else - if must_backtrack_on_gadt then raise Need_backtrack else + 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 sp.ppat_desc with - Parsetree.Ppat_or _ -> explosion_fuel - 5 - | _ -> explosion_fuel - 1 + 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 ~mode sp expected_ty k + type_pat category ~mode sp expected_ty k end end | Ppat_var name -> @@ -1205,7 +1377,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode else enter_variable loc name ty sp.ppat_attributes in - rp k { + rvp k { pat_desc = Tpat_var (id, name); pat_loc = loc; pat_extra=[]; pat_type = ty; @@ -1216,7 +1388,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode let t = instance expected_ty in begin match name.txt with | None -> - rp k { + rvp k { pat_desc = Tpat_any; pat_loc = sp.ppat_loc; pat_extra=[Tpat_unpack, name.loc, sp.ppat_attributes]; @@ -1226,7 +1398,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode | Some s -> let v = { name with txt = s } in let id = enter_variable loc v t ~is_module:true sp.ppat_attributes in - rp k { + rvp k { pat_desc = Tpat_var (id, v); pat_loc = sp.ppat_loc; pat_extra=[Tpat_unpack, loc, sp.ppat_attributes]; @@ -1250,7 +1422,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode end_def (); generalize ty'; let id = enter_variable lloc name ty' attrs in - rp k { + rvp k { pat_desc = Tpat_var (id, name); pat_loc = lloc; pat_extra = [Tpat_constraint cty, loc, sp.ppat_attributes]; @@ -1262,7 +1434,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode end | Ppat_alias(sq, name) -> assert construction_not_used_in_counterexamples; - type_pat sq expected_ty (fun q -> + type_pat Value sq expected_ty (fun q -> begin_def (); let ty_var = build_as_type env q in end_def (); @@ -1270,7 +1442,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode let id = enter_variable ~is_as_variable:true loc name ty_var sp.ppat_attributes in - rp k { + rvp k { pat_desc = Tpat_alias(q, id, name); pat_loc = loc; pat_extra=[]; pat_type = q.pat_type; @@ -1278,7 +1450,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode pat_env = !env }) | Ppat_constant cst -> let cst = constant_or_raise !env loc cst in - rup k { + rvp k @@ unif { pat_desc = Tpat_constant cst; pat_loc = loc; pat_extra=[]; pat_type = type_constant cst; @@ -1296,7 +1468,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode 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 ~mode:(no_explosion mode) p expected_ty k + type_pat category ~mode:(no_explosion mode) p expected_ty k (* TODO: record 'extra' to remember about interval *) | Ppat_interval _ -> raise (Error (loc, !env, Invalid_interval)) @@ -1309,15 +1481,15 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode end_def (); generalize_structure expected_ty; unify_pat_types ~refine loc env ty expected_ty; - map_fold_cont (fun (p,t) -> type_pat p t) spl_ann (fun pl -> - rp k { + map_fold_cont (fun (p,t) -> type_pat Value p t) spl_ann (fun pl -> + rvp k { 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 }) | Ppat_construct(lid, sarg) -> - let opath = + let expected_type = try let (p0, p, _) = extract_concrete_variant !env expected_ty in Some (p0, p, true) @@ -1334,7 +1506,8 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode Env.lookup_all_constructors Env.Pattern ~loc:lid.loc lid.txt !env in wrap_disambiguate "This variant pattern is expected to have" (mk_expected expected_ty) - (Constructor.disambiguate Env.Pattern lid !env opath) candidates + (Constructor.disambiguate Env.Pattern lid !env expected_type) + candidates in if constr.cstr_generalized && must_backtrack_on_gadt then raise Need_backtrack; @@ -1399,14 +1572,16 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode in if constr.cstr_inlined <> None then List.iter check_non_escaping sargs; - map_fold_cont (fun (p,t) -> type_pat p t) (List.combine sargs ty_args) - (fun args -> - rp k { - pat_desc=Tpat_construct(lid, constr, args); - pat_loc = loc; pat_extra=[]; - pat_type = instance expected_ty; - pat_attributes = sp.ppat_attributes; - pat_env = !env }) + 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); + pat_loc = loc; pat_extra=[]; + pat_type = instance expected_ty; + pat_attributes = sp.ppat_attributes; + pat_env = !env }) | Ppat_variant(l, sarg) -> let arg_type = match sarg with None -> [] | Some _ -> [newgenvar()] in let row = { row_fields = @@ -1426,7 +1601,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode then assert (match mode with Normal -> false | Counter_example _ -> true) else unify_pat_types ~refine loc env (newgenty(Tvariant row)) expected_ty; let k arg = - rp k { + rvp k { pat_desc = Tpat_variant(l, arg, ref {row with row_more = newvar()}); pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; @@ -1435,12 +1610,12 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode in begin (* PR#6235: propagate type information *) match sarg, arg_type with - Some p, [ty] -> type_pat p ty (fun p -> k (Some p)) + Some p, [ty] -> type_pat Value p ty (fun p -> k (Some p)) | _ -> k None end | Ppat_record(lid_sp_list, closed) -> assert (lid_sp_list <> []); - let opath, record_ty = + let expected_type, record_ty = try let (p0, p,_) = extract_concrete_record !env expected_ty in begin_def (); @@ -1462,28 +1637,30 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode end_def (); generalize_structure ty_res; generalize_structure ty_arg; - type_pat sarg ty_arg (fun arg -> + type_pat Value sarg ty_arg (fun arg -> k (label_lid, label, arg)) in - let k' k lbl_pat_list = + let make_record_pat lbl_pat_list = check_recordpat_labels loc lbl_pat_list closed; - rup k { - pat_desc = Tpat_record (lbl_pat_list, closed); - pat_loc = loc; pat_extra=[]; - pat_type = instance record_ty; - pat_attributes = sp.ppat_attributes; - pat_env = !env } + { + pat_desc = Tpat_record (lbl_pat_list, closed); + pat_loc = loc; pat_extra=[]; + pat_type = instance record_ty; + pat_attributes = sp.ppat_attributes; + pat_env = !env; + } in + let k' pat = rvp k (unif pat) in begin match mode with | Normal -> - k (wrap_disambiguate "This record pattern is expected to have" + k' (wrap_disambiguate "This record pattern is expected to have" (mk_expected expected_ty) - (type_label_a_list loc false !env type_label_pat opath + (type_label_a_list loc false !env type_label_pat expected_type lid_sp_list) - (k' (fun x -> x))) + make_record_pat) | Counter_example {labels; _} -> - type_label_a_list ~labels loc false !env type_label_pat opath - lid_sp_list (k' k) + type_label_a_list ~labels loc false !env type_label_pat expected_type + lid_sp_list (fun lbl_pat_list -> k' (make_record_pat lbl_pat_list)) end | Ppat_array spl -> let ty_elt = newgenvar() in @@ -1493,8 +1670,8 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode generalize_structure expected_ty; unify_pat_types ~refine loc env (Predef.type_array ty_elt) expected_ty; - map_fold_cont (fun p -> type_pat p ty_elt) spl (fun pl -> - rp k { + map_fold_cont (fun p -> type_pat Value p ty_elt) spl (fun pl -> + rvp k { pat_desc = Tpat_array pl; pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; @@ -1509,7 +1686,7 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode let state = save_state env in let split_or sp = assert may_split; - let typ pat = type_pat ~exception_allowed pat expected_ty k in + 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 begin let initial_pattern_variables = !pattern_variables in @@ -1522,19 +1699,21 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode gadt_equations_level := Some lev; let env1 = ref !env in let inside_or = enter_nonsplit_or mode in - let p1 = - try Some (type_pat ~exception_allowed ~mode:inside_or - sp1 expected_ty ~env:env1 (fun x -> x)) - with Need_backtrack -> None in + let type_pat_result env sp : (_, abort_reason) result = + match + type_pat category ~mode:inside_or sp expected_ty ~env (fun x -> x) + with + | res -> Ok res + | exception Need_backtrack -> Error Adds_constraints + | exception Empty_branch -> Error Empty + in + let p1 = type_pat_result 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 = - try Some (type_pat ~exception_allowed ~mode:inside_or - sp2 expected_ty ~env:env2 (fun x -> x)) - with Need_backtrack -> None in + let p2 = type_pat_result env2 sp2 in end_def (); gadt_equations_level := equation_level; let p2_variables = !pattern_variables in @@ -1547,34 +1726,41 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode check_scope_escape pv_loc !env2 outter_lev pv_type ) p2_variables; begin match p1, p2 with - | None, None -> - let inside_nonsplit_or = - match get_splitting_mode mode with - | None | Some Backtrack_or -> false - | Some (Refine_or {inside_nonsplit_or}) -> inside_nonsplit_or in - if inside_nonsplit_or - then raise Need_backtrack - else split_or sp - | Some p, None | None, Some p -> rp k p (* no variables in this case *) - | Some p1, Some p2 -> - let alpha_env = - enter_orpat_variables loc !env p1_variables p2_variables in - pattern_variables := p1_variables; - module_variables := p1_module_variables; - rp k { pat_desc = Tpat_or(p1, alpha_pat alpha_env p2, None); - pat_loc = loc; - pat_extra=[]; - pat_type = instance expected_ty; - pat_attributes = sp.ppat_attributes; - pat_env = !env } + | Error Empty, Error Empty -> + raise Empty_branch + | Error Adds_constraints, Error _ + | Error _, Error Adds_constraints -> + let inside_nonsplit_or = + match get_splitting_mode mode with + | None | Some Backtrack_or -> false + | Some (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 -> + 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; + let make_pat desc = + { pat_desc = desc; + pat_loc = loc; pat_extra=[]; + pat_type = instance expected_ty; + pat_attributes = sp.ppat_attributes; + pat_env = !env } in + rp k (make_pat (Tpat_or(p1, p2, None))) end end | Ppat_lazy sp1 -> let nv = newgenvar () in unify_pat_types ~refine loc env (Predef.type_lazy_t nv) expected_ty; (* do not explode under lazy: PR#7421 *) - type_pat ~mode:(no_explosion mode) sp1 nv (fun p1 -> - rp k { + type_pat Value ~mode:(no_explosion mode) sp1 nv (fun p1 -> + rvp k { pat_desc = Tpat_lazy p1; pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; @@ -1589,63 +1775,61 @@ and type_pat_aux ~exception_allowed ~no_existentials ~mode generalize_structure ty; let ty, expected_ty' = instance ty, ty in unify_pat_types ~refine loc env ty (instance expected_ty); - type_pat ~exception_allowed sp expected_ty' (fun p -> + type_pat category sp expected_ty' (fun p -> (*Format.printf "%a@.%a@." Printtyp.raw_type_expr ty Printtyp.raw_type_expr p.pat_type;*) pattern_force := force :: !pattern_force; let extra = (Tpat_constraint cty, loc, sp.ppat_attributes) in - let p = - match p.pat_desc with - Tpat_var (id,s) -> - {p with pat_type = ty; - pat_desc = Tpat_alias - ({p with pat_desc = Tpat_any; pat_attributes = []}, id,s); - pat_extra = [extra]; - } - | _ -> {p with pat_type = ty; - pat_extra = extra :: p.pat_extra} + 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 = + 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) | Ppat_type lid -> let (path, p,ty) = build_or_pat !env loc lid in unify_pat_types ~refine loc env ty (instance expected_ty); - k { p with pat_extra = - (Tpat_type (path, lid), loc, sp.ppat_attributes) :: p.pat_extra } + k @@ pure category @@ { p with pat_extra = + (Tpat_type (path, lid), loc, sp.ppat_attributes) + :: p.pat_extra } | Ppat_open (lid,p) -> let path, new_env = !type_open Asttypes.Fresh !env sp.ppat_loc lid in let new_env = ref new_env in - type_pat ~exception_allowed ~env:new_env p expected_ty ( fun p -> + type_pat category ~env:new_env p expected_ty ( fun p -> env := Env.copy_local !env ~from:!new_env; k { p with pat_extra =( Tpat_open (path,lid,!new_env), loc, sp.ppat_attributes) :: p.pat_extra } ) | Ppat_exception p -> - if not exception_allowed then - raise (Error (loc, !env, Exception_pattern_disallowed)) - else begin - type_pat p Predef.type_exn (fun p_exn -> - rp k { - pat_desc = Tpat_exception p_exn; - pat_loc = sp.ppat_loc; - pat_extra = []; - pat_type = expected_ty; - pat_env = !env; - pat_attributes = sp.ppat_attributes; - }) - end + type_pat Value p Predef.type_exn (fun p_exn -> + rcp k { + pat_desc = Tpat_exception p_exn; + pat_loc = sp.ppat_loc; + pat_extra = []; + pat_type = expected_ty; + pat_env = !env; + pat_attributes = sp.ppat_attributes; + }) | Ppat_extension ext -> raise (Error_forward (Builtin_attributes.error_of_extension ext)) -let type_pat ?exception_allowed ?no_existentials ?(mode=Normal) +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 () -> let r = - type_pat ?exception_allowed ~no_existentials ~mode + type_pat category ~no_existentials ~mode ~env sp expected_ty (fun x -> x) in - iter_pattern (fun p -> p.pat_env <- !env) r; - r + map_general_pattern { f = fun p -> { p with pat_env = !env } } r ) (* this function is passed to Partial.parmatch @@ -1662,13 +1846,11 @@ let partial_pred ~lev ~splitting_mode ?(explode=0) } in try reset_pattern None true; - let typed_p = - Ctype.with_passive_variants (type_pat ~lev ~mode env p) expected_ty - in + 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 _ -> + with Error _ | Empty_branch -> set_state state env; None @@ -1700,60 +1882,83 @@ let add_pattern_variables ?check ?check_as env pv = 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 ?exception_allowed ~lev env spat scope expected_ty = +let type_pattern category ~lev env spat scope expected_ty = reset_pattern scope true; let new_env = ref env in - let pat = type_pat ?exception_allowed ~lev new_env spat expected_ty 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 type_pattern_list no_existentials env spatl scope expected_tys allow = +let type_pattern_list + category no_existentials env spatl scope expected_tys allow + = reset_pattern scope allow; let new_env = ref env in let type_pat (attrs, pat) ty = Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () -> - type_pat ~no_existentials new_env pat ty + type_pat category ~no_existentials new_env pat ty ) in let patl = List.map2 type_pat spatl expected_tys in let pvs = get_ref pattern_variables in - let unpacks = get_ref module_variables in + let unpacks = + List.map (fun (name, loc) -> + name, loc, 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 type_class_arg_pattern cl_num val_env met_env l spat = reset_pattern None false; let nv = newvar () in - let pat = type_pat ~no_existentials:In_class_args (ref val_env) spat nv in + let pat = + type_pat Value ~no_existentials:In_class_args (ref val_env) spat nv in if has_variants pat then begin Parmatch.pressure_variants val_env [pat]; - iter_pattern finalize_variant 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 ())); - let (pv, met_env) = + let (pv, val_env, met_env) = List.fold_right - (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} (pv, env) -> + (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} + (pv, val_env, met_env) -> let check s = if pv_as_var then Warnings.Unused_var s else Warnings.Unused_var_strict s in - let id' = Ident.create_local (Ident.name pv_id) in - ((id', pv_id, pv_type)::pv, - Env.add_value id' {val_type = pv_type; - val_kind = Val_ivar (Immutable, cl_num); - val_attributes = pv_attributes; - Types.val_loc = pv_loc; - } ~check - env)) - !pattern_variables ([], met_env) + let id' = Ident.rename pv_id in + let val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in + let val_env = + Env.add_value pv_id + { val_type = pv_type + ; val_kind = Val_reg + ; val_attributes = pv_attributes + ; val_loc = pv_loc + ; val_uid + } + val_env + in + let met_env = + Env.add_value id' ~check + { val_type = pv_type + ; val_kind = Val_ivar (Immutable, cl_num) + ; val_attributes = pv_attributes + ; val_loc = pv_loc + ; val_uid + } + met_env + in + ((id', pv_id, pv_type)::pv, val_env, met_env)) + !pattern_variables ([], val_env, met_env) in - let val_env = add_pattern_variables val_env (get_ref pattern_variables) in (pat, pv, val_env, met_env) let type_self_pattern cl_num privty val_env met_env par_env spat = @@ -1764,7 +1969,8 @@ let type_self_pattern cl_num privty val_env met_env par_env spat = in reset_pattern None false; let nv = newvar() in - let pat = type_pat ~no_existentials:In_self_pattern (ref val_env) spat nv in + let pat = + type_pat Value ~no_existentials:In_self_pattern (ref val_env) spat nv in List.iter (fun f -> f()) (get_ref pattern_force); let meths = ref Meths.empty in let vars = ref Vars.empty in @@ -1776,12 +1982,13 @@ let type_self_pattern cl_num privty val_env met_env par_env spat = (val_env, met_env, par_env) -> let name = Ident.name pv_id in (Env.enter_unbound_value name Val_unbound_self val_env, - Env.add_value pv_id {val_type = pv_type; - val_kind = - Val_self (meths, vars, cl_num, privty); - val_attributes = pv_attributes; - Types.val_loc = pv_loc; - } + Env.add_value pv_id + {val_type = pv_type; + val_kind = Val_self (meths, vars, cl_num, privty); + val_attributes = pv_attributes; + val_loc = pv_loc; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } ~check:(fun s -> if pv_as_var then Warnings.Unused_var s else Warnings.Unused_var_strict s) met_env, @@ -1837,14 +2044,11 @@ let rec is_nonexpansive exp = (* Not sure this is necessary, if [e] is nonexpansive then we shouldn't care if there are exception patterns. But the previous version enforced that there be none, so... *) - let contains_exception_pat p = - let res = ref false in - iter_pattern (fun p -> + let contains_exception_pat pat = + exists_general_pattern { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with - | Tpat_exception _ -> res := true - | _ -> () - ) p; - !res + | Tpat_exception _ -> true + | _ -> false } pat in is_nonexpansive e && List.for_all @@ -1978,6 +2182,11 @@ let check_recursive_class_bindings env ids exprs = raise(Error(expr.cl_loc, env, Illegal_class_expr))) exprs +let is_prim ~name funct = + match funct.exp_desc with + | Texp_ident (_, _, {val_kind=Val_prim{Primitive.prim_name; _}}) -> + prim_name = name + | _ -> false (* Approximate the type of an expression, for better recursion *) let rec approx_type env sty = @@ -2046,28 +2255,37 @@ let rec list_labels_aux env visited ls ty_fun = let list_labels env ty = wrap_trace_gadt_instances env (list_labels_aux env [] []) ty -(* Check that all univars are safe in a type *) -let check_univars env expans kind exp ty_expected vars = - if expans && maybe_expansive exp then - lower_contravariant env exp.exp_type; - (* 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 - let vars' = - List.filter - (fun t -> - let t = repr t in - generalize t; - match t.desc with - Tvar name when t.level = generic_level -> - set_type_desc t (Tunivar name); true - | _ -> false) - vars in - if List.length vars = List.length vars' then () else - let ty = newgenty (Tpoly(repr exp.exp_type, vars')) - and ty_expected = repr ty_expected in - raise (Error (exp.exp_loc, env, - Less_general(kind, [Unification_trace.diff ty ty_expected]))) +(* Check that all univars are safe in a type. Both exp.exp_type and + 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 pty.desc 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 + 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 + raise (Error (exp.exp_loc, env, + Less_general(kind, [Unification_trace.diff ty ty_expected]))) + +let generalize_and_check_univars env kind exp ty_expected vars = + generalize exp.exp_type; + generalize ty_expected; + List.iter generalize vars; + check_univars env kind exp ty_expected vars let check_partial_application statement exp = let rec f delay = @@ -2161,20 +2379,6 @@ let create_package_type loc env (p, l) = in (s, fields, ty) - let wrap_unpacks sexp unpacks = - let open Ast_helper in - List.fold_left - (fun sexp (name, loc) -> - Exp.letmodule ~loc:{ sexp.pexp_loc with loc_ghost = true } - ~attrs:[Attr.mk (mknoloc "#modulepat") (PStr [])] - { name with txt = Some name.txt } - (Mod.unpack ~loc - (Exp.ident ~loc:name.loc (mkloc (Longident.Lident name.txt) - name.loc))) - sexp - ) - sexp unpacks - (* Helpers for type_cases *) let contains_variant_either ty = @@ -2228,12 +2432,11 @@ let contains_polymorphic_variant p = | _ -> false) p -let contains_gadt cp = - exists_pattern - (function - | {pat_desc = Tpat_construct (_, cd, _)} when cd.cstr_generalized -> true - | _ -> false) - cp +let contains_gadt p = + exists_general_pattern { f = fun (type k) (p : k general_pattern) -> + match p.pat_desc with + | Tpat_construct (_, cd, _) when cd.cstr_generalized -> true + | _ -> false } p (* There are various things that we need to do in presence of GADT constructors that aren't required if there are none. @@ -2248,8 +2451,9 @@ let may_contain_gadts p = p let check_absent_variant env = - iter_pattern - (function {pat_desc = Tpat_variant (s, arg, row)} as pat -> + iter_general_pattern { f = fun (type k) (pat : k general_pattern) -> + match pat.pat_desc with + | Tpat_variant (s, arg, row) -> let row = row_repr !row in if List.exists (fun (s',fi) -> s = s' && row_field_repr fi <> Rabsent) row.row_fields @@ -2263,7 +2467,7 @@ let check_absent_variant env = (* Should fail *) unify_pat (ref env) {pat with pat_type = newty (Tvariant row')} (correct_levels pat.pat_type) - | _ -> ()) + | _ -> () } (* Getting proper location of already typed expressions. @@ -2379,7 +2583,7 @@ and type_expect_ exp_type = instance desc.val_type; exp_attributes = sexp.pexp_attributes; exp_env = env } - | Pexp_constant(Pconst_string (str, _) as cst) -> ( + | 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 @@ -2436,9 +2640,7 @@ and type_expect_ in let (pat_exp_list, new_env, unpacks) = type_let existential_context env rec_flag spat_sexp_list scp true in - let body = - type_expect new_env (wrap_unpacks sbody unpacks) - ty_expected_explained 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 @@ -2529,9 +2731,7 @@ and type_expect_ if maybe_expansive arg then lower_contravariant env arg.exp_type; generalize arg.exp_type; let cases, partial = - type_cases ~exception_allowed:true env arg.exp_type ty_expected true loc - caselist - in + type_cases Computation env arg.exp_type ty_expected true loc caselist in re { exp_desc = Texp_match(arg, cases, partial); exp_loc = loc; exp_extra = []; @@ -2541,7 +2741,7 @@ and type_expect_ | Pexp_try(sbody, caselist) -> let body = type_expect env sbody ty_expected_explained in let cases, _ = - type_cases env Predef.type_exn ty_expected false loc caselist in + type_cases Value env Predef.type_exn ty_expected false loc caselist in re { exp_desc = Texp_try(body, cases); exp_loc = loc; exp_extra = []; @@ -2615,7 +2815,7 @@ and type_expect_ end; Some exp in - let ty_record, opath = + let ty_record, expected_type = let get_path ty = try let (p0, p,_) = extract_concrete_record env ty in @@ -2649,7 +2849,7 @@ and type_expect_ (mk_expected ty_record) (type_label_a_list loc closed env (fun e k -> k (type_label_exp true env loc ty_record e)) - opath lid_sexp_list) + expected_type lid_sexp_list) (fun x -> x) in with_explanation (fun () -> @@ -2720,11 +2920,8 @@ and type_expect_ let num_fields = match lbl_exp_list with [] -> assert false | (_, lbl,_)::_ -> Array.length lbl.lbl_all in - let opt_exp = - if opt_sexp <> None && List.length lid_sexp_list = num_fields then - (Location.prerr_warning loc Warnings.Useless_record_with; None) - else opt_exp - in + if opt_sexp <> None && List.length lid_sexp_list = num_fields then + Location.prerr_warning loc Warnings.Useless_record_with; let label_descriptions, representation = let (_, { lbl_all; lbl_repres }, _) = List.hd lbl_exp_list in lbl_all, lbl_repres @@ -2753,8 +2950,10 @@ and type_expect_ exp_attributes = sexp.pexp_attributes; exp_env = env } | Pexp_setfield(srecord, lid, snewval) -> - let (record, label, opath) = type_label_access env srecord lid in - let ty_record = if opath = None then newvar () else record.exp_type in + let (record, label, expected_type) = + type_label_access env srecord lid in + let ty_record = + if expected_type = None then newvar () else record.exp_type in let (label_loc, label, newval) = type_label_exp false env loc ty_record (lid, label, snewval) in unify_exp env record ty_record; @@ -2833,9 +3032,13 @@ and type_expect_ match param.ppat_desc with | Ppat_any -> Ident.create_local "_for", env | Ppat_var {txt} -> - Env.enter_value txt {val_type = instance Predef.type_int; - val_attributes = []; - val_kind = Val_reg; Types.val_loc = loc; } env + Env.enter_value txt + {val_type = instance Predef.type_int; + val_attributes = []; + val_kind = Val_reg; + val_loc = loc; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } env ~check:(fun s -> Warnings.Unused_for_index s) | _ -> raise (Error (param.ppat_loc, env, Invalid_for_loop_index)) @@ -2990,7 +3193,9 @@ and type_expect_ {val_type = method_type; val_kind = Val_reg; val_attributes = []; - Types.val_loc = Location.none} + val_loc = Location.none; + val_uid = Uid.internal_not_actually_unique; + } in let exp_env = Env.add_value method_id method_desc env in let exp = @@ -3155,7 +3360,8 @@ and type_expect_ in let scope = create_scope () in let md = - { md_type = modl.mod_type; md_attributes = []; md_loc = name.loc } + { 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 @@ -3260,7 +3466,7 @@ and type_expect_ end; let exp = type_expect env sbody (mk_expected ty'') in end_def (); - check_univars env false "method" exp ty_expected vars; + generalize_and_check_univars env "method" exp ty_expected vars; { exp with exp_type = instance ty } | Tvar _ -> let exp = type_exp env sbody in @@ -3288,12 +3494,14 @@ and type_expect_ type_private = Public; type_manifest = None; type_variance = []; + type_separability = []; type_is_newtype = true; type_expansion_scope = Btype.lowest_level; type_loc = loc; type_attributes = []; type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } in let scope = create_scope () in @@ -3396,7 +3604,7 @@ and type_expect_ 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 env ty_params ty_func_result true loc [scase] + type_cases Value env ty_params ty_func_result true loc [scase] in let body = match cases with @@ -3458,15 +3666,6 @@ and type_expect_ and type_ident env ?(recarg=Rejected) lid = let (path, desc) = Env.lookup_value ~loc:lid.loc lid.txt env in - if !Clflags.annotations then begin - let dloc = desc.Types.val_loc in - let annot = - if dloc.Location.loc_ghost then Annot.Iref_external - else Annot.Iref_internal dloc - in - let name = Path.name ~paren:Oprint.parenthesized_ident path in - Stypes.record (Stypes.An_ident (lid.loc, name, annot)) - end; let is_recarg = match (repr desc.val_type).desc with | Tconstr(p, _, _) -> Path.is_constructor_typath p @@ -3536,7 +3735,7 @@ and type_function ?in_function loc attrs env ty_expected_explained l caselist = generalize_structure ty_res end; let cases, partial = - type_cases ~in_function:(loc_fun,ty_fun) env ty_arg ty_res + type_cases Value ~in_function:(loc_fun,ty_fun) env ty_arg ty_res true loc caselist in let not_function ty = let ls, tvar = list_labels env ty in @@ -3562,7 +3761,7 @@ and type_label_access env srecord lid = generalize_structure record.exp_type end; let ty_exp = record.exp_type in - let opath = + let expected_type = try let (p0, p,_) = extract_concrete_record env ty_exp in Some(p0, p, (repr ty_exp).level = generic_level || not !Clflags.principal) @@ -3571,8 +3770,8 @@ and type_label_access env srecord lid = let labels = Env.lookup_all_labels ~loc:lid.loc lid.txt env in let label = wrap_disambiguate "This expression has" (mk_expected ty_exp) - (Label.disambiguate () lid env opath) labels in - (record, label, opath) + (Label.disambiguate () lid env expected_type) labels in + (record, label, expected_type) (* Typing format strings for printing or reading. These formats are used by functions in modules Printf, Format, and Scanf. @@ -3600,7 +3799,7 @@ and type_format loc str env = mk_exp_loc (Pexp_construct (mk_lid_loc lid, arg)) in let mk_cst cst = mk_exp_loc (Pexp_constant cst) in let mk_int n = mk_cst (Pconst_integer (Int.to_string n, None)) - and mk_string str = mk_cst (Pconst_string (str, None)) + and mk_string str = mk_cst (Pconst_string (str, loc, None)) and mk_char chr = mk_cst (Pconst_char chr) in let rec mk_formatting_lit fmting = match fmting with | Close_box -> @@ -3855,8 +4054,13 @@ and type_label_exp create env loc ty_expected let arg = type_argument env sarg ty_arg (instance ty_arg) in end_def (); try - check_univars env (vars <> []) "field value" arg label.lbl_arg vars; - arg + if (vars = []) then arg + else begin + 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 *) Option.iter Btype.backtrack snap; @@ -3864,13 +4068,16 @@ and type_label_exp create env loc ty_expected let arg = type_exp env sarg in end_def (); lower_contravariant env arg.exp_type; - unify_exp env arg ty_arg; - check_univars env false "field value" arg label.lbl_arg vars; - arg + 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; + {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 *) in - (lid, label, {arg with exp_type = instance arg.exp_type}) + (lid, label, arg) and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = (* ty_expected' may be generic *) @@ -3924,7 +4131,9 @@ and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = let desc = { val_type = ty; val_kind = Val_reg; val_attributes = []; - Types.val_loc = Location.none} + val_loc = Location.none; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } in let exp_env = Env.add_value id desc env in {pat_desc = Tpat_var (id, mknoloc name); pat_type = ty;pat_extra=[]; @@ -3980,59 +4189,47 @@ and type_application env funct sargs = let ls, tvar = list_labels env ty_fun in tvar || List.mem l ls in - let ignored = ref [] in - let rec type_unknown_args - (args : - (Asttypes.arg_label * (unit -> Typedtree.expression) option) list) - omitted ty_fun = function - [] -> - (List.map - (function l, None -> l, None - | l, Some f -> l, Some (f ())) - (List.rev args), - instance (result_type omitted ty_fun)) - | (l1, sarg1) :: sargl -> - let (ty1, ty2) = - let ty_fun = expand_head env ty_fun in - match ty_fun.desc with - Tvar _ -> - let t1 = newvar () and t2 = newvar () in - let not_identity = function - Texp_ident(_,_,{val_kind=Val_prim - {Primitive.prim_name="%identity"}}) -> - false - | _ -> true - in - if ty_fun.level >= t1.level && not_identity funct.exp_desc then - Location.prerr_warning sarg1.pexp_loc Warnings.Unused_argument; - unify env ty_fun (newty (Tarrow(l1,t1,t2,Clink(ref Cunknown)))); - (t1, t2) - | Tarrow (l,t1,t2,_) when l = l1 - || !Clflags.classic && l1 = Nolabel && not (is_optional l) -> - (t1, t2) - | td -> - let ty_fun = - match td with Tarrow _ -> newty td | _ -> ty_fun in - let ty_res = result_type (omitted @ !ignored) ty_fun in - match ty_res.desc with - Tarrow _ -> - if (!Clflags.classic || not (has_label l1 ty_fun)) then - raise (Error(sarg1.pexp_loc, env, - Apply_wrong_label(l1, ty_res))) - else - raise (Error(funct.exp_loc, env, Incoherent_label_order)) - | _ -> - raise(Error(funct.exp_loc, env, Apply_non_function - (expand_head env funct.exp_type))) - in - let optional = is_optional l1 in - let arg1 () = - let arg1 = type_expect env sarg1 (mk_expected ty1) in - if optional then - unify_exp env arg1 (type_option(newvar())); - arg1 - in - type_unknown_args ((l1, Some arg1) :: args) omitted ty2 sargl + let eliminated_optional_arguments = ref [] in + let omitted_parameters = ref [] in + let type_unknown_arg (ty_fun, typed_args) (lbl, sarg) = + let (ty_arg, ty_res) = + let ty_fun = expand_head env ty_fun in + match ty_fun.desc with + | Tvar _ -> + let t1 = newvar () and t2 = newvar () in + if ty_fun.level >= t1.level && + not (is_prim ~name:"%identity" funct) + then + Location.prerr_warning sarg.pexp_loc Warnings.Unused_argument; + unify env ty_fun (newty (Tarrow(lbl,t1,t2,Clink(ref Cunknown)))); + (t1, t2) + | Tarrow (l,t1,t2,_) when l = lbl + || !Clflags.classic && lbl = Nolabel && not (is_optional l) -> + (t1, t2) + | td -> + let ty_fun = match td with Tarrow _ -> newty td | _ -> ty_fun in + let ty_res = + result_type (!omitted_parameters @ !eliminated_optional_arguments) + ty_fun + in + match ty_res.desc with + | Tarrow _ -> + if !Clflags.classic || not (has_label lbl ty_fun) then + raise (Error(sarg.pexp_loc, env, + Apply_wrong_label(lbl, ty_res, false))) + else + raise (Error(funct.exp_loc, env, Incoherent_label_order)) + | _ -> + raise(Error(funct.exp_loc, env, Apply_non_function + (expand_head env funct.exp_type))) + in + let arg () = + let arg = type_expect env sarg (mk_expected ty_arg) in + if is_optional lbl then + unify_exp env arg (type_option(newvar())); + arg + in + (ty_res, (lbl, Some arg) :: typed_args) in let ignore_labels = !Clflags.classic || @@ -4052,11 +4249,11 @@ and type_application env funct sargs = end in let warned = ref false in - let rec type_args args omitted ty_fun ty_fun0 ty_old sargs more_sargs = + let rec type_args args ty_fun ty_fun0 sargs = match expand_head env ty_fun, expand_head env ty_fun0 with - {desc=Tarrow (l, ty, ty_fun, com); level=lv} as ty_fun', + | {desc=Tarrow (l, ty, ty_fun, com); level=lv} as ty_fun', {desc=Tarrow (_, ty0, ty_fun0, _)} - when (sargs <> [] || more_sargs <> []) && commu_repr com = Cok -> + when sargs <> [] && commu_repr com = Cok -> let may_warn loc w = if not !warned && !Clflags.principal && lv <> generic_level then begin @@ -4066,108 +4263,110 @@ and type_application env funct sargs = in let name = label_name l and optional = is_optional l in - let sargs, more_sargs, arg = - if ignore_labels && not (is_optional l) then begin - (* In classic mode, omitted = [] *) - match sargs, more_sargs with - (l', sarg0) :: _, _ -> - raise(Error(sarg0.pexp_loc, env, - Apply_wrong_label(l', ty_old))) - | _, (l', sarg0) :: more_sargs -> - if l <> l' && l' <> Nolabel then - raise(Error(sarg0.pexp_loc, env, - Apply_wrong_label(l', ty_fun'))) - else - ([], more_sargs, - Some (fun () -> type_argument env sarg0 ty ty0)) - | _ -> - assert false - end else try - let (l', sarg0, sargs, more_sargs) = - try - let (l', sarg0, sargs1, sargs2) = extract_label name sargs in - if sargs1 <> [] then - may_warn sarg0.pexp_loc - (Warnings.Not_principal "commuting this argument"); - (l', sarg0, sargs1 @ sargs2, more_sargs) - with Not_found -> - let (l', sarg0, sargs1, sargs2) = - extract_label name more_sargs in - if sargs1 <> [] || sargs <> [] then - may_warn sarg0.pexp_loc - (Warnings.Not_principal "commuting this argument"); - (l', sarg0, sargs @ sargs1, sargs2) - in - if not optional && is_optional l' then - Location.prerr_warning sarg0.pexp_loc - (Warnings.Nonoptional_label (Printtyp.string_of_label l)); - sargs, more_sargs, + let use_arg sarg l' = + Some ( if not optional || is_optional l' then - Some (fun () -> type_argument env sarg0 ty ty0) + (fun () -> type_argument env sarg ty ty0) else begin - may_warn sarg0.pexp_loc + may_warn sarg.pexp_loc (Warnings.Not_principal "using an optional argument here"); - Some (fun () -> option_some env (type_argument env sarg0 - (extract_option_type env ty) - (extract_option_type env ty0))) - end - with Not_found -> - sargs, more_sargs, - if optional && - (List.mem_assoc Nolabel sargs - || List.mem_assoc Nolabel more_sargs) - then begin - may_warn funct.exp_loc - (Warnings.Without_principality "eliminated optional argument"); - ignored := (l,ty,lv) :: !ignored; - Some (fun () -> option_none env (instance ty) Location.none) - end else begin - may_warn funct.exp_loc - (Warnings.Without_principality "commuted an argument"); - None + (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.Without_principality "eliminated optional argument"); + eliminated_optional_arguments := + (l,ty,lv) :: !eliminated_optional_arguments; + Some (fun () -> option_none env (instance ty) Location.none) + in + let remaining_sargs, arg = + if ignore_labels then begin + (* No reordering is allowed, process arguments in order *) + match sargs with + | [] -> assert false + | (l', sarg) :: remaining_sargs -> + if name = label_name l' || (not optional && l' = Nolabel) then + (remaining_sargs, use_arg sarg l') + else if + optional && + not (List.exists (fun (l, _) -> name = label_name l) + remaining_sargs) && + List.exists (function (Nolabel, _) -> true | _ -> false) + sargs + then + (sargs, eliminate_optional_arg ()) + else + raise(Error(sarg.pexp_loc, env, + Apply_wrong_label(l', ty_fun', optional))) + end else + (* Arguments can be commuted, try to fetch the argument + corresponding to the first parameter. *) + match extract_label name sargs with + | Some (l', sarg, commuted, remaining_sargs) -> + if commuted then begin + may_warn sarg.pexp_loc + (Warnings.Not_principal "commuting this argument") + end; + 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' + | None -> + sargs, + if optional && List.mem_assoc Nolabel sargs then + eliminate_optional_arg () + else begin + (* No argument was given for this parameter, we abstract over + it. *) + may_warn funct.exp_loc + (Warnings.Without_principality "commuted an argument"); + omitted_parameters := (l,ty,lv) :: !omitted_parameters; + None + end in - let omitted = - if arg = None then (l,ty,lv) :: omitted else omitted in - let ty_old = if sargs = [] then ty_fun else ty_old in - type_args ((l,arg)::args) omitted ty_fun ty_fun0 - ty_old sargs more_sargs + type_args ((l,arg)::args) ty_fun ty_fun0 remaining_sargs | _ -> - match sargs with - (l, sarg0) :: _ when ignore_labels -> - raise(Error(sarg0.pexp_loc, env, - Apply_wrong_label(l, ty_old))) - | _ -> - type_unknown_args args omitted ty_fun0 - (sargs @ more_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 in let is_ignore funct = - match funct.exp_desc with - Texp_ident (_, _, {val_kind=Val_prim{Primitive.prim_name="%ignore"}}) -> - (try ignore (filter_arrow env (instance funct.exp_type) Nolabel); - true - with Unify _ -> false) - | _ -> false + is_prim ~name:"%ignore" funct && + (try ignore (filter_arrow env (instance funct.exp_type) Nolabel); true + with Unify _ -> false) in match sargs with - (* Special case for ignore: avoid discarding warning *) + | (* 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 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 false exp; ([Nolabel, Some exp], ty_res) | _ -> let ty = funct.exp_type in - if ignore_labels then - type_args [] [] ty (instance ty) ty [] sargs - else - type_args [] [] ty (instance ty) ty sargs [] + type_args [] ty (instance ty) sargs and type_construct env loc lid sarg ty_expected_explained attrs = let { ty = ty_expected; explanation } = ty_expected_explained in - let opath = + let expected_type = try let (p0, p,_) = extract_concrete_variant env ty_expected in let principal = @@ -4182,7 +4381,7 @@ and type_construct env loc lid sarg ty_expected_explained attrs = let constr = wrap_disambiguate "This variant expression is expected to have" ty_expected_explained - (Constructor.disambiguate Env.Positive lid env opath) constrs + (Constructor.disambiguate Env.Positive lid env expected_type) constrs in let sargs = match sarg with @@ -4270,9 +4469,65 @@ and type_statement ?explanation env sexp = exp end +and type_unpacks ?in_function env unpacks sbody expected_ty = + let ty = newvar() in + (* remember original level *) + let extended_env, tunpacks = + List.fold_left (fun (env, unpacks) (name, loc, uid) -> + begin_def (); + let context = Typetexp.narrow () in + let modl = + !type_module env + Ast_helper.( + Mod.unpack ~loc + (Exp.ident ~loc:name.loc (mkloc (Longident.Lident name.txt) + name.loc))) + in + Mtype.lower_nongen ty.level 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; } + in + let (id, env) = + Env.enter_module_declaration ~scope name.txt pres md env + in + Typetexp.widen context; + env, (id, name, pres, modl) :: unpacks + ) (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 + (* Typing of match cases *) -and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag - loc caselist = +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 partial_flag loc caselist -> (* ty_arg is _fully_ generalized *) let patterns = List.map (fun {pc_lhs=p} -> p) caselist in let contains_polyvars = List.exists contains_polymorphic_variant patterns in @@ -4322,7 +4577,7 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag end_def (); generalize_structure ty_arg; let (pat, ext_env, force, pvs, unpacks) = - type_pattern ?exception_allowed ~lev env pc_lhs scope ty_arg + type_pattern category ~lev env pc_lhs scope ty_arg in pattern_force := force @ !pattern_force; let pat = @@ -4340,7 +4595,7 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag branch_env = ext_env; pat_vars = pvs; unpacks; - contains_gadt = contains_gadt pat; } + contains_gadt = contains_gadt (as_comp_pattern category pat); } ) caselist in let patl = List.map (fun { typed_pat; _ } -> typed_pat) half_typed_cases in @@ -4362,8 +4617,9 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag unify_pats ty_arg'; (* Check for polymorphic variants to close *) if List.exists has_variants patl then begin - Parmatch.pressure_variants env patl; - List.iter (iter_pattern finalize_variant) patl + 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; @@ -4395,7 +4651,11 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag ~check:(fun s -> Warnings.Unused_var_strict s) ~check_as:(fun s -> Warnings.Unused_var s) in - let sexp = wrap_unpacks pc_rhs unpacks in + let unpacks = + List.map (fun (name, loc) -> + name, loc, Uid.mk ~current_unit:(Env.get_unit_name ()) + ) unpacks + in let ty_res' = if !Clflags.principal then begin begin_def (); @@ -4417,11 +4677,12 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag | None -> None | Some scond -> Some - (type_expect ext_env (wrap_unpacks scond unpacks) + (type_unpacks ext_env unpacks scond (mk_expected ~explanation:When_guard Predef.type_bool)) in let exp = - type_expect ?in_function ext_env sexp (mk_expected ty_res') in + type_unpacks ?in_function ext_env unpacks pc_rhs (mk_expected ty_res') + in { c_lhs = pat; c_guard = guard; @@ -4441,7 +4702,10 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag Subst.type_expr (Subst.for_saving Subst.identity) ty_arg' else ty_arg' in - let val_cases, exn_cases = split_cases env cases in + let val_cases, exn_cases = + match category with + | Value -> (cases : value case list), [] + | Computation -> split_cases env cases in if val_cases = [] && exn_cases <> [] then raise (Error (loc, env, No_value_clauses)); let partial = @@ -4452,7 +4716,7 @@ and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag in let unused_check delayed = List.iter (fun { typed_pat; branch_env; _ } -> - check_absent_variant branch_env typed_pat + 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 ; @@ -4512,7 +4776,7 @@ and type_let spat_sexp_list in let nvs = List.map (fun _ -> newvar ()) spatl in let (pat_list, new_env, force, pvs, unpacks) = - type_pattern_list existential_context env spatl scope nvs allow in + type_pattern_list Value existential_context env spatl scope 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 *) @@ -4532,7 +4796,7 @@ and type_let (fun pat -> if has_variants pat then begin Parmatch.pressure_variants env [pat]; - iter_pattern finalize_variant pat + finalize_variants pat end) pat_list; (* Generalize the structure *) @@ -4624,15 +4888,13 @@ and type_let ((if !some_used then check_strict else check) name) ); Env.set_value_used_callback - name vd + vd (fun () -> match !current_slot with | Some slot -> - slot := (name, vd) :: !slot; rec_needed := true + slot := vd.val_uid :: !slot; rec_needed := true | None -> - List.iter - (fun (name, vd) -> Env.mark_value_used name vd) - (get_ref slot); + List.iter Env.mark_value_used (get_ref slot); used := true; some_used := true ) @@ -4646,12 +4908,9 @@ and type_let let exp_list = List.map2 (fun {pvb_expr=sexp; pvb_attributes; _} (pat, slot) -> - let sexp = - if rec_flag = Recursive then wrap_unpacks sexp unpacks else sexp in if is_recursive then current_slot := slot; match pat.pat_type.desc with | Tpoly (ty, tl) -> - begin_def (); if !Clflags.principal then begin_def (); let vars, ty' = instance_poly ~keep_names:true true tl ty in if !Clflags.principal then begin @@ -4659,15 +4918,23 @@ and type_let generalize_structure ty' end; let exp = - Builtin_attributes.warning_scope pvb_attributes - (fun () -> type_expect exp_env sexp (mk_expected ty')) + 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 - end_def (); - check_univars env true "definition" exp pat.pat_type vars; - {exp with exp_type = instance exp.exp_type} + exp, Some vars | _ -> - Builtin_attributes.warning_scope pvb_attributes (fun () -> - type_expect exp_env sexp (mk_expected pat.pat_type))) + 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 current_slot := None; if is_recursive && not !rec_needed then begin @@ -4687,26 +4954,36 @@ and type_let ) ) pat_list - (List.map2 (fun (attrs, _) e -> attrs, e) spatl exp_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 -> + (fun pat (exp, _) -> if maybe_expansive exp then lower_contravariant env pat.pat_type) pat_list exp_list; iter_pattern_variables_type generalize pvs; - (* We also generalize expressions that are not bound to a variable. - This does not matter in general, but those types are shown by the - interactive toplevel, for example: {[ - let _ = Array.get;; - - : 'a array -> int -> 'a = - ]} *) - List.iter (fun exp -> generalize exp.exp_type) exp_list; + 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 -> + 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 -> + (fun (p, (e, _)) pvb -> {vb_pat=p; vb_expr=e; vb_attributes=pvb.pvb_attributes; vb_loc=pvb.pvb_loc; }) @@ -4817,7 +5094,8 @@ let spellcheck_idents ppf unbound valid_idents = spellcheck ppf (Ident.name unbound) (List.map Ident.name valid_idents) open Format -open Printtyp + +let longident = Printtyp.longident (* Returns the first diff of the trace *) let type_clash_of_trace trace = @@ -4863,7 +5141,8 @@ let report_expr_type_clash_hints exp diff = | Some (Texp_constant const) -> report_literal_type_constraint const diff | _ -> [] -let report_pattern_type_clash_hints pat diff = +let report_pattern_type_clash_hints + (type k) (pat : k pattern_desc option) diff = match pat with | Some (Tpat_constant const) -> report_literal_type_constraint const diff | _ -> [] @@ -4964,21 +5243,29 @@ let report_error ~loc env = function Location.errorf ~loc "@[@[<2>This function has type@ %a@]\ @ @[It is applied to too many arguments;@ %s@]@]" - type_expr typ "maybe you forgot a `;'."; + Printtyp.type_expr typ "maybe you forgot a `;'."; | _ -> Location.errorf ~loc "@[@[<2>This expression has type@ %a@]@ %s@]" - type_expr typ + Printtyp.type_expr typ "This is not a function; it cannot be applied." end - | Apply_wrong_label (l, ty) -> + | 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) in - Location.errorf ~loc + let extra_info = + if not extra_info then + [] + else + [ Location.msg + "Since OCaml 4.11, optional arguments do not commute when \ + -nolabels is given" ] + in + Location.errorf ~loc ~sub:extra_info "@[@[<2>The function applied to this argument has type@ %a@]@.\ This argument cannot be applied %a@]" - type_expr ty print_label l + Printtyp.type_expr ty print_label l | Label_multiply_defined s -> Location.errorf ~loc "The record field label %s is defined several times" s @@ -4989,52 +5276,55 @@ let report_error ~loc env = function print_labels labels | Label_not_mutable lid -> Location.errorf ~loc "The record field %a is not mutable" longident lid - | Wrong_name (eorp, ty_expected, kind, p, name, valid_names) -> + | Wrong_name (eorp, ty_expected, { type_path; kind; name; valid_names; }) -> Location.error_of_printer ~loc (fun ppf () -> - let { ty; explanation } = ty_expected in - if Path.is_constructor_typath p then begin - fprintf ppf - "@[The field %s is not part of the record \ - argument for the %a constructor@]" - name - path p; - end else begin - fprintf ppf - "@[@[<2>%s type@ %a%t@]@ \ - The %s %s does not belong to type %a@]" - eorp type_expr ty - (report_type_expected_explanation_opt explanation) - (label_of_kind kind) - name (*kind*) path p; - end; - spellcheck ppf name valid_names - ) () + 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 \ + argument for the %a constructor@]" + name.txt + Printtyp.type_path type_path; + end else begin + fprintf ppf + "@[@[<2>%s type@ %a%t@]@ \ + The %s %s does not belong to type %a@]" + eorp Printtyp.type_expr ty + (report_type_expected_explanation_opt explanation) + (Datatype_kind.label_name kind) + name.txt (*kind*) Printtyp.type_path type_path; + end; + spellcheck ppf name.txt valid_names + )) () | Name_type_mismatch (kind, lid, tp, tpl) -> - let name = label_of_kind kind in + let type_name = Datatype_kind.type_name kind in + let name = Datatype_kind.label_name kind in Location.error_of_printer ~loc (fun ppf () -> - report_ambiguous_type_error ppf env tp tpl + Printtyp.report_ambiguous_type_error ppf env tp tpl (function ppf -> fprintf ppf "The %s %a@ belongs to the %s type" - name longident lid kind) + name longident lid type_name) (function ppf -> fprintf ppf "The %s %a@ belongs to one of the following %s types:" - name longident lid kind) + name longident lid type_name) (function ppf -> fprintf ppf "but a %s was expected belonging to the %s type" - name kind) + name type_name) ) () | Invalid_format msg -> Location.errorf ~loc "%s" msg | Undefined_method (ty, me, valid_methods) -> Location.error_of_printer ~loc (fun ppf () -> - fprintf ppf - "@[@[This expression has type@;<1 2>%a@]@,\ - It has no method %s@]" type_expr ty me; - begin match valid_methods with - | None -> () - | Some valid_methods -> spellcheck ppf me valid_methods - end - ) () + 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; + begin match valid_methods with + | None -> () + | Some valid_methods -> spellcheck ppf me valid_methods + end + )) () | Undefined_inherited_method (me, valid_methods) -> Location.error_of_printer ~loc (fun ppf () -> fprintf ppf "This expression has no method %s" me; @@ -5052,7 +5342,7 @@ let report_error ~loc env = function Location.errorf ~loc "The instance variable %s is not mutable" v | Not_subtype(tr1, tr2) -> Location.error_of_printer ~loc (fun ppf () -> - report_subtyping_error ppf env tr1 "is not a subtype of" tr2 + Printtyp.report_subtyping_error ppf env tr1 "is not a subtype of" tr2 ) () | Outside_class -> Location.errorf ~loc @@ -5065,10 +5355,10 @@ let report_error ~loc env = function Location.error_of_printer ~loc (fun ppf () -> Printtyp.report_unification_error ppf env trace (function ppf -> - let ty, ty' = prepare_expansion (ty, ty') in + let ty, ty' = Printtyp.prepare_expansion (ty, ty') in fprintf ppf "This expression cannot be coerced to type@;<1 2>%a;@ \ it has type" - (type_expansion ty) ty') + (Printtyp.type_expansion ty) ty') (function ppf -> fprintf ppf "but is here used with type"); if b then @@ -5082,13 +5372,13 @@ let report_error ~loc env = function Location.errorf ~loc "This function expects too many arguments,@ \ it should have type@ %a%t" - type_expr ty + Printtyp.type_expr ty (report_type_expected_explanation_opt explanation) end else begin Location.errorf ~loc "This expression should not be a function,@ \ the expected type is@ %a%t" - type_expr ty + Printtyp.type_expr ty (report_type_expected_explanation_opt explanation) end | Abstract_wrong_label (l, ty, explanation) -> @@ -5098,24 +5388,24 @@ let report_error ~loc env = function (prefixed_label_name l) in Location.errorf ~loc "@[@[<2>This function should have type@ %a%t@]@,%s@]" - type_expr ty + Printtyp.type_expr ty (report_type_expected_explanation_opt explanation) (label_mark l) | 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" - type_expr ty id + Printtyp.type_expr ty id | Private_type ty -> Location.errorf ~loc "Cannot create values of the private type %a" - type_expr ty + Printtyp.type_expr ty | Private_label (lid, ty) -> Location.errorf ~loc "Cannot assign field %a of the private type %a" - longident lid type_expr ty + longident lid 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 type_expr ty + constr.cstr_name Printtyp.type_expr ty | Not_a_variant_type lid -> Location.errorf ~loc "The type %a@ is not a variant type" longident lid | Incoherent_label_order -> @@ -5135,7 +5425,7 @@ 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" - type_expr ty + Printtyp.type_expr ty | Unexpected_existential (reason, name, types) -> let reason_str = match reason with @@ -5233,10 +5523,10 @@ let report_error ~loc env = function fprintf ppf "These bindings have type") (function ppf -> fprintf ppf "but bindings were expected of type") - | Empty_pattern -> assert false let report_error ~loc env err = - wrap_printing_env ~error:true env (fun () -> report_error ~loc env err) + Printtyp.wrap_printing_env ~error:true env + (fun () -> report_error ~loc env err) let () = Location.register_error_of_exn diff --git a/typing/typecore.mli b/typing/typecore.mli index f8fc66e9..2c8d177e 100644 --- a/typing/typecore.mli +++ b/typing/typecore.mli @@ -55,6 +55,19 @@ val mk_expected: val is_nonexpansive: Typedtree.expression -> bool +module Datatype_kind : sig + type t = Record | Variant + val type_name : t -> string + val label_name : t -> string +end + +type wrong_name = { + type_path: Path.t; + kind: Datatype_kind.t; + name: string loc; + valid_names: string list; +} + type existential_restriction = | At_toplevel (** no existential types at the toplevel *) | In_group (** nor with [let ... and ...] *) @@ -78,7 +91,8 @@ val type_expression: Env.t -> Parsetree.expression -> Typedtree.expression val type_class_arg_pattern: string -> Env.t -> Env.t -> arg_label -> Parsetree.pattern -> - Typedtree.pattern * (Ident.t * Ident.t * type_expr) list * + Typedtree.pattern * + (Ident.t * Ident.t * type_expr) list * Env.t * Env.t val type_self_pattern: string -> type_expr -> Env.t -> Env.t -> Env.t -> Parsetree.pattern -> @@ -89,7 +103,7 @@ val type_self_pattern: Env.t * Env.t * Env.t val check_partial: ?lev:int -> Env.t -> type_expr -> - Location.t -> Typedtree.case list -> Typedtree.partial + 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 @@ -109,16 +123,15 @@ val reset_delayed_checks: unit -> unit val force_delayed_checks: unit -> unit val name_pattern : string -> Typedtree.pattern list -> Ident.t - -val name_cases : string -> Typedtree.case list -> Ident.t +val name_cases : string -> Typedtree.value Typedtree.case list -> Ident.t val self_coercion : (Path.t * Location.t list ref) list ref type error = | Constructor_arity_mismatch of Longident.t * int * int | Label_mismatch of Longident.t * Ctype.Unification_trace.t - | Pattern_type_clash of - Ctype.Unification_trace.t * Typedtree.pattern_desc option + | Pattern_type_clash : + Ctype.Unification_trace.t * _ Typedtree.pattern_desc option -> error | Or_pattern_type_clash of Ident.t * Ctype.Unification_trace.t | Multiply_bound_variable of string | Orpat_vars of Ident.t * Ident.t list @@ -126,14 +139,13 @@ type error = Ctype.Unification_trace.t * type_forcing_context option * Typedtree.expression_desc option | Apply_non_function of type_expr - | Apply_wrong_label of arg_label * type_expr + | Apply_wrong_label of arg_label * type_expr * bool | Label_multiply_defined of string | Label_missing of Ident.t list | Label_not_mutable of Longident.t - | Wrong_name of - string * type_expected * string * Path.t * string * string list + | Wrong_name of string * type_expected * wrong_name | Name_type_mismatch of - string * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list + Datatype_kind.t * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list | Invalid_format of string | Undefined_method of type_expr * string * string list option | Undefined_inherited_method of string * string list @@ -173,7 +185,6 @@ type error = | Illegal_letrec_pat | Illegal_letrec_expr | Illegal_class_expr - | Empty_pattern | Letop_type_clash of string * Ctype.Unification_trace.t | Andop_type_clash of string * Ctype.Unification_trace.t | Bindings_type_clash of Ctype.Unification_trace.t diff --git a/typing/typedecl.ml b/typing/typedecl.ml index 3e0a8291..d38a1423 100644 --- a/typing/typedecl.ml +++ b/typing/typedecl.ml @@ -37,7 +37,12 @@ type error = | Constraint_failed of type_expr * type_expr | Inconsistent_constraint of Env.t * Ctype.Unification_trace.t | Type_clash of Env.t * Ctype.Unification_trace.t - | Parameters_differ of Path.t * type_expr * type_expr + | Non_regular of { + definition: Path.t; + used_as: type_expr; + defined_as: type_expr; + expansions: (type_expr * type_expr) list; + } | Null_arity_external | Missing_native_external | Unbound_type_var of type_expr * type_declaration @@ -56,8 +61,8 @@ type error = | Cannot_unbox_or_untag_type of native_repr_kind | Deep_unbox_or_untag_attribute of native_repr_kind | Immediacy of Typedecl_immediacy.error + | Separability of Typedecl_separability.error | Bad_unboxed_attribute of string - | Wrong_unboxed_type_float | Boxed_and_unboxed | Nonrec_gadt @@ -84,7 +89,7 @@ let add_type ~check id decl env = Builtin_attributes.warning_scope ~ppwarning:false decl.type_attributes (fun () -> Env.add_type ~check id decl env) -let enter_type rec_flag env sdecl id = +let enter_type rec_flag env sdecl (id, uid) = let needed = match rec_flag with | Asttypes.Nonrecursive -> @@ -98,23 +103,26 @@ let enter_type rec_flag env sdecl id = Btype.is_row_name (Ident.name id) | Asttypes.Recursive -> true in + let arity = List.length sdecl.ptype_params in if not needed then env else let decl = { type_params = List.map (fun _ -> Btype.newgenvar ()) sdecl.ptype_params; - type_arity = List.length sdecl.ptype_params; + type_arity = arity; type_kind = Type_abstract; type_private = sdecl.ptype_private; type_manifest = begin match sdecl.ptype_manifest with None -> None | Some _ -> Some(Ctype.newvar ()) end; type_variance = List.map (fun _ -> Variance.full) sdecl.ptype_params; + type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = sdecl.ptype_loc; type_attributes = sdecl.ptype_attributes; type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = uid; } in add_type ~check:true id decl env @@ -222,7 +230,8 @@ let transl_labels env closed lbls = ld_mutable = ld.ld_mutable; ld_type = ty; ld_loc = ld.ld_loc; - ld_attributes = ld.ld_attributes + ld_attributes = ld.ld_attributes; + ld_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } ) lbls in @@ -244,7 +253,7 @@ let make_constructor env type_path type_params sargs sret_type = let args, targs = transl_constructor_arguments env true sargs in - targs, None, args, None, type_params + targs, None, args, None | Some sret_type -> (* if it's a generalized constructor we must first narrow and then widen so as to not introduce any new constraints *) @@ -255,93 +264,17 @@ let make_constructor env type_path type_params sargs sret_type = in let tret_type = transl_simple_type env false sret_type in let ret_type = tret_type.ctyp_type in - let params = - match (Ctype.repr ret_type).desc with - | Tconstr (p', params, _) when Path.same type_path p' -> - params + (* TODO add back type_path as a parameter ? *) + begin match (Ctype.repr ret_type).desc with + | Tconstr (p', _, _) when Path.same type_path p' -> () | _ -> raise (Error (sret_type.ptyp_loc, Constraint_failed (ret_type, Ctype.newconstr type_path type_params))) - in + end; widen z; - targs, Some tret_type, args, Some ret_type, params - -(* Check that the variable [id] is present in the [univ] list. *) -let check_type_var loc univ id = - let f t = (Btype.repr t).id = id in - if not (List.exists f univ) then raise (Error (loc, Wrong_unboxed_type_float)) - -(* Check that all the variables found in [ty] are in [univ]. - Because [ty] is the argument to an abstract type, the representation - of that abstract type could be any subexpression of [ty], in particular - any type variable present in [ty]. -*) -let rec check_unboxed_abstract_arg loc univ ty = - match ty.desc with - | Tvar _ -> check_type_var loc univ ty.id - | Tarrow (_, t1, t2, _) - | Tfield (_, _, t1, t2) -> - check_unboxed_abstract_arg loc univ t1; - check_unboxed_abstract_arg loc univ t2 - | Ttuple args - | Tconstr (_, args, _) - | Tpackage (_, _, args) -> - List.iter (check_unboxed_abstract_arg loc univ) args - | Tobject (fields, r) -> - check_unboxed_abstract_arg loc univ fields; - begin match !r with - | None -> () - | Some (_, args) -> List.iter (check_unboxed_abstract_arg loc univ) args - end - | Tnil - | Tunivar _ -> () - | Tlink e -> check_unboxed_abstract_arg loc univ e - | Tsubst _ -> assert false - | Tvariant { row_fields; row_more; row_name } -> - List.iter (check_unboxed_abstract_row_field loc univ) row_fields; - check_unboxed_abstract_arg loc univ row_more; - begin match row_name with - | None -> () - | Some (_, args) -> List.iter (check_unboxed_abstract_arg loc univ) args - end - | Tpoly (t, _) -> check_unboxed_abstract_arg loc univ t - -and check_unboxed_abstract_row_field loc univ (_, field) = - match field with - | Rpresent (Some ty) -> check_unboxed_abstract_arg loc univ ty - | Reither (_, args, _, r) -> - List.iter (check_unboxed_abstract_arg loc univ) args; - begin match !r with - | None -> () - | Some f -> check_unboxed_abstract_row_field loc univ ("", f) - end - | Rabsent - | Rpresent None -> () + targs, Some tret_type, args, Some ret_type -(* Check that the argument to a GADT constructor is compatible with unboxing - the type, given the universal parameters of the type. *) -let rec check_unboxed_gadt_arg loc univ env ty = - match get_unboxed_type_representation env ty with - | Some {desc = Tvar _; id} -> check_type_var loc univ id - | Some {desc = Tarrow _ | Ttuple _ | Tpackage _ | Tobject _ | Tnil - | Tvariant _; _} -> - () - (* A comment in [Translcore.transl_exp0] claims the above cannot be - represented by floats. *) - | Some {desc = Tconstr (p, args, _); _} -> - let tydecl = Env.find_type p env in - assert (not tydecl.type_unboxed.unboxed); - if tydecl.type_kind = Type_abstract then - List.iter (check_unboxed_abstract_arg loc univ) args - | Some {desc = Tfield _ | Tlink _ | Tsubst _; _} -> assert false - | Some {desc = Tunivar _; _} -> () - | Some {desc = Tpoly (t2, _); _} -> check_unboxed_gadt_arg loc univ env t2 - | None -> () - (* This case is tricky: the argument is another (or the same) type - in the same recursive definition. In this case we don't have to - check because we will also check that other type for correctness. *) - -let transl_declaration env sdecl id = +let transl_declaration env sdecl (id, uid) = (* Bind type parameters *) reset_type_variables(); Ctype.begin_def (); @@ -355,47 +288,43 @@ let transl_declaration env sdecl id = in let raw_status = get_unboxed_from_attributes sdecl in if raw_status.unboxed && not raw_status.default then begin + let bad msg = raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute msg)) in match sdecl.ptype_kind with - | Ptype_abstract -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "it is abstract")) - | Ptype_variant [{pcd_args = Pcstr_tuple []; _}] -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "its constructor has no argument")) - | Ptype_variant [{pcd_args = Pcstr_tuple [_]; _}] -> () - | Ptype_variant [{pcd_args = Pcstr_tuple _; _}] -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "its constructor has more than one argument")) - | Ptype_variant [{pcd_args = Pcstr_record - [{pld_mutable=Immutable; _}]; _}] -> () - | Ptype_variant [{pcd_args = Pcstr_record [{pld_mutable=Mutable; _}]; _}] -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute "it is mutable")) - | Ptype_variant [{pcd_args = Pcstr_record _; _}] -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "its constructor has more than one argument")) - | Ptype_variant _ -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "it has more than one constructor")) - | Ptype_record [{pld_mutable=Immutable; _}] -> () - | Ptype_record [{pld_mutable=Mutable; _}] -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "it is mutable")) - | Ptype_record _ -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "it has more than one field")) - | Ptype_open -> - raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute - "extensible variant types cannot be unboxed")) + | Ptype_abstract -> bad "it is abstract" + | Ptype_open -> bad "extensible variant types cannot be unboxed" + | Ptype_record fields -> begin match fields with + | [] -> bad "it has no fields" + | _::_::_ -> bad "it has more than one field" + | [{pld_mutable = Mutable}] -> bad "it is mutable" + | [{pld_mutable = Immutable}] -> () + end + | Ptype_variant constructors -> begin match constructors with + | [] -> bad "it has no constructor" + | (_::_::_) -> bad "it has more than one constructor" + | [c] -> begin match c.pcd_args with + | Pcstr_tuple [] -> + bad "its constructor has no argument" + | Pcstr_tuple (_::_::_) -> + bad "its constructor has more than one argument" + | Pcstr_tuple [_] -> + () + | Pcstr_record [] -> + bad "its constructor has no fields" + | Pcstr_record (_::_::_) -> + bad "its constructor has more than one field" + | Pcstr_record [{pld_mutable = Mutable}] -> + bad "it is mutable" + | Pcstr_record [{pld_mutable = Immutable}] -> + () + end + end end; let unboxed_status = match sdecl.ptype_kind with | Ptype_variant [{pcd_args = Pcstr_tuple [_]; _}] - | Ptype_variant [{pcd_args = Pcstr_record - [{pld_mutable = Immutable; _}]; _}] - | Ptype_record [{pld_mutable = Immutable; _}] -> - raw_status - | _ -> (* The type is not unboxable, mark it as boxed *) - unboxed_false_default_false + | Ptype_variant [{pcd_args = Pcstr_record [{pld_mutable=Immutable; _}]; _}] + | Ptype_record [{pld_mutable=Immutable; _}] -> raw_status + | _ -> unboxed_false_default_false (* Not unboxable, mark as boxed *) in let unbox = unboxed_status.unboxed in let (tkind, kind) = @@ -421,28 +350,10 @@ let transl_declaration env sdecl id = raise(Error(sdecl.ptype_loc, Too_many_constructors)); let make_cstr scstr = let name = Ident.create_local scstr.pcd_name.txt in - let targs, tret_type, args, ret_type, cstr_params = + let targs, tret_type, args, ret_type = make_constructor env (Path.Pident id) params scstr.pcd_args scstr.pcd_res in - if Config.flat_float_array && unbox then begin - (* Cannot unbox a type when the argument can be both float and - non-float because it interferes with the dynamic float array - optimization. This can only happen when the type is a GADT - and the argument is an existential type variable or an - unboxed (or abstract) type constructor applied to some - existential type variable. Of course we also have to rule - out any abstract type constructor applied to anything that - might be an existential type variable. - There is a difficulty with existential variables created - out of thin air (rather than bound by the declaration). - See PR#7511 and GPR#1133 for details. *) - match Datarepr.constructor_existentials args ret_type with - | _, [] -> () - | [argty], _ex -> - check_unboxed_gadt_arg sdecl.ptype_loc cstr_params env argty - | _ -> assert false - end; let tcstr = { cd_id = name; cd_name = scstr.pcd_name; @@ -456,7 +367,8 @@ let transl_declaration env sdecl id = cd_args = args; cd_res = ret_type; cd_loc = scstr.pcd_loc; - cd_attributes = scstr.pcd_attributes } + cd_attributes = scstr.pcd_attributes; + cd_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) } in tcstr, cstr in @@ -484,19 +396,22 @@ let transl_declaration env sdecl id = let cty = transl_simple_type env no_row sty in Some cty, Some cty.ctyp_type in + let arity = List.length params in let decl = { type_params = params; - type_arity = List.length params; + type_arity = arity; type_kind = kind; type_private = sdecl.ptype_private; type_manifest = man; type_variance = List.map (fun _ -> Variance.full) params; + type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = sdecl.ptype_loc; type_attributes = sdecl.ptype_attributes; type_immediate = Unknown; type_unboxed = unboxed_status; + type_uid = uid; } in (* Check constraints *) @@ -761,7 +676,7 @@ let check_recursion env loc path decl to_check = let visited = ref [] in - let rec check_regular cpath args prev_exp ty = + let rec check_regular cpath args prev_exp prev_expansions ty = let ty = Ctype.repr ty in if not (List.memq ty !visited) then begin visited := ty :: !visited; @@ -770,7 +685,12 @@ let check_recursion env loc path decl to_check = if Path.same path path' then begin if not (Ctype.equal env false args args') then raise (Error(loc, - Parameters_differ(cpath, ty, Ctype.newconstr path args))) + Non_regular { + definition=path; + used_as=ty; + defined_as=Ctype.newconstr path args; + expansions=List.rev prev_expansions; + })) end (* Attempt to expand a type abbreviation if: 1- [to_check path'] holds @@ -790,15 +710,18 @@ let check_recursion env loc path decl to_check = raise (Error(loc, Constraint_failed (ty, Ctype.newconstr path' params0))); end; - check_regular path' args (path' :: prev_exp) body + check_regular path' args + (path' :: prev_exp) ((ty,body) :: prev_expansions) + body with Not_found -> () end; - List.iter (check_regular cpath args prev_exp) args' + List.iter (check_regular cpath args prev_exp prev_expansions) args' | Tpoly (ty, tl) -> let (_, ty) = Ctype.instance_poly ~keep_names:true false tl ty in - check_regular cpath args prev_exp ty + check_regular cpath args prev_exp prev_expansions ty | _ -> - Btype.iter_type_expr (check_regular cpath args prev_exp) ty + Btype.iter_type_expr + (check_regular cpath args prev_exp prev_expansions) ty end in Option.iter @@ -806,7 +729,7 @@ let check_recursion env loc path decl to_check = let (args, body) = Ctype.instance_parameterized_type ~keep_names:true decl.type_params body in - check_regular path args [] body) + check_regular path args [] [] body) decl.type_manifest let check_abbrev_recursion env id_loc_list to_check tdecl = @@ -814,8 +737,6 @@ let check_abbrev_recursion env id_loc_list to_check tdecl = let id = tdecl.typ_id in check_recursion env (List.assoc id id_loc_list) (Path.Pident id) decl to_check -(* Check multiple declarations of labels/constructors *) - let check_duplicates sdecl_list = let labels = Hashtbl.create 7 and constrs = Hashtbl.create 7 in List.iter @@ -907,38 +828,38 @@ let transl_type_decl env rec_flag sdecl_list = (* Create identifiers. *) let scope = Ctype.create_scope () in - let id_list = - List.map (fun sdecl -> Ident.create_scoped ~scope sdecl.ptype_name.txt) - sdecl_list + let ids_list = + List.map (fun sdecl -> + Ident.create_scoped ~scope sdecl.ptype_name.txt, + 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 id_list in + 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 id_slots id = + 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 - let name = Ident.name id in Env.set_type_used_callback - name td + td (fun old_callback -> match !current_slot with - | Some slot -> slot := (name, td) :: !slot + | Some slot -> slot := td.type_uid :: !slot | None -> - List.iter (fun (name, d) -> Env.mark_type_used name d) - (get_ref slot); + List.iter Env.mark_type_used (get_ref slot); old_callback () ); - id, Some slot + ids, Some slot | Asttypes.Recursive | Asttypes.Nonrecursive -> - id, None + ids, None in let transl_declaration name_sdecl (id, slot) = current_slot := slot; @@ -947,7 +868,7 @@ let transl_type_decl env rec_flag sdecl_list = (fun () -> transl_declaration temp_env name_sdecl id) in let tdecls = - List.map2 transl_declaration sdecl_list (List.map id_slots id_list) in + 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; @@ -960,16 +881,16 @@ let transl_type_decl env rec_flag sdecl_list = | Asttypes.Nonrecursive -> () | Asttypes.Recursive -> List.iter2 - (fun id sdecl -> update_type temp_env new_env id sdecl.ptype_loc) - id_list sdecl_list + (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)) - id_list sdecl_list + List.map2 (fun (id, _) sdecl -> (id, sdecl.ptype_loc)) + ids_list sdecl_list in List.iter (fun (id, decl) -> check_well_founded_manifest new_env (List.assoc id id_loc_list) @@ -999,9 +920,14 @@ let transl_type_decl env rec_flag sdecl_list = |> name_recursion_decls sdecl_list |> Typedecl_variance.update_decls env sdecl_list |> Typedecl_immediacy.update_decls env + |> Typedecl_separability.update_decls env with - | Typedecl_variance.Error (loc, err) -> raise (Error (loc, Variance err)) - | Typedecl_immediacy.Error (loc, err) -> raise (Error (loc, Immediacy err)) + | Typedecl_variance.Error (loc, err) -> + raise (Error (loc, Variance err)) + | Typedecl_immediacy.Error (loc, err) -> + raise (Error (loc, Immediacy err)) + | Typedecl_separability.Error (loc, err) -> + raise (Error (loc, Separability err)) in (* Compute the final environment with variance and immediacy *) let final_env = add_types_to_env decls env in @@ -1026,7 +952,7 @@ let transl_extension_constructor env type_path type_params let args, ret_type, kind = match sext.pext_kind with Pext_decl(sargs, sret_type) -> - let targs, tret_type, args, ret_type, _ = + let targs, tret_type, args, ret_type = make_constructor env type_path typext_params sargs sret_type in @@ -1123,7 +1049,9 @@ let transl_extension_constructor env type_path type_params ext_ret_type = ret_type; ext_private = priv; Types.ext_loc = sext.pext_loc; - Types.ext_attributes = sext.pext_attributes; } + Types.ext_attributes = sext.pext_attributes; + ext_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } in { ext_id = id; ext_name = sext.pext_name; @@ -1138,6 +1066,11 @@ let transl_extension_constructor env type_path type_params (fun () -> transl_extension_constructor env type_path type_params typext_params priv sext) +let is_rebind ext = + match ext.ext_kind with + | Text_rebind _ -> true + | Text_decl _ -> false + let transl_type_extension extend env loc styext = reset_type_variables(); Ctype.begin_def(); @@ -1227,7 +1160,8 @@ let transl_type_extension extend env loc styext = let newenv = List.fold_left (fun env ext -> - Env.add_extension ~check:true ext.ext_id ext.ext_type env) + let rebind = is_rebind ext in + Env.add_extension ~check:true ~rebind ext.ext_id ext.ext_type env) env constructors in let tyext = @@ -1262,7 +1196,10 @@ let transl_exception env sext = raise (Error(ext.ext_loc, Unbound_type_var_ext(ty, ext.ext_type))) | None -> () end; - let newenv = Env.add_extension ~check:true ext.ext_id ext.ext_type env in + let rebind = is_rebind ext in + let newenv = + Env.add_extension ~check:true ~rebind ext.ext_id ext.ext_type env + in ext, newenv let transl_type_exception env t = @@ -1387,7 +1324,9 @@ let transl_value_decl env loc valdecl = match valdecl.pval_prim with [] when Env.is_in_signature env -> { val_type = ty; val_kind = Val_reg; Types.val_loc = loc; - val_attributes = valdecl.pval_attributes } + val_attributes = valdecl.pval_attributes; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } | [] -> raise (Error(valdecl.pval_loc, Val_in_structure)) | _ -> @@ -1415,7 +1354,9 @@ let transl_value_decl env loc valdecl = then raise(Error(valdecl.pval_type.ptyp_loc, Missing_native_external)); check_unboxable env loc ty; { val_type = ty; val_kind = Val_prim prim; Types.val_loc = loc; - val_attributes = valdecl.pval_attributes } + val_attributes = valdecl.pval_attributes; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } in let (id, newenv) = Env.enter_value valdecl.pval_name.txt v env @@ -1438,29 +1379,38 @@ let transl_value_decl env loc valdecl = (fun () -> transl_value_decl env loc valdecl) (* Translate a "with" constraint -- much simplified version of - transl_type_decl. *) -let transl_with_constraint env id row_path orig_decl sdecl = - Env.mark_type_used (Ident.name id) orig_decl; + transl_type_decl. For a constraint [Sig with t = sdecl], + there are two declarations of interest in two environments: + - [sig_decl] is the declaration of [t] in [Sig], + in the environment [sig_env] (containing the declarations + of [Sig] before [t]) + - [sdecl] is the new syntactic declaration, to be type-checked + in the current, outer environment [with_env]. + + In particular, note that [sig_env] is an extension of + [outer_env]. +*) +let transl_with_constraint id row_path ~sig_env ~sig_decl ~outer_env sdecl = + Env.mark_type_used sig_decl.type_uid; reset_type_variables(); Ctype.begin_def(); + (* In the first part of this function, we typecheck the syntactic + declaration [sdecl] in the outer environment [outer_env]. *) + let env = outer_env in + let loc = sdecl.ptype_loc in let tparams = make_params env sdecl.ptype_params in let params = List.map (fun (cty, _) -> cty.ctyp_type) tparams in - let orig_decl = Ctype.instance_declaration orig_decl in - let arity_ok = List.length params = orig_decl.type_arity in - if arity_ok then - List.iter2 (Ctype.unify_var env) params orig_decl.type_params; - let constraints = List.map - (function (ty, ty', loc) -> - try - let cty = transl_simple_type env false ty in - let cty' = transl_simple_type env false ty' in - let ty = cty.ctyp_type in - let ty' = cty'.ctyp_type in - Ctype.unify env ty ty'; - (cty, cty', loc) - with Ctype.Unify tr -> - raise(Error(loc, Inconsistent_constraint (env, tr)))) - sdecl.ptype_cstrs + 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 + (* Note: We delay the unification of those constraints + after the unification of parameters, so that clashing + constraints report an error on the constraint location + rather than the parameter location. *) + (cty, cty', loc) + ) sdecl.ptype_cstrs in let no_row = not (is_fixed_type sdecl) in let (tman, man) = match sdecl.ptype_manifest with @@ -1469,60 +1419,110 @@ let transl_with_constraint env id row_path orig_decl sdecl = let cty = transl_simple_type env no_row sty in Some cty, Some 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 + work in the larger signature environment [sig_env], because + [sig_decl.type_params] and [sig_decl.type_kind] are only valid + there. *) + let env = sig_env in + let sig_decl = Ctype.instance_declaration sig_decl in + let arity_ok = arity = sig_decl.type_arity in + if arity_ok then + List.iter2 (fun (cty, _) tparam -> + try Ctype.unify_var env cty.ctyp_type tparam + with Ctype.Unify tr -> + raise(Error(cty.ctyp_loc, Inconsistent_constraint (env, tr))) + ) tparams sig_decl.type_params; + List.iter (fun (cty, cty', loc) -> + (* Note: contraints must also be enforced in [sig_env] because + they may contain parameter variables from [tparams] + that have now be unified in [sig_env]. *) + try Ctype.unify env cty.ctyp_type cty'.ctyp_type + with Ctype.Unify tr -> + raise(Error(loc, Inconsistent_constraint (env, tr))) + ) constraints; let priv = if sdecl.ptype_private = Private then Private else - if arity_ok && orig_decl.type_kind <> Type_abstract - then orig_decl.type_private else sdecl.ptype_private + if arity_ok && sig_decl.type_kind <> Type_abstract + then sig_decl.type_private else sdecl.ptype_private in - if arity_ok && orig_decl.type_kind <> Type_abstract + if arity_ok && sig_decl.type_kind <> Type_abstract && sdecl.ptype_private = Private then - Location.deprecated sdecl.ptype_loc "spurious use of private"; + Location.deprecated loc "spurious use of private"; let type_kind, type_unboxed = if arity_ok && man <> None then - orig_decl.type_kind, orig_decl.type_unboxed + sig_decl.type_kind, sig_decl.type_unboxed else Type_abstract, unboxed_false_default_false in - let decl = + let new_sig_decl = { type_params = params; - type_arity = List.length params; + type_arity = arity; type_kind; type_private = priv; type_manifest = man; type_variance = []; + type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; - type_loc = sdecl.ptype_loc; + type_loc = loc; type_attributes = sdecl.ptype_attributes; type_immediate = Unknown; type_unboxed; + type_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } in begin match row_path with None -> () - | Some p -> set_fixed_row env sdecl.ptype_loc p decl + | Some p -> set_fixed_row env loc p new_sig_decl end; - begin match Ctype.closed_type_decl decl with None -> () - | Some ty -> raise(Error(sdecl.ptype_loc, Unbound_type_var(ty,decl))) + begin match Ctype.closed_type_decl new_sig_decl with None -> () + | Some ty -> raise(Error(loc, Unbound_type_var(ty, new_sig_decl))) end; - let decl = name_recursion sdecl id decl in - let type_variance = - try Typedecl_variance.compute_decl - env ~check:true decl (Typedecl_variance.variance_of_sdecl sdecl) + let new_sig_decl = name_recursion sdecl id new_sig_decl in + 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 with Typedecl_variance.Error (loc, err) -> raise (Error (loc, Variance err)) in - let type_immediate = + let new_type_immediate = (* Typedecl_immediacy.compute_decl never raises *) - Typedecl_immediacy.compute_decl env decl in - let decl = {decl with type_variance; type_immediate} in + Typedecl_immediacy.compute_decl env new_sig_decl in + let new_type_separability = + try Typedecl_separability.compute_decl env new_sig_decl + with Typedecl_separability.Error (loc, err) -> + raise (Error (loc, Separability err)) in + let new_sig_decl = + (* we intentionally write this without a fragile { decl with ... } + to ensure that people adding new fields to type declarations + consider whether they need to recompute it here; for an example + of bug caused by the previous approach, see #9607 *) + { + type_params = new_sig_decl.type_params; + type_arity = new_sig_decl.type_arity; + type_kind = new_sig_decl.type_kind; + type_private = new_sig_decl.type_private; + type_manifest = new_sig_decl.type_manifest; + type_unboxed = new_sig_decl.type_unboxed; + type_is_newtype = new_sig_decl.type_is_newtype; + type_expansion_scope = new_sig_decl.type_expansion_scope; + type_loc = new_sig_decl.type_loc; + type_attributes = new_sig_decl.type_attributes; + type_uid = new_sig_decl.type_uid; + + type_variance = new_type_variance; + type_immediate = new_type_immediate; + type_separability = new_type_separability; + } in Ctype.end_def(); - generalize_decl decl; + generalize_decl new_sig_decl; { typ_id = id; typ_name = sdecl.ptype_name; typ_params = tparams; - typ_type = decl; + typ_type = new_sig_decl; typ_cstrs = constraints; - typ_loc = sdecl.ptype_loc; + typ_loc = loc; typ_manifest = tman; typ_kind = Ttype_abstract; typ_private = sdecl.ptype_private; @@ -1542,12 +1542,14 @@ let abstract_type_decl arity = type_private = Public; type_manifest = None; type_variance = replicate_list Variance.full arity; + type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_loc = Location.none; type_attributes = []; type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = Uid.internal_not_actually_unique; } in Ctype.end_def(); generalize_decl decl; @@ -1656,15 +1658,41 @@ let report_error ppf = function "Constraints are not satisfied in this type." !Oprint.out_type (Printtyp.tree_of_typexp false ty) !Oprint.out_type (Printtyp.tree_of_typexp false ty') - | Parameters_differ (path, ty, ty') -> - Printtyp.reset_and_mark_loops ty; - Printtyp.mark_loops ty'; + | 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 + Printtyp.reset_and_mark_loops used_as; + Printtyp.mark_loops defined_as; Printtyp.Naming_context.reset (); - fprintf ppf - "@[In the definition of %s, type@ %a@ should be@ %a@]" - (Path.name path) - !Oprint.out_type (Printtyp.tree_of_typexp false ty) - !Oprint.out_type (Printtyp.tree_of_typexp false ty') + 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 false defined_as) + !Oprint.out_type (Printtyp.tree_of_typexp false 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 false defined_as) + !Oprint.out_type (Printtyp.tree_of_typexp false used_as) + pp_expansions expansions + end | Inconsistent_constraint (env, trace) -> fprintf ppf "The type constraints are not consistent.@."; Printtyp.report_unification_error ppf env trace @@ -1816,10 +1844,18 @@ let report_error ppf = function produced using the Stdlib.Sys.Immediate64.Make functor.") | Bad_unboxed_attribute msg -> fprintf ppf "@[This type cannot be unboxed because@ %s.@]" msg - | Wrong_unboxed_type_float -> + | Separability (Typedecl_separability.Non_separable_evar evar) -> + let pp_evar ppf = function + | None -> + fprintf ppf "an unnamed existential variable" + | Some str -> + fprintf ppf "the existential variable %a" + Pprintast.tyvar str in fprintf ppf "@[This type cannot be unboxed because@ \ - it might contain both float and non-float values.@ \ + it might contain both float and non-float values,@ \ + depending on the instantiation of %a.@ \ You should annotate it with [%@%@ocaml.boxed].@]" + pp_evar evar | Boxed_and_unboxed -> fprintf ppf "@[A type cannot be boxed and unboxed at the same time.@]" | Nonrec_gadt -> diff --git a/typing/typedecl.mli b/typing/typedecl.mli index 93b83471..88f5b2f1 100644 --- a/typing/typedecl.mli +++ b/typing/typedecl.mli @@ -39,8 +39,10 @@ val transl_value_decl: Parsetree.value_description -> Typedtree.value_description * Env.t val transl_with_constraint: - Env.t -> Ident.t -> Path.t option -> Types.type_declaration -> - Parsetree.type_declaration -> Typedtree.type_declaration + Ident.t -> Path.t option -> + sig_env:Env.t -> sig_decl:Types.type_declaration -> + outer_env:Env.t -> Parsetree.type_declaration -> + Typedtree.type_declaration val abstract_type_decl: int -> type_declaration val approx_type_decl: @@ -70,7 +72,12 @@ type error = | Constraint_failed of type_expr * type_expr | Inconsistent_constraint of Env.t * Ctype.Unification_trace.t | Type_clash of Env.t * Ctype.Unification_trace.t - | Parameters_differ of Path.t * type_expr * type_expr + | Non_regular of { + definition: Path.t; + used_as: type_expr; + defined_as: type_expr; + expansions: (type_expr * type_expr) list; + } | Null_arity_external | Missing_native_external | Unbound_type_var of type_expr * type_declaration @@ -89,8 +96,8 @@ type error = | Cannot_unbox_or_untag_type of native_repr_kind | Deep_unbox_or_untag_attribute of native_repr_kind | Immediacy of Typedecl_immediacy.error + | Separability of Typedecl_separability.error | Bad_unboxed_attribute of string - | Wrong_unboxed_type_float | Boxed_and_unboxed | Nonrec_gadt diff --git a/typing/typedecl_separability.ml b/typing/typedecl_separability.ml new file mode 100644 index 00000000..32e34228 --- /dev/null +++ b/typing/typedecl_separability.ml @@ -0,0 +1,731 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Gabriel Scherer, projet Parsifal, INRIA Saclay *) +(* Rodolphe Lepigre, projet Deducteam, INRIA Saclay *) +(* *) +(* Copyright 2018 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 Types + +type type_definition = type_declaration +(* We should use 'declaration' for interfaces, and 'definition' for + implementations. The name type_declaration in types.ml is improper + for our usage -- although for OCaml types the declaration and + definition languages are the same. *) + +(** assuming that a datatype has a single constructor/label with + a single argument, [argument_to_unbox] represents the + information we need to check the argument for separability. *) +type argument_to_unbox = { + kind: parameter_kind; (* for error messages *) + mutability: Asttypes.mutable_flag; + argument_type: type_expr; + result_type_parameter_instances: type_expr list; + (** result_type_parameter_instances represents the domain of the + constructor; usually it is just a list of the datatype parameter + ('a, 'b, ...), but when using GADTs or constraints it could + contain arbitrary type expressions. + + For example, [type 'a t = 'b constraint 'a = 'b * int] has + [['b * int]] as [result_type_parameter_instances], and so does + [type _ t = T : 'b -> ('b * int) t]. *) + location : Location.t; +} +and parameter_kind = + | Record_field + | Constructor_parameter + | Constructor_field (** inlined records *) + +(** ['a multiplicity] counts the number of ['a] in + a structure in which expect to see only one ['a]. *) +type 'a multiplicity = + | Zero + | One of 'a + | Several + +type arity = argument_to_unbox multiplicity (**how many parameters?*) + +type branching = arity multiplicity (**how many constructors?*) + +(** Summarize the right-hand-side of a type declaration, + for separability-checking purposes. See {!structure} below. *) +type type_structure = + | Synonym of type_expr + | Abstract + | Open + | Algebraic of branching + +let demultiply_list + : type a b. a list -> (a -> b) -> b multiplicity + = fun li f -> match li with + | [] -> Zero + | [v] -> One (f v) + | _::_::_ -> Several + +let structure : type_definition -> type_structure = fun def -> + match def.type_kind with + | Type_open -> Open + | Type_abstract -> + begin match def.type_manifest with + | None -> Abstract + | Some type_expr -> Synonym type_expr + end + | Type_record (labels, _) -> + Algebraic (One ( + demultiply_list labels @@ fun ld -> { + location = ld.ld_loc; + kind = Record_field; + mutability = ld.ld_mutable; + argument_type = ld.ld_type; + result_type_parameter_instances = def.type_params; + } + )) + | Type_variant constructors -> + Algebraic (demultiply_list constructors @@ fun cd -> + let result_type_parameter_instances = + match cd.cd_res with + (* cd_res is the optional return type (in a GADT); + if None, just use the type parameters *) + | None -> def.type_params + | Some ret_type -> + begin match Ctype.repr ret_type with + | {desc=Tconstr (_, tyl, _)} -> + List.map Ctype.repr tyl + | _ -> assert false + end + in + begin match cd.cd_args with + | Cstr_tuple tys -> + demultiply_list tys @@ fun argument_type -> { + location = cd.cd_loc; + kind = Constructor_parameter; + mutability = Asttypes.Immutable; + argument_type; + result_type_parameter_instances; + } + | Cstr_record labels -> + demultiply_list labels @@ fun ld -> + let argument_type = ld.ld_type in + { + location = ld.ld_loc; + kind = Constructor_field; + mutability = ld.ld_mutable; + argument_type; + result_type_parameter_instances; + } + end) + + +type error = + | Non_separable_evar of string option + +exception Error of Location.t * error + +(* see the .mli file for explanations on the modes *) +module Sep = Types.Separability +type mode = Sep.t = Ind | Sep | Deepsep + +let rank = Sep.rank +let max_mode = Sep.max + +(** If the type context [e(_)] imposes the mode [m] on its hole [_], + and the type context [e'(_)] imposes the mode [m'] on its hole [_], + then the mode on [_] imposed by the context composition [e(e'(_))] + is [compose m m']. + + This operation differs from [max_mode]: [max_mode Ind Sep] is [Sep], + but [compose Ind Sep] is [Ind]. *) +let compose + : mode -> mode -> mode + = fun m1 m2 -> + match m1 with + | Deepsep -> Deepsep + | Sep -> m2 + | Ind -> Ind + +type type_var = { + text: string option; (** the user name of the type variable, None for '_' *) + id: int; (** the identifier of the type node (type_expr.id) of the variable *) +} + +module TVarMap = Map.Make(struct + type t = type_var + let compare v1 v2 = compare v1.id v2.id + end) +type context = mode TVarMap.t +let (++) = TVarMap.union (fun _ m1 m2 -> Some(max_mode m1 m2)) +let empty = TVarMap.empty + + +(** [immediate_subtypes ty] returns the list of all the + immediate sub-type-expressions of [ty]. They represent the biggest + sub-components that may be extracted using a constraint. For + example, the immediate sub-type-expressions of [int * (bool * 'a)] + are [int] and [bool * 'a]. + + Smaller components are extracted recursively in [check_type]. *) +let rec immediate_subtypes : type_expr -> type_expr list = fun ty -> + (* Note: Btype.fold_type_expr is not suitable here: + - it does not do the right thing on Tpoly, iterating on type + parameters as well as the subtype + - it performs a shallow traversal of object types, + while our implementation collects all method types *) + match (Ctype.repr ty).desc with + (* these are the important cases, + on which immediate_subtypes is called from [check_type] *) + | Tarrow(_,ty1,ty2,_) -> + [ty1; ty2] + | Ttuple(tys) + | Tpackage(_,_,tys) -> + tys + | Tobject(row,class_ty) -> + let class_subtys = + match !class_ty with + | None -> [] + | Some(_,tys) -> tys + in + immediate_subtypes_object_row class_subtys row + | Tvariant(row) -> + immediate_subtypes_variant_row [] row + + (* the cases below are not called from [check_type], + they are here for completeness *) + | Tnil | Tfield _ -> + (* these should only occur under Tobject and not at the toplevel, + but "better safe than sorry" *) + immediate_subtypes_object_row [] ty + | Tlink _ | Tsubst _ -> assert false (* impossible due to Ctype.repr *) + | Tvar _ | Tunivar _ -> [] + | Tpoly (pty, _) -> [pty] + | Tconstr (_path, tys, _) -> tys + +and immediate_subtypes_object_row acc ty = match (Ctype.repr ty).desc with + | Tnil -> acc + | Tfield (_label, _kind, ty, rest) -> + let acc = ty :: acc in + immediate_subtypes_object_row acc rest + | _ -> ty :: acc + +and immediate_subtypes_variant_row acc desc = + let add_subtypes acc = + let add_subtype acc (_l, rf) = + immediate_subtypes_variant_row_field acc rf in + List.fold_left add_subtype acc desc.row_fields in + let add_row acc = + let row = Ctype.repr desc.row_more in + match row.desc with + | Tvariant more -> immediate_subtypes_variant_row acc more + | _ -> row :: acc + in + add_row (add_subtypes acc) + +and immediate_subtypes_variant_row_field acc = function + | Rpresent(None) + | Rabsent -> acc + | Rpresent(Some(ty)) -> ty :: acc + | Reither(_,field_types,_,r) -> + let acc = List.rev_append field_types acc in + begin match !r with + | None -> acc + | Some rf -> immediate_subtypes_variant_row_field acc rf + end + +let free_variables ty = + Ctype.free_variables (Ctype.repr ty) + |> List.map (fun {desc; id; _} -> + match desc with + | Tvar text -> {text; id} + | _ -> + (* Ctype.free_variables only returns Tvar nodes *) + assert false) + +(** Coinductive hypotheses to handle equi-recursive types + + OCaml allows infinite/cyclic types, such as + (int * 'a) as 'a + whose infinite unfolding is (int * (int * (int * (int * ...)))). + + Remark: this specific type is only accepted if the -rectypes option + is passed, but such "equi-recursive types" are accepted by + default if the cycle goes through an object type or polymorphic + variant type: + [ `int | `other of 'a ] as 'a + < head : int; rest : 'a > as 'a + + We have to take those infinite types in account in our + separability-checking program: a naive implementation would loop + infinitely when trying to prove that one of them is Deepsep. + + After type-checking, the cycle-introducing form (... as 'a) does + not appear explicitly in the syntax of types: types are graphs/trees + with cycles in them, and we have to use the type_expr.id field, + an identifier for each node in the graph/tree, to detect cycles. + + We avoid looping by remembering the set of separability queries + that we have already asked ourselves (in the current + search branch). For example, if we are asked to check + + (int * 'a) : Deepsep + + our algorithm will check both (int : Deepsep) and ('a : Deepsep), + but it will remember in these sub-checks that it is in the process + of checking (int * 'a) : Deepsep, adding it to a list of "active + goals", or "coinductive hypotheses". + + Each new sub-query will start by checking whether the query + already appears as a coinductive hypothesis; in our example, this + can happen if 'a and (int * 'a) are in fact the same node in the + cyclic tree. In that case, we return immediately (instead of looping): + we reason that, assuming that 'a is indeed Deepsep, then it is + the case that (int * 'a) is also Deepsep. + + This kind of cyclic reasoning can be dangerous: it would be wrong + to argue that an arbitrary 'a type is Deepsep by saying: + "assuming that 'a is Deepsep, then it is the case that 'a is + also Deepsep". In the first case, we made an assumption on 'a, + and used it on a type (int * 'a) which has 'a as a strict sub-component; + in the second, we use it on the same type 'a directly, which is invalid. + + Now consider a type of the form (('a t) as 'a): while 'a is a sub-component + of ('a t), it may still be wrong to reason coinductively about it, + as ('a t) may be defined as (type 'a t = 'a). + + When moving from (int * 'a) to a subcomponent (int) or ('a), we + say that the coinductive hypothesis on (int * 'a : m) is "safe": + it can be used immediately to prove the subcomponents, because we + made progress moving to a strict subcomponent (we are guarded + under a computational type constructor). On the other hand, when + moving from ('a t) to ('a), we say that the coinductive hypothesis + ('a t : m) is "unsafe" for the subgoal, as we don't know whether + we have made strict progress. In the general case, we keep track + of a set of safe and unsafe hypotheses made in the past, and we + use them to terminate checking if we encounter them again, + ensuring termination. + + If we encounter a (ty : m) goal that is exactly a safe hypothesis, + we terminate with a success. In fact, we can use mode subtyping here: + if (ty : m') appears as a hypothesis with (m' >= m), then we would + succeed for (ty : m'), so (ty : m) should succeed as well. + + On the other hand, if we encounter a (ty : m) goal that is an + *unsafe* hypothesis, we terminate the check with a failure. In this case, + we cannot work modulo mode subtyping: if (ty : m') appears with + (m' >= m), then the check (ty : m') would have failed, but it is still + possible that the weaker current query (ty : m) would succeed. + + In usual coinductive-reasoning systems, unsafe hypotheses are turned + into safe hypotheses each time strict progress is made (for each + guarded sub-goal). Consider ((int * 'a) t as 'a : deepsep) for example: + the idea is that the ((int * 'a) t : deepsep) hypothesis would be + unsafe when checking ((int * 'a) : deepsep), but that the progress + step from (int * 'a : deepsep) to ('a : deepsep) would turn all + past unsafe hypotheses into safe hypotheses. There is a problem + with this, though, due to constraints: what if (_ t) is defined as + + type 'b t = 'a constraint 'b = (int * 'a) + + ? + + In that case, then 'a is precisely the one-step unfolding + of the ((int * 'a) t) definition, and it would be an invalid, + cyclic reasoning to prove ('a : deepsep) from the now-safe + hypothesis ((int * 'a) t : deepsep). + + Surprisingly-fortunately, we have exactly the information we need + to know whether (_ t) may or may not pull a constraint trick of + this nature: we can look at its mode signature, where constraints + are marked by a Deepsep mode. If we see Deepsep, we know that a + constraint exists, but we don't know what the constraint is: + we cannot tell at which point, when decomposing the parameter type, + a sub-component can be considered safe again. To model this, + we add a third category of co-inductive hypotheses: to "safe" and + "unsafe" we add the category of "poison" hypotheses, which remain + poisonous during the remaining of the type decomposition, + even in presence of safe, computational types constructors: + + - when going under a computational constructor, + "unsafe" hypotheses become "safe" + - when going under a constraining type (more precisely, under + a type parameter that is marked Deepsep in the mode signature), + "unsafe" hypotheses become "poison" + + The mode signature tells us even a bit more: if a parameter + is marked "Ind", we know that the type constructor cannot unfold + to this parameter (otherwise it would be Sep), so going under + this parameter can be considered a safe/guarded move: if + we have to check (foo t : m) with ((_ : Ind) t) in the signature, + we can recursively check (foo : Ind) with (foo t : m) marked + as "safe", rather than "unsafe". +*) +module TypeMap = Btype.TypeMap +module ModeSet = Set.Make(Types.Separability) + +type coinductive_hyps = { + safe: ModeSet.t TypeMap.t; + unsafe: ModeSet.t TypeMap.t; + poison: ModeSet.t TypeMap.t; +} + +module Hyps : sig + type t = coinductive_hyps + val empty : t + val add : type_expr -> mode -> t -> t + val guard : t -> t + val poison : t -> t + val safe : type_expr -> mode -> t -> bool + val unsafe : type_expr -> mode -> t -> bool +end = struct + type t = coinductive_hyps + + let empty = { + safe = TypeMap.empty; + unsafe = TypeMap.empty; + poison = TypeMap.empty; + } + + let of_opt = function + | Some ms -> ms + | None -> ModeSet.empty + + let merge map1 map2 = + TypeMap.merge (fun _k ms1 ms2 -> + Some (ModeSet.union (of_opt ms1) (of_opt ms2)) + ) map1 map2 + + let guard {safe; unsafe; poison;} = { + safe = merge safe unsafe; + unsafe = TypeMap.empty; + poison; + } + + let poison {safe; unsafe; poison;} = { + safe; + unsafe = TypeMap.empty; + poison = merge poison unsafe; + } + + let add ty m hyps = + let m_map = TypeMap.singleton ty (ModeSet.singleton m) in + { hyps with unsafe = merge m_map hyps.unsafe; } + + let find ty map = try TypeMap.find ty map with Not_found -> ModeSet.empty + + let safe ty m hyps = + match ModeSet.max_elt_opt (find ty hyps.safe) with + | None -> false + | Some best_safe -> rank best_safe >= rank m + + let unsafe ty m {safe = _; unsafe; poison} = + let in_map s = ModeSet.mem m (find ty s) in + List.exists in_map [unsafe; poison] +end + +(** For a type expression [ty] (without constraints and existentials), + any mode checking [ty : m] is satisfied in the "worse case" context + that maps all free variables of [ty] to the most demanding mode, + Deepsep. *) +let worst_case ty = + let add ctx tvar = TVarMap.add tvar Deepsep ctx in + List.fold_left add TVarMap.empty (free_variables ty) + + +(** [check_type env sigma ty m] returns the most permissive context [gamma] + such that [ty] is separable at mode [m] in [gamma], under + the signature [sigma]. *) +let check_type + : Env.t -> type_expr -> mode -> context + = fun env ty m -> + let rec check_type hyps ty m = + let ty = Ctype.repr ty in + if Hyps.safe ty m hyps then empty + else if Hyps.unsafe ty m hyps then worst_case ty + else + let hyps = Hyps.add ty m hyps in + match (ty.desc, m) with + (* Impossible case due to the call to [Ctype.repr]. *) + | (Tlink _ , _ ) -> assert false + (* Impossible case (according to comment in [typing/types.mli]. *) + | (Tsubst(_) , _ ) -> assert false + (* "Indifferent" case, the empty context is sufficient. *) + | (_ , Ind ) -> empty + (* Variable case, add constraint. *) + | (Tvar(alpha) , m ) -> + TVarMap.singleton {text = alpha; id = ty.Types.id} m + (* "Separable" case for constructors with known memory representation. *) + | (Tarrow _ , Sep ) + | (Ttuple _ , Sep ) + | (Tvariant(_) , Sep ) + | (Tobject(_,_) , Sep ) + | ((Tnil | Tfield _) , Sep ) + | (Tpackage(_,_,_) , Sep ) -> empty + (* "Deeply separable" case for these same constructors. *) + | (Tarrow _ , Deepsep) + | (Ttuple _ , Deepsep) + | (Tvariant(_) , Deepsep) + | (Tobject(_,_) , Deepsep) + | ((Tnil | Tfield _) , Deepsep) + | (Tpackage(_,_,_) , Deepsep) -> + let tys = immediate_subtypes ty in + let on_subtype context ty = + context ++ check_type (Hyps.guard hyps) ty Deepsep in + List.fold_left on_subtype empty tys + (* Polymorphic type, and corresponding polymorphic variable. + + In theory, [Tpoly] (forall alpha. tau) would add a new variable + (alpha) in scope, check its body (tau) recursively, and then + remove the new variable from the resulting context. Because the + rule accepts any mode for this variable, the removal never + fails. + + In practice the implementation is simplified by ignoring the + new variable, and always returning the [empty] context + (instead of (alpha : m) in the [Tunivar] case: the constraint + on the variable is removed/ignored at the variable occurrence + site, rather than at the variable-introduction site. *) + (* Note: that we are semantically incomplete in the Deepsep case + (following the syntactic typing rules): the semantics only + requires that *closed* sub-type-expressions be (deeply) + separable; sub-type-expressions containing the quantified + variable cannot be extracted by constraints (this would be + a scope violation), so they could be ignored if they occur + under a separating type constructor. *) + | (Tpoly(pty,_) , m ) -> + check_type hyps pty m + | (Tunivar(_) , _ ) -> empty + (* Type constructor case. *) + | (Tconstr(path,tys,_), m ) -> + let msig = (Env.find_type path env).type_separability in + let on_param context (ty, m_param) = + let hyps = match m_param with + | Ind -> Hyps.guard hyps + | Sep -> hyps + | Deepsep -> Hyps.poison hyps in + context ++ check_type hyps ty (compose m m_param) in + List.fold_left on_param empty (List.combine tys msig) + in + check_type Hyps.empty ty m + +let best_msig decl = List.map (fun _ -> Ind) decl.type_params +let worst_msig decl = List.map (fun _ -> Deepsep) decl.type_params + +(** [msig_of_external_type decl] infers the mode signature of an + abstract/external type. We must assume the worst, namely that this + type may be defined as an unboxed algebraic datatype imposing deep + separability of its parameters. + + One exception is when the type is marked "immediate", which + guarantees that its representation is only integers. Immediate + types are always separable, so [Ind] suffices for their + parameters. + + Note: this differs from {!Types.Separability.default_signature}, + which does not have access to the declaration and its immediacy. *) +let msig_of_external_type decl = + match decl.type_immediate with + | Always | Always_on_64bits -> best_msig decl + | Unknown -> worst_msig decl + +(** [msig_of_context ~decl_loc constructor context] returns the + separability signature of a single-constructor type whose + definition is valid in the mode context [context]. + + Note: A GADT constructor introduces existential type variables, and + may also introduce some equalities between its return type + parameters and type expressions containing universal and + existential variables. In other words, it introduces new type + variables in scope, and restricts existing variables by adding + equality constraints. + + [msig_of_context] performs the reverse transformation: the context + [ctx] computed from the argument of the constructor mentions + existential variables, and the function returns a context over the + (universal) type parameters only. (Type constraints do not + introduce existential variables, but they do introduce equalities; + they are handled as GADTs equalities by this function.) + + The transformation is separability-preserving in the following + sense: for any valid instance of the result mode signature + (replacing the universal type parameters with ground types + respecting the variable's separability mode), any possible + extension of this context instance with ground instances for the + existential variables of [parameter] that respects the equation + constraints will validate the separability requirements of the + modes in the input context [ctx]. + + Sometimes no such universal context exists, as an existential type + cannot be safely introduced, then this function raises an [Error] + exception with a [Non_separable_evar] payload. *) +let msig_of_context : decl_loc:Location.t -> parameters:type_expr list + -> context -> Sep.signature = + fun ~decl_loc ~parameters context -> + let handle_equation (acc, context) param_instance = + (* In the theory, GADT equations are of the form + ('a = ) + for each type parameter 'a of the type constructor. For each + such equation, we should "strengthen" the current context in + the following way: + - if is another variable 'b, + the mode of 'a is set to the mode of 'b, + and 'b is set to Ind + - if is a type expression whose variables are all Ind, + set 'a to Ind and discard the equation + - otherwise (one of the variable of 'b is not Ind), + set 'a to Deepsep and set all variables of to Ind + + In practice, type parameters are determined by their position + in a list, they do not necessarily have a corresponding type variable. + Instead of "setting 'a" in the context as in the description above, + we build a list of modes by repeated consing into + an accumulator variable [acc], setting existential variables + to Ind as we go. *) + let param_instance = Ctype.repr param_instance in + let get context var = + try TVarMap.find var context with Not_found -> Ind in + let set_ind context var = + TVarMap.add var Ind context in + let is_ind context var = match get context var with + | Ind -> true + | Sep | Deepsep -> false in + match param_instance.desc with + | Tvar text -> + let var = {text; id = param_instance.Types.id} in + (get context var) :: acc, (set_ind context var) + | _ -> + let instance_exis = free_variables param_instance in + if List.for_all (is_ind context) instance_exis then + Ind :: acc, context + else + Deepsep :: acc, List.fold_left set_ind context instance_exis + in + let mode_signature, context = + let (mode_signature_rev, ctx) = + List.fold_left handle_equation ([], context) parameters in + (* Note: our inference system is not principal, because the + inference result depends on the order in which those + equations are processed. (To our knowledge this is the only + source of non-principality.) If two parameters ('a, 'b) are + forced to be equal to each other, and also separable, then + either modes (Sep, Ind) and (Ind, Sep) are correct, allow + more declarations than (Sep, Sep), but (Ind, Ind) would be + unsound. + + Such a non-principal example is the following: + + type ('a, 'b) almost_eq = + | Almost_refl : 'c -> ('c, 'c) almost_eq + + (This example looks strange: GADT equations are typically + either on only one parameter, or on two parameters that are + not used to classify constructor arguments. Indeed, we have + not found non-principal declarations in real-world code.) + + In a non-principal system, it is important the our choice of + non-unique solution be at least predictable. We find it more + natural, when either ('a : Sep, 'b : Ind) and ('a : Ind, + 'b : Sep) are correct because 'a = 'b, to choose to make the + first/leftmost parameter more constrained. We read this as + saying that 'a must be Sep, and 'b = 'a so 'b can be + Ind. (We define the second parameter as equal of the first, + already-seen parameter; instead of saying that the first + parameter is equal to the not-yet-seen second one.) + + This is achieved by processing the equations from left to + right with List.fold_left, instead of using + List.fold_right. The code is slightly more awkward as it + needs a List.rev on the accumulated modes, but it gives + a more predictable/natural (non-principal) behavior. + *) + (List.rev mode_signature_rev, ctx) in + (* After all variables determined by the parameters have been set to Ind + by [handle_equation], all variables remaining in the context are + purely existential and should not require a stronger mode than Ind. *) + let check_existential evar mode = + if rank mode > rank Ind then + raise (Error (decl_loc, Non_separable_evar evar.text)) + in + TVarMap.iter check_existential context; + mode_signature + +(** [check_def env def] returns the signature required + for the type definition [def] in the typing environment [env]. + + The exception [Error] is raised if we discover that + no such signature exists -- the definition will always be invalid. + This only happens when the definition is marked to be unboxed. *) + +let check_def + : Env.t -> type_definition -> Sep.signature + = fun env def -> + let boxed = not def.type_unboxed.unboxed in + match structure def with + | Abstract -> + assert boxed; + msig_of_external_type def + | Synonym type_expr -> + check_type env type_expr Sep + |> msig_of_context ~decl_loc:def.type_loc ~parameters:def.type_params + | Open | Algebraic (Zero | Several | One (Zero | Several)) -> + assert boxed; + best_msig def + | Algebraic (One (One constructor)) -> + if boxed then best_msig def + else + check_type env constructor.argument_type Sep + |> msig_of_context ~decl_loc:def.type_loc + ~parameters:constructor.result_type_parameter_instances + +let compute_decl env decl = + if Config.flat_float_array then check_def env decl + else + (* Hack: in -no-flat-float-array mode, instead of always returning + [best_msig], we first compute the separability signature -- + falling back to [best_msig] if it fails. + + This discipline is conservative: it never + rejects -no-flat-float-array programs. At the same time it + guarantees that, for any program that is also accepted + in -flat-float-array mode, the same separability will be + inferred in the two modes. In particular, the same .cmi files + and digests will be produced. + + Before we introduced this hack, the production of different + .cmi files would break the build system of the compiler itself, + when trying to build a -no-flat-float-array system from + a bootstrap compiler itself using -flat-float-array. See #9291. + *) + try check_def env decl with + | Error _ -> + (* It could be nice to emit a warning here, so that users know + that their definition would be rejected in -flat-float-array mode *) + best_msig decl + +(** Separability as a generic property *) +type prop = Types.Separability.signature + +let property : (prop, unit) Typedecl_properties.property = + let open Typedecl_properties in + let eq ts1 ts2 = + List.length ts1 = List.length ts2 + && List.for_all2 Sep.eq ts1 ts2 in + let merge ~prop:_ ~new_prop = + (* the update function is monotonous: ~new_prop is always + more informative than ~prop, which can be ignored *) + new_prop in + let default decl = best_msig decl in + let compute env decl () = compute_decl env decl in + let update_decl decl type_separability = { decl with type_separability } in + let check _env _id _decl () = () in (* FIXME run final check? *) + { eq; merge; default; compute; update_decl; check; } + +(* Definition using the fixpoint infrastructure. *) +let update_decls env decls = + Typedecl_properties.compute_property_noreq property env decls diff --git a/typing/typedecl_separability.mli b/typing/typedecl_separability.mli new file mode 100644 index 00000000..079e6408 --- /dev/null +++ b/typing/typedecl_separability.mli @@ -0,0 +1,132 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Gabriel Scherer, projet Parsifal, INRIA Saclay *) +(* Rodolphe Lepigre, projet Deducteam, INRIA Saclay *) +(* *) +(* Copyright 2018 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 OCaml runtime assumes for type-directed optimizations that all types + are "separable". A type is "separable" if either all its inhabitants + (the values of this type) are floating-point numbers, or none of them are. + + (Note: This assumption is required for the dynamic float array optimization; + it is only made if Config.flat_float_array is set, + otherwise the code in this module becomes trivial + -- see {!compute_decl}.) + + This soundness requirement could be broken by type declarations mixing + existentials and the "[@@unboxed]" annotation. Consider the declaration + + {[ + type any = Any : 'a -> any [@@unboxed] + ]} + + which corresponds to the existential type "exists a. a". If this type is + allowed to be unboxed, then it is inhabited by both [float] values + and non-[float] values. On the contrary, if unboxing is disallowed, the + inhabitants are all blocks with the [Any] constructors pointing to its + parameter: they may point to a float, but they are not floats. + + The present module contains a static analysis ensuring that declarations + annotated with "[@@unboxed]" can be safely unboxed. The idea is to check + the "separability" (in the above sense) of the argument type that would + be unboxed, and reject the unboxed declaration if it would create a + non-separable type. + + Checking mutually-recursive type declarations is a bit subtle. + Consider, for example, the following declarations. + + {[ + type foo = Foo : 'a t -> foo [@@unboxed] + and 'a t = ... + ]} + + Deciding whether the type [foo] should be accepted requires inspecting + the declaration of ['a t], which may itself refer to [foo] in turn. + In general, the analysis performs a fixpoint computation. It is somewhat + similar to what is done for inferring the variance of type parameters. + + Our analysis is defined using inference rules for our judgment + [Def; Gamma |- t : m], in which a type expression [t] is checked + against a "mode" [m]. This "mode" describes the separability + requirement on the type expression (see below for + more details). The mode [Gamma] maps type variables to modes and + [Def] records the "mode signature" of the mutually-recursive type + declarations that are being checked. + + The "mode signature" of a type with parameters [('a, 'b) t] is of the + form [('a : m1, 'b : m2) t], where [m1] and [m2] are modes. Its meaning + is the following: a concrete instance [(foo, bar) t] of the type is + separable if [foo] has mode [m1] and [bar] has mode [m2]. *) + +type error = + | Non_separable_evar of string option +exception Error of Location.t * error +(** Exception raised when a type declaration is not separable, or when its + separability cannot be established. *) + +type mode = Types.Separability.t = Ind | Sep | Deepsep +(** The mode [Sep] ("separable") characterizes types that are indeed separable: + either they only contain floating-point values, or none of the values + at this type are floating-point values. + On a type parameter, it indicates that this parameter must be + separable for the whole type definition to be separable. For + example, the mode signature for the type declaration [type 'a + t = 'a] is [('a : Sep) t]. For the right-hand side to be + separable, the parameter ['a] must be separable. + + The mode [Ind] ("indifferent") characterizes any type -- separable + or not. + On a type parameter, it indicates that this parameter needs not be + separable for the whole type definition to be separable. For + example, [type 'a t = 'a * bool] does not require its parameter + ['a] to be separable as ['a * bool] can never contain [float] + values. Its mode signature is thus [('a : Ind) t]. + + Finally, the mode [Deepsep] ("deeply separable") characterizes + types that are separable, and whose type sub-expressions are also + separable. This advanced feature is only used in the presence of + constraints. + For example, [type 'a t = 'b constraint 'a = 'b * bool] + may not be separable even if ['a] is (its separately depends on 'b, + a fragment of 'a), so its mode signature is [('a : Deepsep) t]. + + The different modes are ordered as [Ind < Sep < Deepsep] (from the least + demanding to the most demanding). *) + +val compute_decl : Env.t -> Types.type_declaration -> mode list +(** [compute_decl env def] returns the signature required + for the type definition [def] in the typing environment [env] + -- including signatures for the current recursive block. + + The {!Error} exception is raised if no such signature exists + -- the definition will always be invalid. This only happens + when the definition is marked to be unboxed. + + Variant (or record) declarations that are not marked with the + "[@@unboxed]" annotation, including those that contain several variants + (or labels), are always separable. In particular, their mode signatures + do not require anything of their type parameters, which are marked [Ind]. + + Finally, if {!Config.flat_float_array} is not set, then separability + is not required anymore; we just use [Ind] as the mode of each parameter + without any check. +*) + +(** Property interface (see {!Typedecl_properties}). These functions + rely on {!compute_decl} and raise the {!Error} exception on error. *) +type prop = Types.Separability.signature +val property : (prop, unit) Typedecl_properties.property +val update_decls : + Env.t -> + (Ident.t * Typedecl_properties.decl) list -> + (Ident.t * Typedecl_properties.decl) list diff --git a/typing/typedtree.ml b/typing/typedtree.ml index 96f5256d..c2d0a0c1 100644 --- a/typing/typedtree.ml +++ b/typing/typedtree.ml @@ -25,12 +25,22 @@ type partial = Partial | Total type attribute = Parsetree.attribute type attributes = attribute list -type pattern = - { pat_desc: pattern_desc; +type value = Value_pattern +type computation = Computation_pattern + +type _ pattern_category = +| Value : value pattern_category +| Computation : computation pattern_category + +type pattern = value general_pattern +and 'k general_pattern = 'k pattern_desc pattern_data + +and 'a pattern_data = + { pat_desc: 'a; pat_loc: Location.t; pat_extra : (pat_extra * Location.t * attribute list) list; pat_type: type_expr; - mutable pat_env: Env.t; + pat_env: Env.t; pat_attributes: attribute list; } @@ -40,22 +50,35 @@ and pat_extra = | Tpat_open of Path.t * Longident.t loc * Env.t | Tpat_unpack -and pattern_desc = - Tpat_any - | Tpat_var of Ident.t * string loc - | Tpat_alias of pattern * Ident.t * string loc - | Tpat_constant of constant - | Tpat_tuple of pattern list - | Tpat_construct of - Longident.t loc * constructor_description * pattern list - | Tpat_variant of label * pattern option * row_desc ref - | Tpat_record of - (Longident.t loc * label_description * pattern) list * - closed_flag - | Tpat_array of pattern list - | Tpat_or of pattern * pattern * row_desc option - | Tpat_lazy of pattern - | Tpat_exception of pattern +and 'k pattern_desc = + (* value patterns *) + | Tpat_any : value pattern_desc + | Tpat_var : Ident.t * string loc -> value pattern_desc + | Tpat_alias : + value general_pattern * Ident.t * string loc -> value pattern_desc + | Tpat_constant : constant -> value pattern_desc + | Tpat_tuple : value general_pattern list -> value pattern_desc + | Tpat_construct : + Longident.t loc * constructor_description * value general_pattern list -> + value pattern_desc + | Tpat_variant : + label * value general_pattern option * row_desc ref -> + value pattern_desc + | Tpat_record : + (Longident.t loc * label_description * value general_pattern) list * + closed_flag -> + value pattern_desc + | Tpat_array : value general_pattern list -> value pattern_desc + | Tpat_lazy : value general_pattern -> value pattern_desc + (* computation patterns *) + | Tpat_value : tpat_value_argument -> computation pattern_desc + | Tpat_exception : value general_pattern -> computation pattern_desc + (* generic constructions *) + | Tpat_or : + 'k general_pattern * 'k general_pattern * row_desc option -> + 'k pattern_desc + +and tpat_value_argument = value general_pattern and expression = { exp_desc: expression_desc; @@ -77,10 +100,10 @@ and expression_desc = | Texp_constant of constant | Texp_let of rec_flag * value_binding list * expression | Texp_function of { arg_label : arg_label; param : Ident.t; - cases : case list; partial : partial; } + cases : value case list; partial : partial; } | Texp_apply of expression * (arg_label * expression option) list - | Texp_match of expression * case list * partial - | Texp_try of expression * case list + | Texp_match of expression * computation case list * partial + | Texp_try of expression * value case list | Texp_tuple of expression list | Texp_construct of Longident.t loc * constructor_description * expression list @@ -117,7 +140,7 @@ and expression_desc = let_ : binding_op; ands : binding_op list; param : Ident.t; - body : case; + body : value case; partial : partial; } | Texp_unreachable @@ -128,9 +151,9 @@ and meth = Tmeth_name of string | Tmeth_val of Ident.t -and case = +and 'k case = { - c_lhs: pattern; + c_lhs: 'k general_pattern; c_guard: expression option; c_rhs: expression; } @@ -592,58 +615,138 @@ and 'a class_infos = (* Auxiliary functions over the a.s.t. *) -let shallow_iter_pattern_desc f = function - | Tpat_alias(p, _, _) -> f p - | Tpat_tuple patl -> List.iter f patl - | Tpat_construct(_, _, patl) -> List.iter f patl - | Tpat_variant(_, pat, _) -> Option.iter f pat +let as_computation_pattern (p : pattern) : computation general_pattern = + { + pat_desc = Tpat_value p; + pat_loc = p.pat_loc; + pat_extra = []; + pat_type = p.pat_type; + pat_env = p.pat_env; + pat_attributes = []; + } + +let rec classify_pattern_desc : type k . k pattern_desc -> k pattern_category = + function + | Tpat_alias _ -> Value + | Tpat_tuple _ -> Value + | Tpat_construct _ -> Value + | Tpat_variant _ -> Value + | Tpat_record _ -> Value + | Tpat_array _ -> Value + | Tpat_lazy _ -> Value + | Tpat_any -> Value + | Tpat_var _ -> Value + | Tpat_constant _ -> Value + + | Tpat_value _ -> Computation + | Tpat_exception _ -> Computation + + | Tpat_or(p1, p2, _) -> + begin match classify_pattern p1, classify_pattern p2 with + | Value, Value -> Value + | Computation, Computation -> Computation + end + +and classify_pattern + : type k . k general_pattern -> k pattern_category + = fun pat -> + classify_pattern_desc pat.pat_desc + +type pattern_action = + { f : 'k . 'k general_pattern -> unit } +let shallow_iter_pattern_desc + : type k . pattern_action -> k pattern_desc -> unit + = fun f -> function + | 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 | Tpat_record (lbl_pat_list, _) -> - List.iter (fun (_, _, pat) -> f pat) lbl_pat_list - | Tpat_array patl -> List.iter f patl - | Tpat_or(p1, p2, _) -> f p1; f p2 - | Tpat_lazy p -> f p - | Tpat_exception p -> f p + List.iter (fun (_, _, pat) -> f.f pat) lbl_pat_list + | Tpat_array patl -> List.iter f.f patl + | Tpat_lazy p -> f.f p | Tpat_any | Tpat_var _ | Tpat_constant _ -> () - -let shallow_map_pattern_desc f d = - match d with + | Tpat_value p -> f.f p + | Tpat_exception p -> f.f p + | Tpat_or(p1, p2, _) -> f.f p1; f.f p2 + +type pattern_transformation = + { f : 'k . 'k general_pattern -> 'k general_pattern } +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 p1, id, s) + Tpat_alias (f.f p1, id, s) | Tpat_tuple pats -> - Tpat_tuple (List.map f pats) + Tpat_tuple (List.map f.f pats) | Tpat_record (lpats, closed) -> - Tpat_record (List.map (fun (lid, l,p) -> lid, l, f p) lpats, closed) + Tpat_record (List.map (fun (lid, l,p) -> lid, l, f.f p) lpats, closed) | Tpat_construct (lid, c,pats) -> - Tpat_construct (lid, c, List.map f pats) + Tpat_construct (lid, c, List.map f.f pats) | Tpat_array pats -> - Tpat_array (List.map f pats) - | Tpat_lazy p1 -> Tpat_lazy (f p1) - | Tpat_exception p1 -> Tpat_exception (f p1) + Tpat_array (List.map f.f pats) + | Tpat_lazy p1 -> Tpat_lazy (f.f p1) | Tpat_variant (x1, Some p1, x2) -> - Tpat_variant (x1, Some (f p1), x2) - | Tpat_or (p1,p2,path) -> - Tpat_or (f p1, f p2, path) + Tpat_variant (x1, Some (f.f p1), x2) | Tpat_var _ | Tpat_constant _ | Tpat_any | Tpat_variant (_,None,_) -> d - -let rec iter_pattern f p = - f p; - shallow_iter_pattern_desc (iter_pattern f) p.pat_desc - -let exists_pattern f p = + | Tpat_value p -> Tpat_value (f.f p) + | Tpat_exception p -> Tpat_exception (f.f p) + | Tpat_or (p1,p2,path) -> + Tpat_or (f.f p1, f.f p2, path) + +let rec iter_general_pattern + : type k . pattern_action -> k general_pattern -> unit + = fun f p -> + f.f p; + shallow_iter_pattern_desc + { f = fun p -> iter_general_pattern f p } + p.pat_desc + +let iter_pattern (f : pattern -> unit) = + iter_general_pattern + { f = fun (type k) (p : k general_pattern) -> + match classify_pattern p with + | Value -> f p + | Computation -> () } + +let rec map_general_pattern + : type k . pattern_transformation -> k general_pattern -> k general_pattern + = fun f p -> + let pat_desc = + shallow_map_pattern_desc + { f = fun p -> map_general_pattern f p } + p.pat_desc in + f.f { p with pat_desc } + +type pattern_predicate = { f : 'k . 'k general_pattern -> bool } +let exists_general_pattern (f : pattern_predicate) p = let exception Found in - let raiser f x = if (f x) then raise Found else () in - match iter_pattern (raiser f) p with + match + iter_general_pattern + { f = fun p -> if f.f p then raise Found else () } + p + with | exception Found -> true | () -> false +let exists_pattern (f : pattern -> bool) = + exists_general_pattern + { f = fun (type k) (p : k general_pattern) -> + match classify_pattern p with + | Value -> f p + | Computation -> false } + + (* List the identifiers bound by a pattern or a let *) -let rec iter_bound_idents f pat = +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) @@ -654,7 +757,9 @@ let rec iter_bound_idents f pat = (* Invariant : both arguments bind the same variables *) iter_bound_idents f p1 | d -> - shallow_iter_pattern_desc (iter_bound_idents f) d + shallow_iter_pattern_desc + { f = fun p -> iter_bound_idents f p } + d let rev_pat_bound_idents_full pat = let idents_full = ref [] in @@ -683,48 +788,54 @@ let let_bound_idents pat = let alpha_var env id = List.assoc id env -let rec alpha_pat env p = match p.pat_desc with -| Tpat_var (id, s) -> (* note the ``Not_found'' case *) - {p with pat_desc = - try Tpat_var (alpha_var env id, s) with - | Not_found -> Tpat_any} -| Tpat_alias (p1, id, s) -> - let new_p = alpha_pat env p1 in - begin try - {p with pat_desc = Tpat_alias (new_p, alpha_var env id, s)} - with - | Not_found -> new_p - end -| d -> - {p with pat_desc = shallow_map_pattern_desc (alpha_pat env) d} +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 *) + {p with pat_desc = + try Tpat_var (alpha_var env id, s) with + | Not_found -> Tpat_any} + | Tpat_alias (p1, id, s) -> + let new_p = alpha_pat env p1 in + begin try + {p with pat_desc = Tpat_alias (new_p, alpha_var env id, s)} + with + | Not_found -> new_p + end + | d -> + let pat_desc = + shallow_map_pattern_desc { f = fun p -> alpha_pat env p } d in + {p with pat_desc} let mkloc = Location.mkloc let mknoloc = Location.mknoloc let split_pattern pat = - let combine_pattern_desc_opts ~into p1 p2 = + let combine_opts merge p1 p2 = match p1, p2 with | None, None -> None | Some p, None | None, Some p -> Some p | Some p1, Some p2 -> - (* The third parameter of [Tpat_or] is [Some _] only for "#typ" - patterns, which we do *not* expand. Hence we can put [None] here. *) - Some { into with pat_desc = Tpat_or (p1, p2, None) } + Some (merge p1 p2) in - let rec split_pattern pat = - match pat.pat_desc with - | Tpat_or (p1, p2, None) -> - let vals1, exns1 = split_pattern p1 in - let vals2, exns2 = split_pattern p2 in - combine_pattern_desc_opts ~into:pat vals1 vals2, - (* We could change the pattern type for exception patterns to - [Predef.exn], but it doesn't really matter. *) - combine_pattern_desc_opts ~into:pat exns1 exns2 + let into pat p1 p2 = + (* The third parameter of [Tpat_or] is [Some _] only for "#typ" + patterns, which we do *not* expand. Hence we can put [None] here. *) + { pat with pat_desc = Tpat_or (p1, p2, None) } in + let rec split_pattern cpat = + match cpat.pat_desc with + | Tpat_value p -> + Some p, None | Tpat_exception p -> None, Some p - | _ -> - Some pat, None + | Tpat_or (cp1, cp2, _) -> + let vals1, exns1 = split_pattern cp1 in + let vals2, exns2 = split_pattern cp2 in + combine_opts (into cpat) vals1 vals2, + (* We could change the pattern type for exception patterns to + [Predef.exn], but it doesn't really matter. *) + combine_opts (into cpat) exns1 exns2 in split_pattern pat diff --git a/typing/typedtree.mli b/typing/typedtree.mli index a646ca2b..a8f8d249 100644 --- a/typing/typedtree.mli +++ b/typing/typedtree.mli @@ -22,7 +22,6 @@ *) open Asttypes -open Types (* Value expressions for the core language *) @@ -35,12 +34,22 @@ type attributes = attribute list (** {1 Core language} *) -type pattern = - { pat_desc: pattern_desc; +type value = Value_pattern +type computation = Computation_pattern + +type _ pattern_category = +| Value : value pattern_category +| Computation : computation pattern_category + +type pattern = value general_pattern +and 'k general_pattern = 'k pattern_desc pattern_data + +and 'a pattern_data = + { pat_desc: 'a; pat_loc: Location.t; pat_extra : (pat_extra * Location.t * attributes) list; - pat_type: type_expr; - mutable pat_env: Env.t; + pat_type: Types.type_expr; + pat_env: Env.t; pat_attributes: attributes; } @@ -62,58 +71,85 @@ and pat_extra = ; pat_extra = (Tpat_unpack, _, _) :: ... } *) -and pattern_desc = - Tpat_any +and 'k pattern_desc = + (* value patterns *) + | Tpat_any : value pattern_desc (** _ *) - | Tpat_var of Ident.t * string loc + | Tpat_var : Ident.t * string loc -> value pattern_desc (** x *) - | Tpat_alias of pattern * Ident.t * string loc + | Tpat_alias : + value general_pattern * Ident.t * string loc -> value pattern_desc (** P as a *) - | Tpat_constant of constant + | Tpat_constant : constant -> value pattern_desc (** 1, 'a', "true", 1.0, 1l, 1L, 1n *) - | Tpat_tuple of pattern list + | Tpat_tuple : value general_pattern list -> value pattern_desc (** (P1, ..., Pn) Invariant: n >= 2 *) - | Tpat_construct of - Longident.t loc * constructor_description * pattern list + | Tpat_construct : + Longident.t loc * Types.constructor_description * + value general_pattern list -> + value pattern_desc (** C [] C P [P] C (P1, ..., Pn) [P1; ...; Pn] *) - | Tpat_variant of label * pattern option * row_desc ref + | Tpat_variant : + label * value general_pattern option * Types.row_desc ref -> + value pattern_desc (** `A (None) `A P (Some P) See {!Types.row_desc} for an explanation of the last parameter. *) - | Tpat_record of - (Longident.t loc * label_description * pattern) list * - closed_flag + | Tpat_record : + (Longident.t loc * Types.label_description * value general_pattern) list * + closed_flag -> + value pattern_desc (** { l1=P1; ...; ln=Pn } (flag = Closed) { l1=P1; ...; ln=Pn; _} (flag = Open) Invariant: n > 0 *) - | Tpat_array of pattern list + | Tpat_array : value general_pattern list -> value pattern_desc (** [| P1; ...; Pn |] *) - | Tpat_or of pattern * pattern * row_desc option + | Tpat_lazy : value general_pattern -> value pattern_desc + (** lazy P *) + (* computation patterns *) + | Tpat_value : tpat_value_argument -> computation pattern_desc + (** P + + Invariant: Tpat_value pattern should not carry + pat_attributes or pat_extra metadata coming from user + syntax, which must be on the inner pattern node -- to + facilitate searching for a certain value pattern + constructor with a specific attributed. + + To enforce this restriction, we made the argument of + the Tpat_value constructor a private synonym of [pattern], + requiring you to use the [as_computation_pattern] function + below instead of using the [Tpat_value] constructor directly. + *) + | Tpat_exception : value general_pattern -> computation pattern_desc + (** exception P *) + (* generic constructions *) + | Tpat_or : + 'k general_pattern * 'k general_pattern * Types.row_desc option -> + 'k pattern_desc (** P1 | P2 [row_desc] = [Some _] when translating [Ppat_type _], [None] otherwise. *) - | Tpat_lazy of pattern - (** lazy P *) - | Tpat_exception of pattern - (** exception P *) + +and tpat_value_argument = private value general_pattern and expression = { exp_desc: expression_desc; exp_loc: Location.t; exp_extra: (exp_extra * Location.t * attributes) list; - exp_type: type_expr; + exp_type: Types.type_expr; exp_env: Env.t; exp_attributes: attributes; } @@ -142,7 +178,7 @@ and expression_desc = let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive) *) | Texp_function of { arg_label : arg_label; param : Ident.t; - cases : case list; partial : partial; } + cases : value case list; partial : partial; } (** [Pexp_fun] and [Pexp_function] both translate to [Texp_function]. See {!Parsetree} for more details. @@ -169,7 +205,7 @@ and expression_desc = (Labelled "y", Some (Texp_constant Const_int 3)) ]) *) - | Texp_match of expression * case list * partial + | Texp_match of expression * computation case list * partial (** match E0 with | P1 -> E1 | P2 | exception P3 -> E2 @@ -178,12 +214,12 @@ and expression_desc = [Texp_match (E0, [(P1, E1); (P2 | exception P3, E2); (exception P4, E3)], _)] *) - | Texp_try of expression * case list + | Texp_try of expression * value case list (** try E with P1 -> E1 | ... | PN -> EN *) | Texp_tuple of expression list (** (E1, ..., EN) *) | Texp_construct of - Longident.t loc * constructor_description * expression list + Longident.t loc * Types.constructor_description * expression list (** C [] C E [E] C (E1, ..., En) [E1;...;En] @@ -205,9 +241,9 @@ and expression_desc = { fields = [| l1, Kept t1; l2 Override P2 |]; representation; extended_expression = Some E0 } *) - | Texp_field of expression * Longident.t loc * label_description + | Texp_field of expression * Longident.t loc * Types.label_description | Texp_setfield of - expression * Longident.t loc * label_description * expression + expression * Longident.t loc * Types.label_description * expression | Texp_array of expression list | Texp_ifthenelse of expression * expression * expression option | Texp_sequence of expression * expression @@ -232,7 +268,7 @@ and expression_desc = let_ : binding_op; ands : binding_op list; param : Ident.t; - body : case; + body : value case; partial : partial; } | Texp_unreachable @@ -244,9 +280,9 @@ and meth = Tmeth_name of string | Tmeth_val of Ident.t -and case = +and 'k case = { - c_lhs: pattern; + c_lhs: 'k general_pattern; c_guard: expression option; c_rhs: expression; } @@ -288,7 +324,7 @@ and class_expr_desc = | Tcl_let of rec_flag * value_binding list * (Ident.t * expression) list * class_expr | Tcl_constraint of - class_expr * class_type option * string list * string list * Concr.t + class_expr * class_type option * string list * string list * Types.Concr.t (* Visible instance variables, methods and concrete methods *) | Tcl_open of open_description * class_expr @@ -297,7 +333,7 @@ and class_structure = cstr_self: pattern; cstr_fields: class_field list; cstr_type: Types.class_signature; - cstr_meths: Ident.t Meths.t; + cstr_meths: Ident.t Types.Meths.t; } and class_field = @@ -387,7 +423,7 @@ and module_binding = { mb_id: Ident.t option; mb_name: string option loc; - mb_presence: module_presence; + mb_presence: Types.module_presence; mb_expr: module_expr; mb_attributes: attributes; mb_loc: Location.t; @@ -428,7 +464,7 @@ and module_type_desc = and primitive_coercion = { pc_desc: Primitive.description; - pc_type: type_expr; + pc_type: Types.type_expr; pc_env: Env.t; pc_loc : Location.t; } @@ -464,7 +500,7 @@ and module_declaration = { md_id: Ident.t option; md_name: string option loc; - md_presence: module_presence; + md_presence: Types.module_presence; md_type: module_type; md_attributes: attributes; md_loc: Location.t; @@ -525,7 +561,7 @@ and with_constraint = and core_type = { mutable ctyp_desc : core_type_desc; (** mutable because of [Typeclass.declare_method] *) - mutable ctyp_type : type_expr; + mutable ctyp_type : Types.type_expr; (** mutable because of [Typeclass.declare_method] *) ctyp_env : Env.t; (* BINANNOT ADDED *) ctyp_loc : Location.t; @@ -718,27 +754,52 @@ and 'a class_infos = (* Auxiliary functions over the a.s.t. *) +(** [as_computation_pattern p] is a computation pattern with description + [Tpat_value p], which enforces a correct placement of pat_attributes + and pat_extra metadata (on the inner value pattern, rather than on + the computation pattern). *) +val as_computation_pattern: pattern -> computation general_pattern + +val classify_pattern_desc: 'k pattern_desc -> 'k pattern_category +val classify_pattern: 'k general_pattern -> 'k pattern_category + +type pattern_action = + { f : 'k . 'k general_pattern -> unit } val shallow_iter_pattern_desc: - (pattern -> unit) -> pattern_desc -> unit + pattern_action -> 'k pattern_desc -> unit + +type pattern_transformation = + { f : 'k . 'k general_pattern -> 'k general_pattern } val shallow_map_pattern_desc: - (pattern -> pattern) -> pattern_desc -> pattern_desc + pattern_transformation -> 'k pattern_desc -> 'k pattern_desc +val iter_general_pattern: pattern_action -> 'k general_pattern -> unit val iter_pattern: (pattern -> unit) -> pattern -> unit + +type pattern_predicate = { f : 'k . 'k general_pattern -> bool } +val exists_general_pattern: pattern_predicate -> 'k general_pattern -> bool val exists_pattern: (pattern -> bool) -> pattern -> bool +(** bottom-up mapping of patterns: the transformation function is + called on the children before being called on the parent *) +val map_general_pattern: + pattern_transformation -> 'k general_pattern -> 'k general_pattern + val let_bound_idents: value_binding list -> Ident.t list val let_bound_idents_full: - value_binding list -> (Ident.t * string loc * type_expr) list + value_binding list -> (Ident.t * string loc * Types.type_expr) list (** Alpha conversion of patterns *) -val alpha_pat: (Ident.t * Ident.t) list -> pattern -> pattern +val alpha_pat: + (Ident.t * Ident.t) list -> 'k general_pattern -> 'k general_pattern val mknoloc: 'a -> 'a Asttypes.loc val mkloc: 'a -> Location.t -> 'a Asttypes.loc -val pat_bound_idents: pattern -> Ident.t list +val pat_bound_idents: 'k general_pattern -> Ident.t list val pat_bound_idents_full: - pattern -> (Ident.t * string loc * type_expr) list + 'k general_pattern -> (Ident.t * string loc * Types.type_expr) list (** Splits an or pattern into its value (left) and exception (right) parts. *) -val split_pattern : pattern -> pattern option * pattern option +val split_pattern: + computation general_pattern -> pattern option * pattern option diff --git a/typing/typemod.ml b/typing/typemod.ml index 4a0c13e3..1f7c480c 100644 --- a/typing/typemod.ml +++ b/typing/typemod.ml @@ -134,8 +134,8 @@ let extract_sig_open env loc mty = let type_open_ ?used_slot ?toplevel ovf env loc lid = let path = Env.lookup_module_path ~load:true ~loc:lid.loc lid.txt env in match Env.open_signature ~loc ?used_slot ?toplevel ovf path env with - | Some env -> path, env - | None -> + | Ok env -> path, env + | Error _ -> let md = Env.find_module path env in ignore (extract_sig_open env lid.loc md.md_type); assert false @@ -150,8 +150,11 @@ let initial_env ~loc ~safe_string ~initially_opened_module in let open_module env m = let open Asttypes in - let lid = {loc; txt = Longident.parse m } in - snd (type_open_ Override env lid.loc lid) + let lexbuf = Lexing.from_string m in + let txt = + Location.init lexbuf (Printf.sprintf "command line argument: -open %S" m); + Parse.simple_module_path lexbuf in + snd (type_open_ Override env loc {txt;loc}) in let add_units env units = String.Set.fold @@ -211,11 +214,6 @@ let type_open_descr ?used_slot ?toplevel env sod = in (od, newenv) -(* Record a module type *) -let rm node = - Stypes.record (Stypes.Ti_mod node); - node - (* Forward declaration, to be filled in by type_module_type_of *) let type_module_type_of_fwd : (Env.t -> Parsetree.module_expr -> @@ -251,7 +249,7 @@ let check_type_decl env loc id row_id newdecl decl rs rem = | Some id -> Env.add_type ~check:false id newdecl env in let env = if rs = Trec_not then env else add_rec_types env rem in - Includemod.type_declarations ~loc env id newdecl decl; + Includemod.type_declarations ~mark:Mark_both ~loc env id newdecl decl; Typedecl.check_coherence env loc (Path.Pident id) newdecl let update_rec_next rs rem = @@ -461,17 +459,19 @@ let merge_constraint initial_env remove_aliases loc sg constr = | Pwith_typesubst _ | Pwith_modsubst _ -> true in let real_ids = ref [] in - let rec merge env sg namelist row_id = + let rec merge sig_env sg namelist row_id = match (sg, namelist, constr) with ([], _, _) -> - raise(Error(loc, env, With_no_component lid.txt)) + raise(Error(loc, sig_env, With_no_component lid.txt)) | (Sig_type(id, decl, rs, priv) :: rem, [s], Pwith_type (_, ({ptype_kind = Ptype_abstract} as sdecl))) when Ident.name id = s && Typedecl.is_fixed_type sdecl -> let decl_row = - { type_params = + let arity = List.length sdecl.ptype_params in + { + type_params = List.map (fun _ -> Btype.newgenvar()) sdecl.ptype_params; - type_arity = List.length sdecl.ptype_params; + type_arity = arity; type_kind = Type_abstract; type_private = Private; type_manifest = None; @@ -487,95 +487,101 @@ let merge_constraint initial_env remove_aliases loc sg constr = make_variance (not n) (not c) false ) sdecl.ptype_params; + type_separability = + Types.Separability.default_signature ~arity; type_loc = sdecl.ptype_loc; type_is_newtype = false; type_expansion_scope = Btype.lowest_level; type_attributes = []; type_immediate = Unknown; type_unboxed = unboxed_false_default_false; + type_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } and id_row = Ident.create_local (s^"#row") in let initial_env = Env.add_type ~check:false id_row decl_row initial_env in - let tdecl = Typedecl.transl_with_constraint - initial_env id (Some(Pident id_row)) decl sdecl in + let tdecl = + Typedecl.transl_with_constraint id (Some(Pident id_row)) + ~sig_env ~sig_decl:decl ~outer_env:initial_env sdecl in let newdecl = tdecl.typ_type in - check_type_decl env sdecl.ptype_loc id row_id newdecl decl rs rem; + check_type_decl sig_env sdecl.ptype_loc id row_id newdecl decl rs rem; let decl_row = {decl_row with type_params = newdecl.type_params} in let rs' = if rs = Trec_first then Trec_not else rs in (Pident id, lid, Twith_type tdecl), Sig_type(id_row, decl_row, rs', priv) :: Sig_type(id, newdecl, rs, priv) :: rem - | (Sig_type(id, decl, rs, priv) :: rem , [s], Pwith_type (_, sdecl)) + | (Sig_type(id, sig_decl, rs, priv) :: rem , [s], + (Pwith_type (_, sdecl) | Pwith_typesubst (_, sdecl) as constr)) when Ident.name id = s -> let tdecl = - Typedecl.transl_with_constraint initial_env id None decl sdecl in - let newdecl = tdecl.typ_type in - check_type_decl env sdecl.ptype_loc id row_id newdecl decl rs rem; - (Pident id, lid, Twith_type tdecl), - Sig_type(id, newdecl, rs, priv) :: rem + Typedecl.transl_with_constraint id None + ~sig_env ~sig_decl ~outer_env:initial_env sdecl in + let newdecl = tdecl.typ_type and loc = sdecl.ptype_loc in + check_type_decl sig_env loc id row_id newdecl sig_decl rs rem; + begin match constr with + Pwith_type _ -> + (Pident id, lid, Twith_type tdecl), + Sig_type(id, newdecl, rs, priv) :: rem + | (* Pwith_typesubst *) _ -> + real_ids := [Pident id]; + (Pident id, lid, Twith_typesubst tdecl), + update_rec_next rs rem + end | (Sig_type(id, _, _, _) :: rem, [s], (Pwith_type _ | Pwith_typesubst _)) when Ident.name id = s ^ "#row" -> - merge env rem namelist (Some id) - | (Sig_type(id, decl, rs, _priv) :: rem, [s], Pwith_typesubst (_, sdecl)) - when Ident.name id = s -> - (* Check as for a normal with constraint, but discard definition *) - let tdecl = - Typedecl.transl_with_constraint initial_env id None decl sdecl in - let newdecl = tdecl.typ_type in - check_type_decl env sdecl.ptype_loc id row_id newdecl decl rs rem; - real_ids := [Pident id]; - (Pident id, lid, Twith_typesubst tdecl), - update_rec_next rs rem + merge sig_env rem namelist (Some id) | (Sig_module(id, pres, md, rs, priv) :: rem, [s], Pwith_module (_, lid')) when Ident.name id = s -> let path, md' = Env.lookup_module ~loc lid'.txt initial_env in let mty = md'.md_type in - let mty = Mtype.scrape_for_type_of ~remove_aliases env mty in + let mty = Mtype.scrape_for_type_of ~remove_aliases sig_env mty in let md'' = { md' with md_type = mty } in - let newmd = Mtype.strengthen_decl ~aliasable:false env md'' path in - ignore(Includemod.modtypes ~loc env newmd.md_type md.md_type); + let newmd = Mtype.strengthen_decl ~aliasable:false sig_env md'' path in + ignore(Includemod.modtypes ~mark:Mark_both ~loc sig_env + newmd.md_type md.md_type); (Pident id, lid, Twith_module (path, lid')), Sig_module(id, pres, newmd, rs, priv) :: rem | (Sig_module(id, _, md, rs, _) :: rem, [s], Pwith_modsubst (_, lid')) when Ident.name id = s -> let path, md' = Env.lookup_module ~loc lid'.txt initial_env in - let aliasable = not (Env.is_functor_arg path env) in - let newmd = Mtype.strengthen_decl ~aliasable env md' path in - ignore(Includemod.modtypes ~loc env newmd.md_type md.md_type); + let aliasable = not (Env.is_functor_arg path sig_env) in + ignore + (Includemod.strengthened_module_decl ~loc ~mark:Mark_both + ~aliasable sig_env md' path md); real_ids := [Pident id]; (Pident id, lid, Twith_modsubst (path, lid')), update_rec_next rs rem - | (Sig_module(id, _, ({md_type = Mty_alias _} as md), _, _) as item :: rem, - s :: namelist, (Pwith_module _ | Pwith_type _)) + | (Sig_module(id, _, md, rs, priv) as item :: rem, s :: namelist, constr) when Ident.name id = s -> - let ((path, _, tcstr), _) = - merge env (extract_sig env loc md.md_type) namelist None - in + let sg = extract_sig sig_env loc md.md_type in + let ((path, _, tcstr), newsg) = merge_signature sig_env sg namelist in let path = path_concat id path in real_ids := path :: !real_ids; - (path, lid, tcstr), item :: rem - | (Sig_module(id, _, md, rs, priv) :: rem, s :: namelist, _) - when Ident.name id = s -> - let ((path, _path_loc, tcstr), newsg) = - merge env (extract_sig env loc md.md_type) namelist None + let item = + match md.md_type, constr with + Mty_alias _, (Pwith_module _ | Pwith_type _) -> + (* A module alias cannot be refined, so keep it + and just check that the constraint is correct *) + item + | _ -> + let newmd = {md with md_type = Mty_signature newsg} in + Sig_module(id, Mp_present, newmd, rs, priv) in - let path = path_concat id path in - real_ids := path :: !real_ids; - let newmd = {md with md_type=Mty_signature newsg} in - let item = Sig_module(id, Mp_present, newmd, rs, priv) in (path, lid, tcstr), item :: rem | (item :: rem, _, _) -> - let (cstr, items) = merge (Env.add_item item env) rem namelist row_id + let (cstr, items) = merge sig_env rem namelist row_id in cstr, item :: items + and merge_signature env sg namelist = + let sig_env = Env.add_signature sg env in + merge sig_env sg namelist None in try let names = Longident.flatten lid.txt in - let (tcstr, sg) = merge initial_env sg names None in + let (tcstr, sg) = merge_signature initial_env sg names in if destructive_substitution then ( match List.rev !real_ids with | [] -> assert false @@ -736,6 +742,7 @@ and approx_module_declaration env pmd = Types.md_type = approx_modtype env pmd.pmd_type; md_attributes = pmd.pmd_attributes; md_loc = pmd.pmd_loc; + md_uid = Uid.internal_not_actually_unique; } and approx_sig env ssg = @@ -838,6 +845,7 @@ and approx_modtype_info env sinfo = mtd_type = Option.map (approx_modtype env) sinfo.pmtd_type; mtd_attributes = sinfo.pmtd_attributes; mtd_loc = sinfo.pmtd_loc; + mtd_uid = Uid.internal_not_actually_unique; } let approx_modtype env smty = @@ -1151,6 +1159,7 @@ and transl_modtype_aux env smty = { md_type = arg.mty_type; md_attributes = []; md_loc = param.loc; + md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } in Env.enter_module_declaration ~scope ~arg:true name Mp_present @@ -1230,10 +1239,13 @@ and transl_signature env sg = td.typ_private = Private then raise (Error (td.typ_loc, env, Invalid_type_subst_rhs)); + let params = td.typ_type.type_params in + if params_are_constrained params + then raise(Error(loc, env, With_cannot_remove_constrained_type)); let info = let subst = Subst.add_type_function (Pident td.typ_id) - ~params:td.typ_type.type_params + ~params ~body:(Option.get td.typ_type.type_manifest) Subst.identity in @@ -1288,6 +1300,7 @@ and transl_signature env sg = 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 = @@ -1323,7 +1336,9 @@ and transl_signature env sg = else { md_type = Mty_alias path; md_attributes = pms.pms_attributes; - md_loc = pms.pms_loc } + md_loc = pms.pms_loc; + md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } in let pres = match md.md_type with @@ -1349,21 +1364,22 @@ and transl_signature env sg = let (tdecls, newenv) = transl_recmodule_modtypes env sdecls in let decls = - List.filter_map (fun md -> + List.filter_map (fun (md, uid) -> match md.md_id with | None -> None - | Some id -> Some (id, md) + | Some id -> Some (id, md, uid) ) tdecls in - List.iter - (fun (id, md) -> Signature_names.check_module names md.md_loc id) - decls; + List.iter (fun (id, md, _) -> + Signature_names.check_module names md.md_loc id + ) decls; let (trem, rem, final_env) = transl_sig newenv srem in - mksig (Tsig_recmodule tdecls) env loc :: trem, - map_rec (fun rs (id, md) -> + mksig (Tsig_recmodule (List.map fst tdecls)) env loc :: trem, + map_rec (fun rs (id, md, uid) -> let d = {Types.md_type = md.md_type.mty_type; md_attributes = md.md_attributes; md_loc = md.md_loc; + md_uid = uid; } in Sig_module(id, Mp_present, d, rs, Exported)) decls rem, @@ -1493,6 +1509,7 @@ and transl_modtype_decl_aux names env Types.mtd_type=Option.map (fun t -> t.mty_type) tmty; mtd_attributes=pmtd_attributes; mtd_loc=pmtd_loc; + mtd_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } in let scope = Ctype.create_scope () in @@ -1512,35 +1529,25 @@ and transl_modtype_decl_aux names env and transl_recmodule_modtypes env sdecls = let make_env curr = List.fold_left - (fun env (id, _, mty) -> - Option.fold ~none:env - ~some:(fun id -> Env.add_module ~arg:true id Mp_present mty env) id) - env curr in - let make_env2 curr = - List.fold_left - (fun env (id, _, mty) -> + (fun env (id, _, md, _) -> Option.fold ~none:env - ~some:(fun id -> - Env.add_module ~arg:true id Mp_present mty.mty_type env - ) id) + ~some:(fun id -> Env.add_module_declaration ~check:true ~arg:true + id Mp_present md env) id) env curr in let transition env_c curr = List.map2 - (fun pmd (id, id_loc, _mty) -> + (fun pmd (id, id_loc, md, _) -> let tmty = Builtin_attributes.warning_scope pmd.pmd_attributes (fun () -> transl_modtype env_c pmd.pmd_type) in - (id, id_loc, tmty)) + let md = { md with Types.md_type = tmty.mty_type } in + (id, id_loc, md, tmty)) sdecls curr in - let map_mtys = + let map_mtys curr = List.filter_map - (fun (id, _, mty) -> - Option.map (fun id -> - (id, Types.{md_type = mty.mty_type; - md_loc = mty.mty_loc; - md_attributes = mty.mty_attributes}) - ) id) + (fun (id, _, md, _) -> Option.map (fun id -> (id, md)) id) + curr in let scope = Ctype.create_scope () in let ids = @@ -1559,7 +1566,13 @@ and transl_recmodule_modtypes env sdecls = let init = List.map2 (fun id pmd -> - (id, pmd.pmd_name, approx_modtype approx_env pmd.pmd_type)) + let md = + { md_type = approx_modtype approx_env pmd.pmd_type; + md_loc = pmd.pmd_loc; + md_attributes = pmd.pmd_attributes; + md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) } + in + (id, pmd.pmd_name, md, ())) ids sdecls in let env0 = make_env init in @@ -1567,7 +1580,7 @@ and transl_recmodule_modtypes env sdecls = Warnings.without_warnings (fun () -> transition env0 init) in - let env1 = make_env2 dcl1 in + let env1 = make_env dcl1 in check_recmod_typedecls env1 (map_mtys dcl1); let dcl2 = transition env1 dcl1 in (* @@ -1576,16 +1589,18 @@ and transl_recmodule_modtypes env sdecls = Format.printf "%a: %a@." Printtyp.ident id Printtyp.modtype mty) dcl2; *) - let env2 = make_env2 dcl2 in + let env2 = make_env dcl2 in check_recmod_typedecls env2 (map_mtys dcl2); let dcl2 = - List.map2 - (fun pmd (id, id_loc, mty) -> + List.map2 (fun pmd (id, id_loc, md, mty) -> + let tmd = {md_id=id; md_name=id_loc; md_type=mty; md_presence=Mp_present; md_loc=pmd.pmd_loc; - md_attributes=pmd.pmd_attributes}) - sdecls dcl2 + md_attributes=pmd.pmd_attributes} + in + tmd, md.md_uid + ) sdecls dcl2 in (dcl2, env2) @@ -1711,7 +1726,7 @@ let check_recmodule_inclusion env bindings = (* Generate fresh names Y_i for the rec. bound module idents X_i *) let bindings1 = List.map - (fun (id, _name, _mty_decl, _modl, mty_actual, _attrs, _loc) -> + (fun (id, _name, _mty_decl, _modl, mty_actual, _attrs, _loc, _uid) -> let ids = Option.map (fun id -> (id, Ident.create_scoped ~scope (Ident.name id))) id @@ -1746,12 +1761,14 @@ let check_recmodule_inclusion env bindings = end else begin (* Base case: check inclusion of s(mty_actual) in s(mty_decl) and insert coercion if needed *) - let check_inclusion (id, name, mty_decl, modl, mty_actual, attrs, loc) = + let check_inclusion + (id, name, mty_decl, modl, mty_actual, attrs, loc, uid) = let mty_decl' = Subst.modtype (Rescope scope) s mty_decl.mty_type and mty_actual' = subst_and_strengthen env scope s id mty_actual in let coercion = try - Includemod.modtypes ~loc:modl.mod_loc env mty_actual' mty_decl' + Includemod.modtypes ~loc:modl.mod_loc ~mark:Mark_both env + mty_actual' mty_decl' with Includemod.Error msg -> raise(Error(modl.mod_loc, env, Not_included msg)) in let modl' = @@ -1762,14 +1779,17 @@ let check_recmodule_inclusion env bindings = mod_loc = modl.mod_loc; mod_attributes = []; } in - { - mb_id = id; - mb_name = name; - mb_presence = Mp_present; - mb_expr = modl'; - mb_attributes = attrs; - mb_loc = loc; - } + let mb = + { + mb_id = id; + mb_name = name; + mb_presence = Mp_present; + mb_expr = modl'; + mb_attributes = attrs; + mb_loc = loc; + } + in + mb, uid in List.map check_inclusion bindings end @@ -1811,10 +1831,9 @@ let modtype_of_package env loc p nl tl = | Some mty when nl <> [] -> package_constraints env loc mty (List.combine (List.map Longident.flatten nl) tl) - | _ -> + | _ | exception Not_found (* missing cmi *) -> if nl = [] then Mty_ident p else raise(Error(loc, env, Signature_expected)) - | exception Not_found -> assert false let package_subtype env p1 nl1 tl1 p2 nl2 tl2 = let mkmty p nl tl = @@ -1825,9 +1844,10 @@ let package_subtype env p1 nl1 tl1 p2 nl2 tl2 = modtype_of_package env Location.none p nl tl in let mty1 = mkmty p1 nl1 tl1 and mty2 = mkmty p2 nl2 tl2 in - try Includemod.modtypes ~loc:Location.none env mty1 mty2 = Tcoerce_none - with Includemod.Error _msg -> false - (* raise(Error(Location.none, env, Not_included msg)) *) + let loc = Location.none in + match Includemod.modtypes ~loc ~mark:Mark_both env mty1 mty2 with + | Tcoerce_none -> true + | _ | exception Includemod.Error _ -> false let () = Ctype.package_subtype := package_subtype @@ -1882,16 +1902,16 @@ and type_module_aux ~alias sttn funct_body anchor env smod = else mty in { md with mod_type = mty } - in rm md + in md | Pmod_structure sstr -> let (str, sg, names, _finalenv) = type_structure funct_body anchor env sstr smod.pmod_loc in let md = - rm { mod_desc = Tmod_structure str; - mod_type = Mty_signature sg; - mod_env = env; - mod_attributes = smod.pmod_attributes; - mod_loc = smod.pmod_loc } + { mod_desc = Tmod_structure str; + mod_type = Mty_signature sg; + mod_env = env; + mod_attributes = smod.pmod_attributes; + mod_loc = smod.pmod_loc } in let sg' = Signature_names.simplify _finalenv names sg in if List.length sg' = List.length sg then md else @@ -1912,6 +1932,7 @@ and type_module_aux ~alias sttn funct_body anchor env smod = { md_type = mty.mty_type; md_attributes = []; md_loc = param.loc; + md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } in let id, newenv = @@ -1923,11 +1944,11 @@ and type_module_aux ~alias sttn funct_body anchor env smod = Named (id, param, mty), Types.Named (id, mty.mty_type), newenv, true in let body = type_module sttn funct_body None newenv sbody in - rm { mod_desc = Tmod_functor(t_arg, body); - mod_type = Mty_functor(ty_arg, body.mod_type); - mod_env = env; - mod_attributes = smod.pmod_attributes; - mod_loc = smod.pmod_loc } + { mod_desc = Tmod_functor(t_arg, body); + mod_type = Mty_functor(ty_arg, body.mod_type); + mod_env = env; + mod_attributes = smod.pmod_attributes; + mod_loc = smod.pmod_loc } | Pmod_apply(sfunct, sarg) -> let arg = type_module true funct_body None env sarg in let path = path_of_module arg in @@ -1939,15 +1960,16 @@ and type_module_aux ~alias sttn funct_body anchor env smod = raise (Error (sfunct.pmod_loc, env, Apply_generative)); if funct_body && Mtype.contains_type env funct.mod_type then raise (Error (smod.pmod_loc, env, Not_allowed_in_functor_body)); - rm { mod_desc = Tmod_apply(funct, arg, Tcoerce_none); - mod_type = mty_res; - mod_env = env; - mod_attributes = smod.pmod_attributes; - mod_loc = smod.pmod_loc } + { mod_desc = Tmod_apply(funct, arg, Tcoerce_none); + mod_type = mty_res; + mod_env = env; + mod_attributes = smod.pmod_attributes; + mod_loc = smod.pmod_loc } | Mty_functor (Named (param, mty_param), mty_res) as mty_functor -> let coercion = try - Includemod.modtypes ~loc:sarg.pmod_loc env arg.mod_type mty_param + Includemod.modtypes ~loc:sarg.pmod_loc ~mark:Mark_both env + arg.mod_type mty_param with Includemod.Error msg -> raise(Error(sarg.pmod_loc, env, Not_included msg)) in let mty_appl = @@ -1977,7 +1999,8 @@ and type_module_aux ~alias sttn funct_body anchor env smod = Cannot_eliminate_dependency mty_functor)) in begin match - Includemod.modtypes ~loc:smod.pmod_loc env mty_res nondep_mty + Includemod.modtypes ~mark:Mark_neither + ~loc:smod.pmod_loc env mty_res nondep_mty with | Tcoerce_none -> () | _ -> @@ -1992,11 +2015,11 @@ and type_module_aux ~alias sttn funct_body anchor env smod = in check_well_formed_module env smod.pmod_loc "the signature of this functor application" mty_appl; - rm { mod_desc = Tmod_apply(funct, arg, coercion); - mod_type = mty_appl; - mod_env = env; - mod_attributes = smod.pmod_attributes; - mod_loc = smod.pmod_loc } + { mod_desc = Tmod_apply(funct, arg, coercion); + mod_type = mty_appl; + mod_env = env; + mod_attributes = smod.pmod_attributes; + mod_loc = smod.pmod_loc } | Mty_alias path -> raise(Error(sfunct.pmod_loc, env, Cannot_scrape_alias path)) | _ -> @@ -2008,10 +2031,10 @@ and type_module_aux ~alias sttn funct_body anchor env smod = let md = wrap_constraint env true arg mty.mty_type (Tmodtype_explicit mty) in - rm { md with - mod_loc = smod.pmod_loc; - mod_attributes = smod.pmod_attributes; - } + { md with + mod_loc = smod.pmod_loc; + mod_attributes = smod.pmod_attributes; + } | Pmod_unpack sexp -> if !Clflags.principal then Ctype.begin_def (); @@ -2040,11 +2063,11 @@ and type_module_aux ~alias sttn funct_body anchor env smod = in if funct_body && Mtype.contains_type env mty then raise (Error (smod.pmod_loc, env, Not_allowed_in_functor_body)); - rm { mod_desc = Tmod_unpack(exp, mty); - mod_type = mty; - mod_env = env; - mod_attributes = smod.pmod_attributes; - mod_loc = smod.pmod_loc } + { mod_desc = Tmod_unpack(exp, mty); + mod_type = mty; + mod_env = env; + mod_attributes = smod.pmod_attributes; + mod_loc = smod.pmod_loc } | Pmod_extension ext -> raise (Error_forward (Builtin_attributes.error_of_extension ext)) @@ -2083,16 +2106,23 @@ and type_open_decl_aux ?used_slot ?toplevel funct_body names env od = Env.enter_signature ~scope (extract_sig_open env md.mod_loc md.mod_type) env in - List.iter (Signature_names.check_sig_item ~info:`From_open names loc) sg; + let info, visibility = + match toplevel with + | Some false | None -> Some `From_open, Hidden + | Some true -> None, Exported + in + List.iter (Signature_names.check_sig_item ?info names loc) sg; let sg = List.map (function - | Sig_value(id, vd, _) -> Sig_value(id, vd, Hidden) - | Sig_type(id, td, rs, _) -> Sig_type(id, td, rs, Hidden) - | Sig_typext(id, ec, et, _) -> Sig_typext(id, ec, et, Hidden) - | Sig_module(id, mp, md, rs, _) -> Sig_module(id, mp, md, rs, Hidden) - | Sig_modtype(id, mtd, _) -> Sig_modtype(id, mtd, Hidden) - | Sig_class(id, cd, rs, _) -> Sig_class(id, cd, rs, Hidden) - | Sig_class_type(id, ctd, rs, _) -> Sig_class_type(id, ctd, rs, Hidden) + | Sig_value(id, vd, _) -> Sig_value(id, vd, visibility) + | Sig_type(id, td, rs, _) -> Sig_type(id, td, rs, visibility) + | Sig_typext(id, ec, et, _) -> Sig_typext(id, ec, et, visibility) + | Sig_module(id, mp, md, rs, _) -> + Sig_module(id, mp, md, rs, visibility) + | Sig_modtype(id, mtd, _) -> Sig_modtype(id, mtd, visibility) + | Sig_class(id, cd, rs, _) -> Sig_class(id, cd, rs, visibility) + | Sig_class_type(id, ctd, rs, _) -> + Sig_class_type(id, ctd, rs, visibility) ) sg in let open_descr = { @@ -2200,10 +2230,12 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = | Mty_alias _ -> Mp_absent | _ -> Mp_present in + let md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in let md = { md_type = enrich_module_type anchor name.txt modl.mod_type env; md_attributes = attrs; md_loc = pmb_loc; + md_uid; } in (*prerr_endline (Ident.unique_toplevel_name id);*) @@ -2219,6 +2251,7 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = {md_type = modl.mod_type; md_attributes = attrs; md_loc = pmb_loc; + md_uid; }, Trec_not, Exported)] in Tstr_module {mb_id=id; mb_name=name; mb_expr=modl; @@ -2248,12 +2281,12 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = pmd_attributes=attrs; pmd_loc=loc}) sbind ) in List.iter - (fun md -> + (fun (md, _) -> Option.iter Signature_names.(check_module names md.md_loc) md.md_id) decls; let bindings1 = List.map2 - (fun {md_id=id; md_type=mty} (name, _, smodl, attrs, loc) -> + (fun ({md_id=id; md_type=mty}, uid) (name, _, smodl, attrs, loc) -> let modl = Builtin_attributes.warning_scope attrs (fun () -> @@ -2264,11 +2297,11 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = let mty' = enrich_module_type anchor name.txt modl.mod_type newenv in - (id, name, mty, modl, mty', attrs, loc)) + (id, name, mty, modl, mty', attrs, loc, uid)) decls sbind in let newenv = (* allow aliasing recursive modules from outside *) List.fold_left - (fun env md -> + (fun env (md, uid) -> match md.md_id with | None -> env | Some id -> @@ -2277,6 +2310,7 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = md_type = md.md_type.mty_type; md_attributes = md.md_attributes; md_loc = md.md_loc; + md_uid = uid; } in Env.add_module_declaration ~check:true @@ -2287,15 +2321,17 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = let bindings2 = check_recmodule_inclusion newenv bindings1 in let mbs = - List.filter_map (fun mb -> Option.map (fun id -> id, mb) mb.mb_id) - bindings2 + List.filter_map (fun (mb, uid) -> + Option.map (fun id -> id, mb, uid) mb.mb_id + ) bindings2 in - Tstr_recmodule bindings2, - map_rec (fun rs (id, mb) -> + Tstr_recmodule (List.map fst bindings2), + map_rec (fun rs (id, mb, uid) -> Sig_module(id, Mp_present, { md_type=mb.mb_expr.mod_type; md_attributes=mb.mb_attributes; md_loc=mb.mb_loc; + md_uid = uid; }, rs, Exported)) mbs [], newenv @@ -2408,9 +2444,6 @@ and type_structure ?(toplevel = false) funct_body anchor env sstr scope = let (str_rem, sig_rem, final_env) = type_struct new_env srem in (str :: str_rem, sg @ sig_rem, final_env) in - if !Clflags.annotations then - (* moved to genannot *) - List.iter (function {pstr_loc = l} -> Stypes.record_phrase l) sstr; let previous_saved_types = Cmt_format.get_saved_types () in let run () = let (items, sg, final_env) = type_struct env sstr in @@ -2455,11 +2488,11 @@ let type_module_type_of env smod = match smod.pmod_desc with | Pmod_ident lid -> (* turn off strengthening in this case *) let path, md = Env.lookup_module ~loc:smod.pmod_loc lid.txt env in - rm { mod_desc = Tmod_ident (path, lid); - mod_type = md.md_type; - mod_env = env; - mod_attributes = smod.pmod_attributes; - mod_loc = smod.pmod_loc } + { mod_desc = Tmod_ident (path, lid); + mod_type = md.md_type; + mod_env = env; + mod_attributes = smod.pmod_attributes; + mod_loc = smod.pmod_loc } | _ -> type_module env smod in let mty = Mtype.scrape_for_type_of ~remove_aliases env tmty.mod_type in @@ -2593,6 +2626,10 @@ let () = (* Typecheck an implementation file *) +let gen_annot outputprefix sourcefile annots = + Cmt2annot.gen_annot (Some (outputprefix ^ ".annot")) + ~sourcefile:(Some sourcefile) ~use_summaries:false annots + let type_implementation sourcefile outputprefix modulename initial_env ast = Cmt_format.clear (); Misc.try_finally (fun () -> @@ -2609,6 +2646,7 @@ let type_implementation sourcefile outputprefix modulename initial_env ast = (fun () -> fprintf std_formatter "%a@." (Printtyp.printed_signature sourcefile) simple_sg ); + gen_annot outputprefix sourcefile (Cmt_format.Implementation str); (str, Tcoerce_none) (* result is ignored by Compile.implementation *) end else begin let sourceintf = @@ -2622,19 +2660,21 @@ let type_implementation sourcefile outputprefix modulename initial_env ast = Interface_not_compiled sourceintf)) in let dclsig = Env.read_signature modulename intf_file in let coercion = - Includemod.compunit initial_env ~mark:Includemod.Mark_positive + Includemod.compunit initial_env ~mark:Mark_positive sourcefile sg intf_file dclsig 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 annots = Cmt_format.Implementation str in Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename - (Cmt_format.Implementation str) (Some sourcefile) initial_env None; + annots (Some sourcefile) initial_env None; + gen_annot outputprefix sourcefile annots; (str, coercion) end else begin let coercion = - Includemod.compunit initial_env ~mark:Includemod.Mark_positive + Includemod.compunit initial_env ~mark:Mark_positive sourcefile sg "(inferred signature)" simple_sg in check_nongen_schemes finalenv simple_sg; @@ -2650,19 +2690,24 @@ let type_implementation sourcefile outputprefix modulename initial_env ast = Env.save_signature ~alerts simple_sg modulename (outputprefix ^ ".cmi") in + let annots = Cmt_format.Implementation str in Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename - (Cmt_format.Implementation str) - (Some sourcefile) initial_env (Some cmi); + annots (Some sourcefile) initial_env (Some cmi); + gen_annot outputprefix sourcefile annots end; (str, coercion) end end ) ~exceptionally:(fun () -> + let annots = + Cmt_format.Partial_implementation + (Array.of_list (Cmt_format.get_saved_types ())) + in Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename - (Cmt_format.Partial_implementation - (Array.of_list (Cmt_format.get_saved_types ()))) - (Some sourcefile) initial_env None) + annots (Some sourcefile) initial_env None; + gen_annot outputprefix sourcefile annots + ) let save_signature modname tsg outputprefix source_file initial_env cmi = Cmt_format.save_cmt (outputprefix ^ ".cmti") modname @@ -2697,7 +2742,9 @@ let package_signatures units = let md = { md_type=Mty_signature sg; md_attributes=[]; - md_loc=Location.none; } + md_loc=Location.none; + md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } in Sig_module(newid, Mp_present, md, Trec_not, Exported)) units_with_ids @@ -2730,7 +2777,8 @@ let package_units initial_env objfiles cmifile modulename = let dclsig = Env.read_signature modulename cmifile in Cmt_format.save_cmt (prefix ^ ".cmt") modulename (Cmt_format.Packed (sg, objfiles)) None initial_env None ; - Includemod.compunit initial_env "(obtained by packing)" sg mlifile dclsig + Includemod.compunit initial_env ~mark:Mark_both + "(obtained by packing)" sg mlifile dclsig end else begin (* Determine imports *) let unit_names = List.map fst units in diff --git a/typing/types.ml b/typing/types.ml index 3bd25556..f03a4bc6 100644 --- a/typing/types.ml +++ b/typing/types.ml @@ -79,6 +79,58 @@ module TypeOps = struct let equal t1 t2 = t1 == t2 end +(* *) + +module Uid = struct + type t = + | Compilation_unit of string + | Item of { comp_unit: string; id: int } + | Internal + | Predef of string + + include Identifiable.Make(struct + type nonrec t = t + + let equal (x : t) y = x = y + let compare (x : t) y = compare x y + let hash (x : t) = Hashtbl.hash x + + let print fmt = function + | Internal -> Format.pp_print_string fmt "" + | Predef name -> Format.fprintf fmt "" name + | Compilation_unit s -> Format.pp_print_string fmt s + | Item { comp_unit; id } -> Format.fprintf fmt "%s.%d" comp_unit id + + let output oc t = + let fmt = Format.formatter_of_out_channel oc in + print fmt t + end) + + let id = ref (-1) + + let reinit () = id := (-1) + + let mk ~current_unit = + incr id; + Item { comp_unit = current_unit; id = !id } + + let of_compilation_unit_id id = + if not (Ident.persistent id) then + Misc.fatal_errorf "Types.Uid.of_compilation_unit_id %S" (Ident.name id); + Compilation_unit (Ident.name id) + + let of_predef_id id = + if not (Ident.is_predef id) then + Misc.fatal_errorf "Types.Uid.of_predef_id %S" (Ident.name id); + Predef (Ident.name id) + + let internal_not_actually_unique = Internal + + let for_actual_declaration = function + | Item _ -> true + | _ -> false +end + (* Maps of methods and instance variables *) module Meths = Misc.Stdlib.String.Map @@ -91,7 +143,8 @@ type value_description = val_kind: value_kind; val_loc: Location.t; val_attributes: Parsetree.attributes; - } + val_uid: Uid.t; + } and value_kind = Val_reg (* Regular value *) @@ -136,6 +189,32 @@ module Variance = struct let get_lower v = (mem Pos v, mem Neg v, mem Inv v, mem Inj v) end +module Separability = struct + type t = Ind | Sep | Deepsep + type signature = t list + let eq (m1 : t) m2 = (m1 = m2) + let rank = function + | Ind -> 0 + | Sep -> 1 + | Deepsep -> 2 + let compare m1 m2 = compare (rank m1) (rank m2) + let max m1 m2 = if rank m1 >= rank m2 then m1 else m2 + + let print ppf = function + | Ind -> Format.fprintf ppf "Ind" + | Sep -> Format.fprintf ppf "Sep" + | Deepsep -> Format.fprintf ppf "Deepsep" + + let print_signature ppf modes = + let pp_sep ppf () = Format.fprintf ppf ",@," in + Format.fprintf ppf "@[(%a)@]" + (Format.pp_print_list ~pp_sep print) modes + + let default_signature ~arity = + let default_mode = if Config.flat_float_array then Deepsep else Ind in + List.init arity (fun _ -> default_mode) +end + (* Type definitions *) type type_declaration = @@ -145,12 +224,14 @@ type type_declaration = type_private: private_flag; type_manifest: type_expr option; type_variance: Variance.t list; + type_separability: Separability.t list; type_is_newtype: bool; type_expansion_scope: int; type_loc: Location.t; type_attributes: Parsetree.attributes; type_immediate: Type_immediacy.t; type_unboxed: unboxed_status; + type_uid: Uid.t; } and type_kind = @@ -173,6 +254,7 @@ and label_declaration = ld_type: type_expr; ld_loc: Location.t; ld_attributes: Parsetree.attributes; + ld_uid: Uid.t; } and constructor_declaration = @@ -182,6 +264,7 @@ and constructor_declaration = cd_res: type_expr option; cd_loc: Location.t; cd_attributes: Parsetree.attributes; + cd_uid: Uid.t; } and constructor_arguments = @@ -200,13 +283,15 @@ let unboxed_true_default_false = {unboxed = true; default = false} let unboxed_true_default_true = {unboxed = true; default = true} type extension_constructor = - { ext_type_path: Path.t; - ext_type_params: type_expr list; - ext_args: constructor_arguments; - ext_ret_type: type_expr option; - ext_private: private_flag; - ext_loc: Location.t; - ext_attributes: Parsetree.attributes; } + { ext_type_path: Path.t; + ext_type_params: type_expr list; + ext_args: constructor_arguments; + ext_ret_type: type_expr option; + ext_private: private_flag; + ext_loc: Location.t; + ext_attributes: Parsetree.attributes; + ext_uid: Uid.t; + } and type_transparence = Type_public (* unrestricted expansion *) @@ -237,6 +322,7 @@ type class_declaration = cty_variance: Variance.t list; cty_loc: Location.t; cty_attributes: Parsetree.attributes; + cty_uid: Uid.t; } type class_type_declaration = @@ -246,6 +332,7 @@ type class_type_declaration = clty_variance: Variance.t list; clty_loc: Location.t; clty_attributes: Parsetree.attributes; + clty_uid: Uid.t; } (* Type expressions for the module language *) @@ -285,6 +372,7 @@ and module_declaration = md_type: module_type; md_attributes: Parsetree.attributes; md_loc: Location.t; + md_uid: Uid.t; } and modtype_declaration = @@ -292,6 +380,7 @@ and modtype_declaration = mtd_type: module_type option; (* Note: abstract *) mtd_attributes: Parsetree.attributes; mtd_loc: Location.t; + mtd_uid: Uid.t; } and rec_status = @@ -323,6 +412,7 @@ type constructor_description = cstr_loc: Location.t; cstr_attributes: Parsetree.attributes; cstr_inlined: type_declaration option; + cstr_uid: Uid.t; } and constructor_tag = @@ -356,6 +446,7 @@ type label_description = lbl_private: private_flag; (* Read-only field? *) lbl_loc: Location.t; lbl_attributes: Parsetree.attributes; + lbl_uid: Uid.t; } let rec bound_value_identifiers = function diff --git a/typing/types.mli b/typing/types.mli index 1dea43aa..7dc20535 100644 --- a/typing/types.mli +++ b/typing/types.mli @@ -240,6 +240,23 @@ module TypeOps : sig val hash : t -> int end +(* *) + +module Uid : sig + type t + + val reinit : unit -> unit + + val mk : current_unit:string -> t + val of_compilation_unit_id : Ident.t -> t + val of_predef_id : Ident.t -> t + val internal_not_actually_unique : t + + val for_actual_declaration : t -> bool + + include Identifiable.S with type t := t +end + (* Maps of methods and instance variables *) module Meths : Map.S with type key = string @@ -252,7 +269,8 @@ type value_description = val_kind: value_kind; val_loc: Location.t; val_attributes: Parsetree.attributes; - } + val_uid: Uid.t; + } and value_kind = Val_reg (* Regular value *) @@ -285,6 +303,38 @@ module Variance : sig val get_lower : t -> bool * bool * bool * bool (* pos, neg, inv, inj *) end +module Separability : sig + (** see {!Typedecl_separability} for an explanation of separability + and separability modes.*) + + type t = Ind | Sep | Deepsep + val eq : t -> t -> bool + val print : Format.formatter -> t -> unit + + val rank : t -> int + (** Modes are ordered from the least to the most demanding: + Ind < Sep < Deepsep. + 'rank' maps them to integers in an order-respecting way: + m1 < m2 <=> rank m1 < rank m2 *) + + val compare : t -> t -> int + (** Compare two mode according to their mode ordering. *) + + val max : t -> t -> t + (** [max_mode m1 m2] returns the most demanding mode. It is used to + express the conjunction of two parameter mode constraints. *) + + type signature = t list + (** The 'separability signature' of a type assigns a mode for + each of its parameters. [('a, 'b) t] has mode [(m1, m2)] if + [(t1, t2) t] is separable whenever [t1, t2] have mode [m1, m2]. *) + + val print_signature : Format.formatter -> signature -> unit + + val default_signature : arity:int -> signature + (** The most pessimistic separability for a completely unknown type. *) +end + (* Type definitions *) type type_declaration = @@ -295,12 +345,14 @@ type type_declaration = type_manifest: type_expr option; type_variance: Variance.t list; (* covariant, contravariant, weakly contravariant, injective *) + type_separability: Separability.t list; type_is_newtype: bool; type_expansion_scope: int; type_loc: Location.t; type_attributes: Parsetree.attributes; type_immediate: Type_immediacy.t; type_unboxed: unboxed_status; + type_uid: Uid.t; } and type_kind = @@ -323,6 +375,7 @@ and label_declaration = ld_type: type_expr; ld_loc: Location.t; ld_attributes: Parsetree.attributes; + ld_uid: Uid.t; } and constructor_declaration = @@ -332,6 +385,7 @@ and constructor_declaration = cd_res: type_expr option; cd_loc: Location.t; cd_attributes: Parsetree.attributes; + cd_uid: Uid.t; } and constructor_arguments = @@ -353,15 +407,16 @@ val unboxed_true_default_false : unboxed_status val unboxed_true_default_true : unboxed_status type extension_constructor = - { - ext_type_path: Path.t; - ext_type_params: type_expr list; - ext_args: constructor_arguments; - ext_ret_type: type_expr option; - ext_private: private_flag; - ext_loc: Location.t; - ext_attributes: Parsetree.attributes; - } + { + ext_type_path: Path.t; + ext_type_params: type_expr list; + ext_args: constructor_arguments; + ext_ret_type: type_expr option; + ext_private: private_flag; + ext_loc: Location.t; + ext_attributes: Parsetree.attributes; + ext_uid: Uid.t; + } and type_transparence = Type_public (* unrestricted expansion *) @@ -392,6 +447,7 @@ type class_declaration = cty_variance: Variance.t list; cty_loc: Location.t; cty_attributes: Parsetree.attributes; + cty_uid: Uid.t; } type class_type_declaration = @@ -401,6 +457,7 @@ type class_type_declaration = clty_variance: Variance.t list; clty_loc: Location.t; clty_attributes: Parsetree.attributes; + clty_uid: Uid.t; } (* Type expressions for the module language *) @@ -440,6 +497,7 @@ and module_declaration = md_type: module_type; md_attributes: Parsetree.attributes; md_loc: Location.t; + md_uid: Uid.t; } and modtype_declaration = @@ -447,6 +505,7 @@ and modtype_declaration = mtd_type: module_type option; (* None: abstract *) mtd_attributes: Parsetree.attributes; mtd_loc: Location.t; + mtd_uid: Uid.t; } and rec_status = @@ -478,6 +537,7 @@ type constructor_description = cstr_loc: Location.t; cstr_attributes: Parsetree.attributes; cstr_inlined: type_declaration option; + cstr_uid: Uid.t; } and constructor_tag = @@ -505,6 +565,7 @@ type label_description = lbl_private: private_flag; (* Read-only field? *) lbl_loc: Location.t; lbl_attributes: Parsetree.attributes; + lbl_uid: Uid.t; } (** Extracts the list of "value" identifiers bound by a signature. diff --git a/typing/untypeast.ml b/typing/untypeast.ml index e7222ad4..7106da5b 100644 --- a/typing/untypeast.ml +++ b/typing/untypeast.ml @@ -24,8 +24,7 @@ type mapper = { attribute: mapper -> T.attribute -> attribute; attributes: mapper -> T.attribute list -> attribute list; binding_op: mapper -> T.binding_op -> T.pattern -> binding_op; - case: mapper -> T.case -> case; - cases: mapper -> T.case list -> case list; + case: 'k . mapper -> 'k T.case -> case; class_declaration: mapper -> T.class_declaration -> class_declaration; class_description: mapper -> T.class_description -> class_description; class_expr: mapper -> T.class_expr -> class_expr; @@ -55,7 +54,7 @@ type mapper = { package_type: mapper -> T.package_type -> package_type; open_declaration: mapper -> T.open_declaration -> open_declaration; open_description: mapper -> T.open_description -> open_description; - pat: mapper -> T.pattern -> pattern; + pat: 'k . mapper -> 'k T.general_pattern -> pattern; row_field: mapper -> T.row_field -> row_field; object_field: mapper -> T.object_field -> object_field; signature: mapper -> T.signature -> signature; @@ -133,7 +132,7 @@ let rec extract_letop_patterns n pat = let constant = function | Const_char c -> Pconst_char c - | Const_string (s,d) -> Pconst_string (s,d) + | Const_string (s,loc,d) -> Pconst_string (s,loc,d) | Const_int i -> Pconst_integer (Int.to_string i, None) | Const_int32 i -> Pconst_integer (Int32.to_string i, Some 'l') | Const_int64 i -> Pconst_integer (Int64.to_string i, Some 'L') @@ -290,7 +289,7 @@ let extension_constructor sub ext = | Text_rebind (_p, lid) -> Pext_rebind (map_loc sub lid) ) -let pattern sub pat = +let pattern : type k . _ -> k T.general_pattern -> _ = fun sub pat -> let loc = sub.location sub pat.pat_loc in (* todo: fix attributes on extras *) let attrs = sub.attributes sub pat.pat_attributes in @@ -347,9 +346,11 @@ let pattern sub pat = Ppat_record (List.map (fun (lid, _, pat) -> map_loc sub lid, sub.pat sub pat) list, closed) | Tpat_array list -> Ppat_array (List.map (sub.pat sub) list) - | Tpat_or (p1, p2, _) -> Ppat_or (sub.pat sub p1, sub.pat sub p2) | Tpat_lazy p -> Ppat_lazy (sub.pat sub p) + | Tpat_exception p -> Ppat_exception (sub.pat sub p) + | Tpat_value p -> (sub.pat sub (p :> pattern)).ppat_desc + | Tpat_or (p1, p2, _) -> Ppat_or (sub.pat sub p1, sub.pat sub p2) in Pat.mk ~loc ~attrs desc @@ -369,9 +370,7 @@ let exp_extra sub (extra, loc, attrs) sexp = in Exp.mk ~loc ~attrs desc -let cases sub l = List.map (sub.case sub) l - -let case sub {c_lhs; c_guard; c_rhs} = +let case : type k . mapper -> k case -> _ = fun sub {c_lhs; c_guard; c_rhs} -> { pc_lhs = sub.pat sub c_lhs; pc_guard = Option.map (sub.expr sub) c_guard; @@ -404,14 +403,14 @@ let expression sub exp = 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 (sub.cases sub 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}) - (sub.cases sub cases)) + (List.map (sub.case sub) cases)) | Texp_apply (exp, list) -> Pexp_apply (sub.expr sub exp, List.fold_right (fun (label, expo) list -> @@ -420,9 +419,9 @@ let expression sub exp = | Some exp -> (label, sub.expr sub exp) :: list ) list []) | Texp_match (exp, cases, _) -> - Pexp_match (sub.expr sub exp, sub.cases sub cases) + Pexp_match (sub.expr sub exp, List.map (sub.case sub) cases) | Texp_try (exp, cases) -> - Pexp_try (sub.expr sub exp, sub.cases sub cases) + Pexp_try (sub.expr sub exp, List.map (sub.case sub) cases) | Texp_tuple list -> Pexp_tuple (List.map (sub.expr sub) list) | Texp_construct (lid, _, args) -> @@ -877,7 +876,6 @@ let default_mapper = value_binding = value_binding; constructor_declaration = constructor_declaration; label_declaration = label_declaration; - cases = cases; case = case; location = location; row_field = row_field ; diff --git a/typing/untypeast.mli b/typing/untypeast.mli index 3cb888f1..d8a01519 100644 --- a/typing/untypeast.mli +++ b/typing/untypeast.mli @@ -20,10 +20,10 @@ val lident_of_path : Path.t -> Longident.t type mapper = { attribute: mapper -> Typedtree.attribute -> attribute; attributes: mapper -> Typedtree.attribute list -> attribute list; - binding_op: mapper -> Typedtree.binding_op -> Typedtree.pattern - -> binding_op; - case: mapper -> Typedtree.case -> case; - cases: mapper -> Typedtree.case list -> case list; + binding_op: + mapper -> + Typedtree.binding_op -> Typedtree.pattern -> binding_op; + case: 'k . mapper -> 'k Typedtree.case -> case; class_declaration: mapper -> Typedtree.class_declaration -> class_declaration; class_description: mapper -> Typedtree.class_description -> class_description; class_expr: mapper -> Typedtree.class_expr -> class_expr; @@ -58,7 +58,7 @@ type mapper = { package_type: mapper -> Typedtree.package_type -> package_type; open_declaration: mapper -> Typedtree.open_declaration -> open_declaration; open_description: mapper -> Typedtree.open_description -> open_description; - pat: mapper -> Typedtree.pattern -> pattern; + pat: 'k . mapper -> 'k Typedtree.general_pattern -> pattern; row_field: mapper -> Typedtree.row_field -> row_field; object_field: mapper -> Typedtree.object_field -> object_field; signature: mapper -> Typedtree.signature -> signature; diff --git a/utils/HACKING.adoc b/utils/HACKING.adoc index 182847b5..5ae1a0f5 100644 --- a/utils/HACKING.adoc +++ b/utils/HACKING.adoc @@ -46,10 +46,5 @@ tested on a large scale: this is when tool authors may update their tools to test the new release, and if you update *after* that you risk breaking them again without them noticing. -For example, the magic numbers for 4.07 were updated in - 7c416d1c01f82122b767cd6f08ca7d0839fd15fa -and - c10b2edccc9704fd99673812f688c103e2ffcfcf - -(There are two commits as one kind of magic number was forgotten, -ideally there should be only one commit.) +For example, the magic numbers for 4.10 were updated in + 6423e5c9d11cfac1c07208aec9f761f37c1640f0 diff --git a/utils/ccomp.ml b/utils/ccomp.ml index 9eecbb2e..2de6bb16 100644 --- a/utils/ccomp.ml +++ b/utils/ccomp.ml @@ -27,8 +27,17 @@ let command cmdline = let run_command cmdline = ignore(command cmdline) -(* Build @responsefile to work around Windows limitations on - command-line length *) +(* Build @responsefile to work around OS limitations on + command-line length. + Under Windows, the max length is 8187 minus the length of the + COMSPEC variable (or 7 if it's not set). To be on the safe side, + we'll use a response file if we need to pass 4096 or more bytes of + arguments. + For Unix-like systems, the threshold is 2^16 (64 KiB), which is + within the lowest observed limits (2^17 per argument under Linux; + between 70000 and 80000 for macOS). +*) + let build_diversion lst = let (responsefile, oc) = Filename.open_temp_file "camlresp" "" in List.iter (fun f -> Printf.fprintf oc "%s\n" f) lst; @@ -40,7 +49,8 @@ let quote_files lst = let lst = List.filter (fun f -> f <> "") lst in let quoted = List.map Filename.quote lst in let s = String.concat " " quoted in - if String.length s >= 4096 && Sys.os_type = "Win32" + if String.length s >= 65536 + || (String.length s >= 4096 && Sys.os_type = "Win32") then build_diversion quoted else s @@ -89,11 +99,12 @@ let compile_file ?output ?(opt="") ?stable_name name = (match !Clflags.c_compiler with | Some cc -> cc | None -> - let (cflags, cppflags) = - if !Clflags.native_code - then (Config.ocamlopt_cflags, Config.ocamlopt_cppflags) - else (Config.ocamlc_cflags, Config.ocamlc_cppflags) in - (String.concat " " [Config.c_compiler; cflags; cppflags])) + (* #7678: ocamlopt only calls the C compiler to process .c files + from the command line, and the behaviour between + ocamlc/ocamlopt should be identical. *) + (String.concat " " [Config.c_compiler; + Config.ocamlc_cflags; + Config.ocamlc_cppflags])) debug_prefix_map (match output with | None -> "" @@ -211,5 +222,5 @@ let call_linker mode output_name files extra = (quote_files files) extra in - command cmd = 0 + command cmd ) diff --git a/utils/ccomp.mli b/utils/ccomp.mli index cf67f24e..89724252 100644 --- a/utils/ccomp.mli +++ b/utils/ccomp.mli @@ -36,4 +36,4 @@ type link_mode = | MainDll | Partial -val call_linker: link_mode -> string -> string list -> string -> bool +val call_linker: link_mode -> string -> string list -> string -> int diff --git a/utils/clflags.ml b/utils/clflags.ml index cc376147..4035c28c 100644 --- a/utils/clflags.ml +++ b/utils/clflags.ml @@ -95,7 +95,8 @@ and for_package = ref (None: string option) (* -for-pack *) and error_size = ref 500 (* -error-size *) and float_const_prop = ref true (* -no-float-const-prop *) and transparent_modules = ref false (* -trans-mod *) -let unique_ids = ref true +let unique_ids = ref true (* -d(no-)unique-ds *) +let locations = ref true (* -d(no-)locations *) let dump_source = ref false (* -dsource *) let dump_parsetree = ref false (* -dparsetree *) and dump_typedtree = ref false (* -dtypedtree *) @@ -420,34 +421,50 @@ module Compiler_pass = struct - the manpages in man/ocaml{c,opt}.m - the manual manual/manual/cmds/unified-options.etex *) - type t = Parsing | Typing + type t = Parsing | Typing | Scheduling let to_string = function | Parsing -> "parsing" | Typing -> "typing" + | Scheduling -> "scheduling" let of_string = function | "parsing" -> Some Parsing | "typing" -> Some Typing + | "scheduling" -> Some Scheduling | _ -> None let rank = function | Parsing -> 0 | Typing -> 1 + | Scheduling -> 50 let passes = [ Parsing; Typing; + Scheduling; ] - let pass_names = List.map to_string passes + let is_compilation_pass _ = true + let is_native_only = function + | Scheduling -> true + | _ -> false + + let enabled is_native t = not (is_native_only t) || is_native + + let available_pass_names ~native = + passes + |> List.filter (enabled native) + |> List.map to_string end let stop_after = ref None (* -stop-after *) let should_stop_after pass = - match !stop_after with - | None -> false - | Some stop -> Compiler_pass.rank stop <= Compiler_pass.rank pass + if Compiler_pass.(rank Typing <= rank pass) && !print_types then true + else + match !stop_after with + | None -> false + | Some stop -> Compiler_pass.rank stop <= Compiler_pass.rank pass module String = Misc.Stdlib.String diff --git a/utils/clflags.mli b/utils/clflags.mli index 1743fc1c..5be371a0 100644 --- a/utils/clflags.mli +++ b/utils/clflags.mli @@ -123,6 +123,7 @@ val error_size : int ref val float_const_prop : bool ref val transparent_modules : bool ref val unique_ids : bool ref +val locations : bool ref val dump_source : bool ref val dump_parsetree : bool ref val dump_typedtree : bool ref @@ -235,11 +236,11 @@ val insn_sched : bool ref val insn_sched_default : bool module Compiler_pass : sig - type t = Parsing | Typing + type t = Parsing | Typing | Scheduling val of_string : string -> t option val to_string : t -> string - val passes : t list - val pass_names : string list + val is_compilation_pass : t -> bool + val available_pass_names : native:bool -> string list end val stop_after : Compiler_pass.t option ref val should_stop_after : Compiler_pass.t -> bool diff --git a/utils/config.mli b/utils/config.mli index 560283f2..515a428d 100644 --- a/utils/config.mli +++ b/utils/config.mli @@ -51,10 +51,14 @@ val ocamlc_cppflags : string (** The flags ocamlc should pass to the C preprocessor *) val ocamlopt_cflags : string -(** The flags ocamlopt should pass to the C compiler *) + [@@ocaml.deprecated "Use ocamlc_cflags instead."] +(** @deprecated {!ocamlc_cflags} should be used instead. + The flags ocamlopt should pass to the C compiler *) val ocamlopt_cppflags : string -(** The flags ocamlopt should pass to the C preprocessor *) + [@@ocaml.deprecated "Use ocamlc_cppflags instead."] +(** @deprecated {!ocamlc_cppflags} should be used instead. + The flags ocamlopt should pass to the C preprocessor *) val bytecomp_c_libraries: string (** The C libraries to link with custom runtimes *) diff --git a/utils/config.mlp b/utils/config.mlp index 4a3bea23..49ffc5bd 100644 --- a/utils/config.mlp +++ b/utils/config.mlp @@ -35,7 +35,9 @@ let c_has_debug_prefix_map = %%CC_HAS_DEBUG_PREFIX_MAP%% let as_has_debug_prefix_map = %%AS_HAS_DEBUG_PREFIX_MAP%% let ocamlc_cflags = "%%OCAMLC_CFLAGS%%" let ocamlc_cppflags = "%%OCAMLC_CPPFLAGS%%" -let ocamlopt_cflags = "%%OCAMLOPT_CFLAGS%%" +(* #7678: ocamlopt uses these only to compile .c files, and the behaviour for + the two drivers should be identical. *) +let ocamlopt_cflags = "%%OCAMLC_CFLAGS%%" let ocamlopt_cppflags = "%%OCAMLOPT_CPPFLAGS%%" let bytecomp_c_libraries = "%%BYTECCLIBS%%" (* bytecomp_c_compiler and native_c_compiler have been supported for a @@ -83,25 +85,25 @@ let flat_float_array = %%FLAT_FLOAT_ARRAY%% let function_sections = %%FUNCTION_SECTIONS%% let afl_instrument = %%AFL_INSTRUMENT%% -let exec_magic_number = "Caml1999X027" +let exec_magic_number = "Caml1999X028" (* exec_magic_number is duplicated in runtime/caml/exec.h *) -and cmi_magic_number = "Caml1999I027" -and cmo_magic_number = "Caml1999O027" -and cma_magic_number = "Caml1999A027" +and cmi_magic_number = "Caml1999I028" +and cmo_magic_number = "Caml1999O028" +and cma_magic_number = "Caml1999A028" and cmx_magic_number = if flambda then - "Caml1999y027" + "Caml1999y028" else - "Caml1999Y027" + "Caml1999Y028" and cmxa_magic_number = if flambda then - "Caml1999z027" + "Caml1999z028" else - "Caml1999Z027" -and ast_impl_magic_number = "Caml1999M027" -and ast_intf_magic_number = "Caml1999N027" -and cmxs_magic_number = "Caml1999D027" -and cmt_magic_number = "Caml1999T027" + "Caml1999Z028" +and ast_impl_magic_number = "Caml1999M028" +and ast_intf_magic_number = "Caml1999N028" +and cmxs_magic_number = "Caml1999D028" +and cmt_magic_number = "Caml1999T028" let interface_suffix = ref ".mli" diff --git a/utils/consistbl.ml b/utils/consistbl.ml index 24fde86f..b3299114 100644 --- a/utils/consistbl.ml +++ b/utils/consistbl.ml @@ -30,21 +30,29 @@ end) = struct let clear = Module_name.Tbl.clear - exception Inconsistency of Module_name.t * filepath * filepath + exception Inconsistency of { + unit_name : Module_name.t; + inconsistent_source : string; + original_source : string; + } exception Not_available of Module_name.t + let check_ tbl name crc source = + let (old_crc, old_source) = Module_name.Tbl.find tbl name in + if crc <> old_crc then raise(Inconsistency { + unit_name = name; + inconsistent_source = source; + original_source = old_source; + }) + let check tbl name crc source = - try - let (old_crc, old_source) = Module_name.Tbl.find tbl name in - if crc <> old_crc then raise(Inconsistency(name, source, old_source)) + try check_ tbl name crc source with Not_found -> Module_name.Tbl.add tbl name (crc, source) let check_noadd tbl name crc source = - try - let (old_crc, old_source) = Module_name.Tbl.find tbl name in - if crc <> old_crc then raise(Inconsistency(name, source, old_source)) + try check_ tbl name crc source with Not_found -> raise (Not_available name) diff --git a/utils/consistbl.mli b/utils/consistbl.mli index 5c8c5428..5067addf 100644 --- a/utils/consistbl.mli +++ b/utils/consistbl.mli @@ -69,11 +69,12 @@ end) : sig (* [filter pred tbl] removes from [tbl] table all (name, CRC) pairs such that [pred name] is [false]. *) - exception Inconsistency of Module_name.t * filepath * filepath - (* Raised by [check] when a CRC mismatch is detected. - First string is the name of the compilation unit. - Second string is the source that caused the inconsistency. - Third string is the source that set the CRC. *) + exception Inconsistency of { + unit_name : Module_name.t; + inconsistent_source : string; + original_source : string; + } + (* Raised by [check] when a CRC mismatch is detected. *) exception Not_available of Module_name.t (* Raised by [check_noadd] when a name doesn't have an associated diff --git a/utils/identifiable.ml b/utils/identifiable.ml index e82390ad..9bbfb657 100644 --- a/utils/identifiable.ml +++ b/utils/identifiable.ml @@ -43,7 +43,6 @@ module type Map = sig with type key = T.t and type 'a t = 'a Map.Make (T).t - val filter_map : 'a t -> f:(key -> 'a -> 'b option) -> 'b t val of_list : (key * 'a) list -> 'a t val disjoint_union : @@ -102,12 +101,6 @@ end module Make_map (T : Thing) = struct include Map.Make (T) - let filter_map t ~f = - fold (fun id v map -> - match f id v with - | None -> map - | Some r -> add id r map) t empty - let of_list l = List.fold_left (fun map (id, v) -> add id v map) empty l diff --git a/utils/identifiable.mli b/utils/identifiable.mli index 4e260711..0da5a661 100644 --- a/utils/identifiable.mli +++ b/utils/identifiable.mli @@ -52,7 +52,6 @@ module type Map = sig with type key = T.t and type 'a t = 'a Map.Make (T).t - val filter_map : 'a t -> f:(key -> 'a -> 'b option) -> 'b t val of_list : (key * 'a) list -> 'a t (** [disjoint_union m1 m2] contains all bindings from [m1] and diff --git a/utils/misc.ml b/utils/misc.ml index f42b7935..df2e74d0 100644 --- a/utils/misc.ml +++ b/utils/misc.ml @@ -56,9 +56,7 @@ let protect_refs = fun refs f -> let backup = List.map (fun (R (r, _)) -> R (r, !r)) refs in set_refs refs; - match f () with - | x -> set_refs backup; x - | exception e -> set_refs backup; raise e + Fun.protect ~finally:(fun () -> set_refs backup) f (* List functions *) @@ -695,8 +693,6 @@ module Color = struct } in pp_set_mark_tags ppf true; (* enable tags *) pp_set_formatter_stag_functions ppf functions'; - (* also setup margins *) - pp_set_margin ppf (pp_get_margin std_formatter()); () external isatty : out_channel -> bool = "caml_sys_isatty" @@ -939,3 +935,256 @@ module EnvLazy = struct loop !log end + + +module Magic_number = struct + type native_obj_config = { + flambda : bool; + } + let native_obj_config = { + flambda = Config.flambda; + } + + type version = int + + type kind = + | Exec + | Cmi | Cmo | Cma + | Cmx of native_obj_config | Cmxa of native_obj_config + | Cmxs + | Cmt + | Ast_impl | Ast_intf + + (* please keep up-to-date, this is used for sanity checking *) + let all_native_obj_configs = [ + {flambda = true}; + {flambda = false}; + ] + let all_kinds = [ + Exec; + Cmi; Cmo; Cma; + ] + @ List.map (fun conf -> Cmx conf) all_native_obj_configs + @ List.map (fun conf -> Cmxa conf) all_native_obj_configs + @ [ + Cmt; + Ast_impl; Ast_intf; + ] + + type raw = string + type info = { + kind: kind; + version: version; + } + + type raw_kind = string + + let parse_kind : raw_kind -> kind option = function + | "Caml1999X" -> Some Exec + | "Caml1999I" -> Some Cmi + | "Caml1999O" -> Some Cmo + | "Caml1999A" -> Some Cma + | "Caml1999y" -> Some (Cmx {flambda = true}) + | "Caml1999Y" -> Some (Cmx {flambda = false}) + | "Caml1999z" -> Some (Cmxa {flambda = true}) + | "Caml1999Z" -> Some (Cmxa {flambda = false}) + + (* Caml2007D and Caml2012T were used instead of the common Caml1999 prefix + between the introduction of those magic numbers and October 2017 + (8ba70ff194b66c0a50ffb97d41fe9c4bdf9362d6). + + We accept them here, but will always produce/show kind prefixes + that follow the current convention, Caml1999{D,T}. *) + | "Caml2007D" | "Caml1999D" -> Some Cmxs + | "Caml2012T" | "Caml1999T" -> Some Cmt + + | "Caml1999M" -> Some Ast_impl + | "Caml1999N" -> Some Ast_intf + | _ -> None + + (* note: over time the magic kind number has changed for certain kinds; + this function returns them as they are produced by the current compiler, + but [parse_kind] accepts older formats as well. *) + let raw_kind : kind -> raw = function + | Exec -> "Caml1999X" + | Cmi -> "Caml1999I" + | Cmo -> "Caml1999O" + | Cma -> "Caml1999A" + | Cmx config -> + if config.flambda + then "Caml1999y" + else "Caml1999Y" + | Cmxa config -> + if config.flambda + then "Caml1999z" + else "Caml1999Z" + | Cmxs -> "Caml1999D" + | Cmt -> "Caml1999T" + | Ast_impl -> "Caml1999M" + | Ast_intf -> "Caml1999N" + + let string_of_kind : kind -> string = function + | Exec -> "exec" + | Cmi -> "cmi" + | Cmo -> "cmo" + | Cma -> "cma" + | Cmx _ -> "cmx" + | Cmxa _ -> "cmxa" + | Cmxs -> "cmxs" + | Cmt -> "cmt" + | Ast_impl -> "ast_impl" + | Ast_intf -> "ast_intf" + + let human_description_of_native_obj_config : native_obj_config -> string = + fun[@warning "+9"] {flambda} -> + if flambda then "flambda" else "non flambda" + + let human_name_of_kind : kind -> string = function + | Exec -> "executable" + | Cmi -> "compiled interface file" + | Cmo -> "bytecode object file" + | Cma -> "bytecode library" + | Cmx config -> + Printf.sprintf "native compilation unit description (%s)" + (human_description_of_native_obj_config config) + | Cmxa config -> + Printf.sprintf "static native library (%s)" + (human_description_of_native_obj_config config) + | Cmxs -> "dynamic native library" + | Cmt -> "compiled typedtree file" + | Ast_impl -> "serialized implementation AST" + | Ast_intf -> "serialized interface AST" + + let kind_length = 9 + let version_length = 3 + let magic_length = + kind_length + version_length + + type parse_error = + | Truncated of string + | Not_a_magic_number of string + + let explain_parse_error kind_opt error = + Printf.sprintf + "We expected a valid %s, but the file %s." + (Option.fold ~none:"object file" ~some:human_name_of_kind kind_opt) + (match error with + | Truncated "" -> "is empty" + | Truncated _ -> "is truncated" + | Not_a_magic_number _ -> "has a different format") + + let parse s : (info, parse_error) result = + if String.length s = magic_length then begin + let raw_kind = String.sub s 0 kind_length in + let raw_version = String.sub s kind_length version_length in + match parse_kind raw_kind with + | None -> Error (Not_a_magic_number s) + | Some kind -> + begin match int_of_string raw_version with + | exception _ -> Error (Truncated s) + | version -> Ok { kind; version } + end + end + else begin + (* a header is "truncated" if it starts like a valid magic number, + that is if its longest segment of length at most [kind_length] + is a prefix of [raw_kind kind] for some kind [kind] *) + let sub_length = min kind_length (String.length s) in + let starts_as kind = + String.sub s 0 sub_length = String.sub (raw_kind kind) 0 sub_length + in + if List.exists starts_as all_kinds then Error (Truncated s) + else Error (Not_a_magic_number s) + end + + let read_info ic = + let header = Buffer.create magic_length in + begin + try Buffer.add_channel header ic magic_length + with End_of_file -> () + end; + parse (Buffer.contents header) + + let raw { kind; version; } = + Printf.sprintf "%s%03d" (raw_kind kind) version + + let current_raw kind = + let open Config in + match[@warning "+9"] kind with + | Exec -> exec_magic_number + | Cmi -> cmi_magic_number + | Cmo -> cmo_magic_number + | Cma -> cma_magic_number + | Cmx config -> + (* the 'if' guarantees that in the common case + we return the "trusted" value from Config. *) + let reference = cmx_magic_number in + if config = native_obj_config then reference + else + (* otherwise we stitch together the magic number + for a different configuration by concatenating + the right magic kind at this configuration + and the rest of the current raw number for our configuration. *) + let raw_kind = raw_kind kind in + let len = String.length raw_kind in + raw_kind ^ String.sub reference len (String.length reference - len) + | Cmxa config -> + let reference = cmxa_magic_number in + if config = native_obj_config then reference + else + let raw_kind = raw_kind kind in + let len = String.length raw_kind in + raw_kind ^ String.sub reference len (String.length reference - len) + | Cmxs -> cmxs_magic_number + | Cmt -> cmt_magic_number + | Ast_intf -> ast_intf_magic_number + | Ast_impl -> ast_impl_magic_number + + (* it would seem more direct to define current_version with the + correct numbers and current_raw on top of it, but for now we + consider the Config.foo values to be ground truth, and don't want + to trust the present module instead. *) + let current_version kind = + let raw = current_raw kind in + try int_of_string (String.sub raw kind_length version_length) + with _ -> assert false + + type 'a unexpected = { expected : 'a; actual : 'a } + type unexpected_error = + | Kind of kind unexpected + | Version of kind * version unexpected + + let explain_unexpected_error = function + | Kind { actual; expected } -> + Printf.sprintf "We expected a %s (%s) but got a %s (%s) instead." + (human_name_of_kind expected) (string_of_kind expected) + (human_name_of_kind actual) (string_of_kind actual) + | Version (kind, { actual; expected }) -> + Printf.sprintf "This seems to be a %s (%s) for %s version of OCaml." + (human_name_of_kind kind) (string_of_kind kind) + (if actual < expected then "an older" else "a newer") + + let check_current expected_kind { kind; version } : _ result = + if kind <> expected_kind then begin + let actual, expected = kind, expected_kind in + Error (Kind { actual; expected }) + end else begin + let actual, expected = version, current_version kind in + if actual <> expected + then Error (Version (kind, { actual; expected })) + else Ok () + end + + type error = + | Parse_error of parse_error + | Unexpected_error of unexpected_error + + let read_current_info ~expected_kind ic = + match read_info ic with + | Error err -> Error (Parse_error err) + | Ok info -> + let kind = Option.value ~default:info.kind expected_kind in + match check_current kind info with + | Error err -> Error (Unexpected_error err) + | Ok () -> Ok info +end diff --git a/utils/misc.mli b/utils/misc.mli index 1e24039a..9af10596 100644 --- a/utils/misc.mli +++ b/utils/misc.mli @@ -82,7 +82,8 @@ type ref_and_value = R : 'a ref * 'a -> ref_and_value val protect_refs : ref_and_value list -> (unit -> 'a) -> 'a (** [protect_refs l f] temporarily sets [r] to [v] for each [R (r, v)] in [l] while executing [f]. The previous contents of the references is restored - even if [f] raises an exception. *) + even if [f] raises an exception, without altering the exception backtrace. +*) module Stdlib : sig module List : sig @@ -485,3 +486,203 @@ module EnvLazy: sig val backtrack : log -> unit end + + +module Magic_number : sig + (** a typical magic number is "Caml1999I011"; it is formed of an + alphanumeric prefix, here Caml1990I, followed by a version, + here 011. The prefix identifies the kind of the versioned data: + here the I indicates that it is the magic number for .cmi files. + + All magic numbers have the same byte length, [magic_length], and + this is important for users as it gives them the number of bytes + to read to obtain the byte sequence that should be a magic + number. Typical user code will look like: + {[ + let ic = open_in_bin path in + let magic = + try really_input_string ic Magic_number.magic_length + with End_of_file -> ... in + match Magic_number.parse magic with + | Error parse_error -> ... + | Ok info -> ... + ]} + + A given compiler version expects one specific version for each + kind of object file, and will fail if given an unsupported + version. Because versions grow monotonically, you can compare + the parsed version with the expected "current version" for + a kind, to tell whether the wrong-magic object file comes from + the past or from the future. + + An example of code block that expects the "currently supported version" + of a given kind of magic numbers, here [Cmxa], is as follows: + {[ + let ic = open_in_bin path in + begin + try Magic_number.(expect_current Cmxa (get_info ic)) with + | Parse_error error -> ... + | Unexpected error -> ... + end; + ... + ]} + + Parse errors distinguish inputs that are [Not_a_magic_number str], + which are likely to come from the file being completely + different, and [Truncated str], raised by headers that are the + (possibly empty) prefix of a valid magic number. + + Unexpected errors correspond to valid magic numbers that are not + the one expected, either because it corresponds to a different + kind, or to a newer or older version. + + The helper functions [explain_parse_error] and [explain_unexpected_error] + will generate a textual explanation of each error, + for use in error messages. + + @since 4.11.0 + *) + + type native_obj_config = { + flambda : bool; + } + (** native object files have a format and magic number that depend + on certain native-compiler configuration parameters. This + configuration space is expressed by the [native_obj_config] + type. *) + + val native_obj_config : native_obj_config + (** the native object file configuration of the active/configured compiler. *) + + type version = int + + type kind = + | Exec + | Cmi | Cmo | Cma + | Cmx of native_obj_config | Cmxa of native_obj_config + | Cmxs + | Cmt | Ast_impl | Ast_intf + + type info = { + kind: kind; + version: version; + (** Note: some versions of the compiler use the same [version] suffix + for all kinds, but others use different versions counters for different + kinds. We may only assume that versions are growing monotonically + (not necessarily always by one) between compiler versions. *) + } + + type raw = string + (** the type of raw magic numbers, + such as "Caml1999A027" for the .cma files of OCaml 4.10 *) + + (** {3 Parsing magic numbers} *) + + type parse_error = + | Truncated of string + | Not_a_magic_number of string + + val explain_parse_error : kind option -> parse_error -> string + (** Produces an explanation for a parse error. If no kind is provided, + we use an unspecific formulation suggesting that any compiler-produced + object file would have been satisfying. *) + + val parse : raw -> (info, parse_error) result + (** Parses a raw magic number *) + + val read_info : in_channel -> (info, parse_error) result + (** Read a raw magic number from an input channel. + + If the data read [str] is not a valid magic number, it can be + recovered from the [Truncated str | Not_a_magic_number str] + payload of the [Error parse_error] case. + + If parsing succeeds with an [Ok info] result, we know that + exactly [magic_length] bytes have been consumed from the + input_channel. + + If you also wish to enforce that the magic number + is at the current version, see {!read_current_info} below. + *) + + val magic_length : int + (** all magic numbers take the same number of bytes *) + + + (** {3 Checking that magic numbers are current} *) + + type 'a unexpected = { expected : 'a; actual : 'a } + type unexpected_error = + | Kind of kind unexpected + | Version of kind * version unexpected + + val check_current : kind -> info -> (unit, unexpected_error) result + (** [check_current kind info] checks that the provided magic [info] + is the current version of [kind]'s magic header. *) + + val explain_unexpected_error : unexpected_error -> string + (** Provides an explanation of the [unexpected_error]. *) + + type error = + | Parse_error of parse_error + | Unexpected_error of unexpected_error + + val read_current_info : + expected_kind:kind option -> in_channel -> (info, error) result + (** Read a magic number as [read_info], + and check that it is the current version as its kind. + If the [expected_kind] argument is [None], any kind is accepted. *) + + + (** {3 Information on magic numbers} *) + + val string_of_kind : kind -> string + (** a user-printable string for a kind, eg. "exec" or "cmo", to use + in error messages. *) + + val human_name_of_kind : kind -> string + (** a user-meaningful name for a kind, eg. "executable file" or + "bytecode object file", to use in error messages. *) + + val current_raw : kind -> raw + (** the current magic number of each kind *) + + val current_version : kind -> version + (** the current version of each kind *) + + + (** {3 Raw representations} + + Mainly for internal usage and testing. *) + + type raw_kind = string + (** the type of raw magic numbers kinds, + such as "Caml1999A" for .cma files *) + + val parse_kind : raw_kind -> kind option + (** parse a raw kind into a kind *) + + val raw_kind : kind -> raw_kind + (** the current raw representation of a kind. + + In some cases the raw representation of a kind has changed + over compiler versions, so other files of the same kind + may have different raw kinds. + Note that all currently known cases are parsed correctly by [parse_kind]. + *) + + val raw : info -> raw + (** A valid raw representation of the magic number. + + Due to past and future changes in the string representation of + magic numbers, we cannot guarantee that the raw strings returned + for past and future versions actually match the expectations of + those compilers. The representation is accurate for current + versions, and it is correctly parsed back into the desired + version by the parsing functions above. + *) + + (**/**) + + val all_kinds : kind list +end diff --git a/utils/numbers.ml b/utils/numbers.ml index 18006a5b..1680675b 100644 --- a/utils/numbers.ml +++ b/utils/numbers.ml @@ -31,6 +31,8 @@ module Int = struct let rec zero_to_n n = if n < 0 then Set.empty else Set.add n (zero_to_n (n-1)) + + let to_string n = Int.to_string n end module Int8 = struct diff --git a/utils/numbers.mli b/utils/numbers.mli index f9c49ef6..fa565e67 100644 --- a/utils/numbers.mli +++ b/utils/numbers.mli @@ -26,6 +26,7 @@ module Int : sig (** [zero_to_n n] is the set of numbers \{0, ..., n\} (inclusive). *) val zero_to_n : int -> Set.t + val to_string : int -> string end module Int8 : sig diff --git a/utils/warnings.ml b/utils/warnings.ml index 9c834854..7adb3495 100644 --- a/utils/warnings.ml +++ b/utils/warnings.ml @@ -700,7 +700,7 @@ let descriptions = [ 1, "Suspicious-looking start-of-comment mark."; 2, "Suspicious-looking end-of-comment mark."; - 3, "Deprecated synonym for the 'deprecated' alert"; + 3, "Deprecated synonym for the 'deprecated' alert."; 4, "Fragile pattern matching: matching that will remain complete even\n\ \ if additional constructors are added to one of the variant types\n\ \ matched."; @@ -761,20 +761,21 @@ let descriptions = 50, "Unexpected documentation comment."; 51, "Warning on non-tail calls if @tailcall present."; 52, "Fragile constant pattern."; - 53, "Attribute cannot appear in this context"; - 54, "Attribute used more than once on an expression"; - 55, "Inlining impossible"; + 53, "Attribute cannot appear in this context."; + 54, "Attribute used more than once on an expression."; + 55, "Inlining impossible."; 56, "Unreachable case in a pattern-matching (based on type information)."; - 57, "Ambiguous or-pattern variables under guard"; - 58, "Missing cmx file"; - 59, "Assignment to non-mutable value"; - 60, "Unused module declaration"; - 61, "Unboxable type in primitive declaration"; - 62, "Type constraint on GADT type declaration"; - 63, "Erroneous printed signature"; - 64, "-unsafe used with a preprocessor returning a syntax tree"; - 65, "Type declaration defining a new '()' constructor"; - 66, "Unused open! statement"; + 57, "Ambiguous or-pattern variables under guard."; + 58, "Missing cmx file."; + 59, "Assignment to non-mutable value."; + 60, "Unused module declaration."; + 61, "Unboxable type in primitive declaration."; + 62, "Type constraint on GADT type declaration."; + 63, "Erroneous printed signature."; + 64, "-unsafe used with a preprocessor returning a syntax tree."; + 65, "Type declaration defining a new '()' constructor."; + 66, "Unused open! statement."; + 67, "Unused functor parameter."; ] ;; diff --git a/yacc/Makefile b/yacc/Makefile index bbd8dcc4..82b91980 100644 --- a/yacc/Makefile +++ b/yacc/Makefile @@ -17,8 +17,8 @@ ROOTDIR = .. -include $(ROOTDIR)/Makefile.config -include $(ROOTDIR)/Makefile.common +-include $(ROOTDIR)/Makefile.config +-include $(ROOTDIR)/Makefile.common OC_CPPFLAGS += -I$(ROOTDIR)/runtime @@ -45,7 +45,8 @@ version.h : $(ROOTDIR)/VERSION echo "#define OCAML_VERSION \"`sed -e 1q $< | tr -d '\r'`\"" > $@ clean: - rm -f $(generated_files) + rm -f ocamlyacc ocamlyacc.exe wstr.o wstr.obj version.h \ + $(ocamlyacc_SOURCES:.c=.o) $(ocamlyacc_SOURCES:.c=.obj) depend: diff --git a/yacc/defs.h b/yacc/defs.h index 91aadc3e..1fd3dc68 100644 --- a/yacc/defs.h +++ b/yacc/defs.h @@ -145,10 +145,16 @@ struct bucket short prec; char class; char assoc; - char entry; + unsigned char entry; /* 1..MAX_ENTRY_POINT (0 for unassigned) */ char true_token; }; +/* MAX_ENTRY_POINT is the maximal number of entry points into the grammar. */ +/* Entry points are identified by a non-zero byte in the input stream, */ +/* so there are at most 255 entry points. */ + +#define MAX_ENTRY_POINT MAXCHAR + /* TABLE_SIZE is the number of entries in the symbol table. */ /* TABLE_SIZE must be a power of two. */ diff --git a/yacc/error.c b/yacc/error.c index b2750c97..a47bed9f 100644 --- a/yacc/error.c +++ b/yacc/error.c @@ -177,8 +177,8 @@ token\n", virtual_input_file_name, lineno, s); void too_many_entries(void) { - fprintf(stderr, "File \"%s\", line %d: more than 256 entry points\n", - virtual_input_file_name, lineno); + fprintf(stderr, "File \"%s\", line %d: more than %u entry points\n", + virtual_input_file_name, lineno, MAX_ENTRY_POINT); done(1); } diff --git a/yacc/reader.c b/yacc/reader.c index 1b0a5f6b..73779679 100644 --- a/yacc/reader.c +++ b/yacc/reader.c @@ -261,9 +261,30 @@ void process_apostrophe_body(FILE *f) static void process_open_curly_bracket(FILE *f) { - if (In_bitmap(caml_ident_start, *cptr) || *cptr == '|') + char *idcptr = cptr; + + if (*idcptr == '%') { + if (*++idcptr == '%') idcptr++; + + if (In_bitmap(caml_ident_start, *idcptr)) { + idcptr++; + while (In_bitmap(caml_ident_body, *idcptr)) idcptr++; + while (*idcptr == '.') { + idcptr++; + if (In_bitmap(caml_ident_start, *idcptr)) { + idcptr++; + while (In_bitmap(caml_ident_body, *idcptr)) idcptr++; + } + } + while (*idcptr == ' ' || *idcptr == 9 || *idcptr == 12) idcptr++; + } else { + return; + } + } + + if (In_bitmap(caml_ident_start, *idcptr) || *idcptr == '|') { - char *newcptr = cptr; + char *newcptr = idcptr; size_t size = 0; char *buf; while(In_bitmap(caml_ident_body, *newcptr)) { newcptr++; } @@ -273,13 +294,13 @@ static void process_open_curly_bracket(FILE *f) { char *s_line; char *s_cptr; - size = newcptr - cptr; + size = newcptr - idcptr; buf = MALLOC(size + 2); if (!buf) no_space(); - memcpy(buf, cptr, size); + memcpy(buf, idcptr, size); buf[size] = '}'; buf[size + 1] = '\0'; - fwrite(cptr, 1, size + 1, f); + fwrite(cptr, 1, newcptr - cptr + 1, f); cptr = newcptr + 1; s_lineno = lineno; s_line = dup_line(); @@ -369,7 +390,7 @@ static void process_comment(FILE *const f) { continue; default: if (In_bitmap(caml_ident_start, c)) { - while (In_bitmap(caml_ident_body, *cptr)) cptr++; + while (In_bitmap(caml_ident_body, *cptr)) putc(*cptr++, f); } continue; } @@ -978,9 +999,9 @@ void declare_start(void) if (bp->class == TERM) terminal_start(bp->name); - bp->entry = ++entry_counter; - if (entry_counter == 256) + if (entry_counter >= MAX_ENTRY_POINT) too_many_entries(); + bp->entry = ++entry_counter; } } @@ -1699,7 +1720,7 @@ void make_goal(void) if (is_polymorphic(bp->tag)) polymorphic_entry_point(bp->name); fprintf(entry_file, - "let %s (lexfun : Lexing.lexbuf -> token) (lexbuf : Lexing.lexbuf) =\n (Parsing.yyparse yytables %d lexfun lexbuf : %s)\n", + "let %s (lexfun : Lexing.lexbuf -> token) (lexbuf : Lexing.lexbuf) =\n (Parsing.yyparse yytables %u lexfun lexbuf : %s)\n", bp->name, bp->entry, bp->tag); fprintf(interface_file, "val %s :\n (Lexing.lexbuf -> token) -> Lexing.lexbuf -> %s\n",