From c05307b6107ba633a8ac724a5f68cc55a172a8b4 Mon Sep 17 00:00:00 2001 From: Stephane Glondu Date: Tue, 5 Jul 2011 21:28:06 +0200 Subject: [PATCH] Imported Upstream version 3.12.1 --- Changes | 3 +- README.win32 | 12 +- VERSION | 4 +- boot/ocamlc | Bin 1099377 -> 1099386 bytes boot/ocamldep | Bin 307777 -> 307754 bytes boot/ocamllex | Bin 169676 -> 169666 bytes camlp4/test/fixtures/assert.ml | 3 + .../fixtures/backquoted_irrefutable_tuple.ml | 3 + camlp4/test/fixtures/backquoted_record.ml | 4 + camlp4/test/fixtures/backquoted_tuple.ml | 3 + camlp4/test/fixtures/big-tab1.ml | 704 + camlp4/test/fixtures/big-tab2.ml | 18282 ++++++++++++++ camlp4/test/fixtures/big-tab3.ml | 20001 ++++++++++++++++ camlp4/test/fixtures/bug-4058.ml | 4 + camlp4/test/fixtures/bug-4337.ml | 1 + camlp4/test/fixtures/bug-by-vincent-balat.ml | 1 + .../fixtures/bug-camlp4o-benjamin-monate.ml | 15 + .../fixtures/bug-camlp4o-constr-arity-expr.ml | 8 + .../test/fixtures/bug-camlp4o-constr-arity.ml | 75 + camlp4/test/fixtures/bug_escaping_quot.ml | 7 + camlp4/test/fixtures/chars.ml | 1 + camlp4/test/fixtures/class_expr_quot.ml | 27 + camlp4/test/fixtures/comments.ml | 66 + camlp4/test/fixtures/comments.mli | 106 + camlp4/test/fixtures/comments2.ml | 70 + camlp4/test/fixtures/constant-parser.ml | 90 + camlp4/test/fixtures/curry-constr.ml | 3 + camlp4/test/fixtures/default_quotation.ml | 4 + .../test/fixtures/exception-with-eqn-bug.ml | 1 + camlp4/test/fixtures/external.ml | 1 + camlp4/test/fixtures/fun.ml | 7 + camlp4/test/fixtures/functor-perf.ml | 2019 ++ camlp4/test/fixtures/functor-perf2.gen.ml | 3029 +++ camlp4/test/fixtures/functor-perf2.ml | 29 + camlp4/test/fixtures/functor-perf3.ml | 50 + camlp4/test/fixtures/gen_map.ml | 8 + camlp4/test/fixtures/gram-fold.ml | 21 + camlp4/test/fixtures/gram-list.ml | 13 + camlp4/test/fixtures/gram-loc-lost.ml | 30 + camlp4/test/fixtures/gram-sub-rule.ml | 33 + camlp4/test/fixtures/gram-tree.ml | 22 + camlp4/test/fixtures/gram-tree2.ml | 22 + camlp4/test/fixtures/gram-tree3.ml | 23 + camlp4/test/fixtures/gram.ml | 2 + camlp4/test/fixtures/idents | 38 + camlp4/test/fixtures/idents1 | 499 + camlp4/test/fixtures/idents2 | 1219 + camlp4/test/fixtures/if.ml | 8 + camlp4/test/fixtures/label.ml | 1 + camlp4/test/fixtures/lambda_free.ml | 68 + camlp4/test/fixtures/loc-bug.ml | 3 + camlp4/test/fixtures/macrotest.ml | 70 + camlp4/test/fixtures/macrotest.mli | 25 + camlp4/test/fixtures/macrotest2.ml | 6 + camlp4/test/fixtures/macrotest3.ml | 11 + camlp4/test/fixtures/make_extend.ml | 1 + camlp4/test/fixtures/match.ml | 9 + camlp4/test/fixtures/match_parser.ml | 10 + camlp4/test/fixtures/meta_multi_term.ml | 16 + camlp4/test/fixtures/metalib.ml | 5 + .../test/fixtures/method_private_virtual.ml | 9 + camlp4/test/fixtures/mod.ml | 15 + camlp4/test/fixtures/mod2.ml | 8 + camlp4/test/fixtures/operators.ml | 7 + camlp4/test/fixtures/operators.mli | 1 + camlp4/test/fixtures/original_syntax.ml | 17 + camlp4/test/fixtures/outside-scope.ml | 21 + camlp4/test/fixtures/parser.ml | 61 + camlp4/test/fixtures/pp_let_in.ml | 10 + camlp4/test/fixtures/pp_let_in2.ml | 1 + camlp4/test/fixtures/pp_xml.ml | 31 + camlp4/test/fixtures/pprecordtyp.ml | 26 + camlp4/test/fixtures/pr4314.ml | 1 + camlp4/test/fixtures/pr4314gram1.ml | 36 + camlp4/test/fixtures/pr4314gram2.ml | 36 + camlp4/test/fixtures/pr4314gram3.ml | 36 + camlp4/test/fixtures/pr4314gram4.ml | 36 + camlp4/test/fixtures/pr4314gram5.ml | 38 + camlp4/test/fixtures/pr4329.ml | 50 + camlp4/test/fixtures/pr4330.ml | 57 + camlp4/test/fixtures/pr4357.ml | 16 + camlp4/test/fixtures/pr4357sample.ml | 3 + camlp4/test/fixtures/pr4357sample2.ml | 5 + camlp4/test/fixtures/pr4452.ml | 24 + camlp4/test/fixtures/private_row.ml | 27 + camlp4/test/fixtures/rec.ml | 2 + camlp4/test/fixtures/seq.ml | 1003 + camlp4/test/fixtures/seq2.ml | 3003 +++ camlp4/test/fixtures/simplify.ml | 11 + camlp4/test/fixtures/simplify_r.ml | 11 + camlp4/test/fixtures/stream-parser-bug.ml | 6 + camlp4/test/fixtures/string.ml | 1 + camlp4/test/fixtures/superfluous.ml | 12 + camlp4/test/fixtures/transform-examples.ml | 3 + camlp4/test/fixtures/try.ml | 6 + camlp4/test/fixtures/tuple_as_retval.ml | 3 + camlp4/test/fixtures/type.ml | 3 + camlp4/test/fixtures/type_decl.ml | 22 + camlp4/test/fixtures/unit.ml | 4 + camlp4/test/fixtures/use.ml | 4 + camlp4/test/fixtures/where.o.ml | 1 + camlp4/test/fixtures/where.r.ml | 1 + camlp4/unmaintained/Makefile | 20 + camlp4/unmaintained/compile/.cvsignore | 4 + camlp4/unmaintained/compile/.depend | 0 camlp4/unmaintained/compile/Makefile | 37 + camlp4/unmaintained/compile/comp_head.ml | 70 + camlp4/unmaintained/compile/comp_trail.ml | 33 + camlp4/unmaintained/compile/compile.ml | 574 + camlp4/unmaintained/compile/compile.sh | 27 + camlp4/unmaintained/etc/.cvsignore | 7 + camlp4/unmaintained/etc/.depend | 6 + camlp4/unmaintained/etc/Makefile | 62 + camlp4/unmaintained/etc/pa_fstream.ml | 163 + camlp4/unmaintained/etc/pa_ifdef.ml | 91 + camlp4/unmaintained/etc/pa_oop.ml | 155 + camlp4/unmaintained/etc/pa_ru.ml | 46 + camlp4/unmaintained/etc/parserify.ml | 305 + camlp4/unmaintained/etc/parserify.mli | 12 + camlp4/unmaintained/etc/pr_depend.ml | 321 + camlp4/unmaintained/etc/pr_extend.ml | 518 + camlp4/unmaintained/etc/pr_extfun.ml | 92 + camlp4/unmaintained/etc/pr_null.ml | 16 + camlp4/unmaintained/etc/pr_op.ml | 210 + camlp4/unmaintained/etc/pr_op_main.ml | 214 + camlp4/unmaintained/etc/pr_rp.ml | 207 + camlp4/unmaintained/etc/pr_rp_main.ml | 206 + camlp4/unmaintained/etc/q_phony.ml | 38 + camlp4/unmaintained/extfold/README | 15 + camlp4/unmaintained/extfold/pa_extfold.ml | 42 + camlp4/unmaintained/format/.depend | 0 camlp4/unmaintained/format/Makefile | 61 + camlp4/unmaintained/format/README | 15 + camlp4/unmaintained/format/pa_format.ml | 52 + camlp4/unmaintained/lefteval/.depend | 0 camlp4/unmaintained/lefteval/Makefile | 61 + camlp4/unmaintained/lefteval/README | 15 + camlp4/unmaintained/lefteval/pa_lefteval.ml | 241 + camlp4/unmaintained/lib/.cvsignore | 3 + camlp4/unmaintained/lib/.depend | 14 + camlp4/unmaintained/lib/Makefile | 52 + camlp4/unmaintained/lib/extfun.ml | 107 + camlp4/unmaintained/lib/extfun.mli | 35 + camlp4/unmaintained/lib/fstream.ml | 77 + camlp4/unmaintained/lib/fstream.mli | 60 + camlp4/unmaintained/ocamllex/Makefile | 59 + camlp4/unmaintained/ocamllex/README | 15 + camlp4/unmaintained/ocamllex/pa_ocamllex.ml | 356 + camlp4/unmaintained/ocpp/.cvsignore | 3 + camlp4/unmaintained/ocpp/.depend | 0 camlp4/unmaintained/ocpp/Makefile | 24 + camlp4/unmaintained/ocpp/ocpp.ml | 129 + camlp4/unmaintained/odyl/.cvsignore | 4 + camlp4/unmaintained/odyl/.depend | 4 + camlp4/unmaintained/odyl/Makefile | 61 + camlp4/unmaintained/odyl/odyl.ml | 57 + camlp4/unmaintained/odyl/odyl_main.mli | 13 + camlp4/unmaintained/olabl/.depend | 0 camlp4/unmaintained/olabl/Makefile | 61 + camlp4/unmaintained/olabl/README | 15 + camlp4/unmaintained/olabl/pa_olabl.ml | 2022 ++ camlp4/unmaintained/scheme/.depend | 0 camlp4/unmaintained/scheme/Makefile | 85 + camlp4/unmaintained/scheme/README | 15 + camlp4/unmaintained/scheme/pa_scheme.ml | 1093 + camlp4/unmaintained/scheme/pa_scheme.sc | 1029 + camlp4/unmaintained/scheme/pr_scheme.ml | 826 + camlp4/unmaintained/scheme/pr_schp_main.ml | 132 + camlp4/unmaintained/sml/.depend | 0 camlp4/unmaintained/sml/Makefile | 68 + camlp4/unmaintained/sml/README | 15 + camlp4/unmaintained/sml/pa_sml.ml | 952 + camlp4/unmaintained/sml/smllib.sml | 395 + configure | 6 +- ocamlbuild/manual/.cvsignore | 6 + ocamlbuild/manual/Makefile | 15 + ocamlbuild/manual/manual.hva | 1 + ocamlbuild/manual/manual.tex | 1054 + ocamlbuild/manual/myocamlbuild.ml | 119 + ocamlbuild/manual/trace.out | 83 + ocamlbuild/test/good-output | 1090 + ocamlbuild/test/runtest.sh | 36 + ocamlbuild/test/test1/foo.ml | 1 + ocamlbuild/test/test10/dbdi | 12 + ocamlbuild/test/test10/test.sh | 6 + ocamlbuild/test/test11/_tags | 2 + ocamlbuild/test/test11/a/aa.ml | 1 + ocamlbuild/test/test11/a/aa.mli | 1 + ocamlbuild/test/test11/b/bb.ml | 1 + ocamlbuild/test/test11/b/libb.mllib | 1 + ocamlbuild/test/test11/myocamlbuild.ml | 5 + ocamlbuild/test/test11/test.sh | 13 + ocamlbuild/test/test2/_tags | 3 + ocamlbuild/test/test2/tata.ml | 1 + ocamlbuild/test/test2/tata.mli | 2 + ocamlbuild/test/test2/test.sh | 18 + ocamlbuild/test/test2/titi.ml | 1 + ocamlbuild/test/test2/toto.ml | 5 + ocamlbuild/test/test2/tutu.ml | 2 + ocamlbuild/test/test2/tutu.mli | 3 + ocamlbuild/test/test2/tyty.mli | 1 + ocamlbuild/test/test2/vivi1.ml | 2 + ocamlbuild/test/test2/vivi2.ml | 2 + ocamlbuild/test/test2/vivi3.ml | 2 + ocamlbuild/test/test3/_tags | 1 + ocamlbuild/test/test3/a.ml | 1 + ocamlbuild/test/test3/a.mli | 1 + ocamlbuild/test/test3/b.ml | 1 + ocamlbuild/test/test3/b.mli | 1 + ocamlbuild/test/test3/c.ml | 1 + ocamlbuild/test/test3/c.mli | 1 + ocamlbuild/test/test3/d.ml | 1 + ocamlbuild/test/test3/d.mli | 1 + ocamlbuild/test/test3/e.ml | 1 + ocamlbuild/test/test3/e.mli | 1 + ocamlbuild/test/test3/f.ml | 2 + ocamlbuild/test/test3/f.mli | 1 + ocamlbuild/test/test3/proj.odocl | 1 + ocamlbuild/test/test3/test.sh | 11 + ocamlbuild/test/test4/_tags | 2 + ocamlbuild/test/test4/a/aa.ml | 1 + ocamlbuild/test/test4/a/aa.mli | 1 + ocamlbuild/test/test4/b/bb.ml | 2 + ocamlbuild/test/test4/test.sh | 11 + ocamlbuild/test/test5/_tags | 1 + ocamlbuild/test/test5/a.ml | 1 + ocamlbuild/test/test5/a.mli | 1 + ocamlbuild/test/test5/b.ml | 1 + ocamlbuild/test/test5/c.mlpack | 1 + ocamlbuild/test/test5/d.ml | 1 + ocamlbuild/test/test5/stack.ml | 1 + ocamlbuild/test/test5/test.sh | 11 + ocamlbuild/test/test6/a.ml | 1 + ocamlbuild/test/test6/a.mli | 1 + ocamlbuild/test/test6/b.ml | 1 + ocamlbuild/test/test6/b.mli | 1 + ocamlbuild/test/test6/b.mli.v1 | 1 + ocamlbuild/test/test6/b.mli.v2 | 2 + ocamlbuild/test/test6/d.ml | 2 + ocamlbuild/test/test6/d.mli | 1 + ocamlbuild/test/test6/d.mli.v1 | 2 + ocamlbuild/test/test6/d.mli.v2 | 1 + ocamlbuild/test/test6/main.ml | 1 + ocamlbuild/test/test6/main.mli | 1 + ocamlbuild/test/test6/test.sh | 26 + ocamlbuild/test/test7/_tags | 1 + ocamlbuild/test/test7/aa.ml | 1 + ocamlbuild/test/test7/bb.mli | 1 + ocamlbuild/test/test7/bb1.ml | 1 + ocamlbuild/test/test7/bb2.ml | 3 + ocamlbuild/test/test7/bb3.ml | 3 + ocamlbuild/test/test7/bbcc.mllib | 1 + ocamlbuild/test/test7/c2.ml | 1 + ocamlbuild/test/test7/c2.mli | 1 + ocamlbuild/test/test7/c3.ml | 1 + ocamlbuild/test/test7/cc.ml | 1 + ocamlbuild/test/test7/cool_plugin.ml | 1 + ocamlbuild/test/test7/main.ml | 1 + ocamlbuild/test/test7/myocamlbuild.ml | 7 + ocamlbuild/test/test7/test.sh | 18 + ocamlbuild/test/test8/a.ml | 1 + ocamlbuild/test/test8/myocamlbuild.ml | 16 + ocamlbuild/test/test8/test.sh | 11 + ocamlbuild/test/test9/dbgl | 10 + ocamlbuild/test/test9/test.sh | 6 + ocamlbuild/test/test9/testglob.ml | 134 + ocamlbuild/test/test_virtual/foo.itarget | 1 + ocamlbuild/test/test_virtual/foo1 | 1 + ocamlbuild/test/test_virtual/foo2 | 1 + ocamlbuild/test/test_virtual/myocamlbuild.ml | 11 + ocamlbuild/test/test_virtual/test.sh | 16 + testlabl/.cvsignore | 1 + testlabl/coerce.diffs | 93 + testlabl/dirs_multimatch | 1 + testlabl/dirs_poly | 1 + testlabl/els.ml | 92 + testlabl/fixedtypes.ml | 77 + testlabl/marshal_objects.diffs | 800 + testlabl/multimatch.diffs | 1418 ++ testlabl/multimatch.ml | 158 + testlabl/newlabels.ps | 1458 ++ testlabl/objvariant.diffs | 354 + testlabl/objvariant.ml | 42 + testlabl/printers.ml | 11 + testlabl/sigsubst.ml | 38 + testlabl/tests.ml | 22 + testlabl/valvirt.diffs | 2349 ++ testlabl/varunion.ml | 435 + typing/unused_var.ml | 4 +- 289 files changed, 73373 insertions(+), 9 deletions(-) create mode 100644 camlp4/test/fixtures/assert.ml create mode 100644 camlp4/test/fixtures/backquoted_irrefutable_tuple.ml create mode 100644 camlp4/test/fixtures/backquoted_record.ml create mode 100644 camlp4/test/fixtures/backquoted_tuple.ml create mode 100644 camlp4/test/fixtures/big-tab1.ml create mode 100644 camlp4/test/fixtures/big-tab2.ml create mode 100644 camlp4/test/fixtures/big-tab3.ml create mode 100644 camlp4/test/fixtures/bug-4058.ml create mode 100644 camlp4/test/fixtures/bug-4337.ml create mode 100644 camlp4/test/fixtures/bug-by-vincent-balat.ml create mode 100644 camlp4/test/fixtures/bug-camlp4o-benjamin-monate.ml create mode 100644 camlp4/test/fixtures/bug-camlp4o-constr-arity-expr.ml create mode 100644 camlp4/test/fixtures/bug-camlp4o-constr-arity.ml create mode 100644 camlp4/test/fixtures/bug_escaping_quot.ml create mode 100644 camlp4/test/fixtures/chars.ml create mode 100644 camlp4/test/fixtures/class_expr_quot.ml create mode 100644 camlp4/test/fixtures/comments.ml create mode 100644 camlp4/test/fixtures/comments.mli create mode 100644 camlp4/test/fixtures/comments2.ml create mode 100644 camlp4/test/fixtures/constant-parser.ml create mode 100644 camlp4/test/fixtures/curry-constr.ml create mode 100644 camlp4/test/fixtures/default_quotation.ml create mode 100644 camlp4/test/fixtures/exception-with-eqn-bug.ml create mode 100644 camlp4/test/fixtures/external.ml create mode 100644 camlp4/test/fixtures/fun.ml create mode 100644 camlp4/test/fixtures/functor-perf.ml create mode 100644 camlp4/test/fixtures/functor-perf2.gen.ml create mode 100644 camlp4/test/fixtures/functor-perf2.ml create mode 100644 camlp4/test/fixtures/functor-perf3.ml create mode 100644 camlp4/test/fixtures/gen_map.ml create mode 100644 camlp4/test/fixtures/gram-fold.ml create mode 100644 camlp4/test/fixtures/gram-list.ml create mode 100644 camlp4/test/fixtures/gram-loc-lost.ml create mode 100644 camlp4/test/fixtures/gram-sub-rule.ml create mode 100644 camlp4/test/fixtures/gram-tree.ml create mode 100644 camlp4/test/fixtures/gram-tree2.ml create mode 100644 camlp4/test/fixtures/gram-tree3.ml create mode 100644 camlp4/test/fixtures/gram.ml create mode 100644 camlp4/test/fixtures/idents create mode 100644 camlp4/test/fixtures/idents1 create mode 100644 camlp4/test/fixtures/idents2 create mode 100644 camlp4/test/fixtures/if.ml create mode 100644 camlp4/test/fixtures/label.ml create mode 100644 camlp4/test/fixtures/lambda_free.ml create mode 100644 camlp4/test/fixtures/loc-bug.ml create mode 100644 camlp4/test/fixtures/macrotest.ml create mode 100644 camlp4/test/fixtures/macrotest.mli create mode 100644 camlp4/test/fixtures/macrotest2.ml create mode 100644 camlp4/test/fixtures/macrotest3.ml create mode 100644 camlp4/test/fixtures/make_extend.ml create mode 100644 camlp4/test/fixtures/match.ml create mode 100644 camlp4/test/fixtures/match_parser.ml create mode 100644 camlp4/test/fixtures/meta_multi_term.ml create mode 100644 camlp4/test/fixtures/metalib.ml create mode 100644 camlp4/test/fixtures/method_private_virtual.ml create mode 100644 camlp4/test/fixtures/mod.ml create mode 100644 camlp4/test/fixtures/mod2.ml create mode 100644 camlp4/test/fixtures/operators.ml create mode 100644 camlp4/test/fixtures/operators.mli create mode 100644 camlp4/test/fixtures/original_syntax.ml create mode 100644 camlp4/test/fixtures/outside-scope.ml create mode 100644 camlp4/test/fixtures/parser.ml create mode 100644 camlp4/test/fixtures/pp_let_in.ml create mode 100644 camlp4/test/fixtures/pp_let_in2.ml create mode 100644 camlp4/test/fixtures/pp_xml.ml create mode 100644 camlp4/test/fixtures/pprecordtyp.ml create mode 100644 camlp4/test/fixtures/pr4314.ml create mode 100644 camlp4/test/fixtures/pr4314gram1.ml create mode 100644 camlp4/test/fixtures/pr4314gram2.ml create mode 100644 camlp4/test/fixtures/pr4314gram3.ml create mode 100644 camlp4/test/fixtures/pr4314gram4.ml create mode 100644 camlp4/test/fixtures/pr4314gram5.ml create mode 100644 camlp4/test/fixtures/pr4329.ml create mode 100644 camlp4/test/fixtures/pr4330.ml create mode 100644 camlp4/test/fixtures/pr4357.ml create mode 100644 camlp4/test/fixtures/pr4357sample.ml create mode 100644 camlp4/test/fixtures/pr4357sample2.ml create mode 100644 camlp4/test/fixtures/pr4452.ml create mode 100644 camlp4/test/fixtures/private_row.ml create mode 100644 camlp4/test/fixtures/rec.ml create mode 100644 camlp4/test/fixtures/seq.ml create mode 100644 camlp4/test/fixtures/seq2.ml create mode 100644 camlp4/test/fixtures/simplify.ml create mode 100644 camlp4/test/fixtures/simplify_r.ml create mode 100644 camlp4/test/fixtures/stream-parser-bug.ml create mode 100644 camlp4/test/fixtures/string.ml create mode 100644 camlp4/test/fixtures/superfluous.ml create mode 100644 camlp4/test/fixtures/transform-examples.ml create mode 100644 camlp4/test/fixtures/try.ml create mode 100644 camlp4/test/fixtures/tuple_as_retval.ml create mode 100644 camlp4/test/fixtures/type.ml create mode 100644 camlp4/test/fixtures/type_decl.ml create mode 100644 camlp4/test/fixtures/unit.ml create mode 100644 camlp4/test/fixtures/use.ml create mode 100644 camlp4/test/fixtures/where.o.ml create mode 100644 camlp4/test/fixtures/where.r.ml create mode 100644 camlp4/unmaintained/Makefile create mode 100644 camlp4/unmaintained/compile/.cvsignore create mode 100644 camlp4/unmaintained/compile/.depend create mode 100644 camlp4/unmaintained/compile/Makefile create mode 100644 camlp4/unmaintained/compile/comp_head.ml create mode 100644 camlp4/unmaintained/compile/comp_trail.ml create mode 100644 camlp4/unmaintained/compile/compile.ml create mode 100755 camlp4/unmaintained/compile/compile.sh create mode 100644 camlp4/unmaintained/etc/.cvsignore create mode 100644 camlp4/unmaintained/etc/.depend create mode 100644 camlp4/unmaintained/etc/Makefile create mode 100644 camlp4/unmaintained/etc/pa_fstream.ml create mode 100644 camlp4/unmaintained/etc/pa_ifdef.ml create mode 100644 camlp4/unmaintained/etc/pa_oop.ml create mode 100644 camlp4/unmaintained/etc/pa_ru.ml create mode 100644 camlp4/unmaintained/etc/parserify.ml create mode 100644 camlp4/unmaintained/etc/parserify.mli create mode 100644 camlp4/unmaintained/etc/pr_depend.ml create mode 100644 camlp4/unmaintained/etc/pr_extend.ml create mode 100644 camlp4/unmaintained/etc/pr_extfun.ml create mode 100644 camlp4/unmaintained/etc/pr_null.ml create mode 100644 camlp4/unmaintained/etc/pr_op.ml create mode 100644 camlp4/unmaintained/etc/pr_op_main.ml create mode 100644 camlp4/unmaintained/etc/pr_rp.ml create mode 100644 camlp4/unmaintained/etc/pr_rp_main.ml create mode 100644 camlp4/unmaintained/etc/q_phony.ml create mode 100644 camlp4/unmaintained/extfold/README create mode 100644 camlp4/unmaintained/extfold/pa_extfold.ml create mode 100644 camlp4/unmaintained/format/.depend create mode 100644 camlp4/unmaintained/format/Makefile create mode 100644 camlp4/unmaintained/format/README create mode 100644 camlp4/unmaintained/format/pa_format.ml create mode 100644 camlp4/unmaintained/lefteval/.depend create mode 100644 camlp4/unmaintained/lefteval/Makefile create mode 100644 camlp4/unmaintained/lefteval/README create mode 100644 camlp4/unmaintained/lefteval/pa_lefteval.ml create mode 100644 camlp4/unmaintained/lib/.cvsignore create mode 100644 camlp4/unmaintained/lib/.depend create mode 100644 camlp4/unmaintained/lib/Makefile create mode 100644 camlp4/unmaintained/lib/extfun.ml create mode 100644 camlp4/unmaintained/lib/extfun.mli create mode 100644 camlp4/unmaintained/lib/fstream.ml create mode 100644 camlp4/unmaintained/lib/fstream.mli create mode 100644 camlp4/unmaintained/ocamllex/Makefile create mode 100644 camlp4/unmaintained/ocamllex/README create mode 100644 camlp4/unmaintained/ocamllex/pa_ocamllex.ml create mode 100644 camlp4/unmaintained/ocpp/.cvsignore create mode 100644 camlp4/unmaintained/ocpp/.depend create mode 100644 camlp4/unmaintained/ocpp/Makefile create mode 100644 camlp4/unmaintained/ocpp/ocpp.ml create mode 100644 camlp4/unmaintained/odyl/.cvsignore create mode 100644 camlp4/unmaintained/odyl/.depend create mode 100644 camlp4/unmaintained/odyl/Makefile create mode 100644 camlp4/unmaintained/odyl/odyl.ml create mode 100644 camlp4/unmaintained/odyl/odyl_main.mli create mode 100644 camlp4/unmaintained/olabl/.depend create mode 100644 camlp4/unmaintained/olabl/Makefile create mode 100644 camlp4/unmaintained/olabl/README create mode 100644 camlp4/unmaintained/olabl/pa_olabl.ml create mode 100644 camlp4/unmaintained/scheme/.depend create mode 100644 camlp4/unmaintained/scheme/Makefile create mode 100644 camlp4/unmaintained/scheme/README create mode 100644 camlp4/unmaintained/scheme/pa_scheme.ml create mode 100644 camlp4/unmaintained/scheme/pa_scheme.sc create mode 100644 camlp4/unmaintained/scheme/pr_scheme.ml create mode 100644 camlp4/unmaintained/scheme/pr_schp_main.ml create mode 100644 camlp4/unmaintained/sml/.depend create mode 100644 camlp4/unmaintained/sml/Makefile create mode 100644 camlp4/unmaintained/sml/README create mode 100644 camlp4/unmaintained/sml/pa_sml.ml create mode 100644 camlp4/unmaintained/sml/smllib.sml create mode 100644 ocamlbuild/manual/.cvsignore create mode 100644 ocamlbuild/manual/Makefile create mode 100644 ocamlbuild/manual/manual.hva create mode 100644 ocamlbuild/manual/manual.tex create mode 100644 ocamlbuild/manual/myocamlbuild.ml create mode 100644 ocamlbuild/manual/trace.out create mode 100644 ocamlbuild/test/good-output create mode 100755 ocamlbuild/test/runtest.sh create mode 100644 ocamlbuild/test/test1/foo.ml create mode 100644 ocamlbuild/test/test10/dbdi create mode 100755 ocamlbuild/test/test10/test.sh create mode 100644 ocamlbuild/test/test11/_tags create mode 100644 ocamlbuild/test/test11/a/aa.ml create mode 100644 ocamlbuild/test/test11/a/aa.mli create mode 100644 ocamlbuild/test/test11/b/bb.ml create mode 100644 ocamlbuild/test/test11/b/libb.mllib create mode 100644 ocamlbuild/test/test11/myocamlbuild.ml create mode 100755 ocamlbuild/test/test11/test.sh create mode 100644 ocamlbuild/test/test2/_tags create mode 100644 ocamlbuild/test/test2/tata.ml create mode 100644 ocamlbuild/test/test2/tata.mli create mode 100755 ocamlbuild/test/test2/test.sh create mode 100644 ocamlbuild/test/test2/titi.ml create mode 100644 ocamlbuild/test/test2/toto.ml create mode 100644 ocamlbuild/test/test2/tutu.ml create mode 100644 ocamlbuild/test/test2/tutu.mli create mode 100644 ocamlbuild/test/test2/tyty.mli create mode 100644 ocamlbuild/test/test2/vivi1.ml create mode 100644 ocamlbuild/test/test2/vivi2.ml create mode 100644 ocamlbuild/test/test2/vivi3.ml create mode 100644 ocamlbuild/test/test3/_tags create mode 100644 ocamlbuild/test/test3/a.ml create mode 100644 ocamlbuild/test/test3/a.mli create mode 100644 ocamlbuild/test/test3/b.ml create mode 100644 ocamlbuild/test/test3/b.mli create mode 100644 ocamlbuild/test/test3/c.ml create mode 100644 ocamlbuild/test/test3/c.mli create mode 100644 ocamlbuild/test/test3/d.ml create mode 100644 ocamlbuild/test/test3/d.mli create mode 100644 ocamlbuild/test/test3/e.ml create mode 100644 ocamlbuild/test/test3/e.mli create mode 100644 ocamlbuild/test/test3/f.ml create mode 100644 ocamlbuild/test/test3/f.mli create mode 100644 ocamlbuild/test/test3/proj.odocl create mode 100755 ocamlbuild/test/test3/test.sh create mode 100644 ocamlbuild/test/test4/_tags create mode 100644 ocamlbuild/test/test4/a/aa.ml create mode 100644 ocamlbuild/test/test4/a/aa.mli create mode 100644 ocamlbuild/test/test4/b/bb.ml create mode 100755 ocamlbuild/test/test4/test.sh create mode 100644 ocamlbuild/test/test5/_tags create mode 100644 ocamlbuild/test/test5/a.ml create mode 100644 ocamlbuild/test/test5/a.mli create mode 100644 ocamlbuild/test/test5/b.ml create mode 100644 ocamlbuild/test/test5/c.mlpack create mode 100644 ocamlbuild/test/test5/d.ml create mode 100644 ocamlbuild/test/test5/stack.ml create mode 100755 ocamlbuild/test/test5/test.sh create mode 100644 ocamlbuild/test/test6/a.ml create mode 100644 ocamlbuild/test/test6/a.mli create mode 100644 ocamlbuild/test/test6/b.ml create mode 100644 ocamlbuild/test/test6/b.mli create mode 100644 ocamlbuild/test/test6/b.mli.v1 create mode 100644 ocamlbuild/test/test6/b.mli.v2 create mode 100644 ocamlbuild/test/test6/d.ml create mode 100644 ocamlbuild/test/test6/d.mli create mode 100644 ocamlbuild/test/test6/d.mli.v1 create mode 100644 ocamlbuild/test/test6/d.mli.v2 create mode 100644 ocamlbuild/test/test6/main.ml create mode 100644 ocamlbuild/test/test6/main.mli create mode 100755 ocamlbuild/test/test6/test.sh create mode 100644 ocamlbuild/test/test7/_tags create mode 100644 ocamlbuild/test/test7/aa.ml create mode 100644 ocamlbuild/test/test7/bb.mli create mode 100644 ocamlbuild/test/test7/bb1.ml create mode 100644 ocamlbuild/test/test7/bb2.ml create mode 100644 ocamlbuild/test/test7/bb3.ml create mode 100644 ocamlbuild/test/test7/bbcc.mllib create mode 100644 ocamlbuild/test/test7/c2.ml create mode 100644 ocamlbuild/test/test7/c2.mli create mode 100644 ocamlbuild/test/test7/c3.ml create mode 100644 ocamlbuild/test/test7/cc.ml create mode 100644 ocamlbuild/test/test7/cool_plugin.ml create mode 100644 ocamlbuild/test/test7/main.ml create mode 100644 ocamlbuild/test/test7/myocamlbuild.ml create mode 100755 ocamlbuild/test/test7/test.sh create mode 100644 ocamlbuild/test/test8/a.ml create mode 100644 ocamlbuild/test/test8/myocamlbuild.ml create mode 100755 ocamlbuild/test/test8/test.sh create mode 100644 ocamlbuild/test/test9/dbgl create mode 100755 ocamlbuild/test/test9/test.sh create mode 100644 ocamlbuild/test/test9/testglob.ml create mode 100644 ocamlbuild/test/test_virtual/foo.itarget create mode 100644 ocamlbuild/test/test_virtual/foo1 create mode 100644 ocamlbuild/test/test_virtual/foo2 create mode 100644 ocamlbuild/test/test_virtual/myocamlbuild.ml create mode 100644 ocamlbuild/test/test_virtual/test.sh create mode 100644 testlabl/.cvsignore create mode 100644 testlabl/coerce.diffs create mode 100644 testlabl/dirs_multimatch create mode 100644 testlabl/dirs_poly create mode 100644 testlabl/els.ml create mode 100644 testlabl/fixedtypes.ml create mode 100644 testlabl/marshal_objects.diffs create mode 100644 testlabl/multimatch.diffs create mode 100644 testlabl/multimatch.ml create mode 100644 testlabl/newlabels.ps create mode 100644 testlabl/objvariant.diffs create mode 100644 testlabl/objvariant.ml create mode 100644 testlabl/printers.ml create mode 100644 testlabl/sigsubst.ml create mode 100644 testlabl/tests.ml create mode 100644 testlabl/valvirt.diffs create mode 100644 testlabl/varunion.ml diff --git a/Changes b/Changes index 17e376ae..e9ea3561 100644 --- a/Changes +++ b/Changes @@ -66,6 +66,7 @@ Bug fixes: - PR#5276: issue with ocamlc -pack and recursively-packed modules - PR#5280: alignment constraints incorrectly autodetected on MIPS 32 - PR#5281: typo in error message +- PR#5308: unused variables not detected in "include (struct .. end)" - camlp4 revised syntax printing bug in the toplevel (reported on caml-list) - configure: do not define _WIN32 under cygwin - Hardened generic comparison in the case where two custom blocks @@ -2720,4 +2721,4 @@ Caml Special Light 1.06: * First public release. -$Id: Changes 11083 2011-06-11 07:24:12Z xleroy $ +$Id: Changes 11110 2011-07-04 21:15:01Z doligez $ diff --git a/README.win32 b/README.win32 index 82b4cba5..27ee0851 100644 --- a/README.win32 +++ b/README.win32 @@ -37,7 +37,7 @@ the GPL. Thus, these .exe files can only be distributed under a license that is compatible with the GPL. Executables generated by MSVC or by MinGW have no such restrictions. -(**) The debugger is supported but the "replay" function of it are not enabled. +(**) The debugger is supported but the "replay" functions are not enabled. Other functions are available (step, goto, run...). The remainder of this document gives more information on each port. @@ -183,6 +183,10 @@ by Jacob Navia, then significantly improved by Christopher A. Watford. The native Win32 port built with Mingw -------------------------------------- +NOTE: Due to changes in cygwin's compilers, this port is not available +in OCaml 3.12.1. A patch will be made available soon after the release +of 3.12.1. + REQUIREMENTS: This port runs under MS Windows Vista, XP, and 2000. @@ -232,7 +236,7 @@ You will need the following software components to perform the recompilation: - Windows NT, 2000, XP, or Vista. - Cygwin: http://sourceware.cygnus.com/cygwin/ Install at least the following packages: binutils, diffutils, - gcc-core, gcc-mingw-core, make, mingw-runtime, ncurses, w32-api. + gcc-core, gcc-mingw-core, make, mingw-runtime, ncurses, w32api. - TCL/TK version 8.5 (see above). - The flexdll tool (see above). @@ -302,7 +306,9 @@ NOTES: The libraries available in this port are "num", "str", "threads", "unix" and "labltk". "graph" is not available. -The replay debugger is supported. +The replay debugger is fully supported. +When upgrading from 3.12.0 to 3.12.1, you will need to remove +/usr/local/bin/ocamlmktop.exe before typing "make install". ------------------------------------------------------------------------------ diff --git a/VERSION b/VERSION index 26a72c1f..8b325e02 100644 --- a/VERSION +++ b/VERSION @@ -1,6 +1,6 @@ -3.12.1+rc1 +3.12.1 # The version string is the first line of this file. # It must be in the format described in stdlib/sys.mli -# $Id: VERSION 11094 2011-06-15 11:01:14Z doligez $ +# $Id: VERSION 11110 2011-07-04 21:15:01Z doligez $ diff --git a/boot/ocamlc b/boot/ocamlc index 98f4c561fdb82f2968d55007ddc58a8f4914e68f..ddc3aa7c0d2efe0af0c2b928137e88f9642176d7 100755 GIT binary patch delta 202 zcmey^I}mdKF((jn0Wmia z^K5rHz^itLPwXoLgWyF5h7A%738e|pCAM3xW4zv@t9FM^oQ;7&@FD}l23ZD%f=AmY&Eex>=F&3OGc*FbW&5J}d>grBIaT#b zi;MJg@{<#D^npZfjy_z8;q=T^d@?c`cvQ5{Ud0E*{M%=*5|}H^)bVAy)iD8iMycsh H#{?7rxbs=^ diff --git a/boot/ocamldep b/boot/ocamldep index cce4cd49963f81420bd0449713dde4bde007da30..2dd0f9e3e2e6653547512427f8ba7496ae344122 100755 GIT binary patch delta 122 zcmX^3L}=9$p$X!RvaPa=t+Gs8WtrDG^PXp5U`bTQW;!In`nb$eD0;b&m52-|+inVE~3 zOUqc#&TPZ#hEq*^GYx x + y ] ]; +END; diff --git a/camlp4/test/fixtures/backquoted_record.ml b/camlp4/test/fixtures/backquoted_record.ml new file mode 100644 index 00000000..e056f731 --- /dev/null +++ b/camlp4/test/fixtures/backquoted_record.ml @@ -0,0 +1,4 @@ +EXTEND Gram + raw_string: + [[ `QUOTATION { Sig.Quotation.q_contents = c; q_name = n } -> (c, n) ]]; +END; diff --git a/camlp4/test/fixtures/backquoted_tuple.ml b/camlp4/test/fixtures/backquoted_tuple.ml new file mode 100644 index 00000000..72ae1a6b --- /dev/null +++ b/camlp4/test/fixtures/backquoted_tuple.ml @@ -0,0 +1,3 @@ +EXTEND Gram + abc: [ [ `(A,y) -> y ] ]; +END; diff --git a/camlp4/test/fixtures/big-tab1.ml b/camlp4/test/fixtures/big-tab1.ml new file mode 100644 index 00000000..254da825 --- /dev/null +++ b/camlp4/test/fixtures/big-tab1.ml @@ -0,0 +1,704 @@ +[| +aaa; +aab; +aac; +aad; +aae; +aaf; +aag; +aah; +aai; +aaj; +aak; +aal; +aam; +aan; +aao; +aap; +aaq; +aar; +aas; +aat; +aau; +aav; +aaw; +aax; +aay; +aaz; +aba; +abb; +abc; +abd; +abe; +abf; +abg; +abh; +abi; +abj; +abk; +abl; +abm; +abn; +abo; +abp; +abq; +abr; +abs; +abt; +abu; +abv; +abw; +abx; +aby; +abz; +aca; +acb; +acc; +acd; +ace; +acf; +acg; +ach; +aci; +acj; +ack; +acl; +acm; +acn; +aco; +acp; +acq; +acr; +acs; +act; +acu; +acv; +acw; +acx; +acy; +acz; +ada; +adb; +adc; +add; +ade; +adf; +adg; +adh; +adi; +adj; +adk; +adl; +adm; +adn; +ado; +adp; +adq; +adr; +ads; +adt; +adu; +adv; +adw; +adx; +ady; +adz; +aea; +aeb; +aec; +aed; +aee; +aef; +aeg; +aeh; +aei; +aej; +aek; +ael; +aem; +aen; +aeo; +aep; +aeq; +aer; +aes; +aet; +aeu; +aev; +aew; +aex; +aey; +aez; +afa; +afb; +afc; +afd; +afe; +aff; +afg; +afh; +afi; +afj; +afk; +afl; +afm; +afn; +afo; +afp; +afq; +afr; +afs; +aft; +afu; +afv; +afw; +afx; +afy; +afz; +aga; +agb; +agc; +agd; +age; +agf; +agg; +agh; +agi; +agj; +agk; +agl; +agm; +agn; +ago; +agp; +agq; +agr; +ags; +agt; +agu; +agv; +agw; +agx; +agy; +agz; +aha; +ahb; +ahc; +ahd; +ahe; +ahf; +ahg; +ahh; +ahi; +ahj; +ahk; +ahl; +ahm; +ahn; +aho; +ahp; +ahq; +ahr; +ahs; +aht; +ahu; +ahv; +ahw; +ahx; +ahy; +ahz; +aia; +aib; +aic; +aid; +aie; +aif; +aig; +aih; +aii; +aij; +aik; +ail; +aim; +ain; +aio; +aip; +aiq; +air; +ais; +ait; +aiu; +aiv; +aiw; +aix; +aiy; +aiz; +aja; +ajb; +ajc; +ajd; +aje; +ajf; +ajg; +ajh; +aji; +ajj; +ajk; +ajl; +ajm; +ajn; +ajo; +ajp; +ajq; +ajr; +ajs; +ajt; +aju; +ajv; +ajw; +ajx; +ajy; +ajz; +aka; +akb; +akc; +akd; +ake; +akf; +akg; +akh; +aki; +akj; +akk; +akl; +akm; +akn; +ako; +akp; +akq; +akr; +aks; +akt; +aku; +akv; +akw; +akx; +aky; +akz; +ala; +alb; +alc; +ald; +ale; +alf; +alg; +alh; +ali; +alj; +alk; +all; +alm; +aln; +alo; +alp; +alq; +alr; +als; +alt; +alu; +alv; +alw; +alx; +aly; +alz; +ama; +amb; +amc; +amd; +ame; +amf; +amg; +amh; +ami; +amj; +amk; +aml; +amm; +amn; +amo; +amp; +amq; +amr; +ams; +amt; +amu; +amv; +amw; +amx; +amy; +amz; +ana; +anb; +anc; +ane; +anf; +ang; +anh; +ani; +anj; +ank; +anl; +anm; +ann; +ano; +anp; +anq; +anr; +ans; +ant; +anu; +anv; +anw; +anx; +any; +anz; +aoa; +aob; +aoc; +aod; +aoe; +aof; +aog; +aoh; +aoi; +aoj; +aok; +aol; +aom; +aon; +aoo; +aop; +aoq; +aor; +aos; +aot; +aou; +aov; +aow; +aox; +aoy; +aoz; +apa; +apb; +apc; +apd; +ape; +apf; +apg; +aph; +api; +apj; +apk; +apl; +apm; +apn; +apo; +app; +apq; +apr; +aps; +apt; +apu; +apv; +apw; +apx; +apy; +apz; +aqa; +aqb; +aqc; +aqd; +aqe; +aqf; +aqg; +aqh; +aqi; +aqj; +aqk; +aql; +aqm; +aqn; +aqo; +aqp; +aqq; +aqr; +aqs; +aqt; +aqu; +aqv; +aqw; +aqx; +aqy; +aqz; +ara; +arb; +arc; +ard; +are; +arf; +arg; +arh; +ari; +arj; +ark; +arl; +arm; +arn; +aro; +arp; +arq; +arr; +ars; +art; +aru; +arv; +arw; +arx; +ary; +arz; +asa; +asb; +asc; +asd; +ase; +asf; +asg; +ash; +asi; +asj; +ask; +asl; +asm; +asn; +aso; +asp; +asq; +ass; +ast; +asu; +asv; +asw; +asx; +asy; +asz; +ata; +atb; +atc; +atd; +ate; +atf; +atg; +ath; +ati; +atj; +atk; +atl; +atm; +atn; +ato; +atp; +atq; +atr; +ats; +att; +atu; +atv; +atw; +atx; +aty; +atz; +aua; +aub; +auc; +aud; +aue; +auf; +aug; +auh; +aui; +auj; +auk; +aul; +aum; +aun; +auo; +aup; +auq; +aur; +aus; +aut; +auu; +auv; +auw; +aux; +auy; +auz; +ava; +avb; +avc; +avd; +ave; +avf; +avg; +avh; +avi; +avj; +avk; +avl; +avm; +avn; +avo; +avp; +avq; +avr; +avs; +avt; +avu; +avv; +avw; +avx; +avy; +avz; +awa; +awb; +awc; +awd; +awe; +awf; +awg; +awh; +awi; +awj; +awk; +awl; +awm; +awn; +awo; +awp; +awq; +awr; +aws; +awt; +awu; +awv; +aww; +awx; +awy; +awz; +axa; +axb; +axc; +axd; +axe; +axf; +axg; +axh; +axi; +axj; +axk; +axl; +axm; +axn; +axo; +axp; +axq; +axr; +axs; +axt; +axu; +axv; +axw; +axx; +axy; +axz; +aya; +ayb; +ayc; +ayd; +aye; +ayf; +ayg; +ayh; +ayi; +ayj; +ayk; +ayl; +aym; +ayn; +ayo; +ayp; +ayq; +ayr; +ays; +ayt; +ayu; +ayv; +ayw; +ayx; +ayy; +ayz; +aza; +azb; +azc; +azd; +aze; +azf; +azg; +azh; +azi; +azj; +azk; +azl; +azm; +azn; +azo; +azp; +azq; +azr; +azs; +azt; +azu; +azv; +azw; +azx; +azy; +azz; +baa; +bab; +bac; +bad; +bae; +baf; +bag; +bah; +bai; +baj; +bak; +bal; +bam; +ban; +bao; +bap; +baq; +bar; +bas; +bat; +bau; +bav; +baw; +bax; +bay; +baz; +bba; +bbb +|]; diff --git a/camlp4/test/fixtures/big-tab2.ml b/camlp4/test/fixtures/big-tab2.ml new file mode 100644 index 00000000..e640f34d --- /dev/null +++ b/camlp4/test/fixtures/big-tab2.ml @@ -0,0 +1,18282 @@ +[| +aaaa; +aaab; +aaac; +aaad; +aaae; +aaaf; +aaag; +aaah; +aaai; +aaaj; +aaak; +aaal; +aaam; +aaan; +aaao; +aaap; +aaaq; +aaar; +aaas; +aaat; +aaau; +aaav; +aaaw; +aaax; +aaay; +aaaz; +aaba; +aabb; +aabc; +aabd; +aabe; +aabf; +aabg; +aabh; +aabi; +aabj; +aabk; +aabl; +aabm; +aabn; +aabo; +aabp; +aabq; +aabr; +aabs; +aabt; +aabu; +aabv; +aabw; +aabx; +aaby; +aabz; +aaca; +aacb; +aacc; +aacd; +aace; +aacf; +aacg; +aach; +aaci; +aacj; +aack; +aacl; +aacm; +aacn; +aaco; +aacp; +aacq; +aacr; +aacs; +aact; +aacu; +aacv; +aacw; +aacx; +aacy; +aacz; +aada; +aadb; +aadc; +aadd; +aade; +aadf; +aadg; +aadh; +aadi; +aadj; +aadk; +aadl; +aadm; +aadn; +aado; +aadp; +aadq; +aadr; +aads; +aadt; +aadu; +aadv; +aadw; +aadx; +aady; +aadz; +aaea; +aaeb; +aaec; +aaed; +aaee; +aaef; +aaeg; +aaeh; +aaei; +aaej; +aaek; +aael; +aaem; +aaen; +aaeo; +aaep; +aaeq; +aaer; +aaes; +aaet; +aaeu; +aaev; +aaew; +aaex; +aaey; +aaez; +aafa; +aafb; +aafc; +aafd; +aafe; +aaff; +aafg; +aafh; +aafi; +aafj; +aafk; +aafl; +aafm; +aafn; +aafo; +aafp; +aafq; +aafr; +aafs; +aaft; +aafu; +aafv; +aafw; +aafx; +aafy; +aafz; +aaga; +aagb; +aagc; +aagd; +aage; +aagf; +aagg; +aagh; +aagi; +aagj; +aagk; +aagl; +aagm; +aagn; +aago; +aagp; +aagq; +aagr; +aags; +aagt; +aagu; +aagv; +aagw; +aagx; +aagy; +aagz; +aaha; +aahb; +aahc; +aahd; +aahe; +aahf; +aahg; +aahh; +aahi; +aahj; +aahk; +aahl; +aahm; +aahn; +aaho; +aahp; +aahq; +aahr; +aahs; +aaht; +aahu; +aahv; +aahw; +aahx; +aahy; +aahz; +aaia; +aaib; +aaic; +aaid; +aaie; +aaif; +aaig; +aaih; +aaii; +aaij; +aaik; +aail; +aaim; +aain; +aaio; +aaip; +aaiq; +aair; +aais; +aait; +aaiu; +aaiv; +aaiw; +aaix; +aaiy; +aaiz; +aaja; +aajb; +aajc; +aajd; +aaje; +aajf; +aajg; +aajh; +aaji; +aajj; +aajk; +aajl; +aajm; +aajn; +aajo; +aajp; +aajq; +aajr; +aajs; +aajt; +aaju; +aajv; +aajw; +aajx; +aajy; +aajz; +aaka; +aakb; +aakc; +aakd; +aake; +aakf; +aakg; +aakh; +aaki; +aakj; +aakk; +aakl; +aakm; +aakn; +aako; +aakp; +aakq; +aakr; +aaks; +aakt; +aaku; +aakv; +aakw; +aakx; +aaky; +aakz; +aala; +aalb; +aalc; +aald; +aale; +aalf; +aalg; +aalh; +aali; +aalj; +aalk; +aall; +aalm; +aaln; +aalo; +aalp; +aalq; +aalr; +aals; +aalt; +aalu; +aalv; +aalw; +aalx; +aaly; +aalz; +aama; +aamb; +aamc; +aamd; +aame; +aamf; +aamg; +aamh; +aami; +aamj; +aamk; +aaml; +aamm; +aamn; +aamo; +aamp; +aamq; +aamr; +aams; +aamt; +aamu; +aamv; +aamw; +aamx; +aamy; +aamz; +aana; +aanb; +aanc; +aand; +aane; +aanf; +aang; +aanh; +aani; +aanj; +aank; +aanl; +aanm; +aann; +aano; +aanp; +aanq; +aanr; +aans; +aant; +aanu; +aanv; +aanw; +aanx; +aany; +aanz; +aaoa; +aaob; +aaoc; +aaod; +aaoe; +aaof; +aaog; +aaoh; +aaoi; +aaoj; +aaok; +aaol; +aaom; +aaon; +aaoo; +aaop; +aaoq; +aaor; +aaos; +aaot; +aaou; +aaov; +aaow; +aaox; +aaoy; +aaoz; +aapa; +aapb; +aapc; +aapd; +aape; +aapf; +aapg; +aaph; +aapi; +aapj; +aapk; +aapl; +aapm; +aapn; +aapo; +aapp; +aapq; +aapr; +aaps; +aapt; +aapu; +aapv; +aapw; +aapx; +aapy; +aapz; +aaqa; +aaqb; +aaqc; +aaqd; +aaqe; +aaqf; +aaqg; +aaqh; +aaqi; +aaqj; +aaqk; +aaql; +aaqm; +aaqn; +aaqo; +aaqp; +aaqq; +aaqr; +aaqs; +aaqt; +aaqu; +aaqv; +aaqw; +aaqx; +aaqy; +aaqz; +aara; +aarb; +aarc; +aard; +aare; +aarf; +aarg; +aarh; +aari; +aarj; +aark; +aarl; +aarm; +aarn; +aaro; +aarp; +aarq; +aarr; +aars; +aart; +aaru; +aarv; +aarw; +aarx; +aary; +aarz; +aasa; +aasb; +aasc; +aasd; +aase; +aasf; +aasg; +aash; +aasi; +aasj; +aask; +aasl; +aasm; +aasn; +aaso; +aasp; +aasq; +aasr; +aass; +aast; +aasu; +aasv; +aasw; +aasx; +aasy; +aasz; +aata; +aatb; +aatc; +aatd; +aate; +aatf; +aatg; +aath; +aati; +aatj; +aatk; +aatl; +aatm; +aatn; +aato; +aatp; +aatq; +aatr; +aats; +aatt; +aatu; +aatv; +aatw; +aatx; +aaty; +aatz; +aaua; +aaub; +aauc; +aaud; +aaue; +aauf; +aaug; +aauh; +aaui; +aauj; +aauk; +aaul; +aaum; +aaun; +aauo; +aaup; +aauq; +aaur; +aaus; +aaut; +aauu; +aauv; +aauw; +aaux; +aauy; +aauz; +aava; +aavb; +aavc; +aavd; +aave; +aavf; +aavg; +aavh; +aavi; +aavj; +aavk; +aavl; +aavm; +aavn; +aavo; +aavp; +aavq; +aavr; +aavs; +aavt; +aavu; +aavv; +aavw; +aavx; +aavy; +aavz; +aawa; +aawb; +aawc; +aawd; +aawe; +aawf; +aawg; +aawh; +aawi; +aawj; +aawk; +aawl; +aawm; +aawn; +aawo; +aawp; +aawq; +aawr; +aaws; +aawt; +aawu; +aawv; +aaww; +aawx; +aawy; +aawz; +aaxa; +aaxb; +aaxc; +aaxd; +aaxe; +aaxf; +aaxg; +aaxh; +aaxi; +aaxj; +aaxk; +aaxl; +aaxm; +aaxn; +aaxo; +aaxp; +aaxq; +aaxr; +aaxs; +aaxt; +aaxu; +aaxv; +aaxw; +aaxx; +aaxy; +aaxz; +aaya; +aayb; +aayc; +aayd; +aaye; +aayf; +aayg; +aayh; +aayi; +aayj; +aayk; +aayl; +aaym; +aayn; +aayo; +aayp; +aayq; +aayr; +aays; +aayt; +aayu; +aayv; +aayw; +aayx; +aayy; +aayz; +aaza; +aazb; +aazc; +aazd; +aaze; +aazf; +aazg; +aazh; +aazi; +aazj; +aazk; +aazl; +aazm; +aazn; +aazo; +aazp; +aazq; +aazr; +aazs; +aazt; +aazu; +aazv; +aazw; +aazx; +aazy; +aazz; +abaa; +abab; +abac; +abad; +abae; +abaf; +abag; +abah; +abai; +abaj; +abak; +abal; +abam; +aban; +abao; +abap; +abaq; +abar; +abas; +abat; +abau; +abav; +abaw; +abax; +abay; +abaz; +abba; +abbb; +abbc; +abbd; +abbe; +abbf; +abbg; +abbh; +abbi; +abbj; +abbk; +abbl; +abbm; +abbn; +abbo; +abbp; +abbq; +abbr; +abbs; +abbt; +abbu; +abbv; +abbw; +abbx; +abby; +abbz; +abca; +abcb; +abcc; +abcd; +abce; +abcf; +abcg; +abch; +abci; +abcj; +abck; +abcl; +abcm; +abcn; +abco; +abcp; +abcq; +abcr; +abcs; +abct; +abcu; +abcv; +abcw; +abcx; +abcy; +abcz; +abda; +abdb; +abdc; +abdd; +abde; +abdf; +abdg; +abdh; +abdi; +abdj; +abdk; +abdl; +abdm; +abdn; +abdo; +abdp; +abdq; +abdr; +abds; +abdt; +abdu; +abdv; +abdw; +abdx; +abdy; +abdz; +abea; +abeb; +abec; +abed; +abee; +abef; +abeg; +abeh; +abei; +abej; +abek; +abel; +abem; +aben; +abeo; +abep; +abeq; +aber; +abes; +abet; +abeu; +abev; +abew; +abex; +abey; +abez; +abfa; +abfb; +abfc; +abfd; +abfe; +abff; +abfg; +abfh; +abfi; +abfj; +abfk; +abfl; +abfm; +abfn; +abfo; +abfp; +abfq; +abfr; +abfs; +abft; +abfu; +abfv; +abfw; +abfx; +abfy; +abfz; +abga; +abgb; +abgc; +abgd; +abge; +abgf; +abgg; +abgh; +abgi; +abgj; +abgk; +abgl; +abgm; +abgn; +abgo; +abgp; +abgq; +abgr; +abgs; +abgt; +abgu; +abgv; +abgw; +abgx; +abgy; +abgz; +abha; +abhb; +abhc; +abhd; +abhe; +abhf; +abhg; +abhh; +abhi; +abhj; +abhk; +abhl; +abhm; +abhn; +abho; +abhp; +abhq; +abhr; +abhs; +abht; +abhu; +abhv; +abhw; +abhx; +abhy; +abhz; +abia; +abib; +abic; +abid; +abie; +abif; +abig; +abih; +abii; +abij; +abik; +abil; +abim; +abin; +abio; +abip; +abiq; +abir; +abis; +abit; +abiu; +abiv; +abiw; +abix; +abiy; +abiz; +abja; +abjb; +abjc; +abjd; +abje; +abjf; +abjg; +abjh; +abji; +abjj; +abjk; +abjl; +abjm; +abjn; +abjo; +abjp; +abjq; +abjr; +abjs; +abjt; +abju; +abjv; +abjw; +abjx; +abjy; +abjz; +abka; +abkb; +abkc; +abkd; +abke; +abkf; +abkg; +abkh; +abki; +abkj; +abkk; +abkl; +abkm; +abkn; +abko; +abkp; +abkq; +abkr; +abks; +abkt; +abku; +abkv; +abkw; +abkx; +abky; +abkz; +abla; +ablb; +ablc; +abld; +able; +ablf; +ablg; +ablh; +abli; +ablj; +ablk; +abll; +ablm; +abln; +ablo; +ablp; +ablq; +ablr; +abls; +ablt; +ablu; +ablv; +ablw; +ablx; +ably; +ablz; +abma; +abmb; +abmc; +abmd; +abme; +abmf; +abmg; +abmh; +abmi; +abmj; +abmk; +abml; +abmm; +abmn; +abmo; +abmp; +abmq; +abmr; +abms; +abmt; +abmu; +abmv; +abmw; +abmx; +abmy; +abmz; +abna; +abnb; +abnc; +abnd; +abne; +abnf; +abng; +abnh; +abni; +abnj; +abnk; +abnl; +abnm; +abnn; +abno; +abnp; +abnq; +abnr; +abns; +abnt; +abnu; +abnv; +abnw; +abnx; +abny; +abnz; +aboa; +abob; +aboc; +abod; +aboe; +abof; +abog; +aboh; +aboi; +aboj; +abok; +abol; +abom; +abon; +aboo; +abop; +aboq; +abor; +abos; +abot; +abou; +abov; +abow; +abox; +aboy; +aboz; +abpa; +abpb; +abpc; +abpd; +abpe; +abpf; +abpg; +abph; +abpi; +abpj; +abpk; +abpl; +abpm; +abpn; +abpo; +abpp; +abpq; +abpr; +abps; +abpt; +abpu; +abpv; +abpw; +abpx; +abpy; +abpz; +abqa; +abqb; +abqc; +abqd; +abqe; +abqf; +abqg; +abqh; +abqi; +abqj; +abqk; +abql; +abqm; +abqn; +abqo; +abqp; +abqq; +abqr; +abqs; +abqt; +abqu; +abqv; +abqw; +abqx; +abqy; +abqz; +abra; +abrb; +abrc; +abrd; +abre; +abrf; +abrg; +abrh; +abri; +abrj; +abrk; +abrl; +abrm; +abrn; +abro; +abrp; +abrq; +abrr; +abrs; +abrt; +abru; +abrv; +abrw; +abrx; +abry; +abrz; +absa; +absb; +absc; +absd; +abse; +absf; +absg; +absh; +absi; +absj; +absk; +absl; +absm; +absn; +abso; +absp; +absq; +absr; +abss; +abst; +absu; +absv; +absw; +absx; +absy; +absz; +abta; +abtb; +abtc; +abtd; +abte; +abtf; +abtg; +abth; +abti; +abtj; +abtk; +abtl; +abtm; +abtn; +abto; +abtp; +abtq; +abtr; +abts; +abtt; +abtu; +abtv; +abtw; +abtx; +abty; +abtz; +abua; +abub; +abuc; +abud; +abue; +abuf; +abug; +abuh; +abui; +abuj; +abuk; +abul; +abum; +abun; +abuo; +abup; +abuq; +abur; +abus; +abut; +abuu; +abuv; +abuw; +abux; +abuy; +abuz; +abva; +abvb; +abvc; +abvd; +abve; +abvf; +abvg; +abvh; +abvi; +abvj; +abvk; +abvl; +abvm; +abvn; +abvo; +abvp; +abvq; +abvr; +abvs; +abvt; +abvu; +abvv; +abvw; +abvx; +abvy; +abvz; +abwa; +abwb; +abwc; +abwd; +abwe; +abwf; +abwg; +abwh; +abwi; +abwj; +abwk; +abwl; +abwm; +abwn; +abwo; +abwp; +abwq; +abwr; +abws; +abwt; +abwu; +abwv; +abww; +abwx; +abwy; +abwz; +abxa; +abxb; +abxc; +abxd; +abxe; +abxf; +abxg; +abxh; +abxi; +abxj; +abxk; +abxl; +abxm; +abxn; +abxo; +abxp; +abxq; +abxr; +abxs; +abxt; +abxu; +abxv; +abxw; +abxx; +abxy; +abxz; +abya; +abyb; +abyc; +abyd; +abye; +abyf; +abyg; +abyh; +abyi; +abyj; +abyk; +abyl; +abym; +abyn; +abyo; +abyp; +abyq; +abyr; +abys; +abyt; +abyu; +abyv; +abyw; +abyx; +abyy; +abyz; +abza; +abzb; +abzc; +abzd; +abze; +abzf; +abzg; +abzh; +abzi; +abzj; +abzk; +abzl; +abzm; +abzn; +abzo; +abzp; +abzq; +abzr; +abzs; +abzt; +abzu; +abzv; +abzw; +abzx; +abzy; +abzz; +acaa; +acab; +acac; +acad; +acae; +acaf; +acag; +acah; +acai; +acaj; +acak; +acal; +acam; +acan; +acao; +acap; +acaq; +acar; +acas; +acat; +acau; +acav; +acaw; +acax; +acay; +acaz; +acba; +acbb; +acbc; +acbd; +acbe; +acbf; +acbg; +acbh; +acbi; +acbj; +acbk; +acbl; +acbm; +acbn; +acbo; +acbp; +acbq; +acbr; +acbs; +acbt; +acbu; +acbv; +acbw; +acbx; +acby; +acbz; +acca; +accb; +accc; +accd; +acce; +accf; +accg; +acch; +acci; +accj; +acck; +accl; +accm; +accn; +acco; +accp; +accq; +accr; +accs; +acct; +accu; +accv; +accw; +accx; +accy; +accz; +acda; +acdb; +acdc; +acdd; +acde; +acdf; +acdg; +acdh; +acdi; +acdj; +acdk; +acdl; +acdm; +acdn; +acdo; +acdp; +acdq; +acdr; +acds; +acdt; +acdu; +acdv; +acdw; +acdx; +acdy; +acdz; +acea; +aceb; +acec; +aced; +acee; +acef; +aceg; +aceh; +acei; +acej; +acek; +acel; +acem; +acen; +aceo; +acep; +aceq; +acer; +aces; +acet; +aceu; +acev; +acew; +acex; +acey; +acez; +acfa; +acfb; +acfc; +acfd; +acfe; +acff; +acfg; +acfh; +acfi; +acfj; +acfk; +acfl; +acfm; +acfn; +acfo; +acfp; +acfq; +acfr; +acfs; +acft; +acfu; +acfv; +acfw; +acfx; +acfy; +acfz; +acga; +acgb; +acgc; +acgd; +acge; +acgf; +acgg; +acgh; +acgi; +acgj; +acgk; +acgl; +acgm; +acgn; +acgo; +acgp; +acgq; +acgr; +acgs; +acgt; +acgu; +acgv; +acgw; +acgx; +acgy; +acgz; +acha; +achb; +achc; +achd; +ache; +achf; +achg; +achh; +achi; +achj; +achk; +achl; +achm; +achn; +acho; +achp; +achq; +achr; +achs; +acht; +achu; +achv; +achw; +achx; +achy; +achz; +acia; +acib; +acic; +acid; +acie; +acif; +acig; +acih; +acii; +acij; +acik; +acil; +acim; +acin; +acio; +acip; +aciq; +acir; +acis; +acit; +aciu; +aciv; +aciw; +acix; +aciy; +aciz; +acja; +acjb; +acjc; +acjd; +acje; +acjf; +acjg; +acjh; +acji; +acjj; +acjk; +acjl; +acjm; +acjn; +acjo; +acjp; +acjq; +acjr; +acjs; +acjt; +acju; +acjv; +acjw; +acjx; +acjy; +acjz; +acka; +ackb; +ackc; +ackd; +acke; +ackf; +ackg; +ackh; +acki; +ackj; +ackk; +ackl; +ackm; +ackn; +acko; +ackp; +ackq; +ackr; +acks; +ackt; +acku; +ackv; +ackw; +ackx; +acky; +ackz; +acla; +aclb; +aclc; +acld; +acle; +aclf; +aclg; +aclh; +acli; +aclj; +aclk; +acll; +aclm; +acln; +aclo; +aclp; +aclq; +aclr; +acls; +aclt; +aclu; +aclv; +aclw; +aclx; +acly; +aclz; +acma; +acmb; +acmc; +acmd; +acme; +acmf; +acmg; +acmh; +acmi; +acmj; +acmk; +acml; +acmm; +acmn; +acmo; +acmp; +acmq; +acmr; +acms; +acmt; +acmu; +acmv; +acmw; +acmx; +acmy; +acmz; +acna; +acnb; +acnc; +acnd; +acne; +acnf; +acng; +acnh; +acni; +acnj; +acnk; +acnl; +acnm; +acnn; +acno; +acnp; +acnq; +acnr; +acns; +acnt; +acnu; +acnv; +acnw; +acnx; +acny; +acnz; +acoa; +acob; +acoc; +acod; +acoe; +acof; +acog; +acoh; +acoi; +acoj; +acok; +acol; +acom; +acon; +acoo; +acop; +acoq; +acor; +acos; +acot; +acou; +acov; +acow; +acox; +acoy; +acoz; +acpa; +acpb; +acpc; +acpd; +acpe; +acpf; +acpg; +acph; +acpi; +acpj; +acpk; +acpl; +acpm; +acpn; +acpo; +acpp; +acpq; +acpr; +acps; +acpt; +acpu; +acpv; +acpw; +acpx; +acpy; +acpz; +acqa; +acqb; +acqc; +acqd; +acqe; +acqf; +acqg; +acqh; +acqi; +acqj; +acqk; +acql; +acqm; +acqn; +acqo; +acqp; +acqq; +acqr; +acqs; +acqt; +acqu; +acqv; +acqw; +acqx; +acqy; +acqz; +acra; +acrb; +acrc; +acrd; +acre; +acrf; +acrg; +acrh; +acri; +acrj; +acrk; +acrl; +acrm; +acrn; +acro; +acrp; +acrq; +acrr; +acrs; +acrt; +acru; +acrv; +acrw; +acrx; +acry; +acrz; +acsa; +acsb; +acsc; +acsd; +acse; +acsf; +acsg; +acsh; +acsi; +acsj; +acsk; +acsl; +acsm; +acsn; +acso; +acsp; +acsq; +acsr; +acss; +acst; +acsu; +acsv; +acsw; +acsx; +acsy; +acsz; +acta; +actb; +actc; +actd; +acte; +actf; +actg; +acth; +acti; +actj; +actk; +actl; +actm; +actn; +acto; +actp; +actq; +actr; +acts; +actt; +actu; +actv; +actw; +actx; +acty; +actz; +acua; +acub; +acuc; +acud; +acue; +acuf; +acug; +acuh; +acui; +acuj; +acuk; +acul; +acum; +acun; +acuo; +acup; +acuq; +acur; +acus; +acut; +acuu; +acuv; +acuw; +acux; +acuy; +acuz; +acva; +acvb; +acvc; +acvd; +acve; +acvf; +acvg; +acvh; +acvi; +acvj; +acvk; +acvl; +acvm; +acvn; +acvo; +acvp; +acvq; +acvr; +acvs; +acvt; +acvu; +acvv; +acvw; +acvx; +acvy; +acvz; +acwa; +acwb; +acwc; +acwd; +acwe; +acwf; +acwg; +acwh; +acwi; +acwj; +acwk; +acwl; +acwm; +acwn; +acwo; +acwp; +acwq; +acwr; +acws; +acwt; +acwu; +acwv; +acww; +acwx; +acwy; +acwz; +acxa; +acxb; +acxc; +acxd; +acxe; +acxf; +acxg; +acxh; +acxi; +acxj; +acxk; +acxl; +acxm; +acxn; +acxo; +acxp; +acxq; +acxr; +acxs; +acxt; +acxu; +acxv; +acxw; +acxx; +acxy; +acxz; +acya; +acyb; +acyc; +acyd; +acye; +acyf; +acyg; +acyh; +acyi; +acyj; +acyk; +acyl; +acym; +acyn; +acyo; +acyp; +acyq; +acyr; +acys; +acyt; +acyu; +acyv; +acyw; +acyx; +acyy; +acyz; +acza; +aczb; +aczc; +aczd; +acze; +aczf; +aczg; +aczh; +aczi; +aczj; +aczk; +aczl; +aczm; +aczn; +aczo; +aczp; +aczq; +aczr; +aczs; +aczt; +aczu; +aczv; +aczw; +aczx; +aczy; +aczz; +adaa; +adab; +adac; +adad; +adae; +adaf; +adag; +adah; +adai; +adaj; +adak; +adal; +adam; +adan; +adao; +adap; +adaq; +adar; +adas; +adat; +adau; +adav; +adaw; +adax; +aday; +adaz; +adba; +adbb; +adbc; +adbd; +adbe; +adbf; +adbg; +adbh; +adbi; +adbj; +adbk; +adbl; +adbm; +adbn; +adbo; +adbp; +adbq; +adbr; +adbs; +adbt; +adbu; +adbv; +adbw; +adbx; +adby; +adbz; +adca; +adcb; +adcc; +adcd; +adce; +adcf; +adcg; +adch; +adci; +adcj; +adck; +adcl; +adcm; +adcn; +adco; +adcp; +adcq; +adcr; +adcs; +adct; +adcu; +adcv; +adcw; +adcx; +adcy; +adcz; +adda; +addb; +addc; +addd; +adde; +addf; +addg; +addh; +addi; +addj; +addk; +addl; +addm; +addn; +addo; +addp; +addq; +addr; +adds; +addt; +addu; +addv; +addw; +addx; +addy; +addz; +adea; +adeb; +adec; +aded; +adee; +adef; +adeg; +adeh; +adei; +adej; +adek; +adel; +adem; +aden; +adeo; +adep; +adeq; +ader; +ades; +adet; +adeu; +adev; +adew; +adex; +adey; +adez; +adfa; +adfb; +adfc; +adfd; +adfe; +adff; +adfg; +adfh; +adfi; +adfj; +adfk; +adfl; +adfm; +adfn; +adfo; +adfp; +adfq; +adfr; +adfs; +adft; +adfu; +adfv; +adfw; +adfx; +adfy; +adfz; +adga; +adgb; +adgc; +adgd; +adge; +adgf; +adgg; +adgh; +adgi; +adgj; +adgk; +adgl; +adgm; +adgn; +adgo; +adgp; +adgq; +adgr; +adgs; +adgt; +adgu; +adgv; +adgw; +adgx; +adgy; +adgz; +adha; +adhb; +adhc; +adhd; +adhe; +adhf; +adhg; +adhh; +adhi; +adhj; +adhk; +adhl; +adhm; +adhn; +adho; +adhp; +adhq; +adhr; +adhs; +adht; +adhu; +adhv; +adhw; +adhx; +adhy; +adhz; +adia; +adib; +adic; +adid; +adie; +adif; +adig; +adih; +adii; +adij; +adik; +adil; +adim; +adin; +adio; +adip; +adiq; +adir; +adis; +adit; +adiu; +adiv; +adiw; +adix; +adiy; +adiz; +adja; +adjb; +adjc; +adjd; +adje; +adjf; +adjg; +adjh; +adji; +adjj; +adjk; +adjl; +adjm; +adjn; +adjo; +adjp; +adjq; +adjr; +adjs; +adjt; +adju; +adjv; +adjw; +adjx; +adjy; +adjz; +adka; +adkb; +adkc; +adkd; +adke; +adkf; +adkg; +adkh; +adki; +adkj; +adkk; +adkl; +adkm; +adkn; +adko; +adkp; +adkq; +adkr; +adks; +adkt; +adku; +adkv; +adkw; +adkx; +adky; +adkz; +adla; +adlb; +adlc; +adld; +adle; +adlf; +adlg; +adlh; +adli; +adlj; +adlk; +adll; +adlm; +adln; +adlo; +adlp; +adlq; +adlr; +adls; +adlt; +adlu; +adlv; +adlw; +adlx; +adly; +adlz; +adma; +admb; +admc; +admd; +adme; +admf; +admg; +admh; +admi; +admj; +admk; +adml; +admm; +admn; +admo; +admp; +admq; +admr; +adms; +admt; +admu; +admv; +admw; +admx; +admy; +admz; +adna; +adnb; +adnc; +adnd; +adne; +adnf; +adng; +adnh; +adni; +adnj; +adnk; +adnl; +adnm; +adnn; +adno; +adnp; +adnq; +adnr; +adns; +adnt; +adnu; +adnv; +adnw; +adnx; +adny; +adnz; +adoa; +adob; +adoc; +adod; +adoe; +adof; +adog; +adoh; +adoi; +adoj; +adok; +adol; +adom; +adon; +adoo; +adop; +adoq; +ador; +ados; +adot; +adou; +adov; +adow; +adox; +adoy; +adoz; +adpa; +adpb; +adpc; +adpd; +adpe; +adpf; +adpg; +adph; +adpi; +adpj; +adpk; +adpl; +adpm; +adpn; +adpo; +adpp; +adpq; +adpr; +adps; +adpt; +adpu; +adpv; +adpw; +adpx; +adpy; +adpz; +adqa; +adqb; +adqc; +adqd; +adqe; +adqf; +adqg; +adqh; +adqi; +adqj; +adqk; +adql; +adqm; +adqn; +adqo; +adqp; +adqq; +adqr; +adqs; +adqt; +adqu; +adqv; +adqw; +adqx; +adqy; +adqz; +adra; +adrb; +adrc; +adrd; +adre; +adrf; +adrg; +adrh; +adri; +adrj; +adrk; +adrl; +adrm; +adrn; +adro; +adrp; +adrq; +adrr; +adrs; +adrt; +adru; +adrv; +adrw; +adrx; +adry; +adrz; +adsa; +adsb; +adsc; +adsd; +adse; +adsf; +adsg; +adsh; +adsi; +adsj; +adsk; +adsl; +adsm; +adsn; +adso; +adsp; +adsq; +adsr; +adss; +adst; +adsu; +adsv; +adsw; +adsx; +adsy; +adsz; +adta; +adtb; +adtc; +adtd; +adte; +adtf; +adtg; +adth; +adti; +adtj; +adtk; +adtl; +adtm; +adtn; +adto; +adtp; +adtq; +adtr; +adts; +adtt; +adtu; +adtv; +adtw; +adtx; +adty; +adtz; +adua; +adub; +aduc; +adud; +adue; +aduf; +adug; +aduh; +adui; +aduj; +aduk; +adul; +adum; +adun; +aduo; +adup; +aduq; +adur; +adus; +adut; +aduu; +aduv; +aduw; +adux; +aduy; +aduz; +adva; +advb; +advc; +advd; +adve; +advf; +advg; +advh; +advi; +advj; +advk; +advl; +advm; +advn; +advo; +advp; +advq; +advr; +advs; +advt; +advu; +advv; +advw; +advx; +advy; +advz; +adwa; +adwb; +adwc; +adwd; +adwe; +adwf; +adwg; +adwh; +adwi; +adwj; +adwk; +adwl; +adwm; +adwn; +adwo; +adwp; +adwq; +adwr; +adws; +adwt; +adwu; +adwv; +adww; +adwx; +adwy; +adwz; +adxa; +adxb; +adxc; +adxd; +adxe; +adxf; +adxg; +adxh; +adxi; +adxj; +adxk; +adxl; +adxm; +adxn; +adxo; +adxp; +adxq; +adxr; +adxs; +adxt; +adxu; +adxv; +adxw; +adxx; +adxy; +adxz; +adya; +adyb; +adyc; +adyd; +adye; +adyf; +adyg; +adyh; +adyi; +adyj; +adyk; +adyl; +adym; +adyn; +adyo; +adyp; +adyq; +adyr; +adys; +adyt; +adyu; +adyv; +adyw; +adyx; +adyy; +adyz; +adza; +adzb; +adzc; +adzd; +adze; +adzf; +adzg; +adzh; +adzi; +adzj; +adzk; +adzl; +adzm; +adzn; +adzo; +adzp; +adzq; +adzr; +adzs; +adzt; +adzu; +adzv; +adzw; +adzx; +adzy; +adzz; +aeaa; +aeab; +aeac; +aead; +aeae; +aeaf; +aeag; +aeah; +aeai; +aeaj; +aeak; +aeal; +aeam; +aean; +aeao; +aeap; +aeaq; +aear; +aeas; +aeat; +aeau; +aeav; +aeaw; +aeax; +aeay; +aeaz; +aeba; +aebb; +aebc; +aebd; +aebe; +aebf; +aebg; +aebh; +aebi; +aebj; +aebk; +aebl; +aebm; +aebn; +aebo; +aebp; +aebq; +aebr; +aebs; +aebt; +aebu; +aebv; +aebw; +aebx; +aeby; +aebz; +aeca; +aecb; +aecc; +aecd; +aece; +aecf; +aecg; +aech; +aeci; +aecj; +aeck; +aecl; +aecm; +aecn; +aeco; +aecp; +aecq; +aecr; +aecs; +aect; +aecu; +aecv; +aecw; +aecx; +aecy; +aecz; +aeda; +aedb; +aedc; +aedd; +aede; +aedf; +aedg; +aedh; +aedi; +aedj; +aedk; +aedl; +aedm; +aedn; +aedo; +aedp; +aedq; +aedr; +aeds; +aedt; +aedu; +aedv; +aedw; +aedx; +aedy; +aedz; +aeea; +aeeb; +aeec; +aeed; +aeee; +aeef; +aeeg; +aeeh; +aeei; +aeej; +aeek; +aeel; +aeem; +aeen; +aeeo; +aeep; +aeeq; +aeer; +aees; +aeet; +aeeu; +aeev; +aeew; +aeex; +aeey; +aeez; +aefa; +aefb; +aefc; +aefd; +aefe; +aeff; +aefg; +aefh; +aefi; +aefj; +aefk; +aefl; +aefm; +aefn; +aefo; +aefp; +aefq; +aefr; +aefs; +aeft; +aefu; +aefv; +aefw; +aefx; +aefy; +aefz; +aega; +aegb; +aegc; +aegd; +aege; +aegf; +aegg; +aegh; +aegi; +aegj; +aegk; +aegl; +aegm; +aegn; +aego; +aegp; +aegq; +aegr; +aegs; +aegt; +aegu; +aegv; +aegw; +aegx; +aegy; +aegz; +aeha; +aehb; +aehc; +aehd; +aehe; +aehf; +aehg; +aehh; +aehi; +aehj; +aehk; +aehl; +aehm; +aehn; +aeho; +aehp; +aehq; +aehr; +aehs; +aeht; +aehu; +aehv; +aehw; +aehx; +aehy; +aehz; +aeia; +aeib; +aeic; +aeid; +aeie; +aeif; +aeig; +aeih; +aeii; +aeij; +aeik; +aeil; +aeim; +aein; +aeio; +aeip; +aeiq; +aeir; +aeis; +aeit; +aeiu; +aeiv; +aeiw; +aeix; +aeiy; +aeiz; +aeja; +aejb; +aejc; +aejd; +aeje; +aejf; +aejg; +aejh; +aeji; +aejj; +aejk; +aejl; +aejm; +aejn; +aejo; +aejp; +aejq; +aejr; +aejs; +aejt; +aeju; +aejv; +aejw; +aejx; +aejy; +aejz; +aeka; +aekb; +aekc; +aekd; +aeke; +aekf; +aekg; +aekh; +aeki; +aekj; +aekk; +aekl; +aekm; +aekn; +aeko; +aekp; +aekq; +aekr; +aeks; +aekt; +aeku; +aekv; +aekw; +aekx; +aeky; +aekz; +aela; +aelb; +aelc; +aeld; +aele; +aelf; +aelg; +aelh; +aeli; +aelj; +aelk; +aell; +aelm; +aeln; +aelo; +aelp; +aelq; +aelr; +aels; +aelt; +aelu; +aelv; +aelw; +aelx; +aely; +aelz; +aema; +aemb; +aemc; +aemd; +aeme; +aemf; +aemg; +aemh; +aemi; +aemj; +aemk; +aeml; +aemm; +aemn; +aemo; +aemp; +aemq; +aemr; +aems; +aemt; +aemu; +aemv; +aemw; +aemx; +aemy; +aemz; +aena; +aenb; +aenc; +aend; +aene; +aenf; +aeng; +aenh; +aeni; +aenj; +aenk; +aenl; +aenm; +aenn; +aeno; +aenp; +aenq; +aenr; +aens; +aent; +aenu; +aenv; +aenw; +aenx; +aeny; +aenz; +aeoa; +aeob; +aeoc; +aeod; +aeoe; +aeof; +aeog; +aeoh; +aeoi; +aeoj; +aeok; +aeol; +aeom; +aeon; +aeoo; +aeop; +aeoq; +aeor; +aeos; +aeot; +aeou; +aeov; +aeow; +aeox; +aeoy; +aeoz; +aepa; +aepb; +aepc; +aepd; +aepe; +aepf; +aepg; +aeph; +aepi; +aepj; +aepk; +aepl; +aepm; +aepn; +aepo; +aepp; +aepq; +aepr; +aeps; +aept; +aepu; +aepv; +aepw; +aepx; +aepy; +aepz; +aeqa; +aeqb; +aeqc; +aeqd; +aeqe; +aeqf; +aeqg; +aeqh; +aeqi; +aeqj; +aeqk; +aeql; +aeqm; +aeqn; +aeqo; +aeqp; +aeqq; +aeqr; +aeqs; +aeqt; +aequ; +aeqv; +aeqw; +aeqx; +aeqy; +aeqz; +aera; +aerb; +aerc; +aerd; +aere; +aerf; +aerg; +aerh; +aeri; +aerj; +aerk; +aerl; +aerm; +aern; +aero; +aerp; +aerq; +aerr; +aers; +aert; +aeru; +aerv; +aerw; +aerx; +aery; +aerz; +aesa; +aesb; +aesc; +aesd; +aese; +aesf; +aesg; +aesh; +aesi; +aesj; +aesk; +aesl; +aesm; +aesn; +aeso; +aesp; +aesq; +aesr; +aess; +aest; +aesu; +aesv; +aesw; +aesx; +aesy; +aesz; +aeta; +aetb; +aetc; +aetd; +aete; +aetf; +aetg; +aeth; +aeti; +aetj; +aetk; +aetl; +aetm; +aetn; +aeto; +aetp; +aetq; +aetr; +aets; +aett; +aetu; +aetv; +aetw; +aetx; +aety; +aetz; +aeua; +aeub; +aeuc; +aeud; +aeue; +aeuf; +aeug; +aeuh; +aeui; +aeuj; +aeuk; +aeul; +aeum; +aeun; +aeuo; +aeup; +aeuq; +aeur; +aeus; +aeut; +aeuu; +aeuv; +aeuw; +aeux; +aeuy; +aeuz; +aeva; +aevb; +aevc; +aevd; +aeve; +aevf; +aevg; +aevh; +aevi; +aevj; +aevk; +aevl; +aevm; +aevn; +aevo; +aevp; +aevq; +aevr; +aevs; +aevt; +aevu; +aevv; +aevw; +aevx; +aevy; +aevz; +aewa; +aewb; +aewc; +aewd; +aewe; +aewf; +aewg; +aewh; +aewi; +aewj; +aewk; +aewl; +aewm; +aewn; +aewo; +aewp; +aewq; +aewr; +aews; +aewt; +aewu; +aewv; +aeww; +aewx; +aewy; +aewz; +aexa; +aexb; +aexc; +aexd; +aexe; +aexf; +aexg; +aexh; +aexi; +aexj; +aexk; +aexl; +aexm; +aexn; +aexo; +aexp; +aexq; +aexr; +aexs; +aext; +aexu; +aexv; +aexw; +aexx; +aexy; +aexz; +aeya; +aeyb; +aeyc; +aeyd; +aeye; +aeyf; +aeyg; +aeyh; +aeyi; +aeyj; +aeyk; +aeyl; +aeym; +aeyn; +aeyo; +aeyp; +aeyq; +aeyr; +aeys; +aeyt; +aeyu; +aeyv; +aeyw; +aeyx; +aeyy; +aeyz; +aeza; +aezb; +aezc; +aezd; +aeze; +aezf; +aezg; +aezh; +aezi; +aezj; +aezk; +aezl; +aezm; +aezn; +aezo; +aezp; +aezq; +aezr; +aezs; +aezt; +aezu; +aezv; +aezw; +aezx; +aezy; +aezz; +afaa; +afab; +afac; +afad; +afae; +afaf; +afag; +afah; +afai; +afaj; +afak; +afal; +afam; +afan; +afao; +afap; +afaq; +afar; +afas; +afat; +afau; +afav; +afaw; +afax; +afay; +afaz; +afba; +afbb; +afbc; +afbd; +afbe; +afbf; +afbg; +afbh; +afbi; +afbj; +afbk; +afbl; +afbm; +afbn; +afbo; +afbp; +afbq; +afbr; +afbs; +afbt; +afbu; +afbv; +afbw; +afbx; +afby; +afbz; +afca; +afcb; +afcc; +afcd; +afce; +afcf; +afcg; +afch; +afci; +afcj; +afck; +afcl; +afcm; +afcn; +afco; +afcp; +afcq; +afcr; +afcs; +afct; +afcu; +afcv; +afcw; +afcx; +afcy; +afcz; +afda; +afdb; +afdc; +afdd; +afde; +afdf; +afdg; +afdh; +afdi; +afdj; +afdk; +afdl; +afdm; +afdn; +afdo; +afdp; +afdq; +afdr; +afds; +afdt; +afdu; +afdv; +afdw; +afdx; +afdy; +afdz; +afea; +afeb; +afec; +afed; +afee; +afef; +afeg; +afeh; +afei; +afej; +afek; +afel; +afem; +afen; +afeo; +afep; +afeq; +afer; +afes; +afet; +afeu; +afev; +afew; +afex; +afey; +afez; +affa; +affb; +affc; +affd; +affe; +afff; +affg; +affh; +affi; +affj; +affk; +affl; +affm; +affn; +affo; +affp; +affq; +affr; +affs; +afft; +affu; +affv; +affw; +affx; +affy; +affz; +afga; +afgb; +afgc; +afgd; +afge; +afgf; +afgg; +afgh; +afgi; +afgj; +afgk; +afgl; +afgm; +afgn; +afgo; +afgp; +afgq; +afgr; +afgs; +afgt; +afgu; +afgv; +afgw; +afgx; +afgy; +afgz; +afha; +afhb; +afhc; +afhd; +afhe; +afhf; +afhg; +afhh; +afhi; +afhj; +afhk; +afhl; +afhm; +afhn; +afho; +afhp; +afhq; +afhr; +afhs; +afht; +afhu; +afhv; +afhw; +afhx; +afhy; +afhz; +afia; +afib; +afic; +afid; +afie; +afif; +afig; +afih; +afii; +afij; +afik; +afil; +afim; +afin; +afio; +afip; +afiq; +afir; +afis; +afit; +afiu; +afiv; +afiw; +afix; +afiy; +afiz; +afja; +afjb; +afjc; +afjd; +afje; +afjf; +afjg; +afjh; +afji; +afjj; +afjk; +afjl; +afjm; +afjn; +afjo; +afjp; +afjq; +afjr; +afjs; +afjt; +afju; +afjv; +afjw; +afjx; +afjy; +afjz; +afka; +afkb; +afkc; +afkd; +afke; +afkf; +afkg; +afkh; +afki; +afkj; +afkk; +afkl; +afkm; +afkn; +afko; +afkp; +afkq; +afkr; +afks; +afkt; +afku; +afkv; +afkw; +afkx; +afky; +afkz; +afla; +aflb; +aflc; +afld; +afle; +aflf; +aflg; +aflh; +afli; +aflj; +aflk; +afll; +aflm; +afln; +aflo; +aflp; +aflq; +aflr; +afls; +aflt; +aflu; +aflv; +aflw; +aflx; +afly; +aflz; +afma; +afmb; +afmc; +afmd; +afme; +afmf; +afmg; +afmh; +afmi; +afmj; +afmk; +afml; +afmm; +afmn; +afmo; +afmp; +afmq; +afmr; +afms; +afmt; +afmu; +afmv; +afmw; +afmx; +afmy; +afmz; +afna; +afnb; +afnc; +afnd; +afne; +afnf; +afng; +afnh; +afni; +afnj; +afnk; +afnl; +afnm; +afnn; +afno; +afnp; +afnq; +afnr; +afns; +afnt; +afnu; +afnv; +afnw; +afnx; +afny; +afnz; +afoa; +afob; +afoc; +afod; +afoe; +afof; +afog; +afoh; +afoi; +afoj; +afok; +afol; +afom; +afon; +afoo; +afop; +afoq; +afor; +afos; +afot; +afou; +afov; +afow; +afox; +afoy; +afoz; +afpa; +afpb; +afpc; +afpd; +afpe; +afpf; +afpg; +afph; +afpi; +afpj; +afpk; +afpl; +afpm; +afpn; +afpo; +afpp; +afpq; +afpr; +afps; +afpt; +afpu; +afpv; +afpw; +afpx; +afpy; +afpz; +afqa; +afqb; +afqc; +afqd; +afqe; +afqf; +afqg; +afqh; +afqi; +afqj; +afqk; +afql; +afqm; +afqn; +afqo; +afqp; +afqq; +afqr; +afqs; +afqt; +afqu; +afqv; +afqw; +afqx; +afqy; +afqz; +afra; +afrb; +afrc; +afrd; +afre; +afrf; +afrg; +afrh; +afri; +afrj; +afrk; +afrl; +afrm; +afrn; +afro; +afrp; +afrq; +afrr; +afrs; +afrt; +afru; +afrv; +afrw; +afrx; +afry; +afrz; +afsa; +afsb; +afsc; +afsd; +afse; +afsf; +afsg; +afsh; +afsi; +afsj; +afsk; +afsl; +afsm; +afsn; +afso; +afsp; +afsq; +afsr; +afss; +afst; +afsu; +afsv; +afsw; +afsx; +afsy; +afsz; +afta; +aftb; +aftc; +aftd; +afte; +aftf; +aftg; +afth; +afti; +aftj; +aftk; +aftl; +aftm; +aftn; +afto; +aftp; +aftq; +aftr; +afts; +aftt; +aftu; +aftv; +aftw; +aftx; +afty; +aftz; +afua; +afub; +afuc; +afud; +afue; +afuf; +afug; +afuh; +afui; +afuj; +afuk; +aful; +afum; +afun; +afuo; +afup; +afuq; +afur; +afus; +afut; +afuu; +afuv; +afuw; +afux; +afuy; +afuz; +afva; +afvb; +afvc; +afvd; +afve; +afvf; +afvg; +afvh; +afvi; +afvj; +afvk; +afvl; +afvm; +afvn; +afvo; +afvp; +afvq; +afvr; +afvs; +afvt; +afvu; +afvv; +afvw; +afvx; +afvy; +afvz; +afwa; +afwb; +afwc; +afwd; +afwe; +afwf; +afwg; +afwh; +afwi; +afwj; +afwk; +afwl; +afwm; +afwn; +afwo; +afwp; +afwq; +afwr; +afws; +afwt; +afwu; +afwv; +afww; +afwx; +afwy; +afwz; +afxa; +afxb; +afxc; +afxd; +afxe; +afxf; +afxg; +afxh; +afxi; +afxj; +afxk; +afxl; +afxm; +afxn; +afxo; +afxp; +afxq; +afxr; +afxs; +afxt; +afxu; +afxv; +afxw; +afxx; +afxy; +afxz; +afya; +afyb; +afyc; +afyd; +afye; +afyf; +afyg; +afyh; +afyi; +afyj; +afyk; +afyl; +afym; +afyn; +afyo; +afyp; +afyq; +afyr; +afys; +afyt; +afyu; +afyv; +afyw; +afyx; +afyy; +afyz; +afza; +afzb; +afzc; +afzd; +afze; +afzf; +afzg; +afzh; +afzi; +afzj; +afzk; +afzl; +afzm; +afzn; +afzo; +afzp; +afzq; +afzr; +afzs; +afzt; +afzu; +afzv; +afzw; +afzx; +afzy; +afzz; +agaa; +agab; +agac; +agad; +agae; +agaf; +agag; +agah; +agai; +agaj; +agak; +agal; +agam; +agan; +agao; +agap; +agaq; +agar; +agas; +agat; +agau; +agav; +agaw; +agax; +agay; +agaz; +agba; +agbb; +agbc; +agbd; +agbe; +agbf; +agbg; +agbh; +agbi; +agbj; +agbk; +agbl; +agbm; +agbn; +agbo; +agbp; +agbq; +agbr; +agbs; +agbt; +agbu; +agbv; +agbw; +agbx; +agby; +agbz; +agca; +agcb; +agcc; +agcd; +agce; +agcf; +agcg; +agch; +agci; +agcj; +agck; +agcl; +agcm; +agcn; +agco; +agcp; +agcq; +agcr; +agcs; +agct; +agcu; +agcv; +agcw; +agcx; +agcy; +agcz; +agda; +agdb; +agdc; +agdd; +agde; +agdf; +agdg; +agdh; +agdi; +agdj; +agdk; +agdl; +agdm; +agdn; +agdo; +agdp; +agdq; +agdr; +agds; +agdt; +agdu; +agdv; +agdw; +agdx; +agdy; +agdz; +agea; +ageb; +agec; +aged; +agee; +agef; +ageg; +ageh; +agei; +agej; +agek; +agel; +agem; +agen; +ageo; +agep; +ageq; +ager; +ages; +aget; +ageu; +agev; +agew; +agex; +agey; +agez; +agfa; +agfb; +agfc; +agfd; +agfe; +agff; +agfg; +agfh; +agfi; +agfj; +agfk; +agfl; +agfm; +agfn; +agfo; +agfp; +agfq; +agfr; +agfs; +agft; +agfu; +agfv; +agfw; +agfx; +agfy; +agfz; +agga; +aggb; +aggc; +aggd; +agge; +aggf; +aggg; +aggh; +aggi; +aggj; +aggk; +aggl; +aggm; +aggn; +aggo; +aggp; +aggq; +aggr; +aggs; +aggt; +aggu; +aggv; +aggw; +aggx; +aggy; +aggz; +agha; +aghb; +aghc; +aghd; +aghe; +aghf; +aghg; +aghh; +aghi; +aghj; +aghk; +aghl; +aghm; +aghn; +agho; +aghp; +aghq; +aghr; +aghs; +aght; +aghu; +aghv; +aghw; +aghx; +aghy; +aghz; +agia; +agib; +agic; +agid; +agie; +agif; +agig; +agih; +agii; +agij; +agik; +agil; +agim; +agin; +agio; +agip; +agiq; +agir; +agis; +agit; +agiu; +agiv; +agiw; +agix; +agiy; +agiz; +agja; +agjb; +agjc; +agjd; +agje; +agjf; +agjg; +agjh; +agji; +agjj; +agjk; +agjl; +agjm; +agjn; +agjo; +agjp; +agjq; +agjr; +agjs; +agjt; +agju; +agjv; +agjw; +agjx; +agjy; +agjz; +agka; +agkb; +agkc; +agkd; +agke; +agkf; +agkg; +agkh; +agki; +agkj; +agkk; +agkl; +agkm; +agkn; +agko; +agkp; +agkq; +agkr; +agks; +agkt; +agku; +agkv; +agkw; +agkx; +agky; +agkz; +agla; +aglb; +aglc; +agld; +agle; +aglf; +aglg; +aglh; +agli; +aglj; +aglk; +agll; +aglm; +agln; +aglo; +aglp; +aglq; +aglr; +agls; +aglt; +aglu; +aglv; +aglw; +aglx; +agly; +aglz; +agma; +agmb; +agmc; +agmd; +agme; +agmf; +agmg; +agmh; +agmi; +agmj; +agmk; +agml; +agmm; +agmn; +agmo; +agmp; +agmq; +agmr; +agms; +agmt; +agmu; +agmv; +agmw; +agmx; +agmy; +agmz; +agna; +agnb; +agnc; +agnd; +agne; +agnf; +agng; +agnh; +agni; +agnj; +agnk; +agnl; +agnm; +agnn; +agno; +agnp; +agnq; +agnr; +agns; +agnt; +agnu; +agnv; +agnw; +agnx; +agny; +agnz; +agoa; +agob; +agoc; +agod; +agoe; +agof; +agog; +agoh; +agoi; +agoj; +agok; +agol; +agom; +agon; +agoo; +agop; +agoq; +agor; +agos; +agot; +agou; +agov; +agow; +agox; +agoy; +agoz; +agpa; +agpb; +agpc; +agpd; +agpe; +agpf; +agpg; +agph; +agpi; +agpj; +agpk; +agpl; +agpm; +agpn; +agpo; +agpp; +agpq; +agpr; +agps; +agpt; +agpu; +agpv; +agpw; +agpx; +agpy; +agpz; +agqa; +agqb; +agqc; +agqd; +agqe; +agqf; +agqg; +agqh; +agqi; +agqj; +agqk; +agql; +agqm; +agqn; +agqo; +agqp; +agqq; +agqr; +agqs; +agqt; +agqu; +agqv; +agqw; +agqx; +agqy; +agqz; +agra; +agrb; +agrc; +agrd; +agre; +agrf; +agrg; +agrh; +agri; +agrj; +agrk; +agrl; +agrm; +agrn; +agro; +agrp; +agrq; +agrr; +agrs; +agrt; +agru; +agrv; +agrw; +agrx; +agry; +agrz; +agsa; +agsb; +agsc; +agsd; +agse; +agsf; +agsg; +agsh; +agsi; +agsj; +agsk; +agsl; +agsm; +agsn; +agso; +agsp; +agsq; +agsr; +agss; +agst; +agsu; +agsv; +agsw; +agsx; +agsy; +agsz; +agta; +agtb; +agtc; +agtd; +agte; +agtf; +agtg; +agth; +agti; +agtj; +agtk; +agtl; +agtm; +agtn; +agto; +agtp; +agtq; +agtr; +agts; +agtt; +agtu; +agtv; +agtw; +agtx; +agty; +agtz; +agua; +agub; +aguc; +agud; +ague; +aguf; +agug; +aguh; +agui; +aguj; +aguk; +agul; +agum; +agun; +aguo; +agup; +aguq; +agur; +agus; +agut; +aguu; +aguv; +aguw; +agux; +aguy; +aguz; +agva; +agvb; +agvc; +agvd; +agve; +agvf; +agvg; +agvh; +agvi; +agvj; +agvk; +agvl; +agvm; +agvn; +agvo; +agvp; +agvq; +agvr; +agvs; +agvt; +agvu; +agvv; +agvw; +agvx; +agvy; +agvz; +agwa; +agwb; +agwc; +agwd; +agwe; +agwf; +agwg; +agwh; +agwi; +agwj; +agwk; +agwl; +agwm; +agwn; +agwo; +agwp; +agwq; +agwr; +agws; +agwt; +agwu; +agwv; +agww; +agwx; +agwy; +agwz; +agxa; +agxb; +agxc; +agxd; +agxe; +agxf; +agxg; +agxh; +agxi; +agxj; +agxk; +agxl; +agxm; +agxn; +agxo; +agxp; +agxq; +agxr; +agxs; +agxt; +agxu; +agxv; +agxw; +agxx; +agxy; +agxz; +agya; +agyb; +agyc; +agyd; +agye; +agyf; +agyg; +agyh; +agyi; +agyj; +agyk; +agyl; +agym; +agyn; +agyo; +agyp; +agyq; +agyr; +agys; +agyt; +agyu; +agyv; +agyw; +agyx; +agyy; +agyz; +agza; +agzb; +agzc; +agzd; +agze; +agzf; +agzg; +agzh; +agzi; +agzj; +agzk; +agzl; +agzm; +agzn; +agzo; +agzp; +agzq; +agzr; +agzs; +agzt; +agzu; +agzv; +agzw; +agzx; +agzy; +agzz; +ahaa; +ahab; +ahac; +ahad; +ahae; +ahaf; +ahag; +ahah; +ahai; +ahaj; +ahak; +ahal; +aham; +ahan; +ahao; +ahap; +ahaq; +ahar; +ahas; +ahat; +ahau; +ahav; +ahaw; +ahax; +ahay; +ahaz; +ahba; +ahbb; +ahbc; +ahbd; +ahbe; +ahbf; +ahbg; +ahbh; +ahbi; +ahbj; +ahbk; +ahbl; +ahbm; +ahbn; +ahbo; +ahbp; +ahbq; +ahbr; +ahbs; +ahbt; +ahbu; +ahbv; +ahbw; +ahbx; +ahby; +ahbz; +ahca; +ahcb; +ahcc; +ahcd; +ahce; +ahcf; +ahcg; +ahch; +ahci; +ahcj; +ahck; +ahcl; +ahcm; +ahcn; +ahco; +ahcp; +ahcq; +ahcr; +ahcs; +ahct; +ahcu; +ahcv; +ahcw; +ahcx; +ahcy; +ahcz; +ahda; +ahdb; +ahdc; +ahdd; +ahde; +ahdf; +ahdg; +ahdh; +ahdi; +ahdj; +ahdk; +ahdl; +ahdm; +ahdn; +ahdo; +ahdp; +ahdq; +ahdr; +ahds; +ahdt; +ahdu; +ahdv; +ahdw; +ahdx; +ahdy; +ahdz; +ahea; +aheb; +ahec; +ahed; +ahee; +ahef; +aheg; +aheh; +ahei; +ahej; +ahek; +ahel; +ahem; +ahen; +aheo; +ahep; +aheq; +aher; +ahes; +ahet; +aheu; +ahev; +ahew; +ahex; +ahey; +ahez; +ahfa; +ahfb; +ahfc; +ahfd; +ahfe; +ahff; +ahfg; +ahfh; +ahfi; +ahfj; +ahfk; +ahfl; +ahfm; +ahfn; +ahfo; +ahfp; +ahfq; +ahfr; +ahfs; +ahft; +ahfu; +ahfv; +ahfw; +ahfx; +ahfy; +ahfz; +ahga; +ahgb; +ahgc; +ahgd; +ahge; +ahgf; +ahgg; +ahgh; +ahgi; +ahgj; +ahgk; +ahgl; +ahgm; +ahgn; +ahgo; +ahgp; +ahgq; +ahgr; +ahgs; +ahgt; +ahgu; +ahgv; +ahgw; +ahgx; +ahgy; +ahgz; +ahha; +ahhb; +ahhc; +ahhd; +ahhe; +ahhf; +ahhg; +ahhh; +ahhi; +ahhj; +ahhk; +ahhl; +ahhm; +ahhn; +ahho; +ahhp; +ahhq; +ahhr; +ahhs; +ahht; +ahhu; +ahhv; +ahhw; +ahhx; +ahhy; +ahhz; +ahia; +ahib; +ahic; +ahid; +ahie; +ahif; +ahig; +ahih; +ahii; +ahij; +ahik; +ahil; +ahim; +ahin; +ahio; +ahip; +ahiq; +ahir; +ahis; +ahit; +ahiu; +ahiv; +ahiw; +ahix; +ahiy; +ahiz; +ahja; +ahjb; +ahjc; +ahjd; +ahje; +ahjf; +ahjg; +ahjh; +ahji; +ahjj; +ahjk; +ahjl; +ahjm; +ahjn; +ahjo; +ahjp; +ahjq; +ahjr; +ahjs; +ahjt; +ahju; +ahjv; +ahjw; +ahjx; +ahjy; +ahjz; +ahka; +ahkb; +ahkc; +ahkd; +ahke; +ahkf; +ahkg; +ahkh; +ahki; +ahkj; +ahkk; +ahkl; +ahkm; +ahkn; +ahko; +ahkp; +ahkq; +ahkr; +ahks; +ahkt; +ahku; +ahkv; +ahkw; +ahkx; +ahky; +ahkz; +ahla; +ahlb; +ahlc; +ahld; +ahle; +ahlf; +ahlg; +ahlh; +ahli; +ahlj; +ahlk; +ahll; +ahlm; +ahln; +ahlo; +ahlp; +ahlq; +ahlr; +ahls; +ahlt; +ahlu; +ahlv; +ahlw; +ahlx; +ahly; +ahlz; +ahma; +ahmb; +ahmc; +ahmd; +ahme; +ahmf; +ahmg; +ahmh; +ahmi; +ahmj; +ahmk; +ahml; +ahmm; +ahmn; +ahmo; +ahmp; +ahmq; +ahmr; +ahms; +ahmt; +ahmu; +ahmv; +ahmw; +ahmx; +ahmy; +ahmz; +ahna; +ahnb; +ahnc; +ahnd; +ahne; +ahnf; +ahng; +ahnh; +ahni; +ahnj; +ahnk; +ahnl; +ahnm; +ahnn; +ahno; +ahnp; +ahnq; +ahnr; +ahns; +ahnt; +ahnu; +ahnv; +ahnw; +ahnx; +ahny; +ahnz; +ahoa; +ahob; +ahoc; +ahod; +ahoe; +ahof; +ahog; +ahoh; +ahoi; +ahoj; +ahok; +ahol; +ahom; +ahon; +ahoo; +ahop; +ahoq; +ahor; +ahos; +ahot; +ahou; +ahov; +ahow; +ahox; +ahoy; +ahoz; +ahpa; +ahpb; +ahpc; +ahpd; +ahpe; +ahpf; +ahpg; +ahph; +ahpi; +ahpj; +ahpk; +ahpl; +ahpm; +ahpn; +ahpo; +ahpp; +ahpq; +ahpr; +ahps; +ahpt; +ahpu; +ahpv; +ahpw; +ahpx; +ahpy; +ahpz; +ahqa; +ahqb; +ahqc; +ahqd; +ahqe; +ahqf; +ahqg; +ahqh; +ahqi; +ahqj; +ahqk; +ahql; +ahqm; +ahqn; +ahqo; +ahqp; +ahqq; +ahqr; +ahqs; +ahqt; +ahqu; +ahqv; +ahqw; +ahqx; +ahqy; +ahqz; +ahra; +ahrb; +ahrc; +ahrd; +ahre; +ahrf; +ahrg; +ahrh; +ahri; +ahrj; +ahrk; +ahrl; +ahrm; +ahrn; +ahro; +ahrp; +ahrq; +ahrr; +ahrs; +ahrt; +ahru; +ahrv; +ahrw; +ahrx; +ahry; +ahrz; +ahsa; +ahsb; +ahsc; +ahsd; +ahse; +ahsf; +ahsg; +ahsh; +ahsi; +ahsj; +ahsk; +ahsl; +ahsm; +ahsn; +ahso; +ahsp; +ahsq; +ahsr; +ahss; +ahst; +ahsu; +ahsv; +ahsw; +ahsx; +ahsy; +ahsz; +ahta; +ahtb; +ahtc; +ahtd; +ahte; +ahtf; +ahtg; +ahth; +ahti; +ahtj; +ahtk; +ahtl; +ahtm; +ahtn; +ahto; +ahtp; +ahtq; +ahtr; +ahts; +ahtt; +ahtu; +ahtv; +ahtw; +ahtx; +ahty; +ahtz; +ahua; +ahub; +ahuc; +ahud; +ahue; +ahuf; +ahug; +ahuh; +ahui; +ahuj; +ahuk; +ahul; +ahum; +ahun; +ahuo; +ahup; +ahuq; +ahur; +ahus; +ahut; +ahuu; +ahuv; +ahuw; +ahux; +ahuy; +ahuz; +ahva; +ahvb; +ahvc; +ahvd; +ahve; +ahvf; +ahvg; +ahvh; +ahvi; +ahvj; +ahvk; +ahvl; +ahvm; +ahvn; +ahvo; +ahvp; +ahvq; +ahvr; +ahvs; +ahvt; +ahvu; +ahvv; +ahvw; +ahvx; +ahvy; +ahvz; +ahwa; +ahwb; +ahwc; +ahwd; +ahwe; +ahwf; +ahwg; +ahwh; +ahwi; +ahwj; +ahwk; +ahwl; +ahwm; +ahwn; +ahwo; +ahwp; +ahwq; +ahwr; +ahws; +ahwt; +ahwu; +ahwv; +ahww; +ahwx; +ahwy; +ahwz; +ahxa; +ahxb; +ahxc; +ahxd; +ahxe; +ahxf; +ahxg; +ahxh; +ahxi; +ahxj; +ahxk; +ahxl; +ahxm; +ahxn; +ahxo; +ahxp; +ahxq; +ahxr; +ahxs; +ahxt; +ahxu; +ahxv; +ahxw; +ahxx; +ahxy; +ahxz; +ahya; +ahyb; +ahyc; +ahyd; +ahye; +ahyf; +ahyg; +ahyh; +ahyi; +ahyj; +ahyk; +ahyl; +ahym; +ahyn; +ahyo; +ahyp; +ahyq; +ahyr; +ahys; +ahyt; +ahyu; +ahyv; +ahyw; +ahyx; +ahyy; +ahyz; +ahza; +ahzb; +ahzc; +ahzd; +ahze; +ahzf; +ahzg; +ahzh; +ahzi; +ahzj; +ahzk; +ahzl; +ahzm; +ahzn; +ahzo; +ahzp; +ahzq; +ahzr; +ahzs; +ahzt; +ahzu; +ahzv; +ahzw; +ahzx; +ahzy; +ahzz; +aiaa; +aiab; +aiac; +aiad; +aiae; +aiaf; +aiag; +aiah; +aiai; +aiaj; +aiak; +aial; +aiam; +aian; +aiao; +aiap; +aiaq; +aiar; +aias; +aiat; +aiau; +aiav; +aiaw; +aiax; +aiay; +aiaz; +aiba; +aibb; +aibc; +aibd; +aibe; +aibf; +aibg; +aibh; +aibi; +aibj; +aibk; +aibl; +aibm; +aibn; +aibo; +aibp; +aibq; +aibr; +aibs; +aibt; +aibu; +aibv; +aibw; +aibx; +aiby; +aibz; +aica; +aicb; +aicc; +aicd; +aice; +aicf; +aicg; +aich; +aici; +aicj; +aick; +aicl; +aicm; +aicn; +aico; +aicp; +aicq; +aicr; +aics; +aict; +aicu; +aicv; +aicw; +aicx; +aicy; +aicz; +aida; +aidb; +aidc; +aidd; +aide; +aidf; +aidg; +aidh; +aidi; +aidj; +aidk; +aidl; +aidm; +aidn; +aido; +aidp; +aidq; +aidr; +aids; +aidt; +aidu; +aidv; +aidw; +aidx; +aidy; +aidz; +aiea; +aieb; +aiec; +aied; +aiee; +aief; +aieg; +aieh; +aiei; +aiej; +aiek; +aiel; +aiem; +aien; +aieo; +aiep; +aieq; +aier; +aies; +aiet; +aieu; +aiev; +aiew; +aiex; +aiey; +aiez; +aifa; +aifb; +aifc; +aifd; +aife; +aiff; +aifg; +aifh; +aifi; +aifj; +aifk; +aifl; +aifm; +aifn; +aifo; +aifp; +aifq; +aifr; +aifs; +aift; +aifu; +aifv; +aifw; +aifx; +aify; +aifz; +aiga; +aigb; +aigc; +aigd; +aige; +aigf; +aigg; +aigh; +aigi; +aigj; +aigk; +aigl; +aigm; +aign; +aigo; +aigp; +aigq; +aigr; +aigs; +aigt; +aigu; +aigv; +aigw; +aigx; +aigy; +aigz; +aiha; +aihb; +aihc; +aihd; +aihe; +aihf; +aihg; +aihh; +aihi; +aihj; +aihk; +aihl; +aihm; +aihn; +aiho; +aihp; +aihq; +aihr; +aihs; +aiht; +aihu; +aihv; +aihw; +aihx; +aihy; +aihz; +aiia; +aiib; +aiic; +aiid; +aiie; +aiif; +aiig; +aiih; +aiii; +aiij; +aiik; +aiil; +aiim; +aiin; +aiio; +aiip; +aiiq; +aiir; +aiis; +aiit; +aiiu; +aiiv; +aiiw; +aiix; +aiiy; +aiiz; +aija; +aijb; +aijc; +aijd; +aije; +aijf; +aijg; +aijh; +aiji; +aijj; +aijk; +aijl; +aijm; +aijn; +aijo; +aijp; +aijq; +aijr; +aijs; +aijt; +aiju; +aijv; +aijw; +aijx; +aijy; +aijz; +aika; +aikb; +aikc; +aikd; +aike; +aikf; +aikg; +aikh; +aiki; +aikj; +aikk; +aikl; +aikm; +aikn; +aiko; +aikp; +aikq; +aikr; +aiks; +aikt; +aiku; +aikv; +aikw; +aikx; +aiky; +aikz; +aila; +ailb; +ailc; +aild; +aile; +ailf; +ailg; +ailh; +aili; +ailj; +ailk; +aill; +ailm; +ailn; +ailo; +ailp; +ailq; +ailr; +ails; +ailt; +ailu; +ailv; +ailw; +ailx; +aily; +ailz; +aima; +aimb; +aimc; +aimd; +aime; +aimf; +aimg; +aimh; +aimi; +aimj; +aimk; +aiml; +aimm; +aimn; +aimo; +aimp; +aimq; +aimr; +aims; +aimt; +aimu; +aimv; +aimw; +aimx; +aimy; +aimz; +aina; +ainb; +ainc; +aind; +aine; +ainf; +aing; +ainh; +aini; +ainj; +aink; +ainl; +ainm; +ainn; +aino; +ainp; +ainq; +ainr; +ains; +aint; +ainu; +ainv; +ainw; +ainx; +ainy; +ainz; +aioa; +aiob; +aioc; +aiod; +aioe; +aiof; +aiog; +aioh; +aioi; +aioj; +aiok; +aiol; +aiom; +aion; +aioo; +aiop; +aioq; +aior; +aios; +aiot; +aiou; +aiov; +aiow; +aiox; +aioy; +aioz; +aipa; +aipb; +aipc; +aipd; +aipe; +aipf; +aipg; +aiph; +aipi; +aipj; +aipk; +aipl; +aipm; +aipn; +aipo; +aipp; +aipq; +aipr; +aips; +aipt; +aipu; +aipv; +aipw; +aipx; +aipy; +aipz; +aiqa; +aiqb; +aiqc; +aiqd; +aiqe; +aiqf; +aiqg; +aiqh; +aiqi; +aiqj; +aiqk; +aiql; +aiqm; +aiqn; +aiqo; +aiqp; +aiqq; +aiqr; +aiqs; +aiqt; +aiqu; +aiqv; +aiqw; +aiqx; +aiqy; +aiqz; +aira; +airb; +airc; +aird; +aire; +airf; +airg; +airh; +airi; +airj; +airk; +airl; +airm; +airn; +airo; +airp; +airq; +airr; +airs; +airt; +airu; +airv; +airw; +airx; +airy; +airz; +aisa; +aisb; +aisc; +aisd; +aise; +aisf; +aisg; +aish; +aisi; +aisj; +aisk; +aisl; +aism; +aisn; +aiso; +aisp; +aisq; +aisr; +aiss; +aist; +aisu; +aisv; +aisw; +aisx; +aisy; +aisz; +aita; +aitb; +aitc; +aitd; +aite; +aitf; +aitg; +aith; +aiti; +aitj; +aitk; +aitl; +aitm; +aitn; +aito; +aitp; +aitq; +aitr; +aits; +aitt; +aitu; +aitv; +aitw; +aitx; +aity; +aitz; +aiua; +aiub; +aiuc; +aiud; +aiue; +aiuf; +aiug; +aiuh; +aiui; +aiuj; +aiuk; +aiul; +aium; +aiun; +aiuo; +aiup; +aiuq; +aiur; +aius; +aiut; +aiuu; +aiuv; +aiuw; +aiux; +aiuy; +aiuz; +aiva; +aivb; +aivc; +aivd; +aive; +aivf; +aivg; +aivh; +aivi; +aivj; +aivk; +aivl; +aivm; +aivn; +aivo; +aivp; +aivq; +aivr; +aivs; +aivt; +aivu; +aivv; +aivw; +aivx; +aivy; +aivz; +aiwa; +aiwb; +aiwc; +aiwd; +aiwe; +aiwf; +aiwg; +aiwh; +aiwi; +aiwj; +aiwk; +aiwl; +aiwm; +aiwn; +aiwo; +aiwp; +aiwq; +aiwr; +aiws; +aiwt; +aiwu; +aiwv; +aiww; +aiwx; +aiwy; +aiwz; +aixa; +aixb; +aixc; +aixd; +aixe; +aixf; +aixg; +aixh; +aixi; +aixj; +aixk; +aixl; +aixm; +aixn; +aixo; +aixp; +aixq; +aixr; +aixs; +aixt; +aixu; +aixv; +aixw; +aixx; +aixy; +aixz; +aiya; +aiyb; +aiyc; +aiyd; +aiye; +aiyf; +aiyg; +aiyh; +aiyi; +aiyj; +aiyk; +aiyl; +aiym; +aiyn; +aiyo; +aiyp; +aiyq; +aiyr; +aiys; +aiyt; +aiyu; +aiyv; +aiyw; +aiyx; +aiyy; +aiyz; +aiza; +aizb; +aizc; +aizd; +aize; +aizf; +aizg; +aizh; +aizi; +aizj; +aizk; +aizl; +aizm; +aizn; +aizo; +aizp; +aizq; +aizr; +aizs; +aizt; +aizu; +aizv; +aizw; +aizx; +aizy; +aizz; +ajaa; +ajab; +ajac; +ajad; +ajae; +ajaf; +ajag; +ajah; +ajai; +ajaj; +ajak; +ajal; +ajam; +ajan; +ajao; +ajap; +ajaq; +ajar; +ajas; +ajat; +ajau; +ajav; +ajaw; +ajax; +ajay; +ajaz; +ajba; +ajbb; +ajbc; +ajbd; +ajbe; +ajbf; +ajbg; +ajbh; +ajbi; +ajbj; +ajbk; +ajbl; +ajbm; +ajbn; +ajbo; +ajbp; +ajbq; +ajbr; +ajbs; +ajbt; +ajbu; +ajbv; +ajbw; +ajbx; +ajby; +ajbz; +ajca; +ajcb; +ajcc; +ajcd; +ajce; +ajcf; +ajcg; +ajch; +ajci; +ajcj; +ajck; +ajcl; +ajcm; +ajcn; +ajco; +ajcp; +ajcq; +ajcr; +ajcs; +ajct; +ajcu; +ajcv; +ajcw; +ajcx; +ajcy; +ajcz; +ajda; +ajdb; +ajdc; +ajdd; +ajde; +ajdf; +ajdg; +ajdh; +ajdi; +ajdj; +ajdk; +ajdl; +ajdm; +ajdn; +ajdo; +ajdp; +ajdq; +ajdr; +ajds; +ajdt; +ajdu; +ajdv; +ajdw; +ajdx; +ajdy; +ajdz; +ajea; +ajeb; +ajec; +ajed; +ajee; +ajef; +ajeg; +ajeh; +ajei; +ajej; +ajek; +ajel; +ajem; +ajen; +ajeo; +ajep; +ajeq; +ajer; +ajes; +ajet; +ajeu; +ajev; +ajew; +ajex; +ajey; +ajez; +ajfa; +ajfb; +ajfc; +ajfd; +ajfe; +ajff; +ajfg; +ajfh; +ajfi; +ajfj; +ajfk; +ajfl; +ajfm; +ajfn; +ajfo; +ajfp; +ajfq; +ajfr; +ajfs; +ajft; +ajfu; +ajfv; +ajfw; +ajfx; +ajfy; +ajfz; +ajga; +ajgb; +ajgc; +ajgd; +ajge; +ajgf; +ajgg; +ajgh; +ajgi; +ajgj; +ajgk; +ajgl; +ajgm; +ajgn; +ajgo; +ajgp; +ajgq; +ajgr; +ajgs; +ajgt; +ajgu; +ajgv; +ajgw; +ajgx; +ajgy; +ajgz; +ajha; +ajhb; +ajhc; +ajhd; +ajhe; +ajhf; +ajhg; +ajhh; +ajhi; +ajhj; +ajhk; +ajhl; +ajhm; +ajhn; +ajho; +ajhp; +ajhq; +ajhr; +ajhs; +ajht; +ajhu; +ajhv; +ajhw; +ajhx; +ajhy; +ajhz; +ajia; +ajib; +ajic; +ajid; +ajie; +ajif; +ajig; +ajih; +ajii; +ajij; +ajik; +ajil; +ajim; +ajin; +ajio; +ajip; +ajiq; +ajir; +ajis; +ajit; +ajiu; +ajiv; +ajiw; +ajix; +ajiy; +ajiz; +ajja; +ajjb; +ajjc; +ajjd; +ajje; +ajjf; +ajjg; +ajjh; +ajji; +ajjj; +ajjk; +ajjl; +ajjm; +ajjn; +ajjo; +ajjp; +ajjq; +ajjr; +ajjs; +ajjt; +ajju; +ajjv; +ajjw; +ajjx; +ajjy; +ajjz; +ajka; +ajkb; +ajkc; +ajkd; +ajke; +ajkf; +ajkg; +ajkh; +ajki; +ajkj; +ajkk; +ajkl; +ajkm; +ajkn; +ajko; +ajkp; +ajkq; +ajkr; +ajks; +ajkt; +ajku; +ajkv; +ajkw; +ajkx; +ajky; +ajkz; +ajla; +ajlb; +ajlc; +ajld; +ajle; +ajlf; +ajlg; +ajlh; +ajli; +ajlj; +ajlk; +ajll; +ajlm; +ajln; +ajlo; +ajlp; +ajlq; +ajlr; +ajls; +ajlt; +ajlu; +ajlv; +ajlw; +ajlx; +ajly; +ajlz; +ajma; +ajmb; +ajmc; +ajmd; +ajme; +ajmf; +ajmg; +ajmh; +ajmi; +ajmj; +ajmk; +ajml; +ajmm; +ajmn; +ajmo; +ajmp; +ajmq; +ajmr; +ajms; +ajmt; +ajmu; +ajmv; +ajmw; +ajmx; +ajmy; +ajmz; +ajna; +ajnb; +ajnc; +ajnd; +ajne; +ajnf; +ajng; +ajnh; +ajni; +ajnj; +ajnk; +ajnl; +ajnm; +ajnn; +ajno; +ajnp; +ajnq; +ajnr; +ajns; +ajnt; +ajnu; +ajnv; +ajnw; +ajnx; +ajny; +ajnz; +ajoa; +ajob; +ajoc; +ajod; +ajoe; +ajof; +ajog; +ajoh; +ajoi; +ajoj; +ajok; +ajol; +ajom; +ajon; +ajoo; +ajop; +ajoq; +ajor; +ajos; +ajot; +ajou; +ajov; +ajow; +ajox; +ajoy; +ajoz; +ajpa; +ajpb; +ajpc; +ajpd; +ajpe; +ajpf; +ajpg; +ajph; +ajpi; +ajpj; +ajpk; +ajpl; +ajpm; +ajpn; +ajpo; +ajpp; +ajpq; +ajpr; +ajps; +ajpt; +ajpu; +ajpv; +ajpw; +ajpx; +ajpy; +ajpz; +ajqa; +ajqb; +ajqc; +ajqd; +ajqe; +ajqf; +ajqg; +ajqh; +ajqi; +ajqj; +ajqk; +ajql; +ajqm; +ajqn; +ajqo; +ajqp; +ajqq; +ajqr; +ajqs; +ajqt; +ajqu; +ajqv; +ajqw; +ajqx; +ajqy; +ajqz; +ajra; +ajrb; +ajrc; +ajrd; +ajre; +ajrf; +ajrg; +ajrh; +ajri; +ajrj; +ajrk; +ajrl; +ajrm; +ajrn; +ajro; +ajrp; +ajrq; +ajrr; +ajrs; +ajrt; +ajru; +ajrv; +ajrw; +ajrx; +ajry; +ajrz; +ajsa; +ajsb; +ajsc; +ajsd; +ajse; +ajsf; +ajsg; +ajsh; +ajsi; +ajsj; +ajsk; +ajsl; +ajsm; +ajsn; +ajso; +ajsp; +ajsq; +ajsr; +ajss; +ajst; +ajsu; +ajsv; +ajsw; +ajsx; +ajsy; +ajsz; +ajta; +ajtb; +ajtc; +ajtd; +ajte; +ajtf; +ajtg; +ajth; +ajti; +ajtj; +ajtk; +ajtl; +ajtm; +ajtn; +ajto; +ajtp; +ajtq; +ajtr; +ajts; +ajtt; +ajtu; +ajtv; +ajtw; +ajtx; +ajty; +ajtz; +ajua; +ajub; +ajuc; +ajud; +ajue; +ajuf; +ajug; +ajuh; +ajui; +ajuj; +ajuk; +ajul; +ajum; +ajun; +ajuo; +ajup; +ajuq; +ajur; +ajus; +ajut; +ajuu; +ajuv; +ajuw; +ajux; +ajuy; +ajuz; +ajva; +ajvb; +ajvc; +ajvd; +ajve; +ajvf; +ajvg; +ajvh; +ajvi; +ajvj; +ajvk; +ajvl; +ajvm; +ajvn; +ajvo; +ajvp; +ajvq; +ajvr; +ajvs; +ajvt; +ajvu; +ajvv; +ajvw; +ajvx; +ajvy; +ajvz; +ajwa; +ajwb; +ajwc; +ajwd; +ajwe; +ajwf; +ajwg; +ajwh; +ajwi; +ajwj; +ajwk; +ajwl; +ajwm; +ajwn; +ajwo; +ajwp; +ajwq; +ajwr; +ajws; +ajwt; +ajwu; +ajwv; +ajww; +ajwx; +ajwy; +ajwz; +ajxa; +ajxb; +ajxc; +ajxd; +ajxe; +ajxf; +ajxg; +ajxh; +ajxi; +ajxj; +ajxk; +ajxl; +ajxm; +ajxn; +ajxo; +ajxp; +ajxq; +ajxr; +ajxs; +ajxt; +ajxu; +ajxv; +ajxw; +ajxx; +ajxy; +ajxz; +ajya; +ajyb; +ajyc; +ajyd; +ajye; +ajyf; +ajyg; +ajyh; +ajyi; +ajyj; +ajyk; +ajyl; +ajym; +ajyn; +ajyo; +ajyp; +ajyq; +ajyr; +ajys; +ajyt; +ajyu; +ajyv; +ajyw; +ajyx; +ajyy; +ajyz; +ajza; +ajzb; +ajzc; +ajzd; +ajze; +ajzf; +ajzg; +ajzh; +ajzi; +ajzj; +ajzk; +ajzl; +ajzm; +ajzn; +ajzo; +ajzp; +ajzq; +ajzr; +ajzs; +ajzt; +ajzu; +ajzv; +ajzw; +ajzx; +ajzy; +ajzz; +akaa; +akab; +akac; +akad; +akae; +akaf; +akag; +akah; +akai; +akaj; +akak; +akal; +akam; +akan; +akao; +akap; +akaq; +akar; +akas; +akat; +akau; +akav; +akaw; +akax; +akay; +akaz; +akba; +akbb; +akbc; +akbd; +akbe; +akbf; +akbg; +akbh; +akbi; +akbj; +akbk; +akbl; +akbm; +akbn; +akbo; +akbp; +akbq; +akbr; +akbs; +akbt; +akbu; +akbv; +akbw; +akbx; +akby; +akbz; +akca; +akcb; +akcc; +akcd; +akce; +akcf; +akcg; +akch; +akci; +akcj; +akck; +akcl; +akcm; +akcn; +akco; +akcp; +akcq; +akcr; +akcs; +akct; +akcu; +akcv; +akcw; +akcx; +akcy; +akcz; +akda; +akdb; +akdc; +akdd; +akde; +akdf; +akdg; +akdh; +akdi; +akdj; +akdk; +akdl; +akdm; +akdn; +akdo; +akdp; +akdq; +akdr; +akds; +akdt; +akdu; +akdv; +akdw; +akdx; +akdy; +akdz; +akea; +akeb; +akec; +aked; +akee; +akef; +akeg; +akeh; +akei; +akej; +akek; +akel; +akem; +aken; +akeo; +akep; +akeq; +aker; +akes; +aket; +akeu; +akev; +akew; +akex; +akey; +akez; +akfa; +akfb; +akfc; +akfd; +akfe; +akff; +akfg; +akfh; +akfi; +akfj; +akfk; +akfl; +akfm; +akfn; +akfo; +akfp; +akfq; +akfr; +akfs; +akft; +akfu; +akfv; +akfw; +akfx; +akfy; +akfz; +akga; +akgb; +akgc; +akgd; +akge; +akgf; +akgg; +akgh; +akgi; +akgj; +akgk; +akgl; +akgm; +akgn; +akgo; +akgp; +akgq; +akgr; +akgs; +akgt; +akgu; +akgv; +akgw; +akgx; +akgy; +akgz; +akha; +akhb; +akhc; +akhd; +akhe; +akhf; +akhg; +akhh; +akhi; +akhj; +akhk; +akhl; +akhm; +akhn; +akho; +akhp; +akhq; +akhr; +akhs; +akht; +akhu; +akhv; +akhw; +akhx; +akhy; +akhz; +akia; +akib; +akic; +akid; +akie; +akif; +akig; +akih; +akii; +akij; +akik; +akil; +akim; +akin; +akio; +akip; +akiq; +akir; +akis; +akit; +akiu; +akiv; +akiw; +akix; +akiy; +akiz; +akja; +akjb; +akjc; +akjd; +akje; +akjf; +akjg; +akjh; +akji; +akjj; +akjk; +akjl; +akjm; +akjn; +akjo; +akjp; +akjq; +akjr; +akjs; +akjt; +akju; +akjv; +akjw; +akjx; +akjy; +akjz; +akka; +akkb; +akkc; +akkd; +akke; +akkf; +akkg; +akkh; +akki; +akkj; +akkk; +akkl; +akkm; +akkn; +akko; +akkp; +akkq; +akkr; +akks; +akkt; +akku; +akkv; +akkw; +akkx; +akky; +akkz; +akla; +aklb; +aklc; +akld; +akle; +aklf; +aklg; +aklh; +akli; +aklj; +aklk; +akll; +aklm; +akln; +aklo; +aklp; +aklq; +aklr; +akls; +aklt; +aklu; +aklv; +aklw; +aklx; +akly; +aklz; +akma; +akmb; +akmc; +akmd; +akme; +akmf; +akmg; +akmh; +akmi; +akmj; +akmk; +akml; +akmm; +akmn; +akmo; +akmp; +akmq; +akmr; +akms; +akmt; +akmu; +akmv; +akmw; +akmx; +akmy; +akmz; +akna; +aknb; +aknc; +aknd; +akne; +aknf; +akng; +aknh; +akni; +aknj; +aknk; +aknl; +aknm; +aknn; +akno; +aknp; +aknq; +aknr; +akns; +aknt; +aknu; +aknv; +aknw; +aknx; +akny; +aknz; +akoa; +akob; +akoc; +akod; +akoe; +akof; +akog; +akoh; +akoi; +akoj; +akok; +akol; +akom; +akon; +akoo; +akop; +akoq; +akor; +akos; +akot; +akou; +akov; +akow; +akox; +akoy; +akoz; +akpa; +akpb; +akpc; +akpd; +akpe; +akpf; +akpg; +akph; +akpi; +akpj; +akpk; +akpl; +akpm; +akpn; +akpo; +akpp; +akpq; +akpr; +akps; +akpt; +akpu; +akpv; +akpw; +akpx; +akpy; +akpz; +akqa; +akqb; +akqc; +akqd; +akqe; +akqf; +akqg; +akqh; +akqi; +akqj; +akqk; +akql; +akqm; +akqn; +akqo; +akqp; +akqq; +akqr; +akqs; +akqt; +akqu; +akqv; +akqw; +akqx; +akqy; +akqz; +akra; +akrb; +akrc; +akrd; +akre; +akrf; +akrg; +akrh; +akri; +akrj; +akrk; +akrl; +akrm; +akrn; +akro; +akrp; +akrq; +akrr; +akrs; +akrt; +akru; +akrv; +akrw; +akrx; +akry; +akrz; +aksa; +aksb; +aksc; +aksd; +akse; +aksf; +aksg; +aksh; +aksi; +aksj; +aksk; +aksl; +aksm; +aksn; +akso; +aksp; +aksq; +aksr; +akss; +akst; +aksu; +aksv; +aksw; +aksx; +aksy; +aksz; +akta; +aktb; +aktc; +aktd; +akte; +aktf; +aktg; +akth; +akti; +aktj; +aktk; +aktl; +aktm; +aktn; +akto; +aktp; +aktq; +aktr; +akts; +aktt; +aktu; +aktv; +aktw; +aktx; +akty; +aktz; +akua; +akub; +akuc; +akud; +akue; +akuf; +akug; +akuh; +akui; +akuj; +akuk; +akul; +akum; +akun; +akuo; +akup; +akuq; +akur; +akus; +akut; +akuu; +akuv; +akuw; +akux; +akuy; +akuz; +akva; +akvb; +akvc; +akvd; +akve; +akvf; +akvg; +akvh; +akvi; +akvj; +akvk; +akvl; +akvm; +akvn; +akvo; +akvp; +akvq; +akvr; +akvs; +akvt; +akvu; +akvv; +akvw; +akvx; +akvy; +akvz; +akwa; +akwb; +akwc; +akwd; +akwe; +akwf; +akwg; +akwh; +akwi; +akwj; +akwk; +akwl; +akwm; +akwn; +akwo; +akwp; +akwq; +akwr; +akws; +akwt; +akwu; +akwv; +akww; +akwx; +akwy; +akwz; +akxa; +akxb; +akxc; +akxd; +akxe; +akxf; +akxg; +akxh; +akxi; +akxj; +akxk; +akxl; +akxm; +akxn; +akxo; +akxp; +akxq; +akxr; +akxs; +akxt; +akxu; +akxv; +akxw; +akxx; +akxy; +akxz; +akya; +akyb; +akyc; +akyd; +akye; +akyf; +akyg; +akyh; +akyi; +akyj; +akyk; +akyl; +akym; +akyn; +akyo; +akyp; +akyq; +akyr; +akys; +akyt; +akyu; +akyv; +akyw; +akyx; +akyy; +akyz; +akza; +akzb; +akzc; +akzd; +akze; +akzf; +akzg; +akzh; +akzi; +akzj; +akzk; +akzl; +akzm; +akzn; +akzo; +akzp; +akzq; +akzr; +akzs; +akzt; +akzu; +akzv; +akzw; +akzx; +akzy; +akzz; +alaa; +alab; +alac; +alad; +alae; +alaf; +alag; +alah; +alai; +alaj; +alak; +alal; +alam; +alan; +alao; +alap; +alaq; +alar; +alas; +alat; +alau; +alav; +alaw; +alax; +alay; +alaz; +alba; +albb; +albc; +albd; +albe; +albf; +albg; +albh; +albi; +albj; +albk; +albl; +albm; +albn; +albo; +albp; +albq; +albr; +albs; +albt; +albu; +albv; +albw; +albx; +alby; +albz; +alca; +alcb; +alcc; +alcd; +alce; +alcf; +alcg; +alch; +alci; +alcj; +alck; +alcl; +alcm; +alcn; +alco; +alcp; +alcq; +alcr; +alcs; +alct; +alcu; +alcv; +alcw; +alcx; +alcy; +alcz; +alda; +aldb; +aldc; +aldd; +alde; +aldf; +aldg; +aldh; +aldi; +aldj; +aldk; +aldl; +aldm; +aldn; +aldo; +aldp; +aldq; +aldr; +alds; +aldt; +aldu; +aldv; +aldw; +aldx; +aldy; +aldz; +alea; +aleb; +alec; +aled; +alee; +alef; +aleg; +aleh; +alei; +alej; +alek; +alel; +alem; +alen; +aleo; +alep; +aleq; +aler; +ales; +alet; +aleu; +alev; +alew; +alex; +aley; +alez; +alfa; +alfb; +alfc; +alfd; +alfe; +alff; +alfg; +alfh; +alfi; +alfj; +alfk; +alfl; +alfm; +alfn; +alfo; +alfp; +alfq; +alfr; +alfs; +alft; +alfu; +alfv; +alfw; +alfx; +alfy; +alfz; +alga; +algb; +algc; +algd; +alge; +algf; +algg; +algh; +algi; +algj; +algk; +algl; +algm; +algn; +algo; +algp; +algq; +algr; +algs; +algt; +algu; +algv; +algw; +algx; +algy; +algz; +alha; +alhb; +alhc; +alhd; +alhe; +alhf; +alhg; +alhh; +alhi; +alhj; +alhk; +alhl; +alhm; +alhn; +alho; +alhp; +alhq; +alhr; +alhs; +alht; +alhu; +alhv; +alhw; +alhx; +alhy; +alhz; +alia; +alib; +alic; +alid; +alie; +alif; +alig; +alih; +alii; +alij; +alik; +alil; +alim; +alin; +alio; +alip; +aliq; +alir; +alis; +alit; +aliu; +aliv; +aliw; +alix; +aliy; +aliz; +alja; +aljb; +aljc; +aljd; +alje; +aljf; +aljg; +aljh; +alji; +aljj; +aljk; +aljl; +aljm; +aljn; +aljo; +aljp; +aljq; +aljr; +aljs; +aljt; +alju; +aljv; +aljw; +aljx; +aljy; +aljz; +alka; +alkb; +alkc; +alkd; +alke; +alkf; +alkg; +alkh; +alki; +alkj; +alkk; +alkl; +alkm; +alkn; +alko; +alkp; +alkq; +alkr; +alks; +alkt; +alku; +alkv; +alkw; +alkx; +alky; +alkz; +alla; +allb; +allc; +alld; +alle; +allf; +allg; +allh; +alli; +allj; +allk; +alll; +allm; +alln; +allo; +allp; +allq; +allr; +alls; +allt; +allu; +allv; +allw; +allx; +ally; +allz; +alma; +almb; +almc; +almd; +alme; +almf; +almg; +almh; +almi; +almj; +almk; +alml; +almm; +almn; +almo; +almp; +almq; +almr; +alms; +almt; +almu; +almv; +almw; +almx; +almy; +almz; +alna; +alnb; +alnc; +alnd; +alne; +alnf; +alng; +alnh; +alni; +alnj; +alnk; +alnl; +alnm; +alnn; +alno; +alnp; +alnq; +alnr; +alns; +alnt; +alnu; +alnv; +alnw; +alnx; +alny; +alnz; +aloa; +alob; +aloc; +alod; +aloe; +alof; +alog; +aloh; +aloi; +aloj; +alok; +alol; +alom; +alon; +aloo; +alop; +aloq; +alor; +alos; +alot; +alou; +alov; +alow; +alox; +aloy; +aloz; +alpa; +alpb; +alpc; +alpd; +alpe; +alpf; +alpg; +alph; +alpi; +alpj; +alpk; +alpl; +alpm; +alpn; +alpo; +alpp; +alpq; +alpr; +alps; +alpt; +alpu; +alpv; +alpw; +alpx; +alpy; +alpz; +alqa; +alqb; +alqc; +alqd; +alqe; +alqf; +alqg; +alqh; +alqi; +alqj; +alqk; +alql; +alqm; +alqn; +alqo; +alqp; +alqq; +alqr; +alqs; +alqt; +alqu; +alqv; +alqw; +alqx; +alqy; +alqz; +alra; +alrb; +alrc; +alrd; +alre; +alrf; +alrg; +alrh; +alri; +alrj; +alrk; +alrl; +alrm; +alrn; +alro; +alrp; +alrq; +alrr; +alrs; +alrt; +alru; +alrv; +alrw; +alrx; +alry; +alrz; +alsa; +alsb; +alsc; +alsd; +alse; +alsf; +alsg; +alsh; +alsi; +alsj; +alsk; +alsl; +alsm; +alsn; +also; +alsp; +alsq; +alsr; +alss; +alst; +alsu; +alsv; +alsw; +alsx; +alsy; +alsz; +alta; +altb; +altc; +altd; +alte; +altf; +altg; +alth; +alti; +altj; +altk; +altl; +altm; +altn; +alto; +altp; +altq; +altr; +alts; +altt; +altu; +altv; +altw; +altx; +alty; +altz; +alua; +alub; +aluc; +alud; +alue; +aluf; +alug; +aluh; +alui; +aluj; +aluk; +alul; +alum; +alun; +aluo; +alup; +aluq; +alur; +alus; +alut; +aluu; +aluv; +aluw; +alux; +aluy; +aluz; +alva; +alvb; +alvc; +alvd; +alve; +alvf; +alvg; +alvh; +alvi; +alvj; +alvk; +alvl; +alvm; +alvn; +alvo; +alvp; +alvq; +alvr; +alvs; +alvt; +alvu; +alvv; +alvw; +alvx; +alvy; +alvz; +alwa; +alwb; +alwc; +alwd; +alwe; +alwf; +alwg; +alwh; +alwi; +alwj; +alwk; +alwl; +alwm; +alwn; +alwo; +alwp; +alwq; +alwr; +alws; +alwt; +alwu; +alwv; +alww; +alwx; +alwy; +alwz; +alxa; +alxb; +alxc; +alxd; +alxe; +alxf; +alxg; +alxh; +alxi; +alxj; +alxk; +alxl; +alxm; +alxn; +alxo; +alxp; +alxq; +alxr; +alxs; +alxt; +alxu; +alxv; +alxw; +alxx; +alxy; +alxz; +alya; +alyb; +alyc; +alyd; +alye; +alyf; +alyg; +alyh; +alyi; +alyj; +alyk; +alyl; +alym; +alyn; +alyo; +alyp; +alyq; +alyr; +alys; +alyt; +alyu; +alyv; +alyw; +alyx; +alyy; +alyz; +alza; +alzb; +alzc; +alzd; +alze; +alzf; +alzg; +alzh; +alzi; +alzj; +alzk; +alzl; +alzm; +alzn; +alzo; +alzp; +alzq; +alzr; +alzs; +alzt; +alzu; +alzv; +alzw; +alzx; +alzy; +alzz; +amaa; +amab; +amac; +amad; +amae; +amaf; +amag; +amah; +amai; +amaj; +amak; +amal; +amam; +aman; +amao; +amap; +amaq; +amar; +amas; +amat; +amau; +amav; +amaw; +amax; +amay; +amaz; +amba; +ambb; +ambc; +ambd; +ambe; +ambf; +ambg; +ambh; +ambi; +ambj; +ambk; +ambl; +ambm; +ambn; +ambo; +ambp; +ambq; +ambr; +ambs; +ambt; +ambu; +ambv; +ambw; +ambx; +amby; +ambz; +amca; +amcb; +amcc; +amcd; +amce; +amcf; +amcg; +amch; +amci; +amcj; +amck; +amcl; +amcm; +amcn; +amco; +amcp; +amcq; +amcr; +amcs; +amct; +amcu; +amcv; +amcw; +amcx; +amcy; +amcz; +amda; +amdb; +amdc; +amdd; +amde; +amdf; +amdg; +amdh; +amdi; +amdj; +amdk; +amdl; +amdm; +amdn; +amdo; +amdp; +amdq; +amdr; +amds; +amdt; +amdu; +amdv; +amdw; +amdx; +amdy; +amdz; +amea; +ameb; +amec; +amed; +amee; +amef; +ameg; +ameh; +amei; +amej; +amek; +amel; +amem; +amen; +ameo; +amep; +ameq; +amer; +ames; +amet; +ameu; +amev; +amew; +amex; +amey; +amez; +amfa; +amfb; +amfc; +amfd; +amfe; +amff; +amfg; +amfh; +amfi; +amfj; +amfk; +amfl; +amfm; +amfn; +amfo; +amfp; +amfq; +amfr; +amfs; +amft; +amfu; +amfv; +amfw; +amfx; +amfy; +amfz; +amga; +amgb; +amgc; +amgd; +amge; +amgf; +amgg; +amgh; +amgi; +amgj; +amgk; +amgl; +amgm; +amgn; +amgo; +amgp; +amgq; +amgr; +amgs; +amgt; +amgu; +amgv; +amgw; +amgx; +amgy; +amgz; +amha; +amhb; +amhc; +amhd; +amhe; +amhf; +amhg; +amhh; +amhi; +amhj; +amhk; +amhl; +amhm; +amhn; +amho; +amhp; +amhq; +amhr; +amhs; +amht; +amhu; +amhv; +amhw; +amhx; +amhy; +amhz; +amia; +amib; +amic; +amid; +amie; +amif; +amig; +amih; +amii; +amij; +amik; +amil; +amim; +amin; +amio; +amip; +amiq; +amir; +amis; +amit; +amiu; +amiv; +amiw; +amix; +amiy; +amiz; +amja; +amjb; +amjc; +amjd; +amje; +amjf; +amjg; +amjh; +amji; +amjj; +amjk; +amjl; +amjm; +amjn; +amjo; +amjp; +amjq; +amjr; +amjs; +amjt; +amju; +amjv; +amjw; +amjx; +amjy; +amjz; +amka; +amkb; +amkc; +amkd; +amke; +amkf; +amkg; +amkh; +amki; +amkj; +amkk; +amkl; +amkm; +amkn; +amko; +amkp; +amkq; +amkr; +amks; +amkt; +amku; +amkv; +amkw; +amkx; +amky; +amkz; +amla; +amlb; +amlc; +amld; +amle; +amlf; +amlg; +amlh; +amli; +amlj; +amlk; +amll; +amlm; +amln; +amlo; +amlp; +amlq; +amlr; +amls; +amlt; +amlu; +amlv; +amlw; +amlx; +amly; +amlz; +amma; +ammb; +ammc; +ammd; +amme; +ammf; +ammg; +ammh; +ammi; +ammj; +ammk; +amml; +ammm; +ammn; +ammo; +ammp; +ammq; +ammr; +amms; +ammt; +ammu; +ammv; +ammw; +ammx; +ammy; +ammz; +amna; +amnb; +amnc; +amnd; +amne; +amnf; +amng; +amnh; +amni; +amnj; +amnk; +amnl; +amnm; +amnn; +amno; +amnp; +amnq; +amnr; +amns; +amnt; +amnu; +amnv; +amnw; +amnx; +amny; +amnz; +amoa; +amob; +amoc; +amod; +amoe; +amof; +amog; +amoh; +amoi; +amoj; +amok; +amol; +amom; +amon; +amoo; +amop; +amoq; +amor; +amos; +amot; +amou; +amov; +amow; +amox; +amoy; +amoz; +ampa; +ampb; +ampc; +ampd; +ampe; +ampf; +ampg; +amph; +ampi; +ampj; +ampk; +ampl; +ampm; +ampn; +ampo; +ampp; +ampq; +ampr; +amps; +ampt; +ampu; +ampv; +ampw; +ampx; +ampy; +ampz; +amqa; +amqb; +amqc; +amqd; +amqe; +amqf; +amqg; +amqh; +amqi; +amqj; +amqk; +amql; +amqm; +amqn; +amqo; +amqp; +amqq; +amqr; +amqs; +amqt; +amqu; +amqv; +amqw; +amqx; +amqy; +amqz; +amra; +amrb; +amrc; +amrd; +amre; +amrf; +amrg; +amrh; +amri; +amrj; +amrk; +amrl; +amrm; +amrn; +amro; +amrp; +amrq; +amrr; +amrs; +amrt; +amru; +amrv; +amrw; +amrx; +amry; +amrz; +amsa; +amsb; +amsc; +amsd; +amse; +amsf; +amsg; +amsh; +amsi; +amsj; +amsk; +amsl; +amsm; +amsn; +amso; +amsp; +amsq; +amsr; +amss; +amst; +amsu; +amsv; +amsw; +amsx; +amsy; +amsz; +amta; +amtb; +amtc; +amtd; +amte; +amtf; +amtg; +amth; +amti; +amtj; +amtk; +amtl; +amtm; +amtn; +amto; +amtp; +amtq; +amtr; +amts; +amtt; +amtu; +amtv; +amtw; +amtx; +amty; +amtz; +amua; +amub; +amuc; +amud; +amue; +amuf; +amug; +amuh; +amui; +amuj; +amuk; +amul; +amum; +amun; +amuo; +amup; +amuq; +amur; +amus; +amut; +amuu; +amuv; +amuw; +amux; +amuy; +amuz; +amva; +amvb; +amvc; +amvd; +amve; +amvf; +amvg; +amvh; +amvi; +amvj; +amvk; +amvl; +amvm; +amvn; +amvo; +amvp; +amvq; +amvr; +amvs; +amvt; +amvu; +amvv; +amvw; +amvx; +amvy; +amvz; +amwa; +amwb; +amwc; +amwd; +amwe; +amwf; +amwg; +amwh; +amwi; +amwj; +amwk; +amwl; +amwm; +amwn; +amwo; +amwp; +amwq; +amwr; +amws; +amwt; +amwu; +amwv; +amww; +amwx; +amwy; +amwz; +amxa; +amxb; +amxc; +amxd; +amxe; +amxf; +amxg; +amxh; +amxi; +amxj; +amxk; +amxl; +amxm; +amxn; +amxo; +amxp; +amxq; +amxr; +amxs; +amxt; +amxu; +amxv; +amxw; +amxx; +amxy; +amxz; +amya; +amyb; +amyc; +amyd; +amye; +amyf; +amyg; +amyh; +amyi; +amyj; +amyk; +amyl; +amym; +amyn; +amyo; +amyp; +amyq; +amyr; +amys; +amyt; +amyu; +amyv; +amyw; +amyx; +amyy; +amyz; +amza; +amzb; +amzc; +amzd; +amze; +amzf; +amzg; +amzh; +amzi; +amzj; +amzk; +amzl; +amzm; +amzn; +amzo; +amzp; +amzq; +amzr; +amzs; +amzt; +amzu; +amzv; +amzw; +amzx; +amzy; +amzz; +anaa; +anab; +anac; +anad; +anae; +anaf; +anag; +anah; +anai; +anaj; +anak; +anal; +anam; +anan; +anao; +anap; +anaq; +anar; +anas; +anat; +anau; +anav; +anaw; +anax; +anay; +anaz; +anba; +anbb; +anbc; +anbd; +anbe; +anbf; +anbg; +anbh; +anbi; +anbj; +anbk; +anbl; +anbm; +anbn; +anbo; +anbp; +anbq; +anbr; +anbs; +anbt; +anbu; +anbv; +anbw; +anbx; +anby; +anbz; +anca; +ancb; +ancc; +ancd; +ance; +ancf; +ancg; +anch; +anci; +ancj; +anck; +ancl; +ancm; +ancn; +anco; +ancp; +ancq; +ancr; +ancs; +anct; +ancu; +ancv; +ancw; +ancx; +ancy; +ancz; +anda; +andb; +andc; +andd; +ande; +andf; +andg; +andh; +andi; +andj; +andk; +andl; +andm; +andn; +ando; +andp; +andq; +andr; +ands; +andt; +andu; +andv; +andw; +andx; +andy; +andz; +anea; +aneb; +anec; +aned; +anee; +anef; +aneg; +aneh; +anei; +anej; +anek; +anel; +anem; +anen; +aneo; +anep; +aneq; +aner; +anes; +anet; +aneu; +anev; +anew; +anex; +aney; +anez; +anfa; +anfb; +anfc; +anfd; +anfe; +anff; +anfg; +anfh; +anfi; +anfj; +anfk; +anfl; +anfm; +anfn; +anfo; +anfp; +anfq; +anfr; +anfs; +anft; +anfu; +anfv; +anfw; +anfx; +anfy; +anfz; +anga; +angb; +angc; +angd; +ange; +angf; +angg; +angh; +angi; +angj; +angk; +angl; +angm; +angn; +ango; +angp; +angq; +angr; +angs; +angt; +angu; +angv; +angw; +angx; +angy; +angz; +anha; +anhb; +anhc; +anhd; +anhe; +anhf; +anhg; +anhh; +anhi; +anhj; +anhk; +anhl; +anhm; +anhn; +anho; +anhp; +anhq; +anhr; +anhs; +anht; +anhu; +anhv; +anhw; +anhx; +anhy; +anhz; +ania; +anib; +anic; +anid; +anie; +anif; +anig; +anih; +anii; +anij; +anik; +anil; +anim; +anin; +anio; +anip; +aniq; +anir; +anis; +anit; +aniu; +aniv; +aniw; +anix; +aniy; +aniz; +anja; +anjb; +anjc; +anjd; +anje; +anjf; +anjg; +anjh; +anji; +anjj; +anjk; +anjl; +anjm; +anjn; +anjo; +anjp; +anjq; +anjr; +anjs; +anjt; +anju; +anjv; +anjw; +anjx; +anjy; +anjz; +anka; +ankb; +ankc; +ankd; +anke; +ankf; +ankg; +ankh; +anki; +ankj; +ankk; +ankl; +ankm; +ankn; +anko; +ankp; +ankq; +ankr; +anks; +ankt; +anku; +ankv; +ankw; +ankx; +anky; +ankz; +anla; +anlb; +anlc; +anld; +anle; +anlf; +anlg; +anlh; +anli; +anlj; +anlk; +anll; +anlm; +anln; +anlo; +anlp; +anlq; +anlr; +anls; +anlt; +anlu; +anlv; +anlw; +anlx; +anly; +anlz; +anma; +anmb; +anmc; +anmd; +anme; +anmf; +anmg; +anmh; +anmi; +anmj; +anmk; +anml; +anmm; +anmn; +anmo; +anmp; +anmq; +anmr; +anms; +anmt; +anmu; +anmv; +anmw; +anmx; +anmy; +anmz; +anna; +annb; +annc; +annd; +anne; +annf; +anng; +annh; +anni; +annj; +annk; +annl; +annm; +annn; +anno; +annp; +annq; +annr; +anns; +annt; +annu; +annv; +annw; +annx; +anny; +annz; +anoa; +anob; +anoc; +anod; +anoe; +anof; +anog; +anoh; +anoi; +anoj; +anok; +anol; +anom; +anon; +anoo; +anop; +anoq; +anor; +anos; +anot; +anou; +anov; +anow; +anox; +anoy; +anoz; +anpa; +anpb; +anpc; +anpd; +anpe; +anpf; +anpg; +anph; +anpi; +anpj; +anpk; +anpl; +anpm; +anpn; +anpo; +anpp; +anpq; +anpr; +anps; +anpt; +anpu; +anpv; +anpw; +anpx; +anpy; +anpz; +anqa; +anqb; +anqc; +anqd; +anqe; +anqf; +anqg; +anqh; +anqi; +anqj; +anqk; +anql; +anqm; +anqn; +anqo; +anqp; +anqq; +anqr; +anqs; +anqt; +anqu; +anqv; +anqw; +anqx; +anqy; +anqz; +anra; +anrb; +anrc; +anrd; +anre; +anrf; +anrg; +anrh; +anri; +anrj; +anrk; +anrl; +anrm; +anrn; +anro; +anrp; +anrq; +anrr; +anrs; +anrt; +anru; +anrv; +anrw; +anrx; +anry; +anrz; +ansa; +ansb; +ansc; +ansd; +anse; +ansf; +ansg; +ansh; +ansi; +ansj; +ansk; +ansl; +ansm; +ansn; +anso; +ansp; +ansq; +ansr; +anss; +anst; +ansu; +ansv; +answ; +ansx; +ansy; +ansz; +anta; +antb; +antc; +antd; +ante; +antf; +antg; +anth; +anti; +antj; +antk; +antl; +antm; +antn; +anto; +antp; +antq; +antr; +ants; +antt; +antu; +antv; +antw; +antx; +anty; +antz; +anua; +anub; +anuc; +anud; +anue; +anuf; +anug; +anuh; +anui; +anuj; +anuk; +anul; +anum; +anun; +anuo; +anup; +anuq; +anur; +anus; +anut; +anuu; +anuv; +anuw; +anux; +anuy; +anuz; +anva; +anvb; +anvc; +anvd; +anve; +anvf; +anvg; +anvh; +anvi; +anvj; +anvk; +anvl; +anvm; +anvn; +anvo; +anvp; +anvq; +anvr; +anvs; +anvt; +anvu; +anvv; +anvw; +anvx; +anvy; +anvz; +anwa; +anwb; +anwc; +anwd; +anwe; +anwf; +anwg; +anwh; +anwi; +anwj; +anwk; +anwl; +anwm; +anwn; +anwo; +anwp; +anwq; +anwr; +anws; +anwt; +anwu; +anwv; +anww; +anwx; +anwy; +anwz; +anxa; +anxb; +anxc; +anxd; +anxe; +anxf; +anxg; +anxh; +anxi; +anxj; +anxk; +anxl; +anxm; +anxn; +anxo; +anxp; +anxq; +anxr; +anxs; +anxt; +anxu; +anxv; +anxw; +anxx; +anxy; +anxz; +anya; +anyb; +anyc; +anyd; +anye; +anyf; +anyg; +anyh; +anyi; +anyj; +anyk; +anyl; +anym; +anyn; +anyo; +anyp; +anyq; +anyr; +anys; +anyt; +anyu; +anyv; +anyw; +anyx; +anyy; +anyz; +anza; +anzb; +anzc; +anzd; +anze; +anzf; +anzg; +anzh; +anzi; +anzj; +anzk; +anzl; +anzm; +anzn; +anzo; +anzp; +anzq; +anzr; +anzs; +anzt; +anzu; +anzv; +anzw; +anzx; +anzy; +anzz; +aoaa; +aoab; +aoac; +aoad; +aoae; +aoaf; +aoag; +aoah; +aoai; +aoaj; +aoak; +aoal; +aoam; +aoan; +aoao; +aoap; +aoaq; +aoar; +aoas; +aoat; +aoau; +aoav; +aoaw; +aoax; +aoay; +aoaz; +aoba; +aobb; +aobc; +aobd; +aobe; +aobf; +aobg; +aobh; +aobi; +aobj; +aobk; +aobl; +aobm; +aobn; +aobo; +aobp; +aobq; +aobr; +aobs; +aobt; +aobu; +aobv; +aobw; +aobx; +aoby; +aobz; +aoca; +aocb; +aocc; +aocd; +aoce; +aocf; +aocg; +aoch; +aoci; +aocj; +aock; +aocl; +aocm; +aocn; +aoco; +aocp; +aocq; +aocr; +aocs; +aoct; +aocu; +aocv; +aocw; +aocx; +aocy; +aocz; +aoda; +aodb; +aodc; +aodd; +aode; +aodf; +aodg; +aodh; +aodi; +aodj; +aodk; +aodl; +aodm; +aodn; +aodo; +aodp; +aodq; +aodr; +aods; +aodt; +aodu; +aodv; +aodw; +aodx; +aody; +aodz; +aoea; +aoeb; +aoec; +aoed; +aoee; +aoef; +aoeg; +aoeh; +aoei; +aoej; +aoek; +aoel; +aoem; +aoen; +aoeo; +aoep; +aoeq; +aoer; +aoes; +aoet; +aoeu; +aoev; +aoew; +aoex; +aoey; +aoez; +aofa; +aofb; +aofc; +aofd; +aofe; +aoff; +aofg; +aofh; +aofi; +aofj; +aofk; +aofl; +aofm; +aofn; +aofo; +aofp; +aofq; +aofr; +aofs; +aoft; +aofu; +aofv; +aofw; +aofx; +aofy; +aofz; +aoga; +aogb; +aogc; +aogd; +aoge; +aogf; +aogg; +aogh; +aogi; +aogj; +aogk; +aogl; +aogm; +aogn; +aogo; +aogp; +aogq; +aogr; +aogs; +aogt; +aogu; +aogv; +aogw; +aogx; +aogy; +aogz; +aoha; +aohb; +aohc; +aohd; +aohe; +aohf; +aohg; +aohh; +aohi; +aohj; +aohk; +aohl; +aohm; +aohn; +aoho; +aohp; +aohq; +aohr; +aohs; +aoht; +aohu; +aohv; +aohw; +aohx; +aohy; +aohz; +aoia; +aoib; +aoic; +aoid; +aoie; +aoif; +aoig; +aoih; +aoii; +aoij; +aoik; +aoil; +aoim; +aoin; +aoio; +aoip; +aoiq; +aoir; +aois; +aoit; +aoiu; +aoiv; +aoiw; +aoix; +aoiy; +aoiz; +aoja; +aojb; +aojc; +aojd; +aoje; +aojf; +aojg; +aojh; +aoji; +aojj; +aojk; +aojl; +aojm; +aojn; +aojo; +aojp; +aojq; +aojr; +aojs; +aojt; +aoju; +aojv; +aojw; +aojx; +aojy; +aojz; +aoka; +aokb; +aokc; +aokd; +aoke; +aokf; +aokg; +aokh; +aoki; +aokj; +aokk; +aokl; +aokm; +aokn; +aoko; +aokp; +aokq; +aokr; +aoks; +aokt; +aoku; +aokv; +aokw; +aokx; +aoky; +aokz; +aola; +aolb; +aolc; +aold; +aole; +aolf; +aolg; +aolh; +aoli; +aolj; +aolk; +aoll; +aolm; +aoln; +aolo; +aolp; +aolq; +aolr; +aols; +aolt; +aolu; +aolv; +aolw; +aolx; +aoly; +aolz; +aoma; +aomb; +aomc; +aomd; +aome; +aomf; +aomg; +aomh; +aomi; +aomj; +aomk; +aoml; +aomm; +aomn; +aomo; +aomp; +aomq; +aomr; +aoms; +aomt; +aomu; +aomv; +aomw; +aomx; +aomy; +aomz; +aona; +aonb; +aonc; +aond; +aone; +aonf; +aong; +aonh; +aoni; +aonj; +aonk; +aonl; +aonm; +aonn; +aono; +aonp; +aonq; +aonr; +aons; +aont; +aonu; +aonv; +aonw; +aonx; +aony; +aonz; +aooa; +aoob; +aooc; +aood; +aooe; +aoof; +aoog; +aooh; +aooi; +aooj; +aook; +aool; +aoom; +aoon; +aooo; +aoop; +aooq; +aoor; +aoos; +aoot; +aoou; +aoov; +aoow; +aoox; +aooy; +aooz; +aopa; +aopb; +aopc; +aopd; +aope; +aopf; +aopg; +aoph; +aopi; +aopj; +aopk; +aopl; +aopm; +aopn; +aopo; +aopp; +aopq; +aopr; +aops; +aopt; +aopu; +aopv; +aopw; +aopx; +aopy; +aopz; +aoqa; +aoqb; +aoqc; +aoqd; +aoqe; +aoqf; +aoqg; +aoqh; +aoqi; +aoqj; +aoqk; +aoql; +aoqm; +aoqn; +aoqo; +aoqp; +aoqq; +aoqr; +aoqs; +aoqt; +aoqu; +aoqv; +aoqw; +aoqx; +aoqy; +aoqz; +aora; +aorb; +aorc; +aord; +aore; +aorf; +aorg; +aorh; +aori; +aorj; +aork; +aorl; +aorm; +aorn; +aoro; +aorp; +aorq; +aorr; +aors; +aort; +aoru; +aorv; +aorw; +aorx; +aory; +aorz; +aosa; +aosb; +aosc; +aosd; +aose; +aosf; +aosg; +aosh; +aosi; +aosj; +aosk; +aosl; +aosm; +aosn; +aoso; +aosp; +aosq; +aosr; +aoss; +aost; +aosu; +aosv; +aosw; +aosx; +aosy; +aosz; +aota; +aotb; +aotc; +aotd; +aote; +aotf; +aotg; +aoth; +aoti; +aotj; +aotk; +aotl; +aotm; +aotn; +aoto; +aotp; +aotq; +aotr; +aots; +aott; +aotu; +aotv; +aotw; +aotx; +aoty; +aotz; +aoua; +aoub; +aouc; +aoud; +aoue; +aouf; +aoug; +aouh; +aoui; +aouj; +aouk; +aoul; +aoum; +aoun; +aouo; +aoup; +aouq; +aour; +aous; +aout; +aouu; +aouv; +aouw; +aoux; +aouy; +aouz; +aova; +aovb; +aovc; +aovd; +aove; +aovf; +aovg; +aovh; +aovi; +aovj; +aovk; +aovl; +aovm; +aovn; +aovo; +aovp; +aovq; +aovr; +aovs; +aovt; +aovu; +aovv; +aovw; +aovx; +aovy; +aovz; +aowa; +aowb; +aowc; +aowd; +aowe; +aowf; +aowg; +aowh; +aowi; +aowj; +aowk; +aowl; +aowm; +aown; +aowo; +aowp; +aowq; +aowr; +aows; +aowt; +aowu; +aowv; +aoww; +aowx; +aowy; +aowz; +aoxa; +aoxb; +aoxc; +aoxd; +aoxe; +aoxf; +aoxg; +aoxh; +aoxi; +aoxj; +aoxk; +aoxl; +aoxm; +aoxn; +aoxo; +aoxp; +aoxq; +aoxr; +aoxs; +aoxt; +aoxu; +aoxv; +aoxw; +aoxx; +aoxy; +aoxz; +aoya; +aoyb; +aoyc; +aoyd; +aoye; +aoyf; +aoyg; +aoyh; +aoyi; +aoyj; +aoyk; +aoyl; +aoym; +aoyn; +aoyo; +aoyp; +aoyq; +aoyr; +aoys; +aoyt; +aoyu; +aoyv; +aoyw; +aoyx; +aoyy; +aoyz; +aoza; +aozb; +aozc; +aozd; +aoze; +aozf; +aozg; +aozh; +aozi; +aozj; +aozk; +aozl; +aozm; +aozn; +aozo; +aozp; +aozq; +aozr; +aozs; +aozt; +aozu; +aozv; +aozw; +aozx; +aozy; +aozz; +apaa; +apab; +apac; +apad; +apae; +apaf; +apag; +apah; +apai; +apaj; +apak; +apal; +apam; +apan; +apao; +apap; +apaq; +apar; +apas; +apat; +apau; +apav; +apaw; +apax; +apay; +apaz; +apba; +apbb; +apbc; +apbd; +apbe; +apbf; +apbg; +apbh; +apbi; +apbj; +apbk; +apbl; +apbm; +apbn; +apbo; +apbp; +apbq; +apbr; +apbs; +apbt; +apbu; +apbv; +apbw; +apbx; +apby; +apbz; +apca; +apcb; +apcc; +apcd; +apce; +apcf; +apcg; +apch; +apci; +apcj; +apck; +apcl; +apcm; +apcn; +apco; +apcp; +apcq; +apcr; +apcs; +apct; +apcu; +apcv; +apcw; +apcx; +apcy; +apcz; +apda; +apdb; +apdc; +apdd; +apde; +apdf; +apdg; +apdh; +apdi; +apdj; +apdk; +apdl; +apdm; +apdn; +apdo; +apdp; +apdq; +apdr; +apds; +apdt; +apdu; +apdv; +apdw; +apdx; +apdy; +apdz; +apea; +apeb; +apec; +aped; +apee; +apef; +apeg; +apeh; +apei; +apej; +apek; +apel; +apem; +apen; +apeo; +apep; +apeq; +aper; +apes; +apet; +apeu; +apev; +apew; +apex; +apey; +apez; +apfa; +apfb; +apfc; +apfd; +apfe; +apff; +apfg; +apfh; +apfi; +apfj; +apfk; +apfl; +apfm; +apfn; +apfo; +apfp; +apfq; +apfr; +apfs; +apft; +apfu; +apfv; +apfw; +apfx; +apfy; +apfz; +apga; +apgb; +apgc; +apgd; +apge; +apgf; +apgg; +apgh; +apgi; +apgj; +apgk; +apgl; +apgm; +apgn; +apgo; +apgp; +apgq; +apgr; +apgs; +apgt; +apgu; +apgv; +apgw; +apgx; +apgy; +apgz; +apha; +aphb; +aphc; +aphd; +aphe; +aphf; +aphg; +aphh; +aphi; +aphj; +aphk; +aphl; +aphm; +aphn; +apho; +aphp; +aphq; +aphr; +aphs; +apht; +aphu; +aphv; +aphw; +aphx; +aphy; +aphz; +apia; +apib; +apic; +apid; +apie; +apif; +apig; +apih; +apii; +apij; +apik; +apil; +apim; +apin; +apio; +apip; +apiq; +apir; +apis; +apit; +apiu; +apiv; +apiw; +apix; +apiy; +apiz; +apja; +apjb; +apjc; +apjd; +apje; +apjf; +apjg; +apjh; +apji; +apjj; +apjk; +apjl; +apjm; +apjn; +apjo; +apjp; +apjq; +apjr; +apjs; +apjt; +apju; +apjv; +apjw; +apjx; +apjy; +apjz; +apka; +apkb; +apkc; +apkd; +apke; +apkf; +apkg; +apkh; +apki; +apkj; +apkk; +apkl; +apkm; +apkn; +apko; +apkp; +apkq; +apkr; +apks; +apkt; +apku; +apkv; +apkw; +apkx; +apky; +apkz; +apla; +aplb; +aplc; +apld; +aple; +aplf; +aplg; +aplh; +apli; +aplj; +aplk; +apll; +aplm; +apln; +aplo; +aplp; +aplq; +aplr; +apls; +aplt; +aplu; +aplv; +aplw; +aplx; +aply; +aplz; +apma; +apmb; +apmc; +apmd; +apme; +apmf; +apmg; +apmh; +apmi; +apmj; +apmk; +apml; +apmm; +apmn; +apmo; +apmp; +apmq; +apmr; +apms; +apmt; +apmu; +apmv; +apmw; +apmx; +apmy; +apmz; +apna; +apnb; +apnc; +apnd; +apne; +apnf; +apng; +apnh; +apni; +apnj; +apnk; +apnl; +apnm; +apnn; +apno; +apnp; +apnq; +apnr; +apns; +apnt; +apnu; +apnv; +apnw; +apnx; +apny; +apnz; +apoa; +apob; +apoc; +apod; +apoe; +apof; +apog; +apoh; +apoi; +apoj; +apok; +apol; +apom; +apon; +apoo; +apop; +apoq; +apor; +apos; +apot; +apou; +apov; +apow; +apox; +apoy; +apoz; +appa; +appb; +appc; +appd; +appe; +appf; +appg; +apph; +appi; +appj; +appk; +appl; +appm; +appn; +appo; +appp; +appq; +appr; +apps; +appt; +appu; +appv; +appw; +appx; +appy; +appz; +apqa; +apqb; +apqc; +apqd; +apqe; +apqf; +apqg; +apqh; +apqi; +apqj; +apqk; +apql; +apqm; +apqn; +apqo; +apqp; +apqq; +apqr; +apqs; +apqt; +apqu; +apqv; +apqw; +apqx; +apqy; +apqz; +apra; +aprb; +aprc; +aprd; +apre; +aprf; +aprg; +aprh; +apri; +aprj; +aprk; +aprl; +aprm; +aprn; +apro; +aprp; +aprq; +aprr; +aprs; +aprt; +apru; +aprv; +aprw; +aprx; +apry; +aprz; +apsa; +apsb; +apsc; +apsd; +apse; +apsf; +apsg; +apsh; +apsi; +apsj; +apsk; +apsl; +apsm; +apsn; +apso; +apsp; +apsq; +apsr; +apss; +apst; +apsu; +apsv; +apsw; +apsx; +apsy; +apsz; +apta; +aptb; +aptc; +aptd; +apte; +aptf; +aptg; +apth; +apti; +aptj; +aptk; +aptl; +aptm; +aptn; +apto; +aptp; +aptq; +aptr; +apts; +aptt; +aptu; +aptv; +aptw; +aptx; +apty; +aptz; +apua; +apub; +apuc; +apud; +apue; +apuf; +apug; +apuh; +apui; +apuj; +apuk; +apul; +apum; +apun; +apuo; +apup; +apuq; +apur; +apus; +aput; +apuu; +apuv; +apuw; +apux; +apuy; +apuz; +apva; +apvb; +apvc; +apvd; +apve; +apvf; +apvg; +apvh; +apvi; +apvj; +apvk; +apvl; +apvm; +apvn; +apvo; +apvp; +apvq; +apvr; +apvs; +apvt; +apvu; +apvv; +apvw; +apvx; +apvy; +apvz; +apwa; +apwb; +apwc; +apwd; +apwe; +apwf; +apwg; +apwh; +apwi; +apwj; +apwk; +apwl; +apwm; +apwn; +apwo; +apwp; +apwq; +apwr; +apws; +apwt; +apwu; +apwv; +apww; +apwx; +apwy; +apwz; +apxa; +apxb; +apxc; +apxd; +apxe; +apxf; +apxg; +apxh; +apxi; +apxj; +apxk; +apxl; +apxm; +apxn; +apxo; +apxp; +apxq; +apxr; +apxs; +apxt; +apxu; +apxv; +apxw; +apxx; +apxy; +apxz; +apya; +apyb; +apyc; +apyd; +apye; +apyf; +apyg; +apyh; +apyi; +apyj; +apyk; +apyl; +apym; +apyn; +apyo; +apyp; +apyq; +apyr; +apys; +apyt; +apyu; +apyv; +apyw; +apyx; +apyy; +apyz; +apza; +apzb; +apzc; +apzd; +apze; +apzf; +apzg; +apzh; +apzi; +apzj; +apzk; +apzl; +apzm; +apzn; +apzo; +apzp; +apzq; +apzr; +apzs; +apzt; +apzu; +apzv; +apzw; +apzx; +apzy; +apzz; +aqaa; +aqab; +aqac; +aqad; +aqae; +aqaf; +aqag; +aqah; +aqai; +aqaj; +aqak; +aqal; +aqam; +aqan; +aqao; +aqap; +aqaq; +aqar; +aqas; +aqat; +aqau; +aqav; +aqaw; +aqax; +aqay; +aqaz; +aqba; +aqbb; +aqbc; +aqbd; +aqbe; +aqbf; +aqbg; +aqbh; +aqbi; +aqbj; +aqbk; +aqbl; +aqbm; +aqbn; +aqbo; +aqbp; +aqbq; +aqbr; +aqbs; +aqbt; +aqbu; +aqbv; +aqbw; +aqbx; +aqby; +aqbz; +aqca; +aqcb; +aqcc; +aqcd; +aqce; +aqcf; +aqcg; +aqch; +aqci; +aqcj; +aqck; +aqcl; +aqcm; +aqcn; +aqco; +aqcp; +aqcq; +aqcr; +aqcs; +aqct; +aqcu; +aqcv; +aqcw; +aqcx; +aqcy; +aqcz; +aqda; +aqdb; +aqdc; +aqdd; +aqde; +aqdf; +aqdg; +aqdh; +aqdi; +aqdj; +aqdk; +aqdl; +aqdm; +aqdn; +aqdo; +aqdp; +aqdq; +aqdr; +aqds; +aqdt; +aqdu; +aqdv; +aqdw; +aqdx; +aqdy; +aqdz; +aqea; +aqeb; +aqec; +aqed; +aqee; +aqef; +aqeg; +aqeh; +aqei; +aqej; +aqek; +aqel; +aqem; +aqen; +aqeo; +aqep; +aqeq; +aqer; +aqes; +aqet; +aqeu; +aqev; +aqew; +aqex; +aqey; +aqez; +aqfa; +aqfb; +aqfc; +aqfd; +aqfe; +aqff; +aqfg; +aqfh; +aqfi; +aqfj; +aqfk; +aqfl; +aqfm; +aqfn; +aqfo; +aqfp; +aqfq; +aqfr; +aqfs; +aqft; +aqfu; +aqfv; +aqfw; +aqfx; +aqfy; +aqfz; +aqga; +aqgb; +aqgc; +aqgd; +aqge; +aqgf; +aqgg; +aqgh; +aqgi; +aqgj; +aqgk; +aqgl; +aqgm; +aqgn; +aqgo; +aqgp; +aqgq; +aqgr; +aqgs; +aqgt; +aqgu; +aqgv; +aqgw; +aqgx; +aqgy; +aqgz; +aqha; +aqhb; +aqhc; +aqhd; +aqhe; +aqhf; +aqhg; +aqhh; +aqhi; +aqhj; +aqhk; +aqhl; +aqhm; +aqhn; +aqho; +aqhp; +aqhq; +aqhr; +aqhs; +aqht; +aqhu; +aqhv; +aqhw; +aqhx; +aqhy; +aqhz; +aqia; +aqib; +aqic; +aqid; +aqie; +aqif; +aqig; +aqih; +aqii; +aqij; +aqik; +aqil; +aqim; +aqin; +aqio; +aqip; +aqiq; +aqir; +aqis; +aqit; +aqiu; +aqiv; +aqiw; +aqix; +aqiy; +aqiz; +aqja; +aqjb; +aqjc; +aqjd; +aqje; +aqjf; +aqjg; +aqjh; +aqji; +aqjj; +aqjk; +aqjl; +aqjm; +aqjn; +aqjo; +aqjp; +aqjq; +aqjr; +aqjs; +aqjt; +aqju; +aqjv; +aqjw; +aqjx; +aqjy; +aqjz; +aqka; +aqkb; +aqkc; +aqkd; +aqke; +aqkf; +aqkg; +aqkh; +aqki; +aqkj; +aqkk; +aqkl; +aqkm; +aqkn; +aqko; +aqkp; +aqkq; +aqkr; +aqks; +aqkt; +aqku; +aqkv; +aqkw; +aqkx; +aqky; +aqkz; +aqla; +aqlb; +aqlc; +aqld; +aqle; +aqlf; +aqlg; +aqlh; +aqli; +aqlj; +aqlk; +aqll; +aqlm; +aqln; +aqlo; +aqlp; +aqlq; +aqlr; +aqls; +aqlt; +aqlu; +aqlv; +aqlw; +aqlx; +aqly; +aqlz; +aqma; +aqmb; +aqmc; +aqmd; +aqme; +aqmf; +aqmg; +aqmh; +aqmi; +aqmj; +aqmk; +aqml; +aqmm; +aqmn; +aqmo; +aqmp; +aqmq; +aqmr; +aqms; +aqmt; +aqmu; +aqmv; +aqmw; +aqmx; +aqmy; +aqmz; +aqna; +aqnb; +aqnc; +aqnd; +aqne; +aqnf; +aqng; +aqnh; +aqni; +aqnj; +aqnk; +aqnl; +aqnm; +aqnn; +aqno; +aqnp; +aqnq; +aqnr; +aqns; +aqnt; +aqnu; +aqnv; +aqnw; +aqnx; +aqny; +aqnz; +aqoa; +aqob; +aqoc; +aqod; +aqoe; +aqof; +aqog; +aqoh; +aqoi; +aqoj; +aqok; +aqol; +aqom; +aqon; +aqoo; +aqop; +aqoq; +aqor; +aqos; +aqot; +aqou; +aqov; +aqow; +aqox; +aqoy; +aqoz; +aqpa; +aqpb; +aqpc; +aqpd; +aqpe; +aqpf; +aqpg; +aqph; +aqpi; +aqpj; +aqpk; +aqpl; +aqpm; +aqpn; +aqpo; +aqpp; +aqpq; +aqpr; +aqps; +aqpt; +aqpu; +aqpv; +aqpw; +aqpx; +aqpy; +aqpz; +aqqa; +aqqb; +aqqc; +aqqd; +aqqe; +aqqf; +aqqg; +aqqh; +aqqi; +aqqj; +aqqk; +aqql; +aqqm; +aqqn; +aqqo; +aqqp; +aqqq; +aqqr; +aqqs; +aqqt; +aqqu; +aqqv; +aqqw; +aqqx; +aqqy; +aqqz; +aqra; +aqrb; +aqrc; +aqrd; +aqre; +aqrf; +aqrg; +aqrh; +aqri; +aqrj; +aqrk; +aqrl; +aqrm; +aqrn; +aqro; +aqrp; +aqrq; +aqrr; +aqrs; +aqrt; +aqru; +aqrv; +aqrw; +aqrx; +aqry; +aqrz; +aqsa; +aqsb; +aqsc; +aqsd; +aqse; +aqsf; +aqsg; +aqsh; +aqsi; +aqsj; +aqsk; +aqsl; +aqsm; +aqsn; +aqso; +aqsp; +aqsq; +aqsr; +aqss; +aqst; +aqsu; +aqsv; +aqsw; +aqsx; +aqsy; +aqsz; +aqta; +aqtb; +aqtc; +aqtd; +aqte; +aqtf; +aqtg; +aqth; +aqti; +aqtj; +aqtk; +aqtl; +aqtm; +aqtn; +aqto; +aqtp; +aqtq; +aqtr; +aqts; +aqtt; +aqtu; +aqtv; +aqtw; +aqtx; +aqty; +aqtz; +aqua; +aqub; +aquc; +aqud; +aque; +aquf; +aqug; +aquh; +aqui; +aquj; +aquk; +aqul; +aqum; +aqun; +aquo; +aqup; +aquq; +aqur; +aqus; +aqut; +aquu; +aquv; +aquw; +aqux; +aquy; +aquz; +aqva; +aqvb; +aqvc; +aqvd; +aqve; +aqvf; +aqvg; +aqvh; +aqvi; +aqvj; +aqvk; +aqvl; +aqvm; +aqvn; +aqvo; +aqvp; +aqvq; +aqvr; +aqvs; +aqvt; +aqvu; +aqvv; +aqvw; +aqvx; +aqvy; +aqvz; +aqwa; +aqwb; +aqwc; +aqwd; +aqwe; +aqwf; +aqwg; +aqwh; +aqwi; +aqwj; +aqwk; +aqwl; +aqwm; +aqwn; +aqwo; +aqwp; +aqwq; +aqwr; +aqws; +aqwt; +aqwu; +aqwv; +aqww; +aqwx; +aqwy; +aqwz; +aqxa; +aqxb; +aqxc; +aqxd; +aqxe; +aqxf; +aqxg; +aqxh; +aqxi; +aqxj; +aqxk; +aqxl; +aqxm; +aqxn; +aqxo; +aqxp; +aqxq; +aqxr; +aqxs; +aqxt; +aqxu; +aqxv; +aqxw; +aqxx; +aqxy; +aqxz; +aqya; +aqyb; +aqyc; +aqyd; +aqye; +aqyf; +aqyg; +aqyh; +aqyi; +aqyj; +aqyk; +aqyl; +aqym; +aqyn; +aqyo; +aqyp; +aqyq; +aqyr; +aqys; +aqyt; +aqyu; +aqyv; +aqyw; +aqyx; +aqyy; +aqyz; +aqza; +aqzb; +aqzc; +aqzd; +aqze; +aqzf; +aqzg; +aqzh; +aqzi; +aqzj; +aqzk; +aqzl; +aqzm; +aqzn; +aqzo; +aqzp; +aqzq; +aqzr; +aqzs; +aqzt; +aqzu; +aqzv; +aqzw; +aqzx; +aqzy; +aqzz; +araa; +arab; +arac; +arad; +arae; +araf; +arag; +arah; +arai; +araj; +arak; +aral; +aram; +aran; +arao; +arap; +araq; +arar; +aras; +arat; +arau; +arav; +araw; +arax; +aray; +araz; +arba; +arbb; +arbc; +arbd; +arbe; +arbf; +arbg; +arbh; +arbi; +arbj; +arbk; +arbl; +arbm; +arbn; +arbo; +arbp; +arbq; +arbr; +arbs; +arbt; +arbu; +arbv; +arbw; +arbx; +arby; +arbz; +arca; +arcb; +arcc; +arcd; +arce; +arcf; +arcg; +arch; +arci; +arcj; +arck; +arcl; +arcm; +arcn; +arco; +arcp; +arcq; +arcr; +arcs; +arct; +arcu; +arcv; +arcw; +arcx; +arcy; +arcz; +arda; +ardb; +ardc; +ardd; +arde; +ardf; +ardg; +ardh; +ardi; +ardj; +ardk; +ardl; +ardm; +ardn; +ardo; +ardp; +ardq; +ardr; +ards; +ardt; +ardu; +ardv; +ardw; +ardx; +ardy; +ardz; +area; +areb; +arec; +ared; +aree; +aref; +areg; +areh; +arei; +arej; +arek; +arel; +arem; +aren; +areo; +arep; +areq; +arer; +ares; +aret; +areu; +arev; +arew; +arex; +arey; +arez; +arfa; +arfb; +arfc; +arfd; +arfe; +arff; +arfg; +arfh; +arfi; +arfj; +arfk; +arfl; +arfm; +arfn; +arfo; +arfp; +arfq; +arfr; +arfs; +arft; +arfu; +arfv; +arfw; +arfx; +arfy; +arfz; +arga; +argb; +argc; +argd; +arge; +argf; +argg; +argh; +argi; +argj; +argk; +argl; +argm; +argn; +argo; +argp; +argq; +argr; +args; +argt; +argu; +argv; +argw; +argx; +argy; +argz; +arha; +arhb; +arhc; +arhd; +arhe; +arhf; +arhg; +arhh; +arhi; +arhj; +arhk; +arhl; +arhm; +arhn; +arho; +arhp; +arhq; +arhr; +arhs; +arht; +arhu; +arhv; +arhw; +arhx; +arhy; +arhz; +aria; +arib; +aric; +arid; +arie; +arif; +arig; +arih; +arii; +arij; +arik; +aril; +arim; +arin; +ario; +arip; +ariq; +arir; +aris; +arit; +ariu; +ariv; +ariw; +arix; +ariy; +ariz; +arja; +arjb; +arjc; +arjd; +arje; +arjf; +arjg; +arjh; +arji; +arjj; +arjk; +arjl; +arjm; +arjn; +arjo; +arjp; +arjq; +arjr; +arjs; +arjt; +arju; +arjv; +arjw; +arjx; +arjy; +arjz; +arka; +arkb; +arkc; +arkd; +arke; +arkf; +arkg; +arkh; +arki; +arkj; +arkk; +arkl; +arkm; +arkn; +arko; +arkp; +arkq; +arkr; +arks; +arkt; +arku; +arkv; +arkw; +arkx; +arky; +arkz; +arla; +arlb; +arlc; +arld; +arle; +arlf; +arlg; +arlh; +arli; +arlj; +arlk; +arll; +arlm; +arln; +arlo; +arlp; +arlq; +arlr; +arls; +arlt; +arlu; +arlv; +arlw; +arlx; +arly; +arlz; +arma; +armb; +armc; +armd; +arme; +armf; +armg; +armh; +armi; +armj; +armk; +arml; +armm; +armn; +armo; +armp; +armq; +armr; +arms; +armt; +armu; +armv; +armw; +armx; +army; +armz; +arna; +arnb; +arnc; +arnd; +arne; +arnf; +arng; +arnh; +arni; +arnj; +arnk; +arnl; +arnm; +arnn; +arno; +arnp; +arnq; +arnr; +arns; +arnt; +arnu; +arnv; +arnw; +arnx; +arny; +arnz; +aroa; +arob; +aroc; +arod; +aroe; +arof; +arog; +aroh; +aroi; +aroj; +arok; +arol; +arom; +aron; +aroo; +arop; +aroq; +aror; +aros; +arot; +arou; +arov; +arow; +arox; +aroy; +aroz; +arpa; +arpb; +arpc; +arpd; +arpe; +arpf; +arpg; +arph; +arpi; +arpj; +arpk; +arpl; +arpm; +arpn; +arpo; +arpp; +arpq; +arpr; +arps; +arpt; +arpu; +arpv; +arpw; +arpx; +arpy; +arpz; +arqa; +arqb; +arqc; +arqd; +arqe; +arqf; +arqg; +arqh; +arqi; +arqj; +arqk; +arql; +arqm; +arqn; +arqo; +arqp; +arqq; +arqr; +arqs; +arqt; +arqu; +arqv; +arqw; +arqx; +arqy; +arqz; +arra; +arrb; +arrc; +arrd; +arre; +arrf; +arrg; +arrh; +arri; +arrj; +arrk; +arrl; +arrm; +arrn; +arro; +arrp; +arrq; +arrr; +arrs; +arrt; +arru; +arrv; +arrw; +arrx; +arry; +arrz; +arsa; +arsb; +arsc; +arsd; +arse; +arsf; +arsg; +arsh; +arsi; +arsj; +arsk; +arsl; +arsm; +arsn; +arso; +arsp; +arsq; +arsr; +arss; +arst; +arsu; +arsv; +arsw; +arsx; +arsy; +arsz; +arta; +artb; +artc; +artd; +arte; +artf; +artg; +arth; +arti; +artj; +artk; +artl; +artm; +artn; +arto; +artp; +artq; +artr; +arts; +artt; +artu; +artv; +artw; +artx; +arty; +artz; +arua; +arub; +aruc; +arud; +arue; +aruf; +arug; +aruh; +arui; +aruj; +aruk; +arul; +arum; +arun; +aruo; +arup; +aruq; +arur; +arus; +arut; +aruu; +aruv; +aruw; +arux; +aruy; +aruz; +arva; +arvb; +arvc; +arvd; +arve; +arvf; +arvg; +arvh; +arvi; +arvj; +arvk; +arvl; +arvm; +arvn; +arvo; +arvp; +arvq; +arvr; +arvs; +arvt; +arvu; +arvv; +arvw; +arvx; +arvy; +arvz; +arwa; +arwb; +arwc; +arwd; +arwe; +arwf; +arwg; +arwh; +arwi; +arwj; +arwk; +arwl; +arwm; +arwn; +arwo; +arwp; +arwq; +arwr; +arws; +arwt; +arwu; +arwv; +arww; +arwx; +arwy; +arwz; +arxa; +arxb; +arxc; +arxd; +arxe; +arxf; +arxg; +arxh; +arxi; +arxj; +arxk; +arxl; +arxm; +arxn; +arxo; +arxp; +arxq; +arxr; +arxs; +arxt; +arxu; +arxv; +arxw; +arxx; +arxy; +arxz; +arya; +aryb; +aryc; +aryd; +arye; +aryf; +aryg; +aryh; +aryi; +aryj; +aryk; +aryl; +arym; +aryn; +aryo; +aryp; +aryq; +aryr; +arys; +aryt; +aryu; +aryv; +aryw; +aryx; +aryy; +aryz; +arza; +arzb; +arzc; +arzd; +arze; +arzf; +arzg; +arzh; +arzi; +arzj; +arzk; +arzl; +arzm; +arzn; +arzo; +arzp; +arzq; +arzr; +arzs; +arzt; +arzu; +arzv; +arzw; +arzx; +arzy; +arzz; +asaa; +asab; +asac; +asad; +asae; +asaf; +asag; +asah; +asai; +asaj; +asak; +asal; +asam; +asan; +asao; +asap; +asaq; +asar; +asas; +asat; +asau; +asav; +asaw; +asax; +asay; +asaz; +asba; +asbb; +asbc; +asbd; +asbe; +asbf; +asbg; +asbh; +asbi; +asbj; +asbk; +asbl; +asbm; +asbn; +asbo; +asbp; +asbq; +asbr; +asbs; +asbt; +asbu; +asbv; +asbw; +asbx; +asby; +asbz; +asca; +ascb; +ascc; +ascd; +asce; +ascf; +ascg; +asch; +asci; +ascj; +asck; +ascl; +ascm; +ascn; +asco; +ascp; +ascq; +ascr; +ascs; +asct; +ascu; +ascv; +ascw; +ascx; +ascy; +ascz; +asda; +asdb; +asdc; +asdd; +asde; +asdf; +asdg; +asdh; +asdi; +asdj; +asdk; +asdl; +asdm; +asdn; +asdo; +asdp; +asdq; +asdr; +asds; +asdt; +asdu; +asdv; +asdw; +asdx; +asdy; +asdz; +asea; +aseb; +asec; +ased; +asee; +asef; +aseg; +aseh; +asei; +asej; +asek; +asel; +asem; +asen; +aseo; +asep; +aseq; +aser; +ases; +aset; +aseu; +asev; +asew; +asex; +asey; +asez; +asfa; +asfb; +asfc; +asfd; +asfe; +asff; +asfg; +asfh; +asfi; +asfj; +asfk; +asfl; +asfm; +asfn; +asfo; +asfp; +asfq; +asfr; +asfs; +asft; +asfu; +asfv; +asfw; +asfx; +asfy; +asfz; +asga; +asgb; +asgc; +asgd; +asge; +asgf; +asgg; +asgh; +asgi; +asgj; +asgk; +asgl; +asgm; +asgn; +asgo; +asgp; +asgq; +asgr; +asgs; +asgt; +asgu; +asgv; +asgw; +asgx; +asgy; +asgz; +asha; +ashb; +ashc; +ashd; +ashe; +ashf; +ashg; +ashh; +ashi; +ashj; +ashk; +ashl; +ashm; +ashn; +asho; +ashp; +ashq; +ashr; +ashs; +asht; +ashu; +ashv; +ashw; +ashx; +ashy; +ashz; +asia; +asib; +asic; +asid; +asie; +asif; +asig; +asih; +asii; +asij; +asik; +asil; +asim; +asin; +asio; +asip; +asiq; +asir; +asis; +asit; +asiu; +asiv; +asiw; +asix; +asiy; +asiz; +asja; +asjb; +asjc; +asjd; +asje; +asjf; +asjg; +asjh; +asji; +asjj; +asjk; +asjl; +asjm; +asjn; +asjo; +asjp; +asjq; +asjr; +asjs; +asjt; +asju; +asjv; +asjw; +asjx; +asjy; +asjz; +aska; +askb; +askc; +askd; +aske; +askf; +askg; +askh; +aski; +askj; +askk; +askl; +askm; +askn; +asko; +askp; +askq; +askr; +asks; +askt; +asku; +askv; +askw; +askx; +asky; +askz; +asla; +aslb; +aslc; +asld; +asle; +aslf; +aslg; +aslh; +asli; +aslj; +aslk; +asll; +aslm; +asln; +aslo; +aslp; +aslq; +aslr; +asls; +aslt; +aslu; +aslv; +aslw; +aslx; +asly; +aslz; +asma; +asmb; +asmc; +asmd; +asme; +asmf; +asmg; +asmh; +asmi; +asmj; +asmk; +asml; +asmm; +asmn; +asmo; +asmp; +asmq; +asmr; +asms; +asmt; +asmu; +asmv; +asmw; +asmx; +asmy; +asmz; +asna; +asnb; +asnc; +asnd; +asne; +asnf; +asng; +asnh; +asni; +asnj; +asnk; +asnl; +asnm; +asnn; +asno; +asnp; +asnq; +asnr; +asns; +asnt; +asnu; +asnv; +asnw; +asnx; +asny; +asnz; +asoa; +asob; +asoc; +asod; +asoe; +asof; +asog; +asoh; +asoi; +asoj; +asok; +asol; +asom; +ason; +asoo; +asop; +asoq; +asor; +asos; +asot; +asou; +asov; +asow; +asox; +asoy; +asoz; +aspa; +aspb; +aspc; +aspd; +aspe; +aspf; +aspg; +asph; +aspi; +aspj; +aspk; +aspl; +aspm; +aspn; +aspo; +aspp; +aspq; +aspr; +asps; +aspt; +aspu; +aspv; +aspw; +aspx; +aspy; +aspz; +asqa; +asqb; +asqc; +asqd; +asqe; +asqf; +asqg; +asqh; +asqi; +asqj; +asqk; +asql; +asqm; +asqn; +asqo; +asqp; +asqq; +asqr; +asqs; +asqt; +asqu; +asqv; +asqw; +asqx; +asqy; +asqz; +asra; +asrb; +asrc; +asrd; +asre; +asrf; +asrg; +asrh; +asri; +asrj; +asrk; +asrl; +asrm; +asrn; +asro; +asrp; +asrq; +asrr; +asrs; +asrt; +asru; +asrv; +asrw; +asrx; +asry; +asrz; +assa; +assb; +assc; +assd; +asse; +assf; +assg; +assh; +assi; +assj; +assk; +assl; +assm; +assn; +asso; +assp; +assq; +assr; +asss; +asst; +assu; +assv; +assw; +assx; +assy; +assz; +asta; +astb; +astc; +astd; +aste; +astf; +astg; +asth; +asti; +astj; +astk; +astl; +astm; +astn; +asto; +astp; +astq; +astr; +asts; +astt; +astu; +astv; +astw; +astx; +asty; +astz; +asua; +asub; +asuc; +asud; +asue; +asuf; +asug; +asuh; +asui; +asuj; +asuk; +asul; +asum; +asun; +asuo; +asup; +asuq; +asur; +asus; +asut; +asuu; +asuv; +asuw; +asux; +asuy; +asuz; +asva; +asvb; +asvc; +asvd; +asve; +asvf; +asvg; +asvh; +asvi; +asvj; +asvk; +asvl; +asvm; +asvn; +asvo; +asvp; +asvq; +asvr; +asvs; +asvt; +asvu; +asvv; +asvw; +asvx; +asvy; +asvz; +aswa; +aswb; +aswc; +aswd; +aswe; +aswf; +aswg; +aswh; +aswi; +aswj; +aswk; +aswl; +aswm; +aswn; +aswo; +aswp; +aswq; +aswr; +asws; +aswt; +aswu; +aswv; +asww; +aswx; +aswy; +aswz; +asxa; +asxb; +asxc; +asxd; +asxe; +asxf; +asxg; +asxh; +asxi; +asxj; +asxk; +asxl; +asxm; +asxn; +asxo; +asxp; +asxq; +asxr; +asxs; +asxt; +asxu; +asxv; +asxw; +asxx; +asxy; +asxz; +asya; +asyb; +asyc; +asyd; +asye; +asyf; +asyg; +asyh; +asyi; +asyj; +asyk; +asyl; +asym; +asyn; +asyo; +asyp; +asyq; +asyr; +asys; +asyt; +asyu; +asyv; +asyw; +asyx; +asyy; +asyz; +asza; +aszb; +aszc; +aszd; +asze; +aszf; +aszg; +aszh; +aszi; +aszj; +aszk; +aszl; +aszm; +aszn; +aszo; +aszp; +aszq; +aszr; +aszs; +aszt; +aszu; +aszv; +aszw; +aszx; +aszy; +aszz; +ataa; +atab; +atac; +atad; +atae; +ataf; +atag; +atah; +atai; +ataj; +atak; +atal; +atam; +atan; +atao; +atap; +ataq; +atar; +atas; +atat; +atau; +atav; +ataw; +atax; +atay; +ataz; +atba; +atbb; +atbc; +atbd; +atbe; +atbf; +atbg; +atbh; +atbi; +atbj; +atbk; +atbl; +atbm; +atbn; +atbo; +atbp; +atbq; +atbr; +atbs; +atbt; +atbu; +atbv; +atbw; +atbx; +atby; +atbz; +atca; +atcb; +atcc; +atcd; +atce; +atcf; +atcg; +atch; +atci; +atcj; +atck; +atcl; +atcm; +atcn; +atco; +atcp; +atcq; +atcr; +atcs; +atct; +atcu; +atcv; +atcw; +atcx; +atcy; +atcz; +atda; +atdb; +atdc; +atdd; +atde; +atdf; +atdg; +atdh; +atdi; +atdj; +atdk; +atdl; +atdm; +atdn; +atdo; +atdp; +atdq; +atdr; +atds; +atdt; +atdu; +atdv; +atdw; +atdx; +atdy; +atdz; +atea; +ateb; +atec; +ated; +atee; +atef; +ateg; +ateh; +atei; +atej; +atek; +atel; +atem; +aten; +ateo; +atep; +ateq; +ater; +ates; +atet; +ateu; +atev; +atew; +atex; +atey; +atez; +atfa; +atfb; +atfc; +atfd; +atfe; +atff; +atfg; +atfh; +atfi; +atfj; +atfk; +atfl; +atfm; +atfn; +atfo; +atfp; +atfq; +atfr; +atfs; +atft; +atfu; +atfv; +atfw; +atfx; +atfy; +atfz; +atga; +atgb; +atgc; +atgd; +atge; +atgf; +atgg; +atgh; +atgi; +atgj; +atgk; +atgl; +atgm; +atgn; +atgo; +atgp; +atgq; +atgr; +atgs; +atgt; +atgu; +atgv; +atgw; +atgx; +atgy; +atgz; +atha; +athb; +athc; +athd; +athe; +athf; +athg; +athh; +athi; +athj; +athk; +athl; +athm; +athn; +atho; +athp; +athq; +athr; +aths; +atht; +athu; +athv; +athw; +athx; +athy; +athz; +atia; +atib; +atic; +atid; +atie; +atif; +atig; +atih; +atii; +atij; +atik; +atil; +atim; +atin; +atio; +atip; +atiq; +atir; +atis; +atit; +atiu; +ativ; +atiw; +atix; +atiy; +atiz; +atja; +atjb; +atjc; +atjd; +atje; +atjf; +atjg; +atjh; +atji; +atjj; +atjk; +atjl; +atjm; +atjn; +atjo; +atjp; +atjq; +atjr; +atjs; +atjt; +atju; +atjv; +atjw; +atjx; +atjy; +atjz; +atka; +atkb; +atkc; +atkd; +atke; +atkf; +atkg; +atkh; +atki; +atkj; +atkk; +atkl; +atkm; +atkn; +atko; +atkp; +atkq; +atkr; +atks; +atkt; +atku; +atkv; +atkw; +atkx; +atky; +atkz; +atla; +atlb; +atlc; +atld; +atle; +atlf; +atlg; +atlh; +atli; +atlj; +atlk; +atll; +atlm; +atln; +atlo; +atlp; +atlq; +atlr; +atls; +atlt; +atlu; +atlv; +atlw; +atlx; +atly; +atlz; +atma; +atmb; +atmc; +atmd; +atme; +atmf; +atmg; +atmh; +atmi; +atmj; +atmk; +atml; +atmm; +atmn; +atmo; +atmp; +atmq; +atmr; +atms; +atmt; +atmu; +atmv; +atmw; +atmx; +atmy; +atmz; +atna; +atnb; +atnc; +atnd; +atne; +atnf; +atng; +atnh; +atni; +atnj; +atnk; +atnl; +atnm; +atnn; +atno; +atnp; +atnq; +atnr; +atns; +atnt; +atnu; +atnv; +atnw; +atnx; +atny; +atnz; +atoa; +atob; +atoc; +atod; +atoe; +atof; +atog; +atoh; +atoi; +atoj; +atok; +atol; +atom; +aton; +atoo; +atop; +atoq; +ator; +atos; +atot; +atou; +atov; +atow; +atox; +atoy; +atoz; +atpa; +atpb; +atpc; +atpd; +atpe; +atpf; +atpg; +atph; +atpi; +atpj; +atpk; +atpl; +atpm; +atpn; +atpo; +atpp; +atpq; +atpr; +atps; +atpt; +atpu; +atpv; +atpw; +atpx; +atpy; +atpz; +atqa; +atqb; +atqc; +atqd; +atqe; +atqf; +atqg; +atqh; +atqi; +atqj; +atqk; +atql; +atqm; +atqn; +atqo; +atqp; +atqq; +atqr; +atqs; +atqt; +atqu; +atqv; +atqw; +atqx; +atqy; +atqz; +atra; +atrb; +atrc; +atrd; +atre; +atrf; +atrg; +atrh; +atri; +atrj; +atrk; +atrl; +atrm; +atrn; +atro; +atrp; +atrq; +atrr; +atrs; +atrt; +atru; +atrv; +atrw; +atrx; +atry; +atrz; +atsa; +atsb; +atsc; +atsd; +atse; +atsf; +atsg; +atsh; +atsi; +atsj; +atsk; +atsl; +atsm; +atsn; +atso; +atsp; +atsq; +atsr; +atss; +atst; +atsu; +atsv; +atsw; +atsx; +atsy; +atsz; +atta; +attb; +attc; +attd; +atte; +attf; +attg; +atth; +atti; +attj; +attk; +attl; +attm; +attn; +atto; +attp; +attq; +attr; +atts; +attt; +attu; +attv; +attw; +attx; +atty; +attz; +atua; +atub; +atuc; +atud; +atue; +atuf; +atug; +atuh; +atui; +atuj; +atuk; +atul; +atum; +atun; +atuo; +atup; +atuq; +atur; +atus; +atut; +atuu; +atuv; +atuw; +atux; +atuy; +atuz; +atva; +atvb; +atvc; +atvd; +atve; +atvf; +atvg; +atvh; +atvi; +atvj; +atvk; +atvl; +atvm; +atvn; +atvo; +atvp; +atvq; +atvr; +atvs; +atvt; +atvu; +atvv; +atvw; +atvx; +atvy; +atvz; +atwa; +atwb; +atwc; +atwd; +atwe; +atwf; +atwg; +atwh; +atwi; +atwj; +atwk; +atwl; +atwm; +atwn; +atwo; +atwp; +atwq; +atwr; +atws; +atwt; +atwu; +atwv; +atww; +atwx; +atwy; +atwz; +atxa; +atxb; +atxc; +atxd; +atxe; +atxf; +atxg; +atxh; +atxi; +atxj; +atxk; +atxl; +atxm; +atxn; +atxo; +atxp; +atxq; +atxr; +atxs; +atxt; +atxu; +atxv; +atxw; +atxx; +atxy; +atxz; +atya; +atyb; +atyc; +atyd; +atye; +atyf; +atyg; +atyh; +atyi; +atyj; +atyk; +atyl; +atym; +atyn; +atyo; +atyp; +atyq; +atyr; +atys; +atyt; +atyu; +atyv; +atyw; +atyx; +atyy; +atyz; +atza; +atzb; +atzc; +atzd; +atze; +atzf; +atzg; +atzh; +atzi; +atzj; +atzk; +atzl; +atzm; +atzn; +atzo; +atzp; +atzq; +atzr; +atzs; +atzt; +atzu; +atzv; +atzw; +atzx; +atzy; +atzz; +auaa; +auab; +auac; +auad; +auae; +auaf; +auag; +auah; +auai; +auaj; +auak; +aual; +auam; +auan; +auao; +auap; +auaq; +auar; +auas; +auat; +auau; +auav; +auaw; +auax; +auay; +auaz; +auba; +aubb; +aubc; +aubd; +aube; +aubf; +aubg; +aubh; +aubi; +aubj; +aubk; +aubl; +aubm; +aubn; +aubo; +aubp; +aubq; +aubr; +aubs; +aubt; +aubu; +aubv; +aubw; +aubx; +auby; +aubz; +auca; +aucb; +aucc; +aucd; +auce; +aucf; +aucg; +auch; +auci; +aucj; +auck; +aucl; +aucm; +aucn; +auco; +aucp; +aucq; +aucr; +aucs; +auct; +aucu; +aucv; +aucw; +aucx; +aucy; +aucz; +auda; +audb; +audc; +audd; +aude; +audf; +audg; +audh; +audi; +audj; +audk; +audl; +audm; +audn; +audo; +audp; +audq; +audr; +auds; +audt; +audu; +audv; +audw; +audx; +audy; +audz; +auea; +aueb; +auec; +aued; +auee; +auef; +aueg; +aueh; +auei; +auej; +auek; +auel; +auem; +auen; +aueo; +auep; +aueq; +auer; +aues; +auet; +aueu; +auev; +auew; +auex; +auey; +auez; +aufa; +aufb; +aufc; +aufd; +aufe; +auff; +aufg; +aufh; +aufi; +aufj; +aufk; +aufl; +aufm; +aufn; +aufo; +aufp; +aufq; +aufr; +aufs; +auft; +aufu; +aufv; +aufw; +aufx; +aufy; +aufz; +auga; +augb; +augc; +augd; +auge; +augf; +augg; +augh; +augi; +augj; +augk; +augl; +augm; +augn; +augo; +augp; +augq; +augr; +augs; +augt; +augu; +augv; +augw; +augx; +augy; +augz; +auha; +auhb; +auhc; +auhd; +auhe; +auhf; +auhg; +auhh; +auhi; +auhj; +auhk; +auhl; +auhm; +auhn; +auho; +auhp; +auhq; +auhr; +auhs; +auht; +auhu; +auhv; +auhw; +auhx; +auhy; +auhz; +auia; +auib; +auic; +auid; +auie; +auif; +auig; +auih; +auii; +auij; +auik; +auil; +auim; +auin; +auio; +auip; +auiq; +auir; +auis; +auit; +auiu; +auiv; +auiw; +auix; +auiy; +auiz; +auja; +aujb; +aujc; +aujd; +auje; +aujf; +aujg; +aujh; +auji; +aujj; +aujk; +aujl; +aujm; +aujn; +aujo; +aujp; +aujq; +aujr; +aujs; +aujt; +auju; +aujv; +aujw; +aujx; +aujy; +aujz; +auka; +aukb; +aukc; +aukd; +auke; +aukf; +aukg; +aukh; +auki; +aukj; +aukk; +aukl; +aukm; +aukn; +auko; +aukp; +aukq; +aukr; +auks; +aukt; +auku; +aukv; +aukw; +aukx; +auky; +aukz; +aula; +aulb; +aulc; +auld; +aule; +aulf; +aulg; +aulh; +auli; +aulj; +aulk; +aull; +aulm; +auln; +aulo; +aulp; +aulq; +aulr; +auls; +ault; +aulu; +aulv; +aulw; +aulx; +auly; +aulz; +auma; +aumb; +aumc; +aumd; +aume; +aumf; +aumg; +aumh; +aumi; +aumj; +aumk; +auml; +aumm; +aumn; +aumo; +aump; +aumq; +aumr; +aums; +aumt; +aumu; +aumv; +aumw; +aumx; +aumy; +aumz; +auna; +aunb; +aunc; +aund; +aune; +aunf; +aung; +aunh; +auni; +aunj; +aunk; +aunl; +aunm; +aunn; +auno; +aunp; +aunq; +aunr; +auns; +aunt; +aunu; +aunv; +aunw; +aunx; +auny; +aunz; +auoa; +auob; +auoc; +auod; +auoe; +auof; +auog; +auoh; +auoi; +auoj; +auok; +auol; +auom; +auon; +auoo; +auop; +auoq; +auor; +auos; +auot; +auou; +auov; +auow; +auox; +auoy; +auoz; +aupa; +aupb; +aupc; +aupd; +aupe; +aupf; +aupg; +auph; +aupi; +aupj; +aupk; +aupl; +aupm; +aupn; +aupo; +aupp; +aupq; +aupr; +aups; +aupt; +aupu; +aupv; +aupw; +aupx; +aupy; +aupz; +auqa; +auqb; +auqc; +auqd; +auqe; +auqf; +auqg; +auqh; +auqi; +auqj; +auqk; +auql; +auqm; +auqn; +auqo; +auqp; +auqq; +auqr; +auqs; +auqt; +auqu; +auqv; +auqw; +auqx; +auqy; +auqz; +aura; +aurb; +aurc; +aurd; +aure; +aurf; +aurg; +aurh; +auri; +aurj; +aurk; +aurl; +aurm; +aurn; +auro; +aurp; +aurq; +aurr; +aurs; +aurt; +auru; +aurv; +aurw; +aurx; +aury; +aurz; +ausa; +ausb; +ausc; +ausd; +ause; +ausf; +ausg; +aush; +ausi; +ausj; +ausk; +ausl; +ausm; +ausn; +auso; +ausp; +ausq; +ausr; +auss; +aust; +ausu; +ausv; +ausw; +ausx; +ausy; +ausz; +auta; +autb; +autc; +autd; +aute; +autf; +autg; +auth; +auti; +autj; +autk; +autl; +autm; +autn; +auto; +autp; +autq; +autr; +auts; +autt; +autu; +autv; +autw; +autx; +auty; +autz; +auua; +auub; +auuc; +auud; +auue; +auuf; +auug; +auuh; +auui; +auuj; +auuk; +auul; +auum; +auun; +auuo; +auup; +auuq; +auur; +auus; +auut; +auuu; +auuv; +auuw; +auux; +auuy; +auuz; +auva; +auvb; +auvc; +auvd; +auve; +auvf; +auvg; +auvh; +auvi; +auvj; +auvk; +auvl; +auvm; +auvn; +auvo; +auvp; +auvq; +auvr; +auvs; +auvt; +auvu; +auvv; +auvw; +auvx; +auvy; +auvz; +auwa; +auwb; +auwc; +auwd; +auwe; +auwf; +auwg; +auwh; +auwi; +auwj; +auwk; +auwl; +auwm; +auwn; +auwo; +auwp; +auwq; +auwr; +auws; +auwt; +auwu; +auwv; +auww; +auwx; +auwy; +auwz; +auxa; +auxb; +auxc; +auxd; +auxe; +auxf; +auxg; +auxh; +auxi; +auxj; +auxk; +auxl; +auxm; +auxn; +auxo; +auxp; +auxq; +auxr; +auxs; +auxt; +auxu; +auxv; +auxw; +auxx; +auxy; +auxz; +auya; +auyb; +auyc; +auyd; +auye; +auyf; +auyg; +auyh; +auyi; +auyj; +auyk; +auyl; +auym; +auyn; +auyo; +auyp; +auyq; +auyr; +auys; +auyt; +auyu; +auyv; +auyw; +auyx; +auyy; +auyz; +auza; +auzb; +auzc; +auzd; +auze; +auzf; +auzg; +auzh; +auzi; +auzj; +auzk; +auzl; +auzm; +auzn; +auzo; +auzp; +auzq; +auzr; +auzs; +auzt; +auzu; +auzv; +auzw; +auzx; +auzy; +auzz; +avaa; +avab; +avac; +avad; +avae; +avaf; +avag; +avah; +avai; +avaj; +avak; +aval; +avam; +avan; +avao; +avap; +avaq; +avar; +avas; +avat; +avau; +avav; +avaw; +avax; +avay; +avaz; +avba; +avbb; +avbc; +avbd; +avbe; +avbf; +avbg; +avbh; +avbi; +avbj; +avbk; +avbl; +avbm; +avbn; +avbo; +avbp; +avbq; +avbr; +avbs; +avbt; +avbu; +avbv; +avbw; +avbx; +avby; +avbz; +avca; +avcb; +avcc; +avcd; +avce; +avcf; +avcg; +avch; +avci; +avcj; +avck; +avcl; +avcm; +avcn; +avco; +avcp; +avcq; +avcr; +avcs; +avct; +avcu; +avcv; +avcw; +avcx; +avcy; +avcz; +avda; +avdb; +avdc; +avdd; +avde; +avdf; +avdg; +avdh; +avdi; +avdj; +avdk; +avdl; +avdm; +avdn; +avdo; +avdp; +avdq; +avdr; +avds; +avdt; +avdu; +avdv; +avdw; +avdx; +avdy; +avdz; +avea; +aveb; +avec; +aved; +avee; +avef; +aveg; +aveh; +avei; +avej; +avek; +avel; +avem; +aven; +aveo; +avep; +aveq; +aver; +aves; +avet; +aveu; +avev; +avew; +avex; +avey; +avez; +avfa; +avfb; +avfc; +avfd; +avfe; +avff; +avfg; +avfh; +avfi; +avfj; +avfk; +avfl; +avfm; +avfn; +avfo; +avfp; +avfq; +avfr; +avfs; +avft; +avfu; +avfv; +avfw; +avfx; +avfy; +avfz; +avga; +avgb; +avgc; +avgd; +avge; +avgf; +avgg; +avgh; +avgi; +avgj; +avgk; +avgl; +avgm; +avgn; +avgo; +avgp; +avgq; +avgr; +avgs; +avgt; +avgu; +avgv; +avgw; +avgx; +avgy; +avgz; +avha; +avhb; +avhc; +avhd; +avhe; +avhf; +avhg; +avhh; +avhi; +avhj; +avhk; +avhl; +avhm; +avhn; +avho; +avhp; +avhq; +avhr; +avhs; +avht; +avhu; +avhv; +avhw; +avhx; +avhy; +avhz; +avia; +avib; +avic; +avid; +avie; +avif; +avig; +avih; +avii; +avij; +avik; +avil; +avim; +avin; +avio; +avip; +aviq; +avir; +avis; +avit; +aviu; +aviv; +aviw; +avix; +aviy; +aviz; +avja; +avjb; +avjc; +avjd; +avje; +avjf; +avjg; +avjh; +avji; +avjj; +avjk; +avjl; +avjm; +avjn; +avjo; +avjp; +avjq; +avjr; +avjs; +avjt; +avju; +avjv; +avjw; +avjx; +avjy; +avjz; +avka; +avkb; +avkc; +avkd; +avke; +avkf; +avkg; +avkh; +avki; +avkj; +avkk; +avkl; +avkm; +avkn; +avko; +avkp; +avkq; +avkr; +avks; +avkt; +avku; +avkv; +avkw; +avkx; +avky; +avkz; +avla; +avlb; +avlc; +avld; +avle; +avlf; +avlg; +avlh; +avli; +avlj; +avlk; +avll; +avlm; +avln; +avlo; +avlp; +avlq; +avlr; +avls; +avlt; +avlu; +avlv; +avlw; +avlx; +avly; +avlz; +avma; +avmb; +avmc; +avmd; +avme; +avmf; +avmg; +avmh; +avmi; +avmj; +avmk; +avml; +avmm; +avmn; +avmo; +avmp; +avmq; +avmr; +avms; +avmt; +avmu; +avmv; +avmw; +avmx; +avmy; +avmz; +avna; +avnb; +avnc; +avnd; +avne; +avnf; +avng; +avnh; +avni; +avnj; +avnk; +avnl; +avnm; +avnn; +avno; +avnp; +avnq; +avnr; +avns; +avnt; +avnu; +avnv; +avnw; +avnx; +avny; +avnz; +avoa; +avob; +avoc; +avod; +avoe; +avof; +avog; +avoh; +avoi; +avoj; +avok; +avol; +avom; +avon; +avoo; +avop; +avoq; +avor; +avos; +avot; +avou; +avov; +avow; +avox; +avoy; +avoz; +avpa; +avpb; +avpc; +avpd; +avpe; +avpf; +avpg; +avph; +avpi; +avpj; +avpk; +avpl; +avpm; +avpn; +avpo; +avpp; +avpq; +avpr; +avps; +avpt; +avpu; +avpv; +avpw; +avpx; +avpy; +avpz; +avqa; +avqb; +avqc; +avqd; +avqe; +avqf; +avqg; +avqh; +avqi; +avqj; +avqk; +avql; +avqm; +avqn; +avqo; +avqp; +avqq; +avqr; +avqs; +avqt; +avqu; +avqv; +avqw; +avqx; +avqy; +avqz; +avra; +avrb; +avrc; +avrd; +avre; +avrf; +avrg; +avrh; +avri; +avrj; +avrk; +avrl; +avrm; +avrn; +avro; +avrp; +avrq; +avrr; +avrs; +avrt; +avru; +avrv; +avrw; +avrx; +avry; +avrz; +avsa; +avsb; +avsc; +avsd; +avse; +avsf; +avsg; +avsh; +avsi; +avsj; +avsk; +avsl; +avsm; +avsn; +avso; +avsp; +avsq; +avsr; +avss; +avst; +avsu; +avsv; +avsw; +avsx; +avsy; +avsz; +avta; +avtb; +avtc; +avtd; +avte; +avtf; +avtg; +avth; +avti; +avtj; +avtk; +avtl; +avtm; +avtn; +avto; +avtp; +avtq; +avtr; +avts; +avtt; +avtu; +avtv; +avtw; +avtx; +avty; +avtz; +avua; +avub; +avuc; +avud; +avue; +avuf; +avug; +avuh; +avui; +avuj; +avuk; +avul; +avum; +avun; +avuo; +avup; +avuq; +avur; +avus; +avut; +avuu; +avuv; +avuw; +avux; +avuy; +avuz; +avva; +avvb; +avvc; +avvd; +avve; +avvf; +avvg; +avvh; +avvi; +avvj; +avvk; +avvl; +avvm; +avvn; +avvo; +avvp; +avvq; +avvr; +avvs; +avvt; +avvu; +avvv; +avvw; +avvx; +avvy; +avvz; +avwa; +avwb; +avwc; +avwd; +avwe; +avwf; +avwg; +avwh; +avwi; +avwj; +avwk; +avwl; +avwm; +avwn; +avwo; +avwp; +avwq; +avwr; +avws; +avwt; +avwu; +avwv; +avww; +avwx; +avwy; +avwz; +avxa; +avxb; +avxc; +avxd; +avxe; +avxf; +avxg; +avxh; +avxi; +avxj; +avxk; +avxl; +avxm; +avxn; +avxo; +avxp; +avxq; +avxr; +avxs; +avxt; +avxu; +avxv; +avxw; +avxx; +avxy; +avxz; +avya; +avyb; +avyc; +avyd; +avye; +avyf; +avyg; +avyh; +avyi; +avyj; +avyk; +avyl; +avym; +avyn; +avyo; +avyp; +avyq; +avyr; +avys; +avyt; +avyu; +avyv; +avyw; +avyx; +avyy; +avyz; +avza; +avzb; +avzc; +avzd; +avze; +avzf; +avzg; +avzh; +avzi; +avzj; +avzk; +avzl; +avzm; +avzn; +avzo; +avzp; +avzq; +avzr; +avzs; +avzt; +avzu; +avzv; +avzw; +avzx; +avzy; +avzz; +awaa; +awab; +awac; +awad; +awae; +awaf; +awag; +awah; +awai; +awaj; +awak; +awal; +awam; +awan; +awao; +awap; +awaq; +awar; +awas; +awat; +awau; +awav; +awaw; +awax; +away; +awaz; +awba; +awbb; +awbc; +awbd; +awbe; +awbf; +awbg; +awbh; +awbi; +awbj; +awbk; +awbl; +awbm; +awbn; +awbo; +awbp; +awbq; +awbr; +awbs; +awbt; +awbu; +awbv; +awbw; +awbx; +awby; +awbz; +awca; +awcb; +awcc; +awcd; +awce; +awcf; +awcg; +awch; +awci; +awcj; +awck; +awcl; +awcm; +awcn; +awco; +awcp; +awcq; +awcr; +awcs; +awct; +awcu; +awcv; +awcw; +awcx; +awcy; +awcz; +awda; +awdb; +awdc; +awdd; +awde; +awdf; +awdg; +awdh; +awdi; +awdj; +awdk; +awdl; +awdm; +awdn; +awdo; +awdp; +awdq; +awdr; +awds; +awdt; +awdu; +awdv; +awdw; +awdx; +awdy; +awdz; +awea; +aweb; +awec; +awed; +awee; +awef; +aweg; +aweh; +awei; +awej; +awek; +awel; +awem; +awen; +aweo; +awep; +aweq; +awer; +awes; +awet; +aweu; +awev; +awew; +awex; +awey; +awez; +awfa; +awfb; +awfc; +awfd; +awfe; +awff; +awfg; +awfh; +awfi; +awfj; +awfk; +awfl; +awfm; +awfn; +awfo; +awfp; +awfq; +awfr; +awfs; +awft; +awfu; +awfv; +awfw; +awfx; +awfy; +awfz; +awga; +awgb; +awgc; +awgd; +awge; +awgf; +awgg; +awgh; +awgi; +awgj; +awgk; +awgl; +awgm; +awgn; +awgo; +awgp; +awgq; +awgr; +awgs; +awgt; +awgu; +awgv; +awgw; +awgx; +awgy; +awgz; +awha; +awhb; +awhc; +awhd; +awhe; +awhf; +awhg; +awhh; +awhi; +awhj; +awhk; +awhl; +awhm; +awhn; +awho; +awhp; +awhq; +awhr; +awhs; +awht; +awhu; +awhv; +awhw; +awhx; +awhy; +awhz; +awia; +awib; +awic; +awid; +awie; +awif; +awig; +awih; +awii; +awij; +awik; +awil; +awim; +awin; +awio; +awip; +awiq; +awir; +awis; +awit; +awiu; +awiv; +awiw; +awix; +awiy; +awiz; +awja; +awjb; +awjc; +awjd; +awje; +awjf; +awjg; +awjh; +awji; +awjj; +awjk; +awjl; +awjm; +awjn; +awjo; +awjp; +awjq; +awjr; +awjs; +awjt; +awju; +awjv; +awjw; +awjx; +awjy; +awjz; +awka; +awkb; +awkc; +awkd; +awke; +awkf; +awkg; +awkh; +awki; +awkj; +awkk; +awkl; +awkm; +awkn; +awko; +awkp; +awkq; +awkr; +awks; +awkt; +awku; +awkv; +awkw; +awkx; +awky; +awkz; +awla; +awlb; +awlc; +awld; +awle; +awlf; +awlg; +awlh; +awli; +awlj; +awlk; +awll; +awlm; +awln; +awlo; +awlp; +awlq; +awlr; +awls; +awlt; +awlu; +awlv; +awlw; +awlx; +awly; +awlz; +awma; +awmb; +awmc; +awmd; +awme; +awmf; +awmg; +awmh; +awmi; +awmj; +awmk; +awml; +awmm; +awmn; +awmo; +awmp; +awmq; +awmr; +awms; +awmt; +awmu; +awmv; +awmw; +awmx; +awmy; +awmz; +awna; +awnb; +awnc; +awnd; +awne; +awnf; +awng; +awnh; +awni; +awnj; +awnk; +awnl; +awnm; +awnn; +awno; +awnp; +awnq; +awnr; +awns; +awnt; +awnu; +awnv; +awnw; +awnx; +awny; +awnz; +awoa; +awob; +awoc; +awod; +awoe; +awof; +awog; +awoh; +awoi; +awoj; +awok; +awol; +awom; +awon; +awoo; +awop; +awoq; +awor; +awos; +awot; +awou; +awov; +awow; +awox; +awoy; +awoz; +awpa; +awpb; +awpc; +awpd; +awpe; +awpf; +awpg; +awph; +awpi; +awpj; +awpk; +awpl; +awpm; +awpn; +awpo; +awpp; +awpq; +awpr; +awps; +awpt; +awpu; +awpv; +awpw; +awpx; +awpy; +awpz; +awqa; +awqb; +awqc; +awqd; +awqe; +awqf; +awqg; +awqh; +awqi; +awqj; +awqk; +awql; +awqm; +awqn; +awqo; +awqp; +awqq; +awqr; +awqs; +awqt; +awqu; +awqv; +awqw; +awqx; +awqy; +awqz; +awra; +awrb; +awrc; +awrd; +awre; +awrf; +awrg; +awrh; +awri; +awrj; +awrk; +awrl; +awrm; +awrn; +awro; +awrp; +awrq; +awrr; +awrs; +awrt; +awru; +awrv; +awrw; +awrx; +awry; +awrz; +awsa; +awsb; +awsc; +awsd; +awse; +awsf; +awsg; +awsh; +awsi; +awsj; +awsk; +awsl; +awsm; +awsn; +awso; +awsp; +awsq; +awsr; +awss; +awst; +awsu; +awsv; +awsw; +awsx; +awsy; +awsz; +awta; +awtb; +awtc; +awtd; +awte; +awtf; +awtg; +awth; +awti; +awtj; +awtk; +awtl; +awtm; +awtn; +awto; +awtp; +awtq; +awtr; +awts; +awtt; +awtu; +awtv; +awtw; +awtx; +awty; +awtz; +awua; +awub; +awuc; +awud; +awue; +awuf; +awug; +awuh; +awui; +awuj; +awuk; +awul; +awum; +awun; +awuo; +awup; +awuq; +awur; +awus; +awut; +awuu; +awuv; +awuw; +awux; +awuy; +awuz; +awva; +awvb; +awvc; +awvd; +awve; +awvf; +awvg; +awvh; +awvi; +awvj; +awvk; +awvl; +awvm; +awvn; +awvo; +awvp; +awvq; +awvr; +awvs; +awvt; +awvu; +awvv; +awvw; +awvx; +awvy; +awvz; +awwa; +awwb; +awwc; +awwd; +awwe; +awwf; +awwg; +awwh; +awwi; +awwj; +awwk; +awwl; +awwm; +awwn; +awwo; +awwp; +awwq; +awwr; +awws; +awwt; +awwu; +awwv; +awww; +awwx; +awwy; +awwz; +awxa; +awxb; +awxc; +awxd; +awxe; +awxf; +awxg; +awxh; +awxi; +awxj; +awxk; +awxl; +awxm; +awxn; +awxo; +awxp; +awxq; +awxr; +awxs; +awxt; +awxu; +awxv; +awxw; +awxx; +awxy; +awxz; +awya; +awyb; +awyc; +awyd; +awye; +awyf; +awyg; +awyh; +awyi; +awyj; +awyk; +awyl; +awym; +awyn; +awyo; +awyp; +awyq; +awyr; +awys; +awyt; +awyu; +awyv; +awyw; +awyx; +awyy; +awyz; +awza; +awzb; +awzc; +awzd; +awze; +awzf; +awzg; +awzh; +awzi; +awzj; +awzk; +awzl; +awzm; +awzn; +awzo; +awzp; +awzq; +awzr; +awzs; +awzt; +awzu; +awzv; +awzw; +awzx; +awzy; +awzz; +axaa; +axab; +axac; +axad; +axae; +axaf; +axag; +axah; +axai; +axaj; +axak; +axal; +axam; +axan; +axao; +axap; +axaq; +axar; +axas; +axat; +axau; +axav; +axaw; +axax; +axay; +axaz; +axba; +axbb; +axbc; +axbd; +axbe; +axbf; +axbg; +axbh; +axbi; +axbj; +axbk; +axbl; +axbm; +axbn; +axbo; +axbp; +axbq; +axbr; +axbs; +axbt; +axbu; +axbv; +axbw; +axbx; +axby; +axbz; +axca; +axcb; +axcc; +axcd; +axce; +axcf; +axcg; +axch; +axci; +axcj; +axck; +axcl; +axcm; +axcn; +axco; +axcp; +axcq; +axcr; +axcs; +axct; +axcu; +axcv; +axcw; +axcx; +axcy; +axcz; +axda; +axdb; +axdc; +axdd; +axde; +axdf; +axdg; +axdh; +axdi; +axdj; +axdk; +axdl; +axdm; +axdn; +axdo; +axdp; +axdq; +axdr; +axds; +axdt; +axdu; +axdv; +axdw; +axdx; +axdy; +axdz; +axea; +axeb; +axec; +axed; +axee; +axef; +axeg; +axeh; +axei; +axej; +axek; +axel; +axem; +axen; +axeo; +axep; +axeq; +axer; +axes; +axet; +axeu; +axev; +axew; +axex; +axey; +axez; +axfa; +axfb; +axfc; +axfd; +axfe; +axff; +axfg; +axfh; +axfi; +axfj; +axfk; +axfl; +axfm; +axfn; +axfo; +axfp; +axfq; +axfr; +axfs; +axft; +axfu; +axfv; +axfw; +axfx; +axfy; +axfz; +axga; +axgb; +axgc; +axgd; +axge; +axgf; +axgg; +axgh; +axgi; +axgj; +axgk; +axgl; +axgm; +axgn; +axgo; +axgp; +axgq; +axgr; +axgs; +axgt; +axgu; +axgv; +axgw; +axgx; +axgy; +axgz; +axha; +axhb; +axhc; +axhd; +axhe; +axhf; +axhg; +axhh; +axhi; +axhj; +axhk; +axhl; +axhm; +axhn; +axho; +axhp; +axhq; +axhr; +axhs; +axht; +axhu; +axhv; +axhw; +axhx; +axhy; +axhz; +axia; +axib; +axic; +axid; +axie; +axif; +axig; +axih; +axii; +axij; +axik; +axil; +axim; +axin; +axio; +axip; +axiq; +axir; +axis; +axit; +axiu; +axiv; +axiw; +axix; +axiy; +axiz; +axja; +axjb; +axjc; +axjd; +axje; +axjf; +axjg; +axjh; +axji; +axjj; +axjk; +axjl; +axjm; +axjn; +axjo; +axjp; +axjq; +axjr; +axjs; +axjt; +axju; +axjv; +axjw; +axjx; +axjy; +axjz; +axka; +axkb; +axkc; +axkd; +axke; +axkf; +axkg; +axkh; +axki; +axkj; +axkk; +axkl; +axkm; +axkn; +axko; +axkp; +axkq; +axkr; +axks; +axkt; +axku; +axkv; +axkw; +axkx; +axky; +axkz; +axla; +axlb; +axlc; +axld; +axle; +axlf; +axlg; +axlh; +axli; +axlj; +axlk; +axll; +axlm; +axln; +axlo; +axlp; +axlq; +axlr; +axls; +axlt; +axlu; +axlv; +axlw; +axlx; +axly; +axlz; +axma; +axmb; +axmc; +axmd; +axme; +axmf; +axmg; +axmh; +axmi; +axmj; +axmk; +axml; +axmm; +axmn; +axmo; +axmp; +axmq; +axmr; +axms; +axmt; +axmu; +axmv; +axmw; +axmx; +axmy; +axmz; +axna; +axnb; +axnc; +axnd; +axne; +axnf; +axng; +axnh; +axni; +axnj; +axnk; +axnl; +axnm; +axnn; +axno; +axnp; +axnq; +axnr; +axns; +axnt; +axnu; +axnv; +axnw; +axnx; +axny; +axnz; +axoa; +axob; +axoc; +axod; +axoe; +axof; +axog; +axoh; +axoi; +axoj; +axok; +axol; +axom; +axon; +axoo; +axop; +axoq; +axor; +axos; +axot; +axou; +axov; +axow; +axox; +axoy; +axoz; +axpa; +axpb; +axpc; +axpd; +axpe; +axpf; +axpg; +axph; +axpi; +axpj; +axpk; +axpl; +axpm; +axpn; +axpo; +axpp; +axpq; +axpr; +axps; +axpt; +axpu; +axpv; +axpw; +axpx; +axpy; +axpz; +axqa; +axqb; +axqc; +axqd; +axqe; +axqf; +axqg; +axqh; +axqi; +axqj; +axqk; +axql; +axqm; +axqn; +axqo; +axqp; +axqq; +axqr; +axqs; +axqt; +axqu; +axqv; +axqw; +axqx; +axqy; +axqz; +axra; +axrb; +axrc; +axrd; +axre; +axrf; +axrg; +axrh; +axri; +axrj; +axrk; +axrl; +axrm; +axrn; +axro; +axrp; +axrq; +axrr; +axrs; +axrt; +axru; +axrv; +axrw; +axrx; +axry; +axrz; +axsa; +axsb; +axsc; +axsd; +axse; +axsf; +axsg; +axsh; +axsi; +axsj; +axsk; +axsl; +axsm; +axsn; +axso; +axsp; +axsq; +axsr; +axss; +axst; +axsu; +axsv; +axsw; +axsx; +axsy; +axsz; +axta; +axtb; +axtc; +axtd; +axte; +axtf; +axtg; +axth; +axti; +axtj; +axtk; +axtl; +axtm; +axtn; +axto; +axtp; +axtq; +axtr; +axts; +axtt; +axtu; +axtv; +axtw; +axtx; +axty; +axtz; +axua; +axub; +axuc; +axud; +axue; +axuf; +axug; +axuh; +axui; +axuj; +axuk; +axul; +axum; +axun; +axuo; +axup; +axuq; +axur; +axus; +axut; +axuu; +axuv; +axuw; +axux; +axuy; +axuz; +axva; +axvb; +axvc; +axvd; +axve; +axvf; +axvg; +axvh; +axvi; +axvj; +axvk; +axvl; +axvm; +axvn; +axvo; +axvp; +axvq; +axvr; +axvs; +axvt; +axvu; +axvv; +axvw; +axvx; +axvy; +axvz; +axwa; +axwb; +axwc; +axwd; +axwe; +axwf; +axwg; +axwh; +axwi; +axwj; +axwk; +axwl; +axwm; +axwn; +axwo; +axwp; +axwq; +axwr; +axws; +axwt; +axwu; +axwv; +axww; +axwx; +axwy; +axwz; +axxa; +axxb; +axxc; +axxd; +axxe; +axxf; +axxg; +axxh; +axxi; +axxj; +axxk; +axxl; +axxm; +axxn; +axxo; +axxp; +axxq; +axxr; +axxs; +axxt; +axxu; +axxv; +axxw; +axxx; +axxy; +axxz; +axya; +axyb; +axyc; +axyd; +axye; +axyf; +axyg; +axyh; +axyi; +axyj; +axyk; +axyl; +axym; +axyn; +axyo; +axyp; +axyq; +axyr; +axys; +axyt; +axyu; +axyv; +axyw; +axyx; +axyy; +axyz; +axza; +axzb; +axzc; +axzd; +axze; +axzf; +axzg; +axzh; +axzi; +axzj; +axzk; +axzl; +axzm; +axzn; +axzo; +axzp; +axzq; +axzr; +axzs; +axzt; +axzu; +axzv; +axzw; +axzx; +axzy; +axzz; +ayaa; +ayab; +ayac; +ayad; +ayae; +ayaf; +ayag; +ayah; +ayai; +ayaj; +ayak; +ayal; +ayam; +ayan; +ayao; +ayap; +ayaq; +ayar; +ayas; +ayat; +ayau; +ayav; +ayaw; +ayax; +ayay; +ayaz; +ayba; +aybb; +aybc; +aybd; +aybe; +aybf; +aybg; +aybh; +aybi; +aybj; +aybk; +aybl; +aybm; +aybn; +aybo; +aybp; +aybq; +aybr; +aybs; +aybt; +aybu; +aybv; +aybw; +aybx; +ayby; +aybz; +ayca; +aycb; +aycc; +aycd; +ayce; +aycf; +aycg; +aych; +ayci; +aycj; +ayck; +aycl; +aycm; +aycn; +ayco; +aycp; +aycq; +aycr; +aycs; +ayct; +aycu; +aycv; +aycw; +aycx; +aycy; +aycz; +ayda; +aydb; +aydc; +aydd; +ayde; +aydf; +aydg; +aydh; +aydi; +aydj; +aydk; +aydl; +aydm; +aydn; +aydo; +aydp; +aydq; +aydr; +ayds; +aydt; +aydu; +aydv; +aydw; +aydx; +aydy; +aydz; +ayea; +ayeb; +ayec; +ayed; +ayee; +ayef; +ayeg; +ayeh; +ayei; +ayej; +ayek; +ayel; +ayem; +ayen; +ayeo; +ayep; +ayeq; +ayer; +ayes; +ayet; +ayeu; +ayev; +ayew; +ayex; +ayey; +ayez; +ayfa; +ayfb; +ayfc; +ayfd; +ayfe; +ayff; +ayfg; +ayfh; +ayfi; +ayfj; +ayfk; +ayfl; +ayfm; +ayfn; +ayfo; +ayfp; +ayfq; +ayfr; +ayfs; +ayft; +ayfu; +ayfv; +ayfw; +ayfx; +ayfy; +ayfz; +ayga; +aygb; +aygc; +aygd; +ayge; +aygf; +aygg; +aygh; +aygi; +aygj; +aygk; +aygl; +aygm; +aygn; +aygo; +aygp; +aygq; +aygr; +aygs; +aygt; +aygu; +aygv; +aygw; +aygx; +aygy; +aygz; +ayha; +ayhb; +ayhc; +ayhd; +ayhe; +ayhf; +ayhg; +ayhh; +ayhi; +ayhj; +ayhk; +ayhl; +ayhm; +ayhn; +ayho; +ayhp; +ayhq; +ayhr; +ayhs; +ayht; +ayhu; +ayhv; +ayhw; +ayhx; +ayhy; +ayhz; +ayia; +ayib; +ayic; +ayid; +ayie; +ayif; +ayig; +ayih; +ayii; +ayij; +ayik; +ayil; +ayim; +ayin; +ayio; +ayip; +ayiq; +ayir; +ayis; +ayit; +ayiu; +ayiv; +ayiw; +ayix; +ayiy; +ayiz; +ayja; +ayjb; +ayjc; +ayjd; +ayje; +ayjf; +ayjg; +ayjh; +ayji; +ayjj; +ayjk; +ayjl; +ayjm; +ayjn; +ayjo; +ayjp; +ayjq; +ayjr; +ayjs; +ayjt; +ayju; +ayjv; +ayjw; +ayjx; +ayjy; +ayjz; +ayka; +aykb; +aykc; +aykd; +ayke; +aykf; +aykg; +aykh; +ayki; +aykj; +aykk; +aykl; +aykm; +aykn; +ayko; +aykp; +aykq; +aykr; +ayks; +aykt; +ayku; +aykv; +aykw; +aykx; +ayky; +aykz; +ayla; +aylb; +aylc; +ayld; +ayle; +aylf; +aylg; +aylh; +ayli; +aylj; +aylk; +ayll; +aylm; +ayln; +aylo; +aylp; +aylq; +aylr; +ayls; +aylt; +aylu; +aylv; +aylw; +aylx; +ayly; +aylz; +ayma; +aymb; +aymc; +aymd; +ayme; +aymf; +aymg; +aymh; +aymi; +aymj; +aymk; +ayml; +aymm; +aymn; +aymo; +aymp; +aymq; +aymr; +ayms; +aymt; +aymu; +aymv; +aymw; +aymx; +aymy; +aymz; +ayna; +aynb; +aync; +aynd; +ayne; +aynf; +ayng; +aynh; +ayni; +aynj; +aynk; +aynl; +aynm; +aynn; +ayno; +aynp; +aynq; +aynr; +ayns; +aynt; +aynu; +aynv; +aynw; +aynx; +ayny; +aynz; +ayoa; +ayob; +ayoc; +ayod; +ayoe; +ayof; +ayog; +ayoh; +ayoi; +ayoj; +ayok; +ayol; +ayom; +ayon; +ayoo; +ayop; +ayoq; +ayor; +ayos; +ayot; +ayou; +ayov; +ayow; +ayox; +ayoy; +ayoz; +aypa; +aypb; +aypc; +aypd; +aype; +aypf; +aypg; +ayph; +aypi; +aypj; +aypk; +aypl; +aypm; +aypn; +aypo; +aypp; +aypq; +aypr; +ayps; +aypt; +aypu; +aypv; +aypw; +aypx; +aypy; +aypz; +ayqa; +ayqb; +ayqc; +ayqd; +ayqe; +ayqf; +ayqg; +ayqh; +ayqi; +ayqj; +ayqk; +ayql; +ayqm; +ayqn; +ayqo; +ayqp; +ayqq; +ayqr; +ayqs; +ayqt; +ayqu; +ayqv; +ayqw; +ayqx; +ayqy; +ayqz; +ayra; +ayrb; +ayrc; +ayrd; +ayre; +ayrf; +ayrg; +ayrh; +ayri; +ayrj; +ayrk; +ayrl; +ayrm; +ayrn; +ayro; +ayrp; +ayrq; +ayrr; +ayrs; +ayrt; +ayru; +ayrv; +ayrw; +ayrx; +ayry; +ayrz; +aysa; +aysb; +aysc; +aysd; +ayse; +aysf; +aysg; +aysh; +aysi; +aysj; +aysk; +aysl; +aysm; +aysn; +ayso; +aysp; +aysq; +aysr; +ayss; +ayst; +aysu; +aysv; +aysw; +aysx; +aysy; +aysz; +ayta; +aytb; +aytc; +aytd; +ayte; +aytf; +aytg; +ayth; +ayti; +aytj; +aytk; +aytl; +aytm; +aytn; +ayto; +aytp; +aytq; +aytr; +ayts; +aytt; +aytu; +aytv; +aytw; +aytx; +ayty; +aytz; +ayua; +ayub; +ayuc; +ayud; +ayue; +ayuf; +ayug; +ayuh; +ayui; +ayuj; +ayuk; +ayul; +ayum; +ayun; +ayuo; +ayup; +ayuq; +ayur; +ayus; +ayut; +ayuu; +ayuv; +ayuw; +ayux; +ayuy; +ayuz; +ayva; +ayvb; +ayvc; +ayvd; +ayve; +ayvf; +ayvg; +ayvh; +ayvi; +ayvj; +ayvk; +ayvl; +ayvm; +ayvn; +ayvo; +ayvp; +ayvq; +ayvr; +ayvs; +ayvt; +ayvu; +ayvv; +ayvw; +ayvx; +ayvy; +ayvz; +aywa; +aywb; +aywc; +aywd; +aywe; +aywf; +aywg; +aywh; +aywi; +aywj; +aywk; +aywl; +aywm; +aywn; +aywo; +aywp; +aywq; +aywr; +ayws; +aywt; +aywu; +aywv; +ayww; +aywx; +aywy; +aywz; +ayxa; +ayxb; +ayxc; +ayxd; +ayxe; +ayxf; +ayxg; +ayxh; +ayxi; +ayxj; +ayxk; +ayxl; +ayxm; +ayxn; +ayxo; +ayxp; +ayxq; +ayxr; +ayxs; +ayxt; +ayxu; +ayxv; +ayxw; +ayxx; +ayxy; +ayxz; +ayya; +ayyb; +ayyc; +ayyd; +ayye; +ayyf; +ayyg; +ayyh; +ayyi; +ayyj; +ayyk; +ayyl; +ayym; +ayyn; +ayyo; +ayyp; +ayyq; +ayyr; +ayys; +ayyt; +ayyu; +ayyv; +ayyw; +ayyx; +ayyy; +ayyz; +ayza; +ayzb; +ayzc; +ayzd; +ayze; +ayzf; +ayzg; +ayzh; +ayzi; +ayzj; +ayzk; +ayzl; +ayzm; +ayzn; +ayzo; +ayzp; +ayzq; +ayzr; +ayzs; +ayzt; +ayzu; +ayzv; +ayzw; +ayzx; +ayzy; +ayzz; +azaa; +azab; +azac; +azad; +azae; +azaf; +azag; +azah; +azai; +azaj; +azak; +azal; +azam; +azan; +azao; +azap; +azaq; +azar; +azas; +azat; +azau; +azav; +azaw; +azax; +azay; +azaz; +azba; +azbb; +azbc; +azbd; +azbe; +azbf; +azbg; +azbh; +azbi; +azbj; +azbk; +azbl; +azbm; +azbn; +azbo; +azbp; +azbq; +azbr; +azbs; +azbt; +azbu; +azbv; +azbw; +azbx; +azby; +azbz; +azca; +azcb; +azcc; +azcd; +azce; +azcf; +azcg; +azch; +azci; +azcj; +azck; +azcl; +azcm; +azcn; +azco; +azcp; +azcq; +azcr; +azcs; +azct; +azcu; +azcv; +azcw; +azcx; +azcy; +azcz; +azda; +azdb; +azdc; +azdd; +azde; +azdf; +azdg; +azdh; +azdi; +azdj; +azdk; +azdl; +azdm; +azdn; +azdo; +azdp; +azdq; +azdr; +azds; +azdt; +azdu; +azdv; +azdw; +azdx; +azdy; +azdz; +azea; +azeb; +azec; +azed; +azee; +azef; +azeg; +azeh; +azei; +azej; +azek; +azel; +azem; +azen; +azeo; +azep; +azeq; +azer; +azes; +azet; +azeu; +azev; +azew; +azex; +azey; +azez; +azfa; +azfb; +azfc; +azfd; +azfe; +azff; +azfg; +azfh; +azfi; +azfj; +azfk; +azfl; +azfm; +azfn; +azfo; +azfp; +azfq; +azfr; +azfs; +azft; +azfu; +azfv; +azfw; +azfx; +azfy; +azfz; +azga; +azgb; +azgc; +azgd; +azge; +azgf; +azgg; +azgh; +azgi; +azgj; +azgk; +azgl; +azgm; +azgn; +azgo; +azgp; +azgq; +azgr; +azgs; +azgt; +azgu; +azgv; +azgw; +azgx; +azgy; +azgz; +azha; +azhb; +azhc; +azhd; +azhe; +azhf; +azhg; +azhh; +azhi; +azhj; +azhk; +azhl; +azhm; +azhn; +azho; +azhp; +azhq; +azhr; +azhs; +azht; +azhu; +azhv; +azhw; +azhx; +azhy; +azhz; +azia; +azib; +azic; +azid; +azie; +azif; +azig; +azih; +azii; +azij; +azik; +azil; +azim; +azin; +azio; +azip; +aziq; +azir; +azis; +azit; +aziu; +aziv; +aziw; +azix; +aziy; +aziz; +azja; +azjb; +azjc; +azjd; +azje; +azjf; +azjg; +azjh; +azji; +azjj; +azjk; +azjl; +azjm; +azjn; +azjo; +azjp; +azjq; +azjr; +azjs; +azjt; +azju; +azjv; +azjw; +azjx; +azjy; +azjz; +azka; +azkb; +azkc; +azkd; +azke; +azkf; +azkg; +azkh; +azki; +azkj; +azkk; +azkl; +azkm; +azkn; +azko; +azkp; +azkq; +azkr; +azks; +azkt; +azku; +azkv; +azkw; +azkx; +azky; +azkz; +azla; +azlb; +azlc; +azld; +azle; +azlf; +azlg; +azlh; +azli; +azlj; +azlk; +azll; +azlm; +azln; +azlo; +azlp; +azlq; +azlr; +azls; +azlt; +azlu; +azlv; +azlw; +azlx; +azly; +azlz; +azma; +azmb; +azmc; +azmd; +azme; +azmf; +azmg; +azmh; +azmi; +azmj; +azmk; +azml; +azmm; +azmn; +azmo; +azmp; +azmq; +azmr; +azms; +azmt; +azmu; +azmv; +azmw; +azmx; +azmy; +azmz; +azna; +aznb; +aznc; +aznd; +azne; +aznf; +azng; +aznh; +azni; +aznj; +aznk; +aznl; +aznm; +aznn; +azno; +aznp; +aznq; +aznr; +azns; +aznt; +aznu; +aznv; +aznw; +aznx; +azny; +aznz; +azoa; +azob; +azoc; +azod; +azoe; +azof; +azog; +azoh; +azoi; +azoj; +azok; +azol; +azom; +azon; +azoo; +azop; +azoq; +azor; +azos; +azot; +azou; +azov; +azow; +azox; +azoy; +azoz; +azpa; +azpb; +azpc; +azpd; +azpe; +azpf; +azpg; +azph; +azpi; +azpj; +azpk; +azpl; +azpm; +azpn; +azpo; +azpp; +azpq; +azpr; +azps; +azpt; +azpu; +azpv; +azpw; +azpx; +azpy; +azpz; +azqa; +azqb; +azqc; +azqd; +azqe; +azqf; +azqg; +azqh; +azqi; +azqj; +azqk; +azql; +azqm; +azqn; +azqo; +azqp; +azqq; +azqr; +azqs; +azqt; +azqu; +azqv; +azqw; +azqx; +azqy; +azqz; +azra; +azrb; +azrc; +azrd; +azre; +azrf; +azrg; +azrh; +azri; +azrj; +azrk; +azrl; +azrm; +azrn; +azro; +azrp; +azrq; +azrr; +azrs; +azrt; +azru; +azrv; +azrw; +azrx; +azry; +azrz; +azsa; +azsb; +azsc; +azsd; +azse; +azsf; +azsg; +azsh; +azsi; +azsj; +azsk; +azsl; +azsm; +azsn; +azso; +azsp; +azsq; +azsr; +azss; +azst; +azsu; +azsv; +azsw; +azsx; +azsy; +azsz; +azta; +aztb; +aztc; +aztd; +azte; +aztf; +aztg; +azth; +azti; +aztj; +aztk; +aztl; +aztm; +aztn; +azto; +aztp; +aztq; +aztr; +azts; +aztt; +aztu; +aztv; +aztw; +aztx; +azty; +aztz; +azua; +azub; +azuc; +azud; +azue; +azuf; +azug; +azuh; +azui; +azuj; +azuk; +azul; +azum; +azun; +azuo; +azup; +azuq; +azur; +azus; +azut; +azuu; +azuv; +azuw; +azux; +azuy; +azuz; +azva; +azvb; +azvc; +azvd; +azve; +azvf; +azvg; +azvh; +azvi; +azvj; +azvk; +azvl; +azvm; +azvn; +azvo; +azvp; +azvq; +azvr; +azvs; +azvt; +azvu; +azvv; +azvw; +azvx; +azvy; +azvz; +azwa; +azwb; +azwc; +azwd; +azwe; +azwf; +azwg; +azwh; +azwi; +azwj; +azwk; +azwl; +azwm; +azwn; +azwo; +azwp; +azwq; +azwr; +azws; +azwt; +azwu; +azwv; +azww; +azwx; +azwy; +azwz; +azxa; +azxb; +azxc; +azxd; +azxe; +azxf; +azxg; +azxh; +azxi; +azxj; +azxk; +azxl; +azxm; +azxn; +azxo; +azxp; +azxq; +azxr; +azxs; +azxt; +azxu; +azxv; +azxw; +azxx; +azxy; +azxz; +azya; +azyb; +azyc; +azyd; +azye; +azyf; +azyg; +azyh; +azyi; +azyj; +azyk; +azyl; +azym; +azyn; +azyo; +azyp; +azyq; +azyr; +azys; +azyt; +azyu; +azyv; +azyw; +azyx; +azyy; +azyz; +azza; +azzb; +azzc; +azzd; +azze; +azzf; +azzg; +azzh; +azzi; +azzj; +azzk; +azzl; +azzm; +azzn; +azzo; +azzp; +azzq; +azzr; +azzs; +azzt; +azzu; +azzv; +azzw; +azzx; +azzy; +azzz; +baaa; +baab; +baac; +baad; +baae; +baaf; +baag; +baah; +baai; +baaj; +baak; +baal; +baam; +baan; +baao; +baap; +baaq; +baar; +baas; +baat; +baau; +baav; +baaw; +baax; +baay; +baaz; +baba; +babb; +babc; +babd; +babe; +babf; +babg; +babh; +babi; +babj; +babk; +babl; +babm; +babn; +babo; +babp; +babq; +babr; +babs; +babt; +babu; +babv; +babw; +babx; +baby; +babz; +baca; +bacb; +bacc; +bacd; +bace; +bacf; +bacg; +bach; +baci; +bacj; +back; +bacl; +bacm; +bacn; +baco; +bacp; +bacq; +bacr; +bacs; +bact; +bacu; +bacv; +bacw; +bacx; +bacy; +bacz; +bada; +badb; +badc; +badd; +bade; +badf; +badg; +badh; +badi; +badj; +badk; +badl; +badm; +badn; +bado; +badp; +badq; +badr; +bads; +badt; +badu; +badv; +badw; +badx; +bady; +badz; +baea; +baeb; +baec; +baed; +baee; +baef; +baeg; +baeh; +baei; +baej; +baek; +bael; +baem; +baen; +baeo; +baep; +baeq; +baer; +baes; +baet; +baeu; +baev; +baew; +baex; +baey; +baez; +bafa; +bafb; +bafc; +bafd; +bafe; +baff; +bafg; +bafh; +bafi; +bafj; +bafk; +bafl; +bafm; +bafn; +bafo; +bafp; +bafq; +bafr; +bafs; +baft; +bafu; +bafv; +bafw; +bafx; +bafy; +bafz; +baga; +bagb; +bagc; +bagd; +bage; +bagf; +bagg; +bagh; +bagi; +bagj; +bagk; +bagl; +bagm; +bagn; +bago; +bagp; +bagq; +bagr; +bags; +bagt; +bagu; +bagv; +bagw; +bagx; +bagy; +bagz; +baha; +bahb; +bahc; +bahd; +bahe; +bahf; +bahg; +bahh; +bahi; +bahj; +bahk; +bahl; +bahm; +bahn; +baho; +bahp; +bahq; +bahr; +bahs; +baht; +bahu; +bahv; +bahw; +bahx; +bahy; +bahz; +baia; +baib; +baic; +baid; +baie; +baif; +baig; +baih; +baii; +baij; +baik; +bail; +baim; +bain; +baio; +baip; +baiq; +bair; +bais; +bait; +baiu; +baiv; +baiw; +baix; +baiy; +baiz; +baja; +bajb; +bajc; +bajd; +baje; +bajf; +bajg; +bajh; +baji; +bajj; +bajk; +bajl; +bajm; +bajn; +bajo; +bajp; +bajq; +bajr; +bajs; +bajt; +baju; +bajv; +bajw; +bajx; +bajy; +bajz; +baka; +bakb; +bakc; +bakd; +bake; +bakf; +bakg; +bakh; +baki; +bakj; +bakk; +bakl; +bakm; +bakn; +bako; +bakp; +bakq; +bakr; +baks; +bakt; +baku; +bakv; +bakw; +bakx; +baky; +bakz; +bala; +balb; +balc; +bald; +bale; +balf; +balg; +balh; +bali; +balj; +balk; +ball; +balm; +baln; +balo; +balp; +balq; +balr; +bals; +balt; +balu; +balv; +balw; +balx; +baly; +balz; +bama; +bamb; +bamc; +bamd; +bame; +bamf; +bamg; +bamh; +bami; +bamj; +bamk; +baml; +bamm; +bamn; +bamo; +bamp; +bamq; +bamr; +bams; +bamt; +bamu; +bamv; +bamw; +bamx; +bamy; +bamz; +bana; +banb; +banc; +band; +bane; +banf; +bang; +banh; +bani; +banj; +bank; +banl; +banm; +bann; +bano; +banp; +banq; +banr; +bans; +bant; +banu; +banv; +banw; +banx; +bany; +banz; +baoa; +baob; +baoc; +baod; +baoe; +baof; +baog; +baoh; +baoi; +baoj; +baok; +baol; +baom; +baon; +baoo; +baop; +baoq; +baor; +baos; +baot; +baou; +baov; +baow; +baox; +baoy; +baoz; +bapa; +bapb; +bapc; +bapd; +bape; +bapf; +bapg; +baph; +bapi; +bapj; +bapk; +bapl; +bapm; +bapn; +bapo; +bapp; +bapq; +bapr; +baps; +bapt; +bapu; +bapv; +bapw; +bapx; +bapy; +bapz; +baqa; +baqb; +baqc; +baqd; +baqe; +baqf; +baqg; +baqh; +baqi; +baqj; +baqk; +baql; +baqm; +baqn; +baqo; +baqp; +baqq; +baqr; +baqs; +baqt; +baqu; +baqv; +baqw; +baqx; +baqy; +baqz; +bara; +barb; +barc; +bard; +bare; +barf; +barg; +barh; +bari; +barj; +bark; +barl; +barm; +barn; +baro; +barp; +barq; +barr; +bars; +bart; +baru; +barv; +barw; +barx; +bary; +barz; +basa; +basb; +basc; +basd; +base; +basf; +basg; +bash; +basi; +basj; +bask; +basl; +basm; +basn; +baso; +basp; +basq; +basr; +bass; +bast; +basu; +basv; +basw; +basx; +basy; +basz; +bata; +batb; +batc; +batd; +bate; +batf; +batg; +bath; +bati; +batj; +batk; +batl; +batm; +batn; +bato; +batp; +batq; +batr; +bats; +batt; +batu; +batv; +batw; +batx; +baty; +batz; +baua; +baub; +bauc; +baud; +baue; +bauf; +baug; +bauh; +baui; +bauj; +bauk; +baul; +baum; +baun; +bauo; +baup; +bauq; +baur; +baus; +baut; +bauu; +bauv; +bauw; +baux; +bauy; +bauz; +bava; +bavb; +bavc; +bavd; +bave; +bavf; +bavg; +bavh; +bavi; +bavj; +bavk; +bavl; +bavm; +bavn; +bavo; +bavp; +bavq; +bavr; +bavs; +bavt; +bavu; +bavv; +bavw; +bavx; +bavy; +bavz; +bawa; +bawb; +bawc; +bawd; +bawe; +bawf; +bawg; +bawh; +bawi; +bawj; +bawk; +bawl; +bawm; +bawn; +bawo; +bawp; +bawq; +bawr; +baws; +bawt; +bawu; +bawv; +baww; +bawx; +bawy; +bawz; +baxa; +baxb; +baxc; +baxd; +baxe; +baxf; +baxg; +baxh; +baxi; +baxj; +baxk; +baxl; +baxm; +baxn; +baxo; +baxp; +baxq; +baxr; +baxs; +baxt; +baxu; +baxv; +baxw; +baxx; +baxy; +baxz; +baya; +bayb; +bayc; +bayd; +baye; +bayf; +bayg; +bayh; +bayi; +bayj; +bayk; +bayl; +baym; +bayn; +bayo; +bayp; +bayq; +bayr; +bays; +bayt; +bayu; +bayv; +bayw; +bayx; +bayy; +bayz; +baza; +bazb; +bazc; +bazd; +baze; +bazf; +bazg; +bazh; +bazi; +bazj; +bazk; +bazl; +bazm; +bazn; +bazo; +bazp; +bazq; +bazr; +bazs; +bazt; +bazu; +bazv; +bazw; +bazx; +bazy; +bazz; +bbaa; +bbab; +bbac; +bbad; +bbae; +bbaf; +bbag; +bbah; +bbai; +bbaj; +bbak; +bbal; +bbam; +bban; +bbao; +bbap; +bbaq; +bbar; +bbas; +bbat; +bbau; +bbav; +bbaw; +bbax; +bbay; +bbaz; +bbba; +bbbb +|]; diff --git a/camlp4/test/fixtures/big-tab3.ml b/camlp4/test/fixtures/big-tab3.ml new file mode 100644 index 00000000..a597031a --- /dev/null +++ b/camlp4/test/fixtures/big-tab3.ml @@ -0,0 +1,20001 @@ +[| +aaaaa; +aaaab; +aaaac; +aaaad; +aaaae; +aaaaf; +aaaag; +aaaah; +aaaai; +aaaaj; +aaaak; +aaaal; +aaaam; +aaaan; +aaaao; +aaaap; +aaaaq; +aaaar; +aaaas; +aaaat; +aaaau; +aaaav; +aaaaw; +aaaax; +aaaay; +aaaaz; +aaaba; +aaabb; +aaabc; +aaabd; +aaabe; +aaabf; +aaabg; +aaabh; +aaabi; +aaabj; +aaabk; +aaabl; +aaabm; +aaabn; +aaabo; +aaabp; +aaabq; +aaabr; +aaabs; +aaabt; +aaabu; +aaabv; +aaabw; +aaabx; +aaaby; +aaabz; +aaaca; +aaacb; +aaacc; +aaacd; +aaace; +aaacf; +aaacg; +aaach; +aaaci; +aaacj; +aaack; +aaacl; +aaacm; +aaacn; +aaaco; +aaacp; +aaacq; +aaacr; +aaacs; +aaact; +aaacu; +aaacv; +aaacw; +aaacx; +aaacy; +aaacz; +aaada; +aaadb; +aaadc; +aaadd; +aaade; +aaadf; +aaadg; +aaadh; +aaadi; +aaadj; +aaadk; +aaadl; +aaadm; +aaadn; +aaado; +aaadp; +aaadq; +aaadr; +aaads; +aaadt; +aaadu; +aaadv; +aaadw; +aaadx; +aaady; +aaadz; +aaaea; +aaaeb; +aaaec; +aaaed; +aaaee; +aaaef; +aaaeg; +aaaeh; +aaaei; +aaaej; +aaaek; +aaael; +aaaem; +aaaen; +aaaeo; +aaaep; +aaaeq; +aaaer; +aaaes; +aaaet; +aaaeu; +aaaev; +aaaew; +aaaex; +aaaey; +aaaez; +aaafa; +aaafb; +aaafc; +aaafd; +aaafe; +aaaff; +aaafg; +aaafh; +aaafi; +aaafj; +aaafk; +aaafl; +aaafm; +aaafn; +aaafo; +aaafp; +aaafq; +aaafr; +aaafs; +aaaft; +aaafu; +aaafv; +aaafw; +aaafx; +aaafy; +aaafz; +aaaga; +aaagb; +aaagc; +aaagd; +aaage; +aaagf; +aaagg; +aaagh; +aaagi; +aaagj; +aaagk; +aaagl; +aaagm; +aaagn; +aaago; +aaagp; +aaagq; +aaagr; +aaags; +aaagt; +aaagu; +aaagv; +aaagw; +aaagx; +aaagy; +aaagz; +aaaha; +aaahb; +aaahc; +aaahd; +aaahe; +aaahf; +aaahg; +aaahh; +aaahi; +aaahj; +aaahk; +aaahl; +aaahm; +aaahn; +aaaho; +aaahp; +aaahq; +aaahr; +aaahs; +aaaht; +aaahu; +aaahv; +aaahw; +aaahx; +aaahy; +aaahz; +aaaia; +aaaib; +aaaic; +aaaid; +aaaie; +aaaif; +aaaig; +aaaih; +aaaii; +aaaij; +aaaik; +aaail; +aaaim; +aaain; +aaaio; +aaaip; +aaaiq; +aaair; +aaais; +aaait; +aaaiu; +aaaiv; +aaaiw; +aaaix; +aaaiy; +aaaiz; +aaaja; +aaajb; +aaajc; +aaajd; +aaaje; +aaajf; +aaajg; +aaajh; +aaaji; +aaajj; +aaajk; +aaajl; +aaajm; +aaajn; +aaajo; +aaajp; +aaajq; +aaajr; +aaajs; +aaajt; +aaaju; +aaajv; +aaajw; +aaajx; +aaajy; +aaajz; +aaaka; +aaakb; +aaakc; +aaakd; +aaake; +aaakf; +aaakg; +aaakh; +aaaki; +aaakj; +aaakk; +aaakl; +aaakm; +aaakn; +aaako; +aaakp; +aaakq; +aaakr; +aaaks; +aaakt; +aaaku; +aaakv; +aaakw; +aaakx; +aaaky; +aaakz; +aaala; +aaalb; +aaalc; +aaald; +aaale; +aaalf; +aaalg; +aaalh; +aaali; +aaalj; +aaalk; +aaall; +aaalm; +aaaln; +aaalo; +aaalp; +aaalq; +aaalr; +aaals; +aaalt; +aaalu; +aaalv; +aaalw; +aaalx; +aaaly; +aaalz; +aaama; +aaamb; +aaamc; +aaamd; +aaame; +aaamf; +aaamg; +aaamh; +aaami; +aaamj; +aaamk; +aaaml; +aaamm; +aaamn; +aaamo; +aaamp; +aaamq; +aaamr; +aaams; +aaamt; +aaamu; +aaamv; +aaamw; +aaamx; +aaamy; +aaamz; +aaana; +aaanb; +aaanc; +aaand; +aaane; +aaanf; +aaang; +aaanh; +aaani; +aaanj; +aaank; +aaanl; +aaanm; +aaann; +aaano; +aaanp; +aaanq; +aaanr; +aaans; +aaant; +aaanu; +aaanv; +aaanw; +aaanx; +aaany; +aaanz; +aaaoa; +aaaob; +aaaoc; +aaaod; +aaaoe; +aaaof; +aaaog; +aaaoh; +aaaoi; +aaaoj; +aaaok; +aaaol; +aaaom; +aaaon; +aaaoo; +aaaop; +aaaoq; +aaaor; +aaaos; +aaaot; +aaaou; +aaaov; +aaaow; +aaaox; +aaaoy; +aaaoz; +aaapa; +aaapb; +aaapc; +aaapd; +aaape; +aaapf; +aaapg; +aaaph; +aaapi; +aaapj; +aaapk; +aaapl; +aaapm; +aaapn; +aaapo; +aaapp; +aaapq; +aaapr; +aaaps; +aaapt; +aaapu; +aaapv; +aaapw; +aaapx; +aaapy; +aaapz; +aaaqa; +aaaqb; +aaaqc; +aaaqd; +aaaqe; +aaaqf; +aaaqg; +aaaqh; +aaaqi; +aaaqj; +aaaqk; +aaaql; +aaaqm; +aaaqn; +aaaqo; +aaaqp; +aaaqq; +aaaqr; +aaaqs; +aaaqt; +aaaqu; +aaaqv; +aaaqw; +aaaqx; +aaaqy; +aaaqz; +aaara; +aaarb; +aaarc; +aaard; +aaare; +aaarf; +aaarg; +aaarh; +aaari; +aaarj; +aaark; +aaarl; +aaarm; +aaarn; +aaaro; +aaarp; +aaarq; +aaarr; +aaars; +aaart; +aaaru; +aaarv; +aaarw; +aaarx; +aaary; +aaarz; +aaasa; +aaasb; +aaasc; +aaasd; +aaase; +aaasf; +aaasg; +aaash; +aaasi; +aaasj; +aaask; +aaasl; +aaasm; +aaasn; +aaaso; +aaasp; +aaasq; +aaasr; +aaass; +aaast; +aaasu; +aaasv; +aaasw; +aaasx; +aaasy; +aaasz; +aaata; +aaatb; +aaatc; +aaatd; +aaate; +aaatf; +aaatg; +aaath; +aaati; +aaatj; +aaatk; +aaatl; +aaatm; +aaatn; +aaato; +aaatp; +aaatq; +aaatr; +aaats; +aaatt; +aaatu; +aaatv; +aaatw; +aaatx; +aaaty; +aaatz; +aaaua; +aaaub; +aaauc; +aaaud; +aaaue; +aaauf; +aaaug; +aaauh; +aaaui; +aaauj; +aaauk; +aaaul; +aaaum; +aaaun; +aaauo; +aaaup; +aaauq; +aaaur; +aaaus; +aaaut; +aaauu; +aaauv; +aaauw; +aaaux; +aaauy; +aaauz; +aaava; +aaavb; +aaavc; +aaavd; +aaave; +aaavf; +aaavg; +aaavh; +aaavi; +aaavj; +aaavk; +aaavl; +aaavm; +aaavn; +aaavo; +aaavp; +aaavq; +aaavr; +aaavs; +aaavt; +aaavu; +aaavv; +aaavw; +aaavx; +aaavy; +aaavz; +aaawa; +aaawb; +aaawc; +aaawd; +aaawe; +aaawf; +aaawg; +aaawh; +aaawi; +aaawj; +aaawk; +aaawl; +aaawm; +aaawn; +aaawo; +aaawp; +aaawq; +aaawr; +aaaws; +aaawt; +aaawu; +aaawv; +aaaww; +aaawx; +aaawy; +aaawz; +aaaxa; +aaaxb; +aaaxc; +aaaxd; +aaaxe; +aaaxf; +aaaxg; +aaaxh; +aaaxi; +aaaxj; +aaaxk; +aaaxl; +aaaxm; +aaaxn; +aaaxo; +aaaxp; +aaaxq; +aaaxr; +aaaxs; +aaaxt; +aaaxu; +aaaxv; +aaaxw; +aaaxx; +aaaxy; +aaaxz; +aaaya; +aaayb; +aaayc; +aaayd; +aaaye; +aaayf; +aaayg; +aaayh; +aaayi; +aaayj; +aaayk; +aaayl; +aaaym; +aaayn; +aaayo; +aaayp; +aaayq; +aaayr; +aaays; +aaayt; +aaayu; +aaayv; +aaayw; +aaayx; +aaayy; +aaayz; +aaaza; +aaazb; +aaazc; +aaazd; +aaaze; +aaazf; +aaazg; +aaazh; +aaazi; +aaazj; +aaazk; +aaazl; +aaazm; +aaazn; +aaazo; +aaazp; +aaazq; +aaazr; +aaazs; +aaazt; +aaazu; +aaazv; +aaazw; +aaazx; +aaazy; +aaazz; +aabaa; +aabab; +aabac; +aabad; +aabae; +aabaf; +aabag; +aabah; +aabai; +aabaj; +aabak; +aabal; +aabam; +aaban; +aabao; +aabap; +aabaq; +aabar; +aabas; +aabat; +aabau; +aabav; +aabaw; +aabax; +aabay; +aabaz; +aabba; +aabbb; +aabbc; +aabbd; +aabbe; +aabbf; +aabbg; +aabbh; +aabbi; +aabbj; +aabbk; +aabbl; +aabbm; +aabbn; +aabbo; +aabbp; +aabbq; +aabbr; +aabbs; +aabbt; +aabbu; +aabbv; +aabbw; +aabbx; +aabby; +aabbz; +aabca; +aabcb; +aabcc; +aabcd; +aabce; +aabcf; +aabcg; +aabch; +aabci; +aabcj; +aabck; +aabcl; +aabcm; +aabcn; +aabco; +aabcp; +aabcq; +aabcr; +aabcs; +aabct; +aabcu; +aabcv; +aabcw; +aabcx; +aabcy; +aabcz; +aabda; +aabdb; +aabdc; +aabdd; +aabde; +aabdf; +aabdg; +aabdh; +aabdi; +aabdj; +aabdk; +aabdl; +aabdm; +aabdn; +aabdo; +aabdp; +aabdq; +aabdr; +aabds; +aabdt; +aabdu; +aabdv; +aabdw; +aabdx; +aabdy; +aabdz; +aabea; +aabeb; +aabec; +aabed; +aabee; +aabef; +aabeg; +aabeh; +aabei; +aabej; +aabek; +aabel; +aabem; +aaben; +aabeo; +aabep; +aabeq; +aaber; +aabes; +aabet; +aabeu; +aabev; +aabew; +aabex; +aabey; +aabez; +aabfa; +aabfb; +aabfc; +aabfd; +aabfe; +aabff; +aabfg; +aabfh; +aabfi; +aabfj; +aabfk; +aabfl; +aabfm; +aabfn; +aabfo; +aabfp; +aabfq; +aabfr; +aabfs; +aabft; +aabfu; +aabfv; +aabfw; +aabfx; +aabfy; +aabfz; +aabga; +aabgb; +aabgc; +aabgd; +aabge; +aabgf; +aabgg; +aabgh; +aabgi; +aabgj; +aabgk; +aabgl; +aabgm; +aabgn; +aabgo; +aabgp; +aabgq; +aabgr; +aabgs; +aabgt; +aabgu; +aabgv; +aabgw; +aabgx; +aabgy; +aabgz; +aabha; +aabhb; +aabhc; +aabhd; +aabhe; +aabhf; +aabhg; +aabhh; +aabhi; +aabhj; +aabhk; +aabhl; +aabhm; +aabhn; +aabho; +aabhp; +aabhq; +aabhr; +aabhs; +aabht; +aabhu; +aabhv; +aabhw; +aabhx; +aabhy; +aabhz; +aabia; +aabib; +aabic; +aabid; +aabie; +aabif; +aabig; +aabih; +aabii; +aabij; +aabik; +aabil; +aabim; +aabin; +aabio; +aabip; +aabiq; +aabir; +aabis; +aabit; +aabiu; +aabiv; +aabiw; +aabix; +aabiy; +aabiz; +aabja; +aabjb; +aabjc; +aabjd; +aabje; +aabjf; +aabjg; +aabjh; +aabji; +aabjj; +aabjk; +aabjl; +aabjm; +aabjn; +aabjo; +aabjp; +aabjq; +aabjr; +aabjs; +aabjt; +aabju; +aabjv; +aabjw; +aabjx; +aabjy; +aabjz; +aabka; +aabkb; +aabkc; +aabkd; +aabke; +aabkf; +aabkg; +aabkh; +aabki; +aabkj; +aabkk; +aabkl; +aabkm; +aabkn; +aabko; +aabkp; +aabkq; +aabkr; +aabks; +aabkt; +aabku; +aabkv; +aabkw; +aabkx; +aabky; +aabkz; +aabla; +aablb; +aablc; +aabld; +aable; +aablf; +aablg; +aablh; +aabli; +aablj; +aablk; +aabll; +aablm; +aabln; +aablo; +aablp; +aablq; +aablr; +aabls; +aablt; +aablu; +aablv; +aablw; +aablx; +aably; +aablz; +aabma; +aabmb; +aabmc; +aabmd; +aabme; +aabmf; +aabmg; +aabmh; +aabmi; +aabmj; +aabmk; +aabml; +aabmm; +aabmn; +aabmo; +aabmp; +aabmq; +aabmr; +aabms; +aabmt; +aabmu; +aabmv; +aabmw; +aabmx; +aabmy; +aabmz; +aabna; +aabnb; +aabnc; +aabnd; +aabne; +aabnf; +aabng; +aabnh; +aabni; +aabnj; +aabnk; +aabnl; +aabnm; +aabnn; +aabno; +aabnp; +aabnq; +aabnr; +aabns; +aabnt; +aabnu; +aabnv; +aabnw; +aabnx; +aabny; +aabnz; +aaboa; +aabob; +aaboc; +aabod; +aaboe; +aabof; +aabog; +aaboh; +aaboi; +aaboj; +aabok; +aabol; +aabom; +aabon; +aaboo; +aabop; +aaboq; +aabor; +aabos; +aabot; +aabou; +aabov; +aabow; +aabox; +aaboy; +aaboz; +aabpa; +aabpb; +aabpc; +aabpd; +aabpe; +aabpf; +aabpg; +aabph; +aabpi; +aabpj; +aabpk; +aabpl; +aabpm; +aabpn; +aabpo; +aabpp; +aabpq; +aabpr; +aabps; +aabpt; +aabpu; +aabpv; +aabpw; +aabpx; +aabpy; +aabpz; +aabqa; +aabqb; +aabqc; +aabqd; +aabqe; +aabqf; +aabqg; +aabqh; +aabqi; +aabqj; +aabqk; +aabql; +aabqm; +aabqn; +aabqo; +aabqp; +aabqq; +aabqr; +aabqs; +aabqt; +aabqu; +aabqv; +aabqw; +aabqx; +aabqy; +aabqz; +aabra; +aabrb; +aabrc; +aabrd; +aabre; +aabrf; +aabrg; +aabrh; +aabri; +aabrj; +aabrk; +aabrl; +aabrm; +aabrn; +aabro; +aabrp; +aabrq; +aabrr; +aabrs; +aabrt; +aabru; +aabrv; +aabrw; +aabrx; +aabry; +aabrz; +aabsa; +aabsb; +aabsc; +aabsd; +aabse; +aabsf; +aabsg; +aabsh; +aabsi; +aabsj; +aabsk; +aabsl; +aabsm; +aabsn; +aabso; +aabsp; +aabsq; +aabsr; +aabss; +aabst; +aabsu; +aabsv; +aabsw; +aabsx; +aabsy; +aabsz; +aabta; +aabtb; +aabtc; +aabtd; +aabte; +aabtf; +aabtg; +aabth; +aabti; +aabtj; +aabtk; +aabtl; +aabtm; +aabtn; +aabto; +aabtp; +aabtq; +aabtr; +aabts; +aabtt; +aabtu; +aabtv; +aabtw; +aabtx; +aabty; +aabtz; +aabua; +aabub; +aabuc; +aabud; +aabue; +aabuf; +aabug; +aabuh; +aabui; +aabuj; +aabuk; +aabul; +aabum; +aabun; +aabuo; +aabup; +aabuq; +aabur; +aabus; +aabut; +aabuu; +aabuv; +aabuw; +aabux; +aabuy; +aabuz; +aabva; +aabvb; +aabvc; +aabvd; +aabve; +aabvf; +aabvg; +aabvh; +aabvi; +aabvj; +aabvk; +aabvl; +aabvm; +aabvn; +aabvo; +aabvp; +aabvq; +aabvr; +aabvs; +aabvt; +aabvu; +aabvv; +aabvw; +aabvx; +aabvy; +aabvz; +aabwa; +aabwb; +aabwc; +aabwd; +aabwe; +aabwf; +aabwg; +aabwh; +aabwi; +aabwj; +aabwk; +aabwl; +aabwm; +aabwn; +aabwo; +aabwp; +aabwq; +aabwr; +aabws; +aabwt; +aabwu; +aabwv; +aabww; +aabwx; +aabwy; +aabwz; +aabxa; +aabxb; +aabxc; +aabxd; +aabxe; +aabxf; +aabxg; +aabxh; +aabxi; +aabxj; +aabxk; +aabxl; +aabxm; +aabxn; +aabxo; +aabxp; +aabxq; +aabxr; +aabxs; +aabxt; +aabxu; +aabxv; +aabxw; +aabxx; +aabxy; +aabxz; +aabya; +aabyb; +aabyc; +aabyd; +aabye; +aabyf; +aabyg; +aabyh; +aabyi; +aabyj; +aabyk; +aabyl; +aabym; +aabyn; +aabyo; +aabyp; +aabyq; +aabyr; +aabys; +aabyt; +aabyu; +aabyv; +aabyw; +aabyx; +aabyy; +aabyz; +aabza; +aabzb; +aabzc; +aabzd; +aabze; +aabzf; +aabzg; +aabzh; +aabzi; +aabzj; +aabzk; +aabzl; +aabzm; +aabzn; +aabzo; +aabzp; +aabzq; +aabzr; +aabzs; +aabzt; +aabzu; +aabzv; +aabzw; +aabzx; +aabzy; +aabzz; +aacaa; +aacab; +aacac; +aacad; +aacae; +aacaf; +aacag; +aacah; +aacai; +aacaj; +aacak; +aacal; +aacam; +aacan; +aacao; +aacap; +aacaq; +aacar; +aacas; +aacat; +aacau; +aacav; +aacaw; +aacax; +aacay; +aacaz; +aacba; +aacbb; +aacbc; +aacbd; +aacbe; +aacbf; +aacbg; +aacbh; +aacbi; +aacbj; +aacbk; +aacbl; +aacbm; +aacbn; +aacbo; +aacbp; +aacbq; +aacbr; +aacbs; +aacbt; +aacbu; +aacbv; +aacbw; +aacbx; +aacby; +aacbz; +aacca; +aaccb; +aaccc; +aaccd; +aacce; +aaccf; +aaccg; +aacch; +aacci; +aaccj; +aacck; +aaccl; +aaccm; +aaccn; +aacco; +aaccp; +aaccq; +aaccr; +aaccs; +aacct; +aaccu; +aaccv; +aaccw; +aaccx; +aaccy; +aaccz; +aacda; +aacdb; +aacdc; +aacdd; +aacde; +aacdf; +aacdg; +aacdh; +aacdi; +aacdj; +aacdk; +aacdl; +aacdm; +aacdn; +aacdo; +aacdp; +aacdq; +aacdr; +aacds; +aacdt; +aacdu; +aacdv; +aacdw; +aacdx; +aacdy; +aacdz; +aacea; +aaceb; +aacec; +aaced; +aacee; +aacef; +aaceg; +aaceh; +aacei; +aacej; +aacek; +aacel; +aacem; +aacen; +aaceo; +aacep; +aaceq; +aacer; +aaces; +aacet; +aaceu; +aacev; +aacew; +aacex; +aacey; +aacez; +aacfa; +aacfb; +aacfc; +aacfd; +aacfe; +aacff; +aacfg; +aacfh; +aacfi; +aacfj; +aacfk; +aacfl; +aacfm; +aacfn; +aacfo; +aacfp; +aacfq; +aacfr; +aacfs; +aacft; +aacfu; +aacfv; +aacfw; +aacfx; +aacfy; +aacfz; +aacga; +aacgb; +aacgc; +aacgd; +aacge; +aacgf; +aacgg; +aacgh; +aacgi; +aacgj; +aacgk; +aacgl; +aacgm; +aacgn; +aacgo; +aacgp; +aacgq; +aacgr; +aacgs; +aacgt; +aacgu; +aacgv; +aacgw; +aacgx; +aacgy; +aacgz; +aacha; +aachb; +aachc; +aachd; +aache; +aachf; +aachg; +aachh; +aachi; +aachj; +aachk; +aachl; +aachm; +aachn; +aacho; +aachp; +aachq; +aachr; +aachs; +aacht; +aachu; +aachv; +aachw; +aachx; +aachy; +aachz; +aacia; +aacib; +aacic; +aacid; +aacie; +aacif; +aacig; +aacih; +aacii; +aacij; +aacik; +aacil; +aacim; +aacin; +aacio; +aacip; +aaciq; +aacir; +aacis; +aacit; +aaciu; +aaciv; +aaciw; +aacix; +aaciy; +aaciz; +aacja; +aacjb; +aacjc; +aacjd; +aacje; +aacjf; +aacjg; +aacjh; +aacji; +aacjj; +aacjk; +aacjl; +aacjm; +aacjn; +aacjo; +aacjp; +aacjq; +aacjr; +aacjs; +aacjt; +aacju; +aacjv; +aacjw; +aacjx; +aacjy; +aacjz; +aacka; +aackb; +aackc; +aackd; +aacke; +aackf; +aackg; +aackh; +aacki; +aackj; +aackk; +aackl; +aackm; +aackn; +aacko; +aackp; +aackq; +aackr; +aacks; +aackt; +aacku; +aackv; +aackw; +aackx; +aacky; +aackz; +aacla; +aaclb; +aaclc; +aacld; +aacle; +aaclf; +aaclg; +aaclh; +aacli; +aaclj; +aaclk; +aacll; +aaclm; +aacln; +aaclo; +aaclp; +aaclq; +aaclr; +aacls; +aaclt; +aaclu; +aaclv; +aaclw; +aaclx; +aacly; +aaclz; +aacma; +aacmb; +aacmc; +aacmd; +aacme; +aacmf; +aacmg; +aacmh; +aacmi; +aacmj; +aacmk; +aacml; +aacmm; +aacmn; +aacmo; +aacmp; +aacmq; +aacmr; +aacms; +aacmt; +aacmu; +aacmv; +aacmw; +aacmx; +aacmy; +aacmz; +aacna; +aacnb; +aacnc; +aacnd; +aacne; +aacnf; +aacng; +aacnh; +aacni; +aacnj; +aacnk; +aacnl; +aacnm; +aacnn; +aacno; +aacnp; +aacnq; +aacnr; +aacns; +aacnt; +aacnu; +aacnv; +aacnw; +aacnx; +aacny; +aacnz; +aacoa; +aacob; +aacoc; +aacod; +aacoe; +aacof; +aacog; +aacoh; +aacoi; +aacoj; +aacok; +aacol; +aacom; +aacon; +aacoo; +aacop; +aacoq; +aacor; +aacos; +aacot; +aacou; +aacov; +aacow; +aacox; +aacoy; +aacoz; +aacpa; +aacpb; +aacpc; +aacpd; +aacpe; +aacpf; +aacpg; +aacph; +aacpi; +aacpj; +aacpk; +aacpl; +aacpm; +aacpn; +aacpo; +aacpp; +aacpq; +aacpr; +aacps; +aacpt; +aacpu; +aacpv; +aacpw; +aacpx; +aacpy; +aacpz; +aacqa; +aacqb; +aacqc; +aacqd; +aacqe; +aacqf; +aacqg; +aacqh; +aacqi; +aacqj; +aacqk; +aacql; +aacqm; +aacqn; +aacqo; +aacqp; +aacqq; +aacqr; +aacqs; +aacqt; +aacqu; +aacqv; +aacqw; +aacqx; +aacqy; +aacqz; +aacra; +aacrb; +aacrc; +aacrd; +aacre; +aacrf; +aacrg; +aacrh; +aacri; +aacrj; +aacrk; +aacrl; +aacrm; +aacrn; +aacro; +aacrp; +aacrq; +aacrr; +aacrs; +aacrt; +aacru; +aacrv; +aacrw; +aacrx; +aacry; +aacrz; +aacsa; +aacsb; +aacsc; +aacsd; +aacse; +aacsf; +aacsg; +aacsh; +aacsi; +aacsj; +aacsk; +aacsl; +aacsm; +aacsn; +aacso; +aacsp; +aacsq; +aacsr; +aacss; +aacst; +aacsu; +aacsv; +aacsw; +aacsx; +aacsy; +aacsz; +aacta; +aactb; +aactc; +aactd; +aacte; +aactf; +aactg; +aacth; +aacti; +aactj; +aactk; +aactl; +aactm; +aactn; +aacto; +aactp; +aactq; +aactr; +aacts; +aactt; +aactu; +aactv; +aactw; +aactx; +aacty; +aactz; +aacua; +aacub; +aacuc; +aacud; +aacue; +aacuf; +aacug; +aacuh; +aacui; +aacuj; +aacuk; +aacul; +aacum; +aacun; +aacuo; +aacup; +aacuq; +aacur; +aacus; +aacut; +aacuu; +aacuv; +aacuw; +aacux; +aacuy; +aacuz; +aacva; +aacvb; +aacvc; +aacvd; +aacve; +aacvf; +aacvg; +aacvh; +aacvi; +aacvj; +aacvk; +aacvl; +aacvm; +aacvn; +aacvo; +aacvp; +aacvq; +aacvr; +aacvs; +aacvt; +aacvu; +aacvv; +aacvw; +aacvx; +aacvy; +aacvz; +aacwa; +aacwb; +aacwc; +aacwd; +aacwe; +aacwf; +aacwg; +aacwh; +aacwi; +aacwj; +aacwk; +aacwl; +aacwm; +aacwn; +aacwo; +aacwp; +aacwq; +aacwr; +aacws; +aacwt; +aacwu; +aacwv; +aacww; +aacwx; +aacwy; +aacwz; +aacxa; +aacxb; +aacxc; +aacxd; +aacxe; +aacxf; +aacxg; +aacxh; +aacxi; +aacxj; +aacxk; +aacxl; +aacxm; +aacxn; +aacxo; +aacxp; +aacxq; +aacxr; +aacxs; +aacxt; +aacxu; +aacxv; +aacxw; +aacxx; +aacxy; +aacxz; +aacya; +aacyb; +aacyc; +aacyd; +aacye; +aacyf; +aacyg; +aacyh; +aacyi; +aacyj; +aacyk; +aacyl; +aacym; +aacyn; +aacyo; +aacyp; +aacyq; +aacyr; +aacys; +aacyt; +aacyu; +aacyv; +aacyw; +aacyx; +aacyy; +aacyz; +aacza; +aaczb; +aaczc; +aaczd; +aacze; +aaczf; +aaczg; +aaczh; +aaczi; +aaczj; +aaczk; +aaczl; +aaczm; +aaczn; +aaczo; +aaczp; +aaczq; +aaczr; +aaczs; +aaczt; +aaczu; +aaczv; +aaczw; +aaczx; +aaczy; +aaczz; +aadaa; +aadab; +aadac; +aadad; +aadae; +aadaf; +aadag; +aadah; +aadai; +aadaj; +aadak; +aadal; +aadam; +aadan; +aadao; +aadap; +aadaq; +aadar; +aadas; +aadat; +aadau; +aadav; +aadaw; +aadax; +aaday; +aadaz; +aadba; +aadbb; +aadbc; +aadbd; +aadbe; +aadbf; +aadbg; +aadbh; +aadbi; +aadbj; +aadbk; +aadbl; +aadbm; +aadbn; +aadbo; +aadbp; +aadbq; +aadbr; +aadbs; +aadbt; +aadbu; +aadbv; +aadbw; +aadbx; +aadby; +aadbz; +aadca; +aadcb; +aadcc; +aadcd; +aadce; +aadcf; +aadcg; +aadch; +aadci; +aadcj; +aadck; +aadcl; +aadcm; +aadcn; +aadco; +aadcp; +aadcq; +aadcr; +aadcs; +aadct; +aadcu; +aadcv; +aadcw; +aadcx; +aadcy; +aadcz; +aadda; +aaddb; +aaddc; +aaddd; +aadde; +aaddf; +aaddg; +aaddh; +aaddi; +aaddj; +aaddk; +aaddl; +aaddm; +aaddn; +aaddo; +aaddp; +aaddq; +aaddr; +aadds; +aaddt; +aaddu; +aaddv; +aaddw; +aaddx; +aaddy; +aaddz; +aadea; +aadeb; +aadec; +aaded; +aadee; +aadef; +aadeg; +aadeh; +aadei; +aadej; +aadek; +aadel; +aadem; +aaden; +aadeo; +aadep; +aadeq; +aader; +aades; +aadet; +aadeu; +aadev; +aadew; +aadex; +aadey; +aadez; +aadfa; +aadfb; +aadfc; +aadfd; +aadfe; +aadff; +aadfg; +aadfh; +aadfi; +aadfj; +aadfk; +aadfl; +aadfm; +aadfn; +aadfo; +aadfp; +aadfq; +aadfr; +aadfs; +aadft; +aadfu; +aadfv; +aadfw; +aadfx; +aadfy; +aadfz; +aadga; +aadgb; +aadgc; +aadgd; +aadge; +aadgf; +aadgg; +aadgh; +aadgi; +aadgj; +aadgk; +aadgl; +aadgm; +aadgn; +aadgo; +aadgp; +aadgq; +aadgr; +aadgs; +aadgt; +aadgu; +aadgv; +aadgw; +aadgx; +aadgy; +aadgz; +aadha; +aadhb; +aadhc; +aadhd; +aadhe; +aadhf; +aadhg; +aadhh; +aadhi; +aadhj; +aadhk; +aadhl; +aadhm; +aadhn; +aadho; +aadhp; +aadhq; +aadhr; +aadhs; +aadht; +aadhu; +aadhv; +aadhw; +aadhx; +aadhy; +aadhz; +aadia; +aadib; +aadic; +aadid; +aadie; +aadif; +aadig; +aadih; +aadii; +aadij; +aadik; +aadil; +aadim; +aadin; +aadio; +aadip; +aadiq; +aadir; +aadis; +aadit; +aadiu; +aadiv; +aadiw; +aadix; +aadiy; +aadiz; +aadja; +aadjb; +aadjc; +aadjd; +aadje; +aadjf; +aadjg; +aadjh; +aadji; +aadjj; +aadjk; +aadjl; +aadjm; +aadjn; +aadjo; +aadjp; +aadjq; +aadjr; +aadjs; +aadjt; +aadju; +aadjv; +aadjw; +aadjx; +aadjy; +aadjz; +aadka; +aadkb; +aadkc; +aadkd; +aadke; +aadkf; +aadkg; +aadkh; +aadki; +aadkj; +aadkk; +aadkl; +aadkm; +aadkn; +aadko; +aadkp; +aadkq; +aadkr; +aadks; +aadkt; +aadku; +aadkv; +aadkw; +aadkx; +aadky; +aadkz; +aadla; +aadlb; +aadlc; +aadld; +aadle; +aadlf; +aadlg; +aadlh; +aadli; +aadlj; +aadlk; +aadll; +aadlm; +aadln; +aadlo; +aadlp; +aadlq; +aadlr; +aadls; +aadlt; +aadlu; +aadlv; +aadlw; +aadlx; +aadly; +aadlz; +aadma; +aadmb; +aadmc; +aadmd; +aadme; +aadmf; +aadmg; +aadmh; +aadmi; +aadmj; +aadmk; +aadml; +aadmm; +aadmn; +aadmo; +aadmp; +aadmq; +aadmr; +aadms; +aadmt; +aadmu; +aadmv; +aadmw; +aadmx; +aadmy; +aadmz; +aadna; +aadnb; +aadnc; +aadnd; +aadne; +aadnf; +aadng; +aadnh; +aadni; +aadnj; +aadnk; +aadnl; +aadnm; +aadnn; +aadno; +aadnp; +aadnq; +aadnr; +aadns; +aadnt; +aadnu; +aadnv; +aadnw; +aadnx; +aadny; +aadnz; +aadoa; +aadob; +aadoc; +aadod; +aadoe; +aadof; +aadog; +aadoh; +aadoi; +aadoj; +aadok; +aadol; +aadom; +aadon; +aadoo; +aadop; +aadoq; +aador; +aados; +aadot; +aadou; +aadov; +aadow; +aadox; +aadoy; +aadoz; +aadpa; +aadpb; +aadpc; +aadpd; +aadpe; +aadpf; +aadpg; +aadph; +aadpi; +aadpj; +aadpk; +aadpl; +aadpm; +aadpn; +aadpo; +aadpp; +aadpq; +aadpr; +aadps; +aadpt; +aadpu; +aadpv; +aadpw; +aadpx; +aadpy; +aadpz; +aadqa; +aadqb; +aadqc; +aadqd; +aadqe; +aadqf; +aadqg; +aadqh; +aadqi; +aadqj; +aadqk; +aadql; +aadqm; +aadqn; +aadqo; +aadqp; +aadqq; +aadqr; +aadqs; +aadqt; +aadqu; +aadqv; +aadqw; +aadqx; +aadqy; +aadqz; +aadra; +aadrb; +aadrc; +aadrd; +aadre; +aadrf; +aadrg; +aadrh; +aadri; +aadrj; +aadrk; +aadrl; +aadrm; +aadrn; +aadro; +aadrp; +aadrq; +aadrr; +aadrs; +aadrt; +aadru; +aadrv; +aadrw; +aadrx; +aadry; +aadrz; +aadsa; +aadsb; +aadsc; +aadsd; +aadse; +aadsf; +aadsg; +aadsh; +aadsi; +aadsj; +aadsk; +aadsl; +aadsm; +aadsn; +aadso; +aadsp; +aadsq; +aadsr; +aadss; +aadst; +aadsu; +aadsv; +aadsw; +aadsx; +aadsy; +aadsz; +aadta; +aadtb; +aadtc; +aadtd; +aadte; +aadtf; +aadtg; +aadth; +aadti; +aadtj; +aadtk; +aadtl; +aadtm; +aadtn; +aadto; +aadtp; +aadtq; +aadtr; +aadts; +aadtt; +aadtu; +aadtv; +aadtw; +aadtx; +aadty; +aadtz; +aadua; +aadub; +aaduc; +aadud; +aadue; +aaduf; +aadug; +aaduh; +aadui; +aaduj; +aaduk; +aadul; +aadum; +aadun; +aaduo; +aadup; +aaduq; +aadur; +aadus; +aadut; +aaduu; +aaduv; +aaduw; +aadux; +aaduy; +aaduz; +aadva; +aadvb; +aadvc; +aadvd; +aadve; +aadvf; +aadvg; +aadvh; +aadvi; +aadvj; +aadvk; +aadvl; +aadvm; +aadvn; +aadvo; +aadvp; +aadvq; +aadvr; +aadvs; +aadvt; +aadvu; +aadvv; +aadvw; +aadvx; +aadvy; +aadvz; +aadwa; +aadwb; +aadwc; +aadwd; +aadwe; +aadwf; +aadwg; +aadwh; +aadwi; +aadwj; +aadwk; +aadwl; +aadwm; +aadwn; +aadwo; +aadwp; +aadwq; +aadwr; +aadws; +aadwt; +aadwu; +aadwv; +aadww; +aadwx; +aadwy; +aadwz; +aadxa; +aadxb; +aadxc; +aadxd; +aadxe; +aadxf; +aadxg; +aadxh; +aadxi; +aadxj; +aadxk; +aadxl; +aadxm; +aadxn; +aadxo; +aadxp; +aadxq; +aadxr; +aadxs; +aadxt; +aadxu; +aadxv; +aadxw; +aadxx; +aadxy; +aadxz; +aadya; +aadyb; +aadyc; +aadyd; +aadye; +aadyf; +aadyg; +aadyh; +aadyi; +aadyj; +aadyk; +aadyl; +aadym; +aadyn; +aadyo; +aadyp; +aadyq; +aadyr; +aadys; +aadyt; +aadyu; +aadyv; +aadyw; +aadyx; +aadyy; +aadyz; +aadza; +aadzb; +aadzc; +aadzd; +aadze; +aadzf; +aadzg; +aadzh; +aadzi; +aadzj; +aadzk; +aadzl; +aadzm; +aadzn; +aadzo; +aadzp; +aadzq; +aadzr; +aadzs; +aadzt; +aadzu; +aadzv; +aadzw; +aadzx; +aadzy; +aadzz; +aaeaa; +aaeab; +aaeac; +aaead; +aaeae; +aaeaf; +aaeag; +aaeah; +aaeai; +aaeaj; +aaeak; +aaeal; +aaeam; +aaean; +aaeao; +aaeap; +aaeaq; +aaear; +aaeas; +aaeat; +aaeau; +aaeav; +aaeaw; +aaeax; +aaeay; +aaeaz; +aaeba; +aaebb; +aaebc; +aaebd; +aaebe; +aaebf; +aaebg; +aaebh; +aaebi; +aaebj; +aaebk; +aaebl; +aaebm; +aaebn; +aaebo; +aaebp; +aaebq; +aaebr; +aaebs; +aaebt; +aaebu; +aaebv; +aaebw; +aaebx; +aaeby; +aaebz; +aaeca; +aaecb; +aaecc; +aaecd; +aaece; +aaecf; +aaecg; +aaech; +aaeci; +aaecj; +aaeck; +aaecl; +aaecm; +aaecn; +aaeco; +aaecp; +aaecq; +aaecr; +aaecs; +aaect; +aaecu; +aaecv; +aaecw; +aaecx; +aaecy; +aaecz; +aaeda; +aaedb; +aaedc; +aaedd; +aaede; +aaedf; +aaedg; +aaedh; +aaedi; +aaedj; +aaedk; +aaedl; +aaedm; +aaedn; +aaedo; +aaedp; +aaedq; +aaedr; +aaeds; +aaedt; +aaedu; +aaedv; +aaedw; +aaedx; +aaedy; +aaedz; +aaeea; +aaeeb; +aaeec; +aaeed; +aaeee; +aaeef; +aaeeg; +aaeeh; +aaeei; +aaeej; +aaeek; +aaeel; +aaeem; +aaeen; +aaeeo; +aaeep; +aaeeq; +aaeer; +aaees; +aaeet; +aaeeu; +aaeev; +aaeew; +aaeex; +aaeey; +aaeez; +aaefa; +aaefb; +aaefc; +aaefd; +aaefe; +aaeff; +aaefg; +aaefh; +aaefi; +aaefj; +aaefk; +aaefl; +aaefm; +aaefn; +aaefo; +aaefp; +aaefq; +aaefr; +aaefs; +aaeft; +aaefu; +aaefv; +aaefw; +aaefx; +aaefy; +aaefz; +aaega; +aaegb; +aaegc; +aaegd; +aaege; +aaegf; +aaegg; +aaegh; +aaegi; +aaegj; +aaegk; +aaegl; +aaegm; +aaegn; +aaego; +aaegp; +aaegq; +aaegr; +aaegs; +aaegt; +aaegu; +aaegv; +aaegw; +aaegx; +aaegy; +aaegz; +aaeha; +aaehb; +aaehc; +aaehd; +aaehe; +aaehf; +aaehg; +aaehh; +aaehi; +aaehj; +aaehk; +aaehl; +aaehm; +aaehn; +aaeho; +aaehp; +aaehq; +aaehr; +aaehs; +aaeht; +aaehu; +aaehv; +aaehw; +aaehx; +aaehy; +aaehz; +aaeia; +aaeib; +aaeic; +aaeid; +aaeie; +aaeif; +aaeig; +aaeih; +aaeii; +aaeij; +aaeik; +aaeil; +aaeim; +aaein; +aaeio; +aaeip; +aaeiq; +aaeir; +aaeis; +aaeit; +aaeiu; +aaeiv; +aaeiw; +aaeix; +aaeiy; +aaeiz; +aaeja; +aaejb; +aaejc; +aaejd; +aaeje; +aaejf; +aaejg; +aaejh; +aaeji; +aaejj; +aaejk; +aaejl; +aaejm; +aaejn; +aaejo; +aaejp; +aaejq; +aaejr; +aaejs; +aaejt; +aaeju; +aaejv; +aaejw; +aaejx; +aaejy; +aaejz; +aaeka; +aaekb; +aaekc; +aaekd; +aaeke; +aaekf; +aaekg; +aaekh; +aaeki; +aaekj; +aaekk; +aaekl; +aaekm; +aaekn; +aaeko; +aaekp; +aaekq; +aaekr; +aaeks; +aaekt; +aaeku; +aaekv; +aaekw; +aaekx; +aaeky; +aaekz; +aaela; +aaelb; +aaelc; +aaeld; +aaele; +aaelf; +aaelg; +aaelh; +aaeli; +aaelj; +aaelk; +aaell; +aaelm; +aaeln; +aaelo; +aaelp; +aaelq; +aaelr; +aaels; +aaelt; +aaelu; +aaelv; +aaelw; +aaelx; +aaely; +aaelz; +aaema; +aaemb; +aaemc; +aaemd; +aaeme; +aaemf; +aaemg; +aaemh; +aaemi; +aaemj; +aaemk; +aaeml; +aaemm; +aaemn; +aaemo; +aaemp; +aaemq; +aaemr; +aaems; +aaemt; +aaemu; +aaemv; +aaemw; +aaemx; +aaemy; +aaemz; +aaena; +aaenb; +aaenc; +aaend; +aaene; +aaenf; +aaeng; +aaenh; +aaeni; +aaenj; +aaenk; +aaenl; +aaenm; +aaenn; +aaeno; +aaenp; +aaenq; +aaenr; +aaens; +aaent; +aaenu; +aaenv; +aaenw; +aaenx; +aaeny; +aaenz; +aaeoa; +aaeob; +aaeoc; +aaeod; +aaeoe; +aaeof; +aaeog; +aaeoh; +aaeoi; +aaeoj; +aaeok; +aaeol; +aaeom; +aaeon; +aaeoo; +aaeop; +aaeoq; +aaeor; +aaeos; +aaeot; +aaeou; +aaeov; +aaeow; +aaeox; +aaeoy; +aaeoz; +aaepa; +aaepb; +aaepc; +aaepd; +aaepe; +aaepf; +aaepg; +aaeph; +aaepi; +aaepj; +aaepk; +aaepl; +aaepm; +aaepn; +aaepo; +aaepp; +aaepq; +aaepr; +aaeps; +aaept; +aaepu; +aaepv; +aaepw; +aaepx; +aaepy; +aaepz; +aaeqa; +aaeqb; +aaeqc; +aaeqd; +aaeqe; +aaeqf; +aaeqg; +aaeqh; +aaeqi; +aaeqj; +aaeqk; +aaeql; +aaeqm; +aaeqn; +aaeqo; +aaeqp; +aaeqq; +aaeqr; +aaeqs; +aaeqt; +aaequ; +aaeqv; +aaeqw; +aaeqx; +aaeqy; +aaeqz; +aaera; +aaerb; +aaerc; +aaerd; +aaere; +aaerf; +aaerg; +aaerh; +aaeri; +aaerj; +aaerk; +aaerl; +aaerm; +aaern; +aaero; +aaerp; +aaerq; +aaerr; +aaers; +aaert; +aaeru; +aaerv; +aaerw; +aaerx; +aaery; +aaerz; +aaesa; +aaesb; +aaesc; +aaesd; +aaese; +aaesf; +aaesg; +aaesh; +aaesi; +aaesj; +aaesk; +aaesl; +aaesm; +aaesn; +aaeso; +aaesp; +aaesq; +aaesr; +aaess; +aaest; +aaesu; +aaesv; +aaesw; +aaesx; +aaesy; +aaesz; +aaeta; +aaetb; +aaetc; +aaetd; +aaete; +aaetf; +aaetg; +aaeth; +aaeti; +aaetj; +aaetk; +aaetl; +aaetm; +aaetn; +aaeto; +aaetp; +aaetq; +aaetr; +aaets; +aaett; +aaetu; +aaetv; +aaetw; +aaetx; +aaety; +aaetz; +aaeua; +aaeub; +aaeuc; +aaeud; +aaeue; +aaeuf; +aaeug; +aaeuh; +aaeui; +aaeuj; +aaeuk; +aaeul; +aaeum; +aaeun; +aaeuo; +aaeup; +aaeuq; +aaeur; +aaeus; +aaeut; +aaeuu; +aaeuv; +aaeuw; +aaeux; +aaeuy; +aaeuz; +aaeva; +aaevb; +aaevc; +aaevd; +aaeve; +aaevf; +aaevg; +aaevh; +aaevi; +aaevj; +aaevk; +aaevl; +aaevm; +aaevn; +aaevo; +aaevp; +aaevq; +aaevr; +aaevs; +aaevt; +aaevu; +aaevv; +aaevw; +aaevx; +aaevy; +aaevz; +aaewa; +aaewb; +aaewc; +aaewd; +aaewe; +aaewf; +aaewg; +aaewh; +aaewi; +aaewj; +aaewk; +aaewl; +aaewm; +aaewn; +aaewo; +aaewp; +aaewq; +aaewr; +aaews; +aaewt; +aaewu; +aaewv; +aaeww; +aaewx; +aaewy; +aaewz; +aaexa; +aaexb; +aaexc; +aaexd; +aaexe; +aaexf; +aaexg; +aaexh; +aaexi; +aaexj; +aaexk; +aaexl; +aaexm; +aaexn; +aaexo; +aaexp; +aaexq; +aaexr; +aaexs; +aaext; +aaexu; +aaexv; +aaexw; +aaexx; +aaexy; +aaexz; +aaeya; +aaeyb; +aaeyc; +aaeyd; +aaeye; +aaeyf; +aaeyg; +aaeyh; +aaeyi; +aaeyj; +aaeyk; +aaeyl; +aaeym; +aaeyn; +aaeyo; +aaeyp; +aaeyq; +aaeyr; +aaeys; +aaeyt; +aaeyu; +aaeyv; +aaeyw; +aaeyx; +aaeyy; +aaeyz; +aaeza; +aaezb; +aaezc; +aaezd; +aaeze; +aaezf; +aaezg; +aaezh; +aaezi; +aaezj; +aaezk; +aaezl; +aaezm; +aaezn; +aaezo; +aaezp; +aaezq; +aaezr; +aaezs; +aaezt; +aaezu; +aaezv; +aaezw; +aaezx; +aaezy; +aaezz; +aafaa; +aafab; +aafac; +aafad; +aafae; +aafaf; +aafag; +aafah; +aafai; +aafaj; +aafak; +aafal; +aafam; +aafan; +aafao; +aafap; +aafaq; +aafar; +aafas; +aafat; +aafau; +aafav; +aafaw; +aafax; +aafay; +aafaz; +aafba; +aafbb; +aafbc; +aafbd; +aafbe; +aafbf; +aafbg; +aafbh; +aafbi; +aafbj; +aafbk; +aafbl; +aafbm; +aafbn; +aafbo; +aafbp; +aafbq; +aafbr; +aafbs; +aafbt; +aafbu; +aafbv; +aafbw; +aafbx; +aafby; +aafbz; +aafca; +aafcb; +aafcc; +aafcd; +aafce; +aafcf; +aafcg; +aafch; +aafci; +aafcj; +aafck; +aafcl; +aafcm; +aafcn; +aafco; +aafcp; +aafcq; +aafcr; +aafcs; +aafct; +aafcu; +aafcv; +aafcw; +aafcx; +aafcy; +aafcz; +aafda; +aafdb; +aafdc; +aafdd; +aafde; +aafdf; +aafdg; +aafdh; +aafdi; +aafdj; +aafdk; +aafdl; +aafdm; +aafdn; +aafdo; +aafdp; +aafdq; +aafdr; +aafds; +aafdt; +aafdu; +aafdv; +aafdw; +aafdx; +aafdy; +aafdz; +aafea; +aafeb; +aafec; +aafed; +aafee; +aafef; +aafeg; +aafeh; +aafei; +aafej; +aafek; +aafel; +aafem; +aafen; +aafeo; +aafep; +aafeq; +aafer; +aafes; +aafet; +aafeu; +aafev; +aafew; +aafex; +aafey; +aafez; +aaffa; +aaffb; +aaffc; +aaffd; +aaffe; +aafff; +aaffg; +aaffh; +aaffi; +aaffj; +aaffk; +aaffl; +aaffm; +aaffn; +aaffo; +aaffp; +aaffq; +aaffr; +aaffs; +aafft; +aaffu; +aaffv; +aaffw; +aaffx; +aaffy; +aaffz; +aafga; +aafgb; +aafgc; +aafgd; +aafge; +aafgf; +aafgg; +aafgh; +aafgi; +aafgj; +aafgk; +aafgl; +aafgm; +aafgn; +aafgo; +aafgp; +aafgq; +aafgr; +aafgs; +aafgt; +aafgu; +aafgv; +aafgw; +aafgx; +aafgy; +aafgz; +aafha; +aafhb; +aafhc; +aafhd; +aafhe; +aafhf; +aafhg; +aafhh; +aafhi; +aafhj; +aafhk; +aafhl; +aafhm; +aafhn; +aafho; +aafhp; +aafhq; +aafhr; +aafhs; +aafht; +aafhu; +aafhv; +aafhw; +aafhx; +aafhy; +aafhz; +aafia; +aafib; +aafic; +aafid; +aafie; +aafif; +aafig; +aafih; +aafii; +aafij; +aafik; +aafil; +aafim; +aafin; +aafio; +aafip; +aafiq; +aafir; +aafis; +aafit; +aafiu; +aafiv; +aafiw; +aafix; +aafiy; +aafiz; +aafja; +aafjb; +aafjc; +aafjd; +aafje; +aafjf; +aafjg; +aafjh; +aafji; +aafjj; +aafjk; +aafjl; +aafjm; +aafjn; +aafjo; +aafjp; +aafjq; +aafjr; +aafjs; +aafjt; +aafju; +aafjv; +aafjw; +aafjx; +aafjy; +aafjz; +aafka; +aafkb; +aafkc; +aafkd; +aafke; +aafkf; +aafkg; +aafkh; +aafki; +aafkj; +aafkk; +aafkl; +aafkm; +aafkn; +aafko; +aafkp; +aafkq; +aafkr; +aafks; +aafkt; +aafku; +aafkv; +aafkw; +aafkx; +aafky; +aafkz; +aafla; +aaflb; +aaflc; +aafld; +aafle; +aaflf; +aaflg; +aaflh; +aafli; +aaflj; +aaflk; +aafll; +aaflm; +aafln; +aaflo; +aaflp; +aaflq; +aaflr; +aafls; +aaflt; +aaflu; +aaflv; +aaflw; +aaflx; +aafly; +aaflz; +aafma; +aafmb; +aafmc; +aafmd; +aafme; +aafmf; +aafmg; +aafmh; +aafmi; +aafmj; +aafmk; +aafml; +aafmm; +aafmn; +aafmo; +aafmp; +aafmq; +aafmr; +aafms; +aafmt; +aafmu; +aafmv; +aafmw; +aafmx; +aafmy; +aafmz; +aafna; +aafnb; +aafnc; +aafnd; +aafne; +aafnf; +aafng; +aafnh; +aafni; +aafnj; +aafnk; +aafnl; +aafnm; +aafnn; +aafno; +aafnp; +aafnq; +aafnr; +aafns; +aafnt; +aafnu; +aafnv; +aafnw; +aafnx; +aafny; +aafnz; +aafoa; +aafob; +aafoc; +aafod; +aafoe; +aafof; +aafog; +aafoh; +aafoi; +aafoj; +aafok; +aafol; +aafom; +aafon; +aafoo; +aafop; +aafoq; +aafor; +aafos; +aafot; +aafou; +aafov; +aafow; +aafox; +aafoy; +aafoz; +aafpa; +aafpb; +aafpc; +aafpd; +aafpe; +aafpf; +aafpg; +aafph; +aafpi; +aafpj; +aafpk; +aafpl; +aafpm; +aafpn; +aafpo; +aafpp; +aafpq; +aafpr; +aafps; +aafpt; +aafpu; +aafpv; +aafpw; +aafpx; +aafpy; +aafpz; +aafqa; +aafqb; +aafqc; +aafqd; +aafqe; +aafqf; +aafqg; +aafqh; +aafqi; +aafqj; +aafqk; +aafql; +aafqm; +aafqn; +aafqo; +aafqp; +aafqq; +aafqr; +aafqs; +aafqt; +aafqu; +aafqv; +aafqw; +aafqx; +aafqy; +aafqz; +aafra; +aafrb; +aafrc; +aafrd; +aafre; +aafrf; +aafrg; +aafrh; +aafri; +aafrj; +aafrk; +aafrl; +aafrm; +aafrn; +aafro; +aafrp; +aafrq; +aafrr; +aafrs; +aafrt; +aafru; +aafrv; +aafrw; +aafrx; +aafry; +aafrz; +aafsa; +aafsb; +aafsc; +aafsd; +aafse; +aafsf; +aafsg; +aafsh; +aafsi; +aafsj; +aafsk; +aafsl; +aafsm; +aafsn; +aafso; +aafsp; +aafsq; +aafsr; +aafss; +aafst; +aafsu; +aafsv; +aafsw; +aafsx; +aafsy; +aafsz; +aafta; +aaftb; +aaftc; +aaftd; +aafte; +aaftf; +aaftg; +aafth; +aafti; +aaftj; +aaftk; +aaftl; +aaftm; +aaftn; +aafto; +aaftp; +aaftq; +aaftr; +aafts; +aaftt; +aaftu; +aaftv; +aaftw; +aaftx; +aafty; +aaftz; +aafua; +aafub; +aafuc; +aafud; +aafue; +aafuf; +aafug; +aafuh; +aafui; +aafuj; +aafuk; +aaful; +aafum; +aafun; +aafuo; +aafup; +aafuq; +aafur; +aafus; +aafut; +aafuu; +aafuv; +aafuw; +aafux; +aafuy; +aafuz; +aafva; +aafvb; +aafvc; +aafvd; +aafve; +aafvf; +aafvg; +aafvh; +aafvi; +aafvj; +aafvk; +aafvl; +aafvm; +aafvn; +aafvo; +aafvp; +aafvq; +aafvr; +aafvs; +aafvt; +aafvu; +aafvv; +aafvw; +aafvx; +aafvy; +aafvz; +aafwa; +aafwb; +aafwc; +aafwd; +aafwe; +aafwf; +aafwg; +aafwh; +aafwi; +aafwj; +aafwk; +aafwl; +aafwm; +aafwn; +aafwo; +aafwp; +aafwq; +aafwr; +aafws; +aafwt; +aafwu; +aafwv; +aafww; +aafwx; +aafwy; +aafwz; +aafxa; +aafxb; +aafxc; +aafxd; +aafxe; +aafxf; +aafxg; +aafxh; +aafxi; +aafxj; +aafxk; +aafxl; +aafxm; +aafxn; +aafxo; +aafxp; +aafxq; +aafxr; +aafxs; +aafxt; +aafxu; +aafxv; +aafxw; +aafxx; +aafxy; +aafxz; +aafya; +aafyb; +aafyc; +aafyd; +aafye; +aafyf; +aafyg; +aafyh; +aafyi; +aafyj; +aafyk; +aafyl; +aafym; +aafyn; +aafyo; +aafyp; +aafyq; +aafyr; +aafys; +aafyt; +aafyu; +aafyv; +aafyw; +aafyx; +aafyy; +aafyz; +aafza; +aafzb; +aafzc; +aafzd; +aafze; +aafzf; +aafzg; +aafzh; +aafzi; +aafzj; +aafzk; +aafzl; +aafzm; +aafzn; +aafzo; +aafzp; +aafzq; +aafzr; +aafzs; +aafzt; +aafzu; +aafzv; +aafzw; +aafzx; +aafzy; +aafzz; +aagaa; +aagab; +aagac; +aagad; +aagae; +aagaf; +aagag; +aagah; +aagai; +aagaj; +aagak; +aagal; +aagam; +aagan; +aagao; +aagap; +aagaq; +aagar; +aagas; +aagat; +aagau; +aagav; +aagaw; +aagax; +aagay; +aagaz; +aagba; +aagbb; +aagbc; +aagbd; +aagbe; +aagbf; +aagbg; +aagbh; +aagbi; +aagbj; +aagbk; +aagbl; +aagbm; +aagbn; +aagbo; +aagbp; +aagbq; +aagbr; +aagbs; +aagbt; +aagbu; +aagbv; +aagbw; +aagbx; +aagby; +aagbz; +aagca; +aagcb; +aagcc; +aagcd; +aagce; +aagcf; +aagcg; +aagch; +aagci; +aagcj; +aagck; +aagcl; +aagcm; +aagcn; +aagco; +aagcp; +aagcq; +aagcr; +aagcs; +aagct; +aagcu; +aagcv; +aagcw; +aagcx; +aagcy; +aagcz; +aagda; +aagdb; +aagdc; +aagdd; +aagde; +aagdf; +aagdg; +aagdh; +aagdi; +aagdj; +aagdk; +aagdl; +aagdm; +aagdn; +aagdo; +aagdp; +aagdq; +aagdr; +aagds; +aagdt; +aagdu; +aagdv; +aagdw; +aagdx; +aagdy; +aagdz; +aagea; +aageb; +aagec; +aaged; +aagee; +aagef; +aageg; +aageh; +aagei; +aagej; +aagek; +aagel; +aagem; +aagen; +aageo; +aagep; +aageq; +aager; +aages; +aaget; +aageu; +aagev; +aagew; +aagex; +aagey; +aagez; +aagfa; +aagfb; +aagfc; +aagfd; +aagfe; +aagff; +aagfg; +aagfh; +aagfi; +aagfj; +aagfk; +aagfl; +aagfm; +aagfn; +aagfo; +aagfp; +aagfq; +aagfr; +aagfs; +aagft; +aagfu; +aagfv; +aagfw; +aagfx; +aagfy; +aagfz; +aagga; +aaggb; +aaggc; +aaggd; +aagge; +aaggf; +aaggg; +aaggh; +aaggi; +aaggj; +aaggk; +aaggl; +aaggm; +aaggn; +aaggo; +aaggp; +aaggq; +aaggr; +aaggs; +aaggt; +aaggu; +aaggv; +aaggw; +aaggx; +aaggy; +aaggz; +aagha; +aaghb; +aaghc; +aaghd; +aaghe; +aaghf; +aaghg; +aaghh; +aaghi; +aaghj; +aaghk; +aaghl; +aaghm; +aaghn; +aagho; +aaghp; +aaghq; +aaghr; +aaghs; +aaght; +aaghu; +aaghv; +aaghw; +aaghx; +aaghy; +aaghz; +aagia; +aagib; +aagic; +aagid; +aagie; +aagif; +aagig; +aagih; +aagii; +aagij; +aagik; +aagil; +aagim; +aagin; +aagio; +aagip; +aagiq; +aagir; +aagis; +aagit; +aagiu; +aagiv; +aagiw; +aagix; +aagiy; +aagiz; +aagja; +aagjb; +aagjc; +aagjd; +aagje; +aagjf; +aagjg; +aagjh; +aagji; +aagjj; +aagjk; +aagjl; +aagjm; +aagjn; +aagjo; +aagjp; +aagjq; +aagjr; +aagjs; +aagjt; +aagju; +aagjv; +aagjw; +aagjx; +aagjy; +aagjz; +aagka; +aagkb; +aagkc; +aagkd; +aagke; +aagkf; +aagkg; +aagkh; +aagki; +aagkj; +aagkk; +aagkl; +aagkm; +aagkn; +aagko; +aagkp; +aagkq; +aagkr; +aagks; +aagkt; +aagku; +aagkv; +aagkw; +aagkx; +aagky; +aagkz; +aagla; +aaglb; +aaglc; +aagld; +aagle; +aaglf; +aaglg; +aaglh; +aagli; +aaglj; +aaglk; +aagll; +aaglm; +aagln; +aaglo; +aaglp; +aaglq; +aaglr; +aagls; +aaglt; +aaglu; +aaglv; +aaglw; +aaglx; +aagly; +aaglz; +aagma; +aagmb; +aagmc; +aagmd; +aagme; +aagmf; +aagmg; +aagmh; +aagmi; +aagmj; +aagmk; +aagml; +aagmm; +aagmn; +aagmo; +aagmp; +aagmq; +aagmr; +aagms; +aagmt; +aagmu; +aagmv; +aagmw; +aagmx; +aagmy; +aagmz; +aagna; +aagnb; +aagnc; +aagnd; +aagne; +aagnf; +aagng; +aagnh; +aagni; +aagnj; +aagnk; +aagnl; +aagnm; +aagnn; +aagno; +aagnp; +aagnq; +aagnr; +aagns; +aagnt; +aagnu; +aagnv; +aagnw; +aagnx; +aagny; +aagnz; +aagoa; +aagob; +aagoc; +aagod; +aagoe; +aagof; +aagog; +aagoh; +aagoi; +aagoj; +aagok; +aagol; +aagom; +aagon; +aagoo; +aagop; +aagoq; +aagor; +aagos; +aagot; +aagou; +aagov; +aagow; +aagox; +aagoy; +aagoz; +aagpa; +aagpb; +aagpc; +aagpd; +aagpe; +aagpf; +aagpg; +aagph; +aagpi; +aagpj; +aagpk; +aagpl; +aagpm; +aagpn; +aagpo; +aagpp; +aagpq; +aagpr; +aagps; +aagpt; +aagpu; +aagpv; +aagpw; +aagpx; +aagpy; +aagpz; +aagqa; +aagqb; +aagqc; +aagqd; +aagqe; +aagqf; +aagqg; +aagqh; +aagqi; +aagqj; +aagqk; +aagql; +aagqm; +aagqn; +aagqo; +aagqp; +aagqq; +aagqr; +aagqs; +aagqt; +aagqu; +aagqv; +aagqw; +aagqx; +aagqy; +aagqz; +aagra; +aagrb; +aagrc; +aagrd; +aagre; +aagrf; +aagrg; +aagrh; +aagri; +aagrj; +aagrk; +aagrl; +aagrm; +aagrn; +aagro; +aagrp; +aagrq; +aagrr; +aagrs; +aagrt; +aagru; +aagrv; +aagrw; +aagrx; +aagry; +aagrz; +aagsa; +aagsb; +aagsc; +aagsd; +aagse; +aagsf; +aagsg; +aagsh; +aagsi; +aagsj; +aagsk; +aagsl; +aagsm; +aagsn; +aagso; +aagsp; +aagsq; +aagsr; +aagss; +aagst; +aagsu; +aagsv; +aagsw; +aagsx; +aagsy; +aagsz; +aagta; +aagtb; +aagtc; +aagtd; +aagte; +aagtf; +aagtg; +aagth; +aagti; +aagtj; +aagtk; +aagtl; +aagtm; +aagtn; +aagto; +aagtp; +aagtq; +aagtr; +aagts; +aagtt; +aagtu; +aagtv; +aagtw; +aagtx; +aagty; +aagtz; +aagua; +aagub; +aaguc; +aagud; +aague; +aaguf; +aagug; +aaguh; +aagui; +aaguj; +aaguk; +aagul; +aagum; +aagun; +aaguo; +aagup; +aaguq; +aagur; +aagus; +aagut; +aaguu; +aaguv; +aaguw; +aagux; +aaguy; +aaguz; +aagva; +aagvb; +aagvc; +aagvd; +aagve; +aagvf; +aagvg; +aagvh; +aagvi; +aagvj; +aagvk; +aagvl; +aagvm; +aagvn; +aagvo; +aagvp; +aagvq; +aagvr; +aagvs; +aagvt; +aagvu; +aagvv; +aagvw; +aagvx; +aagvy; +aagvz; +aagwa; +aagwb; +aagwc; +aagwd; +aagwe; +aagwf; +aagwg; +aagwh; +aagwi; +aagwj; +aagwk; +aagwl; +aagwm; +aagwn; +aagwo; +aagwp; +aagwq; +aagwr; +aagws; +aagwt; +aagwu; +aagwv; +aagww; +aagwx; +aagwy; +aagwz; +aagxa; +aagxb; +aagxc; +aagxd; +aagxe; +aagxf; +aagxg; +aagxh; +aagxi; +aagxj; +aagxk; +aagxl; +aagxm; +aagxn; +aagxo; +aagxp; +aagxq; +aagxr; +aagxs; +aagxt; +aagxu; +aagxv; +aagxw; +aagxx; +aagxy; +aagxz; +aagya; +aagyb; +aagyc; +aagyd; +aagye; +aagyf; +aagyg; +aagyh; +aagyi; +aagyj; +aagyk; +aagyl; +aagym; +aagyn; +aagyo; +aagyp; +aagyq; +aagyr; +aagys; +aagyt; +aagyu; +aagyv; +aagyw; +aagyx; +aagyy; +aagyz; +aagza; +aagzb; +aagzc; +aagzd; +aagze; +aagzf; +aagzg; +aagzh; +aagzi; +aagzj; +aagzk; +aagzl; +aagzm; +aagzn; +aagzo; +aagzp; +aagzq; +aagzr; +aagzs; +aagzt; +aagzu; +aagzv; +aagzw; +aagzx; +aagzy; +aagzz; +aahaa; +aahab; +aahac; +aahad; +aahae; +aahaf; +aahag; +aahah; +aahai; +aahaj; +aahak; +aahal; +aaham; +aahan; +aahao; +aahap; +aahaq; +aahar; +aahas; +aahat; +aahau; +aahav; +aahaw; +aahax; +aahay; +aahaz; +aahba; +aahbb; +aahbc; +aahbd; +aahbe; +aahbf; +aahbg; +aahbh; +aahbi; +aahbj; +aahbk; +aahbl; +aahbm; +aahbn; +aahbo; +aahbp; +aahbq; +aahbr; +aahbs; +aahbt; +aahbu; +aahbv; +aahbw; +aahbx; +aahby; +aahbz; +aahca; +aahcb; +aahcc; +aahcd; +aahce; +aahcf; +aahcg; +aahch; +aahci; +aahcj; +aahck; +aahcl; +aahcm; +aahcn; +aahco; +aahcp; +aahcq; +aahcr; +aahcs; +aahct; +aahcu; +aahcv; +aahcw; +aahcx; +aahcy; +aahcz; +aahda; +aahdb; +aahdc; +aahdd; +aahde; +aahdf; +aahdg; +aahdh; +aahdi; +aahdj; +aahdk; +aahdl; +aahdm; +aahdn; +aahdo; +aahdp; +aahdq; +aahdr; +aahds; +aahdt; +aahdu; +aahdv; +aahdw; +aahdx; +aahdy; +aahdz; +aahea; +aaheb; +aahec; +aahed; +aahee; +aahef; +aaheg; +aaheh; +aahei; +aahej; +aahek; +aahel; +aahem; +aahen; +aaheo; +aahep; +aaheq; +aaher; +aahes; +aahet; +aaheu; +aahev; +aahew; +aahex; +aahey; +aahez; +aahfa; +aahfb; +aahfc; +aahfd; +aahfe; +aahff; +aahfg; +aahfh; +aahfi; +aahfj; +aahfk; +aahfl; +aahfm; +aahfn; +aahfo; +aahfp; +aahfq; +aahfr; +aahfs; +aahft; +aahfu; +aahfv; +aahfw; +aahfx; +aahfy; +aahfz; +aahga; +aahgb; +aahgc; +aahgd; +aahge; +aahgf; +aahgg; +aahgh; +aahgi; +aahgj; +aahgk; +aahgl; +aahgm; +aahgn; +aahgo; +aahgp; +aahgq; +aahgr; +aahgs; +aahgt; +aahgu; +aahgv; +aahgw; +aahgx; +aahgy; +aahgz; +aahha; +aahhb; +aahhc; +aahhd; +aahhe; +aahhf; +aahhg; +aahhh; +aahhi; +aahhj; +aahhk; +aahhl; +aahhm; +aahhn; +aahho; +aahhp; +aahhq; +aahhr; +aahhs; +aahht; +aahhu; +aahhv; +aahhw; +aahhx; +aahhy; +aahhz; +aahia; +aahib; +aahic; +aahid; +aahie; +aahif; +aahig; +aahih; +aahii; +aahij; +aahik; +aahil; +aahim; +aahin; +aahio; +aahip; +aahiq; +aahir; +aahis; +aahit; +aahiu; +aahiv; +aahiw; +aahix; +aahiy; +aahiz; +aahja; +aahjb; +aahjc; +aahjd; +aahje; +aahjf; +aahjg; +aahjh; +aahji; +aahjj; +aahjk; +aahjl; +aahjm; +aahjn; +aahjo; +aahjp; +aahjq; +aahjr; +aahjs; +aahjt; +aahju; +aahjv; +aahjw; +aahjx; +aahjy; +aahjz; +aahka; +aahkb; +aahkc; +aahkd; +aahke; +aahkf; +aahkg; +aahkh; +aahki; +aahkj; +aahkk; +aahkl; +aahkm; +aahkn; +aahko; +aahkp; +aahkq; +aahkr; +aahks; +aahkt; +aahku; +aahkv; +aahkw; +aahkx; +aahky; +aahkz; +aahla; +aahlb; +aahlc; +aahld; +aahle; +aahlf; +aahlg; +aahlh; +aahli; +aahlj; +aahlk; +aahll; +aahlm; +aahln; +aahlo; +aahlp; +aahlq; +aahlr; +aahls; +aahlt; +aahlu; +aahlv; +aahlw; +aahlx; +aahly; +aahlz; +aahma; +aahmb; +aahmc; +aahmd; +aahme; +aahmf; +aahmg; +aahmh; +aahmi; +aahmj; +aahmk; +aahml; +aahmm; +aahmn; +aahmo; +aahmp; +aahmq; +aahmr; +aahms; +aahmt; +aahmu; +aahmv; +aahmw; +aahmx; +aahmy; +aahmz; +aahna; +aahnb; +aahnc; +aahnd; +aahne; +aahnf; +aahng; +aahnh; +aahni; +aahnj; +aahnk; +aahnl; +aahnm; +aahnn; +aahno; +aahnp; +aahnq; +aahnr; +aahns; +aahnt; +aahnu; +aahnv; +aahnw; +aahnx; +aahny; +aahnz; +aahoa; +aahob; +aahoc; +aahod; +aahoe; +aahof; +aahog; +aahoh; +aahoi; +aahoj; +aahok; +aahol; +aahom; +aahon; +aahoo; +aahop; +aahoq; +aahor; +aahos; +aahot; +aahou; +aahov; +aahow; +aahox; +aahoy; +aahoz; +aahpa; +aahpb; +aahpc; +aahpd; +aahpe; +aahpf; +aahpg; +aahph; +aahpi; +aahpj; +aahpk; +aahpl; +aahpm; +aahpn; +aahpo; +aahpp; +aahpq; +aahpr; +aahps; +aahpt; +aahpu; +aahpv; +aahpw; +aahpx; +aahpy; +aahpz; +aahqa; +aahqb; +aahqc; +aahqd; +aahqe; +aahqf; +aahqg; +aahqh; +aahqi; +aahqj; +aahqk; +aahql; +aahqm; +aahqn; +aahqo; +aahqp; +aahqq; +aahqr; +aahqs; +aahqt; +aahqu; +aahqv; +aahqw; +aahqx; +aahqy; +aahqz; +aahra; +aahrb; +aahrc; +aahrd; +aahre; +aahrf; +aahrg; +aahrh; +aahri; +aahrj; +aahrk; +aahrl; +aahrm; +aahrn; +aahro; +aahrp; +aahrq; +aahrr; +aahrs; +aahrt; +aahru; +aahrv; +aahrw; +aahrx; +aahry; +aahrz; +aahsa; +aahsb; +aahsc; +aahsd; +aahse; +aahsf; +aahsg; +aahsh; +aahsi; +aahsj; +aahsk; +aahsl; +aahsm; +aahsn; +aahso; +aahsp; +aahsq; +aahsr; +aahss; +aahst; +aahsu; +aahsv; +aahsw; +aahsx; +aahsy; +aahsz; +aahta; +aahtb; +aahtc; +aahtd; +aahte; +aahtf; +aahtg; +aahth; +aahti; +aahtj; +aahtk; +aahtl; +aahtm; +aahtn; +aahto; +aahtp; +aahtq; +aahtr; +aahts; +aahtt; +aahtu; +aahtv; +aahtw; +aahtx; +aahty; +aahtz; +aahua; +aahub; +aahuc; +aahud; +aahue; +aahuf; +aahug; +aahuh; +aahui; +aahuj; +aahuk; +aahul; +aahum; +aahun; +aahuo; +aahup; +aahuq; +aahur; +aahus; +aahut; +aahuu; +aahuv; +aahuw; +aahux; +aahuy; +aahuz; +aahva; +aahvb; +aahvc; +aahvd; +aahve; +aahvf; +aahvg; +aahvh; +aahvi; +aahvj; +aahvk; +aahvl; +aahvm; +aahvn; +aahvo; +aahvp; +aahvq; +aahvr; +aahvs; +aahvt; +aahvu; +aahvv; +aahvw; +aahvx; +aahvy; +aahvz; +aahwa; +aahwb; +aahwc; +aahwd; +aahwe; +aahwf; +aahwg; +aahwh; +aahwi; +aahwj; +aahwk; +aahwl; +aahwm; +aahwn; +aahwo; +aahwp; +aahwq; +aahwr; +aahws; +aahwt; +aahwu; +aahwv; +aahww; +aahwx; +aahwy; +aahwz; +aahxa; +aahxb; +aahxc; +aahxd; +aahxe; +aahxf; +aahxg; +aahxh; +aahxi; +aahxj; +aahxk; +aahxl; +aahxm; +aahxn; +aahxo; +aahxp; +aahxq; +aahxr; +aahxs; +aahxt; +aahxu; +aahxv; +aahxw; +aahxx; +aahxy; +aahxz; +aahya; +aahyb; +aahyc; +aahyd; +aahye; +aahyf; +aahyg; +aahyh; +aahyi; +aahyj; +aahyk; +aahyl; +aahym; +aahyn; +aahyo; +aahyp; +aahyq; +aahyr; +aahys; +aahyt; +aahyu; +aahyv; +aahyw; +aahyx; +aahyy; +aahyz; +aahza; +aahzb; +aahzc; +aahzd; +aahze; +aahzf; +aahzg; +aahzh; +aahzi; +aahzj; +aahzk; +aahzl; +aahzm; +aahzn; +aahzo; +aahzp; +aahzq; +aahzr; +aahzs; +aahzt; +aahzu; +aahzv; +aahzw; +aahzx; +aahzy; +aahzz; +aaiaa; +aaiab; +aaiac; +aaiad; +aaiae; +aaiaf; +aaiag; +aaiah; +aaiai; +aaiaj; +aaiak; +aaial; +aaiam; +aaian; +aaiao; +aaiap; +aaiaq; +aaiar; +aaias; +aaiat; +aaiau; +aaiav; +aaiaw; +aaiax; +aaiay; +aaiaz; +aaiba; +aaibb; +aaibc; +aaibd; +aaibe; +aaibf; +aaibg; +aaibh; +aaibi; +aaibj; +aaibk; +aaibl; +aaibm; +aaibn; +aaibo; +aaibp; +aaibq; +aaibr; +aaibs; +aaibt; +aaibu; +aaibv; +aaibw; +aaibx; +aaiby; +aaibz; +aaica; +aaicb; +aaicc; +aaicd; +aaice; +aaicf; +aaicg; +aaich; +aaici; +aaicj; +aaick; +aaicl; +aaicm; +aaicn; +aaico; +aaicp; +aaicq; +aaicr; +aaics; +aaict; +aaicu; +aaicv; +aaicw; +aaicx; +aaicy; +aaicz; +aaida; +aaidb; +aaidc; +aaidd; +aaide; +aaidf; +aaidg; +aaidh; +aaidi; +aaidj; +aaidk; +aaidl; +aaidm; +aaidn; +aaido; +aaidp; +aaidq; +aaidr; +aaids; +aaidt; +aaidu; +aaidv; +aaidw; +aaidx; +aaidy; +aaidz; +aaiea; +aaieb; +aaiec; +aaied; +aaiee; +aaief; +aaieg; +aaieh; +aaiei; +aaiej; +aaiek; +aaiel; +aaiem; +aaien; +aaieo; +aaiep; +aaieq; +aaier; +aaies; +aaiet; +aaieu; +aaiev; +aaiew; +aaiex; +aaiey; +aaiez; +aaifa; +aaifb; +aaifc; +aaifd; +aaife; +aaiff; +aaifg; +aaifh; +aaifi; +aaifj; +aaifk; +aaifl; +aaifm; +aaifn; +aaifo; +aaifp; +aaifq; +aaifr; +aaifs; +aaift; +aaifu; +aaifv; +aaifw; +aaifx; +aaify; +aaifz; +aaiga; +aaigb; +aaigc; +aaigd; +aaige; +aaigf; +aaigg; +aaigh; +aaigi; +aaigj; +aaigk; +aaigl; +aaigm; +aaign; +aaigo; +aaigp; +aaigq; +aaigr; +aaigs; +aaigt; +aaigu; +aaigv; +aaigw; +aaigx; +aaigy; +aaigz; +aaiha; +aaihb; +aaihc; +aaihd; +aaihe; +aaihf; +aaihg; +aaihh; +aaihi; +aaihj; +aaihk; +aaihl; +aaihm; +aaihn; +aaiho; +aaihp; +aaihq; +aaihr; +aaihs; +aaiht; +aaihu; +aaihv; +aaihw; +aaihx; +aaihy; +aaihz; +aaiia; +aaiib; +aaiic; +aaiid; +aaiie; +aaiif; +aaiig; +aaiih; +aaiii; +aaiij; +aaiik; +aaiil; +aaiim; +aaiin; +aaiio; +aaiip; +aaiiq; +aaiir; +aaiis; +aaiit; +aaiiu; +aaiiv; +aaiiw; +aaiix; +aaiiy; +aaiiz; +aaija; +aaijb; +aaijc; +aaijd; +aaije; +aaijf; +aaijg; +aaijh; +aaiji; +aaijj; +aaijk; +aaijl; +aaijm; +aaijn; +aaijo; +aaijp; +aaijq; +aaijr; +aaijs; +aaijt; +aaiju; +aaijv; +aaijw; +aaijx; +aaijy; +aaijz; +aaika; +aaikb; +aaikc; +aaikd; +aaike; +aaikf; +aaikg; +aaikh; +aaiki; +aaikj; +aaikk; +aaikl; +aaikm; +aaikn; +aaiko; +aaikp; +aaikq; +aaikr; +aaiks; +aaikt; +aaiku; +aaikv; +aaikw; +aaikx; +aaiky; +aaikz; +aaila; +aailb; +aailc; +aaild; +aaile; +aailf; +aailg; +aailh; +aaili; +aailj; +aailk; +aaill; +aailm; +aailn; +aailo; +aailp; +aailq; +aailr; +aails; +aailt; +aailu; +aailv; +aailw; +aailx; +aaily; +aailz; +aaima; +aaimb; +aaimc; +aaimd; +aaime; +aaimf; +aaimg; +aaimh; +aaimi; +aaimj; +aaimk; +aaiml; +aaimm; +aaimn; +aaimo; +aaimp; +aaimq; +aaimr; +aaims; +aaimt; +aaimu; +aaimv; +aaimw; +aaimx; +aaimy; +aaimz; +aaina; +aainb; +aainc; +aaind; +aaine; +aainf; +aaing; +aainh; +aaini; +aainj; +aaink; +aainl; +aainm; +aainn; +aaino; +aainp; +aainq; +aainr; +aains; +aaint; +aainu; +aainv; +aainw; +aainx; +aainy; +aainz; +aaioa; +aaiob; +aaioc; +aaiod; +aaioe; +aaiof; +aaiog; +aaioh; +aaioi; +aaioj; +aaiok; +aaiol; +aaiom; +aaion; +aaioo; +aaiop; +aaioq; +aaior; +aaios; +aaiot; +aaiou; +aaiov; +aaiow; +aaiox; +aaioy; +aaioz; +aaipa; +aaipb; +aaipc; +aaipd; +aaipe; +aaipf; +aaipg; +aaiph; +aaipi; +aaipj; +aaipk; +aaipl; +aaipm; +aaipn; +aaipo; +aaipp; +aaipq; +aaipr; +aaips; +aaipt; +aaipu; +aaipv; +aaipw; +aaipx; +aaipy; +aaipz; +aaiqa; +aaiqb; +aaiqc; +aaiqd; +aaiqe; +aaiqf; +aaiqg; +aaiqh; +aaiqi; +aaiqj; +aaiqk; +aaiql; +aaiqm; +aaiqn; +aaiqo; +aaiqp; +aaiqq; +aaiqr; +aaiqs; +aaiqt; +aaiqu; +aaiqv; +aaiqw; +aaiqx; +aaiqy; +aaiqz; +aaira; +aairb; +aairc; +aaird; +aaire; +aairf; +aairg; +aairh; +aairi; +aairj; +aairk; +aairl; +aairm; +aairn; +aairo; +aairp; +aairq; +aairr; +aairs; +aairt; +aairu; +aairv; +aairw; +aairx; +aairy; +aairz; +aaisa; +aaisb; +aaisc; +aaisd; +aaise; +aaisf; +aaisg; +aaish; +aaisi; +aaisj; +aaisk; +aaisl; +aaism; +aaisn; +aaiso; +aaisp; +aaisq; +aaisr; +aaiss; +aaist; +aaisu; +aaisv; +aaisw; +aaisx; +aaisy; +aaisz; +aaita; +aaitb; +aaitc; +aaitd; +aaite; +aaitf; +aaitg; +aaith; +aaiti; +aaitj; +aaitk; +aaitl; +aaitm; +aaitn; +aaito; +aaitp; +aaitq; +aaitr; +aaits; +aaitt; +aaitu; +aaitv; +aaitw; +aaitx; +aaity; +aaitz; +aaiua; +aaiub; +aaiuc; +aaiud; +aaiue; +aaiuf; +aaiug; +aaiuh; +aaiui; +aaiuj; +aaiuk; +aaiul; +aaium; +aaiun; +aaiuo; +aaiup; +aaiuq; +aaiur; +aaius; +aaiut; +aaiuu; +aaiuv; +aaiuw; +aaiux; +aaiuy; +aaiuz; +aaiva; +aaivb; +aaivc; +aaivd; +aaive; +aaivf; +aaivg; +aaivh; +aaivi; +aaivj; +aaivk; +aaivl; +aaivm; +aaivn; +aaivo; +aaivp; +aaivq; +aaivr; +aaivs; +aaivt; +aaivu; +aaivv; +aaivw; +aaivx; +aaivy; +aaivz; +aaiwa; +aaiwb; +aaiwc; +aaiwd; +aaiwe; +aaiwf; +aaiwg; +aaiwh; +aaiwi; +aaiwj; +aaiwk; +aaiwl; +aaiwm; +aaiwn; +aaiwo; +aaiwp; +aaiwq; +aaiwr; +aaiws; +aaiwt; +aaiwu; +aaiwv; +aaiww; +aaiwx; +aaiwy; +aaiwz; +aaixa; +aaixb; +aaixc; +aaixd; +aaixe; +aaixf; +aaixg; +aaixh; +aaixi; +aaixj; +aaixk; +aaixl; +aaixm; +aaixn; +aaixo; +aaixp; +aaixq; +aaixr; +aaixs; +aaixt; +aaixu; +aaixv; +aaixw; +aaixx; +aaixy; +aaixz; +aaiya; +aaiyb; +aaiyc; +aaiyd; +aaiye; +aaiyf; +aaiyg; +aaiyh; +aaiyi; +aaiyj; +aaiyk; +aaiyl; +aaiym; +aaiyn; +aaiyo; +aaiyp; +aaiyq; +aaiyr; +aaiys; +aaiyt; +aaiyu; +aaiyv; +aaiyw; +aaiyx; +aaiyy; +aaiyz; +aaiza; +aaizb; +aaizc; +aaizd; +aaize; +aaizf; +aaizg; +aaizh; +aaizi; +aaizj; +aaizk; +aaizl; +aaizm; +aaizn; +aaizo; +aaizp; +aaizq; +aaizr; +aaizs; +aaizt; +aaizu; +aaizv; +aaizw; +aaizx; +aaizy; +aaizz; +aajaa; +aajab; +aajac; +aajad; +aajae; +aajaf; +aajag; +aajah; +aajai; +aajaj; +aajak; +aajal; +aajam; +aajan; +aajao; +aajap; +aajaq; +aajar; +aajas; +aajat; +aajau; +aajav; +aajaw; +aajax; +aajay; +aajaz; +aajba; +aajbb; +aajbc; +aajbd; +aajbe; +aajbf; +aajbg; +aajbh; +aajbi; +aajbj; +aajbk; +aajbl; +aajbm; +aajbn; +aajbo; +aajbp; +aajbq; +aajbr; +aajbs; +aajbt; +aajbu; +aajbv; +aajbw; +aajbx; +aajby; +aajbz; +aajca; +aajcb; +aajcc; +aajcd; +aajce; +aajcf; +aajcg; +aajch; +aajci; +aajcj; +aajck; +aajcl; +aajcm; +aajcn; +aajco; +aajcp; +aajcq; +aajcr; +aajcs; +aajct; +aajcu; +aajcv; +aajcw; +aajcx; +aajcy; +aajcz; +aajda; +aajdb; +aajdc; +aajdd; +aajde; +aajdf; +aajdg; +aajdh; +aajdi; +aajdj; +aajdk; +aajdl; +aajdm; +aajdn; +aajdo; +aajdp; +aajdq; +aajdr; +aajds; +aajdt; +aajdu; +aajdv; +aajdw; +aajdx; +aajdy; +aajdz; +aajea; +aajeb; +aajec; +aajed; +aajee; +aajef; +aajeg; +aajeh; +aajei; +aajej; +aajek; +aajel; +aajem; +aajen; +aajeo; +aajep; +aajeq; +aajer; +aajes; +aajet; +aajeu; +aajev; +aajew; +aajex; +aajey; +aajez; +aajfa; +aajfb; +aajfc; +aajfd; +aajfe; +aajff; +aajfg; +aajfh; +aajfi; +aajfj; +aajfk; +aajfl; +aajfm; +aajfn; +aajfo; +aajfp; +aajfq; +aajfr; +aajfs; +aajft; +aajfu; +aajfv; +aajfw; +aajfx; +aajfy; +aajfz; +aajga; +aajgb; +aajgc; +aajgd; +aajge; +aajgf; +aajgg; +aajgh; +aajgi; +aajgj; +aajgk; +aajgl; +aajgm; +aajgn; +aajgo; +aajgp; +aajgq; +aajgr; +aajgs; +aajgt; +aajgu; +aajgv; +aajgw; +aajgx; +aajgy; +aajgz; +aajha; +aajhb; +aajhc; +aajhd; +aajhe; +aajhf; +aajhg; +aajhh; +aajhi; +aajhj; +aajhk; +aajhl; +aajhm; +aajhn; +aajho; +aajhp; +aajhq; +aajhr; +aajhs; +aajht; +aajhu; +aajhv; +aajhw; +aajhx; +aajhy; +aajhz; +aajia; +aajib; +aajic; +aajid; +aajie; +aajif; +aajig; +aajih; +aajii; +aajij; +aajik; +aajil; +aajim; +aajin; +aajio; +aajip; +aajiq; +aajir; +aajis; +aajit; +aajiu; +aajiv; +aajiw; +aajix; +aajiy; +aajiz; +aajja; +aajjb; +aajjc; +aajjd; +aajje; +aajjf; +aajjg; +aajjh; +aajji; +aajjj; +aajjk; +aajjl; +aajjm; +aajjn; +aajjo; +aajjp; +aajjq; +aajjr; +aajjs; +aajjt; +aajju; +aajjv; +aajjw; +aajjx; +aajjy; +aajjz; +aajka; +aajkb; +aajkc; +aajkd; +aajke; +aajkf; +aajkg; +aajkh; +aajki; +aajkj; +aajkk; +aajkl; +aajkm; +aajkn; +aajko; +aajkp; +aajkq; +aajkr; +aajks; +aajkt; +aajku; +aajkv; +aajkw; +aajkx; +aajky; +aajkz; +aajla; +aajlb; +aajlc; +aajld; +aajle; +aajlf; +aajlg; +aajlh; +aajli; +aajlj; +aajlk; +aajll; +aajlm; +aajln; +aajlo; +aajlp; +aajlq; +aajlr; +aajls; +aajlt; +aajlu; +aajlv; +aajlw; +aajlx; +aajly; +aajlz; +aajma; +aajmb; +aajmc; +aajmd; +aajme; +aajmf; +aajmg; +aajmh; +aajmi; +aajmj; +aajmk; +aajml; +aajmm; +aajmn; +aajmo; +aajmp; +aajmq; +aajmr; +aajms; +aajmt; +aajmu; +aajmv; +aajmw; +aajmx; +aajmy; +aajmz; +aajna; +aajnb; +aajnc; +aajnd; +aajne; +aajnf; +aajng; +aajnh; +aajni; +aajnj; +aajnk; +aajnl; +aajnm; +aajnn; +aajno; +aajnp; +aajnq; +aajnr; +aajns; +aajnt; +aajnu; +aajnv; +aajnw; +aajnx; +aajny; +aajnz; +aajoa; +aajob; +aajoc; +aajod; +aajoe; +aajof; +aajog; +aajoh; +aajoi; +aajoj; +aajok; +aajol; +aajom; +aajon; +aajoo; +aajop; +aajoq; +aajor; +aajos; +aajot; +aajou; +aajov; +aajow; +aajox; +aajoy; +aajoz; +aajpa; +aajpb; +aajpc; +aajpd; +aajpe; +aajpf; +aajpg; +aajph; +aajpi; +aajpj; +aajpk; +aajpl; +aajpm; +aajpn; +aajpo; +aajpp; +aajpq; +aajpr; +aajps; +aajpt; +aajpu; +aajpv; +aajpw; +aajpx; +aajpy; +aajpz; +aajqa; +aajqb; +aajqc; +aajqd; +aajqe; +aajqf; +aajqg; +aajqh; +aajqi; +aajqj; +aajqk; +aajql; +aajqm; +aajqn; +aajqo; +aajqp; +aajqq; +aajqr; +aajqs; +aajqt; +aajqu; +aajqv; +aajqw; +aajqx; +aajqy; +aajqz; +aajra; +aajrb; +aajrc; +aajrd; +aajre; +aajrf; +aajrg; +aajrh; +aajri; +aajrj; +aajrk; +aajrl; +aajrm; +aajrn; +aajro; +aajrp; +aajrq; +aajrr; +aajrs; +aajrt; +aajru; +aajrv; +aajrw; +aajrx; +aajry; +aajrz; +aajsa; +aajsb; +aajsc; +aajsd; +aajse; +aajsf; +aajsg; +aajsh; +aajsi; +aajsj; +aajsk; +aajsl; +aajsm; +aajsn; +aajso; +aajsp; +aajsq; +aajsr; +aajss; +aajst; +aajsu; +aajsv; +aajsw; +aajsx; +aajsy; +aajsz; +aajta; +aajtb; +aajtc; +aajtd; +aajte; +aajtf; +aajtg; +aajth; +aajti; +aajtj; +aajtk; +aajtl; +aajtm; +aajtn; +aajto; +aajtp; +aajtq; +aajtr; +aajts; +aajtt; +aajtu; +aajtv; +aajtw; +aajtx; +aajty; +aajtz; +aajua; +aajub; +aajuc; +aajud; +aajue; +aajuf; +aajug; +aajuh; +aajui; +aajuj; +aajuk; +aajul; +aajum; +aajun; +aajuo; +aajup; +aajuq; +aajur; +aajus; +aajut; +aajuu; +aajuv; +aajuw; +aajux; +aajuy; +aajuz; +aajva; +aajvb; +aajvc; +aajvd; +aajve; +aajvf; +aajvg; +aajvh; +aajvi; +aajvj; +aajvk; +aajvl; +aajvm; +aajvn; +aajvo; +aajvp; +aajvq; +aajvr; +aajvs; +aajvt; +aajvu; +aajvv; +aajvw; +aajvx; +aajvy; +aajvz; +aajwa; +aajwb; +aajwc; +aajwd; +aajwe; +aajwf; +aajwg; +aajwh; +aajwi; +aajwj; +aajwk; +aajwl; +aajwm; +aajwn; +aajwo; +aajwp; +aajwq; +aajwr; +aajws; +aajwt; +aajwu; +aajwv; +aajww; +aajwx; +aajwy; +aajwz; +aajxa; +aajxb; +aajxc; +aajxd; +aajxe; +aajxf; +aajxg; +aajxh; +aajxi; +aajxj; +aajxk; +aajxl; +aajxm; +aajxn; +aajxo; +aajxp; +aajxq; +aajxr; +aajxs; +aajxt; +aajxu; +aajxv; +aajxw; +aajxx; +aajxy; +aajxz; +aajya; +aajyb; +aajyc; +aajyd; +aajye; +aajyf; +aajyg; +aajyh; +aajyi; +aajyj; +aajyk; +aajyl; +aajym; +aajyn; +aajyo; +aajyp; +aajyq; +aajyr; +aajys; +aajyt; +aajyu; +aajyv; +aajyw; +aajyx; +aajyy; +aajyz; +aajza; +aajzb; +aajzc; +aajzd; +aajze; +aajzf; +aajzg; +aajzh; +aajzi; +aajzj; +aajzk; +aajzl; +aajzm; +aajzn; +aajzo; +aajzp; +aajzq; +aajzr; +aajzs; +aajzt; +aajzu; +aajzv; +aajzw; +aajzx; +aajzy; +aajzz; +aakaa; +aakab; +aakac; +aakad; +aakae; +aakaf; +aakag; +aakah; +aakai; +aakaj; +aakak; +aakal; +aakam; +aakan; +aakao; +aakap; +aakaq; +aakar; +aakas; +aakat; +aakau; +aakav; +aakaw; +aakax; +aakay; +aakaz; +aakba; +aakbb; +aakbc; +aakbd; +aakbe; +aakbf; +aakbg; +aakbh; +aakbi; +aakbj; +aakbk; +aakbl; +aakbm; +aakbn; +aakbo; +aakbp; +aakbq; +aakbr; +aakbs; +aakbt; +aakbu; +aakbv; +aakbw; +aakbx; +aakby; +aakbz; +aakca; +aakcb; +aakcc; +aakcd; +aakce; +aakcf; +aakcg; +aakch; +aakci; +aakcj; +aakck; +aakcl; +aakcm; +aakcn; +aakco; +aakcp; +aakcq; +aakcr; +aakcs; +aakct; +aakcu; +aakcv; +aakcw; +aakcx; +aakcy; +aakcz; +aakda; +aakdb; +aakdc; +aakdd; +aakde; +aakdf; +aakdg; +aakdh; +aakdi; +aakdj; +aakdk; +aakdl; +aakdm; +aakdn; +aakdo; +aakdp; +aakdq; +aakdr; +aakds; +aakdt; +aakdu; +aakdv; +aakdw; +aakdx; +aakdy; +aakdz; +aakea; +aakeb; +aakec; +aaked; +aakee; +aakef; +aakeg; +aakeh; +aakei; +aakej; +aakek; +aakel; +aakem; +aaken; +aakeo; +aakep; +aakeq; +aaker; +aakes; +aaket; +aakeu; +aakev; +aakew; +aakex; +aakey; +aakez; +aakfa; +aakfb; +aakfc; +aakfd; +aakfe; +aakff; +aakfg; +aakfh; +aakfi; +aakfj; +aakfk; +aakfl; +aakfm; +aakfn; +aakfo; +aakfp; +aakfq; +aakfr; +aakfs; +aakft; +aakfu; +aakfv; +aakfw; +aakfx; +aakfy; +aakfz; +aakga; +aakgb; +aakgc; +aakgd; +aakge; +aakgf; +aakgg; +aakgh; +aakgi; +aakgj; +aakgk; +aakgl; +aakgm; +aakgn; +aakgo; +aakgp; +aakgq; +aakgr; +aakgs; +aakgt; +aakgu; +aakgv; +aakgw; +aakgx; +aakgy; +aakgz; +aakha; +aakhb; +aakhc; +aakhd; +aakhe; +aakhf; +aakhg; +aakhh; +aakhi; +aakhj; +aakhk; +aakhl; +aakhm; +aakhn; +aakho; +aakhp; +aakhq; +aakhr; +aakhs; +aakht; +aakhu; +aakhv; +aakhw; +aakhx; +aakhy; +aakhz; +aakia; +aakib; +aakic; +aakid; +aakie; +aakif; +aakig; +aakih; +aakii; +aakij; +aakik; +aakil; +aakim; +aakin; +aakio; +aakip; +aakiq; +aakir; +aakis; +aakit; +aakiu; +aakiv; +aakiw; +aakix; +aakiy; +aakiz; +aakja; +aakjb; +aakjc; +aakjd; +aakje; +aakjf; +aakjg; +aakjh; +aakji; +aakjj; +aakjk; +aakjl; +aakjm; +aakjn; +aakjo; +aakjp; +aakjq; +aakjr; +aakjs; +aakjt; +aakju; +aakjv; +aakjw; +aakjx; +aakjy; +aakjz; +aakka; +aakkb; +aakkc; +aakkd; +aakke; +aakkf; +aakkg; +aakkh; +aakki; +aakkj; +aakkk; +aakkl; +aakkm; +aakkn; +aakko; +aakkp; +aakkq; +aakkr; +aakks; +aakkt; +aakku; +aakkv; +aakkw; +aakkx; +aakky; +aakkz; +aakla; +aaklb; +aaklc; +aakld; +aakle; +aaklf; +aaklg; +aaklh; +aakli; +aaklj; +aaklk; +aakll; +aaklm; +aakln; +aaklo; +aaklp; +aaklq; +aaklr; +aakls; +aaklt; +aaklu; +aaklv; +aaklw; +aaklx; +aakly; +aaklz; +aakma; +aakmb; +aakmc; +aakmd; +aakme; +aakmf; +aakmg; +aakmh; +aakmi; +aakmj; +aakmk; +aakml; +aakmm; +aakmn; +aakmo; +aakmp; +aakmq; +aakmr; +aakms; +aakmt; +aakmu; +aakmv; +aakmw; +aakmx; +aakmy; +aakmz; +aakna; +aaknb; +aaknc; +aaknd; +aakne; +aaknf; +aakng; +aaknh; +aakni; +aaknj; +aaknk; +aaknl; +aaknm; +aaknn; +aakno; +aaknp; +aaknq; +aaknr; +aakns; +aaknt; +aaknu; +aaknv; +aaknw; +aaknx; +aakny; +aaknz; +aakoa; +aakob; +aakoc; +aakod; +aakoe; +aakof; +aakog; +aakoh; +aakoi; +aakoj; +aakok; +aakol; +aakom; +aakon; +aakoo; +aakop; +aakoq; +aakor; +aakos; +aakot; +aakou; +aakov; +aakow; +aakox; +aakoy; +aakoz; +aakpa; +aakpb; +aakpc; +aakpd; +aakpe; +aakpf; +aakpg; +aakph; +aakpi; +aakpj; +aakpk; +aakpl; +aakpm; +aakpn; +aakpo; +aakpp; +aakpq; +aakpr; +aakps; +aakpt; +aakpu; +aakpv; +aakpw; +aakpx; +aakpy; +aakpz; +aakqa; +aakqb; +aakqc; +aakqd; +aakqe; +aakqf; +aakqg; +aakqh; +aakqi; +aakqj; +aakqk; +aakql; +aakqm; +aakqn; +aakqo; +aakqp; +aakqq; +aakqr; +aakqs; +aakqt; +aakqu; +aakqv; +aakqw; +aakqx; +aakqy; +aakqz; +aakra; +aakrb; +aakrc; +aakrd; +aakre; +aakrf; +aakrg; +aakrh; +aakri; +aakrj; +aakrk; +aakrl; +aakrm; +aakrn; +aakro; +aakrp; +aakrq; +aakrr; +aakrs; +aakrt; +aakru; +aakrv; +aakrw; +aakrx; +aakry; +aakrz; +aaksa; +aaksb; +aaksc; +aaksd; +aakse; +aaksf; +aaksg; +aaksh; +aaksi; +aaksj; +aaksk; +aaksl; +aaksm; +aaksn; +aakso; +aaksp; +aaksq; +aaksr; +aakss; +aakst; +aaksu; +aaksv; +aaksw; +aaksx; +aaksy; +aaksz; +aakta; +aaktb; +aaktc; +aaktd; +aakte; +aaktf; +aaktg; +aakth; +aakti; +aaktj; +aaktk; +aaktl; +aaktm; +aaktn; +aakto; +aaktp; +aaktq; +aaktr; +aakts; +aaktt; +aaktu; +aaktv; +aaktw; +aaktx; +aakty; +aaktz; +aakua; +aakub; +aakuc; +aakud; +aakue; +aakuf; +aakug; +aakuh; +aakui; +aakuj; +aakuk; +aakul; +aakum; +aakun; +aakuo; +aakup; +aakuq; +aakur; +aakus; +aakut; +aakuu; +aakuv; +aakuw; +aakux; +aakuy; +aakuz; +aakva; +aakvb; +aakvc; +aakvd; +aakve; +aakvf; +aakvg; +aakvh; +aakvi; +aakvj; +aakvk; +aakvl; +aakvm; +aakvn; +aakvo; +aakvp; +aakvq; +aakvr; +aakvs; +aakvt; +aakvu; +aakvv; +aakvw; +aakvx; +aakvy; +aakvz; +aakwa; +aakwb; +aakwc; +aakwd; +aakwe; +aakwf; +aakwg; +aakwh; +aakwi; +aakwj; +aakwk; +aakwl; +aakwm; +aakwn; +aakwo; +aakwp; +aakwq; +aakwr; +aakws; +aakwt; +aakwu; +aakwv; +aakww; +aakwx; +aakwy; +aakwz; +aakxa; +aakxb; +aakxc; +aakxd; +aakxe; +aakxf; +aakxg; +aakxh; +aakxi; +aakxj; +aakxk; +aakxl; +aakxm; +aakxn; +aakxo; +aakxp; +aakxq; +aakxr; +aakxs; +aakxt; +aakxu; +aakxv; +aakxw; +aakxx; +aakxy; +aakxz; +aakya; +aakyb; +aakyc; +aakyd; +aakye; +aakyf; +aakyg; +aakyh; +aakyi; +aakyj; +aakyk; +aakyl; +aakym; +aakyn; +aakyo; +aakyp; +aakyq; +aakyr; +aakys; +aakyt; +aakyu; +aakyv; +aakyw; +aakyx; +aakyy; +aakyz; +aakza; +aakzb; +aakzc; +aakzd; +aakze; +aakzf; +aakzg; +aakzh; +aakzi; +aakzj; +aakzk; +aakzl; +aakzm; +aakzn; +aakzo; +aakzp; +aakzq; +aakzr; +aakzs; +aakzt; +aakzu; +aakzv; +aakzw; +aakzx; +aakzy; +aakzz; +aalaa; +aalab; +aalac; +aalad; +aalae; +aalaf; +aalag; +aalah; +aalai; +aalaj; +aalak; +aalal; +aalam; +aalan; +aalao; +aalap; +aalaq; +aalar; +aalas; +aalat; +aalau; +aalav; +aalaw; +aalax; +aalay; +aalaz; +aalba; +aalbb; +aalbc; +aalbd; +aalbe; +aalbf; +aalbg; +aalbh; +aalbi; +aalbj; +aalbk; +aalbl; +aalbm; +aalbn; +aalbo; +aalbp; +aalbq; +aalbr; +aalbs; +aalbt; +aalbu; +aalbv; +aalbw; +aalbx; +aalby; +aalbz; +aalca; +aalcb; +aalcc; +aalcd; +aalce; +aalcf; +aalcg; +aalch; +aalci; +aalcj; +aalck; +aalcl; +aalcm; +aalcn; +aalco; +aalcp; +aalcq; +aalcr; +aalcs; +aalct; +aalcu; +aalcv; +aalcw; +aalcx; +aalcy; +aalcz; +aalda; +aaldb; +aaldc; +aaldd; +aalde; +aaldf; +aaldg; +aaldh; +aaldi; +aaldj; +aaldk; +aaldl; +aaldm; +aaldn; +aaldo; +aaldp; +aaldq; +aaldr; +aalds; +aaldt; +aaldu; +aaldv; +aaldw; +aaldx; +aaldy; +aaldz; +aalea; +aaleb; +aalec; +aaled; +aalee; +aalef; +aaleg; +aaleh; +aalei; +aalej; +aalek; +aalel; +aalem; +aalen; +aaleo; +aalep; +aaleq; +aaler; +aales; +aalet; +aaleu; +aalev; +aalew; +aalex; +aaley; +aalez; +aalfa; +aalfb; +aalfc; +aalfd; +aalfe; +aalff; +aalfg; +aalfh; +aalfi; +aalfj; +aalfk; +aalfl; +aalfm; +aalfn; +aalfo; +aalfp; +aalfq; +aalfr; +aalfs; +aalft; +aalfu; +aalfv; +aalfw; +aalfx; +aalfy; +aalfz; +aalga; +aalgb; +aalgc; +aalgd; +aalge; +aalgf; +aalgg; +aalgh; +aalgi; +aalgj; +aalgk; +aalgl; +aalgm; +aalgn; +aalgo; +aalgp; +aalgq; +aalgr; +aalgs; +aalgt; +aalgu; +aalgv; +aalgw; +aalgx; +aalgy; +aalgz; +aalha; +aalhb; +aalhc; +aalhd; +aalhe; +aalhf; +aalhg; +aalhh; +aalhi; +aalhj; +aalhk; +aalhl; +aalhm; +aalhn; +aalho; +aalhp; +aalhq; +aalhr; +aalhs; +aalht; +aalhu; +aalhv; +aalhw; +aalhx; +aalhy; +aalhz; +aalia; +aalib; +aalic; +aalid; +aalie; +aalif; +aalig; +aalih; +aalii; +aalij; +aalik; +aalil; +aalim; +aalin; +aalio; +aalip; +aaliq; +aalir; +aalis; +aalit; +aaliu; +aaliv; +aaliw; +aalix; +aaliy; +aaliz; +aalja; +aaljb; +aaljc; +aaljd; +aalje; +aaljf; +aaljg; +aaljh; +aalji; +aaljj; +aaljk; +aaljl; +aaljm; +aaljn; +aaljo; +aaljp; +aaljq; +aaljr; +aaljs; +aaljt; +aalju; +aaljv; +aaljw; +aaljx; +aaljy; +aaljz; +aalka; +aalkb; +aalkc; +aalkd; +aalke; +aalkf; +aalkg; +aalkh; +aalki; +aalkj; +aalkk; +aalkl; +aalkm; +aalkn; +aalko; +aalkp; +aalkq; +aalkr; +aalks; +aalkt; +aalku; +aalkv; +aalkw; +aalkx; +aalky; +aalkz; +aalla; +aallb; +aallc; +aalld; +aalle; +aallf; +aallg; +aallh; +aalli; +aallj; +aallk; +aalll; +aallm; +aalln; +aallo; +aallp; +aallq; +aallr; +aalls; +aallt; +aallu; +aallv; +aallw; +aallx; +aally; +aallz; +aalma; +aalmb; +aalmc; +aalmd; +aalme; +aalmf; +aalmg; +aalmh; +aalmi; +aalmj; +aalmk; +aalml; +aalmm; +aalmn; +aalmo; +aalmp; +aalmq; +aalmr; +aalms; +aalmt; +aalmu; +aalmv; +aalmw; +aalmx; +aalmy; +aalmz; +aalna; +aalnb; +aalnc; +aalnd; +aalne; +aalnf; +aalng; +aalnh; +aalni; +aalnj; +aalnk; +aalnl; +aalnm; +aalnn; +aalno; +aalnp; +aalnq; +aalnr; +aalns; +aalnt; +aalnu; +aalnv; +aalnw; +aalnx; +aalny; +aalnz; +aaloa; +aalob; +aaloc; +aalod; +aaloe; +aalof; +aalog; +aaloh; +aaloi; +aaloj; +aalok; +aalol; +aalom; +aalon; +aaloo; +aalop; +aaloq; +aalor; +aalos; +aalot; +aalou; +aalov; +aalow; +aalox; +aaloy; +aaloz; +aalpa; +aalpb; +aalpc; +aalpd; +aalpe; +aalpf; +aalpg; +aalph; +aalpi; +aalpj; +aalpk; +aalpl; +aalpm; +aalpn; +aalpo; +aalpp; +aalpq; +aalpr; +aalps; +aalpt; +aalpu; +aalpv; +aalpw; +aalpx; +aalpy; +aalpz; +aalqa; +aalqb; +aalqc; +aalqd; +aalqe; +aalqf; +aalqg; +aalqh; +aalqi; +aalqj; +aalqk; +aalql; +aalqm; +aalqn; +aalqo; +aalqp; +aalqq; +aalqr; +aalqs; +aalqt; +aalqu; +aalqv; +aalqw; +aalqx; +aalqy; +aalqz; +aalra; +aalrb; +aalrc; +aalrd; +aalre; +aalrf; +aalrg; +aalrh; +aalri; +aalrj; +aalrk; +aalrl; +aalrm; +aalrn; +aalro; +aalrp; +aalrq; +aalrr; +aalrs; +aalrt; +aalru; +aalrv; +aalrw; +aalrx; +aalry; +aalrz; +aalsa; +aalsb; +aalsc; +aalsd; +aalse; +aalsf; +aalsg; +aalsh; +aalsi; +aalsj; +aalsk; +aalsl; +aalsm; +aalsn; +aalso; +aalsp; +aalsq; +aalsr; +aalss; +aalst; +aalsu; +aalsv; +aalsw; +aalsx; +aalsy; +aalsz; +aalta; +aaltb; +aaltc; +aaltd; +aalte; +aaltf; +aaltg; +aalth; +aalti; +aaltj; +aaltk; +aaltl; +aaltm; +aaltn; +aalto; +aaltp; +aaltq; +aaltr; +aalts; +aaltt; +aaltu; +aaltv; +aaltw; +aaltx; +aalty; +aaltz; +aalua; +aalub; +aaluc; +aalud; +aalue; +aaluf; +aalug; +aaluh; +aalui; +aaluj; +aaluk; +aalul; +aalum; +aalun; +aaluo; +aalup; +aaluq; +aalur; +aalus; +aalut; +aaluu; +aaluv; +aaluw; +aalux; +aaluy; +aaluz; +aalva; +aalvb; +aalvc; +aalvd; +aalve; +aalvf; +aalvg; +aalvh; +aalvi; +aalvj; +aalvk; +aalvl; +aalvm; +aalvn; +aalvo; +aalvp; +aalvq; +aalvr; +aalvs; +aalvt; +aalvu; +aalvv; +aalvw; +aalvx; +aalvy; +aalvz; +aalwa; +aalwb; +aalwc; +aalwd; +aalwe; +aalwf; +aalwg; +aalwh; +aalwi; +aalwj; +aalwk; +aalwl; +aalwm; +aalwn; +aalwo; +aalwp; +aalwq; +aalwr; +aalws; +aalwt; +aalwu; +aalwv; +aalww; +aalwx; +aalwy; +aalwz; +aalxa; +aalxb; +aalxc; +aalxd; +aalxe; +aalxf; +aalxg; +aalxh; +aalxi; +aalxj; +aalxk; +aalxl; +aalxm; +aalxn; +aalxo; +aalxp; +aalxq; +aalxr; +aalxs; +aalxt; +aalxu; +aalxv; +aalxw; +aalxx; +aalxy; +aalxz; +aalya; +aalyb; +aalyc; +aalyd; +aalye; +aalyf; +aalyg; +aalyh; +aalyi; +aalyj; +aalyk; +aalyl; +aalym; +aalyn; +aalyo; +aalyp; +aalyq; +aalyr; +aalys; +aalyt; +aalyu; +aalyv; +aalyw; +aalyx; +aalyy; +aalyz; +aalza; +aalzb; +aalzc; +aalzd; +aalze; +aalzf; +aalzg; +aalzh; +aalzi; +aalzj; +aalzk; +aalzl; +aalzm; +aalzn; +aalzo; +aalzp; +aalzq; +aalzr; +aalzs; +aalzt; +aalzu; +aalzv; +aalzw; +aalzx; +aalzy; +aalzz; +aamaa; +aamab; +aamac; +aamad; +aamae; +aamaf; +aamag; +aamah; +aamai; +aamaj; +aamak; +aamal; +aamam; +aaman; +aamao; +aamap; +aamaq; +aamar; +aamas; +aamat; +aamau; +aamav; +aamaw; +aamax; +aamay; +aamaz; +aamba; +aambb; +aambc; +aambd; +aambe; +aambf; +aambg; +aambh; +aambi; +aambj; +aambk; +aambl; +aambm; +aambn; +aambo; +aambp; +aambq; +aambr; +aambs; +aambt; +aambu; +aambv; +aambw; +aambx; +aamby; +aambz; +aamca; +aamcb; +aamcc; +aamcd; +aamce; +aamcf; +aamcg; +aamch; +aamci; +aamcj; +aamck; +aamcl; +aamcm; +aamcn; +aamco; +aamcp; +aamcq; +aamcr; +aamcs; +aamct; +aamcu; +aamcv; +aamcw; +aamcx; +aamcy; +aamcz; +aamda; +aamdb; +aamdc; +aamdd; +aamde; +aamdf; +aamdg; +aamdh; +aamdi; +aamdj; +aamdk; +aamdl; +aamdm; +aamdn; +aamdo; +aamdp; +aamdq; +aamdr; +aamds; +aamdt; +aamdu; +aamdv; +aamdw; +aamdx; +aamdy; +aamdz; +aamea; +aameb; +aamec; +aamed; +aamee; +aamef; +aameg; +aameh; +aamei; +aamej; +aamek; +aamel; +aamem; +aamen; +aameo; +aamep; +aameq; +aamer; +aames; +aamet; +aameu; +aamev; +aamew; +aamex; +aamey; +aamez; +aamfa; +aamfb; +aamfc; +aamfd; +aamfe; +aamff; +aamfg; +aamfh; +aamfi; +aamfj; +aamfk; +aamfl; +aamfm; +aamfn; +aamfo; +aamfp; +aamfq; +aamfr; +aamfs; +aamft; +aamfu; +aamfv; +aamfw; +aamfx; +aamfy; +aamfz; +aamga; +aamgb; +aamgc; +aamgd; +aamge; +aamgf; +aamgg; +aamgh; +aamgi; +aamgj; +aamgk; +aamgl; +aamgm; +aamgn; +aamgo; +aamgp; +aamgq; +aamgr; +aamgs; +aamgt; +aamgu; +aamgv; +aamgw; +aamgx; +aamgy; +aamgz; +aamha; +aamhb; +aamhc; +aamhd; +aamhe; +aamhf; +aamhg; +aamhh; +aamhi; +aamhj; +aamhk; +aamhl; +aamhm; +aamhn; +aamho; +aamhp; +aamhq; +aamhr; +aamhs; +aamht; +aamhu; +aamhv; +aamhw; +aamhx; +aamhy; +aamhz; +aamia; +aamib; +aamic; +aamid; +aamie; +aamif; +aamig; +aamih; +aamii; +aamij; +aamik; +aamil; +aamim; +aamin; +aamio; +aamip; +aamiq; +aamir; +aamis; +aamit; +aamiu; +aamiv; +aamiw; +aamix; +aamiy; +aamiz; +aamja; +aamjb; +aamjc; +aamjd; +aamje; +aamjf; +aamjg; +aamjh; +aamji; +aamjj; +aamjk; +aamjl; +aamjm; +aamjn; +aamjo; +aamjp; +aamjq; +aamjr; +aamjs; +aamjt; +aamju; +aamjv; +aamjw; +aamjx; +aamjy; +aamjz; +aamka; +aamkb; +aamkc; +aamkd; +aamke; +aamkf; +aamkg; +aamkh; +aamki; +aamkj; +aamkk; +aamkl; +aamkm; +aamkn; +aamko; +aamkp; +aamkq; +aamkr; +aamks; +aamkt; +aamku; +aamkv; +aamkw; +aamkx; +aamky; +aamkz; +aamla; +aamlb; +aamlc; +aamld; +aamle; +aamlf; +aamlg; +aamlh; +aamli; +aamlj; +aamlk; +aamll; +aamlm; +aamln; +aamlo; +aamlp; +aamlq; +aamlr; +aamls; +aamlt; +aamlu; +aamlv; +aamlw; +aamlx; +aamly; +aamlz; +aamma; +aammb; +aammc; +aammd; +aamme; +aammf; +aammg; +aammh; +aammi; +aammj; +aammk; +aamml; +aammm; +aammn; +aammo; +aammp; +aammq; +aammr; +aamms; +aammt; +aammu; +aammv; +aammw; +aammx; +aammy; +aammz; +aamna; +aamnb; +aamnc; +aamnd; +aamne; +aamnf; +aamng; +aamnh; +aamni; +aamnj; +aamnk; +aamnl; +aamnm; +aamnn; +aamno; +aamnp; +aamnq; +aamnr; +aamns; +aamnt; +aamnu; +aamnv; +aamnw; +aamnx; +aamny; +aamnz; +aamoa; +aamob; +aamoc; +aamod; +aamoe; +aamof; +aamog; +aamoh; +aamoi; +aamoj; +aamok; +aamol; +aamom; +aamon; +aamoo; +aamop; +aamoq; +aamor; +aamos; +aamot; +aamou; +aamov; +aamow; +aamox; +aamoy; +aamoz; +aampa; +aampb; +aampc; +aampd; +aampe; +aampf; +aampg; +aamph; +aampi; +aampj; +aampk; +aampl; +aampm; +aampn; +aampo; +aampp; +aampq; +aampr; +aamps; +aampt; +aampu; +aampv; +aampw; +aampx; +aampy; +aampz; +aamqa; +aamqb; +aamqc; +aamqd; +aamqe; +aamqf; +aamqg; +aamqh; +aamqi; +aamqj; +aamqk; +aamql; +aamqm; +aamqn; +aamqo; +aamqp; +aamqq; +aamqr; +aamqs; +aamqt; +aamqu; +aamqv; +aamqw; +aamqx; +aamqy; +aamqz; +aamra; +aamrb; +aamrc; +aamrd; +aamre; +aamrf; +aamrg; +aamrh; +aamri; +aamrj; +aamrk; +aamrl; +aamrm; +aamrn; +aamro; +aamrp; +aamrq; +aamrr; +aamrs; +aamrt; +aamru; +aamrv; +aamrw; +aamrx; +aamry; +aamrz; +aamsa; +aamsb; +aamsc; +aamsd; +aamse; +aamsf; +aamsg; +aamsh; +aamsi; +aamsj; +aamsk; +aamsl; +aamsm; +aamsn; +aamso; +aamsp; +aamsq; +aamsr; +aamss; +aamst; +aamsu; +aamsv; +aamsw; +aamsx; +aamsy; +aamsz; +aamta; +aamtb; +aamtc; +aamtd; +aamte; +aamtf; +aamtg; +aamth; +aamti; +aamtj; +aamtk; +aamtl; +aamtm; +aamtn; +aamto; +aamtp; +aamtq; +aamtr; +aamts; +aamtt; +aamtu; +aamtv; +aamtw; +aamtx; +aamty; +aamtz; +aamua; +aamub; +aamuc; +aamud; +aamue; +aamuf; +aamug; +aamuh; +aamui; +aamuj; +aamuk; +aamul; +aamum; +aamun; +aamuo; +aamup; +aamuq; +aamur; +aamus; +aamut; +aamuu; +aamuv; +aamuw; +aamux; +aamuy; +aamuz; +aamva; +aamvb; +aamvc; +aamvd; +aamve; +aamvf; +aamvg; +aamvh; +aamvi; +aamvj; +aamvk; +aamvl; +aamvm; +aamvn; +aamvo; +aamvp; +aamvq; +aamvr; +aamvs; +aamvt; +aamvu; +aamvv; +aamvw; +aamvx; +aamvy; +aamvz; +aamwa; +aamwb; +aamwc; +aamwd; +aamwe; +aamwf; +aamwg; +aamwh; +aamwi; +aamwj; +aamwk; +aamwl; +aamwm; +aamwn; +aamwo; +aamwp; +aamwq; +aamwr; +aamws; +aamwt; +aamwu; +aamwv; +aamww; +aamwx; +aamwy; +aamwz; +aamxa; +aamxb; +aamxc; +aamxd; +aamxe; +aamxf; +aamxg; +aamxh; +aamxi; +aamxj; +aamxk; +aamxl; +aamxm; +aamxn; +aamxo; +aamxp; +aamxq; +aamxr; +aamxs; +aamxt; +aamxu; +aamxv; +aamxw; +aamxx; +aamxy; +aamxz; +aamya; +aamyb; +aamyc; +aamyd; +aamye; +aamyf; +aamyg; +aamyh; +aamyi; +aamyj; +aamyk; +aamyl; +aamym; +aamyn; +aamyo; +aamyp; +aamyq; +aamyr; +aamys; +aamyt; +aamyu; +aamyv; +aamyw; +aamyx; +aamyy; +aamyz; +aamza; +aamzb; +aamzc; +aamzd; +aamze; +aamzf; +aamzg; +aamzh; +aamzi; +aamzj; +aamzk; +aamzl; +aamzm; +aamzn; +aamzo; +aamzp; +aamzq; +aamzr; +aamzs; +aamzt; +aamzu; +aamzv; +aamzw; +aamzx; +aamzy; +aamzz; +aanaa; +aanab; +aanac; +aanad; +aanae; +aanaf; +aanag; +aanah; +aanai; +aanaj; +aanak; +aanal; +aanam; +aanan; +aanao; +aanap; +aanaq; +aanar; +aanas; +aanat; +aanau; +aanav; +aanaw; +aanax; +aanay; +aanaz; +aanba; +aanbb; +aanbc; +aanbd; +aanbe; +aanbf; +aanbg; +aanbh; +aanbi; +aanbj; +aanbk; +aanbl; +aanbm; +aanbn; +aanbo; +aanbp; +aanbq; +aanbr; +aanbs; +aanbt; +aanbu; +aanbv; +aanbw; +aanbx; +aanby; +aanbz; +aanca; +aancb; +aancc; +aancd; +aance; +aancf; +aancg; +aanch; +aanci; +aancj; +aanck; +aancl; +aancm; +aancn; +aanco; +aancp; +aancq; +aancr; +aancs; +aanct; +aancu; +aancv; +aancw; +aancx; +aancy; +aancz; +aanda; +aandb; +aandc; +aandd; +aande; +aandf; +aandg; +aandh; +aandi; +aandj; +aandk; +aandl; +aandm; +aandn; +aando; +aandp; +aandq; +aandr; +aands; +aandt; +aandu; +aandv; +aandw; +aandx; +aandy; +aandz; +aanea; +aaneb; +aanec; +aaned; +aanee; +aanef; +aaneg; +aaneh; +aanei; +aanej; +aanek; +aanel; +aanem; +aanen; +aaneo; +aanep; +aaneq; +aaner; +aanes; +aanet; +aaneu; +aanev; +aanew; +aanex; +aaney; +aanez; +aanfa; +aanfb; +aanfc; +aanfd; +aanfe; +aanff; +aanfg; +aanfh; +aanfi; +aanfj; +aanfk; +aanfl; +aanfm; +aanfn; +aanfo; +aanfp; +aanfq; +aanfr; +aanfs; +aanft; +aanfu; +aanfv; +aanfw; +aanfx; +aanfy; +aanfz; +aanga; +aangb; +aangc; +aangd; +aange; +aangf; +aangg; +aangh; +aangi; +aangj; +aangk; +aangl; +aangm; +aangn; +aango; +aangp; +aangq; +aangr; +aangs; +aangt; +aangu; +aangv; +aangw; +aangx; +aangy; +aangz; +aanha; +aanhb; +aanhc; +aanhd; +aanhe; +aanhf; +aanhg; +aanhh; +aanhi; +aanhj; +aanhk; +aanhl; +aanhm; +aanhn; +aanho; +aanhp; +aanhq; +aanhr; +aanhs; +aanht; +aanhu; +aanhv; +aanhw; +aanhx; +aanhy; +aanhz; +aania; +aanib; +aanic; +aanid; +aanie; +aanif; +aanig; +aanih; +aanii; +aanij; +aanik; +aanil; +aanim; +aanin; +aanio; +aanip; +aaniq; +aanir; +aanis; +aanit; +aaniu; +aaniv; +aaniw; +aanix; +aaniy; +aaniz; +aanja; +aanjb; +aanjc; +aanjd; +aanje; +aanjf; +aanjg; +aanjh; +aanji; +aanjj; +aanjk; +aanjl; +aanjm; +aanjn; +aanjo; +aanjp; +aanjq; +aanjr; +aanjs; +aanjt; +aanju; +aanjv; +aanjw; +aanjx; +aanjy; +aanjz; +aanka; +aankb; +aankc; +aankd; +aanke; +aankf; +aankg; +aankh; +aanki; +aankj; +aankk; +aankl; +aankm; +aankn; +aanko; +aankp; +aankq; +aankr; +aanks; +aankt; +aanku; +aankv; +aankw; +aankx; +aanky; +aankz; +aanla; +aanlb; +aanlc; +aanld; +aanle; +aanlf; +aanlg; +aanlh; +aanli; +aanlj; +aanlk; +aanll; +aanlm; +aanln; +aanlo; +aanlp; +aanlq; +aanlr; +aanls; +aanlt; +aanlu; +aanlv; +aanlw; +aanlx; +aanly; +aanlz; +aanma; +aanmb; +aanmc; +aanmd; +aanme; +aanmf; +aanmg; +aanmh; +aanmi; +aanmj; +aanmk; +aanml; +aanmm; +aanmn; +aanmo; +aanmp; +aanmq; +aanmr; +aanms; +aanmt; +aanmu; +aanmv; +aanmw; +aanmx; +aanmy; +aanmz; +aanna; +aannb; +aannc; +aannd; +aanne; +aannf; +aanng; +aannh; +aanni; +aannj; +aannk; +aannl; +aannm; +aannn; +aanno; +aannp; +aannq; +aannr; +aanns; +aannt; +aannu; +aannv; +aannw; +aannx; +aanny; +aannz; +aanoa; +aanob; +aanoc; +aanod; +aanoe; +aanof; +aanog; +aanoh; +aanoi; +aanoj; +aanok; +aanol; +aanom; +aanon; +aanoo; +aanop; +aanoq; +aanor; +aanos; +aanot; +aanou; +aanov; +aanow; +aanox; +aanoy; +aanoz; +aanpa; +aanpb; +aanpc; +aanpd; +aanpe; +aanpf; +aanpg; +aanph; +aanpi; +aanpj; +aanpk; +aanpl; +aanpm; +aanpn; +aanpo; +aanpp; +aanpq; +aanpr; +aanps; +aanpt; +aanpu; +aanpv; +aanpw; +aanpx; +aanpy; +aanpz; +aanqa; +aanqb; +aanqc; +aanqd; +aanqe; +aanqf; +aanqg; +aanqh; +aanqi; +aanqj; +aanqk; +aanql; +aanqm; +aanqn; +aanqo; +aanqp; +aanqq; +aanqr; +aanqs; +aanqt; +aanqu; +aanqv; +aanqw; +aanqx; +aanqy; +aanqz; +aanra; +aanrb; +aanrc; +aanrd; +aanre; +aanrf; +aanrg; +aanrh; +aanri; +aanrj; +aanrk; +aanrl; +aanrm; +aanrn; +aanro; +aanrp; +aanrq; +aanrr; +aanrs; +aanrt; +aanru; +aanrv; +aanrw; +aanrx; +aanry; +aanrz; +aansa; +aansb; +aansc; +aansd; +aanse; +aansf; +aansg; +aansh; +aansi; +aansj; +aansk; +aansl; +aansm; +aansn; +aanso; +aansp; +aansq; +aansr; +aanss; +aanst; +aansu; +aansv; +aansw; +aansx; +aansy; +aansz; +aanta; +aantb; +aantc; +aantd; +aante; +aantf; +aantg; +aanth; +aanti; +aantj; +aantk; +aantl; +aantm; +aantn; +aanto; +aantp; +aantq; +aantr; +aants; +aantt; +aantu; +aantv; +aantw; +aantx; +aanty; +aantz; +aanua; +aanub; +aanuc; +aanud; +aanue; +aanuf; +aanug; +aanuh; +aanui; +aanuj; +aanuk; +aanul; +aanum; +aanun; +aanuo; +aanup; +aanuq; +aanur; +aanus; +aanut; +aanuu; +aanuv; +aanuw; +aanux; +aanuy; +aanuz; +aanva; +aanvb; +aanvc; +aanvd; +aanve; +aanvf; +aanvg; +aanvh; +aanvi; +aanvj; +aanvk; +aanvl; +aanvm; +aanvn; +aanvo; +aanvp; +aanvq; +aanvr; +aanvs; +aanvt; +aanvu; +aanvv; +aanvw; +aanvx; +aanvy; +aanvz; +aanwa; +aanwb; +aanwc; +aanwd; +aanwe; +aanwf; +aanwg; +aanwh; +aanwi; +aanwj; +aanwk; +aanwl; +aanwm; +aanwn; +aanwo; +aanwp; +aanwq; +aanwr; +aanws; +aanwt; +aanwu; +aanwv; +aanww; +aanwx; +aanwy; +aanwz; +aanxa; +aanxb; +aanxc; +aanxd; +aanxe; +aanxf; +aanxg; +aanxh; +aanxi; +aanxj; +aanxk; +aanxl; +aanxm; +aanxn; +aanxo; +aanxp; +aanxq; +aanxr; +aanxs; +aanxt; +aanxu; +aanxv; +aanxw; +aanxx; +aanxy; +aanxz; +aanya; +aanyb; +aanyc; +aanyd; +aanye; +aanyf; +aanyg; +aanyh; +aanyi; +aanyj; +aanyk; +aanyl; +aanym; +aanyn; +aanyo; +aanyp; +aanyq; +aanyr; +aanys; +aanyt; +aanyu; +aanyv; +aanyw; +aanyx; +aanyy; +aanyz; +aanza; +aanzb; +aanzc; +aanzd; +aanze; +aanzf; +aanzg; +aanzh; +aanzi; +aanzj; +aanzk; +aanzl; +aanzm; +aanzn; +aanzo; +aanzp; +aanzq; +aanzr; +aanzs; +aanzt; +aanzu; +aanzv; +aanzw; +aanzx; +aanzy; +aanzz; +aaoaa; +aaoab; +aaoac; +aaoad; +aaoae; +aaoaf; +aaoag; +aaoah; +aaoai; +aaoaj; +aaoak; +aaoal; +aaoam; +aaoan; +aaoao; +aaoap; +aaoaq; +aaoar; +aaoas; +aaoat; +aaoau; +aaoav; +aaoaw; +aaoax; +aaoay; +aaoaz; +aaoba; +aaobb; +aaobc; +aaobd; +aaobe; +aaobf; +aaobg; +aaobh; +aaobi; +aaobj; +aaobk; +aaobl; +aaobm; +aaobn; +aaobo; +aaobp; +aaobq; +aaobr; +aaobs; +aaobt; +aaobu; +aaobv; +aaobw; +aaobx; +aaoby; +aaobz; +aaoca; +aaocb; +aaocc; +aaocd; +aaoce; +aaocf; +aaocg; +aaoch; +aaoci; +aaocj; +aaock; +aaocl; +aaocm; +aaocn; +aaoco; +aaocp; +aaocq; +aaocr; +aaocs; +aaoct; +aaocu; +aaocv; +aaocw; +aaocx; +aaocy; +aaocz; +aaoda; +aaodb; +aaodc; +aaodd; +aaode; +aaodf; +aaodg; +aaodh; +aaodi; +aaodj; +aaodk; +aaodl; +aaodm; +aaodn; +aaodo; +aaodp; +aaodq; +aaodr; +aaods; +aaodt; +aaodu; +aaodv; +aaodw; +aaodx; +aaody; +aaodz; +aaoea; +aaoeb; +aaoec; +aaoed; +aaoee; +aaoef; +aaoeg; +aaoeh; +aaoei; +aaoej; +aaoek; +aaoel; +aaoem; +aaoen; +aaoeo; +aaoep; +aaoeq; +aaoer; +aaoes; +aaoet; +aaoeu; +aaoev; +aaoew; +aaoex; +aaoey; +aaoez; +aaofa; +aaofb; +aaofc; +aaofd; +aaofe; +aaoff; +aaofg; +aaofh; +aaofi; +aaofj; +aaofk; +aaofl; +aaofm; +aaofn; +aaofo; +aaofp; +aaofq; +aaofr; +aaofs; +aaoft; +aaofu; +aaofv; +aaofw; +aaofx; +aaofy; +aaofz; +aaoga; +aaogb; +aaogc; +aaogd; +aaoge; +aaogf; +aaogg; +aaogh; +aaogi; +aaogj; +aaogk; +aaogl; +aaogm; +aaogn; +aaogo; +aaogp; +aaogq; +aaogr; +aaogs; +aaogt; +aaogu; +aaogv; +aaogw; +aaogx; +aaogy; +aaogz; +aaoha; +aaohb; +aaohc; +aaohd; +aaohe; +aaohf; +aaohg; +aaohh; +aaohi; +aaohj; +aaohk; +aaohl; +aaohm; +aaohn; +aaoho; +aaohp; +aaohq; +aaohr; +aaohs; +aaoht; +aaohu; +aaohv; +aaohw; +aaohx; +aaohy; +aaohz; +aaoia; +aaoib; +aaoic; +aaoid; +aaoie; +aaoif; +aaoig; +aaoih; +aaoii; +aaoij; +aaoik; +aaoil; +aaoim; +aaoin; +aaoio; +aaoip; +aaoiq; +aaoir; +aaois; +aaoit; +aaoiu; +aaoiv; +aaoiw; +aaoix; +aaoiy; +aaoiz; +aaoja; +aaojb; +aaojc; +aaojd; +aaoje; +aaojf; +aaojg; +aaojh; +aaoji; +aaojj; +aaojk; +aaojl; +aaojm; +aaojn; +aaojo; +aaojp; +aaojq; +aaojr; +aaojs; +aaojt; +aaoju; +aaojv; +aaojw; +aaojx; +aaojy; +aaojz; +aaoka; +aaokb; +aaokc; +aaokd; +aaoke; +aaokf; +aaokg; +aaokh; +aaoki; +aaokj; +aaokk; +aaokl; +aaokm; +aaokn; +aaoko; +aaokp; +aaokq; +aaokr; +aaoks; +aaokt; +aaoku; +aaokv; +aaokw; +aaokx; +aaoky; +aaokz; +aaola; +aaolb; +aaolc; +aaold; +aaole; +aaolf; +aaolg; +aaolh; +aaoli; +aaolj; +aaolk; +aaoll; +aaolm; +aaoln; +aaolo; +aaolp; +aaolq; +aaolr; +aaols; +aaolt; +aaolu; +aaolv; +aaolw; +aaolx; +aaoly; +aaolz; +aaoma; +aaomb; +aaomc; +aaomd; +aaome; +aaomf; +aaomg; +aaomh; +aaomi; +aaomj; +aaomk; +aaoml; +aaomm; +aaomn; +aaomo; +aaomp; +aaomq; +aaomr; +aaoms; +aaomt; +aaomu; +aaomv; +aaomw; +aaomx; +aaomy; +aaomz; +aaona; +aaonb; +aaonc; +aaond; +aaone; +aaonf; +aaong; +aaonh; +aaoni; +aaonj; +aaonk; +aaonl; +aaonm; +aaonn; +aaono; +aaonp; +aaonq; +aaonr; +aaons; +aaont; +aaonu; +aaonv; +aaonw; +aaonx; +aaony; +aaonz; +aaooa; +aaoob; +aaooc; +aaood; +aaooe; +aaoof; +aaoog; +aaooh; +aaooi; +aaooj; +aaook; +aaool; +aaoom; +aaoon; +aaooo; +aaoop; +aaooq; +aaoor; +aaoos; +aaoot; +aaoou; +aaoov; +aaoow; +aaoox; +aaooy; +aaooz; +aaopa; +aaopb; +aaopc; +aaopd; +aaope; +aaopf; +aaopg; +aaoph; +aaopi; +aaopj; +aaopk; +aaopl; +aaopm; +aaopn; +aaopo; +aaopp; +aaopq; +aaopr; +aaops; +aaopt; +aaopu; +aaopv; +aaopw; +aaopx; +aaopy; +aaopz; +aaoqa; +aaoqb; +aaoqc; +aaoqd; +aaoqe; +aaoqf; +aaoqg; +aaoqh; +aaoqi; +aaoqj; +aaoqk; +aaoql; +aaoqm; +aaoqn; +aaoqo; +aaoqp; +aaoqq; +aaoqr; +aaoqs; +aaoqt; +aaoqu; +aaoqv; +aaoqw; +aaoqx; +aaoqy; +aaoqz; +aaora; +aaorb; +aaorc; +aaord; +aaore; +aaorf; +aaorg; +aaorh; +aaori; +aaorj; +aaork; +aaorl; +aaorm; +aaorn; +aaoro; +aaorp; +aaorq; +aaorr; +aaors; +aaort; +aaoru; +aaorv; +aaorw; +aaorx; +aaory; +aaorz; +aaosa; +aaosb; +aaosc; +aaosd; +aaose; +aaosf; +aaosg; +aaosh; +aaosi; +aaosj; +aaosk; +aaosl; +aaosm; +aaosn; +aaoso; +aaosp; +aaosq; +aaosr; +aaoss; +aaost; +aaosu; +aaosv; +aaosw; +aaosx; +aaosy; +aaosz; +aaota; +aaotb; +aaotc; +aaotd; +aaote; +aaotf; +aaotg; +aaoth; +aaoti; +aaotj; +aaotk; +aaotl; +aaotm; +aaotn; +aaoto; +aaotp; +aaotq; +aaotr; +aaots; +aaott; +aaotu; +aaotv; +aaotw; +aaotx; +aaoty; +aaotz; +aaoua; +aaoub; +aaouc; +aaoud; +aaoue; +aaouf; +aaoug; +aaouh; +aaoui; +aaouj; +aaouk; +aaoul; +aaoum; +aaoun; +aaouo; +aaoup; +aaouq; +aaour; +aaous; +aaout; +aaouu; +aaouv; +aaouw; +aaoux; +aaouy; +aaouz; +aaova; +aaovb; +aaovc; +aaovd; +aaove; +aaovf; +aaovg; +aaovh; +aaovi; +aaovj; +aaovk; +aaovl; +aaovm; +aaovn; +aaovo; +aaovp; +aaovq; +aaovr; +aaovs; +aaovt; +aaovu; +aaovv; +aaovw; +aaovx; +aaovy; +aaovz; +aaowa; +aaowb; +aaowc; +aaowd; +aaowe; +aaowf; +aaowg; +aaowh; +aaowi; +aaowj; +aaowk; +aaowl; +aaowm; +aaown; +aaowo; +aaowp; +aaowq; +aaowr; +aaows; +aaowt; +aaowu; +aaowv; +aaoww; +aaowx; +aaowy; +aaowz; +aaoxa; +aaoxb; +aaoxc; +aaoxd; +aaoxe; +aaoxf; +aaoxg; +aaoxh; +aaoxi; +aaoxj; +aaoxk; +aaoxl; +aaoxm; +aaoxn; +aaoxo; +aaoxp; +aaoxq; +aaoxr; +aaoxs; +aaoxt; +aaoxu; +aaoxv; +aaoxw; +aaoxx; +aaoxy; +aaoxz; +aaoya; +aaoyb; +aaoyc; +aaoyd; +aaoye; +aaoyf; +aaoyg; +aaoyh; +aaoyi; +aaoyj; +aaoyk; +aaoyl; +aaoym; +aaoyn; +aaoyo; +aaoyp; +aaoyq; +aaoyr; +aaoys; +aaoyt; +aaoyu; +aaoyv; +aaoyw; +aaoyx; +aaoyy; +aaoyz; +aaoza; +aaozb; +aaozc; +aaozd; +aaoze; +aaozf; +aaozg; +aaozh; +aaozi; +aaozj; +aaozk; +aaozl; +aaozm; +aaozn; +aaozo; +aaozp; +aaozq; +aaozr; +aaozs; +aaozt; +aaozu; +aaozv; +aaozw; +aaozx; +aaozy; +aaozz; +aapaa; +aapab; +aapac; +aapad; +aapae; +aapaf; +aapag; +aapah; +aapai; +aapaj; +aapak; +aapal; +aapam; +aapan; +aapao; +aapap; +aapaq; +aapar; +aapas; +aapat; +aapau; +aapav; +aapaw; +aapax; +aapay; +aapaz; +aapba; +aapbb; +aapbc; +aapbd; +aapbe; +aapbf; +aapbg; +aapbh; +aapbi; +aapbj; +aapbk; +aapbl; +aapbm; +aapbn; +aapbo; +aapbp; +aapbq; +aapbr; +aapbs; +aapbt; +aapbu; +aapbv; +aapbw; +aapbx; +aapby; +aapbz; +aapca; +aapcb; +aapcc; +aapcd; +aapce; +aapcf; +aapcg; +aapch; +aapci; +aapcj; +aapck; +aapcl; +aapcm; +aapcn; +aapco; +aapcp; +aapcq; +aapcr; +aapcs; +aapct; +aapcu; +aapcv; +aapcw; +aapcx; +aapcy; +aapcz; +aapda; +aapdb; +aapdc; +aapdd; +aapde; +aapdf; +aapdg; +aapdh; +aapdi; +aapdj; +aapdk; +aapdl; +aapdm; +aapdn; +aapdo; +aapdp; +aapdq; +aapdr; +aapds; +aapdt; +aapdu; +aapdv; +aapdw; +aapdx; +aapdy; +aapdz; +aapea; +aapeb; +aapec; +aaped; +aapee; +aapef; +aapeg; +aapeh; +aapei; +aapej; +aapek; +aapel; +aapem; +aapen; +aapeo; +aapep; +aapeq; +aaper; +aapes; +aapet; +aapeu; +aapev; +aapew; +aapex; +aapey; +aapez; +aapfa; +aapfb; +aapfc; +aapfd; +aapfe; +aapff; +aapfg; +aapfh; +aapfi; +aapfj; +aapfk; +aapfl; +aapfm; +aapfn; +aapfo; +aapfp; +aapfq; +aapfr; +aapfs; +aapft; +aapfu; +aapfv; +aapfw; +aapfx; +aapfy; +aapfz; +aapga; +aapgb; +aapgc; +aapgd; +aapge; +aapgf; +aapgg; +aapgh; +aapgi; +aapgj; +aapgk; +aapgl; +aapgm; +aapgn; +aapgo; +aapgp; +aapgq; +aapgr; +aapgs; +aapgt; +aapgu; +aapgv; +aapgw; +aapgx; +aapgy; +aapgz; +aapha; +aaphb; +aaphc; +aaphd; +aaphe; +aaphf; +aaphg; +aaphh; +aaphi; +aaphj; +aaphk; +aaphl; +aaphm; +aaphn; +aapho; +aaphp; +aaphq; +aaphr; +aaphs; +aapht; +aaphu; +aaphv; +aaphw; +aaphx; +aaphy; +aaphz; +aapia; +aapib; +aapic; +aapid; +aapie; +aapif; +aapig; +aapih; +aapii; +aapij; +aapik; +aapil; +aapim; +aapin; +aapio; +aapip; +aapiq; +aapir; +aapis; +aapit; +aapiu; +aapiv; +aapiw; +aapix; +aapiy; +aapiz; +aapja; +aapjb; +aapjc; +aapjd; +aapje; +aapjf; +aapjg; +aapjh; +aapji; +aapjj; +aapjk; +aapjl; +aapjm; +aapjn; +aapjo; +aapjp; +aapjq; +aapjr; +aapjs; +aapjt; +aapju; +aapjv; +aapjw; +aapjx; +aapjy; +aapjz; +aapka; +aapkb; +aapkc; +aapkd; +aapke; +aapkf; +aapkg; +aapkh; +aapki; +aapkj; +aapkk; +aapkl; +aapkm; +aapkn; +aapko; +aapkp; +aapkq; +aapkr; +aapks; +aapkt; +aapku; +aapkv; +aapkw; +aapkx; +aapky; +aapkz; +aapla; +aaplb; +aaplc; +aapld; +aaple; +aaplf; +aaplg; +aaplh; +aapli; +aaplj; +aaplk; +aapll; +aaplm; +aapln; +aaplo; +aaplp; +aaplq; +aaplr; +aapls; +aaplt; +aaplu; +aaplv; +aaplw; +aaplx; +aaply; +aaplz; +aapma; +aapmb; +aapmc; +aapmd; +aapme; +aapmf; +aapmg; +aapmh; +aapmi; +aapmj; +aapmk; +aapml; +aapmm; +aapmn; +aapmo; +aapmp; +aapmq; +aapmr; +aapms; +aapmt; +aapmu; +aapmv; +aapmw; +aapmx; +aapmy; +aapmz; +aapna; +aapnb; +aapnc; +aapnd; +aapne; +aapnf; +aapng; +aapnh; +aapni; +aapnj; +aapnk; +aapnl; +aapnm; +aapnn; +aapno; +aapnp; +aapnq; +aapnr; +aapns; +aapnt; +aapnu; +aapnv; +aapnw; +aapnx; +aapny; +aapnz; +aapoa; +aapob; +aapoc; +aapod; +aapoe; +aapof; +aapog; +aapoh; +aapoi; +aapoj; +aapok; +aapol; +aapom; +aapon; +aapoo; +aapop; +aapoq; +aapor; +aapos; +aapot; +aapou; +aapov; +aapow; +aapox; +aapoy; +aapoz; +aappa; +aappb; +aappc; +aappd; +aappe; +aappf; +aappg; +aapph; +aappi; +aappj; +aappk; +aappl; +aappm; +aappn; +aappo; +aappp; +aappq; +aappr; +aapps; +aappt; +aappu; +aappv; +aappw; +aappx; +aappy; +aappz; +aapqa; +aapqb; +aapqc; +aapqd; +aapqe; +aapqf; +aapqg; +aapqh; +aapqi; +aapqj; +aapqk; +aapql; +aapqm; +aapqn; +aapqo; +aapqp; +aapqq; +aapqr; +aapqs; +aapqt; +aapqu; +aapqv; +aapqw; +aapqx; +aapqy; +aapqz; +aapra; +aaprb; +aaprc; +aaprd; +aapre; +aaprf; +aaprg; +aaprh; +aapri; +aaprj; +aaprk; +aaprl; +aaprm; +aaprn; +aapro; +aaprp; +aaprq; +aaprr; +aaprs; +aaprt; +aapru; +aaprv; +aaprw; +aaprx; +aapry; +aaprz; +aapsa; +aapsb; +aapsc; +aapsd; +aapse; +aapsf; +aapsg; +aapsh; +aapsi; +aapsj; +aapsk; +aapsl; +aapsm; +aapsn; +aapso; +aapsp; +aapsq; +aapsr; +aapss; +aapst; +aapsu; +aapsv; +aapsw; +aapsx; +aapsy; +aapsz; +aapta; +aaptb; +aaptc; +aaptd; +aapte; +aaptf; +aaptg; +aapth; +aapti; +aaptj; +aaptk; +aaptl; +aaptm; +aaptn; +aapto; +aaptp; +aaptq; +aaptr; +aapts; +aaptt; +aaptu; +aaptv; +aaptw; +aaptx; +aapty; +aaptz; +aapua; +aapub; +aapuc; +aapud; +aapue; +aapuf; +aapug; +aapuh; +aapui; +aapuj; +aapuk; +aapul; +aapum; +aapun; +aapuo; +aapup; +aapuq; +aapur; +aapus; +aaput; +aapuu; +aapuv; +aapuw; +aapux; +aapuy; +aapuz; +aapva; +aapvb; +aapvc; +aapvd; +aapve; +aapvf; +aapvg; +aapvh; +aapvi; +aapvj; +aapvk; +aapvl; +aapvm; +aapvn; +aapvo; +aapvp; +aapvq; +aapvr; +aapvs; +aapvt; +aapvu; +aapvv; +aapvw; +aapvx; +aapvy; +aapvz; +aapwa; +aapwb; +aapwc; +aapwd; +aapwe; +aapwf; +aapwg; +aapwh; +aapwi; +aapwj; +aapwk; +aapwl; +aapwm; +aapwn; +aapwo; +aapwp; +aapwq; +aapwr; +aapws; +aapwt; +aapwu; +aapwv; +aapww; +aapwx; +aapwy; +aapwz; +aapxa; +aapxb; +aapxc; +aapxd; +aapxe; +aapxf; +aapxg; +aapxh; +aapxi; +aapxj; +aapxk; +aapxl; +aapxm; +aapxn; +aapxo; +aapxp; +aapxq; +aapxr; +aapxs; +aapxt; +aapxu; +aapxv; +aapxw; +aapxx; +aapxy; +aapxz; +aapya; +aapyb; +aapyc; +aapyd; +aapye; +aapyf; +aapyg; +aapyh; +aapyi; +aapyj; +aapyk; +aapyl; +aapym; +aapyn; +aapyo; +aapyp; +aapyq; +aapyr; +aapys; +aapyt; +aapyu; +aapyv; +aapyw; +aapyx; +aapyy; +aapyz; +aapza; +aapzb; +aapzc; +aapzd; +aapze; +aapzf; +aapzg; +aapzh; +aapzi; +aapzj; +aapzk; +aapzl; +aapzm; +aapzn; +aapzo; +aapzp; +aapzq; +aapzr; +aapzs; +aapzt; +aapzu; +aapzv; +aapzw; +aapzx; +aapzy; +aapzz; +aaqaa; +aaqab; +aaqac; +aaqad; +aaqae; +aaqaf; +aaqag; +aaqah; +aaqai; +aaqaj; +aaqak; +aaqal; +aaqam; +aaqan; +aaqao; +aaqap; +aaqaq; +aaqar; +aaqas; +aaqat; +aaqau; +aaqav; +aaqaw; +aaqax; +aaqay; +aaqaz; +aaqba; +aaqbb; +aaqbc; +aaqbd; +aaqbe; +aaqbf; +aaqbg; +aaqbh; +aaqbi; +aaqbj; +aaqbk; +aaqbl; +aaqbm; +aaqbn; +aaqbo; +aaqbp; +aaqbq; +aaqbr; +aaqbs; +aaqbt; +aaqbu; +aaqbv; +aaqbw; +aaqbx; +aaqby; +aaqbz; +aaqca; +aaqcb; +aaqcc; +aaqcd; +aaqce; +aaqcf; +aaqcg; +aaqch; +aaqci; +aaqcj; +aaqck; +aaqcl; +aaqcm; +aaqcn; +aaqco; +aaqcp; +aaqcq; +aaqcr; +aaqcs; +aaqct; +aaqcu; +aaqcv; +aaqcw; +aaqcx; +aaqcy; +aaqcz; +aaqda; +aaqdb; +aaqdc; +aaqdd; +aaqde; +aaqdf; +aaqdg; +aaqdh; +aaqdi; +aaqdj; +aaqdk; +aaqdl; +aaqdm; +aaqdn; +aaqdo; +aaqdp; +aaqdq; +aaqdr; +aaqds; +aaqdt; +aaqdu; +aaqdv; +aaqdw; +aaqdx; +aaqdy; +aaqdz; +aaqea; +aaqeb; +aaqec; +aaqed; +aaqee; +aaqef; +aaqeg; +aaqeh; +aaqei; +aaqej; +aaqek; +aaqel; +aaqem; +aaqen; +aaqeo; +aaqep; +aaqeq; +aaqer; +aaqes; +aaqet; +aaqeu; +aaqev; +aaqew; +aaqex; +aaqey; +aaqez; +aaqfa; +aaqfb; +aaqfc; +aaqfd; +aaqfe; +aaqff; +aaqfg; +aaqfh; +aaqfi; +aaqfj; +aaqfk; +aaqfl; +aaqfm; +aaqfn; +aaqfo; +aaqfp; +aaqfq; +aaqfr; +aaqfs; +aaqft; +aaqfu; +aaqfv; +aaqfw; +aaqfx; +aaqfy; +aaqfz; +aaqga; +aaqgb; +aaqgc; +aaqgd; +aaqge; +aaqgf; +aaqgg; +aaqgh; +aaqgi; +aaqgj; +aaqgk; +aaqgl; +aaqgm; +aaqgn; +aaqgo; +aaqgp; +aaqgq; +aaqgr; +aaqgs; +aaqgt; +aaqgu; +aaqgv; +aaqgw; +aaqgx; +aaqgy; +aaqgz; +aaqha; +aaqhb; +aaqhc; +aaqhd; +aaqhe; +aaqhf; +aaqhg; +aaqhh; +aaqhi; +aaqhj; +aaqhk; +aaqhl; +aaqhm; +aaqhn; +aaqho; +aaqhp; +aaqhq; +aaqhr; +aaqhs; +aaqht; +aaqhu; +aaqhv; +aaqhw; +aaqhx; +aaqhy; +aaqhz; +aaqia; +aaqib; +aaqic; +aaqid; +aaqie; +aaqif; +aaqig; +aaqih; +aaqii; +aaqij; +aaqik; +aaqil; +aaqim; +aaqin; +aaqio; +aaqip; +aaqiq; +aaqir; +aaqis; +aaqit; +aaqiu; +aaqiv; +aaqiw; +aaqix; +aaqiy; +aaqiz; +aaqja; +aaqjb; +aaqjc; +aaqjd; +aaqje; +aaqjf; +aaqjg; +aaqjh; +aaqji; +aaqjj; +aaqjk; +aaqjl; +aaqjm; +aaqjn; +aaqjo; +aaqjp; +aaqjq; +aaqjr; +aaqjs; +aaqjt; +aaqju; +aaqjv; +aaqjw; +aaqjx; +aaqjy; +aaqjz; +aaqka; +aaqkb; +aaqkc; +aaqkd; +aaqke; +aaqkf; +aaqkg; +aaqkh; +aaqki; +aaqkj; +aaqkk; +aaqkl; +aaqkm; +aaqkn; +aaqko; +aaqkp; +aaqkq; +aaqkr; +aaqks; +aaqkt; +aaqku; +aaqkv; +aaqkw; +aaqkx; +aaqky; +aaqkz; +aaqla; +aaqlb; +aaqlc; +aaqld; +aaqle; +aaqlf; +aaqlg; +aaqlh; +aaqli; +aaqlj; +aaqlk; +aaqll; +aaqlm; +aaqln; +aaqlo; +aaqlp; +aaqlq; +aaqlr; +aaqls; +aaqlt; +aaqlu; +aaqlv; +aaqlw; +aaqlx; +aaqly; +aaqlz; +aaqma; +aaqmb; +aaqmc; +aaqmd; +aaqme; +aaqmf; +aaqmg; +aaqmh; +aaqmi; +aaqmj; +aaqmk; +aaqml; +aaqmm; +aaqmn; +aaqmo; +aaqmp; +aaqmq; +aaqmr; +aaqms; +aaqmt; +aaqmu; +aaqmv; +aaqmw; +aaqmx; +aaqmy; +aaqmz; +aaqna; +aaqnb; +aaqnc; +aaqnd; +aaqne; +aaqnf; +aaqng; +aaqnh; +aaqni; +aaqnj; +aaqnk; +aaqnl; +aaqnm; +aaqnn; +aaqno; +aaqnp; +aaqnq; +aaqnr; +aaqns; +aaqnt; +aaqnu; +aaqnv; +aaqnw; +aaqnx; +aaqny; +aaqnz; +aaqoa; +aaqob; +aaqoc; +aaqod; +aaqoe; +aaqof; +aaqog; +aaqoh; +aaqoi; +aaqoj; +aaqok; +aaqol; +aaqom; +aaqon; +aaqoo; +aaqop; +aaqoq; +aaqor; +aaqos; +aaqot; +aaqou; +aaqov; +aaqow; +aaqox; +aaqoy; +aaqoz; +aaqpa; +aaqpb; +aaqpc; +aaqpd; +aaqpe; +aaqpf; +aaqpg; +aaqph; +aaqpi; +aaqpj; +aaqpk; +aaqpl; +aaqpm; +aaqpn; +aaqpo; +aaqpp; +aaqpq; +aaqpr; +aaqps; +aaqpt; +aaqpu; +aaqpv; +aaqpw; +aaqpx; +aaqpy; +aaqpz; +aaqqa; +aaqqb; +aaqqc; +aaqqd; +aaqqe; +aaqqf; +aaqqg; +aaqqh; +aaqqi; +aaqqj; +aaqqk; +aaqql; +aaqqm; +aaqqn; +aaqqo; +aaqqp; +aaqqq; +aaqqr; +aaqqs; +aaqqt; +aaqqu; +aaqqv; +aaqqw; +aaqqx; +aaqqy; +aaqqz; +aaqra; +aaqrb; +aaqrc; +aaqrd; +aaqre; +aaqrf; +aaqrg; +aaqrh; +aaqri; +aaqrj; +aaqrk; +aaqrl; +aaqrm; +aaqrn; +aaqro; +aaqrp; +aaqrq; +aaqrr; +aaqrs; +aaqrt; +aaqru; +aaqrv; +aaqrw; +aaqrx; +aaqry; +aaqrz; +aaqsa; +aaqsb; +aaqsc; +aaqsd; +aaqse; +aaqsf; +aaqsg; +aaqsh; +aaqsi; +aaqsj; +aaqsk; +aaqsl; +aaqsm; +aaqsn; +aaqso; +aaqsp; +aaqsq; +aaqsr; +aaqss; +aaqst; +aaqsu; +aaqsv; +aaqsw; +aaqsx; +aaqsy; +aaqsz; +aaqta; +aaqtb; +aaqtc; +aaqtd; +aaqte; +aaqtf; +aaqtg; +aaqth; +aaqti; +aaqtj; +aaqtk; +aaqtl; +aaqtm; +aaqtn; +aaqto; +aaqtp; +aaqtq; +aaqtr; +aaqts; +aaqtt; +aaqtu; +aaqtv; +aaqtw; +aaqtx; +aaqty; +aaqtz; +aaqua; +aaqub; +aaquc; +aaqud; +aaque; +aaquf; +aaqug; +aaquh; +aaqui; +aaquj; +aaquk; +aaqul; +aaqum; +aaqun; +aaquo; +aaqup; +aaquq; +aaqur; +aaqus; +aaqut; +aaquu; +aaquv; +aaquw; +aaqux; +aaquy; +aaquz; +aaqva; +aaqvb; +aaqvc; +aaqvd; +aaqve; +aaqvf; +aaqvg; +aaqvh; +aaqvi; +aaqvj; +aaqvk; +aaqvl; +aaqvm; +aaqvn; +aaqvo; +aaqvp; +aaqvq; +aaqvr; +aaqvs; +aaqvt; +aaqvu; +aaqvv; +aaqvw; +aaqvx; +aaqvy; +aaqvz; +aaqwa; +aaqwb; +aaqwc; +aaqwd; +aaqwe; +aaqwf; +aaqwg; +aaqwh; +aaqwi; +aaqwj; +aaqwk; +aaqwl; +aaqwm; +aaqwn; +aaqwo; +aaqwp; +aaqwq; +aaqwr; +aaqws; +aaqwt; +aaqwu; +aaqwv; +aaqww; +aaqwx; +aaqwy; +aaqwz; +aaqxa; +aaqxb; +aaqxc; +aaqxd; +aaqxe; +aaqxf; +aaqxg; +aaqxh; +aaqxi; +aaqxj; +aaqxk; +aaqxl; +aaqxm; +aaqxn; +aaqxo; +aaqxp; +aaqxq; +aaqxr; +aaqxs; +aaqxt; +aaqxu; +aaqxv; +aaqxw; +aaqxx; +aaqxy; +aaqxz; +aaqya; +aaqyb; +aaqyc; +aaqyd; +aaqye; +aaqyf; +aaqyg; +aaqyh; +aaqyi; +aaqyj; +aaqyk; +aaqyl; +aaqym; +aaqyn; +aaqyo; +aaqyp; +aaqyq; +aaqyr; +aaqys; +aaqyt; +aaqyu; +aaqyv; +aaqyw; +aaqyx; +aaqyy; +aaqyz; +aaqza; +aaqzb; +aaqzc; +aaqzd; +aaqze; +aaqzf; +aaqzg; +aaqzh; +aaqzi; +aaqzj; +aaqzk; +aaqzl; +aaqzm; +aaqzn; +aaqzo; +aaqzp; +aaqzq; +aaqzr; +aaqzs; +aaqzt; +aaqzu; +aaqzv; +aaqzw; +aaqzx; +aaqzy; +aaqzz; +aaraa; +aarab; +aarac; +aarad; +aarae; +aaraf; +aarag; +aarah; +aarai; +aaraj; +aarak; +aaral; +aaram; +aaran; +aarao; +aarap; +aaraq; +aarar; +aaras; +aarat; +aarau; +aarav; +aaraw; +aarax; +aaray; +aaraz; +aarba; +aarbb; +aarbc; +aarbd; +aarbe; +aarbf; +aarbg; +aarbh; +aarbi; +aarbj; +aarbk; +aarbl; +aarbm; +aarbn; +aarbo; +aarbp; +aarbq; +aarbr; +aarbs; +aarbt; +aarbu; +aarbv; +aarbw; +aarbx; +aarby; +aarbz; +aarca; +aarcb; +aarcc; +aarcd; +aarce; +aarcf; +aarcg; +aarch; +aarci; +aarcj; +aarck; +aarcl; +aarcm; +aarcn; +aarco; +aarcp; +aarcq; +aarcr; +aarcs; +aarct; +aarcu; +aarcv; +aarcw; +aarcx; +aarcy; +aarcz; +aarda; +aardb; +aardc; +aardd; +aarde; +aardf; +aardg; +aardh; +aardi; +aardj; +aardk; +aardl; +aardm; +aardn; +aardo; +aardp; +aardq; +aardr; +aards; +aardt; +aardu; +aardv; +aardw; +aardx; +aardy; +aardz; +aarea; +aareb; +aarec; +aared; +aaree; +aaref; +aareg; +aareh; +aarei; +aarej; +aarek; +aarel; +aarem; +aaren; +aareo; +aarep; +aareq; +aarer; +aares; +aaret; +aareu; +aarev; +aarew; +aarex; +aarey; +aarez; +aarfa; +aarfb; +aarfc; +aarfd; +aarfe; +aarff; +aarfg; +aarfh; +aarfi; +aarfj; +aarfk; +aarfl; +aarfm; +aarfn; +aarfo; +aarfp; +aarfq; +aarfr; +aarfs; +aarft; +aarfu; +aarfv; +aarfw; +aarfx; +aarfy; +aarfz; +aarga; +aargb; +aargc; +aargd; +aarge; +aargf; +aargg; +aargh; +aargi; +aargj; +aargk; +aargl; +aargm; +aargn; +aargo; +aargp; +aargq; +aargr; +aargs; +aargt; +aargu; +aargv; +aargw; +aargx; +aargy; +aargz; +aarha; +aarhb; +aarhc; +aarhd; +aarhe; +aarhf; +aarhg; +aarhh; +aarhi; +aarhj; +aarhk; +aarhl; +aarhm; +aarhn; +aarho; +aarhp; +aarhq; +aarhr; +aarhs; +aarht; +aarhu; +aarhv; +aarhw; +aarhx; +aarhy; +aarhz; +aaria; +aarib; +aaric; +aarid; +aarie; +aarif; +aarig; +aarih; +aarii; +aarij; +aarik; +aaril; +aarim; +aarin; +aario; +aarip; +aariq; +aarir; +aaris; +aarit; +aariu; +aariv; +aariw; +aarix; +aariy; +aariz; +aarja; +aarjb; +aarjc; +aarjd; +aarje; +aarjf; +aarjg; +aarjh; +aarji; +aarjj; +aarjk; +aarjl; +aarjm; +aarjn; +aarjo; +aarjp; +aarjq; +aarjr; +aarjs; +aarjt; +aarju; +aarjv; +aarjw; +aarjx; +aarjy; +aarjz; +aarka; +aarkb; +aarkc; +aarkd; +aarke; +aarkf; +aarkg; +aarkh; +aarki; +aarkj; +aarkk; +aarkl; +aarkm; +aarkn; +aarko; +aarkp; +aarkq; +aarkr; +aarks; +aarkt; +aarku; +aarkv; +aarkw; +aarkx; +aarky; +aarkz; +aarla; +aarlb; +aarlc; +aarld; +aarle; +aarlf; +aarlg; +aarlh; +aarli; +aarlj; +aarlk; +aarll; +aarlm; +aarln; +aarlo; +aarlp; +aarlq; +aarlr; +aarls; +aarlt; +aarlu; +aarlv; +aarlw; +aarlx; +aarly; +aarlz; +aarma; +aarmb; +aarmc; +aarmd; +aarme; +aarmf; +aarmg; +aarmh; +aarmi; +aarmj; +aarmk; +aarml; +aarmm; +aarmn; +aarmo; +aarmp; +aarmq; +aarmr; +aarms; +aarmt; +aarmu; +aarmv; +aarmw; +aarmx; +aarmy; +aarmz; +aarna; +aarnb; +aarnc; +aarnd; +aarne; +aarnf; +aarng; +aarnh; +aarni; +aarnj; +aarnk; +aarnl; +aarnm; +aarnn; +aarno; +aarnp; +aarnq; +aarnr; +aarns; +aarnt; +aarnu; +aarnv; +aarnw; +aarnx; +aarny; +aarnz; +aaroa; +aarob; +aaroc; +aarod; +aaroe; +aarof; +aarog; +aaroh; +aaroi; +aaroj; +aarok; +aarol; +aarom; +aaron; +aaroo; +aarop; +aaroq; +aaror; +aaros; +aarot; +aarou; +aarov; +aarow; +aarox; +aaroy; +aaroz; +aarpa; +aarpb; +aarpc; +aarpd; +aarpe; +aarpf; +aarpg; +aarph; +aarpi; +aarpj; +aarpk; +aarpl; +aarpm; +aarpn; +aarpo; +aarpp; +aarpq; +aarpr; +aarps; +aarpt; +aarpu; +aarpv; +aarpw; +aarpx; +aarpy; +aarpz; +aarqa; +aarqb; +aarqc; +aarqd; +aarqe; +aarqf; +aarqg; +aarqh; +aarqi; +aarqj; +aarqk; +aarql; +aarqm; +aarqn; +aarqo; +aarqp; +aarqq; +aarqr; +aarqs; +aarqt; +aarqu; +aarqv; +aarqw; +aarqx; +aarqy; +aarqz; +aarra; +aarrb; +aarrc; +aarrd; +aarre; +aarrf; +aarrg; +aarrh; +aarri; +aarrj; +aarrk; +aarrl; +aarrm; +aarrn; +aarro; +aarrp; +aarrq; +aarrr; +aarrs; +aarrt; +aarru; +aarrv; +aarrw; +aarrx; +aarry; +aarrz; +aarsa; +aarsb; +aarsc; +aarsd; +aarse; +aarsf; +aarsg; +aarsh; +aarsi; +aarsj; +aarsk; +aarsl; +aarsm; +aarsn; +aarso; +aarsp; +aarsq; +aarsr; +aarss; +aarst; +aarsu; +aarsv; +aarsw; +aarsx; +aarsy; +aarsz; +aarta; +aartb; +aartc; +aartd; +aarte; +aartf; +aartg; +aarth; +aarti; +aartj; +aartk; +aartl; +aartm; +aartn; +aarto; +aartp; +aartq; +aartr; +aarts; +aartt; +aartu; +aartv; +aartw; +aartx; +aarty; +aartz; +aarua; +aarub; +aaruc; +aarud; +aarue; +aaruf; +aarug; +aaruh; +aarui; +aaruj; +aaruk; +aarul; +aarum; +aarun; +aaruo; +aarup; +aaruq; +aarur; +aarus; +aarut; +aaruu; +aaruv; +aaruw; +aarux; +aaruy; +aaruz; +aarva; +aarvb; +aarvc; +aarvd; +aarve; +aarvf; +aarvg; +aarvh; +aarvi; +aarvj; +aarvk; +aarvl; +aarvm; +aarvn; +aarvo; +aarvp; +aarvq; +aarvr; +aarvs; +aarvt; +aarvu; +aarvv; +aarvw; +aarvx; +aarvy; +aarvz; +aarwa; +aarwb; +aarwc; +aarwd; +aarwe; +aarwf; +aarwg; +aarwh; +aarwi; +aarwj; +aarwk; +aarwl; +aarwm; +aarwn; +aarwo; +aarwp; +aarwq; +aarwr; +aarws; +aarwt; +aarwu; +aarwv; +aarww; +aarwx; +aarwy; +aarwz; +aarxa; +aarxb; +aarxc; +aarxd; +aarxe; +aarxf; +aarxg; +aarxh; +aarxi; +aarxj; +aarxk; +aarxl; +aarxm; +aarxn; +aarxo; +aarxp; +aarxq; +aarxr; +aarxs; +aarxt; +aarxu; +aarxv; +aarxw; +aarxx; +aarxy; +aarxz; +aarya; +aaryb; +aaryc; +aaryd; +aarye; +aaryf; +aaryg; +aaryh; +aaryi; +aaryj; +aaryk; +aaryl; +aarym; +aaryn; +aaryo; +aaryp; +aaryq; +aaryr; +aarys; +aaryt; +aaryu; +aaryv; +aaryw; +aaryx; +aaryy; +aaryz; +aarza; +aarzb; +aarzc; +aarzd; +aarze; +aarzf; +aarzg; +aarzh; +aarzi; +aarzj; +aarzk; +aarzl; +aarzm; +aarzn; +aarzo; +aarzp; +aarzq; +aarzr; +aarzs; +aarzt; +aarzu; +aarzv; +aarzw; +aarzx; +aarzy; +aarzz; +aasaa; +aasab; +aasac; +aasad; +aasae; +aasaf; +aasag; +aasah; +aasai; +aasaj; +aasak; +aasal; +aasam; +aasan; +aasao; +aasap; +aasaq; +aasar; +aasas; +aasat; +aasau; +aasav; +aasaw; +aasax; +aasay; +aasaz; +aasba; +aasbb; +aasbc; +aasbd; +aasbe; +aasbf; +aasbg; +aasbh; +aasbi; +aasbj; +aasbk; +aasbl; +aasbm; +aasbn; +aasbo; +aasbp; +aasbq; +aasbr; +aasbs; +aasbt; +aasbu; +aasbv; +aasbw; +aasbx; +aasby; +aasbz; +aasca; +aascb; +aascc; +aascd; +aasce; +aascf; +aascg; +aasch; +aasci; +aascj; +aasck; +aascl; +aascm; +aascn; +aasco; +aascp; +aascq; +aascr; +aascs; +aasct; +aascu; +aascv; +aascw; +aascx; +aascy; +aascz; +aasda; +aasdb; +aasdc; +aasdd; +aasde; +aasdf; +aasdg; +aasdh; +aasdi; +aasdj; +aasdk; +aasdl; +aasdm; +aasdn; +aasdo; +aasdp; +aasdq; +aasdr; +aasds; +aasdt; +aasdu; +aasdv; +aasdw; +aasdx; +aasdy; +aasdz; +aasea; +aaseb; +aasec; +aased; +aasee; +aasef; +aaseg; +aaseh; +aasei; +aasej; +aasek; +aasel; +aasem; +aasen; +aaseo; +aasep; +aaseq; +aaser; +aases; +aaset; +aaseu; +aasev; +aasew; +aasex; +aasey; +aasez; +aasfa; +aasfb; +aasfc; +aasfd; +aasfe; +aasff; +aasfg; +aasfh; +aasfi; +aasfj; +aasfk; +aasfl; +aasfm; +aasfn; +aasfo; +aasfp; +aasfq; +aasfr; +aasfs; +aasft; +aasfu; +aasfv; +aasfw; +aasfx; +aasfy; +aasfz; +aasga; +aasgb; +aasgc; +aasgd; +aasge; +aasgf; +aasgg; +aasgh; +aasgi; +aasgj; +aasgk; +aasgl; +aasgm; +aasgn; +aasgo; +aasgp; +aasgq; +aasgr; +aasgs; +aasgt; +aasgu; +aasgv; +aasgw; +aasgx; +aasgy; +aasgz; +aasha; +aashb; +aashc; +aashd; +aashe; +aashf; +aashg; +aashh; +aashi; +aashj; +aashk; +aashl; +aashm; +aashn; +aasho; +aashp; +aashq; +aashr; +aashs; +aasht; +aashu; +aashv; +aashw; +aashx; +aashy; +aashz; +aasia; +aasib; +aasic; +aasid; +aasie; +aasif; +aasig; +aasih; +aasii; +aasij; +aasik; +aasil; +aasim; +aasin; +aasio; +aasip; +aasiq; +aasir; +aasis; +aasit; +aasiu; +aasiv; +aasiw; +aasix; +aasiy; +aasiz; +aasja; +aasjb; +aasjc; +aasjd; +aasje; +aasjf; +aasjg; +aasjh; +aasji; +aasjj; +aasjk; +aasjl; +aasjm; +aasjn; +aasjo; +aasjp; +aasjq; +aasjr; +aasjs; +aasjt; +aasju; +aasjv; +aasjw; +aasjx; +aasjy; +aasjz; +aaska; +aaskb; +aaskc; +aaskd; +aaske; +aaskf; +aaskg; +aaskh; +aaski; +aaskj; +aaskk; +aaskl; +aaskm; +aaskn; +aasko; +aaskp; +aaskq; +aaskr; +aasks; +aaskt; +aasku; +aaskv; +aaskw; +aaskx; +aasky; +aaskz; +aasla; +aaslb; +aaslc; +aasld; +aasle; +aaslf; +aaslg; +aaslh; +aasli; +aaslj; +aaslk; +aasll; +aaslm; +aasln; +aaslo; +aaslp; +aaslq; +aaslr; +aasls; +aaslt; +aaslu; +aaslv; +aaslw; +aaslx; +aasly; +aaslz; +aasma; +aasmb; +aasmc; +aasmd; +aasme; +aasmf; +aasmg; +aasmh; +aasmi; +aasmj; +aasmk; +aasml; +aasmm; +aasmn; +aasmo; +aasmp; +aasmq; +aasmr; +aasms; +aasmt; +aasmu; +aasmv; +aasmw; +aasmx; +aasmy; +aasmz; +aasna; +aasnb; +aasnc; +aasnd; +aasne; +aasnf; +aasng; +aasnh; +aasni; +aasnj; +aasnk; +aasnl; +aasnm; +aasnn; +aasno; +aasnp; +aasnq; +aasnr; +aasns; +aasnt; +aasnu; +aasnv; +aasnw; +aasnx; +aasny; +aasnz; +aasoa; +aasob; +aasoc; +aasod; +aasoe; +aasof; +aasog; +aasoh; +aasoi; +aasoj; +aasok; +aasol; +aasom; +aason; +aasoo; +aasop; +aasoq; +aasor; +aasos; +aasot; +aasou; +aasov; +aasow; +aasox; +aasoy; +aasoz; +aaspa; +aaspb; +aaspc; +aaspd; +aaspe; +aaspf; +aaspg; +aasph; +aaspi; +aaspj; +aaspk; +aaspl; +aaspm; +aaspn; +aaspo; +aaspp; +aaspq; +aaspr; +aasps; +aaspt; +aaspu; +aaspv; +aaspw; +aaspx; +aaspy; +aaspz; +aasqa; +aasqb; +aasqc; +aasqd; +aasqe; +aasqf; +aasqg; +aasqh; +aasqi; +aasqj; +aasqk; +aasql; +aasqm; +aasqn; +aasqo; +aasqp; +aasqq; +aasqr; +aasqs; +aasqt; +aasqu; +aasqv; +aasqw; +aasqx; +aasqy; +aasqz; +aasra; +aasrb; +aasrc; +aasrd; +aasre; +aasrf; +aasrg; +aasrh; +aasri; +aasrj; +aasrk; +aasrl; +aasrm; +aasrn; +aasro; +aasrp; +aasrq; +aasrr; +aasrs; +aasrt; +aasru; +aasrv; +aasrw; +aasrx; +aasry; +aasrz; +aassa; +aassb; +aassc; +aassd; +aasse; +aassf; +aassg; +aassh; +aassi; +aassj; +aassk; +aassl; +aassm; +aassn; +aasso; +aassp; +aassq; +aassr; +aasss; +aasst; +aassu; +aassv; +aassw; +aassx; +aassy; +aassz; +aasta; +aastb; +aastc; +aastd; +aaste; +aastf; +aastg; +aasth; +aasti; +aastj; +aastk; +aastl; +aastm; +aastn; +aasto; +aastp; +aastq; +aastr; +aasts; +aastt; +aastu; +aastv; +aastw; +aastx; +aasty; +aastz; +aasua; +aasub; +aasuc; +aasud; +aasue; +aasuf; +aasug; +aasuh; +aasui; +aasuj; +aasuk; +aasul; +aasum; +aasun; +aasuo; +aasup; +aasuq; +aasur; +aasus; +aasut; +aasuu; +aasuv; +aasuw; +aasux; +aasuy; +aasuz; +aasva; +aasvb; +aasvc; +aasvd; +aasve; +aasvf; +aasvg; +aasvh; +aasvi; +aasvj; +aasvk; +aasvl; +aasvm; +aasvn; +aasvo; +aasvp; +aasvq; +aasvr; +aasvs; +aasvt; +aasvu; +aasvv; +aasvw; +aasvx; +aasvy; +aasvz; +aaswa; +aaswb; +aaswc; +aaswd; +aaswe; +aaswf; +aaswg; +aaswh; +aaswi; +aaswj; +aaswk; +aaswl; +aaswm; +aaswn; +aaswo; +aaswp; +aaswq; +aaswr; +aasws; +aaswt; +aaswu; +aaswv; +aasww; +aaswx; +aaswy; +aaswz; +aasxa; +aasxb; +aasxc; +aasxd; +aasxe; +aasxf; +aasxg; +aasxh; +aasxi; +aasxj; +aasxk; +aasxl; +aasxm; +aasxn; +aasxo; +aasxp; +aasxq; +aasxr; +aasxs; +aasxt; +aasxu; +aasxv; +aasxw; +aasxx; +aasxy; +aasxz; +aasya; +aasyb; +aasyc; +aasyd; +aasye; +aasyf; +aasyg; +aasyh; +aasyi; +aasyj; +aasyk; +aasyl; +aasym; +aasyn; +aasyo; +aasyp; +aasyq; +aasyr; +aasys; +aasyt; +aasyu; +aasyv; +aasyw; +aasyx; +aasyy; +aasyz; +aasza; +aaszb; +aaszc; +aaszd; +aasze; +aaszf; +aaszg; +aaszh; +aaszi; +aaszj; +aaszk; +aaszl; +aaszm; +aaszn; +aaszo; +aaszp; +aaszq; +aaszr; +aaszs; +aaszt; +aaszu; +aaszv; +aaszw; +aaszx; +aaszy; +aaszz; +aataa; +aatab; +aatac; +aatad; +aatae; +aataf; +aatag; +aatah; +aatai; +aataj; +aatak; +aatal; +aatam; +aatan; +aatao; +aatap; +aataq; +aatar; +aatas; +aatat; +aatau; +aatav; +aataw; +aatax; +aatay; +aataz; +aatba; +aatbb; +aatbc; +aatbd; +aatbe; +aatbf; +aatbg; +aatbh; +aatbi; +aatbj; +aatbk; +aatbl; +aatbm; +aatbn; +aatbo; +aatbp; +aatbq; +aatbr; +aatbs; +aatbt; +aatbu; +aatbv; +aatbw; +aatbx; +aatby; +aatbz; +aatca; +aatcb; +aatcc; +aatcd; +aatce; +aatcf; +aatcg; +aatch; +aatci; +aatcj; +aatck; +aatcl; +aatcm; +aatcn; +aatco; +aatcp; +aatcq; +aatcr; +aatcs; +aatct; +aatcu; +aatcv; +aatcw; +aatcx; +aatcy; +aatcz; +aatda; +aatdb; +aatdc; +aatdd; +aatde; +aatdf; +aatdg; +aatdh; +aatdi; +aatdj; +aatdk; +aatdl; +aatdm; +aatdn; +aatdo; +aatdp; +aatdq; +aatdr; +aatds; +aatdt; +aatdu; +aatdv; +aatdw; +aatdx; +aatdy; +aatdz; +aatea; +aateb; +aatec; +aated; +aatee; +aatef; +aateg; +aateh; +aatei; +aatej; +aatek; +aatel; +aatem; +aaten; +aateo; +aatep; +aateq; +aater; +aates; +aatet; +aateu; +aatev; +aatew; +aatex; +aatey; +aatez; +aatfa; +aatfb; +aatfc; +aatfd; +aatfe; +aatff; +aatfg; +aatfh; +aatfi; +aatfj; +aatfk; +aatfl; +aatfm; +aatfn; +aatfo; +aatfp; +aatfq; +aatfr; +aatfs; +aatft; +aatfu; +aatfv; +aatfw; +aatfx; +aatfy; +aatfz; +aatga; +aatgb; +aatgc; +aatgd; +aatge; +aatgf; +aatgg; +aatgh; +aatgi; +aatgj; +aatgk; +aatgl; +aatgm; +aatgn; +aatgo; +aatgp; +aatgq; +aatgr; +aatgs; +aatgt; +aatgu; +aatgv; +aatgw; +aatgx; +aatgy; +aatgz; +aatha; +aathb; +aathc; +aathd; +aathe; +aathf; +aathg; +aathh; +aathi; +aathj; +aathk; +aathl; +aathm; +aathn; +aatho; +aathp; +aathq; +aathr; +aaths; +aatht; +aathu; +aathv; +aathw; +aathx; +aathy; +aathz; +aatia; +aatib; +aatic; +aatid; +aatie; +aatif; +aatig; +aatih; +aatii; +aatij; +aatik; +aatil; +aatim; +aatin; +aatio; +aatip; +aatiq; +aatir; +aatis; +aatit; +aatiu; +aativ; +aatiw; +aatix; +aatiy; +aatiz; +aatja; +aatjb; +aatjc; +aatjd; +aatje; +aatjf; +aatjg; +aatjh; +aatji; +aatjj; +aatjk; +aatjl; +aatjm; +aatjn; +aatjo; +aatjp; +aatjq; +aatjr; +aatjs; +aatjt; +aatju; +aatjv; +aatjw; +aatjx; +aatjy; +aatjz; +aatka; +aatkb; +aatkc; +aatkd; +aatke; +aatkf; +aatkg; +aatkh; +aatki; +aatkj; +aatkk; +aatkl; +aatkm; +aatkn; +aatko; +aatkp; +aatkq; +aatkr; +aatks; +aatkt; +aatku; +aatkv; +aatkw; +aatkx; +aatky; +aatkz; +aatla; +aatlb; +aatlc; +aatld; +aatle; +aatlf; +aatlg; +aatlh; +aatli; +aatlj; +aatlk; +aatll; +aatlm; +aatln; +aatlo; +aatlp; +aatlq; +aatlr; +aatls; +aatlt; +aatlu; +aatlv; +aatlw; +aatlx; +aatly; +aatlz; +aatma; +aatmb; +aatmc; +aatmd; +aatme; +aatmf; +aatmg; +aatmh; +aatmi; +aatmj; +aatmk; +aatml; +aatmm; +aatmn; +aatmo; +aatmp; +aatmq; +aatmr; +aatms; +aatmt; +aatmu; +aatmv; +aatmw; +aatmx; +aatmy; +aatmz; +aatna; +aatnb; +aatnc; +aatnd; +aatne; +aatnf; +aatng; +aatnh; +aatni; +aatnj; +aatnk; +aatnl; +aatnm; +aatnn; +aatno; +aatnp; +aatnq; +aatnr; +aatns; +aatnt; +aatnu; +aatnv; +aatnw; +aatnx; +aatny; +aatnz; +aatoa; +aatob; +aatoc; +aatod; +aatoe; +aatof; +aatog; +aatoh; +aatoi; +aatoj; +aatok; +aatol; +aatom; +aaton; +aatoo; +aatop; +aatoq; +aator; +aatos; +aatot; +aatou; +aatov; +aatow; +aatox; +aatoy; +aatoz; +aatpa; +aatpb; +aatpc; +aatpd; +aatpe; +aatpf; +aatpg; +aatph; +aatpi; +aatpj; +aatpk; +aatpl; +aatpm; +aatpn; +aatpo; +aatpp; +aatpq; +aatpr; +aatps; +aatpt; +aatpu; +aatpv; +aatpw; +aatpx; +aatpy; +aatpz; +aatqa; +aatqb; +aatqc; +aatqd; +aatqe; +aatqf; +aatqg; +aatqh; +aatqi; +aatqj; +aatqk; +aatql; +aatqm; +aatqn; +aatqo; +aatqp; +aatqq; +aatqr; +aatqs; +aatqt; +aatqu; +aatqv; +aatqw; +aatqx; +aatqy; +aatqz; +aatra; +aatrb; +aatrc; +aatrd; +aatre; +aatrf; +aatrg; +aatrh; +aatri; +aatrj; +aatrk; +aatrl; +aatrm; +aatrn; +aatro; +aatrp; +aatrq; +aatrr; +aatrs; +aatrt; +aatru; +aatrv; +aatrw; +aatrx; +aatry; +aatrz; +aatsa; +aatsb; +aatsc; +aatsd; +aatse; +aatsf; +aatsg; +aatsh; +aatsi; +aatsj; +aatsk; +aatsl; +aatsm; +aatsn; +aatso; +aatsp; +aatsq; +aatsr; +aatss; +aatst; +aatsu; +aatsv; +aatsw; +aatsx; +aatsy; +aatsz; +aatta; +aattb; +aattc; +aattd; +aatte; +aattf; +aattg; +aatth; +aatti; +aattj; +aattk; +aattl; +aattm; +aattn; +aatto; +aattp; +aattq; +aattr; +aatts; +aattt; +aattu; +aattv; +aattw; +aattx; +aatty; +aattz; +aatua; +aatub; +aatuc; +aatud; +aatue; +aatuf; +aatug; +aatuh; +aatui; +aatuj; +aatuk; +aatul; +aatum; +aatun; +aatuo; +aatup; +aatuq; +aatur; +aatus; +aatut; +aatuu; +aatuv; +aatuw; +aatux; +aatuy; +aatuz; +aatva; +aatvb; +aatvc; +aatvd; +aatve; +aatvf; +aatvg; +aatvh; +aatvi; +aatvj; +aatvk; +aatvl; +aatvm; +aatvn; +aatvo; +aatvp; +aatvq; +aatvr; +aatvs; +aatvt; +aatvu; +aatvv; +aatvw; +aatvx; +aatvy; +aatvz; +aatwa; +aatwb; +aatwc; +aatwd; +aatwe; +aatwf; +aatwg; +aatwh; +aatwi; +aatwj; +aatwk; +aatwl; +aatwm; +aatwn; +aatwo; +aatwp; +aatwq; +aatwr; +aatws; +aatwt; +aatwu; +aatwv; +aatww; +aatwx; +aatwy; +aatwz; +aatxa; +aatxb; +aatxc; +aatxd; +aatxe; +aatxf; +aatxg; +aatxh; +aatxi; +aatxj; +aatxk; +aatxl; +aatxm; +aatxn; +aatxo; +aatxp; +aatxq; +aatxr; +aatxs; +aatxt; +aatxu; +aatxv; +aatxw; +aatxx; +aatxy; +aatxz; +aatya; +aatyb; +aatyc; +aatyd; +aatye; +aatyf; +aatyg; +aatyh; +aatyi; +aatyj; +aatyk; +aatyl; +aatym; +aatyn; +aatyo; +aatyp; +aatyq; +aatyr; +aatys; +aatyt; +aatyu; +aatyv; +aatyw; +aatyx; +aatyy; +aatyz; +aatza; +aatzb; +aatzc; +aatzd; +aatze; +aatzf; +aatzg; +aatzh; +aatzi; +aatzj; +aatzk; +aatzl; +aatzm; +aatzn; +aatzo; +aatzp; +aatzq; +aatzr; +aatzs; +aatzt; +aatzu; +aatzv; +aatzw; +aatzx; +aatzy; +aatzz; +aauaa; +aauab; +aauac; +aauad; +aauae; +aauaf; +aauag; +aauah; +aauai; +aauaj; +aauak; +aaual; +aauam; +aauan; +aauao; +aauap; +aauaq; +aauar; +aauas; +aauat; +aauau; +aauav; +aauaw; +aauax; +aauay; +aauaz; +aauba; +aaubb; +aaubc; +aaubd; +aaube; +aaubf; +aaubg; +aaubh; +aaubi; +aaubj; +aaubk; +aaubl; +aaubm; +aaubn; +aaubo; +aaubp; +aaubq; +aaubr; +aaubs; +aaubt; +aaubu; +aaubv; +aaubw; +aaubx; +aauby; +aaubz; +aauca; +aaucb; +aaucc; +aaucd; +aauce; +aaucf; +aaucg; +aauch; +aauci; +aaucj; +aauck; +aaucl; +aaucm; +aaucn; +aauco; +aaucp; +aaucq; +aaucr; +aaucs; +aauct; +aaucu; +aaucv; +aaucw; +aaucx; +aaucy; +aaucz; +aauda; +aaudb; +aaudc; +aaudd; +aaude; +aaudf; +aaudg; +aaudh; +aaudi; +aaudj; +aaudk; +aaudl; +aaudm; +aaudn; +aaudo; +aaudp; +aaudq; +aaudr; +aauds; +aaudt; +aaudu; +aaudv; +aaudw; +aaudx; +aaudy; +aaudz; +aauea; +aaueb; +aauec; +aaued; +aauee; +aauef; +aaueg; +aaueh; +aauei; +aauej; +aauek; +aauel; +aauem; +aauen; +aaueo; +aauep; +aaueq; +aauer; +aaues; +aauet; +aaueu; +aauev; +aauew; +aauex; +aauey; +aauez; +aaufa; +aaufb; +aaufc; +aaufd; +aaufe; +aauff; +aaufg; +aaufh; +aaufi; +aaufj; +aaufk; +aaufl; +aaufm; +aaufn; +aaufo; +aaufp; +aaufq; +aaufr; +aaufs; +aauft; +aaufu; +aaufv; +aaufw; +aaufx; +aaufy; +aaufz; +aauga; +aaugb; +aaugc; +aaugd; +aauge; +aaugf; +aaugg; +aaugh; +aaugi; +aaugj; +aaugk; +aaugl; +aaugm; +aaugn; +aaugo; +aaugp; +aaugq; +aaugr; +aaugs; +aaugt; +aaugu; +aaugv; +aaugw; +aaugx; +aaugy; +aaugz; +aauha; +aauhb; +aauhc; +aauhd; +aauhe; +aauhf; +aauhg; +aauhh; +aauhi; +aauhj; +aauhk; +aauhl; +aauhm; +aauhn; +aauho; +aauhp; +aauhq; +aauhr; +aauhs; +aauht; +aauhu; +aauhv; +aauhw; +aauhx; +aauhy; +aauhz; +aauia; +aauib; +aauic; +aauid; +aauie; +aauif; +aauig; +aauih; +aauii; +aauij; +aauik; +aauil; +aauim; +aauin; +aauio; +aauip; +aauiq; +aauir; +aauis; +aauit; +aauiu; +aauiv; +aauiw; +aauix; +aauiy; +aauiz; +aauja; +aaujb; +aaujc; +aaujd; +aauje; +aaujf; +aaujg; +aaujh; +aauji; +aaujj; +aaujk; +aaujl; +aaujm; +aaujn; +aaujo; +aaujp; +aaujq; +aaujr; +aaujs; +aaujt; +aauju; +aaujv; +aaujw; +aaujx; +aaujy; +aaujz; +aauka; +aaukb; +aaukc; +aaukd; +aauke; +aaukf; +aaukg; +aaukh; +aauki; +aaukj; +aaukk; +aaukl; +aaukm; +aaukn; +aauko; +aaukp; +aaukq; +aaukr; +aauks; +aaukt; +aauku; +aaukv; +aaukw; +aaukx; +aauky; +aaukz; +aaula; +aaulb; +aaulc; +aauld; +aaule; +aaulf; +aaulg; +aaulh; +aauli; +aaulj; +aaulk; +aaull; +aaulm; +aauln; +aaulo; +aaulp; +aaulq; +aaulr; +aauls; +aault; +aaulu; +aaulv; +aaulw; +aaulx; +aauly; +aaulz; +aauma; +aaumb; +aaumc; +aaumd; +aaume; +aaumf; +aaumg; +aaumh; +aaumi; +aaumj; +aaumk; +aauml; +aaumm; +aaumn; +aaumo; +aaump; +aaumq; +aaumr; +aaums; +aaumt; +aaumu; +aaumv; +aaumw; +aaumx; +aaumy; +aaumz; +aauna; +aaunb; +aaunc; +aaund; +aaune; +aaunf; +aaung; +aaunh; +aauni; +aaunj; +aaunk; +aaunl; +aaunm; +aaunn; +aauno; +aaunp; +aaunq; +aaunr; +aauns; +aaunt; +aaunu; +aaunv; +aaunw; +aaunx; +aauny; +aaunz; +aauoa; +aauob; +aauoc; +aauod; +aauoe; +aauof; +aauog; +aauoh; +aauoi; +aauoj; +aauok; +aauol; +aauom; +aauon; +aauoo; +aauop; +aauoq; +aauor; +aauos; +aauot; +aauou; +aauov; +aauow; +aauox; +aauoy; +aauoz; +aaupa; +aaupb; +aaupc; +aaupd; +aaupe; +aaupf; +aaupg; +aauph; +aaupi; +aaupj; +aaupk; +aaupl; +aaupm; +aaupn; +aaupo; +aaupp; +aaupq; +aaupr; +aaups; +aaupt; +aaupu; +aaupv; +aaupw; +aaupx; +aaupy; +aaupz; +aauqa; +aauqb; +aauqc; +aauqd; +aauqe; +aauqf; +aauqg; +aauqh; +aauqi; +aauqj; +aauqk; +aauql; +aauqm; +aauqn; +aauqo; +aauqp; +aauqq; +aauqr; +aauqs; +aauqt; +aauqu; +aauqv; +aauqw; +aauqx; +aauqy; +aauqz; +aaura; +aaurb; +aaurc; +aaurd; +aaure; +aaurf; +aaurg; +aaurh; +aauri; +aaurj; +aaurk; +aaurl; +aaurm; +aaurn; +aauro; +aaurp; +aaurq; +aaurr; +aaurs; +aaurt; +aauru; +aaurv; +aaurw; +aaurx; +aaury; +aaurz; +aausa; +aausb; +aausc; +aausd; +aause; +aausf; +aausg; +aaush; +aausi; +aausj; +aausk; +aausl; +aausm; +aausn; +aauso; +aausp; +aausq; +aausr; +aauss; +aaust; +aausu; +aausv; +aausw; +aausx; +aausy; +aausz; +aauta; +aautb; +aautc; +aautd; +aaute; +aautf; +aautg; +aauth; +aauti; +aautj; +aautk; +aautl; +aautm; +aautn; +aauto; +aautp; +aautq; +aautr; +aauts; +aautt; +aautu; +aautv; +aautw; +aautx; +aauty; +aautz; +aauua; +aauub; +aauuc; +aauud; +aauue; +aauuf; +aauug; +aauuh; +aauui; +aauuj; +aauuk; +aauul; +aauum; +aauun; +aauuo; +aauup; +aauuq; +aauur; +aauus; +aauut; +aauuu; +aauuv; +aauuw; +aauux; +aauuy; +aauuz; +aauva; +aauvb; +aauvc; +aauvd; +aauve; +aauvf; +aauvg; +aauvh; +aauvi; +aauvj; +aauvk; +aauvl; +aauvm; +aauvn; +aauvo; +aauvp; +aauvq; +aauvr; +aauvs; +aauvt; +aauvu; +aauvv; +aauvw; +aauvx; +aauvy; +aauvz; +aauwa; +aauwb; +aauwc; +aauwd; +aauwe; +aauwf; +aauwg; +aauwh; +aauwi; +aauwj; +aauwk; +aauwl; +aauwm; +aauwn; +aauwo; +aauwp; +aauwq; +aauwr; +aauws; +aauwt; +aauwu; +aauwv; +aauww; +aauwx; +aauwy; +aauwz; +aauxa; +aauxb; +aauxc; +aauxd; +aauxe; +aauxf; +aauxg; +aauxh; +aauxi; +aauxj; +aauxk; +aauxl; +aauxm; +aauxn; +aauxo; +aauxp; +aauxq; +aauxr; +aauxs; +aauxt; +aauxu; +aauxv; +aauxw; +aauxx; +aauxy; +aauxz; +aauya; +aauyb; +aauyc; +aauyd; +aauye; +aauyf; +aauyg; +aauyh; +aauyi; +aauyj; +aauyk; +aauyl; +aauym; +aauyn; +aauyo; +aauyp; +aauyq; +aauyr; +aauys; +aauyt; +aauyu; +aauyv; +aauyw; +aauyx; +aauyy; +aauyz; +aauza; +aauzb; +aauzc; +aauzd; +aauze; +aauzf; +aauzg; +aauzh; +aauzi; +aauzj; +aauzk; +aauzl; +aauzm; +aauzn; +aauzo; +aauzp; +aauzq; +aauzr; +aauzs; +aauzt; +aauzu; +aauzv; +aauzw; +aauzx; +aauzy; +aauzz; +aavaa; +aavab; +aavac; +aavad; +aavae; +aavaf; +aavag; +aavah; +aavai; +aavaj; +aavak; +aaval; +aavam; +aavan; +aavao; +aavap; +aavaq; +aavar; +aavas; +aavat; +aavau; +aavav; +aavaw; +aavax; +aavay; +aavaz; +aavba; +aavbb; +aavbc; +aavbd; +aavbe; +aavbf; +aavbg; +aavbh; +aavbi; +aavbj; +aavbk; +aavbl; +aavbm; +aavbn; +aavbo; +aavbp; +aavbq; +aavbr; +aavbs; +aavbt; +aavbu; +aavbv; +aavbw; +aavbx; +aavby; +aavbz; +aavca; +aavcb; +aavcc; +aavcd; +aavce; +aavcf; +aavcg; +aavch; +aavci; +aavcj; +aavck; +aavcl; +aavcm; +aavcn; +aavco; +aavcp; +aavcq; +aavcr; +aavcs; +aavct; +aavcu; +aavcv; +aavcw; +aavcx; +aavcy; +aavcz; +aavda; +aavdb; +aavdc; +aavdd; +aavde; +aavdf; +aavdg; +aavdh; +aavdi; +aavdj; +aavdk; +aavdl; +aavdm; +aavdn; +aavdo; +aavdp; +aavdq; +aavdr; +aavds; +aavdt; +aavdu; +aavdv; +aavdw; +aavdx; +aavdy; +aavdz; +aavea; +aaveb; +aavec; +aaved; +aavee; +aavef; +aaveg; +aaveh; +aavei; +aavej; +aavek; +aavel; +aavem; +aaven; +aaveo; +aavep; +aaveq; +aaver; +aaves; +aavet; +aaveu; +aavev; +aavew; +aavex; +aavey; +aavez; +aavfa; +aavfb; +aavfc; +aavfd; +aavfe; +aavff; +aavfg; +aavfh; +aavfi; +aavfj; +aavfk; +aavfl; +aavfm; +aavfn; +aavfo; +aavfp; +aavfq; +aavfr; +aavfs; +aavft; +aavfu; +aavfv; +aavfw; +aavfx; +aavfy; +aavfz; +aavga; +aavgb; +aavgc; +aavgd; +aavge; +aavgf; +aavgg; +aavgh; +aavgi; +aavgj; +aavgk; +aavgl; +aavgm; +aavgn; +aavgo; +aavgp; +aavgq; +aavgr; +aavgs; +aavgt; +aavgu; +aavgv; +aavgw; +aavgx; +aavgy; +aavgz; +aavha; +aavhb; +aavhc; +aavhd; +aavhe; +aavhf; +aavhg; +aavhh; +aavhi; +aavhj; +aavhk; +aavhl; +aavhm; +aavhn; +aavho; +aavhp; +aavhq; +aavhr; +aavhs; +aavht; +aavhu; +aavhv; +aavhw; +aavhx; +aavhy; +aavhz; +aavia; +aavib; +aavic; +aavid; +aavie; +aavif; +aavig; +aavih; +aavii; +aavij; +aavik; +aavil; +aavim; +aavin; +aavio; +aavip; +aaviq; +aavir; +aavis; +aavit; +aaviu; +aaviv; +aaviw; +aavix; +aaviy; +aaviz; +aavja; +aavjb; +aavjc; +aavjd; +aavje; +aavjf; +aavjg; +aavjh; +aavji; +aavjj; +aavjk; +aavjl; +aavjm; +aavjn; +aavjo; +aavjp; +aavjq; +aavjr; +aavjs; +aavjt; +aavju; +aavjv; +aavjw; +aavjx; +aavjy; +aavjz; +aavka; +aavkb; +aavkc; +aavkd; +aavke; +aavkf; +aavkg; +aavkh; +aavki; +aavkj; +aavkk; +aavkl; +aavkm; +aavkn; +aavko; +aavkp; +aavkq; +aavkr; +aavks; +aavkt; +aavku; +aavkv; +aavkw; +aavkx; +aavky; +aavkz; +aavla; +aavlb; +aavlc; +aavld; +aavle; +aavlf; +aavlg; +aavlh; +aavli; +aavlj; +aavlk; +aavll; +aavlm; +aavln; +aavlo; +aavlp; +aavlq; +aavlr; +aavls; +aavlt; +aavlu; +aavlv; +aavlw; +aavlx; +aavly; +aavlz; +aavma; +aavmb; +aavmc; +aavmd; +aavme; +aavmf; +aavmg; +aavmh; +aavmi; +aavmj; +aavmk; +aavml; +aavmm; +aavmn; +aavmo; +aavmp; +aavmq; +aavmr; +aavms; +aavmt; +aavmu; +aavmv; +aavmw; +aavmx; +aavmy; +aavmz; +aavna; +aavnb; +aavnc; +aavnd; +aavne; +aavnf; +aavng; +aavnh; +aavni; +aavnj; +aavnk; +aavnl; +aavnm; +aavnn; +aavno; +aavnp; +aavnq; +aavnr; +aavns; +aavnt; +aavnu; +aavnv; +aavnw; +aavnx; +aavny; +aavnz; +aavoa; +aavob; +aavoc; +aavod; +aavoe; +aavof; +aavog; +aavoh; +aavoi; +aavoj; +aavok; +aavol; +aavom; +aavon; +aavoo; +aavop; +aavoq; +aavor; +aavos; +aavot; +aavou; +aavov; +aavow; +aavox; +aavoy; +aavoz; +aavpa; +aavpb; +aavpc; +aavpd; +aavpe; +aavpf; +aavpg; +aavph; +aavpi; +aavpj; +aavpk; +aavpl; +aavpm; +aavpn; +aavpo; +aavpp; +aavpq; +aavpr; +aavps; +aavpt; +aavpu; +aavpv; +aavpw; +aavpx; +aavpy; +aavpz; +aavqa; +aavqb; +aavqc; +aavqd; +aavqe; +aavqf; +aavqg; +aavqh; +aavqi; +aavqj; +aavqk; +aavql; +aavqm; +aavqn; +aavqo; +aavqp; +aavqq; +aavqr; +aavqs; +aavqt; +aavqu; +aavqv; +aavqw; +aavqx; +aavqy; +aavqz; +aavra; +aavrb; +aavrc; +aavrd; +aavre; +aavrf; +aavrg; +aavrh; +aavri; +aavrj; +aavrk; +aavrl; +aavrm; +aavrn; +aavro; +aavrp; +aavrq; +aavrr; +aavrs; +aavrt; +aavru; +aavrv; +aavrw; +aavrx; +aavry; +aavrz; +aavsa; +aavsb; +aavsc; +aavsd; +aavse; +aavsf; +aavsg; +aavsh; +aavsi; +aavsj; +aavsk; +aavsl; +aavsm; +aavsn; +aavso; +aavsp; +aavsq; +aavsr; +aavss; +aavst; +aavsu; +aavsv; +aavsw; +aavsx; +aavsy; +aavsz; +aavta; +aavtb; +aavtc; +aavtd; +aavte; +aavtf; +aavtg; +aavth; +aavti; +aavtj; +aavtk; +aavtl; +aavtm; +aavtn; +aavto; +aavtp; +aavtq; +aavtr; +aavts; +aavtt; +aavtu; +aavtv; +aavtw; +aavtx; +aavty; +aavtz; +aavua; +aavub; +aavuc; +aavud; +aavue; +aavuf; +aavug; +aavuh; +aavui; +aavuj; +aavuk; +aavul; +aavum; +aavun; +aavuo; +aavup; +aavuq; +aavur; +aavus; +aavut; +aavuu; +aavuv; +aavuw; +aavux; +aavuy; +aavuz; +aavva; +aavvb; +aavvc; +aavvd; +aavve; +aavvf; +aavvg; +aavvh; +aavvi; +aavvj; +aavvk; +aavvl; +aavvm; +aavvn; +aavvo; +aavvp; +aavvq; +aavvr; +aavvs; +aavvt; +aavvu; +aavvv; +aavvw; +aavvx; +aavvy; +aavvz; +aavwa; +aavwb; +aavwc; +aavwd; +aavwe; +aavwf; +aavwg; +aavwh; +aavwi; +aavwj; +aavwk; +aavwl; +aavwm; +aavwn; +aavwo; +aavwp; +aavwq; +aavwr; +aavws; +aavwt; +aavwu; +aavwv; +aavww; +aavwx; +aavwy; +aavwz; +aavxa; +aavxb; +aavxc; +aavxd; +aavxe; +aavxf; +aavxg; +aavxh; +aavxi; +aavxj; +aavxk; +aavxl; +aavxm; +aavxn; +aavxo; +aavxp; +aavxq; +aavxr; +aavxs; +aavxt; +aavxu; +aavxv; +aavxw; +aavxx; +aavxy; +aavxz; +aavya; +aavyb; +aavyc; +aavyd; +aavye; +aavyf; +aavyg; +aavyh; +aavyi; +aavyj; +aavyk; +aavyl; +aavym; +aavyn; +aavyo; +aavyp; +aavyq; +aavyr; +aavys; +aavyt; +aavyu; +aavyv; +aavyw; +aavyx; +aavyy; +aavyz; +aavza; +aavzb; +aavzc; +aavzd; +aavze; +aavzf; +aavzg; +aavzh; +aavzi; +aavzj; +aavzk; +aavzl; +aavzm; +aavzn; +aavzo; +aavzp; +aavzq; +aavzr; +aavzs; +aavzt; +aavzu; +aavzv; +aavzw; +aavzx; +aavzy; +aavzz; +aawaa; +aawab; +aawac; +aawad; +aawae; +aawaf; +aawag; +aawah; +aawai; +aawaj; +aawak; +aawal; +aawam; +aawan; +aawao; +aawap; +aawaq; +aawar; +aawas; +aawat; +aawau; +aawav; +aawaw; +aawax; +aaway; +aawaz; +aawba; +aawbb; +aawbc; +aawbd; +aawbe; +aawbf; +aawbg; +aawbh; +aawbi; +aawbj; +aawbk; +aawbl; +aawbm; +aawbn; +aawbo; +aawbp; +aawbq; +aawbr; +aawbs; +aawbt; +aawbu; +aawbv; +aawbw; +aawbx; +aawby; +aawbz; +aawca; +aawcb; +aawcc; +aawcd; +aawce; +aawcf; +aawcg; +aawch; +aawci; +aawcj; +aawck; +aawcl; +aawcm; +aawcn; +aawco; +aawcp; +aawcq; +aawcr; +aawcs; +aawct; +aawcu; +aawcv; +aawcw; +aawcx; +aawcy; +aawcz; +aawda; +aawdb; +aawdc; +aawdd; +aawde; +aawdf; +aawdg; +aawdh; +aawdi; +aawdj; +aawdk; +aawdl; +aawdm; +aawdn; +aawdo; +aawdp; +aawdq; +aawdr; +aawds; +aawdt; +aawdu; +aawdv; +aawdw; +aawdx; +aawdy; +aawdz; +aawea; +aaweb; +aawec; +aawed; +aawee; +aawef; +aaweg; +aaweh; +aawei; +aawej; +aawek; +aawel; +aawem; +aawen; +aaweo; +aawep; +aaweq; +aawer; +aawes; +aawet; +aaweu; +aawev; +aawew; +aawex; +aawey; +aawez; +aawfa; +aawfb; +aawfc; +aawfd; +aawfe; +aawff; +aawfg; +aawfh; +aawfi; +aawfj; +aawfk; +aawfl; +aawfm; +aawfn; +aawfo; +aawfp; +aawfq; +aawfr; +aawfs; +aawft; +aawfu; +aawfv; +aawfw; +aawfx; +aawfy; +aawfz; +aawga; +aawgb; +aawgc; +aawgd; +aawge; +aawgf; +aawgg; +aawgh; +aawgi; +aawgj; +aawgk; +aawgl; +aawgm; +aawgn; +aawgo; +aawgp; +aawgq; +aawgr; +aawgs; +aawgt; +aawgu; +aawgv; +aawgw; +aawgx; +aawgy; +aawgz; +aawha; +aawhb; +aawhc; +aawhd; +aawhe; +aawhf; +aawhg; +aawhh; +aawhi; +aawhj; +aawhk; +aawhl; +aawhm; +aawhn; +aawho; +aawhp; +aawhq; +aawhr; +aawhs; +aawht; +aawhu; +aawhv; +aawhw; +aawhx; +aawhy; +aawhz; +aawia; +aawib; +aawic; +aawid; +aawie; +aawif; +aawig; +aawih; +aawii; +aawij; +aawik; +aawil; +aawim; +aawin; +aawio; +aawip; +aawiq; +aawir; +aawis; +aawit; +aawiu; +aawiv; +aawiw; +aawix; +aawiy; +aawiz; +aawja; +aawjb; +aawjc; +aawjd; +aawje; +aawjf; +aawjg; +aawjh; +aawji; +aawjj; +aawjk; +aawjl; +aawjm; +aawjn; +aawjo; +aawjp; +aawjq; +aawjr; +aawjs; +aawjt; +aawju; +aawjv; +aawjw; +aawjx; +aawjy; +aawjz; +aawka; +aawkb; +aawkc; +aawkd; +aawke; +aawkf; +aawkg; +aawkh; +aawki; +aawkj; +aawkk; +aawkl; +aawkm; +aawkn; +aawko; +aawkp; +aawkq; +aawkr; +aawks; +aawkt; +aawku; +aawkv; +aawkw; +aawkx; +aawky; +aawkz; +aawla; +aawlb; +aawlc; +aawld; +aawle; +aawlf; +aawlg; +aawlh; +aawli; +aawlj; +aawlk; +aawll; +aawlm; +aawln; +aawlo; +aawlp; +aawlq; +aawlr; +aawls; +aawlt; +aawlu; +aawlv; +aawlw; +aawlx; +aawly; +aawlz; +aawma; +aawmb; +aawmc; +aawmd; +aawme; +aawmf; +aawmg; +aawmh; +aawmi; +aawmj; +aawmk; +aawml; +aawmm; +aawmn; +aawmo; +aawmp; +aawmq; +aawmr; +aawms; +aawmt; +aawmu; +aawmv; +aawmw; +aawmx; +aawmy; +aawmz; +aawna; +aawnb; +aawnc; +aawnd; +aawne; +aawnf; +aawng; +aawnh; +aawni; +aawnj; +aawnk; +aawnl; +aawnm; +aawnn; +aawno; +aawnp; +aawnq; +aawnr; +aawns; +aawnt; +aawnu; +aawnv; +aawnw; +aawnx; +aawny; +aawnz; +aawoa; +aawob; +aawoc; +aawod; +aawoe; +aawof; +aawog; +aawoh; +aawoi; +aawoj; +aawok; +aawol; +aawom; +aawon; +aawoo; +aawop; +aawoq; +aawor; +aawos; +aawot; +aawou; +aawov; +aawow; +aawox; +aawoy; +aawoz; +aawpa; +aawpb; +aawpc; +aawpd; +aawpe; +aawpf; +aawpg; +aawph; +aawpi; +aawpj; +aawpk; +aawpl; +aawpm; +aawpn; +aawpo; +aawpp; +aawpq; +aawpr; +aawps; +aawpt; +aawpu; +aawpv; +aawpw; +aawpx; +aawpy; +aawpz; +aawqa; +aawqb; +aawqc; +aawqd; +aawqe; +aawqf; +aawqg; +aawqh; +aawqi; +aawqj; +aawqk; +aawql; +aawqm; +aawqn; +aawqo; +aawqp; +aawqq; +aawqr; +aawqs; +aawqt; +aawqu; +aawqv; +aawqw; +aawqx; +aawqy; +aawqz; +aawra; +aawrb; +aawrc; +aawrd; +aawre; +aawrf; +aawrg; +aawrh; +aawri; +aawrj; +aawrk; +aawrl; +aawrm; +aawrn; +aawro; +aawrp; +aawrq; +aawrr; +aawrs; +aawrt; +aawru; +aawrv; +aawrw; +aawrx; +aawry; +aawrz; +aawsa; +aawsb; +aawsc; +aawsd; +aawse; +aawsf; +aawsg; +aawsh; +aawsi; +aawsj; +aawsk; +aawsl; +aawsm; +aawsn; +aawso; +aawsp; +aawsq; +aawsr; +aawss; +aawst; +aawsu; +aawsv; +aawsw; +aawsx; +aawsy; +aawsz; +aawta; +aawtb; +aawtc; +aawtd; +aawte; +aawtf; +aawtg; +aawth; +aawti; +aawtj; +aawtk; +aawtl; +aawtm; +aawtn; +aawto; +aawtp; +aawtq; +aawtr; +aawts; +aawtt; +aawtu; +aawtv; +aawtw; +aawtx; +aawty; +aawtz; +aawua; +aawub; +aawuc; +aawud; +aawue; +aawuf; +aawug; +aawuh; +aawui; +aawuj; +aawuk; +aawul; +aawum; +aawun; +aawuo; +aawup; +aawuq; +aawur; +aawus; +aawut; +aawuu; +aawuv; +aawuw; +aawux; +aawuy; +aawuz; +aawva; +aawvb; +aawvc; +aawvd; +aawve; +aawvf; +aawvg; +aawvh; +aawvi; +aawvj; +aawvk; +aawvl; +aawvm; +aawvn; +aawvo; +aawvp; +aawvq; +aawvr; +aawvs; +aawvt; +aawvu; +aawvv; +aawvw; +aawvx; +aawvy; +aawvz; +aawwa; +aawwb; +aawwc; +aawwd; +aawwe; +aawwf; +aawwg; +aawwh; +aawwi; +aawwj; +aawwk; +aawwl; +aawwm; +aawwn; +aawwo; +aawwp; +aawwq; +aawwr; +aawws; +aawwt; +aawwu; +aawwv; +aawww; +aawwx; +aawwy; +aawwz; +aawxa; +aawxb; +aawxc; +aawxd; +aawxe; +aawxf; +aawxg; +aawxh; +aawxi; +aawxj; +aawxk; +aawxl; +aawxm; +aawxn; +aawxo; +aawxp; +aawxq; +aawxr; +aawxs; +aawxt; +aawxu; +aawxv; +aawxw; +aawxx; +aawxy; +aawxz; +aawya; +aawyb; +aawyc; +aawyd; +aawye; +aawyf; +aawyg; +aawyh; +aawyi; +aawyj; +aawyk; +aawyl; +aawym; +aawyn; +aawyo; +aawyp; +aawyq; +aawyr; +aawys; +aawyt; +aawyu; +aawyv; +aawyw; +aawyx; +aawyy; +aawyz; +aawza; +aawzb; +aawzc; +aawzd; +aawze; +aawzf; +aawzg; +aawzh; +aawzi; +aawzj; +aawzk; +aawzl; +aawzm; +aawzn; +aawzo; +aawzp; +aawzq; +aawzr; +aawzs; +aawzt; +aawzu; +aawzv; +aawzw; +aawzx; +aawzy; +aawzz; +aaxaa; +aaxab; +aaxac; +aaxad; +aaxae; +aaxaf; +aaxag; +aaxah; +aaxai; +aaxaj; +aaxak; +aaxal; +aaxam; +aaxan; +aaxao; +aaxap; +aaxaq; +aaxar; +aaxas; +aaxat; +aaxau; +aaxav; +aaxaw; +aaxax; +aaxay; +aaxaz; +aaxba; +aaxbb; +aaxbc; +aaxbd; +aaxbe; +aaxbf; +aaxbg; +aaxbh; +aaxbi; +aaxbj; +aaxbk; +aaxbl; +aaxbm; +aaxbn; +aaxbo; +aaxbp; +aaxbq; +aaxbr; +aaxbs; +aaxbt; +aaxbu; +aaxbv; +aaxbw; +aaxbx; +aaxby; +aaxbz; +aaxca; +aaxcb; +aaxcc; +aaxcd; +aaxce; +aaxcf; +aaxcg; +aaxch; +aaxci; +aaxcj; +aaxck; +aaxcl; +aaxcm; +aaxcn; +aaxco; +aaxcp; +aaxcq; +aaxcr; +aaxcs; +aaxct; +aaxcu; +aaxcv; +aaxcw; +aaxcx; +aaxcy; +aaxcz; +aaxda; +aaxdb; +aaxdc; +aaxdd; +aaxde; +aaxdf; +aaxdg; +aaxdh; +aaxdi; +aaxdj; +aaxdk; +aaxdl; +aaxdm; +aaxdn; +aaxdo; +aaxdp; +aaxdq; +aaxdr; +aaxds; +aaxdt; +aaxdu; +aaxdv; +aaxdw; +aaxdx; +aaxdy; +aaxdz; +aaxea; +aaxeb; +aaxec; +aaxed; +aaxee; +aaxef; +aaxeg; +aaxeh; +aaxei; +aaxej; +aaxek; +aaxel; +aaxem; +aaxen; +aaxeo; +aaxep; +aaxeq; +aaxer; +aaxes; +aaxet; +aaxeu; +aaxev; +aaxew; +aaxex; +aaxey; +aaxez; +aaxfa; +aaxfb; +aaxfc; +aaxfd; +aaxfe; +aaxff; +aaxfg; +aaxfh; +aaxfi; +aaxfj; +aaxfk; +aaxfl; +aaxfm; +aaxfn; +aaxfo; +aaxfp; +aaxfq; +aaxfr; +aaxfs; +aaxft; +aaxfu; +aaxfv; +aaxfw; +aaxfx; +aaxfy; +aaxfz; +aaxga; +aaxgb; +aaxgc; +aaxgd; +aaxge; +aaxgf; +aaxgg; +aaxgh; +aaxgi; +aaxgj; +aaxgk; +aaxgl; +aaxgm; +aaxgn; +aaxgo; +aaxgp; +aaxgq; +aaxgr; +aaxgs; +aaxgt; +aaxgu; +aaxgv; +aaxgw; +aaxgx; +aaxgy; +aaxgz; +aaxha; +aaxhb; +aaxhc; +aaxhd; +aaxhe; +aaxhf; +aaxhg; +aaxhh; +aaxhi; +aaxhj; +aaxhk; +aaxhl; +aaxhm; +aaxhn; +aaxho; +aaxhp; +aaxhq; +aaxhr; +aaxhs; +aaxht; +aaxhu; +aaxhv; +aaxhw; +aaxhx; +aaxhy; +aaxhz; +aaxia; +aaxib; +aaxic; +aaxid; +aaxie; +aaxif; +aaxig; +aaxih; +aaxii; +aaxij; +aaxik; +aaxil; +aaxim; +aaxin; +aaxio; +aaxip; +aaxiq; +aaxir; +aaxis; +aaxit; +aaxiu; +aaxiv; +aaxiw; +aaxix; +aaxiy; +aaxiz; +aaxja; +aaxjb; +aaxjc; +aaxjd; +aaxje; +aaxjf; +aaxjg; +aaxjh; +aaxji; +aaxjj; +aaxjk; +aaxjl; +aaxjm; +aaxjn; +aaxjo; +aaxjp; +aaxjq; +aaxjr; +aaxjs; +aaxjt; +aaxju; +aaxjv; +aaxjw; +aaxjx; +aaxjy; +aaxjz; +aaxka; +aaxkb; +aaxkc; +aaxkd; +aaxke; +aaxkf; +aaxkg; +aaxkh; +aaxki; +aaxkj; +aaxkk; +aaxkl; +aaxkm; +aaxkn; +aaxko; +aaxkp; +aaxkq; +aaxkr; +aaxks; +aaxkt; +aaxku; +aaxkv; +aaxkw; +aaxkx; +aaxky; +aaxkz; +aaxla; +aaxlb; +aaxlc; +aaxld; +aaxle; +aaxlf; +aaxlg; +aaxlh; +aaxli; +aaxlj; +aaxlk; +aaxll; +aaxlm; +aaxln; +aaxlo; +aaxlp; +aaxlq; +aaxlr; +aaxls; +aaxlt; +aaxlu; +aaxlv; +aaxlw; +aaxlx; +aaxly; +aaxlz; +aaxma; +aaxmb; +aaxmc; +aaxmd; +aaxme; +aaxmf; +aaxmg; +aaxmh; +aaxmi; +aaxmj; +aaxmk; +aaxml; +aaxmm; +aaxmn; +aaxmo; +aaxmp; +aaxmq; +aaxmr; +aaxms; +aaxmt; +aaxmu; +aaxmv; +aaxmw; +aaxmx; +aaxmy; +aaxmz; +aaxna; +aaxnb; +aaxnc; +aaxnd; +aaxne; +aaxnf; +aaxng; +aaxnh; +aaxni; +aaxnj; +aaxnk; +aaxnl; +aaxnm; +aaxnn; +aaxno; +aaxnp; +aaxnq; +aaxnr; +aaxns; +aaxnt; +aaxnu; +aaxnv; +aaxnw; +aaxnx; +aaxny; +aaxnz; +aaxoa; +aaxob; +aaxoc; +aaxod; +aaxoe; +aaxof; +aaxog; +aaxoh; +aaxoi; +aaxoj; +aaxok; +aaxol; +aaxom; +aaxon; +aaxoo; +aaxop; +aaxoq; +aaxor; +aaxos; +aaxot; +aaxou; +aaxov; +aaxow; +aaxox; +aaxoy; +aaxoz; +aaxpa; +aaxpb; +aaxpc; +aaxpd; +aaxpe; +aaxpf; +aaxpg; +aaxph; +aaxpi; +aaxpj; +aaxpk; +aaxpl; +aaxpm; +aaxpn; +aaxpo; +aaxpp; +aaxpq; +aaxpr; +aaxps; +aaxpt; +aaxpu; +aaxpv; +aaxpw; +aaxpx; +aaxpy; +aaxpz; +aaxqa; +aaxqb; +aaxqc; +aaxqd; +aaxqe; +aaxqf; +aaxqg; +aaxqh; +aaxqi; +aaxqj; +aaxqk; +aaxql; +aaxqm; +aaxqn; +aaxqo; +aaxqp; +aaxqq; +aaxqr; +aaxqs; +aaxqt; +aaxqu; +aaxqv; +aaxqw; +aaxqx; +aaxqy; +aaxqz; +aaxra; +aaxrb; +aaxrc; +aaxrd; +aaxre; +aaxrf; +aaxrg; +aaxrh; +aaxri; +aaxrj; +aaxrk; +aaxrl; +aaxrm; +aaxrn; +aaxro; +aaxrp; +aaxrq; +aaxrr; +aaxrs; +aaxrt; +aaxru; +aaxrv; +aaxrw; +aaxrx; +aaxry; +aaxrz; +aaxsa; +aaxsb; +aaxsc; +aaxsd; +aaxse; +aaxsf; +aaxsg; +aaxsh; +aaxsi; +aaxsj; +aaxsk; +aaxsl; +aaxsm; +aaxsn; +aaxso; +aaxsp; +aaxsq; +aaxsr; +aaxss; +aaxst; +aaxsu; +aaxsv; +aaxsw; +aaxsx; +aaxsy; +aaxsz; +aaxta; +aaxtb; +aaxtc; +aaxtd; +aaxte; +aaxtf; +aaxtg; +aaxth; +aaxti; +aaxtj; +aaxtk; +aaxtl; +aaxtm; +aaxtn; +aaxto; +aaxtp; +aaxtq; +aaxtr; +aaxts; +aaxtt; +aaxtu; +aaxtv; +aaxtw; +aaxtx; +aaxty; +aaxtz; +aaxua; +aaxub; +aaxuc; +aaxud; +aaxue; +aaxuf; +aaxug; +aaxuh; +aaxui; +aaxuj; +aaxuk; +aaxul; +aaxum; +aaxun; +aaxuo; +aaxup; +aaxuq; +aaxur; +aaxus; +aaxut; +aaxuu; +aaxuv; +aaxuw; +aaxux; +aaxuy; +aaxuz; +aaxva; +aaxvb; +aaxvc; +aaxvd; +aaxve; +aaxvf; +aaxvg; +aaxvh; +aaxvi; +aaxvj; +aaxvk; +aaxvl; +aaxvm; +aaxvn; +aaxvo; +aaxvp; +aaxvq; +aaxvr; +aaxvs; +aaxvt; +aaxvu; +aaxvv; +aaxvw; +aaxvx; +aaxvy; +aaxvz; +aaxwa; +aaxwb; +aaxwc; +aaxwd; +aaxwe; +aaxwf; +aaxwg; +aaxwh; +aaxwi; +aaxwj; +aaxwk; +aaxwl; +aaxwm; +aaxwn; +aaxwo; +aaxwp; +aaxwq; +aaxwr; +aaxws; +aaxwt; +aaxwu; +aaxwv; +aaxww; +aaxwx; +aaxwy; +aaxwz; +aaxxa; +aaxxb; +aaxxc; +aaxxd; +aaxxe; +aaxxf; +aaxxg; +aaxxh; +aaxxi; +aaxxj; +aaxxk; +aaxxl; +aaxxm; +aaxxn; +aaxxo; +aaxxp; +aaxxq; +aaxxr; +aaxxs; +aaxxt; +aaxxu; +aaxxv; +aaxxw; +aaxxx; +aaxxy; +aaxxz; +aaxya; +aaxyb; +aaxyc; +aaxyd; +aaxye; +aaxyf; +aaxyg; +aaxyh; +aaxyi; +aaxyj; +aaxyk; +aaxyl; +aaxym; +aaxyn; +aaxyo; +aaxyp; +aaxyq; +aaxyr; +aaxys; +aaxyt; +aaxyu; +aaxyv; +aaxyw; +aaxyx; +aaxyy; +aaxyz; +aaxza; +aaxzb; +aaxzc; +aaxzd; +aaxze; +aaxzf; +aaxzg; +aaxzh; +aaxzi; +aaxzj; +aaxzk; +aaxzl; +aaxzm; +aaxzn; +aaxzo; +aaxzp; +aaxzq; +aaxzr; +aaxzs; +aaxzt; +aaxzu; +aaxzv; +aaxzw; +aaxzx; +aaxzy; +aaxzz; +aayaa; +aayab; +aayac; +aayad; +aayae; +aayaf; +aayag; +aayah; +aayai; +aayaj; +aayak; +aayal; +aayam; +aayan; +aayao; +aayap; +aayaq; +aayar; +aayas; +aayat; +aayau; +aayav; +aayaw; +aayax; +aayay; +aayaz; +aayba; +aaybb; +aaybc; +aaybd; +aaybe; +aaybf; +aaybg; +aaybh; +aaybi; +aaybj; +aaybk; +aaybl; +aaybm; +aaybn; +aaybo; +aaybp; +aaybq; +aaybr; +aaybs; +aaybt; +aaybu; +aaybv; +aaybw; +aaybx; +aayby; +aaybz; +aayca; +aaycb; +aaycc; +aaycd; +aayce; +aaycf; +aaycg; +aaych; +aayci; +aaycj; +aayck; +aaycl; +aaycm; +aaycn; +aayco; +aaycp; +aaycq; +aaycr; +aaycs; +aayct; +aaycu; +aaycv; +aaycw; +aaycx; +aaycy; +aaycz; +aayda; +aaydb; +aaydc; +aaydd; +aayde; +aaydf; +aaydg; +aaydh; +aaydi; +aaydj; +aaydk; +aaydl; +aaydm; +aaydn; +aaydo; +aaydp; +aaydq; +aaydr; +aayds; +aaydt; +aaydu; +aaydv; +aaydw; +aaydx; +aaydy; +aaydz; +aayea; +aayeb; +aayec; +aayed; +aayee; +aayef; +aayeg; +aayeh; +aayei; +aayej; +aayek; +aayel; +aayem; +aayen; +aayeo; +aayep; +aayeq; +aayer; +aayes; +aayet; +aayeu; +aayev; +aayew; +aayex; +aayey; +aayez; +aayfa; +aayfb; +aayfc; +aayfd; +aayfe; +aayff; +aayfg; +aayfh; +aayfi; +aayfj; +aayfk; +aayfl; +aayfm; +aayfn; +aayfo; +aayfp; +aayfq; +aayfr; +aayfs; +aayft; +aayfu; +aayfv; +aayfw; +aayfx; +aayfy; +aayfz; +aayga; +aaygb; +aaygc; +aaygd; +aayge; +aaygf; +aaygg; +aaygh; +aaygi; +aaygj; +aaygk; +aaygl; +aaygm; +aaygn; +aaygo; +aaygp; +aaygq; +aaygr; +aaygs; +aaygt; +aaygu; +aaygv; +aaygw; +aaygx; +aaygy; +aaygz; +aayha; +aayhb; +aayhc; +aayhd; +aayhe; +aayhf; +aayhg; +aayhh; +aayhi; +aayhj; +aayhk; +aayhl; +aayhm; +aayhn; +aayho; +aayhp; +aayhq; +aayhr; +aayhs; +aayht; +aayhu; +aayhv; +aayhw; +aayhx; +aayhy; +aayhz; +aayia; +aayib; +aayic; +aayid; +aayie; +aayif; +aayig; +aayih; +aayii; +aayij; +aayik; +aayil; +aayim; +aayin; +aayio; +aayip; +aayiq; +aayir; +aayis; +aayit; +aayiu; +aayiv; +aayiw; +aayix; +aayiy; +aayiz; +aayja; +aayjb; +aayjc; +aayjd; +aayje; +aayjf; +aayjg; +aayjh; +aayji; +aayjj; +aayjk; +aayjl; +aayjm; +aayjn; +aayjo; +aayjp; +aayjq; +aayjr; +aayjs; +aayjt; +aayju; +aayjv; +aayjw; +aayjx; +aayjy; +aayjz; +aayka; +aaykb; +aaykc; +aaykd; +aayke; +aaykf; +aaykg; +aaykh; +aayki; +aaykj; +aaykk; +aaykl; +aaykm; +aaykn; +aayko; +aaykp; +aaykq; +aaykr; +aayks; +aaykt; +aayku; +aaykv; +aaykw; +aaykx; +aayky; +aaykz; +aayla; +aaylb; +aaylc; +aayld; +aayle; +aaylf; +aaylg; +aaylh; +aayli; +aaylj; +aaylk; +aayll; +aaylm; +aayln; +aaylo; +aaylp; +aaylq; +aaylr; +aayls; +aaylt; +aaylu; +aaylv; +aaylw; +aaylx; +aayly; +aaylz; +aayma; +aaymb; +aaymc; +aaymd; +aayme; +aaymf; +aaymg; +aaymh; +aaymi; +aaymj; +aaymk; +aayml; +aaymm; +aaymn; +aaymo; +aaymp; +aaymq; +aaymr; +aayms; +aaymt; +aaymu; +aaymv; +aaymw; +aaymx; +aaymy; +aaymz; +aayna; +aaynb; +aaync; +aaynd; +aayne; +aaynf; +aayng; +aaynh; +aayni; +aaynj; +aaynk; +aaynl; +aaynm; +aaynn; +aayno; +aaynp; +aaynq; +aaynr; +aayns; +aaynt; +aaynu; +aaynv; +aaynw; +aaynx; +aayny; +aaynz; +aayoa; +aayob; +aayoc; +aayod; +aayoe; +aayof; +aayog; +aayoh; +aayoi; +aayoj; +aayok; +aayol; +aayom; +aayon; +aayoo; +aayop; +aayoq; +aayor; +aayos; +aayot; +aayou; +aayov; +aayow; +aayox; +aayoy; +aayoz; +aaypa; +aaypb; +aaypc; +aaypd; +aaype; +aaypf; +aaypg; +aayph; +aaypi; +aaypj; +aaypk; +aaypl; +aaypm; +aaypn; +aaypo; +aaypp; +aaypq; +aaypr; +aayps; +aaypt; +aaypu; +aaypv; +aaypw; +aaypx; +aaypy; +aaypz; +aayqa; +aayqb; +aayqc; +aayqd; +aayqe; +aayqf; +aayqg; +aayqh; +aayqi; +aayqj; +aayqk; +aayql; +aayqm; +aayqn; +aayqo; +aayqp; +aayqq; +aayqr; +aayqs; +aayqt; +aayqu; +aayqv; +aayqw; +aayqx; +aayqy; +aayqz; +aayra; +aayrb; +aayrc; +aayrd; +aayre; +aayrf; +aayrg; +aayrh; +aayri; +aayrj; +aayrk; +aayrl; +aayrm; +aayrn; +aayro; +aayrp; +aayrq; +aayrr; +aayrs; +aayrt; +aayru; +aayrv; +aayrw; +aayrx; +aayry; +aayrz; +aaysa; +aaysb; +aaysc; +aaysd; +aayse; +aaysf; +aaysg; +aaysh; +aaysi; +aaysj; +aaysk; +aaysl; +aaysm; +aaysn; +aayso; +aaysp; +aaysq; +aaysr; +aayss; +aayst; +aaysu; +aaysv; +aaysw; +aaysx; +aaysy; +aaysz; +aayta; +aaytb; +aaytc; +aaytd; +aayte; +aaytf; +aaytg; +aayth; +aayti; +aaytj; +aaytk; +aaytl; +aaytm; +aaytn; +aayto; +aaytp; +aaytq; +aaytr; +aayts; +aaytt; +aaytu; +aaytv; +aaytw; +aaytx; +aayty; +aaytz; +aayua; +aayub; +aayuc; +aayud; +aayue; +aayuf; +aayug; +aayuh; +aayui; +aayuj; +aayuk; +aayul; +aayum; +aayun; +aayuo; +aayup; +aayuq; +aayur; +aayus; +aayut; +aayuu; +aayuv; +aayuw; +aayux; +aayuy; +aayuz; +aayva; +aayvb; +aayvc; +aayvd; +aayve; +aayvf; +aayvg; +aayvh; +aayvi; +aayvj; +aayvk; +aayvl; +aayvm; +aayvn; +aayvo; +aayvp; +aayvq; +aayvr; +aayvs; +aayvt; +aayvu; +aayvv; +aayvw; +aayvx; +aayvy; +aayvz; +aaywa; +aaywb; +aaywc; +aaywd; +aaywe; +aaywf; +aaywg; +aaywh; +aaywi; +aaywj; +aaywk; +aaywl; +aaywm; +aaywn; +aaywo; +aaywp; +aaywq; +aaywr; +aayws; +aaywt; +aaywu; +aaywv; +aayww; +aaywx; +aaywy; +aaywz; +aayxa; +aayxb; +aayxc; +aayxd; +aayxe; +aayxf; +aayxg; +aayxh; +aayxi; +aayxj; +aayxk; +aayxl; +aayxm; +aayxn; +aayxo; +aayxp; +aayxq; +aayxr; +aayxs; +aayxt; +aayxu; +aayxv; +aayxw; +aayxx; +aayxy; +aayxz; +aayya; +aayyb; +aayyc; +aayyd; +aayye; +aayyf; +aayyg; +aayyh; +aayyi; +aayyj; +aayyk; +aayyl; +aayym; +aayyn; +aayyo; +aayyp; +aayyq; +aayyr; +aayys; +aayyt; +aayyu; +aayyv; +aayyw; +aayyx; +aayyy; +aayyz; +aayza; +aayzb; +aayzc; +aayzd; +aayze; +aayzf; +aayzg; +aayzh; +aayzi; +aayzj; +aayzk; +aayzl; +aayzm; +aayzn; +aayzo; +aayzp; +aayzq; +aayzr; +aayzs; +aayzt; +aayzu; +aayzv; +aayzw; +aayzx; +aayzy; +aayzz; +aazaa; +aazab; +aazac; +aazad; +aazae; +aazaf; +aazag; +aazah; +aazai; +aazaj; +aazak; +aazal; +aazam; +aazan; +aazao; +aazap; +aazaq; +aazar; +aazas; +aazat; +aazau; +aazav; +aazaw; +aazax; +aazay; +aazaz; +aazba; +aazbb; +aazbc; +aazbd; +aazbe; +aazbf; +aazbg; +aazbh; +aazbi; +aazbj; +aazbk; +aazbl; +aazbm; +aazbn; +aazbo; +aazbp; +aazbq; +aazbr; +aazbs; +aazbt; +aazbu; +aazbv; +aazbw; +aazbx; +aazby; +aazbz; +aazca; +aazcb; +aazcc; +aazcd; +aazce; +aazcf; +aazcg; +aazch; +aazci; +aazcj; +aazck; +aazcl; +aazcm; +aazcn; +aazco; +aazcp; +aazcq; +aazcr; +aazcs; +aazct; +aazcu; +aazcv; +aazcw; +aazcx; +aazcy; +aazcz; +aazda; +aazdb; +aazdc; +aazdd; +aazde; +aazdf; +aazdg; +aazdh; +aazdi; +aazdj; +aazdk; +aazdl; +aazdm; +aazdn; +aazdo; +aazdp; +aazdq; +aazdr; +aazds; +aazdt; +aazdu; +aazdv; +aazdw; +aazdx; +aazdy; +aazdz; +aazea; +aazeb; +aazec; +aazed; +aazee; +aazef; +aazeg; +aazeh; +aazei; +aazej; +aazek; +aazel; +aazem; +aazen; +aazeo; +aazep; +aazeq; +aazer; +aazes; +aazet; +aazeu; +aazev; +aazew; +aazex; +aazey; +aazez; +aazfa; +aazfb; +aazfc; +aazfd; +aazfe; +aazff; +aazfg; +aazfh; +aazfi; +aazfj; +aazfk; +aazfl; +aazfm; +aazfn; +aazfo; +aazfp; +aazfq; +aazfr; +aazfs; +aazft; +aazfu; +aazfv; +aazfw; +aazfx; +aazfy; +aazfz; +aazga; +aazgb; +aazgc; +aazgd; +aazge; +aazgf; +aazgg; +aazgh; +aazgi; +aazgj; +aazgk; +aazgl; +aazgm; +aazgn; +aazgo; +aazgp; +aazgq; +aazgr; +aazgs; +aazgt; +aazgu; +aazgv; +aazgw; +aazgx; +aazgy; +aazgz; +aazha; +aazhb; +aazhc; +aazhd; +aazhe; +aazhf; +aazhg; +aazhh; +aazhi; +aazhj; +aazhk; +aazhl; +aazhm; +aazhn; +aazho; +aazhp; +aazhq; +aazhr; +aazhs; +aazht; +aazhu; +aazhv; +aazhw; +aazhx; +aazhy; +aazhz; +aazia; +aazib; +aazic; +aazid; +aazie; +aazif; +aazig; +aazih; +aazii; +aazij; +aazik; +aazil; +aazim; +aazin; +aazio; +aazip; +aaziq; +aazir; +aazis; +aazit; +aaziu; +aaziv; +aaziw; +aazix; +aaziy; +aaziz; +aazja; +aazjb; +aazjc; +aazjd; +aazje; +aazjf; +aazjg; +aazjh; +aazji; +aazjj; +aazjk; +aazjl; +aazjm; +aazjn; +aazjo; +aazjp; +aazjq; +aazjr; +aazjs; +aazjt; +aazju; +aazjv; +aazjw; +aazjx; +aazjy; +aazjz; +aazka; +aazkb; +aazkc; +aazkd; +aazke; +aazkf; +aazkg; +aazkh; +aazki; +aazkj; +aazkk; +aazkl; +aazkm; +aazkn; +aazko; +aazkp; +aazkq; +aazkr; +aazks; +aazkt; +aazku; +aazkv; +aazkw; +aazkx; +aazky; +aazkz; +aazla; +aazlb; +aazlc; +aazld; +aazle; +aazlf; +aazlg; +aazlh; +aazli; +aazlj; +aazlk; +aazll; +aazlm; +aazln; +aazlo; +aazlp; +aazlq; +aazlr; +aazls; +aazlt; +aazlu; +aazlv; +aazlw; +aazlx; +aazly; +aazlz; +aazma; +aazmb; +aazmc; +aazmd; +aazme; +aazmf; +aazmg; +aazmh; +aazmi; +aazmj; +aazmk; +aazml; +aazmm; +aazmn; +aazmo; +aazmp; +aazmq; +aazmr; +aazms; +aazmt; +aazmu; +aazmv; +aazmw; +aazmx; +aazmy; +aazmz; +aazna; +aaznb; +aaznc; +aaznd; +aazne; +aaznf; +aazng; +aaznh; +aazni; +aaznj; +aaznk; +aaznl; +aaznm; +aaznn; +aazno; +aaznp; +aaznq; +aaznr; +aazns; +aaznt; +aaznu; +aaznv; +aaznw; +aaznx; +aazny; +aaznz; +aazoa; +aazob; +aazoc; +aazod; +aazoe; +aazof; +aazog; +aazoh; +aazoi; +aazoj; +aazok; +aazol; +aazom; +aazon; +aazoo; +aazop; +aazoq; +aazor; +aazos; +aazot; +aazou; +aazov; +aazow; +aazox; +aazoy; +aazoz; +aazpa; +aazpb; +aazpc; +aazpd; +aazpe; +aazpf; +aazpg; +aazph; +aazpi; +aazpj; +aazpk; +aazpl; +aazpm; +aazpn; +aazpo; +aazpp; +aazpq; +aazpr; +aazps; +aazpt; +aazpu; +aazpv; +aazpw; +aazpx; +aazpy; +aazpz; +aazqa; +aazqb; +aazqc; +aazqd; +aazqe; +aazqf; +aazqg; +aazqh; +aazqi; +aazqj; +aazqk; +aazql; +aazqm; +aazqn; +aazqo; +aazqp; +aazqq; +aazqr; +aazqs; +aazqt; +aazqu; +aazqv; +aazqw; +aazqx; +aazqy; +aazqz; +aazra; +aazrb; +aazrc; +aazrd; +aazre; +aazrf; +aazrg; +aazrh; +aazri; +aazrj; +aazrk; +aazrl; +aazrm; +aazrn; +aazro; +aazrp; +aazrq; +aazrr; +aazrs; +aazrt; +aazru; +aazrv; +aazrw; +aazrx; +aazry; +aazrz; +aazsa; +aazsb; +aazsc; +aazsd; +aazse; +aazsf; +aazsg; +aazsh; +aazsi; +aazsj; +aazsk; +aazsl; +aazsm; +aazsn; +aazso; +aazsp; +aazsq; +aazsr; +aazss; +aazst; +aazsu; +aazsv; +aazsw; +aazsx; +aazsy; +aazsz; +aazta; +aaztb; +aaztc; +aaztd; +aazte; +aaztf; +aaztg; +aazth; +aazti; +aaztj; +aaztk; +aaztl; +aaztm; +aaztn; +aazto; +aaztp; +aaztq; +aaztr; +aazts; +aaztt; +aaztu; +aaztv; +aaztw; +aaztx; +aazty; +aaztz; +aazua; +aazub; +aazuc; +aazud; +aazue; +aazuf; +aazug; +aazuh; +aazui; +aazuj; +aazuk; +aazul; +aazum; +aazun; +aazuo; +aazup; +aazuq; +aazur; +aazus; +aazut; +aazuu; +aazuv; +aazuw; +aazux; +aazuy; +aazuz; +aazva; +aazvb; +aazvc; +aazvd; +aazve; +aazvf; +aazvg; +aazvh; +aazvi; +aazvj; +aazvk; +aazvl; +aazvm; +aazvn; +aazvo; +aazvp; +aazvq; +aazvr; +aazvs; +aazvt; +aazvu; +aazvv; +aazvw; +aazvx; +aazvy; +aazvz; +aazwa; +aazwb; +aazwc; +aazwd; +aazwe; +aazwf; +aazwg; +aazwh; +aazwi; +aazwj; +aazwk; +aazwl; +aazwm; +aazwn; +aazwo; +aazwp; +aazwq; +aazwr; +aazws; +aazwt; +aazwu; +aazwv; +aazww; +aazwx; +aazwy; +aazwz; +aazxa; +aazxb; +aazxc; +aazxd; +aazxe; +aazxf; +aazxg; +aazxh; +aazxi; +aazxj; +aazxk; +aazxl; +aazxm; +aazxn; +aazxo; +aazxp; +aazxq; +aazxr; +aazxs; +aazxt; +aazxu; +aazxv; +aazxw; +aazxx; +aazxy; +aazxz; +aazya; +aazyb; +aazyc; +aazyd; +aazye; +aazyf; +aazyg; +aazyh; +aazyi; +aazyj; +aazyk; +aazyl; +aazym; +aazyn; +aazyo; +aazyp; +aazyq; +aazyr; +aazys; +aazyt; +aazyu; +aazyv; +aazyw; +aazyx; +aazyy; +aazyz; +aazza; +aazzb; +aazzc; +aazzd; +aazze; +aazzf; +aazzg; +aazzh; +aazzi; +aazzj; +aazzk; +aazzl; +aazzm; +aazzn; +aazzo; +aazzp; +aazzq; +aazzr; +aazzs; +aazzt; +aazzu; +aazzv; +aazzw; +aazzx; +aazzy; +aazzz; +abaaa; +abaab; +abaac; +abaad; +abaae; +abaaf; +abaag; +abaah; +abaai; +abaaj; +abaak; +abaal; +abaam; +abaan; +abaao; +abaap; +abaaq; +abaar; +abaas; +abaat; +abaau; +abaav; +abaaw; +abaax; +abaay; +abaaz; +ababa; +ababb; +ababc; +ababd; +ababe; +ababf; +ababg; +ababh; +ababi; +ababj; +ababk; +ababl; +ababm; +ababn; +ababo; +ababp; +ababq; +ababr; +ababs; +ababt; +ababu; +ababv; +ababw; +ababx; +ababy; +ababz; +abaca; +abacb; +abacc; +abacd; +abace; +abacf; +abacg; +abach; +abaci; +abacj; +aback; +abacl; +abacm; +abacn; +abaco; +abacp; +abacq; +abacr; +abacs; +abact; +abacu; +abacv; +abacw; +abacx; +abacy; +abacz; +abada; +abadb; +abadc; +abadd; +abade; +abadf; +abadg; +abadh; +abadi; +abadj; +abadk; +abadl; +abadm; +abadn; +abado; +abadp; +abadq; +abadr; +abads; +abadt; +abadu; +abadv; +abadw; +abadx; +abady; +abadz; +abaea; +abaeb; +abaec; +abaed; +abaee; +abaef; +abaeg; +abaeh; +abaei; +abaej; +abaek; +abael; +abaem; +abaen; +abaeo; +abaep; +abaeq; +abaer; +abaes; +abaet; +abaeu; +abaev; +abaew; +abaex; +abaey; +abaez; +abafa; +abafb; +abafc; +abafd; +abafe; +abaff; +abafg; +abafh; +abafi; +abafj; +abafk; +abafl; +abafm; +abafn; +abafo; +abafp; +abafq; +abafr; +abafs; +abaft; +abafu; +abafv; +abafw; +abafx; +abafy; +abafz; +abaga; +abagb; +abagc; +abagd; +abage; +abagf; +abagg; +abagh; +abagi; +abagj; +abagk; +abagl; +abagm; +abagn; +abago; +abagp; +abagq; +abagr; +abags; +abagt; +abagu; +abagv; +abagw; +abagx; +abagy; +abagz; +abaha; +abahb; +abahc; +abahd; +abahe; +abahf; +abahg; +abahh; +abahi; +abahj; +abahk; +abahl; +abahm; +abahn; +abaho; +abahp; +abahq; +abahr; +abahs; +abaht; +abahu; +abahv; +abahw; +abahx; +abahy; +abahz; +abaia; +abaib; +abaic; +abaid; +abaie; +abaif; +abaig; +abaih; +abaii; +abaij; +abaik; +abail; +abaim; +abain; +abaio; +abaip; +abaiq; +abair; +abais; +abait; +abaiu; +abaiv; +abaiw; +abaix; +abaiy; +abaiz; +abaja; +abajb; +abajc; +abajd; +abaje; +abajf; +abajg; +abajh; +abaji; +abajj; +abajk; +abajl; +abajm; +abajn; +abajo; +abajp; +abajq; +abajr; +abajs; +abajt; +abaju; +abajv; +abajw; +abajx; +abajy; +abajz; +abaka; +abakb; +abakc; +abakd; +abake; +abakf; +abakg; +abakh; +abaki; +abakj; +abakk; +abakl; +abakm; +abakn; +abako; +abakp; +abakq; +abakr; +abaks; +abakt; +abaku; +abakv; +abakw; +abakx; +abaky; +abakz; +abala; +abalb; +abalc; +abald; +abale; +abalf; +abalg; +abalh; +abali; +abalj; +abalk; +aball; +abalm; +abaln; +abalo; +abalp; +abalq; +abalr; +abals; +abalt; +abalu; +abalv; +abalw; +abalx; +abaly; +abalz; +abama; +abamb; +abamc; +abamd; +abame; +abamf; +abamg; +abamh; +abami; +abamj; +abamk; +abaml; +abamm; +abamn; +abamo; +abamp; +abamq; +abamr; +abams; +abamt; +abamu; +abamv; +abamw; +abamx; +abamy; +abamz; +abana; +abanb; +abanc; +aband; +abane; +abanf; +abang; +abanh; +abani; +abanj; +abank; +abanl; +abanm; +abann; +abano; +abanp; +abanq; +abanr; +abans; +abant; +abanu; +abanv; +abanw; +abanx; +abany; +abanz; +abaoa; +abaob; +abaoc; +abaod; +abaoe; +abaof; +abaog; +abaoh; +abaoi; +abaoj; +abaok; +abaol; +abaom; +abaon; +abaoo; +abaop; +abaoq; +abaor; +abaos; +abaot; +abaou; +abaov; +abaow; +abaox; +abaoy; +abaoz; +abapa; +abapb; +abapc; +abapd; +abape; +abapf; +abapg; +abaph; +abapi; +abapj; +abapk; +abapl; +abapm; +abapn; +abapo; +abapp; +abapq; +abapr; +abaps; +abapt; +abapu; +abapv; +abapw; +abapx; +abapy; +abapz; +abaqa; +abaqb; +abaqc; +abaqd; +abaqe; +abaqf; +abaqg; +abaqh; +abaqi; +abaqj; +abaqk; +abaql; +abaqm; +abaqn; +abaqo; +abaqp; +abaqq; +abaqr; +abaqs; +abaqt; +abaqu; +abaqv; +abaqw; +abaqx; +abaqy; +abaqz; +abara; +abarb; +abarc; +abard; +abare; +abarf; +abarg; +abarh; +abari; +abarj; +abark; +abarl; +abarm; +abarn; +abaro; +abarp; +abarq; +abarr; +abars; +abart; +abaru; +abarv; +abarw; +abarx; +abary; +abarz; +abasa; +abasb; +abasc; +abasd; +abase; +abasf; +abasg; +abash; +abasi; +abasj; +abask; +abasl; +abasm; +abasn; +abaso; +abasp; +abasq; +abasr; +abass; +abast; +abasu; +abasv; +abasw; +abasx; +abasy; +abasz; +abata; +abatb; +abatc; +abatd; +abate; +abatf; +abatg; +abath; +abati; +abatj; +abatk; +abatl; +abatm; +abatn; +abato; +abatp; +abatq; +abatr; +abats; +abatt; +abatu; +abatv; +abatw; +abatx; +abaty; +abatz; +abaua; +abaub; +abauc; +abaud; +abaue; +abauf; +abaug; +abauh; +abaui; +abauj; +abauk; +abaul; +abaum; +abaun; +abauo; +abaup; +abauq; +abaur; +abaus; +abaut; +abauu; +abauv; +abauw; +abaux; +abauy; +abauz; +abava; +abavb; +abavc; +abavd; +abave; +abavf; +abavg; +abavh; +abavi; +abavj; +abavk; +abavl; +abavm; +abavn; +abavo; +abavp; +abavq; +abavr; +abavs; +abavt; +abavu; +abavv; +abavw; +abavx; +abavy; +abavz; +abawa; +abawb; +abawc; +abawd; +abawe; +abawf; +abawg; +abawh; +abawi; +abawj; +abawk; +abawl; +abawm; +abawn; +abawo; +abawp; +abawq; +abawr; +abaws; +abawt; +abawu; +abawv; +abaww; +abawx; +abawy; +abawz; +abaxa; +abaxb; +abaxc; +abaxd; +abaxe; +abaxf; +abaxg; +abaxh; +abaxi; +abaxj; +abaxk; +abaxl; +abaxm; +abaxn; +abaxo; +abaxp; +abaxq; +abaxr; +abaxs; +abaxt; +abaxu; +abaxv; +abaxw; +abaxx; +abaxy; +abaxz; +abaya; +abayb; +abayc; +abayd; +abaye; +abayf; +abayg; +abayh; +abayi; +abayj; +abayk; +abayl; +abaym; +abayn; +abayo; +abayp; +abayq; +abayr; +abays; +abayt; +abayu; +abayv; +abayw; +abayx; +abayy; +abayz; +abaza; +abazb; +abazc; +abazd; +abaze; +abazf; +abazg; +abazh; +abazi; +abazj; +abazk; +abazl; +abazm; +abazn; +abazo; +abazp; +abazq; +abazr; +abazs; +abazt; +abazu; +abazv; +abazw; +abazx; +abazy; +abazz; +abbaa; +abbab; +abbac; +abbad; +abbae; +abbaf; +abbag; +abbah; +abbai; +abbaj; +abbak; +abbal; +abbam; +abban; +abbao; +abbap; +abbaq; +abbar; +abbas; +abbat; +abbau; +abbav; +abbaw; +abbax; +abbay; +abbaz; +abbba; +abbbb; +abbbc; +abbbd; +abbbe; +abbbf; +abbbg; +abbbh; +abbbi; +abbbj; +abbbk; +abbbl; +abbbm; +abbbn; +abbbo; +abbbp; +abbbq; +abbbr; +abbbs; +abbbt; +abbbu; +abbbv; +abbbw; +abbbx; +abbby; +abbbz; +abbca; +abbcb; +abbcc; +abbcd; +abbce; +abbcf; +abbcg; +abbch; +abbci; +abbcj; +abbck; +abbcl; +abbcm; +abbcn; +abbco; +abbcp; +abbcq; +abbcr; +abbcs; +abbct; +abbcu; +abbcv; +abbcw; +abbcx; +abbcy; +abbcz; +abbda; +abbdb; +abbdc; +abbdd; +abbde; +abbdf; +abbdg; +abbdh; +abbdi; +abbdj; +abbdk; +abbdl; +abbdm; +abbdn; +abbdo; +abbdp; +abbdq; +abbdr; +abbds; +abbdt; +abbdu; +abbdv; +abbdw; +abbdx; +abbdy; +abbdz; +abbea; +abbeb; +abbec; +abbed; +abbee; +abbef; +abbeg; +abbeh; +abbei; +abbej; +abbek; +abbel; +abbem; +abben; +abbeo; +abbep; +abbeq; +abber; +abbes; +abbet; +abbeu; +abbev; +abbew; +abbex; +abbey; +abbez; +abbfa; +abbfb; +abbfc; +abbfd; +abbfe; +abbff; +abbfg; +abbfh; +abbfi; +abbfj; +abbfk; +abbfl; +abbfm; +abbfn; +abbfo; +abbfp; +abbfq; +abbfr; +abbfs; +abbft; +abbfu; +abbfv; +abbfw; +abbfx; +abbfy; +abbfz; +abbga; +abbgb; +abbgc; +abbgd; +abbge; +abbgf; +abbgg; +abbgh; +abbgi; +abbgj; +abbgk; +abbgl; +abbgm; +abbgn; +abbgo; +abbgp; +abbgq; +abbgr; +abbgs; +abbgt; +abbgu; +abbgv; +abbgw; +abbgx; +abbgy; +abbgz; +abbha; +abbhb; +abbhc; +abbhd; +abbhe; +abbhf; +abbhg; +abbhh; +abbhi; +abbhj; +abbhk; +abbhl; +abbhm; +abbhn; +abbho; +abbhp; +abbhq; +abbhr; +abbhs; +abbht; +abbhu; +abbhv; +abbhw; +abbhx; +abbhy; +abbhz; +abbia; +abbib; +abbic; +abbid; +abbie; +abbif; +abbig; +abbih; +abbii; +abbij; +abbik; +abbil; +abbim; +abbin; +abbio; +abbip; +abbiq; +abbir; +abbis; +abbit; +abbiu; +abbiv; +abbiw; +abbix; +abbiy; +abbiz; +abbja; +abbjb; +abbjc; +abbjd; +abbje; +abbjf; +abbjg; +abbjh; +abbji; +abbjj; +abbjk; +abbjl; +abbjm; +abbjn; +abbjo; +abbjp; +abbjq; +abbjr; +abbjs; +abbjt; +abbju; +abbjv; +abbjw; +abbjx; +abbjy; +abbjz; +abbka; +abbkb; +abbkc; +abbkd; +abbke; +abbkf; +abbkg; +abbkh; +abbki; +abbkj; +abbkk; +abbkl; +abbkm; +abbkn; +abbko; +abbkp; +abbkq; +abbkr; +abbks; +abbkt; +abbku; +abbkv; +abbkw; +abbkx; +abbky; +abbkz; +abbla; +abblb; +abblc; +abbld; +abble; +abblf; +abblg; +abblh; +abbli; +abblj; +abblk; +abbll; +abblm; +abbln; +abblo; +abblp; +abblq; +abblr; +abbls; +abblt; +abblu; +abblv; +abblw; +abblx; +abbly; +abblz; +abbma; +abbmb; +abbmc; +abbmd; +abbme; +abbmf; +abbmg; +abbmh; +abbmi; +abbmj; +abbmk; +abbml; +abbmm; +abbmn; +abbmo; +abbmp; +abbmq; +abbmr; +abbms; +abbmt; +abbmu; +abbmv; +abbmw; +abbmx; +abbmy; +abbmz; +abbna; +abbnb; +abbnc; +abbnd; +abbne; +abbnf; +abbng; +abbnh; +abbni; +abbnj; +abbnk; +abbnl; +abbnm; +abbnn; +abbno; +abbnp; +abbnq; +abbnr; +abbns; +abbnt; +abbnu; +abbnv; +abbnw; +abbnx; +abbny; +abbnz; +abboa; +abbob; +abboc; +abbod; +abboe; +abbof; +abbog; +abboh; +abboi; +abboj; +abbok; +abbol; +abbom; +abbon; +abboo; +abbop; +abboq; +abbor; +abbos; +abbot; +abbou; +abbov; +abbow; +abbox; +abboy; +abboz; +abbpa; +abbpb; +abbpc; +abbpd; +abbpe; +abbpf; +abbpg; +abbph; +abbpi; +abbpj; +abbpk; +abbpl; +abbpm; +abbpn; +abbpo; +abbpp; +abbpq; +abbpr; +abbps; +abbpt; +abbpu; +abbpv; +abbpw; +abbpx; +abbpy; +abbpz; +abbqa; +abbqb; +abbqc; +abbqd; +abbqe; +abbqf; +abbqg; +abbqh; +abbqi; +abbqj; +abbqk; +abbql; +abbqm; +abbqn; +abbqo; +abbqp; +abbqq; +abbqr; +abbqs; +abbqt; +abbqu; +abbqv; +abbqw; +abbqx; +abbqy; +abbqz; +abbra; +abbrb; +abbrc; +abbrd; +abbre; +abbrf; +abbrg; +abbrh; +abbri; +abbrj; +abbrk; +abbrl; +abbrm; +abbrn; +abbro; +abbrp; +abbrq; +abbrr; +abbrs; +abbrt; +abbru; +abbrv; +abbrw; +abbrx; +abbry; +abbrz; +abbsa; +abbsb; +abbsc; +abbsd; +abbse; +abbsf; +abbsg; +abbsh; +abbsi; +abbsj; +abbsk; +abbsl; +abbsm; +abbsn; +abbso; +abbsp; +abbsq; +abbsr; +abbss; +abbst; +abbsu; +abbsv; +abbsw; +abbsx; +abbsy; +abbsz; +abbta; +abbtb; +abbtc; +abbtd; +abbte; +abbtf; +abbtg; +abbth; +abbti; +abbtj; +abbtk; +abbtl; +abbtm; +abbtn; +abbto; +abbtp; +abbtq; +abbtr; +abbts; +abbtt; +abbtu; +abbtv; +abbtw; +abbtx; +abbty; +abbtz; +abbua; +abbub; +abbuc; +abbud; +abbue; +abbuf; +abbug; +abbuh; +abbui; +abbuj; +abbuk; +abbul; +abbum; +abbun; +abbuo; +abbup; +abbuq; +abbur; +abbus; +abbut; +abbuu; +abbuv; +abbuw; +abbux; +abbuy; +abbuz; +abbva; +abbvb; +abbvc; +abbvd; +abbve; +abbvf; +abbvg; +abbvh; +abbvi; +abbvj; +abbvk; +abbvl; +abbvm; +abbvn; +abbvo; +abbvp; +abbvq; +abbvr; +abbvs; +abbvt; +abbvu; +abbvv; +abbvw; +abbvx; +abbvy; +abbvz; +abbwa; +abbwb; +abbwc; +abbwd; +abbwe; +abbwf; +abbwg; +abbwh; +abbwi; +abbwj; +abbwk; +abbwl; +abbwm; +abbwn; +abbwo; +abbwp; +abbwq; +abbwr; +abbws; +abbwt; +abbwu; +abbwv; +abbww; +abbwx; +abbwy; +abbwz; +abbxa; +abbxb; +abbxc; +abbxd; +abbxe; +abbxf; +abbxg; +abbxh; +abbxi; +abbxj; +abbxk; +abbxl; +abbxm; +abbxn; +abbxo; +abbxp; +abbxq; +abbxr; +abbxs; +abbxt; +abbxu; +abbxv; +abbxw; +abbxx; +abbxy; +abbxz; +abbya; +abbyb; +abbyc; +abbyd; +abbye; +abbyf; +abbyg; +abbyh; +abbyi; +abbyj; +abbyk; +abbyl; +abbym; +abbyn; +abbyo; +abbyp; +abbyq; +abbyr; +abbys; +abbyt; +abbyu; +abbyv; +abbyw; +abbyx; +abbyy; +abbyz; +abbza; +abbzb; +abbzc; +abbzd; +abbze; +abbzf; +abbzg; +abbzh; +abbzi; +abbzj; +abbzk; +abbzl; +abbzm; +abbzn; +abbzo; +abbzp; +abbzq; +abbzr; +abbzs; +abbzt; +abbzu; +abbzv; +abbzw; +abbzx; +abbzy; +abbzz; +abcaa; +abcab; +abcac; +abcad; +abcae; +abcaf; +abcag; +abcah; +abcai; +abcaj; +abcak; +abcal; +abcam; +abcan; +abcao; +abcap; +abcaq; +abcar; +abcas; +abcat; +abcau; +abcav; +abcaw; +abcax; +abcay; +abcaz; +abcba; +abcbb; +abcbc; +abcbd; +abcbe; +abcbf; +abcbg; +abcbh; +abcbi; +abcbj; +abcbk; +abcbl; +abcbm; +abcbn; +abcbo; +abcbp; +abcbq; +abcbr; +abcbs; +abcbt; +abcbu; +abcbv; +abcbw; +abcbx; +abcby; +abcbz; +abcca; +abccb; +abccc; +abccd; +abcce; +abccf; +abccg; +abcch; +abcci; +abccj; +abcck; +abccl; +abccm; +abccn; +abcco; +abccp; +abccq; +abccr; +abccs; +abcct; +abccu; +abccv; +abccw; +abccx; +abccy; +abccz; +abcda; +abcdb; +abcdc; +abcdd; +abcde; +abcdf; +abcdg; +abcdh; +abcdi; +abcdj; +abcdk; +abcdl; +abcdm; +abcdn; +abcdo; +abcdp; +abcdq; +abcdr; +abcds; +abcdt; +abcdu; +abcdv; +abcdw; +abcdx; +abcdy; +abcdz; +abcea; +abceb; +abcec; +abced; +abcee; +abcef; +abceg; +abceh; +abcei; +abcej; +abcek; +abcel; +abcem; +abcen; +abceo; +abcep; +abceq; +abcer; +abces; +abcet; +abceu; +abcev; +abcew; +abcex; +abcey; +abcez; +abcfa; +abcfb; +abcfc; +abcfd; +abcfe; +abcff; +abcfg; +abcfh; +abcfi; +abcfj; +abcfk; +abcfl; +abcfm; +abcfn; +abcfo; +abcfp; +abcfq; +abcfr; +abcfs; +abcft; +abcfu; +abcfv; +abcfw; +abcfx; +abcfy; +abcfz; +abcga; +abcgb; +abcgc; +abcgd; +abcge; +abcgf; +abcgg; +abcgh; +abcgi; +abcgj; +abcgk; +abcgl; +abcgm; +abcgn; +abcgo; +abcgp; +abcgq; +abcgr; +abcgs; +abcgt; +abcgu; +abcgv; +abcgw; +abcgx; +abcgy; +abcgz; +abcha; +abchb; +abchc; +abchd; +abche; +abchf; +abchg; +abchh; +abchi; +abchj; +abchk; +abchl; +abchm; +abchn; +abcho; +abchp; +abchq; +abchr; +abchs; +abcht; +abchu; +abchv; +abchw; +abchx; +abchy; +abchz; +abcia; +abcib; +abcic; +abcid; +abcie; +abcif; +abcig; +abcih; +abcii; +abcij; +abcik; +abcil; +abcim; +abcin; +abcio; +abcip; +abciq; +abcir; +abcis; +abcit; +abciu; +abciv; +abciw; +abcix; +abciy; +abciz; +abcja; +abcjb; +abcjc; +abcjd; +abcje; +abcjf; +abcjg; +abcjh; +abcji; +abcjj; +abcjk; +abcjl; +abcjm; +abcjn; +abcjo; +abcjp; +abcjq; +abcjr; +abcjs; +abcjt; +abcju; +abcjv; +abcjw; +abcjx; +abcjy; +abcjz; +abcka; +abckb; +abckc; +abckd; +abcke; +abckf; +abckg; +abckh; +abcki; +abckj; +abckk; +abckl; +abckm; +abckn; +abcko; +abckp; +abckq; +abckr; +abcks; +abckt; +abcku; +abckv; +abckw; +abckx; +abcky; +abckz; +abcla; +abclb; +abclc; +abcld; +abcle; +abclf; +abclg; +abclh; +abcli; +abclj; +abclk; +abcll; +abclm; +abcln; +abclo; +abclp; +abclq; +abclr; +abcls; +abclt; +abclu; +abclv; +abclw; +abclx; +abcly; +abclz; +abcma; +abcmb; +abcmc; +abcmd; +abcme; +abcmf; +abcmg; +abcmh; +abcmi; +abcmj; +abcmk; +abcml; +abcmm; +abcmn; +abcmo; +abcmp; +abcmq; +abcmr; +abcms; +abcmt; +abcmu; +abcmv; +abcmw; +abcmx; +abcmy; +abcmz; +abcna; +abcnb; +abcnc; +abcnd; +abcne; +abcnf; +abcng; +abcnh; +abcni; +abcnj; +abcnk; +abcnl; +abcnm; +abcnn; +abcno; +abcnp; +abcnq; +abcnr; +abcns; +abcnt; +abcnu; +abcnv; +abcnw; +abcnx; +abcny; +abcnz; +abcoa; +abcob; +abcoc; +abcod; +abcoe; +abcof; +abcog; +abcoh; +abcoi; +abcoj; +abcok; +abcol; +abcom; +abcon; +abcoo; +abcop; +abcoq; +abcor; +abcos; +abcot; +abcou; +abcov; +abcow; +abcox; +abcoy; +abcoz; +abcpa; +abcpb; +abcpc; +abcpd; +abcpe; +abcpf; +abcpg; +abcph; +abcpi; +abcpj; +abcpk; +abcpl; +abcpm; +abcpn; +abcpo; +abcpp; +abcpq; +abcpr; +abcps; +abcpt; +abcpu; +abcpv; +abcpw; +abcpx; +abcpy; +abcpz; +abcqa; +abcqb; +abcqc; +abcqd; +abcqe; +abcqf; +abcqg; +abcqh; +abcqi; +abcqj; +abcqk; +abcql; +abcqm; +abcqn; +abcqo; +abcqp; +abcqq; +abcqr; +abcqs; +abcqt; +abcqu; +abcqv; +abcqw; +abcqx; +abcqy; +abcqz; +abcra; +abcrb; +abcrc; +abcrd; +abcre; +abcrf; +abcrg; +abcrh; +abcri; +abcrj; +abcrk; +abcrl; +abcrm; +abcrn; +abcro; +abcrp; +abcrq; +abcrr; +abcrs; +abcrt; +abcru; +abcrv; +abcrw; +abcrx; +abcry; +abcrz; +abcsa; +abcsb; +abcsc; +abcsd; +abcse; +abcsf; +abcsg; +abcsh; +abcsi; +abcsj; +abcsk; +abcsl; +abcsm; +abcsn; +abcso; +abcsp; +abcsq; +abcsr; +abcss; +abcst; +abcsu; +abcsv; +abcsw; +abcsx; +abcsy; +abcsz; +abcta; +abctb; +abctc; +abctd; +abcte; +abctf; +abctg; +abcth; +abcti; +abctj; +abctk; +abctl; +abctm; +abctn; +abcto; +abctp; +abctq; +abctr; +abcts; +abctt; +abctu; +abctv; +abctw; +abctx; +abcty; +abctz; +abcua; +abcub; +abcuc; +abcud; +abcue; +abcuf; +abcug; +abcuh; +abcui; +abcuj; +abcuk; +abcul; +abcum; +abcun; +abcuo; +abcup; +abcuq; +abcur; +abcus; +abcut; +abcuu; +abcuv; +abcuw; +abcux; +abcuy; +abcuz; +abcva; +abcvb; +abcvc; +abcvd; +abcve; +abcvf; +abcvg; +abcvh; +abcvi; +abcvj; +abcvk; +abcvl; +abcvm; +abcvn; +abcvo; +abcvp; +abcvq; +abcvr; +abcvs; +abcvt; +abcvu; +abcvv; +abcvw; +abcvx; +abcvy; +abcvz; +abcwa; +abcwb; +abcwc; +abcwd; +abcwe; +abcwf; +abcwg; +abcwh; +abcwi; +abcwj; +abcwk; +abcwl; +abcwm; +abcwn; +abcwo; +abcwp; +abcwq; +abcwr; +abcws; +abcwt; +abcwu; +abcwv; +abcww; +abcwx; +abcwy; +abcwz; +abcxa; +abcxb; +abcxc; +abcxd; +abcxe; +abcxf; +abcxg; +abcxh; +abcxi; +abcxj; +abcxk; +abcxl; +abcxm; +abcxn; +abcxo; +abcxp; +abcxq; +abcxr; +abcxs; +abcxt; +abcxu; +abcxv; +abcxw; +abcxx; +abcxy; +abcxz; +abcya; +abcyb; +abcyc; +abcyd; +abcye; +abcyf; +abcyg; +abcyh; +abcyi; +abcyj; +abcyk; +abcyl; +abcym; +abcyn; +abcyo; +abcyp; +abcyq; +abcyr; +abcys; +abcyt; +abcyu; +abcyv; +abcyw; +abcyx; +abcyy; +abcyz; +abcza; +abczb; +abczc; +abczd; +abcze; +abczf; +abczg; +abczh; +abczi; +abczj; +abczk; +abczl; +abczm; +abczn; +abczo; +abczp; +abczq; +abczr; +abczs; +abczt; +abczu; +abczv; +abczw; +abczx; +abczy; +abczz; +abdaa; +abdab; +abdac; +abdad; +abdae; +abdaf; +abdag; +abdah; +abdai; +abdaj; +abdak; +abdal; +abdam; +abdan; +abdao; +abdap; +abdaq; +abdar; +abdas; +abdat; +abdau; +abdav; +abdaw; +abdax; +abday; +abdaz; +abdba; +abdbb; +abdbc; +abdbd; +abdbe; +abdbf; +abdbg; +abdbh; +abdbi; +abdbj; +abdbk; +abdbl; +abdbm; +abdbn; +abdbo; +abdbp; +abdbq; +abdbr; +abdbs; +abdbt; +abdbu; +abdbv; +abdbw; +abdbx; +abdby; +abdbz; +abdca; +abdcb; +abdcc; +abdcd; +abdce; +abdcf; +abdcg; +abdch; +abdci; +abdcj; +abdck; +abdcl; +abdcm; +abdcn; +abdco; +abdcp; +abdcq; +abdcr; +abdcs; +abdct; +abdcu; +abdcv; +abdcw; +abdcx; +abdcy; +abdcz; +abdda; +abddb; +abddc; +abddd; +abdde; +abddf; +abddg; +abddh; +abddi; +abddj; +abddk; +abddl; +abddm; +abddn; +abddo; +abddp; +abddq; +abddr; +abdds; +abddt; +abddu; +abddv; +abddw; +abddx; +abddy; +abddz; +abdea; +abdeb; +abdec; +abded; +abdee; +abdef; +abdeg; +abdeh; +abdei; +abdej; +abdek; +abdel; +abdem; +abden; +abdeo; +abdep; +abdeq; +abder; +abdes; +abdet; +abdeu; +abdev; +abdew; +abdex; +abdey; +abdez; +abdfa; +abdfb; +abdfc; +abdfd; +abdfe; +abdff; +abdfg; +abdfh; +abdfi; +abdfj; +abdfk; +abdfl; +abdfm; +abdfn; +abdfo; +abdfp; +abdfq; +abdfr; +abdfs; +abdft; +abdfu; +abdfv; +abdfw; +abdfx; +abdfy; +abdfz; +abdga; +abdgb; +abdgc; +abdgd; +abdge; +abdgf; +abdgg; +abdgh; +abdgi; +abdgj; +abdgk; +abdgl; +abdgm; +abdgn; +abdgo; +abdgp; +abdgq; +abdgr; +abdgs; +abdgt; +abdgu; +abdgv; +abdgw; +abdgx; +abdgy; +abdgz; +abdha; +abdhb; +abdhc; +abdhd; +abdhe; +abdhf; +abdhg; +abdhh; +abdhi; +abdhj; +abdhk; +abdhl; +abdhm; +abdhn; +abdho; +abdhp; +abdhq; +abdhr; +abdhs; +abdht; +abdhu; +abdhv; +abdhw; +abdhx; +abdhy; +abdhz; +abdia; +abdib; +abdic; +abdid; +abdie; +abdif; +abdig; +abdih; +abdii; +abdij; +abdik; +abdil; +abdim; +abdin; +abdio; +abdip; +abdiq; +abdir; +abdis; +abdit; +abdiu; +abdiv; +abdiw; +abdix; +abdiy; +abdiz; +abdja; +abdjb; +abdjc; +abdjd; +abdje; +abdjf; +abdjg; +abdjh; +abdji; +abdjj; +abdjk; +abdjl; +abdjm; +abdjn; +abdjo; +abdjp; +abdjq; +abdjr; +abdjs; +abdjt; +abdju; +abdjv; +abdjw; +abdjx; +abdjy; +abdjz; +abdka; +abdkb; +abdkc; +abdkd; +abdke; +abdkf; +abdkg; +abdkh; +abdki; +abdkj; +abdkk; +abdkl; +abdkm; +abdkn; +abdko; +abdkp; +abdkq; +abdkr; +abdks; +abdkt; +abdku; +abdkv; +abdkw; +abdkx; +abdky; +abdkz; +abdla; +abdlb; +abdlc; +abdld; +abdle; +abdlf; +abdlg; +abdlh; +abdli; +abdlj; +abdlk; +abdll; +abdlm; +abdln; +abdlo; +abdlp; +abdlq; +abdlr; +abdls; +abdlt; +abdlu; +abdlv; +abdlw; +abdlx; +abdly; +abdlz; +abdma; +abdmb; +abdmc; +abdmd; +abdme; +abdmf; +abdmg; +abdmh; +abdmi; +abdmj; +abdmk; +abdml; +abdmm; +abdmn; +abdmo; +abdmp; +abdmq; +abdmr; +abdms; +abdmt; +abdmu; +abdmv; +abdmw; +abdmx; +abdmy; +abdmz; +abdna; +abdnb; +abdnc; +abdnd; +abdne; +abdnf; +abdng; +abdnh; +abdni; +abdnj; +abdnk; +abdnl; +abdnm; +abdnn; +abdno; +abdnp; +abdnq; +abdnr; +abdns; +abdnt; +abdnu; +abdnv; +abdnw; +abdnx; +abdny; +abdnz; +abdoa; +abdob; +abdoc; +abdod; +abdoe; +abdof; +abdog; +abdoh; +abdoi; +abdoj; +abdok; +abdol; +abdom; +abdon; +abdoo; +abdop; +abdoq; +abdor; +abdos; +abdot; +abdou; +abdov; +abdow; +abdox; +abdoy; +abdoz; +abdpa; +abdpb; +abdpc; +abdpd; +aljwf +|]; diff --git a/camlp4/test/fixtures/bug-4058.ml b/camlp4/test/fixtures/bug-4058.ml new file mode 100644 index 00000000..f83322bb --- /dev/null +++ b/camlp4/test/fixtures/bug-4058.ml @@ -0,0 +1,4 @@ +let _ = (fun x -> x), 1 +let _ = (x := 1), 2 +let _ = (x <- 1), 2 +let _ = (if true then 1 else 2), 1 diff --git a/camlp4/test/fixtures/bug-4337.ml b/camlp4/test/fixtures/bug-4337.ml new file mode 100644 index 00000000..5a44ed0c --- /dev/null +++ b/camlp4/test/fixtures/bug-4337.ml @@ -0,0 +1 @@ +match [] with []°-> () | _ -> ();; diff --git a/camlp4/test/fixtures/bug-by-vincent-balat.ml b/camlp4/test/fixtures/bug-by-vincent-balat.ml new file mode 100644 index 00000000..ed75488a --- /dev/null +++ b/camlp4/test/fixtures/bug-by-vincent-balat.ml @@ -0,0 +1 @@ +fun a -> x <- !x + 1; x <- !x + 2 diff --git a/camlp4/test/fixtures/bug-camlp4o-benjamin-monate.ml b/camlp4/test/fixtures/bug-camlp4o-benjamin-monate.ml new file mode 100644 index 00000000..e7e583de --- /dev/null +++ b/camlp4/test/fixtures/bug-camlp4o-benjamin-monate.ml @@ -0,0 +1,15 @@ +type t = A of t | B ;; +let f = function A A B -> B | B | A B | A (A _) -> B ;; + +exception True +let qexists f q = + try + Queue.iter (fun v -> if f v then raise True) q; + false + with True -> true + +type u = True | False +let g x = function | True -> () | False -> () + +type v = [`True | `False] +let h x = function | `True -> () | `False -> () diff --git a/camlp4/test/fixtures/bug-camlp4o-constr-arity-expr.ml b/camlp4/test/fixtures/bug-camlp4o-constr-arity-expr.ml new file mode 100644 index 00000000..fc9b6ada --- /dev/null +++ b/camlp4/test/fixtures/bug-camlp4o-constr-arity-expr.ml @@ -0,0 +1,8 @@ +(* Some Some Some None;; *) +(* ((Some None) None) None;; *) +((Some) None);; +(* ((Some Some) Some) None;; *) +type t = A of int * int * int;; +A (1, 2, 3);; +(A) (1, 2, 3);; +(A (1, 2)) 3;; diff --git a/camlp4/test/fixtures/bug-camlp4o-constr-arity.ml b/camlp4/test/fixtures/bug-camlp4o-constr-arity.ml new file mode 100644 index 00000000..25efe042 --- /dev/null +++ b/camlp4/test/fixtures/bug-camlp4o-constr-arity.ml @@ -0,0 +1,75 @@ +type t = A of t * t | B;; +type t2 = C of (t2 * t2) | D;; +type 'a t3 = S of 'a | T;; + +fun B B B -> ();; + +fun B (A (B, B)) B -> ();; + +fun D (D, D) -> ();; + +fun (C (D, D)) -> ();; + +let A (b, B) = A (B, B);; + +let f (A (B, B)) = ();; + +let f B (A (B, B)) = ();; + +let (D, d) = (D, D);; + +let (C (D, d)) = (C (D, D));; + +function S S T -> ();; + +function Some (A (B, B)) -> ();; + +function S (A (B, B)) -> ();; + +function S (D, D) -> ();; + +function (C (D, D)) -> ();; + +function +| Some Some Some x -> x +(* | None None None x -> x *) +| _ -> assert false;; + +fun None None None -> ();; + +fun (Some None) None None -> ();; + +let Some a = Some 42;; +let Some a :: y = [Some 42];; +let Some a, b = Some 42, 43;; +let (Some a), b = Some 42, 43;; +let Some a as b = let _ = b = 42 in Some 42;; +(* let Some (a as b) = let _ = b = None in Some 42;; *) +(* let Some (a as b) = let _ = b = 42 in Some 42;; *) +(* let (Some a) as b = let _ = b = 42 in Some 42;; *) +(* let (Some a) as b = let _ = b = None in Some 42;; *) +let Some a | Some a = Some 42;; +let x,y as r = 1,2 ;; +let ((x, y) as r) = (1, 2);; + +type top = Top of (int * int);; + +match Top (1,2) with Top min as t -> ();; + +match Top (1,2) with Top (min,max) as t -> ();; + +(* let Some 'a' .. 'b' = Some 'b';; *) + +let rec f x y = ();; + +fun x y -> ();; + +fun (x, y) -> ();; + +function x, y -> ();; + +let rec next line pos0 = () in ();; + +(* fun Some None None None -> ();; *) +(* fun x, y -> ();; |+ syntax error +| *) + diff --git a/camlp4/test/fixtures/bug_escaping_quot.ml b/camlp4/test/fixtures/bug_escaping_quot.ml new file mode 100644 index 00000000..57e5ecdb --- /dev/null +++ b/camlp4/test/fixtures/bug_escaping_quot.ml @@ -0,0 +1,7 @@ +open Camlp4.PreCast;; +Camlp4_config.antiquotations := true;; +let expand_my_quot_expr _loc _loc_name_opt quotation_contents = + Printf.eprintf "%S\n%!" quotation_contents; + <:expr< dummy >> +;; +Syntax.Quotation.add "my" Syntax.Quotation.DynAst.expr_tag expand_my_quot_expr;; diff --git a/camlp4/test/fixtures/chars.ml b/camlp4/test/fixtures/chars.ml new file mode 100644 index 00000000..3d307f0a --- /dev/null +++ b/camlp4/test/fixtures/chars.ml @@ -0,0 +1 @@ +'"' diff --git a/camlp4/test/fixtures/class_expr_quot.ml b/camlp4/test/fixtures/class_expr_quot.ml new file mode 100644 index 00000000..f37e976b --- /dev/null +++ b/camlp4/test/fixtures/class_expr_quot.ml @@ -0,0 +1,27 @@ +<:class_expr< a >>; +<:class_expr< A.a B.b >>; +<:class_expr< a [ t ] >>; +<:class_expr< virtual a >>; +<:class_expr< virtual $a$ >>; +<:class_expr< virtual $lid:a$ >>; +<:class_expr< virtual $lid:a$ [ 't ] >>; +(* <:class_expr< virtual a [ t ] >>; *) +<:class_expr< $opt:v$ a >>; +<:class_expr< $opt:v$ a [ t ] >>; +<:class_expr< $opt:v$ $a$ >>; +<:class_expr< $opt:v$ $id:a$ >>; +<:class_expr< $opt:v$ $a$ [ $t$ ] >>; +(* <:class_expr< $opt:v$ a [ $t$ ] >>; *) +(* <:class_expr< $opt:v$ a $opt:t$ >>; *) +(* <:class_expr< $opt:v$ $a$ $opt:t$ >>; *) + +<:class_type< a >>; +<:class_type< a [ t ] >>; +<:class_type< virtual a >>; +<:class_type< virtual $a$ >>; +<:class_type< virtual $lid:a$ >>; +<:class_type< virtual $lid:a$ [ 't ] >>; +<:class_type< $opt:v$ a >>; +<:class_type< $opt:v$ a [ t ] >>; +<:class_type< $opt:v$ $a$ >>; +<:class_type< $opt:v$ $a$ [ $t$ ] >>; diff --git a/camlp4/test/fixtures/comments.ml b/camlp4/test/fixtures/comments.ml new file mode 100644 index 00000000..5a648766 --- /dev/null +++ b/camlp4/test/fixtures/comments.ml @@ -0,0 +1,66 @@ +(** The first special comment of the file is the comment associated + to the whole module.*) + +(** The comment for function f *) +let f x y = x + y + +(** This comment is not attached to any element since there is another + special comment just before the next element. *) + +(** Comment for exception My_exception, even with a simple comment + between the special comment and the exception.*) +(* A simple comment. *) +exception My_exception of (int -> int) * int + +(** Comment for type weather *) +type weather = +| Rain of int (** The comment for constructor Rain *) +| Sun (** The comment for constructor Sun *) + +(** The comment for type my_record *) +type my_record = { + foo : int ; (** Comment for field foo *) + bar : string ; (** Comment for field bar *) + } + +(** The comment for class my_class *) +class my_class = + object + (** A comment to describe inheritance from cl *) + inherit cl + + (** The comment for the instance variable tutu *) + val mutable tutu = "tutu" + (** The comment for toto *) + val toto = 1 + val titi = "titi" + (** Comment for method toto *) + method toto = tutu ^ "!" + (** Comment for method m *) + method m (f : float) = 1 + end + +(** The comment for class type my_class_type *) +class type my_class_type = + object + (** The comment for the instance variable x. *) + val mutable x : int + (** The commend for method m. *) + method m : int -> int + end + +(** The comment for module Foo *) +module Foo = + struct + (** The comment for x *) + let x = 42 + (** A special comment in the class, but not associated to any element. *) + end + +(** The comment for module type my_module_type. *) +module type MY_MODULE_TYPE = + sig + (* Comment for value x. *) + val x : int + (* ... *) + end diff --git a/camlp4/test/fixtures/comments.mli b/camlp4/test/fixtures/comments.mli new file mode 100644 index 00000000..33e1434b --- /dev/null +++ b/camlp4/test/fixtures/comments.mli @@ -0,0 +1,106 @@ +(** The first special comment of the file is the comment associated + with the whole module.*) + + +(** Special comments can be placed between elements and are kept + by the OCamldoc tool, but are not associated to any element. + @-tags in these comments are ignored.*) + +(*******************************************************************) +(** Comments like the one above, with more than two asterisks, + are ignored. *) + +(** The comment for function f. *) +val f : int -> int -> int +(** The continuation of the comment for function f. *) + +(** Comment for exception My_exception, even with a simple comment + between the special comment and the exception.*) +(* Hello, I'm a simple comment :-) *) +exception My_exception of (int -> int) * int + +(** Comment for type weather *) +type weather = +| Rain of int (** The comment for construtor Rain *) +| Sun (** The comment for constructor Sun *) + +(** Comment for type weather2 *) +type weather2 = +| Rain of int (** The comment for construtor Rain *) +| Sun (** The comment for constructor Sun *) +(** I can continue the comment for type weather2 here + because there is already a comment associated to the last constructor.*) + +(** The comment for type my_record *) +type my_record = { + foo : int ; (** Comment for field foo *) + bar : string ; (** Comment for field bar *) + } + (** Continuation of comment for type my_record *) + +(** Comment for foo *) +val foo : string +(** This comment is associated to foo and not to bar. *) +val bar : string +(** This comment is assciated to bar. *) + +(** The comment for class my_class *) +class my_class : + object + (** A comment to describe inheritance from cl *) + inherit cl + + (** The comment for attribute tutu *) + val mutable tutu : string + + (** The comment for attribute toto. *) + val toto : int + + (** This comment is not attached to titi since + there is a blank line before titi, but is kept + as a comment in the class. *) + + val titi : string + + (** Comment for method toto *) + method toto : string + + (** Comment for method m *) + method m : float -> int + end + +(** The comment for the class type my_class_type *) +class type my_class_type = + object + (** The comment for variable x. *) + val mutable x : int + + (** The commend for method m. *) + method m : int -> int +end + +(** The comment for module Foo *) +module Foo : + sig + (** The comment for x *) + val x : int + + (** A special comment that is kept but not associated to any element *) + end + +(** The comment for module type my_module_type. *) +module type MY_MODULE_TYPE = + sig + (** The comment for value x. *) + val x : int + + (** The comment for module M. *) + module M : + sig + (** The comment for value y. *) + val y : int + + (* ... *) + end + + end diff --git a/camlp4/test/fixtures/comments2.ml b/camlp4/test/fixtures/comments2.ml new file mode 100644 index 00000000..d99e851b --- /dev/null +++ b/camlp4/test/fixtures/comments2.ml @@ -0,0 +1,70 @@ +(** The first special comment of the file is the comment associated + to the whole module.*) + +(** The comment for function f *) +let f x y = x + y + +(** This comment is not attached to any element since there is another + special comment just before the next element. *) + +(** Comment for exception My_exception, even with a simple comment + between the special comment and the exception.*) +(* A simple comment. *) +exception My_exception of (int -> int) * int + +(** Comment for type weather *) +type weather = + (** The comment for constructor Rain *) +| Rain of int + (** The comment for constructor Sun *) +| Sun + +(** The comment for type my_record *) +type my_record = { + (** Comment for field foo *) + foo : int ; + (** Comment for field bar *) + bar : string ; + } + +(** The comment for class my_class *) +class my_class = + object + (** A comment to describe inheritance from cl *) + inherit cl + + (** The comment for the instance variable tutu *) + val mutable tutu = "tutu" + (** The comment for toto *) + val toto = 1 + val titi = "titi" + (** Comment for method toto *) + method toto = tutu ^ "!" + (** Comment for method m *) + method m (f : float) = 1 + end + +(** The comment for class type my_class_type *) +class type my_class_type = + object + (** The comment for the instance variable x. *) + val mutable x : int + (** The commend for method m. *) + method m : int -> int + end + +(** The comment for module Foo *) +module Foo = + struct + (** The comment for x *) + let x = 42 + (** A special comment in the class, but not associated to any element. *) + end + +(** The comment for module type my_module_type. *) +module type MY_MODULE_TYPE = + sig + (* Comment for value x. *) + val x : int + (* ... *) + end diff --git a/camlp4/test/fixtures/constant-parser.ml b/camlp4/test/fixtures/constant-parser.ml new file mode 100644 index 00000000..a91f54b5 --- /dev/null +++ b/camlp4/test/fixtures/constant-parser.ml @@ -0,0 +1,90 @@ +open Camlp4 + +module Id = struct + let name = "Camlp4Parsers.LoadCamlp4Ast" + let version = Sys.ocaml_version +end + +module Make (Ast : Camlp4.Sig.Camlp4Ast.S) = struct + module Ast = Ast + open Ast + + let _loc = Loc.ghost + + let parse_implem ?directive_handler:(_) _ _ = + let e = + Ast.ExApp (_loc, + Ast.ExApp (_loc, + Ast.ExId (_loc, + Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"), Ast.IdLid (_loc, "extend"))), + Ast.ExTyc (_loc, Ast.ExId (_loc, Ast.IdLid (_loc, "expr")), + Ast.TyApp (_loc, + Ast.TyId (_loc, + Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"), + Ast.IdAcc (_loc, Ast.IdUid (_loc, "Entry"), + Ast.IdLid (_loc, "t")))), + Ast.TyQuo (_loc, "expr")))), + Ast.ExTup (_loc, + Ast.ExCom (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "None")), + Ast.ExApp (_loc, + Ast.ExApp (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "::")), + Ast.ExTup (_loc, + Ast.ExCom (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "None")), + Ast.ExCom (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "None")), + Ast.ExApp (_loc, + Ast.ExApp (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "::")), + Ast.ExTup (_loc, + Ast.ExCom (_loc, + Ast.ExApp (_loc, + Ast.ExApp (_loc, + Ast.ExId (_loc, Ast.IdUid (_loc, "::")), + Ast.ExApp (_loc, + Ast.ExId (_loc, + Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"), + Ast.IdUid (_loc, "Skeyword"))), + Ast.ExStr (_loc, "foo"))), + Ast.ExId (_loc, Ast.IdUid (_loc, "[]"))), + Ast.ExApp (_loc, + Ast.ExId (_loc, + Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"), + Ast.IdAcc (_loc, Ast.IdUid (_loc, "Action"), + Ast.IdLid (_loc, "mk")))), + Ast.ExFun (_loc, + Ast.AsArr (_loc, Ast.PaAny _loc, Ast.ONone, + Ast.ExFun (_loc, + Ast.AsArr (_loc, + Ast.PaTyc (_loc, + Ast.PaId (_loc, + Ast.IdLid (_loc, "_loc")), + Ast.TyId (_loc, + Ast.IdAcc (_loc, + Ast.IdUid (_loc, "Loc"), + Ast.IdLid (_loc, "t")))), + Ast.ONone, + Ast.ExTyc (_loc, + Ast.ExApp (_loc, + Ast.ExApp (_loc, + Ast.ExId (_loc, + Ast.IdAcc (_loc, + Ast.IdUid (_loc, "Ast"), + Ast.IdUid (_loc, "ExId"))), + Ast.ExId (_loc, + Ast.IdLid (_loc, "_loc"))), + Ast.ExApp (_loc, + Ast.ExApp (_loc, + Ast.ExId (_loc, + Ast.IdAcc (_loc, + Ast.IdUid (_loc, "Ast"), + Ast.IdUid (_loc, "IdLid"))), + Ast.ExId (_loc, + Ast.IdLid (_loc, "_loc"))), + Ast.ExStr (_loc, "foo"))), + Ast.TyQuo (_loc, "expr")))))))))), + Ast.ExId (_loc, Ast.IdUid (_loc, "[]"))))))), + Ast.ExId (_loc, Ast.IdUid (_loc, "[]")))))) + in Ast.StExp (_loc, e) + let parse_interf ?directive_handler:(_) _ _ = assert false;; + +end;; + +let module M = Camlp4.Register.OCamlParser(Id)(Make) in () diff --git a/camlp4/test/fixtures/curry-constr.ml b/camlp4/test/fixtures/curry-constr.ml new file mode 100644 index 00000000..4443ece4 --- /dev/null +++ b/camlp4/test/fixtures/curry-constr.ml @@ -0,0 +1,3 @@ +type t = A of int +type u = B of t +let f = function B A x -> x diff --git a/camlp4/test/fixtures/default_quotation.ml b/camlp4/test/fixtures/default_quotation.ml new file mode 100644 index 00000000..c640507b --- /dev/null +++ b/camlp4/test/fixtures/default_quotation.ml @@ -0,0 +1,4 @@ +#default_quotation "expr"; +open Camlp4.PreCast; +fun [ << $x$ - $y$ >> when x = y -> << 0 >> + | e -> e ]; diff --git a/camlp4/test/fixtures/exception-with-eqn-bug.ml b/camlp4/test/fixtures/exception-with-eqn-bug.ml new file mode 100644 index 00000000..b93c2024 --- /dev/null +++ b/camlp4/test/fixtures/exception-with-eqn-bug.ml @@ -0,0 +1 @@ +exception Foo of string = Bar diff --git a/camlp4/test/fixtures/external.ml b/camlp4/test/fixtures/external.ml new file mode 100644 index 00000000..9ee32bba --- /dev/null +++ b/camlp4/test/fixtures/external.ml @@ -0,0 +1 @@ +external f : 'a -> 'b = "%identity"; diff --git a/camlp4/test/fixtures/fun.ml b/camlp4/test/fixtures/fun.ml new file mode 100644 index 00000000..6c3264df --- /dev/null +++ b/camlp4/test/fixtures/fun.ml @@ -0,0 +1,7 @@ +value f = fun []; +value f = fun [ [] -> fun [ 4 -> () ] ]; +value f = fun []; +value f = fun []; +value f = fun []; +value f = g x y; +value f = (g x) y; diff --git a/camlp4/test/fixtures/functor-perf.ml b/camlp4/test/fixtures/functor-perf.ml new file mode 100644 index 00000000..3e55acba --- /dev/null +++ b/camlp4/test/fixtures/functor-perf.ml @@ -0,0 +1,2019 @@ +module type S = sig +(* <%- for i in 0 .. 1000 do -%> + val f<%= i %> : int -> int -> int +<%- end -%> *) + val f0 : int -> int -> int + val f1 : int -> int -> int + val f2 : int -> int -> int + val f3 : int -> int -> int + val f4 : int -> int -> int + val f5 : int -> int -> int + val f6 : int -> int -> int + val f7 : int -> int -> int + val f8 : int -> int -> int + val f9 : int -> int -> int + val f10 : int -> int -> int + val f11 : int -> int -> int + val f12 : int -> int -> int + val f13 : int -> int -> int + val f14 : int -> int -> int + val f15 : int -> int -> int + val f16 : int -> int -> int + val f17 : int -> int -> int + val f18 : int -> int -> int + val f19 : int -> int -> int + val f20 : int -> int -> int + val f21 : int -> int -> int + val f22 : int -> int -> int + val f23 : int -> int -> int + val f24 : int -> int -> int + val f25 : int -> int -> int + val f26 : int -> int -> int + val f27 : int -> int -> int + val f28 : int -> int -> int + val f29 : int -> int -> int + val f30 : int -> int -> int + val f31 : int -> int -> int + val f32 : int -> int -> int + val f33 : int -> int -> int + val f34 : int -> int -> int + val f35 : int -> int -> int + val f36 : int -> int -> int + val f37 : int -> int -> int + val f38 : int -> int -> int + val f39 : int -> int -> int + val f40 : int -> int -> int + val f41 : int -> int -> int + val f42 : int -> int -> int + val f43 : int -> int -> int + val f44 : int -> int -> int + val f45 : int -> int -> int + val f46 : int -> int -> int + val f47 : int -> int -> int + val f48 : int -> int -> int + val f49 : int -> int -> int + val f50 : int -> int -> int + val f51 : int -> int -> int + val f52 : int -> int -> int + val f53 : int -> int -> int + val f54 : int -> int -> int + val f55 : int -> int -> int + val f56 : int -> int -> int + val f57 : int -> int -> int + val f58 : int -> int -> int + val f59 : int -> int -> int + val f60 : int -> int -> int + val f61 : int -> int -> int + val f62 : int -> int -> int + val f63 : int -> int -> int + val f64 : int -> int -> int + val f65 : int -> int -> int + val f66 : int -> int -> int + val f67 : int -> int -> int + val f68 : int -> int -> int + val f69 : int -> int -> int + val f70 : int -> int -> int + val f71 : int -> int -> int + val f72 : int -> int -> int + val f73 : int -> int -> int + val f74 : int -> int -> int + val f75 : int -> int -> int + val f76 : int -> int -> int + val f77 : int -> int -> int + val f78 : int -> int -> int + val f79 : int -> int -> int + val f80 : int -> int -> int + val f81 : int -> int -> int + val f82 : int -> int -> int + val f83 : int -> int -> int + val f84 : int -> int -> int + val f85 : int -> int -> int + val f86 : int -> int -> int + val f87 : int -> int -> int + val f88 : int -> int -> int + val f89 : int -> int -> int + val f90 : int -> int -> int + val f91 : int -> int -> int + val f92 : int -> int -> int + val f93 : int -> int -> int + val f94 : int -> int -> int + val f95 : int -> int -> int + val f96 : int -> int -> int + val f97 : int -> int -> int + val f98 : int -> int -> int + val f99 : int -> int -> int + val f100 : int -> int -> int + val f101 : int -> int -> int + val f102 : int -> int -> int + val f103 : int -> int -> int + val f104 : int -> int -> int + val f105 : int -> int -> int + val f106 : int -> int -> int + val f107 : int -> int -> int + val f108 : int -> int -> int + val f109 : int -> int -> int + val f110 : int -> int -> int + val f111 : int -> int -> int + val f112 : int -> int -> int + val f113 : int -> int -> int + val f114 : int -> int -> int + val f115 : int -> int -> int + val f116 : int -> int -> int + val f117 : int -> int -> int + val f118 : int -> int -> int + val f119 : int -> int -> int + val f120 : int -> int -> int + val f121 : int -> int -> int + val f122 : int -> int -> int + val f123 : int -> int -> int + val f124 : int -> int -> int + val f125 : int -> int -> int + val f126 : int -> int -> int + val f127 : int -> int -> int + val f128 : int -> int -> int + val f129 : int -> int -> int + val f130 : int -> int -> int + val f131 : int -> int -> int + val f132 : int -> int -> int + val f133 : int -> int -> int + val f134 : int -> int -> int + val f135 : int -> int -> int + val f136 : int -> int -> int + val f137 : int -> int -> int + val f138 : int -> int -> int + val f139 : int -> int -> int + val f140 : int -> int -> int + val f141 : int -> int -> int + val f142 : int -> int -> int + val f143 : int -> int -> int + val f144 : int -> int -> int + val f145 : int -> int -> int + val f146 : int -> int -> int + val f147 : int -> int -> int + val f148 : int -> int -> int + val f149 : int -> int -> int + val f150 : int -> int -> int + val f151 : int -> int -> int + val f152 : int -> int -> int + val f153 : int -> int -> int + val f154 : int -> int -> int + val f155 : int -> int -> int + val f156 : int -> int -> int + val f157 : int -> int -> int + val f158 : int -> int -> int + val f159 : int -> int -> int + val f160 : int -> int -> int + val f161 : int -> int -> int + val f162 : int -> int -> int + val f163 : int -> int -> int + val f164 : int -> int -> int + val f165 : int -> int -> int + val f166 : int -> int -> int + val f167 : int -> int -> int + val f168 : int -> int -> int + val f169 : int -> int -> int + val f170 : int -> int -> int + val f171 : int -> int -> int + val f172 : int -> int -> int + val f173 : int -> int -> int + val f174 : int -> int -> int + val f175 : int -> int -> int + val f176 : int -> int -> int + val f177 : int -> int -> int + val f178 : int -> int -> int + val f179 : int -> int -> int + val f180 : int -> int -> int + val f181 : int -> int -> int + val f182 : int -> int -> int + val f183 : int -> int -> int + val f184 : int -> int -> int + val f185 : int -> int -> int + val f186 : int -> int -> int + val f187 : int -> int -> int + val f188 : int -> int -> int + val f189 : int -> int -> int + val f190 : int -> int -> int + val f191 : int -> int -> int + val f192 : int -> int -> int + val f193 : int -> int -> int + val f194 : int -> int -> int + val f195 : int -> int -> int + val f196 : int -> int -> int + val f197 : int -> int -> int + val f198 : int -> int -> int + val f199 : int -> int -> int + val f200 : int -> int -> int + val f201 : int -> int -> int + val f202 : int -> int -> int + val f203 : int -> int -> int + val f204 : int -> int -> int + val f205 : int -> int -> int + val f206 : int -> int -> int + val f207 : int -> int -> int + val f208 : int -> int -> int + val f209 : int -> int -> int + val f210 : int -> int -> int + val f211 : int -> int -> int + val f212 : int -> int -> int + val f213 : int -> int -> int + val f214 : int -> int -> int + val f215 : int -> int -> int + val f216 : int -> int -> int + val f217 : int -> int -> int + val f218 : int -> int -> int + val f219 : int -> int -> int + val f220 : int -> int -> int + val f221 : int -> int -> int + val f222 : int -> int -> int + val f223 : int -> int -> int + val f224 : int -> int -> int + val f225 : int -> int -> int + val f226 : int -> int -> int + val f227 : int -> int -> int + val f228 : int -> int -> int + val f229 : int -> int -> int + val f230 : int -> int -> int + val f231 : int -> int -> int + val f232 : int -> int -> int + val f233 : int -> int -> int + val f234 : int -> int -> int + val f235 : int -> int -> int + val f236 : int -> int -> int + val f237 : int -> int -> int + val f238 : int -> int -> int + val f239 : int -> int -> int + val f240 : int -> int -> int + val f241 : int -> int -> int + val f242 : int -> int -> int + val f243 : int -> int -> int + val f244 : int -> int -> int + val f245 : int -> int -> int + val f246 : int -> int -> int + val f247 : int -> int -> int + val f248 : int -> int -> int + val f249 : int -> int -> int + val f250 : int -> int -> int + val f251 : int -> int -> int + val f252 : int -> int -> int + val f253 : int -> int -> int + val f254 : int -> int -> int + val f255 : int -> int -> int + val f256 : int -> int -> int + val f257 : int -> int -> int + val f258 : int -> int -> int + val f259 : int -> int -> int + val f260 : int -> int -> int + val f261 : int -> int -> int + val f262 : int -> int -> int + val f263 : int -> int -> int + val f264 : int -> int -> int + val f265 : int -> int -> int + val f266 : int -> int -> int + val f267 : int -> int -> int + val f268 : int -> int -> int + val f269 : int -> int -> int + val f270 : int -> int -> int + val f271 : int -> int -> int + val f272 : int -> int -> int + val f273 : int -> int -> int + val f274 : int -> int -> int + val f275 : int -> int -> int + val f276 : int -> int -> int + val f277 : int -> int -> int + val f278 : int -> int -> int + val f279 : int -> int -> int + val f280 : int -> int -> int + val f281 : int -> int -> int + val f282 : int -> int -> int + val f283 : int -> int -> int + val f284 : int -> int -> int + val f285 : int -> int -> int + val f286 : int -> int -> int + val f287 : int -> int -> int + val f288 : int -> int -> int + val f289 : int -> int -> int + val f290 : int -> int -> int + val f291 : int -> int -> int + val f292 : int -> int -> int + val f293 : int -> int -> int + val f294 : int -> int -> int + val f295 : int -> int -> int + val f296 : int -> int -> int + val f297 : int -> int -> int + val f298 : int -> int -> int + val f299 : int -> int -> int + val f300 : int -> int -> int + val f301 : int -> int -> int + val f302 : int -> int -> int + val f303 : int -> int -> int + val f304 : int -> int -> int + val f305 : int -> int -> int + val f306 : int -> int -> int + val f307 : int -> int -> int + val f308 : int -> int -> int + val f309 : int -> int -> int + val f310 : int -> int -> int + val f311 : int -> int -> int + val f312 : int -> int -> int + val f313 : int -> int -> int + val f314 : int -> int -> int + val f315 : int -> int -> int + val f316 : int -> int -> int + val f317 : int -> int -> int + val f318 : int -> int -> int + val f319 : int -> int -> int + val f320 : int -> int -> int + val f321 : int -> int -> int + val f322 : int -> int -> int + val f323 : int -> int -> int + val f324 : int -> int -> int + val f325 : int -> int -> int + val f326 : int -> int -> int + val f327 : int -> int -> int + val f328 : int -> int -> int + val f329 : int -> int -> int + val f330 : int -> int -> int + val f331 : int -> int -> int + val f332 : int -> int -> int + val f333 : int -> int -> int + val f334 : int -> int -> int + val f335 : int -> int -> int + val f336 : int -> int -> int + val f337 : int -> int -> int + val f338 : int -> int -> int + val f339 : int -> int -> int + val f340 : int -> int -> int + val f341 : int -> int -> int + val f342 : int -> int -> int + val f343 : int -> int -> int + val f344 : int -> int -> int + val f345 : int -> int -> int + val f346 : int -> int -> int + val f347 : int -> int -> int + val f348 : int -> int -> int + val f349 : int -> int -> int + val f350 : int -> int -> int + val f351 : int -> int -> int + val f352 : int -> int -> int + val f353 : int -> int -> int + val f354 : int -> int -> int + val f355 : int -> int -> int + val f356 : int -> int -> int + val f357 : int -> int -> int + val f358 : int -> int -> int + val f359 : int -> int -> int + val f360 : int -> int -> int + val f361 : int -> int -> int + val f362 : int -> int -> int + val f363 : int -> int -> int + val f364 : int -> int -> int + val f365 : int -> int -> int + val f366 : int -> int -> int + val f367 : int -> int -> int + val f368 : int -> int -> int + val f369 : int -> int -> int + val f370 : int -> int -> int + val f371 : int -> int -> int + val f372 : int -> int -> int + val f373 : int -> int -> int + val f374 : int -> int -> int + val f375 : int -> int -> int + val f376 : int -> int -> int + val f377 : int -> int -> int + val f378 : int -> int -> int + val f379 : int -> int -> int + val f380 : int -> int -> int + val f381 : int -> int -> int + val f382 : int -> int -> int + val f383 : int -> int -> int + val f384 : int -> int -> int + val f385 : int -> int -> int + val f386 : int -> int -> int + val f387 : int -> int -> int + val f388 : int -> int -> int + val f389 : int -> int -> int + val f390 : int -> int -> int + val f391 : int -> int -> int + val f392 : int -> int -> int + val f393 : int -> int -> int + val f394 : int -> int -> int + val f395 : int -> int -> int + val f396 : int -> int -> int + val f397 : int -> int -> int + val f398 : int -> int -> int + val f399 : int -> int -> int + val f400 : int -> int -> int + val f401 : int -> int -> int + val f402 : int -> int -> int + val f403 : int -> int -> int + val f404 : int -> int -> int + val f405 : int -> int -> int + val f406 : int -> int -> int + val f407 : int -> int -> int + val f408 : int -> int -> int + val f409 : int -> int -> int + val f410 : int -> int -> int + val f411 : int -> int -> int + val f412 : int -> int -> int + val f413 : int -> int -> int + val f414 : int -> int -> int + val f415 : int -> int -> int + val f416 : int -> int -> int + val f417 : int -> int -> int + val f418 : int -> int -> int + val f419 : int -> int -> int + val f420 : int -> int -> int + val f421 : int -> int -> int + val f422 : int -> int -> int + val f423 : int -> int -> int + val f424 : int -> int -> int + val f425 : int -> int -> int + val f426 : int -> int -> int + val f427 : int -> int -> int + val f428 : int -> int -> int + val f429 : int -> int -> int + val f430 : int -> int -> int + val f431 : int -> int -> int + val f432 : int -> int -> int + val f433 : int -> int -> int + val f434 : int -> int -> int + val f435 : int -> int -> int + val f436 : int -> int -> int + val f437 : int -> int -> int + val f438 : int -> int -> int + val f439 : int -> int -> int + val f440 : int -> int -> int + val f441 : int -> int -> int + val f442 : int -> int -> int + val f443 : int -> int -> int + val f444 : int -> int -> int + val f445 : int -> int -> int + val f446 : int -> int -> int + val f447 : int -> int -> int + val f448 : int -> int -> int + val f449 : int -> int -> int + val f450 : int -> int -> int + val f451 : int -> int -> int + val f452 : int -> int -> int + val f453 : int -> int -> int + val f454 : int -> int -> int + val f455 : int -> int -> int + val f456 : int -> int -> int + val f457 : int -> int -> int + val f458 : int -> int -> int + val f459 : int -> int -> int + val f460 : int -> int -> int + val f461 : int -> int -> int + val f462 : int -> int -> int + val f463 : int -> int -> int + val f464 : int -> int -> int + val f465 : int -> int -> int + val f466 : int -> int -> int + val f467 : int -> int -> int + val f468 : int -> int -> int + val f469 : int -> int -> int + val f470 : int -> int -> int + val f471 : int -> int -> int + val f472 : int -> int -> int + val f473 : int -> int -> int + val f474 : int -> int -> int + val f475 : int -> int -> int + val f476 : int -> int -> int + val f477 : int -> int -> int + val f478 : int -> int -> int + val f479 : int -> int -> int + val f480 : int -> int -> int + val f481 : int -> int -> int + val f482 : int -> int -> int + val f483 : int -> int -> int + val f484 : int -> int -> int + val f485 : int -> int -> int + val f486 : int -> int -> int + val f487 : int -> int -> int + val f488 : int -> int -> int + val f489 : int -> int -> int + val f490 : int -> int -> int + val f491 : int -> int -> int + val f492 : int -> int -> int + val f493 : int -> int -> int + val f494 : int -> int -> int + val f495 : int -> int -> int + val f496 : int -> int -> int + val f497 : int -> int -> int + val f498 : int -> int -> int + val f499 : int -> int -> int + val f500 : int -> int -> int + val f501 : int -> int -> int + val f502 : int -> int -> int + val f503 : int -> int -> int + val f504 : int -> int -> int + val f505 : int -> int -> int + val f506 : int -> int -> int + val f507 : int -> int -> int + val f508 : int -> int -> int + val f509 : int -> int -> int + val f510 : int -> int -> int + val f511 : int -> int -> int + val f512 : int -> int -> int + val f513 : int -> int -> int + val f514 : int -> int -> int + val f515 : int -> int -> int + val f516 : int -> int -> int + val f517 : int -> int -> int + val f518 : int -> int -> int + val f519 : int -> int -> int + val f520 : int -> int -> int + val f521 : int -> int -> int + val f522 : int -> int -> int + val f523 : int -> int -> int + val f524 : int -> int -> int + val f525 : int -> int -> int + val f526 : int -> int -> int + val f527 : int -> int -> int + val f528 : int -> int -> int + val f529 : int -> int -> int + val f530 : int -> int -> int + val f531 : int -> int -> int + val f532 : int -> int -> int + val f533 : int -> int -> int + val f534 : int -> int -> int + val f535 : int -> int -> int + val f536 : int -> int -> int + val f537 : int -> int -> int + val f538 : int -> int -> int + val f539 : int -> int -> int + val f540 : int -> int -> int + val f541 : int -> int -> int + val f542 : int -> int -> int + val f543 : int -> int -> int + val f544 : int -> int -> int + val f545 : int -> int -> int + val f546 : int -> int -> int + val f547 : int -> int -> int + val f548 : int -> int -> int + val f549 : int -> int -> int + val f550 : int -> int -> int + val f551 : int -> int -> int + val f552 : int -> int -> int + val f553 : int -> int -> int + val f554 : int -> int -> int + val f555 : int -> int -> int + val f556 : int -> int -> int + val f557 : int -> int -> int + val f558 : int -> int -> int + val f559 : int -> int -> int + val f560 : int -> int -> int + val f561 : int -> int -> int + val f562 : int -> int -> int + val f563 : int -> int -> int + val f564 : int -> int -> int + val f565 : int -> int -> int + val f566 : int -> int -> int + val f567 : int -> int -> int + val f568 : int -> int -> int + val f569 : int -> int -> int + val f570 : int -> int -> int + val f571 : int -> int -> int + val f572 : int -> int -> int + val f573 : int -> int -> int + val f574 : int -> int -> int + val f575 : int -> int -> int + val f576 : int -> int -> int + val f577 : int -> int -> int + val f578 : int -> int -> int + val f579 : int -> int -> int + val f580 : int -> int -> int + val f581 : int -> int -> int + val f582 : int -> int -> int + val f583 : int -> int -> int + val f584 : int -> int -> int + val f585 : int -> int -> int + val f586 : int -> int -> int + val f587 : int -> int -> int + val f588 : int -> int -> int + val f589 : int -> int -> int + val f590 : int -> int -> int + val f591 : int -> int -> int + val f592 : int -> int -> int + val f593 : int -> int -> int + val f594 : int -> int -> int + val f595 : int -> int -> int + val f596 : int -> int -> int + val f597 : int -> int -> int + val f598 : int -> int -> int + val f599 : int -> int -> int + val f600 : int -> int -> int + val f601 : int -> int -> int + val f602 : int -> int -> int + val f603 : int -> int -> int + val f604 : int -> int -> int + val f605 : int -> int -> int + val f606 : int -> int -> int + val f607 : int -> int -> int + val f608 : int -> int -> int + val f609 : int -> int -> int + val f610 : int -> int -> int + val f611 : int -> int -> int + val f612 : int -> int -> int + val f613 : int -> int -> int + val f614 : int -> int -> int + val f615 : int -> int -> int + val f616 : int -> int -> int + val f617 : int -> int -> int + val f618 : int -> int -> int + val f619 : int -> int -> int + val f620 : int -> int -> int + val f621 : int -> int -> int + val f622 : int -> int -> int + val f623 : int -> int -> int + val f624 : int -> int -> int + val f625 : int -> int -> int + val f626 : int -> int -> int + val f627 : int -> int -> int + val f628 : int -> int -> int + val f629 : int -> int -> int + val f630 : int -> int -> int + val f631 : int -> int -> int + val f632 : int -> int -> int + val f633 : int -> int -> int + val f634 : int -> int -> int + val f635 : int -> int -> int + val f636 : int -> int -> int + val f637 : int -> int -> int + val f638 : int -> int -> int + val f639 : int -> int -> int + val f640 : int -> int -> int + val f641 : int -> int -> int + val f642 : int -> int -> int + val f643 : int -> int -> int + val f644 : int -> int -> int + val f645 : int -> int -> int + val f646 : int -> int -> int + val f647 : int -> int -> int + val f648 : int -> int -> int + val f649 : int -> int -> int + val f650 : int -> int -> int + val f651 : int -> int -> int + val f652 : int -> int -> int + val f653 : int -> int -> int + val f654 : int -> int -> int + val f655 : int -> int -> int + val f656 : int -> int -> int + val f657 : int -> int -> int + val f658 : int -> int -> int + val f659 : int -> int -> int + val f660 : int -> int -> int + val f661 : int -> int -> int + val f662 : int -> int -> int + val f663 : int -> int -> int + val f664 : int -> int -> int + val f665 : int -> int -> int + val f666 : int -> int -> int + val f667 : int -> int -> int + val f668 : int -> int -> int + val f669 : int -> int -> int + val f670 : int -> int -> int + val f671 : int -> int -> int + val f672 : int -> int -> int + val f673 : int -> int -> int + val f674 : int -> int -> int + val f675 : int -> int -> int + val f676 : int -> int -> int + val f677 : int -> int -> int + val f678 : int -> int -> int + val f679 : int -> int -> int + val f680 : int -> int -> int + val f681 : int -> int -> int + val f682 : int -> int -> int + val f683 : int -> int -> int + val f684 : int -> int -> int + val f685 : int -> int -> int + val f686 : int -> int -> int + val f687 : int -> int -> int + val f688 : int -> int -> int + val f689 : int -> int -> int + val f690 : int -> int -> int + val f691 : int -> int -> int + val f692 : int -> int -> int + val f693 : int -> int -> int + val f694 : int -> int -> int + val f695 : int -> int -> int + val f696 : int -> int -> int + val f697 : int -> int -> int + val f698 : int -> int -> int + val f699 : int -> int -> int + val f700 : int -> int -> int + val f701 : int -> int -> int + val f702 : int -> int -> int + val f703 : int -> int -> int + val f704 : int -> int -> int + val f705 : int -> int -> int + val f706 : int -> int -> int + val f707 : int -> int -> int + val f708 : int -> int -> int + val f709 : int -> int -> int + val f710 : int -> int -> int + val f711 : int -> int -> int + val f712 : int -> int -> int + val f713 : int -> int -> int + val f714 : int -> int -> int + val f715 : int -> int -> int + val f716 : int -> int -> int + val f717 : int -> int -> int + val f718 : int -> int -> int + val f719 : int -> int -> int + val f720 : int -> int -> int + val f721 : int -> int -> int + val f722 : int -> int -> int + val f723 : int -> int -> int + val f724 : int -> int -> int + val f725 : int -> int -> int + val f726 : int -> int -> int + val f727 : int -> int -> int + val f728 : int -> int -> int + val f729 : int -> int -> int + val f730 : int -> int -> int + val f731 : int -> int -> int + val f732 : int -> int -> int + val f733 : int -> int -> int + val f734 : int -> int -> int + val f735 : int -> int -> int + val f736 : int -> int -> int + val f737 : int -> int -> int + val f738 : int -> int -> int + val f739 : int -> int -> int + val f740 : int -> int -> int + val f741 : int -> int -> int + val f742 : int -> int -> int + val f743 : int -> int -> int + val f744 : int -> int -> int + val f745 : int -> int -> int + val f746 : int -> int -> int + val f747 : int -> int -> int + val f748 : int -> int -> int + val f749 : int -> int -> int + val f750 : int -> int -> int + val f751 : int -> int -> int + val f752 : int -> int -> int + val f753 : int -> int -> int + val f754 : int -> int -> int + val f755 : int -> int -> int + val f756 : int -> int -> int + val f757 : int -> int -> int + val f758 : int -> int -> int + val f759 : int -> int -> int + val f760 : int -> int -> int + val f761 : int -> int -> int + val f762 : int -> int -> int + val f763 : int -> int -> int + val f764 : int -> int -> int + val f765 : int -> int -> int + val f766 : int -> int -> int + val f767 : int -> int -> int + val f768 : int -> int -> int + val f769 : int -> int -> int + val f770 : int -> int -> int + val f771 : int -> int -> int + val f772 : int -> int -> int + val f773 : int -> int -> int + val f774 : int -> int -> int + val f775 : int -> int -> int + val f776 : int -> int -> int + val f777 : int -> int -> int + val f778 : int -> int -> int + val f779 : int -> int -> int + val f780 : int -> int -> int + val f781 : int -> int -> int + val f782 : int -> int -> int + val f783 : int -> int -> int + val f784 : int -> int -> int + val f785 : int -> int -> int + val f786 : int -> int -> int + val f787 : int -> int -> int + val f788 : int -> int -> int + val f789 : int -> int -> int + val f790 : int -> int -> int + val f791 : int -> int -> int + val f792 : int -> int -> int + val f793 : int -> int -> int + val f794 : int -> int -> int + val f795 : int -> int -> int + val f796 : int -> int -> int + val f797 : int -> int -> int + val f798 : int -> int -> int + val f799 : int -> int -> int + val f800 : int -> int -> int + val f801 : int -> int -> int + val f802 : int -> int -> int + val f803 : int -> int -> int + val f804 : int -> int -> int + val f805 : int -> int -> int + val f806 : int -> int -> int + val f807 : int -> int -> int + val f808 : int -> int -> int + val f809 : int -> int -> int + val f810 : int -> int -> int + val f811 : int -> int -> int + val f812 : int -> int -> int + val f813 : int -> int -> int + val f814 : int -> int -> int + val f815 : int -> int -> int + val f816 : int -> int -> int + val f817 : int -> int -> int + val f818 : int -> int -> int + val f819 : int -> int -> int + val f820 : int -> int -> int + val f821 : int -> int -> int + val f822 : int -> int -> int + val f823 : int -> int -> int + val f824 : int -> int -> int + val f825 : int -> int -> int + val f826 : int -> int -> int + val f827 : int -> int -> int + val f828 : int -> int -> int + val f829 : int -> int -> int + val f830 : int -> int -> int + val f831 : int -> int -> int + val f832 : int -> int -> int + val f833 : int -> int -> int + val f834 : int -> int -> int + val f835 : int -> int -> int + val f836 : int -> int -> int + val f837 : int -> int -> int + val f838 : int -> int -> int + val f839 : int -> int -> int + val f840 : int -> int -> int + val f841 : int -> int -> int + val f842 : int -> int -> int + val f843 : int -> int -> int + val f844 : int -> int -> int + val f845 : int -> int -> int + val f846 : int -> int -> int + val f847 : int -> int -> int + val f848 : int -> int -> int + val f849 : int -> int -> int + val f850 : int -> int -> int + val f851 : int -> int -> int + val f852 : int -> int -> int + val f853 : int -> int -> int + val f854 : int -> int -> int + val f855 : int -> int -> int + val f856 : int -> int -> int + val f857 : int -> int -> int + val f858 : int -> int -> int + val f859 : int -> int -> int + val f860 : int -> int -> int + val f861 : int -> int -> int + val f862 : int -> int -> int + val f863 : int -> int -> int + val f864 : int -> int -> int + val f865 : int -> int -> int + val f866 : int -> int -> int + val f867 : int -> int -> int + val f868 : int -> int -> int + val f869 : int -> int -> int + val f870 : int -> int -> int + val f871 : int -> int -> int + val f872 : int -> int -> int + val f873 : int -> int -> int + val f874 : int -> int -> int + val f875 : int -> int -> int + val f876 : int -> int -> int + val f877 : int -> int -> int + val f878 : int -> int -> int + val f879 : int -> int -> int + val f880 : int -> int -> int + val f881 : int -> int -> int + val f882 : int -> int -> int + val f883 : int -> int -> int + val f884 : int -> int -> int + val f885 : int -> int -> int + val f886 : int -> int -> int + val f887 : int -> int -> int + val f888 : int -> int -> int + val f889 : int -> int -> int + val f890 : int -> int -> int + val f891 : int -> int -> int + val f892 : int -> int -> int + val f893 : int -> int -> int + val f894 : int -> int -> int + val f895 : int -> int -> int + val f896 : int -> int -> int + val f897 : int -> int -> int + val f898 : int -> int -> int + val f899 : int -> int -> int + val f900 : int -> int -> int + val f901 : int -> int -> int + val f902 : int -> int -> int + val f903 : int -> int -> int + val f904 : int -> int -> int + val f905 : int -> int -> int + val f906 : int -> int -> int + val f907 : int -> int -> int + val f908 : int -> int -> int + val f909 : int -> int -> int + val f910 : int -> int -> int + val f911 : int -> int -> int + val f912 : int -> int -> int + val f913 : int -> int -> int + val f914 : int -> int -> int + val f915 : int -> int -> int + val f916 : int -> int -> int + val f917 : int -> int -> int + val f918 : int -> int -> int + val f919 : int -> int -> int + val f920 : int -> int -> int + val f921 : int -> int -> int + val f922 : int -> int -> int + val f923 : int -> int -> int + val f924 : int -> int -> int + val f925 : int -> int -> int + val f926 : int -> int -> int + val f927 : int -> int -> int + val f928 : int -> int -> int + val f929 : int -> int -> int + val f930 : int -> int -> int + val f931 : int -> int -> int + val f932 : int -> int -> int + val f933 : int -> int -> int + val f934 : int -> int -> int + val f935 : int -> int -> int + val f936 : int -> int -> int + val f937 : int -> int -> int + val f938 : int -> int -> int + val f939 : int -> int -> int + val f940 : int -> int -> int + val f941 : int -> int -> int + val f942 : int -> int -> int + val f943 : int -> int -> int + val f944 : int -> int -> int + val f945 : int -> int -> int + val f946 : int -> int -> int + val f947 : int -> int -> int + val f948 : int -> int -> int + val f949 : int -> int -> int + val f950 : int -> int -> int + val f951 : int -> int -> int + val f952 : int -> int -> int + val f953 : int -> int -> int + val f954 : int -> int -> int + val f955 : int -> int -> int + val f956 : int -> int -> int + val f957 : int -> int -> int + val f958 : int -> int -> int + val f959 : int -> int -> int + val f960 : int -> int -> int + val f961 : int -> int -> int + val f962 : int -> int -> int + val f963 : int -> int -> int + val f964 : int -> int -> int + val f965 : int -> int -> int + val f966 : int -> int -> int + val f967 : int -> int -> int + val f968 : int -> int -> int + val f969 : int -> int -> int + val f970 : int -> int -> int + val f971 : int -> int -> int + val f972 : int -> int -> int + val f973 : int -> int -> int + val f974 : int -> int -> int + val f975 : int -> int -> int + val f976 : int -> int -> int + val f977 : int -> int -> int + val f978 : int -> int -> int + val f979 : int -> int -> int + val f980 : int -> int -> int + val f981 : int -> int -> int + val f982 : int -> int -> int + val f983 : int -> int -> int + val f984 : int -> int -> int + val f985 : int -> int -> int + val f986 : int -> int -> int + val f987 : int -> int -> int + val f988 : int -> int -> int + val f989 : int -> int -> int + val f990 : int -> int -> int + val f991 : int -> int -> int + val f992 : int -> int -> int + val f993 : int -> int -> int + val f994 : int -> int -> int + val f995 : int -> int -> int + val f996 : int -> int -> int + val f997 : int -> int -> int + val f998 : int -> int -> int + val f999 : int -> int -> int + val f1000 : int -> int -> int +end + +module Make (M : S) = struct + include M +end + +module M = struct +(* <%- for i in 0 .. 1000 do -%> + let f<%= i %> = ( + ) +<%- end -%> *) + let f0 = ( + ) + let f1 = ( + ) + let f2 = ( + ) + let f3 = ( + ) + let f4 = ( + ) + let f5 = ( + ) + let f6 = ( + ) + let f7 = ( + ) + let f8 = ( + ) + let f9 = ( + ) + let f10 = ( + ) + let f11 = ( + ) + let f12 = ( + ) + let f13 = ( + ) + let f14 = ( + ) + let f15 = ( + ) + let f16 = ( + ) + let f17 = ( + ) + let f18 = ( + ) + let f19 = ( + ) + let f20 = ( + ) + let f21 = ( + ) + let f22 = ( + ) + let f23 = ( + ) + let f24 = ( + ) + let f25 = ( + ) + let f26 = ( + ) + let f27 = ( + ) + let f28 = ( + ) + let f29 = ( + ) + let f30 = ( + ) + let f31 = ( + ) + let f32 = ( + ) + let f33 = ( + ) + let f34 = ( + ) + let f35 = ( + ) + let f36 = ( + ) + let f37 = ( + ) + let f38 = ( + ) + let f39 = ( + ) + let f40 = ( + ) + let f41 = ( + ) + let f42 = ( + ) + let f43 = ( + ) + let f44 = ( + ) + let f45 = ( + ) + let f46 = ( + ) + let f47 = ( + ) + let f48 = ( + ) + let f49 = ( + ) + let f50 = ( + ) + let f51 = ( + ) + let f52 = ( + ) + let f53 = ( + ) + let f54 = ( + ) + let f55 = ( + ) + let f56 = ( + ) + let f57 = ( + ) + let f58 = ( + ) + let f59 = ( + ) + let f60 = ( + ) + let f61 = ( + ) + let f62 = ( + ) + let f63 = ( + ) + let f64 = ( + ) + let f65 = ( + ) + let f66 = ( + ) + let f67 = ( + ) + let f68 = ( + ) + let f69 = ( + ) + let f70 = ( + ) + let f71 = ( + ) + let f72 = ( + ) + let f73 = ( + ) + let f74 = ( + ) + let f75 = ( + ) + let f76 = ( + ) + let f77 = ( + ) + let f78 = ( + ) + let f79 = ( + ) + let f80 = ( + ) + let f81 = ( + ) + let f82 = ( + ) + let f83 = ( + ) + let f84 = ( + ) + let f85 = ( + ) + let f86 = ( + ) + let f87 = ( + ) + let f88 = ( + ) + let f89 = ( + ) + let f90 = ( + ) + let f91 = ( + ) + let f92 = ( + ) + let f93 = ( + ) + let f94 = ( + ) + let f95 = ( + ) + let f96 = ( + ) + let f97 = ( + ) + let f98 = ( + ) + let f99 = ( + ) + let f100 = ( + ) + let f101 = ( + ) + let f102 = ( + ) + let f103 = ( + ) + let f104 = ( + ) + let f105 = ( + ) + let f106 = ( + ) + let f107 = ( + ) + let f108 = ( + ) + let f109 = ( + ) + let f110 = ( + ) + let f111 = ( + ) + let f112 = ( + ) + let f113 = ( + ) + let f114 = ( + ) + let f115 = ( + ) + let f116 = ( + ) + let f117 = ( + ) + let f118 = ( + ) + let f119 = ( + ) + let f120 = ( + ) + let f121 = ( + ) + let f122 = ( + ) + let f123 = ( + ) + let f124 = ( + ) + let f125 = ( + ) + let f126 = ( + ) + let f127 = ( + ) + let f128 = ( + ) + let f129 = ( + ) + let f130 = ( + ) + let f131 = ( + ) + let f132 = ( + ) + let f133 = ( + ) + let f134 = ( + ) + let f135 = ( + ) + let f136 = ( + ) + let f137 = ( + ) + let f138 = ( + ) + let f139 = ( + ) + let f140 = ( + ) + let f141 = ( + ) + let f142 = ( + ) + let f143 = ( + ) + let f144 = ( + ) + let f145 = ( + ) + let f146 = ( + ) + let f147 = ( + ) + let f148 = ( + ) + let f149 = ( + ) + let f150 = ( + ) + let f151 = ( + ) + let f152 = ( + ) + let f153 = ( + ) + let f154 = ( + ) + let f155 = ( + ) + let f156 = ( + ) + let f157 = ( + ) + let f158 = ( + ) + let f159 = ( + ) + let f160 = ( + ) + let f161 = ( + ) + let f162 = ( + ) + let f163 = ( + ) + let f164 = ( + ) + let f165 = ( + ) + let f166 = ( + ) + let f167 = ( + ) + let f168 = ( + ) + let f169 = ( + ) + let f170 = ( + ) + let f171 = ( + ) + let f172 = ( + ) + let f173 = ( + ) + let f174 = ( + ) + let f175 = ( + ) + let f176 = ( + ) + let f177 = ( + ) + let f178 = ( + ) + let f179 = ( + ) + let f180 = ( + ) + let f181 = ( + ) + let f182 = ( + ) + let f183 = ( + ) + let f184 = ( + ) + let f185 = ( + ) + let f186 = ( + ) + let f187 = ( + ) + let f188 = ( + ) + let f189 = ( + ) + let f190 = ( + ) + let f191 = ( + ) + let f192 = ( + ) + let f193 = ( + ) + let f194 = ( + ) + let f195 = ( + ) + let f196 = ( + ) + let f197 = ( + ) + let f198 = ( + ) + let f199 = ( + ) + let f200 = ( + ) + let f201 = ( + ) + let f202 = ( + ) + let f203 = ( + ) + let f204 = ( + ) + let f205 = ( + ) + let f206 = ( + ) + let f207 = ( + ) + let f208 = ( + ) + let f209 = ( + ) + let f210 = ( + ) + let f211 = ( + ) + let f212 = ( + ) + let f213 = ( + ) + let f214 = ( + ) + let f215 = ( + ) + let f216 = ( + ) + let f217 = ( + ) + let f218 = ( + ) + let f219 = ( + ) + let f220 = ( + ) + let f221 = ( + ) + let f222 = ( + ) + let f223 = ( + ) + let f224 = ( + ) + let f225 = ( + ) + let f226 = ( + ) + let f227 = ( + ) + let f228 = ( + ) + let f229 = ( + ) + let f230 = ( + ) + let f231 = ( + ) + let f232 = ( + ) + let f233 = ( + ) + let f234 = ( + ) + let f235 = ( + ) + let f236 = ( + ) + let f237 = ( + ) + let f238 = ( + ) + let f239 = ( + ) + let f240 = ( + ) + let f241 = ( + ) + let f242 = ( + ) + let f243 = ( + ) + let f244 = ( + ) + let f245 = ( + ) + let f246 = ( + ) + let f247 = ( + ) + let f248 = ( + ) + let f249 = ( + ) + let f250 = ( + ) + let f251 = ( + ) + let f252 = ( + ) + let f253 = ( + ) + let f254 = ( + ) + let f255 = ( + ) + let f256 = ( + ) + let f257 = ( + ) + let f258 = ( + ) + let f259 = ( + ) + let f260 = ( + ) + let f261 = ( + ) + let f262 = ( + ) + let f263 = ( + ) + let f264 = ( + ) + let f265 = ( + ) + let f266 = ( + ) + let f267 = ( + ) + let f268 = ( + ) + let f269 = ( + ) + let f270 = ( + ) + let f271 = ( + ) + let f272 = ( + ) + let f273 = ( + ) + let f274 = ( + ) + let f275 = ( + ) + let f276 = ( + ) + let f277 = ( + ) + let f278 = ( + ) + let f279 = ( + ) + let f280 = ( + ) + let f281 = ( + ) + let f282 = ( + ) + let f283 = ( + ) + let f284 = ( + ) + let f285 = ( + ) + let f286 = ( + ) + let f287 = ( + ) + let f288 = ( + ) + let f289 = ( + ) + let f290 = ( + ) + let f291 = ( + ) + let f292 = ( + ) + let f293 = ( + ) + let f294 = ( + ) + let f295 = ( + ) + let f296 = ( + ) + let f297 = ( + ) + let f298 = ( + ) + let f299 = ( + ) + let f300 = ( + ) + let f301 = ( + ) + let f302 = ( + ) + let f303 = ( + ) + let f304 = ( + ) + let f305 = ( + ) + let f306 = ( + ) + let f307 = ( + ) + let f308 = ( + ) + let f309 = ( + ) + let f310 = ( + ) + let f311 = ( + ) + let f312 = ( + ) + let f313 = ( + ) + let f314 = ( + ) + let f315 = ( + ) + let f316 = ( + ) + let f317 = ( + ) + let f318 = ( + ) + let f319 = ( + ) + let f320 = ( + ) + let f321 = ( + ) + let f322 = ( + ) + let f323 = ( + ) + let f324 = ( + ) + let f325 = ( + ) + let f326 = ( + ) + let f327 = ( + ) + let f328 = ( + ) + let f329 = ( + ) + let f330 = ( + ) + let f331 = ( + ) + let f332 = ( + ) + let f333 = ( + ) + let f334 = ( + ) + let f335 = ( + ) + let f336 = ( + ) + let f337 = ( + ) + let f338 = ( + ) + let f339 = ( + ) + let f340 = ( + ) + let f341 = ( + ) + let f342 = ( + ) + let f343 = ( + ) + let f344 = ( + ) + let f345 = ( + ) + let f346 = ( + ) + let f347 = ( + ) + let f348 = ( + ) + let f349 = ( + ) + let f350 = ( + ) + let f351 = ( + ) + let f352 = ( + ) + let f353 = ( + ) + let f354 = ( + ) + let f355 = ( + ) + let f356 = ( + ) + let f357 = ( + ) + let f358 = ( + ) + let f359 = ( + ) + let f360 = ( + ) + let f361 = ( + ) + let f362 = ( + ) + let f363 = ( + ) + let f364 = ( + ) + let f365 = ( + ) + let f366 = ( + ) + let f367 = ( + ) + let f368 = ( + ) + let f369 = ( + ) + let f370 = ( + ) + let f371 = ( + ) + let f372 = ( + ) + let f373 = ( + ) + let f374 = ( + ) + let f375 = ( + ) + let f376 = ( + ) + let f377 = ( + ) + let f378 = ( + ) + let f379 = ( + ) + let f380 = ( + ) + let f381 = ( + ) + let f382 = ( + ) + let f383 = ( + ) + let f384 = ( + ) + let f385 = ( + ) + let f386 = ( + ) + let f387 = ( + ) + let f388 = ( + ) + let f389 = ( + ) + let f390 = ( + ) + let f391 = ( + ) + let f392 = ( + ) + let f393 = ( + ) + let f394 = ( + ) + let f395 = ( + ) + let f396 = ( + ) + let f397 = ( + ) + let f398 = ( + ) + let f399 = ( + ) + let f400 = ( + ) + let f401 = ( + ) + let f402 = ( + ) + let f403 = ( + ) + let f404 = ( + ) + let f405 = ( + ) + let f406 = ( + ) + let f407 = ( + ) + let f408 = ( + ) + let f409 = ( + ) + let f410 = ( + ) + let f411 = ( + ) + let f412 = ( + ) + let f413 = ( + ) + let f414 = ( + ) + let f415 = ( + ) + let f416 = ( + ) + let f417 = ( + ) + let f418 = ( + ) + let f419 = ( + ) + let f420 = ( + ) + let f421 = ( + ) + let f422 = ( + ) + let f423 = ( + ) + let f424 = ( + ) + let f425 = ( + ) + let f426 = ( + ) + let f427 = ( + ) + let f428 = ( + ) + let f429 = ( + ) + let f430 = ( + ) + let f431 = ( + ) + let f432 = ( + ) + let f433 = ( + ) + let f434 = ( + ) + let f435 = ( + ) + let f436 = ( + ) + let f437 = ( + ) + let f438 = ( + ) + let f439 = ( + ) + let f440 = ( + ) + let f441 = ( + ) + let f442 = ( + ) + let f443 = ( + ) + let f444 = ( + ) + let f445 = ( + ) + let f446 = ( + ) + let f447 = ( + ) + let f448 = ( + ) + let f449 = ( + ) + let f450 = ( + ) + let f451 = ( + ) + let f452 = ( + ) + let f453 = ( + ) + let f454 = ( + ) + let f455 = ( + ) + let f456 = ( + ) + let f457 = ( + ) + let f458 = ( + ) + let f459 = ( + ) + let f460 = ( + ) + let f461 = ( + ) + let f462 = ( + ) + let f463 = ( + ) + let f464 = ( + ) + let f465 = ( + ) + let f466 = ( + ) + let f467 = ( + ) + let f468 = ( + ) + let f469 = ( + ) + let f470 = ( + ) + let f471 = ( + ) + let f472 = ( + ) + let f473 = ( + ) + let f474 = ( + ) + let f475 = ( + ) + let f476 = ( + ) + let f477 = ( + ) + let f478 = ( + ) + let f479 = ( + ) + let f480 = ( + ) + let f481 = ( + ) + let f482 = ( + ) + let f483 = ( + ) + let f484 = ( + ) + let f485 = ( + ) + let f486 = ( + ) + let f487 = ( + ) + let f488 = ( + ) + let f489 = ( + ) + let f490 = ( + ) + let f491 = ( + ) + let f492 = ( + ) + let f493 = ( + ) + let f494 = ( + ) + let f495 = ( + ) + let f496 = ( + ) + let f497 = ( + ) + let f498 = ( + ) + let f499 = ( + ) + let f500 = ( + ) + let f501 = ( + ) + let f502 = ( + ) + let f503 = ( + ) + let f504 = ( + ) + let f505 = ( + ) + let f506 = ( + ) + let f507 = ( + ) + let f508 = ( + ) + let f509 = ( + ) + let f510 = ( + ) + let f511 = ( + ) + let f512 = ( + ) + let f513 = ( + ) + let f514 = ( + ) + let f515 = ( + ) + let f516 = ( + ) + let f517 = ( + ) + let f518 = ( + ) + let f519 = ( + ) + let f520 = ( + ) + let f521 = ( + ) + let f522 = ( + ) + let f523 = ( + ) + let f524 = ( + ) + let f525 = ( + ) + let f526 = ( + ) + let f527 = ( + ) + let f528 = ( + ) + let f529 = ( + ) + let f530 = ( + ) + let f531 = ( + ) + let f532 = ( + ) + let f533 = ( + ) + let f534 = ( + ) + let f535 = ( + ) + let f536 = ( + ) + let f537 = ( + ) + let f538 = ( + ) + let f539 = ( + ) + let f540 = ( + ) + let f541 = ( + ) + let f542 = ( + ) + let f543 = ( + ) + let f544 = ( + ) + let f545 = ( + ) + let f546 = ( + ) + let f547 = ( + ) + let f548 = ( + ) + let f549 = ( + ) + let f550 = ( + ) + let f551 = ( + ) + let f552 = ( + ) + let f553 = ( + ) + let f554 = ( + ) + let f555 = ( + ) + let f556 = ( + ) + let f557 = ( + ) + let f558 = ( + ) + let f559 = ( + ) + let f560 = ( + ) + let f561 = ( + ) + let f562 = ( + ) + let f563 = ( + ) + let f564 = ( + ) + let f565 = ( + ) + let f566 = ( + ) + let f567 = ( + ) + let f568 = ( + ) + let f569 = ( + ) + let f570 = ( + ) + let f571 = ( + ) + let f572 = ( + ) + let f573 = ( + ) + let f574 = ( + ) + let f575 = ( + ) + let f576 = ( + ) + let f577 = ( + ) + let f578 = ( + ) + let f579 = ( + ) + let f580 = ( + ) + let f581 = ( + ) + let f582 = ( + ) + let f583 = ( + ) + let f584 = ( + ) + let f585 = ( + ) + let f586 = ( + ) + let f587 = ( + ) + let f588 = ( + ) + let f589 = ( + ) + let f590 = ( + ) + let f591 = ( + ) + let f592 = ( + ) + let f593 = ( + ) + let f594 = ( + ) + let f595 = ( + ) + let f596 = ( + ) + let f597 = ( + ) + let f598 = ( + ) + let f599 = ( + ) + let f600 = ( + ) + let f601 = ( + ) + let f602 = ( + ) + let f603 = ( + ) + let f604 = ( + ) + let f605 = ( + ) + let f606 = ( + ) + let f607 = ( + ) + let f608 = ( + ) + let f609 = ( + ) + let f610 = ( + ) + let f611 = ( + ) + let f612 = ( + ) + let f613 = ( + ) + let f614 = ( + ) + let f615 = ( + ) + let f616 = ( + ) + let f617 = ( + ) + let f618 = ( + ) + let f619 = ( + ) + let f620 = ( + ) + let f621 = ( + ) + let f622 = ( + ) + let f623 = ( + ) + let f624 = ( + ) + let f625 = ( + ) + let f626 = ( + ) + let f627 = ( + ) + let f628 = ( + ) + let f629 = ( + ) + let f630 = ( + ) + let f631 = ( + ) + let f632 = ( + ) + let f633 = ( + ) + let f634 = ( + ) + let f635 = ( + ) + let f636 = ( + ) + let f637 = ( + ) + let f638 = ( + ) + let f639 = ( + ) + let f640 = ( + ) + let f641 = ( + ) + let f642 = ( + ) + let f643 = ( + ) + let f644 = ( + ) + let f645 = ( + ) + let f646 = ( + ) + let f647 = ( + ) + let f648 = ( + ) + let f649 = ( + ) + let f650 = ( + ) + let f651 = ( + ) + let f652 = ( + ) + let f653 = ( + ) + let f654 = ( + ) + let f655 = ( + ) + let f656 = ( + ) + let f657 = ( + ) + let f658 = ( + ) + let f659 = ( + ) + let f660 = ( + ) + let f661 = ( + ) + let f662 = ( + ) + let f663 = ( + ) + let f664 = ( + ) + let f665 = ( + ) + let f666 = ( + ) + let f667 = ( + ) + let f668 = ( + ) + let f669 = ( + ) + let f670 = ( + ) + let f671 = ( + ) + let f672 = ( + ) + let f673 = ( + ) + let f674 = ( + ) + let f675 = ( + ) + let f676 = ( + ) + let f677 = ( + ) + let f678 = ( + ) + let f679 = ( + ) + let f680 = ( + ) + let f681 = ( + ) + let f682 = ( + ) + let f683 = ( + ) + let f684 = ( + ) + let f685 = ( + ) + let f686 = ( + ) + let f687 = ( + ) + let f688 = ( + ) + let f689 = ( + ) + let f690 = ( + ) + let f691 = ( + ) + let f692 = ( + ) + let f693 = ( + ) + let f694 = ( + ) + let f695 = ( + ) + let f696 = ( + ) + let f697 = ( + ) + let f698 = ( + ) + let f699 = ( + ) + let f700 = ( + ) + let f701 = ( + ) + let f702 = ( + ) + let f703 = ( + ) + let f704 = ( + ) + let f705 = ( + ) + let f706 = ( + ) + let f707 = ( + ) + let f708 = ( + ) + let f709 = ( + ) + let f710 = ( + ) + let f711 = ( + ) + let f712 = ( + ) + let f713 = ( + ) + let f714 = ( + ) + let f715 = ( + ) + let f716 = ( + ) + let f717 = ( + ) + let f718 = ( + ) + let f719 = ( + ) + let f720 = ( + ) + let f721 = ( + ) + let f722 = ( + ) + let f723 = ( + ) + let f724 = ( + ) + let f725 = ( + ) + let f726 = ( + ) + let f727 = ( + ) + let f728 = ( + ) + let f729 = ( + ) + let f730 = ( + ) + let f731 = ( + ) + let f732 = ( + ) + let f733 = ( + ) + let f734 = ( + ) + let f735 = ( + ) + let f736 = ( + ) + let f737 = ( + ) + let f738 = ( + ) + let f739 = ( + ) + let f740 = ( + ) + let f741 = ( + ) + let f742 = ( + ) + let f743 = ( + ) + let f744 = ( + ) + let f745 = ( + ) + let f746 = ( + ) + let f747 = ( + ) + let f748 = ( + ) + let f749 = ( + ) + let f750 = ( + ) + let f751 = ( + ) + let f752 = ( + ) + let f753 = ( + ) + let f754 = ( + ) + let f755 = ( + ) + let f756 = ( + ) + let f757 = ( + ) + let f758 = ( + ) + let f759 = ( + ) + let f760 = ( + ) + let f761 = ( + ) + let f762 = ( + ) + let f763 = ( + ) + let f764 = ( + ) + let f765 = ( + ) + let f766 = ( + ) + let f767 = ( + ) + let f768 = ( + ) + let f769 = ( + ) + let f770 = ( + ) + let f771 = ( + ) + let f772 = ( + ) + let f773 = ( + ) + let f774 = ( + ) + let f775 = ( + ) + let f776 = ( + ) + let f777 = ( + ) + let f778 = ( + ) + let f779 = ( + ) + let f780 = ( + ) + let f781 = ( + ) + let f782 = ( + ) + let f783 = ( + ) + let f784 = ( + ) + let f785 = ( + ) + let f786 = ( + ) + let f787 = ( + ) + let f788 = ( + ) + let f789 = ( + ) + let f790 = ( + ) + let f791 = ( + ) + let f792 = ( + ) + let f793 = ( + ) + let f794 = ( + ) + let f795 = ( + ) + let f796 = ( + ) + let f797 = ( + ) + let f798 = ( + ) + let f799 = ( + ) + let f800 = ( + ) + let f801 = ( + ) + let f802 = ( + ) + let f803 = ( + ) + let f804 = ( + ) + let f805 = ( + ) + let f806 = ( + ) + let f807 = ( + ) + let f808 = ( + ) + let f809 = ( + ) + let f810 = ( + ) + let f811 = ( + ) + let f812 = ( + ) + let f813 = ( + ) + let f814 = ( + ) + let f815 = ( + ) + let f816 = ( + ) + let f817 = ( + ) + let f818 = ( + ) + let f819 = ( + ) + let f820 = ( + ) + let f821 = ( + ) + let f822 = ( + ) + let f823 = ( + ) + let f824 = ( + ) + let f825 = ( + ) + let f826 = ( + ) + let f827 = ( + ) + let f828 = ( + ) + let f829 = ( + ) + let f830 = ( + ) + let f831 = ( + ) + let f832 = ( + ) + let f833 = ( + ) + let f834 = ( + ) + let f835 = ( + ) + let f836 = ( + ) + let f837 = ( + ) + let f838 = ( + ) + let f839 = ( + ) + let f840 = ( + ) + let f841 = ( + ) + let f842 = ( + ) + let f843 = ( + ) + let f844 = ( + ) + let f845 = ( + ) + let f846 = ( + ) + let f847 = ( + ) + let f848 = ( + ) + let f849 = ( + ) + let f850 = ( + ) + let f851 = ( + ) + let f852 = ( + ) + let f853 = ( + ) + let f854 = ( + ) + let f855 = ( + ) + let f856 = ( + ) + let f857 = ( + ) + let f858 = ( + ) + let f859 = ( + ) + let f860 = ( + ) + let f861 = ( + ) + let f862 = ( + ) + let f863 = ( + ) + let f864 = ( + ) + let f865 = ( + ) + let f866 = ( + ) + let f867 = ( + ) + let f868 = ( + ) + let f869 = ( + ) + let f870 = ( + ) + let f871 = ( + ) + let f872 = ( + ) + let f873 = ( + ) + let f874 = ( + ) + let f875 = ( + ) + let f876 = ( + ) + let f877 = ( + ) + let f878 = ( + ) + let f879 = ( + ) + let f880 = ( + ) + let f881 = ( + ) + let f882 = ( + ) + let f883 = ( + ) + let f884 = ( + ) + let f885 = ( + ) + let f886 = ( + ) + let f887 = ( + ) + let f888 = ( + ) + let f889 = ( + ) + let f890 = ( + ) + let f891 = ( + ) + let f892 = ( + ) + let f893 = ( + ) + let f894 = ( + ) + let f895 = ( + ) + let f896 = ( + ) + let f897 = ( + ) + let f898 = ( + ) + let f899 = ( + ) + let f900 = ( + ) + let f901 = ( + ) + let f902 = ( + ) + let f903 = ( + ) + let f904 = ( + ) + let f905 = ( + ) + let f906 = ( + ) + let f907 = ( + ) + let f908 = ( + ) + let f909 = ( + ) + let f910 = ( + ) + let f911 = ( + ) + let f912 = ( + ) + let f913 = ( + ) + let f914 = ( + ) + let f915 = ( + ) + let f916 = ( + ) + let f917 = ( + ) + let f918 = ( + ) + let f919 = ( + ) + let f920 = ( + ) + let f921 = ( + ) + let f922 = ( + ) + let f923 = ( + ) + let f924 = ( + ) + let f925 = ( + ) + let f926 = ( + ) + let f927 = ( + ) + let f928 = ( + ) + let f929 = ( + ) + let f930 = ( + ) + let f931 = ( + ) + let f932 = ( + ) + let f933 = ( + ) + let f934 = ( + ) + let f935 = ( + ) + let f936 = ( + ) + let f937 = ( + ) + let f938 = ( + ) + let f939 = ( + ) + let f940 = ( + ) + let f941 = ( + ) + let f942 = ( + ) + let f943 = ( + ) + let f944 = ( + ) + let f945 = ( + ) + let f946 = ( + ) + let f947 = ( + ) + let f948 = ( + ) + let f949 = ( + ) + let f950 = ( + ) + let f951 = ( + ) + let f952 = ( + ) + let f953 = ( + ) + let f954 = ( + ) + let f955 = ( + ) + let f956 = ( + ) + let f957 = ( + ) + let f958 = ( + ) + let f959 = ( + ) + let f960 = ( + ) + let f961 = ( + ) + let f962 = ( + ) + let f963 = ( + ) + let f964 = ( + ) + let f965 = ( + ) + let f966 = ( + ) + let f967 = ( + ) + let f968 = ( + ) + let f969 = ( + ) + let f970 = ( + ) + let f971 = ( + ) + let f972 = ( + ) + let f973 = ( + ) + let f974 = ( + ) + let f975 = ( + ) + let f976 = ( + ) + let f977 = ( + ) + let f978 = ( + ) + let f979 = ( + ) + let f980 = ( + ) + let f981 = ( + ) + let f982 = ( + ) + let f983 = ( + ) + let f984 = ( + ) + let f985 = ( + ) + let f986 = ( + ) + let f987 = ( + ) + let f988 = ( + ) + let f989 = ( + ) + let f990 = ( + ) + let f991 = ( + ) + let f992 = ( + ) + let f993 = ( + ) + let f994 = ( + ) + let f995 = ( + ) + let f996 = ( + ) + let f997 = ( + ) + let f998 = ( + ) + let f999 = ( + ) + let f1000 = ( + ) +end + +module X = Make(Make(Make(M))) diff --git a/camlp4/test/fixtures/functor-perf2.gen.ml b/camlp4/test/fixtures/functor-perf2.gen.ml new file mode 100644 index 00000000..730a1bf8 --- /dev/null +++ b/camlp4/test/fixtures/functor-perf2.gen.ml @@ -0,0 +1,3029 @@ + + +module type S = sig + type t0 + type t1 + type t2 + type t3 + type t4 + type t5 + type t6 + type t7 + type t8 + type t9 + type t10 + type t11 + type t12 + type t13 + type t14 + type t15 + type t16 + type t17 + type t18 + type t19 + type t20 + type t21 + type t22 + type t23 + type t24 + type t25 + type t26 + type t27 + type t28 + type t29 + type t30 + type t31 + type t32 + type t33 + type t34 + type t35 + type t36 + type t37 + type t38 + type t39 + type t40 + type t41 + type t42 + type t43 + type t44 + type t45 + type t46 + type t47 + type t48 + type t49 + type t50 + type t51 + type t52 + type t53 + type t54 + type t55 + type t56 + type t57 + type t58 + type t59 + type t60 + type t61 + type t62 + type t63 + type t64 + type t65 + type t66 + type t67 + type t68 + type t69 + type t70 + type t71 + type t72 + type t73 + type t74 + type t75 + type t76 + type t77 + type t78 + type t79 + type t80 + type t81 + type t82 + type t83 + type t84 + type t85 + type t86 + type t87 + type t88 + type t89 + type t90 + type t91 + type t92 + type t93 + type t94 + type t95 + type t96 + type t97 + type t98 + type t99 + type t100 + type t101 + type t102 + type t103 + type t104 + type t105 + type t106 + type t107 + type t108 + type t109 + type t110 + type t111 + type t112 + type t113 + type t114 + type t115 + type t116 + type t117 + type t118 + type t119 + type t120 + type t121 + type t122 + type t123 + type t124 + type t125 + type t126 + type t127 + type t128 + type t129 + type t130 + type t131 + type t132 + type t133 + type t134 + type t135 + type t136 + type t137 + type t138 + type t139 + type t140 + type t141 + type t142 + type t143 + type t144 + type t145 + type t146 + type t147 + type t148 + type t149 + type t150 + type t151 + type t152 + type t153 + type t154 + type t155 + type t156 + type t157 + type t158 + type t159 + type t160 + type t161 + type t162 + type t163 + type t164 + type t165 + type t166 + type t167 + type t168 + type t169 + type t170 + type t171 + type t172 + type t173 + type t174 + type t175 + type t176 + type t177 + type t178 + type t179 + type t180 + type t181 + type t182 + type t183 + type t184 + type t185 + type t186 + type t187 + type t188 + type t189 + type t190 + type t191 + type t192 + type t193 + type t194 + type t195 + type t196 + type t197 + type t198 + type t199 + type t200 + type t201 + type t202 + type t203 + type t204 + type t205 + type t206 + type t207 + type t208 + type t209 + type t210 + type t211 + type t212 + type t213 + type t214 + type t215 + type t216 + type t217 + type t218 + type t219 + type t220 + type t221 + type t222 + type t223 + type t224 + type t225 + type t226 + type t227 + type t228 + type t229 + type t230 + type t231 + type t232 + type t233 + type t234 + type t235 + type t236 + type t237 + type t238 + type t239 + type t240 + type t241 + type t242 + type t243 + type t244 + type t245 + type t246 + type t247 + type t248 + type t249 + type t250 + type t251 + type t252 + type t253 + type t254 + type t255 + type t256 + type t257 + type t258 + type t259 + type t260 + type t261 + type t262 + type t263 + type t264 + type t265 + type t266 + type t267 + type t268 + type t269 + type t270 + type t271 + type t272 + type t273 + type t274 + type t275 + type t276 + type t277 + type t278 + type t279 + type t280 + type t281 + type t282 + type t283 + type t284 + type t285 + type t286 + type t287 + type t288 + type t289 + type t290 + type t291 + type t292 + type t293 + type t294 + type t295 + type t296 + type t297 + type t298 + type t299 + type t300 + type t301 + type t302 + type t303 + type t304 + type t305 + type t306 + type t307 + type t308 + type t309 + type t310 + type t311 + type t312 + type t313 + type t314 + type t315 + type t316 + type t317 + type t318 + type t319 + type t320 + type t321 + type t322 + type t323 + type t324 + type t325 + type t326 + type t327 + type t328 + type t329 + type t330 + type t331 + type t332 + type t333 + type t334 + type t335 + type t336 + type t337 + type t338 + type t339 + type t340 + type t341 + type t342 + type t343 + type t344 + type t345 + type t346 + type t347 + type t348 + type t349 + type t350 + type t351 + type t352 + type t353 + type t354 + type t355 + type t356 + type t357 + type t358 + type t359 + type t360 + type t361 + type t362 + type t363 + type t364 + type t365 + type t366 + type t367 + type t368 + type t369 + type t370 + type t371 + type t372 + type t373 + type t374 + type t375 + type t376 + type t377 + type t378 + type t379 + type t380 + type t381 + type t382 + type t383 + type t384 + type t385 + type t386 + type t387 + type t388 + type t389 + type t390 + type t391 + type t392 + type t393 + type t394 + type t395 + type t396 + type t397 + type t398 + type t399 + type t400 + type t401 + type t402 + type t403 + type t404 + type t405 + type t406 + type t407 + type t408 + type t409 + type t410 + type t411 + type t412 + type t413 + type t414 + type t415 + type t416 + type t417 + type t418 + type t419 + type t420 + type t421 + type t422 + type t423 + type t424 + type t425 + type t426 + type t427 + type t428 + type t429 + type t430 + type t431 + type t432 + type t433 + type t434 + type t435 + type t436 + type t437 + type t438 + type t439 + type t440 + type t441 + type t442 + type t443 + type t444 + type t445 + type t446 + type t447 + type t448 + type t449 + type t450 + type t451 + type t452 + type t453 + type t454 + type t455 + type t456 + type t457 + type t458 + type t459 + type t460 + type t461 + type t462 + type t463 + type t464 + type t465 + type t466 + type t467 + type t468 + type t469 + type t470 + type t471 + type t472 + type t473 + type t474 + type t475 + type t476 + type t477 + type t478 + type t479 + type t480 + type t481 + type t482 + type t483 + type t484 + type t485 + type t486 + type t487 + type t488 + type t489 + type t490 + type t491 + type t492 + type t493 + type t494 + type t495 + type t496 + type t497 + type t498 + type t499 + type t500 + type t501 + type t502 + type t503 + type t504 + type t505 + type t506 + type t507 + type t508 + type t509 + type t510 + type t511 + type t512 + type t513 + type t514 + type t515 + type t516 + type t517 + type t518 + type t519 + type t520 + type t521 + type t522 + type t523 + type t524 + type t525 + type t526 + type t527 + type t528 + type t529 + type t530 + type t531 + type t532 + type t533 + type t534 + type t535 + type t536 + type t537 + type t538 + type t539 + type t540 + type t541 + type t542 + type t543 + type t544 + type t545 + type t546 + type t547 + type t548 + type t549 + type t550 + type t551 + type t552 + type t553 + type t554 + type t555 + type t556 + type t557 + type t558 + type t559 + type t560 + type t561 + type t562 + type t563 + type t564 + type t565 + type t566 + type t567 + type t568 + type t569 + type t570 + type t571 + type t572 + type t573 + type t574 + type t575 + type t576 + type t577 + type t578 + type t579 + type t580 + type t581 + type t582 + type t583 + type t584 + type t585 + type t586 + type t587 + type t588 + type t589 + type t590 + type t591 + type t592 + type t593 + type t594 + type t595 + type t596 + type t597 + type t598 + type t599 + type t600 + type t601 + type t602 + type t603 + type t604 + type t605 + type t606 + type t607 + type t608 + type t609 + type t610 + type t611 + type t612 + type t613 + type t614 + type t615 + type t616 + type t617 + type t618 + type t619 + type t620 + type t621 + type t622 + type t623 + type t624 + type t625 + type t626 + type t627 + type t628 + type t629 + type t630 + type t631 + type t632 + type t633 + type t634 + type t635 + type t636 + type t637 + type t638 + type t639 + type t640 + type t641 + type t642 + type t643 + type t644 + type t645 + type t646 + type t647 + type t648 + type t649 + type t650 + type t651 + type t652 + type t653 + type t654 + type t655 + type t656 + type t657 + type t658 + type t659 + type t660 + type t661 + type t662 + type t663 + type t664 + type t665 + type t666 + type t667 + type t668 + type t669 + type t670 + type t671 + type t672 + type t673 + type t674 + type t675 + type t676 + type t677 + type t678 + type t679 + type t680 + type t681 + type t682 + type t683 + type t684 + type t685 + type t686 + type t687 + type t688 + type t689 + type t690 + type t691 + type t692 + type t693 + type t694 + type t695 + type t696 + type t697 + type t698 + type t699 + type t700 + type t701 + type t702 + type t703 + type t704 + type t705 + type t706 + type t707 + type t708 + type t709 + type t710 + type t711 + type t712 + type t713 + type t714 + type t715 + type t716 + type t717 + type t718 + type t719 + type t720 + type t721 + type t722 + type t723 + type t724 + type t725 + type t726 + type t727 + type t728 + type t729 + type t730 + type t731 + type t732 + type t733 + type t734 + type t735 + type t736 + type t737 + type t738 + type t739 + type t740 + type t741 + type t742 + type t743 + type t744 + type t745 + type t746 + type t747 + type t748 + type t749 + type t750 + type t751 + type t752 + type t753 + type t754 + type t755 + type t756 + type t757 + type t758 + type t759 + type t760 + type t761 + type t762 + type t763 + type t764 + type t765 + type t766 + type t767 + type t768 + type t769 + type t770 + type t771 + type t772 + type t773 + type t774 + type t775 + type t776 + type t777 + type t778 + type t779 + type t780 + type t781 + type t782 + type t783 + type t784 + type t785 + type t786 + type t787 + type t788 + type t789 + type t790 + type t791 + type t792 + type t793 + type t794 + type t795 + type t796 + type t797 + type t798 + type t799 + type t800 + type t801 + type t802 + type t803 + type t804 + type t805 + type t806 + type t807 + type t808 + type t809 + type t810 + type t811 + type t812 + type t813 + type t814 + type t815 + type t816 + type t817 + type t818 + type t819 + type t820 + type t821 + type t822 + type t823 + type t824 + type t825 + type t826 + type t827 + type t828 + type t829 + type t830 + type t831 + type t832 + type t833 + type t834 + type t835 + type t836 + type t837 + type t838 + type t839 + type t840 + type t841 + type t842 + type t843 + type t844 + type t845 + type t846 + type t847 + type t848 + type t849 + type t850 + type t851 + type t852 + type t853 + type t854 + type t855 + type t856 + type t857 + type t858 + type t859 + type t860 + type t861 + type t862 + type t863 + type t864 + type t865 + type t866 + type t867 + type t868 + type t869 + type t870 + type t871 + type t872 + type t873 + type t874 + type t875 + type t876 + type t877 + type t878 + type t879 + type t880 + type t881 + type t882 + type t883 + type t884 + type t885 + type t886 + type t887 + type t888 + type t889 + type t890 + type t891 + type t892 + type t893 + type t894 + type t895 + type t896 + type t897 + type t898 + type t899 + type t900 + type t901 + type t902 + type t903 + type t904 + type t905 + type t906 + type t907 + type t908 + type t909 + type t910 + type t911 + type t912 + type t913 + type t914 + type t915 + type t916 + type t917 + type t918 + type t919 + type t920 + type t921 + type t922 + type t923 + type t924 + type t925 + type t926 + type t927 + type t928 + type t929 + type t930 + type t931 + type t932 + type t933 + type t934 + type t935 + type t936 + type t937 + type t938 + type t939 + type t940 + type t941 + type t942 + type t943 + type t944 + type t945 + type t946 + type t947 + type t948 + type t949 + type t950 + type t951 + type t952 + type t953 + type t954 + type t955 + type t956 + type t957 + type t958 + type t959 + type t960 + type t961 + type t962 + type t963 + type t964 + type t965 + type t966 + type t967 + type t968 + type t969 + type t970 + type t971 + type t972 + type t973 + type t974 + type t975 + type t976 + type t977 + type t978 + type t979 + type t980 + type t981 + type t982 + type t983 + type t984 + type t985 + type t986 + type t987 + type t988 + type t989 + type t990 + type t991 + type t992 + type t993 + type t994 + type t995 + type t996 + type t997 + type t998 + type t999 + type t1000 +end + +module Make (M : S) +: S with type t0 = M.t0 + and type t1 = M.t1 + and type t2 = M.t2 + and type t3 = M.t3 + and type t4 = M.t4 + and type t5 = M.t5 + and type t6 = M.t6 + and type t7 = M.t7 + and type t8 = M.t8 + and type t9 = M.t9 + and type t10 = M.t10 + and type t11 = M.t11 + and type t12 = M.t12 + and type t13 = M.t13 + and type t14 = M.t14 + and type t15 = M.t15 + and type t16 = M.t16 + and type t17 = M.t17 + and type t18 = M.t18 + and type t19 = M.t19 + and type t20 = M.t20 + and type t21 = M.t21 + and type t22 = M.t22 + and type t23 = M.t23 + and type t24 = M.t24 + and type t25 = M.t25 + and type t26 = M.t26 + and type t27 = M.t27 + and type t28 = M.t28 + and type t29 = M.t29 + and type t30 = M.t30 + and type t31 = M.t31 + and type t32 = M.t32 + and type t33 = M.t33 + and type t34 = M.t34 + and type t35 = M.t35 + and type t36 = M.t36 + and type t37 = M.t37 + and type t38 = M.t38 + and type t39 = M.t39 + and type t40 = M.t40 + and type t41 = M.t41 + and type t42 = M.t42 + and type t43 = M.t43 + and type t44 = M.t44 + and type t45 = M.t45 + and type t46 = M.t46 + and type t47 = M.t47 + and type t48 = M.t48 + and type t49 = M.t49 + and type t50 = M.t50 + and type t51 = M.t51 + and type t52 = M.t52 + and type t53 = M.t53 + and type t54 = M.t54 + and type t55 = M.t55 + and type t56 = M.t56 + and type t57 = M.t57 + and type t58 = M.t58 + and type t59 = M.t59 + and type t60 = M.t60 + and type t61 = M.t61 + and type t62 = M.t62 + and type t63 = M.t63 + and type t64 = M.t64 + and type t65 = M.t65 + and type t66 = M.t66 + and type t67 = M.t67 + and type t68 = M.t68 + and type t69 = M.t69 + and type t70 = M.t70 + and type t71 = M.t71 + and type t72 = M.t72 + and type t73 = M.t73 + and type t74 = M.t74 + and type t75 = M.t75 + and type t76 = M.t76 + and type t77 = M.t77 + and type t78 = M.t78 + and type t79 = M.t79 + and type t80 = M.t80 + and type t81 = M.t81 + and type t82 = M.t82 + and type t83 = M.t83 + and type t84 = M.t84 + and type t85 = M.t85 + and type t86 = M.t86 + and type t87 = M.t87 + and type t88 = M.t88 + and type t89 = M.t89 + and type t90 = M.t90 + and type t91 = M.t91 + and type t92 = M.t92 + and type t93 = M.t93 + and type t94 = M.t94 + and type t95 = M.t95 + and type t96 = M.t96 + and type t97 = M.t97 + and type t98 = M.t98 + and type t99 = M.t99 + and type t100 = M.t100 + and type t101 = M.t101 + and type t102 = M.t102 + and type t103 = M.t103 + and type t104 = M.t104 + and type t105 = M.t105 + and type t106 = M.t106 + and type t107 = M.t107 + and type t108 = M.t108 + and type t109 = M.t109 + and type t110 = M.t110 + and type t111 = M.t111 + and type t112 = M.t112 + and type t113 = M.t113 + and type t114 = M.t114 + and type t115 = M.t115 + and type t116 = M.t116 + and type t117 = M.t117 + and type t118 = M.t118 + and type t119 = M.t119 + and type t120 = M.t120 + and type t121 = M.t121 + and type t122 = M.t122 + and type t123 = M.t123 + and type t124 = M.t124 + and type t125 = M.t125 + and type t126 = M.t126 + and type t127 = M.t127 + and type t128 = M.t128 + and type t129 = M.t129 + and type t130 = M.t130 + and type t131 = M.t131 + and type t132 = M.t132 + and type t133 = M.t133 + and type t134 = M.t134 + and type t135 = M.t135 + and type t136 = M.t136 + and type t137 = M.t137 + and type t138 = M.t138 + and type t139 = M.t139 + and type t140 = M.t140 + and type t141 = M.t141 + and type t142 = M.t142 + and type t143 = M.t143 + and type t144 = M.t144 + and type t145 = M.t145 + and type t146 = M.t146 + and type t147 = M.t147 + and type t148 = M.t148 + and type t149 = M.t149 + and type t150 = M.t150 + and type t151 = M.t151 + and type t152 = M.t152 + and type t153 = M.t153 + and type t154 = M.t154 + and type t155 = M.t155 + and type t156 = M.t156 + and type t157 = M.t157 + and type t158 = M.t158 + and type t159 = M.t159 + and type t160 = M.t160 + and type t161 = M.t161 + and type t162 = M.t162 + and type t163 = M.t163 + and type t164 = M.t164 + and type t165 = M.t165 + and type t166 = M.t166 + and type t167 = M.t167 + and type t168 = M.t168 + and type t169 = M.t169 + and type t170 = M.t170 + and type t171 = M.t171 + and type t172 = M.t172 + and type t173 = M.t173 + and type t174 = M.t174 + and type t175 = M.t175 + and type t176 = M.t176 + and type t177 = M.t177 + and type t178 = M.t178 + and type t179 = M.t179 + and type t180 = M.t180 + and type t181 = M.t181 + and type t182 = M.t182 + and type t183 = M.t183 + and type t184 = M.t184 + and type t185 = M.t185 + and type t186 = M.t186 + and type t187 = M.t187 + and type t188 = M.t188 + and type t189 = M.t189 + and type t190 = M.t190 + and type t191 = M.t191 + and type t192 = M.t192 + and type t193 = M.t193 + and type t194 = M.t194 + and type t195 = M.t195 + and type t196 = M.t196 + and type t197 = M.t197 + and type t198 = M.t198 + and type t199 = M.t199 + and type t200 = M.t200 + and type t201 = M.t201 + and type t202 = M.t202 + and type t203 = M.t203 + and type t204 = M.t204 + and type t205 = M.t205 + and type t206 = M.t206 + and type t207 = M.t207 + and type t208 = M.t208 + and type t209 = M.t209 + and type t210 = M.t210 + and type t211 = M.t211 + and type t212 = M.t212 + and type t213 = M.t213 + and type t214 = M.t214 + and type t215 = M.t215 + and type t216 = M.t216 + and type t217 = M.t217 + and type t218 = M.t218 + and type t219 = M.t219 + and type t220 = M.t220 + and type t221 = M.t221 + and type t222 = M.t222 + and type t223 = M.t223 + and type t224 = M.t224 + and type t225 = M.t225 + and type t226 = M.t226 + and type t227 = M.t227 + and type t228 = M.t228 + and type t229 = M.t229 + and type t230 = M.t230 + and type t231 = M.t231 + and type t232 = M.t232 + and type t233 = M.t233 + and type t234 = M.t234 + and type t235 = M.t235 + and type t236 = M.t236 + and type t237 = M.t237 + and type t238 = M.t238 + and type t239 = M.t239 + and type t240 = M.t240 + and type t241 = M.t241 + and type t242 = M.t242 + and type t243 = M.t243 + and type t244 = M.t244 + and type t245 = M.t245 + and type t246 = M.t246 + and type t247 = M.t247 + and type t248 = M.t248 + and type t249 = M.t249 + and type t250 = M.t250 + and type t251 = M.t251 + and type t252 = M.t252 + and type t253 = M.t253 + and type t254 = M.t254 + and type t255 = M.t255 + and type t256 = M.t256 + and type t257 = M.t257 + and type t258 = M.t258 + and type t259 = M.t259 + and type t260 = M.t260 + and type t261 = M.t261 + and type t262 = M.t262 + and type t263 = M.t263 + and type t264 = M.t264 + and type t265 = M.t265 + and type t266 = M.t266 + and type t267 = M.t267 + and type t268 = M.t268 + and type t269 = M.t269 + and type t270 = M.t270 + and type t271 = M.t271 + and type t272 = M.t272 + and type t273 = M.t273 + and type t274 = M.t274 + and type t275 = M.t275 + and type t276 = M.t276 + and type t277 = M.t277 + and type t278 = M.t278 + and type t279 = M.t279 + and type t280 = M.t280 + and type t281 = M.t281 + and type t282 = M.t282 + and type t283 = M.t283 + and type t284 = M.t284 + and type t285 = M.t285 + and type t286 = M.t286 + and type t287 = M.t287 + and type t288 = M.t288 + and type t289 = M.t289 + and type t290 = M.t290 + and type t291 = M.t291 + and type t292 = M.t292 + and type t293 = M.t293 + and type t294 = M.t294 + and type t295 = M.t295 + and type t296 = M.t296 + and type t297 = M.t297 + and type t298 = M.t298 + and type t299 = M.t299 + and type t300 = M.t300 + and type t301 = M.t301 + and type t302 = M.t302 + and type t303 = M.t303 + and type t304 = M.t304 + and type t305 = M.t305 + and type t306 = M.t306 + and type t307 = M.t307 + and type t308 = M.t308 + and type t309 = M.t309 + and type t310 = M.t310 + and type t311 = M.t311 + and type t312 = M.t312 + and type t313 = M.t313 + and type t314 = M.t314 + and type t315 = M.t315 + and type t316 = M.t316 + and type t317 = M.t317 + and type t318 = M.t318 + and type t319 = M.t319 + and type t320 = M.t320 + and type t321 = M.t321 + and type t322 = M.t322 + and type t323 = M.t323 + and type t324 = M.t324 + and type t325 = M.t325 + and type t326 = M.t326 + and type t327 = M.t327 + and type t328 = M.t328 + and type t329 = M.t329 + and type t330 = M.t330 + and type t331 = M.t331 + and type t332 = M.t332 + and type t333 = M.t333 + and type t334 = M.t334 + and type t335 = M.t335 + and type t336 = M.t336 + and type t337 = M.t337 + and type t338 = M.t338 + and type t339 = M.t339 + and type t340 = M.t340 + and type t341 = M.t341 + and type t342 = M.t342 + and type t343 = M.t343 + and type t344 = M.t344 + and type t345 = M.t345 + and type t346 = M.t346 + and type t347 = M.t347 + and type t348 = M.t348 + and type t349 = M.t349 + and type t350 = M.t350 + and type t351 = M.t351 + and type t352 = M.t352 + and type t353 = M.t353 + and type t354 = M.t354 + and type t355 = M.t355 + and type t356 = M.t356 + and type t357 = M.t357 + and type t358 = M.t358 + and type t359 = M.t359 + and type t360 = M.t360 + and type t361 = M.t361 + and type t362 = M.t362 + and type t363 = M.t363 + and type t364 = M.t364 + and type t365 = M.t365 + and type t366 = M.t366 + and type t367 = M.t367 + and type t368 = M.t368 + and type t369 = M.t369 + and type t370 = M.t370 + and type t371 = M.t371 + and type t372 = M.t372 + and type t373 = M.t373 + and type t374 = M.t374 + and type t375 = M.t375 + and type t376 = M.t376 + and type t377 = M.t377 + and type t378 = M.t378 + and type t379 = M.t379 + and type t380 = M.t380 + and type t381 = M.t381 + and type t382 = M.t382 + and type t383 = M.t383 + and type t384 = M.t384 + and type t385 = M.t385 + and type t386 = M.t386 + and type t387 = M.t387 + and type t388 = M.t388 + and type t389 = M.t389 + and type t390 = M.t390 + and type t391 = M.t391 + and type t392 = M.t392 + and type t393 = M.t393 + and type t394 = M.t394 + and type t395 = M.t395 + and type t396 = M.t396 + and type t397 = M.t397 + and type t398 = M.t398 + and type t399 = M.t399 + and type t400 = M.t400 + and type t401 = M.t401 + and type t402 = M.t402 + and type t403 = M.t403 + and type t404 = M.t404 + and type t405 = M.t405 + and type t406 = M.t406 + and type t407 = M.t407 + and type t408 = M.t408 + and type t409 = M.t409 + and type t410 = M.t410 + and type t411 = M.t411 + and type t412 = M.t412 + and type t413 = M.t413 + and type t414 = M.t414 + and type t415 = M.t415 + and type t416 = M.t416 + and type t417 = M.t417 + and type t418 = M.t418 + and type t419 = M.t419 + and type t420 = M.t420 + and type t421 = M.t421 + and type t422 = M.t422 + and type t423 = M.t423 + and type t424 = M.t424 + and type t425 = M.t425 + and type t426 = M.t426 + and type t427 = M.t427 + and type t428 = M.t428 + and type t429 = M.t429 + and type t430 = M.t430 + and type t431 = M.t431 + and type t432 = M.t432 + and type t433 = M.t433 + and type t434 = M.t434 + and type t435 = M.t435 + and type t436 = M.t436 + and type t437 = M.t437 + and type t438 = M.t438 + and type t439 = M.t439 + and type t440 = M.t440 + and type t441 = M.t441 + and type t442 = M.t442 + and type t443 = M.t443 + and type t444 = M.t444 + and type t445 = M.t445 + and type t446 = M.t446 + and type t447 = M.t447 + and type t448 = M.t448 + and type t449 = M.t449 + and type t450 = M.t450 + and type t451 = M.t451 + and type t452 = M.t452 + and type t453 = M.t453 + and type t454 = M.t454 + and type t455 = M.t455 + and type t456 = M.t456 + and type t457 = M.t457 + and type t458 = M.t458 + and type t459 = M.t459 + and type t460 = M.t460 + and type t461 = M.t461 + and type t462 = M.t462 + and type t463 = M.t463 + and type t464 = M.t464 + and type t465 = M.t465 + and type t466 = M.t466 + and type t467 = M.t467 + and type t468 = M.t468 + and type t469 = M.t469 + and type t470 = M.t470 + and type t471 = M.t471 + and type t472 = M.t472 + and type t473 = M.t473 + and type t474 = M.t474 + and type t475 = M.t475 + and type t476 = M.t476 + and type t477 = M.t477 + and type t478 = M.t478 + and type t479 = M.t479 + and type t480 = M.t480 + and type t481 = M.t481 + and type t482 = M.t482 + and type t483 = M.t483 + and type t484 = M.t484 + and type t485 = M.t485 + and type t486 = M.t486 + and type t487 = M.t487 + and type t488 = M.t488 + and type t489 = M.t489 + and type t490 = M.t490 + and type t491 = M.t491 + and type t492 = M.t492 + and type t493 = M.t493 + and type t494 = M.t494 + and type t495 = M.t495 + and type t496 = M.t496 + and type t497 = M.t497 + and type t498 = M.t498 + and type t499 = M.t499 + and type t500 = M.t500 + and type t501 = M.t501 + and type t502 = M.t502 + and type t503 = M.t503 + and type t504 = M.t504 + and type t505 = M.t505 + and type t506 = M.t506 + and type t507 = M.t507 + and type t508 = M.t508 + and type t509 = M.t509 + and type t510 = M.t510 + and type t511 = M.t511 + and type t512 = M.t512 + and type t513 = M.t513 + and type t514 = M.t514 + and type t515 = M.t515 + and type t516 = M.t516 + and type t517 = M.t517 + and type t518 = M.t518 + and type t519 = M.t519 + and type t520 = M.t520 + and type t521 = M.t521 + and type t522 = M.t522 + and type t523 = M.t523 + and type t524 = M.t524 + and type t525 = M.t525 + and type t526 = M.t526 + and type t527 = M.t527 + and type t528 = M.t528 + and type t529 = M.t529 + and type t530 = M.t530 + and type t531 = M.t531 + and type t532 = M.t532 + and type t533 = M.t533 + and type t534 = M.t534 + and type t535 = M.t535 + and type t536 = M.t536 + and type t537 = M.t537 + and type t538 = M.t538 + and type t539 = M.t539 + and type t540 = M.t540 + and type t541 = M.t541 + and type t542 = M.t542 + and type t543 = M.t543 + and type t544 = M.t544 + and type t545 = M.t545 + and type t546 = M.t546 + and type t547 = M.t547 + and type t548 = M.t548 + and type t549 = M.t549 + and type t550 = M.t550 + and type t551 = M.t551 + and type t552 = M.t552 + and type t553 = M.t553 + and type t554 = M.t554 + and type t555 = M.t555 + and type t556 = M.t556 + and type t557 = M.t557 + and type t558 = M.t558 + and type t559 = M.t559 + and type t560 = M.t560 + and type t561 = M.t561 + and type t562 = M.t562 + and type t563 = M.t563 + and type t564 = M.t564 + and type t565 = M.t565 + and type t566 = M.t566 + and type t567 = M.t567 + and type t568 = M.t568 + and type t569 = M.t569 + and type t570 = M.t570 + and type t571 = M.t571 + and type t572 = M.t572 + and type t573 = M.t573 + and type t574 = M.t574 + and type t575 = M.t575 + and type t576 = M.t576 + and type t577 = M.t577 + and type t578 = M.t578 + and type t579 = M.t579 + and type t580 = M.t580 + and type t581 = M.t581 + and type t582 = M.t582 + and type t583 = M.t583 + and type t584 = M.t584 + and type t585 = M.t585 + and type t586 = M.t586 + and type t587 = M.t587 + and type t588 = M.t588 + and type t589 = M.t589 + and type t590 = M.t590 + and type t591 = M.t591 + and type t592 = M.t592 + and type t593 = M.t593 + and type t594 = M.t594 + and type t595 = M.t595 + and type t596 = M.t596 + and type t597 = M.t597 + and type t598 = M.t598 + and type t599 = M.t599 + and type t600 = M.t600 + and type t601 = M.t601 + and type t602 = M.t602 + and type t603 = M.t603 + and type t604 = M.t604 + and type t605 = M.t605 + and type t606 = M.t606 + and type t607 = M.t607 + and type t608 = M.t608 + and type t609 = M.t609 + and type t610 = M.t610 + and type t611 = M.t611 + and type t612 = M.t612 + and type t613 = M.t613 + and type t614 = M.t614 + and type t615 = M.t615 + and type t616 = M.t616 + and type t617 = M.t617 + and type t618 = M.t618 + and type t619 = M.t619 + and type t620 = M.t620 + and type t621 = M.t621 + and type t622 = M.t622 + and type t623 = M.t623 + and type t624 = M.t624 + and type t625 = M.t625 + and type t626 = M.t626 + and type t627 = M.t627 + and type t628 = M.t628 + and type t629 = M.t629 + and type t630 = M.t630 + and type t631 = M.t631 + and type t632 = M.t632 + and type t633 = M.t633 + and type t634 = M.t634 + and type t635 = M.t635 + and type t636 = M.t636 + and type t637 = M.t637 + and type t638 = M.t638 + and type t639 = M.t639 + and type t640 = M.t640 + and type t641 = M.t641 + and type t642 = M.t642 + and type t643 = M.t643 + and type t644 = M.t644 + and type t645 = M.t645 + and type t646 = M.t646 + and type t647 = M.t647 + and type t648 = M.t648 + and type t649 = M.t649 + and type t650 = M.t650 + and type t651 = M.t651 + and type t652 = M.t652 + and type t653 = M.t653 + and type t654 = M.t654 + and type t655 = M.t655 + and type t656 = M.t656 + and type t657 = M.t657 + and type t658 = M.t658 + and type t659 = M.t659 + and type t660 = M.t660 + and type t661 = M.t661 + and type t662 = M.t662 + and type t663 = M.t663 + and type t664 = M.t664 + and type t665 = M.t665 + and type t666 = M.t666 + and type t667 = M.t667 + and type t668 = M.t668 + and type t669 = M.t669 + and type t670 = M.t670 + and type t671 = M.t671 + and type t672 = M.t672 + and type t673 = M.t673 + and type t674 = M.t674 + and type t675 = M.t675 + and type t676 = M.t676 + and type t677 = M.t677 + and type t678 = M.t678 + and type t679 = M.t679 + and type t680 = M.t680 + and type t681 = M.t681 + and type t682 = M.t682 + and type t683 = M.t683 + and type t684 = M.t684 + and type t685 = M.t685 + and type t686 = M.t686 + and type t687 = M.t687 + and type t688 = M.t688 + and type t689 = M.t689 + and type t690 = M.t690 + and type t691 = M.t691 + and type t692 = M.t692 + and type t693 = M.t693 + and type t694 = M.t694 + and type t695 = M.t695 + and type t696 = M.t696 + and type t697 = M.t697 + and type t698 = M.t698 + and type t699 = M.t699 + and type t700 = M.t700 + and type t701 = M.t701 + and type t702 = M.t702 + and type t703 = M.t703 + and type t704 = M.t704 + and type t705 = M.t705 + and type t706 = M.t706 + and type t707 = M.t707 + and type t708 = M.t708 + and type t709 = M.t709 + and type t710 = M.t710 + and type t711 = M.t711 + and type t712 = M.t712 + and type t713 = M.t713 + and type t714 = M.t714 + and type t715 = M.t715 + and type t716 = M.t716 + and type t717 = M.t717 + and type t718 = M.t718 + and type t719 = M.t719 + and type t720 = M.t720 + and type t721 = M.t721 + and type t722 = M.t722 + and type t723 = M.t723 + and type t724 = M.t724 + and type t725 = M.t725 + and type t726 = M.t726 + and type t727 = M.t727 + and type t728 = M.t728 + and type t729 = M.t729 + and type t730 = M.t730 + and type t731 = M.t731 + and type t732 = M.t732 + and type t733 = M.t733 + and type t734 = M.t734 + and type t735 = M.t735 + and type t736 = M.t736 + and type t737 = M.t737 + and type t738 = M.t738 + and type t739 = M.t739 + and type t740 = M.t740 + and type t741 = M.t741 + and type t742 = M.t742 + and type t743 = M.t743 + and type t744 = M.t744 + and type t745 = M.t745 + and type t746 = M.t746 + and type t747 = M.t747 + and type t748 = M.t748 + and type t749 = M.t749 + and type t750 = M.t750 + and type t751 = M.t751 + and type t752 = M.t752 + and type t753 = M.t753 + and type t754 = M.t754 + and type t755 = M.t755 + and type t756 = M.t756 + and type t757 = M.t757 + and type t758 = M.t758 + and type t759 = M.t759 + and type t760 = M.t760 + and type t761 = M.t761 + and type t762 = M.t762 + and type t763 = M.t763 + and type t764 = M.t764 + and type t765 = M.t765 + and type t766 = M.t766 + and type t767 = M.t767 + and type t768 = M.t768 + and type t769 = M.t769 + and type t770 = M.t770 + and type t771 = M.t771 + and type t772 = M.t772 + and type t773 = M.t773 + and type t774 = M.t774 + and type t775 = M.t775 + and type t776 = M.t776 + and type t777 = M.t777 + and type t778 = M.t778 + and type t779 = M.t779 + and type t780 = M.t780 + and type t781 = M.t781 + and type t782 = M.t782 + and type t783 = M.t783 + and type t784 = M.t784 + and type t785 = M.t785 + and type t786 = M.t786 + and type t787 = M.t787 + and type t788 = M.t788 + and type t789 = M.t789 + and type t790 = M.t790 + and type t791 = M.t791 + and type t792 = M.t792 + and type t793 = M.t793 + and type t794 = M.t794 + and type t795 = M.t795 + and type t796 = M.t796 + and type t797 = M.t797 + and type t798 = M.t798 + and type t799 = M.t799 + and type t800 = M.t800 + and type t801 = M.t801 + and type t802 = M.t802 + and type t803 = M.t803 + and type t804 = M.t804 + and type t805 = M.t805 + and type t806 = M.t806 + and type t807 = M.t807 + and type t808 = M.t808 + and type t809 = M.t809 + and type t810 = M.t810 + and type t811 = M.t811 + and type t812 = M.t812 + and type t813 = M.t813 + and type t814 = M.t814 + and type t815 = M.t815 + and type t816 = M.t816 + and type t817 = M.t817 + and type t818 = M.t818 + and type t819 = M.t819 + and type t820 = M.t820 + and type t821 = M.t821 + and type t822 = M.t822 + and type t823 = M.t823 + and type t824 = M.t824 + and type t825 = M.t825 + and type t826 = M.t826 + and type t827 = M.t827 + and type t828 = M.t828 + and type t829 = M.t829 + and type t830 = M.t830 + and type t831 = M.t831 + and type t832 = M.t832 + and type t833 = M.t833 + and type t834 = M.t834 + and type t835 = M.t835 + and type t836 = M.t836 + and type t837 = M.t837 + and type t838 = M.t838 + and type t839 = M.t839 + and type t840 = M.t840 + and type t841 = M.t841 + and type t842 = M.t842 + and type t843 = M.t843 + and type t844 = M.t844 + and type t845 = M.t845 + and type t846 = M.t846 + and type t847 = M.t847 + and type t848 = M.t848 + and type t849 = M.t849 + and type t850 = M.t850 + and type t851 = M.t851 + and type t852 = M.t852 + and type t853 = M.t853 + and type t854 = M.t854 + and type t855 = M.t855 + and type t856 = M.t856 + and type t857 = M.t857 + and type t858 = M.t858 + and type t859 = M.t859 + and type t860 = M.t860 + and type t861 = M.t861 + and type t862 = M.t862 + and type t863 = M.t863 + and type t864 = M.t864 + and type t865 = M.t865 + and type t866 = M.t866 + and type t867 = M.t867 + and type t868 = M.t868 + and type t869 = M.t869 + and type t870 = M.t870 + and type t871 = M.t871 + and type t872 = M.t872 + and type t873 = M.t873 + and type t874 = M.t874 + and type t875 = M.t875 + and type t876 = M.t876 + and type t877 = M.t877 + and type t878 = M.t878 + and type t879 = M.t879 + and type t880 = M.t880 + and type t881 = M.t881 + and type t882 = M.t882 + and type t883 = M.t883 + and type t884 = M.t884 + and type t885 = M.t885 + and type t886 = M.t886 + and type t887 = M.t887 + and type t888 = M.t888 + and type t889 = M.t889 + and type t890 = M.t890 + and type t891 = M.t891 + and type t892 = M.t892 + and type t893 = M.t893 + and type t894 = M.t894 + and type t895 = M.t895 + and type t896 = M.t896 + and type t897 = M.t897 + and type t898 = M.t898 + and type t899 = M.t899 + and type t900 = M.t900 + and type t901 = M.t901 + and type t902 = M.t902 + and type t903 = M.t903 + and type t904 = M.t904 + and type t905 = M.t905 + and type t906 = M.t906 + and type t907 = M.t907 + and type t908 = M.t908 + and type t909 = M.t909 + and type t910 = M.t910 + and type t911 = M.t911 + and type t912 = M.t912 + and type t913 = M.t913 + and type t914 = M.t914 + and type t915 = M.t915 + and type t916 = M.t916 + and type t917 = M.t917 + and type t918 = M.t918 + and type t919 = M.t919 + and type t920 = M.t920 + and type t921 = M.t921 + and type t922 = M.t922 + and type t923 = M.t923 + and type t924 = M.t924 + and type t925 = M.t925 + and type t926 = M.t926 + and type t927 = M.t927 + and type t928 = M.t928 + and type t929 = M.t929 + and type t930 = M.t930 + and type t931 = M.t931 + and type t932 = M.t932 + and type t933 = M.t933 + and type t934 = M.t934 + and type t935 = M.t935 + and type t936 = M.t936 + and type t937 = M.t937 + and type t938 = M.t938 + and type t939 = M.t939 + and type t940 = M.t940 + and type t941 = M.t941 + and type t942 = M.t942 + and type t943 = M.t943 + and type t944 = M.t944 + and type t945 = M.t945 + and type t946 = M.t946 + and type t947 = M.t947 + and type t948 = M.t948 + and type t949 = M.t949 + and type t950 = M.t950 + and type t951 = M.t951 + and type t952 = M.t952 + and type t953 = M.t953 + and type t954 = M.t954 + and type t955 = M.t955 + and type t956 = M.t956 + and type t957 = M.t957 + and type t958 = M.t958 + and type t959 = M.t959 + and type t960 = M.t960 + and type t961 = M.t961 + and type t962 = M.t962 + and type t963 = M.t963 + and type t964 = M.t964 + and type t965 = M.t965 + and type t966 = M.t966 + and type t967 = M.t967 + and type t968 = M.t968 + and type t969 = M.t969 + and type t970 = M.t970 + and type t971 = M.t971 + and type t972 = M.t972 + and type t973 = M.t973 + and type t974 = M.t974 + and type t975 = M.t975 + and type t976 = M.t976 + and type t977 = M.t977 + and type t978 = M.t978 + and type t979 = M.t979 + and type t980 = M.t980 + and type t981 = M.t981 + and type t982 = M.t982 + and type t983 = M.t983 + and type t984 = M.t984 + and type t985 = M.t985 + and type t986 = M.t986 + and type t987 = M.t987 + and type t988 = M.t988 + and type t989 = M.t989 + and type t990 = M.t990 + and type t991 = M.t991 + and type t992 = M.t992 + and type t993 = M.t993 + and type t994 = M.t994 + and type t995 = M.t995 + and type t996 = M.t996 + and type t997 = M.t997 + and type t998 = M.t998 + and type t999 = M.t999 + and type t1000 = M.t1000 += struct + include M +end + +module M = struct + type t0 = int -> int -> int + type t1 = int -> int -> int + type t2 = int -> int -> int + type t3 = int -> int -> int + type t4 = int -> int -> int + type t5 = int -> int -> int + type t6 = int -> int -> int + type t7 = int -> int -> int + type t8 = int -> int -> int + type t9 = int -> int -> int + type t10 = int -> int -> int + type t11 = int -> int -> int + type t12 = int -> int -> int + type t13 = int -> int -> int + type t14 = int -> int -> int + type t15 = int -> int -> int + type t16 = int -> int -> int + type t17 = int -> int -> int + type t18 = int -> int -> int + type t19 = int -> int -> int + type t20 = int -> int -> int + type t21 = int -> int -> int + type t22 = int -> int -> int + type t23 = int -> int -> int + type t24 = int -> int -> int + type t25 = int -> int -> int + type t26 = int -> int -> int + type t27 = int -> int -> int + type t28 = int -> int -> int + type t29 = int -> int -> int + type t30 = int -> int -> int + type t31 = int -> int -> int + type t32 = int -> int -> int + type t33 = int -> int -> int + type t34 = int -> int -> int + type t35 = int -> int -> int + type t36 = int -> int -> int + type t37 = int -> int -> int + type t38 = int -> int -> int + type t39 = int -> int -> int + type t40 = int -> int -> int + type t41 = int -> int -> int + type t42 = int -> int -> int + type t43 = int -> int -> int + type t44 = int -> int -> int + type t45 = int -> int -> int + type t46 = int -> int -> int + type t47 = int -> int -> int + type t48 = int -> int -> int + type t49 = int -> int -> int + type t50 = int -> int -> int + type t51 = int -> int -> int + type t52 = int -> int -> int + type t53 = int -> int -> int + type t54 = int -> int -> int + type t55 = int -> int -> int + type t56 = int -> int -> int + type t57 = int -> int -> int + type t58 = int -> int -> int + type t59 = int -> int -> int + type t60 = int -> int -> int + type t61 = int -> int -> int + type t62 = int -> int -> int + type t63 = int -> int -> int + type t64 = int -> int -> int + type t65 = int -> int -> int + type t66 = int -> int -> int + type t67 = int -> int -> int + type t68 = int -> int -> int + type t69 = int -> int -> int + type t70 = int -> int -> int + type t71 = int -> int -> int + type t72 = int -> int -> int + type t73 = int -> int -> int + type t74 = int -> int -> int + type t75 = int -> int -> int + type t76 = int -> int -> int + type t77 = int -> int -> int + type t78 = int -> int -> int + type t79 = int -> int -> int + type t80 = int -> int -> int + type t81 = int -> int -> int + type t82 = int -> int -> int + type t83 = int -> int -> int + type t84 = int -> int -> int + type t85 = int -> int -> int + type t86 = int -> int -> int + type t87 = int -> int -> int + type t88 = int -> int -> int + type t89 = int -> int -> int + type t90 = int -> int -> int + type t91 = int -> int -> int + type t92 = int -> int -> int + type t93 = int -> int -> int + type t94 = int -> int -> int + type t95 = int -> int -> int + type t96 = int -> int -> int + type t97 = int -> int -> int + type t98 = int -> int -> int + type t99 = int -> int -> int + type t100 = int -> int -> int + type t101 = int -> int -> int + type t102 = int -> int -> int + type t103 = int -> int -> int + type t104 = int -> int -> int + type t105 = int -> int -> int + type t106 = int -> int -> int + type t107 = int -> int -> int + type t108 = int -> int -> int + type t109 = int -> int -> int + type t110 = int -> int -> int + type t111 = int -> int -> int + type t112 = int -> int -> int + type t113 = int -> int -> int + type t114 = int -> int -> int + type t115 = int -> int -> int + type t116 = int -> int -> int + type t117 = int -> int -> int + type t118 = int -> int -> int + type t119 = int -> int -> int + type t120 = int -> int -> int + type t121 = int -> int -> int + type t122 = int -> int -> int + type t123 = int -> int -> int + type t124 = int -> int -> int + type t125 = int -> int -> int + type t126 = int -> int -> int + type t127 = int -> int -> int + type t128 = int -> int -> int + type t129 = int -> int -> int + type t130 = int -> int -> int + type t131 = int -> int -> int + type t132 = int -> int -> int + type t133 = int -> int -> int + type t134 = int -> int -> int + type t135 = int -> int -> int + type t136 = int -> int -> int + type t137 = int -> int -> int + type t138 = int -> int -> int + type t139 = int -> int -> int + type t140 = int -> int -> int + type t141 = int -> int -> int + type t142 = int -> int -> int + type t143 = int -> int -> int + type t144 = int -> int -> int + type t145 = int -> int -> int + type t146 = int -> int -> int + type t147 = int -> int -> int + type t148 = int -> int -> int + type t149 = int -> int -> int + type t150 = int -> int -> int + type t151 = int -> int -> int + type t152 = int -> int -> int + type t153 = int -> int -> int + type t154 = int -> int -> int + type t155 = int -> int -> int + type t156 = int -> int -> int + type t157 = int -> int -> int + type t158 = int -> int -> int + type t159 = int -> int -> int + type t160 = int -> int -> int + type t161 = int -> int -> int + type t162 = int -> int -> int + type t163 = int -> int -> int + type t164 = int -> int -> int + type t165 = int -> int -> int + type t166 = int -> int -> int + type t167 = int -> int -> int + type t168 = int -> int -> int + type t169 = int -> int -> int + type t170 = int -> int -> int + type t171 = int -> int -> int + type t172 = int -> int -> int + type t173 = int -> int -> int + type t174 = int -> int -> int + type t175 = int -> int -> int + type t176 = int -> int -> int + type t177 = int -> int -> int + type t178 = int -> int -> int + type t179 = int -> int -> int + type t180 = int -> int -> int + type t181 = int -> int -> int + type t182 = int -> int -> int + type t183 = int -> int -> int + type t184 = int -> int -> int + type t185 = int -> int -> int + type t186 = int -> int -> int + type t187 = int -> int -> int + type t188 = int -> int -> int + type t189 = int -> int -> int + type t190 = int -> int -> int + type t191 = int -> int -> int + type t192 = int -> int -> int + type t193 = int -> int -> int + type t194 = int -> int -> int + type t195 = int -> int -> int + type t196 = int -> int -> int + type t197 = int -> int -> int + type t198 = int -> int -> int + type t199 = int -> int -> int + type t200 = int -> int -> int + type t201 = int -> int -> int + type t202 = int -> int -> int + type t203 = int -> int -> int + type t204 = int -> int -> int + type t205 = int -> int -> int + type t206 = int -> int -> int + type t207 = int -> int -> int + type t208 = int -> int -> int + type t209 = int -> int -> int + type t210 = int -> int -> int + type t211 = int -> int -> int + type t212 = int -> int -> int + type t213 = int -> int -> int + type t214 = int -> int -> int + type t215 = int -> int -> int + type t216 = int -> int -> int + type t217 = int -> int -> int + type t218 = int -> int -> int + type t219 = int -> int -> int + type t220 = int -> int -> int + type t221 = int -> int -> int + type t222 = int -> int -> int + type t223 = int -> int -> int + type t224 = int -> int -> int + type t225 = int -> int -> int + type t226 = int -> int -> int + type t227 = int -> int -> int + type t228 = int -> int -> int + type t229 = int -> int -> int + type t230 = int -> int -> int + type t231 = int -> int -> int + type t232 = int -> int -> int + type t233 = int -> int -> int + type t234 = int -> int -> int + type t235 = int -> int -> int + type t236 = int -> int -> int + type t237 = int -> int -> int + type t238 = int -> int -> int + type t239 = int -> int -> int + type t240 = int -> int -> int + type t241 = int -> int -> int + type t242 = int -> int -> int + type t243 = int -> int -> int + type t244 = int -> int -> int + type t245 = int -> int -> int + type t246 = int -> int -> int + type t247 = int -> int -> int + type t248 = int -> int -> int + type t249 = int -> int -> int + type t250 = int -> int -> int + type t251 = int -> int -> int + type t252 = int -> int -> int + type t253 = int -> int -> int + type t254 = int -> int -> int + type t255 = int -> int -> int + type t256 = int -> int -> int + type t257 = int -> int -> int + type t258 = int -> int -> int + type t259 = int -> int -> int + type t260 = int -> int -> int + type t261 = int -> int -> int + type t262 = int -> int -> int + type t263 = int -> int -> int + type t264 = int -> int -> int + type t265 = int -> int -> int + type t266 = int -> int -> int + type t267 = int -> int -> int + type t268 = int -> int -> int + type t269 = int -> int -> int + type t270 = int -> int -> int + type t271 = int -> int -> int + type t272 = int -> int -> int + type t273 = int -> int -> int + type t274 = int -> int -> int + type t275 = int -> int -> int + type t276 = int -> int -> int + type t277 = int -> int -> int + type t278 = int -> int -> int + type t279 = int -> int -> int + type t280 = int -> int -> int + type t281 = int -> int -> int + type t282 = int -> int -> int + type t283 = int -> int -> int + type t284 = int -> int -> int + type t285 = int -> int -> int + type t286 = int -> int -> int + type t287 = int -> int -> int + type t288 = int -> int -> int + type t289 = int -> int -> int + type t290 = int -> int -> int + type t291 = int -> int -> int + type t292 = int -> int -> int + type t293 = int -> int -> int + type t294 = int -> int -> int + type t295 = int -> int -> int + type t296 = int -> int -> int + type t297 = int -> int -> int + type t298 = int -> int -> int + type t299 = int -> int -> int + type t300 = int -> int -> int + type t301 = int -> int -> int + type t302 = int -> int -> int + type t303 = int -> int -> int + type t304 = int -> int -> int + type t305 = int -> int -> int + type t306 = int -> int -> int + type t307 = int -> int -> int + type t308 = int -> int -> int + type t309 = int -> int -> int + type t310 = int -> int -> int + type t311 = int -> int -> int + type t312 = int -> int -> int + type t313 = int -> int -> int + type t314 = int -> int -> int + type t315 = int -> int -> int + type t316 = int -> int -> int + type t317 = int -> int -> int + type t318 = int -> int -> int + type t319 = int -> int -> int + type t320 = int -> int -> int + type t321 = int -> int -> int + type t322 = int -> int -> int + type t323 = int -> int -> int + type t324 = int -> int -> int + type t325 = int -> int -> int + type t326 = int -> int -> int + type t327 = int -> int -> int + type t328 = int -> int -> int + type t329 = int -> int -> int + type t330 = int -> int -> int + type t331 = int -> int -> int + type t332 = int -> int -> int + type t333 = int -> int -> int + type t334 = int -> int -> int + type t335 = int -> int -> int + type t336 = int -> int -> int + type t337 = int -> int -> int + type t338 = int -> int -> int + type t339 = int -> int -> int + type t340 = int -> int -> int + type t341 = int -> int -> int + type t342 = int -> int -> int + type t343 = int -> int -> int + type t344 = int -> int -> int + type t345 = int -> int -> int + type t346 = int -> int -> int + type t347 = int -> int -> int + type t348 = int -> int -> int + type t349 = int -> int -> int + type t350 = int -> int -> int + type t351 = int -> int -> int + type t352 = int -> int -> int + type t353 = int -> int -> int + type t354 = int -> int -> int + type t355 = int -> int -> int + type t356 = int -> int -> int + type t357 = int -> int -> int + type t358 = int -> int -> int + type t359 = int -> int -> int + type t360 = int -> int -> int + type t361 = int -> int -> int + type t362 = int -> int -> int + type t363 = int -> int -> int + type t364 = int -> int -> int + type t365 = int -> int -> int + type t366 = int -> int -> int + type t367 = int -> int -> int + type t368 = int -> int -> int + type t369 = int -> int -> int + type t370 = int -> int -> int + type t371 = int -> int -> int + type t372 = int -> int -> int + type t373 = int -> int -> int + type t374 = int -> int -> int + type t375 = int -> int -> int + type t376 = int -> int -> int + type t377 = int -> int -> int + type t378 = int -> int -> int + type t379 = int -> int -> int + type t380 = int -> int -> int + type t381 = int -> int -> int + type t382 = int -> int -> int + type t383 = int -> int -> int + type t384 = int -> int -> int + type t385 = int -> int -> int + type t386 = int -> int -> int + type t387 = int -> int -> int + type t388 = int -> int -> int + type t389 = int -> int -> int + type t390 = int -> int -> int + type t391 = int -> int -> int + type t392 = int -> int -> int + type t393 = int -> int -> int + type t394 = int -> int -> int + type t395 = int -> int -> int + type t396 = int -> int -> int + type t397 = int -> int -> int + type t398 = int -> int -> int + type t399 = int -> int -> int + type t400 = int -> int -> int + type t401 = int -> int -> int + type t402 = int -> int -> int + type t403 = int -> int -> int + type t404 = int -> int -> int + type t405 = int -> int -> int + type t406 = int -> int -> int + type t407 = int -> int -> int + type t408 = int -> int -> int + type t409 = int -> int -> int + type t410 = int -> int -> int + type t411 = int -> int -> int + type t412 = int -> int -> int + type t413 = int -> int -> int + type t414 = int -> int -> int + type t415 = int -> int -> int + type t416 = int -> int -> int + type t417 = int -> int -> int + type t418 = int -> int -> int + type t419 = int -> int -> int + type t420 = int -> int -> int + type t421 = int -> int -> int + type t422 = int -> int -> int + type t423 = int -> int -> int + type t424 = int -> int -> int + type t425 = int -> int -> int + type t426 = int -> int -> int + type t427 = int -> int -> int + type t428 = int -> int -> int + type t429 = int -> int -> int + type t430 = int -> int -> int + type t431 = int -> int -> int + type t432 = int -> int -> int + type t433 = int -> int -> int + type t434 = int -> int -> int + type t435 = int -> int -> int + type t436 = int -> int -> int + type t437 = int -> int -> int + type t438 = int -> int -> int + type t439 = int -> int -> int + type t440 = int -> int -> int + type t441 = int -> int -> int + type t442 = int -> int -> int + type t443 = int -> int -> int + type t444 = int -> int -> int + type t445 = int -> int -> int + type t446 = int -> int -> int + type t447 = int -> int -> int + type t448 = int -> int -> int + type t449 = int -> int -> int + type t450 = int -> int -> int + type t451 = int -> int -> int + type t452 = int -> int -> int + type t453 = int -> int -> int + type t454 = int -> int -> int + type t455 = int -> int -> int + type t456 = int -> int -> int + type t457 = int -> int -> int + type t458 = int -> int -> int + type t459 = int -> int -> int + type t460 = int -> int -> int + type t461 = int -> int -> int + type t462 = int -> int -> int + type t463 = int -> int -> int + type t464 = int -> int -> int + type t465 = int -> int -> int + type t466 = int -> int -> int + type t467 = int -> int -> int + type t468 = int -> int -> int + type t469 = int -> int -> int + type t470 = int -> int -> int + type t471 = int -> int -> int + type t472 = int -> int -> int + type t473 = int -> int -> int + type t474 = int -> int -> int + type t475 = int -> int -> int + type t476 = int -> int -> int + type t477 = int -> int -> int + type t478 = int -> int -> int + type t479 = int -> int -> int + type t480 = int -> int -> int + type t481 = int -> int -> int + type t482 = int -> int -> int + type t483 = int -> int -> int + type t484 = int -> int -> int + type t485 = int -> int -> int + type t486 = int -> int -> int + type t487 = int -> int -> int + type t488 = int -> int -> int + type t489 = int -> int -> int + type t490 = int -> int -> int + type t491 = int -> int -> int + type t492 = int -> int -> int + type t493 = int -> int -> int + type t494 = int -> int -> int + type t495 = int -> int -> int + type t496 = int -> int -> int + type t497 = int -> int -> int + type t498 = int -> int -> int + type t499 = int -> int -> int + type t500 = int -> int -> int + type t501 = int -> int -> int + type t502 = int -> int -> int + type t503 = int -> int -> int + type t504 = int -> int -> int + type t505 = int -> int -> int + type t506 = int -> int -> int + type t507 = int -> int -> int + type t508 = int -> int -> int + type t509 = int -> int -> int + type t510 = int -> int -> int + type t511 = int -> int -> int + type t512 = int -> int -> int + type t513 = int -> int -> int + type t514 = int -> int -> int + type t515 = int -> int -> int + type t516 = int -> int -> int + type t517 = int -> int -> int + type t518 = int -> int -> int + type t519 = int -> int -> int + type t520 = int -> int -> int + type t521 = int -> int -> int + type t522 = int -> int -> int + type t523 = int -> int -> int + type t524 = int -> int -> int + type t525 = int -> int -> int + type t526 = int -> int -> int + type t527 = int -> int -> int + type t528 = int -> int -> int + type t529 = int -> int -> int + type t530 = int -> int -> int + type t531 = int -> int -> int + type t532 = int -> int -> int + type t533 = int -> int -> int + type t534 = int -> int -> int + type t535 = int -> int -> int + type t536 = int -> int -> int + type t537 = int -> int -> int + type t538 = int -> int -> int + type t539 = int -> int -> int + type t540 = int -> int -> int + type t541 = int -> int -> int + type t542 = int -> int -> int + type t543 = int -> int -> int + type t544 = int -> int -> int + type t545 = int -> int -> int + type t546 = int -> int -> int + type t547 = int -> int -> int + type t548 = int -> int -> int + type t549 = int -> int -> int + type t550 = int -> int -> int + type t551 = int -> int -> int + type t552 = int -> int -> int + type t553 = int -> int -> int + type t554 = int -> int -> int + type t555 = int -> int -> int + type t556 = int -> int -> int + type t557 = int -> int -> int + type t558 = int -> int -> int + type t559 = int -> int -> int + type t560 = int -> int -> int + type t561 = int -> int -> int + type t562 = int -> int -> int + type t563 = int -> int -> int + type t564 = int -> int -> int + type t565 = int -> int -> int + type t566 = int -> int -> int + type t567 = int -> int -> int + type t568 = int -> int -> int + type t569 = int -> int -> int + type t570 = int -> int -> int + type t571 = int -> int -> int + type t572 = int -> int -> int + type t573 = int -> int -> int + type t574 = int -> int -> int + type t575 = int -> int -> int + type t576 = int -> int -> int + type t577 = int -> int -> int + type t578 = int -> int -> int + type t579 = int -> int -> int + type t580 = int -> int -> int + type t581 = int -> int -> int + type t582 = int -> int -> int + type t583 = int -> int -> int + type t584 = int -> int -> int + type t585 = int -> int -> int + type t586 = int -> int -> int + type t587 = int -> int -> int + type t588 = int -> int -> int + type t589 = int -> int -> int + type t590 = int -> int -> int + type t591 = int -> int -> int + type t592 = int -> int -> int + type t593 = int -> int -> int + type t594 = int -> int -> int + type t595 = int -> int -> int + type t596 = int -> int -> int + type t597 = int -> int -> int + type t598 = int -> int -> int + type t599 = int -> int -> int + type t600 = int -> int -> int + type t601 = int -> int -> int + type t602 = int -> int -> int + type t603 = int -> int -> int + type t604 = int -> int -> int + type t605 = int -> int -> int + type t606 = int -> int -> int + type t607 = int -> int -> int + type t608 = int -> int -> int + type t609 = int -> int -> int + type t610 = int -> int -> int + type t611 = int -> int -> int + type t612 = int -> int -> int + type t613 = int -> int -> int + type t614 = int -> int -> int + type t615 = int -> int -> int + type t616 = int -> int -> int + type t617 = int -> int -> int + type t618 = int -> int -> int + type t619 = int -> int -> int + type t620 = int -> int -> int + type t621 = int -> int -> int + type t622 = int -> int -> int + type t623 = int -> int -> int + type t624 = int -> int -> int + type t625 = int -> int -> int + type t626 = int -> int -> int + type t627 = int -> int -> int + type t628 = int -> int -> int + type t629 = int -> int -> int + type t630 = int -> int -> int + type t631 = int -> int -> int + type t632 = int -> int -> int + type t633 = int -> int -> int + type t634 = int -> int -> int + type t635 = int -> int -> int + type t636 = int -> int -> int + type t637 = int -> int -> int + type t638 = int -> int -> int + type t639 = int -> int -> int + type t640 = int -> int -> int + type t641 = int -> int -> int + type t642 = int -> int -> int + type t643 = int -> int -> int + type t644 = int -> int -> int + type t645 = int -> int -> int + type t646 = int -> int -> int + type t647 = int -> int -> int + type t648 = int -> int -> int + type t649 = int -> int -> int + type t650 = int -> int -> int + type t651 = int -> int -> int + type t652 = int -> int -> int + type t653 = int -> int -> int + type t654 = int -> int -> int + type t655 = int -> int -> int + type t656 = int -> int -> int + type t657 = int -> int -> int + type t658 = int -> int -> int + type t659 = int -> int -> int + type t660 = int -> int -> int + type t661 = int -> int -> int + type t662 = int -> int -> int + type t663 = int -> int -> int + type t664 = int -> int -> int + type t665 = int -> int -> int + type t666 = int -> int -> int + type t667 = int -> int -> int + type t668 = int -> int -> int + type t669 = int -> int -> int + type t670 = int -> int -> int + type t671 = int -> int -> int + type t672 = int -> int -> int + type t673 = int -> int -> int + type t674 = int -> int -> int + type t675 = int -> int -> int + type t676 = int -> int -> int + type t677 = int -> int -> int + type t678 = int -> int -> int + type t679 = int -> int -> int + type t680 = int -> int -> int + type t681 = int -> int -> int + type t682 = int -> int -> int + type t683 = int -> int -> int + type t684 = int -> int -> int + type t685 = int -> int -> int + type t686 = int -> int -> int + type t687 = int -> int -> int + type t688 = int -> int -> int + type t689 = int -> int -> int + type t690 = int -> int -> int + type t691 = int -> int -> int + type t692 = int -> int -> int + type t693 = int -> int -> int + type t694 = int -> int -> int + type t695 = int -> int -> int + type t696 = int -> int -> int + type t697 = int -> int -> int + type t698 = int -> int -> int + type t699 = int -> int -> int + type t700 = int -> int -> int + type t701 = int -> int -> int + type t702 = int -> int -> int + type t703 = int -> int -> int + type t704 = int -> int -> int + type t705 = int -> int -> int + type t706 = int -> int -> int + type t707 = int -> int -> int + type t708 = int -> int -> int + type t709 = int -> int -> int + type t710 = int -> int -> int + type t711 = int -> int -> int + type t712 = int -> int -> int + type t713 = int -> int -> int + type t714 = int -> int -> int + type t715 = int -> int -> int + type t716 = int -> int -> int + type t717 = int -> int -> int + type t718 = int -> int -> int + type t719 = int -> int -> int + type t720 = int -> int -> int + type t721 = int -> int -> int + type t722 = int -> int -> int + type t723 = int -> int -> int + type t724 = int -> int -> int + type t725 = int -> int -> int + type t726 = int -> int -> int + type t727 = int -> int -> int + type t728 = int -> int -> int + type t729 = int -> int -> int + type t730 = int -> int -> int + type t731 = int -> int -> int + type t732 = int -> int -> int + type t733 = int -> int -> int + type t734 = int -> int -> int + type t735 = int -> int -> int + type t736 = int -> int -> int + type t737 = int -> int -> int + type t738 = int -> int -> int + type t739 = int -> int -> int + type t740 = int -> int -> int + type t741 = int -> int -> int + type t742 = int -> int -> int + type t743 = int -> int -> int + type t744 = int -> int -> int + type t745 = int -> int -> int + type t746 = int -> int -> int + type t747 = int -> int -> int + type t748 = int -> int -> int + type t749 = int -> int -> int + type t750 = int -> int -> int + type t751 = int -> int -> int + type t752 = int -> int -> int + type t753 = int -> int -> int + type t754 = int -> int -> int + type t755 = int -> int -> int + type t756 = int -> int -> int + type t757 = int -> int -> int + type t758 = int -> int -> int + type t759 = int -> int -> int + type t760 = int -> int -> int + type t761 = int -> int -> int + type t762 = int -> int -> int + type t763 = int -> int -> int + type t764 = int -> int -> int + type t765 = int -> int -> int + type t766 = int -> int -> int + type t767 = int -> int -> int + type t768 = int -> int -> int + type t769 = int -> int -> int + type t770 = int -> int -> int + type t771 = int -> int -> int + type t772 = int -> int -> int + type t773 = int -> int -> int + type t774 = int -> int -> int + type t775 = int -> int -> int + type t776 = int -> int -> int + type t777 = int -> int -> int + type t778 = int -> int -> int + type t779 = int -> int -> int + type t780 = int -> int -> int + type t781 = int -> int -> int + type t782 = int -> int -> int + type t783 = int -> int -> int + type t784 = int -> int -> int + type t785 = int -> int -> int + type t786 = int -> int -> int + type t787 = int -> int -> int + type t788 = int -> int -> int + type t789 = int -> int -> int + type t790 = int -> int -> int + type t791 = int -> int -> int + type t792 = int -> int -> int + type t793 = int -> int -> int + type t794 = int -> int -> int + type t795 = int -> int -> int + type t796 = int -> int -> int + type t797 = int -> int -> int + type t798 = int -> int -> int + type t799 = int -> int -> int + type t800 = int -> int -> int + type t801 = int -> int -> int + type t802 = int -> int -> int + type t803 = int -> int -> int + type t804 = int -> int -> int + type t805 = int -> int -> int + type t806 = int -> int -> int + type t807 = int -> int -> int + type t808 = int -> int -> int + type t809 = int -> int -> int + type t810 = int -> int -> int + type t811 = int -> int -> int + type t812 = int -> int -> int + type t813 = int -> int -> int + type t814 = int -> int -> int + type t815 = int -> int -> int + type t816 = int -> int -> int + type t817 = int -> int -> int + type t818 = int -> int -> int + type t819 = int -> int -> int + type t820 = int -> int -> int + type t821 = int -> int -> int + type t822 = int -> int -> int + type t823 = int -> int -> int + type t824 = int -> int -> int + type t825 = int -> int -> int + type t826 = int -> int -> int + type t827 = int -> int -> int + type t828 = int -> int -> int + type t829 = int -> int -> int + type t830 = int -> int -> int + type t831 = int -> int -> int + type t832 = int -> int -> int + type t833 = int -> int -> int + type t834 = int -> int -> int + type t835 = int -> int -> int + type t836 = int -> int -> int + type t837 = int -> int -> int + type t838 = int -> int -> int + type t839 = int -> int -> int + type t840 = int -> int -> int + type t841 = int -> int -> int + type t842 = int -> int -> int + type t843 = int -> int -> int + type t844 = int -> int -> int + type t845 = int -> int -> int + type t846 = int -> int -> int + type t847 = int -> int -> int + type t848 = int -> int -> int + type t849 = int -> int -> int + type t850 = int -> int -> int + type t851 = int -> int -> int + type t852 = int -> int -> int + type t853 = int -> int -> int + type t854 = int -> int -> int + type t855 = int -> int -> int + type t856 = int -> int -> int + type t857 = int -> int -> int + type t858 = int -> int -> int + type t859 = int -> int -> int + type t860 = int -> int -> int + type t861 = int -> int -> int + type t862 = int -> int -> int + type t863 = int -> int -> int + type t864 = int -> int -> int + type t865 = int -> int -> int + type t866 = int -> int -> int + type t867 = int -> int -> int + type t868 = int -> int -> int + type t869 = int -> int -> int + type t870 = int -> int -> int + type t871 = int -> int -> int + type t872 = int -> int -> int + type t873 = int -> int -> int + type t874 = int -> int -> int + type t875 = int -> int -> int + type t876 = int -> int -> int + type t877 = int -> int -> int + type t878 = int -> int -> int + type t879 = int -> int -> int + type t880 = int -> int -> int + type t881 = int -> int -> int + type t882 = int -> int -> int + type t883 = int -> int -> int + type t884 = int -> int -> int + type t885 = int -> int -> int + type t886 = int -> int -> int + type t887 = int -> int -> int + type t888 = int -> int -> int + type t889 = int -> int -> int + type t890 = int -> int -> int + type t891 = int -> int -> int + type t892 = int -> int -> int + type t893 = int -> int -> int + type t894 = int -> int -> int + type t895 = int -> int -> int + type t896 = int -> int -> int + type t897 = int -> int -> int + type t898 = int -> int -> int + type t899 = int -> int -> int + type t900 = int -> int -> int + type t901 = int -> int -> int + type t902 = int -> int -> int + type t903 = int -> int -> int + type t904 = int -> int -> int + type t905 = int -> int -> int + type t906 = int -> int -> int + type t907 = int -> int -> int + type t908 = int -> int -> int + type t909 = int -> int -> int + type t910 = int -> int -> int + type t911 = int -> int -> int + type t912 = int -> int -> int + type t913 = int -> int -> int + type t914 = int -> int -> int + type t915 = int -> int -> int + type t916 = int -> int -> int + type t917 = int -> int -> int + type t918 = int -> int -> int + type t919 = int -> int -> int + type t920 = int -> int -> int + type t921 = int -> int -> int + type t922 = int -> int -> int + type t923 = int -> int -> int + type t924 = int -> int -> int + type t925 = int -> int -> int + type t926 = int -> int -> int + type t927 = int -> int -> int + type t928 = int -> int -> int + type t929 = int -> int -> int + type t930 = int -> int -> int + type t931 = int -> int -> int + type t932 = int -> int -> int + type t933 = int -> int -> int + type t934 = int -> int -> int + type t935 = int -> int -> int + type t936 = int -> int -> int + type t937 = int -> int -> int + type t938 = int -> int -> int + type t939 = int -> int -> int + type t940 = int -> int -> int + type t941 = int -> int -> int + type t942 = int -> int -> int + type t943 = int -> int -> int + type t944 = int -> int -> int + type t945 = int -> int -> int + type t946 = int -> int -> int + type t947 = int -> int -> int + type t948 = int -> int -> int + type t949 = int -> int -> int + type t950 = int -> int -> int + type t951 = int -> int -> int + type t952 = int -> int -> int + type t953 = int -> int -> int + type t954 = int -> int -> int + type t955 = int -> int -> int + type t956 = int -> int -> int + type t957 = int -> int -> int + type t958 = int -> int -> int + type t959 = int -> int -> int + type t960 = int -> int -> int + type t961 = int -> int -> int + type t962 = int -> int -> int + type t963 = int -> int -> int + type t964 = int -> int -> int + type t965 = int -> int -> int + type t966 = int -> int -> int + type t967 = int -> int -> int + type t968 = int -> int -> int + type t969 = int -> int -> int + type t970 = int -> int -> int + type t971 = int -> int -> int + type t972 = int -> int -> int + type t973 = int -> int -> int + type t974 = int -> int -> int + type t975 = int -> int -> int + type t976 = int -> int -> int + type t977 = int -> int -> int + type t978 = int -> int -> int + type t979 = int -> int -> int + type t980 = int -> int -> int + type t981 = int -> int -> int + type t982 = int -> int -> int + type t983 = int -> int -> int + type t984 = int -> int -> int + type t985 = int -> int -> int + type t986 = int -> int -> int + type t987 = int -> int -> int + type t988 = int -> int -> int + type t989 = int -> int -> int + type t990 = int -> int -> int + type t991 = int -> int -> int + type t992 = int -> int -> int + type t993 = int -> int -> int + type t994 = int -> int -> int + type t995 = int -> int -> int + type t996 = int -> int -> int + type t997 = int -> int -> int + type t998 = int -> int -> int + type t999 = int -> int -> int + type t1000 = int -> int -> int +end + +module X = + Make + (Make + (Make + (Make + (Make + (Make + (Make + (Make + (Make + (Make + (Make + (M))))))))))) diff --git a/camlp4/test/fixtures/functor-perf2.ml b/camlp4/test/fixtures/functor-perf2.ml new file mode 100644 index 00000000..57b8bbad --- /dev/null +++ b/camlp4/test/fixtures/functor-perf2.ml @@ -0,0 +1,29 @@ +<% types, with_constrs, module_application = ARGV.map { |x| x.to_i } %> + +module type S = sig +<%- for i in 0 .. types do -%> + type t<%= i %> +<%- end -%> +end + +module Make (M : S) +: S with type t0 = M.t0 + <%- for i in 1 .. with_constrs do -%> + and type t<%= i %> = M.t<%= i %> + <%- end -%> += struct + include M +end + +module M = struct +<%- for i in 0 .. types do -%> + type t<%= i %> = int -> int -> int +<%- end -%> +end + +module X = + Make +<%- module_application.times do -%> + (Make +<%- end -%> + (M)<%= ')' * module_application %> diff --git a/camlp4/test/fixtures/functor-perf3.ml b/camlp4/test/fixtures/functor-perf3.ml new file mode 100644 index 00000000..5bf5359c --- /dev/null +++ b/camlp4/test/fixtures/functor-perf3.ml @@ -0,0 +1,50 @@ +<% types, with_constrs, make, make2 = ARGV.map { |x| x.to_i } %> + +module type S = sig +<%- for i in 0 .. types do -%> + type t<%= i %> +<%- end -%> +end + +module Make (M : S) +: S with type t0 = M.t0 + <%- for i in 1 .. with_constrs do -%> + and type t<%= i %> = M.t<%= i %> + <%- end -%> += struct + include M +end + +module type S2 = sig + module M : S +end + +module Make2 (M2 : S2) +: S2 with module M = M2.M += struct + include M2 +end + +module M = struct +<%- for i in 0 .. types do -%> + type t<%= i %> = int -> int -> int +<%- end -%> +end + +module M1 = + Make +<%- make.times do -%> + (Make +<%- end -%> + (M)<%= ')' * make %> + +module M2 = struct + module M = M1 +end + +module X = + Make2 +<%- make2.times do -%> + (Make2 +<%- end -%> + (M2)<%= ')' * make2 %> diff --git a/camlp4/test/fixtures/gen_map.ml b/camlp4/test/fixtures/gen_map.ml new file mode 100644 index 00000000..86557520 --- /dev/null +++ b/camlp4/test/fixtures/gen_map.ml @@ -0,0 +1,8 @@ +type t = + A of int * t * t +| B of int list +| C of option t + +module Map = struct + module T = Camlp4Filters.GenerateMap.Generated +end diff --git a/camlp4/test/fixtures/gram-fold.ml b/camlp4/test/fixtures/gram-fold.ml new file mode 100644 index 00000000..5cd53b17 --- /dev/null +++ b/camlp4/test/fixtures/gram-fold.ml @@ -0,0 +1,21 @@ +open Camlp4.PreCast; +module G = MakeGram Lexer; +type t = [ A of t and t | B of string | C ]; +value main = G.Entry.mk "main"; +value rec length x acc = + match x with + [ A x y -> length x (length y acc) + | B _ -> succ acc + | C -> acc ]; +EXTEND G + GLOBAL: main; + main: + [ [ + l = FOLD1 (fun a b -> A (B a) b) (C) ident -> l + ] ]; + ident: + [ [ `LIDENT s -> s ] ]; +END; +let f = Sys.argv.(1) in +Format.printf "%d@." + (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0); diff --git a/camlp4/test/fixtures/gram-list.ml b/camlp4/test/fixtures/gram-list.ml new file mode 100644 index 00000000..f3df766e --- /dev/null +++ b/camlp4/test/fixtures/gram-list.ml @@ -0,0 +1,13 @@ +open Camlp4.PreCast; +module G = MakeGram Lexer; +value main = G.Entry.mk "main"; +EXTEND G + GLOBAL: main; + main: + [ [ l = LIST1 ident -> l ] ]; + ident: + [ [ `LIDENT s -> s ] ]; +END; +let f = Sys.argv.(1) in +Format.printf "%d@." + (List.length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f)))); diff --git a/camlp4/test/fixtures/gram-loc-lost.ml b/camlp4/test/fixtures/gram-loc-lost.ml new file mode 100644 index 00000000..38b164e5 --- /dev/null +++ b/camlp4/test/fixtures/gram-loc-lost.ml @@ -0,0 +1,30 @@ +open Camlp4.PreCast; +module G = MakeGram Lexer; +(* type t = [ A of Loc.t and t and t | B of Loc.t and string ]; *) +value main = G.Entry.mk "main"; +(* value rec length x acc = + match x with + [ A x y -> length x (length y acc) + | B _ -> succ acc ]; +value length _ _ = -1; *) +EXTEND G + GLOBAL: main; + main: + [ RIGHTA + [ x = SELF; y = SELF -> + let l = Loc.merge x y in + if l = _loc then _loc + else do { + Format.eprintf "bad loc: %a <> %a + %a@." + Loc.dump _loc Loc.dump x Loc.dump y; + _loc + } + | i = ident -> i ] ]; + ident: + [ [ `LIDENT _ -> _loc ] ]; +END; +try + let f = Sys.argv.(1) in + Format.printf "%a@." + Loc.dump (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) +with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e; diff --git a/camlp4/test/fixtures/gram-sub-rule.ml b/camlp4/test/fixtures/gram-sub-rule.ml new file mode 100644 index 00000000..4066caee --- /dev/null +++ b/camlp4/test/fixtures/gram-sub-rule.ml @@ -0,0 +1,33 @@ +open Camlp4.PreCast.Syntax; + +value mo _loc = + fun + [ None -> <:expr< None >> + | Some e -> <:expr< Some $e$ >> ]; + +EXTEND Gram +GLOBAL: expr; +expr: + [ [ "testbegin"; + lb = [ "("; l = LIST0 a_LIDENT SEP ","; ")" -> l | "()" -> [] ]; + b = bar; + "testend" -> + let e = + List.fold_right (fun i acc -> <:expr< [ $lid:i$ :: $acc$ ] >>) lb <:expr< [] >> + in <:expr< ($e$, $b$) >> + ] ]; +bar: + [ [ x = OPT [ o = OPT [ x = "testb" -> + <:expr< $str:Token.extract_string x$ >> ]; "testc"; b = baz -> + <:expr< ($mo _loc o$, $b$) >> ] -> mo _loc x + ] ]; +(* bar: + [ [ o = OPT [ o = OPT [ "bar" -> <:expr< bar >> ]; b = baz -> <:expr< ($mo _loc o$, $b$) >> ] -> + mo _loc o + ] ]; *) +(* bar: + [ [ o = OPT [ "bar" -> <:expr< bar >> ]; b = baz -> <:expr< ($mo _loc o$, $b$) >> + ] ]; *) +baz: + [ [ "baz" -> <:expr< baz >> ] ]; +END; diff --git a/camlp4/test/fixtures/gram-tree.ml b/camlp4/test/fixtures/gram-tree.ml new file mode 100644 index 00000000..ec1dd05d --- /dev/null +++ b/camlp4/test/fixtures/gram-tree.ml @@ -0,0 +1,22 @@ +open Camlp4.PreCast; +module G = MakeGram Lexer; +type t = [ A of t and t | B of string ]; +value main = G.Entry.mk "main"; +(* value rec length x acc = + match x with + [ A x y -> length x (length y acc) + | B _ -> succ acc ]; *) +value length _ _ = -1; +EXTEND G + GLOBAL: main; + main: + [ [ x = SELF; y = SELF -> A x y + | i = ident -> B i ] ]; + ident: + [ [ `LIDENT s -> s ] ]; +END; +try + let f = Sys.argv.(1) in + Format.printf "%d@." + (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0) +with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e; diff --git a/camlp4/test/fixtures/gram-tree2.ml b/camlp4/test/fixtures/gram-tree2.ml new file mode 100644 index 00000000..68f8b0ac --- /dev/null +++ b/camlp4/test/fixtures/gram-tree2.ml @@ -0,0 +1,22 @@ +open Camlp4.PreCast; +module G = MakeGram Lexer; +type t = [ A of t and t | B of string ]; +value main = G.Entry.mk "main"; +(* value rec length x acc = + match x with + [ A x y -> length x (length y acc) + | B _ -> succ acc ]; *) +value length _ _ = -1; +EXTEND G + GLOBAL: main; + main: + [ [ i = ident; x = SELF -> A (B i) x + | i = ident -> B i ] ]; + ident: + [ [ `LIDENT s -> s ] ]; +END; +try + let f = Sys.argv.(1) in + Format.printf "%d@." + (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0) +with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e; diff --git a/camlp4/test/fixtures/gram-tree3.ml b/camlp4/test/fixtures/gram-tree3.ml new file mode 100644 index 00000000..06af8dd2 --- /dev/null +++ b/camlp4/test/fixtures/gram-tree3.ml @@ -0,0 +1,23 @@ +open Camlp4.PreCast; +module G = MakeGram Lexer; +type t = [ A of t and t | B of string ]; +value main = G.Entry.mk "main"; +(* value rec length x acc = + match x with + [ A x y -> length x (length y acc) + | B _ -> succ acc ]; *) +value length _ _ = -1; +EXTEND G + GLOBAL: main; + main: + [ RIGHTA + [ x = SELF; y = SELF -> A x y + | i = ident -> B i ] ]; + ident: + [ [ `LIDENT s -> s ] ]; +END; +try + let f = Sys.argv.(1) in + Format.printf "%d@." + (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0) +with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e; diff --git a/camlp4/test/fixtures/gram.ml b/camlp4/test/fixtures/gram.ml new file mode 100644 index 00000000..6a5f7e34 --- /dev/null +++ b/camlp4/test/fixtures/gram.ml @@ -0,0 +1,2 @@ +EXTEND G expr: [[ l = LIST0 STRING -> l ]]; END; +EXTEND G expr: [[ l = LIST0 [ x = STRING -> x ] -> l ]]; END; diff --git a/camlp4/test/fixtures/idents b/camlp4/test/fixtures/idents new file mode 100644 index 00000000..de414688 --- /dev/null +++ b/camlp4/test/fixtures/idents @@ -0,0 +1,38 @@ +aaa aab aac aad aae aaf aag aah aai aaj aak aal aam aan aao aap aaq aar aas +aat aau aav aaw aax aay aaz aba abb abc abd abe abf abg abh abi abj abk abl +abm abn abo abp abq abr abs abt abu abv abw abx aby abz aca acb acc acd ace +acf acg ach aci acj ack acl acm acn aco acp acq acr acs act acu acv acw acx +acy acz ada adb adc add ade adf adg adh adi adj adk adl adm adn ado adp adq +adr ads adt adu adv adw adx ady adz aea aeb aec aed aee aef aeg aeh aei aej +aek ael aem aen aeo aep aeq aer aes aet aeu aev aew aex aey aez afa afb afc +afd afe aff afg afh afi afj afk afl afm afn afo afp afq afr afs aft afu afv +afw afx afy afz aga agb agc agd age agf agg agh agi agj agk agl agm agn ago +agp agq agr ags agt agu agv agw agx agy agz aha ahb ahc ahd ahe ahf ahg ahh +ahi ahj ahk ahl ahm ahn aho ahp ahq ahr ahs aht ahu ahv ahw ahx ahy ahz aia +aib aic aid aie aif aig aih aii aij aik ail aim ain aio aip aiq air ais ait +aiu aiv aiw aix aiy aiz aja ajb ajc ajd aje ajf ajg ajh aji ajj ajk ajl ajm +ajn ajo ajp ajq ajr ajs ajt aju ajv ajw ajx ajy ajz aka akb akc akd ake akf +akg akh aki akj akk akl akm akn ako akp akq akr aks akt aku akv akw akx aky +akz ala alb alc ald ale alf alg alh ali alj alk all alm aln alo alp alq alr +als alt alu alv alw alx aly alz ama amb amc amd ame amf amg amh ami amj amk +aml amm amn amo amp amq amr ams amt amu amv amw amx amy amz ana anb anc and +ane anf ang anh ani anj ank anl anm ann ano anp anq anr ans ant anu anv anw +anx any anz aoa aob aoc aod aoe aof aog aoh aoi aoj aok aol aom aon aoo aop +aoq aor aos aot aou aov aow aox aoy aoz apa apb apc apd ape apf apg aph api +apj apk apl apm apn apo app apq apr aps apt apu apv apw apx apy apz aqa aqb +aqc aqd aqe aqf aqg aqh aqi aqj aqk aql aqm aqn aqo aqp aqq aqr aqs aqt aqu +aqv aqw aqx aqy aqz ara arb arc ard are arf arg arh ari arj ark arl arm arn +aro arp arq arr ars art aru arv arw arx ary arz asa asb asc asd ase asf asg +ash asi asj ask asl asm asn aso asp asq asr ass ast asu asv asw asx asy asz +ata atb atc atd ate atf atg ath ati atj atk atl atm atn ato atp atq atr ats +att atu atv atw atx aty atz aua aub auc aud aue auf aug auh aui auj auk aul +aum aun auo aup auq aur aus aut auu auv auw aux auy auz ava avb avc avd ave +avf avg avh avi avj avk avl avm avn avo avp avq avr avs avt avu avv avw avx +avy avz awa awb awc awd awe awf awg awh awi awj awk awl awm awn awo awp awq +awr aws awt awu awv aww awx awy awz axa axb axc axd axe axf axg axh axi axj +axk axl axm axn axo axp axq axr axs axt axu axv axw axx axy axz aya ayb ayc +ayd aye ayf ayg ayh ayi ayj ayk ayl aym ayn ayo ayp ayq ayr ays ayt ayu ayv +ayw ayx ayy ayz aza azb azc azd aze azf azg azh azi azj azk azl azm azn azo +azp azq azr azs azt azu azv azw azx azy azz baa bab bac bad bae baf bag bah +bai baj bak bal bam ban bao bap baq bar bas bat bau bav baw bax bay baz bba +bbb diff --git a/camlp4/test/fixtures/idents1 b/camlp4/test/fixtures/idents1 new file mode 100644 index 00000000..5da54402 --- /dev/null +++ b/camlp4/test/fixtures/idents1 @@ -0,0 +1,499 @@ +aaaa aaab aaac aaad aaae aaaf aaag aaah aaai aaaj aaak aaal aaam aaan aaao +aaap aaaq aaar aaas aaat aaau aaav aaaw aaax aaay aaaz aaba aabb aabc aabd +aabe aabf aabg aabh aabi aabj aabk aabl aabm aabn aabo aabp aabq aabr aabs +aabt aabu aabv aabw aabx aaby aabz aaca aacb aacc aacd aace aacf aacg aach +aaci aacj aack aacl aacm aacn aaco aacp aacq aacr aacs aact aacu aacv aacw +aacx aacy aacz aada aadb aadc aadd aade aadf aadg aadh aadi aadj aadk aadl +aadm aadn aado aadp aadq aadr aads aadt aadu aadv aadw aadx aady aadz aaea +aaeb aaec aaed aaee aaef aaeg aaeh aaei aaej aaek aael aaem aaen aaeo aaep +aaeq aaer aaes aaet aaeu aaev aaew aaex aaey aaez aafa aafb aafc aafd aafe +aaff aafg aafh aafi aafj aafk aafl aafm aafn aafo aafp aafq aafr aafs aaft +aafu aafv aafw aafx aafy aafz aaga aagb aagc aagd aage aagf aagg aagh aagi +aagj aagk aagl aagm aagn aago aagp aagq aagr aags aagt aagu aagv aagw aagx +aagy aagz aaha aahb aahc aahd aahe aahf aahg aahh aahi aahj aahk aahl aahm +aahn aaho aahp aahq aahr aahs aaht aahu aahv aahw aahx aahy aahz aaia aaib +aaic aaid aaie aaif aaig aaih aaii aaij aaik aail aaim aain aaio aaip aaiq +aair aais aait aaiu aaiv aaiw aaix aaiy aaiz aaja aajb aajc aajd aaje aajf +aajg aajh aaji aajj aajk aajl aajm aajn aajo aajp aajq aajr aajs aajt aaju +aajv aajw aajx aajy aajz aaka aakb aakc aakd aake aakf aakg aakh aaki aakj +aakk aakl aakm aakn aako aakp aakq aakr aaks aakt aaku aakv aakw aakx aaky +aakz aala aalb aalc aald aale aalf aalg aalh aali aalj aalk aall aalm aaln +aalo aalp aalq aalr aals aalt aalu aalv aalw aalx aaly aalz aama aamb aamc +aamd aame aamf aamg aamh aami aamj aamk aaml aamm aamn aamo aamp aamq aamr +aams aamt aamu aamv aamw aamx aamy aamz aana aanb aanc aand aane aanf aang +aanh aani aanj aank aanl aanm aann aano aanp aanq aanr aans aant aanu aanv +aanw aanx aany aanz aaoa aaob aaoc aaod aaoe aaof aaog aaoh aaoi aaoj aaok +aaol aaom aaon aaoo aaop aaoq aaor aaos aaot aaou aaov aaow aaox aaoy aaoz +aapa aapb aapc aapd aape aapf aapg aaph aapi aapj aapk aapl aapm aapn aapo +aapp aapq aapr aaps aapt aapu aapv aapw aapx aapy aapz aaqa aaqb aaqc aaqd +aaqe aaqf aaqg aaqh aaqi aaqj aaqk aaql aaqm aaqn aaqo aaqp aaqq aaqr aaqs +aaqt aaqu aaqv aaqw aaqx aaqy aaqz aara aarb aarc aard aare aarf aarg aarh +aari aarj aark aarl aarm aarn aaro aarp aarq aarr aars aart aaru aarv aarw +aarx aary aarz aasa aasb aasc aasd aase aasf aasg aash aasi aasj aask aasl +aasm aasn aaso aasp aasq aasr aass aast aasu aasv aasw aasx aasy aasz aata +aatb aatc aatd aate aatf aatg aath aati aatj aatk aatl aatm aatn aato aatp +aatq aatr aats aatt aatu aatv aatw aatx aaty aatz aaua aaub aauc aaud aaue +aauf aaug aauh aaui aauj aauk aaul aaum aaun aauo aaup aauq aaur aaus aaut +aauu aauv aauw aaux aauy aauz aava aavb aavc aavd aave aavf aavg aavh aavi +aavj aavk aavl aavm aavn aavo aavp aavq aavr aavs aavt aavu aavv aavw aavx +aavy aavz aawa aawb aawc aawd aawe aawf aawg aawh aawi aawj aawk aawl aawm +aawn aawo aawp aawq aawr aaws aawt aawu aawv aaww aawx aawy aawz aaxa aaxb +aaxc aaxd aaxe aaxf aaxg aaxh aaxi aaxj aaxk aaxl aaxm aaxn aaxo aaxp aaxq +aaxr aaxs aaxt aaxu aaxv aaxw aaxx aaxy aaxz aaya aayb aayc aayd aaye aayf +aayg aayh aayi aayj aayk aayl aaym aayn aayo aayp aayq aayr aays aayt aayu +aayv aayw aayx aayy aayz aaza aazb aazc aazd aaze aazf aazg aazh aazi aazj +aazk aazl aazm aazn aazo aazp aazq aazr aazs aazt aazu aazv aazw aazx aazy +aazz abaa abab abac abad abae abaf abag abah abai abaj abak abal abam aban +abao abap abaq abar abas abat abau abav abaw abax abay abaz abba abbb abbc +abbd abbe abbf abbg abbh abbi abbj abbk abbl abbm abbn abbo abbp abbq abbr +abbs abbt abbu abbv abbw abbx abby abbz abca abcb abcc abcd abce abcf abcg +abch abci abcj abck abcl abcm abcn abco abcp abcq abcr abcs abct abcu abcv +abcw abcx abcy abcz abda abdb abdc abdd abde abdf abdg abdh abdi abdj abdk +abdl abdm abdn abdo abdp abdq abdr abds abdt abdu abdv abdw abdx abdy abdz +abea abeb abec abed abee abef abeg abeh abei abej abek abel abem aben abeo +abep abeq aber abes abet abeu abev abew abex abey abez abfa abfb abfc abfd +abfe abff abfg abfh abfi abfj abfk abfl abfm abfn abfo abfp abfq abfr abfs +abft abfu abfv abfw abfx abfy abfz abga abgb abgc abgd abge abgf abgg abgh +abgi abgj abgk abgl abgm abgn abgo abgp abgq abgr abgs abgt abgu abgv abgw +abgx abgy abgz abha abhb abhc abhd abhe abhf abhg abhh abhi abhj abhk abhl +abhm abhn abho abhp abhq abhr abhs abht abhu abhv abhw abhx abhy abhz abia +abib abic abid abie abif abig abih abii abij abik abil abim abin abio abip +abiq abir abis abit abiu abiv abiw abix abiy abiz abja abjb abjc abjd abje +abjf abjg abjh abji abjj abjk abjl abjm abjn abjo abjp abjq abjr abjs abjt +abju abjv abjw abjx abjy abjz abka abkb abkc abkd abke abkf abkg abkh abki +abkj abkk abkl abkm abkn abko abkp abkq abkr abks abkt abku abkv abkw abkx +abky abkz abla ablb ablc abld able ablf ablg ablh abli ablj ablk abll ablm +abln ablo ablp ablq ablr abls ablt ablu ablv ablw ablx ably ablz abma abmb +abmc abmd abme abmf abmg abmh abmi abmj abmk abml abmm abmn abmo abmp abmq +abmr abms abmt abmu abmv abmw abmx abmy abmz abna abnb abnc abnd abne abnf +abng abnh abni abnj abnk abnl abnm abnn abno abnp abnq abnr abns abnt abnu +abnv abnw abnx abny abnz aboa abob aboc abod aboe abof abog aboh aboi aboj +abok abol abom abon aboo abop aboq abor abos abot abou abov abow abox aboy +aboz abpa abpb abpc abpd abpe abpf abpg abph abpi abpj abpk abpl abpm abpn +abpo abpp abpq abpr abps abpt abpu abpv abpw abpx abpy abpz abqa abqb abqc +abqd abqe abqf abqg abqh abqi abqj abqk abql abqm abqn abqo abqp abqq abqr +abqs abqt abqu abqv abqw abqx abqy abqz abra abrb abrc abrd abre abrf abrg +abrh abri abrj abrk abrl abrm abrn abro abrp abrq abrr abrs abrt abru abrv +abrw abrx abry abrz absa absb absc absd abse absf absg absh absi absj absk +absl absm absn abso absp absq absr abss abst absu absv absw absx absy absz +abta abtb abtc abtd abte abtf abtg abth abti abtj abtk abtl abtm abtn abto +abtp abtq abtr abts abtt abtu abtv abtw abtx abty abtz abua abub abuc abud +abue abuf abug abuh abui abuj abuk abul abum abun abuo abup abuq abur abus +abut abuu abuv abuw abux abuy abuz abva abvb abvc abvd abve abvf abvg abvh +abvi abvj abvk abvl abvm abvn abvo abvp abvq abvr abvs abvt abvu abvv abvw +abvx abvy abvz abwa abwb abwc abwd abwe abwf abwg abwh abwi abwj abwk abwl +abwm abwn abwo abwp abwq abwr abws abwt abwu abwv abww abwx abwy abwz abxa +abxb abxc abxd abxe abxf abxg abxh abxi abxj abxk abxl abxm abxn abxo abxp +abxq abxr abxs abxt abxu abxv abxw abxx abxy abxz abya abyb abyc abyd abye +abyf abyg abyh abyi abyj abyk abyl abym abyn abyo abyp abyq abyr abys abyt +abyu abyv abyw abyx abyy abyz abza abzb abzc abzd abze abzf abzg abzh abzi +abzj abzk abzl abzm abzn abzo abzp abzq abzr abzs abzt abzu abzv abzw abzx +abzy abzz acaa acab acac acad acae acaf acag acah acai acaj acak acal acam +acan acao acap acaq acar acas acat acau acav acaw acax acay acaz acba acbb +acbc acbd acbe acbf acbg acbh acbi acbj acbk acbl acbm acbn acbo acbp acbq +acbr acbs acbt acbu acbv acbw acbx acby acbz acca accb accc accd acce accf +accg acch acci accj acck accl accm accn acco accp accq accr accs acct accu +accv accw accx accy accz acda acdb acdc acdd acde acdf acdg acdh acdi acdj +acdk acdl acdm acdn acdo acdp acdq acdr acds acdt acdu acdv acdw acdx acdy +acdz acea aceb acec aced acee acef aceg aceh acei acej acek acel acem acen +aceo acep aceq acer aces acet aceu acev acew acex acey acez acfa acfb acfc +acfd acfe acff acfg acfh acfi acfj acfk acfl acfm acfn acfo acfp acfq acfr +acfs acft acfu acfv acfw acfx acfy acfz acga acgb acgc acgd acge acgf acgg +acgh acgi acgj acgk acgl acgm acgn acgo acgp acgq acgr acgs acgt acgu acgv +acgw acgx acgy acgz acha achb achc achd ache achf achg achh achi achj achk +achl achm achn acho achp achq achr achs acht achu achv achw achx achy achz +acia acib acic acid acie acif acig acih acii acij acik acil acim acin acio +acip aciq acir acis acit aciu aciv aciw acix aciy aciz acja acjb acjc acjd +acje acjf acjg acjh acji acjj acjk acjl acjm acjn acjo acjp acjq acjr acjs +acjt acju acjv acjw acjx acjy acjz acka ackb ackc ackd acke ackf ackg ackh +acki ackj ackk ackl ackm ackn acko ackp ackq ackr acks ackt acku ackv ackw +ackx acky ackz acla aclb aclc acld acle aclf aclg aclh acli aclj aclk acll +aclm acln aclo aclp aclq aclr acls aclt aclu aclv aclw aclx acly aclz acma +acmb acmc acmd acme acmf acmg acmh acmi acmj acmk acml acmm acmn acmo acmp +acmq acmr acms acmt acmu acmv acmw acmx acmy acmz acna acnb acnc acnd acne +acnf acng acnh acni acnj acnk acnl acnm acnn acno acnp acnq acnr acns acnt +acnu acnv acnw acnx acny acnz acoa acob acoc acod acoe acof acog acoh acoi +acoj acok acol acom acon acoo acop acoq acor acos acot acou acov acow acox +acoy acoz acpa acpb acpc acpd acpe acpf acpg acph acpi acpj acpk acpl acpm +acpn acpo acpp acpq acpr acps acpt acpu acpv acpw acpx acpy acpz acqa acqb +acqc acqd acqe acqf acqg acqh acqi acqj acqk acql acqm acqn acqo acqp acqq +acqr acqs acqt acqu acqv acqw acqx acqy acqz acra acrb acrc acrd acre acrf +acrg acrh acri acrj acrk acrl acrm acrn acro acrp acrq acrr acrs acrt acru +acrv acrw acrx acry acrz acsa acsb acsc acsd acse acsf acsg acsh acsi acsj +acsk acsl acsm acsn acso acsp acsq acsr acss acst acsu acsv acsw acsx acsy +acsz acta actb actc actd acte actf actg acth acti actj actk actl actm actn +acto actp actq actr acts actt actu actv actw actx acty actz acua acub acuc +acud acue acuf acug acuh acui acuj acuk acul acum acun acuo acup acuq acur +acus acut acuu acuv acuw acux acuy acuz acva acvb acvc acvd acve acvf acvg +acvh acvi acvj acvk acvl acvm acvn acvo acvp acvq acvr acvs acvt acvu acvv +acvw acvx acvy acvz acwa acwb acwc acwd acwe acwf acwg acwh acwi acwj acwk +acwl acwm acwn acwo acwp acwq acwr acws acwt acwu acwv acww acwx acwy acwz +acxa acxb acxc acxd acxe acxf acxg acxh acxi acxj acxk acxl acxm acxn acxo +acxp acxq acxr acxs acxt acxu acxv acxw acxx acxy acxz acya acyb acyc acyd +acye acyf acyg acyh acyi acyj acyk acyl acym acyn acyo acyp acyq acyr acys +acyt acyu acyv acyw acyx acyy acyz acza aczb aczc aczd acze aczf aczg aczh +aczi aczj aczk aczl aczm aczn aczo aczp aczq aczr aczs aczt aczu aczv aczw +aczx aczy aczz adaa adab adac adad adae adaf adag adah adai adaj adak adal +adam adan adao adap adaq adar adas adat adau adav adaw adax aday adaz adba +adbb adbc adbd adbe adbf adbg adbh adbi adbj adbk adbl adbm adbn adbo adbp +adbq adbr adbs adbt adbu adbv adbw adbx adby adbz adca adcb adcc adcd adce +adcf adcg adch adci adcj adck adcl adcm adcn adco adcp adcq adcr adcs adct +adcu adcv adcw adcx adcy adcz adda addb addc addd adde addf addg addh addi +addj addk addl addm addn addo addp addq addr adds addt addu addv addw addx +addy addz adea adeb adec aded adee adef adeg adeh adei adej adek adel adem +aden adeo adep adeq ader ades adet adeu adev adew adex adey adez adfa adfb +adfc adfd adfe adff adfg adfh adfi adfj adfk adfl adfm adfn adfo adfp adfq +adfr adfs adft adfu adfv adfw adfx adfy adfz adga adgb adgc adgd adge adgf +adgg adgh adgi adgj adgk adgl adgm adgn adgo adgp adgq adgr adgs adgt adgu +adgv adgw adgx adgy adgz adha adhb adhc adhd adhe adhf adhg adhh adhi adhj +adhk adhl adhm adhn adho adhp adhq adhr adhs adht adhu adhv adhw adhx adhy +adhz adia adib adic adid adie adif adig adih adii adij adik adil adim adin +adio adip adiq adir adis adit adiu adiv adiw adix adiy adiz adja adjb adjc +adjd adje adjf adjg adjh adji adjj adjk adjl adjm adjn adjo adjp adjq adjr +adjs adjt adju adjv adjw adjx adjy adjz adka adkb adkc adkd adke adkf adkg +adkh adki adkj adkk adkl adkm adkn adko adkp adkq adkr adks adkt adku adkv +adkw adkx adky adkz adla adlb adlc adld adle adlf adlg adlh adli adlj adlk +adll adlm adln adlo adlp adlq adlr adls adlt adlu adlv adlw adlx adly adlz +adma admb admc admd adme admf admg admh admi admj admk adml admm admn admo +admp admq admr adms admt admu admv admw admx admy admz adna adnb adnc adnd +adne adnf adng adnh adni adnj adnk adnl adnm adnn adno adnp adnq adnr adns +adnt adnu adnv adnw adnx adny adnz adoa adob adoc adod adoe adof adog adoh +adoi adoj adok adol adom adon adoo adop adoq ador ados adot adou adov adow +adox adoy adoz adpa adpb adpc adpd adpe adpf adpg adph adpi adpj adpk adpl +adpm adpn adpo adpp adpq adpr adps adpt adpu adpv adpw adpx adpy adpz adqa +adqb adqc adqd adqe adqf adqg adqh adqi adqj adqk adql adqm adqn adqo adqp +adqq adqr adqs adqt adqu adqv adqw adqx adqy adqz adra adrb adrc adrd adre +adrf adrg adrh adri adrj adrk adrl adrm adrn adro adrp adrq adrr adrs adrt +adru adrv adrw adrx adry adrz adsa adsb adsc adsd adse adsf adsg adsh adsi +adsj adsk adsl adsm adsn adso adsp adsq adsr adss adst adsu adsv adsw adsx +adsy adsz adta adtb adtc adtd adte adtf adtg adth adti adtj adtk adtl adtm +adtn adto adtp adtq adtr adts adtt adtu adtv adtw adtx adty adtz adua adub +aduc adud adue aduf adug aduh adui aduj aduk adul adum adun aduo adup aduq +adur adus adut aduu aduv aduw adux aduy aduz adva advb advc advd adve advf +advg advh advi advj advk advl advm advn advo advp advq advr advs advt advu +advv advw advx advy advz adwa adwb adwc adwd adwe adwf adwg adwh adwi adwj +adwk adwl adwm adwn adwo adwp adwq adwr adws adwt adwu adwv adww adwx adwy +adwz adxa adxb adxc adxd adxe adxf adxg adxh adxi adxj adxk adxl adxm adxn +adxo adxp adxq adxr adxs adxt adxu adxv adxw adxx adxy adxz adya adyb adyc +adyd adye adyf adyg adyh adyi adyj adyk adyl adym adyn adyo adyp adyq adyr +adys adyt adyu adyv adyw adyx adyy adyz adza adzb adzc adzd adze adzf adzg +adzh adzi adzj adzk adzl adzm adzn adzo adzp adzq adzr adzs adzt adzu adzv +adzw adzx adzy adzz aeaa aeab aeac aead aeae aeaf aeag aeah aeai aeaj aeak +aeal aeam aean aeao aeap aeaq aear aeas aeat aeau aeav aeaw aeax aeay aeaz +aeba aebb aebc aebd aebe aebf aebg aebh aebi aebj aebk aebl aebm aebn aebo +aebp aebq aebr aebs aebt aebu aebv aebw aebx aeby aebz aeca aecb aecc aecd +aece aecf aecg aech aeci aecj aeck aecl aecm aecn aeco aecp aecq aecr aecs +aect aecu aecv aecw aecx aecy aecz aeda aedb aedc aedd aede aedf aedg aedh +aedi aedj aedk aedl aedm aedn aedo aedp aedq aedr aeds aedt aedu aedv aedw +aedx aedy aedz aeea aeeb aeec aeed aeee aeef aeeg aeeh aeei aeej aeek aeel +aeem aeen aeeo aeep aeeq aeer aees aeet aeeu aeev aeew aeex aeey aeez aefa +aefb aefc aefd aefe aeff aefg aefh aefi aefj aefk aefl aefm aefn aefo aefp +aefq aefr aefs aeft aefu aefv aefw aefx aefy aefz aega aegb aegc aegd aege +aegf aegg aegh aegi aegj aegk aegl aegm aegn aego aegp aegq aegr aegs aegt +aegu aegv aegw aegx aegy aegz aeha aehb aehc aehd aehe aehf aehg aehh aehi +aehj aehk aehl aehm aehn aeho aehp aehq aehr aehs aeht aehu aehv aehw aehx +aehy aehz aeia aeib aeic aeid aeie aeif aeig aeih aeii aeij aeik aeil aeim +aein aeio aeip aeiq aeir aeis aeit aeiu aeiv aeiw aeix aeiy aeiz aeja aejb +aejc aejd aeje aejf aejg aejh aeji aejj aejk aejl aejm aejn aejo aejp aejq +aejr aejs aejt aeju aejv aejw aejx aejy aejz aeka aekb aekc aekd aeke aekf +aekg aekh aeki aekj aekk aekl aekm aekn aeko aekp aekq aekr aeks aekt aeku +aekv aekw aekx aeky aekz aela aelb aelc aeld aele aelf aelg aelh aeli aelj +aelk aell aelm aeln aelo aelp aelq aelr aels aelt aelu aelv aelw aelx aely +aelz aema aemb aemc aemd aeme aemf aemg aemh aemi aemj aemk aeml aemm aemn +aemo aemp aemq aemr aems aemt aemu aemv aemw aemx aemy aemz aena aenb aenc +aend aene aenf aeng aenh aeni aenj aenk aenl aenm aenn aeno aenp aenq aenr +aens aent aenu aenv aenw aenx aeny aenz aeoa aeob aeoc aeod aeoe aeof aeog +aeoh aeoi aeoj aeok aeol aeom aeon aeoo aeop aeoq aeor aeos aeot aeou aeov +aeow aeox aeoy aeoz aepa aepb aepc aepd aepe aepf aepg aeph aepi aepj aepk +aepl aepm aepn aepo aepp aepq aepr aeps aept aepu aepv aepw aepx aepy aepz +aeqa aeqb aeqc aeqd aeqe aeqf aeqg aeqh aeqi aeqj aeqk aeql aeqm aeqn aeqo +aeqp aeqq aeqr aeqs aeqt aequ aeqv aeqw aeqx aeqy aeqz aera aerb aerc aerd +aere aerf aerg aerh aeri aerj aerk aerl aerm aern aero aerp aerq aerr aers +aert aeru aerv aerw aerx aery aerz aesa aesb aesc aesd aese aesf aesg aesh +aesi aesj aesk aesl aesm aesn aeso aesp aesq aesr aess aest aesu aesv aesw +aesx aesy aesz aeta aetb aetc aetd aete aetf aetg aeth aeti aetj aetk aetl +aetm aetn aeto aetp aetq aetr aets aett aetu aetv aetw aetx aety aetz aeua +aeub aeuc aeud aeue aeuf aeug aeuh aeui aeuj aeuk aeul aeum aeun aeuo aeup +aeuq aeur aeus aeut aeuu aeuv aeuw aeux aeuy aeuz aeva aevb aevc aevd aeve +aevf aevg aevh aevi aevj aevk aevl aevm aevn aevo aevp aevq aevr aevs aevt +aevu aevv aevw aevx aevy aevz aewa aewb aewc aewd aewe aewf aewg aewh aewi +aewj aewk aewl aewm aewn aewo aewp aewq aewr aews aewt aewu aewv aeww aewx +aewy aewz aexa aexb aexc aexd aexe aexf aexg aexh aexi aexj aexk aexl aexm +aexn aexo aexp aexq aexr aexs aext aexu aexv aexw aexx aexy aexz aeya aeyb +aeyc aeyd aeye aeyf aeyg aeyh aeyi aeyj aeyk aeyl aeym aeyn aeyo aeyp aeyq +aeyr aeys aeyt aeyu aeyv aeyw aeyx aeyy aeyz aeza aezb aezc aezd aeze aezf +aezg aezh aezi aezj aezk aezl aezm aezn aezo aezp aezq aezr aezs aezt aezu +aezv aezw aezx aezy aezz afaa afab afac afad afae afaf afag afah afai afaj +afak afal afam afan afao afap afaq afar afas afat afau afav afaw afax afay +afaz afba afbb afbc afbd afbe afbf afbg afbh afbi afbj afbk afbl afbm afbn +afbo afbp afbq afbr afbs afbt afbu afbv afbw afbx afby afbz afca afcb afcc +afcd afce afcf afcg afch afci afcj afck afcl afcm afcn afco afcp afcq afcr +afcs afct afcu afcv afcw afcx afcy afcz afda afdb afdc afdd afde afdf afdg +afdh afdi afdj afdk afdl afdm afdn afdo afdp afdq afdr afds afdt afdu afdv +afdw afdx afdy afdz afea afeb afec afed afee afef afeg afeh afei afej afek +afel afem afen afeo afep afeq afer afes afet afeu afev afew afex afey afez +affa affb affc affd affe afff affg affh affi affj affk affl affm affn affo +affp affq affr affs afft affu affv affw affx affy affz afga afgb afgc afgd +afge afgf afgg afgh afgi afgj afgk afgl afgm afgn afgo afgp afgq afgr afgs +afgt afgu afgv afgw afgx afgy afgz afha afhb afhc afhd afhe afhf afhg afhh +afhi afhj afhk afhl afhm afhn afho afhp afhq afhr afhs afht afhu afhv afhw +afhx afhy afhz afia afib afic afid afie afif afig afih afii afij afik afil +afim afin afio afip afiq afir afis afit afiu afiv afiw afix afiy afiz afja +afjb afjc afjd afje afjf afjg afjh afji afjj afjk afjl afjm afjn afjo afjp +afjq afjr afjs afjt afju afjv afjw afjx afjy afjz afka afkb afkc afkd afke +afkf afkg afkh afki afkj afkk afkl afkm afkn afko afkp afkq afkr afks afkt +afku afkv afkw afkx afky afkz afla aflb aflc afld afle aflf aflg aflh afli +aflj aflk afll aflm afln aflo aflp aflq aflr afls aflt aflu aflv aflw aflx +afly aflz afma afmb afmc afmd afme afmf afmg afmh afmi afmj afmk afml afmm +afmn afmo afmp afmq afmr afms afmt afmu afmv afmw afmx afmy afmz afna afnb +afnc afnd afne afnf afng afnh afni afnj afnk afnl afnm afnn afno afnp afnq +afnr afns afnt afnu afnv afnw afnx afny afnz afoa afob afoc afod afoe afof +afog afoh afoi afoj afok afol afom afon afoo afop afoq afor afos afot afou +afov afow afox afoy afoz afpa afpb afpc afpd afpe afpf afpg afph afpi afpj +afpk afpl afpm afpn afpo afpp afpq afpr afps afpt afpu afpv afpw afpx afpy +afpz afqa afqb afqc afqd afqe afqf afqg afqh afqi afqj afqk afql afqm afqn +afqo afqp afqq afqr afqs afqt afqu afqv afqw afqx afqy afqz afra afrb afrc +afrd afre afrf afrg afrh afri afrj afrk afrl afrm afrn afro afrp afrq afrr +afrs afrt afru afrv afrw afrx afry afrz afsa afsb afsc afsd afse afsf afsg +afsh afsi afsj afsk afsl afsm afsn afso afsp afsq afsr afss afst afsu afsv +afsw afsx afsy afsz afta aftb aftc aftd afte aftf aftg afth afti aftj aftk +aftl aftm aftn afto aftp aftq aftr afts aftt aftu aftv aftw aftx afty aftz +afua afub afuc afud afue afuf afug afuh afui afuj afuk aful afum afun afuo +afup afuq afur afus afut afuu afuv afuw afux afuy afuz afva afvb afvc afvd +afve afvf afvg afvh afvi afvj afvk afvl afvm afvn afvo afvp afvq afvr afvs +afvt afvu afvv afvw afvx afvy afvz afwa afwb afwc afwd afwe afwf afwg afwh +afwi afwj afwk afwl afwm afwn afwo afwp afwq afwr afws afwt afwu afwv afww +afwx afwy afwz afxa afxb afxc afxd afxe afxf afxg afxh afxi afxj afxk afxl +afxm afxn afxo afxp afxq afxr afxs afxt afxu afxv afxw afxx afxy afxz afya +afyb afyc afyd afye afyf afyg afyh afyi afyj afyk afyl afym afyn afyo afyp +afyq afyr afys afyt afyu afyv afyw afyx afyy afyz afza afzb afzc afzd afze +afzf afzg afzh afzi afzj afzk afzl afzm afzn afzo afzp afzq afzr afzs afzt +afzu afzv afzw afzx afzy afzz agaa agab agac agad agae agaf agag agah agai +agaj agak agal agam agan agao agap agaq agar agas agat agau agav agaw agax +agay agaz agba agbb agbc agbd agbe agbf agbg agbh agbi agbj agbk agbl agbm +agbn agbo agbp agbq agbr agbs agbt agbu agbv agbw agbx agby agbz agca agcb +agcc agcd agce agcf agcg agch agci agcj agck agcl agcm agcn agco agcp agcq +agcr agcs agct agcu agcv agcw agcx agcy agcz agda agdb agdc agdd agde agdf +agdg agdh agdi agdj agdk agdl agdm agdn agdo agdp agdq agdr agds agdt agdu +agdv agdw agdx agdy agdz agea ageb agec aged agee agef ageg ageh agei agej +agek agel agem agen ageo agep ageq ager ages aget ageu agev agew agex agey +agez agfa agfb agfc agfd agfe agff agfg agfh agfi agfj agfk agfl agfm agfn +agfo agfp agfq agfr agfs agft agfu agfv agfw agfx agfy agfz agga aggb aggc +aggd agge aggf aggg aggh aggi aggj aggk aggl aggm aggn aggo aggp aggq aggr +aggs aggt aggu aggv aggw aggx aggy aggz agha aghb aghc aghd aghe aghf aghg +aghh aghi aghj aghk aghl aghm aghn agho aghp aghq aghr aghs aght aghu aghv +aghw aghx aghy aghz agia agib agic agid agie agif agig agih agii agij agik +agil agim agin agio agip agiq agir agis agit agiu agiv agiw agix agiy agiz +agja agjb agjc agjd agje agjf agjg agjh agji agjj agjk agjl agjm agjn agjo +agjp agjq agjr agjs agjt agju agjv agjw agjx agjy agjz agka agkb agkc agkd +agke agkf agkg agkh agki agkj agkk agkl agkm agkn agko agkp agkq agkr agks +agkt agku agkv agkw agkx agky agkz agla aglb aglc agld agle aglf aglg aglh +agli aglj aglk agll aglm agln aglo aglp aglq aglr agls aglt aglu aglv aglw +aglx agly aglz agma agmb agmc agmd agme agmf agmg agmh agmi agmj agmk agml +agmm agmn agmo agmp agmq agmr agms agmt agmu agmv agmw agmx agmy agmz agna +agnb agnc agnd agne agnf agng agnh agni agnj agnk agnl agnm agnn agno agnp +agnq agnr agns agnt agnu agnv agnw agnx agny agnz agoa agob agoc agod agoe +agof agog agoh agoi agoj agok agol agom agon agoo agop agoq agor agos agot +agou agov agow agox agoy agoz agpa agpb agpc agpd agpe agpf agpg agph agpi +agpj agpk agpl agpm agpn agpo agpp agpq agpr agps agpt agpu agpv agpw agpx +agpy agpz agqa agqb agqc agqd agqe agqf agqg agqh agqi agqj agqk agql agqm +agqn agqo agqp agqq agqr agqs agqt agqu agqv agqw agqx agqy agqz agra agrb +agrc agrd agre agrf agrg agrh agri agrj agrk agrl agrm agrn agro agrp agrq +agrr agrs agrt agru agrv agrw agrx agry agrz agsa agsb agsc agsd agse agsf +agsg agsh agsi agsj agsk agsl agsm agsn agso agsp agsq agsr agss agst agsu +agsv agsw agsx agsy agsz agta agtb agtc agtd agte agtf agtg agth agti agtj +agtk agtl agtm agtn agto agtp agtq agtr agts agtt agtu agtv agtw agtx agty +agtz agua agub aguc agud ague aguf agug aguh agui aguj aguk agul agum agun +aguo agup aguq agur agus agut aguu aguv aguw agux aguy aguz agva agvb agvc +agvd agve agvf agvg agvh agvi agvj agvk agvl agvm agvn agvo agvp agvq agvr +agvs agvt agvu agvv agvw agvx agvy agvz agwa agwb agwc agwd agwe agwf agwg +agwh agwi agwj agwk agwl agwm agwn agwo agwp agwq agwr agws agwt agwu agwv +agww agwx agwy agwz agxa agxb agxc agxd agxe agxf agxg agxh agxi agxj agxk +agxl agxm agxn agxo agxp agxq agxr agxs agxt agxu agxv agxw agxx agxy agxz +agya agyb agyc agyd agye agyf agyg agyh agyi agyj agyk agyl agym agyn agyo +agyp agyq agyr agys agyt agyu agyv agyw agyx agyy agyz agza agzb agzc agzd +agze agzf agzg agzh agzi agzj agzk agzl agzm agzn agzo agzp agzq agzr agzs +agzt agzu agzv agzw agzx agzy agzz ahaa ahab ahac ahad ahae ahaf ahag ahah +ahai ahaj ahak ahal aham ahan ahao ahap ahaq ahar ahas ahat ahau ahav ahaw +ahax ahay ahaz ahba ahbb ahbc ahbd ahbe ahbf ahbg ahbh ahbi ahbj ahbk ahbl +ahbm ahbn ahbo ahbp ahbq ahbr ahbs ahbt ahbu ahbv ahbw ahbx ahby ahbz ahca +ahcb ahcc ahcd ahce ahcf ahcg ahch ahci ahcj ahck ahcl ahcm ahcn ahco ahcp +ahcq ahcr ahcs ahct ahcu ahcv ahcw ahcx ahcy ahcz ahda ahdb ahdc ahdd ahde +ahdf ahdg ahdh ahdi ahdj ahdk ahdl ahdm ahdn ahdo ahdp ahdq ahdr ahds ahdt +ahdu ahdv ahdw ahdx ahdy ahdz ahea aheb ahec ahed ahee ahef aheg aheh ahei +ahej ahek ahel ahem ahen aheo ahep aheq aher ahes ahet aheu ahev ahew ahex +ahey ahez ahfa ahfb ahfc ahfd ahfe ahff ahfg ahfh ahfi ahfj ahfk ahfl ahfm +ahfn ahfo ahfp ahfq ahfr ahfs ahft ahfu ahfv ahfw ahfx ahfy ahfz ahga ahgb +ahgc ahgd ahge ahgf ahgg ahgh ahgi ahgj ahgk ahgl ahgm ahgn ahgo ahgp ahgq +ahgr ahgs ahgt ahgu ahgv ahgw ahgx ahgy ahgz ahha ahhb ahhc ahhd ahhe ahhf +ahhg ahhh ahhi ahhj ahhk ahhl ahhm ahhn ahho ahhp ahhq ahhr ahhs ahht ahhu +ahhv ahhw ahhx ahhy ahhz ahia ahib ahic ahid ahie ahif ahig ahih ahii ahij +ahik ahil ahim ahin ahio ahip ahiq ahir ahis ahit ahiu ahiv ahiw ahix ahiy +ahiz ahja ahjb ahjc ahjd ahje ahjf ahjg ahjh ahji ahjj ahjk ahjl ahjm ahjn +ahjo ahjp ahjq ahjr ahjs ahjt ahju ahjv ahjw ahjx ahjy ahjz ahka ahkb ahkc +ahkd ahke ahkf ahkg ahkh ahki ahkj ahkk ahkl ahkm ahkn ahko ahkp ahkq ahkr +ahks ahkt ahku ahkv ahkw ahkx ahky ahkz ahla ahlb ahlc ahld ahle ahlf ahlg +ahlh ahli ahlj ahlk ahll ahlm ahln ahlo ahlp ahlq ahlr ahls ahlt ahlu ahlv +ahlw ahlx ahly ahlz ahma ahmb ahmc ahmd ahme ahmf ahmg ahmh ahmi ahmj ahmk +ahml ahmm ahmn ahmo ahmp ahmq ahmr ahms ahmt ahmu ahmv ahmw ahmx ahmy ahmz +ahna ahnb ahnc ahnd ahne ahnf ahng ahnh ahni ahnj ahnk ahnl ahnm ahnn ahno +ahnp ahnq ahnr ahns ahnt ahnu ahnv ahnw ahnx ahny ahnz ahoa ahob ahoc ahod +ahoe ahof ahog ahoh ahoi ahoj ahok ahol ahom ahon ahoo ahop ahoq ahor ahos +ahot ahou ahov ahow ahox ahoy ahoz ahpa ahpb ahpc ahpd ahpe ahpf ahpg ahph +ahpi ahpj ahpk ahpl ahpm ahpn ahpo ahpp ahpq ahpr ahps ahpt ahpu ahpv ahpw +ahpx ahpy ahpz ahqa ahqb ahqc ahqd ahqe ahqf ahqg ahqh ahqi ahqj ahqk ahql +ahqm ahqn ahqo ahqp ahqq ahqr ahqs ahqt ahqu ahqv ahqw ahqx ahqy ahqz ahra +ahrb ahrc ahrd ahre ahrf ahrg ahrh ahri ahrj ahrk ahrl ahrm ahrn ahro ahrp +ahrq ahrr ahrs ahrt ahru ahrv ahrw ahrx ahry ahrz ahsa ahsb ahsc ahsd ahse +ahsf ahsg ahsh ahsi ahsj ahsk ahsl ahsm ahsn ahso ahsp ahsq ahsr ahss ahst +ahsu ahsv ahsw ahsx ahsy ahsz ahta ahtb ahtc ahtd ahte ahtf ahtg ahth ahti +ahtj ahtk ahtl ahtm ahtn ahto ahtp ahtq ahtr ahts ahtt ahtu ahtv ahtw ahtx +ahty ahtz ahua ahub ahuc ahud ahue ahuf ahug ahuh ahui ahuj ahuk ahul ahum +ahun ahuo ahup ahuq ahur ahus ahut ahuu ahuv ahuw ahux ahuy ahuz ahva ahvb +ahvc ahvd ahve ahvf ahvg ahvh ahvi ahvj ahvk ahvl ahvm ahvn ahvo ahvp ahvq +ahvr ahvs ahvt ahvu ahvv ahvw ahvx ahvy ahvz ahwa ahwb ahwc ahwd ahwe ahwf +ahwg ahwh ahwi ahwj ahwk ahwl ahwm ahwn ahwo ahwp ahwq ahwr ahws ahwt ahwu +ahwv ahww ahwx ahwy ahwz ahxa ahxb ahxc ahxd ahxe ahxf ahxg ahxh ahxi ahxj +ahxk ahxl ahxm ahxn ahxo ahxp ahxq ahxr ahxs ahxt ahxu ahxv ahxw ahxx ahxy +ahxz ahya ahyb ahyc ahyd ahye ahyf ahyg ahyh ahyi ahyj ahyk ahyl ahym ahyn +ahyo ahyp ahyq ahyr ahys ahyt ahyu ahyv ahyw ahyx ahyy ahyz ahza ahzb ahzc +ahzd ahze ahzf ahzg ahzh ahzi ahzj ahzk ahzl ahzm ahzn ahzo ahzp ahzq ahzr +ahzs ahzt ahzu ahzv ahzw ahzx ahzy ahzz aiaa aiab aiac aiad aiae aiaf aiag +aiah aiai aiaj aiak aial aiam aian aiao aiap aiaq aiar aias aiat aiau aiav +aiaw aiax aiay aiaz aiba aibb aibc aibd aibe aibf aibg aibh aibi aibj aibk +aibl aibm aibn aibo aibp aibq aibr aibs aibt aibu aibv aibw aibx aiby aibz +aica aicb aicc aicd aice aicf aicg aich aici aicj aick aicl aicm aicn aico +aicp aicq aicr aics aict aicu aicv aicw aicx aicy aicz aida aidb aidc aidd +aide aidf aidg aidh aidi aidj aidk aidl aidm aidn aido aidp aidq aidr aids +aidt aidu aidv aidw aidx aidy aidz aiea aieb aiec aied aiee aief aieg aieh +aiei aiej aiek aiel aiem aien aieo aiep aieq aier aies aiet aieu aiev aiew +aiex aiey aiez aifa aifb aifc aifd aife aiff aifg aifh aifi aifj aifk aifl +aifm aifn aifo aifp aifq aifr aifs aift aifu aifv aifw aifx aify aifz aiga +aigb aigc aigd aige aigf aigg aigh aigi aigj aigk aigl aigm aign aigo aigp +aigq aigr aigs aigt aigu aigv aigw aigx aigy aigz aiha aihb aihc aihd aihe +aihf aihg aihh aihi aihj aihk aihl aihm aihn aiho aihp aihq aihr aihs aiht +aihu aihv aihw aihx aihy aihz aiia aiib aiic aiid aiie aiif aiig aiih aiii +aiij aiik aiil aiim aiin aiio aiip aiiq aiir aiis aiit aiiu aiiv aiiw aiix +aiiy aiiz aija aijb aijc aijd aije aijf aijg aijh aiji aijj aijk aijl aijm +aijn aijo aijp aijq aijr aijs aijt aiju aijv aijw aijx aijy aijz aika aikb +aikc aikd aike aikf aikg aikh aiki aikj aikk aikl aikm aikn aiko aikp aikq +aikr aiks aikt aiku aikv aikw aikx aiky aikz aila ailb ailc aild aile ailf +ailg ailh aili ailj ailk aill ailm ailn ailo ailp ailq ailr ails ailt ailu +ailv ailw ailx aily ailz aima aimb aimc aimd aime aimf aimg aimh aimi aimj +aimk aiml aimm aimn aimo aimp aimq aimr aims aimt aimu aimv aimw aimx aimy +aimz aina ainb ainc aind aine ainf aing ainh aini ainj aink ainl ainm ainn +aino ainp ainq ainr ains aint ainu ainv ainw ainx ainy ainz aioa aiob aioc +aiod aioe aiof aiog aioh aioi aioj aiok aiol aiom aion aioo aiop aioq aior +aios aiot aiou aiov aiow aiox aioy aioz aipa aipb aipc aipd aipe aipf aipg +aiph aipi aipj aipk aipl aipm aipn aipo aipp aipq aipr aips aipt aipu aipv +aipw aipx aipy aipz aiqa aiqb aiqc aiqd aiqe aiqf aiqg aiqh aiqi aiqj aiqk +aiql aiqm aiqn aiqo aiqp aiqq aiqr aiqs aiqt aiqu aiqv aiqw aiqx aiqy aiqz +aira airb airc aird aire airf airg airh airi airj airk airl airm airn airo +airp airq airr airs airt airu airv airw airx airy airz aisa aisb aisc aisd +aise aisf aisg aish aisi aisj aisk aisl aism aisn aiso aisp aisq aisr aiss +aist aisu aisv aisw aisx aisy aisz aita aitb aitc aitd aite aitf aitg aith +aiti aitj aitk aitl aitm aitn aito aitp aitq aitr aits aitt aitu aitv aitw +aitx aity aitz aiua aiub aiuc aiud aiue aiuf aiug aiuh aiui aiuj aiuk aiul +aium aiun aiuo aiup aiuq aiur aius aiut aiuu aiuv aiuw aiux aiuy aiuz aiva +aivb aivc aivd aive aivf aivg aivh aivi aivj aivk aivl aivm aivn aivo aivp +aivq aivr aivs aivt aivu aivv aivw aivx aivy aivz aiwa aiwb aiwc aiwd aiwe +aiwf aiwg aiwh aiwi aiwj aiwk aiwl aiwm aiwn aiwo aiwp aiwq aiwr aiws aiwt +aiwu aiwv aiww aiwx aiwy aiwz aixa aixb aixc aixd aixe aixf aixg aixh aixi +aixj aixk aixl aixm aixn aixo aixp aixq aixr aixs aixt aixu aixv aixw aixx +aixy aixz aiya aiyb aiyc aiyd aiye aiyf aiyg aiyh aiyi aiyj aiyk aiyl aiym +aiyn aiyo aiyp aiyq aiyr aiys aiyt aiyu aiyv aiyw aiyx aiyy aiyz aiza aizb +aizc aizd aize aizf aizg aizh aizi aizj aizk aizl aizm aizn aizo aizp aizq +aizr aizs aizt aizu aizv aizw aizx aizy aizz ajaa ajab ajac ajad ajae ajaf +ajag ajah ajai ajaj ajak ajal ajam ajan ajao ajap ajaq ajar ajas ajat ajau +ajav ajaw ajax ajay ajaz ajba ajbb ajbc ajbd ajbe ajbf ajbg ajbh ajbi ajbj +ajbk ajbl ajbm ajbn ajbo ajbp ajbq ajbr ajbs ajbt ajbu ajbv ajbw ajbx ajby +ajbz ajca ajcb ajcc ajcd ajce ajcf ajcg ajch ajci ajcj ajck ajcl ajcm ajcn +ajco ajcp ajcq ajcr ajcs ajct ajcu ajcv ajcw ajcx ajcy ajcz ajda ajdb ajdc +ajdd ajde ajdf ajdg ajdh ajdi ajdj ajdk ajdl ajdm ajdn ajdo ajdp ajdq ajdr +ajds ajdt ajdu ajdv ajdw ajdx ajdy ajdz ajea ajeb ajec ajed ajee ajef ajeg +ajeh ajei ajej ajek ajel ajem ajen ajeo ajep ajeq ajer ajes ajet ajeu ajev +ajew ajex ajey ajez ajfa ajfb ajfc ajfd ajfe ajff ajfg ajfh ajfi ajfj ajfk +ajfl ajfm ajfn ajfo ajfp ajfq ajfr ajfs ajft ajfu ajfv ajfw ajfx ajfy ajfz +ajga ajgb ajgc ajgd ajge ajgf ajgg ajgh ajgi ajgj ajgk ajgl ajgm ajgn ajgo +ajgp ajgq ajgr ajgs ajgt ajgu ajgv ajgw ajgx ajgy ajgz ajha ajhb ajhc ajhd +ajhe ajhf ajhg ajhh ajhi ajhj ajhk ajhl ajhm ajhn ajho ajhp ajhq ajhr ajhs +ajht ajhu ajhv ajhw ajhx ajhy ajhz ajia ajib ajic ajid ajie ajif ajig ajih +ajii ajij ajik ajil ajim ajin ajio ajip ajiq ajir ajis ajit ajiu ajiv ajiw +ajix ajiy ajiz ajja ajjb ajjc ajjd ajje ajjf ajjg ajjh ajji ajjj ajjk ajjl +ajjm ajjn ajjo ajjp ajjq ajjr ajjs ajjt ajju ajjv ajjw ajjx ajjy ajjz ajka +ajkb ajkc ajkd ajke ajkf ajkg ajkh ajki ajkj ajkk ajkl ajkm ajkn ajko ajkp +ajkq ajkr ajks ajkt ajku ajkv ajkw ajkx ajky ajkz ajla ajlb ajlc ajld ajle +ajlf ajlg ajlh ajli ajlj ajlk ajll ajlm ajln ajlo ajlp ajlq ajlr ajls ajlt +ajlu ajlv ajlw ajlx ajly ajlz ajma ajmb ajmc ajmd ajme ajmf ajmg ajmh ajmi +ajmj ajmk ajml ajmm ajmn ajmo ajmp ajmq ajmr ajms ajmt ajmu ajmv ajmw ajmx +ajmy ajmz ajna ajnb ajnc ajnd ajne ajnf ajng ajnh ajni ajnj ajnk ajnl ajnm +ajnn ajno ajnp ajnq ajnr ajns ajnt ajnu ajnv ajnw ajnx ajny ajnz ajoa ajob +ajoc ajod ajoe ajof ajog ajoh ajoi ajoj ajok ajol ajom ajon ajoo ajop ajoq +ajor ajos ajot ajou ajov ajow ajox ajoy ajoz ajpa ajpb ajpc ajpd ajpe ajpf +ajpg ajph ajpi ajpj ajpk ajpl ajpm ajpn ajpo ajpp ajpq ajpr ajps ajpt ajpu +ajpv ajpw ajpx ajpy ajpz ajqa ajqb ajqc ajqd ajqe ajqf ajqg ajqh ajqi ajqj +ajqk ajql ajqm ajqn ajqo ajqp ajqq ajqr ajqs ajqt ajqu ajqv ajqw ajqx ajqy +ajqz ajra ajrb ajrc ajrd ajre ajrf ajrg ajrh ajri ajrj ajrk ajrl ajrm ajrn +ajro ajrp ajrq ajrr ajrs ajrt ajru ajrv ajrw ajrx ajry ajrz ajsa ajsb ajsc +ajsd ajse ajsf ajsg ajsh ajsi ajsj ajsk ajsl ajsm ajsn ajso ajsp ajsq ajsr +ajss ajst ajsu ajsv ajsw ajsx ajsy ajsz ajta ajtb ajtc ajtd ajte ajtf ajtg +ajth ajti ajtj ajtk ajtl ajtm ajtn ajto ajtp ajtq ajtr ajts ajtt ajtu ajtv +ajtw ajtx ajty ajtz ajua ajub ajuc ajud ajue ajuf ajug ajuh ajui ajuj ajuk +ajul ajum ajun ajuo ajup ajuq ajur ajus ajut ajuu ajuv ajuw ajux ajuy ajuz +ajva ajvb ajvc ajvd ajve ajvf ajvg ajvh ajvi ajvj ajvk ajvl ajvm ajvn ajvo +ajvp ajvq ajvr ajvs ajvt ajvu ajvv ajvw ajvx ajvy ajvz ajwa ajwb ajwc ajwd +ajwe ajwf ajwg ajwh ajwi ajwj ajwk ajwl ajwm ajwn ajwo ajwp ajwq ajwr ajws +ajwt ajwu ajwv ajww ajwx ajwy ajwz ajxa ajxb ajxc ajxd ajxe ajxf ajxg ajxh +ajxi ajxj ajxk ajxl ajxm ajxn ajxo ajxp ajxq ajxr ajxs ajxt ajxu ajxv ajxw +ajxx ajxy ajxz ajya ajyb ajyc ajyd ajye ajyf ajyg ajyh ajyi ajyj ajyk ajyl +ajym ajyn ajyo ajyp ajyq ajyr ajys ajyt ajyu ajyv ajyw ajyx ajyy ajyz ajza +ajzb ajzc ajzd ajze ajzf ajzg ajzh ajzi ajzj ajzk ajzl ajzm ajzn ajzo ajzp +ajzq ajzr ajzs ajzt ajzu ajzv ajzw ajzx ajzy ajzz akaa akab akac akad akae +akaf akag akah akai akaj akak akal akam akan akao akap akaq akar akas akat +akau akav akaw akax akay akaz akba akbb akbc akbd akbe akbf akbg akbh akbi +akbj akbk akbl akbm akbn akbo akbp akbq akbr akbs akbt akbu akbv akbw akbx +akby akbz akca akcb akcc akcd akce akcf akcg akch akci akcj akck akcl akcm +akcn akco akcp akcq akcr akcs akct akcu akcv akcw akcx akcy akcz akda akdb +akdc akdd akde akdf akdg akdh akdi akdj akdk akdl akdm akdn akdo akdp akdq +akdr akds akdt akdu akdv akdw akdx akdy akdz akea akeb akec aked akee akef +akeg akeh akei akej akek akel akem aken akeo akep akeq aker akes aket akeu +akev akew akex akey akez akfa akfb akfc akfd akfe akff akfg akfh akfi akfj +akfk akfl akfm akfn akfo akfp akfq akfr akfs akft akfu akfv akfw akfx akfy +akfz akga akgb akgc akgd akge akgf akgg akgh akgi akgj akgk akgl akgm akgn +akgo akgp akgq akgr akgs akgt akgu akgv akgw akgx akgy akgz akha akhb akhc +akhd akhe akhf akhg akhh akhi akhj akhk akhl akhm akhn akho akhp akhq akhr +akhs akht akhu akhv akhw akhx akhy akhz akia akib akic akid akie akif akig +akih akii akij akik akil akim akin akio akip akiq akir akis akit akiu akiv +akiw akix akiy akiz akja akjb akjc akjd akje akjf akjg akjh akji akjj akjk +akjl akjm akjn akjo akjp akjq akjr akjs akjt akju akjv akjw akjx akjy akjz +akka akkb akkc akkd akke akkf akkg akkh akki akkj akkk akkl akkm akkn akko +akkp akkq akkr akks akkt akku akkv akkw akkx akky akkz akla aklb aklc akld +akle aklf aklg aklh akli aklj aklk akll aklm akln aklo aklp aklq aklr akls +aklt aklu aklv aklw aklx akly aklz akma akmb akmc akmd akme akmf akmg akmh +akmi akmj akmk akml akmm akmn akmo akmp akmq akmr akms akmt akmu akmv akmw +akmx akmy akmz akna aknb aknc aknd akne aknf akng aknh akni aknj aknk aknl +aknm aknn akno aknp aknq aknr akns aknt aknu aknv aknw aknx akny aknz akoa +akob akoc akod akoe akof akog akoh akoi akoj akok akol akom akon akoo akop +akoq akor akos akot akou akov akow akox akoy akoz akpa akpb akpc akpd akpe +akpf akpg akph akpi akpj akpk akpl akpm akpn akpo akpp akpq akpr akps akpt +akpu akpv akpw akpx akpy akpz akqa akqb akqc akqd akqe akqf akqg akqh akqi +akqj akqk akql akqm akqn akqo akqp akqq akqr akqs akqt akqu akqv akqw akqx +akqy akqz akra akrb akrc akrd akre akrf akrg akrh akri akrj akrk akrl akrm +akrn akro akrp akrq akrr akrs akrt akru akrv akrw akrx akry akrz aksa aksb +aksc aksd akse aksf aksg aksh aksi aksj aksk aksl aksm aksn akso aksp aksq +aksr akss akst aksu aksv aksw aksx aksy aksz akta aktb aktc aktd akte aktf +aktg akth akti aktj aktk aktl aktm aktn akto aktp aktq aktr akts aktt aktu +aktv aktw aktx akty aktz akua akub akuc akud akue akuf akug akuh akui akuj +akuk akul akum akun akuo akup akuq akur akus akut akuu akuv akuw akux akuy +akuz akva akvb akvc akvd akve akvf akvg akvh akvi akvj akvk akvl akvm akvn +akvo akvp akvq akvr akvs akvt akvu akvv akvw akvx akvy akvz akwa akwb akwc +akwd akwe akwf akwg akwh akwi akwj akwk akwl akwm akwn akwo akwp akwq akwr +akws akwt akwu akwv akww akwx akwy akwz akxa akxb akxc akxd akxe akxf akxg +akxh akxi akxj akxk akxl akxm akxn akxo akxp akxq akxr akxs akxt akxu akxv +akxw akxx akxy akxz akya akyb akyc akyd akye akyf akyg akyh akyi akyj akyk +akyl akym akyn akyo akyp akyq akyr akys akyt akyu akyv akyw akyx akyy akyz +akza akzb akzc akzd akze akzf akzg akzh akzi akzj akzk akzl akzm akzn akzo +akzp akzq akzr akzs akzt akzu akzv akzw akzx akzy akzz alaa alab alac alad +alae alaf alag alah alai alaj alak alal alam alan alao alap alaq alar alas +alat alau alav alaw alax alay alaz alba albb albc albd albe albf albg albh +albi albj albk albl albm albn albo albp albq albr albs albt albu albv albw diff --git a/camlp4/test/fixtures/idents2 b/camlp4/test/fixtures/idents2 new file mode 100644 index 00000000..ef07f3e1 --- /dev/null +++ b/camlp4/test/fixtures/idents2 @@ -0,0 +1,1219 @@ +aaaa aaab aaac aaad aaae aaaf aaag aaah aaai aaaj aaak aaal aaam aaan aaao +aaap aaaq aaar aaas aaat aaau aaav aaaw aaax aaay aaaz aaba aabb aabc aabd +aabe aabf aabg aabh aabi aabj aabk aabl aabm aabn aabo aabp aabq aabr aabs +aabt aabu aabv aabw aabx aaby aabz aaca aacb aacc aacd aace aacf aacg aach +aaci aacj aack aacl aacm aacn aaco aacp aacq aacr aacs aact aacu aacv aacw +aacx aacy aacz aada aadb aadc aadd aade aadf aadg aadh aadi aadj aadk aadl +aadm aadn aado aadp aadq aadr aads aadt aadu aadv aadw aadx aady aadz aaea +aaeb aaec aaed aaee aaef aaeg aaeh aaei aaej aaek aael aaem aaen aaeo aaep +aaeq aaer aaes aaet aaeu aaev aaew aaex aaey aaez aafa aafb aafc aafd aafe +aaff aafg aafh aafi aafj aafk aafl aafm aafn aafo aafp aafq aafr aafs aaft +aafu aafv aafw aafx aafy aafz aaga aagb aagc aagd aage aagf aagg aagh aagi +aagj aagk aagl aagm aagn aago aagp aagq aagr aags aagt aagu aagv aagw aagx +aagy aagz aaha aahb aahc aahd aahe aahf aahg aahh aahi aahj aahk aahl aahm +aahn aaho aahp aahq aahr aahs aaht aahu aahv aahw aahx aahy aahz aaia aaib +aaic aaid aaie aaif aaig aaih aaii aaij aaik aail aaim aain aaio aaip aaiq +aair aais aait aaiu aaiv aaiw aaix aaiy aaiz aaja aajb aajc aajd aaje aajf +aajg aajh aaji aajj aajk aajl aajm aajn aajo aajp aajq aajr aajs aajt aaju +aajv aajw aajx aajy aajz aaka aakb aakc aakd aake aakf aakg aakh aaki aakj +aakk aakl aakm aakn aako aakp aakq aakr aaks aakt aaku aakv aakw aakx aaky +aakz aala aalb aalc aald aale aalf aalg aalh aali aalj aalk aall aalm aaln +aalo aalp aalq aalr aals aalt aalu aalv aalw aalx aaly aalz aama aamb aamc +aamd aame aamf aamg aamh aami aamj aamk aaml aamm aamn aamo aamp aamq aamr +aams aamt aamu aamv aamw aamx aamy aamz aana aanb aanc aand aane aanf aang +aanh aani aanj aank aanl aanm aann aano aanp aanq aanr aans aant aanu aanv +aanw aanx aany aanz aaoa aaob aaoc aaod aaoe aaof aaog aaoh aaoi aaoj aaok +aaol aaom aaon aaoo aaop aaoq aaor aaos aaot aaou aaov aaow aaox aaoy aaoz +aapa aapb aapc aapd aape aapf aapg aaph aapi aapj aapk aapl aapm aapn aapo +aapp aapq aapr aaps aapt aapu aapv aapw aapx aapy aapz aaqa aaqb aaqc aaqd +aaqe aaqf aaqg aaqh aaqi aaqj aaqk aaql aaqm aaqn aaqo aaqp aaqq aaqr aaqs +aaqt aaqu aaqv aaqw aaqx aaqy aaqz aara aarb aarc aard aare aarf aarg aarh +aari aarj aark aarl aarm aarn aaro aarp aarq aarr aars aart aaru aarv aarw +aarx aary aarz aasa aasb aasc aasd aase aasf aasg aash aasi aasj aask aasl +aasm aasn aaso aasp aasq aasr aass aast aasu aasv aasw aasx aasy aasz aata +aatb aatc aatd aate aatf aatg aath aati aatj aatk aatl aatm aatn aato aatp +aatq aatr aats aatt aatu aatv aatw aatx aaty aatz aaua aaub aauc aaud aaue +aauf aaug aauh aaui aauj aauk aaul aaum aaun aauo aaup aauq aaur aaus aaut +aauu aauv aauw aaux aauy aauz aava aavb aavc aavd aave aavf aavg aavh aavi +aavj aavk aavl aavm aavn aavo aavp aavq aavr aavs aavt aavu aavv aavw aavx +aavy aavz aawa aawb aawc aawd aawe aawf aawg aawh aawi aawj aawk aawl aawm +aawn aawo aawp aawq aawr aaws aawt aawu aawv aaww aawx aawy aawz aaxa aaxb +aaxc aaxd aaxe aaxf aaxg aaxh aaxi aaxj aaxk aaxl aaxm aaxn aaxo aaxp aaxq +aaxr aaxs aaxt aaxu aaxv aaxw aaxx aaxy aaxz aaya aayb aayc aayd aaye aayf +aayg aayh aayi aayj aayk aayl aaym aayn aayo aayp aayq aayr aays aayt aayu +aayv aayw aayx aayy aayz aaza aazb aazc aazd aaze aazf aazg aazh aazi aazj +aazk aazl aazm aazn aazo aazp aazq aazr aazs aazt aazu aazv aazw aazx aazy +aazz abaa abab abac abad abae abaf abag abah abai abaj abak abal abam aban +abao abap abaq abar abas abat abau abav abaw abax abay abaz abba abbb abbc +abbd abbe abbf abbg abbh abbi abbj abbk abbl abbm abbn abbo abbp abbq abbr +abbs abbt abbu abbv abbw abbx abby abbz abca abcb abcc abcd abce abcf abcg +abch abci abcj abck abcl abcm abcn abco abcp abcq abcr abcs abct abcu abcv +abcw abcx abcy abcz abda abdb abdc abdd abde abdf abdg abdh abdi abdj abdk +abdl abdm abdn abdo abdp abdq abdr abds abdt abdu abdv abdw abdx abdy abdz +abea abeb abec abed abee abef abeg abeh abei abej abek abel abem aben abeo +abep abeq aber abes abet abeu abev abew abex abey abez abfa abfb abfc abfd +abfe abff abfg abfh abfi abfj abfk abfl abfm abfn abfo abfp abfq abfr abfs +abft abfu abfv abfw abfx abfy abfz abga abgb abgc abgd abge abgf abgg abgh +abgi abgj abgk abgl abgm abgn abgo abgp abgq abgr abgs abgt abgu abgv abgw +abgx abgy abgz abha abhb abhc abhd abhe abhf abhg abhh abhi abhj abhk abhl +abhm abhn abho abhp abhq abhr abhs abht abhu abhv abhw abhx abhy abhz abia +abib abic abid abie abif abig abih abii abij abik abil abim abin abio abip +abiq abir abis abit abiu abiv abiw abix abiy abiz abja abjb abjc abjd abje +abjf abjg abjh abji abjj abjk abjl abjm abjn abjo abjp abjq abjr abjs abjt +abju abjv abjw abjx abjy abjz abka abkb abkc abkd abke abkf abkg abkh abki +abkj abkk abkl abkm abkn abko abkp abkq abkr abks abkt abku abkv abkw abkx +abky abkz abla ablb ablc abld able ablf ablg ablh abli ablj ablk abll ablm +abln ablo ablp ablq ablr abls ablt ablu ablv ablw ablx ably ablz abma abmb +abmc abmd abme abmf abmg abmh abmi abmj abmk abml abmm abmn abmo abmp abmq +abmr abms abmt abmu abmv abmw abmx abmy abmz abna abnb abnc abnd abne abnf +abng abnh abni abnj abnk abnl abnm abnn abno abnp abnq abnr abns abnt abnu +abnv abnw abnx abny abnz aboa abob aboc abod aboe abof abog aboh aboi aboj +abok abol abom abon aboo abop aboq abor abos abot abou abov abow abox aboy +aboz abpa abpb abpc abpd abpe abpf abpg abph abpi abpj abpk abpl abpm abpn +abpo abpp abpq abpr abps abpt abpu abpv abpw abpx abpy abpz abqa abqb abqc +abqd abqe abqf abqg abqh abqi abqj abqk abql abqm abqn abqo abqp abqq abqr +abqs abqt abqu abqv abqw abqx abqy abqz abra abrb abrc abrd abre abrf abrg +abrh abri abrj abrk abrl abrm abrn abro abrp abrq abrr abrs abrt abru abrv +abrw abrx abry abrz absa absb absc absd abse absf absg absh absi absj absk +absl absm absn abso absp absq absr abss abst absu absv absw absx absy absz +abta abtb abtc abtd abte abtf abtg abth abti abtj abtk abtl abtm abtn abto +abtp abtq abtr abts abtt abtu abtv abtw abtx abty abtz abua abub abuc abud +abue abuf abug abuh abui abuj abuk abul abum abun abuo abup abuq abur abus +abut abuu abuv abuw abux abuy abuz abva abvb abvc abvd abve abvf abvg abvh +abvi abvj abvk abvl abvm abvn abvo abvp abvq abvr abvs abvt abvu abvv abvw +abvx abvy abvz abwa abwb abwc abwd abwe abwf abwg abwh abwi abwj abwk abwl +abwm abwn abwo abwp abwq abwr abws abwt abwu abwv abww abwx abwy abwz abxa +abxb abxc abxd abxe abxf abxg abxh abxi abxj abxk abxl abxm abxn abxo abxp +abxq abxr abxs abxt abxu abxv abxw abxx abxy abxz abya abyb abyc abyd abye +abyf abyg abyh abyi abyj abyk abyl abym abyn abyo abyp abyq abyr abys abyt +abyu abyv abyw abyx abyy abyz abza abzb abzc abzd abze abzf abzg abzh abzi +abzj abzk abzl abzm abzn abzo abzp abzq abzr abzs abzt abzu abzv abzw abzx +abzy abzz acaa acab acac acad acae acaf acag acah acai acaj acak acal acam +acan acao acap acaq acar acas acat acau acav acaw acax acay acaz acba acbb +acbc acbd acbe acbf acbg acbh acbi acbj acbk acbl acbm acbn acbo acbp acbq +acbr acbs acbt acbu acbv acbw acbx acby acbz acca accb accc accd acce accf +accg acch acci accj acck accl accm accn acco accp accq accr accs acct accu +accv accw accx accy accz acda acdb acdc acdd acde acdf acdg acdh acdi acdj +acdk acdl acdm acdn acdo acdp acdq acdr acds acdt acdu acdv acdw acdx acdy +acdz acea aceb acec aced acee acef aceg aceh acei acej acek acel acem acen +aceo acep aceq acer aces acet aceu acev acew acex acey acez acfa acfb acfc +acfd acfe acff acfg acfh acfi acfj acfk acfl acfm acfn acfo acfp acfq acfr +acfs acft acfu acfv acfw acfx acfy acfz acga acgb acgc acgd acge acgf acgg +acgh acgi acgj acgk acgl acgm acgn acgo acgp acgq acgr acgs acgt acgu acgv +acgw acgx acgy acgz acha achb achc achd ache achf achg achh achi achj achk +achl achm achn acho achp achq achr achs acht achu achv achw achx achy achz +acia acib acic acid acie acif acig acih acii acij acik acil acim acin acio +acip aciq acir acis acit aciu aciv aciw acix aciy aciz acja acjb acjc acjd +acje acjf acjg acjh acji acjj acjk acjl acjm acjn acjo acjp acjq acjr acjs +acjt acju acjv acjw acjx acjy acjz acka ackb ackc ackd acke ackf ackg ackh +acki ackj ackk ackl ackm ackn acko ackp ackq ackr acks ackt acku ackv ackw +ackx acky ackz acla aclb aclc acld acle aclf aclg aclh acli aclj aclk acll +aclm acln aclo aclp aclq aclr acls aclt aclu aclv aclw aclx acly aclz acma +acmb acmc acmd acme acmf acmg acmh acmi acmj acmk acml acmm acmn acmo acmp +acmq acmr acms acmt acmu acmv acmw acmx acmy acmz acna acnb acnc acnd acne +acnf acng acnh acni acnj acnk acnl acnm acnn acno acnp acnq acnr acns acnt +acnu acnv acnw acnx acny acnz acoa acob acoc acod acoe acof acog acoh acoi +acoj acok acol acom acon acoo acop acoq acor acos acot acou acov acow acox +acoy acoz acpa acpb acpc acpd acpe acpf acpg acph acpi acpj acpk acpl acpm +acpn acpo acpp acpq acpr acps acpt acpu acpv acpw acpx acpy acpz acqa acqb +acqc acqd acqe acqf acqg acqh acqi acqj acqk acql acqm acqn acqo acqp acqq +acqr acqs acqt acqu acqv acqw acqx acqy acqz acra acrb acrc acrd acre acrf +acrg acrh acri acrj acrk acrl acrm acrn acro acrp acrq acrr acrs acrt acru +acrv acrw acrx acry acrz acsa acsb acsc acsd acse acsf acsg acsh acsi acsj +acsk acsl acsm acsn acso acsp acsq acsr acss acst acsu acsv acsw acsx acsy +acsz acta actb actc actd acte actf actg acth acti actj actk actl actm actn +acto actp actq actr acts actt actu actv actw actx acty actz acua acub acuc +acud acue acuf acug acuh acui acuj acuk acul acum acun acuo acup acuq acur +acus acut acuu acuv acuw acux acuy acuz acva acvb acvc acvd acve acvf acvg +acvh acvi acvj acvk acvl acvm acvn acvo acvp acvq acvr acvs acvt acvu acvv +acvw acvx acvy acvz acwa acwb acwc acwd acwe acwf acwg acwh acwi acwj acwk +acwl acwm acwn acwo acwp acwq acwr acws acwt acwu acwv acww acwx acwy acwz +acxa acxb acxc acxd acxe acxf acxg acxh acxi acxj acxk acxl acxm acxn acxo +acxp acxq acxr acxs acxt acxu acxv acxw acxx acxy acxz acya acyb acyc acyd +acye acyf acyg acyh acyi acyj acyk acyl acym acyn acyo acyp acyq acyr acys +acyt acyu acyv acyw acyx acyy acyz acza aczb aczc aczd acze aczf aczg aczh +aczi aczj aczk aczl aczm aczn aczo aczp aczq aczr aczs aczt aczu aczv aczw +aczx aczy aczz adaa adab adac adad adae adaf adag adah adai adaj adak adal +adam adan adao adap adaq adar adas adat adau adav adaw adax aday adaz adba +adbb adbc adbd adbe adbf adbg adbh adbi adbj adbk adbl adbm adbn adbo adbp +adbq adbr adbs adbt adbu adbv adbw adbx adby adbz adca adcb adcc adcd adce +adcf adcg adch adci adcj adck adcl adcm adcn adco adcp adcq adcr adcs adct +adcu adcv adcw adcx adcy adcz adda addb addc addd adde addf addg addh addi +addj addk addl addm addn addo addp addq addr adds addt addu addv addw addx +addy addz adea adeb adec aded adee adef adeg adeh adei adej adek adel adem +aden adeo adep adeq ader ades adet adeu adev adew adex adey adez adfa adfb +adfc adfd adfe adff adfg adfh adfi adfj adfk adfl adfm adfn adfo adfp adfq +adfr adfs adft adfu adfv adfw adfx adfy adfz adga adgb adgc adgd adge adgf +adgg adgh adgi adgj adgk adgl adgm adgn adgo adgp adgq adgr adgs adgt adgu +adgv adgw adgx adgy adgz adha adhb adhc adhd adhe adhf adhg adhh adhi adhj +adhk adhl adhm adhn adho adhp adhq adhr adhs adht adhu adhv adhw adhx adhy +adhz adia adib adic adid adie adif adig adih adii adij adik adil adim adin +adio adip adiq adir adis adit adiu adiv adiw adix adiy adiz adja adjb adjc +adjd adje adjf adjg adjh adji adjj adjk adjl adjm adjn adjo adjp adjq adjr +adjs adjt adju adjv adjw adjx adjy adjz adka adkb adkc adkd adke adkf adkg +adkh adki adkj adkk adkl adkm adkn adko adkp adkq adkr adks adkt adku adkv +adkw adkx adky adkz adla adlb adlc adld adle adlf adlg adlh adli adlj adlk +adll adlm adln adlo adlp adlq adlr adls adlt adlu adlv adlw adlx adly adlz +adma admb admc admd adme admf admg admh admi admj admk adml admm admn admo +admp admq admr adms admt admu admv admw admx admy admz adna adnb adnc adnd +adne adnf adng adnh adni adnj adnk adnl adnm adnn adno adnp adnq adnr adns +adnt adnu adnv adnw adnx adny adnz adoa adob adoc adod adoe adof adog adoh +adoi adoj adok adol adom adon adoo adop adoq ador ados adot adou adov adow +adox adoy adoz adpa adpb adpc adpd adpe adpf adpg adph adpi adpj adpk adpl +adpm adpn adpo adpp adpq adpr adps adpt adpu adpv adpw adpx adpy adpz adqa +adqb adqc adqd adqe adqf adqg adqh adqi adqj adqk adql adqm adqn adqo adqp +adqq adqr adqs adqt adqu adqv adqw adqx adqy adqz adra adrb adrc adrd adre +adrf adrg adrh adri adrj adrk adrl adrm adrn adro adrp adrq adrr adrs adrt +adru adrv adrw adrx adry adrz adsa adsb adsc adsd adse adsf adsg adsh adsi +adsj adsk adsl adsm adsn adso adsp adsq adsr adss adst adsu adsv adsw adsx +adsy adsz adta adtb adtc adtd adte adtf adtg adth adti adtj adtk adtl adtm +adtn adto adtp adtq adtr adts adtt adtu adtv adtw adtx adty adtz adua adub +aduc adud adue aduf adug aduh adui aduj aduk adul adum adun aduo adup aduq +adur adus adut aduu aduv aduw adux aduy aduz adva advb advc advd adve advf +advg advh advi advj advk advl advm advn advo advp advq advr advs advt advu +advv advw advx advy advz adwa adwb adwc adwd adwe adwf adwg adwh adwi adwj +adwk adwl adwm adwn adwo adwp adwq adwr adws adwt adwu adwv adww adwx adwy +adwz adxa adxb adxc adxd adxe adxf adxg adxh adxi adxj adxk adxl adxm adxn +adxo adxp adxq adxr adxs adxt adxu adxv adxw adxx adxy adxz adya adyb adyc +adyd adye adyf adyg adyh adyi adyj adyk adyl adym adyn adyo adyp adyq adyr +adys adyt adyu adyv adyw adyx adyy adyz adza adzb adzc adzd adze adzf adzg +adzh adzi adzj adzk adzl adzm adzn adzo adzp adzq adzr adzs adzt adzu adzv +adzw adzx adzy adzz aeaa aeab aeac aead aeae aeaf aeag aeah aeai aeaj aeak +aeal aeam aean aeao aeap aeaq aear aeas aeat aeau aeav aeaw aeax aeay aeaz +aeba aebb aebc aebd aebe aebf aebg aebh aebi aebj aebk aebl aebm aebn aebo +aebp aebq aebr aebs aebt aebu aebv aebw aebx aeby aebz aeca aecb aecc aecd +aece aecf aecg aech aeci aecj aeck aecl aecm aecn aeco aecp aecq aecr aecs +aect aecu aecv aecw aecx aecy aecz aeda aedb aedc aedd aede aedf aedg aedh +aedi aedj aedk aedl aedm aedn aedo aedp aedq aedr aeds aedt aedu aedv aedw +aedx aedy aedz aeea aeeb aeec aeed aeee aeef aeeg aeeh aeei aeej aeek aeel +aeem aeen aeeo aeep aeeq aeer aees aeet aeeu aeev aeew aeex aeey aeez aefa +aefb aefc aefd aefe aeff aefg aefh aefi aefj aefk aefl aefm aefn aefo aefp +aefq aefr aefs aeft aefu aefv aefw aefx aefy aefz aega aegb aegc aegd aege +aegf aegg aegh aegi aegj aegk aegl aegm aegn aego aegp aegq aegr aegs aegt +aegu aegv aegw aegx aegy aegz aeha aehb aehc aehd aehe aehf aehg aehh aehi +aehj aehk aehl aehm aehn aeho aehp aehq aehr aehs aeht aehu aehv aehw aehx +aehy aehz aeia aeib aeic aeid aeie aeif aeig aeih aeii aeij aeik aeil aeim +aein aeio aeip aeiq aeir aeis aeit aeiu aeiv aeiw aeix aeiy aeiz aeja aejb +aejc aejd aeje aejf aejg aejh aeji aejj aejk aejl aejm aejn aejo aejp aejq +aejr aejs aejt aeju aejv aejw aejx aejy aejz aeka aekb aekc aekd aeke aekf +aekg aekh aeki aekj aekk aekl aekm aekn aeko aekp aekq aekr aeks aekt aeku +aekv aekw aekx aeky aekz aela aelb aelc aeld aele aelf aelg aelh aeli aelj +aelk aell aelm aeln aelo aelp aelq aelr aels aelt aelu aelv aelw aelx aely +aelz aema aemb aemc aemd aeme aemf aemg aemh aemi aemj aemk aeml aemm aemn +aemo aemp aemq aemr aems aemt aemu aemv aemw aemx aemy aemz aena aenb aenc +aend aene aenf aeng aenh aeni aenj aenk aenl aenm aenn aeno aenp aenq aenr +aens aent aenu aenv aenw aenx aeny aenz aeoa aeob aeoc aeod aeoe aeof aeog +aeoh aeoi aeoj aeok aeol aeom aeon aeoo aeop aeoq aeor aeos aeot aeou aeov +aeow aeox aeoy aeoz aepa aepb aepc aepd aepe aepf aepg aeph aepi aepj aepk +aepl aepm aepn aepo aepp aepq aepr aeps aept aepu aepv aepw aepx aepy aepz +aeqa aeqb aeqc aeqd aeqe aeqf aeqg aeqh aeqi aeqj aeqk aeql aeqm aeqn aeqo +aeqp aeqq aeqr aeqs aeqt aequ aeqv aeqw aeqx aeqy aeqz aera aerb aerc aerd +aere aerf aerg aerh aeri aerj aerk aerl aerm aern aero aerp aerq aerr aers +aert aeru aerv aerw aerx aery aerz aesa aesb aesc aesd aese aesf aesg aesh +aesi aesj aesk aesl aesm aesn aeso aesp aesq aesr aess aest aesu aesv aesw +aesx aesy aesz aeta aetb aetc aetd aete aetf aetg aeth aeti aetj aetk aetl +aetm aetn aeto aetp aetq aetr aets aett aetu aetv aetw aetx aety aetz aeua +aeub aeuc aeud aeue aeuf aeug aeuh aeui aeuj aeuk aeul aeum aeun aeuo aeup +aeuq aeur aeus aeut aeuu aeuv aeuw aeux aeuy aeuz aeva aevb aevc aevd aeve +aevf aevg aevh aevi aevj aevk aevl aevm aevn aevo aevp aevq aevr aevs aevt +aevu aevv aevw aevx aevy aevz aewa aewb aewc aewd aewe aewf aewg aewh aewi +aewj aewk aewl aewm aewn aewo aewp aewq aewr aews aewt aewu aewv aeww aewx +aewy aewz aexa aexb aexc aexd aexe aexf aexg aexh aexi aexj aexk aexl aexm +aexn aexo aexp aexq aexr aexs aext aexu aexv aexw aexx aexy aexz aeya aeyb +aeyc aeyd aeye aeyf aeyg aeyh aeyi aeyj aeyk aeyl aeym aeyn aeyo aeyp aeyq +aeyr aeys aeyt aeyu aeyv aeyw aeyx aeyy aeyz aeza aezb aezc aezd aeze aezf +aezg aezh aezi aezj aezk aezl aezm aezn aezo aezp aezq aezr aezs aezt aezu +aezv aezw aezx aezy aezz afaa afab afac afad afae afaf afag afah afai afaj +afak afal afam afan afao afap afaq afar afas afat afau afav afaw afax afay +afaz afba afbb afbc afbd afbe afbf afbg afbh afbi afbj afbk afbl afbm afbn +afbo afbp afbq afbr afbs afbt afbu afbv afbw afbx afby afbz afca afcb afcc +afcd afce afcf afcg afch afci afcj afck afcl afcm afcn afco afcp afcq afcr +afcs afct afcu afcv afcw afcx afcy afcz afda afdb afdc afdd afde afdf afdg +afdh afdi afdj afdk afdl afdm afdn afdo afdp afdq afdr afds afdt afdu afdv +afdw afdx afdy afdz afea afeb afec afed afee afef afeg afeh afei afej afek +afel afem afen afeo afep afeq afer afes afet afeu afev afew afex afey afez +affa affb affc affd affe afff affg affh affi affj affk affl affm affn affo +affp affq affr affs afft affu affv affw affx affy affz afga afgb afgc afgd +afge afgf afgg afgh afgi afgj afgk afgl afgm afgn afgo afgp afgq afgr afgs +afgt afgu afgv afgw afgx afgy afgz afha afhb afhc afhd afhe afhf afhg afhh +afhi afhj afhk afhl afhm afhn afho afhp afhq afhr afhs afht afhu afhv afhw +afhx afhy afhz afia afib afic afid afie afif afig afih afii afij afik afil +afim afin afio afip afiq afir afis afit afiu afiv afiw afix afiy afiz afja +afjb afjc afjd afje afjf afjg afjh afji afjj afjk afjl afjm afjn afjo afjp +afjq afjr afjs afjt afju afjv afjw afjx afjy afjz afka afkb afkc afkd afke +afkf afkg afkh afki afkj afkk afkl afkm afkn afko afkp afkq afkr afks afkt +afku afkv afkw afkx afky afkz afla aflb aflc afld afle aflf aflg aflh afli +aflj aflk afll aflm afln aflo aflp aflq aflr afls aflt aflu aflv aflw aflx +afly aflz afma afmb afmc afmd afme afmf afmg afmh afmi afmj afmk afml afmm +afmn afmo afmp afmq afmr afms afmt afmu afmv afmw afmx afmy afmz afna afnb +afnc afnd afne afnf afng afnh afni afnj afnk afnl afnm afnn afno afnp afnq +afnr afns afnt afnu afnv afnw afnx afny afnz afoa afob afoc afod afoe afof +afog afoh afoi afoj afok afol afom afon afoo afop afoq afor afos afot afou +afov afow afox afoy afoz afpa afpb afpc afpd afpe afpf afpg afph afpi afpj +afpk afpl afpm afpn afpo afpp afpq afpr afps afpt afpu afpv afpw afpx afpy +afpz afqa afqb afqc afqd afqe afqf afqg afqh afqi afqj afqk afql afqm afqn +afqo afqp afqq afqr afqs afqt afqu afqv afqw afqx afqy afqz afra afrb afrc +afrd afre afrf afrg afrh afri afrj afrk afrl afrm afrn afro afrp afrq afrr +afrs afrt afru afrv afrw afrx afry afrz afsa afsb afsc afsd afse afsf afsg +afsh afsi afsj afsk afsl afsm afsn afso afsp afsq afsr afss afst afsu afsv +afsw afsx afsy afsz afta aftb aftc aftd afte aftf aftg afth afti aftj aftk +aftl aftm aftn afto aftp aftq aftr afts aftt aftu aftv aftw aftx afty aftz +afua afub afuc afud afue afuf afug afuh afui afuj afuk aful afum afun afuo +afup afuq afur afus afut afuu afuv afuw afux afuy afuz afva afvb afvc afvd +afve afvf afvg afvh afvi afvj afvk afvl afvm afvn afvo afvp afvq afvr afvs +afvt afvu afvv afvw afvx afvy afvz afwa afwb afwc afwd afwe afwf afwg afwh +afwi afwj afwk afwl afwm afwn afwo afwp afwq afwr afws afwt afwu afwv afww +afwx afwy afwz afxa afxb afxc afxd afxe afxf afxg afxh afxi afxj afxk afxl +afxm afxn afxo afxp afxq afxr afxs afxt afxu afxv afxw afxx afxy afxz afya +afyb afyc afyd afye afyf afyg afyh afyi afyj afyk afyl afym afyn afyo afyp +afyq afyr afys afyt afyu afyv afyw afyx afyy afyz afza afzb afzc afzd afze +afzf afzg afzh afzi afzj afzk afzl afzm afzn afzo afzp afzq afzr afzs afzt +afzu afzv afzw afzx afzy afzz agaa agab agac agad agae agaf agag agah agai +agaj agak agal agam agan agao agap agaq agar agas agat agau agav agaw agax +agay agaz agba agbb agbc agbd agbe agbf agbg agbh agbi agbj agbk agbl agbm +agbn agbo agbp agbq agbr agbs agbt agbu agbv agbw agbx agby agbz agca agcb +agcc agcd agce agcf agcg agch agci agcj agck agcl agcm agcn agco agcp agcq +agcr agcs agct agcu agcv agcw agcx agcy agcz agda agdb agdc agdd agde agdf +agdg agdh agdi agdj agdk agdl agdm agdn agdo agdp agdq agdr agds agdt agdu +agdv agdw agdx agdy agdz agea ageb agec aged agee agef ageg ageh agei agej +agek agel agem agen ageo agep ageq ager ages aget ageu agev agew agex agey +agez agfa agfb agfc agfd agfe agff agfg agfh agfi agfj agfk agfl agfm agfn +agfo agfp agfq agfr agfs agft agfu agfv agfw agfx agfy agfz agga aggb aggc +aggd agge aggf aggg aggh aggi aggj aggk aggl aggm aggn aggo aggp aggq aggr +aggs aggt aggu aggv aggw aggx aggy aggz agha aghb aghc aghd aghe aghf aghg +aghh aghi aghj aghk aghl aghm aghn agho aghp aghq aghr aghs aght aghu aghv +aghw aghx aghy aghz agia agib agic agid agie agif agig agih agii agij agik +agil agim agin agio agip agiq agir agis agit agiu agiv agiw agix agiy agiz +agja agjb agjc agjd agje agjf agjg agjh agji agjj agjk agjl agjm agjn agjo +agjp agjq agjr agjs agjt agju agjv agjw agjx agjy agjz agka agkb agkc agkd +agke agkf agkg agkh agki agkj agkk agkl agkm agkn agko agkp agkq agkr agks +agkt agku agkv agkw agkx agky agkz agla aglb aglc agld agle aglf aglg aglh +agli aglj aglk agll aglm agln aglo aglp aglq aglr agls aglt aglu aglv aglw +aglx agly aglz agma agmb agmc agmd agme agmf agmg agmh agmi agmj agmk agml +agmm agmn agmo agmp agmq agmr agms agmt agmu agmv agmw agmx agmy agmz agna +agnb agnc agnd agne agnf agng agnh agni agnj agnk agnl agnm agnn agno agnp +agnq agnr agns agnt agnu agnv agnw agnx agny agnz agoa agob agoc agod agoe +agof agog agoh agoi agoj agok agol agom agon agoo agop agoq agor agos agot +agou agov agow agox agoy agoz agpa agpb agpc agpd agpe agpf agpg agph agpi +agpj agpk agpl agpm agpn agpo agpp agpq agpr agps agpt agpu agpv agpw agpx +agpy agpz agqa agqb agqc agqd agqe agqf agqg agqh agqi agqj agqk agql agqm +agqn agqo agqp agqq agqr agqs agqt agqu agqv agqw agqx agqy agqz agra agrb +agrc agrd agre agrf agrg agrh agri agrj agrk agrl agrm agrn agro agrp agrq +agrr agrs agrt agru agrv agrw agrx agry agrz agsa agsb agsc agsd agse agsf +agsg agsh agsi agsj agsk agsl agsm agsn agso agsp agsq agsr agss agst agsu +agsv agsw agsx agsy agsz agta agtb agtc agtd agte agtf agtg agth agti agtj +agtk agtl agtm agtn agto agtp agtq agtr agts agtt agtu agtv agtw agtx agty +agtz agua agub aguc agud ague aguf agug aguh agui aguj aguk agul agum agun +aguo agup aguq agur agus agut aguu aguv aguw agux aguy aguz agva agvb agvc +agvd agve agvf agvg agvh agvi agvj agvk agvl agvm agvn agvo agvp agvq agvr +agvs agvt agvu agvv agvw agvx agvy agvz agwa agwb agwc agwd agwe agwf agwg +agwh agwi agwj agwk agwl agwm agwn agwo agwp agwq agwr agws agwt agwu agwv +agww agwx agwy agwz agxa agxb agxc agxd agxe agxf agxg agxh agxi agxj agxk +agxl agxm agxn agxo agxp agxq agxr agxs agxt agxu agxv agxw agxx agxy agxz +agya agyb agyc agyd agye agyf agyg agyh agyi agyj agyk agyl agym agyn agyo +agyp agyq agyr agys agyt agyu agyv agyw agyx agyy agyz agza agzb agzc agzd +agze agzf agzg agzh agzi agzj agzk agzl agzm agzn agzo agzp agzq agzr agzs +agzt agzu agzv agzw agzx agzy agzz ahaa ahab ahac ahad ahae ahaf ahag ahah +ahai ahaj ahak ahal aham ahan ahao ahap ahaq ahar ahas ahat ahau ahav ahaw +ahax ahay ahaz ahba ahbb ahbc ahbd ahbe ahbf ahbg ahbh ahbi ahbj ahbk ahbl +ahbm ahbn ahbo ahbp ahbq ahbr ahbs ahbt ahbu ahbv ahbw ahbx ahby ahbz ahca +ahcb ahcc ahcd ahce ahcf ahcg ahch ahci ahcj ahck ahcl ahcm ahcn ahco ahcp +ahcq ahcr ahcs ahct ahcu ahcv ahcw ahcx ahcy ahcz ahda ahdb ahdc ahdd ahde +ahdf ahdg ahdh ahdi ahdj ahdk ahdl ahdm ahdn ahdo ahdp ahdq ahdr ahds ahdt +ahdu ahdv ahdw ahdx ahdy ahdz ahea aheb ahec ahed ahee ahef aheg aheh ahei +ahej ahek ahel ahem ahen aheo ahep aheq aher ahes ahet aheu ahev ahew ahex +ahey ahez ahfa ahfb ahfc ahfd ahfe ahff ahfg ahfh ahfi ahfj ahfk ahfl ahfm +ahfn ahfo ahfp ahfq ahfr ahfs ahft ahfu ahfv ahfw ahfx ahfy ahfz ahga ahgb +ahgc ahgd ahge ahgf ahgg ahgh ahgi ahgj ahgk ahgl ahgm ahgn ahgo ahgp ahgq +ahgr ahgs ahgt ahgu ahgv ahgw ahgx ahgy ahgz ahha ahhb ahhc ahhd ahhe ahhf +ahhg ahhh ahhi ahhj ahhk ahhl ahhm ahhn ahho ahhp ahhq ahhr ahhs ahht ahhu +ahhv ahhw ahhx ahhy ahhz ahia ahib ahic ahid ahie ahif ahig ahih ahii ahij +ahik ahil ahim ahin ahio ahip ahiq ahir ahis ahit ahiu ahiv ahiw ahix ahiy +ahiz ahja ahjb ahjc ahjd ahje ahjf ahjg ahjh ahji ahjj ahjk ahjl ahjm ahjn +ahjo ahjp ahjq ahjr ahjs ahjt ahju ahjv ahjw ahjx ahjy ahjz ahka ahkb ahkc +ahkd ahke ahkf ahkg ahkh ahki ahkj ahkk ahkl ahkm ahkn ahko ahkp ahkq ahkr +ahks ahkt ahku ahkv ahkw ahkx ahky ahkz ahla ahlb ahlc ahld ahle ahlf ahlg +ahlh ahli ahlj ahlk ahll ahlm ahln ahlo ahlp ahlq ahlr ahls ahlt ahlu ahlv +ahlw ahlx ahly ahlz ahma ahmb ahmc ahmd ahme ahmf ahmg ahmh ahmi ahmj ahmk +ahml ahmm ahmn ahmo ahmp ahmq ahmr ahms ahmt ahmu ahmv ahmw ahmx ahmy ahmz +ahna ahnb ahnc ahnd ahne ahnf ahng ahnh ahni ahnj ahnk ahnl ahnm ahnn ahno +ahnp ahnq ahnr ahns ahnt ahnu ahnv ahnw ahnx ahny ahnz ahoa ahob ahoc ahod +ahoe ahof ahog ahoh ahoi ahoj ahok ahol ahom ahon ahoo ahop ahoq ahor ahos +ahot ahou ahov ahow ahox ahoy ahoz ahpa ahpb ahpc ahpd ahpe ahpf ahpg ahph +ahpi ahpj ahpk ahpl ahpm ahpn ahpo ahpp ahpq ahpr ahps ahpt ahpu ahpv ahpw +ahpx ahpy ahpz ahqa ahqb ahqc ahqd ahqe ahqf ahqg ahqh ahqi ahqj ahqk ahql +ahqm ahqn ahqo ahqp ahqq ahqr ahqs ahqt ahqu ahqv ahqw ahqx ahqy ahqz ahra +ahrb ahrc ahrd ahre ahrf ahrg ahrh ahri ahrj ahrk ahrl ahrm ahrn ahro ahrp +ahrq ahrr ahrs ahrt ahru ahrv ahrw ahrx ahry ahrz ahsa ahsb ahsc ahsd ahse +ahsf ahsg ahsh ahsi ahsj ahsk ahsl ahsm ahsn ahso ahsp ahsq ahsr ahss ahst +ahsu ahsv ahsw ahsx ahsy ahsz ahta ahtb ahtc ahtd ahte ahtf ahtg ahth ahti +ahtj ahtk ahtl ahtm ahtn ahto ahtp ahtq ahtr ahts ahtt ahtu ahtv ahtw ahtx +ahty ahtz ahua ahub ahuc ahud ahue ahuf ahug ahuh ahui ahuj ahuk ahul ahum +ahun ahuo ahup ahuq ahur ahus ahut ahuu ahuv ahuw ahux ahuy ahuz ahva ahvb +ahvc ahvd ahve ahvf ahvg ahvh ahvi ahvj ahvk ahvl ahvm ahvn ahvo ahvp ahvq +ahvr ahvs ahvt ahvu ahvv ahvw ahvx ahvy ahvz ahwa ahwb ahwc ahwd ahwe ahwf +ahwg ahwh ahwi ahwj ahwk ahwl ahwm ahwn ahwo ahwp ahwq ahwr ahws ahwt ahwu +ahwv ahww ahwx ahwy ahwz ahxa ahxb ahxc ahxd ahxe ahxf ahxg ahxh ahxi ahxj +ahxk ahxl ahxm ahxn ahxo ahxp ahxq ahxr ahxs ahxt ahxu ahxv ahxw ahxx ahxy +ahxz ahya ahyb ahyc ahyd ahye ahyf ahyg ahyh ahyi ahyj ahyk ahyl ahym ahyn +ahyo ahyp ahyq ahyr ahys ahyt ahyu ahyv ahyw ahyx ahyy ahyz ahza ahzb ahzc +ahzd ahze ahzf ahzg ahzh ahzi ahzj ahzk ahzl ahzm ahzn ahzo ahzp ahzq ahzr +ahzs ahzt ahzu ahzv ahzw ahzx ahzy ahzz aiaa aiab aiac aiad aiae aiaf aiag +aiah aiai aiaj aiak aial aiam aian aiao aiap aiaq aiar aias aiat aiau aiav +aiaw aiax aiay aiaz aiba aibb aibc aibd aibe aibf aibg aibh aibi aibj aibk +aibl aibm aibn aibo aibp aibq aibr aibs aibt aibu aibv aibw aibx aiby aibz +aica aicb aicc aicd aice aicf aicg aich aici aicj aick aicl aicm aicn aico +aicp aicq aicr aics aict aicu aicv aicw aicx aicy aicz aida aidb aidc aidd +aide aidf aidg aidh aidi aidj aidk aidl aidm aidn aido aidp aidq aidr aids +aidt aidu aidv aidw aidx aidy aidz aiea aieb aiec aied aiee aief aieg aieh +aiei aiej aiek aiel aiem aien aieo aiep aieq aier aies aiet aieu aiev aiew +aiex aiey aiez aifa aifb aifc aifd aife aiff aifg aifh aifi aifj aifk aifl +aifm aifn aifo aifp aifq aifr aifs aift aifu aifv aifw aifx aify aifz aiga +aigb aigc aigd aige aigf aigg aigh aigi aigj aigk aigl aigm aign aigo aigp +aigq aigr aigs aigt aigu aigv aigw aigx aigy aigz aiha aihb aihc aihd aihe +aihf aihg aihh aihi aihj aihk aihl aihm aihn aiho aihp aihq aihr aihs aiht +aihu aihv aihw aihx aihy aihz aiia aiib aiic aiid aiie aiif aiig aiih aiii +aiij aiik aiil aiim aiin aiio aiip aiiq aiir aiis aiit aiiu aiiv aiiw aiix +aiiy aiiz aija aijb aijc aijd aije aijf aijg aijh aiji aijj aijk aijl aijm +aijn aijo aijp aijq aijr aijs aijt aiju aijv aijw aijx aijy aijz aika aikb +aikc aikd aike aikf aikg aikh aiki aikj aikk aikl aikm aikn aiko aikp aikq +aikr aiks aikt aiku aikv aikw aikx aiky aikz aila ailb ailc aild aile ailf +ailg ailh aili ailj ailk aill ailm ailn ailo ailp ailq ailr ails ailt ailu +ailv ailw ailx aily ailz aima aimb aimc aimd aime aimf aimg aimh aimi aimj +aimk aiml aimm aimn aimo aimp aimq aimr aims aimt aimu aimv aimw aimx aimy +aimz aina ainb ainc aind aine ainf aing ainh aini ainj aink ainl ainm ainn +aino ainp ainq ainr ains aint ainu ainv ainw ainx ainy ainz aioa aiob aioc +aiod aioe aiof aiog aioh aioi aioj aiok aiol aiom aion aioo aiop aioq aior +aios aiot aiou aiov aiow aiox aioy aioz aipa aipb aipc aipd aipe aipf aipg +aiph aipi aipj aipk aipl aipm aipn aipo aipp aipq aipr aips aipt aipu aipv +aipw aipx aipy aipz aiqa aiqb aiqc aiqd aiqe aiqf aiqg aiqh aiqi aiqj aiqk +aiql aiqm aiqn aiqo aiqp aiqq aiqr aiqs aiqt aiqu aiqv aiqw aiqx aiqy aiqz +aira airb airc aird aire airf airg airh airi airj airk airl airm airn airo +airp airq airr airs airt airu airv airw airx airy airz aisa aisb aisc aisd +aise aisf aisg aish aisi aisj aisk aisl aism aisn aiso aisp aisq aisr aiss +aist aisu aisv aisw aisx aisy aisz aita aitb aitc aitd aite aitf aitg aith +aiti aitj aitk aitl aitm aitn aito aitp aitq aitr aits aitt aitu aitv aitw +aitx aity aitz aiua aiub aiuc aiud aiue aiuf aiug aiuh aiui aiuj aiuk aiul +aium aiun aiuo aiup aiuq aiur aius aiut aiuu aiuv aiuw aiux aiuy aiuz aiva +aivb aivc aivd aive aivf aivg aivh aivi aivj aivk aivl aivm aivn aivo aivp +aivq aivr aivs aivt aivu aivv aivw aivx aivy aivz aiwa aiwb aiwc aiwd aiwe +aiwf aiwg aiwh aiwi aiwj aiwk aiwl aiwm aiwn aiwo aiwp aiwq aiwr aiws aiwt +aiwu aiwv aiww aiwx aiwy aiwz aixa aixb aixc aixd aixe aixf aixg aixh aixi +aixj aixk aixl aixm aixn aixo aixp aixq aixr aixs aixt aixu aixv aixw aixx +aixy aixz aiya aiyb aiyc aiyd aiye aiyf aiyg aiyh aiyi aiyj aiyk aiyl aiym +aiyn aiyo aiyp aiyq aiyr aiys aiyt aiyu aiyv aiyw aiyx aiyy aiyz aiza aizb +aizc aizd aize aizf aizg aizh aizi aizj aizk aizl aizm aizn aizo aizp aizq +aizr aizs aizt aizu aizv aizw aizx aizy aizz ajaa ajab ajac ajad ajae ajaf +ajag ajah ajai ajaj ajak ajal ajam ajan ajao ajap ajaq ajar ajas ajat ajau +ajav ajaw ajax ajay ajaz ajba ajbb ajbc ajbd ajbe ajbf ajbg ajbh ajbi ajbj +ajbk ajbl ajbm ajbn ajbo ajbp ajbq ajbr ajbs ajbt ajbu ajbv ajbw ajbx ajby +ajbz ajca ajcb ajcc ajcd ajce ajcf ajcg ajch ajci ajcj ajck ajcl ajcm ajcn +ajco ajcp ajcq ajcr ajcs ajct ajcu ajcv ajcw ajcx ajcy ajcz ajda ajdb ajdc +ajdd ajde ajdf ajdg ajdh ajdi ajdj ajdk ajdl ajdm ajdn ajdo ajdp ajdq ajdr +ajds ajdt ajdu ajdv ajdw ajdx ajdy ajdz ajea ajeb ajec ajed ajee ajef ajeg +ajeh ajei ajej ajek ajel ajem ajen ajeo ajep ajeq ajer ajes ajet ajeu ajev +ajew ajex ajey ajez ajfa ajfb ajfc ajfd ajfe ajff ajfg ajfh ajfi ajfj ajfk +ajfl ajfm ajfn ajfo ajfp ajfq ajfr ajfs ajft ajfu ajfv ajfw ajfx ajfy ajfz +ajga ajgb ajgc ajgd ajge ajgf ajgg ajgh ajgi ajgj ajgk ajgl ajgm ajgn ajgo +ajgp ajgq ajgr ajgs ajgt ajgu ajgv ajgw ajgx ajgy ajgz ajha ajhb ajhc ajhd +ajhe ajhf ajhg ajhh ajhi ajhj ajhk ajhl ajhm ajhn ajho ajhp ajhq ajhr ajhs +ajht ajhu ajhv ajhw ajhx ajhy ajhz ajia ajib ajic ajid ajie ajif ajig ajih +ajii ajij ajik ajil ajim ajin ajio ajip ajiq ajir ajis ajit ajiu ajiv ajiw +ajix ajiy ajiz ajja ajjb ajjc ajjd ajje ajjf ajjg ajjh ajji ajjj ajjk ajjl +ajjm ajjn ajjo ajjp ajjq ajjr ajjs ajjt ajju ajjv ajjw ajjx ajjy ajjz ajka +ajkb ajkc ajkd ajke ajkf ajkg ajkh ajki ajkj ajkk ajkl ajkm ajkn ajko ajkp +ajkq ajkr ajks ajkt ajku ajkv ajkw ajkx ajky ajkz ajla ajlb ajlc ajld ajle +ajlf ajlg ajlh ajli ajlj ajlk ajll ajlm ajln ajlo ajlp ajlq ajlr ajls ajlt +ajlu ajlv ajlw ajlx ajly ajlz ajma ajmb ajmc ajmd ajme ajmf ajmg ajmh ajmi +ajmj ajmk ajml ajmm ajmn ajmo ajmp ajmq ajmr ajms ajmt ajmu ajmv ajmw ajmx +ajmy ajmz ajna ajnb ajnc ajnd ajne ajnf ajng ajnh ajni ajnj ajnk ajnl ajnm +ajnn ajno ajnp ajnq ajnr ajns ajnt ajnu ajnv ajnw ajnx ajny ajnz ajoa ajob +ajoc ajod ajoe ajof ajog ajoh ajoi ajoj ajok ajol ajom ajon ajoo ajop ajoq +ajor ajos ajot ajou ajov ajow ajox ajoy ajoz ajpa ajpb ajpc ajpd ajpe ajpf +ajpg ajph ajpi ajpj ajpk ajpl ajpm ajpn ajpo ajpp ajpq ajpr ajps ajpt ajpu +ajpv ajpw ajpx ajpy ajpz ajqa ajqb ajqc ajqd ajqe ajqf ajqg ajqh ajqi ajqj +ajqk ajql ajqm ajqn ajqo ajqp ajqq ajqr ajqs ajqt ajqu ajqv ajqw ajqx ajqy +ajqz ajra ajrb ajrc ajrd ajre ajrf ajrg ajrh ajri ajrj ajrk ajrl ajrm ajrn +ajro ajrp ajrq ajrr ajrs ajrt ajru ajrv ajrw ajrx ajry ajrz ajsa ajsb ajsc +ajsd ajse ajsf ajsg ajsh ajsi ajsj ajsk ajsl ajsm ajsn ajso ajsp ajsq ajsr +ajss ajst ajsu ajsv ajsw ajsx ajsy ajsz ajta ajtb ajtc ajtd ajte ajtf ajtg +ajth ajti ajtj ajtk ajtl ajtm ajtn ajto ajtp ajtq ajtr ajts ajtt ajtu ajtv +ajtw ajtx ajty ajtz ajua ajub ajuc ajud ajue ajuf ajug ajuh ajui ajuj ajuk +ajul ajum ajun ajuo ajup ajuq ajur ajus ajut ajuu ajuv ajuw ajux ajuy ajuz +ajva ajvb ajvc ajvd ajve ajvf ajvg ajvh ajvi ajvj ajvk ajvl ajvm ajvn ajvo +ajvp ajvq ajvr ajvs ajvt ajvu ajvv ajvw ajvx ajvy ajvz ajwa ajwb ajwc ajwd +ajwe ajwf ajwg ajwh ajwi ajwj ajwk ajwl ajwm ajwn ajwo ajwp ajwq ajwr ajws +ajwt ajwu ajwv ajww ajwx ajwy ajwz ajxa ajxb ajxc ajxd ajxe ajxf ajxg ajxh +ajxi ajxj ajxk ajxl ajxm ajxn ajxo ajxp ajxq ajxr ajxs ajxt ajxu ajxv ajxw +ajxx ajxy ajxz ajya ajyb ajyc ajyd ajye ajyf ajyg ajyh ajyi ajyj ajyk ajyl +ajym ajyn ajyo ajyp ajyq ajyr ajys ajyt ajyu ajyv ajyw ajyx ajyy ajyz ajza +ajzb ajzc ajzd ajze ajzf ajzg ajzh ajzi ajzj ajzk ajzl ajzm ajzn ajzo ajzp +ajzq ajzr ajzs ajzt ajzu ajzv ajzw ajzx ajzy ajzz akaa akab akac akad akae +akaf akag akah akai akaj akak akal akam akan akao akap akaq akar akas akat +akau akav akaw akax akay akaz akba akbb akbc akbd akbe akbf akbg akbh akbi +akbj akbk akbl akbm akbn akbo akbp akbq akbr akbs akbt akbu akbv akbw akbx +akby akbz akca akcb akcc akcd akce akcf akcg akch akci akcj akck akcl akcm +akcn akco akcp akcq akcr akcs akct akcu akcv akcw akcx akcy akcz akda akdb +akdc akdd akde akdf akdg akdh akdi akdj akdk akdl akdm akdn akdo akdp akdq +akdr akds akdt akdu akdv akdw akdx akdy akdz akea akeb akec aked akee akef +akeg akeh akei akej akek akel akem aken akeo akep akeq aker akes aket akeu +akev akew akex akey akez akfa akfb akfc akfd akfe akff akfg akfh akfi akfj +akfk akfl akfm akfn akfo akfp akfq akfr akfs akft akfu akfv akfw akfx akfy +akfz akga akgb akgc akgd akge akgf akgg akgh akgi akgj akgk akgl akgm akgn +akgo akgp akgq akgr akgs akgt akgu akgv akgw akgx akgy akgz akha akhb akhc +akhd akhe akhf akhg akhh akhi akhj akhk akhl akhm akhn akho akhp akhq akhr +akhs akht akhu akhv akhw akhx akhy akhz akia akib akic akid akie akif akig +akih akii akij akik akil akim akin akio akip akiq akir akis akit akiu akiv +akiw akix akiy akiz akja akjb akjc akjd akje akjf akjg akjh akji akjj akjk +akjl akjm akjn akjo akjp akjq akjr akjs akjt akju akjv akjw akjx akjy akjz +akka akkb akkc akkd akke akkf akkg akkh akki akkj akkk akkl akkm akkn akko +akkp akkq akkr akks akkt akku akkv akkw akkx akky akkz akla aklb aklc akld +akle aklf aklg aklh akli aklj aklk akll aklm akln aklo aklp aklq aklr akls +aklt aklu aklv aklw aklx akly aklz akma akmb akmc akmd akme akmf akmg akmh +akmi akmj akmk akml akmm akmn akmo akmp akmq akmr akms akmt akmu akmv akmw +akmx akmy akmz akna aknb aknc aknd akne aknf akng aknh akni aknj aknk aknl +aknm aknn akno aknp aknq aknr akns aknt aknu aknv aknw aknx akny aknz akoa +akob akoc akod akoe akof akog akoh akoi akoj akok akol akom akon akoo akop +akoq akor akos akot akou akov akow akox akoy akoz akpa akpb akpc akpd akpe +akpf akpg akph akpi akpj akpk akpl akpm akpn akpo akpp akpq akpr akps akpt +akpu akpv akpw akpx akpy akpz akqa akqb akqc akqd akqe akqf akqg akqh akqi +akqj akqk akql akqm akqn akqo akqp akqq akqr akqs akqt akqu akqv akqw akqx +akqy akqz akra akrb akrc akrd akre akrf akrg akrh akri akrj akrk akrl akrm +akrn akro akrp akrq akrr akrs akrt akru akrv akrw akrx akry akrz aksa aksb +aksc aksd akse aksf aksg aksh aksi aksj aksk aksl aksm aksn akso aksp aksq +aksr akss akst aksu aksv aksw aksx aksy aksz akta aktb aktc aktd akte aktf +aktg akth akti aktj aktk aktl aktm aktn akto aktp aktq aktr akts aktt aktu +aktv aktw aktx akty aktz akua akub akuc akud akue akuf akug akuh akui akuj +akuk akul akum akun akuo akup akuq akur akus akut akuu akuv akuw akux akuy +akuz akva akvb akvc akvd akve akvf akvg akvh akvi akvj akvk akvl akvm akvn +akvo akvp akvq akvr akvs akvt akvu akvv akvw akvx akvy akvz akwa akwb akwc +akwd akwe akwf akwg akwh akwi akwj akwk akwl akwm akwn akwo akwp akwq akwr +akws akwt akwu akwv akww akwx akwy akwz akxa akxb akxc akxd akxe akxf akxg +akxh akxi akxj akxk akxl akxm akxn akxo akxp akxq akxr akxs akxt akxu akxv +akxw akxx akxy akxz akya akyb akyc akyd akye akyf akyg akyh akyi akyj akyk +akyl akym akyn akyo akyp akyq akyr akys akyt akyu akyv akyw akyx akyy akyz +akza akzb akzc akzd akze akzf akzg akzh akzi akzj akzk akzl akzm akzn akzo +akzp akzq akzr akzs akzt akzu akzv akzw akzx akzy akzz alaa alab alac alad +alae alaf alag alah alai alaj alak alal alam alan alao alap alaq alar alas +alat alau alav alaw alax alay alaz alba albb albc albd albe albf albg albh +albi albj albk albl albm albn albo albp albq albr albs albt albu albv albw +albx alby albz alca alcb alcc alcd alce alcf alcg alch alci alcj alck alcl +alcm alcn alco alcp alcq alcr alcs alct alcu alcv alcw alcx alcy alcz alda +aldb aldc aldd alde aldf aldg aldh aldi aldj aldk aldl aldm aldn aldo aldp +aldq aldr alds aldt aldu aldv aldw aldx aldy aldz alea aleb alec aled alee +alef aleg aleh alei alej alek alel alem alen aleo alep aleq aler ales alet +aleu alev alew alex aley alez alfa alfb alfc alfd alfe alff alfg alfh alfi +alfj alfk alfl alfm alfn alfo alfp alfq alfr alfs alft alfu alfv alfw alfx +alfy alfz alga algb algc algd alge algf algg algh algi algj algk algl algm +algn algo algp algq algr algs algt algu algv algw algx algy algz alha alhb +alhc alhd alhe alhf alhg alhh alhi alhj alhk alhl alhm alhn alho alhp alhq +alhr alhs alht alhu alhv alhw alhx alhy alhz alia alib alic alid alie alif +alig alih alii alij alik alil alim alin alio alip aliq alir alis alit aliu +aliv aliw alix aliy aliz alja aljb aljc aljd alje aljf aljg aljh alji aljj +aljk aljl aljm aljn aljo aljp aljq aljr aljs aljt alju aljv aljw aljx aljy +aljz alka alkb alkc alkd alke alkf alkg alkh alki alkj alkk alkl alkm alkn +alko alkp alkq alkr alks alkt alku alkv alkw alkx alky alkz alla allb allc +alld alle allf allg allh alli allj allk alll allm alln allo allp allq allr +alls allt allu allv allw allx ally allz alma almb almc almd alme almf almg +almh almi almj almk alml almm almn almo almp almq almr alms almt almu almv +almw almx almy almz alna alnb alnc alnd alne alnf alng alnh alni alnj alnk +alnl alnm alnn alno alnp alnq alnr alns alnt alnu alnv alnw alnx alny alnz +aloa alob aloc alod aloe alof alog aloh aloi aloj alok alol alom alon aloo +alop aloq alor alos alot alou alov alow alox aloy aloz alpa alpb alpc alpd +alpe alpf alpg alph alpi alpj alpk alpl alpm alpn alpo alpp alpq alpr alps +alpt alpu alpv alpw alpx alpy alpz alqa alqb alqc alqd alqe alqf alqg alqh +alqi alqj alqk alql alqm alqn alqo alqp alqq alqr alqs alqt alqu alqv alqw +alqx alqy alqz alra alrb alrc alrd alre alrf alrg alrh alri alrj alrk alrl +alrm alrn alro alrp alrq alrr alrs alrt alru alrv alrw alrx alry alrz alsa +alsb alsc alsd alse alsf alsg alsh alsi alsj alsk alsl alsm alsn also alsp +alsq alsr alss alst alsu alsv alsw alsx alsy alsz alta altb altc altd alte +altf altg alth alti altj altk altl altm altn alto altp altq altr alts altt +altu altv altw altx alty altz alua alub aluc alud alue aluf alug aluh alui +aluj aluk alul alum alun aluo alup aluq alur alus alut aluu aluv aluw alux +aluy aluz alva alvb alvc alvd alve alvf alvg alvh alvi alvj alvk alvl alvm +alvn alvo alvp alvq alvr alvs alvt alvu alvv alvw alvx alvy alvz alwa alwb +alwc alwd alwe alwf alwg alwh alwi alwj alwk alwl alwm alwn alwo alwp alwq +alwr alws alwt alwu alwv alww alwx alwy alwz alxa alxb alxc alxd alxe alxf +alxg alxh alxi alxj alxk alxl alxm alxn alxo alxp alxq alxr alxs alxt alxu +alxv alxw alxx alxy alxz alya alyb alyc alyd alye alyf alyg alyh alyi alyj +alyk alyl alym alyn alyo alyp alyq alyr alys alyt alyu alyv alyw alyx alyy +alyz alza alzb alzc alzd alze alzf alzg alzh alzi alzj alzk alzl alzm alzn +alzo alzp alzq alzr alzs alzt alzu alzv alzw alzx alzy alzz amaa amab amac +amad amae amaf amag amah amai amaj amak amal amam aman amao amap amaq amar +amas amat amau amav amaw amax amay amaz amba ambb ambc ambd ambe ambf ambg +ambh ambi ambj ambk ambl ambm ambn ambo ambp ambq ambr ambs ambt ambu ambv +ambw ambx amby ambz amca amcb amcc amcd amce amcf amcg amch amci amcj amck +amcl amcm amcn amco amcp amcq amcr amcs amct amcu amcv amcw amcx amcy amcz +amda amdb amdc amdd amde amdf amdg amdh amdi amdj amdk amdl amdm amdn amdo +amdp amdq amdr amds amdt amdu amdv amdw amdx amdy amdz amea ameb amec amed +amee amef ameg ameh amei amej amek amel amem amen ameo amep ameq amer ames +amet ameu amev amew amex amey amez amfa amfb amfc amfd amfe amff amfg amfh +amfi amfj amfk amfl amfm amfn amfo amfp amfq amfr amfs amft amfu amfv amfw +amfx amfy amfz amga amgb amgc amgd amge amgf amgg amgh amgi amgj amgk amgl +amgm amgn amgo amgp amgq amgr amgs amgt amgu amgv amgw amgx amgy amgz amha +amhb amhc amhd amhe amhf amhg amhh amhi amhj amhk amhl amhm amhn amho amhp +amhq amhr amhs amht amhu amhv amhw amhx amhy amhz amia amib amic amid amie +amif amig amih amii amij amik amil amim amin amio amip amiq amir amis amit +amiu amiv amiw amix amiy amiz amja amjb amjc amjd amje amjf amjg amjh amji +amjj amjk amjl amjm amjn amjo amjp amjq amjr amjs amjt amju amjv amjw amjx +amjy amjz amka amkb amkc amkd amke amkf amkg amkh amki amkj amkk amkl amkm +amkn amko amkp amkq amkr amks amkt amku amkv amkw amkx amky amkz amla amlb +amlc amld amle amlf amlg amlh amli amlj amlk amll amlm amln amlo amlp amlq +amlr amls amlt amlu amlv amlw amlx amly amlz amma ammb ammc ammd amme ammf +ammg ammh ammi ammj ammk amml ammm ammn ammo ammp ammq ammr amms ammt ammu +ammv ammw ammx ammy ammz amna amnb amnc amnd amne amnf amng amnh amni amnj +amnk amnl amnm amnn amno amnp amnq amnr amns amnt amnu amnv amnw amnx amny +amnz amoa amob amoc amod amoe amof amog amoh amoi amoj amok amol amom amon +amoo amop amoq amor amos amot amou amov amow amox amoy amoz ampa ampb ampc +ampd ampe ampf ampg amph ampi ampj ampk ampl ampm ampn ampo ampp ampq ampr +amps ampt ampu ampv ampw ampx ampy ampz amqa amqb amqc amqd amqe amqf amqg +amqh amqi amqj amqk amql amqm amqn amqo amqp amqq amqr amqs amqt amqu amqv +amqw amqx amqy amqz amra amrb amrc amrd amre amrf amrg amrh amri amrj amrk +amrl amrm amrn amro amrp amrq amrr amrs amrt amru amrv amrw amrx amry amrz +amsa amsb amsc amsd amse amsf amsg amsh amsi amsj amsk amsl amsm amsn amso +amsp amsq amsr amss amst amsu amsv amsw amsx amsy amsz amta amtb amtc amtd +amte amtf amtg amth amti amtj amtk amtl amtm amtn amto amtp amtq amtr amts +amtt amtu amtv amtw amtx amty amtz amua amub amuc amud amue amuf amug amuh +amui amuj amuk amul amum amun amuo amup amuq amur amus amut amuu amuv amuw +amux amuy amuz amva amvb amvc amvd amve amvf amvg amvh amvi amvj amvk amvl +amvm amvn amvo amvp amvq amvr amvs amvt amvu amvv amvw amvx amvy amvz amwa +amwb amwc amwd amwe amwf amwg amwh amwi amwj amwk amwl amwm amwn amwo amwp +amwq amwr amws amwt amwu amwv amww amwx amwy amwz amxa amxb amxc amxd amxe +amxf amxg amxh amxi amxj amxk amxl amxm amxn amxo amxp amxq amxr amxs amxt +amxu amxv amxw amxx amxy amxz amya amyb amyc amyd amye amyf amyg amyh amyi +amyj amyk amyl amym amyn amyo amyp amyq amyr amys amyt amyu amyv amyw amyx +amyy amyz amza amzb amzc amzd amze amzf amzg amzh amzi amzj amzk amzl amzm +amzn amzo amzp amzq amzr amzs amzt amzu amzv amzw amzx amzy amzz anaa anab +anac anad anae anaf anag anah anai anaj anak anal anam anan anao anap anaq +anar anas anat anau anav anaw anax anay anaz anba anbb anbc anbd anbe anbf +anbg anbh anbi anbj anbk anbl anbm anbn anbo anbp anbq anbr anbs anbt anbu +anbv anbw anbx anby anbz anca ancb ancc ancd ance ancf ancg anch anci ancj +anck ancl ancm ancn anco ancp ancq ancr ancs anct ancu ancv ancw ancx ancy +ancz anda andb andc andd ande andf andg andh andi andj andk andl andm andn +ando andp andq andr ands andt andu andv andw andx andy andz anea aneb anec +aned anee anef aneg aneh anei anej anek anel anem anen aneo anep aneq aner +anes anet aneu anev anew anex aney anez anfa anfb anfc anfd anfe anff anfg +anfh anfi anfj anfk anfl anfm anfn anfo anfp anfq anfr anfs anft anfu anfv +anfw anfx anfy anfz anga angb angc angd ange angf angg angh angi angj angk +angl angm angn ango angp angq angr angs angt angu angv angw angx angy angz +anha anhb anhc anhd anhe anhf anhg anhh anhi anhj anhk anhl anhm anhn anho +anhp anhq anhr anhs anht anhu anhv anhw anhx anhy anhz ania anib anic anid +anie anif anig anih anii anij anik anil anim anin anio anip aniq anir anis +anit aniu aniv aniw anix aniy aniz anja anjb anjc anjd anje anjf anjg anjh +anji anjj anjk anjl anjm anjn anjo anjp anjq anjr anjs anjt anju anjv anjw +anjx anjy anjz anka ankb ankc ankd anke ankf ankg ankh anki ankj ankk ankl +ankm ankn anko ankp ankq ankr anks ankt anku ankv ankw ankx anky ankz anla +anlb anlc anld anle anlf anlg anlh anli anlj anlk anll anlm anln anlo anlp +anlq anlr anls anlt anlu anlv anlw anlx anly anlz anma anmb anmc anmd anme +anmf anmg anmh anmi anmj anmk anml anmm anmn anmo anmp anmq anmr anms anmt +anmu anmv anmw anmx anmy anmz anna annb annc annd anne annf anng annh anni +annj annk annl annm annn anno annp annq annr anns annt annu annv annw annx +anny annz anoa anob anoc anod anoe anof anog anoh anoi anoj anok anol anom +anon anoo anop anoq anor anos anot anou anov anow anox anoy anoz anpa anpb +anpc anpd anpe anpf anpg anph anpi anpj anpk anpl anpm anpn anpo anpp anpq +anpr anps anpt anpu anpv anpw anpx anpy anpz anqa anqb anqc anqd anqe anqf +anqg anqh anqi anqj anqk anql anqm anqn anqo anqp anqq anqr anqs anqt anqu +anqv anqw anqx anqy anqz anra anrb anrc anrd anre anrf anrg anrh anri anrj +anrk anrl anrm anrn anro anrp anrq anrr anrs anrt anru anrv anrw anrx anry +anrz ansa ansb ansc ansd anse ansf ansg ansh ansi ansj ansk ansl ansm ansn +anso ansp ansq ansr anss anst ansu ansv answ ansx ansy ansz anta antb antc +antd ante antf antg anth anti antj antk antl antm antn anto antp antq antr +ants antt antu antv antw antx anty antz anua anub anuc anud anue anuf anug +anuh anui anuj anuk anul anum anun anuo anup anuq anur anus anut anuu anuv +anuw anux anuy anuz anva anvb anvc anvd anve anvf anvg anvh anvi anvj anvk +anvl anvm anvn anvo anvp anvq anvr anvs anvt anvu anvv anvw anvx anvy anvz +anwa anwb anwc anwd anwe anwf anwg anwh anwi anwj anwk anwl anwm anwn anwo +anwp anwq anwr anws anwt anwu anwv anww anwx anwy anwz anxa anxb anxc anxd +anxe anxf anxg anxh anxi anxj anxk anxl anxm anxn anxo anxp anxq anxr anxs +anxt anxu anxv anxw anxx anxy anxz anya anyb anyc anyd anye anyf anyg anyh +anyi anyj anyk anyl anym anyn anyo anyp anyq anyr anys anyt anyu anyv anyw +anyx anyy anyz anza anzb anzc anzd anze anzf anzg anzh anzi anzj anzk anzl +anzm anzn anzo anzp anzq anzr anzs anzt anzu anzv anzw anzx anzy anzz aoaa +aoab aoac aoad aoae aoaf aoag aoah aoai aoaj aoak aoal aoam aoan aoao aoap +aoaq aoar aoas aoat aoau aoav aoaw aoax aoay aoaz aoba aobb aobc aobd aobe +aobf aobg aobh aobi aobj aobk aobl aobm aobn aobo aobp aobq aobr aobs aobt +aobu aobv aobw aobx aoby aobz aoca aocb aocc aocd aoce aocf aocg aoch aoci +aocj aock aocl aocm aocn aoco aocp aocq aocr aocs aoct aocu aocv aocw aocx +aocy aocz aoda aodb aodc aodd aode aodf aodg aodh aodi aodj aodk aodl aodm +aodn aodo aodp aodq aodr aods aodt aodu aodv aodw aodx aody aodz aoea aoeb +aoec aoed aoee aoef aoeg aoeh aoei aoej aoek aoel aoem aoen aoeo aoep aoeq +aoer aoes aoet aoeu aoev aoew aoex aoey aoez aofa aofb aofc aofd aofe aoff +aofg aofh aofi aofj aofk aofl aofm aofn aofo aofp aofq aofr aofs aoft aofu +aofv aofw aofx aofy aofz aoga aogb aogc aogd aoge aogf aogg aogh aogi aogj +aogk aogl aogm aogn aogo aogp aogq aogr aogs aogt aogu aogv aogw aogx aogy +aogz aoha aohb aohc aohd aohe aohf aohg aohh aohi aohj aohk aohl aohm aohn +aoho aohp aohq aohr aohs aoht aohu aohv aohw aohx aohy aohz aoia aoib aoic +aoid aoie aoif aoig aoih aoii aoij aoik aoil aoim aoin aoio aoip aoiq aoir +aois aoit aoiu aoiv aoiw aoix aoiy aoiz aoja aojb aojc aojd aoje aojf aojg +aojh aoji aojj aojk aojl aojm aojn aojo aojp aojq aojr aojs aojt aoju aojv +aojw aojx aojy aojz aoka aokb aokc aokd aoke aokf aokg aokh aoki aokj aokk +aokl aokm aokn aoko aokp aokq aokr aoks aokt aoku aokv aokw aokx aoky aokz +aola aolb aolc aold aole aolf aolg aolh aoli aolj aolk aoll aolm aoln aolo +aolp aolq aolr aols aolt aolu aolv aolw aolx aoly aolz aoma aomb aomc aomd +aome aomf aomg aomh aomi aomj aomk aoml aomm aomn aomo aomp aomq aomr aoms +aomt aomu aomv aomw aomx aomy aomz aona aonb aonc aond aone aonf aong aonh +aoni aonj aonk aonl aonm aonn aono aonp aonq aonr aons aont aonu aonv aonw +aonx aony aonz aooa aoob aooc aood aooe aoof aoog aooh aooi aooj aook aool +aoom aoon aooo aoop aooq aoor aoos aoot aoou aoov aoow aoox aooy aooz aopa +aopb aopc aopd aope aopf aopg aoph aopi aopj aopk aopl aopm aopn aopo aopp +aopq aopr aops aopt aopu aopv aopw aopx aopy aopz aoqa aoqb aoqc aoqd aoqe +aoqf aoqg aoqh aoqi aoqj aoqk aoql aoqm aoqn aoqo aoqp aoqq aoqr aoqs aoqt +aoqu aoqv aoqw aoqx aoqy aoqz aora aorb aorc aord aore aorf aorg aorh aori +aorj aork aorl aorm aorn aoro aorp aorq aorr aors aort aoru aorv aorw aorx +aory aorz aosa aosb aosc aosd aose aosf aosg aosh aosi aosj aosk aosl aosm +aosn aoso aosp aosq aosr aoss aost aosu aosv aosw aosx aosy aosz aota aotb +aotc aotd aote aotf aotg aoth aoti aotj aotk aotl aotm aotn aoto aotp aotq +aotr aots aott aotu aotv aotw aotx aoty aotz aoua aoub aouc aoud aoue aouf +aoug aouh aoui aouj aouk aoul aoum aoun aouo aoup aouq aour aous aout aouu +aouv aouw aoux aouy aouz aova aovb aovc aovd aove aovf aovg aovh aovi aovj +aovk aovl aovm aovn aovo aovp aovq aovr aovs aovt aovu aovv aovw aovx aovy +aovz aowa aowb aowc aowd aowe aowf aowg aowh aowi aowj aowk aowl aowm aown +aowo aowp aowq aowr aows aowt aowu aowv aoww aowx aowy aowz aoxa aoxb aoxc +aoxd aoxe aoxf aoxg aoxh aoxi aoxj aoxk aoxl aoxm aoxn aoxo aoxp aoxq aoxr +aoxs aoxt aoxu aoxv aoxw aoxx aoxy aoxz aoya aoyb aoyc aoyd aoye aoyf aoyg +aoyh aoyi aoyj aoyk aoyl aoym aoyn aoyo aoyp aoyq aoyr aoys aoyt aoyu aoyv +aoyw aoyx aoyy aoyz aoza aozb aozc aozd aoze aozf aozg aozh aozi aozj aozk +aozl aozm aozn aozo aozp aozq aozr aozs aozt aozu aozv aozw aozx aozy aozz +apaa apab apac apad apae apaf apag apah apai apaj apak apal apam apan apao +apap apaq apar apas apat apau apav apaw apax apay apaz apba apbb apbc apbd +apbe apbf apbg apbh apbi apbj apbk apbl apbm apbn apbo apbp apbq apbr apbs +apbt apbu apbv apbw apbx apby apbz apca apcb apcc apcd apce apcf apcg apch +apci apcj apck apcl apcm apcn apco apcp apcq apcr apcs apct apcu apcv apcw +apcx apcy apcz apda apdb apdc apdd apde apdf apdg apdh apdi apdj apdk apdl +apdm apdn apdo apdp apdq apdr apds apdt apdu apdv apdw apdx apdy apdz apea +apeb apec aped apee apef apeg apeh apei apej apek apel apem apen apeo apep +apeq aper apes apet apeu apev apew apex apey apez apfa apfb apfc apfd apfe +apff apfg apfh apfi apfj apfk apfl apfm apfn apfo apfp apfq apfr apfs apft +apfu apfv apfw apfx apfy apfz apga apgb apgc apgd apge apgf apgg apgh apgi +apgj apgk apgl apgm apgn apgo apgp apgq apgr apgs apgt apgu apgv apgw apgx +apgy apgz apha aphb aphc aphd aphe aphf aphg aphh aphi aphj aphk aphl aphm +aphn apho aphp aphq aphr aphs apht aphu aphv aphw aphx aphy aphz apia apib +apic apid apie apif apig apih apii apij apik apil apim apin apio apip apiq +apir apis apit apiu apiv apiw apix apiy apiz apja apjb apjc apjd apje apjf +apjg apjh apji apjj apjk apjl apjm apjn apjo apjp apjq apjr apjs apjt apju +apjv apjw apjx apjy apjz apka apkb apkc apkd apke apkf apkg apkh apki apkj +apkk apkl apkm apkn apko apkp apkq apkr apks apkt apku apkv apkw apkx apky +apkz apla aplb aplc apld aple aplf aplg aplh apli aplj aplk apll aplm apln +aplo aplp aplq aplr apls aplt aplu aplv aplw aplx aply aplz apma apmb apmc +apmd apme apmf apmg apmh apmi apmj apmk apml apmm apmn apmo apmp apmq apmr +apms apmt apmu apmv apmw apmx apmy apmz apna apnb apnc apnd apne apnf apng +apnh apni apnj apnk apnl apnm apnn apno apnp apnq apnr apns apnt apnu apnv +apnw apnx apny apnz apoa apob apoc apod apoe apof apog apoh apoi apoj apok +apol apom apon apoo apop apoq apor apos apot apou apov apow apox apoy apoz +appa appb appc appd appe appf appg apph appi appj appk appl appm appn appo +appp appq appr apps appt appu appv appw appx appy appz apqa apqb apqc apqd +apqe apqf apqg apqh apqi apqj apqk apql apqm apqn apqo apqp apqq apqr apqs +apqt apqu apqv apqw apqx apqy apqz apra aprb aprc aprd apre aprf aprg aprh +apri aprj aprk aprl aprm aprn apro aprp aprq aprr aprs aprt apru aprv aprw +aprx apry aprz apsa apsb apsc apsd apse apsf apsg apsh apsi apsj apsk apsl +apsm apsn apso apsp apsq apsr apss apst apsu apsv apsw apsx apsy apsz apta +aptb aptc aptd apte aptf aptg apth apti aptj aptk aptl aptm aptn apto aptp +aptq aptr apts aptt aptu aptv aptw aptx apty aptz apua apub apuc apud apue +apuf apug apuh apui apuj apuk apul apum apun apuo apup apuq apur apus aput +apuu apuv apuw apux apuy apuz apva apvb apvc apvd apve apvf apvg apvh apvi +apvj apvk apvl apvm apvn apvo apvp apvq apvr apvs apvt apvu apvv apvw apvx +apvy apvz apwa apwb apwc apwd apwe apwf apwg apwh apwi apwj apwk apwl apwm +apwn apwo apwp apwq apwr apws apwt apwu apwv apww apwx apwy apwz apxa apxb +apxc apxd apxe apxf apxg apxh apxi apxj apxk apxl apxm apxn apxo apxp apxq +apxr apxs apxt apxu apxv apxw apxx apxy apxz apya apyb apyc apyd apye apyf +apyg apyh apyi apyj apyk apyl apym apyn apyo apyp apyq apyr apys apyt apyu +apyv apyw apyx apyy apyz apza apzb apzc apzd apze apzf apzg apzh apzi apzj +apzk apzl apzm apzn apzo apzp apzq apzr apzs apzt apzu apzv apzw apzx apzy +apzz aqaa aqab aqac aqad aqae aqaf aqag aqah aqai aqaj aqak aqal aqam aqan +aqao aqap aqaq aqar aqas aqat aqau aqav aqaw aqax aqay aqaz aqba aqbb aqbc +aqbd aqbe aqbf aqbg aqbh aqbi aqbj aqbk aqbl aqbm aqbn aqbo aqbp aqbq aqbr +aqbs aqbt aqbu aqbv aqbw aqbx aqby aqbz aqca aqcb aqcc aqcd aqce aqcf aqcg +aqch aqci aqcj aqck aqcl aqcm aqcn aqco aqcp aqcq aqcr aqcs aqct aqcu aqcv +aqcw aqcx aqcy aqcz aqda aqdb aqdc aqdd aqde aqdf aqdg aqdh aqdi aqdj aqdk +aqdl aqdm aqdn aqdo aqdp aqdq aqdr aqds aqdt aqdu aqdv aqdw aqdx aqdy aqdz +aqea aqeb aqec aqed aqee aqef aqeg aqeh aqei aqej aqek aqel aqem aqen aqeo +aqep aqeq aqer aqes aqet aqeu aqev aqew aqex aqey aqez aqfa aqfb aqfc aqfd +aqfe aqff aqfg aqfh aqfi aqfj aqfk aqfl aqfm aqfn aqfo aqfp aqfq aqfr aqfs +aqft aqfu aqfv aqfw aqfx aqfy aqfz aqga aqgb aqgc aqgd aqge aqgf aqgg aqgh +aqgi aqgj aqgk aqgl aqgm aqgn aqgo aqgp aqgq aqgr aqgs aqgt aqgu aqgv aqgw +aqgx aqgy aqgz aqha aqhb aqhc aqhd aqhe aqhf aqhg aqhh aqhi aqhj aqhk aqhl +aqhm aqhn aqho aqhp aqhq aqhr aqhs aqht aqhu aqhv aqhw aqhx aqhy aqhz aqia +aqib aqic aqid aqie aqif aqig aqih aqii aqij aqik aqil aqim aqin aqio aqip +aqiq aqir aqis aqit aqiu aqiv aqiw aqix aqiy aqiz aqja aqjb aqjc aqjd aqje +aqjf aqjg aqjh aqji aqjj aqjk aqjl aqjm aqjn aqjo aqjp aqjq aqjr aqjs aqjt +aqju aqjv aqjw aqjx aqjy aqjz aqka aqkb aqkc aqkd aqke aqkf aqkg aqkh aqki +aqkj aqkk aqkl aqkm aqkn aqko aqkp aqkq aqkr aqks aqkt aqku aqkv aqkw aqkx +aqky aqkz aqla aqlb aqlc aqld aqle aqlf aqlg aqlh aqli aqlj aqlk aqll aqlm +aqln aqlo aqlp aqlq aqlr aqls aqlt aqlu aqlv aqlw aqlx aqly aqlz aqma aqmb +aqmc aqmd aqme aqmf aqmg aqmh aqmi aqmj aqmk aqml aqmm aqmn aqmo aqmp aqmq +aqmr aqms aqmt aqmu aqmv aqmw aqmx aqmy aqmz aqna aqnb aqnc aqnd aqne aqnf +aqng aqnh aqni aqnj aqnk aqnl aqnm aqnn aqno aqnp aqnq aqnr aqns aqnt aqnu +aqnv aqnw aqnx aqny aqnz aqoa aqob aqoc aqod aqoe aqof aqog aqoh aqoi aqoj +aqok aqol aqom aqon aqoo aqop aqoq aqor aqos aqot aqou aqov aqow aqox aqoy +aqoz aqpa aqpb aqpc aqpd aqpe aqpf aqpg aqph aqpi aqpj aqpk aqpl aqpm aqpn +aqpo aqpp aqpq aqpr aqps aqpt aqpu aqpv aqpw aqpx aqpy aqpz aqqa aqqb aqqc +aqqd aqqe aqqf aqqg aqqh aqqi aqqj aqqk aqql aqqm aqqn aqqo aqqp aqqq aqqr +aqqs aqqt aqqu aqqv aqqw aqqx aqqy aqqz aqra aqrb aqrc aqrd aqre aqrf aqrg +aqrh aqri aqrj aqrk aqrl aqrm aqrn aqro aqrp aqrq aqrr aqrs aqrt aqru aqrv +aqrw aqrx aqry aqrz aqsa aqsb aqsc aqsd aqse aqsf aqsg aqsh aqsi aqsj aqsk +aqsl aqsm aqsn aqso aqsp aqsq aqsr aqss aqst aqsu aqsv aqsw aqsx aqsy aqsz +aqta aqtb aqtc aqtd aqte aqtf aqtg aqth aqti aqtj aqtk aqtl aqtm aqtn aqto +aqtp aqtq aqtr aqts aqtt aqtu aqtv aqtw aqtx aqty aqtz aqua aqub aquc aqud +aque aquf aqug aquh aqui aquj aquk aqul aqum aqun aquo aqup aquq aqur aqus +aqut aquu aquv aquw aqux aquy aquz aqva aqvb aqvc aqvd aqve aqvf aqvg aqvh +aqvi aqvj aqvk aqvl aqvm aqvn aqvo aqvp aqvq aqvr aqvs aqvt aqvu aqvv aqvw +aqvx aqvy aqvz aqwa aqwb aqwc aqwd aqwe aqwf aqwg aqwh aqwi aqwj aqwk aqwl +aqwm aqwn aqwo aqwp aqwq aqwr aqws aqwt aqwu aqwv aqww aqwx aqwy aqwz aqxa +aqxb aqxc aqxd aqxe aqxf aqxg aqxh aqxi aqxj aqxk aqxl aqxm aqxn aqxo aqxp +aqxq aqxr aqxs aqxt aqxu aqxv aqxw aqxx aqxy aqxz aqya aqyb aqyc aqyd aqye +aqyf aqyg aqyh aqyi aqyj aqyk aqyl aqym aqyn aqyo aqyp aqyq aqyr aqys aqyt +aqyu aqyv aqyw aqyx aqyy aqyz aqza aqzb aqzc aqzd aqze aqzf aqzg aqzh aqzi +aqzj aqzk aqzl aqzm aqzn aqzo aqzp aqzq aqzr aqzs aqzt aqzu aqzv aqzw aqzx +aqzy aqzz araa arab arac arad arae araf arag arah arai araj arak aral aram +aran arao arap araq arar aras arat arau arav araw arax aray araz arba arbb +arbc arbd arbe arbf arbg arbh arbi arbj arbk arbl arbm arbn arbo arbp arbq +arbr arbs arbt arbu arbv arbw arbx arby arbz arca arcb arcc arcd arce arcf +arcg arch arci arcj arck arcl arcm arcn arco arcp arcq arcr arcs arct arcu +arcv arcw arcx arcy arcz arda ardb ardc ardd arde ardf ardg ardh ardi ardj +ardk ardl ardm ardn ardo ardp ardq ardr ards ardt ardu ardv ardw ardx ardy +ardz area areb arec ared aree aref areg areh arei arej arek arel arem aren +areo arep areq arer ares aret areu arev arew arex arey arez arfa arfb arfc +arfd arfe arff arfg arfh arfi arfj arfk arfl arfm arfn arfo arfp arfq arfr +arfs arft arfu arfv arfw arfx arfy arfz arga argb argc argd arge argf argg +argh argi argj argk argl argm argn argo argp argq argr args argt argu argv +argw argx argy argz arha arhb arhc arhd arhe arhf arhg arhh arhi arhj arhk +arhl arhm arhn arho arhp arhq arhr arhs arht arhu arhv arhw arhx arhy arhz +aria arib aric arid arie arif arig arih arii arij arik aril arim arin ario +arip ariq arir aris arit ariu ariv ariw arix ariy ariz arja arjb arjc arjd +arje arjf arjg arjh arji arjj arjk arjl arjm arjn arjo arjp arjq arjr arjs +arjt arju arjv arjw arjx arjy arjz arka arkb arkc arkd arke arkf arkg arkh +arki arkj arkk arkl arkm arkn arko arkp arkq arkr arks arkt arku arkv arkw +arkx arky arkz arla arlb arlc arld arle arlf arlg arlh arli arlj arlk arll +arlm arln arlo arlp arlq arlr arls arlt arlu arlv arlw arlx arly arlz arma +armb armc armd arme armf armg armh armi armj armk arml armm armn armo armp +armq armr arms armt armu armv armw armx army armz arna arnb arnc arnd arne +arnf arng arnh arni arnj arnk arnl arnm arnn arno arnp arnq arnr arns arnt +arnu arnv arnw arnx arny arnz aroa arob aroc arod aroe arof arog aroh aroi +aroj arok arol arom aron aroo arop aroq aror aros arot arou arov arow arox +aroy aroz arpa arpb arpc arpd arpe arpf arpg arph arpi arpj arpk arpl arpm +arpn arpo arpp arpq arpr arps arpt arpu arpv arpw arpx arpy arpz arqa arqb +arqc arqd arqe arqf arqg arqh arqi arqj arqk arql arqm arqn arqo arqp arqq +arqr arqs arqt arqu arqv arqw arqx arqy arqz arra arrb arrc arrd arre arrf +arrg arrh arri arrj arrk arrl arrm arrn arro arrp arrq arrr arrs arrt arru +arrv arrw arrx arry arrz arsa arsb arsc arsd arse arsf arsg arsh arsi arsj +arsk arsl arsm arsn arso arsp arsq arsr arss arst arsu arsv arsw arsx arsy +arsz arta artb artc artd arte artf artg arth arti artj artk artl artm artn +arto artp artq artr arts artt artu artv artw artx arty artz arua arub aruc +arud arue aruf arug aruh arui aruj aruk arul arum arun aruo arup aruq arur +arus arut aruu aruv aruw arux aruy aruz arva arvb arvc arvd arve arvf arvg +arvh arvi arvj arvk arvl arvm arvn arvo arvp arvq arvr arvs arvt arvu arvv +arvw arvx arvy arvz arwa arwb arwc arwd arwe arwf arwg arwh arwi arwj arwk +arwl arwm arwn arwo arwp arwq arwr arws arwt arwu arwv arww arwx arwy arwz +arxa arxb arxc arxd arxe arxf arxg arxh arxi arxj arxk arxl arxm arxn arxo +arxp arxq arxr arxs arxt arxu arxv arxw arxx arxy arxz arya aryb aryc aryd +arye aryf aryg aryh aryi aryj aryk aryl arym aryn aryo aryp aryq aryr arys +aryt aryu aryv aryw aryx aryy aryz arza arzb arzc arzd arze arzf arzg arzh +arzi arzj arzk arzl arzm arzn arzo arzp arzq arzr arzs arzt arzu arzv arzw +arzx arzy arzz asaa asab asac asad asae asaf asag asah asai asaj asak asal +asam asan asao asap asaq asar asas asat asau asav asaw asax asay asaz asba +asbb asbc asbd asbe asbf asbg asbh asbi asbj asbk asbl asbm asbn asbo asbp +asbq asbr asbs asbt asbu asbv asbw asbx asby asbz asca ascb ascc ascd asce +ascf ascg asch asci ascj asck ascl ascm ascn asco ascp ascq ascr ascs asct +ascu ascv ascw ascx ascy ascz asda asdb asdc asdd asde asdf asdg asdh asdi +asdj asdk asdl asdm asdn asdo asdp asdq asdr asds asdt asdu asdv asdw asdx +asdy asdz asea aseb asec ased asee asef aseg aseh asei asej asek asel asem +asen aseo asep aseq aser ases aset aseu asev asew asex asey asez asfa asfb +asfc asfd asfe asff asfg asfh asfi asfj asfk asfl asfm asfn asfo asfp asfq +asfr asfs asft asfu asfv asfw asfx asfy asfz asga asgb asgc asgd asge asgf +asgg asgh asgi asgj asgk asgl asgm asgn asgo asgp asgq asgr asgs asgt asgu +asgv asgw asgx asgy asgz asha ashb ashc ashd ashe ashf ashg ashh ashi ashj +ashk ashl ashm ashn asho ashp ashq ashr ashs asht ashu ashv ashw ashx ashy +ashz asia asib asic asid asie asif asig asih asii asij asik asil asim asin +asio asip asiq asir asis asit asiu asiv asiw asix asiy asiz asja asjb asjc +asjd asje asjf asjg asjh asji asjj asjk asjl asjm asjn asjo asjp asjq asjr +asjs asjt asju asjv asjw asjx asjy asjz aska askb askc askd aske askf askg +askh aski askj askk askl askm askn asko askp askq askr asks askt asku askv +askw askx asky askz asla aslb aslc asld asle aslf aslg aslh asli aslj aslk +asll aslm asln aslo aslp aslq aslr asls aslt aslu aslv aslw aslx asly aslz +asma asmb asmc asmd asme asmf asmg asmh asmi asmj asmk asml asmm asmn asmo +asmp asmq asmr asms asmt asmu asmv asmw asmx asmy asmz asna asnb asnc asnd +asne asnf asng asnh asni asnj asnk asnl asnm asnn asno asnp asnq asnr asns +asnt asnu asnv asnw asnx asny asnz asoa asob asoc asod asoe asof asog asoh +asoi asoj asok asol asom ason asoo asop asoq asor asos asot asou asov asow +asox asoy asoz aspa aspb aspc aspd aspe aspf aspg asph aspi aspj aspk aspl +aspm aspn aspo aspp aspq aspr asps aspt aspu aspv aspw aspx aspy aspz asqa +asqb asqc asqd asqe asqf asqg asqh asqi asqj asqk asql asqm asqn asqo asqp +asqq asqr asqs asqt asqu asqv asqw asqx asqy asqz asra asrb asrc asrd asre +asrf asrg asrh asri asrj asrk asrl asrm asrn asro asrp asrq asrr asrs asrt +asru asrv asrw asrx asry asrz assa assb assc assd asse assf assg assh assi +assj assk assl assm assn asso assp assq assr asss asst assu assv assw assx +assy assz asta astb astc astd aste astf astg asth asti astj astk astl astm +astn asto astp astq astr asts astt astu astv astw astx asty astz asua asub +asuc asud asue asuf asug asuh asui asuj asuk asul asum asun asuo asup asuq +asur asus asut asuu asuv asuw asux asuy asuz asva asvb asvc asvd asve asvf +asvg asvh asvi asvj asvk asvl asvm asvn asvo asvp asvq asvr asvs asvt asvu +asvv asvw asvx asvy asvz aswa aswb aswc aswd aswe aswf aswg aswh aswi aswj +aswk aswl aswm aswn aswo aswp aswq aswr asws aswt aswu aswv asww aswx aswy +aswz asxa asxb asxc asxd asxe asxf asxg asxh asxi asxj asxk asxl asxm asxn +asxo asxp asxq asxr asxs asxt asxu asxv asxw asxx asxy asxz asya asyb asyc +asyd asye asyf asyg asyh asyi asyj asyk asyl asym asyn asyo asyp asyq asyr +asys asyt asyu asyv asyw asyx asyy asyz asza aszb aszc aszd asze aszf aszg +aszh aszi aszj aszk aszl aszm aszn aszo aszp aszq aszr aszs aszt aszu aszv +aszw aszx aszy aszz ataa atab atac atad atae ataf atag atah atai ataj atak +atal atam atan atao atap ataq atar atas atat atau atav ataw atax atay ataz +atba atbb atbc atbd atbe atbf atbg atbh atbi atbj atbk atbl atbm atbn atbo +atbp atbq atbr atbs atbt atbu atbv atbw atbx atby atbz atca atcb atcc atcd +atce atcf atcg atch atci atcj atck atcl atcm atcn atco atcp atcq atcr atcs +atct atcu atcv atcw atcx atcy atcz atda atdb atdc atdd atde atdf atdg atdh +atdi atdj atdk atdl atdm atdn atdo atdp atdq atdr atds atdt atdu atdv atdw +atdx atdy atdz atea ateb atec ated atee atef ateg ateh atei atej atek atel +atem aten ateo atep ateq ater ates atet ateu atev atew atex atey atez atfa +atfb atfc atfd atfe atff atfg atfh atfi atfj atfk atfl atfm atfn atfo atfp +atfq atfr atfs atft atfu atfv atfw atfx atfy atfz atga atgb atgc atgd atge +atgf atgg atgh atgi atgj atgk atgl atgm atgn atgo atgp atgq atgr atgs atgt +atgu atgv atgw atgx atgy atgz atha athb athc athd athe athf athg athh athi +athj athk athl athm athn atho athp athq athr aths atht athu athv athw athx +athy athz atia atib atic atid atie atif atig atih atii atij atik atil atim +atin atio atip atiq atir atis atit atiu ativ atiw atix atiy atiz atja atjb +atjc atjd atje atjf atjg atjh atji atjj atjk atjl atjm atjn atjo atjp atjq +atjr atjs atjt atju atjv atjw atjx atjy atjz atka atkb atkc atkd atke atkf +atkg atkh atki atkj atkk atkl atkm atkn atko atkp atkq atkr atks atkt atku +atkv atkw atkx atky atkz atla atlb atlc atld atle atlf atlg atlh atli atlj +atlk atll atlm atln atlo atlp atlq atlr atls atlt atlu atlv atlw atlx atly +atlz atma atmb atmc atmd atme atmf atmg atmh atmi atmj atmk atml atmm atmn +atmo atmp atmq atmr atms atmt atmu atmv atmw atmx atmy atmz atna atnb atnc +atnd atne atnf atng atnh atni atnj atnk atnl atnm atnn atno atnp atnq atnr +atns atnt atnu atnv atnw atnx atny atnz atoa atob atoc atod atoe atof atog +atoh atoi atoj atok atol atom aton atoo atop atoq ator atos atot atou atov +atow atox atoy atoz atpa atpb atpc atpd atpe atpf atpg atph atpi atpj atpk +atpl atpm atpn atpo atpp atpq atpr atps atpt atpu atpv atpw atpx atpy atpz +atqa atqb atqc atqd atqe atqf atqg atqh atqi atqj atqk atql atqm atqn atqo +atqp atqq atqr atqs atqt atqu atqv atqw atqx atqy atqz atra atrb atrc atrd +atre atrf atrg atrh atri atrj atrk atrl atrm atrn atro atrp atrq atrr atrs +atrt atru atrv atrw atrx atry atrz atsa atsb atsc atsd atse atsf atsg atsh +atsi atsj atsk atsl atsm atsn atso atsp atsq atsr atss atst atsu atsv atsw +atsx atsy atsz atta attb attc attd atte attf attg atth atti attj attk attl +attm attn atto attp attq attr atts attt attu attv attw attx atty attz atua +atub atuc atud atue atuf atug atuh atui atuj atuk atul atum atun atuo atup +atuq atur atus atut atuu atuv atuw atux atuy atuz atva atvb atvc atvd atve +atvf atvg atvh atvi atvj atvk atvl atvm atvn atvo atvp atvq atvr atvs atvt +atvu atvv atvw atvx atvy atvz atwa atwb atwc atwd atwe atwf atwg atwh atwi +atwj atwk atwl atwm atwn atwo atwp atwq atwr atws atwt atwu atwv atww atwx +atwy atwz atxa atxb atxc atxd atxe atxf atxg atxh atxi atxj atxk atxl atxm +atxn atxo atxp atxq atxr atxs atxt atxu atxv atxw atxx atxy atxz atya atyb +atyc atyd atye atyf atyg atyh atyi atyj atyk atyl atym atyn atyo atyp atyq +atyr atys atyt atyu atyv atyw atyx atyy atyz atza atzb atzc atzd atze atzf +atzg atzh atzi atzj atzk atzl atzm atzn atzo atzp atzq atzr atzs atzt atzu +atzv atzw atzx atzy atzz auaa auab auac auad auae auaf auag auah auai auaj +auak aual auam auan auao auap auaq auar auas auat auau auav auaw auax auay +auaz auba aubb aubc aubd aube aubf aubg aubh aubi aubj aubk aubl aubm aubn +aubo aubp aubq aubr aubs aubt aubu aubv aubw aubx auby aubz auca aucb aucc +aucd auce aucf aucg auch auci aucj auck aucl aucm aucn auco aucp aucq aucr +aucs auct aucu aucv aucw aucx aucy aucz auda audb audc audd aude audf audg +audh audi audj audk audl audm audn audo audp audq audr auds audt audu audv +audw audx audy audz auea aueb auec aued auee auef aueg aueh auei auej auek +auel auem auen aueo auep aueq auer aues auet aueu auev auew auex auey auez +aufa aufb aufc aufd aufe auff aufg aufh aufi aufj aufk aufl aufm aufn aufo +aufp aufq aufr aufs auft aufu aufv aufw aufx aufy aufz auga augb augc augd +auge augf augg augh augi augj augk augl augm augn augo augp augq augr augs +augt augu augv augw augx augy augz auha auhb auhc auhd auhe auhf auhg auhh +auhi auhj auhk auhl auhm auhn auho auhp auhq auhr auhs auht auhu auhv auhw +auhx auhy auhz auia auib auic auid auie auif auig auih auii auij auik auil +auim auin auio auip auiq auir auis auit auiu auiv auiw auix auiy auiz auja +aujb aujc aujd auje aujf aujg aujh auji aujj aujk aujl aujm aujn aujo aujp +aujq aujr aujs aujt auju aujv aujw aujx aujy aujz auka aukb aukc aukd auke +aukf aukg aukh auki aukj aukk aukl aukm aukn auko aukp aukq aukr auks aukt +auku aukv aukw aukx auky aukz aula aulb aulc auld aule aulf aulg aulh auli +aulj aulk aull aulm auln aulo aulp aulq aulr auls ault aulu aulv aulw aulx +auly aulz auma aumb aumc aumd aume aumf aumg aumh aumi aumj aumk auml aumm +aumn aumo aump aumq aumr aums aumt aumu aumv aumw aumx aumy aumz auna aunb +aunc aund aune aunf aung aunh auni aunj aunk aunl aunm aunn auno aunp aunq +aunr auns aunt aunu aunv aunw aunx auny aunz auoa auob auoc auod auoe auof +auog auoh auoi auoj auok auol auom auon auoo auop auoq auor auos auot auou +auov auow auox auoy auoz aupa aupb aupc aupd aupe aupf aupg auph aupi aupj +aupk aupl aupm aupn aupo aupp aupq aupr aups aupt aupu aupv aupw aupx aupy +aupz auqa auqb auqc auqd auqe auqf auqg auqh auqi auqj auqk auql auqm auqn +auqo auqp auqq auqr auqs auqt auqu auqv auqw auqx auqy auqz aura aurb aurc +aurd aure aurf aurg aurh auri aurj aurk aurl aurm aurn auro aurp aurq aurr +aurs aurt auru aurv aurw aurx aury aurz ausa ausb ausc ausd ause ausf ausg +aush ausi ausj ausk ausl ausm ausn auso ausp ausq ausr auss aust ausu ausv +ausw ausx ausy ausz auta autb autc autd aute autf autg auth auti autj autk +autl autm autn auto autp autq autr auts autt autu autv autw autx auty autz +auua auub auuc auud auue auuf auug auuh auui auuj auuk auul auum auun auuo +auup auuq auur auus auut auuu auuv auuw auux auuy auuz auva auvb auvc auvd +auve auvf auvg auvh auvi auvj auvk auvl auvm auvn auvo auvp auvq auvr auvs +auvt auvu auvv auvw auvx auvy auvz auwa auwb auwc auwd auwe auwf auwg auwh +auwi auwj auwk auwl auwm auwn auwo auwp auwq auwr auws auwt auwu auwv auww +auwx auwy auwz auxa auxb auxc auxd auxe auxf auxg auxh auxi auxj auxk auxl +auxm auxn auxo auxp auxq auxr auxs auxt auxu auxv auxw auxx auxy auxz auya +auyb auyc auyd auye auyf auyg auyh auyi auyj auyk auyl auym auyn auyo auyp +auyq auyr auys auyt auyu auyv auyw auyx auyy auyz auza auzb auzc auzd auze +auzf auzg auzh auzi auzj auzk auzl auzm auzn auzo auzp auzq auzr auzs auzt +auzu auzv auzw auzx auzy auzz avaa avab avac avad avae avaf avag avah avai +avaj avak aval avam avan avao avap avaq avar avas avat avau avav avaw avax +avay avaz avba avbb avbc avbd avbe avbf avbg avbh avbi avbj avbk avbl avbm +avbn avbo avbp avbq avbr avbs avbt avbu avbv avbw avbx avby avbz avca avcb +avcc avcd avce avcf avcg avch avci avcj avck avcl avcm avcn avco avcp avcq +avcr avcs avct avcu avcv avcw avcx avcy avcz avda avdb avdc avdd avde avdf +avdg avdh avdi avdj avdk avdl avdm avdn avdo avdp avdq avdr avds avdt avdu +avdv avdw avdx avdy avdz avea aveb avec aved avee avef aveg aveh avei avej +avek avel avem aven aveo avep aveq aver aves avet aveu avev avew avex avey +avez avfa avfb avfc avfd avfe avff avfg avfh avfi avfj avfk avfl avfm avfn +avfo avfp avfq avfr avfs avft avfu avfv avfw avfx avfy avfz avga avgb avgc +avgd avge avgf avgg avgh avgi avgj avgk avgl avgm avgn avgo avgp avgq avgr +avgs avgt avgu avgv avgw avgx avgy avgz avha avhb avhc avhd avhe avhf avhg +avhh avhi avhj avhk avhl avhm avhn avho avhp avhq avhr avhs avht avhu avhv +avhw avhx avhy avhz avia avib avic avid avie avif avig avih avii avij avik +avil avim avin avio avip aviq avir avis avit aviu aviv aviw avix aviy aviz +avja avjb avjc avjd avje avjf avjg avjh avji avjj avjk avjl avjm avjn avjo +avjp avjq avjr avjs avjt avju avjv avjw avjx avjy avjz avka avkb avkc avkd +avke avkf avkg avkh avki avkj avkk avkl avkm avkn avko avkp avkq avkr avks +avkt avku avkv avkw avkx avky avkz avla avlb avlc avld avle avlf avlg avlh +avli avlj avlk avll avlm avln avlo avlp avlq avlr avls avlt avlu avlv avlw +avlx avly avlz avma avmb avmc avmd avme avmf avmg avmh avmi avmj avmk avml +avmm avmn avmo avmp avmq avmr avms avmt avmu avmv avmw avmx avmy avmz avna +avnb avnc avnd avne avnf avng avnh avni avnj avnk avnl avnm avnn avno avnp +avnq avnr avns avnt avnu avnv avnw avnx avny avnz avoa avob avoc avod avoe +avof avog avoh avoi avoj avok avol avom avon avoo avop avoq avor avos avot +avou avov avow avox avoy avoz avpa avpb avpc avpd avpe avpf avpg avph avpi +avpj avpk avpl avpm avpn avpo avpp avpq avpr avps avpt avpu avpv avpw avpx +avpy avpz avqa avqb avqc avqd avqe avqf avqg avqh avqi avqj avqk avql avqm +avqn avqo avqp avqq avqr avqs avqt avqu avqv avqw avqx avqy avqz avra avrb +avrc avrd avre avrf avrg avrh avri avrj avrk avrl avrm avrn avro avrp avrq +avrr avrs avrt avru avrv avrw avrx avry avrz avsa avsb avsc avsd avse avsf +avsg avsh avsi avsj avsk avsl avsm avsn avso avsp avsq avsr avss avst avsu +avsv avsw avsx avsy avsz avta avtb avtc avtd avte avtf avtg avth avti avtj +avtk avtl avtm avtn avto avtp avtq avtr avts avtt avtu avtv avtw avtx avty +avtz avua avub avuc avud avue avuf avug avuh avui avuj avuk avul avum avun +avuo avup avuq avur avus avut avuu avuv avuw avux avuy avuz avva avvb avvc +avvd avve avvf avvg avvh avvi avvj avvk avvl avvm avvn avvo avvp avvq avvr +avvs avvt avvu avvv avvw avvx avvy avvz avwa avwb avwc avwd avwe avwf avwg +avwh avwi avwj avwk avwl avwm avwn avwo avwp avwq avwr avws avwt avwu avwv +avww avwx avwy avwz avxa avxb avxc avxd avxe avxf avxg avxh avxi avxj avxk +avxl avxm avxn avxo avxp avxq avxr avxs avxt avxu avxv avxw avxx avxy avxz +avya avyb avyc avyd avye avyf avyg avyh avyi avyj avyk avyl avym avyn avyo +avyp avyq avyr avys avyt avyu avyv avyw avyx avyy avyz avza avzb avzc avzd +avze avzf avzg avzh avzi avzj avzk avzl avzm avzn avzo avzp avzq avzr avzs +avzt avzu avzv avzw avzx avzy avzz awaa awab awac awad awae awaf awag awah +awai awaj awak awal awam awan awao awap awaq awar awas awat awau awav awaw +awax away awaz awba awbb awbc awbd awbe awbf awbg awbh awbi awbj awbk awbl +awbm awbn awbo awbp awbq awbr awbs awbt awbu awbv awbw awbx awby awbz awca +awcb awcc awcd awce awcf awcg awch awci awcj awck awcl awcm awcn awco awcp +awcq awcr awcs awct awcu awcv awcw awcx awcy awcz awda awdb awdc awdd awde +awdf awdg awdh awdi awdj awdk awdl awdm awdn awdo awdp awdq awdr awds awdt +awdu awdv awdw awdx awdy awdz awea aweb awec awed awee awef aweg aweh awei +awej awek awel awem awen aweo awep aweq awer awes awet aweu awev awew awex +awey awez awfa awfb awfc awfd awfe awff awfg awfh awfi awfj awfk awfl awfm +awfn awfo awfp awfq awfr awfs awft awfu awfv awfw awfx awfy awfz awga awgb +awgc awgd awge awgf awgg awgh awgi awgj awgk awgl awgm awgn awgo awgp awgq +awgr awgs awgt awgu awgv awgw awgx awgy awgz awha awhb awhc awhd awhe awhf +awhg awhh awhi awhj awhk awhl awhm awhn awho awhp awhq awhr awhs awht awhu +awhv awhw awhx awhy awhz awia awib awic awid awie awif awig awih awii awij +awik awil awim awin awio awip awiq awir awis awit awiu awiv awiw awix awiy +awiz awja awjb awjc awjd awje awjf awjg awjh awji awjj awjk awjl awjm awjn +awjo awjp awjq awjr awjs awjt awju awjv awjw awjx awjy awjz awka awkb awkc +awkd awke awkf awkg awkh awki awkj awkk awkl awkm awkn awko awkp awkq awkr +awks awkt awku awkv awkw awkx awky awkz awla awlb awlc awld awle awlf awlg +awlh awli awlj awlk awll awlm awln awlo awlp awlq awlr awls awlt awlu awlv +awlw awlx awly awlz awma awmb awmc awmd awme awmf awmg awmh awmi awmj awmk +awml awmm awmn awmo awmp awmq awmr awms awmt awmu awmv awmw awmx awmy awmz +awna awnb awnc awnd awne awnf awng awnh awni awnj awnk awnl awnm awnn awno +awnp awnq awnr awns awnt awnu awnv awnw awnx awny awnz awoa awob awoc awod +awoe awof awog awoh awoi awoj awok awol awom awon awoo awop awoq awor awos +awot awou awov awow awox awoy awoz awpa awpb awpc awpd awpe awpf awpg awph +awpi awpj awpk awpl awpm awpn awpo awpp awpq awpr awps awpt awpu awpv awpw +awpx awpy awpz awqa awqb awqc awqd awqe awqf awqg awqh awqi awqj awqk awql +awqm awqn awqo awqp awqq awqr awqs awqt awqu awqv awqw awqx awqy awqz awra +awrb awrc awrd awre awrf awrg awrh awri awrj awrk awrl awrm awrn awro awrp +awrq awrr awrs awrt awru awrv awrw awrx awry awrz awsa awsb awsc awsd awse +awsf awsg awsh awsi awsj awsk awsl awsm awsn awso awsp awsq awsr awss awst +awsu awsv awsw awsx awsy awsz awta awtb awtc awtd awte awtf awtg awth awti +awtj awtk awtl awtm awtn awto awtp awtq awtr awts awtt awtu awtv awtw awtx +awty awtz awua awub awuc awud awue awuf awug awuh awui awuj awuk awul awum +awun awuo awup awuq awur awus awut awuu awuv awuw awux awuy awuz awva awvb +awvc awvd awve awvf awvg awvh awvi awvj awvk awvl awvm awvn awvo awvp awvq +awvr awvs awvt awvu awvv awvw awvx awvy awvz awwa awwb awwc awwd awwe awwf +awwg awwh awwi awwj awwk awwl awwm awwn awwo awwp awwq awwr awws awwt awwu +awwv awww awwx awwy awwz awxa awxb awxc awxd awxe awxf awxg awxh awxi awxj +awxk awxl awxm awxn awxo awxp awxq awxr awxs awxt awxu awxv awxw awxx awxy +awxz awya awyb awyc awyd awye awyf awyg awyh awyi awyj awyk awyl awym awyn +awyo awyp awyq awyr awys awyt awyu awyv awyw awyx awyy awyz awza awzb awzc +awzd awze awzf awzg awzh awzi awzj awzk awzl awzm awzn awzo awzp awzq awzr +awzs awzt awzu awzv awzw awzx awzy awzz axaa axab axac axad axae axaf axag +axah axai axaj axak axal axam axan axao axap axaq axar axas axat axau axav +axaw axax axay axaz axba axbb axbc axbd axbe axbf axbg axbh axbi axbj axbk +axbl axbm axbn axbo axbp axbq axbr axbs axbt axbu axbv axbw axbx axby axbz +axca axcb axcc axcd axce axcf axcg axch axci axcj axck axcl axcm axcn axco +axcp axcq axcr axcs axct axcu axcv axcw axcx axcy axcz axda axdb axdc axdd +axde axdf axdg axdh axdi axdj axdk axdl axdm axdn axdo axdp axdq axdr axds +axdt axdu axdv axdw axdx axdy axdz axea axeb axec axed axee axef axeg axeh +axei axej axek axel axem axen axeo axep axeq axer axes axet axeu axev axew +axex axey axez axfa axfb axfc axfd axfe axff axfg axfh axfi axfj axfk axfl +axfm axfn axfo axfp axfq axfr axfs axft axfu axfv axfw axfx axfy axfz axga +axgb axgc axgd axge axgf axgg axgh axgi axgj axgk axgl axgm axgn axgo axgp +axgq axgr axgs axgt axgu axgv axgw axgx axgy axgz axha axhb axhc axhd axhe +axhf axhg axhh axhi axhj axhk axhl axhm axhn axho axhp axhq axhr axhs axht +axhu axhv axhw axhx axhy axhz axia axib axic axid axie axif axig axih axii +axij axik axil axim axin axio axip axiq axir axis axit axiu axiv axiw axix +axiy axiz axja axjb axjc axjd axje axjf axjg axjh axji axjj axjk axjl axjm +axjn axjo axjp axjq axjr axjs axjt axju axjv axjw axjx axjy axjz axka axkb +axkc axkd axke axkf axkg axkh axki axkj axkk axkl axkm axkn axko axkp axkq +axkr axks axkt axku axkv axkw axkx axky axkz axla axlb axlc axld axle axlf +axlg axlh axli axlj axlk axll axlm axln axlo axlp axlq axlr axls axlt axlu +axlv axlw axlx axly axlz axma axmb axmc axmd axme axmf axmg axmh axmi axmj +axmk axml axmm axmn axmo axmp axmq axmr axms axmt axmu axmv axmw axmx axmy +axmz axna axnb axnc axnd axne axnf axng axnh axni axnj axnk axnl axnm axnn +axno axnp axnq axnr axns axnt axnu axnv axnw axnx axny axnz axoa axob axoc +axod axoe axof axog axoh axoi axoj axok axol axom axon axoo axop axoq axor +axos axot axou axov axow axox axoy axoz axpa axpb axpc axpd axpe axpf axpg +axph axpi axpj axpk axpl axpm axpn axpo axpp axpq axpr axps axpt axpu axpv +axpw axpx axpy axpz axqa axqb axqc axqd axqe axqf axqg axqh axqi axqj axqk +axql axqm axqn axqo axqp axqq axqr axqs axqt axqu axqv axqw axqx axqy axqz +axra axrb axrc axrd axre axrf axrg axrh axri axrj axrk axrl axrm axrn axro +axrp axrq axrr axrs axrt axru axrv axrw axrx axry axrz axsa axsb axsc axsd +axse axsf axsg axsh axsi axsj axsk axsl axsm axsn axso axsp axsq axsr axss +axst axsu axsv axsw axsx axsy axsz axta axtb axtc axtd axte axtf axtg axth +axti axtj axtk axtl axtm axtn axto axtp axtq axtr axts axtt axtu axtv axtw +axtx axty axtz axua axub axuc axud axue axuf axug axuh axui axuj axuk axul +axum axun axuo axup axuq axur axus axut axuu axuv axuw axux axuy axuz axva +axvb axvc axvd axve axvf axvg axvh axvi axvj axvk axvl axvm axvn axvo axvp +axvq axvr axvs axvt axvu axvv axvw axvx axvy axvz axwa axwb axwc axwd axwe +axwf axwg axwh axwi axwj axwk axwl axwm axwn axwo axwp axwq axwr axws axwt +axwu axwv axww axwx axwy axwz axxa axxb axxc axxd axxe axxf axxg axxh axxi +axxj axxk axxl axxm axxn axxo axxp axxq axxr axxs axxt axxu axxv axxw axxx +axxy axxz axya axyb axyc axyd axye axyf axyg axyh axyi axyj axyk axyl axym +axyn axyo axyp axyq axyr axys axyt axyu axyv axyw axyx axyy axyz axza axzb +axzc axzd axze axzf axzg axzh axzi axzj axzk axzl axzm axzn axzo axzp axzq +axzr axzs axzt axzu axzv axzw axzx axzy axzz ayaa ayab ayac ayad ayae ayaf +ayag ayah ayai ayaj ayak ayal ayam ayan ayao ayap ayaq ayar ayas ayat ayau +ayav ayaw ayax ayay ayaz ayba aybb aybc aybd aybe aybf aybg aybh aybi aybj +aybk aybl aybm aybn aybo aybp aybq aybr aybs aybt aybu aybv aybw aybx ayby +aybz ayca aycb aycc aycd ayce aycf aycg aych ayci aycj ayck aycl aycm aycn +ayco aycp aycq aycr aycs ayct aycu aycv aycw aycx aycy aycz ayda aydb aydc +aydd ayde aydf aydg aydh aydi aydj aydk aydl aydm aydn aydo aydp aydq aydr +ayds aydt aydu aydv aydw aydx aydy aydz ayea ayeb ayec ayed ayee ayef ayeg +ayeh ayei ayej ayek ayel ayem ayen ayeo ayep ayeq ayer ayes ayet ayeu ayev +ayew ayex ayey ayez ayfa ayfb ayfc ayfd ayfe ayff ayfg ayfh ayfi ayfj ayfk +ayfl ayfm ayfn ayfo ayfp ayfq ayfr ayfs ayft ayfu ayfv ayfw ayfx ayfy ayfz +ayga aygb aygc aygd ayge aygf aygg aygh aygi aygj aygk aygl aygm aygn aygo +aygp aygq aygr aygs aygt aygu aygv aygw aygx aygy aygz ayha ayhb ayhc ayhd +ayhe ayhf ayhg ayhh ayhi ayhj ayhk ayhl ayhm ayhn ayho ayhp ayhq ayhr ayhs +ayht ayhu ayhv ayhw ayhx ayhy ayhz ayia ayib ayic ayid ayie ayif ayig ayih +ayii ayij ayik ayil ayim ayin ayio ayip ayiq ayir ayis ayit ayiu ayiv ayiw +ayix ayiy ayiz ayja ayjb ayjc ayjd ayje ayjf ayjg ayjh ayji ayjj ayjk ayjl +ayjm ayjn ayjo ayjp ayjq ayjr ayjs ayjt ayju ayjv ayjw ayjx ayjy ayjz ayka +aykb aykc aykd ayke aykf aykg aykh ayki aykj aykk aykl aykm aykn ayko aykp +aykq aykr ayks aykt ayku aykv aykw aykx ayky aykz ayla aylb aylc ayld ayle +aylf aylg aylh ayli aylj aylk ayll aylm ayln aylo aylp aylq aylr ayls aylt +aylu aylv aylw aylx ayly aylz ayma aymb aymc aymd ayme aymf aymg aymh aymi +aymj aymk ayml aymm aymn aymo aymp aymq aymr ayms aymt aymu aymv aymw aymx +aymy aymz ayna aynb aync aynd ayne aynf ayng aynh ayni aynj aynk aynl aynm +aynn ayno aynp aynq aynr ayns aynt aynu aynv aynw aynx ayny aynz ayoa ayob +ayoc ayod ayoe ayof ayog ayoh ayoi ayoj ayok ayol ayom ayon ayoo ayop ayoq +ayor ayos ayot ayou ayov ayow ayox ayoy ayoz aypa aypb aypc aypd aype aypf +aypg ayph aypi aypj aypk aypl aypm aypn aypo aypp aypq aypr ayps aypt aypu +aypv aypw aypx aypy aypz ayqa ayqb ayqc ayqd ayqe ayqf ayqg ayqh ayqi ayqj +ayqk ayql ayqm ayqn ayqo ayqp ayqq ayqr ayqs ayqt ayqu ayqv ayqw ayqx ayqy +ayqz ayra ayrb ayrc ayrd ayre ayrf ayrg ayrh ayri ayrj ayrk ayrl ayrm ayrn +ayro ayrp ayrq ayrr ayrs ayrt ayru ayrv ayrw ayrx ayry ayrz aysa aysb aysc +aysd ayse aysf aysg aysh aysi aysj aysk aysl aysm aysn ayso aysp aysq aysr +ayss ayst aysu aysv aysw aysx aysy aysz ayta aytb aytc aytd ayte aytf aytg +ayth ayti aytj aytk aytl aytm aytn ayto aytp aytq aytr ayts aytt aytu aytv +aytw aytx ayty aytz ayua ayub ayuc ayud ayue ayuf ayug ayuh ayui ayuj ayuk +ayul ayum ayun ayuo ayup ayuq ayur ayus ayut ayuu ayuv ayuw ayux ayuy ayuz +ayva ayvb ayvc ayvd ayve ayvf ayvg ayvh ayvi ayvj ayvk ayvl ayvm ayvn ayvo +ayvp ayvq ayvr ayvs ayvt ayvu ayvv ayvw ayvx ayvy ayvz aywa aywb aywc aywd +aywe aywf aywg aywh aywi aywj aywk aywl aywm aywn aywo aywp aywq aywr ayws +aywt aywu aywv ayww aywx aywy aywz ayxa ayxb ayxc ayxd ayxe ayxf ayxg ayxh +ayxi ayxj ayxk ayxl ayxm ayxn ayxo ayxp ayxq ayxr ayxs ayxt ayxu ayxv ayxw +ayxx ayxy ayxz ayya ayyb ayyc ayyd ayye ayyf ayyg ayyh ayyi ayyj ayyk ayyl +ayym ayyn ayyo ayyp ayyq ayyr ayys ayyt ayyu ayyv ayyw ayyx ayyy ayyz ayza +ayzb ayzc ayzd ayze ayzf ayzg ayzh ayzi ayzj ayzk ayzl ayzm ayzn ayzo ayzp +ayzq ayzr ayzs ayzt ayzu ayzv ayzw ayzx ayzy ayzz azaa azab azac azad azae +azaf azag azah azai azaj azak azal azam azan azao azap azaq azar azas azat +azau azav azaw azax azay azaz azba azbb azbc azbd azbe azbf azbg azbh azbi +azbj azbk azbl azbm azbn azbo azbp azbq azbr azbs azbt azbu azbv azbw azbx +azby azbz azca azcb azcc azcd azce azcf azcg azch azci azcj azck azcl azcm +azcn azco azcp azcq azcr azcs azct azcu azcv azcw azcx azcy azcz azda azdb +azdc azdd azde azdf azdg azdh azdi azdj azdk azdl azdm azdn azdo azdp azdq +azdr azds azdt azdu azdv azdw azdx azdy azdz azea azeb azec azed azee azef +azeg azeh azei azej azek azel azem azen azeo azep azeq azer azes azet azeu +azev azew azex azey azez azfa azfb azfc azfd azfe azff azfg azfh azfi azfj +azfk azfl azfm azfn azfo azfp azfq azfr azfs azft azfu azfv azfw azfx azfy +azfz azga azgb azgc azgd azge azgf azgg azgh azgi azgj azgk azgl azgm azgn +azgo azgp azgq azgr azgs azgt azgu azgv azgw azgx azgy azgz azha azhb azhc +azhd azhe azhf azhg azhh azhi azhj azhk azhl azhm azhn azho azhp azhq azhr +azhs azht azhu azhv azhw azhx azhy azhz azia azib azic azid azie azif azig +azih azii azij azik azil azim azin azio azip aziq azir azis azit aziu aziv +aziw azix aziy aziz azja azjb azjc azjd azje azjf azjg azjh azji azjj azjk +azjl azjm azjn azjo azjp azjq azjr azjs azjt azju azjv azjw azjx azjy azjz +azka azkb azkc azkd azke azkf azkg azkh azki azkj azkk azkl azkm azkn azko +azkp azkq azkr azks azkt azku azkv azkw azkx azky azkz azla azlb azlc azld +azle azlf azlg azlh azli azlj azlk azll azlm azln azlo azlp azlq azlr azls +azlt azlu azlv azlw azlx azly azlz azma azmb azmc azmd azme azmf azmg azmh +azmi azmj azmk azml azmm azmn azmo azmp azmq azmr azms azmt azmu azmv azmw +azmx azmy azmz azna aznb aznc aznd azne aznf azng aznh azni aznj aznk aznl +aznm aznn azno aznp aznq aznr azns aznt aznu aznv aznw aznx azny aznz azoa +azob azoc azod azoe azof azog azoh azoi azoj azok azol azom azon azoo azop +azoq azor azos azot azou azov azow azox azoy azoz azpa azpb azpc azpd azpe +azpf azpg azph azpi azpj azpk azpl azpm azpn azpo azpp azpq azpr azps azpt +azpu azpv azpw azpx azpy azpz azqa azqb azqc azqd azqe azqf azqg azqh azqi +azqj azqk azql azqm azqn azqo azqp azqq azqr azqs azqt azqu azqv azqw azqx +azqy azqz azra azrb azrc azrd azre azrf azrg azrh azri azrj azrk azrl azrm +azrn azro azrp azrq azrr azrs azrt azru azrv azrw azrx azry azrz azsa azsb +azsc azsd azse azsf azsg azsh azsi azsj azsk azsl azsm azsn azso azsp azsq +azsr azss azst azsu azsv azsw azsx azsy azsz azta aztb aztc aztd azte aztf +aztg azth azti aztj aztk aztl aztm aztn azto aztp aztq aztr azts aztt aztu +aztv aztw aztx azty aztz azua azub azuc azud azue azuf azug azuh azui azuj +azuk azul azum azun azuo azup azuq azur azus azut azuu azuv azuw azux azuy +azuz azva azvb azvc azvd azve azvf azvg azvh azvi azvj azvk azvl azvm azvn +azvo azvp azvq azvr azvs azvt azvu azvv azvw azvx azvy azvz azwa azwb azwc +azwd azwe azwf azwg azwh azwi azwj azwk azwl azwm azwn azwo azwp azwq azwr +azws azwt azwu azwv azww azwx azwy azwz azxa azxb azxc azxd azxe azxf azxg +azxh azxi azxj azxk azxl azxm azxn azxo azxp azxq azxr azxs azxt azxu azxv +azxw azxx azxy azxz azya azyb azyc azyd azye azyf azyg azyh azyi azyj azyk +azyl azym azyn azyo azyp azyq azyr azys azyt azyu azyv azyw azyx azyy azyz +azza azzb azzc azzd azze azzf azzg azzh azzi azzj azzk azzl azzm azzn azzo +azzp azzq azzr azzs azzt azzu azzv azzw azzx azzy azzz baaa baab baac baad +baae baaf baag baah baai baaj baak baal baam baan baao baap baaq baar baas +baat baau baav baaw baax baay baaz baba babb babc babd babe babf babg babh +babi babj babk babl babm babn babo babp babq babr babs babt babu babv babw +babx baby babz baca bacb bacc bacd bace bacf bacg bach baci bacj back bacl +bacm bacn baco bacp bacq bacr bacs bact bacu bacv bacw bacx bacy bacz bada +badb badc badd bade badf badg badh badi badj badk badl badm badn bado badp +badq badr bads badt badu badv badw badx bady badz baea baeb baec baed baee +baef baeg baeh baei baej baek bael baem baen baeo baep baeq baer baes baet +baeu baev baew baex baey baez bafa bafb bafc bafd bafe baff bafg bafh bafi +bafj bafk bafl bafm bafn bafo bafp bafq bafr bafs baft bafu bafv bafw bafx +bafy bafz baga bagb bagc bagd bage bagf bagg bagh bagi bagj bagk bagl bagm +bagn bago bagp bagq bagr bags bagt bagu bagv bagw bagx bagy bagz baha bahb +bahc bahd bahe bahf bahg bahh bahi bahj bahk bahl bahm bahn baho bahp bahq +bahr bahs baht bahu bahv bahw bahx bahy bahz baia baib baic baid baie baif +baig baih baii baij baik bail baim bain baio baip baiq bair bais bait baiu +baiv baiw baix baiy baiz baja bajb bajc bajd baje bajf bajg bajh baji bajj +bajk bajl bajm bajn bajo bajp bajq bajr bajs bajt baju bajv bajw bajx bajy +bajz baka bakb bakc bakd bake bakf bakg bakh baki bakj bakk bakl bakm bakn +bako bakp bakq bakr baks bakt baku bakv bakw bakx baky bakz bala balb balc +bald bale balf balg balh bali balj balk ball balm baln balo balp balq balr +bals balt balu balv balw balx baly balz bama bamb bamc bamd bame bamf bamg +bamh bami bamj bamk baml bamm bamn bamo bamp bamq bamr bams bamt bamu bamv +bamw bamx bamy bamz bana banb banc band bane banf bang banh bani banj bank +banl banm bann bano banp banq banr bans bant banu banv banw banx bany banz +baoa baob baoc baod baoe baof baog baoh baoi baoj baok baol baom baon baoo +baop baoq baor baos baot baou baov baow baox baoy baoz bapa bapb bapc bapd +bape bapf bapg baph bapi bapj bapk bapl bapm bapn bapo bapp bapq bapr baps +bapt bapu bapv bapw bapx bapy bapz baqa baqb baqc baqd baqe baqf baqg baqh +baqi baqj baqk baql baqm baqn baqo baqp baqq baqr baqs baqt baqu baqv baqw +baqx baqy baqz bara barb barc bard bare barf barg barh bari barj bark barl +barm barn baro barp barq barr bars bart baru barv barw barx bary barz basa +basb basc basd base basf basg bash basi basj bask basl basm basn baso basp +basq basr bass bast basu basv basw basx basy basz bata batb batc batd bate +batf batg bath bati batj batk batl batm batn bato batp batq batr bats batt +batu batv batw batx baty batz baua baub bauc baud baue bauf baug bauh baui +bauj bauk baul baum baun bauo baup bauq baur baus baut bauu bauv bauw baux +bauy bauz bava bavb bavc bavd bave bavf bavg bavh bavi bavj bavk bavl bavm +bavn bavo bavp bavq bavr bavs bavt bavu bavv bavw bavx bavy bavz bawa bawb +bawc bawd bawe bawf bawg bawh bawi bawj bawk bawl bawm bawn bawo bawp bawq +bawr baws bawt bawu bawv baww bawx bawy bawz baxa baxb baxc baxd baxe baxf +baxg baxh baxi baxj baxk baxl baxm baxn baxo baxp baxq baxr baxs baxt baxu +baxv baxw baxx baxy baxz baya bayb bayc bayd baye bayf bayg bayh bayi bayj +bayk bayl baym bayn bayo bayp bayq bayr bays bayt bayu bayv bayw bayx bayy +bayz baza bazb bazc bazd baze bazf bazg bazh bazi bazj bazk bazl bazm bazn +bazo bazp bazq bazr bazs bazt bazu bazv bazw bazx bazy bazz bbaa bbab bbac +bbad bbae bbaf bbag bbah bbai bbaj bbak bbal bbam bban bbao bbap bbaq bbar +bbas bbat bbau bbav bbaw bbax bbay bbaz bbba bbbb diff --git a/camlp4/test/fixtures/if.ml b/camlp4/test/fixtures/if.ml new file mode 100644 index 00000000..3f9b452c --- /dev/null +++ b/camlp4/test/fixtures/if.ml @@ -0,0 +1,8 @@ +let x = if x then a else b in x + +let x = if StringSet.mem "*" sections then a else b in x + +let x = +if StringSet.mem "*" sections then fun _ -> true else + fun x -> StringSet.mem x sections +in x diff --git a/camlp4/test/fixtures/label.ml b/camlp4/test/fixtures/label.ml new file mode 100644 index 00000000..a60f367a --- /dev/null +++ b/camlp4/test/fixtures/label.ml @@ -0,0 +1 @@ +value f ~a:_ ?b:_ = (); diff --git a/camlp4/test/fixtures/lambda_free.ml b/camlp4/test/fixtures/lambda_free.ml new file mode 100644 index 00000000..4d6f1351 --- /dev/null +++ b/camlp4/test/fixtures/lambda_free.ml @@ -0,0 +1,68 @@ +open Format; + +module S = Set.Make String; + +type term = + [ Lambda of string and term + | Atom of string + | App of term and term + | Opt of term and option term and term + ]; + +value free_vars = + let rec fv t env free = + match t with + [ Lambda x t -> fv t (S.add x env) free + | Atom x -> if S.mem x env then free else S.add x free + | App t1 t2 -> fv t1 env (fv t2 env free) + | Opt _ _ _ -> assert False ] + in fun t -> fv t S.empty S.empty; + +value print_set f s = do { + fprintf f "@[<2>{ "; + S.iter (fprintf f "%s@ ") s; + fprintf f "}@]"; +}; + +value t1 = Lambda "x" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "x" (Atom "x"))); +value t2 = Lambda "x" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "z" (Atom "z"))); +value t3 = Lambda "x" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "x" (Atom "z"))); +value t4 = Lambda "a" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "x" (Atom "z"))); + +printf "t1: %a@." print_set (free_vars t1); +printf "t2: %a@." print_set (free_vars t2); +printf "t3: %a@." print_set (free_vars t3); +printf "t4: %a@." print_set (free_vars t4); + +class fold ['accu] init = + object (o : 'self_type) + value accu : 'accu = init; + method accu = accu; + method term t = + match t with + [ Lambda x t -> (o#string x)#term t + | Atom x -> o#string x + | App t1 t2 -> (o#term t1)#term t2 + | Opt t1 ot t2 -> ((o#term t1)#option (fun o -> o#term) ot)#term t2 ]; + method string : string -> 'self_type = fun _ -> o; + method option : ! 'a. ('self_type -> 'a -> 'self_type) -> option 'a -> 'self_type = + fun f opt -> + match opt with + [ None -> o + | Some x -> f o x ]; + end; + +class fold_atoms ['accu] f init = + object (o : 'self_type) + inherit fold ['accu] init as super; + method term t = + match t with + [ Atom x -> {< accu = f x accu >} + | _ -> super#term t ]; + end; + +value t5 = Opt (Atom "a") (Some (Atom "b")) (Atom "c"); + +value atoms = ((new fold_atoms S.add S.empty)#term t5)#accu; + +printf "atoms: %a@." print_set atoms; diff --git a/camlp4/test/fixtures/loc-bug.ml b/camlp4/test/fixtures/loc-bug.ml new file mode 100644 index 00000000..2901e6f8 --- /dev/null +++ b/camlp4/test/fixtures/loc-bug.ml @@ -0,0 +1,3 @@ +#default_quotation "expr";; +Lwt.return + << 3 + >> diff --git a/camlp4/test/fixtures/macrotest.ml b/camlp4/test/fixtures/macrotest.ml new file mode 100644 index 00000000..023a5b42 --- /dev/null +++ b/camlp4/test/fixtures/macrotest.ml @@ -0,0 +1,70 @@ +DEFINE A = 42; +DEFINE B = 51; + +IFDEF A THEN + value a_should_be_present = B + 2; + print_int (a_should_be_present + 1); +ENDIF; + +print_int (a_should_be_present + 2); + +IFNDEF C THEN + print_int (a_should_be_present + 3); +ENDIF; + +IFNDEF C THEN + print_int (a_should_be_present + 4); +ELSE + print_int (c_should_not_be_present + 1); +ENDIF; + +IFDEF C THEN + print_int (c_should_not_be_present + 2); +ELSIF + print_int (A * a_should_be_present + 5); +ENDIF; + +IFDEF DNE THEN + print_int (c_should_not_be_present + 2); +ELSIF + print_int (A * a_should_be_present + 5); +ENDIF; + +IFDEF OPT THEN + print_int (c_should_not_be_present + 2); +ELSIF + print_int (A * a_should_be_present + 5); +ENDIF; + +value e = + IFDEF DNE THEN + print_int (c_should_not_be_present + 2) + ELSE + print_int (A * a_should_be_present + 5) + ENDIF; + +value f = + fun _ -> + IFDEF DNE THEN + print_int (c_should_not_be_present + 2) + ELSE + print_int (A * a_should_be_present + 5) + ENDIF; + +IFDEF A THEN + DEFINE Z = "ok"; +ELSE + DEFINE Z = "ko"; +ENDIF; + +Z; + +IFDEF DNE THEN + DEFINE Z = "ko2"; +ELSE + DEFINE Z = "ok2"; +ENDIF; + +Z; + +pouet; diff --git a/camlp4/test/fixtures/macrotest.mli b/camlp4/test/fixtures/macrotest.mli new file mode 100644 index 00000000..4912fd34 --- /dev/null +++ b/camlp4/test/fixtures/macrotest.mli @@ -0,0 +1,25 @@ +DEFINE A; +DEFINE B; + +IFDEF A THEN + value a_should_be_present : int; +ENDIF; + +IFNDEF C THEN + value b_should_be_present : int; +ENDIF; + +IFNDEF C THEN + value c_should_be_present : int; +ELSE + value a_should_NOT_be_present : int; +END; + +IFDEF C THEN + value b_should_NOT_be_present : int; +ELSE + value d_should_be_present : int; + value e_should_be_present : int; +ENDIF; + +value f_should_be_present : int; diff --git a/camlp4/test/fixtures/macrotest2.ml b/camlp4/test/fixtures/macrotest2.ml new file mode 100644 index 00000000..cb2d4cff --- /dev/null +++ b/camlp4/test/fixtures/macrotest2.ml @@ -0,0 +1,6 @@ +IFNDEF UNDEFINED_VARIABLE THEN + DEFINE SQUARE (x) = x * x ;; + DEFINE DOUBLE_SQUARE (x) = (SQUARE x) * 2 ;; +END;; + +Printf.printf "%d\n" (DOUBLE_SQUARE(42)) ;; diff --git a/camlp4/test/fixtures/macrotest3.ml b/camlp4/test/fixtures/macrotest3.ml new file mode 100644 index 00000000..ef618d28 --- /dev/null +++ b/camlp4/test/fixtures/macrotest3.ml @@ -0,0 +1,11 @@ +IFNDEF UNDEFINED_VARIABLE THEN + DEFINE UNDEFINED_VARIABLE + + IFDEF UNDEFINED_VARIABLE THEN + DEFINE SQUARE (x) = x * x ;; + DEFINE DOUBLE_SQUARE (x) = (SQUARE x) * 2 ;; + END +END;; + +Printf.printf "%d\n" (DOUBLE_SQUARE(42)) ;; + diff --git a/camlp4/test/fixtures/make_extend.ml b/camlp4/test/fixtures/make_extend.ml new file mode 100644 index 00000000..f2d625c2 --- /dev/null +++ b/camlp4/test/fixtures/make_extend.ml @@ -0,0 +1 @@ +<:expr< EXTEND G expr: [[ "foo" -> <:expr< foo >> ]]; END >>; diff --git a/camlp4/test/fixtures/match.ml b/camlp4/test/fixtures/match.ml new file mode 100644 index 00000000..9fb52cb7 --- /dev/null +++ b/camlp4/test/fixtures/match.ml @@ -0,0 +1,9 @@ +let x = + match y with + | A z -> z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z + | B l -> + (match l with + | [] -> () + | x::xs -> p x; self xs) + | C -> () +in x diff --git a/camlp4/test/fixtures/match_parser.ml b/camlp4/test/fixtures/match_parser.ml new file mode 100644 index 00000000..e053ee88 --- /dev/null +++ b/camlp4/test/fixtures/match_parser.ml @@ -0,0 +1,10 @@ +open Camlp4.PreCast; + +let _loc = Loc.ghost in +let e = <:expr< parser [: `"a" :] -> t >> in +let a = + match e with + [ <:expr< parser [: `$str:x$ :] -> t >> -> x + | _ -> assert False ] +in Format.printf "a: %S@." a; + diff --git a/camlp4/test/fixtures/meta_multi_term.ml b/camlp4/test/fixtures/meta_multi_term.ml new file mode 100644 index 00000000..35e96b2a --- /dev/null +++ b/camlp4/test/fixtures/meta_multi_term.ml @@ -0,0 +1,16 @@ +open Camlp4.PreCast; +value _loc = Loc.ghost; + +module Term = struct + type patt = + [ PApp of patt and patt + | PAny + | PVar of string + | POlb of string and expr ] + and expr = + [ EApp of expr and expr + | EVar of string + | ELam of patt and expr ]; +end; + +module MetaTerm = MetaGenerator Term; diff --git a/camlp4/test/fixtures/metalib.ml b/camlp4/test/fixtures/metalib.ml new file mode 100644 index 00000000..22dff11c --- /dev/null +++ b/camlp4/test/fixtures/metalib.ml @@ -0,0 +1,5 @@ +#load "camlp4of.cma";; +open Camlp4.PreCast;; +module M = Ast.Meta.Make(Ast.Meta.MetaGhostLoc);; +let ghost = Loc.ghost;; +M.Expr.meta_ctyp ghost <:ctyp@ghost< int >>;; diff --git a/camlp4/test/fixtures/method_private_virtual.ml b/camlp4/test/fixtures/method_private_virtual.ml new file mode 100644 index 00000000..6c0b94a6 --- /dev/null +++ b/camlp4/test/fixtures/method_private_virtual.ml @@ -0,0 +1,9 @@ +class virtual c1 = object method virtual private f : unit end;; +class virtual c2 = object method private virtual f : unit end;; + +<:str_item< class virtual c1 = object method virtual private f : unit; end >>;; +<:str_item< class virtual c2 = object method private virtual f : unit; end >>;; +<:str_item< class virtual c2 = object method $private:p$ virtual f : unit; end >>;; +<:str_item< class virtual c2 = object method virtual $private:p$ f : unit; end >>;; +<:str_item< class $virtual:v$ c2 [$t1$] = + object ($pat:self$) method virtual $private:p$ $lid:f$ : $t2$; end >>;; diff --git a/camlp4/test/fixtures/mod.ml b/camlp4/test/fixtures/mod.ml new file mode 100644 index 00000000..ca2b3e03 --- /dev/null +++ b/camlp4/test/fixtures/mod.ml @@ -0,0 +1,15 @@ +module type S = sig type t end +module F (A : S) = struct + type t2 = A.t + module A = A +end + +module A = struct type t = int end + +module type S3 = sig + module M : S +end + +module type S2 = S with type t = F(A).t2 + +module type S4 = S3 with module M = F(A).A diff --git a/camlp4/test/fixtures/mod2.ml b/camlp4/test/fixtures/mod2.ml new file mode 100644 index 00000000..c0a1667d --- /dev/null +++ b/camlp4/test/fixtures/mod2.ml @@ -0,0 +1,8 @@ +module type S = sig type t = 'a; end; +module F (A : S) = struct + type t2 = A.t; +end; + +module A = struct type t = int; end; + +module type S2 = S with type t = (F A).t2; diff --git a/camlp4/test/fixtures/operators.ml b/camlp4/test/fixtures/operators.ml new file mode 100644 index 00000000..467c37c3 --- /dev/null +++ b/camlp4/test/fixtures/operators.ml @@ -0,0 +1,7 @@ +let _ : int = 42 +let (+) = M.(+) +let (+) = M.(+) in 42 +let (+) : int -> int -> int = (+) +let (+) : int -> int -> int = (+) in 42 +let None = None +let None : int option = None diff --git a/camlp4/test/fixtures/operators.mli b/camlp4/test/fixtures/operators.mli new file mode 100644 index 00000000..af445306 --- /dev/null +++ b/camlp4/test/fixtures/operators.mli @@ -0,0 +1 @@ +val (+) : int -> int -> int diff --git a/camlp4/test/fixtures/original_syntax.ml b/camlp4/test/fixtures/original_syntax.ml new file mode 100644 index 00000000..bf08d561 --- /dev/null +++ b/camlp4/test/fixtures/original_syntax.ml @@ -0,0 +1,17 @@ +fun x when x <> 0 -> x / 42 +;; +object val virtual mutable x : int val mutable virtual y : int end +;; +- !r +;; +! -r +;; +-32 +;; +- - 32 +;; +!(r.b) +;; +(!r).b = !r.b +;; +let l : (unit -> int) list = [(fun _ -> 42); (fun _ -> 42)] diff --git a/camlp4/test/fixtures/outside-scope.ml b/camlp4/test/fixtures/outside-scope.ml new file mode 100644 index 00000000..6b8b80b8 --- /dev/null +++ b/camlp4/test/fixtures/outside-scope.ml @@ -0,0 +1,21 @@ +type t 'a = [ Nil | Cons of 'a and t 'a ]; + +module A : sig + value app_hd : t 'a -> ('a -> 'a) -> option 'a; +end = struct + value app_hd x f = + match x with + [ Nil -> None + | Cons x _ -> Some (f x) ]; +end; +open A; + +module M = struct + external mk_nil : unit -> t 'a = "%identity"; + value nil = mk_nil (); + (* value is_nil x = x = nil; *) +end; + +(* M.app_hd succ (M.Cons 1 M.Nil); *) +(* M.hd (M.Cons 1 M.Nil); *) +app_hd (M.nil : t 'a) (fun (x : int) -> (x : 'a)); diff --git a/camlp4/test/fixtures/parser.ml b/camlp4/test/fixtures/parser.ml new file mode 100644 index 00000000..7e41f35b --- /dev/null +++ b/camlp4/test/fixtures/parser.ml @@ -0,0 +1,61 @@ +open Camlp4.PreCast; +type t = [ A of t and t | B of string ]; +value lex = Lexer.mk (); + + (* value list0 symb = + let rec loop al = + parser + [ [: a = symb; s :] -> loop [a :: al] s + | [: :] -> al ] + in + parser [: a = loop [] :] -> List.rev a + ; + value list0sep symb sep = + let rec kont al = + parser + [ [: v = sep; a = symb; s :] -> kont [a :: al] s + | [: :] -> al ] + in + parser + [ [: a = symb; s :] -> List.rev (kont [a] s) + | [: :] -> [] ] + ; + value list1 symb = + let rec loop al = + parser + [ [: a = symb; s :] -> loop [a :: al] s + | [: :] -> al ] + in + parser [: a = symb; s :] -> List.rev (loop [a] s) + ; + value list1sep symb sep = + let rec kont al = + parser + [ [: v = sep; a = symb; s :] -> kont [a :: al] s + | [: :] -> al ] + in + parser [: a = symb; s :] -> List.rev (kont [a] s) + ; *) + +value list1 = + let rec self stream acc = + match stream with parser + [ [: `(EOI, _) :] -> acc + | [: `(LIDENT x, _); xs :] -> self xs (A acc (B x)) + | [: `(BLANKS _ | NEWLINE, _); xs :] -> self xs acc ] + in + parser [: `(LIDENT x, _); xs :] -> self xs (B x); +value rec length x acc = + match x with + [ A x y -> length x (length y acc) + | B _ -> succ acc ]; +(* value length _ _ = -1; *) +open Format; +try + let f = Sys.argv.(1) in + let () = printf "parsing...@." in + let a = list1 (lex (Loc.mk f) (Stream.of_channel (open_in f))) in + let () = printf "counting...@." in + let n = length a 0 in + printf "%d@." n +with e -> eprintf "error: %a@." Camlp4.ErrorHandler.print e; diff --git a/camlp4/test/fixtures/pp_let_in.ml b/camlp4/test/fixtures/pp_let_in.ml new file mode 100644 index 00000000..c6162499 --- /dev/null +++ b/camlp4/test/fixtures/pp_let_in.ml @@ -0,0 +1,10 @@ +let i = "toto" in do { (let i = 42 in print_int i); print_string i }; +let i = "toto" in do { print_string i; let i = 42 in print_int i; print_int i }; +let i = "toto" in do { + (let i = 42 in print_int i); + let i = i ^ i; + let i = i ^ i; + print_string i; + print_string i; + let i = i ^ i; + print_string i }; diff --git a/camlp4/test/fixtures/pp_let_in2.ml b/camlp4/test/fixtures/pp_let_in2.ml new file mode 100644 index 00000000..7e9b3496 --- /dev/null +++ b/camlp4/test/fixtures/pp_let_in2.ml @@ -0,0 +1 @@ +let i = "toto" in ((let i = 42 in print_int i); print_string i) diff --git a/camlp4/test/fixtures/pp_xml.ml b/camlp4/test/fixtures/pp_xml.ml new file mode 100644 index 00000000..986998c4 --- /dev/null +++ b/camlp4/test/fixtures/pp_xml.ml @@ -0,0 +1,31 @@ + +type xml = Elt of string * xml list | Pcdata of string + +let pp = Format.fprintf + +let rec print_elt f = + function + | Elt (tag, contents) -> + pp f "@[@[<%s>@,%a@]@,@]" + tag print_list_elts contents tag + | Pcdata s -> + Format.pp_print_string f s + +and print_list_elts f = + let rec loop = + function + | [] -> () + | x::xs -> (pp f "@,"; print_elt f x; loop xs) in + function + | [] -> () + | [x] -> print_elt f x + | x::xs -> (print_elt f x; loop xs) + +let tree = + Elt ("div", [ + Elt ("p", [Pcdata "a short text"]); + Elt ("p", [Pcdata "a looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong text"]) + ]) + +let () = Format.printf "%a@." print_elt tree + diff --git a/camlp4/test/fixtures/pprecordtyp.ml b/camlp4/test/fixtures/pprecordtyp.ml new file mode 100644 index 00000000..1b140af0 --- /dev/null +++ b/camlp4/test/fixtures/pprecordtyp.ml @@ -0,0 +1,26 @@ +open Camlp4.PreCast + +let _loc = Loc.mk "?" + +let base base fields ty = + let fields = List.fold_right (fun field acc -> + let c = <:ctyp< $lid:field$ : $uid:field$.record >> in + <:ctyp< $c$ ; $acc$ >>) fields <:ctyp< >> + in + <:module_binding< $uid:base$ : + sig type record = { + key : $ty$; + $fields$ + } end = struct + type record = { + key : $ty$; + $fields$ + } end + >> + +module CleanAst = Camlp4.Struct.CleanAst.Make(Ast) +let _ = + let b = base "b" ["f1"; "f2"] <:ctyp< int >> in + Camlp4.PreCast.Printers.OCaml.print_implem + ((new CleanAst.clean_ast)#str_item + <:str_item< module rec $b$ >>) diff --git a/camlp4/test/fixtures/pr4314.ml b/camlp4/test/fixtures/pr4314.ml new file mode 100644 index 00000000..9e6b23bc --- /dev/null +++ b/camlp4/test/fixtures/pr4314.ml @@ -0,0 +1 @@ +(int_of_string "1" : unit); diff --git a/camlp4/test/fixtures/pr4314gram1.ml b/camlp4/test/fixtures/pr4314gram1.ml new file mode 100644 index 00000000..a83b073a --- /dev/null +++ b/camlp4/test/fixtures/pr4314gram1.ml @@ -0,0 +1,36 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram ; + +value exp = G.Entry.mk "exp" ; +value prog = G.Entry.mk "prog" ; + +EXTEND G +exp: +[ "apply" + [ e1 = SELF; e2 = SELF -> + let p = Loc.dump in + let () = + Format.eprintf "e1: %a,@.e2: %a,@.e1-e2: %a,@._loc: %a@." + p e1 p e2 p (Loc.merge e1 e2) p _loc + in + _loc + ] +| "simple" + [ _ = LIDENT -> _loc ] +]; +prog: [[ e = exp; `EOI -> e ]]; +END ; + +(* and the following function: *) + +value parse_string entry s = +try + G.parse_string entry (Loc.mk "") s +with [ Loc.Exc_located loc exn -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + failwith "Syntax Error" +end ] ; + +parse_string prog "f x"; diff --git a/camlp4/test/fixtures/pr4314gram2.ml b/camlp4/test/fixtures/pr4314gram2.ml new file mode 100644 index 00000000..38a5222e --- /dev/null +++ b/camlp4/test/fixtures/pr4314gram2.ml @@ -0,0 +1,36 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram ; + +value exp = G.Entry.mk "exp" ; +value prog = G.Entry.mk "prog" ; + +EXTEND G +exp: +[ "apply" + [ e1 = exp LEVEL "simple"; e2 = SELF -> + let p = Loc.dump in + let () = + Format.eprintf "e1: %a,@.e2: %a,@.e1-e2: %a,@._loc: %a@." + p e1 p e2 p (Loc.merge e1 e2) p _loc + in + _loc + ] +| "simple" + [ _ = LIDENT -> _loc ] +]; +prog: [[ e = exp; `EOI -> e ]]; +END ; + +(* and the following function: *) + +value parse_string entry s = +try + G.parse_string entry (Loc.mk "") s +with [ Loc.Exc_located loc exn -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + failwith "Syntax Error" +end ] ; + +parse_string prog "f x"; diff --git a/camlp4/test/fixtures/pr4314gram3.ml b/camlp4/test/fixtures/pr4314gram3.ml new file mode 100644 index 00000000..3298bcbf --- /dev/null +++ b/camlp4/test/fixtures/pr4314gram3.ml @@ -0,0 +1,36 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram ; + +value exp = G.Entry.mk "exp" ; +value prog = G.Entry.mk "prog" ; + +EXTEND G +exp: +[ "apply" + [ e1 = SELF; e2 = exp LEVEL "simple" -> + let p = Loc.dump in + let () = + Format.eprintf "e1: %a,@.e2: %a,@.e1-e2: %a,@._loc: %a@." + p e1 p e2 p (Loc.merge e1 e2) p _loc + in + _loc + ] +| "simple" + [ _ = LIDENT -> _loc ] +]; +prog: [[ e = exp; `EOI -> e ]]; +END ; + +(* and the following function: *) + +value parse_string entry s = +try + G.parse_string entry (Loc.mk "") s +with [ Loc.Exc_located loc exn -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + failwith "Syntax Error" +end ] ; + +parse_string prog "f x"; diff --git a/camlp4/test/fixtures/pr4314gram4.ml b/camlp4/test/fixtures/pr4314gram4.ml new file mode 100644 index 00000000..1c6712e2 --- /dev/null +++ b/camlp4/test/fixtures/pr4314gram4.ml @@ -0,0 +1,36 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram ; + +value exp = G.Entry.mk "exp" ; +value prog = G.Entry.mk "prog" ; + +EXTEND G +exp: +[ "apply" + [ e1 = SELF; e2 = exp LEVEL "simple"; e3 = exp LEVEL "simple" -> + let p = Loc.dump in + let () = + Format.eprintf "e1: %a,@.e2: %a,@.e3: %a,@._loc: %a@." + p e1 p e2 p e3 p _loc + in + _loc + ] +| "simple" + [ _ = LIDENT -> _loc ] +]; +prog: [[ e = exp; `EOI -> e ]]; +END ; + +(* and the following function: *) + +value parse_string entry s = +try + G.parse_string entry (Loc.mk "") s +with [ Loc.Exc_located loc exn -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + failwith "Syntax Error" +end ] ; + +parse_string prog "f x y"; diff --git a/camlp4/test/fixtures/pr4314gram5.ml b/camlp4/test/fixtures/pr4314gram5.ml new file mode 100644 index 00000000..bd2fb11c --- /dev/null +++ b/camlp4/test/fixtures/pr4314gram5.ml @@ -0,0 +1,38 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram ; + +value exp = G.Entry.mk "exp" ; +value prog = G.Entry.mk "prog" ; + +EXTEND G +exp: +[ "apply" +[ e1 = SELF; e2 = exp LEVEL "simple"; e3 = SELF -> + let p = Loc.dump in + let () = + Format.eprintf "e1: %a,@.e2: %a,@.e3: %a,@._loc: %a@." + p e1 p e2 p e3 p _loc + in + _loc + ] +| "simple" +[ x = LIDENT; y = LIDENT -> + let () = Format.eprintf "reduce expr simple (%S, %S) at %a@." x y Loc.dump _loc in _loc ] +]; +prog: [[ e = exp; `EOI -> e ]]; +END ; + +(* and the following function: *) + +value parse_string entry s = +try + print_endline s; + G.parse_string entry (Loc.mk "") s +with [ Loc.Exc_located loc exn -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + failwith "Syntax Error" +end ] ; + +parse_string prog "f1 f2 x1 x2 y1 y2"; diff --git a/camlp4/test/fixtures/pr4329.ml b/camlp4/test/fixtures/pr4329.ml new file mode 100644 index 00000000..72f2b787 --- /dev/null +++ b/camlp4/test/fixtures/pr4329.ml @@ -0,0 +1,50 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram; + +value ab_eoi = G.Entry.mk "ab_eoi" ; +value a_or_ab = G.Entry.mk "a_or_ab" ; +value a_or_ab_eoi = G.Entry.mk "a_or_ab_eoi" ; +value c_a_or_ab_eoi = G.Entry.mk "c_a_or_ab_eoi" ; + +EXTEND G +ab_eoi: [[ "a"; "b"; `EOI -> () ]]; +a_or_ab: [[ "a" -> () | "a"; "b" -> () ]]; +a_or_ab_eoi: [[ a_or_ab; `EOI -> () ]]; +c_a_or_ab_eoi: [[ "c"; a_or_ab; `EOI -> () ]]; +END ; + +value parse_string entry s = +try + G.parse_string entry (Loc.mk "") s +with [ Loc.Exc_located loc exn -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + (* failwith "Syntax Error" *) +end ] ; + +(* Consider the following syntax errors: *) +parse_string ab_eoi "a c" ; +(* File "", line 1, characters 2-3 +Stream.Error("illegal begin of ab_eoi") +Exception: Failure "Syntax Error". +--> "Illegal begin": at least the first symbol was correct +--> nevertheless, the reported position is correct +--> The message used to be: "b" then EOI expected after "a" in [ab_eoi] *) + +parse_string a_or_ab_eoi "a c" ; +(* File "", line 1, characters 0-1 +Stream.Error("illegal begin of a_or_ab_eoi") +Exception: Failure "Syntax Error". +--> "Illegal begin": at least the first non-terminal was correct +--> the reported position is weird +--> I think the message used to be either: "b" expected after "a" in +[a_or_ab] +or: EOI expected after [a_or_ab] in [a_or_ab_eoi] *) + +parse_string c_a_or_ab_eoi "c a c" ; +(* File "", line 1, characters 2-3 +Stream.Error("[a_or_ab] expected after \"c\" (in [c_a_or_ab_eoi])") +Exception: Failure "Syntax Error". +--> "[a_or_ab] expected": this is very confusing: there is a valid a_or_ab +there, namely "a" *) diff --git a/camlp4/test/fixtures/pr4330.ml b/camlp4/test/fixtures/pr4330.ml new file mode 100644 index 00000000..19593584 --- /dev/null +++ b/camlp4/test/fixtures/pr4330.ml @@ -0,0 +1,57 @@ +open Camlp4.PreCast ; +module G = Camlp4.PreCast.Gram ; + +value a = G.Entry.mk "a" ; +value a_eoi = G.Entry.mk "a_eoi" ; + +EXTEND G +a: [[ "one" -> 1 | x = a; "plus"; y = a -> x+y ]]; +a_eoi: [[ x = a; `EOI -> x ]]; +END ; + +(* and the following function: *) + +value parse_string entry s o = +try + Printf.eprintf "Parsing %S\n%!" s; + assert (o = Some (G.parse_string entry (Loc.mk "") s)) +with [ Loc.Exc_located loc exn when o <> None -> +begin + print_endline (Loc.to_string loc); + print_endline (Printexc.to_string exn); + assert (o = None) +end +| exn when o = None -> Printf.eprintf "Fail as expected\n%!" +| exn -> begin + Printf.eprintf "Unexpected exception: \n%!"; + print_endline (Printexc.to_string exn); + assert (o = None) +end ] ; + +(* The following is correct: *) + +parse_string a_eoi "one plus one" (Some 2); + +(* While all of the following inputs should be rejected because they are not *) +(* legal according to the grammar: *) + +parse_string a_eoi "one plus" None; +(* - : int = 1 *) +parse_string a_eoi "one plus plus" None; +(* - : int = 1 *) +parse_string a_eoi "one plus one plus" None; +(* - : int = 2 *) +parse_string a_eoi "one plus one plus plus" None; +(* - : int = 2 *) + +(* Curiously, you may only repeat the operator twice. If you specify it three +times, gramlib complains. *) + +parse_string a_eoi "one plus plus plus" None ; +(* File "", line 1, characters 9-13 *) +(* Stream.Error("EOI expected after [a] (in [a_eoi])") *) +(* Exception: Failure "Syntax Error". *) +parse_string a_eoi "one plus one plus plus plus" None ; +(* File "", line 1, characters 18-22 *) +(* Stream.Error("EOI expected after [a] (in [a_eoi])") *) +(* Exception: Failure "Syntax Error". *) diff --git a/camlp4/test/fixtures/pr4357.ml b/camlp4/test/fixtures/pr4357.ml new file mode 100644 index 00000000..2d84004a --- /dev/null +++ b/camlp4/test/fixtures/pr4357.ml @@ -0,0 +1,16 @@ +open Camlp4.PreCast + +let sample_expr _loc _loc_name s = + Printf.eprintf "file=%s line=%d offset=%d bol=%d\n%!" + (Loc.file_name _loc) + (Loc.start_line _loc) + (Loc.start_off _loc) + (Loc.start_bol _loc); + <:expr< $lid:s$ >> +;; + +Quotation.add + "sample" + Syntax.Quotation.DynAst.expr_tag + sample_expr +;; diff --git a/camlp4/test/fixtures/pr4357sample.ml b/camlp4/test/fixtures/pr4357sample.ml new file mode 100644 index 00000000..789bcb8d --- /dev/null +++ b/camlp4/test/fixtures/pr4357sample.ml @@ -0,0 +1,3 @@ +let u = "Hello";; +let s = <:sample>;; +print_string s diff --git a/camlp4/test/fixtures/pr4357sample2.ml b/camlp4/test/fixtures/pr4357sample2.ml new file mode 100644 index 00000000..f6fe8d02 --- /dev/null +++ b/camlp4/test/fixtures/pr4357sample2.ml @@ -0,0 +1,5 @@ +#default_quotation "sample";; +let u = "Hello";; +let s = <>;; +let s = <:sample>;; +print_string s diff --git a/camlp4/test/fixtures/pr4452.ml b/camlp4/test/fixtures/pr4452.ml new file mode 100644 index 00000000..bed7db7b --- /dev/null +++ b/camlp4/test/fixtures/pr4452.ml @@ -0,0 +1,24 @@ +open Camlp4.PreCast + +let _loc = Loc.mk "?" + +let base base fields ty = + let fields = List.fold_right (fun field acc -> + let c = <:ctyp< $lid:field$ : $uid:field$.record >> in + <:ctyp< $c$ ; $acc$ >>) fields <:ctyp< >> + in + <:module_binding< $uid:base$ : + sig type record = { + key : $ty$; + $fields$ + } end = struct + type record = { + key : $ty$; + $fields$ + } end + >> + +let _ = + let b = base "b" ["f1"; "f2"] <:ctyp< int >> in + Camlp4.PreCast.Printers.OCaml.print_implem + <:str_item< module rec $b$ >> diff --git a/camlp4/test/fixtures/private_row.ml b/camlp4/test/fixtures/private_row.ml new file mode 100644 index 00000000..53ada775 --- /dev/null +++ b/camlp4/test/fixtures/private_row.ml @@ -0,0 +1,27 @@ + + +module type Ops = sig + type expr + val eval : expr -> int + end + ;; + + +module Plus = struct + type 'a expr0 = [`Num of int | `Plus of 'a * 'a ] + module F(X : Ops with type expr = private ([> 'a expr0] as 'a)) = + struct + type expr = X.expr expr0 + let eval : expr -> int = function + `Num n -> n + |`Plus(e1,e2) -> X.eval e1 + X.eval e2 + end + module rec L : (Ops with type expr = L.expr expr0) = F(L) + end + ;; + + +open Printf +;; + +let _ = Printf.printf "%d\n%!" (Plus.L.eval (`Plus ((`Num 5),(`Num 2))));; diff --git a/camlp4/test/fixtures/rec.ml b/camlp4/test/fixtures/rec.ml new file mode 100644 index 00000000..1c74b24d --- /dev/null +++ b/camlp4/test/fixtures/rec.ml @@ -0,0 +1,2 @@ +(* rec.ml *) +value rec x = 42; diff --git a/camlp4/test/fixtures/seq.ml b/camlp4/test/fixtures/seq.ml new file mode 100644 index 00000000..dd563d4c --- /dev/null +++ b/camlp4/test/fixtures/seq.ml @@ -0,0 +1,1003 @@ +module M = struct + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; +end; diff --git a/camlp4/test/fixtures/seq2.ml b/camlp4/test/fixtures/seq2.ml new file mode 100644 index 00000000..d47c2540 --- /dev/null +++ b/camlp4/test/fixtures/seq2.ml @@ -0,0 +1,3003 @@ +module M = struct + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; + foo bar; +end; diff --git a/camlp4/test/fixtures/simplify.ml b/camlp4/test/fixtures/simplify.ml new file mode 100644 index 00000000..d910641c --- /dev/null +++ b/camlp4/test/fixtures/simplify.ml @@ -0,0 +1,11 @@ +open Camlp4.PreCast + +let simplify = + object + inherit Ast.map as super + method expr e = + match super#expr e with + | <:expr< $x$ + 0 >> | <:expr< 0 + $x$ >> -> x + | x -> x + end +in AstFilters.register_str_item_filter simplify#str_item diff --git a/camlp4/test/fixtures/simplify_r.ml b/camlp4/test/fixtures/simplify_r.ml new file mode 100644 index 00000000..fa60135f --- /dev/null +++ b/camlp4/test/fixtures/simplify_r.ml @@ -0,0 +1,11 @@ +open Camlp4.PreCast; + +let simplify = + object + inherit Ast.map as super; + method expr e = + match super#expr e with + [ <:expr< $x$ + 0 >> | <:expr< 0 + $x$ >> -> x + | x -> x ]; + end +in AstFilters.register_str_item_filter simplify#str_item; diff --git a/camlp4/test/fixtures/stream-parser-bug.ml b/camlp4/test/fixtures/stream-parser-bug.ml new file mode 100644 index 00000000..6c17793c --- /dev/null +++ b/camlp4/test/fixtures/stream-parser-bug.ml @@ -0,0 +1,6 @@ +let foo = parser + | [< '42; ps >] -> + let ps = ps + 42 in + type_phrases ps + | [< >] -> [< >] + diff --git a/camlp4/test/fixtures/string.ml b/camlp4/test/fixtures/string.ml new file mode 100644 index 00000000..5b0e6466 --- /dev/null +++ b/camlp4/test/fixtures/string.ml @@ -0,0 +1 @@ +"abc"; diff --git a/camlp4/test/fixtures/superfluous.ml b/camlp4/test/fixtures/superfluous.ml new file mode 100644 index 00000000..79b086b9 --- /dev/null +++ b/camlp4/test/fixtures/superfluous.ml @@ -0,0 +1,12 @@ +open Camlp4.PreCast;; +open Syntax;; + +let _loc = Loc.ghost;; +let st = <:str_item< >>;; +let e = <:expr< 1 >> +let bi = <:binding< x = 0 >>;; + +(* none of these holds due to superfluous StSem and StNil *) +assert (Ast.StSem (_loc, st, st) = <:str_item< $st$ $st$ >>);; +assert (Ast.StExp (_loc, e) = <:str_item< $exp:e$ >>);; +assert (Ast.StVal (_loc, bi) = <:str_item< let $bi$ >>);; diff --git a/camlp4/test/fixtures/transform-examples.ml b/camlp4/test/fixtures/transform-examples.ml new file mode 100644 index 00000000..0aea9c4d --- /dev/null +++ b/camlp4/test/fixtures/transform-examples.ml @@ -0,0 +1,3 @@ +<:expr< $x$ + $y$ - $z$ >> -> <:expr< plus_minus $x$ $y$ $z$ >> + +<< List.rev (List.rev $l$) >> -> l diff --git a/camlp4/test/fixtures/try.ml b/camlp4/test/fixtures/try.ml new file mode 100644 index 00000000..90c01a3e --- /dev/null +++ b/camlp4/test/fixtures/try.ml @@ -0,0 +1,6 @@ +try + let f = Sys.getenv "CAMLP4_DEBUG_FILE" + in + foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar +with Not_found -> stderr + diff --git a/camlp4/test/fixtures/tuple_as_retval.ml b/camlp4/test/fixtures/tuple_as_retval.ml new file mode 100644 index 00000000..1dd68e6a --- /dev/null +++ b/camlp4/test/fixtures/tuple_as_retval.ml @@ -0,0 +1,3 @@ +EXTEND Gram + abc: [ [ (x,y) = foo -> x+y ] ]; +END; diff --git a/camlp4/test/fixtures/type.ml b/camlp4/test/fixtures/type.ml new file mode 100644 index 00000000..f17cc50b --- /dev/null +++ b/camlp4/test/fixtures/type.ml @@ -0,0 +1,3 @@ +type t = [ A of int | B of t ]; +type t2 = [ A of int | B of t ]; +type t3 = [ A of int | B of t ]; diff --git a/camlp4/test/fixtures/type_decl.ml b/camlp4/test/fixtures/type_decl.ml new file mode 100644 index 00000000..8610ba29 --- /dev/null +++ b/camlp4/test/fixtures/type_decl.ml @@ -0,0 +1,22 @@ +module M = struct + type t = A of int * int * int * int * int * int * int * int * int * int + | B | B | B | B | B | B | B | B + and t2 = + | B | B | B | B | B | B | B | B + and t3 = + | B | B | B of a * a * a * a * a * a * a * a * a * a * a | B | B | B | B | B + and t4 = + | B | B | B | B | B | B | B | B + and t5 = + | B | B | B | B | B | B | B | B + and t6 = + | B | B | B | A of int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int | B | B | B | B | B + and t7 = + | B | B | B | B | B | B | B | B + and t8 = + | B | B | B | B | B | B | B | B + and t9 = + | B | B | B | B | B | B | B | B + and t10 = + | A of (a * a) +end diff --git a/camlp4/test/fixtures/unit.ml b/camlp4/test/fixtures/unit.ml new file mode 100644 index 00000000..52241dfa --- /dev/null +++ b/camlp4/test/fixtures/unit.ml @@ -0,0 +1,4 @@ +type t1 = ();; +type t2 = unit;; +let x : t1 = ();; +let y : t2 = ();; diff --git a/camlp4/test/fixtures/use.ml b/camlp4/test/fixtures/use.ml new file mode 100644 index 00000000..36e2f695 --- /dev/null +++ b/camlp4/test/fixtures/use.ml @@ -0,0 +1,4 @@ +(* use.ml *) +#use "test/fixtures/rec.ml"; +(* value use *) +value use = 3; diff --git a/camlp4/test/fixtures/where.o.ml b/camlp4/test/fixtures/where.o.ml new file mode 100644 index 00000000..8295d4a2 --- /dev/null +++ b/camlp4/test/fixtures/where.o.ml @@ -0,0 +1 @@ +let where = 42 diff --git a/camlp4/test/fixtures/where.r.ml b/camlp4/test/fixtures/where.r.ml new file mode 100644 index 00000000..e48c3085 --- /dev/null +++ b/camlp4/test/fixtures/where.r.ml @@ -0,0 +1 @@ +x where x = 42; diff --git a/camlp4/unmaintained/Makefile b/camlp4/unmaintained/Makefile new file mode 100644 index 00000000..b6db0753 --- /dev/null +++ b/camlp4/unmaintained/Makefile @@ -0,0 +1,20 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# The unmaintained directory +# + +include ../config/Makefile.cnf + +DIRS=format lefteval ocamllex olabl scheme sml + +include ../config/Makefile.base diff --git a/camlp4/unmaintained/compile/.cvsignore b/camlp4/unmaintained/compile/.cvsignore new file mode 100644 index 00000000..47817cce --- /dev/null +++ b/camlp4/unmaintained/compile/.cvsignore @@ -0,0 +1,4 @@ +*.fast +*.fast.opt +o_fast.ml +pa_o_fast.ml diff --git a/camlp4/unmaintained/compile/.depend b/camlp4/unmaintained/compile/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/compile/Makefile b/camlp4/unmaintained/compile/Makefile new file mode 100644 index 00000000..bd4078f2 --- /dev/null +++ b/camlp4/unmaintained/compile/Makefile @@ -0,0 +1,37 @@ + + +include ../config/Makefile.cnf + +INCLUDES=-I ../camlp4 -I ../lib +SRC=../etc/pa_o.ml ../etc/pa_op.ml # FIXME and why not pa_$D.ml? +D=o +COMP_OPT=-strict_parsing -e "Grammar.Entry.obj Pcaml.interf" -e "Grammar.Entry.obj Pcaml.implem" -e "Grammar.Entry.obj Pcaml.top_phrase" -e "Grammar.Entry.obj Pcaml.use_file" +CLEANFILES=pa_*_fast.ml *_fast.ml + +# FIXME +EXECUTABLES=#camlp4$D.fast + +include ../config/Makefile.base + +WARNINGS=Ay + +camlp4$D.fast: pa_$D_fast.cmo + rm -f camlp4$D.fast + cd ../camlp4; $(MAKE) CAMLP4=../compile/camlp4$D.fast CAMLP4M="../compile/pa_$D_fast.cmo ../meta/pr_dump.cmo" + +camlp4$D.fast.opt: pa_$D_fast.cmx + rm -f camlp4$D.fast.opt + cd ../camlp4; $(MAKE) ../compile/camlp4$D.fast.opt CAMLP4OPT=../compile/camlp4$D.fast.opt CAMLP4M="../compile/pa_$D_fast.cmx ../meta/pr_dump.cmx" + +pa_$D_fast.ml: comp_head.ml $D_fast.ml comp_trail.ml + cat $(SRC) | sed -e "s/Plexer.make_lexer *()/P.lexer_pos/" -e "/EXTEND/,/END/d" -e "/Grammar.Entry.of_parser/d" -e "/Grammar.Entry.gcreate/d" | cat comp_head.ml - $D_fast.ml comp_trail.ml > pa_$D_fast.ml + +$D_fast.ml: compile.cmo $(SRC) + echo '(* camlp4r *)' >$D_fast.ml + OTOP=$(OTOP) EXE=$(EXE) ./compile.sh $(COMP_OPT) $(SRC) >> $D_fast.ml + +install-local: + if test -f camlp4$D.fast.opt; then cp camlp4$D.fast.opt $(BINDIR)/camlp4$D.opt$(EXE); fi + for TARG in pa_$D_fast.cmi pa_$D_fast.cmo pa_$D_fast.cmx ; do if test -f $$TARG; then cp $$TARG "$(LIBDIR)/camlp4/."; fi; done + +include .depend diff --git a/camlp4/unmaintained/compile/comp_head.ml b/camlp4/unmaintained/compile/comp_head.ml new file mode 100644 index 00000000..cd623436 --- /dev/null +++ b/camlp4/unmaintained/compile/comp_head.ml @@ -0,0 +1,70 @@ +(* camlp4r q_MLast.cmo pa_extend.cmo *) + + +module P = + struct + value gloc bp strm = Grammar.loc_of_token_interval bp (Stream.count strm); + value list0 symb = + let rec loop al = + parser + [ [: a = symb; s :] -> loop [a :: al] s + | [: :] -> al ] + in + parser [: a = loop [] :] -> List.rev a + ; + value list0sep symb sep = + let rec kont al = + parser + [ [: v = sep; a = symb; s :] -> kont [a :: al] s + | [: :] -> al ] + in + parser + [ [: a = symb; s :] -> List.rev (kont [a] s) + | [: :] -> [] ] + ; + value list1 symb = + let rec loop al = + parser + [ [: a = symb; s :] -> loop [a :: al] s + | [: :] -> al ] + in + parser [: a = symb; s :] -> List.rev (loop [a] s) + ; + value list1sep symb sep = + let rec kont al = + parser + [ [: v = sep; a = symb; s :] -> kont [a :: al] s + | [: :] -> al ] + in + parser [: a = symb; s :] -> List.rev (kont [a] s) + ; + value option f = + parser + [ [: x = f :] -> Some x + | [: :] -> None ] + ; + value token (p_con, p_prm) = + if p_prm = "" then parser [: `(con, prm) when con = p_con :] -> prm + else parser [: `(con, prm) when con = p_con && prm = p_prm :] -> prm + ; + value orzero f f0 = + parser bp + [ [: x = f :] -> x + | [: x = f0 :] ep -> +(* +let (loc1, loc2) = Grammar.loc_of_token_interval bp ep in +let _ = do { Printf.eprintf "recovered or_zero at loc (%d, %d)\n" loc1 loc2; flush stderr } in +*) + x ] + ; + value error entry prev_symb symb = + symb ^ " expected" ^ + (if prev_symb = "" then "" else " after " ^ prev_symb) ^ + " (in [" ^ entry ^ "])" + ; + value lexer = Plexer.gmake(); + end +; + +(****************************************) + diff --git a/camlp4/unmaintained/compile/comp_trail.ml b/camlp4/unmaintained/compile/comp_trail.ml new file mode 100644 index 00000000..75f40abb --- /dev/null +++ b/camlp4/unmaintained/compile/comp_trail.ml @@ -0,0 +1,33 @@ +(* camlp4r pa_extend.cmo *) +(****************************************) + +value interf_p = + Grammar.Entry.of_parser Pcaml.gram "interf" interf_0 +; + +value implem_p = + Grammar.Entry.of_parser Pcaml.gram "implem" implem_0 +; + +value top_phrase_p = + Grammar.Entry.of_parser Pcaml.gram "top_phrase" top_phrase_0 +; + +value use_file_p = + Grammar.Entry.of_parser Pcaml.gram "use_file" use_file_0 +; + +EXTEND + interf: + [ [ x = interf_p -> x ] ] + ; + implem: + [ [ x = implem_p -> x ] ] + ; + top_phrase: + [ [ x = top_phrase_p -> x ] ] + ; + use_file: + [ [ x = use_file_p -> x ] ] + ; +END; diff --git a/camlp4/unmaintained/compile/compile.ml b/camlp4/unmaintained/compile/compile.ml new file mode 100644 index 00000000..b5e6ba5a --- /dev/null +++ b/camlp4/unmaintained/compile/compile.ml @@ -0,0 +1,574 @@ +(* camlp4r *) + + +open Gramext; + +value strict_parsing = ref False; +value keywords = ref []; + +value _loc = Loc.ghost; + +(* Watch the segmentation faults here! the compiled file must have been + loaded in camlp4 with the option pa_extend.cmo -meta_action. *) +value magic_act (act : Obj.t) : MLast.expr = Obj.magic act; + +(* Names of symbols for error messages; code borrowed to grammar.ml *) + +value rec name_of_symbol entry = + fun + [ Snterm e -> "[" ^ e.ename ^ "]" + | Snterml e l -> "[" ^ e.ename ^ " level " ^ l ^ "]" + | Sself | Snext -> "[" ^ entry.ename ^ "]" + | Stoken tok -> entry.egram.glexer.Token.tok_text tok + | _ -> "???" ] +; + +value rec name_of_symbol_failed entry = + fun + [ Slist0 s -> name_of_symbol_failed entry s + | Slist0sep s _ -> name_of_symbol_failed entry s + | Slist1 s -> name_of_symbol_failed entry s + | Slist1sep s _ -> name_of_symbol_failed entry s + | Sopt s -> name_of_symbol_failed entry s + | Stree t -> name_of_tree_failed entry t + | s -> name_of_symbol entry s ] +and name_of_tree_failed entry = + fun + [ Node {node = s; brother = bro; son = son} -> + let txt = name_of_symbol_failed entry s in + let txt = + match (s, son) with + [ (Sopt _, Node _) -> txt ^ " or " ^ name_of_tree_failed entry son + | _ -> txt ] + in + let txt = + match bro with + [ DeadEnd | LocAct _ _ -> txt + | _ -> txt ^ " or " ^ name_of_tree_failed entry bro ] + in + txt + | DeadEnd | LocAct _ _ -> "???" ] +; + +value tree_failed entry prev_symb tree = + let (s2, s3) = + let txt = name_of_tree_failed entry tree in + match prev_symb with + [ Slist0 s -> + let txt1 = name_of_symbol_failed entry s in + ("", txt1 ^ " or " ^ txt) + | Slist1 s -> + let txt1 = name_of_symbol_failed entry s in + ("", txt1 ^ " or " ^ txt) + | Slist0sep s sep -> + let txt1 = name_of_symbol_failed entry s in + ("", txt1 ^ " or " ^ txt) + | Slist1sep s sep -> + let txt1 = name_of_symbol_failed entry s in + ("", txt1 ^ " or " ^ txt) + | Sopt _ | Stree _ -> ("", txt) + | _ -> (name_of_symbol entry prev_symb, txt) ] + in + <:expr< + P.error $str:entry.ename$ $`str:s2$ $`str:s3$ + >> +; + +(* Compilation *) + +value rec find_act = + fun + [ DeadEnd -> failwith "find_act" + | LocAct act _ -> (magic_act act, 0) + | Node {son = son; brother = bro} -> + let (act, n) = try find_act son with [ Failure _ -> find_act bro ] in + (act, n + 1) ] +; + +value level_number e l = + match e.edesc with + [ Dlevels elevs -> + loop 0 elevs where rec loop n = + fun + [ [lev :: levs] -> if lev.lname = Some l then n else loop (n + 1) levs + | [] -> failwith ("level " ^ l ^ " not found in entry " ^ e.ename) ] + | Dparser _ -> 0 ] +; + +value nth_patt_of_act (e, n) = + let patt_list = + loop e where rec loop = + fun + [ <:expr< fun (_loc : Locaction.t) -> $_$ >> -> + [] + | <:expr< fun ($p$ : $_$) -> $e$ >> -> [p :: loop e] + | <:expr< fun $p$ -> $e$ >> -> [p :: loop e] + | _ -> failwith "nth_patt_of_act" ] + in + List.nth patt_list n +; + +value rec last_patt_of_act = + fun + [ <:expr< fun ($p$ : $_$) (_loc : Locaction.t) -> + $_$ >> -> p + | <:expr< fun $_$ -> $e$ >> -> last_patt_of_act e + | _ -> failwith "last_patt_of_act" ] +; + +#load "pr_r.cmo"; +value rec final_action = + fun + [ + <:expr< fun (_loc : Loc.t) -> ($e$ : $_$) >> -> e + | <:expr< fun $_$ -> $e$ >> -> final_action e + | ast -> do { + print_endline "final_action failed"; + Pcaml.print_implem.val [(MLast.StExp _loc ast, _loc)]; + failwith "final_action"; + } ] +; + +value parse_standard_symbol e rkont fkont ending_act = + <:expr< + match try Some ($e$ __strm) with [ Stream.Failure -> None ] with + [ Some $nth_patt_of_act ending_act$ -> $rkont$ + | _ -> $fkont$ ] + >> +; + +value parse_symbol_no_failure e rkont fkont ending_act = + <:expr< + let $nth_patt_of_act ending_act$ = + try $e$ __strm with [ Stream.Failure -> raise (Stream.Error "") ] + in + $rkont$ + >> +; + +value rec contain_loc = + fun + [ <:expr< $lid:s$ >> -> (s = "loc") || (s = "_loc") + | <:expr< $uid:_$ >> -> False + | <:expr< $str:_$ >> -> False + | <:expr< ($list:el$) >> -> List.exists contain_loc el + | <:expr< $e1$ $e2$ >> -> contain_loc e1 || contain_loc e2 + | _ -> True ] +; + +value gen_let_loc _loc e = + if contain_loc e then <:expr< let _loc = P.gloc bp __strm in $e$ >> else e +; + +value phony_entry = Grammar.Entry.obj Pcaml.implem; + +value rec parse_tree entry nlevn alevn (tree, fst_symb) act_kont kont = + match tree with + [ DeadEnd -> kont + | LocAct act _ -> + let act = magic_act act in + act_kont False act + | Node {node = Sself; son = LocAct act _; brother = bro} -> + let act = magic_act act in + let n = entry.ename ^ "_" ^ string_of_int alevn in + let e = + if strict_parsing.val || alevn = 0 || fst_symb then <:expr< $lid:n$ >> + else <:expr< P.orzero $lid:n$ $lid:entry.ename ^ "_0"$ >> + in + let p2 = + match bro with + [ DeadEnd -> kont + | _ -> parse_tree entry nlevn alevn (bro, fst_symb) act_kont kont ] + in + let p1 = act_kont True act in + parse_standard_symbol e p1 p2 (act, 0) + | Node {node = s; son = LocAct act _; brother = bro} -> + let act = magic_act act in + let p2 = parse_tree entry nlevn alevn (bro, fst_symb) act_kont kont in + let p1 = act_kont False act in + parse_symbol entry nlevn s p1 p2 (act, 0) + | Node {node = s; son = son; brother = bro} -> + let p2 = parse_tree entry nlevn alevn (bro, fst_symb) act_kont kont in + let p1 = + let err = + let txt = tree_failed entry s son in + <:expr< raise (Stream.Error $txt$) >> + in + match son with + [ Node {brother = DeadEnd} -> + parse_tree entry nlevn alevn (son, False) act_kont err + | _ -> + let p1 = + parse_tree entry nlevn alevn (son, True) act_kont + <:expr< raise Stream.Failure >> + in + <:expr< try $p1$ with [ Stream.Failure -> $err$ ] >> ] + in + parse_symbol entry nlevn s p1 p2 (find_act son) ] +and parse_symbol entry nlevn s rkont fkont ending_act = + match s with + [ Slist0 s -> + let e = <:expr< P.list0 $symbol_parser entry nlevn s$ >> in + parse_symbol_no_failure e rkont fkont ending_act + | Slist1 s -> + let e = <:expr< P.list1 $symbol_parser entry nlevn s$ >> in + parse_standard_symbol e rkont fkont ending_act + | Slist0sep s sep -> + let e = + <:expr< + P.list0sep $symbol_parser entry nlevn s$ + $symbol_parser entry nlevn sep$ >> + in + parse_symbol_no_failure e rkont fkont ending_act + | Slist1sep s sep -> + let e = + <:expr< + P.list1sep $symbol_parser entry nlevn s$ + $symbol_parser entry nlevn sep$ >> + in + parse_standard_symbol e rkont fkont ending_act + | Sopt s -> + let e = <:expr< P.option $symbol_parser entry nlevn s$ >> in + parse_symbol_no_failure e rkont fkont ending_act + | Stree tree -> + let kont = <:expr< raise Stream.Failure >> in + let act_kont _ act = gen_let_loc _loc (final_action act) in + let e = parse_tree phony_entry 0 0 (tree, True) act_kont kont in + parse_standard_symbol <:expr< fun __strm -> $e$ >> rkont fkont ending_act + | Snterm e -> + let n = + match e.edesc with + [ Dparser _ -> e.ename + | Dlevels _ -> e.ename ^ "_0" ] + in + parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act + | Snterml e l -> + let n = e.ename ^ "_" ^ string_of_int (level_number e l) in + parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act + | Sself -> + let n = entry.ename ^ "_0" in + parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act + | Snext -> + let n = entry.ename ^ "_" ^ string_of_int nlevn in + parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act + | Stoken tok -> + let _ = + do { + if fst tok = "" && not (List.mem (snd tok) keywords.val) then + keywords.val := [snd tok :: keywords.val] + else () + } + in + let p = + let patt = nth_patt_of_act ending_act in + let p_con = fst tok in + let p_prm = snd tok in + if snd tok = "" then + if fst tok = "ANY" then <:patt< (_, $patt$) >> + else <:patt< ($`str:p_con$, $patt$) >> + else + match patt with + [ <:patt< _ >> -> <:patt< ($`str:p_con$, $`str:p_prm$) >> + | _ -> <:patt< ($`str:p_con$, ($`str:p_prm$ as $patt$)) >> ] + in + <:expr< + match Stream.peek __strm with + [ Some $p$ -> do { Stream.junk __strm; $rkont$ } + | _ -> $fkont$ ] + >> + | _ -> + parse_standard_symbol <:expr< not_impl >> rkont fkont ending_act ] +and symbol_parser entry nlevn = + fun + [ Snterm e -> + let n = e.ename ^ "_0" in + <:expr< $lid:n$ >> + | Snterml e l -> + let n = e.ename ^ "_" ^ string_of_int (level_number e l) in + <:expr< $lid:n$ >> + | Snext -> + let n = entry.ename ^ "_" ^ string_of_int nlevn in + if strict_parsing.val then <:expr< $lid:n$ >> + else + let n0 = entry.ename ^ "_0" in + <:expr< P.orzero $lid:n$ $lid:n0$ >> + | Stoken tok -> + let _ = + do { + if fst tok = "" && not (List.mem (snd tok) keywords.val) then + keywords.val := [snd tok :: keywords.val] + else () + } + in + <:expr< P.token ($`str:fst tok$, $`str:snd tok$) >> + | Stree tree -> + let kont = <:expr< raise Stream.Failure >> in + let act_kont _ act = final_action act in + <:expr< + fun __strm -> + $parse_tree phony_entry 0 0 (tree, True) act_kont kont$ + >> + | _ -> + <:expr< aaa >> ] +; + +value rec start_parser_of_levels entry clevn levs = + let n = entry.ename ^ "_" ^ string_of_int clevn in + let next = entry.ename ^ "_" ^ string_of_int (clevn + 1) in + let p = <:patt< $lid:n$ >> in + match levs with + [ [] -> [Some (p, <:expr< fun __strm -> raise Stream.Failure >>)] + | [lev :: levs] -> + let pel = start_parser_of_levels entry (succ clevn) levs in + match lev.lprefix with + [ DeadEnd -> + let ncont = + if not strict_parsing.val && clevn = 0 then + entry.ename ^ "_gen_cont" + else entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" + in + let curr = + <:expr< let a = $lid:next$ __strm in $lid:ncont$ bp a __strm >> + in + let curr = <:expr< let bp = Stream.count __strm in $curr$ >> in + let e = <:expr< fun __strm -> $curr$ >> in + let pel = if levs = [] then [] else pel in + [Some (p, e) :: pel] + | tree -> + let alevn = clevn in + let (kont, pel) = + match levs with + [ [] -> (<:expr< raise Stream.Failure >>, []) + | _ -> + let e = + match (lev.assoc, lev.lsuffix) with + [ (NonA, _) | (_, DeadEnd) -> <:expr< $lid:next$ __strm >> + | _ -> + let ncont = + entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" + in + <:expr< + let a = $lid:next$ __strm in + $lid:ncont$ bp a __strm + >> ] + in + (e, pel) ] + in + let act_kont end_with_self act = + if lev.lsuffix = DeadEnd then gen_let_loc _loc (final_action act) + else + let ncont = entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" in + gen_let_loc _loc + <:expr< $lid:ncont$ bp $final_action act$ __strm >> + in + let curr = + parse_tree entry (succ clevn) alevn (tree, True) act_kont kont + in + let curr = <:expr< let bp = Stream.count __strm in $curr$ >> in + let e = <:expr< fun __strm -> $curr$ >> in + [Some (p, e) :: pel] ] ] +; + +value rec continue_parser_of_levels entry clevn levs = + let n = entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" in + let p = <:patt< $lid:n$ >> in + match levs with + [ [] -> [None] + | [lev :: levs] -> + let pel = continue_parser_of_levels entry (succ clevn) levs in + match lev.lsuffix with + [ DeadEnd -> + [None :: pel] + | tree -> + let alevn = + match lev.assoc with + [ LeftA | NonA -> succ clevn + | RightA -> clevn ] + in + let (kont, pel) = + match levs with + [ [] -> (<:expr< a__ >>, []) + | _ -> (<:expr< a__ >>, pel) ] + in + let act_kont end_with_self act = + let p = last_patt_of_act act in + match lev.assoc with + [ RightA | NonA -> + <:expr< + let $p$ = a__ in + $gen_let_loc _loc (final_action act)$ + >> + | LeftA -> + let ncont = + entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" + in + gen_let_loc _loc + <:expr< + let $p$ = a__ in + $lid:ncont$ bp $final_action act$ __strm + >> ] + in + let curr = + parse_tree entry (succ clevn) alevn (tree, True) act_kont kont + in + let e = <:expr< fun bp a__ __strm -> $curr$ >> in + [Some (p, e) :: pel] ] ] +; + +value continue_parser_of_levels_again entry levs = + let n = entry.ename ^ "_gen_cont" in + let e = + loop <:expr< a__ >> 0 levs where rec loop var levn = + fun + [ [] -> <:expr< if x == a__ then x else $lid:n$ bp x __strm >> + | [lev :: levs] -> + match lev.lsuffix with + [ DeadEnd -> loop var (levn + 1) levs + | _ -> + let n = entry.ename ^ "_" ^ string_of_int levn ^ "_cont" in + let rest = loop <:expr< x >> (levn + 1) levs in + <:expr< let x = $lid:n$ bp $var$ __strm in $rest$ >> ] ] + in + (<:patt< $lid:n$ >>, <:expr< fun bp a__ __strm -> $e$ >>) +; + +value empty_entry ename = + let p = <:patt< $lid:ename$ >> in + let e = + <:expr< + fun __strm -> + raise (Stream.Error $str:"entry [" ^ ename ^ "] is empty"$) >> + in + [Some (p, e)] +; + +value start_parser_of_entry entry = + match entry.edesc with + [ Dlevels [] -> empty_entry entry.ename + | Dlevels elev -> start_parser_of_levels entry 0 elev + | Dparser p -> [] ] +; + +value continue_parser_of_entry entry = + match entry.edesc with + [ Dlevels elev -> continue_parser_of_levels entry 0 elev + | Dparser p -> [] ] +; + +value continue_parser_of_entry_again entry = + if strict_parsing.val then [] + else + match entry.edesc with + [ Dlevels ([_; _ :: _] as levs) -> + [continue_parser_of_levels_again entry levs] + | _ -> [] ] +; + +value rec list_alternate l1 l2 = + match (l1, l2) with + [ ([x1 :: l1], [x2 :: l2]) -> [x1; x2 :: list_alternate l1 l2] + | ([], l2) -> l2 + | (l1, []) -> l1 ] +; + +value compile_entry entry = + let pel1 = start_parser_of_entry entry in + let pel2 = continue_parser_of_entry entry in + let pel = list_alternate pel1 pel2 in + List.fold_right + (fun pe list -> + match pe with + [ Some pe -> [pe :: list] + | None -> list ]) + pel (continue_parser_of_entry_again entry) +; + +(* get all entries connected together *) + +value rec scan_tree list = + fun + [ Node {node = n; son = son; brother = bro} -> + let list = scan_symbol list n in + let list = scan_tree list son in + let list = scan_tree list bro in + list + | LocAct _ _ | DeadEnd -> list ] +and scan_symbol list = + fun + [ Snterm e -> scan_entry list e + | Snterml e l -> scan_entry list e + | Slist0 s -> scan_symbol list s + | Slist0sep s sep -> scan_symbol (scan_symbol list s) sep + | Slist1 s -> scan_symbol list s + | Slist1sep s sep -> scan_symbol (scan_symbol list s) sep + | Sopt s -> scan_symbol list s + | Stree t -> scan_tree list t + | Smeta _ _ _ | Sself | Snext | Stoken _ -> list ] +and scan_level list lev = + let list = scan_tree list lev.lsuffix in + let list = scan_tree list lev.lprefix in + list +and scan_levels list levs = List.fold_left scan_level list levs +and scan_entry list entry = + if List.memq entry list then list + else + match entry.edesc with + [ Dlevels levs -> scan_levels [entry :: list] levs + | Dparser _ -> list ] +; + +value all_entries_in_graph list entry = + List.rev (scan_entry list entry) +; + +(* main *) + +value entries = ref []; + +value rec list_mem_right_assoc x = + fun + [ [] -> False + | [(a, b) :: l] -> x = b || list_mem_right_assoc x l ] +; + +value rec expr_list = + fun + [ [] -> <:expr< [] >> + | [x :: l] -> <:expr< [$`str:x$ :: $expr_list l$] >> ] +; + +value compile () = + let _ = do { keywords.val := []; } in + let list = List.fold_left all_entries_in_graph [] entries.val in + let list = + List.filter (fun e -> List.memq e list) entries.val @ + List.filter (fun e -> not (List.memq e entries.val)) list + in + let list = + let set = ref [] in + List.fold_right + (fun entry list -> + if List.mem entry.ename set.val then + list + else do { set.val := [entry.ename :: set.val]; [entry :: list] }) + list [] + in + let pell = List.map compile_entry list in + let pel = List.flatten pell in + let si1 = <:str_item< value rec $list:pel$ >> in + let si2 = + let list = List.sort compare keywords.val in + <:str_item< + List.iter (fun kw -> P.lexer.Token.tok_using ("", kw)) + $expr_list list$ + >> + in + let loc = Loc.ghost in + ([(si1, loc); (si2, loc)], False) +; + +Pcaml.parse_implem.val := fun _ _ -> compile (); + +Pcaml.add_option "-strict_parsing" (Arg.Set strict_parsing) + "Don't generate error recovering by trying continuations or first levels" +; diff --git a/camlp4/unmaintained/compile/compile.sh b/camlp4/unmaintained/compile/compile.sh new file mode 100755 index 00000000..a2f4f773 --- /dev/null +++ b/camlp4/unmaintained/compile/compile.sh @@ -0,0 +1,27 @@ +#!/bin/sh -e + +ARGS= +FILES= +ENTRIES= +while test "" != "$1"; do + case $1 in + -e) + shift; + if test "$ENTRIES" != ""; then ENTRIES="$ENTRIES; "; fi + ENTRIES="$ENTRIES$1";; + *.ml*) FILES="$FILES $1";; + *) ARGS="$ARGS $1";; + esac + shift +done + +cat $FILES | sed -e 's/Pcaml.parse_i.*$//' > tmp.ml +echo "Compile.entries.val := [$ENTRIES];" >> tmp.ml +> tmp.mli +set -x +$OTOP/boot/ocamlrun$EXE $OTOP/boot/ocamlc -I $OTOP/boot -c tmp.mli +$OTOP/boot/ocamlrun$EXE ../boot/camlp4boot$EXE -meta_action tmp.ml -o tmp.ppo +$OTOP/boot/ocamlrun$EXE $OTOP/boot/ocamlc -I $OTOP/boot -I ../lib -I ../camlp4 -c -impl tmp.ppo +rm tmp.ppo +> tmp.null +$OTOP/boot/ocamlrun$EXE ../camlp4/camlp4$EXE ./compile.cmo ./tmp.cmo ../etc/pr_r.cmo ../etc/pr_rp.cmo $ARGS -sep "\n\n" -impl tmp.null && rm tmp.* diff --git a/camlp4/unmaintained/etc/.cvsignore b/camlp4/unmaintained/etc/.cvsignore new file mode 100644 index 00000000..50d8a8ea --- /dev/null +++ b/camlp4/unmaintained/etc/.cvsignore @@ -0,0 +1,7 @@ +*.cm[oia] +camlp4o +camlp4sch +camlp4o.opt +version.sh +mkcamlp4.sh +mkcamlp4.mpw diff --git a/camlp4/unmaintained/etc/.depend b/camlp4/unmaintained/etc/.depend new file mode 100644 index 00000000..863adc1c --- /dev/null +++ b/camlp4/unmaintained/etc/.depend @@ -0,0 +1,6 @@ +parserify.cmo: parserify.cmi +parserify.cmx: parserify.cmi +pr_op_main.cmo: parserify.cmi +pr_op_main.cmx: parserify.cmx +pr_rp_main.cmo: parserify.cmi +pr_rp_main.cmx: parserify.cmx diff --git a/camlp4/unmaintained/etc/Makefile b/camlp4/unmaintained/etc/Makefile new file mode 100644 index 00000000..47bc4120 --- /dev/null +++ b/camlp4/unmaintained/etc/Makefile @@ -0,0 +1,62 @@ + + +include ../config/Makefile.cnf + +INCLUDES=-I ../camlp4 -I ../lib -I ../meta -I $(OTOP)/lex -I $(OTOP)/parsing +OBJS=q_phony.cmo pa_o.cmo pa_op.cmo pa_oop.cmo pa_ru.cmo pa_extfun.cmo pa_fstream.cmo pa_ifdef.cmo pr_r.cmo pr_rp.cmo pr_o.cmo pr_op.cmo pr_extend.cmo pr_extfun.cmo pr_null.cmo pr_depend.cmo genTraversal.cmo fi_exc_tracer.cmo +INTF=pa_o.cmi +CAMLP4OM=pa_o.cmo pa_op.cmo ../meta/pr_dump.cmo +CAMLP4OMX=$(CAMLP4OM:.cmo=.cmx) +EXECUTABLES=camlp4o + +include ../config/Makefile.base + +all-local: mkcamlp4.sh + +pr_rp.cmo: parserify.cmo pr_rp_main.cmo + $(OCAMLC) parserify.cmo pr_rp_main.cmo -a -o $@ + +pr_op.cmo: parserify.cmo pr_op_main.cmo + $(OCAMLC) parserify.cmo pr_op_main.cmo -a -o $@ + +pr_rp.cmx: parserify.cmx pr_rp_main.cmx + $(OCAMLOPT) parserify.cmx pr_rp_main.cmx -a -o pr_rp.cmxa + mv pr_rp.cmxa pr_rp.cmx + mv pr_rp.$(A) pr_rp.$(O) + +pr_op.cmx: parserify.cmx pr_op_main.cmx + $(OCAMLOPT) parserify.cmx pr_op_main.cmx -a -o pr_op.cmxa + mv pr_op.cmxa pr_op.cmx + mv pr_op.$(A) pr_op.$(O) + +camlp4o$(EXE): ../camlp4/camlp4$(EXE) $(CAMLP4OM) + rm -f camlp4o$(EXE) + cd ../camlp4; $(MAKE) CAMLP4=../etc/camlp4o$(EXE) CAMLP4M="-I ../etc $(CAMLP4OM)" + +camlp4o.opt: $(CAMLP4OMX) + rm -f camlp4o.opt + cd ../camlp4; $(MAKE) ../etc/camlp4o.opt CAMLP4OPT=../etc/camlp4o.opt CAMLP4M="-I ../etc $(CAMLP4OMX)" + +mkcamlp4.sh: mkcamlp4.sh.tpl version.sh + sed -e "s!LIBDIR!$(LIBDIR)!g" -e "/define VERSION/r version.sh" \ + mkcamlp4.sh.tpl > mkcamlp4.sh + +version.sh : $(OTOP)/VERSION + echo "VERSION=\"`sed -e 1q ../VERSION`\"" >version.sh + +install-local: + -$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)" + cp $(OBJS) "$(LIBDIR)/camlp4/." + cp $(INTF) "$(LIBDIR)/camlp4/." + cp camlp4o$(EXE) "$(BINDIR)/." + if test -f camlp4o.opt; then \ + cp camlp4o.opt "$(BINDIR)/camlp4o.opt$(EXE)"; \ + cp $(OBJSX) "$(LIBDIR)/camlp4/."; \ + for file in $(OBJSX); do \ + cp "`echo $$file | sed -e 's/\.cmx$$/.$(O)/'`" "$(LIBDIR)/camlp4/."; \ + done ; \ + fi + cp mkcamlp4.sh "$(BINDIR)/mkcamlp4" + chmod a+x "$(BINDIR)/mkcamlp4" + +include .depend diff --git a/camlp4/unmaintained/etc/pa_fstream.ml b/camlp4/unmaintained/etc/pa_fstream.ml new file mode 100644 index 00000000..e5027b58 --- /dev/null +++ b/camlp4/unmaintained/etc/pa_fstream.ml @@ -0,0 +1,163 @@ +(* camlp4r pa_extend.cmo q_MLast.cmo *) + + +open Pcaml; + +type spat_comp = + [ SpTrm of Loc.t and MLast.patt and option MLast.expr + | SpNtr of Loc.t and MLast.patt and MLast.expr + | SpStr of Loc.t and MLast.patt ] +; +type sexp_comp = + [ SeTrm of Loc.t and MLast.expr + | SeNtr of Loc.t and MLast.expr ] +; + +(* parsers *) + +value strm_n = "__strm"; +value next_fun _loc = <:expr< Fstream.next >>; + +value rec pattern_eq_expression p e = + match (p, e) with + [ (<:patt< $lid:a$ >>, <:expr< $lid:b$ >>) -> a = b + | (<:patt< $uid:a$ >>, <:expr< $uid:b$ >>) -> a = b + | (<:patt< $p1$ $p2$ >>, <:expr< $e1$ $e2$ >>) -> + pattern_eq_expression p1 e1 && pattern_eq_expression p2 e2 + | (<:patt< ($list:pl$) >>, <:expr< ($list:el$) >>) -> + loop pl el where rec loop pl el = + match (pl, el) with + [ ([p :: pl], [e :: el]) -> + pattern_eq_expression p e && loop pl el + | ([], []) -> True + | _ -> False ] + | _ -> False ] +; + +value stream_pattern_component skont = + fun + [ SpTrm _loc p wo -> + let p = <:patt< Some ($p$, $lid:strm_n$) >> in + if wo = None && pattern_eq_expression p skont then + <:expr< $next_fun _loc$ $lid:strm_n$ >> + else + <:expr< match $next_fun _loc$ $lid:strm_n$ with + [ $p$ $when:wo$ -> $skont$ + | _ -> None ] >> + | SpNtr _loc p e -> + let p = <:patt< Some ($p$, $lid:strm_n$) >> in + if pattern_eq_expression p skont then <:expr< $e$ $lid:strm_n$ >> + else + <:expr< match $e$ $lid:strm_n$ with + [ $p$ -> $skont$ + | _ -> None ] >> + | SpStr _loc p -> + <:expr< let $p$ = $lid:strm_n$ in $skont$ >> ] +; + +value rec stream_pattern _loc epo e = + fun + [ [] -> + let e = + match epo with + [ Some ep -> <:expr< let $ep$ = Fstream.count $lid:strm_n$ in $e$ >> + | None -> e ] + in + <:expr< Some ($e$, $lid:strm_n$) >> + | [spc :: spcl] -> + let skont = stream_pattern _loc epo e spcl in + stream_pattern_component skont spc ] +; + +value rec parser_cases _loc = + fun + [ [] -> <:expr< None >> + | [(spcl, epo, e) :: spel] -> + match parser_cases _loc spel with + [ <:expr< None >> -> stream_pattern _loc epo e spcl + | pc -> + <:expr< match $stream_pattern _loc epo e spcl$ with + [ Some _ as x -> x + | None -> $pc$ ] >> ] ] +; + +value cparser_match _loc me bpo pc = + let pc = parser_cases _loc pc in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >> + | None -> pc ] + in + <:expr< let ($lid:strm_n$ : Stream.t _) = $me$ in $e$ >> +; + +value cparser _loc bpo pc = + let e = parser_cases _loc pc in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Fstream.count $lid:strm_n$ in $e$ >> + | None -> e ] + in + let p = <:patt< ($lid:strm_n$ : Fstream.t _) >> in <:expr< fun $p$ -> $e$ >> +; + +(* streams *) + +value slazy _loc x = <:expr< fun () -> $x$ >>; + +value rec cstream _loc = + fun + [ [] -> <:expr< Fstream.nil >> + | [SeTrm _loc e :: sel] -> + let e2 = cstream _loc sel in + let x = <:expr< Fstream.cons $e$ $e2$ >> in + <:expr< Fstream.flazy $slazy _loc x$ >> + | [SeNtr _loc e] -> + e + | [SeNtr _loc e :: sel] -> + let e2 = cstream _loc sel in + let x = <:expr< Fstream.app $e$ $e2$ >> in + <:expr< Fstream.flazy $slazy _loc x$ >> ] +; + +EXTEND + GLOBAL: expr; + expr: LEVEL "top" + [ [ "fparser"; po = OPT ipatt; "["; pcl = LIST0 parser_case SEP "|"; "]" -> + <:expr< $cparser _loc po pcl$ >> + | "fparser"; po = OPT ipatt; pc = parser_case -> + <:expr< $cparser _loc po [pc]$ >> + | "match"; e = SELF; "with"; "parser"; po = OPT ipatt; "["; + pcl = LIST0 parser_case SEP "|"; "]" -> + <:expr< $cparser_match _loc e po pcl$ >> + | "match"; e = SELF; "with"; "parser"; po = OPT ipatt; + pc = parser_case -> + <:expr< $cparser_match _loc e po [pc]$ >> ] ] + ; + parser_case: + [ [ "[:"; sp = stream_patt; ":]"; po = OPT ipatt; "->"; e = expr -> + (sp, po, e) ] ] + ; + stream_patt: + [ [ spc = stream_patt_comp -> [spc] + | spc = stream_patt_comp; ";"; sp = LIST1 stream_patt_comp SEP ";" -> + [spc :: sp] + | -> [] ] ] + ; + stream_patt_comp: + [ [ "`"; p = patt; eo = OPT [ "when"; e = expr -> e ] -> SpTrm _loc p eo + | p = patt; "="; e = expr -> SpNtr _loc p e + | p = patt -> SpStr _loc p ] ] + ; + ipatt: + [ [ i = LIDENT -> <:patt< $lid:i$ >> ] ] + ; + expr: LEVEL "simple" + [ [ "fstream"; "[:"; se = LIST0 stream_expr_comp SEP ";"; ":]" -> + <:expr< $cstream _loc se$ >> ] ] + ; + stream_expr_comp: + [ [ "`"; e = expr -> SeTrm _loc e + | e = expr -> SeNtr _loc e ] ] + ; +END; diff --git a/camlp4/unmaintained/etc/pa_ifdef.ml b/camlp4/unmaintained/etc/pa_ifdef.ml new file mode 100644 index 00000000..06652630 --- /dev/null +++ b/camlp4/unmaintained/etc/pa_ifdef.ml @@ -0,0 +1,91 @@ +(* camlp4r pa_extend.cmo q_MLast.cmo *) + + +(* This module is deprecated since version 3.07; use pa_macro.ml instead *) + +value _ = + prerr_endline "Warning: pa_ifdef is deprecated since OCaml 3.07. Use pa_macro instead." +; + +type item_or_def 'a = + [ SdStr of 'a | SdDef of string | SdUnd of string | SdNop ] +; + +value list_remove x l = + List.fold_right (fun e l -> if e = x then l else [e :: l]) l [] +; + +value defined = ref ["OCAML_308"; "OCAML_307"; "OCAML_305"; "CAMLP4_300"; "NEWSEQ"]; +value define x = defined.val := [x :: defined.val]; +value undef x = defined.val := list_remove x defined.val; + +EXTEND + GLOBAL: Pcaml.expr Pcaml.str_item Pcaml.sig_item; + Pcaml.expr: LEVEL "top" + [ [ "ifdef"; c = UIDENT; "then"; e1 = Pcaml.expr; "else"; + e2 = Pcaml.expr -> + if List.mem c defined.val then e1 else e2 + | "ifndef"; c = UIDENT; "then"; e1 = Pcaml.expr; "else"; + e2 = Pcaml.expr -> + if List.mem c defined.val then e2 else e1 ] ] + ; + Pcaml.str_item: FIRST + [ [ x = def_undef_str -> + match x with + [ SdStr si -> si + | SdDef x -> do { define x; <:str_item< declare end >> } + | SdUnd x -> do { undef x; <:str_item< declare end >> } + | SdNop -> <:str_item< declare end >> ] ] ] + ; + def_undef_str: + [ [ "ifdef"; c = UIDENT; "then"; e1 = str_item_def_undef; + "else"; e2 = str_item_def_undef -> + if List.mem c defined.val then e1 else e2 + | "ifdef"; c = UIDENT; "then"; e1 = str_item_def_undef -> + if List.mem c defined.val then e1 else SdNop + | "ifndef"; c = UIDENT; "then"; e1 = str_item_def_undef; + "else"; e2 = str_item_def_undef -> + if List.mem c defined.val then e2 else e1 + | "ifndef"; c = UIDENT; "then"; e1 = str_item_def_undef -> + if List.mem c defined.val then SdNop else e1 + | "define"; c = UIDENT -> SdDef c + | "undef"; c = UIDENT -> SdUnd c ] ] + ; + str_item_def_undef: + [ [ d = def_undef_str -> d + | si = Pcaml.str_item -> SdStr si ] ] + ; + Pcaml.sig_item: FIRST + [ [ x = def_undef_sig -> + match x with + [ SdStr si -> si + | SdDef x -> do { define x; <:sig_item< declare end >> } + | SdUnd x -> do { undef x; <:sig_item< declare end >> } + | SdNop -> <:sig_item< declare end >> ] ] ] + ; + def_undef_sig: + [ [ "ifdef"; c = UIDENT; "then"; e1 = sig_item_def_undef; + "else"; e2 = sig_item_def_undef -> + if List.mem c defined.val then e1 else e2 + | "ifdef"; c = UIDENT; "then"; e1 = sig_item_def_undef -> + if List.mem c defined.val then e1 else SdNop + | "ifndef"; c = UIDENT; "then"; e1 = sig_item_def_undef; + "else"; e2 = sig_item_def_undef -> + if List.mem c defined.val then e2 else e1 + | "ifndef"; c = UIDENT; "then"; e1 = sig_item_def_undef -> + if List.mem c defined.val then SdNop else e1 + | "define"; c = UIDENT -> SdDef c + | "undef"; c = UIDENT -> SdUnd c ] ] + ; + sig_item_def_undef: + [ [ d = def_undef_sig -> d + | si = Pcaml.sig_item -> SdStr si ] ] + ; +END; + +Pcaml.add_option "-D" (Arg.String define) + " Define for ifdef instruction." +; +Pcaml.add_option "-U" (Arg.String undef) + " Undefine for ifdef instruction." +; diff --git a/camlp4/unmaintained/etc/pa_oop.ml b/camlp4/unmaintained/etc/pa_oop.ml new file mode 100644 index 00000000..bb5684ba --- /dev/null +++ b/camlp4/unmaintained/etc/pa_oop.ml @@ -0,0 +1,155 @@ +(* camlp4r pa_extend.cmo q_MLast.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; + +type spat_comp = + [ SpTrm of Loc.t and MLast.patt and option MLast.expr + | SpNtr of Loc.t and MLast.patt and MLast.expr + | SpStr of Loc.t and MLast.patt ] +; +type sexp_comp = + [ SeTrm of Loc.t and MLast.expr | SeNtr of Loc.t and MLast.expr ] +; + +value strm_n = "__strm"; +value peek_fun _loc = <:expr< Stream.peek >>; +value junk_fun _loc = <:expr< Stream.junk >>; + +(* Parsers. *) + +value stream_pattern_component skont = + fun + [ SpTrm _loc p wo -> + (<:expr< $peek_fun _loc$ $lid:strm_n$ >>, p, wo, + <:expr< do { $junk_fun _loc$ $lid:strm_n$; $skont$ } >>) + | SpNtr _loc p e -> + (<:expr< try Some ($e$ $lid:strm_n$) with + [ Stream.Failure -> None ] >>, + p, None, skont) + | SpStr _loc p -> + (<:expr< Some $lid:strm_n$ >>, p, None, skont) ] +; + +value rec stream_pattern _loc epo e ekont = + fun + [ [] -> + match epo with + [ Some ep -> <:expr< let $ep$ = Stream.count $lid:strm_n$ in $e$ >> + | _ -> e ] + | [(spc, err) :: spcl] -> + let skont = + let ekont err = + let str = + match err with + [ Some estr -> estr + | _ -> <:expr< "" >> ] + in + <:expr< raise (Stream.Error $str$) >> + in + stream_pattern _loc epo e ekont spcl + in + let (tst, p, wo, e) = stream_pattern_component skont spc in + let ckont = ekont err in + <:expr< match $tst$ with + [ Some $p$ $when:wo$ -> $e$ | _ -> $ckont$ ] >> ] +; + +value rec parser_cases _loc = + fun + [ [] -> <:expr< raise Stream.Failure >> + | [(spcl, epo, e) :: spel] -> + stream_pattern _loc epo e (fun _ -> parser_cases _loc spel) spcl ] +; + +value cparser _loc bpo pc = + let e = parser_cases _loc pc in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $e$ >> + | None -> e ] + in + let p = <:patt< ($lid:strm_n$ : Stream.t _) >> in + <:expr< fun $p$ -> $e$ >> +; + +value cparser_match _loc me bpo pc = + let pc = parser_cases _loc pc in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >> + | None -> pc ] + in + <:expr< let $lid:strm_n$ = $me$ in $e$ >> +; + +(* streams *) + +value slazy _loc e = <:expr< fun _ -> $e$ >>; + +value rec cstream gloc = + fun + [ [] -> let _loc = gloc in <:expr< Stream.sempty >> + | [SeTrm _loc e :: secl] -> + <:expr< Stream.lcons $slazy _loc e$ $cstream gloc secl$ >> + | [SeNtr _loc e :: secl] -> + <:expr< Stream.lapp $slazy _loc e$ $cstream gloc secl$ >> ] +; + +(* Syntax extensions in Ocaml grammar *) + + +EXTEND + GLOBAL: expr; + expr: LEVEL "expr1" + [ [ "parser"; po = OPT ipatt; OPT "|"; pcl = LIST1 parser_case SEP "|" -> + <:expr< $cparser _loc po pcl$ >> + | "match"; e = expr; "with"; "parser"; po = OPT ipatt; OPT "|"; + pcl = LIST1 parser_case SEP "|" -> + <:expr< $cparser_match _loc e po pcl$ >> ] ] + ; + parser_case: + [ [ "[<"; sp = stream_patt; ">]"; po = OPT ipatt; "->"; e = expr -> + (sp, po, e) ] ] + ; + stream_patt: + [ [ spc = stream_patt_comp -> [(spc, None)] + | spc = stream_patt_comp; ";"; sp = LIST1 stream_patt_comp_err SEP ";" -> + [(spc, None) :: sp] + | (* empty *) -> [] ] ] + ; + stream_patt_comp_err: + [ [ spc = stream_patt_comp; + eo = OPT [ "??"; e = expr LEVEL "expr1" -> e ] -> + (spc, eo) ] ] + ; + stream_patt_comp: + [ [ "'"; p = patt; eo = OPT [ "when"; e = (expr LEVEL "expr1") -> e ] -> + SpTrm _loc p eo + | p = patt; "="; e = (expr LEVEL "expr1") -> SpNtr _loc p e + | p = patt -> SpStr _loc p ] ] + ; + ipatt: + [ [ i = LIDENT -> <:patt< $lid:i$ >> ] ] + ; + + expr: LEVEL "simple" + [ [ "[<"; se = LIST0 stream_expr_comp SEP ";"; ">]" -> + <:expr< $cstream _loc se$ >> ] ] + ; + stream_expr_comp: + [ [ "'"; e = expr LEVEL "expr1" -> SeTrm _loc e + | e = expr LEVEL "expr1" -> SeNtr _loc e ] ] + ; +END; diff --git a/camlp4/unmaintained/etc/pa_ru.ml b/camlp4/unmaintained/etc/pa_ru.ml new file mode 100644 index 00000000..1761c5e4 --- /dev/null +++ b/camlp4/unmaintained/etc/pa_ru.ml @@ -0,0 +1,46 @@ +(* camlp4r pa_extend.cmo q_MLast.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; + +value o2b = + fun + [ Some _ -> True + | None -> False ] +; + +EXTEND + GLOBAL: expr; + expr: LEVEL "top" + [ [ "do"; "{"; seq = sequence; "}" -> + match seq with + [ [e] -> e + | _ -> <:expr< do { $list:seq$ } >> ] ] ] + ; + sequence: + [ [ "let"; o = OPT "rec"; l = LIST1 let_binding SEP "and"; [ "in" | ";" ]; + el = SELF -> + let e = + match el with + [ [e] -> e + | _ -> <:expr< do { $list:el$ } >> ] + in + [ <:expr< let $opt:o2b o$ $list:l$ in $e$ >> ] + | e = expr; ";"; el = SELF -> + let e = let _loc = MLast.loc_of_expr e in <:expr< ($e$ : unit) >> in + [e :: el] + | e = expr; ";" -> [e] + | e = expr -> [e] ] ] + ; +END; diff --git a/camlp4/unmaintained/etc/parserify.ml b/camlp4/unmaintained/etc/parserify.ml new file mode 100644 index 00000000..f0a3be8b --- /dev/null +++ b/camlp4/unmaintained/etc/parserify.ml @@ -0,0 +1,305 @@ +(* camlp4r q_MLast.cmo *) + + +(* FIXME FIXME *) +value _loc = Loc.mk "FIXME parserify.ml"; + +type spc = + [ SPCterm of (MLast.patt * option MLast.expr) + | SPCnterm of MLast.patt and MLast.expr + | SPCsterm of MLast.patt ] +; + +exception NotImpl; + +value rec subst v = + MLast.Map.Expr.expr (fun [ <:expr@_loc< __strm >> -> <:expr< $lid:v$ >> + | e -> e ]) +(* FIXME FIXME *) + (* match e with + [ <:expr< $lid:x$ >> -> if x = "__strm" then <:expr< $lid:v$ >> else e + | <:expr< $uid:_$ >> -> e + | <:expr< $int:_$ >> -> e + | <:expr< $chr:_$ >> -> e + | <:expr< $str:_$ >> -> e + | <:expr@_loc< $e1$ . $lab$ >> -> <:expr< $subst v e1$ . $lab$ >> + | <:expr@_loc< $x$ $y$ >> -> <:expr< $subst v x$ $subst v y$ >> + | <:expr@_loc< let $lid:s1$ = $e1$ in $e2$ >> -> + if s1 = v then <:expr< let $lid:s1$ = $subst v e1$ in $e2$ >> + else <:expr< let $lid:s1$ = $subst v e1$ in $subst v e2$ >> + | <:expr@_loc< let _ = $e1$ in $e2$ >> -> + <:expr< let _ = $subst v e1$ in $subst v e2$ >> + | <:expr@_loc< ($list:el$) >> -> <:expr< ($list:List.map (subst v) el$) >> + | _ -> raise NotImpl ] *) +; + +value rec is_free v = + fun + [ <:expr< $lid:x$ >> -> x <> v + | <:expr< $uid:_$ >> -> True + | <:expr< $int:_$ >> -> True + | <:expr< $chr:_$ >> -> True + | <:expr< $str:_$ >> -> True + | <:expr< $e$ . $_$ >> -> is_free v e + | <:expr< $x$ $y$ >> -> is_free v x && is_free v y + | <:expr< let $lid:s1$ = $e1$ in $e2$ >> -> + is_free v e1 && (s1 = v || is_free v e2) + | <:expr< let _ = $e1$ in $e2$ >> -> is_free v e1 && is_free v e2 + | <:expr< ($list:el$) >> -> List.for_all (is_free v) el + | _ -> raise NotImpl ] +; + +value gensym = + let cnt = ref 0 in + fun () -> + do { incr cnt; "pr_rp_symb_" ^ string_of_int cnt.val } +; + +value free_var_in_expr c e = + let rec loop_alpha v = + let x = String.make 1 v in + if is_free x e then Some x + else if v = 'z' then None + else loop_alpha (Char.chr (Char.code v + 1)) + in + let rec loop_count cnt = + let x = String.make 1 c ^ string_of_int cnt in + if is_free x e then x else loop_count (succ cnt) + in + try + match loop_alpha c with + [ Some v -> v + | None -> loop_count 1 ] + with + [ NotImpl -> gensym () ] +; + +value parserify _loc = + fun + [ <:expr< $e$ __strm >> -> e + | e -> <:expr< fun __strm -> $e$ >> ] +; + +value is_raise_failure = + fun + [ <:expr< raise Stream.Failure >> -> True + | _ -> False ] +; + +value is_raise_error = + fun + [ <:expr< raise (Stream.Error $_$) >> -> True + | _ -> False ] +; + +value semantic _loc e = + try + if is_free "__strm" e then e + else + let v = free_var_in_expr 's' e in + <:expr< let $lid:v$ = __strm in $subst v e$ >> + with + [ NotImpl -> e ] +; + +value rewrite_parser = + rewrite True where rec rewrite top ge = + match ge with + [ <:expr@_loc< let $p$ = try $e$ with [ Stream.Failure -> raise $exc$ ] in + $sp_kont$ >> -> + let f = parserify _loc e in + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some $p$ -> $rewrite False sp_kont$ + | _ -> raise $exc$ ] + >> + | <:expr@_loc< let $p$ = Stream.count __strm in $f$ >> -> + try + if is_free "__strm" f then ge + else + let v = free_var_in_expr 's' f in + <:expr< + let $lid:v$ = __strm in + let $p$ = Stream.count __strm in $subst v f$ + >> + with + [ NotImpl -> ge ] + | <:expr@_loc< let $p$ = __strm in $e$ >> -> + <:expr< let $p$ = __strm in $rewrite False e$ >> + | <:expr@_loc< let $p$ = $f$ __strm in $sp_kont$ >> when top -> + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some $p$ -> $rewrite False sp_kont$ + | _ -> raise Stream.Failure ] + >> + | <:expr@_loc< let $p$ = $e$ in $sp_kont$ >> -> + if match e with + [ <:expr< match try Some $_$ with [ Stream.Failure -> None ] with + [ $list:_$ ] >> + | <:expr< match Stream.peek __strm with [ $list:_$ ] >> + | <:expr< try $_$ with [ Stream.Failure -> $_$ ] >> + | <:expr< let $_$ = Stream.count __strm in $_$ >> -> True + | _ -> False ] + then + let f = rewrite True <:expr< fun __strm -> $e$ >> in + let exc = + if top then <:expr< Stream.Failure >> + else <:expr< Stream.Error "" >> + in + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some $p$ -> $rewrite False sp_kont$ + | _ -> raise $exc$ ] + >> + else semantic _loc ge + | <:expr@_loc< match try Some $e$ with [ Stream.Failure -> None ] with + [ Some $p$ -> $sp_kont$ + | _ -> $p_kont$ ] >> -> + let f = parserify _loc e in + if not top && is_raise_failure p_kont then semantic _loc ge + else + let (p, f, sp_kont, p_kont) = + if top || is_raise_error p_kont then + (p, f, rewrite False sp_kont, rewrite top p_kont) + else + let f = + <:expr< + fun __strm -> + match + try Some ($f$ __strm) with [ Stream.Failure -> None ] + with + [ Some $p$ -> $rewrite False sp_kont$ + | _ -> $rewrite top p_kont$ ] + >> + in + (<:patt< a >>, f, <:expr< a >>, + <:expr< raise (Stream.Error "") >>) + in + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some $p$ -> $sp_kont$ + | _ -> $p_kont$ ] + >> + | <:expr< match Stream.peek __strm with [ $list:pel$ ] >> -> + let rec iter pel = + match pel with + [ [(<:patt< Some $p$ >>, eo, + <:expr< do { Stream.junk __strm; $sp_kont$ } >>); + (<:patt< _ >>, None, p_kont) :: _] -> + <:expr< + match Stream.peek __strm with + [ Some $p$ $when:eo$ -> + do { Stream.junk __strm; $rewrite False sp_kont$ } + | _ -> $rewrite top p_kont$ ] + >> + | [(<:patt< Some $p$ >>, eo, + <:expr< do { Stream.junk __strm; $sp_kont$ } >>) :: pel] -> + let p_kont = iter pel in + <:expr< + match Stream.peek __strm with + [ Some $p$ $when:eo$ -> + do { Stream.junk __strm; $rewrite False sp_kont$ } + | _ -> $p_kont$ ] + >> + | _ -> + <:expr< match Stream.peek __strm with [ $list:pel$ ] >> ] + in + iter pel + | <:expr@_loc< try Some $e$ with [ Stream.Failure -> $p_kont$ ] >> -> + let f = parserify _loc e in + let e = + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some a -> Some a + | _ -> $p_kont$ ] + >> + in + rewrite top e + | <:expr@_loc< try $e$ with [ Stream.Failure -> $p_kont$ ] >> -> + let f = parserify _loc e in + let e = + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some a -> a + | _ -> $rewrite top p_kont$ ] + >> + in + rewrite top e + | <:expr< $f$ __strm >> -> + if top then + <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some a -> a + | _ -> raise Stream.Failure ] + >> + else + let v = free_var_in_expr 's' f in + <:expr< let $lid:v$ = __strm in $subst v f$ $lid:v$ >> + | e -> let loc = MLast.loc_of_expr e in semantic loc e ] +; + +value spc_of_parser = + let rec parser_cases e = + match e with + [ <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some $p$ -> $sp_kont$ + | _ -> $p_kont$ ] + >> -> + let spc = (SPCnterm p f, None) in + let (sp, epo, e) = kont sp_kont in + [([spc :: sp], epo, e) :: parser_cases p_kont] + | <:expr< + match Stream.peek __strm with + [ Some $p$ $when:wo$ -> do { Stream.junk __strm; $sp_kont$ } + | _ -> $p_kont$ ] + >> -> + let spc = (SPCterm (p, wo), None) in + let (sp, epo, e) = kont sp_kont in + [([spc :: sp], epo, e) :: parser_cases p_kont] + | <:expr< let $p$ = __strm in $sp_kont$ >> -> + let spc = (SPCsterm p, None) in + let (sp, epo, e) = kont sp_kont in + [([spc :: sp], epo, e)] + | <:expr< let $p$ = Stream.count __strm in $e$ >> -> [([], Some p, e)] + | <:expr< raise Stream.Failure >> -> [] + | _ -> [([], None, e)] ] + and kont e = + match e with + [ <:expr< + match try Some ($f$ __strm) with [ Stream.Failure -> None ] with + [ Some $p$ -> $sp_kont$ + | _ -> raise (Stream.Error $err$) ] + >> -> + let err = + match err with + [ <:expr< "" >> -> None + | _ -> Some err ] + in + let spc = (SPCnterm p f, err) in + let (sp, epo, e) = kont sp_kont in + ([spc :: sp], epo, e) + | <:expr< + match Stream.peek __strm with + [ Some $p$ $when:wo$ -> do { Stream.junk __strm; $sp_kont$ } + | _ -> raise (Stream.Error $err$) ] + >> -> + let err = + match err with + [ <:expr< "" >> -> None + | _ -> Some err ] + in + let spc = (SPCterm (p, wo), err) in + let (sp, epo, e) = kont sp_kont in + ([spc :: sp], epo, e) + | <:expr< let $p$ = __strm in $sp_kont$ >> -> + let spc = (SPCsterm p, None) in + let (sp, epo, e) = kont sp_kont in + ([spc :: sp], epo, e) + | <:expr< let $p$ = Stream.count __strm in $e$ >> -> ([], Some p, e) + | _ -> ([], None, e) ] + in + parser_cases +; + +value parser_of_expr e = spc_of_parser (rewrite_parser e); diff --git a/camlp4/unmaintained/etc/parserify.mli b/camlp4/unmaintained/etc/parserify.mli new file mode 100644 index 00000000..c1affdba --- /dev/null +++ b/camlp4/unmaintained/etc/parserify.mli @@ -0,0 +1,12 @@ +(* camlp4r *) + + +type spc = + [ SPCterm of (MLast.patt * option MLast.expr) + | SPCnterm of MLast.patt and MLast.expr + | SPCsterm of MLast.patt ] +; + +value parser_of_expr : + MLast.expr -> + list (list (spc * option MLast.expr) * option MLast.patt * MLast.expr); diff --git a/camlp4/unmaintained/etc/pr_depend.ml b/camlp4/unmaintained/etc/pr_depend.ml new file mode 100644 index 00000000..53224daa --- /dev/null +++ b/camlp4/unmaintained/etc/pr_depend.ml @@ -0,0 +1,321 @@ +(* camlp4r *) + + +open MLast; + +value not_impl name x = + Format.eprintf "pr_depend: not impl: %s; %a@." name ObjTools.print (Obj.repr x) +; + +module StrSet = + Set.Make (struct type t = string; value compare = compare; end) +; + +value fset = ref StrSet.empty; +value addmodule s = fset.val := StrSet.add s fset.val; + +value list = List.iter; + +value option f = + fun + [ Some x -> f x + | None -> () ] +; + +value longident = + fun + [ [s; _ :: _] -> addmodule s + | _ -> () ] +; + +value rec ctyp = + fun + [ TyAcc _ t _ -> ctyp_module t + | TyAli _ t1 t2 -> do { ctyp t1; ctyp t2; } + | TyApp _ t1 t2 -> do { ctyp t1; ctyp t2; } + | TyAny _ -> () + | TyArr _ t1 t2 -> do { ctyp t1; ctyp t2; } + | TyCls _ li -> longident li + | TyLab _ _ t -> ctyp t + | TyLid _ _ -> () + | TyMan _ t1 t2 -> do { ctyp t1; ctyp t2; } + | TyOlb _ _ t -> ctyp t + | TyQuo _ _ -> () + | TyRec _ ldl -> list label_decl ldl + | TySum _ cdl -> list constr_decl cdl + | TyPrv _ t -> ctyp t + | TyTup _ tl -> list ctyp tl + | TyVrn _ sbtll _ -> list variant sbtll + | x -> not_impl "ctyp" x ] +and constr_decl (_, _, tl) = list ctyp tl +and label_decl (_, _, _, t) = ctyp t +and variant = + fun + [ RfTag _ _ tl -> list ctyp tl + | RfInh t -> ctyp t ] +and ctyp_module = + fun + [ TyAcc _ t _ -> ctyp_module t + | TyApp _ t1 t2 -> do { ctyp t1; ctyp t2; } + | TyUid _ m -> addmodule m + | x -> not_impl "ctyp_module" x ] +; + +value rec patt = + fun + [ PaAcc _ p _ -> patt_module p + | PaAli _ p1 p2 -> do { patt p1; patt p2; } + | PaAny _ -> () + | PaApp _ p1 p2 -> do { patt p1; patt p2; } + | PaArr _ pl -> list patt pl + | PaChr _ _ -> () + | PaInt _ _ -> () + | PaLab _ _ po -> option patt po + | PaLid _ _ -> () + | PaOlb _ _ peoo -> + option (fun (p, eo) -> do { patt p; option expr eo }) peoo + | PaOrp _ p1 p2 -> do { patt p1; patt p2; } + | PaRec _ lpl -> list label_patt lpl + | PaRng _ p1 p2 -> do { patt p1; patt p2; } + | PaStr _ _ -> () + | PaTup _ pl -> list patt pl + | PaTyc _ p t -> do { patt p; ctyp t; } + | PaUid _ _ -> () + | PaVrn _ _ -> () + | x -> not_impl "patt" x ] +and patt_module = + fun + [ PaUid _ m -> addmodule m + | PaAcc _ p _ -> patt_module p + | x -> not_impl "patt_module" x ] +and label_patt (p1, p2) = do { patt p1; patt p2; } +and expr = + fun + [ ExAcc _ e1 e2 -> do { expr_module e1; expr e2; } + | ExApp _ e1 e2 -> do { expr e1; expr e2; } + | ExAre _ e1 e2 -> do { expr e1; expr e2; } + | ExArr _ el -> list expr el + | ExAsf _ -> () + | ExAsr _ e -> do { expr e; } + | ExAss _ e1 e2 -> do { expr e1; expr e2; } + | ExChr _ _ -> () + | ExCoe _ e t1 t2 -> do { expr e; option ctyp t1; ctyp t2 } + | ExFor _ _ e1 e2 _ el -> do { expr e1; expr e2; list expr el; } + | ExFun _ pwel -> list match_case pwel + | ExIfe _ e1 e2 e3 -> do { expr e1; expr e2; expr e3; } + | ExInt _ _ -> () + | ExInt32 _ _ -> () + | ExInt64 _ _ -> () + | ExNativeInt _ _ -> () + | ExFlo _ _ -> () + | ExLab _ _ eo -> option expr eo + | ExLaz _ e -> expr e + | ExLet _ _ pel e -> do { list let_binding pel; expr e; } + | ExLid _ _ -> () + | ExLmd _ _ me e -> do { module_expr me; expr e; } + | ExMat _ e pwel -> do { expr e; list match_case pwel; } + | ExNew _ li -> longident li + | ExOlb _ _ eo -> option expr eo + | ExRec _ lel w -> do { list label_expr lel; option expr w; } + | ExSeq _ el -> list expr el + | ExSnd _ e _ -> expr e + | ExSte _ e1 e2 -> do { expr e1; expr e2; } + | ExStr _ _ -> () + | ExTry _ e pwel -> do { expr e; list match_case pwel; } + | ExTup _ el -> list expr el + | ExTyc _ e t -> do { expr e; ctyp t; } + | ExUid _ _ -> () + | ExVrn _ _ -> () + | ExWhi _ e el -> do { expr e; list expr el; } + | x -> not_impl "expr" x ] +and expr_module = + fun + [ ExUid _ m -> addmodule m + | e -> expr e ] +and let_binding (p, e) = do { patt p; expr e } +and label_expr (p, e) = do { patt p; expr e } +and match_case (p, w, e) = do { patt p; option expr w; expr e; } +and module_type = + fun + [ MtAcc _ (MtUid _ m) _ -> addmodule m + | MtFun _ _ mt1 mt2 -> do { module_type mt1; module_type mt2; } + | MtSig _ sil -> list sig_item sil + | MtUid _ _ -> () + | MtWit _ mt wc -> do { module_type mt; list with_constr wc; } + | x -> not_impl "module_type" x ] +and with_constr = + fun + [ WcTyp _ _ _ t -> ctyp t + | x -> not_impl "with_constr" x ] +and sig_item = + fun + [ SgDcl _ sil -> list sig_item sil + | SgExc _ _ tl -> list ctyp tl + | SgExt _ _ t _ -> ctyp t + | SgMod _ _ mt -> module_type mt + | SgRecMod _ mts -> list (fun (_, mt) -> module_type mt) mts + | SgMty _ _ mt -> module_type mt + | SgOpn _ [s :: _] -> addmodule s + | SgTyp _ tdl -> list type_decl tdl + | SgVal _ _ t -> ctyp t + | x -> not_impl "sig_item" x ] +and module_expr = + fun + [ MeAcc _ (MeUid _ m) _ -> addmodule m + | MeApp _ me1 me2 -> do { module_expr me1; module_expr me2; } + | MeFun _ _ mt me -> do { module_type mt; module_expr me; } + | MeStr _ sil -> list str_item sil + | MeTyc _ me mt -> do { module_expr me; module_type mt; } + | MeUid _ _ -> () + | x -> not_impl "module_expr" x ] +and str_item = + fun + [ StCls _ cil -> list (fun ci -> class_expr ci.ciExp) cil + | StDcl _ sil -> list str_item sil + | StDir _ _ _ -> () + | StExc _ _ tl _ -> list ctyp tl + | StExp _ e -> expr e + | StExt _ _ t _ -> ctyp t + | StMod _ _ me -> module_expr me + | StRecMod _ nmtmes -> list (fun (_, mt, me) -> do { module_expr me; module_type mt; }) nmtmes + | StMty _ _ mt -> module_type mt + | StOpn _ [s :: _] -> addmodule s + | StTyp _ tdl -> list type_decl tdl + | StVal _ _ pel -> list let_binding pel + | x -> not_impl "str_item" x ] +and type_decl (_, _, t, _) = ctyp t +and class_expr = + fun + [ CeApp _ ce e -> do { class_expr ce; expr e; } + | CeCon _ li tl -> do { longident li; list ctyp tl; } + | CeFun _ p ce -> do { patt p; class_expr ce; } + | CeLet _ _ pel ce -> do { list let_binding pel; class_expr ce; } + | CeStr _ po csil -> do { option patt po; list class_str_item csil; } + | x -> not_impl "class_expr" x ] +and class_str_item = + fun + [ CrInh _ ce _ -> class_expr ce + | CrIni _ e -> expr e + | CrMth _ _ _ e None -> expr e + | CrMth _ _ _ e (Some t) -> do { expr e; ctyp t } + | CrVal _ _ _ e -> expr e + | CrVir _ _ _ t -> ctyp t + | x -> not_impl "class_str_item" x ] +; + +(* Print dependencies *) + +value load_path = ref [""]; + +value find_in_path path name = + if not (Filename.is_implicit name) then + if Sys.file_exists name then name else raise Not_found + else + let rec try_dir = + fun + [ [] -> raise Not_found + | [dir :: rem] -> + let fullname = Filename.concat dir name in + if Sys.file_exists fullname then fullname else try_dir rem ] + in + try_dir path +; + +value find_depend modname (byt_deps, opt_deps) = + let name = String.uncapitalize modname in + try + let filename = find_in_path load_path.val (name ^ ".mli") in + let basename = Filename.chop_suffix filename ".mli" in + let byt_dep = basename ^ ".cmi" in + let opt_dep = + if Sys.file_exists (basename ^ ".ml") then basename ^ ".cmx" + else basename ^ ".cmi" + in + ([byt_dep :: byt_deps], [opt_dep :: opt_deps]) + with + [ Not_found -> + try + let filename = find_in_path load_path.val (name ^ ".ml") in + let basename = Filename.chop_suffix filename ".ml" in + ([basename ^ ".cmo" :: byt_deps], [basename ^ ".cmx" :: opt_deps]) + with + [ Not_found -> (byt_deps, opt_deps) ] ] +; + +value (depends_on, escaped_eol) = + match Sys.os_type with + [ "Unix" | "Win32" | "Cygwin" -> (": ", "\\\n ") + | "MacOS" -> ("\196 ", "\182\n ") + | _ -> assert False ] +; + +value print_depend target_file deps = + match deps with + [ [] -> () + | _ -> + do { + print_string target_file; + print_string depends_on; + let rec print_items pos = + fun + [ [] -> print_string "\n" + | [dep :: rem] -> + if pos + String.length dep <= 77 then do { + print_string dep; + print_string " "; + print_items (pos + String.length dep + 1) rem + } + else do { + print_string escaped_eol; + print_string dep; + print_string " "; + print_items (String.length dep + 5) rem + } ] + in + print_items (String.length target_file + 2) deps + } ] +; + +(* Main *) + +value depend_sig ast = + do { + fset.val := StrSet.empty; + List.iter (fun (si, _) -> sig_item si) ast; + let basename = Filename.chop_suffix Pcaml.input_file.val ".mli" in + let (byt_deps, _) = StrSet.fold find_depend fset.val ([], []) in + print_depend (basename ^ ".cmi") byt_deps; + } +; + +value depend_str ast = + do { + fset.val := StrSet.empty; + List.iter (fun (si, _) -> str_item si) ast; + let basename = + if Filename.check_suffix Pcaml.input_file.val ".ml" then + Filename.chop_suffix Pcaml.input_file.val ".ml" + else + try + let len = String.rindex Pcaml.input_file.val '.' in + String.sub Pcaml.input_file.val 0 len + with + [ Failure _ | Not_found -> Pcaml.input_file.val ] + in + let init_deps = + if Sys.file_exists (basename ^ ".mli") then + let cmi_name = basename ^ ".cmi" in ([cmi_name], [cmi_name]) + else ([], []) + in + let (byt_deps, opt_deps) = StrSet.fold find_depend fset.val init_deps in + print_depend (basename ^ ".cmo") byt_deps; + print_depend (basename ^ ".cmx") opt_deps; + } +; + +Pcaml.print_interf.val := depend_sig; +Pcaml.print_implem.val := depend_str; + +Pcaml.add_option "-I" + (Arg.String (fun dir -> load_path.val := load_path.val @ [dir])) + " Add to the list of include directories."; diff --git a/camlp4/unmaintained/etc/pr_extend.ml b/camlp4/unmaintained/etc/pr_extend.ml new file mode 100644 index 00000000..5f8b6933 --- /dev/null +++ b/camlp4/unmaintained/etc/pr_extend.ml @@ -0,0 +1,518 @@ +(* camlp4r q_MLast.cmo ./pa_extfun.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; +open Spretty; + +value no_slist = ref False; + +value expr e dg k = pr_expr.pr_fun "top" e dg k; +value patt e dg k = pr_patt.pr_fun "top" e dg k; + +(* Utilities *) + +value rec list elem el k = + match el with + [ [] -> k + | [x] -> [: `elem x k :] + | [x :: l] -> [: `elem x [: :]; list elem l k :] ] +; + +value rec listws elem sep el k = + match el with + [ [] -> k + | [x] -> [: `elem x k :] + | [x :: l] -> [: `elem x [: `sep :]; listws elem sep l k :] ] +; + +value rec listwbws elem b sep el dg k = + match el with + [ [] -> [: b; k :] + | [x] -> [: `elem b x dg k :] + | [x :: l] -> + let sdg = + match sep with + [ S _ x -> x + | _ -> "" ] + in + [: `elem b x sdg [: :]; listwbws elem [: `sep :] sep l dg k :] ] +; + +(* Extracting *) + +value rec get_globals = + fun + [ [(<:patt< _ >>, <:expr< ($e$ : $uid:gmod1$.Entry.e '$_$) >>) :: pel] -> + let (gmod, gl) = get_globals pel in + if gmod = "" || gmod = gmod1 then (gmod1, [e :: gl]) + else raise Not_found + | [] -> ("", []) + | _ -> raise Not_found ] +; + +value rec get_locals = + fun + [ [(<:patt< $_$ >>, + <:expr< (grammar_entry_create $_$ : $_$) >>) :: pel] -> + get_locals pel + | [] -> () + | _ -> raise Not_found ] +; + +value unposition = + fun + [ <:expr< None >> -> None + | <:expr< Some Gramext.First >> -> Some Gramext.First + | <:expr< Some Gramext.Last >> -> Some Gramext.Last + | <:expr< Some (Gramext.Before $str:s$) >> -> Some (Gramext.Before s) + | <:expr< Some (Gramext.After $str:s$) >> -> Some (Gramext.After s) + | <:expr< Some (Gramext.Level $str:s$) >> -> Some (Gramext.Level s) + | _ -> raise Not_found ] +; + +value unlabel = + fun + [ <:expr< None >> -> None + | <:expr< Some $str:s$ >> -> Some s + | _ -> raise Not_found ] +; + +value unassoc = + fun + [ <:expr< None >> -> None + | <:expr< Some Gramext.NonA >> -> Some Gramext.NonA + | <:expr< Some Gramext.LeftA >> -> Some Gramext.LeftA + | <:expr< Some Gramext.RightA >> -> Some Gramext.RightA + | _ -> raise Not_found ] +; + +value rec unaction = + fun + [ <:expr< fun ($lid:locp$ : Loc.t) -> ($a$ : $_$) >> + when locp = Stdpp.loc_name.val -> + let ao = + match a with + [ <:expr< () >> -> None + | _ -> Some a ] + in + ([], ao) + | <:expr< fun ($p$ : $_$) -> $e$ >> -> + let (pl, a) = unaction e in ([p :: pl], a) + | <:expr@_loc< fun _ -> $e$ >> -> + let (pl, a) = unaction e in ([ <:patt< _ >> :: pl ], a) + | _ -> raise Not_found ] +; + +value untoken = + fun + [ <:expr< ($str:x$, $str:y$) >> -> (x, y) + | _ -> raise Not_found ] +; + +type symbol = + [ Snterm of MLast.expr + | Snterml of MLast.expr and string + | Slist0 of symbol + | Slist0sep of symbol and symbol + | Slist1 of symbol + | Slist1sep of symbol and symbol + | Sopt of symbol + | Sself + | Snext + | Stoken of Token.pattern + | Srules of list (list (option MLast.patt * symbol) * option MLast.expr) ] +; + +value rec unsymbol = + fun + [ <:expr< Gramext.Snterm ($uid:_$.Entry.obj ($e$ : $_$)) >> -> Snterm e + | <:expr< Gramext.Snterml ($uid:_$.Entry.obj ($e$ : $_$)) $str:s$ >> -> + Snterml e s + | <:expr< Gramext.Snterml ($uid:_$.Entry.obj ($e$ : $_$), $str:s$) >> -> + Snterml e s + | <:expr< Gramext.Slist0 $e$ >> -> Slist0 (unsymbol e) + | <:expr< Gramext.Slist0sep $e1$ $e2$ >> -> + Slist0sep (unsymbol e1) (unsymbol e2) + | <:expr< Gramext.Slist0sep ($e1$, $e2$) >> -> + Slist0sep (unsymbol e1) (unsymbol e2) + | <:expr< Gramext.Slist1 $e$ >> -> Slist1 (unsymbol e) + | <:expr< Gramext.Slist1sep $e1$ $e2$ >> -> + Slist1sep (unsymbol e1) (unsymbol e2) + | <:expr< Gramext.Slist1sep ($e1$, $e2$) >> -> + Slist1sep (unsymbol e1) (unsymbol e2) + | <:expr< Gramext.Sopt $e$ >> -> Sopt (unsymbol e) + | <:expr< Gramext.Sself >> -> Sself + | <:expr< Gramext.Snext >> -> Snext + | <:expr< Gramext.Stoken $e$ >> -> Stoken (untoken e) + | <:expr< Gramext.srules $e$ >> -> Srules (unrule_list [] e) + | _ -> raise Not_found ] +and unpsymbol_list pl e = + match (pl, e) with + [ ([], <:expr< [] >>) -> [] + | ([p :: pl], <:expr< [$e$ :: $el$] >>) -> + let op = + match p with + [ <:patt< _ >> -> None + | _ -> Some p ] + in + [(op, unsymbol e) :: unpsymbol_list pl el] + | _ -> raise Not_found ] +and unrule = + fun + [ <:expr@_loc< ($e1$, Gramext.action $e2$) >> -> + let (pl, a) = + match unaction e2 with + [ ([], None) -> ([], Some <:expr< () >>) + | x -> x ] + in + let sl = unpsymbol_list (List.rev pl) e1 in + (sl, a) + | _ -> raise Not_found ] +and unrule_list rl = + fun + [ <:expr< [$e$ :: $el$] >> -> unrule_list [unrule e :: rl] el + | <:expr< [] >> -> rl + | _ -> raise Not_found ] +; + +value unlevel = + fun + [ <:expr< ($e1$, $e2$, $e3$) >> -> + (unlabel e1, unassoc e2, unrule_list [] e3) + | _ -> raise Not_found ] +; + +value rec unlevel_list = + fun + [ <:expr< [$e$ :: $el$] >> -> [unlevel e :: unlevel_list el] + | <:expr< [] >> -> [] + | _ -> raise Not_found ] +; + +value unentry = + fun + [ <:expr< (Grammar.Entry.obj ($e$ : Grammar.Entry.e '$_$), $pos$, $ll$) >> -> + (e, unposition pos, unlevel_list ll) + | _ -> raise Not_found ] +; + +value rec unentry_list = + fun + [ <:expr< [$e$ :: $el$] >> -> [unentry e :: unentry_list el] + | <:expr< [] >> -> [] + | _ -> raise Not_found ] +; + +value unextend_body e = + let ((_, globals), e) = + match e with + [ <:expr< let $list:pel$ in $e1$ >> -> + try (get_globals pel, e1) with + [ Not_found -> (("", []), e) ] + | _ -> (("", []), e) ] + in + let e = + match e with + [ <:expr< + let grammar_entry_create s = + Grammar.Entry.create (Grammar.of_entry $_$) s + in + $e$ >> -> + let e = + match e with + [ <:expr< let $list:pel$ in $e1$ >> -> + try let _ = get_locals pel in e1 with + [ Not_found -> e ] + | _ -> e ] + in + e + | _ -> e ] + in + let el = unentry_list e in + (globals, el) +; + +value ungextend_body e = + let e = + match e with + [ <:expr< + let grammar_entry_create = Gram.Entry.create in + let $list:ll$ in $e$ + >> -> + let _ = get_locals ll in e + | _ -> e ] + in + match e with + [ <:expr< do { $list:el$ } >> -> + List.map + (fun + [ <:expr< $uid:_$.extend ($e$ : $uid:_$.Entry.e '$_$) $pos$ $ll$ >> -> + (e, unposition pos, unlevel_list ll) + | _ -> raise Not_found ]) + el + | _ -> raise Not_found ] +; + +(* Printing *) + +value ident s k = HVbox [: `S LR s; k :]; +value string s k = HVbox [: `S LR ("\"" ^ s ^ "\""); k :]; + +value position = + fun + [ None -> [: :] + | Some Gramext.First -> [: `S LR "FIRST" :] + | Some Gramext.Last -> [: `S LR "LAST" :] + | Some (Gramext.Before s) -> [: `S LR "BEFORE"; `string s [: :] :] + | Some (Gramext.After s) -> [: `S LR "AFTER"; `string s [: :] :] + | Some (Gramext.Level s) -> [: `S LR "LEVEL"; `string s [: :] :] ] +; + +value action expr a dg k = + expr a dg k +; + +value token (con, prm) k = + if con = "" then string prm k + else if prm = "" then HVbox [: `S LR con; k :] + else HVbox [: `S LR con; `string prm k :] +; + +value simplify_rules rl = + try + List.map + (fun + [ ([(Some <:patt< $lid:x$ >>, s)], Some <:expr< $lid:y$ >>) -> + if x = y then ([(None, s)], None) else raise Exit + | ([], _) as r -> r + | _ -> raise Exit ]) + rl + with + [ Exit -> rl ] +; + +value rec symbol s k = + match s with + [ Snterm e -> expr e "" k + | Snterml e s -> HVbox [: `expr e "" [: :]; `S LR "LEVEL"; `string s k :] + | Slist0 s -> HVbox [: `S LR "LIST0"; `symbol s k :] + | Slist0sep s sep -> + HVbox + [: `S LR "LIST0"; `symbol s [: :]; `S LR "SEP"; + `symbol sep k :] + | Slist1 s -> HVbox [: `S LR "LIST1"; `symbol s k :] + | Slist1sep s sep -> + HVbox + [: `S LR "LIST1"; `symbol s [: :]; `S LR "SEP"; + `symbol sep k :] + | Sopt s -> HVbox [: `S LR "OPT"; `symbol s k :] + | Sself -> HVbox [: `S LR "SELF"; k :] + | Snext -> HVbox [: `S LR "NEXT"; k :] + | Stoken tok -> token tok k + | Srules + [([(Some <:patt< a >>, Snterm <:expr< a_list >>)], Some <:expr< a >>); + ([(Some <:patt< a >>, + ((Slist0 _ | Slist1 _ | Slist0sep _ _ | Slist1sep _ _) as s))], + Some <:expr< Qast.List a >>)] + when not no_slist.val + -> + match s with + [ Slist0 s -> HVbox [: `S LR "SLIST0"; `simple_symbol s k :] + | Slist1 s -> HVbox [: `S LR "SLIST1"; `simple_symbol s k :] + | Slist0sep s sep -> + HVbox + [: `S LR "SLIST0"; `simple_symbol s [: :]; `S LR "SEP"; + `symbol sep k :] + | Slist1sep s sep -> + HVbox + [: `S LR "SLIST1"; `simple_symbol s [: :]; `S LR "SEP"; + `simple_symbol sep k :] + | _ -> assert False ] + | Srules + [([(Some <:patt< a >>, Snterm <:expr< a_opt >>)], Some <:expr< a >>); + ([(Some <:patt< a >>, Sopt s)], Some <:expr< Qast.Option a >>)] + when not no_slist.val + -> + let s = + match s with + [ Srules + [([(Some <:patt< x >>, Stoken ("", str))], + Some <:expr< Qast.Str x >>)] -> + Stoken ("", str) + | s -> s ] + in + HVbox [: `S LR "SOPT"; `simple_symbol s k :] + | Srules rl -> + let rl = simplify_rules rl in + HVbox [: `HVbox [: :]; rule_list rl k :] ] +and simple_symbol s k = + match s with + [ Snterml _ _ -> HVbox [: `S LO "("; `symbol s [: `S RO ")"; k :] :] + | s -> symbol s k ] +and psymbol (p, s) k = + match p with + [ None -> symbol s k + | Some p -> HVbox [: `patt p "" [: `S LR "=" :]; `symbol s k :] ] +and psymbol_list sl k = + listws psymbol (S RO ";") sl k +and rule b (sl, a) dg k = + match a with + [ None -> HVbox [: b; `HOVbox [: psymbol_list sl k :] :] + | Some a -> + HVbox + [: b; + `HOVbox + [: `HOVbox + [: `HVbox [: :]; + psymbol_list sl [: `S LR "->" :] :]; + `action expr a dg k :] :] ] +and rule_list ll k = + listwbws rule [: `S LR "[" :] (S LR "|") ll "" + [: `S LR "]"; k :] +; + +value label = + fun + [ Some s -> [: `S LR ("\"" ^ s ^ "\"") :] + | None -> [: :] ] +; + +value intloc loc = ((Loc.start_off loc), (Loc.stop_off loc)); + +value intloc2 (bp, ep) = (bp.Lexing.pos_cnum, ep.Lexing.pos_cnum); + + +value assoc = + fun + [ Some Gramext.NonA -> [: `S LR "NONA" :] + | Some Gramext.LeftA -> [: `S LR "LEFTA" :] + | Some Gramext.RightA -> [: `S LR "RIGHTA" :] + | None -> [: :] ] +; + +value level b (lab, ass, rl) _ k = + let s = + if rl = [] then [: `S LR "[ ]"; k :] + else [: `Vbox [: `HVbox [: :]; rule_list rl k :] :] + in + match (lab, ass) with + [ (None, None) -> HVbox [: b; s :] + | _ -> + Vbox + [: `HVbox [: b; label lab; assoc ass :]; + `HVbox [: `HVbox [: :]; s :] :] ] +; + +value level_list ll k = + Vbox + [: `HVbox [: :]; + listwbws level [: `S LR "[" :] (S LR "|") ll "" + [: `S LR "]"; k :] :] +; + +value entry (e, pos, ll) k = + BEbox + [: `LocInfo (intloc(MLast.loc_of_expr e)) + (HVbox [: `expr e "" [: `S RO ":" :]; position pos :]); + `level_list ll [: :]; + `HVbox [: `S RO ";"; k :] :] +; + +value entry_list el k = + Vbox [: `HVbox [: :]; list entry el k :] +; + +value extend_body (globals, e) k = + let s = entry_list e k in + match globals with + [ [] -> s + | sl -> + HVbox + [: `HVbox [: :]; + `HOVbox + [: `S LR "GLOBAL"; `S RO ":"; + list (fun e k -> HVbox [: `expr e "" k :]) sl + [: `S RO ";" :] :]; + `s :] ] +; + +value extend e _ k = + match e with + [ <:expr< Grammar.extend $e$ >> -> + try + let ex = unextend_body e in + BEbox + [: `S LR "EXTEND"; `extend_body ex [: :]; + `HVbox [: `S LR "END"; k :] :] + with + [ Not_found -> + HVbox + [: `S LR "Grammar.extend"; + `HOVbox + [: `S LO "("; + `expr e "" [: `HVbox [: `S RO ")"; k :] :] :] :] ] + | _ -> expr e "" k ] +; + +value get_gextend = + fun + [ <:expr< let $list:gl$ in $e$ >> -> + try + let (gmod, gl) = get_globals gl in + let el = ungextend_body e in + Some (gmod, gl, el) + with + [ Not_found -> None ] + | _ -> None ] +; + +value gextend e _ k = + match get_gextend e with + [ Some (gmod, gl, el) -> + BEbox + [: `HVbox [: `S LR "GEXTEND"; `S LR gmod :]; + `extend_body (gl, el) [: :]; + `HVbox [: `S LR "END"; k :] :] + | None -> expr e "" k ] +; + +value is_gextend e = get_gextend e <> None; + +(* Printer extensions *) + +let lev = + try find_pr_level "expr1" pr_expr.pr_levels with + [ Failure _ -> find_pr_level "top" pr_expr.pr_levels ] +in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< let $list:_$ in $_$ >> as e when is_gextend e -> + fun _ next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "apply" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Grammar.extend $_$ >> as e -> + fun _ next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "simple" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Grammar.extend $_$ >> as e -> + fun _ _ _ k -> [: `extend e "" k :] + | <:expr< let $list:_$ in $_$ >> as e when is_gextend e -> + fun _ _ _ k -> [: `gextend e "" k :] ]; + +Pcaml.add_option "-no_slist" (Arg.Set no_slist) + "Don't reconstruct SLIST and SOPT"; diff --git a/camlp4/unmaintained/etc/pr_extfun.ml b/camlp4/unmaintained/etc/pr_extfun.ml new file mode 100644 index 00000000..4479bb40 --- /dev/null +++ b/camlp4/unmaintained/etc/pr_extfun.ml @@ -0,0 +1,92 @@ +(* camlp4r q_MLast.cmo ./pa_extfun.cmo *) + + +open Pcaml; +open Spretty; + +value _loc = Loc.mk "FIXME pr_extfun.ml"; + +value expr e dg k = pr_expr.pr_fun "top" e dg k; +value patt e dg k = pr_patt.pr_fun "top" e dg k; + +value rec un_extfun rpel = + fun + [ <:expr< [ ($_$, $_$, fun [ $list:pel$ ]) :: $el$ ] >> -> + let (p, wo, e) = + match pel with + [ [(p, wo, <:expr< Some $e$ >>); + (<:patt< _ >>, None, <:expr< None >>)] -> + (p, wo, e) + | [(p, wo, <:expr< Some $e$ >>)] -> (p, wo, e) + | _ -> raise Not_found ] + in + let rpel = + match rpel with + [ [(p1, wo1, e1) :: pel] -> + if wo1 = wo && e1 = e then + let p = + match (p1, p) with + [ (<:patt< ($x1$ as $x2$) >>, <:patt< ($y1$ as $y2$) >>) -> + if x2 = y2 then <:patt< ($x1$ | $y1$ as $x2$) >> + else <:patt< $p1$ | $p$ >> + | _ -> <:patt< $p1$ | $p$ >> ] + in + [(p, wo, e) :: pel] + else [(p, wo, e) :: rpel] + | [] -> [(p, wo, e)] ] + in + un_extfun rpel el + | <:expr< [] >> -> List.rev rpel + | _ -> raise Not_found ] +; + +value rec listwbws elem b sep el k = + match el with + [ [] -> [: b; k :] + | [x] -> [: `elem b x k :] + | [x :: l] -> [: `elem b x [: :]; listwbws elem [: `sep :] sep l k :] ] +; + +value rec match_assoc_list pwel k = + match pwel with + [ [pwe] -> match_assoc [: `S LR "[" :] pwe [: `S LR "]"; k :] + | pel -> + Vbox + [: `HVbox [: :]; + listwbws match_assoc [: `S LR "[" :] (S LR "|") pel + [: `S LR "]"; k :] :] ] +and match_assoc b (p, w, e) k = + let s = + let (p, k) = + match p with + [ <:patt< ($p$ as $p2$) >> -> (p, [: `S LR "as"; `patt p2 "" [: :] :]) + | _ -> (p, [: :]) ] + in + match w with + [ Some e1 -> + [: `HVbox + [: `HVbox [: :]; `patt p "" k; + `HVbox [: `S LR "when"; `expr e1 "" [: `S LR "->" :] :] :] :] + | _ -> [: `patt p "" [: k; `S LR "->" :] :] ] + in + HVbox [: b; `HVbox [: `HVbox s; `expr e "" k :] :] +; + +let lev = find_pr_level "top" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Extfun.extend $e$ $list$ >> as ge -> + fun _ next dg k -> + try + let pel = un_extfun [] list in + [: `HVbox [: :]; + `BEbox [: `S LR "extfun"; `expr e "" [: :]; `S LR "with" :]; + `match_assoc_list pel k :] + with + [ Not_found -> [: `next ge dg k :] ] ]; + +let lev = find_pr_level "apply" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Extfun.extend $_$ $_$ >> as ge -> + fun _ next dg k -> [: `next ge dg k :] ]; diff --git a/camlp4/unmaintained/etc/pr_null.ml b/camlp4/unmaintained/etc/pr_null.ml new file mode 100644 index 00000000..22f3cb74 --- /dev/null +++ b/camlp4/unmaintained/etc/pr_null.ml @@ -0,0 +1,16 @@ +(* camlp4r *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +Pcaml.print_interf.val := fun _ -> (); +Pcaml.print_implem.val := fun _ -> (); diff --git a/camlp4/unmaintained/etc/pr_op.ml b/camlp4/unmaintained/etc/pr_op.ml new file mode 100644 index 00000000..9b2aebcf --- /dev/null +++ b/camlp4/unmaintained/etc/pr_op.ml @@ -0,0 +1,210 @@ +(* camlp4r q_MLast.cmo ./pa_extfun.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; +open Spretty; + +value expr e dg k = pr_expr.pr_fun "top" e dg k; +value patt e dg k = pr_patt.pr_fun "top" e dg k; + +value spatt p dg k = + match p with + [ <:patt< $lid:s$ >> -> + if String.length s >= 2 && s.[1] == ''' then + HVbox [: `S LR (" " ^ s); k :] + else patt p dg k + | _ -> patt p dg k ] +; + +(* Streams *) + +value stream e _ k = + let rec get = + fun + [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.ising $x$ >> -> [(True, x)] + | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)] + | <:expr< Stream.sempty >> -> [] + | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)] + | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)] + | e -> [(False, e)] ] + in + let elem e dg k = + match e with + [ (True, e) -> [: `HOVbox [: `S LO "'"; `expr e dg k :] :] + | (False, e) -> [: `expr e dg k :] ] + in + let rec glop e k = + match e with + [ [] -> k + | [e] -> [: elem e "" k :] + | [e :: el] -> [: elem e ";" [: `S RO ";" :]; glop el k :] ] + in + HOVbox [: `S LR "[<"; glop (get e) [: `S LR ">]"; k :] :] +; + +(* Parsers *) + +value parser_cases b spel dg k = + let rec parser_cases b spel dg k = + match spel with + [ [] -> [: `HVbox [: b; k :] :] + | [(sp, epo, e)] -> [: `parser_case b sp epo e dg k :] + | [(sp, epo, e) :: spel] -> + [: `parser_case b sp epo e "|" [: :]; + parser_cases [: `S LR "|" :] spel dg k :] ] + and parser_case b sp epo e dg k = + let epo = + match epo with + [ Some p -> [: `patt p "" [: `S LR "->" :] :] + | _ -> [: `S LR "->" :] ] + in + HVbox + [: b; + `HOVbox + [: `HOVbox + [: `S LR "[<"; + stream_patt [: :] sp [: `S LR ">]"; epo :] :]; + `expr e dg k :] :] + and stream_patt b sp k = + match sp with + [ [] -> [: `HVbox [: b; k :] :] + | [(spc, None)] -> [: `stream_patt_comp b spc "" k :] + | [(spc, Some e)] -> + [: `HVbox + [: `stream_patt_comp b spc "" [: :]; + `HVbox [: `S LR "??"; `expr e "" k :] :] :] + | [(spc, None) :: spcl] -> + [: `stream_patt_comp b spc ";" [: `S RO ";" :]; + stream_patt [: :] spcl k :] + | [(spc, Some e) :: spcl] -> + [: `HVbox + [: `stream_patt_comp b spc "" [: :]; + `HVbox [: `S LR "??"; `expr e ";" [: `S RO ";" :] :] :]; + stream_patt [: :] spcl k :] ] + and stream_patt_comp b spc dg k = + match spc with + [ SPCterm (p, w) -> + HVbox [: b; `S LO "'"; `spatt p "" (when_opt w k) :] + | SPCnterm p e -> + HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e dg k :] :] + | SPCsterm p -> HVbox [: b; `patt p "" k :] ] + and when_opt wo k = + match wo with + [ Some e -> [: `S LR "when"; `expr e "" k :] + | _ -> k ] + in + parser_cases b spel dg k +; + +value parser_body e dg k = + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + match Parserify.parser_of_expr e with + [ [] -> + let spe = ([], None, <:expr< raise Stream.Failure >>) in + HVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: :] [spe] dg k :] + | spel -> + BEVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: :] spel dg k :] ] +; + +value pmatch e dg k = + let (me, e) = + match e with + [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e) + | _ -> failwith "Pr_op.pmatch" ] + in + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + let spel = Parser_of_expr.parser_of_expr e in + Vbox + [: `HVbox [: :]; + `HVbox + [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + `BEbox [: `HVbox [: :]; parser_cases [: :] spel dg k :] :] +; + +(* Printer extensions *) + +pr_expr_fun_args.val := + extfun pr_expr_fun_args.val with + [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge) + | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ]; + +let lev = find_pr_level "expr1" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e -> + fun curr next dg k -> + if not (List.mem dg ["|"; ";"]) then [: `pmatch e dg k :] + else [: `S LO "("; `pmatch e "" [: `S RO ")"; k :] :] + | <:expr< fun __strm -> $x$ >> -> + fun curr next dg k -> + if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :] + else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :] + | <:expr< fun [ (__strm : $_$) -> $x$ ] >> -> + fun curr next dg k -> + if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :] + else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :] ]; + +let lev = find_pr_level "apply" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun curr next dg k -> [: `next e "" k :] ]; + +let lev = find_pr_level "dot" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.sempty >> as e -> + fun curr next dg k -> [: `next e "" k :] ]; + +let lev = find_pr_level "simple" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun curr next dg k -> + [: `stream e "" k :] ]; diff --git a/camlp4/unmaintained/etc/pr_op_main.ml b/camlp4/unmaintained/etc/pr_op_main.ml new file mode 100644 index 00000000..3ea53ba4 --- /dev/null +++ b/camlp4/unmaintained/etc/pr_op_main.ml @@ -0,0 +1,214 @@ +(* camlp4r q_MLast.cmo ./pa_extfun.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; +open Spretty; + +value _loc = Loc.mk "FIXME pr_op_main.ml"; + +value expr e dg k = pr_expr.pr_fun "top" e dg k; +value patt e dg k = pr_patt.pr_fun "top" e dg k; + +value spatt p dg k = + match p with + [ <:patt< $lid:s$ >> -> + if String.length s >= 2 && s.[1] == ''' then + HVbox [: `S LR (" " ^ s); k :] + else patt p dg k + | _ -> patt p dg k ] +; + +(* Streams *) + +value stream e _ k = + let rec get = + fun + [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.ising $x$ >> -> [(True, x)] + | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)] + | <:expr< Stream.sempty >> -> [] + | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)] + | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)] + | e -> [(False, e)] ] + in + let elem e dg k = + match e with + [ (True, e) -> [: `HOVbox [: `S LO "'"; `expr e dg k :] :] + | (False, e) -> [: `expr e dg k :] ] + in + let rec glop e k = + match e with + [ [] -> k + | [e] -> [: elem e "" k :] + | [e :: el] -> [: elem e ";" [: `S RO ";" :]; glop el k :] ] + in + HOVbox [: `S LR "[<"; glop (get e) [: `S LR ">]"; k :] :] +; + +(* Parsers *) + +open Parserify; + +value parser_cases b spel dg k = + let rec parser_cases b spel dg k = + match spel with + [ [] -> [: `HVbox [: b; k :] :] + | [(sp, epo, e)] -> [: `parser_case b sp epo e dg k :] + | [(sp, epo, e) :: spel] -> + [: `parser_case b sp epo e "|" [: :]; + parser_cases [: `S LR "|" :] spel dg k :] ] + and parser_case b sp epo e dg k = + let epo = + match epo with + [ Some p -> [: `patt p "" [: `S LR "->" :] :] + | _ -> [: `S LR "->" :] ] + in + HVbox + [: b; + `HOVbox + [: `HOVbox + [: `S LR "[<"; + stream_patt [: :] sp [: `S LR ">]"; epo :] :]; + `expr e dg k :] :] + and stream_patt b sp k = + match sp with + [ [] -> [: `HVbox [: b; k :] :] + | [(spc, None)] -> [: `stream_patt_comp b spc "" k :] + | [(spc, Some e)] -> + [: `HVbox + [: `stream_patt_comp b spc "" [: :]; + `HVbox [: `S LR "??"; `expr e "" k :] :] :] + | [(spc, None) :: spcl] -> + [: `stream_patt_comp b spc ";" [: `S RO ";" :]; + stream_patt [: :] spcl k :] + | [(spc, Some e) :: spcl] -> + [: `HVbox + [: `stream_patt_comp b spc "" [: :]; + `HVbox [: `S LR "??"; `expr e ";" [: `S RO ";" :] :] :]; + stream_patt [: :] spcl k :] ] + and stream_patt_comp b spc dg k = + match spc with + [ SPCterm (p, w) -> + HVbox [: b; `S LO "'"; `spatt p "" (when_opt w k) :] + | SPCnterm p e -> + HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e dg k :] :] + | SPCsterm p -> HVbox [: b; `patt p "" k :] ] + and when_opt wo k = + match wo with + [ Some e -> [: `S LR "when"; `expr e "" k :] + | _ -> k ] + in + parser_cases b spel dg k +; + +value parser_body e dg k = + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + match parser_of_expr e with + [ [] -> + let spe = ([], None, <:expr< raise Stream.Failure >>) in + HVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: :] [spe] dg k :] + | spel -> + BEVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: :] spel dg k :] ] +; + +value pmatch e dg k = + let (me, e) = + match e with + [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e) + | _ -> failwith "Pr_op.pmatch" ] + in + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + let spel = parser_of_expr e in + Vbox + [: `HVbox [: :]; + `HVbox + [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + `BEbox [: `HVbox [: :]; parser_cases [: :] spel dg k :] :] +; + +(* Printer extensions *) + +pr_expr_fun_args.val := + extfun pr_expr_fun_args.val with + [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge) + | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ]; + +let lev = find_pr_level "expr1" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e -> + fun _ _ dg k -> + if not (List.mem dg ["|"; ";"]) then [: `pmatch e dg k :] + else [: `S LO "("; `pmatch e "" [: `S RO ")"; k :] :] + | <:expr< fun __strm -> $x$ >> -> + fun _ _ dg k -> + if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :] + else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :] + | <:expr< fun [ (__strm : $_$) -> $x$ ] >> -> + fun _ _ dg k -> + if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :] + else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :] ]; + +let lev = find_pr_level "apply" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun _ next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "dot" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.sempty >> as e -> + fun _ next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "simple" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun _ _ _ k -> + [: `stream e "" k :] ]; diff --git a/camlp4/unmaintained/etc/pr_rp.ml b/camlp4/unmaintained/etc/pr_rp.ml new file mode 100644 index 00000000..0604b463 --- /dev/null +++ b/camlp4/unmaintained/etc/pr_rp.ml @@ -0,0 +1,207 @@ +(* camlp4r q_MLast.cmo ./pa_extfun.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; +open Spretty; + +value _loc = (Token.nowhere, Token.nowhere); + +value expr e dg k = pr_expr.pr_fun "top" e dg k; +value patt e dg k = pr_patt.pr_fun "top" e dg k; + +(* Streams *) + +value stream e dg k = + let rec get = + fun + [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.ising $x$ >> -> [(True, x)] + | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)] + | <:expr< Stream.sempty >> -> [] + | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)] + | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)] + | e -> [(False, e)] ] + in + let elem e k = + match e with + [ (True, e) -> [: `HOVbox [: `S LO "`"; `expr e "" k :] :] + | (False, e) -> [: `expr e "" k :] ] + in + let rec glop e k = + match e with + [ [] -> k + | [e] -> [: elem e k :] + | [e :: el] -> [: elem e [: `S RO ";" :]; glop el k :] ] + in + HOVbox [: `S LR "[:"; glop (get e) [: `S LR ":]"; k :] :] +; + +(* Parsers *) + +value parser_cases b spel k = + let rec parser_cases b spel k = + match spel with + [ [] -> [: `HVbox [: b; k :] :] + | [(sp, epo, e)] -> [: `parser_case b sp epo e k :] + | [(sp, epo, e) :: spel] -> + [: `parser_case b sp epo e [: :]; + parser_cases [: `S LR "|" :] spel k :] ] + and parser_case b sp epo e k = + let epo = + match epo with + [ Some p -> [: `patt p "" [: `S LR "->" :] :] + | _ -> [: `S LR "->" :] ] + in + HVbox + [: b; + `HOVbox + [: `HOVbox + [: `S LR "[:"; + stream_patt [: :] sp [: `S LR ":]"; epo :] :]; + `expr e "" k :] :] + and stream_patt b sp k = + match sp with + [ [] -> [: `HVbox [: b; k :] :] + | [(spc, None)] -> [: `stream_patt_comp b spc k :] + | [(spc, Some e)] -> + [: `HVbox + [: `stream_patt_comp b spc [: :]; + `HVbox [: `S LR "?"; `expr e "" k :] :] :] + | [(spc, None) :: spcl] -> + [: `stream_patt_comp b spc [: `S RO ";" :]; + stream_patt [: :] spcl k :] + | [(spc, Some e) :: spcl] -> + [: `HVbox + [: `stream_patt_comp b spc [: :]; + `HVbox [: `S LR "?"; `expr e "" [: `S RO ";" :] :] :]; + stream_patt [: :] spcl k :] ] + and stream_patt_comp b spc k = + match spc with + [ SPCterm (p, w) -> + HVbox [: b; `S LO "`"; `patt p "" [: :]; `HVbox [: when_opt w k :] :] + | SPCnterm p e -> + HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e "" k :] :] + | SPCsterm p -> HVbox [: b; `patt p "" k :] ] + and when_opt wo k = + match wo with + [ Some e -> [: `S LR "when"; `expr e "" k :] + | _ -> k ] + in + parser_cases b spel k +; + +value parser_body e dg k = + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + match Parserify.parser_of_expr e with + [ [] -> + HVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + `HVbox [: `S LR "[]"; k :] :] + | [spe] -> + HVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: :] [spe] k :] + | spel -> + Vbox + [: `HVbox [: :]; + `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :] ] +; + +value pmatch e dg k = + let (me, e) = + match e with + [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e) + | <:expr< match $_$ __strm with [ $list:_$ ] >> -> (<:expr< __strm >>, e) + | _ -> failwith "Pr_rp.pmatch" ] + in + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + let spel = Parserify.parser_of_expr e in + Vbox + [: `HVbox [: :]; + `HVbox + [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :] +; + +(* Printer extensions *) + +pr_expr_fun_args.val := + extfun pr_expr_fun_args.val with + [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge) + | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ]; + +let lev = find_pr_level "top" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e -> + fun curr next _ k -> [: `pmatch e "" k :] + | <:expr< match $_$ __strm with [ $list:_$ ] >> as e -> + fun curr next _ k -> [: `pmatch e "" k :] + | <:expr< fun __strm -> $x$ >> -> + fun curr next _ k -> [: `parser_body x "" k :] + | <:expr< fun (__strm : $_$) -> $x$ >> -> + fun curr next _ k -> [: `parser_body x "" k :] ]; + +let lev = find_pr_level "apply" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun curr next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "dot" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.sempty >> as e -> + fun curr next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "simple" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun curr next _ k -> [: `stream e "" k :] ]; diff --git a/camlp4/unmaintained/etc/pr_rp_main.ml b/camlp4/unmaintained/etc/pr_rp_main.ml new file mode 100644 index 00000000..534d4073 --- /dev/null +++ b/camlp4/unmaintained/etc/pr_rp_main.ml @@ -0,0 +1,206 @@ +(* camlp4r q_MLast.cmo ./pa_extfun.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 1998 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; +open Spretty; + +value _loc = Loc.mk "FIXME pr_rp_main.ml"; + +value expr e dg k = pr_expr.pr_fun "top" e dg k; +value patt e dg k = pr_patt.pr_fun "top" e dg k; + +(* Streams *) + +value stream e _ k = + let rec get = + fun + [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.ising $x$ >> -> [(True, x)] + | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y] + | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y] + | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)] + | <:expr< Stream.sempty >> -> [] + | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)] + | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)] + | e -> [(False, e)] ] + in + let elem e k = + match e with + [ (True, e) -> [: `HOVbox [: `S LO "`"; `expr e "" k :] :] + | (False, e) -> [: `expr e "" k :] ] + in + let rec glop e k = + match e with + [ [] -> k + | [e] -> [: elem e k :] + | [e :: el] -> [: elem e [: `S RO ";" :]; glop el k :] ] + in + HOVbox [: `S LR "[:"; glop (get e) [: `S LR ":]"; k :] :] +; + +(* Parsers *) + +open Parserify; + +value parser_cases b spel k = + let rec parser_cases b spel k = + match spel with + [ [] -> [: `HVbox [: b; k :] :] + | [(sp, epo, e)] -> [: `parser_case b sp epo e k :] + | [(sp, epo, e) :: spel] -> + [: `parser_case b sp epo e [: :]; + parser_cases [: `S LR "|" :] spel k :] ] + and parser_case b sp epo e k = + let epo = + match epo with + [ Some p -> [: `patt p "" [: `S LR "->" :] :] + | _ -> [: `S LR "->" :] ] + in + HVbox + [: b; + `HOVbox + [: `HOVbox + [: `S LR "[:"; + stream_patt [: :] sp [: `S LR ":]"; epo :] :]; + `expr e "" k :] :] + and stream_patt b sp k = + match sp with + [ [] -> [: `HVbox [: b; k :] :] + | [(spc, None)] -> [: `stream_patt_comp b spc k :] + | [(spc, Some e)] -> + [: `HVbox + [: `stream_patt_comp b spc [: :]; + `HVbox [: `S LR "?"; `expr e "" k :] :] :] + | [(spc, None) :: spcl] -> + [: `stream_patt_comp b spc [: `S RO ";" :]; + stream_patt [: :] spcl k :] + | [(spc, Some e) :: spcl] -> + [: `HVbox + [: `stream_patt_comp b spc [: :]; + `HVbox [: `S LR "?"; `expr e "" [: `S RO ";" :] :] :]; + stream_patt [: :] spcl k :] ] + and stream_patt_comp b spc k = + match spc with + [ SPCterm (p, w) -> + HVbox [: b; `S LO "`"; `patt p "" [: :]; `HVbox [: when_opt w k :] :] + | SPCnterm p e -> + HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e "" k :] :] + | SPCsterm p -> HVbox [: b; `patt p "" k :] ] + and when_opt wo k = + match wo with + [ Some e -> [: `S LR "when"; `expr e "" k :] + | _ -> k ] + in + parser_cases b spel k +; + +value parser_body e _ k = + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + match parser_of_expr e with + [ [] -> + HVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + `HVbox [: `S LR "[]"; k :] :] + | [spe] -> + HVbox + [: `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: :] [spe] k :] + | spel -> + Vbox + [: `HVbox [: :]; + `HVbox + [: `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :] ] +; + +value pmatch e _ k = + let (me, e) = + match e with + [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e) + | _ -> failwith "Pr_rp.pmatch" ] + in + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + let spel = parser_of_expr e in + Vbox + [: `HVbox [: :]; + `HVbox + [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser"; + match bp with + [ Some p -> [: `patt p "" [: :] :] + | _ -> [: :] ] :]; + parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :] +; + +(* Printer extensions *) + +pr_expr_fun_args.val := + extfun pr_expr_fun_args.val with + [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge) + | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ]; + +let lev = find_pr_level "top" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e -> + fun _ _ _ k -> [: `pmatch e "" k :] + | <:expr< fun __strm -> $x$ >> -> + fun _ _ _ k -> [: `parser_body x "" k :] + | <:expr< fun (__strm : $_$) -> $x$ >> -> + fun _ _ _ k -> [: `parser_body x "" k :] ]; + +let lev = find_pr_level "apply" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun _ next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "dot" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.sempty >> as e -> + fun _ next _ k -> [: `next e "" k :] ]; + +let lev = find_pr_level "simple" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> | + <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> | + <:expr< Stream.lcons (fun _ -> $_$) $_$ >> | + <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> | + <:expr< Stream.slazy $_$ >> as e -> + fun _ _ _ k -> [: `stream e "" k :] ]; diff --git a/camlp4/unmaintained/etc/q_phony.ml b/camlp4/unmaintained/etc/q_phony.ml new file mode 100644 index 00000000..e4908081 --- /dev/null +++ b/camlp4/unmaintained/etc/q_phony.ml @@ -0,0 +1,38 @@ +(* camlp4r pa_extend.cmo q_MLast.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2001 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +open Pcaml; + +value t = ref ""; + +Quotation.add "" + (Quotation.ExAst + (fun c s -> + let _loc = c.Quotation.loc in + let t = + if t.val = "" then "<<" ^ s ^ ">>" + else "<:" ^ t.val ^ "<" ^ s ^ ">>" + in + <:expr< $uid:t$ >>, + fun c s -> + let _loc = c.Quotation.loc in + let t = + if t.val = "" then "<<" ^ s ^ ">>" + else "<:" ^ t.val ^ "<" ^ s ^ ">>" + in + <:patt< $uid:t$ >>)) +; + +Quotation.default.val := ""; +Quotation.translate.val := fun s -> do { t.val := s; "" }; diff --git a/camlp4/unmaintained/extfold/README b/camlp4/unmaintained/extfold/README new file mode 100644 index 00000000..2a09ff09 --- /dev/null +++ b/camlp4/unmaintained/extfold/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + Nicolas Pouillard diff --git a/camlp4/unmaintained/extfold/pa_extfold.ml b/camlp4/unmaintained/extfold/pa_extfold.ml new file mode 100644 index 00000000..aa8e922b --- /dev/null +++ b/camlp4/unmaintained/extfold/pa_extfold.ml @@ -0,0 +1,42 @@ +(* camlp4r pa_extend.cmo q_MLast.cmo *) + + +open Pcaml; +open Pa_extend; + +value sfold _loc n foldfun f e s = + let styp = STquo _loc (new_type_var ()) in + let e = <:expr< Extfold.$lid:foldfun$ $f$ $e$ >> in + let t = STapp _loc (STapp _loc (STtyp <:ctyp< Extfold.t _ >>) s.styp) styp in + {used = s.used; text = TXmeta _loc n [s.text] e t; styp = styp} +; + +value sfoldsep _loc n foldfun f e s sep = + let styp = STquo _loc (new_type_var ()) in + let e = <:expr< Extfold.$lid:foldfun$ $f$ $e$ >> in + let t = + STapp _loc (STapp _loc (STtyp <:ctyp< Extfold.tsep _ >>) s.styp) styp + in + {used = s.used @ sep.used; text = TXmeta _loc n [s.text; sep.text] e t; + styp = styp} +; + +EXTEND + GLOBAL: symbol; + symbol: LEVEL "top" + [ [ UIDENT "FOLD0"; f = simple_expr; e = simple_expr; s = SELF -> + sfold _loc "FOLD0" "sfold0" f e s + | UIDENT "FOLD1"; f = simple_expr; e = simple_expr; s = SELF -> + sfold _loc "FOLD1" "sfold1" f e s + | UIDENT "FOLD0"; f = simple_expr; e = simple_expr; s = SELF; + UIDENT "SEP"; sep = symbol -> + sfoldsep _loc "FOLD0 SEP" "sfold0sep" f e s sep + | UIDENT "FOLD1"; f = simple_expr; e = simple_expr; s = SELF; + UIDENT "SEP"; sep = symbol -> + sfoldsep _loc "FOLD1 SEP" "sfold1sep" f e s sep ] ] + ; + simple_expr: + [ [ i = LIDENT -> <:expr< $lid:i$ >> + | "("; e = expr; ")" -> e ] ] + ; +END; diff --git a/camlp4/unmaintained/format/.depend b/camlp4/unmaintained/format/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/format/Makefile b/camlp4/unmaintained/format/Makefile new file mode 100644 index 00000000..c3887209 --- /dev/null +++ b/camlp4/unmaintained/format/Makefile @@ -0,0 +1,61 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# Makefile for pa_format +# M.Mauny +# + +include ../../config/Makefile.cnf + +OCAMLTOP=../../.. +CAMLP4=../../camlp4/camlp4$(EXE) + +OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) +OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) + +P4INCLUDES= -nolib -I ../../lib -I ../../meta -I ../../etc +OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../lib -I ../../camlp4 +OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES) + +SRC=pa_format.ml +OBJS=$(SRC:.ml=.cmo) +OBJSX=$(SRC:.ml=.cmx) + +all: $(OBJS) + +opt: $(OBJSX) + +depend: + cp .depend .depend.bak + > .depend + for file in $(SRC); do \ + $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \ + sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \ + done + +clean: + rm -f *.cm* *.$(O) *.bak .*.bak + + +.SUFFIXES: .cmx .cmo .cmi .ml .mli + +.mli.cmi: + $(OCAMLC) $(OCAMLCFLAGS) -c $< + + +.ml.cmo: + $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +.ml.cmx: + $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +include .depend diff --git a/camlp4/unmaintained/format/README b/camlp4/unmaintained/format/README new file mode 100644 index 00000000..809d42f2 --- /dev/null +++ b/camlp4/unmaintained/format/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + diff --git a/camlp4/unmaintained/format/pa_format.ml b/camlp4/unmaintained/format/pa_format.ml new file mode 100644 index 00000000..640a7503 --- /dev/null +++ b/camlp4/unmaintained/format/pa_format.ml @@ -0,0 +1,52 @@ +(* pa_r.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + +open Pcaml; + +EXTEND + GLOBAL: expr; + expr: LEVEL "top" + [ [ n = box_type; d = SELF; "begin"; + el = LIST0 [ e = box_expr; ";" -> e ]; "end" -> + let el = [<:expr< Format.$lid:"open_" ^ n$ $d$ >> :: el] in + let el = el @ [<:expr< Format.close_box () >>] in + <:expr< do { $list:el$ } >> + | "hbox"; "begin"; el = LIST0 [ e = box_expr; ";" -> e ]; "end" -> + let el = [<:expr< Format.open_hbox () >> :: el] in + let el = el @ [<:expr< Format.close_box () >>] in + <:expr< do { $list:el$ } >> + | "nobox"; "begin"; el = LIST0 [ e = box_expr; ";" -> e ]; "end" -> + match el with + [ [e] -> e + | _ -> <:expr< do { $list:el$ } >> ] ] ] + ; + box_type: + [ [ n = "hovbox" -> n + | n = "hvbox" -> n + | n = "vbox" -> n + | n = "box" -> n ] ] + ; + box_expr: + [ [ s = STRING -> <:expr< Format.print_string $str:s$ >> + | UIDENT "STRING"; e = expr -> <:expr< Format.print_string $e$ >> + | UIDENT "INT"; e = expr -> <:expr< Format.print_int $e$ >> + | "/-" -> <:expr< Format.print_space () >> + | "//" -> <:expr< Format.print_cut () >> + | "!/" -> <:expr< Format.force_newline () >> + | "?/" -> <:expr< Format.print_if_newline () >> + | e = expr -> e ] ] + ; +END; diff --git a/camlp4/unmaintained/lefteval/.depend b/camlp4/unmaintained/lefteval/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/lefteval/Makefile b/camlp4/unmaintained/lefteval/Makefile new file mode 100644 index 00000000..7e5cdd02 --- /dev/null +++ b/camlp4/unmaintained/lefteval/Makefile @@ -0,0 +1,61 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# Makefile for pa_lefteval +# M.Mauny +# + +include ../../config/Makefile.cnf + +OCAMLTOP=../../.. +CAMLP4=../../camlp4/camlp4$(EXE) + +OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) +OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) + +P4INCLUDES= -nolib -I ../../meta -I ../../etc +OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../camlp4 +OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES) + +SRC=pa_lefteval.ml +OBJS=$(SRC:.ml=.cmo) +OBJSX=$(SRC:.ml=.cmx) + +all: $(OBJS) + +opt: $(OBJSX) + +depend: + cp .depend .depend.bak + > .depend + for file in $(SRC); do \ + $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \ + sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \ + done + +clean: + rm -f *.cm* *.$(O) *.bak .*.bak + + +.SUFFIXES: .cmx .cmo .cmi .ml .mli + +.mli.cmi: + $(OCAMLC) $(OCAMLCFLAGS) -c $< + + +.ml.cmo: + $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +.ml.cmx: + $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +include .depend diff --git a/camlp4/unmaintained/lefteval/README b/camlp4/unmaintained/lefteval/README new file mode 100644 index 00000000..809d42f2 --- /dev/null +++ b/camlp4/unmaintained/lefteval/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + diff --git a/camlp4/unmaintained/lefteval/pa_lefteval.ml b/camlp4/unmaintained/lefteval/pa_lefteval.ml new file mode 100644 index 00000000..56ad2979 --- /dev/null +++ b/camlp4/unmaintained/lefteval/pa_lefteval.ml @@ -0,0 +1,241 @@ +(* pa_r.cmo q_MLast.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + +value not_impl name x = + let desc = + if Obj.is_block (Obj.repr x) then + "tag = " ^ string_of_int (Obj.tag (Obj.repr x)) + else "int_val = " ^ string_of_int (Obj.magic x) + in + failwith ("pa_lefteval: not impl: " ^ name ^ "; " ^ desc ^ ">") +; + +value rec expr_fa al = + fun + [ <:expr< $f$ $a$ >> -> expr_fa [a :: al] f + | f -> (f, al) ] +; + +(* generating let..in before functions calls which evaluates + several (more than one) of their arguments *) + +value no_side_effects_ht = + let ht = Hashtbl.create 73 in + do { + List.iter (fun s -> Hashtbl.add ht s True) + ["<"; "="; "@"; "^"; "+"; "-"; "ref"]; + ht + } +; + +value no_side_effects = + fun + [ <:expr< $uid:_$ >> -> True + | <:expr< $uid:_$ . $uid:_$ >> -> True + | <:expr< $lid:s$ >> -> + try Hashtbl.find no_side_effects_ht s with [ Not_found -> False ] + | _ -> False ] +; + +value rec may_side_effect = + fun + [ <:expr< $lid:_$ >> | <:expr< $uid:_$ >> | <:expr< $str:_$ >> | + <:expr< $chr:_$ >> | <:expr< $int:_$ >> | <:expr< $flo:_$ >> | + <:expr< $_$ . $_$ >> | <:expr< fun [ $list:_$ ] >> -> + False + | <:expr< ($list:el$) >> -> List.exists may_side_effect el + | <:expr< $_$ $_$ >> as e -> + let (f, el) = expr_fa [] e in + not (no_side_effects f) || List.exists may_side_effect el + | _ -> True ] +; + +value rec may_be_side_effect_victim = + fun + [ <:expr< $lid:_$ . $_$ >> -> True + | <:expr< $uid:_$ . $e$ >> -> may_be_side_effect_victim e + | _ -> False ] +; + +value rec may_depend_on_order el = + loop False False el where rec loop + side_effect_found side_effect_victim_found = + fun + [ [e :: el] -> + if may_side_effect e then + if side_effect_found || side_effect_victim_found then True + else loop True True el + else if may_be_side_effect_victim e then + if side_effect_found then True else loop False True el + else loop side_effect_found side_effect_victim_found el + | [] -> False ] +; + +value gen_let_in loc expr el = + let (pel, el) = + loop 0 (List.rev el) where rec loop n = + fun + [ [e :: el] -> + if may_side_effect e || may_be_side_effect_victim e then + if n = 0 then + let (pel, el) = loop 1 el in + (pel, [expr e :: el]) + else + let id = "xxx" ^ string_of_int n in + let (pel, el) = loop (n + 1) el in + ([(<:patt< $lid:id$ >>, expr e) :: pel], + [<:expr< $lid:id$ >> :: el]) + else + let (pel, el) = loop n el in + (pel, [expr e :: el]) + | [] -> ([], []) ] + in + match List.rev el with + [ [e :: el] -> (pel, e, el) + | _ -> assert False ] +; + +value left_eval_apply loc expr e1 e2 = + let (f, el) = expr_fa [] <:expr< $e1$ $e2$ >> in + if not (may_depend_on_order [f :: el]) then <:expr< $expr e1$ $expr e2$ >> + else + let (pel, e, el) = gen_let_in loc expr [f :: el] in + let e = List.fold_left (fun e e1 -> <:expr< $e$ $e1$ >>) e el in + List.fold_left (fun e (p1, e1) -> <:expr< let $p1$ = $e1$ in $e$ >>) e pel +; + +value left_eval_tuple loc expr el = + if not (may_depend_on_order el) then <:expr< ($list:List.map expr el$) >> + else + let (pel, e, el) = gen_let_in loc expr el in + List.fold_left (fun e (p1, e1) -> <:expr< let $p1$ = $e1$ in $e$ >>) + <:expr< ($list:[e :: el]$) >> pel +; + +value left_eval_record loc expr lel = + let el = List.map snd lel in + if not (may_depend_on_order el) then + let lel = List.map (fun (p, e) -> (p, expr e)) lel in + <:expr< { $list:lel$ } >> + else + let (pel, e, el) = gen_let_in loc expr el in + let e = + let lel = List.combine (List.map fst lel) [e :: el] in + <:expr< { $list:lel$ } >> + in + List.fold_left (fun e (p1, e1) -> <:expr< let $p1$ = $e1$ in $e$ >>) e pel +; + +value left_eval_assign loc expr e1 e2 = <:expr< $e1$ := $expr e2$ >>; + +(* scanning the input tree, calling "left_eval_*" functions if necessary *) + +value map_option f = + fun + [ Some x -> Some (f x) + | None -> None ] +; + +value class_infos f ci = + {MLast.ciLoc = ci.MLast.ciLoc; MLast.ciVir = ci.MLast.ciVir; + MLast.ciPrm = ci.MLast.ciPrm; MLast.ciNam = ci.MLast.ciNam; + MLast.ciExp = f ci.MLast.ciExp} +; + +value rec expr x = + let loc = MLast.loc_of_expr x in + match x with + [ <:expr< fun [ $list:pwel$ ] >> -> + <:expr< fun [ $list:List.map match_assoc pwel$ ] >> + | <:expr< match $e$ with [ $list:pwel$ ] >> -> + <:expr< match $expr e$ with [ $list:List.map match_assoc pwel$ ] >> + | <:expr< try $e$ with [ $list:pwel$ ] >> -> + <:expr< try $expr e$ with [ $list:List.map match_assoc pwel$ ] >> + | <:expr< let $opt:rf$ $list:pel$ in $e$ >> -> + <:expr< let $opt:rf$ $list:List.map let_binding pel$ in $expr e$ >> + | <:expr< let module $s$ = $me$ in $e$ >> -> + <:expr< let module $s$ = $module_expr me$ in $expr e$ >> + | <:expr< if $e1$ then $e2$ else $e3$ >> -> + <:expr< if $expr e1$ then $expr e2$ else $expr e3$ >> + | <:expr< while $e$ do { $list:el$ } >> -> + <:expr< while $expr e$ do { $list:List.map expr el$ } >> + | <:expr< do { $list:el$ } >> -> <:expr< do { $list:List.map expr el$ } >> + | <:expr< $e$ # $s$ >> -> <:expr< $expr e$ # $s$ >> + | <:expr< ($e$ : $t$) >> -> <:expr< ($expr e$ : $t$) >> + | <:expr< $e1$ || $e2$ >> -> <:expr< $expr e1$ || $expr e2$ >> + | <:expr< $e1$ && $e2$ >> -> <:expr< $expr e1$ && $expr e2$ >> + | <:expr< $e1$ $e2$ >> -> left_eval_apply loc expr e1 e2 + | <:expr< ($list:el$) >> -> left_eval_tuple loc expr el + | <:expr< { $list:lel$ } >> -> left_eval_record loc expr lel + | <:expr< $e1$ := $e2$ >> -> left_eval_assign loc expr e1 e2 + | <:expr< $_$ . $_$ >> | <:expr< $uid:_$ >> | <:expr< $lid:_$ >> | + <:expr< $str:_$ >> | <:expr< $chr:_$ >> | <:expr< $int:_$ >> | + <:expr< $flo:_$ >> | <:expr< new $list:_$ >> -> + x + | x -> not_impl "expr" x ] +and let_binding (p, e) = (p, expr e) +and match_assoc (p, eo, e) = (p, map_option expr eo, expr e) +and module_expr x = + let loc = MLast.loc_of_module_expr x in + match x with + [ <:module_expr< functor ($s$ : $mt$) -> $me$ >> -> + <:module_expr< functor ($s$ : $mt$) -> $module_expr me$ >> + | <:module_expr< ($me$ : $mt$) >> -> + <:module_expr< ($module_expr me$ : $mt$) >> + | <:module_expr< struct $list:sil$ end >> -> + <:module_expr< struct $list:List.map str_item sil$ end >> + | <:module_expr< $_$ . $_$ >> | <:module_expr< $_$ $_$ >> | + <:module_expr< $uid:_$ >> -> + x ] +and str_item x = + let loc = MLast.loc_of_str_item x in + match x with + [ <:str_item< module $s$ = $me$ >> -> + <:str_item< module $s$ = $module_expr me$ >> + | <:str_item< value $opt:rf$ $list:pel$ >> -> + <:str_item< value $opt:rf$ $list:List.map let_binding pel$ >> + | <:str_item< declare $list:sil$ end >> -> + <:str_item< declare $list:List.map str_item sil$ end >> + | <:str_item< class $list:ce$ >> -> + <:str_item< class $list:List.map (class_infos class_expr) ce$ >> + | <:str_item< $exp:e$ >> -> <:str_item< $exp:expr e$ >> + | <:str_item< open $_$ >> | <:str_item< type $list:_$ >> | + <:str_item< exception $_$ of $list:_$ = $_$ >> | + <:str_item< module type $_$ = $_$ >> | <:str_item< # $_$ $opt:_$ >> -> + x + | x -> not_impl "str_item" x ] +and class_expr x = + let loc = MLast.loc_of_class_expr x in + match x with + [ <:class_expr< object $opt:p$ $list:csil$ end >> -> + <:class_expr< object $opt:p$ $list:List.map class_str_item csil$ end >> + | x -> not_impl "class_expr" x ] +and class_str_item x = + let loc = MLast.loc_of_class_str_item x in + match x with + [ <:class_str_item< value $opt:mf$ $s$ = $e$ >> -> + <:class_str_item< value $opt:mf$ $s$ = $expr e$ >> + | <:class_str_item< method $s$ = $e$ >> -> + <:class_str_item< method $s$ = $expr e$ >> + | x -> not_impl "class_str_item" x ] +; + +value parse_implem = Pcaml.parse_implem.val; +value parse_implem_with_left_eval strm = + let (r, b) = parse_implem strm in + (List.map (fun (si, loc) -> (str_item si, loc)) r, b) +; +Pcaml.parse_implem.val := parse_implem_with_left_eval; diff --git a/camlp4/unmaintained/lib/.cvsignore b/camlp4/unmaintained/lib/.cvsignore new file mode 100644 index 00000000..c77a681d --- /dev/null +++ b/camlp4/unmaintained/lib/.cvsignore @@ -0,0 +1,3 @@ +*.cm[oiax] +*.cmxa +*.lib diff --git a/camlp4/unmaintained/lib/.depend b/camlp4/unmaintained/lib/.depend new file mode 100644 index 00000000..a7793969 --- /dev/null +++ b/camlp4/unmaintained/lib/.depend @@ -0,0 +1,14 @@ +debug.cmo: debug.cmi +debug.cmx: debug.cmi +extfun.cmo: extfun.cmi +extfun.cmx: extfun.cmi +fstream.cmo: fstream.cmi +fstream.cmx: fstream.cmi +grammar.cmo: token.cmi plexer.cmi loc.cmi +grammar.cmx: token.cmx plexer.cmi loc.cmx +loc.cmo: loc.cmi +loc.cmx: loc.cmi +token.cmo: loc.cmi token.cmi +token.cmx: loc.cmx token.cmi +plexer.cmi: token.cmi loc.cmi +token.cmi: loc.cmi diff --git a/camlp4/unmaintained/lib/Makefile b/camlp4/unmaintained/lib/Makefile new file mode 100644 index 00000000..3d5be9b4 --- /dev/null +++ b/camlp4/unmaintained/lib/Makefile @@ -0,0 +1,52 @@ + + +include ../config/Makefile.cnf + +INCLUDES=-I $(OTOP)/parsing -I $(OTOP)/utils +LIBRARIES=gramlib.cma +OBJS=$(OTOP)/utils/misc.cmo $(OTOP)/parsing/linenum.cmo \ + $(OTOP)/utils/warnings.cmo $(OTOP)/parsing/location.cmo \ + $(OTOP)/utils/config.cmo debug.cmo loc.cmo \ + token.cmo lexer_token.cmo lexer_error.cmo \ + plexer.cmo grammar.cmo extfun.cmo \ + fstream.cmo +CLEANFILES=plexer.ml + +include ../config/Makefile.base + +debug.cmo: debug.cmi +debug.cmo: debug.ml + $(OCAMLC) -pp '$(CAMLP4BOOT)' -rectypes $(OCAMLCFLAGS) $< -c -o $@ + +plexer.cmo: plexer.ml plexer.cmi + $(OCAMLC) $(OCAMLCFLAGS) $< -c -o $@ + +plexer.cmx: plexer.ml plexer.cmi + $(OCAMLOPT) $(OCAMLCFLAGS) $< -c -o $@ + +$(LIBRARIES): $(OBJS) + $(OCAMLC) -linkall $(OBJS) -a -o $(LIBRARIES) + +$(LIBRARIESX): $(OBJSX) + $(OCAMLOPT) -linkall $(OBJSX) -a -o $(LIBRARIESX) + +$(LIBRARIESP): $(OBJSP) + $(OCAMLOPT) -linkall $(OBJSP) -a -o $(LIBRARIESP) + +install-local: + -$(MKDIR) "$(LIBDIR)/camlp4" + cp $(LIBRARIES) *.mli "$(LIBDIR)/camlp4/." + cp *.cmi "$(LIBDIR)/camlp4/." + test -f $(LIBRARIESX) && $(MAKE) installopt LIBDIR="$(LIBDIR)" || true + +installopt: + for f in $(LIBRARIESX) $(LIBRARIESP) *.cmx ; do \ + test -f $$f && cp $$f "$(LIBDIR)/camlp4/." || true ; \ + done + # Special treatment for this one: some versions of make don't like $(A) in $(TARGET:.cma=.$(A)) + target="`echo $(LIBRARIES) | sed -e 's/\.cma$$/.$(A)/'`" ; \ + if test -f $$target ; then \ + cp $$target "$(LIBDIR)/camlp4/." && ( cd "$(LIBDIR)/camlp4/." && $(RANLIB) $$target ) \ + fi + +include .depend diff --git a/camlp4/unmaintained/lib/extfun.ml b/camlp4/unmaintained/lib/extfun.ml new file mode 100644 index 00000000..4f4cbbd9 --- /dev/null +++ b/camlp4/unmaintained/lib/extfun.ml @@ -0,0 +1,107 @@ +(* camlp4r *) + +(* Copyright 2001 INRIA *) + +(* Extensible Functions *) + +type t 'a 'b = list (matching 'a 'b) +and matching 'a 'b = { patt : patt; has_when : bool; expr : expr 'a 'b } +and patt = + [ Eapp of list patt + | Eacc of list patt + | Econ of string + | Estr of string + | Eint of string + | Etup of list patt + | Evar of unit ] +and expr 'a 'b = 'a -> option 'b +; + +exception Failure; + +value empty = []; + +(*** Apply ***) + +value rec apply_matchings a = + fun + [ [m :: ml] -> + match m.expr a with + [ None -> apply_matchings a ml + | x -> x ] + | [] -> None ] +; + +value apply ef a = + match apply_matchings a ef with + [ Some x -> x + | None -> raise Failure ] +; + +(*** Trace ***) + +value rec list_iter_sep f s = + fun + [ [] -> () + | [x] -> f x + | [x :: l] -> do { f x; s (); list_iter_sep f s l } ] +; + +value rec print_patt = + fun + [ Eapp pl -> list_iter_sep print_patt2 (fun () -> print_string " ") pl + | p -> print_patt2 p ] +and print_patt2 = + fun + [ Eacc pl -> list_iter_sep print_patt1 (fun () -> print_string ".") pl + | p -> print_patt1 p ] +and print_patt1 = + fun + [ Econ s -> print_string s + | Estr s -> do { print_string "\""; print_string s; print_string "\"" } + | Eint s -> print_string s + | Evar () -> print_string "_" + | Etup pl -> + do { + print_string "("; + list_iter_sep print_patt (fun () -> print_string ", ") pl; + print_string ")" + } + | Eapp _ | Eacc _ as p -> + do { print_string "("; print_patt p; print_string ")" } ] +; + +value print ef = + List.iter + (fun m -> + do { + print_patt m.patt; + if m.has_when then print_string " when ..." else (); + print_newline () + }) + ef +; + +(*** Extension ***) + +value insert_matching matchings (patt, has_when, expr) = + let m1 = {patt = patt; has_when = has_when; expr = expr} in + let rec loop = + fun + [ [m :: ml] as gml -> + if m1.has_when && not m.has_when then [m1 :: gml] else + if not m1.has_when && m.has_when then [m :: loop ml] else + (* either both or none have a when clause *) + if compare m1.patt m.patt = 0 then + if not m1.has_when then [m1 :: ml] else [m1 :: gml] + else [m :: loop ml] + | [] -> [m1] ] + in + loop matchings +; + +(* available extension function *) + +value extend ef matchings_def = + List.fold_left insert_matching ef matchings_def +; diff --git a/camlp4/unmaintained/lib/extfun.mli b/camlp4/unmaintained/lib/extfun.mli new file mode 100644 index 00000000..6d71fc11 --- /dev/null +++ b/camlp4/unmaintained/lib/extfun.mli @@ -0,0 +1,35 @@ +(* camlp4r *) + + +(** Extensible functions. + + This module implements pattern matching extensible functions. + To extend, use syntax [pa_extfun.cmo]: + + [extfun e with [ pattern_matching ]] *) + +type t 'a 'b = 'x; + (** The type of the extensible functions of type ['a -> 'b] *) +value empty : t 'a 'b; + (** Empty extensible function *) +value apply : t 'a 'b -> 'a -> 'b; + (** Apply an extensible function *) +exception Failure; + (** Match failure while applying an extensible function *) +value print : t 'a 'b -> unit; + (** Print patterns in the order they are recorded *) + +(**/**) + +type patt = + [ Eapp of list patt + | Eacc of list patt + | Econ of string + | Estr of string + | Eint of string + | Etup of list patt + | Evar of unit ] +and expr 'a 'b = 'a -> option 'b +; + +value extend : t 'a 'b -> list (patt * bool * expr 'a 'b) -> t 'a 'b; diff --git a/camlp4/unmaintained/lib/fstream.ml b/camlp4/unmaintained/lib/fstream.ml new file mode 100644 index 00000000..8c3171a8 --- /dev/null +++ b/camlp4/unmaintained/lib/fstream.ml @@ -0,0 +1,77 @@ +(* camlp4r *) + +(* Copyright 2001 INRIA *) + +type t 'a = { count : int; data : Lazy.t (data 'a) } +and data 'a = + [ Nil + | Cons of 'a and t 'a + | App of t 'a and t 'a ] +; + +value from f = + loop 0 where rec loop i = + {count = 0; + data = + lazy + (match f i with + [ Some x -> Cons x (loop (i + 1)) + | None -> Nil ])} +; + +value rec next s = + let count = s.count + 1 in + match Lazy.force s.data with + [ Nil -> None + | Cons a s -> Some (a, {count = count; data = s.data}) + | App s1 s2 -> + match next s1 with + [ Some (a, s1) -> Some (a, {count = count; data = lazy (App s1 s2)}) + | None -> + match next s2 with + [ Some (a, s2) -> Some (a, {count = count; data = s2.data}) + | None -> None ] ] ] +; + +value empty s = + match next s with + [ Some _ -> None + | None -> Some ((), s) ] +; + +value nil = {count = 0; data = lazy Nil}; +value cons a s = Cons a s; +value app s1 s2 = App s1 s2; +value flazy f = {count = 0; data = Lazy.lazy_from_fun f}; + +value of_list l = + List.fold_right (fun x s -> flazy (fun () -> cons x s)) l nil +; + +value of_string s = + from (fun c -> if c < String.length s then Some s.[c] else None) +; + +value of_channel ic = + from (fun _ -> try Some (input_char ic) with [ End_of_file -> None ]) +; + +value iter f = + do_rec where rec do_rec strm = + match next strm with + [ Some (a, strm) -> + let _ = f a in + do_rec strm + | None -> () ] +; + +value count s = s.count; + +value count_unfrozen s = + loop 0 s where rec loop cnt s = + if Lazy.lazy_is_val s.data then + match Lazy.force s.data with + [ Cons _ s -> loop (cnt + 1) s + | _ -> cnt ] + else cnt +; diff --git a/camlp4/unmaintained/lib/fstream.mli b/camlp4/unmaintained/lib/fstream.mli new file mode 100644 index 00000000..723389ac --- /dev/null +++ b/camlp4/unmaintained/lib/fstream.mli @@ -0,0 +1,60 @@ +(* camlp4r *) + + +(* Module [Fstream]: functional streams *) + +(* This module implement functional streams. + To be used with syntax [pa_fstream.cmo]. The syntax is: +- stream: [fstream [: ... :]] +- parser: [parser [ [: ... :] -> ... | ... ]] + + Functional parsers are of type: [Fstream.t 'a -> option ('a * Fstream.t 'a)] + + They have limited backtrack, i.e if a rule fails, the next rule is tested + with the initial stream; limited because when in case of a rule with two + consecutive symbols [a] and [b], if [b] fails, the rule fails: there is + no try with the next rule of [a]. +*) + +type t 'a = 'x; + (* The type of 'a functional streams *) +value from : (int -> option 'a) -> t 'a; + (* [Fstream.from f] returns a stream built from the function [f]. + To create a new stream element, the function [f] is called with + the current stream count. The user function [f] must return either + [Some ] for a value or [None] to specify the end of the + stream. *) + +value of_list : list 'a -> t 'a; + (* Return the stream holding the elements of the list in the same + order. *) +value of_string : string -> t char; + (* Return the stream of the characters of the string parameter. *) +value of_channel : in_channel -> t char; + (* Return the stream of the characters read from the input channel. *) + +value iter : ('a -> unit) -> t 'a -> unit; + (* [Fstream.iter f s] scans the whole stream s, applying function [f] + in turn to each stream element encountered. *) + +value next : t 'a -> option ('a * t 'a); + (* Return [Some (a, s)] where [a] is the first element of the stream + and [s] the remaining stream, or [None] if the stream is empty. *) +value empty : t 'a -> option (unit * t 'a); + (* Return [Some ((), s)] if the stream is empty where [s] is itself, + else [None] *) +value count : t 'a -> int; + (* Return the current count of the stream elements, i.e. the number + of the stream elements discarded. *) +value count_unfrozen : t 'a -> int; + (* Return the number of unfrozen elements in the beginning of the + stream; useful to determine the position of a parsing error (longuest + path). *) + +(*--*) + +value nil : t 'a; +type data 'a = 'x; +value cons : 'a -> t 'a -> data 'a; +value app : t 'a -> t 'a -> data 'a; +value flazy : (unit -> data 'a) -> t 'a; diff --git a/camlp4/unmaintained/ocamllex/Makefile b/camlp4/unmaintained/ocamllex/Makefile new file mode 100644 index 00000000..b232023e --- /dev/null +++ b/camlp4/unmaintained/ocamllex/Makefile @@ -0,0 +1,59 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# Makefile for pa_ocamllex +# M.Mauny +# + +include ../../config/Makefile.cnf + +OCAMLTOP=../../.. + +CAMLP4=../../camlp4/camlp4$(EXE) + +OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) +OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) + +P4INCLUDES= -nolib -I ../../etc -I ../../meta +OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../camlp4 -I ../../lib -I $(OCAMLTOP)/lex +OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES) + +SRC=pa_ocamllex.ml +OBJS=pa_ocamllex.cmo +OBJSX=$(OBJS:.cmo=.cmx) + +all: $(OBJS) pa_ocamllex.cma + +opt: $(OBJSX) pa_ocamllex.cmxa + +pa_ocamllex.cma: pa_ocamllex.cmo + $(OCAMLC) $(OCAMLCFLAGS) cset.cmo syntax.cmo table.cmo lexgen.cmo compact.cmo pa_ocamllex.cmo -a -o pa_ocamllex.cma + +pa_ocamllex.cmxa: pa_ocamllex.cmo + $(OCAMLOPT) $(OCAMLCFLAGS) cset.cmx syntax.cmx table.cmx lexgen.cmx compact.cmx pa_ocamllex.cmx -a -o pa_ocamllex.cmxa + +clean: + rm -f *.cm* *.$(O) *.$(A) *.bak .*.bak + +depend: + +.SUFFIXES: .cmx .cmo .cmi .ml .mli + +.mli.cmi: + $(OCAMLC) $(OCAMLCFLAGS) -c $< + + +.ml.cmo: + $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +.ml.cmx: + $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< diff --git a/camlp4/unmaintained/ocamllex/README b/camlp4/unmaintained/ocamllex/README new file mode 100644 index 00000000..809d42f2 --- /dev/null +++ b/camlp4/unmaintained/ocamllex/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + diff --git a/camlp4/unmaintained/ocamllex/pa_ocamllex.ml b/camlp4/unmaintained/ocamllex/pa_ocamllex.ml new file mode 100644 index 00000000..e1d4a8ef --- /dev/null +++ b/camlp4/unmaintained/ocamllex/pa_ocamllex.ml @@ -0,0 +1,356 @@ +(* pa_o.cmo q_MLast.cmo pa_extend.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Alain Frisch, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + +open Syntax +open Lexgen +open Compact + +(* Adapted from output.ml *) +(**************************) + +(* Output the DFA tables and its entry points *) + +(* To output an array of short ints, encoded as a string *) + +let output_byte buf b = + Buffer.add_char buf '\\'; + Buffer.add_char buf (Char.chr(48 + b / 100)); + Buffer.add_char buf (Char.chr(48 + (b / 10) mod 10)); + Buffer.add_char buf (Char.chr(48 + b mod 10)) + +let loc = (Lexing.dummy_pos,Lexing.dummy_pos) + +let output_array v = + let b = Buffer.create (Array.length v * 3) in + for i = 0 to Array.length v - 1 do + output_byte b (v.(i) land 0xFF); + output_byte b ((v.(i) asr 8) land 0xFF); + if i land 7 = 7 then Buffer.add_string b "\\\n " + done; + let s = Buffer.contents b in + <:expr< $str:s$ >> + +let output_byte_array v = + let b = Buffer.create (Array.length v * 2) in + for i = 0 to Array.length v - 1 do + output_byte b (v.(i) land 0xFF); + if i land 15 = 15 then Buffer.add_string b "\\\n " + done; + let s = Buffer.contents b in + <:expr< $str:s$ >> + + + +(* Output the tables *) + +let output_tables tbl = + <:str_item< value lex_tables = { + Lexing.lex_base = $output_array tbl.tbl_base$; + Lexing.lex_backtrk = $output_array tbl.tbl_backtrk$; + Lexing.lex_default = $output_array tbl.tbl_default$; + Lexing.lex_trans = $output_array tbl.tbl_trans$; + Lexing.lex_check = $output_array tbl.tbl_check$; + Lexing.lex_base_code = $output_array tbl.tbl_base_code$; + Lexing.lex_backtrk_code = $output_array tbl.tbl_backtrk_code$; + Lexing.lex_default_code = $output_array tbl.tbl_default_code$; + Lexing.lex_trans_code = $output_array tbl.tbl_trans_code$; + Lexing.lex_check_code = $output_array tbl.tbl_check_code$; + Lexing.lex_code = $output_byte_array tbl.tbl_code$ + } >> + +(* Output the entries *) + +let rec make_alias n = function + | [] -> [] + | h::t -> + (h, "__ocaml_lex_arg_" ^ (string_of_int n)) :: (make_alias (succ n) t) + +let abstraction = + List.fold_right (fun (p,a) e -> <:expr< fun ($p$ as $lid:a$) -> $e$ >>) + + +let application = + List.fold_left (fun f (_,a) -> <:expr< $f$ $lid:a$ >>) + +let int i = <:expr< $int:string_of_int i$ >> + +let output_memory_actions acts = + let aux = function + | Copy (tgt, src) -> + <:expr< lexbuf.Lexing.lex_mem.($int tgt$) := + lexbuf.Lexing.lex_mem.($int src$) >> + | Set tgt -> + <:expr< lexbuf.Lexing.lex_mem.($int tgt$) := + lexbuf.Lexing.lex_curr_pos >> + in + <:expr< do { $list:List.map aux acts$ } >> + +let output_base_mem = function + | Mem i -> <:expr< lexbuf.Lexing.lex_mem.($int i$) >> + | Start -> <:expr< lexbuf.Lexing.lex_start_pos >> + | End -> <:expr< lexbuf.Lexing.lex_curr_pos >> + +let output_tag_access = function + | Sum (a,0) -> output_base_mem a + | Sum (a,i) -> <:expr< $output_base_mem a$ + $int i$ >> + +let rec output_env e = function + | [] -> e + | (x, Ident_string (o,nstart,nend)) :: rem -> + <:expr< + let $lid:x$ = + Lexing.$lid:if o then "sub_lexeme_opt" else "sub_lexeme"$ + lexbuf $output_tag_access nstart$ $output_tag_access nend$ + in $output_env e rem$ + >> + | (x, Ident_char (o,nstart)) :: rem -> + <:expr< + let $lid:x$ = + Lexing.$lid: if o then "sub_lexeme_char_opt" else "sub_lexeme_char"$ + lexbuf $output_tag_access nstart$ + in $output_env e rem$ + >> + +let output_entry e = + let init_num, init_moves = e.auto_initial_state in + let args = make_alias 0 (e.auto_args @ [ <:patt< lexbuf >> ]) in + let f = "__ocaml_lex_rec_" ^ e.auto_name ^ "_rec" in + let call_f = application <:expr< $lid:f$ >> args in + let body_wrapper = + <:expr< + do { + lexbuf.Lexing.lex_mem := Array.create $int e.auto_mem_size$ (-1) ; + $output_memory_actions init_moves$; + $call_f$ $int init_num$ + } >> in + let cases = + List.map + (fun (num, env, (loc,e)) -> + <:patt< $int:string_of_int num$ >>, + None, + output_env <:expr< $e$ >> env + (* Note: the <:expr<...>> above is there to set the location *) + ) e.auto_actions @ + [ <:patt< __ocaml_lex_n >>, + None, + <:expr< do + { lexbuf.Lexing.refill_buff lexbuf; $call_f$ __ocaml_lex_n }>> ] + in + let engine = + if e.auto_mem_size = 0 + then <:expr< Lexing.engine >> + else <:expr< Lexing.new_engine >> in + let body = + <:expr< fun state -> + match $engine$ lex_tables state lexbuf with [ $list:cases$ ] >> in + [ + <:patt< $lid:e.auto_name$ >>, (abstraction args body_wrapper); + <:patt< $lid:f$ >>, (abstraction args body) + ] + +(* Main output function *) + +exception Table_overflow + +let output_lexdef tables entry_points = + Printf.eprintf + "pa_ocamllex: lexer found; %d states, %d transitions, table size %d bytes\n" + (Array.length tables.tbl_base) + (Array.length tables.tbl_trans) + (2 * (Array.length tables.tbl_base + Array.length tables.tbl_backtrk + + Array.length tables.tbl_default + Array.length tables.tbl_trans + + Array.length tables.tbl_check)); + let size_groups = + (2 * (Array.length tables.tbl_base_code + + Array.length tables.tbl_backtrk_code + + Array.length tables.tbl_default_code + + Array.length tables.tbl_trans_code + + Array.length tables.tbl_check_code) + + Array.length tables.tbl_code) in + if size_groups > 0 then + Printf.eprintf "pa_ocamllex: %d additional bytes used for bindings\n" + size_groups ; + flush stderr; + if Array.length tables.tbl_trans > 0x8000 then raise Table_overflow; + + let entries = List.map output_entry entry_points in + [output_tables tables; <:str_item< value rec $list:List.flatten entries$ >> ] + + +(* Adapted from parser.mly and main.ml *) +(***************************************) + +(* Auxiliaries for the parser. *) + +let char s = Char.code (Token.eval_char s) + +let named_regexps = + (Hashtbl.create 13 : (string, regular_expression) Hashtbl.t) + +let regexp_for_string s = + let rec re_string n = + if n >= String.length s then Epsilon + else if succ n = String.length s then + Characters (Cset.singleton (Char.code s.[n])) + else + Sequence + (Characters(Cset.singleton (Char.code s.[n])), + re_string (succ n)) + in re_string 0 + +let char_class c1 c2 = Cset.interval c1 c2 + +let all_chars = Cset.all_chars + +let rec remove_as = function + | Bind (e,_) -> remove_as e + | Epsilon|Eof|Characters _ as e -> e + | Sequence (e1, e2) -> Sequence (remove_as e1, remove_as e2) + | Alternative (e1, e2) -> Alternative (remove_as e1, remove_as e2) + | Repetition e -> Repetition (remove_as e) + +let () = + Hashtbl.add named_regexps "eof" (Characters Cset.eof) + +(* The parser *) + +let let_regexp = Grammar.Entry.create Pcaml.gram "pa_ocamllex let" +let header = Grammar.Entry.create Pcaml.gram "pa_ocamllex header" +let lexer_def = Grammar.Entry.create Pcaml.gram "pa_ocaml lexerdef" + +EXTEND + GLOBAL: Pcaml.str_item let_regexp header lexer_def; + + let_regexp: [ + [ x = LIDENT; "="; r = regexp -> + if Hashtbl.mem named_regexps x then + Printf.eprintf + "pa_ocamllex (warning): multiple definition of named regexp '%s'\n" + x; + Hashtbl.add named_regexps x r; + ] + ]; + + lexer_def: [ + [ def = LIST0 definition SEP "and" -> + (try + let (entries, transitions) = make_dfa def in + let tables = compact_tables transitions in + let output = output_lexdef tables entries in + <:str_item< declare $list: output$ end >> + with + |Table_overflow -> + failwith "Transition table overflow in lexer, automaton is too big" + | Lexgen.Memory_overflow -> + failwith "Position memory overflow in lexer, too many as variables") + ] + ]; + + + Pcaml.str_item: [ + [ "pa_ocamllex"; LIDENT "rule"; d = lexer_def -> d + | "pa_ocamllex"; "let"; let_regexp -> + <:str_item< declare $list: []$ end >> + ] + ]; + + definition: [ + [ x=LIDENT; pl = LIST0 Pcaml.patt LEVEL "simple"; "="; + short=[ LIDENT "parse" -> false | LIDENT "shortest" -> true ]; + OPT "|"; l = LIST0 [ r=regexp; a=action -> (r,a) ] SEP "|" -> + { name=x ; shortest=short ; args=pl ; clauses = l } ] + ]; + + action: [ + [ "{"; e = OPT Pcaml.expr; "}" -> + let e = match e with + | Some e -> e + | None -> <:expr< () >> + in + (loc,e) + ] + ]; + + header: [ + [ "{"; e = LIST0 [ si = Pcaml.str_item; OPT ";;" -> si ]; "}" -> + [<:str_item< declare $list:e$ end>>, loc] ] + | [ -> [] ] + ]; + + regexp: [ + [ r = regexp; "as"; i = LIDENT -> Bind (r,i) ] + | [ r1 = regexp; "|"; r2 = regexp -> Alternative(r1,r2) ] + | [ r1 = regexp; r2 = regexp -> Sequence(r1,r2) ] + | [ r = regexp; "*" -> Repetition r + | r = regexp; "+" -> Sequence(Repetition (remove_as r), r) + | r = regexp; "?" -> Alternative(Epsilon, r) + | "("; r = regexp; ")" -> r + | "_" -> Characters all_chars + | c = CHAR -> Characters (Cset.singleton (char c)) + | s = STRING -> regexp_for_string (Token.eval_string loc s) + | "["; cc = ch_class; "]" -> Characters cc + | x = LIDENT -> + try Hashtbl.find named_regexps x + with Not_found -> + failwith + ("pa_ocamllex (error): reference to unbound regexp name `"^x^"'") + ] + ]; + + ch_class: [ + [ "^"; cc = ch_class -> Cset.complement cc] + | [ c1 = CHAR; "-"; c2 = CHAR -> Cset.interval (char c1) (char c2) + | c = CHAR -> Cset.singleton (char c) + | cc1 = ch_class; cc2 = ch_class -> Cset.union cc1 cc2 + ] + ]; +END + +(* We have to be careful about "rule"; in standalone mode, + it is used as a keyword (otherwise, there is a conflict + with named regexp); in normal mode, it is used as LIDENT + (we do not want to reserve such an useful identifier). + + Plexer does not like identifiers used as keyword _and_ + as LIDENT ... +*) + +let standalone = + let already = ref false in + fun () -> + if not (!already) then + begin + already := true; + Printf.eprintf "pa_ocamllex: stand-alone mode\n"; + + DELETE_RULE Pcaml.str_item: "pa_ocamllex"; LIDENT "rule";lexer_def END; + DELETE_RULE Pcaml.str_item: "pa_ocamllex"; "let"; let_regexp END; + let ocamllex = Grammar.Entry.create Pcaml.gram "pa_ocamllex" in + EXTEND GLOBAL: ocamllex let_regexp header lexer_def; + ocamllex: [ + [ h = header; + l = [LIST0 ["let"; let_regexp]; "rule"; d = lexer_def -> (d,loc)]; + t = header; EOI -> h @ (l :: t) ,false + ] + ]; + END; + Pcaml.parse_implem := Grammar.Entry.parse ocamllex + end + +let () = + Pcaml.add_option "-ocamllex" (Arg.Unit standalone) + "Activate (standalone) ocamllex emulation mode." + diff --git a/camlp4/unmaintained/ocpp/.cvsignore b/camlp4/unmaintained/ocpp/.cvsignore new file mode 100644 index 00000000..baef26c6 --- /dev/null +++ b/camlp4/unmaintained/ocpp/.cvsignore @@ -0,0 +1,3 @@ +*.cm[oia] +ocpp +crc.ml diff --git a/camlp4/unmaintained/ocpp/.depend b/camlp4/unmaintained/ocpp/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/ocpp/Makefile b/camlp4/unmaintained/ocpp/Makefile new file mode 100644 index 00000000..b92fa3c5 --- /dev/null +++ b/camlp4/unmaintained/ocpp/Makefile @@ -0,0 +1,24 @@ + + +include ../config/Makefile.cnf + +EXECUTABLES=ocpp +OBJS=ocpp.cmo +INCLUDES=-I ../camlp4 -I ../lib -I ../odyl -I $(OTOP)/otherlibs/dynlink +OCPPM=../lib/debug.cmo ../lib/loc.cmo ../lib/stdpp.cmo ../camlp4/quotation.cmo + +include ../config/Makefile.base + +ocpp$(EXE): $(OBJS) + $(OCAMLC) $(LINKFLAGS) $(OCPPM) ../odyl/odyl.cma $(OBJS) ../odyl/odyl.cmo -linkall -o $@ + +ocpp.opt: $(OBJSX) + $(OCAMLOPT) $(LINKFLAGS) $(OCPPM:.cmo=.cmx) ../odyl/odyl.cmxa $(OBJSX) ../odyl/odyl.cmx -linkall -o $@ + +install-local: + -$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)" + cp $(OBJS) "$(LIBDIR)/camlp4/." + cp ocpp$(EXE) "$(BINDIR)/." + if test -f ocpp.opt ; then \ + cp ocpp.opt "$(LIBDIR)/camlp4/." ; \ + fi diff --git a/camlp4/unmaintained/ocpp/ocpp.ml b/camlp4/unmaintained/ocpp/ocpp.ml new file mode 100644 index 00000000..eb2ccdf5 --- /dev/null +++ b/camlp4/unmaintained/ocpp/ocpp.ml @@ -0,0 +1,129 @@ +(* camlp4r *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + + +value buff = ref (String.create 80); +value store len x = + do { + if len >= String.length buff.val then + buff.val := buff.val ^ String.create (String.length buff.val) + else (); + buff.val.[len] := x; + succ len + } +; +value get_buff len = String.sub buff.val 0 len; + +value rec copy_strip_locate cs = + match cs with parser + [ [: `'$' :] -> maybe_locate cs + | [: `c :] -> do { print_char c; copy_strip_locate cs } + | [: :] -> () ] +and maybe_locate cs = + match cs with parser + [ [: `'1'..'9' :] -> locate cs + | [: :] -> do { print_char '$'; copy_strip_locate cs } ] +and locate cs = + match cs with parser + [ [: `'0'..'9' :] -> locate cs + | [: `':' :] -> inside_locate cs + | [: :] -> raise (Stream.Error "colon char expected") ] +and inside_locate cs = + match cs with parser + [ [: `'$' :] -> copy_strip_locate cs + | [: `'\\'; `c :] -> do { print_char c; inside_locate cs } + | [: `c :] -> do { print_char c; inside_locate cs } + | [: :] -> raise (Stream.Error "end of file in locate directive") ] +; + +value file = ref ""; + +value quot name loc str = + let loc = Loc.move `stop (String.length str) loc in + let exp = + try + match Quotation.find name with + [ Quotation.ExStr f -> f + | _ -> raise Not_found ] + with + [ Not_found -> Stdpp.raise_with_loc loc Not_found ] + in + let new_str = + try exp True { Quotation.loc = Loc.mk file.val ; loc_name_opt = None } str with + [ Loc.Exc_located loc exc -> Stdpp.raise_with_loc loc exc + | exc -> Stdpp.raise_with_loc loc exc ] + in + let cs = Stream.of_string new_str in copy_strip_locate cs +; + +value rec ident len = + parser + [ [: `('A'..'Z' | 'a'..'z' | '0'..'9' | '_' | ''' as c); s :] -> + ident (store len c) s + | [: :] -> get_buff len ] +; + +value loc_of_ep ep = + Loc.set_all `start 1 0 ep (Loc.mk file.val); + +value rec copy cs = + match cs with parser + [ [: `'<' :] -> maybe_quot cs + | [: `'"' :] -> do { print_char '"'; inside_string cs } + | [: `c :] -> do { print_char c; copy cs } + | [: :] -> () ] +and maybe_quot cs = + match cs with parser + [ [: `'<' :] ep -> inside_quot "" (loc_of_ep ep) 0 cs + | [: `':'; i = ident 0; `'<' ?? "less char expected" :] ep -> + inside_quot i (loc_of_ep ep) 0 cs + | [: :] -> do { print_char '<'; copy cs } ] +and inside_quot name loc len cs = + match cs with parser + [ [: `'>' :] -> maybe_end_quot name loc len cs + | [: `c :] -> inside_quot name loc (store len c) cs + | [: :] -> raise (Stream.Error "end of file in quotation") ] +and maybe_end_quot name loc len cs = + match cs with parser + [ [: `'>' :] -> do { quot name loc (get_buff len); copy cs } + | [: :] -> inside_quot name loc (store len '>') cs ] +and inside_string cs = + match cs with parser + [ [: `'"' :] -> do { print_char '"'; copy cs } + | [: `c :] -> do { print_char c; inside_string cs } + | [: :] -> raise (Stream.Error "end of file in string") ] +; + +value copy_quot cs = do { copy cs; flush stdout; }; + +Arg.parse [] (fun x -> file.val := x) "ocpp "; + +value main () = + try + if file.val <> "" then + copy_quot (Stream.of_channel (open_in_bin file.val)) + else () + with exc -> + do { + Format.printf "@."; + raise + (match exc with + [ Loc.Exc_located loc exc -> + do { Format.eprintf "%a@." Loc.print loc; exc } + | exc -> exc ]) + } +; + +Odyl_main.name.val := "ocpp"; +Odyl_main.go.val := main; diff --git a/camlp4/unmaintained/odyl/.cvsignore b/camlp4/unmaintained/odyl/.cvsignore new file mode 100644 index 00000000..8ae0ebb0 --- /dev/null +++ b/camlp4/unmaintained/odyl/.cvsignore @@ -0,0 +1,4 @@ +*.cm[oia] +odyl +*.lib +odyl_config.ml diff --git a/camlp4/unmaintained/odyl/.depend b/camlp4/unmaintained/odyl/.depend new file mode 100644 index 00000000..a2629440 --- /dev/null +++ b/camlp4/unmaintained/odyl/.depend @@ -0,0 +1,4 @@ +odyl.cmo: odyl_main.cmi odyl_config.cmo +odyl.cmx: odyl_main.cmx odyl_config.cmx +odyl_main.cmo: odyl_config.cmo odyl_main.cmi +odyl_main.cmx: odyl_config.cmx odyl_main.cmi diff --git a/camlp4/unmaintained/odyl/Makefile b/camlp4/unmaintained/odyl/Makefile new file mode 100644 index 00000000..f4f5d870 --- /dev/null +++ b/camlp4/unmaintained/odyl/Makefile @@ -0,0 +1,61 @@ + + +include ../config/Makefile.cnf + +EXECUTABLES=odyl +INCLUDES=-I $(OTOP)/otherlibs/dynlink +OBJS=odyl_config.cmo odyl_main.cmo +OBJSX=odyl.cmx odyl.cmxa +CLEANFILES=odyl_config.ml + +include ../config/Makefile.base + +odyl$(EXE): odyl.cma odyl.cmo + $(OCAMLC) odyl.cma odyl.cmo -o $@ + +odyl.opt: odyl.cmxa odyl.cmx + $(OCAMLOPT) odyl.cmxa odyl.cmx -o $@ + +odyl.cma: $(OBJS) + $(OCAMLC) $(LINKFLAGS) dynlink.cma $(OBJS) -a -o $@ + +odyl.cmxa: $(OBJSX) + $(OCAMLOPT) $(LINKFLAGS) $(OBJSX) -a -o $@ + +odyl.p.cmxa: $(OBJSP) + $(OCAMLOPT) $(LINKFLAGS) $(OBJSP) -a -o $@ + +odyl_main.cmx: odyl_main.ml + $(CAMLP4BOOT) -nolib -DOPT -o odyl_main.ppo odyl_main.ml + $(OCAMLOPT) -c -impl odyl_main.ppo + rm -f odyl_main.ppo + +odyl_main.p.cmx: odyl_main.ml + $(CAMLP4BOOT) -nolib -DOPT -o odyl_main.ppo odyl_main.ml + $(OCAMLOPT) -p -c -o $@ -impl odyl_main.ppo + rm -f odyl_main.ppo + +odyl_config.ml: + (echo '(* camlp4r *)'; \ + echo 'value standard_library ='; \ + echo ' try Sys.getenv "CAMLP4LIB" with [ Not_found -> '; \ + echo ' try Sys.getenv "OCAMLLIB" ^ "/camlp4" with [ Not_found -> '; \ + echo ' try Sys.getenv "CAMLLIB" ^ "/camlp4" with [ Not_found -> '; \ + echo ' "$(LIBDIR)/camlp4"]]];') \ + | sed -e 's|\\|/|g' > odyl_config.ml + +install-local: + -$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)" + cp odyl.cmo odyl.cma odyl_main.cmi $(LIBDIR)/camlp4/. + for f in odyl.$(A) odyl.p.$(A) ; do \ + if test -f $$f ; then \ + cp $$f "$(LIBDIR)/camlp4/." && ( cd "$(LIBDIR)/camlp4/." && $(RANLIB) $$f ) ; \ + fi ; \ + done + for f in odyl.cmx odyl.o odyl.p.cmx odyl.p.o odyl.cmxa odyl.p.cmxa ; do \ + if test -f $$f ; then \ + cp $$f "$(LIBDIR)/camlp4/." ; \ + fi ; \ + done + +include .depend diff --git a/camlp4/unmaintained/odyl/odyl.ml b/camlp4/unmaintained/odyl/odyl.ml new file mode 100644 index 00000000..23b7136c --- /dev/null +++ b/camlp4/unmaintained/odyl/odyl.ml @@ -0,0 +1,57 @@ +(* camlp4r *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2001 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +value apply_load () = + let i = ref 1 in + let stop = ref False in + while not stop.val && i.val < Array.length Sys.argv do { + let s = Sys.argv.(i.val) in + if s = "-I" && i.val + 1 < Array.length Sys.argv then do { + Odyl_main.directory Sys.argv.(i.val + 1); + i.val := i.val + 2 + } + else if s = "-nolib" then do { Odyl_main.nolib.val := True; incr i } + else if s = "-where" then do { + print_string Odyl_config.standard_library; + print_newline (); + flush stdout; + exit 0 + } + else if s = "-version" then do { + print_string Sys.ocaml_version; + print_newline (); + flush stdout; + exit 0 + } + else if s = "--" then do { incr i; stop.val := True; () } + else if String.length s > 0 && s.[0] == '-' then stop.val := True + else if Filename.check_suffix s ".cmo" || Filename.check_suffix s ".cma" + then do { Odyl_main.loadfile s; incr i } + else stop.val := True + } +; + +value main () = + try do { apply_load () ; Odyl_main.go.val () } with + [ Odyl_main.Error fname str -> + do { + flush stdout; + Printf.eprintf "Error while loading \"%s\": " fname; + Printf.eprintf "%s.\n" str; + flush stderr; + exit 2 + } ] +; + +Printexc.catch main (); diff --git a/camlp4/unmaintained/odyl/odyl_main.mli b/camlp4/unmaintained/odyl/odyl_main.mli new file mode 100644 index 00000000..122c9335 --- /dev/null +++ b/camlp4/unmaintained/odyl/odyl_main.mli @@ -0,0 +1,13 @@ +(* camlp4r *) + + +exception Error of string and string; + +value nolib : ref bool; +value initialized : ref bool; +value path : ref (list string); +value loadfile : string -> unit; +value directory : string -> unit; + +value go : ref (unit -> unit); +value name : ref string; diff --git a/camlp4/unmaintained/olabl/.depend b/camlp4/unmaintained/olabl/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/olabl/Makefile b/camlp4/unmaintained/olabl/Makefile new file mode 100644 index 00000000..f928d458 --- /dev/null +++ b/camlp4/unmaintained/olabl/Makefile @@ -0,0 +1,61 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# Makefile for pa_lefteval +# M.Mauny +# + +include ../../config/Makefile.cnf + +OCAMLTOP=../../.. +CAMLP4=../../camlp4/camlp4$(EXE) + +OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) +OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) + +P4INCLUDES= -nolib -I ../../meta -I ../../lib -I ../../etc +OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../lib -I ../../camlp4 +OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES) + +SRC=pa_olabl.ml +OBJS=$(SRC:.ml=.cmo) +OBJSX=$(SRC:.ml=.cmx) + +all: $(OBJS) + +opt: $(OBJSX) + +depend: + cp .depend .depend.bak + > .depend + for file in $(SRC); do \ + $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \ + sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \ + done + +clean: + rm -f *.cm* *.$(O) *.bak .*.bak + + +.SUFFIXES: .cmx .cmo .cmi .ml .mli + +.mli.cmi: + $(OCAMLC) $(OCAMLCFLAGS) -c $< + + +.ml.cmo: + $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +.ml.cmx: + $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +include .depend diff --git a/camlp4/unmaintained/olabl/README b/camlp4/unmaintained/olabl/README new file mode 100644 index 00000000..809d42f2 --- /dev/null +++ b/camlp4/unmaintained/olabl/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + diff --git a/camlp4/unmaintained/olabl/pa_olabl.ml b/camlp4/unmaintained/olabl/pa_olabl.ml new file mode 100644 index 00000000..285902a1 --- /dev/null +++ b/camlp4/unmaintained/olabl/pa_olabl.ml @@ -0,0 +1,2022 @@ +(* pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + + +module Plexer = + struct + open Stdpp; + open Token; + value buff = ref (String.create 80); + value store len x = + do { + if len >= String.length buff.val then + buff.val := buff.val ^ String.create (String.length buff.val) + else (); + buff.val.[len] := x; + succ len + } + ; + value mstore len s = + add_rec len 0 where rec add_rec len i = + if i == String.length s then len + else add_rec (store len s.[i]) (succ i) + ; + value get_buff len = String.sub buff.val 0 len; + value rec ident len = + parser + [ [: `('A'..'Z' | 'a'..'z' | '\192'..'\214' | '\216'..'\246' | + '\248'..'\255' | '0'..'9' | '_' | ''' as + c) + ; + s :] -> + ident (store len c) s + | [: :] -> len ] + and ident2 len = + parser + [ [: `('!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' | + '%' | '.' | ':' | '<' | '>' | '|' as + c) + ; + s :] -> + ident2 (store len c) s + | [: :] -> len ] + and ident3 len = + parser + [ [: `('0'..'9' | 'A'..'Z' | 'a'..'z' | '\192'..'\214' | + '\216'..'\246' | '\248'..'\255' | '_' | '!' | '%' | '&' | '*' | + '+' | '-' | '.' | '/' | ':' | '<' | '=' | '>' | '?' | '@' | '^' | + '|' | '~' | ''' | '$' as + c) + ; + s :] -> + ident3 (store len c) s + | [: :] -> len ] + and ident4 len = + parser + [ [: `('!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' | + '%' | '.' | '<' | '>' | '|' as + c) + ; + s :] -> + ident4 (store len c) s + | [: :] -> len ] + and base_number len = + parser + [ [: `'o' | 'O'; s :] -> octal_digits (store len 'o') s + | [: `'x' | 'X'; s :] -> hexa_digits (store len 'x') s + | [: `'b' | 'B'; s :] -> binary_digits (store len 'b') s + | [: a = number len :] -> a ] + and octal_digits len = + parser + [ [: `('0'..'7' as d); s :] -> octal_digits (store len d) s + | [: :] -> ("INT", get_buff len) ] + and hexa_digits len = + parser + [ [: `('0'..'9' | 'a'..'f' | 'A'..'F' as d); s :] -> + hexa_digits (store len d) s + | [: :] -> ("INT", get_buff len) ] + and binary_digits len = + parser + [ [: `('0'..'1' as d); s :] -> binary_digits (store len d) s + | [: :] -> ("INT", get_buff len) ] + and number len = + parser + [ [: `('0'..'9' as c); s :] -> number (store len c) s + | [: `'.'; s :] -> decimal_part (store len '.') s + | [: `'e' | 'E'; s :] -> exponent_part (store len 'E') s + | [: :] -> ("INT", get_buff len) ] + and decimal_part len = + parser + [ [: `('0'..'9' as c); s :] -> decimal_part (store len c) s + | [: `'e' | 'E'; s :] -> exponent_part (store len 'E') s + | [: :] -> ("FLOAT", get_buff len) ] + and exponent_part len = + parser + [ [: `('+' | '-' as c); s :] -> end_exponent_part (store len c) s + | [: a = end_exponent_part len :] -> a ] + and end_exponent_part len = + parser + [ [: `('0'..'9' as c); s :] -> end_exponent_part (store len c) s + | [: :] -> ("FLOAT", get_buff len) ] + ; + value valch x = Char.code x - Char.code '0'; + value rec backslash s i = + if i = String.length s then raise Not_found + else + match s.[i] with + [ 'n' -> ('\n', i + 1) + | 'r' -> ('\r', i + 1) + | 't' -> ('\t', i + 1) + | 'b' -> ('\b', i + 1) + | '\\' -> ('\\', i + 1) + | '0'..'9' as c -> backslash1 (valch c) s (i + 1) + | _ -> raise Not_found ] + and backslash1 cod s i = + if i = String.length s then (Char.chr cod, i) + else + match s.[i] with + [ '0'..'9' as c -> backslash2 (10 * cod + valch c) s (i + 1) + | _ -> (Char.chr cod, i) ] + and backslash2 cod s i = + if i = String.length s then (Char.chr cod, i) + else + match s.[i] with + [ '0'..'9' as c -> (Char.chr (10 * cod + valch c), i + 1) + | _ -> (Char.chr cod, i) ] + ; + value rec skip_indent s i = + if i = String.length s then i + else + match s.[i] with + [ ' ' | '\t' -> skip_indent s (i + 1) + | _ -> i ] + ; + value skip_opt_linefeed s i = + if i = String.length s then i else if s.[i] = '\010' then i + 1 else i + ; + value char_of_char_token s = + if String.length s = 1 then s.[0] + else if String.length s = 0 then failwith "invalid char token" + else if s.[0] = '\\' then + if String.length s = 2 && s.[1] = ''' then ''' + else + try + let (c, i) = backslash s 1 in + if i = String.length s then c else raise Not_found + with + [ Not_found -> failwith "invalid char token" ] + else failwith "invalid char token" + ; + value string_of_string_token s = + loop 0 0 where rec loop len i = + if i = String.length s then get_buff len + else + let (len, i) = + if s.[i] = '\\' then + let i = i + 1 in + if i = String.length s then failwith "invalid string token" + else if s.[i] = '"' then (store len '"', i + 1) + else + match s.[i] with + [ '\010' -> (len, skip_indent s (i + 1)) + | '\013' -> (len, skip_indent s (skip_opt_linefeed s (i + 1))) + | c -> + try + let (c, i) = backslash s i in + (store len c, i) + with + [ Not_found -> (store (store len '\\') c, i + 1) ] ] + else (store len s.[i], i + 1) + in + loop len i + ; + value rec skip_spaces = + parser + [ [: `' ' | '\n' | '\r' | '\t' | '\026' | '\012'; s :] -> skip_spaces s + | [: :] -> () ] + ; + value error_on_unknown_keywords = ref False; + value next_token_fun find_id_kwd find_spe_kwd fname lnum bolpos = + let make_pos p = + {Lexing.pos_fname = fname.val; Lexing.pos_lnum = lnum.val; + Lexing.pos_bol = bolpos.val; Lexing.pos_cnum = p} in + let mkloc (bp, ep) = (make_pos bp, make_pos ep) in + + let err loc msg = raise_with_loc loc (Token.Error msg) in + let keyword_or_error (bp,ep) s = + try ("", find_spe_kwd s) with + [ Not_found -> + if error_on_unknown_keywords.val then + err (mkloc (bp, ep)) ("illegal token: " ^ s) + else ("", s) ] + in + let rec next_token = + parser bp + [ [: `('A'..'Z' | 'À'..'Ö' | 'Ø'..'Þ' as c); s :] -> + let id = get_buff (ident (store 0 c) s) in + try ("", find_id_kwd id) with [ Not_found -> ("UIDENT", id) ] + | [: `('a'..'z' | 'ß'..'ö' | 'ø'..'ÿ' | '_' as c); s :] -> + let id = get_buff (ident (store 0 c) s) in + let is_label = + match Stream.peek s with + [ Some ':' -> + match Stream.npeek 2 s with + [ [_; ':' | '=' | '>'] -> False + | _ -> True ] + | _ -> False ] + in + if is_label then do { Stream.junk s; ("LABEL", id) } + else try ("", find_id_kwd id) with [ Not_found -> ("LIDENT", id) ] + | [: `('1'..'9' as c); s :] -> number (store 0 c) s + | [: `'0'; s :] -> base_number (store 0 '0') s + | [: `'''; s :] ep -> + match Stream.npeek 2 s with + [ [_; '''] | ['\\'; _] -> ("CHAR", char bp 0 s) + | _ -> keyword_or_error (bp, ep) "'" ] + | [: `'"'; s :] -> ("STRING", string bp 0 s) + | [: `'$'; s :] -> locate_or_antiquot bp 0 s + | [: `('!' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' | + '%' as + c) + ; + s :] -> + let id = get_buff (ident2 (store 0 c) s) in + keyword_or_error (bp, Stream.count s) id + | [: `('?' as c); s :] -> + let id = get_buff (ident4 (store 0 c) s) in + keyword_or_error (bp, Stream.count s) id + | [: `'<'; s :] -> less bp s + | [: `(':' as c1); + (is_label, len) = + parser + [ [: `(']' | ':' | '=' | '>' as c2) :] -> + (False, store (store 0 c1) c2) + | [: `('a'..'z' | 'ß'..'ö' | 'ø'..'ÿ' | '_' as c); s :] -> + (True, ident (store 0 c) s) + | [: :] -> (False, store 0 c1) ] :] ep -> + let id = get_buff len in + if is_label then ("ELABEL", id) else keyword_or_error (bp, ep) id + | [: `('>' | '|' as c1); + len = + parser + [ [: `(']' | '}' as c2) :] -> store (store 0 c1) c2 + | [: a = ident2 (store 0 c1) :] -> a ] :] ep -> + let id = get_buff len in + keyword_or_error (bp, ep) id + | [: `('[' | '{' as c1); s :] -> + let len = + match Stream.npeek 2 s with + [ ['<'; '<' | ':'] -> store 0 c1 + | _ -> + match s with parser + [ [: `('|' | '<' | ':' as c2) :] -> store (store 0 c1) c2 + | [: :] -> store 0 c1 ] ] + in + let ep = Stream.count s in + let id = get_buff len in + keyword_or_error (bp, ep) id + | [: `'.'; id = parser [ [: `'.' :] -> ".." | [: :] -> "." ] :] ep -> + keyword_or_error (bp, ep) id + | [: `';'; id = parser [ [: `';' :] -> ";;" | [: :] -> ";" ] :] ep -> + keyword_or_error (bp, ep) id + | [: `'\\'; s :] -> ("LIDENT", get_buff (ident3 0 s)) + | [: `c :] ep -> keyword_or_error (bp, ep) (String.make 1 c) ] + and less bp = + parser + [ [: `'<'; s :] -> ("QUOTATION", ":" ^ get_buff (quotation bp 0 s)) + | [: `':'; i = parser [: len = ident 0 :] -> get_buff len; + `'<' ? "character '<' expected"; s :] -> + ("QUOTATION", i ^ ":" ^ get_buff (quotation bp 0 s)) + | [: s :] ep -> + let id = get_buff (ident2 (store 0 '<') s) in + keyword_or_error (bp, ep) id ] + and string bp len = + parser + [ [: `'"' :] -> get_buff len + | [: `'\\'; `c; s :] -> string bp (store (store len '\\') c) s + | [: `c; s :] -> string bp (store len c) s + | [: :] ep -> err (mkloc (bp, ep)) "string not terminated" ] + and char bp len = + parser + [ [: `'''; s :] -> + if len = 0 then char bp (store len ''') s else get_buff len + | [: `'\\'; `c; s :] -> char bp (store (store len '\\') c) s + | [: `c; s :] -> char bp (store len c) s + | [: :] ep -> err (mkloc(bp,ep)) "char not terminated" ] + and locate_or_antiquot bp len = + parser + [ [: `'$' :] -> ("ANTIQUOT", ":" ^ get_buff len) + | [: `('a'..'z' | 'A'..'Z' as c); s :] -> antiquot bp (store len c) s + | [: `('0'..'9' as c); s :] -> maybe_locate bp (store len c) s + | [: `':'; s :] -> + let k = get_buff len in + ("ANTIQUOT", k ^ ":" ^ locate_or_antiquot_rest bp 0 s) + | [: `'\\'; `c; s :] -> + ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s) + | [: `c; s :] -> + ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s) + | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ] + and maybe_locate bp len = + parser + [ [: `'$' :] -> ("ANTIQUOT", ":" ^ get_buff len) + | [: `('0'..'9' as c); s :] -> maybe_locate bp (store len c) s + | [: `':'; s :] -> + ("LOCATE", get_buff len ^ ":" ^ locate_or_antiquot_rest bp 0 s) + | [: `'\\'; `c; s :] -> + ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s) + | [: `c; s :] -> + ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s) + | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ] + and antiquot bp len = + parser + [ [: `'$' :] -> ("ANTIQUOT", ":" ^ get_buff len) + | [: `('a'..'z' | 'A'..'Z' | '0'..'9' as c); s :] -> + antiquot bp (store len c) s + | [: `':'; s :] -> + let k = get_buff len in + ("ANTIQUOT", k ^ ":" ^ locate_or_antiquot_rest bp 0 s) + | [: `'\\'; `c; s :] -> + ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s) + | [: `c; s :] -> + ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s) + | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ] + and locate_or_antiquot_rest bp len = + parser + [ [: `'$' :] -> get_buff len + | [: `'\\'; `c; s :] -> locate_or_antiquot_rest bp (store len c) s + | [: `c; s :] -> locate_or_antiquot_rest bp (store len c) s + | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ] + and quotation bp len = + parser + [ [: `'>'; s :] -> maybe_end_quotation bp len s + | [: `'<'; s :] -> + quotation bp (maybe_nested_quotation bp (store len '<') __strm) s + | [: `'\\'; + len = + parser + [ [: `('>' | '<' | '\\' as c) :] -> store len c + | [: :] -> store len '\\' ]; + s :] -> + quotation bp len s + | [: `c; s :] -> quotation bp (store len c) s + | [: :] ep -> err (mkloc(bp,ep)) "quotation not terminated" ] + and maybe_nested_quotation bp len = + parser + [ [: `'<'; s :] -> mstore (quotation bp (store len '<') s) ">>" + | [: `':'; len = ident (store len ':'); + a = + parser + [ [: `'<'; s :] -> mstore (quotation bp (store len '<') s) ">>" + | [: :] -> len ] :] -> + a + | [: :] -> len ] + and maybe_end_quotation bp len = + parser + [ [: `'>' :] -> len + | [: a = quotation bp (store len '>') :] -> a ] + in + let rec next_token_loc = + parser bp + [ [: `' ' | '\n' | '\r' | '\t' | '\026' | '\012'; s :] -> + next_token_loc s + | [: `'('; s :] -> maybe_comment bp s + | [: `'#'; _ = spaces_tabs; a = linenum bp :] -> a + | [: tok = next_token :] ep -> (tok, mkloc(bp, ep)) + | [: _ = Stream.empty :] -> (("EOI", ""), mkloc(bp, succ bp)) ] + and maybe_comment bp = + parser + [ [: `'*'; s :] -> do { comment bp s; next_token_loc s } + | [: :] ep -> + let tok = keyword_or_error (bp, ep) "(" in + (tok, mkloc(bp, ep)) ] + and comment bp = + parser + [ [: `'('; s :] -> maybe_nested_comment bp s + | [: `'*'; s :] -> maybe_end_comment bp s + | [: `c; s :] -> comment bp s + | [: :] ep -> err (mkloc(bp,ep)) "comment not terminated" ] + and maybe_nested_comment bp = + parser + [ [: `'*'; s :] -> do { comment bp s; comment bp s } + | [: a = comment bp :] -> a ] + and maybe_end_comment bp = + parser [ [: `')' :] -> () | [: a = comment bp :] -> a ] + and linenum bp = + parser + [ [: `'0'..'9'; _ = digits; _ = spaces_tabs; `'"'; _ = any_to_nl; + s :] -> + next_token_loc s + | [: :] -> (keyword_or_error (bp, bp + 1) "#", mkloc(bp, bp + 1)) ] + and spaces_tabs = + parser [ [: `' ' | '\t'; s :] -> spaces_tabs s | [: :] -> () ] + and digits = parser [ [: `'0'..'9'; s :] -> digits s | [: :] -> () ] + and any_to_nl = + parser + [ [: `'\r' | '\n' :] -> () + | [: `_; s :] -> any_to_nl s + | [: :] -> () ] + in + fun cstrm -> + try next_token_loc cstrm with + [ Stream.Error str -> + err (mkloc(Stream.count cstrm, Stream.count cstrm + 1)) str ] + ; + value locerr () = invalid_arg "Lexer: location function"; + value loct_create () = ref (Array.create 1024 None); + value loct_func loct i = + match + if i < 0 || i >= Array.length loct.val then None + else Array.unsafe_get loct.val i + with + [ Some loc -> loc + | _ -> locerr () ] + ; + value loct_add loct i loc = + do { + if i >= Array.length loct.val then do { + let new_tmax = Array.length loct.val * 2 in + let new_loct = Array.create new_tmax None in + Array.blit loct.val 0 new_loct 0 (Array.length loct.val); + loct.val := new_loct + } + else (); + loct.val.(i) := Some loc + } + ; + value func kwd_table = + let bolpos = ref 0 in + let lnum = ref 0 in + let fname = ref "" in + let find = Hashtbl.find kwd_table in + let lex cstrm = + let next_token_loc = next_token_fun find find fname lnum bolpos in + let loct = loct_create () in + let ts = + Stream.from + (fun i -> + let (tok, loc) = next_token_loc cstrm in + do { loct_add loct i loc; Some tok }) + in + let locf = loct_func loct in + (ts, locf) + in + lex + ; + value rec check_keyword_stream = + parser [: _ = check; _ = Stream.empty :] -> True + and check = + parser + [ [: `'A'..'Z' | 'a'..'z' | 'À'..'Ö' | 'Ø'..'ö' | 'ø'..'ÿ'; s :] -> + check_ident s + | [: `'!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' | + '%' | '.' + ; + s :] -> + check_ident2 s + | [: `'<'; s :] -> + match Stream.npeek 1 s with + [ [':' | '<'] -> () + | _ -> check_ident2 s ] + | [: `':'; + _ = + parser + [ [: `']' | ':' | '=' | '>' :] -> () + | [: :] -> () ] :] ep -> + () + | [: `'>' | '|'; + _ = + parser + [ [: `']' | '}' :] -> () + | [: a = check_ident2 :] -> a ] :] -> + () + | [: `'[' | '{'; s :] -> + match Stream.npeek 2 s with + [ ['<'; '<' | ':'] -> () + | _ -> + match s with parser + [ [: :] -> + match Stream.peek __strm with + [ Some ('|' | '<' | ':') -> Stream.junk __strm + | _ -> () ] ] ] + | [: `';'; _ = parser [ [: `';' :] -> () | [: :] -> () ] :] -> () + | [: `_ :] -> () ] + and check_ident = + parser + [ [: `'A'..'Z' | 'a'..'z' | 'À'..'Ö' | 'Ø'..'ö' | 'ø'..'ÿ' | '0'..'9' | + '_' | ''' + ; + s :] -> + check_ident s + | [: :] -> () ] + and check_ident2 = + parser + [ [: `'!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' | + '%' | '.' | ':' | '<' | '>' | '|' + ; + s :] -> + check_ident2 s + | [: :] -> () ] + ; + value check_keyword s = + try check_keyword_stream (Stream.of_string s) with _ -> False + ; + value using_token kwd_table (p_con, p_prm) = + match p_con with + [ "" -> + try + let _ = Hashtbl.find kwd_table p_prm in + () + with + [ Not_found -> + if check_keyword p_prm then Hashtbl.add kwd_table p_prm p_prm + else + raise + (Token.Error + ("the token \"" ^ p_prm ^ + "\" does not respect Plexer rules")) ] + | "LIDENT" | "UIDENT" | "INT" | "FLOAT" | "CHAR" | "STRING" | + "QUOTATION" | "ANTIQUOT" | "LOCATE" | "LABEL" | "ELABEL" | "EOI" -> + () + | _ -> + raise + (Token.Error + ("the constructor \"" ^ p_con ^ + "\" is not recognized by Llexer")) ] + ; + value removing_token kwd_table (p_con, p_prm) = + if p_con = "" then Hashtbl.remove kwd_table p_prm else () + ; + value text = + fun + [ ("", t) -> "'" ^ t ^ "'" + | ("LIDENT", "") -> "lowercase identifier" + | ("LIDENT", t) -> "'" ^ t ^ "'" + | ("UIDENT", "") -> "uppercase identifier" + | ("UIDENT", t) -> "'" ^ t ^ "'" + | ("INT", "") -> "integer" + | ("INT", s) -> "'" ^ s ^ "'" + | ("FLOAT", "") -> "float" + | ("STRING", "") -> "string" + | ("CHAR", "") -> "char" + | ("QUOTATION", "") -> "quotation" + | ("ANTIQUOT", k) -> "antiquot \"" ^ k ^ "\"" + | ("LOCATE", "") -> "locate" + | ("LABEL", "") -> "label" + | ("ELABEL", "") -> "elabel" + | ("EOI", "") -> "end of input" + | (con, "") -> con + | (con, prm) -> con ^ " \"" ^ prm ^ "\"" ] + ; + value eq_before_colon p e = + loop 0 where rec loop i = + if i == String.length e then + failwith "Internal error in Plexer: incorrect ANTIQUOT" + else if i == String.length p then e.[i] == ':' + else if p.[i] == e.[i] then loop (i + 1) + else False + ; + value after_colon e = + try + let i = String.index e ':' in + String.sub e (i + 1) (String.length e - i - 1) + with + [ Not_found -> "" ] + ; + value gmake () = + let kwd_table = Hashtbl.create 301 in + {tok_func = func kwd_table; tok_using = using_token kwd_table; + tok_removing = removing_token kwd_table; + tok_match = Token.default_match; tok_text = text; tok_comm = None} + ; + end +; + +open Stdpp; +open Pcaml; + +Pcaml.no_constructors_arity.val := True; + +do { + Grammar.Unsafe.gram_reinit gram (Plexer.gmake ()); + Grammar.Unsafe.clear_entry interf; + Grammar.Unsafe.clear_entry implem; + Grammar.Unsafe.clear_entry top_phrase; + Grammar.Unsafe.clear_entry use_file; + Grammar.Unsafe.clear_entry module_type; + Grammar.Unsafe.clear_entry module_expr; + Grammar.Unsafe.clear_entry sig_item; + Grammar.Unsafe.clear_entry str_item; + Grammar.Unsafe.clear_entry expr; + Grammar.Unsafe.clear_entry patt; + Grammar.Unsafe.clear_entry ctyp; + Grammar.Unsafe.clear_entry let_binding; + Grammar.Unsafe.clear_entry class_type; + Grammar.Unsafe.clear_entry class_expr; + Grammar.Unsafe.clear_entry class_sig_item; + Grammar.Unsafe.clear_entry class_str_item +}; + +Pcaml.parse_interf.val := Grammar.Entry.parse interf; +Pcaml.parse_implem.val := Grammar.Entry.parse implem; + +value o2b = + fun + [ Some _ -> True + | None -> False ] +; + +value mkumin loc f arg = + match arg with + [ <:expr< $int:n$ >> when int_of_string n > 0 -> + let n = "-" ^ n in + <:expr< $int:n$ >> + | <:expr< $flo:n$ >> when float_of_string n > 0.0 -> + let n = "-" ^ n in + <:expr< $flo:n$ >> + | _ -> + let f = "~" ^ f in + <:expr< $lid:f$ $arg$ >> ] +; + +external loc_of_node : 'a -> Loc.t = "%field0"; + +value mklistexp loc last = + loop True where rec loop top = + fun + [ [] -> + match last with + [ Some e -> e + | None -> <:expr< [] >> ] + | [e1 :: el] -> + let loc = if top then loc else (fst (loc_of_node e1), snd loc) in + <:expr< [$e1$ :: $loop False el$] >> ] +; + +value mklistpat loc last = + loop True where rec loop top = + fun + [ [] -> + match last with + [ Some p -> p + | None -> <:patt< [] >> ] + | [p1 :: pl] -> + let loc = if top then loc else (fst (loc_of_node p1), snd loc) in + <:patt< [$p1$ :: $loop False pl$] >> ] +; + +value neg s = string_of_int (- int_of_string s); + +value is_operator = + let ht = Hashtbl.create 73 in + let ct = Hashtbl.create 73 in + do { + List.iter (fun x -> Hashtbl.add ht x True) + ["asr"; "land"; "lor"; "lsl"; "lsr"; "lxor"; "mod"; "or"]; + List.iter (fun x -> Hashtbl.add ct x True) + ['!'; '&'; '*'; '+'; '-'; '/'; ':'; '<'; '='; '>'; '@'; '^'; '|'; '~'; + '?'; '%'; '.']; + fun x -> + try Hashtbl.find ht x with + [ Not_found -> try Hashtbl.find ct x.[0] with _ -> False ] + } +; + +(* +value p_operator strm = + match Stream.peek strm with + [ Some (Token.Tterm "(") -> + match Stream.npeek 3 strm with + [ [_; Token.Tterm x; Token.Tterm ")"] when is_operator x -> + do { Stream.junk strm; Stream.junk strm; Stream.junk strm; x } + | _ -> raise Stream.Failure ] + | _ -> raise Stream.Failure ] +; + +value operator = Grammar.Entry.of_parser gram "operator" p_operator; +*) + +value operator = + Grammar.Entry.of_parser gram "operator" + (parser [: `("", x) when is_operator x :] -> x) +; + +value symbolchar = + let list = + ['!'; '$'; '%'; '&'; '*'; '+'; '-'; '.'; '/'; ':'; '<'; '='; '>'; '?'; + '@'; '^'; '|'; '~'] + in + let rec loop s i = + if i == String.length s then True + else if List.mem s.[i] list then loop s (i + 1) + else False + in + loop +; + +value prefixop = + let list = ['!'; '?'; '~'] in + let excl = ["!="] in + Grammar.Entry.of_parser gram "prefixop" + (parser + [: `("", x) + when + not (List.mem x excl) && String.length x >= 2 && + List.mem x.[0] list && symbolchar x 1 :] -> + x) +; + +value infixop0 = + let list = ['='; '<'; '>'; '|'; '&'; '$'] in + let excl = ["<-"; "||"; "&&"] in + Grammar.Entry.of_parser gram "infixop0" + (parser + [: `("", x) + when + not (List.mem x excl) && String.length x >= 2 && + List.mem x.[0] list && symbolchar x 1 :] -> + x) +; + +value infixop1 = + let list = ['@'; '^'] in + Grammar.Entry.of_parser gram "infixop1" + (parser + [: `("", x) + when + String.length x >= 2 && List.mem x.[0] list && + symbolchar x 1 :] -> + x) +; + +value infixop2 = + let list = ['+'; '-'] in + Grammar.Entry.of_parser gram "infixop2" + (parser + [: `("", x) + when + x <> "->" && String.length x >= 2 && List.mem x.[0] list && + symbolchar x 1 :] -> + x) +; + +value infixop3 = + let list = ['*'; '/'; '%'] in + Grammar.Entry.of_parser gram "infixop3" + (parser + [: `("", x) + when + String.length x >= 2 && List.mem x.[0] list && + symbolchar x 1 :] -> + x) +; + +value infixop4 = + Grammar.Entry.of_parser gram "infixop4" + (parser + [: `("", x) + when + String.length x >= 3 && x.[0] == '*' && x.[1] == '*' && + symbolchar x 2 :] -> + x) +; + +value test_constr_decl = + Grammar.Entry.of_parser gram "test_constr_decl" + (fun strm -> + match Stream.npeek 1 strm with + [ [("UIDENT", _)] -> + match Stream.npeek 2 strm with + [ [_; ("", ".")] -> raise Stream.Failure + | [_; ("", "(")] -> raise Stream.Failure + | [_ :: _] -> () + | _ -> raise Stream.Failure ] + | [("", "|")] -> () + | _ -> raise Stream.Failure ]) +; + +value stream_peek_nth n strm = + loop n (Stream.npeek n strm) where rec loop n = + fun + [ [] -> None + | [x] -> if n == 1 then Some x else None + | [_ :: l] -> loop (n - 1) l ] +; + +value test_label_eq = + let rec test lev strm = + match stream_peek_nth lev strm with + [ Some (("UIDENT", _) | ("LIDENT", _) | ("", ".")) -> test (lev + 1) strm + | Some ("", "=") -> () + | _ -> raise Stream.Failure ] + in + Grammar.Entry.of_parser gram "test_label_eq" (test 1) +; + +value constr_arity = ref [("Some", 1); ("Match_Failure", 1)]; + +value rec constr_expr_arity = + fun + [ <:expr< $uid:c$ >> -> + try List.assoc c constr_arity.val with [ Not_found -> 0 ] + | <:expr< $uid:_$.$e$ >> -> constr_expr_arity e + | _ -> 1 ] +; + +value rec constr_patt_arity = + fun + [ <:patt< $uid:c$ >> -> + try List.assoc c constr_arity.val with [ Not_found -> 0 ] + | <:patt< $uid:_$.$p$ >> -> constr_patt_arity p + | _ -> 1 ] +; + +value rec get_seq = + fun + [ <:expr< do { $list:el$ } >> -> el + | e -> [e] ] +; + +value choose_tvar tpl = + let rec find_alpha v = + let s = String.make 1 v in + if List.mem_assoc s tpl then + if v = 'z' then None else find_alpha (Char.chr (Char.code v + 1)) + else Some (String.make 1 v) + in + let rec make_n n = + let v = "a" ^ string_of_int n in + if List.mem_assoc v tpl then make_n (succ n) else v + in + match find_alpha 'a' with + [ Some x -> x + | None -> make_n 1 ] +; + +value rec patt_lid = + fun + [ <:patt< $lid:i$ $p$ >> -> Some (i, [p]) + | <:patt< $p1$ $p2$ >> -> + match patt_lid p1 with + [ Some (i, pl) -> Some (i, [p2 :: pl]) + | None -> None ] + | _ -> None ] +; + +value type_parameter = Grammar.Entry.create gram "type_parameter"; +value fun_def = Grammar.Entry.create gram "fun_def"; +value fun_binding = Grammar.Entry.create gram "fun_binding"; + +EXTEND + GLOBAL: interf implem top_phrase use_file sig_item str_item ctyp patt expr + module_type module_expr let_binding type_parameter fun_def fun_binding; + (* Main entry points *) + interf: + [ [ st = LIST0 [ s = sig_item; OPT ";;" -> (s, loc) ]; EOI -> + (st, False) ] ] + ; + implem: + [ [ st = LIST0 [ s = str_item; OPT ";;" -> (s, loc) ]; EOI -> + (st, False) ] ] + ; + top_phrase: + [ [ ph = phrase; ";;" -> Some ph + | EOI -> None ] ] + ; + use_file: + [ [ l = LIST0 [ ph = phrase; OPT ";;" -> ph ]; EOI -> (l, False) ] ] + ; + phrase: + [ [ sti = str_item -> sti + | "#"; n = LIDENT; dp = dir_param -> MLast.StDir loc n dp ] ] + ; + dir_param: + [ [ -> None + | e = expr -> Some e ] ] + ; + (* Module expressions *) + module_expr: + [ [ "functor"; "("; i = UIDENT; ":"; t = module_type; ")"; "->"; + me = SELF -> + <:module_expr< functor ( $i$ : $t$ ) -> $me$ >> + | "struct"; st = LIST0 [ s = str_item; OPT ";;" -> s ]; "end" -> + <:module_expr< struct $list:st$ end >> ] + | [ me1 = SELF; me2 = SELF -> <:module_expr< $me1$ $me2$ >> ] + | [ i = mod_expr_ident -> i + | "("; me = SELF; ":"; mt = module_type; ")" -> + <:module_expr< ( $me$ : $mt$ ) >> + | "("; me = SELF; ")" -> <:module_expr< $me$ >> ] ] + ; + mod_expr_ident: + [ LEFTA + [ m1 = SELF; "."; m2 = SELF -> <:module_expr< $m1$ . $m2$ >> ] + | [ m = UIDENT -> <:module_expr< $uid:m$ >> ] ] + ; + str_item: + [ "top" + [ "exception"; (_, c, tl) = constructor_declaration -> + <:str_item< exception $c$ of $list:tl$ >> + | "external"; i = LIDENT; ":"; t = ctyp; "="; pd = LIST1 STRING -> + <:str_item< external $i$ : $t$ = $list:pd$ >> + | "external"; i = LABEL; t = ctyp; "="; pd = LIST1 STRING -> + <:str_item< external $i$ : $t$ = $list:pd$ >> + | "external"; "("; i = operator; ")"; ":"; t = ctyp; "="; + pd = LIST1 STRING -> + <:str_item< external $i$ : $t$ = $list:pd$ >> + | "module"; i = UIDENT; mb = module_binding -> + <:str_item< module $i$ = $mb$ >> + | "module"; "type"; i = UIDENT; "="; mt = module_type -> + <:str_item< module type $i$ = $mt$ >> + | "open"; i = mod_ident -> <:str_item< open $i$ >> + | "type"; tdl = LIST1 type_declaration SEP "and" -> + <:str_item< type $list:tdl$ >> + | "let"; r = OPT "rec"; l = LIST1 let_binding SEP "and"; "in"; + x = expr -> + let e = <:expr< let $opt:o2b r$ $list:l$ in $x$ >> in + <:str_item< $exp:e$ >> + | "let"; r = OPT "rec"; l = LIST1 let_binding SEP "and" -> + match l with + [ [(<:patt< _ >>, e)] -> <:str_item< $exp:e$ >> + | _ -> <:str_item< value $opt:o2b r$ $list:l$ >> ] + | "let"; "module"; m = UIDENT; mb = module_binding; "in"; e = expr -> + <:str_item< let module $m$ = $mb$ in $e$ >> + | e = expr -> <:str_item< $exp:e$ >> ] ] + ; + module_binding: + [ RIGHTA + [ "("; m = UIDENT; ":"; mt = module_type; ")"; mb = SELF -> + <:module_expr< functor ( $m$ : $mt$ ) -> $mb$ >> + | ":"; mt = module_type; "="; me = module_expr -> + <:module_expr< ( $me$ : $mt$ ) >> + | "="; me = module_expr -> <:module_expr< $me$ >> ] ] + ; + (* Module types *) + module_type: + [ [ "functor"; "("; i = UIDENT; ":"; t = SELF; ")"; "->"; mt = SELF -> + <:module_type< functor ( $i$ : $t$ ) -> $mt$ >> ] + | [ mt = SELF; "with"; wcl = LIST1 with_constr SEP "and" -> + <:module_type< $mt$ with $list:wcl$ >> ] + | [ "sig"; sg = LIST0 [ s = sig_item; OPT ";;" -> s ]; "end" -> + <:module_type< sig $list:sg$ end >> + | i = mod_type_ident -> i + | "("; mt = SELF; ")" -> <:module_type< $mt$ >> ] ] + ; + mod_type_ident: + [ LEFTA + [ m1 = SELF; "."; m2 = SELF -> <:module_type< $m1$ . $m2$ >> + | m1 = SELF; "("; m2 = SELF; ")" -> <:module_type< $m1$ $m2$ >> ] + | [ m = UIDENT -> <:module_type< $uid:m$ >> + | m = LIDENT -> <:module_type< $lid:m$ >> ] ] + ; + sig_item: + [ "top" + [ "exception"; (_, c, tl) = constructor_declaration -> + <:sig_item< exception $c$ of $list:tl$ >> + | "external"; i = LIDENT; ":"; t = ctyp; "="; pd = LIST1 STRING -> + <:sig_item< external $i$ : $t$ = $list:pd$ >> + | "external"; i = LABEL; t = ctyp; "="; pd = LIST1 STRING -> + <:sig_item< external $i$ : $t$ = $list:pd$ >> + | "external"; "("; i = operator; ")"; ":"; t = ctyp; "="; + pd = LIST1 STRING -> + <:sig_item< external $i$ : $t$ = $list:pd$ >> + | "include"; mt = module_type -> <:sig_item< include $mt$ >> + | "module"; i = UIDENT; mt = module_declaration -> + <:sig_item< module $i$ : $mt$ >> + | "module"; "type"; i = UIDENT; "="; mt = module_type -> + <:sig_item< module type $i$ = $mt$ >> + | "open"; i = mod_ident -> <:sig_item< open $i$ >> + | "type"; tdl = LIST1 type_declaration SEP "and" -> + <:sig_item< type $list:tdl$ >> + | "val"; i = LIDENT; ":"; t = ctyp -> <:sig_item< value $i$ : $t$ >> + | "val"; i = LABEL; t = ctyp -> <:sig_item< value $i$ : $t$ >> + | "val"; "("; i = operator; ")"; ":"; t = ctyp -> + <:sig_item< value $i$ : $t$ >> ] ] + ; + module_declaration: + [ RIGHTA + [ ":"; mt = module_type -> <:module_type< $mt$ >> + | "("; i = UIDENT; ":"; t = module_type; ")"; mt = SELF -> + <:module_type< functor ( $i$ : $t$ ) -> $mt$ >> ] ] + ; + (* "with" constraints (additional type equations over signature + components) *) + with_constr: + [ [ "type"; tp = type_parameters; i = mod_ident; "="; t = ctyp -> + MLast.WcTyp loc i tp t + | "module"; i = mod_ident; "="; me = module_expr -> + MLast.WcMod loc i me ] ] + ; + (* Core expressions *) + expr: + [ "top" LEFTA + [ e1 = SELF; ";"; e2 = SELF -> + <:expr< do { $list:[e1 :: get_seq e2]$ } >> + | e1 = SELF; ";" -> e1 ] + | "expr1" + [ "let"; o = OPT "rec"; l = LIST1 let_binding SEP "and"; "in"; + x = expr LEVEL "top" -> + <:expr< let $opt:o2b o$ $list:l$ in $x$ >> + | "let"; "module"; m = UIDENT; mb = module_binding; "in"; + e = expr LEVEL "top" -> + <:expr< let module $m$ = $mb$ in $e$ >> + | "function"; OPT "|"; l = LIST1 match_case SEP "|" -> + <:expr< fun [ $list:l$ ] >> + | "fun"; p = patt LEVEL "simple"; e = fun_def -> + <:expr< fun [$p$ -> $e$] >> + | "match"; x = SELF; "with"; OPT "|"; l = LIST1 match_case SEP "|" -> + <:expr< match $x$ with [ $list:l$ ] >> + | "try"; x = SELF; "with"; OPT "|"; l = LIST1 match_case SEP "|" -> + <:expr< try $x$ with [ $list:l$ ] >> + | "if"; e1 = SELF; "then"; e2 = expr LEVEL "expr1"; + e3 = [ "else"; e = expr LEVEL "expr1" -> e | -> <:expr< () >> ] -> + <:expr< if $e1$ then $e2$ else $e3$ >> + | "for"; i = LIDENT; "="; e1 = SELF; df = direction_flag; e2 = SELF; + "do"; e = SELF; "done" -> + <:expr< for $i$ = $e1$ $to:df$ $e2$ do { $list:get_seq e$ } >> + | "while"; e1 = SELF; "do"; e2 = SELF; "done" -> + <:expr< while $e1$ do { $list:get_seq e2$ } >> ] + | [ e = SELF; ","; el = LIST1 NEXT SEP "," -> + <:expr< ( $list:[e :: el]$ ) >> ] + | ":=" NONA + [ e1 = SELF; ":="; e2 = expr LEVEL "expr1" -> + <:expr< $e1$.val := $e2$ >> + | e1 = SELF; "<-"; e2 = expr LEVEL "expr1" -> <:expr< $e1$ := $e2$ >> ] + | "||" RIGHTA + [ e1 = SELF; f = [ op = "or" -> op | op = "||" -> op ]; e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | "&&" RIGHTA + [ e1 = SELF; f = [ op = "&" -> op | op = "&&" -> op ]; e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | "<" LEFTA + [ e1 = SELF; + f = + [ op = "<" -> op + | op = ">" -> op + | op = "<=" -> op + | op = ">=" -> op + | op = "=" -> op + | op = "<>" -> op + | op = "==" -> op + | op = "!=" -> op + | op = infixop0 -> op ]; + e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | "^" RIGHTA + [ e1 = SELF; + f = [ op = "^" -> op | op = "@" -> op | op = infixop1 -> op ]; + e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | RIGHTA + [ e1 = SELF; "::"; e2 = SELF -> <:expr< [$e1$ :: $e2$] >> ] + | "+" LEFTA + [ e1 = SELF; + f = + [ op = "+" -> op + | op = "-" -> op + | op = "+." -> op + | op = "-." -> op + | op = infixop2 -> op ]; + e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | "*" LEFTA + [ e1 = SELF; + f = + [ op = "*" -> op + | op = "/" -> op + | op = "*." -> op + | op = "/." -> op + | op = "land" -> op + | op = "lor" -> op + | op = "lxor" -> op + | op = "mod" -> op + | op = infixop3 -> op ]; + e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | "**" RIGHTA + [ e1 = SELF; + f = + [ op = "**" -> op + | op = "asr" -> op + | op = "lsl" -> op + | op = "lsr" -> op + | op = infixop4 -> op ]; + e2 = SELF -> + <:expr< $lid:f$ $e1$ $e2$ >> ] + | "unary minus" NONA + [ f = [ op = "-" -> op | op = "-." -> op ]; e = SELF -> + <:expr< $mkumin loc f e$ >> ] + | "apply" LEFTA + [ e1 = SELF; e2 = SELF -> + match constr_expr_arity e1 with + [ 1 -> <:expr< $e1$ $e2$ >> + | _ -> + match e2 with + [ <:expr< ( $list:el$ ) >> -> + List.fold_left (fun e1 e2 -> <:expr< $e1$ $e2$ >>) e1 el + | _ -> <:expr< $e1$ $e2$ >> ] ] + | "assert"; e = expr LEVEL "simple" -> + match e with + [ <:expr< False >> -> MLast.ExAsf loc + | _ -> MLast.ExAsr loc e ] + | "lazy"; e = SELF -> + <:expr< lazy ($e$) >> ] + | "simple" LEFTA + [ e1 = SELF; "."; "("; e2 = SELF; ")" -> <:expr< $e1$ .( $e2$ ) >> + | e1 = SELF; "."; "["; e2 = SELF; "]" -> <:expr< $e1$ .[ $e2$ ] >> + | e1 = SELF; "."; e2 = SELF -> <:expr< $e1$ . $e2$ >> + | "!"; e = SELF -> <:expr< $e$ . val>> + | f = + [ op = "~-" -> op + | op = "~-." -> op + | op = "~" -> op + | op = prefixop -> op ]; + e = SELF -> + <:expr< $lid:f$ $e$ >> + | s = INT -> <:expr< $int:s$ >> + | s = FLOAT -> <:expr< $flo:s$ >> + | s = STRING -> <:expr< $str:s$ >> + | c = CHAR -> <:expr< $chr:c$ >> + | i = expr_ident -> i + | s = "false" -> <:expr< False >> + | s = "true" -> <:expr< True >> + | "["; "]" -> <:expr< [] >> + | "["; el = expr1_semi_list; "]" -> <:expr< $mklistexp loc None el$ >> + | "[|"; "|]" -> <:expr< [| |] >> + | "[|"; el = expr1_semi_list; "|]" -> <:expr< [| $list:el$ |] >> + | "{"; test_label_eq; lel = lbl_expr_list; "}" -> + <:expr< { $list:lel$ } >> + | "{"; e = expr LEVEL "simple"; "with"; lel = lbl_expr_list; "}" -> + <:expr< { ($e$) with $list:lel$ } >> + | "("; ")" -> <:expr< () >> + | "("; e = SELF; ":"; t = ctyp; ")" -> <:expr< ($e$ : $t$) >> + | "("; e = SELF; ")" -> <:expr< $e$ >> + | "("; "-"; ")" -> <:expr< $lid:"-"$ >> + | "("; "-."; ")" -> <:expr< $lid:"-."$ >> + | "("; op = operator; ")" -> <:expr< $lid:op$ >> + | "begin"; e = SELF; "end" -> <:expr< $e$ >> + | x = LOCATE -> + let x = + try + let i = String.index x ':' in + ({Lexing.pos_fname = ""; + Lexing.pos_lnum = 0; + Lexing.pos_bol = 0; + Lexing.pos_cnum = int_of_string (String.sub x 0 i)}, + String.sub x (i + 1) (String.length x - i - 1)) + with + [ Not_found | Failure _ -> (Token.nowhere, x) ] + in + Pcaml.handle_expr_locate loc x + | x = QUOTATION -> + let x = + try + let i = String.index x ':' in + (String.sub x 0 i, + String.sub x (i + 1) (String.length x - i - 1)) + with + [ Not_found -> ("", x) ] + in + Pcaml.handle_expr_quotation loc x ] ] + ; + let_binding: + [ [ p = patt; e = fun_binding -> + match patt_lid p with + [ Some (i, pl) -> + let e = + List.fold_left (fun e p -> <:expr< fun $p$ -> $e$ >>) e pl + in + (<:patt< $lid:i$ >>, e) + | None -> (p, e) ] ] ] + ; + fun_binding: + [ RIGHTA + [ p = patt LEVEL "simple"; e = SELF -> <:expr< fun $p$ -> $e$ >> + | "="; e = expr -> <:expr< $e$ >> + | ":"; t = ctyp; "="; e = expr -> <:expr< ($e$ : $t$) >> ] ] + ; + match_case: + [ [ x1 = patt; w = OPT [ "when"; e = expr -> e ]; "->"; x2 = expr -> + (x1, w, x2) ] ] + ; + lbl_expr_list: + [ [ le = lbl_expr; ";"; lel = SELF -> [le :: lel] + | le = lbl_expr; ";" -> [le] + | le = lbl_expr -> [le] ] ] + ; + lbl_expr: + [ [ i = patt_label_ident; "="; e = expr LEVEL "expr1" -> (i, e) ] ] + ; + expr1_semi_list: + [ [ e = expr LEVEL "expr1"; ";"; el = SELF -> [e :: el] + | e = expr LEVEL "expr1"; ";" -> [e] + | e = expr LEVEL "expr1" -> [e] ] ] + ; + fun_def: + [ RIGHTA + [ p = patt LEVEL "simple"; e = SELF -> <:expr< fun $p$ -> $e$ >> + | "->"; e = expr -> <:expr< $e$ >> ] ] + ; + expr_ident: + [ RIGHTA + [ i = LIDENT -> <:expr< $lid:i$ >> + | i = UIDENT -> <:expr< $uid:i$ >> + | m = UIDENT; "."; i = SELF -> + let rec loop m = + fun + [ <:expr< $x$ . $y$ >> -> loop <:expr< $m$ . $x$ >> y + | e -> <:expr< $m$ . $e$ >> ] + in + loop <:expr< $uid:m$ >> i + | m = UIDENT; "."; "("; i = operator; ")" -> + <:expr< $uid:m$ . $lid:i$ >> ] ] + ; + (* Patterns *) + patt: + [ LEFTA + [ p1 = SELF; "as"; i = LIDENT -> <:patt< ($p1$ as $lid:i$) >> ] + | LEFTA + [ p1 = SELF; "|"; p2 = SELF -> <:patt< $p1$ | $p2$ >> ] + | [ p = SELF; ","; pl = LIST1 NEXT SEP "," -> + <:patt< ( $list:[p :: pl]$) >> ] + | NONA + [ p1 = SELF; ".."; p2 = SELF -> <:patt< $p1$ .. $p2$ >> ] + | RIGHTA + [ p1 = SELF; "::"; p2 = SELF -> <:patt< [$p1$ :: $p2$] >> ] + | LEFTA + [ p1 = SELF; p2 = SELF -> + match constr_patt_arity p1 with + [ 1 -> <:patt< $p1$ $p2$ >> + | n -> + let p2 = + match p2 with + [ <:patt< _ >> when n > 1 -> + let pl = + loop n where rec loop n = + if n = 0 then [] else [<:patt< _ >> :: loop (n - 1)] + in + <:patt< ( $list:pl$ ) >> + | _ -> p2 ] + in + match p2 with + [ <:patt< ( $list:pl$ ) >> -> + List.fold_left (fun p1 p2 -> <:patt< $p1$ $p2$ >>) p1 pl + | _ -> <:patt< $p1$ $p2$ >> ] ] ] + | LEFTA + [ p1 = SELF; "."; p2 = SELF -> <:patt< $p1$ . $p2$ >> ] + | "simple" + [ s = LIDENT -> <:patt< $lid:s$ >> + | s = UIDENT -> <:patt< $uid:s$ >> + | s = INT -> <:patt< $int:s$ >> + | "-"; s = INT -> <:patt< $int:neg s$ >> + | s = STRING -> <:patt< $str:s$ >> + | s = CHAR -> <:patt< $chr:s$ >> + | s = "false" -> <:patt< False >> + | s = "true" -> <:patt< True >> + | "["; "]" -> <:patt< [] >> + | "["; pl = patt_semi_list; "]" -> <:patt< $mklistpat loc None pl$ >> + | "[|"; "|]" -> <:patt< [| |] >> + | "[|"; pl = patt_semi_list; "|]" -> <:patt< [| $list:pl$ |] >> + | "{"; lpl = lbl_patt_list; "}" -> <:patt< { $list:lpl$ } >> + | "("; ")" -> <:patt< () >> + | "("; p = SELF; ":"; t = ctyp; ")" -> <:patt< ($p$ : $t$) >> + | "("; p = SELF; ")" -> <:patt< $p$ >> + | "("; "-"; ")" -> <:patt< $lid:"-"$ >> + | "("; op = operator; ")" -> <:patt< $lid:op$ >> + | "_" -> <:patt< _ >> + | x = LOCATE -> + let x = + try + let i = String.index x ':' in + ({Lexing.pos_fname = ""; + Lexing.pos_lnum = 0; + Lexing.pos_bol = 0; + Lexing.pos_cnum = int_of_string (String.sub x 0 i)}, + String.sub x (i + 1) (String.length x - i - 1)) + with + [ Not_found | Failure _ -> (Token.nowhere, x) ] + in + Pcaml.handle_patt_locate loc x + | x = QUOTATION -> + let x = + try + let i = String.index x ':' in + (String.sub x 0 i, + String.sub x (i + 1) (String.length x - i - 1)) + with + [ Not_found -> ("", x) ] + in + Pcaml.handle_patt_quotation loc x ] ] + ; + patt_semi_list: + [ [ p = patt; ";"; pl = SELF -> [p :: pl] + | p = patt; ";" -> [p] + | p = patt -> [p] ] ] + ; + lbl_patt_list: + [ [ le = lbl_patt; ";"; lel = SELF -> [le :: lel] + | le = lbl_patt; ";" -> [le] + | le = lbl_patt -> [le] ] ] + ; + lbl_patt: + [ [ i = patt_label_ident; "="; p = patt -> (i, p) ] ] + ; + patt_label_ident: + [ RIGHTA + [ i = UIDENT -> <:patt< $uid:i$ >> + | i = LIDENT -> <:patt< $lid:i$ >> + | m = UIDENT; "."; i = SELF -> <:patt< $uid:m$ . $i$ >> ] ] + ; + (* Type declaration *) + type_declaration: + [ [ tpl = type_parameters; n = type_patt; "="; tk = type_kind; + cl = LIST0 constrain -> + (n, tpl, tk, cl) + | tpl = type_parameters; n = type_patt; cl = LIST0 constrain -> + (n, tpl, <:ctyp< '$choose_tvar tpl$ >>, cl) ] ] + ; + type_patt: + [ [ n = LIDENT -> (loc, n) ] ] + ; + constrain: + [ [ "constraint"; t1 = ctyp; "="; t2 = ctyp -> (t1, t2) ] ] + ; + type_kind: + [ [ test_constr_decl; OPT "|"; + cdl = LIST1 constructor_declaration SEP "|" -> + <:ctyp< [ $list:cdl$ ] >> + | t = ctyp -> <:ctyp< $t$ >> + | t = ctyp; "="; "{"; ldl = label_declarations; "}" -> + <:ctyp< $t$ == { $list:ldl$ } >> + | t = ctyp; "="; OPT "|"; cdl = LIST1 constructor_declaration SEP "|" -> + <:ctyp< $t$ == [ $list:cdl$ ] >> + | "{"; ldl = label_declarations; "}" -> <:ctyp< { $list:ldl$ } >> ] ] + ; + type_parameters: + [ [ -> (* empty *) [] + | tp = type_parameter -> [tp] + | "("; tpl = LIST1 type_parameter SEP ","; ")" -> tpl ] ] + ; + type_parameter: + [ [ "'"; i = ident -> (i, (False, False)) ] ] + ; + constructor_declaration: + [ [ ci = UIDENT; "of"; cal = LIST1 ctyp LEVEL "ctyp1" SEP "*" -> + (loc, ci, cal) + | ci = UIDENT -> (loc, ci, []) ] ] + ; + label_declarations: + [ [ ld = label_declaration; ";"; ldl = SELF -> [ld :: ldl] + | ld = label_declaration; ";" -> [ld] + | ld = label_declaration -> [ld] ] ] + ; + label_declaration: + [ [ i = LIDENT; ":"; t = ctyp -> (loc, i, False, t) + | i = LABEL; t = ctyp -> (loc, i, False, t) + | "mutable"; i = LIDENT; ":"; t = ctyp -> (loc, i, True, t) + | "mutable"; i = LABEL; t = ctyp -> (loc, i, True, t) ] ] + ; + (* Core types *) + ctyp: + [ [ t1 = SELF; "as"; "'"; i = ident -> <:ctyp< $t1$ as '$i$ >> ] + | "arrow" RIGHTA + [ t1 = SELF; "->"; t2 = SELF -> <:ctyp< $t1$ -> $t2$ >> ] + | [ t = SELF; "*"; tl = LIST1 ctyp LEVEL "ctyp1" SEP "*" -> + <:ctyp< ( $list:[t :: tl]$ ) >> ] + | "ctyp1" + [ t1 = SELF; t2 = SELF -> <:ctyp< $t2$ $t1$ >> ] + | "ctyp2" + [ t1 = SELF; "."; t2 = SELF -> <:ctyp< $t1$ . $t2$ >> + | t1 = SELF; "("; t2 = SELF; ")" -> <:ctyp< $t1$ $t2$ >> ] + | "simple" + [ "'"; i = ident -> <:ctyp< '$i$ >> + | "_" -> <:ctyp< _ >> + | i = LIDENT -> <:ctyp< $lid:i$ >> + | i = UIDENT -> <:ctyp< $uid:i$ >> + | "("; t = SELF; ","; tl = LIST1 ctyp SEP ","; ")"; + i = ctyp LEVEL "ctyp2" -> + List.fold_left (fun c a -> <:ctyp< $c$ $a$ >>) i [t :: tl] + | "("; t = SELF; ")" -> <:ctyp< $t$ >> ] ] + ; + (* Identifiers *) + ident: + [ [ i = LIDENT -> i + | i = UIDENT -> i ] ] + ; + mod_ident: + [ RIGHTA + [ i = UIDENT -> [i] + | i = LIDENT -> [i] + | m = UIDENT; "."; i = SELF -> [m :: i] ] ] + ; + (* Miscellaneous *) + direction_flag: + [ [ "to" -> True + | "downto" -> False ] ] + ; +END; + +(* Objects and Classes *) + +value rec class_type_of_ctyp loc t = + match t with + [ <:ctyp< $lid:i$ >> -> <:class_type< $list:[i]$ >> + | <:ctyp< $uid:m$.$t$ >> -> <:class_type< $list:[m :: type_id_list t]$ >> + | _ -> raise_with_loc loc (Stream.Error "lowercase identifier expected") ] +and type_id_list = + fun + [ <:ctyp< $uid:m$.$t$ >> -> [m :: type_id_list t] + | <:ctyp< $lid:i$ >> -> [i] + | t -> + raise_with_loc (loc_of_node t) + (Stream.Error "lowercase identifier expected") ] +; + +value class_fun_binding = Grammar.Entry.create gram "class_fun_binding"; + +EXTEND + GLOBAL: str_item sig_item expr ctyp class_sig_item class_str_item class_type + class_expr class_fun_binding; + str_item: + [ [ "class"; cd = LIST1 class_declaration SEP "and" -> + <:str_item< class $list:cd$ >> + | "class"; "type"; ctd = LIST1 class_type_declaration SEP "and" -> + <:str_item< class type $list:ctd$ >> ] ] + ; + sig_item: + [ [ "class"; cd = LIST1 class_description SEP "and" -> + <:sig_item< class $list:cd$ >> + | "class"; "type"; ctd = LIST1 class_type_declaration SEP "and" -> + <:sig_item< class type $list:ctd$ >> ] ] + ; + (* Class expressions *) + class_declaration: + [ [ vf = OPT "virtual"; ctp = class_type_parameters; i = LIDENT; + cfb = class_fun_binding -> + {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp; + MLast.ciNam = i; MLast.ciExp = cfb} ] ] + ; + class_fun_binding: + [ [ "="; ce = class_expr -> ce + | ":"; ct = class_type; "="; ce = class_expr -> + <:class_expr< ($ce$ : $ct$) >> + | p = patt LEVEL "simple"; cfb = SELF -> + <:class_expr< fun $p$ -> $cfb$ >> ] ] + ; + class_type_parameters: + [ [ -> (loc, []) + | "["; tpl = LIST1 type_parameter SEP ","; "]" -> (loc, tpl) ] ] + ; + class_fun_def: + [ [ p = patt LEVEL "simple"; "->"; ce = class_expr -> + <:class_expr< fun $p$ -> $ce$ >> + | p = patt LEVEL "simple"; cfd = SELF -> + <:class_expr< fun $p$ -> $cfd$ >> ] ] + ; + class_expr: + [ "top" + [ "fun"; cfd = class_fun_def -> cfd + | "let"; rf = OPT "rec"; lb = LIST1 let_binding SEP "and"; "in"; + ce = SELF -> + <:class_expr< let $opt:o2b rf$ $list:lb$ in $ce$ >> ] + | "apply" NONA + [ ce = SELF; e = expr LEVEL "label" -> + <:class_expr< $ce$ $e$ >> ] + | "simple" + [ "["; ct = ctyp; ","; ctcl = LIST1 ctyp SEP ","; "]"; + ci = class_longident -> + <:class_expr< $list:ci$ [ $list:[ct :: ctcl]$ ] >> + | "["; ct = ctyp; "]"; ci = class_longident -> + <:class_expr< $list:ci$ [ $ct$ ] >> + | ci = class_longident -> <:class_expr< $list:ci$ >> + | "object"; cspo = OPT class_self_patt; cf = class_structure; "end" -> + <:class_expr< object $opt:cspo$ $list:cf$ end >> + | "("; ce = SELF; ":"; ct = class_type; ")" -> + <:class_expr< ($ce$ : $ct$) >> + | "("; ce = SELF; ")" -> ce ] ] + ; + class_structure: + [ [ cf = LIST0 class_str_item -> cf ] ] + ; + class_self_patt: + [ [ "("; p = patt; ")" -> p + | "("; p = patt; ":"; t = ctyp; ")" -> <:patt< ($p$ : $t$) >> ] ] + ; + class_str_item: + [ [ "inherit"; ce = class_expr; pb = OPT [ "as"; i = LIDENT -> i ] -> + <:class_str_item< inherit $ce$ $opt:pb$ >> + | "val"; (lab, mf, e) = cvalue -> + <:class_str_item< value $opt:mf$ $lab$ = $e$ >> + | "method"; "private"; "virtual"; l = label; ":"; t = ctyp -> + <:class_str_item< method virtual private $l$ : $t$ >> + | "method"; "virtual"; "private"; l = label; ":"; t = ctyp -> + <:class_str_item< method virtual private $l$ : $t$ >> + | "method"; "virtual"; l = label; ":"; t = ctyp -> + <:class_str_item< method virtual $l$ : $t$ >> + | "method"; "private"; l = label; fb = fun_binding -> + <:class_str_item< method private $l$ = $fb$ >> + | "method"; l = label; fb = fun_binding -> + <:class_str_item< method $l$ = $fb$ >> + | "constraint"; t1 = ctyp; "="; t2 = ctyp -> + <:class_str_item< type $t1$ = $t2$ >> + | "initializer"; se = expr -> <:class_str_item< initializer $se$ >> ] ] + ; + cvalue: + [ [ mf = OPT "mutable"; l = label; "="; e = expr -> (l, o2b mf, e) + | mf = OPT "mutable"; l = label; ":"; t = ctyp; "="; e = expr -> + (l, o2b mf, <:expr< ($e$ : $t$) >>) + | mf = OPT "mutable"; l = label; ":"; t1 = ctyp; ":>"; t2 = ctyp; "="; + e = expr -> + (l, o2b mf, <:expr< ($e$ : $t1$ :> $t2$) >>) + | mf = OPT "mutable"; l = label; ":>"; t = ctyp; "="; e = expr -> + (l, o2b mf, <:expr< ($e$ :> $t$) >>) ] ] + ; + label: + [ [ i = LIDENT -> i ] ] + ; + (* Class types *) + class_type: + [ [ t = ctyp LEVEL "ctyp1" -> class_type_of_ctyp loc t + | t = ctyp LEVEL "ctyp1"; "->"; ct = SELF -> + <:class_type< [ $t$ ] -> $ct$ >> + | t = ctyp LEVEL "ctyp1"; "*"; tl = LIST1 ctyp LEVEL "simple" SEP "*"; + "->"; ct = SELF -> + <:class_type< [ ($t$ * $list:tl$) ] -> $ct$ >> + | cs = class_signature -> cs ] ] + ; + class_signature: + [ [ "["; tl = LIST1 ctyp SEP ","; "]"; id = clty_longident -> + <:class_type< $list:id$ [ $list:tl$ ] >> + | id = clty_longident -> <:class_type< $list:id$ >> + | "object"; cst = OPT class_self_type; csf = LIST0 class_sig_item; + "end" -> + <:class_type< object $opt:cst$ $list:csf$ end >> ] ] + ; + class_self_type: + [ [ "("; t = ctyp; ")" -> t ] ] + ; + class_sig_item: + [ [ "inherit"; cs = class_signature -> <:class_sig_item< inherit $cs$ >> + | "val"; mf = OPT "mutable"; l = label; ":"; t = ctyp -> + <:class_sig_item< value $opt:o2b mf$ $l$ : $t$ >> + | "method"; "private"; "virtual"; l = label; ":"; t = ctyp -> + <:class_sig_item< method virtual private $l$ : $t$ >> + | "method"; "virtual"; "private"; l = label; ":"; t = ctyp -> + <:class_sig_item< method virtual private $l$ : $t$ >> + | "method"; "virtual"; l = label; ":"; t = ctyp -> + <:class_sig_item< method virtual $l$ : $t$ >> + | "method"; "private"; l = label; ":"; t = ctyp -> + <:class_sig_item< method private $l$ : $t$ >> + | "method"; l = label; ":"; t = ctyp -> + <:class_sig_item< method $l$ : $t$ >> + | "constraint"; t1 = ctyp; "="; t2 = ctyp -> + <:class_sig_item< type $t1$ = $t2$ >> ] ] + ; + class_description: + [ [ vf = OPT "virtual"; ctp = class_type_parameters; n = LIDENT; ":"; + ct = class_type -> + {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp; + MLast.ciNam = n; MLast.ciExp = ct} + | vf = OPT "virtual"; ctp = class_type_parameters; n = LABEL; + ct = class_type -> + {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp; + MLast.ciNam = n; MLast.ciExp = ct} ] ] + ; + class_type_declaration: + [ [ vf = OPT "virtual"; ctp = class_type_parameters; n = LIDENT; "="; + cs = class_signature -> + {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp; + MLast.ciNam = n; MLast.ciExp = cs} ] ] + ; + (* Expressions *) + expr: LEVEL "apply" + [ LEFTA + [ "new"; i = class_longident -> <:expr< new $list:i$ >> ] ] + ; + expr: LEVEL "simple" + [ [ e = SELF; "#"; lab = label -> <:expr< $e$ # $lab$ >> ] ] + ; + expr: LEVEL "simple" + [ [ "("; e = SELF; ":"; t1 = ctyp; ":>"; t2 = ctyp; ")" -> + <:expr< ($e$ : $t1$ :> $t2$) >> + | "("; e = SELF; ":>"; t = ctyp; ")" -> <:expr< ($e$ :> $t$) >> + | "{<"; ">}" -> <:expr< {< >} >> + | "{<"; fel = field_expr_list; ">}" -> <:expr< {< $list:fel$ >} >> ] ] + ; + field_expr_list: + [ [ l = label; "="; e = expr LEVEL "expr1"; ";"; fel = SELF -> + [(l, e) :: fel] + | l = label; "="; e = expr LEVEL "expr1"; ";" -> [(l, e)] + | l = label; "="; e = expr LEVEL "expr1" -> [(l, e)] ] ] + ; + (* Core types *) + ctyp: LEVEL "simple" + [ [ "#"; id = class_longident -> <:ctyp< # $list:id$ >> + | "<"; (ml, v) = meth_list; ">" -> <:ctyp< < $list:ml$ $opt:v$ > >> + | "<"; ">" -> <:ctyp< < > >> ] ] + ; + meth_list: + [ [ f = field; ";"; (ml, v) = SELF -> ([f :: ml], v) + | f = field; ";" -> ([f], False) + | f = field -> ([f], False) + | ".." -> ([], True) ] ] + ; + field: + [ [ lab = LIDENT; ":"; t = ctyp -> (lab, t) + | lab = LABEL; t = ctyp -> (lab, t) ] ] + ; + (* Identifiers *) + clty_longident: + [ [ m = UIDENT; "."; l = SELF -> [m :: l] + | i = LIDENT -> [i] ] ] + ; + class_longident: + [ [ m = UIDENT; "."; l = SELF -> [m :: l] + | i = LIDENT -> [i] ] ] + ; +END; + +(* Labels *) + +EXTEND + GLOBAL: ctyp expr patt fun_def fun_binding class_type class_fun_binding; + ctyp: AFTER "arrow" + [ NONA + [ i = LABEL; t = SELF -> <:ctyp< ~ $i$ : $t$ >> + | "?"; i = LABEL; t = SELF -> <:ctyp< ? $i$ : $t$ >> ] ] + ; + ctyp: LEVEL "simple" + [ [ "["; OPT "|"; rfl = LIST0 row_field SEP "|"; "]" -> + <:ctyp< [ = $list:rfl$ ] >> + | "["; ">"; OPT "|"; rfl = LIST1 row_field SEP "|"; "]" -> + <:ctyp< [ > $list:rfl$ ] >> + | "[<"; OPT "|"; rfl = LIST1 row_field SEP "|"; "]" -> + <:ctyp< [ < $list:rfl$ ] >> + | "[<"; OPT "|"; rfl = LIST1 row_field SEP "|"; ">"; + ntl = LIST1 name_tag; "]" -> + <:ctyp< [ < $list:rfl$ > $list:ntl$ ] >> ] ] + ; + row_field: + [ [ "`"; i = ident -> MLast.RfTag i False [] + | "`"; i = ident; "of"; ao = OPT "&"; l = LIST1 ctyp SEP "&" -> + MLast.RfTag i (o2b ao) l + | "`"; i = ident; "&"; l = LIST1 ctyp SEP "&" -> MLast.RfTag i True l + | "`"; i = ident; l = LIST1 ctyp SEP "&" -> MLast.RfTag i False l ] ] + ; + name_tag: + [ [ "`"; i = ident -> i ] ] + ; + expr: LEVEL "expr1" + [ [ "fun"; p = labeled_patt; e = fun_def -> <:expr< fun $p$ -> $e$ >> ] ] + ; + expr: AFTER "apply" + [ "label" + [ i = LABEL; e = SELF -> <:expr< ~ $i$ : $e$ >> + | i = ELABEL -> <:expr< ~ $i$ >> + | "?"; i = LABEL; e = SELF -> <:expr< ? $i$ : $e$ >> + | "?"; i = ELABEL -> <:expr< ? $i$ >> ] ] + ; + expr: LEVEL "simple" + [ [ "`"; s = ident -> <:expr< ` $s$ >> ] ] + ; + fun_def: + [ [ p = labeled_patt; e = SELF -> <:expr< fun $p$ -> $e$ >> ] ] + ; + fun_binding: + [ [ p = labeled_patt; e = SELF -> <:expr< fun $p$ -> $e$ >> ] ] + ; + patt: LEVEL "simple" + [ [ "`"; s = ident -> <:patt< ` $s$ >> ] ] + ; + labeled_patt: + [ [ i = LABEL; p = patt LEVEL "simple" -> <:patt< ~ $i$ : $p$ >> + | i = ELABEL -> <:patt< ~ $i$ >> + | "?"; i = LABEL; j = LIDENT -> <:patt< ? $i$ : ($lid:j$) >> + | "?"; "("; i = LABEL; j = LIDENT; ")" -> <:patt< ? $i$ : ($lid:j$) >> + | "?"; "("; i = LABEL; j = LIDENT; "="; e = expr; ")" -> + <:patt< ? $i$ : ( $lid:j$ = $e$ ) >> + | "?"; i = ELABEL -> <:patt< ? $i$ : ($lid:i$) >> + | "?"; "("; i = ELABEL; "="; e = expr; ")" -> + <:patt< ? $i$ : ( $lid:i$ = $e$ ) >> ] ] + ; + class_type: + [ [ i = LABEL; t = ctyp LEVEL "ctyp1"; "->"; ct = SELF -> + <:class_type< [ ~ $i$ : $t$ ] -> $ct$ >> + | "?"; i = LABEL; t = ctyp LEVEL "ctyp1"; "->"; ct = SELF -> + <:class_type< [ ? $i$ : $t$ ] -> $ct$ >> ] ] + ; + class_fun_binding: + [ [ p = labeled_patt; cfb = SELF -> <:class_expr< fun $p$ -> $cfb$ >> ] ] + ; + ident: + [ [ i = LIDENT -> i + | i = UIDENT -> i ] ] + ; +END; + +type spat_comp = + [ SpTrm of Loc.t and MLast.patt and option MLast.expr + | SpNtr of Loc.t and MLast.patt and MLast.expr + | SpStr of Loc.t and MLast.patt ] +; +type sexp_comp = + [ SeTrm of Loc.t and MLast.expr | SeNtr of Loc.t and MLast.expr ] +; + +value strm_n = "__strm"; +value peek_fun loc = <:expr< Stream.peek >>; +value junk_fun loc = <:expr< Stream.junk >>; + +(* Parsers. *) +(* In syntax generated, many cases are optimisations. *) + +value rec pattern_eq_expression p e = + match (p, e) with + [ (<:patt< $lid:a$ >>, <:expr< $lid:b$ >>) -> a = b + | (<:patt< $uid:a$ >>, <:expr< $uid:b$ >>) -> a = b + | (<:patt< $p1$ $p2$ >>, <:expr< $e1$ $e2$ >>) -> + pattern_eq_expression p1 e1 && pattern_eq_expression p2 e2 + | _ -> False ] +; + +value is_raise e = + match e with + [ <:expr< raise $_$ >> -> True + | _ -> False ] +; + +value is_raise_failure e = + match e with + [ <:expr< raise Stream.Failure >> -> True + | _ -> False ] +; + +value rec handle_failure e = + match e with + [ <:expr< try $te$ with [ Stream.Failure -> $e$] >> -> handle_failure e + | <:expr< match $me$ with [ $list:pel$ ] >> -> + handle_failure me && + List.for_all + (fun + [ (_, None, e) -> handle_failure e + | _ -> False ]) + pel + | <:expr< let $list:pel$ in $e$ >> -> + List.for_all (fun (p, e) -> handle_failure e) pel && handle_failure e + | <:expr< $lid:_$ >> | <:expr< $int:_$ >> | <:expr< $str:_$ >> | + <:expr< $chr:_$ >> | <:expr< fun [ $list:_$ ] >> | <:expr< $uid:_$ >> -> + True + | <:expr< raise $e$ >> -> + match e with + [ <:expr< Stream.Failure >> -> False + | _ -> True ] + | <:expr< $f$ $x$ >> -> + is_constr_apply f && handle_failure f && handle_failure x + | _ -> False ] +and is_constr_apply = + fun + [ <:expr< $uid:_$ >> -> True + | <:expr< $lid:_$ >> -> False + | <:expr< $x$ $_$ >> -> is_constr_apply x + | _ -> False ] +; + +value rec subst v e = + let loc = MLast.loc_of_expr e in + match e with + [ <:expr< $lid:x$ >> -> + let x = if x = v then strm_n else x in + <:expr< $lid:x$ >> + | <:expr< $uid:_$ >> -> e + | <:expr< $int:_$ >> -> e + | <:expr< $chr:_$ >> -> e + | <:expr< $str:_$ >> -> e + | <:expr< $_$ . $_$ >> -> e + | <:expr< let $opt:rf$ $list:pel$ in $e$ >> -> + <:expr< let $opt:rf$ $list:List.map (subst_pe v) pel$ in $subst v e$ >> + | <:expr< $e1$ $e2$ >> -> <:expr< $subst v e1$ $subst v e2$ >> + | <:expr< ( $list:el$ ) >> -> <:expr< ( $list:List.map (subst v) el$ ) >> + | _ -> raise Not_found ] +and subst_pe v (p, e) = + match p with + [ <:patt< $lid:v'$ >> -> if v = v' then (p, e) else (p, subst v e) + | _ -> raise Not_found ] +; + +value stream_pattern_component skont ckont = + fun + [ SpTrm loc p wo -> + <:expr< match $peek_fun loc$ $lid:strm_n$ with + [ Some $p$ $when:wo$ -> + do { $junk_fun loc$ $lid:strm_n$; $skont$ } + | _ -> $ckont$ ] >> + | SpNtr loc p e -> + let e = + match e with + [ <:expr< fun [ ($lid:v$ : Stream.t _) -> $e$ ] >> when v = strm_n -> + e + | _ -> <:expr< $e$ $lid:strm_n$ >> ] + in + if pattern_eq_expression p skont then + if is_raise_failure ckont then e + else if handle_failure e then e + else <:expr< try $e$ with [ Stream.Failure -> $ckont$ ] >> + else if is_raise_failure ckont then <:expr< let $p$ = $e$ in $skont$ >> + else if pattern_eq_expression <:patt< Some $p$ >> skont then + <:expr< try Some $e$ with [ Stream.Failure -> $ckont$ ] >> + else if is_raise ckont then + let tst = + if handle_failure e then e + else <:expr< try $e$ with [ Stream.Failure -> $ckont$ ] >> + in + <:expr< let $p$ = $tst$ in $skont$ >> + else + <:expr< match try Some $e$ with [ Stream.Failure -> None ] with + [ Some $p$ -> $skont$ + | _ -> $ckont$ ] >> + | SpStr loc p -> + try + match p with + [ <:patt< $lid:v$ >> -> subst v skont + | _ -> raise Not_found ] + with + [ Not_found -> <:expr< let $p$ = $lid:strm_n$ in $skont$ >> ] ] +; + +value rec stream_pattern loc epo e ekont = + fun + [ [] -> + match epo with + [ Some ep -> <:expr< let $ep$ = Stream.count $lid:strm_n$ in $e$ >> + | _ -> e ] + | [(spc, err) :: spcl] -> + let skont = + let ekont err = + let str = + match err with + [ Some estr -> estr + | _ -> <:expr< "" >> ] + in + <:expr< raise (Stream.Error $str$) >> + in + stream_pattern loc epo e ekont spcl + in + let ckont = ekont err in + stream_pattern_component skont ckont spc ] +; + +value stream_patterns_term loc ekont tspel = + let pel = + List.map + (fun (p, w, loc, spcl, epo, e) -> + let p = <:patt< Some $p$ >> in + let e = + let ekont err = + let str = + match err with + [ Some estr -> estr + | _ -> <:expr< "" >> ] + in + <:expr< raise (Stream.Error $str$) >> + in + let skont = stream_pattern loc epo e ekont spcl in + <:expr< do { $junk_fun loc$ $lid:strm_n$; $skont$ } >> + in + (p, w, e)) + tspel + in + let pel = pel @ [(<:patt< _ >>, None, ekont ())] in + <:expr< match $peek_fun loc$ $lid:strm_n$ with [ $list:pel$ ] >> +; + +value rec group_terms = + fun + [ [([(SpTrm loc p w, None) :: spcl], epo, e) :: spel] -> + let (tspel, spel) = group_terms spel in + ([(p, w, loc, spcl, epo, e) :: tspel], spel) + | spel -> ([], spel) ] +; + +value rec parser_cases loc = + fun + [ [] -> <:expr< raise Stream.Failure >> + | spel -> + match group_terms spel with + [ ([], [(spcl, epo, e) :: spel]) -> + stream_pattern loc epo e (fun _ -> parser_cases loc spel) spcl + | (tspel, spel) -> + stream_patterns_term loc (fun _ -> parser_cases loc spel) tspel ] ] +; + +value cparser loc bpo pc = + let e = parser_cases loc pc in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $e$ >> + | None -> e ] + in + let p = <:patt< ($lid:strm_n$ : Stream.t _) >> in + <:expr< fun $p$ -> $e$ >> +; + +value cparser_match loc me bpo pc = + let pc = parser_cases loc pc in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >> + | None -> pc ] + in + <:expr< let $lid:strm_n$ = $me$ in $e$ >> +; + +(* streams *) + +value rec not_computing = + fun + [ <:expr< $lid:_$ >> | <:expr< $uid:_$ >> | <:expr< $int:_$ >> | + <:expr< $flo:_$ >> | <:expr< $chr:_$ >> | <:expr< $str:_$ >> -> + True + | <:expr< $x$ $y$ >> -> is_cons_apply_not_computing x && not_computing y + | _ -> False ] +and is_cons_apply_not_computing = + fun + [ <:expr< $uid:_$ >> -> True + | <:expr< $lid:_$ >> -> False + | <:expr< $x$ $y$ >> -> is_cons_apply_not_computing x && not_computing y + | _ -> False ] +; + +value slazy loc e = + match e with + [ <:expr< $f$ () >> -> + match f with + [ <:expr< $lid:_$ >> -> f + | _ -> <:expr< fun _ -> $e$ >> ] + | _ -> <:expr< fun _ -> $e$ >> ] +; + +value rec cstream gloc = + fun + [ [] -> + let loc = gloc in + <:expr< Stream.sempty >> + | [SeTrm loc e] -> + if not_computing e then <:expr< Stream.ising $e$ >> + else <:expr< Stream.lsing $slazy loc e$ >> + | [SeTrm loc e :: secl] -> + if not_computing e then <:expr< Stream.icons $e$ $cstream gloc secl$ >> + else <:expr< Stream.lcons $slazy loc e$ $cstream gloc secl$ >> + | [SeNtr loc e] -> + if not_computing e then e else <:expr< Stream.slazy $slazy loc e$ >> + | [SeNtr loc e :: secl] -> + if not_computing e then <:expr< Stream.iapp $e$ $cstream gloc secl$ >> + else <:expr< Stream.lapp $slazy loc e$ $cstream gloc secl$ >> ] +; + +(* Syntax extensions in Ocaml grammar *) + +EXTEND + GLOBAL: expr; + expr: LEVEL "expr1" + [ [ "parser"; po = OPT ipatt; OPT "|"; pcl = LIST1 parser_case SEP "|" -> + <:expr< $cparser loc po pcl$ >> + | "match"; e = SELF; "with"; "parser"; po = OPT ipatt; OPT "|"; + pcl = LIST1 parser_case SEP "|" -> + <:expr< $cparser_match loc e po pcl$ >> ] ] + ; + parser_case: + [ [ "[<"; sp = stream_patt; ">]"; po = OPT ipatt; "->"; e = expr -> + (sp, po, e) ] ] + ; + stream_patt: + [ [ spc = stream_patt_comp -> [(spc, None)] + | spc = stream_patt_comp; ";" -> [(spc, None)] + | spc = stream_patt_comp; ";"; sp = stream_patt_comp_err_list -> + [(spc, None) :: sp] + | -> (* empty *) [] ] ] + ; + stream_patt_comp_err_list: + [ [ spc = stream_patt_comp_err -> [spc] + | spc = stream_patt_comp_err; ";" -> [spc] + | spc = stream_patt_comp_err; ";"; sp = SELF -> [spc :: sp] ] ] + ; + stream_patt_comp: + [ [ "'"; p = patt; eo = OPT [ "when"; e = expr LEVEL "expr1" -> e ] -> + SpTrm loc p eo + | p = patt; "="; e = expr LEVEL "expr1" -> SpNtr loc p e + | p = patt -> SpStr loc p ] ] + ; + stream_patt_comp_err: + [ [ spc = stream_patt_comp; + eo = OPT [ "?"; e = expr LEVEL "expr1" -> e ] -> + (spc, eo) ] ] + ; + ipatt: + [ [ i = LIDENT -> <:patt< $lid:i$ >> ] ] + ; + expr: LEVEL "simple" + [ [ "[<"; ">]" -> <:expr< $cstream loc []$ >> + | "[<"; sel = stream_expr_comp_list; ">]" -> + <:expr< $cstream loc sel$ >> ] ] + ; + stream_expr_comp_list: + [ [ se = stream_expr_comp; ";"; sel = SELF -> [se :: sel] + | se = stream_expr_comp; ";" -> [se] + | se = stream_expr_comp -> [se] ] ] + ; + stream_expr_comp: + [ [ "'"; e = expr LEVEL "expr1" -> SeTrm loc e + | e = expr LEVEL "expr1" -> SeNtr loc e ] ] + ; +END; diff --git a/camlp4/unmaintained/scheme/.depend b/camlp4/unmaintained/scheme/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/scheme/Makefile b/camlp4/unmaintained/scheme/Makefile new file mode 100644 index 00000000..01036c22 --- /dev/null +++ b/camlp4/unmaintained/scheme/Makefile @@ -0,0 +1,85 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# Makefile for pa_lefteval +# M.Mauny +# + +include ../../config/Makefile.cnf + +OCAMLTOP=../../.. +CAMLP4=../../camlp4/camlp4$(EXE) + +OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) +OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) + +P4INCLUDES= -nolib -I ../../meta -I ../../etc +OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../camlp4 -I ../../lib -I ../../etc +OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES) + +SCHSRC=pa_scheme.sc +SRC=pa_scheme.ml pr_scheme.ml pr_schp_main.ml +OBJS=$(SRC:.ml=.cmo) +OBJSX=$(OCAMLSRC:.ml=.cmx) + +all: $(OBJS) pr_schemep.cmo camlp4sch$(EXE) + +opt: all + +bootstrap: camlp4sch$(EXE) save + ./camlp4sch$(EXE) ../../etc/q_phony.cmo ../../meta/pa_extend.cmo ../../etc/pr_r.cmo ../../etc/pr_extend.cmo ../../etc/pr_rp.cmo -impl pa_scheme.sc \ + | sed -e 's/^;; \(.*\)$$/(* \1 *)/' -e 's/^; \(.*\)$$/(* \1 *)/' \ + -e 's/$$Id.*\$$/File generated by pretty print; do not edit!/' > pa_scheme.ml + @if cmp -s pa_scheme.ml SAVED/pa_scheme.ml; then \ + echo 'pa_scheme.ml and SAVED/pa_scheme.ml are identical' ; \ + else \ + echo '**** Note: pa_scheme.ml differs from SAVED/pa_scheme.ml'; \ + fi + +save: + test -d SAVED || mkdir SAVED + mkdir SAVED.$$$$ && mv SAVED pa_scheme.ml SAVED.$$$$ && mv SAVED.$$$$ SAVED + +restore: + mv SAVED SAVED.$$$$ && mv SAVED.$$$$/* . && rmdir SAVED.$$$$ + +depend: + cp .depend .depend.bak + > .depend + for file in $(SRC); do \ + $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \ + sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \ + done + +clean: + rm -f camlp4sch$(EXE) *.cm* *.$(O) *.bak .*.bak + +camlp4sch: pa_scheme.cmo + rm -f camlp4sch + DIR=`pwd` && cd ../../camlp4 && $(MAKE) CAMLP4=$$DIR/camlp4sch CAMLP4M="-I $$DIR pa_scheme.cmo ../meta/pr_dump.cmo" + +pr_schemep.cmo: pr_schp_main.cmo + $(OCAMLC) ../../etc/parserify.cmo pr_schp_main.cmo -a -o $@ + +.SUFFIXES: .cmx .cmo .cmi .ml .mli + +.mli.cmi: + $(OCAMLC) $(OCAMLCFLAGS) -c $< + + +.ml.cmo: + $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<` -loc loc" -c $< + +.ml.cmx: + $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<` -loc loc" -c $< + +include .depend diff --git a/camlp4/unmaintained/scheme/README b/camlp4/unmaintained/scheme/README new file mode 100644 index 00000000..809d42f2 --- /dev/null +++ b/camlp4/unmaintained/scheme/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + diff --git a/camlp4/unmaintained/scheme/pa_scheme.ml b/camlp4/unmaintained/scheme/pa_scheme.ml new file mode 100644 index 00000000..43893210 --- /dev/null +++ b/camlp4/unmaintained/scheme/pa_scheme.ml @@ -0,0 +1,1093 @@ +(* pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *) +(* ********************************************************************** *) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(* ********************************************************************** *) +(* File generated by pretty print; do not edit! *) + +open Pcaml; +open Stdpp; + +type choice 'a 'b = + [ Left of 'a + | Right of 'b ] +; + +(* Buffer *) + +module Buff = + struct + value buff = ref (String.create 80); + value store len x = + do { + if len >= String.length buff.val then + buff.val := buff.val ^ String.create (String.length buff.val) + else (); + buff.val.[len] := x; + succ len + } + ; + value get len = String.sub buff.val 0 len; + end +; + +(* Lexer *) + +value rec skip_to_eol = + parser + [ [: `'\n' | '\r' :] -> () + | [: `_; s :] -> skip_to_eol s ] +; + +value no_ident = ['('; ')'; '['; ']'; '{'; '}'; ' '; '\t'; '\n'; '\r'; ';']; + +value rec ident len = + parser + [ [: `'.' :] -> (Buff.get len, True) + | [: `x when not (List.mem x no_ident); s :] -> ident (Buff.store len x) s + | [: :] -> (Buff.get len, False) ] +; + +value identifier kwt (s, dot) = + let con = + try do { (Hashtbl.find kwt s : unit); "" } with + [ Not_found -> + match s.[0] with + [ 'A'..'Z' -> if dot then "UIDENTDOT" else "UIDENT" + | _ -> if dot then "LIDENTDOT" else "LIDENT" ] ] + in + (con, s) +; + +value rec string len = + parser + [ [: `'"' :] -> Buff.get len + | [: `'\\'; `c; s :] -> string (Buff.store (Buff.store len '\\') c) s + | [: `x; s :] -> string (Buff.store len x) s ] +; + +value rec end_exponent_part_under len = + parser + [ [: `('0'..'9' as c); s :] -> end_exponent_part_under (Buff.store len c) s + | [: :] -> ("FLOAT", Buff.get len) ] +; + +value end_exponent_part len = + parser + [ [: `('0'..'9' as c); s :] -> end_exponent_part_under (Buff.store len c) s + | [: :] -> raise (Stream.Error "ill-formed floating-point constant") ] +; + +value exponent_part len = + parser + [ [: `('+' | '-' as c); s :] -> end_exponent_part (Buff.store len c) s + | [: a = end_exponent_part len :] -> a ] +; + +value rec decimal_part len = + parser + [ [: `('0'..'9' as c); s :] -> decimal_part (Buff.store len c) s + | [: `'e' | 'E'; s :] -> exponent_part (Buff.store len 'E') s + | [: :] -> ("FLOAT", Buff.get len) ] +; + +value rec number len = + parser + [ [: `('0'..'9' as c); s :] -> number (Buff.store len c) s + | [: `'.'; s :] -> decimal_part (Buff.store len '.') s + | [: `'e' | 'E'; s :] -> exponent_part (Buff.store len 'E') s + | [: :] -> ("INT", Buff.get len) ] +; + +value binary = parser [: `('0'..'1' as c) :] -> c; + +value octal = parser [: `('0'..'7' as c) :] -> c; + +value hexa = parser [: `('0'..'9' | 'a'..'f' | 'A'..'F' as c) :] -> c; + +value rec digits_under kind len = + parser + [ [: d = kind; s :] -> digits_under kind (Buff.store len d) s + | [: :] -> Buff.get len ] +; + +value digits kind bp len = + parser + [ [: d = kind; s :] -> ("INT", digits_under kind (Buff.store len d) s) + | [: s :] ep -> + raise_with_loc + (Reloc.shift_pos bp Reloc.zero_loc, Reloc.shift_pos ep Reloc.zero_loc) + (Failure "ill-formed integer constant") ] +; + +value base_number kwt bp len = + parser + [ [: `'b' | 'B'; s :] -> digits binary bp (Buff.store len 'b') s + | [: `'o' | 'O'; s :] -> digits octal bp (Buff.store len 'o') s + | [: `'x' | 'X'; s :] -> digits hexa bp (Buff.store len 'x') s + | [: id = ident (Buff.store 0 '#') :] -> identifier kwt id ] +; + +value rec operator len = + parser + [ [: `'.' :] -> Buff.get (Buff.store len '.') + | [: :] -> Buff.get len ] +; + +value char_or_quote_id x = + parser + [ [: `''' :] -> ("CHAR", String.make 1 x) + | [: s :] ep -> + if List.mem x no_ident then + Stdpp.raise_with_loc + (Reloc.shift_pos (ep - 2) Reloc.zero_loc, + Reloc.shift_pos (ep - 1) Reloc.zero_loc) + (Stream.Error "bad quote") + else + let len = Buff.store (Buff.store 0 ''') x in + let (s, dot) = ident len s in + (if dot then "LIDENTDOT" else "LIDENT", s) ] +; + +value rec char len = + parser + [ [: `''' :] -> len + | [: `x; s :] -> char (Buff.store len x) s ] +; + +value quote = + parser + [ [: `'\\'; len = char (Buff.store 0 '\\') :] -> ("CHAR", Buff.get len) + | [: `x; s :] -> char_or_quote_id x s ] +; + +(* The system with LIDENTDOT and UIDENTDOT is not great (it would be *) +(* better to have a token DOT (actually SPACEDOT and DOT)) but it is *) +(* the only way (that I have found) to have a good behaviour in the *) +(* toplevel (not expecting tokens after a phrase). Drawbacks: 1/ to be *) +(* complete, we should have STRINGDOT, RIGHTPARENDOT, and so on 2/ the *) +(* parser rule with dot is right associative and we have to reverse *) +(* the resulting tree (using the function leftify). *) +(* This is a complicated issue: the behaviour of the OCaml toplevel *) +(* is strange, anyway. For example, even without Camlp4, The OCaml *) +(* toplevel accepts that: *) +(* # let x = 32;; foo bar match let ) *) + +value rec lexer kwt = parser [: t = lexer0 kwt; _ = no_dot :] -> t +and no_dot = + parser + [ [: `'.' :] ep -> + Stdpp.raise_with_loc + (Reloc.shift_pos (ep - 1) Reloc.zero_loc, + Reloc.shift_pos ep Reloc.zero_loc) + (Stream.Error "bad dot") + | [: :] -> () ] +and lexer0 kwt = + parser bp + [ [: `'\t' | '\n' | '\r'; s :] -> lexer0 kwt s + | [: `' '; s :] -> after_space kwt s + | [: `';'; _ = skip_to_eol; s :] -> lexer kwt s + | [: `'(' :] -> (("", "("), (bp, bp + 1)) + | [: `')'; s :] ep -> (("", rparen s), (bp, ep)) + | [: `'[' :] -> (("", "["), (bp, bp + 1)) + | [: `']' :] -> (("", "]"), (bp, bp + 1)) + | [: `'{' :] -> (("", "{"), (bp, bp + 1)) + | [: `'}' :] -> (("", "}"), (bp, bp + 1)) + | [: `'"'; s = string 0 :] ep -> (("STRING", s), (bp, ep)) + | [: `'''; tok = quote :] ep -> (tok, (bp, ep)) + | [: `'<'; tok = less kwt :] ep -> (tok, (bp, ep)) + | [: `'-'; tok = minus kwt :] ep -> (tok, (bp, ep)) + | [: `'~'; tok = tilde :] ep -> (tok, (bp, ep)) + | [: `'?'; tok = question :] ep -> (tok, (bp, ep)) + | [: `'#'; tok = base_number kwt bp (Buff.store 0 '0') :] ep -> + (tok, (bp, ep)) + | [: `('0'..'9' as c); tok = number (Buff.store 0 c) :] ep -> + (tok, (bp, ep)) + | [: `('+' | '*' | '/' as c); id = operator (Buff.store 0 c) :] ep -> + (identifier kwt (id, False), (bp, ep)) + | [: `x; id = ident (Buff.store 0 x) :] ep -> (identifier kwt id, (bp, ep)) + | [: :] -> (("EOI", ""), (bp, bp + 1)) ] +and rparen = + parser + [ [: `'.' :] -> ")." + | [: ___ :] -> ")" ] +and after_space kwt = + parser + [ [: `'.' :] ep -> (("", "."), (ep - 1, ep)) + | [: x = lexer0 kwt :] -> x ] +and tilde = + parser + [ [: `('a'..'z' as c); (s, dot) = ident (Buff.store 0 c) :] -> + ("TILDEIDENT", s) + | [: :] -> ("LIDENT", "~") ] +and question = + parser + [ [: `('a'..'z' as c); (s, dot) = ident (Buff.store 0 c) :] -> + ("QUESTIONIDENT", s) + | [: :] -> ("LIDENT", "?") ] +and minus kwt = + parser + [ [: `'.' :] -> identifier kwt ("-.", False) + | [: `('0'..'9' as c); n = number (Buff.store (Buff.store 0 '-') c) :] -> + n + | [: id = ident (Buff.store 0 '-') :] -> identifier kwt id ] +and less kwt = + parser + [ [: `':'; lab = label 0; `'<' ? "'<' expected"; q = quotation 0 :] -> + ("QUOT", lab ^ ":" ^ q) + | [: id = ident (Buff.store 0 '<') :] -> identifier kwt id ] +and label len = + parser + [ [: `('a'..'z' | 'A'..'Z' | '_' as c); s :] -> label (Buff.store len c) s + | [: :] -> Buff.get len ] +and quotation len = + parser + [ [: `'>'; s :] -> quotation_greater len s + | [: `x; s :] -> quotation (Buff.store len x) s + | [: :] -> failwith "quotation not terminated" ] +and quotation_greater len = + parser + [ [: `'>' :] -> Buff.get len + | [: a = quotation (Buff.store len '>') :] -> a ] +; + +value lexer_using kwt (con, prm) = + match con with + [ "CHAR" | "EOI" | "INT" | "FLOAT" | "LIDENT" | "LIDENTDOT" | + "QUESTIONIDENT" | "QUOT" | "STRING" | "TILDEIDENT" | "UIDENT" | + "UIDENTDOT" -> + () + | "ANTIQUOT" -> () + | "" -> + try Hashtbl.find kwt prm with [ Not_found -> Hashtbl.add kwt prm () ] + | _ -> + raise + (Token.Error + ("the constructor \"" ^ con ^ "\" is not recognized by Plexer")) ] +; + +value lexer_text (con, prm) = + if con = "" then "'" ^ prm ^ "'" + else if prm = "" then con + else con ^ " \"" ^ prm ^ "\"" +; + +value lexer_gmake () = + let kwt = Hashtbl.create 89 in + {Token.tok_func = + Token.lexer_func_of_parser + (fun s -> + let (r, (bp, ep)) = lexer kwt s in + (r, + (Reloc.shift_pos bp Reloc.zero_loc, + Reloc.shift_pos ep Reloc.zero_loc))); + Token.tok_using = lexer_using kwt; Token.tok_removing = fun []; + Token.tok_match = Token.default_match; Token.tok_text = lexer_text; + Token.tok_comm = None} +; + +(* Building AST *) + +type sexpr = + [ Sacc of Loc.t and sexpr and sexpr + | Schar of Loc.t and string + | Sexpr of Loc.t and list sexpr + | Sint of Loc.t and string + | Sfloat of Loc.t and string + | Slid of Loc.t and string + | Slist of Loc.t and list sexpr + | Sqid of Loc.t and string + | Squot of Loc.t and string and string + | Srec of Loc.t and list sexpr + | Sstring of Loc.t and string + | Stid of Loc.t and string + | Suid of Loc.t and string ] +; + +value loc_of_sexpr = + fun [ + Sacc loc _ _ | Schar loc _ | Sexpr loc _ | Sint loc _ | Sfloat loc _ | + Slid loc _ | Slist loc _ | Sqid loc _ | Squot loc _ _ | Srec loc _ | + Sstring loc _ | Stid loc _ | Suid loc _ -> + loc ] +; +value error_loc loc err = + raise_with_loc loc (Stream.Error (err ^ " expected")) +; +value error se err = error_loc (loc_of_sexpr se) err; + +value strm_n = "__strm"; +value peek_fun loc = <:expr< Stream.peek >>; +value junk_fun loc = <:expr< Stream.junk >>; + +value assoc_left_parsed_op_list = + ["+"; "*"; "+."; "*."; "land"; "lor"; "lxor"] +; +value assoc_right_parsed_op_list = ["and"; "or"; "^"; "@"]; +value and_by_couple_op_list = ["="; "<>"; "<"; ">"; "<="; ">="; "=="; "!="]; + +value op_apply loc e1 e2 = + fun + [ "and" -> <:expr< $e1$ && $e2$ >> + | "or" -> <:expr< $e1$ || $e2$ >> + | x -> <:expr< $lid:x$ $e1$ $e2$ >> ] +; + +value string_se = + fun + [ Sstring loc s -> s + | se -> error se "string" ] +; + +value mod_ident_se = + fun + [ Suid _ s -> [Pcaml.rename_id.val s] + | Slid _ s -> [Pcaml.rename_id.val s] + | se -> error se "mod_ident" ] +; + +value lident_expr loc s = + if String.length s > 1 && s.[0] = '`' then + let s = String.sub s 1 (String.length s - 1) in + <:expr< ` $s$ >> + else <:expr< $lid:(Pcaml.rename_id.val s)$ >> +; + +value rec module_expr_se = + fun + [ Sexpr loc [Slid _ "functor"; Suid _ s; se1; se2] -> + let s = Pcaml.rename_id.val s in + let mt = module_type_se se1 in + let me = module_expr_se se2 in + <:module_expr< functor ($s$ : $mt$) -> $me$ >> + | Sexpr loc [Slid _ "struct" :: sl] -> + let mel = List.map str_item_se sl in + <:module_expr< struct $list:mel$ end >> + | Sexpr loc [se1; se2] -> + let me1 = module_expr_se se1 in + let me2 = module_expr_se se2 in + <:module_expr< $me1$ $me2$ >> + | Suid loc s -> <:module_expr< $uid:(Pcaml.rename_id.val s)$ >> + | se -> error se "module expr" ] +and module_type_se = + fun + [ Sexpr loc [Slid _ "functor"; Suid _ s; se1; se2] -> + let s = Pcaml.rename_id.val s in + let mt1 = module_type_se se1 in + let mt2 = module_type_se se2 in + <:module_type< functor ($s$ : $mt1$) -> $mt2$ >> + | Sexpr loc [Slid _ "sig" :: sel] -> + let sil = List.map sig_item_se sel in + <:module_type< sig $list:sil$ end >> + | Sexpr loc [Slid _ "with"; se; Sexpr _ sel] -> + let mt = module_type_se se in + let wcl = List.map with_constr_se sel in + <:module_type< $mt$ with $list:wcl$ >> + | Suid loc s -> <:module_type< $uid:(Pcaml.rename_id.val s)$ >> + | se -> error se "module type" ] +and with_constr_se = + fun + [ Sexpr loc [Slid _ "type"; se1; se2] -> + let tn = mod_ident_se se1 in + let te = ctyp_se se2 in + MLast.WcTyp loc tn [] te + | se -> error se "with constr" ] +and sig_item_se = + fun + [ Sexpr loc [Slid _ "type" :: sel] -> + let tdl = type_declaration_list_se sel in + <:sig_item< type $list:tdl$ >> + | Sexpr loc [Slid _ "exception"; Suid _ c :: sel] -> + let c = Pcaml.rename_id.val c in + let tl = List.map ctyp_se sel in + <:sig_item< exception $c$ of $list:tl$ >> + | Sexpr loc [Slid _ "value"; Slid _ s; se] -> + let s = Pcaml.rename_id.val s in + let t = ctyp_se se in + <:sig_item< value $s$ : $t$ >> + | Sexpr loc [Slid _ "external"; Slid _ i; se :: sel] -> + let i = Pcaml.rename_id.val i in + let pd = List.map string_se sel in + let t = ctyp_se se in + <:sig_item< external $i$ : $t$ = $list:pd$ >> + | Sexpr loc [Slid _ "module"; Suid _ s; se] -> + let s = Pcaml.rename_id.val s in + let mb = module_type_se se in + <:sig_item< module $s$ : $mb$ >> + | Sexpr loc [Slid _ "moduletype"; Suid _ s; se] -> + let s = Pcaml.rename_id.val s in + let mt = module_type_se se in + <:sig_item< module type $s$ = $mt$ >> + | se -> error se "sig item" ] +and str_item_se se = + match se with + [ Sexpr loc [Slid _ "open"; se] -> + let s = mod_ident_se se in + <:str_item< open $s$ >> + | Sexpr loc [Slid _ "type" :: sel] -> + let tdl = type_declaration_list_se sel in + <:str_item< type $list:tdl$ >> + | Sexpr loc [Slid _ "exception"; Suid _ c :: sel] -> + let c = Pcaml.rename_id.val c in + let tl = List.map ctyp_se sel in + <:str_item< exception $c$ of $list:tl$ >> + | Sexpr loc [Slid _ ("define" | "definerec" as r); se :: sel] -> + let r = r = "definerec" in + let (p, e) = fun_binding_se se (begin_se loc sel) in + <:str_item< value $opt:r$ $p$ = $e$ >> + | Sexpr loc [Slid _ ("define*" | "definerec*" as r) :: sel] -> + let r = r = "definerec*" in + let lbs = List.map let_binding_se sel in + <:str_item< value $opt:r$ $list:lbs$ >> + | Sexpr loc [Slid _ "external"; Slid _ i; se :: sel] -> + let i = Pcaml.rename_id.val i in + let pd = List.map string_se sel in + let t = ctyp_se se in + <:str_item< external $i$ : $t$ = $list:pd$ >> + | Sexpr loc [Slid _ "module"; Suid _ i; se] -> + let i = Pcaml.rename_id.val i in + let mb = module_binding_se se in + <:str_item< module $i$ = $mb$ >> + | Sexpr loc [Slid _ "moduletype"; Suid _ s; se] -> + let s = Pcaml.rename_id.val s in + let mt = module_type_se se in + <:str_item< module type $s$ = $mt$ >> + | _ -> + let loc = loc_of_sexpr se in + let e = expr_se se in + <:str_item< $exp:e$ >> ] +and module_binding_se se = module_expr_se se +and expr_se = + fun + [ Sacc loc se1 se2 -> + let e1 = expr_se se1 in + match se2 with + [ Slist loc [se2] -> + let e2 = expr_se se2 in + <:expr< $e1$ .[ $e2$ ] >> + | Sexpr loc [se2] -> + let e2 = expr_se se2 in + <:expr< $e1$ .( $e2$ ) >> + | _ -> + let e2 = expr_se se2 in + <:expr< $e1$ . $e2$ >> ] + | Slid loc s -> lident_expr loc s + | Suid loc s -> <:expr< $uid:(Pcaml.rename_id.val s)$ >> + | Sint loc s -> <:expr< $int:s$ >> + | Sfloat loc s -> <:expr< $flo:s$ >> + | Schar loc s -> <:expr< $chr:s$ >> + | Sstring loc s -> <:expr< $str:s$ >> + | Stid loc s -> <:expr< ~ $(Pcaml.rename_id.val s)$ >> + | Sqid loc s -> <:expr< ? $(Pcaml.rename_id.val s)$ >> + | Sexpr loc [] -> <:expr< () >> + | Sexpr loc [Slid _ s; e1 :: ([_ :: _] as sel)] + when List.mem s assoc_left_parsed_op_list -> + let rec loop e1 = + fun + [ [] -> e1 + | [e2 :: el] -> loop (op_apply loc e1 e2 s) el ] + in + loop (expr_se e1) (List.map expr_se sel) + | Sexpr loc [Slid _ s :: ([_; _ :: _] as sel)] + when List.mem s assoc_right_parsed_op_list -> + let rec loop = + fun + [ [] -> assert False + | [e1] -> e1 + | [e1 :: el] -> + let e2 = loop el in + op_apply loc e1 e2 s ] + in + loop (List.map expr_se sel) + | Sexpr loc [Slid _ s :: ([_; _ :: _] as sel)] + when List.mem s and_by_couple_op_list -> + let rec loop = + fun + [ [] | [_] -> assert False + | [e1; e2] -> <:expr< $lid:s$ $e1$ $e2$ >> + | [e1 :: ([e2; _ :: _] as el)] -> + let a1 = op_apply loc e1 e2 s in + let a2 = loop el in + <:expr< $a1$ && $a2$ >> ] + in + loop (List.map expr_se sel) + | Sexpr loc [Stid _ s; se] -> + let e = expr_se se in + <:expr< ~ $s$ : $e$ >> + | Sexpr loc [Slid _ "-"; se] -> + let e = expr_se se in + <:expr< - $e$ >> + | Sexpr loc [Slid _ "if"; se; se1] -> + let e = expr_se se in + let e1 = expr_se se1 in + <:expr< if $e$ then $e1$ else () >> + | Sexpr loc [Slid _ "if"; se; se1; se2] -> + let e = expr_se se in + let e1 = expr_se se1 in + let e2 = expr_se se2 in + <:expr< if $e$ then $e1$ else $e2$ >> + | Sexpr loc [Slid _ "cond" :: sel] -> + let rec loop = + fun + [ [Sexpr loc [Slid _ "else" :: sel]] -> begin_se loc sel + | [Sexpr loc [se1 :: sel1] :: sel] -> + let e1 = expr_se se1 in + let e2 = begin_se loc sel1 in + let e3 = loop sel in + <:expr< if $e1$ then $e2$ else $e3$ >> + | [] -> <:expr< () >> + | [se :: _] -> error se "cond clause" ] + in + loop sel + | Sexpr loc [Slid _ "while"; se :: sel] -> + let e = expr_se se in + let el = List.map expr_se sel in + <:expr< while $e$ do { $list:el$ } >> + | Sexpr loc [Slid _ "for"; Slid _ i; se1; se2 :: sel] -> + let i = Pcaml.rename_id.val i in + let e1 = expr_se se1 in + let e2 = expr_se se2 in + let el = List.map expr_se sel in + <:expr< for $i$ = $e1$ to $e2$ do { $list:el$ } >> + | Sexpr loc [Slid loc1 "lambda"] -> <:expr< fun [] >> + | Sexpr loc [Slid loc1 "lambda"; sep :: sel] -> + let e = begin_se loc1 sel in + match ipatt_opt_se sep with + [ Left p -> <:expr< fun $p$ -> $e$ >> + | Right (se, sel) -> + List.fold_right + (fun se e -> + let p = ipatt_se se in + <:expr< fun $p$ -> $e$ >>) + [se :: sel] e ] + | Sexpr loc [Slid _ "lambda_match" :: sel] -> + let pel = List.map (match_case loc) sel in + <:expr< fun [ $list:pel$ ] >> + | Sexpr loc [Slid _ ("let" | "letrec" as r) :: sel] -> + match sel with + [ [Sexpr _ sel1 :: sel2] -> + let r = r = "letrec" in + let lbs = List.map let_binding_se sel1 in + let e = begin_se loc sel2 in + <:expr< let $opt:r$ $list:lbs$ in $e$ >> + | [Slid _ n; Sexpr _ sl :: sel] -> + let n = Pcaml.rename_id.val n in + let (pl, el) = + List.fold_right + (fun se (pl, el) -> + match se with + [ Sexpr _ [se1; se2] -> + ([patt_se se1 :: pl], [expr_se se2 :: el]) + | se -> error se "named let" ]) + sl ([], []) + in + let e1 = + List.fold_right (fun p e -> <:expr< fun $p$ -> $e$ >>) pl + (begin_se loc sel) + in + let e2 = + List.fold_left (fun e1 e2 -> <:expr< $e1$ $e2$ >>) + <:expr< $lid:n$ >> el + in + <:expr< let rec $lid:n$ = $e1$ in $e2$ >> + | [se :: _] -> error se "let_binding" + | _ -> error_loc loc "let_binding" ] + | Sexpr loc [Slid _ "let*" :: sel] -> + match sel with + [ [Sexpr _ sel1 :: sel2] -> + List.fold_right + (fun se ek -> + let (p, e) = let_binding_se se in + <:expr< let $p$ = $e$ in $ek$ >>) + sel1 (begin_se loc sel2) + | [se :: _] -> error se "let_binding" + | _ -> error_loc loc "let_binding" ] + | Sexpr loc [Slid _ "match"; se :: sel] -> + let e = expr_se se in + let pel = List.map (match_case loc) sel in + <:expr< match $e$ with [ $list:pel$ ] >> + | Sexpr loc [Slid _ "parser" :: sel] -> + let e = + match sel with + [ [(Slid _ _ as se) :: sel] -> + let p = patt_se se in + let pc = parser_cases_se loc sel in + <:expr< let $p$ = Stream.count $lid:strm_n$ in $pc$ >> + | _ -> parser_cases_se loc sel ] + in + <:expr< fun ($lid:strm_n$ : Stream.t _) -> $e$ >> + | Sexpr loc [Slid _ "match_with_parser"; se :: sel] -> + let me = expr_se se in + let (bpo, sel) = + match sel with + [ [(Slid _ _ as se) :: sel] -> (Some (patt_se se), sel) + | _ -> (None, sel) ] + in + let pc = parser_cases_se loc sel in + let e = + match bpo with + [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >> + | None -> pc ] + in + match me with + [ <:expr< $lid:x$ >> when x = strm_n -> e + | _ -> <:expr< let ($lid:strm_n$ : Stream.t _) = $me$ in $e$ >> ] + | Sexpr loc [Slid _ "try"; se :: sel] -> + let e = expr_se se in + let pel = List.map (match_case loc) sel in + <:expr< try $e$ with [ $list:pel$ ] >> + | Sexpr loc [Slid _ "begin" :: sel] -> + let el = List.map expr_se sel in + <:expr< do { $list:el$ } >> + | Sexpr loc [Slid _ ":="; se1; se2] -> + let e1 = expr_se se1 in + let e2 = expr_se se2 in + <:expr< $e1$ := $e2$ >> + | Sexpr loc [Slid _ "values" :: sel] -> + let el = List.map expr_se sel in + <:expr< ( $list:el$ ) >> + | Srec loc [Slid _ "with"; se :: sel] -> + let e = expr_se se in + let lel = List.map (label_expr_se loc) sel in + <:expr< { ($e$) with $list:lel$ } >> + | Srec loc sel -> + let lel = List.map (label_expr_se loc) sel in + <:expr< { $list:lel$ } >> + | Sexpr loc [Slid _ ":"; se1; se2] -> + let e = expr_se se1 in + let t = ctyp_se se2 in + <:expr< ( $e$ : $t$ ) >> + | Sexpr loc [se] -> + let e = expr_se se in + <:expr< $e$ () >> + | Sexpr loc [Slid _ "assert"; Suid _ "False"] -> <:expr< assert False >> + | Sexpr loc [Slid _ "assert"; se] -> + let e = expr_se se in + <:expr< assert $e$ >> + | Sexpr loc [Slid _ "lazy"; se] -> + let e = expr_se se in + <:expr< lazy $e$ >> + | Sexpr loc [se :: sel] -> + List.fold_left + (fun e se -> + let e1 = expr_se se in + <:expr< $e$ $e1$ >>) + (expr_se se) sel + | Slist loc sel -> + let rec loop = + fun + [ [] -> <:expr< [] >> + | [se1; Slid _ "."; se2] -> + let e = expr_se se1 in + let el = expr_se se2 in + <:expr< [$e$ :: $el$] >> + | [se :: sel] -> + let e = expr_se se in + let el = loop sel in + <:expr< [$e$ :: $el$] >> ] + in + loop sel + | Squot loc typ txt -> Pcaml.handle_expr_quotation loc (typ, txt) ] +and begin_se loc = + fun + [ [] -> <:expr< () >> + | [se] -> expr_se se + | sel -> + let el = List.map expr_se sel in + let loc = (fst (loc_of_sexpr (List.hd sel)), snd loc) in + <:expr< do { $list:el$ } >> ] +and let_binding_se = + fun + [ Sexpr loc [se :: sel] -> + let e = begin_se loc sel in + match ipatt_opt_se se with + [ Left p -> (p, e) + | Right _ -> fun_binding_se se e ] + | se -> error se "let_binding" ] +and fun_binding_se se e = + match se with + [ Sexpr _ [Slid _ "values" :: _] -> (ipatt_se se, e) + | Sexpr _ [Slid loc s :: sel] -> + let s = Pcaml.rename_id.val s in + let e = + List.fold_right + (fun se e -> + let loc = (fst (loc_of_sexpr se), snd (MLast.loc_of_expr e)) in + let p = ipatt_se se in + <:expr< fun $p$ -> $e$ >>) + sel e + in + let p = <:patt< $lid:s$ >> in + (p, e) + | _ -> (ipatt_se se, e) ] +and match_case loc = + fun + [ Sexpr loc [Sexpr _ [Slid _ "when"; se; sew] :: sel] -> + (patt_se se, Some (expr_se sew), begin_se loc sel) + | Sexpr loc [se :: sel] -> (patt_se se, None, begin_se loc sel) + | se -> error se "match_case" ] +and label_expr_se loc = + fun + [ Sexpr _ [se1; se2] -> (patt_se se1, expr_se se2) + | se -> error se "label_expr" ] +and label_patt_se loc = + fun + [ Sexpr _ [se1; se2] -> (patt_se se1, patt_se se2) + | se -> error se "label_patt" ] +and parser_cases_se loc = + fun + [ [] -> <:expr< raise Stream.Failure >> + | [Sexpr loc [Sexpr _ spsel :: act] :: sel] -> + let ekont _ = parser_cases_se loc sel in + let act = + match act with + [ [se] -> expr_se se + | [sep; se] -> + let p = patt_se sep in + let e = expr_se se in + <:expr< let $p$ = Stream.count $lid:strm_n$ in $e$ >> + | _ -> error_loc loc "parser_case" ] + in + stream_pattern_se loc act ekont spsel + | [se :: _] -> error se "parser_case" ] +and stream_pattern_se loc act ekont = + fun + [ [] -> act + | [se :: sel] -> + let ckont err = <:expr< raise (Stream.Error $err$) >> in + let skont = stream_pattern_se loc act ckont sel in + stream_pattern_component skont ekont <:expr< "" >> se ] +and stream_pattern_component skont ekont err = + fun + [ Sexpr loc [Slid _ "`"; se :: wol] -> + let wo = + match wol with + [ [se] -> Some (expr_se se) + | [] -> None + | _ -> error_loc loc "stream_pattern_component" ] + in + let e = peek_fun loc in + let p = patt_se se in + let j = junk_fun loc in + let k = ekont err in + <:expr< match $e$ $lid:strm_n$ with + [ Some $p$ $when:wo$ -> do { $j$ $lid:strm_n$ ; $skont$ } + | _ -> $k$ ] >> + | Sexpr loc [se1; se2] -> + let p = patt_se se1 in + let e = + let e = expr_se se2 in + <:expr< try Some ($e$ $lid:strm_n$) with [ Stream.Failure -> None ] >> + in + let k = ekont err in + <:expr< match $e$ with [ Some $p$ -> $skont$ | _ -> $k$ ] >> + | Sexpr loc [Slid _ "?"; se1; se2] -> + stream_pattern_component skont ekont (expr_se se2) se1 + | Slid loc s -> + let s = Pcaml.rename_id.val s in + <:expr< let $lid:s$ = $lid:strm_n$ in $skont$ >> + | se -> error se "stream_pattern_component" ] +and patt_se = + fun + [ Sacc loc se1 se2 -> + let p1 = patt_se se1 in + let p2 = patt_se se2 in + <:patt< $p1$ . $p2$ >> + | Slid loc "_" -> <:patt< _ >> + | Slid loc s -> <:patt< $lid:(Pcaml.rename_id.val s)$ >> + | Suid loc s -> <:patt< $uid:(Pcaml.rename_id.val s)$ >> + | Sint loc s -> <:patt< $int:s$ >> + | Sfloat loc s -> <:patt< $flo:s$ >> + | Schar loc s -> <:patt< $chr:s$ >> + | Sstring loc s -> <:patt< $str:s$ >> + | Stid loc _ -> error_loc loc "patt" + | Sqid loc _ -> error_loc loc "patt" + | Srec loc sel -> + let lpl = List.map (label_patt_se loc) sel in + <:patt< { $list:lpl$ } >> + | Sexpr loc [Slid _ ":"; se1; se2] -> + let p = patt_se se1 in + let t = ctyp_se se2 in + <:patt< ($p$ : $t$) >> + | Sexpr loc [Slid _ "or"; se :: sel] -> + List.fold_left + (fun p se -> + let p1 = patt_se se in + <:patt< $p$ | $p1$ >>) + (patt_se se) sel + | Sexpr loc [Slid _ "range"; se1; se2] -> + let p1 = patt_se se1 in + let p2 = patt_se se2 in + <:patt< $p1$ .. $p2$ >> + | Sexpr loc [Slid _ "values" :: sel] -> + let pl = List.map patt_se sel in + <:patt< ( $list:pl$ ) >> + | Sexpr loc [Slid _ "as"; se1; se2] -> + let p1 = patt_se se1 in + let p2 = patt_se se2 in + <:patt< ($p1$ as $p2$) >> + | Sexpr loc [se :: sel] -> + List.fold_left + (fun p se -> + let p1 = patt_se se in + <:patt< $p$ $p1$ >>) + (patt_se se) sel + | Sexpr loc [] -> <:patt< () >> + | Slist loc sel -> + let rec loop = + fun + [ [] -> <:patt< [] >> + | [se1; Slid _ "."; se2] -> + let p = patt_se se1 in + let pl = patt_se se2 in + <:patt< [$p$ :: $pl$] >> + | [se :: sel] -> + let p = patt_se se in + let pl = loop sel in + <:patt< [$p$ :: $pl$] >> ] + in + loop sel + | Squot loc typ txt -> Pcaml.handle_patt_quotation loc (typ, txt) ] +and ipatt_se se = + match ipatt_opt_se se with + [ Left p -> p + | Right (se, _) -> error se "ipatt" ] +and ipatt_opt_se = + fun + [ Slid loc "_" -> Left <:patt< _ >> + | Slid loc s -> Left <:patt< $lid:(Pcaml.rename_id.val s)$ >> + | Stid loc s -> Left <:patt< ~ $(Pcaml.rename_id.val s)$ >> + | Sqid loc s -> Left <:patt< ? $(Pcaml.rename_id.val s)$ >> + | Sexpr loc [Sqid _ s; se] -> + let s = Pcaml.rename_id.val s in + let e = expr_se se in + Left <:patt< ? ( $lid:s$ = $e$ ) >> + | Sexpr loc [Slid _ ":"; se1; se2] -> + let p = ipatt_se se1 in + let t = ctyp_se se2 in + Left <:patt< ($p$ : $t$) >> + | Sexpr loc [Slid _ "values" :: sel] -> + let pl = List.map ipatt_se sel in + Left <:patt< ( $list:pl$ ) >> + | Sexpr loc [] -> Left <:patt< () >> + | Sexpr loc [se :: sel] -> Right (se, sel) + | se -> error se "ipatt" ] +and type_declaration_list_se = + fun + [ [se1; se2 :: sel] -> + let (n1, loc1, tpl) = + match se1 with + [ Sexpr _ [Slid loc n :: sel] -> + (n, loc, List.map type_parameter_se sel) + | Slid loc n -> (n, loc, []) + | se -> error se "type declaration" ] + in + [((loc1, Pcaml.rename_id.val n1), tpl, ctyp_se se2, []) :: + type_declaration_list_se sel] + | [] -> [] + | [se :: _] -> error se "type_declaration" ] +and type_parameter_se = + fun + [ Slid _ s when String.length s >= 2 && s.[0] = ''' -> + (String.sub s 1 (String.length s - 1), (False, False)) + | se -> error se "type_parameter" ] +and ctyp_se = + fun + [ Sexpr loc [Slid _ "sum" :: sel] -> + let cdl = List.map constructor_declaration_se sel in + <:ctyp< [ $list:cdl$ ] >> + | Srec loc sel -> + let ldl = List.map label_declaration_se sel in + <:ctyp< { $list:ldl$ } >> + | Sexpr loc [Slid _ "->" :: ([_; _ :: _] as sel)] -> + let rec loop = + fun + [ [] -> assert False + | [se] -> ctyp_se se + | [se :: sel] -> + let t1 = ctyp_se se in + let loc = (fst (loc_of_sexpr se), snd loc) in + let t2 = loop sel in + <:ctyp< $t1$ -> $t2$ >> ] + in + loop sel + | Sexpr loc [Slid _ "*" :: sel] -> + let tl = List.map ctyp_se sel in + <:ctyp< ($list:tl$) >> + | Sexpr loc [se :: sel] -> + List.fold_left + (fun t se -> + let t2 = ctyp_se se in + <:ctyp< $t$ $t2$ >>) + (ctyp_se se) sel + | Sacc loc se1 se2 -> + let t1 = ctyp_se se1 in + let t2 = ctyp_se se2 in + <:ctyp< $t1$ . $t2$ >> + | Slid loc "_" -> <:ctyp< _ >> + | Slid loc s -> + if s.[0] = ''' then + let s = String.sub s 1 (String.length s - 1) in + <:ctyp< '$s$ >> + else <:ctyp< $lid:(Pcaml.rename_id.val s)$ >> + | Suid loc s -> <:ctyp< $uid:(Pcaml.rename_id.val s)$ >> + | se -> error se "ctyp" ] +and constructor_declaration_se = + fun + [ Sexpr loc [Suid _ ci :: sel] -> + (loc, Pcaml.rename_id.val ci, List.map ctyp_se sel) + | se -> error se "constructor_declaration" ] +and label_declaration_se = + fun + [ Sexpr loc [Slid _ lab; Slid _ "mutable"; se] -> + (loc, Pcaml.rename_id.val lab, True, ctyp_se se) + | Sexpr loc [Slid _ lab; se] -> + (loc, Pcaml.rename_id.val lab, False, ctyp_se se) + | se -> error se "label_declaration" ] +; + +value directive_se = + fun + [ Sexpr _ [Slid _ s] -> (s, None) + | Sexpr _ [Slid _ s; se] -> + let e = expr_se se in + (s, Some e) + | se -> error se "directive" ] +; + +(* Parser *) + +Pcaml.syntax_name.val := "Scheme"; +Pcaml.no_constructors_arity.val := False; + +do { + Grammar.Unsafe.gram_reinit gram (lexer_gmake ()); + Grammar.Unsafe.clear_entry interf; + Grammar.Unsafe.clear_entry implem; + Grammar.Unsafe.clear_entry top_phrase; + Grammar.Unsafe.clear_entry use_file; + Grammar.Unsafe.clear_entry module_type; + Grammar.Unsafe.clear_entry module_expr; + Grammar.Unsafe.clear_entry sig_item; + Grammar.Unsafe.clear_entry str_item; + Grammar.Unsafe.clear_entry expr; + Grammar.Unsafe.clear_entry patt; + Grammar.Unsafe.clear_entry ctyp; + Grammar.Unsafe.clear_entry let_binding; + Grammar.Unsafe.clear_entry type_declaration; + Grammar.Unsafe.clear_entry class_type; + Grammar.Unsafe.clear_entry class_expr; + Grammar.Unsafe.clear_entry class_sig_item; + Grammar.Unsafe.clear_entry class_str_item +}; + +Pcaml.parse_interf.val := Grammar.Entry.parse interf; +Pcaml.parse_implem.val := Grammar.Entry.parse implem; + +value sexpr = Grammar.Entry.create gram "sexpr"; + +value rec leftify = + fun + [ Sacc loc1 se1 se2 -> + match leftify se2 with + [ Sacc loc2 se2 se3 -> Sacc loc1 (Sacc loc2 se1 se2) se3 + | se2 -> Sacc loc1 se1 se2 ] + | x -> x ] +; + +EXTEND + GLOBAL: implem interf top_phrase use_file str_item sig_item expr patt sexpr; + implem: + [ [ "#"; se = sexpr -> + let (n, dp) = directive_se se in + ([(<:str_item< # $n$ $opt:dp$ >>, loc)], True) + | si = str_item; x = SELF -> + let (sil, stopped) = x in + let loc = MLast.loc_of_str_item si in + ([(si, loc) :: sil], stopped) + | EOI -> ([], False) ] ] + ; + interf: + [ [ "#"; se = sexpr -> + let (n, dp) = directive_se se in + ([(<:sig_item< # $n$ $opt:dp$ >>, loc)], True) + | si = sig_item; x = SELF -> + let (sil, stopped) = x in + let loc = MLast.loc_of_sig_item si in + ([(si, loc) :: sil], stopped) + | EOI -> ([], False) ] ] + ; + top_phrase: + [ [ "#"; se = sexpr -> + let (n, dp) = directive_se se in + Some <:str_item< # $n$ $opt:dp$ >> + | se = sexpr -> Some (str_item_se se) + | EOI -> None ] ] + ; + use_file: + [ [ "#"; se = sexpr -> + let (n, dp) = directive_se se in + ([<:str_item< # $n$ $opt:dp$ >>], True) + | si = str_item; x = SELF -> + let (sil, stopped) = x in + ([si :: sil], stopped) + | EOI -> ([], False) ] ] + ; + str_item: + [ [ se = sexpr -> str_item_se se + | e = expr -> <:str_item< $exp:e$ >> ] ] + ; + sig_item: + [ [ se = sexpr -> sig_item_se se ] ] + ; + expr: + [ "top" + [ se = sexpr -> expr_se se ] ] + ; + patt: + [ [ se = sexpr -> patt_se se ] ] + ; + sexpr: + [ [ se1 = sexpr_dot; se2 = SELF -> leftify (Sacc loc se1 se2) ] + | [ "("; sl = LIST0 sexpr; ")" -> Sexpr loc sl + | "("; sl = LIST0 sexpr; ")."; se = SELF -> + leftify (Sacc loc (Sexpr loc sl) se) + | "["; sl = LIST0 sexpr; "]" -> Slist loc sl + | "{"; sl = LIST0 sexpr; "}" -> Srec loc sl + | a = pa_extend_keyword -> Slid loc a + | s = LIDENT -> Slid loc s + | s = UIDENT -> Suid loc s + | s = TILDEIDENT -> Stid loc s + | s = QUESTIONIDENT -> Sqid loc s + | s = INT -> Sint loc s + | s = FLOAT -> Sfloat loc s + | s = CHAR -> Schar loc s + | s = STRING -> Sstring loc s + | s = QUOT -> + let i = String.index s ':' in + let typ = String.sub s 0 i in + let txt = String.sub s (i + 1) (String.length s - i - 1) in + Squot loc typ txt ] ] + ; + sexpr_dot: + [ [ s = LIDENTDOT -> Slid loc s + | s = UIDENTDOT -> Suid loc s ] ] + ; + pa_extend_keyword: + [ [ "_" -> "_" + | "," -> "," + | "=" -> "=" + | ":" -> ":" + | "." -> "." + | "/" -> "/" ] ] + ; +END; diff --git a/camlp4/unmaintained/scheme/pa_scheme.sc b/camlp4/unmaintained/scheme/pa_scheme.sc new file mode 100644 index 00000000..cc6de189 --- /dev/null +++ b/camlp4/unmaintained/scheme/pa_scheme.sc @@ -0,0 +1,1029 @@ +; pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo +; ********************************************************************** +; +; Camlp4 +; +; Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt +; +; Copyright 2002 Institut National de Recherche en Informatique et +; en Automatique. All rights reserved. This file is distributed +; under the terms of the GNU Library General Public License, with +; the special exception on linking described in file +; ../../../LICENSE. +; +; ********************************************************************** + +(open Pcaml) +(open Stdpp) + +(type (choice 'a 'b) (sum (Left 'a) (Right 'b))) + +; Buffer + +(module Buff + (struct + (define buff (ref (String.create 80))) + (define (store len x) + (if (>= len (String.length buff.val)) + (:= buff.val (^ buff.val (String.create (String.length buff.val))))) + (:= buff.val.[len] x) + (succ len)) + (define (get len) (String.sub buff.val 0 len)))) + +; Lexer + +(definerec skip_to_eol + (parser + (((` (or '\n' '\r'))) ()) + (((` _) s) (skip_to_eol s)))) + +(define no_ident ['(' ')' '[' ']' '{' '}' ' ' '\t' '\n' '\r' ';']) + +(definerec (ident len) + (parser + (((` '.')) (values (Buff.get len) True)) + (((` x (not (List.mem x no_ident))) s) (ident (Buff.store len x) s)) + (() (values (Buff.get len) False)))) + +(define (identifier kwt (values s dot)) + (let ((con + (try (begin (: (Hashtbl.find kwt s) unit) "") + (Not_found + (match s.[0] + ((range 'A' 'Z') (if dot "UIDENTDOT" "UIDENT")) + (_ (if dot "LIDENTDOT" "LIDENT"))))))) + (values con s))) + +(definerec (string len) + (parser + (((` '"')) (Buff.get len)) + (((` '\\') (` c) s) (string (Buff.store (Buff.store len '\\') c) s)) + (((` x) s) (string (Buff.store len x) s)))) + +(definerec (end_exponent_part_under len) + (parser + (((` (as (range '0' '9') c)) s) + (end_exponent_part_under (Buff.store len c) s)) + (() (values "FLOAT" (Buff.get len))))) + +(define (end_exponent_part len) + (parser + (((` (as (range '0' '9') c)) s) + (end_exponent_part_under (Buff.store len c) s)) + (() (raise (Stream.Error "ill-formed floating-point constant"))))) + +(define (exponent_part len) + (parser + (((` (as (or '+' '-') c)) s) (end_exponent_part (Buff.store len c) s)) + (((a (end_exponent_part len))) a))) + +(definerec (decimal_part len) + (parser + (((` (as (range '0' '9') c)) s) (decimal_part (Buff.store len c) s)) + (((` (or 'e' 'E')) s) (exponent_part (Buff.store len 'E') s)) + (() (values "FLOAT" (Buff.get len))))) + +(definerec (number len) + (parser + (((` (as (range '0' '9') c)) s) (number (Buff.store len c) s)) + (((` '.') s) (decimal_part (Buff.store len '.') s)) + (((` (or 'e' 'E')) s) (exponent_part (Buff.store len 'E') s)) + (() (values "INT" (Buff.get len))))) + +(define binary + (parser + (((` (as (range '0' '1') c))) c))) + +(define octal + (parser + (((` (as (range '0' '7') c))) c))) + +(define hexa + (parser + (((` (as (or (range '0' '9') (range 'a' 'f') (range 'A' 'F')) c))) c))) + +(definerec (digits_under kind len) + (parser + (((d kind) s) (digits_under kind (Buff.store len d) s)) + (() (Buff.get len)))) + +(define (digits kind bp len) + (parser + (((d kind) s) (values "INT" (digits_under kind (Buff.store len d) s))) + ((s) ep + (raise_with_loc (values + (Reloc.shift_pos bp Reloc.zero_loc) + (Reloc.shift_pos ep Reloc.zero_loc)) + (Failure "ill-formed integer constant"))))) + +(define (base_number kwt bp len) + (parser + (((` (or 'b' 'B')) s) (digits binary bp (Buff.store len 'b') s)) + (((` (or 'o' 'O')) s) (digits octal bp (Buff.store len 'o') s)) + (((` (or 'x' 'X')) s) (digits hexa bp (Buff.store len 'x') s)) + (((id (ident (Buff.store 0 '#')))) (identifier kwt id)))) + +(definerec (operator len) + (parser + (((` '.')) (Buff.get (Buff.store len '.'))) + (() (Buff.get len)))) + +(define (char_or_quote_id x) + (parser + (((` ''')) (values "CHAR" (String.make 1 x))) + ((s) ep + (if (List.mem x no_ident) + (Stdpp.raise_with_loc (values + (Reloc.shift_pos (- ep 2) Reloc.zero_loc) + (Reloc.shift_pos (- ep 1) Reloc.zero_loc)) + (Stream.Error "bad quote")) + (let* ((len (Buff.store (Buff.store 0 ''') x)) + ((values s dot) (ident len s))) + (values (if dot "LIDENTDOT" "LIDENT") s)))))) + +(definerec (char len) + (parser + (((` ''')) len) + (((` x) s) (char (Buff.store len x) s)))) + +(define quote + (parser + (((` '\\') (len (char (Buff.store 0 '\\')))) + (values "CHAR" (Buff.get len))) + (((` x) s) (char_or_quote_id x s)))) + +; The system with LIDENTDOT and UIDENTDOT is not great (it would be +; better to have a token DOT (actually SPACEDOT and DOT)) but it is +; the only way (that I have found) to have a good behaviour in the +; toplevel (not expecting tokens after a phrase). Drawbacks: 1/ to be +; complete, we should have STRINGDOT, RIGHTPARENDOT, and so on 2/ the +; parser rule with dot is right associative and we have to reverse +; the resulting tree (using the function leftify). +; This is a complicated issue: the behaviour of the OCaml toplevel +; is strange, anyway. For example, even without Camlp4, The OCaml +; toplevel accepts that: +; # let x = 32;; foo bar match let ) + +(definerec* + ((lexer kwt) + (parser + (((t (lexer0 kwt)) + (_ no_dot)) t))) + (no_dot + (parser + (((` '.')) ep + (Stdpp.raise_with_loc (values + (Reloc.shift_pos (- ep 1) Reloc.zero_loc) + (Reloc.shift_pos ep Reloc.zero_loc)) + (Stream.Error "bad dot"))) + (() ()))) + ((lexer0 kwt) + (parser bp + (((` (or '\t' '\n' '\r')) s) (lexer0 kwt s)) + (((` ' ') s) (after_space kwt s)) + (((` ';') (_ skip_to_eol) s) (lexer kwt s)) + (((` '(')) (values (values "" "(") (values bp (+ bp 1)))) + (((` ')') s) ep (values (values "" (rparen s)) (values bp ep))) + (((` '[')) (values (values "" "[") (values bp (+ bp 1)))) + (((` ']')) (values (values "" "]") (values bp (+ bp 1)))) + (((` '{')) (values (values "" "{") (values bp (+ bp 1)))) + (((` '}')) (values (values "" "}") (values bp (+ bp 1)))) + (((` '"') (s (string 0))) ep + (values (values "STRING" s) (values bp ep))) + (((` ''') (tok quote)) ep (values tok (values bp ep))) + (((` '<') (tok (less kwt))) ep (values tok (values bp ep))) + (((` '-') (tok (minus kwt))) ep (values tok (values bp ep))) + (((` '~') (tok tilde)) ep (values tok (values bp ep))) + (((` '?') (tok question)) ep (values tok (values bp ep))) + (((` '#') (tok (base_number kwt bp (Buff.store 0 '0')))) ep + (values tok (values bp ep))) + (((` (as (range '0' '9') c)) (tok (number (Buff.store 0 c)))) ep + (values tok (values bp ep))) + (((` (as (or '+' '*' '/') c)) (id (operator (Buff.store 0 c)))) ep + (values (identifier kwt (values id False)) (values bp ep))) + (((` x) (id (ident (Buff.store 0 x)))) ep + (values (identifier kwt id) (values bp ep))) + (() (values (values "EOI" "") (values bp (+ bp 1)))))) + (rparen + (parser + (((` '.')) ").") + ((_) ")"))) + ((after_space kwt) + (parser + (((` '.')) ep (values (values "" ".") (values (- ep 1) ep))) + (((x (lexer0 kwt))) x))) + (tilde + (parser + (((` (as (range 'a' 'z') c)) ((values s dot) (ident (Buff.store 0 c)))) + (values "TILDEIDENT" s)) + (() (values "LIDENT" "~")))) + (question + (parser + (((` (as (range 'a' 'z') c)) ((values s dot) (ident (Buff.store 0 c)))) + (values "QUESTIONIDENT" s)) + (() (values "LIDENT" "?")))) + ((minus kwt) + (parser + (((` '.')) (identifier kwt (values "-." False))) + (((` (as (range '0' '9') c)) + (n (number (Buff.store (Buff.store 0 '-') c)))) ep n) + (((id (ident (Buff.store 0 '-')))) (identifier kwt id)))) + ((less kwt) + (parser + (((` ':') (lab (label 0)) (? (` '<') "'<' expected") (q (quotation 0))) + (values "QUOT" (^ lab ":" q))) + (((id (ident (Buff.store 0 '<')))) (identifier kwt id)))) + ((label len) + (parser + (((` (as (or (range 'a' 'z') (range 'A' 'Z') '_') c)) s) + (label (Buff.store len c) s)) + (() (Buff.get len)))) + ((quotation len) + (parser + (((` '>') s) (quotation_greater len s)) + (((` x) s) (quotation (Buff.store len x) s)) + (() (failwith "quotation not terminated")))) + ((quotation_greater len) + (parser + (((` '>')) (Buff.get len)) + (((a (quotation (Buff.store len '>')))) a)))) + +(define (lexer_using kwt (values con prm)) + (match con + ((or "CHAR" "EOI" "INT" "FLOAT" "LIDENT" "LIDENTDOT" "QUESTIONIDENT" + "QUOT" "STRING" "TILDEIDENT" "UIDENT" "UIDENTDOT") + ()) + ("ANTIQUOT" ()) + ("" (try (Hashtbl.find kwt prm) (Not_found (Hashtbl.add kwt prm ())))) + (_ + (raise + (Token.Error + (^ "the constructor \"" con "\" is not recognized by Plexer")))))) + +(define (lexer_text (values con prm)) + (cond + ((= con "") (^ "'"prm "'")) + ((= prm "") con) + (else (^ con " \"" prm "\"")))) + +(define (lexer_gmake ()) + (let ((kwt (Hashtbl.create 89))) + {(Token.tok_func + (Token.lexer_func_of_parser + (lambda (s) + (let (((values r (values bp ep)) (lexer kwt s))) + (values r (values (Reloc.shift_pos bp Reloc.zero_loc) + (Reloc.shift_pos ep Reloc.zero_loc))))))) + (Token.tok_using (lexer_using kwt)) + (Token.tok_removing (lambda)) + (Token.tok_match Token.default_match) + (Token.tok_text lexer_text) + (Token.tok_comm None)})) + +; Building AST + +(type sexpr + (sum + (Sacc MLast.loc sexpr sexpr) + (Schar MLast.loc string) + (Sexpr MLast.loc (list sexpr)) + (Sint MLast.loc string) + (Sfloat MLast.loc string) + (Slid MLast.loc string) + (Slist MLast.loc (list sexpr)) + (Sqid MLast.loc string) + (Squot MLast.loc string string) + (Srec MLast.loc (list sexpr)) + (Sstring MLast.loc string) + (Stid MLast.loc string) + (Suid MLast.loc string))) + +(define loc_of_sexpr + (lambda_match + ((or (Sacc loc _ _) (Schar loc _) (Sexpr loc _) (Sint loc _) + (Sfloat loc _) (Slid loc _) (Slist loc _) (Sqid loc _) (Squot loc _ _) + (Srec loc _) (Sstring loc _) (Stid loc _) (Suid loc _)) + loc))) +(define (error_loc loc err) + (raise_with_loc loc (Stream.Error (^ err " expected")))) +(define (error se err) (error_loc (loc_of_sexpr se) err)) + +(define strm_n "strm__") +(define (peek_fun loc) <:expr< Stream.peek >>) +(define (junk_fun loc) <:expr< Stream.junk >>) + +(define assoc_left_parsed_op_list ["+" "*" "+." "*." "land" "lor" "lxor"]) +(define assoc_right_parsed_op_list ["and" "or" "^" "@"]) +(define and_by_couple_op_list ["=" "<>" "<" ">" "<=" ">=" "==" "!="]) + +(define (op_apply loc e1 e2) + (lambda_match + ("and" <:expr< $e1$ && $e2$ >>) + ("or" <:expr< $e1$ || $e2$ >>) + (x <:expr< $lid:x$ $e1$ $e2$ >>))) + +(define string_se + (lambda_match + ((Sstring loc s) s) + (se (error se "string")))) + +(define mod_ident_se + (lambda_match + ((Suid _ s) [(Pcaml.rename_id.val s)]) + ((Slid _ s) [(Pcaml.rename_id.val s)]) + (se (error se "mod_ident")))) + +(define (lident_expr loc s) + (if (&& (> (String.length s) 1) (= s.[0] '`')) + (let ((s (String.sub s 1 (- (String.length s) 1)))) + <:expr< ` $s$ >>) + <:expr< $lid:(Pcaml.rename_id.val s)$ >>)) + +(definerec* + (module_expr_se + (lambda_match + ((Sexpr loc [(Slid _ "functor") (Suid _ s) se1 se2]) + (let* ((s (Pcaml.rename_id.val s)) + (mt (module_type_se se1)) + (me (module_expr_se se2))) + <:module_expr< functor ($s$ : $mt$) -> $me$ >>)) + ((Sexpr loc [(Slid _ "struct") . sl]) + (let ((mel (List.map str_item_se sl))) + <:module_expr< struct $list:mel$ end >>)) + ((Sexpr loc [se1 se2]) + (let* ((me1 (module_expr_se se1)) + (me2 (module_expr_se se2))) + <:module_expr< $me1$ $me2$ >>)) + ((Suid loc s) <:module_expr< $uid:(Pcaml.rename_id.val s)$ >>) + (se (error se "module expr")))) + (module_type_se + (lambda_match + ((Sexpr loc [(Slid _ "functor") (Suid _ s) se1 se2]) + (let* ((s (Pcaml.rename_id.val s)) + (mt1 (module_type_se se1)) + (mt2 (module_type_se se2))) + <:module_type< functor ($s$ : $mt1$) -> $mt2$ >>)) + ((Sexpr loc [(Slid _ "sig") . sel]) + (let ((sil (List.map sig_item_se sel))) + <:module_type< sig $list:sil$ end >>)) + ((Sexpr loc [(Slid _ "with") se (Sexpr _ sel)]) + (let* ((mt (module_type_se se)) + (wcl (List.map with_constr_se sel))) + <:module_type< $mt$ with $list:wcl$ >>)) + ((Suid loc s) <:module_type< $uid:(Pcaml.rename_id.val s)$ >>) + (se (error se "module type")))) + (with_constr_se + (lambda_match + ((Sexpr loc [(Slid _ "type") se1 se2]) + (let* ((tn (mod_ident_se se1)) + (te (ctyp_se se2))) + (MLast.WcTyp loc tn [] te))) + (se (error se "with constr")))) + (sig_item_se + (lambda_match + ((Sexpr loc [(Slid _ "type") . sel]) + (let ((tdl (type_declaration_list_se sel))) + <:sig_item< type $list:tdl$ >>)) + ((Sexpr loc [(Slid _ "exception") (Suid _ c) . sel]) + (let* ((c (Pcaml.rename_id.val c)) + (tl (List.map ctyp_se sel))) + <:sig_item< exception $c$ of $list:tl$ >>)) + ((Sexpr loc [(Slid _ "value") (Slid _ s) se]) + (let* ((s (Pcaml.rename_id.val s)) + (t (ctyp_se se))) + <:sig_item< value $s$ : $t$ >>)) + ((Sexpr loc [(Slid _ "external") (Slid _ i) se . sel]) + (let* ((i (Pcaml.rename_id.val i)) + (pd (List.map string_se sel)) + (t (ctyp_se se))) + <:sig_item< external $i$ : $t$ = $list:pd$ >>)) + ((Sexpr loc [(Slid _ "module") (Suid _ s) se]) + (let* ((s (Pcaml.rename_id.val s)) + (mb (module_type_se se))) + <:sig_item< module $s$ : $mb$ >>)) + ((Sexpr loc [(Slid _ "moduletype") (Suid _ s) se]) + (let* ((s (Pcaml.rename_id.val s)) + (mt (module_type_se se))) + <:sig_item< module type $s$ = $mt$ >>)) + (se (error se "sig item")))) + ((str_item_se se) + (match se + ((Sexpr loc [(Slid _ "open") se]) + (let ((s (mod_ident_se se))) <:str_item< open $s$ >>)) + ((Sexpr loc [(Slid _ "type") . sel]) + (let ((tdl (type_declaration_list_se sel))) + <:str_item< type $list:tdl$ >>)) + ((Sexpr loc [(Slid _ "exception") (Suid _ c) . sel]) + (let* ((c (Pcaml.rename_id.val c)) + (tl (List.map ctyp_se sel))) + <:str_item< exception $c$ of $list:tl$ >>)) + ((Sexpr loc [(Slid _ (as (or "define" "definerec") r)) se . sel]) + (let* ((r (= r "definerec")) + ((values p e) (fun_binding_se se (begin_se loc sel)))) + <:str_item< value $opt:r$ $p$ = $e$ >>)) + ((Sexpr loc [(Slid _ (as (or "define*" "definerec*") r)) . sel]) + (let* ((r (= r "definerec*")) + (lbs (List.map let_binding_se sel))) + <:str_item< value $opt:r$ $list:lbs$ >>)) + ((Sexpr loc [(Slid _ "external") (Slid _ i) se . sel]) + (let* ((i (Pcaml.rename_id.val i)) + (pd (List.map string_se sel)) + (t (ctyp_se se))) + <:str_item< external $i$ : $t$ = $list:pd$ >>)) + ((Sexpr loc [(Slid _ "module") (Suid _ i) se]) + (let* ((i (Pcaml.rename_id.val i)) + (mb (module_binding_se se))) + <:str_item< module $i$ = $mb$ >>)) + ((Sexpr loc [(Slid _ "moduletype") (Suid _ s) se]) + (let* ((s (Pcaml.rename_id.val s)) + (mt (module_type_se se))) + <:str_item< module type $s$ = $mt$ >>)) + (_ + (let* ((loc (loc_of_sexpr se)) + (e (expr_se se))) + <:str_item< $exp:e$ >>)))) + ((module_binding_se se) (module_expr_se se)) + (expr_se + (lambda_match + ((Sacc loc se1 se2) + (let ((e1 (expr_se se1))) + (match se2 + ((Slist loc [se2]) + (let ((e2 (expr_se se2))) <:expr< $e1$ .[ $e2$ ] >>)) + ((Sexpr loc [se2]) + (let ((e2 (expr_se se2))) <:expr< $e1$ .( $e2$ ) >>)) + (_ (let ((e2 (expr_se se2))) <:expr< $e1$ . $e2$ >>))))) + ((Slid loc s) (lident_expr loc s)) + ((Suid loc s) <:expr< $uid:(Pcaml.rename_id.val s)$ >>) + ((Sint loc s) <:expr< $int:s$ >>) + ((Sfloat loc s) <:expr< $flo:s$ >>) + ((Schar loc s) <:expr< $chr:s$ >>) + ((Sstring loc s) <:expr< $str:s$ >>) + ((Stid loc s) <:expr< ~ $(Pcaml.rename_id.val s)$ >>) + ((Sqid loc s) <:expr< ? $(Pcaml.rename_id.val s)$ >>) + ((Sexpr loc []) <:expr< () >>) + ((when (Sexpr loc [(Slid _ s) e1 . (as [_ . _] sel)]) + (List.mem s assoc_left_parsed_op_list)) + (letrec + (((loop e1) + (lambda_match + ([] e1) + ([e2 . el] (loop (op_apply loc e1 e2 s) el))))) + (loop (expr_se e1) (List.map expr_se sel)))) + ((when (Sexpr loc [(Slid _ s) . (as [_ _ . _] sel)]) + (List.mem s assoc_right_parsed_op_list)) + (letrec + ((loop + (lambda_match + ([] + (assert False)) + ([e1] e1) + ([e1 . el] (let ((e2 (loop el))) (op_apply loc e1 e2 s)))))) + (loop (List.map expr_se sel)))) + ((when (Sexpr loc [(Slid _ s) . (as [_ _ . _] sel)]) + (List.mem s and_by_couple_op_list)) + (letrec + ((loop + (lambda_match + ((or [] [_]) (assert False)) + ([e1 e2] <:expr< $lid:s$ $e1$ $e2$ >>) + ([e1 . (as [e2 _ . _] el)] + (let* ((a1 (op_apply loc e1 e2 s)) + (a2 (loop el))) + <:expr< $a1$ && $a2$ >>))))) + (loop (List.map expr_se sel)))) + ((Sexpr loc [(Stid _ s) se]) + (let ((e (expr_se se))) <:expr< ~ $s$ : $e$ >>)) + ((Sexpr loc [(Slid _ "-") se]) + (let ((e (expr_se se))) <:expr< - $e$ >>)) + ((Sexpr loc [(Slid _ "if") se se1]) + (let* ((e (expr_se se)) + (e1 (expr_se se1))) + <:expr< if $e$ then $e1$ else () >>)) + ((Sexpr loc [(Slid _ "if") se se1 se2]) + (let* ((e (expr_se se)) + (e1 (expr_se se1)) + (e2 (expr_se se2))) + <:expr< if $e$ then $e1$ else $e2$ >>)) + ((Sexpr loc [(Slid _ "cond") . sel]) + (letrec + ((loop + (lambda_match + ([(Sexpr loc [(Slid _ "else") . sel])] (begin_se loc sel)) + ([(Sexpr loc [se1 . sel1]) . sel] + (let* ((e1 (expr_se se1)) + (e2 (begin_se loc sel1)) + (e3 (loop sel))) + <:expr< if $e1$ then $e2$ else $e3$ >>)) + ([] <:expr< () >>) + ([se . _] (error se "cond clause"))))) + (loop sel))) + ((Sexpr loc [(Slid _ "while") se . sel]) + (let* ((e (expr_se se)) + (el (List.map expr_se sel))) + <:expr< while $e$ do { $list:el$ } >>)) + ((Sexpr loc [(Slid _ "for") (Slid _ i) se1 se2 . sel]) + (let* ((i (Pcaml.rename_id.val i)) + (e1 (expr_se se1)) + (e2 (expr_se se2)) + (el (List.map expr_se sel))) + <:expr< for $i$ = $e1$ to $e2$ do { $list:el$ } >>)) + ((Sexpr loc [(Slid loc1 "lambda")]) <:expr< fun [] >>) + ((Sexpr loc [(Slid loc1 "lambda") sep . sel]) + (let ((e (begin_se loc1 sel))) + (match (ipatt_opt_se sep) + ((Left p) <:expr< fun $p$ -> $e$ >>) + ((Right (values se sel)) + (List.fold_right + (lambda (se e) + (let ((p (ipatt_se se))) <:expr< fun $p$ -> $e$ >>)) + [se . sel] e))))) + ((Sexpr loc [(Slid _ "lambda_match") . sel]) + (let ((pel (List.map (match_case loc) sel))) + <:expr< fun [ $list:pel$ ] >>)) + ((Sexpr loc [(Slid _ (as (or "let" "letrec") r)) . sel]) + (match sel + ([(Sexpr _ sel1) . sel2] + (let* ((r (= r "letrec")) + (lbs (List.map let_binding_se sel1)) + (e (begin_se loc sel2))) + <:expr< let $opt:r$ $list:lbs$ in $e$ >>)) + ([(Slid _ n) (Sexpr _ sl) . sel] + (let* ((n (Pcaml.rename_id.val n)) + ((values pl el) + (List.fold_right + (lambda (se (values pl el)) + (match se + ((Sexpr _ [se1 se2]) + (values [(patt_se se1) . pl] + [(expr_se se2) . el])) + (se (error se "named let")))) + sl (values [] []))) + (e1 + (List.fold_right + (lambda (p e) <:expr< fun $p$ -> $e$ >>) + pl (begin_se loc sel))) + (e2 + (List.fold_left + (lambda (e1 e2) <:expr< $e1$ $e2$ >>) + <:expr< $lid:n$ >> el))) + <:expr< let rec $lid:n$ = $e1$ in $e2$ >>)) + ([se . _] (error se "let_binding")) + (_ (error_loc loc "let_binding")))) + ((Sexpr loc [(Slid _ "let*") . sel]) + (match sel + ([(Sexpr _ sel1) . sel2] + (List.fold_right + (lambda (se ek) + (let (((values p e) (let_binding_se se))) + <:expr< let $p$ = $e$ in $ek$ >>)) + sel1 (begin_se loc sel2))) + ([se . _] (error se "let_binding")) + (_ (error_loc loc "let_binding")))) + ((Sexpr loc [(Slid _ "match") se . sel]) + (let* ((e (expr_se se)) + (pel (List.map (match_case loc) sel))) + <:expr< match $e$ with [ $list:pel$ ] >>)) + ((Sexpr loc [(Slid _ "parser") . sel]) + (let ((e + (match sel + ([(as (Slid _ _) se) . sel] + (let* ((p (patt_se se)) + (pc (parser_cases_se loc sel))) + <:expr< let $p$ = Stream.count $lid:strm_n$ in $pc$ >>)) + (_ (parser_cases_se loc sel))))) + <:expr< fun ($lid:strm_n$ : Stream.t _) -> $e$ >>)) + ((Sexpr loc [(Slid _ "match_with_parser") se . sel]) + (let* ((me (expr_se se)) + ((values bpo sel) + (match sel + ([(as (Slid _ _) se) . sel] (values (Some (patt_se se)) sel)) + (_ (values None sel)))) + (pc (parser_cases_se loc sel)) + (e + (match bpo + ((Some bp) + <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >>) + (None pc)))) + (match me + ((when <:expr< $lid:x$ >> (= x strm_n)) e) + (_ <:expr< let ($lid:strm_n$ : Stream.t _) = $me$ in $e$ >>)))) + ((Sexpr loc [(Slid _ "try") se . sel]) + (let* ((e (expr_se se)) + (pel (List.map (match_case loc) sel))) + <:expr< try $e$ with [ $list:pel$ ] >>)) + ((Sexpr loc [(Slid _ "begin") . sel]) + (let ((el (List.map expr_se sel))) <:expr< do { $list:el$ } >>)) + ((Sexpr loc [(Slid _ ":=") se1 se2]) + (let* ((e1 (expr_se se1)) + (e2 (expr_se se2))) + <:expr< $e1$ := $e2$ >>)) + ((Sexpr loc [(Slid _ "values") . sel]) + (let ((el (List.map expr_se sel))) <:expr< ( $list:el$ ) >>)) + ((Srec loc [(Slid _ "with") se . sel]) + (let* ((e (expr_se se)) + (lel (List.map (label_expr_se loc) sel))) + <:expr< { ($e$) with $list:lel$ } >>)) + ((Srec loc sel) + (let ((lel (List.map (label_expr_se loc) sel))) + <:expr< { $list:lel$ } >>)) + ((Sexpr loc [(Slid _ ":") se1 se2]) + (let* ((e (expr_se se1)) (t (ctyp_se se2))) <:expr< ( $e$ : $t$ ) >>)) + ((Sexpr loc [se]) (let ((e (expr_se se))) <:expr< $e$ () >>)) + ((Sexpr loc [(Slid _ "assert") (Suid _ "False")]) + <:expr< assert False >>) + ((Sexpr loc [(Slid _ "assert") se]) + (let ((e (expr_se se))) <:expr< assert $e$ >>)) + ((Sexpr loc [(Slid _ "lazy") se]) + (let ((e (expr_se se))) <:expr< lazy $e$ >>)) + ((Sexpr loc [se . sel]) + (List.fold_left + (lambda (e se) (let ((e1 (expr_se se))) <:expr< $e$ $e1$ >>)) + (expr_se se) sel)) + ((Slist loc sel) + (letrec ((loop + (lambda_match + ([] <:expr< [] >>) + ([se1 (Slid _ ".") se2] + (let* ((e (expr_se se1)) + (el (expr_se se2))) + <:expr< [$e$ :: $el$] >>)) + ([se . sel] + (let* ((e (expr_se se)) + (el (loop sel))) + <:expr< [$e$ :: $el$] >>))))) + (loop sel))) + ((Squot loc typ txt) + (Pcaml.handle_expr_quotation loc (values typ txt))))) + ((begin_se loc) + (lambda_match + ([] <:expr< () >>) + ([se] (expr_se se)) + ((sel) + (let* ((el (List.map expr_se sel)) + (loc (values (fst (loc_of_sexpr (List.hd sel))) (snd loc)))) + <:expr< do { $list:el$ } >>)))) + (let_binding_se + (lambda_match + ((Sexpr loc [se . sel]) + (let ((e (begin_se loc sel))) + (match (ipatt_opt_se se) + ((Left p) (values p e)) + ((Right _) (fun_binding_se se e))))) + (se (error se "let_binding")))) + ((fun_binding_se se e) + (match se + ((Sexpr _ [(Slid _ "values") . _]) (values (ipatt_se se) e)) + ((Sexpr _ [(Slid loc s) . sel]) + (let* ((s (Pcaml.rename_id.val s)) + (e + (List.fold_right + (lambda (se e) + (let* ((loc + (values (fst (loc_of_sexpr se)) + (snd (MLast.loc_of_expr e)))) + (p (ipatt_se se))) + <:expr< fun $p$ -> $e$ >>)) + sel e)) + (p <:patt< $lid:s$ >>)) + (values p e))) + ((_) (values (ipatt_se se) e)))) + ((match_case loc) + (lambda_match + ((Sexpr loc [(Sexpr _ [(Slid _ "when") se sew]) . sel]) + (values (patt_se se) (Some (expr_se sew)) (begin_se loc sel))) + ((Sexpr loc [se . sel]) + (values (patt_se se) None (begin_se loc sel))) + (se (error se "match_case")))) + ((label_expr_se loc) + (lambda_match + ((Sexpr _ [se1 se2]) (values (patt_se se1) (expr_se se2))) + (se (error se "label_expr")))) + ((label_patt_se loc) + (lambda_match + ((Sexpr _ [se1 se2]) (values (patt_se se1) (patt_se se2))) + (se (error se "label_patt")))) + ((parser_cases_se loc) + (lambda_match + ([] <:expr< raise Stream.Failure >>) + ([(Sexpr loc [(Sexpr _ spsel) . act]) . sel] + (let* ((ekont (lambda _ (parser_cases_se loc sel))) + (act (match act + ([se] (expr_se se)) + ([sep se] + (let* ((p (patt_se sep)) + (e (expr_se se))) + <:expr< let $p$ = Stream.count $lid:strm_n$ in $e$ >>)) + (_ (error_loc loc "parser_case"))))) + (stream_pattern_se loc act ekont spsel))) + ([se . _] + (error se "parser_case")))) + ((stream_pattern_se loc act ekont) + (lambda_match + ([] act) + ([se . sel] + (let* ((ckont (lambda err <:expr< raise (Stream.Error $err$) >>)) + (skont (stream_pattern_se loc act ckont sel))) + (stream_pattern_component skont ekont <:expr< "" >> se))))) + ((stream_pattern_component skont ekont err) + (lambda_match + ((Sexpr loc [(Slid _ "`") se . wol]) + (let* ((wo (match wol + ([se] (Some (expr_se se))) + ([] None) + (_ (error_loc loc "stream_pattern_component")))) + (e (peek_fun loc)) + (p (patt_se se)) + (j (junk_fun loc)) + (k (ekont err))) + <:expr< match $e$ $lid:strm_n$ with + [ Some $p$ $when:wo$ -> do { $j$ $lid:strm_n$ ; $skont$ } + | _ -> $k$ ] >>)) + ((Sexpr loc [se1 se2]) + (let* ((p (patt_se se1)) + (e (let ((e (expr_se se2))) + <:expr< try Some ($e$ $lid:strm_n$) with [ Stream.Failure -> None ] >>)) + (k (ekont err))) + <:expr< match $e$ with [ Some $p$ -> $skont$ | _ -> $k$ ] >>)) + ((Sexpr loc [(Slid _ "?") se1 se2]) + (stream_pattern_component skont ekont (expr_se se2) se1)) + ((Slid loc s) + (let ((s (Pcaml.rename_id.val s))) + <:expr< let $lid:s$ = $lid:strm_n$ in $skont$ >>)) + (se + (error se "stream_pattern_component")))) + (patt_se + (lambda_match + ((Sacc loc se1 se2) + (let* ((p1 (patt_se se1)) (p2 (patt_se se2))) <:patt< $p1$ . $p2$ >>)) + ((Slid loc "_") <:patt< _ >>) + ((Slid loc s) <:patt< $lid:(Pcaml.rename_id.val s)$ >>) + ((Suid loc s) <:patt< $uid:(Pcaml.rename_id.val s)$ >>) + ((Sint loc s) <:patt< $int:s$ >>) + ((Sfloat loc s) <:patt< $flo:s$ >>) + ((Schar loc s) <:patt< $chr:s$ >>) + ((Sstring loc s) <:patt< $str:s$ >>) + ((Stid loc _) (error_loc loc "patt")) + ((Sqid loc _) (error_loc loc "patt")) + ((Srec loc sel) + (let ((lpl (List.map (label_patt_se loc) sel))) + <:patt< { $list:lpl$ } >>)) + ((Sexpr loc [(Slid _ ":") se1 se2]) + (let* ((p (patt_se se1)) (t (ctyp_se se2))) <:patt< ($p$ : $t$) >>)) + ((Sexpr loc [(Slid _ "or") se . sel]) + (List.fold_left + (lambda (p se) (let ((p1 (patt_se se))) <:patt< $p$ | $p1$ >>)) + (patt_se se) sel)) + ((Sexpr loc [(Slid _ "range") se1 se2]) + (let* ((p1 (patt_se se1)) (p2 (patt_se se2))) <:patt< $p1$ .. $p2$ >>)) + ((Sexpr loc [(Slid _ "values") . sel]) + (let ((pl (List.map patt_se sel))) <:patt< ( $list:pl$ ) >>)) + ((Sexpr loc [(Slid _ "as") se1 se2]) + (let* ((p1 (patt_se se1)) + (p2 (patt_se se2))) + <:patt< ($p1$ as $p2$) >>)) + ((Sexpr loc [se . sel]) + (List.fold_left + (lambda (p se) (let ((p1 (patt_se se))) <:patt< $p$ $p1$ >>)) + (patt_se se) sel)) + ((Sexpr loc []) <:patt< () >>) + ((Slist loc sel) + (letrec ((loop + (lambda_match + ([] <:patt< [] >>) + ([se1 (Slid _ ".") se2] + (let* ((p (patt_se se1)) + (pl (patt_se se2))) + <:patt< [$p$ :: $pl$] >>)) + ([se . sel] + (let* ((p (patt_se se)) + (pl (loop sel))) + <:patt< [$p$ :: $pl$] >>))))) + (loop sel))) + ((Squot loc typ txt) + (Pcaml.handle_patt_quotation loc (values typ txt))))) + ((ipatt_se se) + (match (ipatt_opt_se se) + ((Left p) p) + ((Right (values se _)) (error se "ipatt")))) + (ipatt_opt_se + (lambda_match + ((Slid loc "_") (Left <:patt< _ >>)) + ((Slid loc s) (Left <:patt< $lid:(Pcaml.rename_id.val s)$ >>)) + ((Stid loc s) (Left <:patt< ~ $(Pcaml.rename_id.val s)$ >>)) + ((Sqid loc s) (Left <:patt< ? $(Pcaml.rename_id.val s)$ >>)) + ((Sexpr loc [(Sqid _ s) se]) + (let* ((s (Pcaml.rename_id.val s)) + (e (expr_se se))) + (Left <:patt< ? ( $lid:s$ = $e$ ) >>))) + ((Sexpr loc [(Slid _ ":") se1 se2]) + (let* ((p (ipatt_se se1)) (t (ctyp_se se2))) + (Left <:patt< ($p$ : $t$) >>))) + ((Sexpr loc [(Slid _ "values") . sel]) + (let ((pl (List.map ipatt_se sel))) (Left <:patt< ( $list:pl$ ) >>))) + ((Sexpr loc []) (Left <:patt< () >>)) + ((Sexpr loc [se . sel]) (Right (values se sel))) + (se (error se "ipatt")))) + (type_declaration_list_se + (lambda_match + ([se1 se2 . sel] + (let (((values n1 loc1 tpl) + (match se1 + ((Sexpr _ [(Slid loc n) . sel]) + (values n loc (List.map type_parameter_se sel))) + ((Slid loc n) + (values n loc [])) + ((se) + (error se "type declaration"))))) + [(values (values loc1 (Pcaml.rename_id.val n1)) tpl (ctyp_se se2) []) . + (type_declaration_list_se sel)])) + ([] []) + ([se . _] (error se "type_declaration")))) + (type_parameter_se + (lambda_match + ((when (Slid _ s) (and (>= (String.length s) 2) (= s.[0] '''))) + (values (String.sub s 1 (- (String.length s) 1)) (values False False))) + (se + (error se "type_parameter")))) + (ctyp_se + (lambda_match + ((Sexpr loc [(Slid _ "sum") . sel]) + (let ((cdl (List.map constructor_declaration_se sel))) + <:ctyp< [ $list:cdl$ ] >>)) + ((Srec loc sel) + (let ((ldl (List.map label_declaration_se sel))) + <:ctyp< { $list:ldl$ } >>)) + ((Sexpr loc [(Slid _ "->") . (as [_ _ . _] sel)]) + (letrec + ((loop + (lambda_match + ([] (assert False)) + ([se] (ctyp_se se)) + ([se . sel] + (let* ((t1 (ctyp_se se)) + (loc (values (fst (loc_of_sexpr se)) (snd loc))) + (t2 (loop sel))) + <:ctyp< $t1$ -> $t2$ >>))))) + (loop sel))) + ((Sexpr loc [(Slid _ "*") . sel]) + (let ((tl (List.map ctyp_se sel))) <:ctyp< ($list:tl$) >>)) + ((Sexpr loc [se . sel]) + (List.fold_left + (lambda (t se) (let ((t2 (ctyp_se se))) <:ctyp< $t$ $t2$ >>)) + (ctyp_se se) sel)) + ((Sacc loc se1 se2) + (let* ((t1 (ctyp_se se1)) (t2 (ctyp_se se2))) <:ctyp< $t1$ . $t2$ >>)) + ((Slid loc "_") <:ctyp< _ >>) + ((Slid loc s) + (if (= s.[0] ''') + (let ((s (String.sub s 1 (- (String.length s) 1)))) + <:ctyp< '$s$ >>) + <:ctyp< $lid:(Pcaml.rename_id.val s)$ >>)) + ((Suid loc s) <:ctyp< $uid:(Pcaml.rename_id.val s)$ >>) + (se (error se "ctyp")))) + (constructor_declaration_se + (lambda_match + ((Sexpr loc [(Suid _ ci) . sel]) + (values loc (Pcaml.rename_id.val ci) (List.map ctyp_se sel))) + (se + (error se "constructor_declaration")))) + (label_declaration_se + (lambda_match + ((Sexpr loc [(Slid _ lab) (Slid _ "mutable") se]) + (values loc (Pcaml.rename_id.val lab) True (ctyp_se se))) + ((Sexpr loc [(Slid _ lab) se]) + (values loc (Pcaml.rename_id.val lab) False (ctyp_se se))) + (se + (error se "label_declaration"))))) + +(define directive_se + (lambda_match + ((Sexpr _ [(Slid _ s)]) (values s None)) + ((Sexpr _ [(Slid _ s) se]) (let ((e (expr_se se))) (values s (Some e)))) + (se (error se "directive")))) + +; Parser + +(:= Pcaml.syntax_name.val "Scheme") +(:= Pcaml.no_constructors_arity.val False) + +(begin + (Grammar.Unsafe.gram_reinit gram (lexer_gmake ())) + (Grammar.Unsafe.clear_entry interf) + (Grammar.Unsafe.clear_entry implem) + (Grammar.Unsafe.clear_entry top_phrase) + (Grammar.Unsafe.clear_entry use_file) + (Grammar.Unsafe.clear_entry module_type) + (Grammar.Unsafe.clear_entry module_expr) + (Grammar.Unsafe.clear_entry sig_item) + (Grammar.Unsafe.clear_entry str_item) + (Grammar.Unsafe.clear_entry expr) + (Grammar.Unsafe.clear_entry patt) + (Grammar.Unsafe.clear_entry ctyp) + (Grammar.Unsafe.clear_entry let_binding) + (Grammar.Unsafe.clear_entry type_declaration) + (Grammar.Unsafe.clear_entry class_type) + (Grammar.Unsafe.clear_entry class_expr) + (Grammar.Unsafe.clear_entry class_sig_item) + (Grammar.Unsafe.clear_entry class_str_item)) + +(:= Pcaml.parse_interf.val (Grammar.Entry.parse interf)) +(:= Pcaml.parse_implem.val (Grammar.Entry.parse implem)) + +(define sexpr (Grammar.Entry.create gram "sexpr")) + +(definerec leftify + (lambda_match + ((Sacc loc1 se1 se2) + (match (leftify se2) + ((Sacc loc2 se2 se3) (Sacc loc1 (Sacc loc2 se1 se2) se3)) + (se2 (Sacc loc1 se1 se2)))) + (x x))) + +EXTEND + GLOBAL : implem interf top_phrase use_file str_item sig_item expr + patt sexpr / + implem : + [ [ "#" / se = sexpr -> + (let (((values n dp) (directive_se se))) + (values [(values <:str_item< # $n$ $opt:dp$ >> loc)] True)) + | si = str_item / x = SELF -> + (let* (((values sil stopped) x) + (loc (MLast.loc_of_str_item si))) + (values [(values si loc) . sil] stopped)) + | EOI -> (values [] False) ] ] + / + interf : + [ [ "#" / se = sexpr -> + (let (((values n dp) (directive_se se))) + (values [(values <:sig_item< # $n$ $opt:dp$ >> loc)] True)) + | si = sig_item / x = SELF -> + (let* (((values sil stopped) x) + (loc (MLast.loc_of_sig_item si))) + (values [(values si loc) . sil] stopped)) + | EOI -> (values [] False) ] ] + / + top_phrase : + [ [ "#" / se = sexpr -> + (let (((values n dp) (directive_se se))) + (Some <:str_item< # $n$ $opt:dp$ >>)) + | se = sexpr -> (Some (str_item_se se)) + | EOI -> None ] ] + / + use_file : + [ [ "#" / se = sexpr -> + (let (((values n dp) (directive_se se))) + (values [<:str_item< # $n$ $opt:dp$ >>] True)) + | si = str_item / x = SELF -> + (let (((values sil stopped) x)) (values [si . sil] stopped)) + | EOI -> (values [] False) ] ] + / + str_item : + [ [ se = sexpr -> (str_item_se se) + | e = expr -> <:str_item< $exp:e$ >> ] ] + / + sig_item : + [ [ se = sexpr -> (sig_item_se se) ] ] + / + expr : + [ "top" + [ se = sexpr -> (expr_se se) ] ] + / + patt : + [ [ se = sexpr -> (patt_se se) ] ] + / + sexpr : + [ [ se1 = sexpr_dot / se2 = sexpr -> (leftify (Sacc loc se1 se2)) ] + | [ "(" / sl = LIST0 sexpr / ")" -> (Sexpr loc sl) + | "(" / sl = LIST0 sexpr / ")." / se = sexpr -> + (leftify (Sacc loc (Sexpr loc sl) se)) + | "[" / sl = LIST0 sexpr / "]" -> (Slist loc sl) + | "{" / sl = LIST0 sexpr / "}" -> (Srec loc sl) + | a = pa_extend_keyword -> (Slid loc a) + | s = LIDENT -> (Slid loc s) + | s = UIDENT -> (Suid loc s) + | s = TILDEIDENT -> (Stid loc s) + | s = QUESTIONIDENT -> (Sqid loc s) + | s = INT -> (Sint loc s) + | s = FLOAT -> (Sfloat loc s) + | s = CHAR -> (Schar loc s) + | s = STRING -> (Sstring loc s) + | s = QUOT -> + (let* ((i (String.index s ':')) + (typ (String.sub s 0 i)) + (txt (String.sub s (+ i 1) (- (- (String.length s) i) 1)))) + (Squot loc typ txt)) ] ] + / + sexpr_dot : + [ [ s = LIDENTDOT -> (Slid loc s) + | s = UIDENTDOT -> (Suid loc s) ] ] + / + pa_extend_keyword : + [ [ "_" -> "_" + | "," -> "," + | "=" -> "=" + | ":" -> ":" + | "." -> "." + | "/" -> "/" ] ] + / +END diff --git a/camlp4/unmaintained/scheme/pr_scheme.ml b/camlp4/unmaintained/scheme/pr_scheme.ml new file mode 100644 index 00000000..a9cf348e --- /dev/null +++ b/camlp4/unmaintained/scheme/pr_scheme.ml @@ -0,0 +1,826 @@ +(* pa_r.cmo q_MLast.cmo pa_extfun.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + +open Pcaml; +open Format; + +type printer_t 'a = + { pr_fun : mutable string -> next 'a; + pr_levels : mutable list (pr_level 'a) } +and pr_level 'a = + { pr_label : string; + pr_box : formatter -> (formatter -> unit) -> 'a -> unit; + pr_rules : mutable pr_rule 'a } +and pr_rule 'a = + Extfun.t 'a (formatter -> curr 'a -> next 'a -> string -> kont -> unit) +and curr 'a = formatter -> ('a * string * kont) -> unit +and next 'a = formatter -> ('a * string * kont) -> unit +and kont = formatter -> unit; + +value not_impl name x ppf k = + let desc = + if Obj.is_block (Obj.repr x) then + "tag = " ^ string_of_int (Obj.tag (Obj.repr x)) + else "int_val = " ^ string_of_int (Obj.magic x) + in + fprintf ppf "%t" name desc k +; + +value pr_fun name pr lab = + loop False pr.pr_levels where rec loop app = + fun + [ [] -> fun ppf (x, dg, k) -> failwith ("unable to print " ^ name) + | [lev :: levl] -> + if app || lev.pr_label = lab then + let next = loop True levl in + let rec curr ppf (x, dg, k) = + Extfun.apply lev.pr_rules x ppf curr next dg k + in + fun ppf ((x, _, _) as n) -> lev.pr_box ppf (fun ppf -> curr ppf n) x + else loop app levl ] +; + +value rec find_pr_level lab = + fun + [ [] -> failwith ("level " ^ lab ^ " not found") + | [lev :: levl] -> + if lev.pr_label = lab then lev else find_pr_level lab levl ] +; + +value pr_constr_decl = {pr_fun = fun []; pr_levels = []}; +value constr_decl ppf (x, k) = pr_constr_decl.pr_fun "top" ppf (x, "", k); +pr_constr_decl.pr_fun := pr_fun "constr_decl" pr_constr_decl; + +value pr_ctyp = {pr_fun = fun []; pr_levels = []}; +pr_ctyp.pr_fun := pr_fun "ctyp" pr_ctyp; +value ctyp ppf (x, k) = pr_ctyp.pr_fun "top" ppf (x, "", k); + +value pr_expr = {pr_fun = fun []; pr_levels = []}; +pr_expr.pr_fun := pr_fun "expr" pr_expr; +value expr ppf (x, k) = pr_expr.pr_fun "top" ppf (x, "", k); + +value pr_label_decl = {pr_fun = fun []; pr_levels = []}; +value label_decl ppf (x, k) = pr_label_decl.pr_fun "top" ppf (x, "", k); +pr_label_decl.pr_fun := pr_fun "label_decl" pr_label_decl; + +value pr_let_binding = {pr_fun = fun []; pr_levels = []}; +pr_let_binding.pr_fun := pr_fun "let_binding" pr_let_binding; +value let_binding ppf (x, k) = pr_let_binding.pr_fun "top" ppf (x, "", k); + +value pr_match_assoc = {pr_fun = fun []; pr_levels = []}; +pr_match_assoc.pr_fun := pr_fun "match_assoc" pr_match_assoc; +value match_assoc ppf (x, k) = pr_match_assoc.pr_fun "top" ppf (x, "", k); + +value pr_mod_ident = {pr_fun = fun []; pr_levels = []}; +pr_mod_ident.pr_fun := pr_fun "mod_ident" pr_mod_ident; +value mod_ident ppf (x, k) = pr_mod_ident.pr_fun "top" ppf (x, "", k); + +value pr_module_binding = {pr_fun = fun []; pr_levels = []}; +pr_module_binding.pr_fun := pr_fun "module_binding" pr_module_binding; +value module_binding ppf (x, k) = + pr_module_binding.pr_fun "top" ppf (x, "", k); + +value pr_module_expr = {pr_fun = fun []; pr_levels = []}; +pr_module_expr.pr_fun := pr_fun "module_expr" pr_module_expr; +value module_expr ppf (x, k) = pr_module_expr.pr_fun "top" ppf (x, "", k); + +value pr_module_type = {pr_fun = fun []; pr_levels = []}; +pr_module_type.pr_fun := pr_fun "module_type" pr_module_type; +value module_type ppf (x, k) = pr_module_type.pr_fun "top" ppf (x, "", k); + +value pr_patt = {pr_fun = fun []; pr_levels = []}; +pr_patt.pr_fun := pr_fun "patt" pr_patt; +value patt ppf (x, k) = pr_patt.pr_fun "top" ppf (x, "", k); + +value pr_sig_item = {pr_fun = fun []; pr_levels = []}; +pr_sig_item.pr_fun := pr_fun "sig_item" pr_sig_item; +value sig_item ppf (x, k) = pr_sig_item.pr_fun "top" ppf (x, "", k); + +value pr_str_item = {pr_fun = fun []; pr_levels = []}; +pr_str_item.pr_fun := pr_fun "str_item" pr_str_item; +value str_item ppf (x, k) = pr_str_item.pr_fun "top" ppf (x, "", k); + +value pr_type_decl = {pr_fun = fun []; pr_levels = []}; +value type_decl ppf (x, k) = pr_type_decl.pr_fun "top" ppf (x, "", k); +pr_type_decl.pr_fun := pr_fun "type_decl" pr_type_decl; + +value pr_type_params = {pr_fun = fun []; pr_levels = []}; +value type_params ppf (x, k) = pr_type_params.pr_fun "top" ppf (x, "", k); +pr_type_params.pr_fun := pr_fun "type_params" pr_type_params; + +value pr_with_constr = {pr_fun = fun []; pr_levels = []}; +value with_constr ppf (x, k) = pr_with_constr.pr_fun "top" ppf (x, "", k); +pr_with_constr.pr_fun := pr_fun "with_constr" pr_with_constr; + +(* general functions *) + +value nok ppf = (); +value ks s k ppf = fprintf ppf "%s%t" s k; + +value rec list f ppf (l, k) = + match l with + [ [] -> k ppf + | [x] -> f ppf (x, k) + | [x :: l] -> fprintf ppf "%a@ %a" f (x, nok) (list f) (l, k) ] +; + +value rec listwb b f ppf (l, k) = + match l with + [ [] -> k ppf + | [x] -> f ppf ((b, x), k) + | [x :: l] -> fprintf ppf "%a@ %a" f ((b, x), nok) (listwb "" f) (l, k) ] +; + +(* specific functions *) + +value rec is_irrefut_patt = + fun + [ <:patt< $lid:_$ >> -> True + | <:patt< () >> -> True + | <:patt< _ >> -> True + | <:patt< ($x$ as $y$) >> -> is_irrefut_patt x && is_irrefut_patt y + | <:patt< { $list:fpl$ } >> -> + List.for_all (fun (_, p) -> is_irrefut_patt p) fpl + | <:patt< ($p$ : $_$) >> -> is_irrefut_patt p + | <:patt< ($list:pl$) >> -> List.for_all is_irrefut_patt pl + | <:patt< ? $_$ : ( $p$ ) >> -> is_irrefut_patt p + | <:patt< ? $_$ : ($p$ = $_$) >> -> is_irrefut_patt p + | <:patt< ~ $_$ >> -> True + | <:patt< ~ $_$ : $p$ >> -> is_irrefut_patt p + | _ -> False ] +; + +value expr_fun_args ge = Extfun.apply pr_expr_fun_args.val ge; + +pr_expr_fun_args.val := + extfun Extfun.empty with + [ <:expr< fun [$p$ -> $e$] >> as ge -> + if is_irrefut_patt p then + let (pl, e) = expr_fun_args e in + ([p :: pl], e) + else ([], ge) + | ge -> ([], ge) ]; + +value sequence ppf (e, k) = + match e with + [ <:expr< do { $list:el$ } >> -> + fprintf ppf "@[%a@]" (list expr) (el, k) + | _ -> expr ppf (e, k) ] +; + +value string ppf (s, k) = fprintf ppf "\"%s\"%t" s k; + +value int_repr s = + if String.length s > 2 && s.[0] = '0' then + match s.[1] with + [ 'b' | 'o' | 'x' | 'B' | 'O' | 'X' -> + "#" ^ String.sub s 1 (String.length s - 1) + | _ -> s ] + else s +; + +value assoc_left_parsed_op_list = ["+"; "*"; "land"; "lor"; "lxor"]; +value assoc_right_parsed_op_list = ["and"; "or"; "^"; "@"]; +value and_by_couple_op_list = ["="; "<>"; "<"; ">"; "<="; ">="; "=="; "!="]; + +(* extensible pretty print functions *) + +pr_constr_decl.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ (loc, c, []) -> + fun ppf curr next dg k -> fprintf ppf "(@[%s%t@]" c (ks ")" k) + | (loc, c, tl) -> + fun ppf curr next dg k -> + fprintf ppf "(@[%s@ %a@]" c (list ctyp) (tl, ks ")" k) ]}]; + +pr_ctyp.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:ctyp< [ $list:cdl$ ] >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[sum@ %a@]" (list constr_decl) (cdl, ks ")" k) + | <:ctyp< { $list:cdl$ } >> -> + fun ppf curr next dg k -> + fprintf ppf "{@[%a@]" (list label_decl) (cdl, ks "}" k) + | <:ctyp< ( $list:tl$ ) >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[* @[%a@]@]" (list ctyp) (tl, ks ")" k) + | <:ctyp< $t1$ -> $t2$ >> -> + fun ppf curr next dg k -> + let tl = + loop t2 where rec loop = + fun + [ <:ctyp< $t1$ -> $t2$ >> -> [t1 :: loop t2] + | t -> [t] ] + in + fprintf ppf "(@[-> @[%a@]@]" (list ctyp) + ([t1 :: tl], ks ")" k) + | <:ctyp< $t1$ $t2$ >> -> + fun ppf curr next dg k -> + let (t, tl) = + loop [t2] t1 where rec loop tl = + fun + [ <:ctyp< $t1$ $t2$ >> -> loop [t2 :: tl] t1 + | t1 -> (t1, tl) ] + in + fprintf ppf "(@[%a@ %a@]" ctyp (t, nok) (list ctyp) (tl, ks ")" k) + | <:ctyp< $t1$ . $t2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "%a.%a" ctyp (t1, nok) ctyp (t2, k) + | <:ctyp< $lid:s$ >> | <:ctyp< $uid:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" s k + | <:ctyp< ' $s$ >> -> + fun ppf curr next dg k -> fprintf ppf "'%s%t" s k + | <:ctyp< _ >> -> + fun ppf curr next dg k -> fprintf ppf "_%t" k + | x -> + fun ppf curr next dg k -> not_impl "ctyp" x ppf k ]}]; + +pr_expr.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:expr< fun [] >> -> + fun ppf curr next dg k -> + fprintf ppf "(lambda%t" (ks ")" k) + | <:expr< fun $lid:s$ -> $e$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(lambda@ %s@;<1 1>%a" s expr (e, ks ")" k) + | <:expr< fun [ $list:pwel$ ] >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[lambda_match@ %a@]" (list match_assoc) + (pwel, ks ")" k) + | <:expr< match $e$ with [ $list:pwel$ ] >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[match@ %a@]@ %a@]" expr (e, nok) + (list match_assoc) (pwel, ks ")" k) + | <:expr< try $e$ with [ $list:pwel$ ] >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[try@ %a@]@ %a@]" expr (e, nok) + (list match_assoc) (pwel, ks ")" k) + | <:expr< let $p1$ = $e1$ in $e2$ >> -> + fun ppf curr next dg k -> + let (pel, e) = + loop [(p1, e1)] e2 where rec loop pel = + fun + [ <:expr< let $p1$ = $e1$ in $e2$ >> -> + loop [(p1, e1) :: pel] e2 + | e -> (List.rev pel, e) ] + in + let b = + match pel with + [ [_] -> "let" + | _ -> "let*" ] + in + fprintf ppf "(@[@[%s (@[%a@]@]@;<1 2>%a@]" b + (listwb "" let_binding) (pel, ks ")" nok) + sequence (e, ks ")" k) + | <:expr< let $opt:rf$ $list:pel$ in $e$ >> -> + fun ppf curr next dg k -> + let b = if rf then "letrec" else "let" in + fprintf ppf "(@[%s@ (@[%a@]@ %a@]" b + (listwb "" let_binding) (pel, ks ")" nok) expr (e, ks ")" k) + | <:expr< if $e1$ then $e2$ else () >> -> + fun ppf curr next dg k -> + fprintf ppf "(if @[%a@;<1 0>%a@]" expr (e1, nok) + expr (e2, ks ")" k) + | <:expr< if $e1$ then $e2$ else $e3$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(if @[%a@ %a@ %a@]" expr (e1, nok) + expr (e2, nok) expr (e3, ks ")" k) + | <:expr< do { $list:el$ } >> -> + fun ppf curr next dg k -> + fprintf ppf "(begin@;<1 1>@[%a@]" (list expr) (el, ks ")" k) + | <:expr< for $i$ = $e1$ to $e2$ do { $list:el$ } >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[for %s@ %a@ %a %a@]" i expr (e1, nok) + expr (e2, nok) (list expr) (el, ks ")" k) + | <:expr< ($e$ : $t$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(:@ %a@ %a" expr (e, nok) ctyp (t, ks ")" k) + | <:expr< ($list:el$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(values @[%a@]" (list expr) (el, ks ")" k) + | <:expr< { $list:fel$ } >> -> + fun ppf curr next dg k -> + let record_binding ppf ((p, e), k) = + fprintf ppf "(@[%a@ %a@]" patt (p, nok) expr (e, ks ")" k) + in + fprintf ppf "{@[%a@]" (list record_binding) (fel, ks "}" k) + | <:expr< { ($e$) with $list:fel$ } >> -> + fun ppf curr next dg k -> + let record_binding ppf ((p, e), k) = + fprintf ppf "(@[%a@ %a@]" patt (p, nok) expr (e, ks ")" k) + in + fprintf ppf "{@[@[with@ %a@]@ @[%a@]@]" expr (e, nok) + (list record_binding) (fel, ks "}" k) + | <:expr< $e1$ := $e2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(:=@;<1 1>%a@;<1 1>%a" expr (e1, nok) + expr (e2, ks ")" k) + | <:expr< [$_$ :: $_$] >> as e -> + fun ppf curr next dg k -> + let (el, c) = + make_list e where rec make_list e = + match e with + [ <:expr< [$e$ :: $y$] >> -> + let (el, c) = make_list y in + ([e :: el], c) + | <:expr< [] >> -> ([], None) + | x -> ([], Some e) ] + in + match c with + [ None -> + fprintf ppf "[%a" (list expr) (el, ks "]" k) + | Some x -> + fprintf ppf "[%a@ %a" (list expr) (el, ks " ." nok) + expr (x, ks "]" k) ] + | <:expr< lazy ($x$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[lazy@ %a@]" expr (x, ks ")" k) + | <:expr< $lid:s$ $e1$ $e2$ >> + when List.mem s assoc_right_parsed_op_list -> + fun ppf curr next dg k -> + let el = + loop [e1] e2 where rec loop el = + fun + [ <:expr< $lid:s1$ $e1$ $e2$ >> when s1 = s -> + loop [e1 :: el] e2 + | e -> List.rev [e :: el] ] + in + fprintf ppf "(@[%s %a@]" s (list expr) (el, ks ")" k) + | <:expr< $e1$ $e2$ >> -> + fun ppf curr next dg k -> + let (f, el) = + loop [e2] e1 where rec loop el = + fun + [ <:expr< $e1$ $e2$ >> -> loop [e2 :: el] e1 + | e1 -> (e1, el) ] + in + fprintf ppf "(@[%a@ %a@]" expr (f, nok) (list expr) (el, ks ")" k) + | <:expr< ~ $s$ : ($e$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(~%s@ %a" s expr (e, ks ")" k) + | <:expr< $e1$ .[ $e2$ ] >> -> + fun ppf curr next dg k -> + fprintf ppf "%a.[%a" expr (e1, nok) expr (e2, ks "]" k) + | <:expr< $e1$ .( $e2$ ) >> -> + fun ppf curr next dg k -> + fprintf ppf "%a.(%a" expr (e1, nok) expr (e2, ks ")" k) + | <:expr< $e1$ . $e2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "%a.%a" expr (e1, nok) expr (e2, k) + | <:expr< $int:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" (int_repr s) k + | <:expr< $lid:s$ >> | <:expr< $uid:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" s k + | <:expr< ` $s$ >> -> + fun ppf curr next dg k -> fprintf ppf "`%s%t" s k + | <:expr< $str:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "\"%s\"%t" s k + | <:expr< $chr:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "'%s'%t" s k + | x -> + fun ppf curr next dg k -> not_impl "expr" x ppf k ]}]; + +pr_label_decl.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ (loc, f, m, t) -> + fun ppf curr next dg k -> + fprintf ppf "(@[%s%t@ %a@]" f + (fun ppf -> if m then fprintf ppf "@ mutable" else ()) + ctyp (t, ks ")" k) ]}]; + +pr_let_binding.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ (b, (p, e)) -> + fun ppf curr next dg k -> + let (pl, e) = expr_fun_args e in + match pl with + [ [] -> + fprintf ppf "(@[%s%s%a@ %a@]" b + (if b = "" then "" else " ") patt (p, nok) + sequence (e, ks ")" k) + | _ -> + fprintf ppf "(@[%s%s(%a)@ %a@]" b + (if b = "" then "" else " ") (list patt) ([p :: pl], nok) + sequence (e, ks ")" k) ] ]}]; + +pr_match_assoc.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ (p, we, e) -> + fun ppf curr next dg k -> + fprintf ppf "(@[%t@ %a@]" + (fun ppf -> + match we with + [ Some e -> + fprintf ppf "(when@ %a@ %a" patt (p, nok) + expr (e, ks ")" nok) + | None -> patt ppf (p, nok) ]) + sequence (e, ks ")" k) ]}]; + +pr_mod_ident.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ [s] -> + fun ppf curr next dg k -> + fprintf ppf "%s%t" s k + | [s :: sl] -> + fun ppf curr next dg k -> + fprintf ppf "%s.%a" s curr (sl, "", k) + | x -> + fun ppf curr next dg k -> not_impl "mod_ident" x ppf k ]}]; + +pr_module_binding.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ (b, s, me) -> + fun ppf curr next dg k -> + fprintf ppf "%s@ %s@ %a" b s module_expr (me, k) ]}]; + +pr_module_expr.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:module_expr< functor ($i$ : $mt$) -> $me$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[@[functor@ %s@]@ %a@]@ %a@]" + i module_type (mt, nok) module_expr (me, ks ")" k) + | <:module_expr< struct $list:sil$ end >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[struct@ @[%a@]@]" (list str_item) + (sil, ks ")" k) + | <:module_expr< $me1$ $me2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[%a@ %a@]" module_expr (me1, nok) + module_expr (me2, ks ")" k) + | <:module_expr< $uid:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" s k + | x -> + fun ppf curr next dg k -> not_impl "module_expr" x ppf k ]}]; + +pr_module_type.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:module_type< functor ($i$ : $mt1$) -> $mt2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[@[functor@ %s@]@ %a@]@ %a@]" + i module_type (mt1, nok) module_type (mt2, ks ")" k) + | <:module_type< sig $list:sil$ end >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[sig@ @[%a@]@]" (list sig_item) (sil, ks ")" k) + | <:module_type< $mt$ with $list:wcl$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[with@;<1 2>@[%a@ (%a@]@]" module_type (mt, nok) + (list with_constr) (wcl, ks "))" k) + | <:module_type< $uid:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" s k + | x -> + fun ppf curr next dg k -> not_impl "module_type" x ppf k ]}]; + +pr_patt.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:patt< $p1$ | $p2$ >> -> + fun ppf curr next dg k -> + let (f, pl) = + loop [p2] p1 where rec loop pl = + fun + [ <:patt< $p1$ | $p2$ >> -> loop [p2 :: pl] p1 + | p1 -> (p1, pl) ] + in + fprintf ppf "(@[or@ %a@ %a@]" patt (f, nok) (list patt) + (pl, ks ")" k) + | <:patt< ($p1$ as $p2$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[as@ %a@ %a@]" patt (p1, nok) patt (p2, ks ")" k) + | <:patt< $p1$ .. $p2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[range@ %a@ %a@]" patt (p1, nok) patt (p2, ks ")" k) + | <:patt< [$_$ :: $_$] >> as p -> + fun ppf curr next dg k -> + let (pl, c) = + make_list p where rec make_list p = + match p with + [ <:patt< [$p$ :: $y$] >> -> + let (pl, c) = make_list y in + ([p :: pl], c) + | <:patt< [] >> -> ([], None) + | x -> ([], Some p) ] + in + match c with + [ None -> + fprintf ppf "[%a" (list patt) (pl, ks "]" k) + | Some x -> + fprintf ppf "[%a@ %a" (list patt) (pl, ks " ." nok) + patt (x, ks "]" k) ] + | <:patt< $p1$ $p2$ >> -> + fun ppf curr next dg k -> + let pl = + loop [p2] p1 where rec loop pl = + fun + [ <:patt< $p1$ $p2$ >> -> loop [p2 :: pl] p1 + | p1 -> [p1 :: pl] ] + in + fprintf ppf "(@[%a@]" (list patt) (pl, ks ")" k) + | <:patt< ($p$ : $t$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(:@ %a@ %a" patt (p, nok) ctyp (t, ks ")" k) + | <:patt< ($list:pl$) >> -> + fun ppf curr next dg k -> + fprintf ppf "(values @[%a@]" (list patt) (pl, ks ")" k) + | <:patt< { $list:fpl$ } >> -> + fun ppf curr next dg k -> + let record_binding ppf ((p1, p2), k) = + fprintf ppf "(@[%a@ %a@]" patt (p1, nok) patt (p2, ks ")" k) + in + fprintf ppf "(@[{}@ %a@]" (list record_binding) (fpl, ks ")" k) + | <:patt< ? $x$ >> -> + fun ppf curr next dg k -> fprintf ppf "?%s%t" x k + | <:patt< ? ($lid:x$ = $e$) >> -> + fun ppf curr next dg k -> fprintf ppf "(?%s@ %a" x expr (e, ks ")" k) + | <:patt< $p1$ . $p2$ >> -> + fun ppf curr next dg k -> + fprintf ppf "%a.%a" patt (p1, nok) patt (p2, k) + | <:patt< $lid:s$ >> | <:patt< $uid:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" s k + | <:patt< $str:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "\"%s\"%t" s k + | <:patt< $chr:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "'%s'%t" s k + | <:patt< $int:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" (int_repr s) k + | <:patt< $flo:s$ >> -> + fun ppf curr next dg k -> fprintf ppf "%s%t" s k + | <:patt< _ >> -> + fun ppf curr next dg k -> fprintf ppf "_%t" k + | x -> + fun ppf curr next dg k -> not_impl "patt" x ppf k ]}]; + +pr_sig_item.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:sig_item< type $list:tdl$ >> -> + fun ppf curr next dg k -> + match tdl with + [ [td] -> fprintf ppf "(%a" type_decl (("type", td), ks ")" k) + | tdl -> + fprintf ppf "(@[type@ %a@]" (listwb "" type_decl) + (tdl, ks ")" k) ] + | <:sig_item< exception $c$ of $list:tl$ >> -> + fun ppf curr next dg k -> + match tl with + [ [] -> fprintf ppf "(@[exception@ %s%t@]" c (ks ")" k) + | tl -> + fprintf ppf "(@[@[exception@ %s@]@ %a@]" c + (list ctyp) (tl, ks ")" k) ] + | <:sig_item< value $i$ : $t$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[value %s@]@ %a@]" i ctyp (t, ks ")" k) + | <:sig_item< external $i$ : $t$ = $list:pd$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[external@ %s@]@ %a@ %a@]" i ctyp (t, nok) + (list string) (pd, ks ")" k) + | <:sig_item< module $s$ : $mt$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[module@ %s@]@ %a@]" s + module_type (mt, ks ")" k) + | <:sig_item< module type $s$ = $mt$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[moduletype@ %s@]@ %a@]" s + module_type (mt, ks ")" k) + | <:sig_item< declare $list:s$ end >> -> + fun ppf curr next dg k -> + if s = [] then fprintf ppf "; ..." + else fprintf ppf "%a" (list sig_item) (s, k) + | MLast.SgUse _ _ _ -> + fun ppf curr next dg k -> () + | x -> + fun ppf curr next dg k -> not_impl "sig_item" x ppf k ]}]; + +pr_str_item.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ <:str_item< open $i$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(open@ %a" mod_ident (i, ks ")" k) + | <:str_item< type $list:tdl$ >> -> + fun ppf curr next dg k -> + match tdl with + [ [td] -> fprintf ppf "(%a" type_decl (("type", td), ks ")" k) + | tdl -> + fprintf ppf "(@[type@ %a@]" (listwb "" type_decl) + (tdl, ks ")" k) ] + | <:str_item< exception $c$ of $list:tl$ >> -> + fun ppf curr next dg k -> + match tl with + [ [] -> fprintf ppf "(@[exception@ %s%t@]" c (ks ")" k) + | tl -> + fprintf ppf "(@[@[exception@ %s@]@ %a@]" c + (list ctyp) (tl, ks ")" k) ] + | <:str_item< value $opt:rf$ $list:pel$ >> -> + fun ppf curr next dg k -> + let b = if rf then "definerec" else "define" in + match pel with + [ [(p, e)] -> + fprintf ppf "%a" let_binding ((b, (p, e)), k) + | pel -> + fprintf ppf "(@[%s*@ %a@]" b (listwb "" let_binding) + (pel, ks ")" k) ] + | <:str_item< module $s$ = $me$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(%a" module_binding (("module", s, me), ks ")" k) + | <:str_item< module type $s$ = $mt$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[@[moduletype@ %s@]@ %a@]" s + module_type (mt, ks ")" k) + | <:str_item< external $i$ : $t$ = $list:pd$ >> -> + fun ppf curr next dg k -> + fprintf ppf "(@[external@ %s@ %a@ %a@]" i ctyp (t, nok) + (list string) (pd, ks ")" k) + | <:str_item< $exp:e$ >> -> + fun ppf curr next dg k -> + fprintf ppf "%a" expr (e, k) + | <:str_item< # $s$ $opt:x$ >> -> + fun ppf curr next dg k -> + match x with + [ Some e -> fprintf ppf "; # (%s %a" s expr (e, ks ")" k) + | None -> fprintf ppf "; # (%s%t" s (ks ")" k) ] + | <:str_item< declare $list:s$ end >> -> + fun ppf curr next dg k -> + if s = [] then fprintf ppf "; ..." + else fprintf ppf "%a" (list str_item) (s, k) + | MLast.StUse _ _ _ -> + fun ppf curr next dg k -> () + | x -> + fun ppf curr next dg k -> not_impl "str_item" x ppf k ]}]; + +pr_type_decl.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ (b, ((_, tn), tp, te, cl)) -> + fun ppf curr next dg k -> + fprintf ppf "%t%t@;<1 1>%a" + (fun ppf -> + if b <> "" then fprintf ppf "%s@ " b + else ()) + (fun ppf -> + match tp with + [ [] -> fprintf ppf "%s" tn + | tp -> fprintf ppf "(%s%a)" tn type_params (tp, nok) ]) + ctyp (te, k) ]}]; + +pr_type_params.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ [(s, vari) :: tpl] -> + fun ppf curr next dg k -> + fprintf ppf "@ '%s%a" s type_params (tpl, k) + | [] -> + fun ppf curr next dg k -> () ]}]; + +pr_with_constr.pr_levels := + [{pr_label = "top"; + pr_box ppf f x = fprintf ppf "@[%t@]" f; + pr_rules = + extfun Extfun.empty with + [ MLast.WcTyp _ m tp te -> + fun ppf curr next dg k -> + fprintf ppf "(type@ %t@;<1 1>%a" + (fun ppf -> + match tp with + [ [] -> fprintf ppf "%a" mod_ident (m, nok) + | tp -> + fprintf ppf "(%a@ %a)" mod_ident (m, nok) + type_params (tp, nok) ]) + ctyp (te, ks ")" k) + | x -> + fun ppf curr next dg k -> not_impl "with_constr" x ppf k ]}]; + +(* main *) + +value output_string_eval ppf s = + loop 0 where rec loop i = + if i == String.length s then () + else if i == String.length s - 1 then pp_print_char ppf s.[i] + else + match (s.[i], s.[i + 1]) with + [ ('\\', 'n') -> do { pp_print_char ppf '\n'; loop (i + 2) } + | (c, _) -> do { pp_print_char ppf c; loop (i + 1) } ] +; + +value sep = Pcaml.inter_phrases; + +value input_source ic len = + let buff = Buffer.create 20 in + try + let rec loop i = + if i >= len then Buffer.contents buff + else do { let c = input_char ic in Buffer.add_char buff c; loop (i + 1) } + in + loop 0 + with + [ End_of_file -> + let s = Buffer.contents buff in + if s = "" then + match sep.val with + [ Some s -> s + | None -> "\n" ] + else s ] +; + +value copy_source ppf (ic, first, bp, ep) = + match sep.val with + [ Some str -> + if first then () + else if ep == in_channel_length ic then pp_print_string ppf "\n" + else output_string_eval ppf str + | None -> + do { + seek_in ic bp; + let s = input_source ic (ep - bp) in pp_print_string ppf s + } ] +; + +value copy_to_end ppf (ic, first, bp) = + let ilen = in_channel_length ic in + if bp < ilen then copy_source ppf (ic, first, bp, ilen) + else pp_print_string ppf "\n" +; + +value apply_printer printer ast = + let ppf = std_formatter in + if Pcaml.input_file.val <> "-" && Pcaml.input_file.val <> "" then do { + let ic = open_in_bin Pcaml.input_file.val in + try + let (first, last_pos) = + List.fold_left + (fun (first, last_pos) (si, (bp, ep)) -> + do { + fprintf ppf "@[%a@]@?" copy_source (ic, first, last_pos.Lexing.pos_cnum, bp.Lexing.pos_cnum); + fprintf ppf "@[%a@]@?" printer (si, nok); + (False, ep) + }) + (True, Token.nowhere) ast + in + fprintf ppf "@[%a@]@?" copy_to_end (ic, first, last_pos.Lexing.pos_cnum) + with x -> + do { fprintf ppf "@."; close_in ic; raise x }; + close_in ic; + } + else failwith "not implemented" +; + +Pcaml.print_interf.val := apply_printer sig_item; +Pcaml.print_implem.val := apply_printer str_item; + +Pcaml.add_option "-l" (Arg.Int (fun x -> set_margin x)) + " Maximum line length for pretty printing."; + +Pcaml.add_option "-sep" (Arg.String (fun x -> sep.val := Some x)) + " Use this string between phrases instead of reading source."; diff --git a/camlp4/unmaintained/scheme/pr_schp_main.ml b/camlp4/unmaintained/scheme/pr_schp_main.ml new file mode 100644 index 00000000..4d3a6fb4 --- /dev/null +++ b/camlp4/unmaintained/scheme/pr_schp_main.ml @@ -0,0 +1,132 @@ +(* pa_r.cmo q_MLast.cmo pa_extfun.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + +open Format; +open Pcaml; +open Parserify; + +value nok = Pr_scheme.nok; +value ks = Pr_scheme.ks; +value patt = Pr_scheme.patt; +value expr = Pr_scheme.expr; +value find_pr_level = Pr_scheme.find_pr_level; +value pr_expr = Pr_scheme.pr_expr; +type printer_t 'a = Pr_scheme.printer_t 'a == + { pr_fun : mutable string -> Pr_scheme.next 'a; + pr_levels : mutable list (pr_level 'a) } +and pr_level 'a = Pr_scheme.pr_level 'a == + { pr_label : string; + pr_box : formatter -> (formatter -> unit) -> 'a -> unit; + pr_rules : mutable Pr_scheme.pr_rule 'a } +; + +(* extensions for rebuilding syntax of parsers *) + +value parser_cases ppf (spel, k) = + let rec parser_cases ppf (spel, k) = + match spel with + [ [] -> fprintf ppf "[: `HVbox [: b; k :] :]" + | [(sp, epo, e)] -> parser_case ppf (sp, epo, e, k) + | [(sp, epo, e) :: spel] -> + fprintf ppf "%a@ %a" parser_case (sp, epo, e, nok) + parser_cases (spel, k) ] + and parser_case ppf (sp, epo, e, k) = + fprintf ppf "(@[@[(%a)%t@]@ %a@]" stream_patt (sp, nok) + (fun ppf -> + match epo with + [ Some p -> fprintf ppf "@ %a" patt (p, nok) + | None -> () ]) + expr (e, ks ")" k) + and stream_patt ppf (sp, k) = + match sp with + [ [] -> k ppf + | [(spc, None)] -> fprintf ppf "%a" stream_patt_comp (spc, k) + | [(spc, Some e)] -> + fprintf ppf "(@[? %a@ %a@]" stream_patt_comp (spc, nok) + expr (e, ks ")" k) + | [(spc, None) :: spcl] -> + fprintf ppf "%a@ %a" stream_patt_comp (spc, nok) stream_patt (spcl, k) + | [(spc, Some e) :: spcl] -> + fprintf ppf "(@[? %a@ %a@]@ %a" stream_patt_comp (spc, nok) + expr (e, ks ")" nok) stream_patt (spcl, k) ] + and stream_patt_comp ppf (spc, k) = + match spc with + [ SPCterm (p, w) -> + match w with + [ Some e -> + fprintf ppf "(` %a@ %a" patt (p, nok) expr (e, ks ")" k) + | None -> fprintf ppf "(` %a" patt (p, ks ")" k) ] + | SPCnterm p e -> + fprintf ppf "(@[%a %a@]" patt (p, nok) expr (e, ks ")" k) + | SPCsterm p -> fprintf ppf "%a" patt (p, k) ] + in + parser_cases ppf (spel, k) +; + +value parser_body ppf (e, k) = + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + match parser_of_expr e with + [ [] -> + fprintf ppf "(parser%t%t" + (fun ppf -> + match bp with + [ Some p -> fprintf ppf "@ %a" patt (p, nok) + | _ -> ()]) + (ks ")" k) + | spel -> + fprintf ppf "(@[@[parser%t@]@ @[%a@]@]" + (fun ppf -> + match bp with + [ Some p -> fprintf ppf "@ %a" patt (p, nok) + | _ -> ()]) + parser_cases (spel, ks ")" k) ] +; + +value pmatch ppf (e, k) = + let (me, e) = + match e with + [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e) + | _ -> failwith "Pr_schp_main.pmatch" ] + in + let (bp, e) = + match e with + [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e) + | e -> (None, e) ] + in + let spel = parser_of_expr e in + fprintf ppf "(@[@[match_with_parser@ %a@]%t@ @[%a@]@]" expr (me, nok) + (fun ppf -> + match bp with + [ Some p -> fprintf ppf "@ %a" patt (p, nok) + | _ -> () ]) + parser_cases (spel, ks ")" k) +; + +pr_expr_fun_args.val := + extfun pr_expr_fun_args.val with + [ <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ]; + +let lev = find_pr_level "top" pr_expr.pr_levels in +lev.pr_rules := + extfun lev.pr_rules with + [ <:expr< fun (__strm : $_$) -> $x$ >> -> + fun ppf curr next dg k -> fprintf ppf "%a" parser_body (x, k) + | <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e -> + fun ppf curr next dg k -> fprintf ppf "%a" pmatch (e, k) ]; diff --git a/camlp4/unmaintained/sml/.depend b/camlp4/unmaintained/sml/.depend new file mode 100644 index 00000000..e69de29b diff --git a/camlp4/unmaintained/sml/Makefile b/camlp4/unmaintained/sml/Makefile new file mode 100644 index 00000000..ea3980be --- /dev/null +++ b/camlp4/unmaintained/sml/Makefile @@ -0,0 +1,68 @@ +######################################################################### +# # +# Objective Caml # +# # +# Camlp4 # +# # +# Copyright 2004 Institut National de Recherche en Informatique et # +# en Automatique. All rights reserved. This file is distributed # +# under the terms of the Q Public License version 1.0. # +# # +######################################################################### +# +# Makefile for pa_sml +# M.Mauny +# + +include ../../config/Makefile.cnf + +OCAMLTOP=../../.. + +OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) -nostdlib -I $(OCAMLTOP)/stdlib +OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) -nostdlib -I $(OCAMLTOP)/stdlib + +P4INCLUDES=-I ../../meta -I ../../etc -I ../../lib -I ../../camlp4 +OCAMLINCLUDES=-I ../../meta -I ../../lib -I ../../camlp4 + +CAMLP4=camlp4$(EXE) -nolib +OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES) + +SRC=pa_sml.ml +OBJS=$(SRC:.ml=.cmo) +OBJSX=$(SRC:.ml=.cmx) + +all: $(OBJS) smllib.cmo + +opt: $(OBJSX) smllib.cmx + +depend: + cp .depend .depend.bak + > .depend + for file in $(SRC); do \ + $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \ + sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \ + done + +clean: + rm -f *.cm* *.o *.bak .*.bak + + +.SUFFIXES: .cmx .cmo .cmi .ml .mli .sml + +.mli.cmi: + $(OCAMLC) $(OCAMLCFLAGS) -c $< + + +.sml.cmo: + $(OCAMLC) -I ../../../otherlibs/unix -pp "$(CAMLP4) ./pa_sml.cmo ../../meta/pr_dump.cmo -impl" -c -o $*.cmo -impl $< + +.sml.cmx: + $(OCAMLOPT) -I ../../../otherlibs/unix -pp "$(CAMLP4) ./pa_sml.cmo ../../meta/pr_dump.cmo -impl" -c -o $*.cmx -impl $< + +.ml.cmo: + $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +.ml.cmx: + $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $< + +include .depend diff --git a/camlp4/unmaintained/sml/README b/camlp4/unmaintained/sml/README new file mode 100644 index 00000000..809d42f2 --- /dev/null +++ b/camlp4/unmaintained/sml/README @@ -0,0 +1,15 @@ +This is an application of or an extension for Camlp4. Although it is +currently distributed with OCaml/Camlp4, it may or may not be +actively maintained. + +It probably won't be part of future OCaml/Camlp4 distributions but be +accessible from the Camlp4 hump. If you are interested in developing +this package further and/or actively maintain it, please let us know +(caml@inria.fr) + +This package is distributed under the same license as the Objective +Caml Library (that is, LGPL with a special exception allowing both +static and dynamic link). + +-- Michel Mauny + diff --git a/camlp4/unmaintained/sml/pa_sml.ml b/camlp4/unmaintained/sml/pa_sml.ml new file mode 100644 index 00000000..1808cdea --- /dev/null +++ b/camlp4/unmaintained/sml/pa_sml.ml @@ -0,0 +1,952 @@ +(* pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *) +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* en Automatique. All rights reserved. This file is distributed *) +(* under the terms of the GNU Library General Public License, with *) +(* the special exception on linking described in file *) +(* ../../../LICENSE. *) +(* *) +(***********************************************************************) + + + +open Stdpp; +open Pcaml; + +value ocaml_records = ref False; + +Pcaml.no_constructors_arity.val := True; + +value lexer = Plexer.gmake (); + +do { + Grammar.Unsafe.gram_reinit gram lexer; + Grammar.Unsafe.clear_entry interf; + Grammar.Unsafe.clear_entry implem; + Grammar.Unsafe.clear_entry top_phrase; + Grammar.Unsafe.clear_entry use_file; + Grammar.Unsafe.clear_entry module_type; + Grammar.Unsafe.clear_entry module_expr; + Grammar.Unsafe.clear_entry sig_item; + Grammar.Unsafe.clear_entry str_item; + Grammar.Unsafe.clear_entry expr; + Grammar.Unsafe.clear_entry patt; + Grammar.Unsafe.clear_entry ctyp; + Grammar.Unsafe.clear_entry let_binding; +}; + +Pcaml.parse_interf.val := Grammar.Entry.parse interf; +Pcaml.parse_implem.val := Grammar.Entry.parse implem; + +value not_impl loc s = + raise_with_loc loc (Stream.Error ("not implemented feature [" ^ s ^ "]")) +; + +type altern 'a 'b = [ Left of 'a | Right of 'b ]; + +value get_seq = + fun + [ <:expr< do { $list:el$ } >> -> el + | e -> [e] ] +; + +value choose_tvar tpl = + let rec find_alpha v = + let s = String.make 1 v in + if List.mem_assoc s tpl then + if v = 'z' then None else find_alpha (Char.chr (Char.code v + 1)) + else Some (String.make 1 v) + in + let rec make_n n = + let v = "a" ^ string_of_int n in + if List.mem_assoc v tpl then make_n (succ n) else v + in + match find_alpha 'a' with + [ Some x -> x + | None -> make_n 1 ] +; + +value mklistexp loc last = + loop True where rec loop top = + fun + [ [] -> + match last with + [ Some e -> e + | None -> <:expr< [] >> ] + | [e1 :: el] -> + let loc = if top then loc else (fst (MLast.loc_of_expr e1), snd loc) in + <:expr< [$e1$ :: $loop False el$] >> ] +; + +value mklistpat loc last = + loop True where rec loop top = + fun + [ [] -> + match last with + [ Some p -> p + | None -> <:patt< [] >> ] + | [p1 :: pl] -> + let loc = if top then loc else (fst (MLast.loc_of_patt p1), snd loc) in + <:patt< [$p1$ :: $loop False pl$] >> ] +; + +value expr_of_patt p = + let loc = MLast.loc_of_patt p in + match p with + [ <:patt< $lid:x$ >> -> <:expr< $lid:x$ >> + | _ -> Stdpp.raise_with_loc loc (Stream.Error "identifier expected") ] +; + +value apply_bind loc e bl = + let rec loop e = + fun + [ [] -> e + | [<:str_item< value $p1$ = $e1$ >> :: list] -> + loop_let e [(p1, e1)] list + | [<:str_item< value rec $p1$ = $e1$ >> :: list] -> + loop_letrec e [(p1, e1)] list + | [<:str_item< module $s$ = $me$ >> :: list] -> + let e = <:expr< let module $s$ = $me$ in $e$ >> in + loop e list + | [si :: list] -> + raise Exit ] + and loop_let e pel = + fun + [ [<:str_item< value $p1$ = $e1$ >> :: list] -> + loop_let e [(p1, e1) :: pel] list + | list -> + let e = <:expr< let $list:pel$ in $e$ >> in + loop e list ] + and loop_letrec e pel = + fun + [ [<:str_item< value rec $p1$ = $e1$ >> :: list] -> + loop_letrec e [(p1, e1) :: pel] list + | list -> + let e = <:expr< let rec $list:pel$ in $e$ >> in + loop e list ] + in + loop e (List.rev bl) +; + +value make_local loc sl1 sl2 = + try + let pl = + List.map + (fun + [ <:str_item< value $opt:_$ $p$ = $_$ >> -> p + | _ -> raise Exit ]) + sl2 + in + let e1 = + match List.map expr_of_patt pl with + [ [e] -> e + | el -> <:expr< ($list:el$) >> ] + in + let p1 = + match pl with + [ [p] -> p + | pl -> <:patt< ($list:pl$) >> ] + in + let e = apply_bind loc e1 sl2 in + let e = apply_bind loc e sl1 in + <:str_item< value $p1$ = $e$ >> + with + [ Exit -> + do { + Printf.eprintf "\ +*** Warning: a 'local' statement will be defined global because of bindings +which cannot be defined as first class values (modules, exceptions, ...)\n"; + flush stderr; + <:str_item< declare $list:sl1 @ sl2$ end >> + } ] +; + +value str_declare loc = + fun + [ [d] -> d + | dl -> <:str_item< declare $list:dl$ end >> ] +; + +value sig_declare loc = + fun + [ [d] -> d + | dl -> <:sig_item< declare $list:dl$ end >> ] +; + +value extract_label_types loc tn tal cdol = + let (cdl, aux) = + List.fold_right + (fun (loc, c, tl, aux_opt) (cdl, aux) -> + match aux_opt with + [ Some anon_record_type -> + let new_tn = tn ^ "_" ^ c in + let loc = MLast.loc_of_ctyp anon_record_type in + let aux_def = ((loc, new_tn), [], anon_record_type, []) in + let tl = [<:ctyp< $lid:new_tn$ >>] in + ([(loc, c, tl) :: cdl], [aux_def :: aux]) + | None -> ([(loc, c, tl) :: cdl], aux) ]) + cdol ([], []) + in + [((loc, tn), tal, <:ctyp< [ $list:cdl$ ] >>, []) :: aux] +; + +value function_of_clause_list loc xl = + let (fname, fname_loc, nbpat, l) = + List.fold_left + (fun (fname, fname_loc, nbpat, l) ((x1, loc), x2, x3, x4) -> + let (fname, fname_loc, nbpat) = + if fname = "" then (x1, loc, List.length x2) + else if x1 <> fname then + raise_with_loc loc + (Stream.Error ("'" ^ fname ^ "' expected")) + else if List.length x2 <> nbpat then + raise_with_loc loc + (Stream.Error "bad number of patterns in that clause") + else (fname, fname_loc, nbpat) + in + let x4 = + match x3 with + [ Some t -> <:expr< ($x4$ : $t$) >> + | _ -> x4 ] + in + let l = [(x2, x4) :: l] in + (fname, fname_loc, nbpat, l)) + ("", loc, 0, []) xl + in + let l = List.rev l in + let e = + match l with + [ [(pl, e)] -> + List.fold_right (fun p e -> <:expr< fun $p$ -> $e$ >>) pl e + | _ -> + if nbpat = 1 then + let pwel = + List.map + (fun (pl, e) -> (<:patt< $List.hd pl$ >>, None, e)) l + in + <:expr< fun [ $list:pwel$ ] >> + else + let sl = + loop 0 where rec loop n = + if n = nbpat then [] + else ["a" ^ string_of_int (n + 1) :: loop (n + 1)] + in + let e = + let el = List.map (fun s -> <:expr< $lid:s$ >>) sl in + let pwel = + List.map + (fun (pl, e) -> (<:patt< ($list:pl$) >>, None, e)) l + in + <:expr< match ($list:el$) with [ $list:pwel$ ] >> + in + List.fold_right (fun s e -> <:expr< fun $lid:s$ -> $e$ >>) sl e ] + in + (let loc = fname_loc in <:patt< $lid:fname$ >>, e) +; + +value record_expr loc x1 = + if ocaml_records.val then <:expr< { $list:x1$ } >> + else + let list1 = + List.map + (fun (l, v) -> + let id = + match l with + [ <:patt< $lid:l$ >> -> l + | _ -> "" ] + in + let loc = MLast.loc_of_expr v in + <:class_str_item< value $id$ = $v$ >>) + x1 + in + let list2 = + List.map + (fun (l, v) -> + let id = + match l with + [ <:patt< $lid:l$ >> -> l + | _ -> "" ] + in + let loc = MLast.loc_of_patt l in + <:class_str_item< method $id$ = $lid:id$ >>) + x1 + in + <:expr< + let module M = + struct + class a = object $list:list1 @ list2$ end; + end + in + new M.a + >> +; + +value record_match_assoc loc lpl e = + if ocaml_records.val then (<:patt< { $list:lpl$ } >>, e) + else + let pl = List.map (fun (_, p) -> p) lpl in + let e = + let el = + List.map + (fun (l, _) -> + let s = + match l with + [ <:patt< $lid:l$ >> -> l + | _ -> "" ] + in + let loc = MLast.loc_of_patt l in + <:expr< v # $lid:s$ >>) + lpl + in + let loc = MLast.loc_of_expr e in + <:expr< let v = $e$ in ($list:el$) >> + in + let p = <:patt< ($list:pl$) >> in + (p, e) +; + +value op = + Grammar.Entry.of_parser gram "op" + (parser [: `("", "op"); `(_, x) :] -> x) +; +lexer.Token.tok_using ("", "op"); + +value special x = + if String.length x >= 2 then + match x.[0] with + [ '+' | '<' | '^' -> True + | _ -> False ] + else False +; + +value idd = + let p = + parser + [ [: `("LIDENT", x) :] -> x + | [: `("UIDENT", x) :] -> x + | [: `("", "op"); `(_, x) :] -> x + | [: `("", x) when special x :] -> x ] + in + Grammar.Entry.of_parser Pcaml.gram "ID" p +; + +value uncap s = String.uncapitalize s; + +EXTEND + GLOBAL: implem interf top_phrase use_file sig_item str_item ctyp patt expr + module_type module_expr; + + implem: + [ [ x = interdec; EOI -> x ] ] + ; + interf: + [ [ x = LIST1 [ s = sig_item; OPT ";" -> (s, loc) ] -> (x, False) ] ] + ; + top_phrase: + [ [ ph = phrase; ";" -> Some ph + | EOI -> None ] ] + ; + use_file: + [ [ l = LIST0 phrase; EOI -> (l, False) ] ] + ; + phrase: + [ [ x = str_item -> x + | x = expr -> <:str_item< $exp:x$ >> + | "#"; n = LIDENT; dp = dir_param -> MLast.StDir loc n dp ] ] + ; + dir_param: + [ [ -> None + | e = expr -> Some e ] ] + ; + sdecs: + [ [ x = sdec; l = sdecs -> [x :: l] + | ";"; l = sdecs -> l + | -> [] ] ] + ; + + fsigb: [ [ -> not_impl loc "fsigb" ] ]; + fsigconstraint_op: [ [ -> not_impl loc "fsigconstraint_op" ] ]; + fct_exp: [ [ -> not_impl loc "fct_exp" ] ]; + exp_pa: [ [ -> not_impl loc "exp_pa" ] ]; + rvb: [ [ -> not_impl loc "rvb" ] ]; + tyvarseq: [ [ -> not_impl loc "tyvarseq" ] ]; + + tyvar_pc: + [ [ "'"; x1 = LIDENT -> [(x1, (False, False))] + | "'"; x1 = LIDENT; ","; l = tyvar_pc -> [(x1, (False, False)) :: l] ] ] + ; + id: + [ [ x1 = idd -> x1 + | "*" -> "*" ] ] + ; + ident: + [ [ x1 = idd -> x1 + | "*" -> "*" + | "=" -> "=" + | "<" -> "<" + | ">" -> ">" + | "<=" -> "<=" + | ">=" -> ">=" + | "^" -> "^" ] ] + ; + op_op: + [ [ x1 = op -> not_impl loc "op_op 1" + | -> () ] ] + ; + qid: + [ [ x1 = idd; "."; x2 = qid -> <:module_expr< $uid:x1$ . $x2$ >> + | x1 = idd -> <:module_expr< $uid:x1$ >> + | x1 = "*" -> <:module_expr< $uid:x1$ >> + | x1 = "=" -> <:module_expr< $uid:x1$ >> ] ] + ; + eqid: + [ [ x1 = UIDENT; "."; x2 = eqid -> <:expr< $uid:x1$ . $x2$ >> + | x1 = UIDENT -> <:expr< $uid:x1$ >> + | x1 = idd -> <:expr< $lid:x1$ >> + | x1 = "*" -> <:expr< $lid:x1$ >> + | x1 = "=" -> <:expr< $lid:x1$ >> ] ] + ; + sqid: + [ [ x1 = idd; "."; x2 = sqid -> [x1 :: x2] + | x1 = idd -> [x1] + | x1 = "*" -> [x1] + | x1 = "=" -> [x1] ] ] + ; + tycon: + [ [ LIDENT "real" -> <:ctyp< float >> + | x1 = idd; "."; x2 = tycon -> + let r = <:ctyp< $uid:x1$ . $x2$ >> in + loop r where rec loop = + fun + [ <:ctyp< $a$ . ($b$ . $c$) >> -> <:ctyp< $a$ . $b$ . $loop c$ >> + | x -> x ] + | x1 = idd -> <:ctyp< $lid:uncap x1$ >> ] ] + ; + selector: + [ [ x1 = id -> x1 + | x1 = INT -> not_impl loc "selector 1" ] ] + ; + tlabel: + [ [ x1 = selector; ":"; x2 = ctyp -> (loc, x1, False, x2) ] ] + ; + tuple_ty: + [ [ x1 = ctyp LEVEL "ty'"; "*"; x2 = tuple_ty -> [x1 :: x2] + | x1 = ctyp LEVEL "ty'" -> [x1] ] ] + ; + ctyp: + [ RIGHTA + [ x1 = ctyp; "->"; x2 = ctyp -> <:ctyp< $x1$ -> $x2$ >> ] + | [ x1 = ctyp; "*"; x2 = tuple_ty -> <:ctyp< ($list:[x1 :: x2]$) >> ] + | "ty'" + [ "'"; x1 = LIDENT -> <:ctyp< '$x1$ >> + | "'"; "'"; x1 = LIDENT -> <:ctyp< '$x1$ >> + | "{"; x1 = LIST1 tlabel SEP ","; "}" -> + if ocaml_records.val then <:ctyp< { $list:x1$ } >> + else + let list = List.map (fun (_, l, _, t) -> (l, t)) x1 in + <:ctyp< < $list:list$ > >> + | "{"; "}" -> not_impl loc "ty' 3" + | "("; x1 = ctyp; ","; x2 = LIST1 ctyp SEP ","; ")"; x3 = tycon -> + List.fold_left (fun t1 t2 -> <:ctyp< $t1$ $t2$ >>) x3 [x1 :: x2] + | "("; x1 = ctyp; ")" -> x1 + | x1 = ctyp; x2 = tycon -> <:ctyp< $x2$ $x1$ >> + | x1 = tycon -> x1 ] ] + ; + rule: + [ [ x1 = patt; "=>"; x2 = expr -> (x1, None, x2) ] ] + ; + elabel: + [ [ x1 = selector; "="; x2 = expr -> (<:patt< $lid:x1$ >>, x2) ] ] + ; + exp_ps: + [ [ x1 = expr -> x1 + | x1 = expr; ";"; x2 = exp_ps -> + <:expr< do { $list:[x1 :: get_seq x2]$ } >> ] ] + ; + expr: + [ [ "if"; x1 = expr; "then"; x2 = expr; "else"; x3 = expr -> + <:expr< if $x1$ then $x2$ else $x3$ >> + | "fn"; x1 = LIST1 rule SEP "|" -> <:expr< fun [$list:x1$] >> + | "case"; x1 = expr; "of"; x2 = LIST1 rule SEP "|" -> + <:expr< match $x1$ with [$list:x2$] >> + | "while"; x1 = expr; "do"; x2 = expr -> + <:expr< while $x1$ do { $x2$ } >> + | x1 = expr; "handle"; x2 = LIST1 rule SEP "|" -> + <:expr< try $x1$ with [$list:x2$] >> ] + | RIGHTA + [ "raise"; x1 = expr -> <:expr< raise $x1$ >> ] + | [ e1 = expr; ":="; e2 = expr -> <:expr< $e1$.val := $e2$ >> ] + | LEFTA + [ x1 = expr; "orelse"; x2 = expr -> <:expr< $x1$ || $x2$ >> ] + | LEFTA + [ x1 = expr; "andalso"; x2 = expr -> <:expr< $x1$ && $x2$ >> ] + | LEFTA + [ x1 = expr; ":"; x2 = ctyp -> <:expr< ($x1$ : $x2$) >> ] + | "4" NONA + [ x1 = expr; "<"; x2 = expr -> <:expr< $x1$ < $x2$ >> + | x1 = expr; ">"; x2 = expr -> <:expr< $x1$ > $x2$ >> + | x1 = expr; "<>"; x2 = expr -> <:expr< $x1$ <> $x2$ >> + | x1 = expr; "="; x2 = expr -> <:expr< $x1$ = $x2$ >> + | x1 = expr; ">="; x2 = expr -> <:expr< $x1$ >= $x2$ >> + | x1 = expr; "<="; x2 = expr -> <:expr< $x1$ <= $x2$ >> ] + | RIGHTA + [ x1 = expr; "^"; x2 = expr -> <:expr< $x1$ ^ $x2$ >> + | x1 = expr; "@"; x2 = expr -> <:expr< $x1$ @ $x2$ >> + | x1 = expr; "o"; x2 = expr -> <:expr< ooo $x1$ $x2$ >> ] + | "5" RIGHTA + [ x1 = expr; "::"; x2 = expr -> <:expr< [$x1$ :: $x2$] >> ] + | "6" LEFTA + [ x1 = expr; "+"; x2 = expr -> <:expr< $x1$ + $x2$ >> + | x1 = expr; "-"; x2 = expr -> <:expr< $x1$ - $x2$ >> ] + | "7" LEFTA + [ x1 = expr; "*"; x2 = expr -> <:expr< $x1$ * $x2$ >> + | x1 = expr; "/"; x2 = expr -> <:expr< $x1$ / $x2$ >> + | x1 = expr; "div"; x2 = expr -> <:expr< $x1$ / $x2$ >> + | x1 = expr; "mod"; x2 = expr -> <:expr< $x1$ mod $x2$ >> ] + | LEFTA + [ x1 = expr; x2 = expr -> <:expr< $x1$ $x2$ >> ] + | [ "#"; x1 = STRING -> <:expr< $chr:x1$ >> + | "#"; x1 = selector; x2 = expr -> + if ocaml_records.val then <:expr< $x2$ . $lid:x1$ >> + else <:expr< $x2$ # $lid:x1$ >> + | x1 = expr; "ocaml_record_access"; x2 = expr -> <:expr< $x1$ . $x2$ >> ] + | [ "!"; x1 = expr -> <:expr< $x1$ . val >> + | "~"; x1 = expr -> <:expr< - $x1$ >> ] + | [ x1 = LIDENT -> + match x1 with + [ "true" | "false" -> <:expr< $uid:String.capitalize x1$ >> + | "nil" -> <:expr< [] >> + | _ -> <:expr< $lid:x1$ >> ] + | x1 = UIDENT -> <:expr< $uid:x1$ >> + | x1 = UIDENT; "."; x2 = eqid -> <:expr< $uid:x1$ . $x2$ >> + | x1 = INT -> <:expr< $int:x1$ >> + | x1 = FLOAT -> <:expr< $flo:x1$ >> + | x1 = STRING -> <:expr< $str:x1$ >> + | "~"; x1 = INT -> <:expr< $int:"-"^x1$ >> + | i = op -> + if i = "::" then <:expr< fun (x, y) -> [x :: y] >> + else <:expr< fun (x, y) -> $lid:i$ x y >> + | "let"; x1 = ldecs; "in"; x2 = exp_ps; "end" -> + List.fold_right + (fun pel x2 -> + let loc = + match pel with + [ [(p, _) :: _] -> + (fst (MLast.loc_of_patt p), snd (MLast.loc_of_expr x2)) + | _ -> loc ] + in + match pel with + [ [(_, <:expr< fun [$list:_$] >>) :: _] -> + <:expr< let rec $list:pel$ in $x2$ >> + | _ -> + let pel = + List.map + (fun (p, e) -> + match p with + [ <:patt< { $list:lpl$ } >> -> + record_match_assoc (MLast.loc_of_patt p) lpl e + | _ -> (p, e) ]) + pel + in + <:expr< let $list:pel$ in $x2$ >> ]) + x1 x2 + | "{"; x1 = LIST1 elabel SEP ","; "}" -> record_expr loc x1 + | "["; "]" -> <:expr< [] >> + | "["; x1 = expr; "]" -> <:expr< [$x1$] >> + | "["; x1 = expr; ","; x2 = LIST1 SELF SEP ","; "]" -> + mklistexp loc None [x1 :: x2] + | "("; ")" -> <:expr< () >> + | "("; x1 = expr; ","; x2 = LIST1 SELF SEP ","; ")" -> + <:expr< ($list:[x1::x2]$) >> + | "("; x1 = expr; ";"; x2 = LIST1 SELF SEP ";"; ")" -> + <:expr< do { $list:[x1::x2]$ } >> + | "("; x1 = expr; ")" -> x1 ] ] + ; + fixity: + [ [ "infix" -> ("infix", None) + | "infix"; x1 = INT -> not_impl loc "fixity 2" + | "infixr" -> not_impl loc "fixity 3" + | "infixr"; x1 = INT -> ("infixr", Some x1) + | "nonfix" -> not_impl loc "fixity 5" ] ] + ; + patt: + [ [ x1 = patt; "as"; x2 = patt -> <:patt< ($x1$ as $x2$) >> ] + | LEFTA + [ x1 = patt; ":"; x2 = ctyp -> <:patt< ($x1$ : $x2$) >> ] + | RIGHTA + [ x1 = patt; "::"; x2 = patt -> <:patt< [$x1$ :: $x2$] >> ] + | [ x1 = patt; x2 = patt -> + match x1 with + [ <:patt< ref >> -> <:patt< {contents = $x2$} >> + | _ -> <:patt< $x1$ $x2$ >> ] ] + | "apat" + [ x1 = patt; "."; x2 = patt -> <:patt< $x1$ . $x2$ >> + | x1 = INT -> <:patt< $int:x1$ >> + | x1 = UIDENT -> <:patt< $uid:x1$ >> + | x1 = STRING -> <:patt< $str:x1$ >> + | "#"; x1 = STRING -> <:patt< $chr:x1$ >> + | "~"; x1 = INT -> <:patt< $int:"-"^x1$ >> + | LIDENT "nil" -> <:patt< [] >> + | LIDENT "false" -> <:patt< False >> + | LIDENT "true" -> <:patt< True >> + | x1 = id -> <:patt< $lid:x1$ >> + | x1 = op -> <:patt< $lid:x1$ >> + | "_" -> <:patt< _ >> + | "["; "]" -> <:patt< [] >> + | "["; x1 = patt; "]" -> <:patt< [$x1$] >> + | "["; x1 = patt; ","; x2 = LIST1 SELF SEP ","; "]" -> + mklistpat loc None [x1 :: x2] + | "{"; x1 = LIST1 plabel SEP ","; "}" -> <:patt< {$list:x1$} >> + | "("; ")" -> <:patt< () >> + | "("; x1 = patt; ","; x2 = LIST1 SELF SEP ","; ")" -> + <:patt< ($list:[x1::x2]$) >> + | "("; x1 = patt; ")" -> x1 ] ] + ; + plabel: + [ [ x1 = selector; "="; x2 = patt -> (<:patt< $lid:x1$ >>, x2) + | x1 = selector -> (<:patt< $lid:x1$ >>, <:patt< $lid:x1$ >>) ] ] + ; + vb: + [ [ "lazy"; x1 = patt; "="; x2 = expr -> not_impl loc "vb 1" + | x1 = patt; "="; x2 = expr -> (x1, x2) ] ] + ; + constrain: + [ [ -> None + | ":"; x1 = ctyp -> Some x1 ] ] + ; + fb: + [ [ xl = LIST1 clause SEP "|" -> function_of_clause_list loc xl + | "lazy"; x1 = LIST1 clause SEP "|" -> not_impl loc "fb 2" ] ] + ; + clause: + [ [ x1 = patt LEVEL "apat"; x2 = LIST1 (patt LEVEL "apat"); + x3 = constrain; "="; x4 = expr -> + let x1 = + match x1 with + [ <:patt< $lid:id$ >> -> (id, MLast.loc_of_patt x1) + | _ -> not_impl loc "clause 1" ] + in + (x1, x2, x3, x4) ] ] + ; + tb: + [ [ x1 = tyvars; x2 = idd; "="; x3 = ctyp -> + ((loc, uncap x2), x1, x3, []) + | x1 = tyvars; x2 = idd; "="; x3 = ctyp; "=="; x4 = dbrhs -> + let x4 = List.map (fun (loc, c, tl, _) -> (loc, c, tl)) x4 in + ((loc, uncap x2), x1, <:ctyp< $x3$ == [ $list:x4$ ] >>, []) ] ] + ; + tyvars: + [ [ "'"; x1 = LIDENT -> [(x1, (False, False))] + | "("; x1 = tyvar_pc; ")" -> x1 + | -> [] ] ] + ; + db1: + [ [ x1 = tyvars; x2 = ident; "="; x3 = dbrhs -> + let x2 = uncap x2 in + extract_label_types loc x2 x1 x3 + | "lazy"; x1 = tyvars; x2 = ident; "="; x3 = dbrhs -> + not_impl loc "db 2" ] ] + ; + db: + [ [ x1 = LIST1 db1 SEP "and" -> + List.fold_right (fun td tdl -> td @ tdl) x1 [] ] ] + ; + dbrhs: + [ [ x1 = LIST1 constr SEP "|" -> x1 + | "datatype"; x1 = tycon -> not_impl loc "dbrhs 2" ] ] + ; + constr: + [ [ x1 = op_op; x2 = ident -> (loc, x2, [], None) + | x1 = op_op; x2 = ident; "of"; x3 = ctyp -> + match x3 with + [ <:ctyp< {$list:_$} >> -> (loc, x2, [], Some x3) + | _ -> (loc, x2, [x3], None) ] ] ] + ; + eb: + [ [ x1 = op_op; x2 = ident -> (x2, [], []) + | x1 = op_op; x2 = ident; "of"; x3 = ctyp -> (x2, [x3], []) + | x1 = op_op; x2 = ident; "="; x3 = sqid -> (x2, [], x3) ] ] + ; + ldec1: + [ [ "val"; x1 = LIST1 vb SEP "and" -> x1 + | "fun"; x1 = LIST1 fb SEP "and" -> x1 ] ] + ; + ldecs: + [ [ -> [] + | x1 = ldec1; x2 = ldecs -> [x1 :: x2] + | ";"; x1 = ldecs -> x1 + | "local"; x1 = ldecs; "in"; x2 = ldecs; "end"; x3 = ldecs -> + not_impl loc "ldecs 4" ] ] + ; + spec_s: + [ [ -> [] + | x1 = spec; x2 = spec_s -> [x1 :: x2] + | ";"; x1 = spec_s -> x1 ] ] + ; + spec: + [ [ "structure"; x1 = LIST1 strspec SEP "and" -> sig_declare loc x1 + | "functor"; x1 = LIST1 fctspec SEP "and" -> sig_declare loc x1 + | "datatype"; x1 = db -> <:sig_item< type $list:x1$ >> + | "type"; x1 = LIST1 tyspec SEP "and" -> <:sig_item< type $list:x1$ >> + | "eqtype"; x1 = LIST1 tyspec SEP "and" -> <:sig_item< type $list:x1$ >> + | "val"; x1 = LIST1 valspec SEP "and" -> sig_declare loc x1 + | "exception"; x1 = LIST1 exnspec SEP "and" -> sig_declare loc x1 + | "sharing"; x1 = LIST1 sharespec SEP "and" -> <:sig_item< declare end >> + | "include"; x1 = module_type -> <:sig_item< include $x1$ >> ] ] + ; + sig_item: + [ [ x = spec -> x ] ] + ; + strspec: + [ [ x1 = ident; ":"; x2 = module_type; x3 = LIST0 sharing_def -> + let x2 = + List.fold_left + (fun mt sdl -> + List.fold_right + (fun spl mt -> + match spl with + [ Right ([m1], m2) -> + let (m1, m2) = + match m2 with + [ <:module_expr< $uid:x$ . $_$ >> -> + if x = x1 then (m2, m1) else (m1, m2) + | _ -> (m1, m2) ] + in + let m1 = + loop m1 where rec loop = + fun + [ <:module_expr< $uid:x$ >> -> x + | <:module_expr< $uid:x$ . $y$ >> -> loop y + | _ -> not_impl loc "strspec 2" ] + in + <:module_type< $mt$ with module $[m1]$ = $m2$ >> + | _ -> not_impl loc "strspec 1" ]) + sdl mt) + x2 x3 + in + <:sig_item< module $x1$ : $x2$ >> ] ] + ; + sharing_def: + [ [ "sharing"; x3 = LIST1 sharespec SEP "and" -> x3 ] ] + ; + fctspec: + [ [ x1 = ident; x2 = fsig -> <:sig_item< module $x1$ : $x2$ >> ] ] + ; + tyspec: + [ [ x1 = tyvars; x2 = idd -> + ((loc, uncap x2), x1, <:ctyp< '$choose_tvar x1$ >>, []) + | x1 = tyvars; x2 = idd; "="; x3 = ctyp -> + ((loc, uncap x2), x1, x3, []) ] ] + ; + valspec: + [ [ x1 = op_op; x2 = ident; ":"; x3 = ctyp -> + <:sig_item< value $x2$ : $x3$ >> ] ] + ; + exnspec: + [ [ x1 = ident -> <:sig_item< exception $x1$ >> + | x1 = ident; "of"; x2 = ctyp -> + <:sig_item< exception $x1$ of $x2$ >> ] ] + ; + sharespec: + [ [ "type"; x1 = patheqn -> Left x1 + | x1 = patheqn -> Right x1 ] ] + ; + patheqn: + [ [ l = patheqn1 -> l ] ] + ; + patheqn1: + [ [ (l, y) = patheqn1; "="; x = qid -> ([y :: l], x) + | x = qid -> ([], x) ] ] + ; + whspec: + [ [ "type"; x1 = tyvars; x2 = sqid; "="; x3 = ctyp -> + MLast.WcTyp loc x2 x1 x3 + | x1 = sqid; "="; x2 = qid -> MLast.WcMod loc x1 x2 ] ] + ; + module_type: + [ [ x1 = ident -> <:module_type< $uid:x1$ >> + | "sig"; x1 = spec_s; "end" -> <:module_type< sig $list:x1$ end >> + | x1 = module_type; "where"; x2 = LIST1 whspec SEP "and" -> + <:module_type< $x1$ with $list:x2$ >> ] ] + ; + sigconstraint_op: + [ [ -> None + | ":"; x1 = module_type -> Some x1 + | ":>"; x1 = module_type -> not_impl loc "sigconstraint_op 3" ] ] + ; + sigb: + [ [ x1 = ident; "="; x2 = module_type -> + <:str_item< module type $x1$ = $x2$ >> ] ] + ; + fsig: + [ [ ":"; x1 = ident -> not_impl loc "fsig 1" + | x1 = fparamList; ":"; x2 = module_type -> not_impl loc "fsig 2" ] ] + ; + module_expr: + [ [ x1 = qid -> x1 + | "struct"; x1 = strdecs; "end" -> <:module_expr< struct $list:x1$ end >> + | x1 = qid; x2 = arg_fct -> + match x2 with + [ Left [] -> x1 + | Left x2 -> <:module_expr< $x1$ (struct $list:x2$ end) >> + | Right x2 -> <:module_expr< $x1$ $x2$ >> ] + | "let"; x1 = strdecs; "in"; x2 = module_expr; "end" -> + not_impl loc "str 4" + | x1 = module_expr; ":"; x2 = module_type -> not_impl loc "str 5" + | x1 = module_expr; x2 = ":>"; x3 = module_type -> + not_impl loc "str 6" ] ] + ; + arg_fct: + [ [ "("; x1 = strdecs; ")"; x2 = arg_fct -> not_impl loc "arg_fct 1" + | "("; x1 = module_expr; ")"; x2 = arg_fct -> not_impl loc "arg_fct 2" + | "("; x1 = module_expr; ")" -> Right x1 + | "("; x2 = strdecs; ")" -> Left x2 ] ] + ; + strdecs: + [ [ x1 = str_item LEVEL "strdec"; x2 = strdecs -> [x1 :: x2] + | ";"; x1 = strdecs -> x1 + | -> [] ] ] + ; + str_item: + [ [ "signature"; x1 = LIST1 sigb SEP "and" -> str_declare loc x1 + | "funsig"; x1 = fsigb -> not_impl loc "sdec 3" ] + | "strdec" + [ "structure"; x1 = LIST1 strb SEP "and" -> str_declare loc x1 + | "functor"; x1 = LIST1 fctb SEP "and" -> str_declare loc x1 + | "local"; x1 = sdecs; "in"; x2 = sdecs; "end" -> + make_local loc x1 x2 ] + | [ "val"; x1 = LIST1 vb SEP "and" -> <:str_item< value $list:x1$ >> + | "val"; x1 = tyvarseq; x3 = LIST1 vb SEP "and" -> + not_impl loc "ldec 2" + | "val"; "rec"; x1 = rvb -> not_impl loc "ldec 3" + | "val"; "rec"; x1 = tyvarseq; x2 = rvb -> not_impl loc "ldec 4" + | "fun"; x1 = LIST1 fb SEP "and" -> <:str_item< value rec $list:x1$ >> + | "fun"; x1 = tyvarseq; x2 = fb -> not_impl loc "ldec 6" + | "type"; x1 = LIST1 tb SEP "and" -> <:str_item< type $list:x1$ >> + | "datatype"; x1 = db -> <:str_item< type $list:x1$ >> + | "datatype"; x1 = db; "withtype"; x2 = tb -> + <:str_item< type $list:x1 @ [x2]$ >> + | "abstype"; x1 = db; "with"; x2 = ldecs; "end" -> not_impl loc "ldec 10" + | "abstype"; x1 = db; "withtype"; x2 = tb; "with"; x3 = ldecs; "end" -> + not_impl loc "ldec 11" + | "exception"; x1 = LIST1 eb SEP "and" -> + let dl = + List.map + (fun (s, tl, eqn) -> + <:str_item< exception $s$ of $list:tl$ = $eqn$ >>) + x1 + in + str_declare loc dl + | "open"; x1 = LIST1 sqid -> + let dl = List.map (fun sl -> <:str_item< open $sl$ >>) x1 in + str_declare loc dl + | LIDENT "use"; s = STRING -> + <:str_item< #use $str:s$ >> + | x1 = fixity; list = LIST1 idd -> + match x1 with + [ ("infixr", Some n) -> + do { + List.iter + (fun s -> + EXTEND + expr: LEVEL $n$ + [ [ x1 = expr; $s$; x2 = expr -> + <:expr< $lid:s$ ($x1$, $x2$) >> ] ] + ; + END) + list; + str_declare loc [] + } + | ("infix", None) -> + do { + List.iter + (fun s -> + EXTEND + expr: LEVEL "4" + [ [ x1 = expr; $s$; x2 = expr -> + <:expr< $lid:s$ ($x1$, $x2$) >> ] ] + ; + clause: + [ [ x1 = patt LEVEL "apat"; $s$; + x2 = patt LEVEL "apat"; "="; x4 = expr -> + ((s, loc), [<:patt< ($x1$, $x2$) >>], + None, x4) ] ] + ; + END) + list; + str_declare loc [] + } + | _ -> not_impl loc "ldec 14" ] + | "overload"; x1 = ident; ":"; x2 = ctyp; "as"; x3 = exp_pa -> + not_impl loc "ldec 15" + | x = expr -> <:str_item< $exp:x$ >> ] ] + ; + sdec: + [ [ x = str_item -> x ] ] + ; + strb: + [ [ x1 = ident; x2 = sigconstraint_op; "="; x3 = module_expr -> + let x3 = + match x2 with + [ Some x2 -> <:module_expr< ($x3$ : $x2$) >> + | None -> x3 ] + in + <:str_item< module $x1$ = $x3$ >> ] ] + ; + fparam: + [ [ x1 = idd; ":"; x2 = module_type -> [<:sig_item< module $x1$ : $x2$ >>] + | x1 = spec_s -> x1 ] ] + ; + fparamList: + [ [ "("; x1 = fparam; ")" -> [x1] + | "("; x1 = fparam; ")"; x2 = fparamList -> [x1 :: x2] ] ] + ; + fctb: + [ [ x1 = ident; x2 = fparamList; x3 = sigconstraint_op; "="; + x4 = module_expr -> + let list = List.flatten x2 in + let x4 = + if list = [] then x4 + else + match x4 with + [ <:module_expr< struct $list:list$ end >> -> + let si = + let loc = (Token.nowhere, Token.nowhere) in + <:str_item< open AAA >> in + <:module_expr< struct $list:[si :: list]$ end >> + | _ -> not_impl loc "fctb 1" ] + in + let x4 = + match x3 with + [ Some x3 -> <:module_expr< ($x4$ : $x3$) >> + | None -> x4 ] + in + let x4 = + if list = [] then x4 + else + let mt = + let loc = + (fst (MLast.loc_of_sig_item (List.hd list)), + snd (MLast.loc_of_sig_item (List.hd (List.rev list)))) + in + <:module_type< sig $list:list$ end >> + in + <:module_expr< functor (AAA : $mt$) -> $x4$ >> + in + <:str_item< module $x1$ = $x4$ >> + | x1 = ident; x2 = fsigconstraint_op; "="; x3 = fct_exp -> + not_impl loc "fctb 2" ] ] + ; + interdec: + [ [ x = LIST1 [ s = str_item; OPT ";" -> (s, loc) ] -> (x, False) + | x = expr; OPT ";" -> not_impl loc "interdec 2" ] ] + ; +END; + +Pcaml.add_option "-records" (Arg.Set ocaml_records) + "Convert record into OCaml records, instead of objects"; diff --git a/camlp4/unmaintained/sml/smllib.sml b/camlp4/unmaintained/sml/smllib.sml new file mode 100644 index 00000000..5ecd0937 --- /dev/null +++ b/camlp4/unmaintained/sml/smllib.sml @@ -0,0 +1,395 @@ +(***********************************************************************) +(* *) +(* Camlp4 *) +(* *) +(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *) +(* *) +(* Copyright 2002 Institut National de Recherche en Informatique et *) +(* Automatique. Distributed only by permission. *) +(* *) +(***********************************************************************) + + + +datatype 'a option = SOME of 'a | NONE +exception Fail of string +exception Domain +exception Subscript +type 'a vector = 'a array + +structure OCaml = + struct + structure List = List + structure String = String + end + +structure Time = + struct + datatype time = TIME of { sec : int, usec : int } + fun toString _ = failwith "not implemented Time.toString" + fun now _ = failwith "not implemented Time.now" + end + +datatype cpu_timer = + CPUT of { gc : Time.time, sys : Time.time, usr : Time.time } + +datatype real_timer = + RealT of Time.time + +structure Char = + struct + val ord = Char.code + end + +structure General = + struct + datatype order = LESS | EQUAL | GREATER + end +type order = General.order == LESS | EQUAL | GREATER + +structure OS = + struct + exception SysErr + structure Path = + struct + fun dir s = + let val r = Filename.dirname s in + if r = "." then "" else r + end + val file = Filename.basename + fun ext s = + let fun loop i = + if i < 0 then NONE + else if String.get s i = #"." then + let val len = String.length s - i - 1 in + if len = 0 then NONE else SOME (String.sub s (i + 1) len) + end + else loop (i - 1) + in + loop (String.length s - 1) + end + fun splitDirFile s = + {dir = Filename.dirname s, + file = Filename.basename s} + fun joinDirFile x = + let val {dir,file} = x in Filename.concat dir file end + end + structure FileSys = + struct + datatype access_mode = A_READ | A_WRITE | A_EXEC + val chDir = Sys.chdir + fun isDir s = + (Unix.stat s) ocaml_record_access Unix.st_kind = Unix.S_DIR + handle Unix.Unix_error _ => raise SysErr + fun access (s, accs) = + let val st = Unix.stat s + val prm = st ocaml_record_access Unix.st_perm + val prm = + if st ocaml_record_access Unix.st_uid = Unix.getuid () then + lsr prm 6 + else if st ocaml_record_access Unix.st_uid = Unix.getgid () + then + lsr prm 3 + else prm + val rf = + if List.mem A_READ accs then land prm 4 <> 0 else true + val wf = + if List.mem A_WRITE accs then land prm 2 <> 0 else true + val xf = + if List.mem A_EXEC accs then land prm 1 <> 0 else true + in + rf andalso wf andalso xf + end + handle Unix.Unix_error (_, f, _) => + if f = "stat" then false else raise SysErr + end + structure Process = + struct + fun system s = (flush stdout; flush stderr; Sys.command s) + fun getEnv s = SOME (Sys.getenv s) handle Not_found => NONE + val success = 0 + end + end + +exception SysErr = OS.SysErr + +structure IO = + struct + exception Io of {cause:exn, function:string, name:string} + end + +structure TextIO = + struct + type instream = in_channel * char option option ref + type outstream = out_channel + type elem = char + type vector = string + fun openIn fname = + (open_in fname, ref NONE) handle exn => + raise IO.Io {cause = exn, function = "openIn", name = fname} + val openOut = open_out + fun closeIn (ic, ahc) = (ahc := SOME NONE; close_in ic) + val closeOut = close_out + val stdIn = (stdin, ref (NONE : char option option)) + fun endOfStream (ic, _) = pos_in ic = in_channel_length ic + fun inputLine (ic, ahc) = + case !ahc of + NONE => + (input_line ic ^ "\n" handle End_of_file => (ahc := SOME NONE; "")) + | SOME NONE => "" + | SOME (SOME c) => + (ahc := NONE; + if c = #"\n" then "\n" + else + String.make 1 c ^ input_line ic ^ "\n" handle + End_of_file => (ahc := SOME NONE; "")) + fun input1 (ic, ahc) = + case !ahc of + NONE => + (SOME (input_char ic) handle End_of_file => (ahc := SOME NONE; NONE)) + | SOME NONE => NONE + | SOME x => (ahc := NONE; x) + fun inputN (ins, n) = + let fun loop n = + if n <= 0 then "" + else + case input1 ins of + SOME c => String.make 1 c ^ loop (n - 1) + | NONE => "" + in + loop n + end + fun output (oc, v) = output_string oc v + fun inputAll ic = failwith "not implemented TextIO.inputAll" + fun lookahead (ic, ahc) = + case !ahc of + NONE => let val r = SOME (input_char ic) in ahc := SOME r; r end + | SOME x => x + fun print s = (print_string s; flush stdout) + end + +structure Timer = + struct + fun startRealTimer () = failwith "not implemented Timer.startRealTimer" + fun startCPUTimer () = failwith "not implemented Timer.startCPUTimer" + fun checkRealTimer _ = failwith "not implemented Timer.checkRealTimer" + fun checkCPUTimer _ = failwith "not implemented Timer.checkCPUTimer" + end + +structure Date = + struct + datatype month = + Jan | Feb | Mar | Apr | May | Jun | Jul | Sep | Oct | Nov | Dec + datatype wday = Sun | Mon | Tue | Wed | Thu | Fri | Sat + datatype date = + DATE of + {day : int, hour : int, isDst : bool option, minute : int, + month : month, offset : int option, second : int, wday : wday, + yday : int, year : int} + fun fmt _ _ = failwith "not implemented Date.fmt" + fun fromTimeLocal _ = failwith "not implemented Date.fromTimeLocal" + end + +structure Posix = + struct + structure ProcEnv = + struct + fun getenv s = SOME (Sys.getenv s) handle Not_found => NONE + end + end + +structure SMLofNJ = + struct + fun exportML s = failwith ("not implemented exportML " ^ s) + end + +fun null x = x = [] +fun explode s = + let fun loop i = + if i = String.length s then [] + else String.get s i :: loop (i + 1) + in + loop 0 + end + +val app = List.iter +fun implode [] = "" + | implode (c :: l) = String.make 1 c ^ implode l + +fun ooo f g x = f (g x) + +structure Array = + struct + fun array (len, v) = Array.create len v + fun sub _ = failwith "not implemented Array.sub" + fun update _ = failwith "not implemented Array.update" + (* for make the profiler work *) + val set = Array.set + val get = Array.get + end + +structure Vector = + struct + fun tabulate _ = failwith "not implemented Vector.tabulate" + fun sub _ = failwith "not implemented Vector.sub" + end + +structure Bool = + struct + val toString = string_of_bool + end + +structure String = + struct + val size = String.length + fun substring (s, beg, len) = + String.sub s beg len handle Invalid_argument _ => raise Subscript + val concat = String.concat "" + fun sub (s, i) = String.get s i + val str = String.make 1 + fun compare (s1, s2) = + if s1 < s2 then LESS + else if s1 > s2 then GREATER + else EQUAL + fun isPrefix s1 s2 = + let fun loop i1 i2 = + if i1 >= String.length s1 then true + else if i2 >= String.length s2 then false + else if String.get s1 i1 = String.get s2 i2 then loop (i1 + 1) (i2 + 1) + else false + in + loop 0 0 + end + fun tokens p s = + let fun loop tok i = + if i >= String.length s then + if tok = "" then [] else [tok] + else if p (String.get s i) then + if tok <> "" then tok :: loop "" (i + 1) + else loop "" (i + 1) + else loop (tok ^ String.make 1 (String.get s i)) (i + 1) + in + loop "" 0 + end + fun extract _ = failwith "not implemented String.extract" + end + +structure Substring = + struct + type substring = string * int * int + fun string (s : substring) = String.substring s + fun all s : substring = (s, 0, String.size s) + fun splitl f ((s, beg, len) : substring) : substring * substring = + let fun loop di = + if di = len then ((s, beg, len), (s, 0, 0)) + else if f (String.sub (s, beg + di)) then loop (di + 1) + else ((s, beg, di), (s, beg + di, len - di)) + in + loop 0 + end + fun getc (s, i, len) = + if len > 0 andalso i < String.size s then + SOME (String.sub (s, i), (s, i+1, len-1)) + else NONE + fun slice _ = failwith "not implemented: Substring.slice" + fun isEmpty (s, beg, len) = len = 0 + fun concat sl = String.concat (List.map string sl) + end +type substring = Substring.substring + +structure StringCvt = + struct + datatype radix = BIN | OCT | DEC | HEX + type ('a, 'b) reader = 'b -> ('a * 'b) option + end + +structure ListPair = + struct + fun zip (a1::l1, a2::l2) = (a1, a2) :: zip (l1, l2) + | zip _ = [] + val unzip = List.split + fun all f (x1 :: l1, x2 :: l2) = f (x1, x2) andalso all f (l1, l2) + | all _ _ = true + fun map f (a1::l1, a2::l2) = + let val r = f (a1, a2) in r :: map f (l1, l2) end + | map _ _ = [] + end + +structure ListMergeSort = + struct + fun uniqueSort cmp l = + List.sort + (fn x => fn y => + case cmp (x, y) of + LESS => ~1 + | EQUAL => 0 + | GREATER => 1) + l + end + +structure List = + struct + exception Empty + fun hd [] = raise Empty + | hd (x :: l) = x + fun tl [] = raise Empty + | tl (x :: l) = l + fun foldr f a l = + let fun loop a [] = a + | loop a (x :: l) = loop (f (x, a)) l + in + loop a (List.rev l) + end + fun foldl f a l = List.fold_left (fn a => fn x => f (x, a)) a l + val concat = List.flatten + val exists = List.exists + val filter = List.filter + val length = List.length + val map = List.map + val rev = List.rev + val all = List.for_all + fun find f [] = NONE + | find f (x :: l) = if f x then SOME x else find f l + fun last s = + case List.rev s of + [] => raise Empty + | x :: _ => x + fun take _ = failwith "not implemented: List.take" + fun partition _ = failwith "not implemented: List.partition" + fun mapPartial f [] = [] + | mapPartial f (x :: l) = + case f x of + NONE => mapPartial f l + | SOME y => y :: mapPartial f l + fun op @ l1 l2 = List.rev_append (List.rev l1) l2 + end + +structure Int = + struct + type int1 = int + type int = int1 + val toString = string_of_int + fun fromString s = SOME (int_of_string s) handle Failure _ => NONE + fun min (x, y) = if x < y then x else y + fun max (x, y) = if x > y then x else y + fun scan radix getc src = failwith "not impl: Int.scan" + end + +val foldr = List.foldr +val exists = List.exists +val size = String.size +val substring = String.substring +val concat = String.concat +val length = List.length +val op @ = List.op @ +val hd = List.hd +val tl = List.tl +val map = List.map +val rev = List.rev +val use_hook = ref (fn (s : string) => (failwith "no defined directive use" : unit)) +fun use s = !use_hook s +fun isSome (SOME _) = true + | isSome NONE = false +fun valOf (SOME x) = x + | valOf NONE = failwith "valOf" +val print = TextIO.print diff --git a/configure b/configure index 37d46c2b..9be51995 100755 --- a/configure +++ b/configure @@ -13,7 +13,7 @@ # # ######################################################################### -# $Id: configure 11064 2011-06-04 08:13:25Z xleroy $ +# $Id: configure 11110 2011-07-04 21:15:01Z doligez $ configure_options="$*" prefix=/usr/local @@ -1537,6 +1537,10 @@ if test $has_tk = true; then fi fi +case "$host" in + *-*-cygwin*) tk_libs="$tk_libs -lws2_32";; +esac + if test $has_tk = true; then if sh ./hasgot $tk_libs $tk_x11_libs $tkauxlibs Tk_SetGrid; then echo "Tcl/Tk libraries found." diff --git a/ocamlbuild/manual/.cvsignore b/ocamlbuild/manual/.cvsignore new file mode 100644 index 00000000..a7bf093d --- /dev/null +++ b/ocamlbuild/manual/.cvsignore @@ -0,0 +1,6 @@ +*.aux +*.haux +*.html +*.htoc +*.log +*.pdf diff --git a/ocamlbuild/manual/Makefile b/ocamlbuild/manual/Makefile new file mode 100644 index 00000000..055d42e7 --- /dev/null +++ b/ocamlbuild/manual/Makefile @@ -0,0 +1,15 @@ +# Makefile + +all: manual.pdf manual.html + +%.pdf: %.tex + pdflatex $< + pdflatex $< + +%.html: %.tex manual.hva + hevea -fix -O manual.hva $< + +.PHONY: clean + +clean: + rm -f *.pdf *.log *.aux *.ps *.dvi manual.h{tml,aux,toc} diff --git a/ocamlbuild/manual/manual.hva b/ocamlbuild/manual/manual.hva new file mode 100644 index 00000000..d175fdb9 --- /dev/null +++ b/ocamlbuild/manual/manual.hva @@ -0,0 +1 @@ +\newcommand{\mathscr}[1]{{\mathcal{#1}}} \ No newline at end of file diff --git a/ocamlbuild/manual/manual.tex b/ocamlbuild/manual/manual.tex new file mode 100644 index 00000000..62d90045 --- /dev/null +++ b/ocamlbuild/manual/manual.tex @@ -0,0 +1,1054 @@ +% -*- LaTeX -*- +%(*** preamble +\documentclass[9pt]{article} +\usepackage[utf8]{inputenc} +\usepackage{palatino} +\usepackage{mathrsfs} +\usepackage{xspace} +\usepackage[T1]{fontenc} +\usepackage[english]{babel} +\usepackage[a4paper,lmargin=1cm,rmargin=1cm,tmargin=1cm,bmargin=2cm]{geometry} +\newcommand{\ocb}{\texttt{ocamlbuild}\xspace} +\newcommand{\tags}{\texttt{\_tags}\xspace} +%***) +%(*** title +\begin{document} +\title{The \ocb users manual} +\author{Berke \textsc{Durak}, Nicolas \textsc{Pouillard}} +\date{February 2007} +\maketitle +%***) +%(*** abstract +\begin{abstract} +\ocb is a tool automating the compilation of most OCaml projects with minimal +user input. Its use is not restricted to projects having a simple structure -- +the extra effort needed to make it work with the more complex projects is in +reasonable proportion with their added complexity. In practice, one will use a +set of small text files, and, if needed, an OCaml compilation module that can +fine-tune the behaviour and define custom rules. +\end{abstract} +%***) +%(*** Features of ocamlbuild +\section{Features of \ocb} +{\em This section is intended to read like a sales brochure or a datasheet.} + +\begin{itemize} +\item Built-in compilation rules for OCaml projects handle all the nasty cases: +native and byte-code, missing \texttt{.mli} files, preprocessor rules, +libraries, package (-pack) debugging and profiling flags, C stubs. +\item Plugin mechanism for writing compilation rules and actions in a real programming language, +OCaml itself. +\item Automatic inference of dependencies. +\item Correct handling of dynamically discovered dependencies. +\item Object files and other temporary files are created in a specific directory, leaving your main directory uncluttered. +\item Sanity checks ensure that object files are where they are supposed to be: in the build directory. +\item Regular projects are built using a single command with no extra files. +\item Parallel compilation to speed up things on multi-core systems. +\item Sophisticated display mode to keep your screen free of boring and repetitive compilation message +while giving you important progress information in a glimpse, and correctly multiplexing the error messages. +\item Tags and flags provide a concise and convenient mechanism for automatic selection of compilation, preprocessing and +other options. +\item Extended shell-like glob patterns, that can be combined using boolean operators, +allow you to concisely define the tags that apply to a given file. +\item Mechanisms for defining the mutual visibility of subdirectories. +\item Cache mechanism avoiding unnecessary compilations where reasonably computable. +\end{itemize} +%***) +%(*** Limitations +\section{Limitations} +{\em Not perfect nor complete yet, but already pretty damn useful.} + +We were not expecting to write the ultimate compilation tool in a few man-months, however we believe we have +a tool that solves many compilation problems, especially our own, in a satisfactory way. Hence there are a +lot of missing features, incomplete options and hideous bugs lurking in \ocb, and we hope that the OCaml community +will find our first try at \ocb useful and hopefully help it grow into a tool that satisfies most needs of most users +by providing feedback, bug reports and patches. + +The plugin API maybe somewhat lacking in maturity, as it has only been tested +by a few people. We believe a good API can only evolve under pressure from +many peers and the courage to rewrite things cleanly when time is ripe by the +developers. Most of the important functions a user will need are encapsulated +in the plugin API, which is the \texttt{Ocamlbuild\_plugin} module pack. We +intend to keep that API backwards compatible. It may happen that intricate +projects need features not available in that module -- you may then use +functions or values directly from the core \ocb modules. We ask you to report +such usage to the authors so that we may make the necessary changes to the API; +you may also want to isolate calls to the non-API parts of the \ocb library +from the rest of your plugin to be able to keep the later when incompatible +changes arise. + +The way that \ocb handles the command-line options, the \tags file, +the target names, names of the tags, and so on, are not expected to change in +incompatible ways. We intend to keep a project that compiles without a plugin +compilable without modifications in the future. +%***) +%(*** Using ocamlbuild +\section{Using \ocb} +{\em Learn how to use \ocb with short, specific, straight-to-the-point examples.} + +The amount of time and effort spent on the compilation process of a project +should be proportionate to that spent on the project itself. It should be easy +to set up a small project, maybe a little harder for a medium-sized project, +and it may take some more time, but not too much, for a big project. Ideally +setting up a big project would be as easy as setting up a small project. However, +as projects grow, modularization techniques start to be used, and the probability +of using meta programming or multiple programming languages increases, thus making +the compilation process more delicate. + +\ocb is intended to be very easy to use for projects, large or small, with a simple +compilation process: typing +\texttt{ocamlbuild foo.native} should be enough to compile the native version +of a program whose top module is \texttt{foo.ml} and whose dependencies are in +the same directory. As your project gets more complex, you will gradually +start to use command-line options to specify libraries to link with, then +configuration files, ultimately culminating in a custom OCaml plugin for +complex projects with arbitrary dependencies and actions. + +%(*** Hygiene *) +\subsection{Hygiene \& where is my code ?} +Your code is in the \texttt{\_build} directory, but \ocb automatically creates +a symbolic link to the executables it produces in the current directory. +\ocb copies the source files and compiles them in a separate directory +which is \texttt{\_build} by default. + +For \ocb, any file that is not in the build directory is a source file. +It is not unreasonable to think that some users may have bought binary object files +they keep in their project directory. Usually binary files cluttering the project +directory are due to previous builds using other systems. \ocb has so-called +``hygiene'' rules that state that object files (\texttt{.cmo}, \texttt{.cmi}, +or \texttt{.o} files, for instance) must not appear outside of the build +directory. These rules are enforced at startup; any violations will be reported +and \ocb will exit. You must then remove these files by hand or run, with caution, +the script \texttt{sanitize.sh}, which is generated in your source directory. +This script will contain commands to remove them for you. + +To disable these checks, you can use the \texttt{-no-hygiene} flag. If you have +files that must elude the hygiene squad, just tag them with \texttt{precious} +or \texttt{not\_hygienic}. +%***) +%(*** Hello, world ! +\subsection{Hello, world !} +Assuming we are in a directory named \texttt{example1} containing one file \texttt{hello.ml} +whose contents are +\begin{verbatim} +let _ = + Printf.printf "Hello, %s ! My name is %s\n" + (if Array.length Sys.argv > 1 then Sys.argv.(1) else "stranger") + Sys.argv.(0) +;; +\end{verbatim} +we can compile and link it into a native executable by invoking \texttt{ocamlbuild hello.native}. +Here, \texttt{hello} is the basename of the top-level module and \texttt{native} is an extension used +by \ocb to denote native code executables. +\begin{verbatim} +% ls +hello.ml +% ocamlbuild hello.native +Finished, 4 targets (0 cached) in 00:00:00. +% ls -l +total 12 +drwxrwx--- 2 linus gallium 4096 2007-01-17 16:24 _build/ +-rw-rw---- 1 linus gallium 43 2007-01-17 16:23 hello.ml +lrwxrwxrwx 1 linus gallium 19 2007-01-17 16:24 hello.native -> _build/hello.native* +\end{verbatim} +What's this funny \texttt{\_build} directory ? Well that's where \ocb does its dirty work +of compiling. You usually won't have to look very often into this directory. Source files are be copied +into \texttt{\_build} and this is where the compilers will be run. Various cache files are also stored +there. Its contents may look like this: +\begin{verbatim} +% ls -l _build +total 208 +-rw-rw---- 1 linus gallium 337 2007-01-17 16:24 _digests +-rw-rw---- 1 linus gallium 191 2007-01-17 16:24 hello.cmi +-rw-rw---- 1 linus gallium 262 2007-01-17 16:24 hello.cmo +-rw-rw---- 1 linus gallium 225 2007-01-17 16:24 hello.cmx +-rw-rw---- 1 linus gallium 43 2007-01-17 16:23 hello.ml +-rw-rw---- 1 linus gallium 17 2007-01-17 16:24 hello.ml.depends +-rwxrwx--- 1 linus gallium 173528 2007-01-17 16:24 hello.native* +-rw-rw---- 1 linus gallium 936 2007-01-17 16:24 hello.o +-rw-rw---- 1 linus gallium 22 2007-01-17 16:24 ocamlc.where +\end{verbatim} +%***) +%(*** Executing my code +\subsection{Executing my code} +You can execute your code the old-fashioned way (\texttt{./hello.native}). +You may also type +\begin{verbatim} +ocamlbuild hello.native -- Caesar +\end{verbatim} +and it will compile and then run \texttt{hello.native} with the arguments following \texttt{-{}-}, +which should display: +\begin{verbatim} +% ocamlbuild hello.native -- Caesar +Finished, 4 targets (0 cached) in 00:00:00. +Hello, Caesar ! My name is _build/hello.native +\end{verbatim} +%***) +%(*** The log file, verbosity and debugging +\subsection{The log file, verbosity and debugging} +By default, if you run \ocb on a terminal, it will use some ANSI escape sequences +to display a nice, one-line progress indicator. To see what commands \ocb has actually run, +you can check the contents of the \texttt{\_build/\_log} file. To change the name of the +log file or to disable logging, use the \texttt{-log } or \texttt{-no-log} options. +Note that the log file is truncated at each execution of \ocb. + +The log file contains all the external commands that \ocb ran or intended to +run along with the target name and the computed tags. With the +\texttt{-verbose } option, \ocb will also write more or less useful +debugging information; a verbosity level of $1$ (which can also be specified +using the \texttt{-verbose} switch) prints generally useful information; higher +levels produce much more output. +%***) +%(*** Cleaning +\subsection{Cleaning} +\ocb may leave a \texttt{\_build} directory and symbolic links to executables in +that directory (unless when using -no-links). All of these can be removed safely +by hand, or by invoking \ocb with the \texttt{-clean} flag. +%***) +%(*** Where and how to run \ocb +\subsection{Where and how to run \ocb ?} +An important point is that \ocb must be invoked from the root of the project, +even if this project has multiple, nested subdirectories. This is because \ocb +likes to store the object files in a single \texttt{\_build} directory. You +can change the name of that directory with the \texttt{-build-dir} option. + +\ocb can be either invoked manually from the UNIX or Windows shell, or +automatically from a build script or a Makefile. Unless run with the +\texttt{-no-hygiene} option, there is the possibility that \ocb will prompt the +user for a response. By default, on UNIX systems, if \ocb senses that the +standard output is a terminal, it will use a nice progress indicator using ANSI +codes, instrumenting the output of the processes it spawns to have a consistent +display. Under non-UNIX systems, or if the standard output is not a terminal, +it will run in classic mode where it will echo the executed commands on its +standard output. This selection can be overridden with the \texttt{-classic-display} option. +%***) +%(*** Dependencies +\subsection{Dependencies} +{\em Dependencies are automatically discovered.} + +Most of the value of \ocb lies in the fact that it often needs no extra +information to compile a project besides the name of the top-level module. +\ocb calls \texttt{ocamldep} to automatically find the dependencies of any +modules it wants to compile. These dependencies are dynamically incorporated +in the dependency graph, something \texttt{make} cannot do. +For instance, let's add a module \texttt{Greet} that implements various ways of +greeting people. +\begin{verbatim} +% cat greet.ml +type how = Nicely | Badly;; + +let greet how who = + match how with Nicely -> Printf.printf "Hello, %s !\n" who + | Badly -> Printf.printf "Oh, here is that %s again.\n" who +;; +% cat hello.ml +open Greet + +let _ = + let name = + if Array.length Sys.argv > 1 then + Sys.argv.(1) + else + "stranger" + in + greet + (if name = "Caesar" then Nicely else Badly) + name; + Printf.printf "My name is %s\n" Sys.argv.(0) +;; +\end{verbatim} +Then the module \texttt{Hello} depends on the module \texttt{Greet} and \ocb can +figure this out for himself -- we still only have to invoke \texttt{\ocb +hello.native}. Needless to say, this works for any number of modules. +%***) +%(*** Native and byte code +\subsection{Native and byte-code} +If we want to compile byte-code instead of native, we just a target name of +\texttt{hello.byte} instead of \texttt{hello.native}, i.e., we type +\texttt{\ocb hello.byte}. +%***) +%(*** Compile flags +\subsection{Compile flags} +To pass a flag to the compiler, such as the \texttt{-rectypes} option, +use the \texttt{-cflag} option as in: +\begin{verbatim} +ocamlbuild -cflag -rectypes hello.native +\end{verbatim} +You can put multiple \texttt{-cflag} options, they will be passed to the compiler +in the same order. You can also given them in a comma-separated list with the +\texttt{-cflags} option (notice the plural): +\begin{verbatim} +ocamlbuild -cflags -I,+lablgtk,-rectypes hello.native +\end{verbatim} +These flags apply when compiling, that is, when producing \texttt{.cmi}, +\texttt{.cmo},\texttt{.cmx} and \texttt{.o} files from \texttt{.ml} or +\texttt{.mli} files. +%***) +%(*** Link flags +\subsection{Link flags} +Link flags apply when the various object files are collected and linked into +one executable. These will typically be include directories for libraries. +They are given using the \texttt{-lflag} and \texttt{-lflags} options, which +work in the same way as the \texttt{-cflag} and \texttt{-cflags} options. +%***) +%(*** Linking with external libraries +\subsection{Linking with external libraries} +In our third example, we use one Unix system call and functions from the \texttt{num} +library: +\begin{verbatim} +% cat epoch.ml +let _ = + let s = Num.num_of_string (Printf.sprintf "%.0f" (Unix.gettimeofday ())) in + let ps = Num.mult_num (Num.num_of_string "1000000000000") s in + Printf.printf "%s picoseconds have passed since January 1st, 1970.\n" + (Num.string_of_num ps) +;; +\end{verbatim} +This requires linking with the \texttt{unix} and \texttt{num} modules, which is accomplished +by using the \texttt{-lib unix} and \texttt{-lib num} flags, or, alternatively, \texttt{-libs unix,num}: +\begin{verbatim} +% ocamlbuild -libs nums,unix epoch.native -- +Finished, 4 targets (4 cached) in 00:00:00. +1169051647000000000000 picoseconds have passed since January 1st, 1970. +\end{verbatim} +You may need to add options such as \texttt{-cflags -I,/usr/local/lib/ocaml/} +and \texttt{-lflags -I,/usr/local/lib/ocaml/} if the libraries you wish to +link with are not in OCaml's default search path. +%***) +%(*** The _tags files +\subsection{The \tags files} +Finer control over the compiler flags applied to each source file, such as +preprocessing, debugging, profiling and linking options, can be gained using +\ocb's tagging mechanism. + +Every source file has a set of tags which tells \ocb what kind of file it is +and what to do with it. A tag is simply a string, usually lowercase, for +example \texttt{ocaml} or \texttt{native}. The set of tags attached to a file +is computed by applying the tagging rules to the filename. Tagging rules are +defined in \tags files in any parent directory of a file, up to the main +project directory. + +Each line in the \tags file is made of a glob pattern (see subsection +\ref{subsec:glob}) and a list of tags. More than one rule can apply to a file +and rules are applied in the order in which they appear in a file. +By preceding a tag with a minus sign, one may remove tags from one or more files. + +\subsubsection{Example: the built-in \tags file} +\begin{verbatim} + <**/*.ml> or <**/*.mli> or <**/*.mlpack> or <**/*.ml.depends>: ocaml + <**/*.byte>: ocaml, byte, program + <**/*.odoc>: ocaml, doc + <**/*.native>: ocaml, native, program + <**/*.cma>: ocaml, byte, library + <**/*.cmxa>: ocaml, native, library + <**/*.cmo>: ocaml, byte + <**/*.cmi>: ocaml, byte, native + <**/*.cmx>: ocaml, native +\end{verbatim} + +A special tag made from the path name of the file relative to the toplevel +of the project is automatically defined for each file. For a file +\texttt{foo/bar.ml} this tag will be \texttt{file:foo/bar.ml}. + +If you do not have subdirectories, you can put \texttt{*.ml} instead of +\texttt{**/*.ml}. +%***) +%(*** Glob patterns and expressions +\subsection{Glob patterns and expressions} +\label{subsec:glob} +Glob patterns have a syntax similar to those used by UNIX shells to select path +names (like \texttt{foo\_*.ba?}). They are used in \ocb to define the files +and directories to which tags apply. Glob expressions are glob patterns +enclosed in brackets \texttt{<} and \texttt{>} combined using the standard +boolean operators \texttt{and}, \texttt{or}, \texttt{not}. This allows one to +describe sets of path names in more concise and more readable ways. + +Please note that file and directory names are supposed to be made of the +following characters: $\texttt{a}$, $\dots$, $\texttt{z}$, $\texttt{A}$, +$\dots$, $\texttt{Z}$, $\texttt{0}$, $\dots$, $\texttt{9}$, $\texttt{\_}$, +$\texttt{-}$ and $\texttt{.}$. This is called the pathname alphabet $P$. + +\begin{table}[h] + \begin{center} + \small + \begin{tabular}{|p{3cm}|l|p{3cm}|p{3cm}|p{5cm}|} + \hline + {\em Formal syntax} & + {\em Example} & {\em Matches} & {\em Does not match} & + {\em Meaning (formal meaning)} \\ + \hline + \hline +%% + {$u$ \vspace*{0.5em} A string of pathname characters} & + \texttt{foo.ml} & + \texttt{foo.ml} & + \texttt{fo.ml}, \texttt{bar/foo.ml} & + The exact string $u$ + ($\{ u \}$, where $u \in P^*$) \\ + \hline +%% + {\texttt{*} \vspace*{0.5em} The wild-card star}& + \texttt{*}& + $\varepsilon$, \texttt{foo}, \texttt{bar} & + \texttt{foo/bar}, \texttt{/bar} & + Any string not containing a slash + ($P^*$) \\ + \hline +%% + {\texttt{?} \vspace*{0.5em} The joker}& + \texttt{?}& + \texttt{a}, \texttt{b}, \texttt{z} & + \texttt{/}, \texttt{bar} & + Any one-letter string, excluding the slash \\ + \hline +%% + {\texttt{**/} \vspace*{0.5em} The prefix inter-directory star}& + \texttt{**/foo.ml}& + \texttt{foo.ml}, \texttt{bar/foo.ml}, \texttt{bar/baz/foo.ml} & + \texttt{foo/bar}, \texttt{/bar} & + The empty string, or any string ending with a slash + ($\varepsilon \cup P^*\mathtt{/}$) \\ + \hline +%% + {\texttt{/**} \vspace*{0.5em} The suffix inter-directory star}& + \texttt{foo/**}& + \texttt{foo}, \texttt{foo/bar} & + \texttt{bar/foo} & + Any string starting with a slash, or the empty string + ($\varepsilon \cup \mathtt{/}P^*$) \\ + \hline +%% + {\texttt{/**/} \vspace*{0.5em} The infix inter-directory star}& + \texttt{bar/**/foo.ml}& + \texttt{bar/foo.ml}, \texttt{bar/baz/foo.ml} & + \texttt{foo.ml} & + Any string starting and ending with a slash + ($\varepsilon \cup \mathtt{/}P^*\mathtt{/}$) \\ + \hline +%% + {$\mathtt{[} r_1 r_2 \cdots r_k \mathtt{]}$ + where $r_i$ is either $c$ or $c_1-c_2$ $(1 \leq i \leq k)$ + \vspace*{0.5em} The positive character class}& + \texttt{[a-fA-F0-9\_.]}& + \texttt{3}, \texttt{F}, \texttt{.} & + \texttt{z}, \texttt{bar} & + Any one-letter string made of characters from one of the ranges + $r_i$ ($1 \leq i \leq n$). + ($\mathscr L(r_1) \cup \cdots \cup \mathscr L(r_n)$) \\ + \hline +%% + {\texttt{[\char`\^}$r_1 r_2 \cdots r_k \mathtt{]}$ + where $r_i$ is either $c$ or $c_1-c_2$ $(1 \leq i \leq k)$ + \vspace*{0.5em} The negative character class}& + \texttt{[\char`\^a-fA-F0-9\_.]}& + \texttt{z}, \texttt{bar} & + \texttt{3}, \texttt{F}, \texttt{.} & + Any one-letter string NOT made of characters from one of the ranges + $r_i$ ($1 \leq i \leq n$). + ($\Sigma^* \setminus \left(\mathscr L(r_1) \cup \cdots \cup \mathscr L(r_n)\right)$) \\ + \hline +%% + {$p_1 p_2$ \vspace*{0.5em} A concatenation of patterns}& + \texttt{foo*}& + \texttt{foo}, \texttt{foob}, \texttt{foobar} & + \texttt{fo}, \texttt{bar} & + Any string with a prefix matching $p_1$ and the corresponding suffix + matching $p_2$, + ($\{ uv \mid u \in \mathscr L(p_1), v \in \mathscr L(p_2) \}$) \\ + \hline +%% + {$\mathtt{\{} p_1 \mathtt{,} p_2 \mathtt{,} \cdots \mathtt{,} p_k \mathtt{\}}$ \vspace*{0.5em} A union of patterns}& + \texttt{toto.\{ml,mli\}}& + \texttt{toto.ml}, \texttt{toto.mli} & + \texttt{toto.} & + Any string matching one of the patterns $p_i$ for $1 \leq i \leq k$. + ($\mathscr L(p_1) \cup \cdots \cup \mathscr L(p_k)$) \\ + \hline +%% + \end{tabular} + \end{center} + \caption{ + Syntax and semantics of glob patterns. + } +\end{table} +\begin{table} + \begin{center} + \small + \begin{tabular}{|p{2cm}|l|p{7cm}|} + \hline + {\em Formal syntax} & + {\em Example} & + {\em Meaning (formal meaning)} \\ + \hline + \hline + {$\mathtt{<}p\mathtt{>}$} & + \texttt{} & + Pathnames matching the pattern $p$ \\ + \hline + {$e_1 \; \mathtt{or} \; e_2$} & + \texttt{<*.ml> or } & + Pathnames matching at least one of the expressions $e_1$ and $e_2$ \\ + \hline + {$e_1 \; \mathtt{and} \; e_2$} & + \texttt{<*.ml> and } & + Pathnames matching both expressions $e_1$ and $e_2$ \\ + \hline + {$\mathtt{not} \; e$} & + \texttt{not <*.mli>} & + Pathnames not matching the expression $e$ \\ + \hline + {$\mathtt{true}$} & + \texttt{true} & + All pathnames \\ + \hline + {$\mathtt{false}$} & + \texttt{false} & + No pathnames \\ + \hline + \end{tabular} + \end{center} + \caption{ + Syntax and semantics of glob expressions. + } +\end{table} +%***) +%(*** Subdirectories +\subsection{Subdirectories} +If the files of your project are held in one or more subdirectories, +\ocb must be made aware of that fact using the \texttt{-I} or \texttt{-Is} options +or by adding an \texttt{include} tag. For instance, assume your project is made +of three subdirectories, \texttt{foo}, \texttt{bar} and \texttt{baz} containing +various \texttt{.ml} files, the main file being \texttt{foo/main.ml}. Then you can +either type: +\begin{verbatim} +% ocamlbuild -Is foo,bar,baz foo/main.native +\end{verbatim} +or add the following line in the \tags file +\begin{verbatim} + or or : include +\end{verbatim} +and call +\begin{verbatim} +% ocamlbuild foo/main.native +\end{verbatim} + +There are then two cases. If no other modules named \texttt{Bar} or +\texttt{Baz} exist elsewhere in the project, then you are done. Just use +\texttt{Foo}, \texttt{Foo.Bar} and \texttt{Foo.Baz} in your code. +Otherwise, you will need to use the plugin mechanism and define the mutual +visibility of the subdirectories using the \texttt{Pathname.define\_context} +function. + +\subsubsection{Note on subdirectory traversal} +\ocb used to traverse by default any subdirectory not explicitly excluded. +This is no longer the case. Note that you can still have a fine grained +control using your \tags file and the \texttt{traverse} tag. + +There is no longer the \texttt{true: traverse} tag declaration by default. To +make \ocb recursive use one of these: +\begin{enumerate} +\item Give the \texttt{-r} flag to ocamlbuild. +\item Have a \tags or myocamlbuild.ml file in your top directory. +\end{enumerate} + +%***) +%(*** Grouping targets +\subsection{Grouping targets with \texttt{.itarget}} +You can create a file named \texttt{foo.itarget} containing +a list of targets, one per line, such as +\begin{verbatim} +main.native +main.byte +stuff.docdir/index.html +\end{verbatim} +Requesting the target \texttt{foo.otarget} will then build every target +listed in the file \texttt{foo.itarget}. Blank lines and lines starting +with a sharp (\texttt{\#}) are ignored. +%***) +%(*** Packing subdirectories into modules +\subsection{Packing subdirectories into modules} +OCaml's \texttt{-pack} option allows you to structure the contents of a +module in a subdirectory. For instance, assume you have a directory +\texttt{foo} containing two modules \texttt{bar.ml} and \texttt{baz.ml}. +You want from these to build a module \texttt{Foo} containing \texttt{Bar} +and \texttt{Baz} as submodules. In the case where no modules named +\texttt{Bar} or \texttt{Baz} exist outside of \texttt{Foo}, to do this you +must write a file \texttt{foo.mlpack}, preferably sitting in the same +directory as the directory \texttt{Foo} and containing the list of modules +(one per line) it must contain: +\begin{verbatim} +Bar +Baz +\end{verbatim} +Then when you will request for building \texttt{foo.cmo} the package will be +made from \texttt{bar.cmo} and \texttt{baz.cmo}. +%***) +%(*** Making an OCaml library +\subsection{Making an OCaml library} +In a similar way than for packaged modules you can make a library by putting +it's contents in a file (with the mllib extension). For instance, assume you +have a two modules \texttt{bar.ml} and \texttt{baz.ml}. You want from these to +build a library \texttt{foo.cmx?a} containing \texttt{Bar} and \texttt{Baz} +modules. To do this you must write a file \texttt{foo.mllib} containing the +list of modules (one per line) it must contain: +\begin{verbatim} +Bar +Baz +\end{verbatim} +Then when you will request for building \texttt{foo.cma} the library will be +made from \texttt{bar.cmo} and \texttt{baz.cmo}. +%***) +%(*** Making an OCaml toplevel +\subsection{Making an OCaml toplevel} +Making a toplevel is almost the same thing than making a packaged module or a +library. Just write a file with the \texttt{mltop} extension (like +\texttt{foo.mltop}) and request for building the toplevel using the +\texttt{top} extension (\texttt{foo.top} in this example). +%***) +%(*** Preprocessor options +\subsection{Preprocessor options and tags} +You can specify preprocessor options with \texttt{-pp} followed by the +preprocessor string, for instance \texttt{ocamlbuild -pp "camlp4o.opt -unsafe"} +would run your sources thru CamlP4 with the \texttt{-unsafe} option. +Another way is to use the tags file. +\begin{center} + \begin{tabular}{|l|l|l|} + \hline + \textbf{Tag} & \textbf{Preprocessor command} & \textbf{Remark} \\ + \hline + \hline + \texttt{pp(cmd...)} & \texttt{cmd...} & Arbitrary + preprocessor command\footnote{The command must not contain newlines or parentheses.} \\ + \hline + \texttt{camlp4o} & \texttt{camlp4o} & Original OCaml syntax \\ + \hline + \texttt{camlp4r} & \texttt{camlp4r} & Revised OCaml syntax \\ + \hline + \texttt{camlp4of} & \texttt{camlp4of} & Original OCaml syntax with extensions \\ + \hline + \texttt{camlp4rf} & \texttt{camlp4rf} & Revised OCaml syntax with extensions \\ + \hline + \end{tabular} +\end{center} + +%%%%% \subsubsection{An example, dealing with some configuration variables} +%%%%% +%%%%% It's quite common to have in your sources some files that you want to access +%%%%% when your program is running. One often uses some variables that are setup by +%%%%% the end user. Now suppose that there is only two files that use these variables +%%%%% (mylib.ml and parseopt.ml). +%%%%% +%%%%% In the \tags file: +%%%%% \begin{verbatim} +%%%%% "mylib.ml" or "parseopt.ml": pp(sed -e "s,LIBDIR,/usr/local/lib/FOO,g") +%%%%% \end{verbatim} +%%%%% +%%%%% In fact that solution is not really acceptable, since the variable is hardcoded +%%%%% in the \tags file. Trying to workaround this issue by using some shell variable +%%%%% does not work either since the -pp argument will be escaped in simple quotes. +%%%%% Note also that using some script shell that will do that sed and use \verb'$LIBDIR' +%%%%% as a shell variable is not a good idea since \ocb don't know this dependency on that +%%%%% shell script. +%%%%% +%%%%% There is in fact at least two good solutions. The first is to tell that dependency +%%%%% using the \texttt{dep} function in your plugin. The second is simpler it just consist +%%%%% on generating some OCaml file at configure time. By naming this configuration file +%%%%% \texttt{myocamlbuild_config.ml} \ocb will make it also available to your plugin. +%%%%% +%%%%% In your \texttt{myocamlbuild_config.mli} interface: +%%%%% \begin{verbotim} +%%%%% val prefix : string +%%%%% val libdir : string +%%%%% \end{verbotim} +%%%%% +%%%%% And in your \texttt{configure} script +%%%%% \begin{verbatim} +%%%%% #!/bin/sh +%%%%% +%%%%% # Setting defaults values +%%%%% PREFIX=/usr/local +%%%%% LIBDIR=$PREFIX/lib/FOO +%%%%% CONF=myocamlbuild_config.ml +%%%%% +%%%%% # ... some shell to parse option and check configuration ... +%%%%% +%%%%% # Dumping the configuration as an OCaml file. +%%%%% rm -f $CONF +%%%%% echo "let prefix = \"$PREFIX\";;" >> $CONF +%%%%% echo "let libdir = \"$LIBDIR\";;" >> $CONF +%%%%% chmod -w $CONF +%%%%% \end{verbatim} + +%***) +%(*** Debugging and profiling +\subsection{Debugging byte code and profiling native code} +The preferred way of compiling code suitable for debugging with \texttt{ocamldebug} or +profiling native code with \texttt{ocamlprof} is to use the appropriate target +extensions, \texttt{.d.byte} for debugging or \texttt{.p.native}. + +Another way is to add use the \texttt{debug} or \texttt{profile} tags. +Note that these tags must be applied at the compilation and linking stages. +Hence you must either use \texttt{-tag debug} or \texttt{-tag profile} +on the command line, or add a +\begin{verbatim} +true: debug +\end{verbatim} +line to your \tags file. +Please note that the byte-code profiler works in a wholly different way +and is not supported by \ocb. +%***) +%(*** Generating documentation using \texttt{ocamldoc} +\subsection{Generating documentation using \texttt{ocamldoc}} +Write the names of the modules whose interfaces will be documented in a file +whose extension is \texttt{.odocl}, for example \texttt{foo.odocl}, then invoke +\ocb on the target \texttt{foo.docdir/index.html}. This will collect all the +documentation from the interfaces (which will be build, if necessary) using +\texttt{ocamldoc} and generate a set of HTML files under the directory +\texttt{foo.docdir/}, which is actually a link to \texttt{\_build/foo.docdir/}. +As for packing subdirectories into modules, the module names must be written +one per line, without extensions and correctly capitalized. Note that +generating documentation in formats other than HTML or from implementations is +not supported. +%***) +%(*** The display line +\subsection{The display line} +Provided \ocb runs in a terminal under a POSIX environment, it will +display a sophisticated progress-indicator line that graciously interacts +with the output of subcommands. This line looks like this: +\begin{verbatim} +00:00:02 210 (180 ) main.cmx ONbp--il / +\end{verbatim} +Here, 00:00:02 is the elapsed time in hour:minute:second format since \ocb has +been invoked; 210 is the number of external commands, typically calls to the +compiler or the like, that may or may not have been invoked; 180 is the number +of external commands that have not been invoked since their result is already +in the build directory; \texttt{main.cmx} is the name of the last target built; +\texttt{ONbp--il} is a short string that describes the tags that have been +encountered and the slash at the end is a frame from a rotating ticker. Hence, +the display line has the following structure: +\begin{verbatim} +HH:MM:SS JOBS (CACHED) PATHNAME TAGS TICKER +\end{verbatim} + +The tag string is made of 8 indicators which each monitor a tag. These tags +are \texttt{ocaml}, \texttt{native}, \texttt{byte}, \texttt{program}, +\texttt{pp}, \texttt{debug}, \texttt{interf} and \texttt{link}. Initially, +each indicator displays a dash \texttt{-}. If the current target has the +monitored tag, then the indicator displays the corresponding character +(see table \ref{tab:tag-chars}) in uppercase. Otherwise, it displays that +character in lowercase. This allows you to see the set of tags that have +been applied to files in your project during the current invocation of \ocb. + +Hence the tag string \texttt{ONbp--il} means that the current target +\texttt{main.cmx} has the tags \texttt{ocaml} and \texttt{native}, and that +the tags \texttt{ocaml}, \texttt{native}, \texttt{byte}, \texttt{program}, +\texttt{interf} and \texttt{link} have already been seen. + +\begin{table} + \begin{center} + \begin{tabular}{|l|c|} + \hline + \textbf{Tag} & \textbf{Display character} \\ + \hline + \hline + ocaml & O \\ + \hline + native & N \\ + \hline + byte & B \\ + \hline + program & P \\ + \hline + pp & R \\ + \hline + debug & D \\ + \hline + interf & I \\ + \hline + link & L \\ + \hline + \end{tabular} + \end{center} + \caption{\label{tab:tag-chars} Relation between the characters displayed in + the tag string and the tags.} +\end{table} +%***) +%(*** ocamllex, ocamlyacc and menhir +\subsection{\texttt{ocamllex}, \texttt{ocamlyacc} and \texttt{menhir}} +\ocb knows how to run the standard lexer and parser generator tools +\texttt{ocamllex} and \texttt{ocamlyacc} when your files have the +standard \texttt{.mll} and \texttt{.mly} extensions. If you want to +use \texttt{menhir} instead of \texttt{ocamlyacc}, you can either +launch \ocb with the \texttt{-use-menhir} option or add a +\begin{verbatim} +true: use_menhir +\end{verbatim} +line to your \tags file. Note that there is currently no way +of using \texttt{menhir} and \texttt{ocamlyacc} in the same execution +of \ocb. +%***) +%(*** Changing the compilers +\subsection{Changing the compilers or tools} +As \ocb is part of your OCaml distribution, it knows if it can call the +native compilers and tools (\texttt{ocamlc.opt}, \texttt{ocamlopt.opt}...) +or not. However you may want \ocb to use another \texttt{ocaml} compiler +for different reasons (such as cross-compiling or using a wrapper such as +\texttt{ocamlfind}). Here is the list of relevant options: +\begin{itemize} + \item \texttt{-ocamlc } + \item \texttt{-ocamlopt } + \item \texttt{-ocamldep } + \item \texttt{-ocamlyacc } + \item \texttt{-menhir } + \item \texttt{-ocamllex } + \item \texttt{-ocamlmktop } + \item \texttt{-ocamlrun } +\end{itemize} + +%***) +\subsection{Writing a \texttt{myocamlbuild.ml} plugin} +%(*** Interaction with version control systems +\subsection{Interaction with version control systems} +Here are tips for configuring your version control system to ignore the files +and directories generated by \ocb. + +The directory \texttt{\_build} and any symbolic links +pointing into \texttt{\_build} should be ignored. +To do this, you must add the following ignore patterns to your version +control system's ignore set: +\begin{verbatim} +_build +*.native +*.byte +*.d.native +*.p.byte +\end{verbatim} + +For CVS, add the above lines to the \texttt{.cvsignore} file. +For Subversion (SVN), type \texttt{svn propedit svn:ignore .} and add the +above lines. +%***) +%(*** A shell script for driving it all? +\subsection{A shell script for driving it all?} +{\em To shell or to make ?} +Traditionally, makefiles have two major functions. The first one +is the dependency-ordering, rule-matching logic used for compiling. +The second one is as a dispatcher for various actions defined using +phony targets with shell script actions. These actions include cleaning, +cleaning really well, archiving, uploading and so on. Their characteristic +is that they rely little or not on the building process -- they either need +the building to have been completed, or they don't need anything. +As \texttt{/bin/sh} scripts have been here for three to four decades and are +not going anywhere, why not replace that functionality of makefiles with a +shell script ? We have thought of three bad reasons: +\begin{itemize} + \item Typing \texttt{make} to compile is now an automatism, + \item We need to share variable definitions between rules and actions, + \item Escaping already way too special-character-sensitive shell code with + invisible tabs and backslashes is a dangerously fun game. +\end{itemize} +We also have bad reasons for not using an OCaml script to drive everything: +\begin{itemize} + \item \texttt{Sys.command} calls the \texttt{/bin/sh} anyway, + \item Shell scripts can execute partial commands or commands with badly formed arguments. + \item Shell scripts are more concise for expressing... shell scripts. +\end{itemize} +Anyway you are of course free to use a makefile or an OCaml script to call ocamlbuild. +Here is an example shell driver script: +\begin{verbatim} +#!/bin/sh + +set -e + +TARGET=epoch +FLAGS="-libs unix,nums" +OCAMLBUILD=ocamlbuild + +ocb() +{ + $OCAMLBUILD $FLAGS $* +} + +rule() { + case $1 in + clean) ocb -clean;; + native) ocb $TARGET.native;; + byte) ocb $TARGET.byte;; + all) ocb $TARGET.native $TARGET.byte;; + depend) echo "Not needed.";; + *) echo "Unknown action $1";; + esac; +} + +if [ $# -eq 0 ]; then + rule all +else + while [ $# -gt 0 ]; do + rule $1; + shift + done +fi +\end{verbatim} +%***) +%\subsection{Common errors} +%***) +\appendix +%(*** Motivations +\section{Motivations} +{\em This inflammatory appendix describes the frustration that led us to write \ocb.} + +Many people have painfully found that the utilities of the \texttt{make} +family, namely GNU Make, BSD Make, and their derivatives, fail to scale to +large projects, especially when using multi-stage compilation rules, such as +custom pre-processors, unless dependencies are hand-defined. But as your +project gets larger, more modular, and uses more diverse pre-processing tools, +it becomes increasingly difficult to correctly define dependencies by hand. +Hence people tend to use language-specific tools that attempt to extract +dependencies. However another problem then appears: \texttt{make} was designed +with the idea of a static dependency graph. Dependency extracting tools, +however, are typically run by a rule in \texttt{make} itself; this means that +make has to reload the dependency information. This is the origin of the +\texttt{make clean; make depend; make} mantra. This approach tends to work +quite well as long as all the files sit in a single directory and there is only +one stage of pre-processing. If there are two or more stages, then dependency +extracting tools must be run two or more times - and this means multiple +invocations of \texttt{make}. Also, if one distributes the modules of a large +project into multiple subdirectories, it becomes difficult to distribute the +makefiles themselves, because the language of \texttt{make} was not conceived +to be modular; the only two mechanisms permitted, inclusion of makefile +fragments, and invocation of other make instances, must be skillfully +coordinated with phony target names (\texttt{depend1, depend2...}) to insure +inclusion of generated dependencies with multi-stage programming; changes in +the structure of the project must be reflected by hand and the order of +variable definitions must be well-thought ahead to avoid long afternoons spent +combinatorially fiddling makefiles until it works but no one understands why. + +These problems become especially apparent with OCaml: to ensure type safety and +to allow a small amount of cross-unit optimization when compiling native code, +interface and object files include cryptographical digests of interfaces they +are to be linked with. This means that linking is safer, but that makefile sloppiness +leads to messages such as: +\begin{verbatim} +Files foo.cmo and bar.cmo +make inconsistent assumptions over interface Bar +\end{verbatim} + +The typical reaction is then to issue the mantra \texttt{make clean; make +depend; make} and everything compiles just fine... from the beginning. Hence +on medium projects, the programmer often has to wait for minutes instead of the +few seconds that would be taken if \texttt{make} could correctly guess the +small number of files that really had to be recompiled. + +It is not surprising that hacking a build tool such as \texttt{make} to include +a programming language while retaining the original syntax and semantics gives +an improvised and cumbersome macro language of dubious expressive power. For +example, using GNU make, suppose you have a list of \texttt{.ml}s that you want +to convert into a list including both \texttt{.cmo}s and \texttt{.cmi}s, that +is you want to transform \texttt{a.ml b.ml c.ml} into \texttt{a.cmi a.cmo b.cmi +b.cmo c.cmi c.cmo} while preserving the dependency order which must be hand +specified for linking \footnote{By the way, what's the point of having a +declarative language if \texttt{make} can't sort the dependencies in +topological order for giving them to \texttt{gcc} or whatever ?}. +Unfortunately \texttt{\$patsubst \%.ml, \%.cmi \%.cmo, a.ml b.ml c.ml} won't +work since the \%-sign in the right-hand of a \texttt{patsubst} gets +substituted only once. You then have to delve into something that is hardly +lambda calculus: an intricate network of \texttt{foreach}, \texttt{eval}, +\texttt{call} and \texttt{define}s may get you the job done, unless you chicken +out and opt for an external \texttt{awk}, \texttt{sed} or \texttt{perl} call. +People who at this point have not lost their temper or sanity usually resort to +metaprogramming by writing Makefile generators using a mixture of shell and m4. +One such an attempt gave something that is the nightmare of wannabe package +maintainers: it's called \texttt{autotools}. + +Note that it is also difficult to write \texttt{Makefiles} to build object +files in a separate directory. It is not impossible since the language of +\texttt{make} is Turing-complete, a proof of which is left as an exercise. +Note that building things in a separate directory is not necessarily a young +enthusiast's way of giving a different look and feel to his projects -- it may +be a good way of telling the computer that \texttt{foo.mli} is generated by +\texttt{ocamlyacc} using \texttt{foo.mly} and can thus be removed. +%***) +%(*** Default rules +\section{Summary of default rules} +The contents of this table give a summary of the most important default rules. +To get the most accurate and up-to-date information, launch \ocb with the +\texttt{-documentation} option. +\begin{center} +\small +\begin{tabular}{|l|l|p{5cm}|} + \hline + \textbf{Tags} & \textbf{Dependencies} & \textbf{Targets} \\ + \hline + \hline + & \%.itarget & \%.otarget \\ + \hline + ocaml & \%.mli \%.mli.depends & \%.cmi \\ + \hline + byte, debug, ocaml & \%.mlpack \%.cmi & \%.d.cmo \\ + \hline + byte, ocaml & \%.mlpack & \%.cmo \%.cmi \\ + \hline + byte, ocaml & \%.mli \%.ml \%.ml.depends \%.cmi & \%.d.cmo \\ + \hline + byte, ocaml & \%.mli \%.ml \%.ml.depends \%.cmi & \%.cmo \\ + \hline + native, ocaml, profile & \%.mlpack \%.cmi & \%.p.cmx \%.p.o \\ + \hline + native, ocaml & \%.mlpack \%.cmi & \%.cmx \%.o \\ + \hline + native, ocaml, profile & \%.ml \%.ml.depends \%.cmi & \%.p.cmx \%.p.o \\ + \hline + native, ocaml & \%.ml \%.ml.depends \%.cmi & \%.cmx \%.o \\ + \hline + debug, ocaml & \%.ml \%.ml.depends \%.cmi & \%.d.cmo \\ + \hline + ocaml & \%.ml \%.ml.depends & \%.cmo \%.cmi \\ + \hline + byte, debug, ocaml, program & \%.d.cmo & \%.d.byte \\ + \hline + byte, ocaml, program & \%.cmo & \%.byte \\ + \hline + native, ocaml, profile, program & \%.p.cmx \%.p.o & \%.p.native \\ + \hline + native, ocaml, program & \%.cmx \%.o & \%.native \\ + \hline + byte, debug, library, ocaml & \%.mllib & \%.d.cma \\ + \hline + byte, library, ocaml & \%.mllib & \%.cma \\ + \hline + byte, debug, library, ocaml & \%.d.cmo & \%.d.cma \\ + \hline + byte, library, ocaml & \%.cmo & \%.cma \\ + \hline + & lib\%(libname).clib & lib\%(libname).a dll\%(libname).so \\ + \hline + & \%(path)/lib\%(libname).clib & \%(path)/lib\%(libname).a \%(path)/dll\%(libname).so \\ + \hline + library, native, ocaml, profile & \%.mllib & \%.p.cmxa \%.p.a \\ + \hline + library, native, ocaml & \%.mllib & \%.cmxa \%.a \\ + \hline + library, native, ocaml, profile & \%.p.cmx \%.p.o & \%.p.cmxa \%.p.a \\ + \hline + library, native, ocaml & \%.cmx \%.o & \%.cmxa \%.a \\ + \hline + & \%.ml & \%.ml.depends \\ + \hline + & \%.mli & \%.mli.depends \\ + \hline + ocaml & \%.mll & \%.ml \\ + \hline + doc, ocaml & \%.mli \%.mli.depends & \%.odoc \\ + \hline + & \%.odocl & \%.docdir/index.html \\ + \hline + ocaml & \%.mly & \%.ml \%.mli \\ + \hline + & \%.c & \%.o \\ + \hline + & \%.ml \%.ml.depends & \%.inferred.mli \\ + \hline +\end{tabular} +\end{center} +%***) +\end{document} diff --git a/ocamlbuild/manual/myocamlbuild.ml b/ocamlbuild/manual/myocamlbuild.ml new file mode 100644 index 00000000..9cc944ee --- /dev/null +++ b/ocamlbuild/manual/myocamlbuild.ml @@ -0,0 +1,119 @@ +(*p + \usepackage{xspace} + \newcommand{\ocb}{\texttt{ocamlbuild}\xspace} + \newcommand{\tags}{\texttt{\_tags}\xspace} +*) +let main = let module M = struct + +open Ocamlbuild_plugin;; +open Command;; + +let pdflatex = ref (A"pdflatex");; +let ocamlweb = ref (A"ocamlweb");; + +(*c dispatch is the main call of an \ocb plugin *) +dispatch begin function + + (*c Here one can change the default value of options, they can still be updated by a command line option. *) + | Before_options -> + + (*c This will put all warnings to \texttt{ocaml\{c,opt\}} by default. *) + Options.ocaml_cflags := ["-w";"A"] + + (*c Here one can change the final value of options. *) + | After_options -> + + (*c This avoids the creation of symbolic links to the build directory. *) + Options.make_links := false + + (*c This hook is called before the hygiene phase. + This phase also serve as collecting all the information about the + source tree. *) + | Before_hygiene -> + + (*c Here you can dynamically tag some files or directories. *) + (*c This is done here by checking the [SOME_COND] variable which is + impossible in the \tags file. *) + if getenv "SOME_COND" ~default:"false" = "true" then + + (*c By setting foo\_dir as not\_hygienic one say that the foo directory + can contains non hygienic files (such as \texttt{.cmi}, \texttt{.cmo}\ldots). *) + tag_file "foo_dir" ["not_hygienic"] + + (*c One can also do things after the hygiene step. *) + | After_hygiene -> () + + (*c One can setup rules before the standard ones but that's not recommended. *) + | Before_rules -> () + + (*c Here one can add or override new rules *) + | After_rules -> + + (*c Rules can be declared by a call of the form + [rule name ~prod ~dep action]. + The first argument is the name of the rule. + [~prod:string] specifies the product of the rule. + Note that [~prods:string list] also exists. + [~dep] and [~deps] are for dependencies *) + rule "LaTeX to PDF conversion rule" + ~prod:"%.pdf" + ~dep:"%.tex" + begin fun env _build -> + + (*c The action is a function that receive two arguments: + [env] is a conversion function that substitutes `\%' occurrences + according to the targets to which the rule applies. + [_build] can be called to build new things (dynamic dependencies). *) + let tex = env "%.tex" and _pdf = env "%.pdf" in + + (*c Here we say: ``We compile the file tex form \LaTeX\xspace to PDF''. + Note that in fact that is a set of tags, thus the order does not + matter. But you got the idea. *) + let tags = tags_of_pathname tex++"compile"++"LaTeX"++"pdf" in + + (*c Here we produce the command to run. + [S] is for giving a sequence of command pieces. + [A] is for atoms. + [P] is for pathnames. + [Px] is a special pathname that should be the main product of the + rule (for display purposes). + [T] is for tags. + + The other constructors are given in the documentation of the + [Command] module in [Signatures.COMMAND]. *) + let cmd = Cmd(S[!pdflatex; T tags; P tex; Sh"< /dev/null"]) in + (*c Hoping that \LaTeX will converge in two iterations *) + Seq[cmd; cmd] + end; + + (*c Here we make an extension of any rule that produces a command + containing these tags. *) + flag ["compile"; "LaTeX"; "pdf"; "safe"] (A"-halt-on-error"); + + (*c Here we give an exception: the file ``manual.tex'' is tagged ``safe''.\ocweol + With this tag we add the -halt-on-error flag during the \LaTeX + compilation. *) + tag_file "manual.tex" ["safe"]; + + (*c The generic \LaTeX rule could look at the file searching for some + \verb'\input{}' command, but \LaTeX is so complex that it will + be hard to make this solution complete. + Here we manually inject some dependencies at one particular point. *) + + (*c The [dep] function takes tags and pathnames. This will build pathnames + if a command contains these tags. Note that every file [some_file_name] is + tagged [file:some_file_name]. *) + dep ["compile"; "LaTeX"; "pdf"; "file:manual.tex"] + ["ocamlweb.sty"; "myocamlbuild.tex"]; + + rule "OCaml to LaTeX conversion rule (using ocamlweb)" + ~prod:"%.tex" + ~dep:"%.ml" + begin fun env _build -> + let tex = env "%.tex" and ml = env "%.ml" in + let tags = tags_of_pathname ml++"ocamlweb"++"LaTeX" in + Cmd(S[!ocamlweb; T tags; P ml; A"-o"; Px tex]) + end; +end;; + +end in ();; \ No newline at end of file diff --git a/ocamlbuild/manual/trace.out b/ocamlbuild/manual/trace.out new file mode 100644 index 00000000..cb2a3551 --- /dev/null +++ b/ocamlbuild/manual/trace.out @@ -0,0 +1,83 @@ +00:00:00 0 (0) STARTING -------- | +00:00:00 1 (0) back.ml.depends O------- | +00:00:00 8 (0) keyword.mli.depends O-b---i- | +00:00:00 16 (0) mark.cmi O-B---I- / +00:00:00 20 (0) stringSet.cmi O-B---I- / +00:00:00 24 (0) time.mli.depends O-b---i- / +00:00:00 32 (0) stdlib.ml.depends O-b---i- - +00:00:00 35 (0) stringSet.cmx ONb---i- - +00:00:00 37 (0) settings.cmx ONb---i- - +00:00:00 44 (0) lineCount.cmx ONb---i- \ +00:00:00 45 (0) interface.ml.depends Onb---i- \ +00:00:00 45 (0) interface.ml.depends Onb---i- \ +00:00:01 52 (0) stringMap.ml.depends Onb---i- | +00:00:01 53 (0) printer.cmx ONb---i- | +00:00:01 53 (0) printer.cmx ONb---i- | +00:00:01 57 (0) time.cmx ONb---i- / +00:00:01 64 (0) partialGrammar.cmi OnB---I- / +00:00:01 67 (0) parameters.ml.depends Onb---i- / +00:00:01 72 (0) misc.ml.depends Onb---i- - +00:00:01 74 (0) keyword.ml.depends Onb---i- - +00:00:01 77 (0) error.cmi OnB---I- - +00:00:01 82 (0) parameters.cmx ONb---i- \ +00:00:01 84 (0) action.cmx ONb---i- \ +00:00:01 87 (0) parser.mli.depends Onb---i- \ +00:00:02 96 (0) parserAux.cmx ONb---i- | +00:00:02 103 (0) tarjan.ml.depends Onb---i- | +00:00:02 106 (0) unionFind.cmx ONb---i- | +00:00:02 108 (0) lexer.mll Onb---i- / +00:00:02 108 (0) lexer.mll Onb---i- / +00:00:02 110 (0) lexer.cmo OnB---i- - +00:00:02 111 (0) parser.cmx ONb---i- - +00:00:02 112 (0) partialGrammar.cmx ONb---i- - +00:00:02 114 (0) lexer.cmx ONb---i- \ +00:00:02 116 (0) codeBits.mli.depends Onb---i- \ +00:00:03 118 (0) preFront.cmx ONb---i- | +00:00:03 120 (0) tokenType.cmx ONb---i- | +00:00:03 123 (0) inliner.cmi OnB---I- | +00:00:03 126 (0) traverse.cmx ONb---i- / +00:00:03 126 (0) traverse.cmx ONb---i- / +00:00:03 129 (0) code.cmi OnB---I- / +00:00:03 131 (0) lr1.mli.depends Onb---i- / +00:00:03 134 (0) lookahead.mli.depends Onb---i- - +00:00:03 137 (0) gMap.ml.depends Onb---i- - +00:00:03 144 (0) lr1.cmi OnB---I- - +00:00:03 146 (0) item.ml.depends Onb---i- - +00:00:03 149 (0) patricia.cmi OnB---I- \ +00:00:03 151 (0) patricia.cmx ONb---i- \ +00:00:03 151 (0) patricia.cmx ONb---i- \ +00:00:04 154 (0) front.cmi OnB---I- | +00:00:04 164 (0) listMonad.ml.depends Onb---i- | +00:00:04 167 (0) listMonad.cmx ONb---i- | +00:00:04 170 (0) infer.cmi OnB---I- / +00:00:04 171 (0) lexmli.mll Onb---i- / +00:00:04 172 (0) lexmli.ml.depends Onb---i- / +00:00:04 174 (0) lexdep.mll Onb---i- - +00:00:04 177 (0) interface.cmx ONb---i- - +00:00:04 178 (0) IO.ml.depends Onb---i- \ +00:00:04 181 (0) lexmli.cmx ONb---i- \ +00:00:04 183 (0) IO.cmx ONb---i- \ +00:00:05 187 (0) infer.cmx ONb---i- | +00:00:05 190 (0) dot.cmi OnB---I- | +00:00:05 193 (0) compressedBitSet.cmi OnB---I- / +00:00:05 195 (0) dot.cmx ONb---i- / +00:00:05 197 (0) grammar.cmx ONb---i- / +00:00:05 197 (0) grammar.cmx ONb---i- / +00:00:05 197 (0) grammar.cmx ONb---i- - +00:00:05 200 (0) infiniteArray.cmi OnB---I- - +00:00:05 201 (0) item.cmx ONb---i- - +00:00:05 204 (0) breadth.mli.depends Onb---i- \ +00:00:05 208 (0) invariant.ml.depends Onb---i- \ +00:00:06 212 (0) invariant.cmx ONb---i- | +00:00:06 213 (0) inliner.cmx ONb---i- | +00:00:06 214 (0) code.cmx ONb---i- / +00:00:06 216 (0) back.native ONbP--iL - +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. +Finished, 216 targets (0 cached) in 00:00:06. diff --git a/ocamlbuild/test/good-output b/ocamlbuild/test/good-output new file mode 100644 index 00000000..5e8af9f8 --- /dev/null +++ b/ocamlbuild/test/good-output @@ -0,0 +1,1090 @@ + _____ _ ____ +|_ _|__ ___| |_|___ \ + | |/ _ \/ __| __| __) | + | | __/\__ \ |_ / __/ + |_|\___||___/\__|_____| + ++ CMDOPTS='-- -help' ++ BUILD='../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help' ++ BUILD2='../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help' ++ rm -rf _build ++ cp vivi1.ml vivi.ml ++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help +ocamldep.opt -modules toto.ml > toto.ml.depends +ocamldep.opt -modules tata.mli > tata.mli.depends +ocamldep.opt -modules titi.ml > titi.ml.depends +ocamldep.opt -modules tutu.mli > tutu.mli.depends +ocamlc.opt -c -o tata.cmi tata.mli +ocamlc.opt -c -o titi.cmo titi.ml +ocamlc.opt -c -o tutu.cmi tutu.mli +ocamlc.opt -c -o toto.cmo toto.ml +ocamldep.opt -modules tata.ml > tata.ml.depends +ocamldep.opt -modules tutu.ml > tutu.ml.depends +ocamldep.opt -modules tyty.mli > tyty.mli.depends +ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends +ocamlc.opt -c -o tyty.cmi tyty.mli +ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml +ocamlc.opt -c -o tata.cmo tata.ml +ocamlc.opt -c -o tutu.cmo tutu.ml +ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte +ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml +ocamlopt.opt -c -o tata.cmx tata.ml +ocamlopt.opt -c -o titi.cmx titi.ml +ocamlopt.opt -c -o tutu.cmx tutu.ml +ocamlopt.opt -c -o toto.cmx toto.ml +ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native +Warning: Using -- only run the last target +toto.native: _build/toto.native: Hello world!!! +Tutu.tutu => 1 +Tata.tata => "TATA2" ++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help +[cache hit] ocamldep.opt -modules toto.ml > toto.ml.depends +[cache hit] ocamldep.opt -modules tata.mli > tata.mli.depends +[cache hit] ocamlc.opt -c -o tata.cmi tata.mli +[cache hit] ocamldep.opt -modules titi.ml > titi.ml.depends +[cache hit] ocamlc.opt -c -o titi.cmo titi.ml +[cache hit] ocamldep.opt -modules tutu.mli > tutu.mli.depends +[cache hit] ocamlc.opt -c -o tutu.cmi tutu.mli +[cache hit] ocamlc.opt -c -o toto.cmo toto.ml +[cache hit] ocamldep.opt -modules tata.ml > tata.ml.depends +[cache hit] ocamlc.opt -c -o tata.cmo tata.ml +[cache hit] ocamldep.opt -modules tutu.ml > tutu.ml.depends +[cache hit] ocamldep.opt -modules tyty.mli > tyty.mli.depends +[cache hit] ocamlc.opt -c -o tyty.cmi tyty.mli +[cache hit] ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends +[cache hit] ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml +[cache hit] ocamlc.opt -c -o tutu.cmo tutu.ml +[cache hit] ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte +[cache hit] ocamlopt.opt -c -o tata.cmx tata.ml +[cache hit] ocamlopt.opt -c -o titi.cmx titi.ml +[cache hit] ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml +[cache hit] ocamlopt.opt -c -o tutu.cmx tutu.ml +[cache hit] ocamlopt.opt -c -o toto.cmx toto.ml +[cache hit] ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native +Warning: Using -- only run the last target +toto.native: _build/toto.native: Hello world!!! +Tutu.tutu => 1 +Tata.tata => "TATA2" ++ cp vivi2.ml vivi.ml ++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help +ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends +ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml +ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte +ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml +ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native +Warning: Using -- only run the last target +toto.native: _build/toto.native: Hello world!!! +Tutu.tutu => 1 +Tata.tata => "TATA2" ++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help +[cache hit] ocamldep.opt -modules toto.ml > toto.ml.depends +[cache hit] ocamldep.opt -modules tata.mli > tata.mli.depends +[cache hit] ocamlc.opt -c -o tata.cmi tata.mli +[cache hit] ocamldep.opt -modules titi.ml > titi.ml.depends +[cache hit] ocamlc.opt -c -o titi.cmo titi.ml +[cache hit] ocamldep.opt -modules tutu.mli > tutu.mli.depends +[cache hit] ocamlc.opt -c -o tutu.cmi tutu.mli +[cache hit] ocamlc.opt -c -o toto.cmo toto.ml +[cache hit] ocamldep.opt -modules tata.ml > tata.ml.depends +[cache hit] ocamlc.opt -c -o tata.cmo tata.ml +[cache hit] ocamldep.opt -modules tutu.ml > tutu.ml.depends +[cache hit] ocamldep.opt -modules tyty.mli > tyty.mli.depends +[cache hit] ocamlc.opt -c -o tyty.cmi tyty.mli +[cache hit] ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends +[cache hit] ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml +[cache hit] ocamlc.opt -c -o tutu.cmo tutu.ml +[cache hit] ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte +[cache hit] ocamlopt.opt -c -o tata.cmx tata.ml +[cache hit] ocamlopt.opt -c -o titi.cmx titi.ml +[cache hit] ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml +[cache hit] ocamlopt.opt -c -o tutu.cmx tutu.ml +[cache hit] ocamlopt.opt -c -o toto.cmx toto.ml +[cache hit] ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native +Warning: Using -- only run the last target +toto.native: _build/toto.native: Hello world!!! +Tutu.tutu => 1 +Tata.tata => "TATA2" ++ cp vivi3.ml vivi.ml ++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help +ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends +ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml +ocamlc.opt -c -o tutu.cmo tutu.ml +ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte +ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml +ocamlopt.opt -c -o tutu.cmx tutu.ml +ocamlopt.opt -c -o toto.cmx toto.ml +ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native +Warning: Using -- only run the last target +toto.native: _build/toto.native: Hello world!!! +Tutu.tutu => 2 +Tata.tata => "TATA2" ++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help +[cache hit] ocamldep.opt -modules toto.ml > toto.ml.depends +[cache hit] ocamldep.opt -modules tata.mli > tata.mli.depends +[cache hit] ocamlc.opt -c -o tata.cmi tata.mli +[cache hit] ocamldep.opt -modules titi.ml > titi.ml.depends +[cache hit] ocamlc.opt -c -o titi.cmo titi.ml +[cache hit] ocamldep.opt -modules tutu.mli > tutu.mli.depends +[cache hit] ocamlc.opt -c -o tutu.cmi tutu.mli +[cache hit] ocamlc.opt -c -o toto.cmo toto.ml +[cache hit] ocamldep.opt -modules tata.ml > tata.ml.depends +[cache hit] ocamlc.opt -c -o tata.cmo tata.ml +[cache hit] ocamldep.opt -modules tutu.ml > tutu.ml.depends +[cache hit] ocamldep.opt -modules tyty.mli > tyty.mli.depends +[cache hit] ocamlc.opt -c -o tyty.cmi tyty.mli +[cache hit] ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends +[cache hit] ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml +[cache hit] ocamlc.opt -c -o tutu.cmo tutu.ml +[cache hit] ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte +[cache hit] ocamlopt.opt -c -o tata.cmx tata.ml +[cache hit] ocamlopt.opt -c -o titi.cmx titi.ml +[cache hit] ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml +[cache hit] ocamlopt.opt -c -o tutu.cmx tutu.ml +[cache hit] ocamlopt.opt -c -o toto.cmx toto.ml +[cache hit] ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native +Warning: Using -- only run the last target +toto.native: _build/toto.native: Hello world!!! +Tutu.tutu => 2 +Tata.tata => "TATA2" + _____ _ _____ +|_ _|__ ___| |_|___ / + | |/ _ \/ __| __| |_ \ + | | __/\__ \ |_ ___) | + |_|\___||___/\__|____/ + ++ CMDOTPS= ++ BUILD='../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ rm -rf _build ++ ../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display +ocamldep.opt -modules a.mli > a.mli.depends +ocamlc.opt -c -o a.cmi a.mli +ocamldep.opt -modules a.ml > a.ml.depends +ocamldep.opt -modules b.mli > b.mli.depends +ocamlc.opt -c -o b.cmi b.mli +ocamlc.opt -c -o a.cmo a.ml +ocamldep.opt -modules b.ml > b.ml.depends +ocamldep.opt -modules c.mli > c.mli.depends +ocamlc.opt -c -o c.cmi c.mli +ocamlc.opt -c -o b.cmo b.ml +ocamldep.opt -modules c.ml > c.ml.depends +ocamldep.opt -modules d.mli > d.mli.depends +ocamlc.opt -c -o d.cmi d.mli +ocamlc.opt -c -o c.cmo c.ml +ocamldep.opt -modules d.ml > d.ml.depends +ocamldep.opt -modules e.mli > e.mli.depends +ocamlc.opt -c -o e.cmi e.mli +ocamlc.opt -c -o d.cmo d.ml +ocamldep.opt -modules e.ml > e.ml.depends +ocamldep.opt -modules f.mli > f.mli.depends +ocamlc.opt -c -o f.cmi f.mli +ocamlc.opt -c -o e.cmo e.ml +ocamldep.opt -modules f.ml > f.ml.depends +ocamlc.opt -c -o f.cmo f.ml +ocamlc.opt unix.cma f.cmo e.cmo d.cmo c.cmo b.cmo a.cmo -o a.byte +ocamlopt.opt -c -o f.cmx f.ml +ocamlopt.opt -c -o e.cmx e.ml +ocamlopt.opt -c -o d.cmx d.ml +ocamlopt.opt -c -o c.cmx c.ml +ocamlopt.opt -c -o b.cmx b.ml +ocamlopt.opt -c -o a.cmx a.ml +ocamlopt.opt unix.cmxa f.cmx e.cmx d.cmx c.cmx b.cmx a.cmx -o a.native +ocamldoc.opt -dump a.odoc a.mli +ocamldoc.opt -dump b.odoc b.mli +ocamldoc.opt -dump c.odoc c.mli +ocamldoc.opt -dump d.odoc d.mli +ocamldoc.opt -dump e.odoc e.mli +ocamldoc.opt -dump f.odoc f.mli +rm -rf proj.docdir +mkdir -p proj.docdir +ocamldoc.opt -load a.odoc -load b.odoc -load c.odoc -load d.odoc -load e.odoc -load f.odoc -html -d proj.docdir ++ ../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules a.mli > a.mli.depends +[cache hit] ocamlc.opt -c -o a.cmi a.mli +[cache hit] ocamldep.opt -modules a.ml > a.ml.depends +[cache hit] ocamldep.opt -modules b.mli > b.mli.depends +[cache hit] ocamlc.opt -c -o b.cmi b.mli +[cache hit] ocamlc.opt -c -o a.cmo a.ml +[cache hit] ocamldep.opt -modules b.ml > b.ml.depends +[cache hit] ocamldep.opt -modules c.mli > c.mli.depends +[cache hit] ocamlc.opt -c -o c.cmi c.mli +[cache hit] ocamlc.opt -c -o b.cmo b.ml +[cache hit] ocamldep.opt -modules c.ml > c.ml.depends +[cache hit] ocamldep.opt -modules d.mli > d.mli.depends +[cache hit] ocamlc.opt -c -o d.cmi d.mli +[cache hit] ocamlc.opt -c -o c.cmo c.ml +[cache hit] ocamldep.opt -modules d.ml > d.ml.depends +[cache hit] ocamldep.opt -modules e.mli > e.mli.depends +[cache hit] ocamlc.opt -c -o e.cmi e.mli +[cache hit] ocamlc.opt -c -o d.cmo d.ml +[cache hit] ocamldep.opt -modules e.ml > e.ml.depends +[cache hit] ocamldep.opt -modules f.mli > f.mli.depends +[cache hit] ocamlc.opt -c -o f.cmi f.mli +[cache hit] ocamlc.opt -c -o e.cmo e.ml +[cache hit] ocamldep.opt -modules f.ml > f.ml.depends +[cache hit] ocamlc.opt -c -o f.cmo f.ml +[cache hit] ocamlc.opt unix.cma f.cmo e.cmo d.cmo c.cmo b.cmo a.cmo -o a.byte +[cache hit] ocamlopt.opt -c -o f.cmx f.ml +[cache hit] ocamlopt.opt -c -o e.cmx e.ml +[cache hit] ocamlopt.opt -c -o d.cmx d.ml +[cache hit] ocamlopt.opt -c -o c.cmx c.ml +[cache hit] ocamlopt.opt -c -o b.cmx b.ml +[cache hit] ocamlopt.opt -c -o a.cmx a.ml +[cache hit] ocamlopt.opt unix.cmxa f.cmx e.cmx d.cmx c.cmx b.cmx a.cmx -o a.native +[cache hit] ocamldoc.opt -dump a.odoc a.mli +[cache hit] ocamldoc.opt -dump b.odoc b.mli +[cache hit] ocamldoc.opt -dump c.odoc c.mli +[cache hit] ocamldoc.opt -dump d.odoc d.mli +[cache hit] ocamldoc.opt -dump e.odoc e.mli +[cache hit] ocamldoc.opt -dump f.odoc f.mli +[cache hit] rm -rf proj.docdir +[cache hit] mkdir -p proj.docdir +[cache hit] ocamldoc.opt -load a.odoc -load b.odoc -load c.odoc -load d.odoc -load e.odoc -load f.odoc -html -d proj.docdir + _____ _ _ _ +|_ _|__ ___| |_| || | + | |/ _ \/ __| __| || |_ + | | __/\__ \ |_|__ _| + |_|\___||___/\__| |_| + ++ CMDOTPS= ++ BUILD='../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ rm -rf _build ++ ../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display +ocamldep.opt -modules a/aa.mli > a/aa.mli.depends +ocamlc.opt -c -I a -I b -o a/aa.cmi a/aa.mli +ocamldep.opt -modules a/aa.ml > a/aa.ml.depends +ocamldep.opt -modules b/bb.ml > b/bb.ml.depends +ocamlc.opt -c -I b -I a -o b/bb.cmo b/bb.ml +ocamlc.opt -c -I a -I b -o a/aa.cmo a/aa.ml +ocamlc.opt str.cma b/bb.cmo a/aa.cmo -o a/aa.byte +ocamlopt.opt -c -I b -I a -o b/bb.cmx b/bb.ml +ocamlopt.opt -c -I a -I b -o a/aa.cmx a/aa.ml +ocamlopt.opt str.cmxa b/bb.cmx a/aa.cmx -o a/aa.native ++ ../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules a/aa.mli > a/aa.mli.depends +[cache hit] ocamlc.opt -c -I a -I b -o a/aa.cmi a/aa.mli +[cache hit] ocamldep.opt -modules a/aa.ml > a/aa.ml.depends +[cache hit] ocamldep.opt -modules b/bb.ml > b/bb.ml.depends +[cache hit] ocamlc.opt -c -I b -I a -o b/bb.cmo b/bb.ml +[cache hit] ocamlc.opt -c -I a -I b -o a/aa.cmo a/aa.ml +[cache hit] ocamlc.opt str.cma b/bb.cmo a/aa.cmo -o a/aa.byte +[cache hit] ocamlopt.opt -c -I b -I a -o b/bb.cmx b/bb.ml +[cache hit] ocamlopt.opt -c -I a -I b -o a/aa.cmx a/aa.ml +[cache hit] ocamlopt.opt str.cmxa b/bb.cmx a/aa.cmx -o a/aa.native + _____ _ ____ +|_ _|__ ___| |_| ___| + | |/ _ \/ __| __|___ \ + | | __/\__ \ |_ ___) | + |_|\___||___/\__|____/ + ++ CMDOPTS= ++ BUILD='../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ rm -rf _build ++ ../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display +ocamldep.opt -modules d.ml > d.ml.depends +ocamldep.opt -modules a.mli > a.mli.depends +ocamlc.opt -c -o a.cmi a.mli +ocamldep.opt -modules a.ml > a.ml.depends +ocamldep.opt -modules stack.ml > stack.ml.depends +ocamlc.opt -c -o stack.cmo stack.ml +ocamldep.opt -modules b.ml > b.ml.depends +ocamlc.opt -c -o a.cmo a.ml +ocamlc.opt -c -o b.cmo b.ml +ocamlc.opt -pack a.cmo b.cmo -o c.cmo +ocamlc.opt -c -o d.cmo d.ml +ocamlc.opt stack.cmo c.cmo d.cmo -o d.byte +ocamlopt.opt -c -o stack.cmx stack.ml +ocamlopt.opt -c -for-pack C -o a.cmx a.ml +ocamlopt.opt -c -for-pack C -o b.cmx b.ml +touch c.mli ; if ocamlopt.opt -pack a.cmx b.cmx -o c.cmx ; then rm -f c.mli ; else rm -f c.mli ; exit 1; fi +ocamlopt.opt -c -o d.cmx d.ml +ocamlopt.opt stack.cmx c.cmx d.cmx -o d.native ++ ../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules d.ml > d.ml.depends +[cache hit] ocamldep.opt -modules a.mli > a.mli.depends +[cache hit] ocamlc.opt -c -o a.cmi a.mli +[cache hit] ocamldep.opt -modules a.ml > a.ml.depends +[cache hit] ocamldep.opt -modules stack.ml > stack.ml.depends +[cache hit] ocamlc.opt -c -o stack.cmo stack.ml +[cache hit] ocamlc.opt -c -o a.cmo a.ml +[cache hit] ocamldep.opt -modules b.ml > b.ml.depends +[cache hit] ocamlc.opt -c -o b.cmo b.ml +[cache hit] ocamlc.opt -pack a.cmo b.cmo -o c.cmo +[cache hit] ocamlc.opt -c -o d.cmo d.ml +[cache hit] ocamlc.opt stack.cmo c.cmo d.cmo -o d.byte +[cache hit] ocamlopt.opt -c -o stack.cmx stack.ml +[cache hit] ocamlopt.opt -c -for-pack C -o a.cmx a.ml +[cache hit] ocamlopt.opt -c -for-pack C -o b.cmx b.ml +[cache hit] touch c.mli ; if ocamlopt.opt -pack a.cmx b.cmx -o c.cmx ; then rm -f c.mli ; else rm -f c.mli ; exit 1; fi +[cache hit] ocamlopt.opt -c -o d.cmx d.ml +[cache hit] ocamlopt.opt stack.cmx c.cmx d.cmx -o d.native + _____ _ __ +|_ _|__ ___| |_ / /_ + | |/ _ \/ __| __| '_ \ + | | __/\__ \ |_| (_) | + |_|\___||___/\__|\___/ + ++ rm -rf _build ++ CMDOPTS= ++ BUILD='../../_build/ocamlbuild.native -no-skip main.byte -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native -no-skip main.byte -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native -no-skip main.byte -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ cp b.mli.v1 b.mli ++ cp d.mli.v1 d.mli ++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display +ocamldep.opt -modules main.mli > main.mli.depends +ocamlc.opt -c -o main.cmi main.mli +ocamldep.opt -modules main.ml > main.ml.depends +ocamldep.opt -modules a.mli > a.mli.depends +ocamldep.opt -modules d.mli > d.mli.depends +ocamlc.opt -c -o a.cmi a.mli +ocamlc.opt -c -o d.cmi d.mli +ocamlc.opt -c -o main.cmo main.ml +ocamldep.opt -modules a.ml > a.ml.depends +ocamldep.opt -modules b.mli > b.mli.depends +ocamlc.opt -c -o b.cmi b.mli +ocamldep.opt -modules d.ml > d.ml.depends +ocamlc.opt -c -o a.cmo a.ml +ocamlc.opt -c -o d.cmo d.ml +ocamldep.opt -modules b.ml > b.ml.depends +ocamlc.opt -c -o b.cmo b.ml +ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte ++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules main.mli > main.mli.depends +[cache hit] ocamlc.opt -c -o main.cmi main.mli +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules a.mli > a.mli.depends +[cache hit] ocamlc.opt -c -o a.cmi a.mli +[cache hit] ocamldep.opt -modules d.mli > d.mli.depends +[cache hit] ocamlc.opt -c -o d.cmi d.mli +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules a.ml > a.ml.depends +[cache hit] ocamldep.opt -modules b.mli > b.mli.depends +[cache hit] ocamlc.opt -c -o b.cmi b.mli +[cache hit] ocamlc.opt -c -o a.cmo a.ml +[cache hit] ocamldep.opt -modules d.ml > d.ml.depends +[cache hit] ocamlc.opt -c -o d.cmo d.ml +[cache hit] ocamldep.opt -modules b.ml > b.ml.depends +[cache hit] ocamlc.opt -c -o b.cmo b.ml +[cache hit] ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte ++ cp b.mli.v2 b.mli ++ cp d.mli.v2 d.mli ++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display +ocamldep.opt -modules d.mli > d.mli.depends +ocamlc.opt -c -o d.cmi d.mli +ocamlc.opt -c -o main.cmo main.ml +ocamldep.opt -modules b.mli > b.mli.depends ++ ocamldep.opt -modules b.mli > b.mli.depends +File "b.mli", line 1, characters 0-2: +Syntax error +Command exited with code 2. ++ cp b.mli.v1 b.mli ++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display +ocamldep.opt -modules b.mli > b.mli.depends +ocamlc.opt -c -o b.cmi b.mli +ocamlc.opt -c -o d.cmo d.ml +ocamlc.opt -c -o b.cmo b.ml +ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte ++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules main.mli > main.mli.depends +[cache hit] ocamlc.opt -c -o main.cmi main.mli +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules a.mli > a.mli.depends +[cache hit] ocamlc.opt -c -o a.cmi a.mli +[cache hit] ocamldep.opt -modules d.mli > d.mli.depends +[cache hit] ocamlc.opt -c -o d.cmi d.mli +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules a.ml > a.ml.depends +[cache hit] ocamldep.opt -modules b.mli > b.mli.depends +[cache hit] ocamlc.opt -c -o b.cmi b.mli +[cache hit] ocamlc.opt -c -o a.cmo a.ml +[cache hit] ocamldep.opt -modules d.ml > d.ml.depends +[cache hit] ocamlc.opt -c -o d.cmo d.ml +[cache hit] ocamldep.opt -modules b.ml > b.ml.depends +[cache hit] ocamlc.opt -c -o b.cmo b.ml +[cache hit] ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte ++ echo PASS +PASS + _____ _ _____ +|_ _|__ ___| ||___ | + | |/ _ \/ __| __| / / + | | __/\__ \ |_ / / + |_|\___||___/\__/_/ + ++ CMDOPTS= ++ BUILD='../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ rm -rf _build ++ cp bb1.ml bb.ml ++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display +ocamlopt.opt -I /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild unix.cmxa /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuildlib.cmxa myocamlbuild.ml /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuild.cmx -o myocamlbuild +ocamldep.opt -modules bb.mli > bb.mli.depends +ocamlc.opt -c -o bb.cmi bb.mli +ocamldep.opt -modules bb.ml > bb.ml.depends +ocamldep.opt -modules cc.ml > cc.ml.depends +ocamldep.opt -modules aa.ml > aa.ml.depends +ocamldep.opt -modules c2.mli > c2.mli.depends +ocamlc.opt -c -o aa.cmo aa.ml +ocamlc.opt -c -o c2.cmi c2.mli +ocamlc.opt -c -o bb.cmo bb.ml +ocamlc.opt -c -o cc.cmo cc.ml +ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma +ocamldep.opt -modules main.ml > main.ml.depends +ocamldep.opt -modules c3.ml > c3.ml.depends +ocamlc.opt -c -o c3.cmo c3.ml +ocamlc.opt -c -o main.cmo main.ml +ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends +ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml +ocamldep.opt -modules c2.ml > c2.ml.depends +ocamlc.opt -c -o c2.cmo c2.ml +ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte +ocamlopt.opt -c -o bb.cmx bb.ml +ocamlopt.opt -c -o aa.cmx aa.ml +ocamlopt.opt -c -o c2.cmx c2.ml +ocamlopt.opt -c -o cc.cmx cc.ml +ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa +ocamlopt.opt -c -o c3.cmx c3.ml +ocamlopt.opt -c -o main.cmx main.ml +ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native ++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends +[cache hit] ocamlc.opt -c -o bb.cmi bb.mli +[cache hit] ocamldep.opt -modules bb.ml > bb.ml.depends +[cache hit] ocamlc.opt -c -o bb.cmo bb.ml +[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends +[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends +[cache hit] ocamlc.opt -c -o aa.cmo aa.ml +[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends +[cache hit] ocamlc.opt -c -o c2.cmi c2.mli +[cache hit] ocamlc.opt -c -o cc.cmo cc.ml +[cache hit] ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends +[cache hit] ocamlc.opt -c -o c3.cmo c3.ml +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends +[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml +[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends +[cache hit] ocamlc.opt -c -o c2.cmo c2.ml +[cache hit] ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte +[cache hit] ocamlopt.opt -c -o bb.cmx bb.ml +[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml +[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml +[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml +[cache hit] ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa +[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml +[cache hit] ocamlopt.opt -c -o main.cmx main.ml +[cache hit] ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native ++ cp bb2.ml bb.ml ++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 +[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends +[cache hit] ocamlc.opt -c -o bb.cmi bb.mli +ocamldep.opt -modules bb.ml > bb.ml.depends +[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends +[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends +[cache hit] ocamlc.opt -c -o aa.cmo aa.ml +[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends +[cache hit] ocamlc.opt -c -o c2.cmi c2.mli +[cache hit] ocamlc.opt -c -o cc.cmo cc.ml +ocamlc.opt -c -o bb.cmo bb.ml +ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends +[cache hit] ocamlc.opt -c -o c3.cmo c3.ml +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends +[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml +[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends +[cache hit] ocamlc.opt -c -o c2.cmo c2.ml +ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte +[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml +ocamlopt.opt -c -o bb.cmx bb.ml +[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml +ocamlopt.opt -c -o cc.cmx cc.ml +ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa +ocamlopt.opt -c -o c3.cmx c3.ml +ocamlopt.opt -c -o main.cmx main.ml +ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native ++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends +[cache hit] ocamlc.opt -c -o bb.cmi bb.mli +[cache hit] ocamldep.opt -modules bb.ml > bb.ml.depends +[cache hit] ocamlc.opt -c -o bb.cmo bb.ml +[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends +[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends +[cache hit] ocamlc.opt -c -o aa.cmo aa.ml +[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends +[cache hit] ocamlc.opt -c -o c2.cmi c2.mli +[cache hit] ocamlc.opt -c -o cc.cmo cc.ml +[cache hit] ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends +[cache hit] ocamlc.opt -c -o c3.cmo c3.ml +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends +[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml +[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends +[cache hit] ocamlc.opt -c -o c2.cmo c2.ml +[cache hit] ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte +[cache hit] ocamlopt.opt -c -o bb.cmx bb.ml +[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml +[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml +[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml +[cache hit] ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa +[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml +[cache hit] ocamlopt.opt -c -o main.cmx main.ml +[cache hit] ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native ++ cp bb3.ml bb.ml ++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 +[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends +[cache hit] ocamlc.opt -c -o bb.cmi bb.mli +ocamldep.opt -modules bb.ml > bb.ml.depends +[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends +[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends +[cache hit] ocamlc.opt -c -o aa.cmo aa.ml +[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends +[cache hit] ocamlc.opt -c -o c2.cmi c2.mli +[cache hit] ocamlc.opt -c -o cc.cmo cc.ml +ocamlc.opt -c -o bb.cmo bb.ml +ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends +[cache hit] ocamlc.opt -c -o c3.cmo c3.ml +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends +[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml +[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends +[cache hit] ocamlc.opt -c -o c2.cmo c2.ml +ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte +[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml +ocamlopt.opt -c -o bb.cmx bb.ml +[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml +[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml +ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa +[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml +[cache hit] ocamlopt.opt -c -o main.cmx main.ml +ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native ++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends +[cache hit] ocamlc.opt -c -o bb.cmi bb.mli +[cache hit] ocamldep.opt -modules bb.ml > bb.ml.depends +[cache hit] ocamlc.opt -c -o bb.cmo bb.ml +[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends +[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends +[cache hit] ocamlc.opt -c -o aa.cmo aa.ml +[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends +[cache hit] ocamlc.opt -c -o c2.cmi c2.mli +[cache hit] ocamlc.opt -c -o cc.cmo cc.ml +[cache hit] ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma +[cache hit] ocamldep.opt -modules main.ml > main.ml.depends +[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends +[cache hit] ocamlc.opt -c -o c3.cmo c3.ml +[cache hit] ocamlc.opt -c -o main.cmo main.ml +[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends +[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml +[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends +[cache hit] ocamlc.opt -c -o c2.cmo c2.ml +[cache hit] ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte +[cache hit] ocamlopt.opt -c -o bb.cmx bb.ml +[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml +[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml +[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml +[cache hit] ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa +[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml +[cache hit] ocamlopt.opt -c -o main.cmx main.ml +[cache hit] ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native + _____ _ ___ +|_ _|__ ___| |_( _ ) + | |/ _ \/ __| __/ _ \ + | | __/\__ \ || (_) | + |_|\___||___/\__\___/ + ++ CMDOPTS= ++ BUILD='../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ rm -rf _build ++ ../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display +ocamlopt.opt -I /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild unix.cmxa /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuildlib.cmxa myocamlbuild.ml /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuild.cmx -o myocamlbuild +ocamldep.opt -modules a.ml > a.ml.depends +ocamldep.opt -modules myconfig.ml > myconfig.ml.depends +ocamlc.opt -c -o myconfig.cmo myconfig.ml +ocamlc.opt -c -o a.cmo a.ml +ocamlc.opt myconfig.cmo a.cmo -o a.byte +ocamlopt.opt -c -o myconfig.cmx myconfig.ml +ocamlopt.opt -c -o a.cmx a.ml +ocamlopt.opt myconfig.cmx a.cmx -o a.native +cp -p a.byte a +cp -p a.native a.opt +cp -p a.byte bin/a.byte +cp -p bin/a.byte bin/a +cp -p a.native bin/a.native +cp -p bin/a.native bin/a.opt ++ ../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] ocamldep.opt -modules a.ml > a.ml.depends +[cache hit] ocamldep.opt -modules myconfig.ml > myconfig.ml.depends +[cache hit] ocamlc.opt -c -o myconfig.cmo myconfig.ml +[cache hit] ocamlc.opt -c -o a.cmo a.ml +[cache hit] ocamlc.opt myconfig.cmo a.cmo -o a.byte +[cache hit] ocamlopt.opt -c -o myconfig.cmx myconfig.ml +[cache hit] ocamlopt.opt -c -o a.cmx a.ml +[cache hit] ocamlopt.opt myconfig.cmx a.cmx -o a.native +[cache hit] cp -p a.byte a +[cache hit] cp -p a.native a.opt +[cache hit] cp -p a.byte bin/a.byte +[cache hit] cp -p bin/a.byte bin/a +[cache hit] cp -p a.native bin/a.native +[cache hit] cp -p bin/a.native bin/a.opt + _____ _ ___ +|_ _|__ ___| |_ / _ \ + | |/ _ \/ __| __| (_) | + | | __/\__ \ |_ \__, | + |_|\___||___/\__| /_/ + +++ dirname ./test9/test.sh ++ cd ./test9/../.. ++ ./_build/ocamlbuild.native -quiet -build-dir _buildtest -no-links test/test9/testglob.native ++ ./_buildtest/test/test9/testglob.native +Globexp for "\"hello\"" OK +Globexp for "" OK +Globexp for "" OK +Globexp for " and or " OK +Globexp for " titi" OK +Glob.eval "<[a]>" "a" = true OK +Glob.eval "<[a]>" "b" = false OK +Glob.eval "<[a]>" "a" = true OK +Glob.eval "<[a]>" "b" = false OK +Glob.eval "<[a]>" "a" = true OK +Glob.eval "<[a]>" "b" = false OK +Glob.eval "<[a-z]>" "a" = true OK +Glob.eval "<[a-z]>" "e" = true OK +Glob.eval "<[a-z]>" "k" = true OK +Glob.eval "<[a-z]>" "z" = true OK +Glob.eval "<[a-z]>" "0" = false OK +Glob.eval "<[a-z]>" "A" = false OK +Glob.eval "<[a-z]>" "~" = false OK +Glob.eval "<[a-z]>" "a" = true OK +Glob.eval "<[a-z]>" "e" = true OK +Glob.eval "<[a-z]>" "k" = true OK +Glob.eval "<[a-z]>" "z" = true OK +Glob.eval "<[a-z]>" "0" = false OK +Glob.eval "<[a-z]>" "A" = false OK +Glob.eval "<[a-z]>" "~" = false OK +Glob.eval "<[a-z]>" "a" = true OK +Glob.eval "<[a-z]>" "e" = true OK +Glob.eval "<[a-z]>" "k" = true OK +Glob.eval "<[a-z]>" "z" = true OK +Glob.eval "<[a-z]>" "0" = false OK +Glob.eval "<[a-z]>" "A" = false OK +Glob.eval "<[a-z]>" "~" = false OK +Glob.eval "<[a-z][0-9]>" "a0" = true OK +Glob.eval "<[a-z][0-9]>" "b9" = true OK +Glob.eval "<[a-z][0-9]>" "a00" = false OK +Glob.eval "<[a-z][0-9]>" "a0a" = false OK +Glob.eval "<[a-z][0-9]>" "b0a" = false OK +Glob.eval "<[a-z][0-9]>" "isduis" = false OK +Glob.eval "<[a-z][0-9]>" "" = false OK +Glob.eval "<[a-z][0-9]>" "a0" = true OK +Glob.eval "<[a-z][0-9]>" "b9" = true OK +Glob.eval "<[a-z][0-9]>" "a00" = false OK +Glob.eval "<[a-z][0-9]>" "a0a" = false OK +Glob.eval "<[a-z][0-9]>" "b0a" = false OK +Glob.eval "<[a-z][0-9]>" "isduis" = false OK +Glob.eval "<[a-z][0-9]>" "" = false OK +Glob.eval "<[a-z][0-9]>" "a0" = true OK +Glob.eval "<[a-z][0-9]>" "b9" = true OK +Glob.eval "<[a-z][0-9]>" "a00" = false OK +Glob.eval "<[a-z][0-9]>" "a0a" = false OK +Glob.eval "<[a-z][0-9]>" "b0a" = false OK +Glob.eval "<[a-z][0-9]>" "isduis" = false OK +Glob.eval "<[a-z][0-9]>" "" = false OK +Glob.eval "" "hello" = true OK +Glob.eval "" "helli" = false OK +Glob.eval "" "hello" = true OK +Glob.eval "" "helli" = false OK +Glob.eval "" "hello" = true OK +Glob.eval "" "helli" = false OK +Glob.eval "\"hello\"" "hello" = true OK +Glob.eval "\"hello\"" "heidi" = false OK +Glob.eval "\"hello\"" "hello" = true OK +Glob.eval "\"hello\"" "heidi" = false OK +Glob.eval "\"hello\"" "hello" = true OK +Glob.eval "\"hello\"" "heidi" = false OK +Glob.eval "<*>" "" = true OK +Glob.eval "<*>" "a" = true OK +Glob.eval "<*>" "ax" = true OK +Glob.eval "<*>" "" = true OK +Glob.eval "<*>" "a" = true OK +Glob.eval "<*>" "ax" = true OK +Glob.eval "<*>" "" = true OK +Glob.eval "<*>" "a" = true OK +Glob.eval "<*>" "ax" = true OK +Glob.eval "" "ab" = true OK +Glob.eval "" "acb" = true OK +Glob.eval "" "axxxxxb" = true OK +Glob.eval "" "ababbababb" = true OK +Glob.eval "" "abx" = false OK +Glob.eval "" "xxxxxab" = false OK +Glob.eval "" "xab" = false OK +Glob.eval "" "ab" = true OK +Glob.eval "" "acb" = true OK +Glob.eval "" "axxxxxb" = true OK +Glob.eval "" "ababbababb" = true OK +Glob.eval "" "abx" = false OK +Glob.eval "" "xxxxxab" = false OK +Glob.eval "" "xab" = false OK +Glob.eval "" "ab" = true OK +Glob.eval "" "acb" = true OK +Glob.eval "" "axxxxxb" = true OK +Glob.eval "" "ababbababb" = true OK +Glob.eval "" "abx" = false OK +Glob.eval "" "xxxxxab" = false OK +Glob.eval "" "xab" = false OK +Glob.eval "<*.ml>" "hello.ml" = true OK +Glob.eval "<*.ml>" ".ml" = true OK +Glob.eval "<*.ml>" "ml" = false OK +Glob.eval "<*.ml>" "" = false OK +Glob.eval "<*.ml>" "toto.mli" = false OK +Glob.eval "<*.ml>" "hello.ml" = true OK +Glob.eval "<*.ml>" ".ml" = true OK +Glob.eval "<*.ml>" "ml" = false OK +Glob.eval "<*.ml>" "" = false OK +Glob.eval "<*.ml>" "toto.mli" = false OK +Glob.eval "<*.ml>" "hello.ml" = true OK +Glob.eval "<*.ml>" ".ml" = true OK +Glob.eval "<*.ml>" "ml" = false OK +Glob.eval "<*.ml>" "" = false OK +Glob.eval "<*.ml>" "toto.mli" = false OK +Glob.eval "" "a" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "aa" = false OK +Glob.eval "" "ba" = false OK +Glob.eval "" "ab" = false OK +Glob.eval "" "abaa" = false OK +Glob.eval "" "a" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "aa" = false OK +Glob.eval "" "ba" = false OK +Glob.eval "" "ab" = false OK +Glob.eval "" "abaa" = false OK +Glob.eval "" "a" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "aa" = false OK +Glob.eval "" "ba" = false OK +Glob.eval "" "ab" = false OK +Glob.eval "" "abaa" = false OK +Glob.eval "" "ab" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "abab" = false OK +Glob.eval "" "aba" = false OK +Glob.eval "" "abx" = false OK +Glob.eval "" "ab" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "abab" = false OK +Glob.eval "" "aba" = false OK +Glob.eval "" "abx" = false OK +Glob.eval "" "ab" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "abab" = false OK +Glob.eval "" "aba" = false OK +Glob.eval "" "abx" = false OK +Glob.eval "" "abac" = true OK +Glob.eval "" "abxc" = true OK +Glob.eval "" "abab" = false OK +Glob.eval "" "ababab" = false OK +Glob.eval "" "ababa" = false OK +Glob.eval "" "abac" = true OK +Glob.eval "" "abxc" = true OK +Glob.eval "" "abab" = false OK +Glob.eval "" "ababab" = false OK +Glob.eval "" "ababa" = false OK +Glob.eval "" "abac" = true OK +Glob.eval "" "abxc" = true OK +Glob.eval "" "abab" = false OK +Glob.eval "" "ababab" = false OK +Glob.eval "" "ababa" = false OK +Glob.eval "<*ab?cd*>" "123abecd345" = true OK +Glob.eval "<*ab?cd*>" "abccd" = true OK +Glob.eval "<*ab?cd*>" "abccd345" = true OK +Glob.eval "<*ab?cd*>" "ababcababccdab" = true OK +Glob.eval "<*ab?cd*>" "abcd" = false OK +Glob.eval "<*ab?cd*>" "aaaaabcdababcd" = false OK +Glob.eval "<*ab?cd*>" "123abecd345" = true OK +Glob.eval "<*ab?cd*>" "abccd" = true OK +Glob.eval "<*ab?cd*>" "abccd345" = true OK +Glob.eval "<*ab?cd*>" "ababcababccdab" = true OK +Glob.eval "<*ab?cd*>" "abcd" = false OK +Glob.eval "<*ab?cd*>" "aaaaabcdababcd" = false OK +Glob.eval "<*ab?cd*>" "123abecd345" = true OK +Glob.eval "<*ab?cd*>" "abccd" = true OK +Glob.eval "<*ab?cd*>" "abccd345" = true OK +Glob.eval "<*ab?cd*>" "ababcababccdab" = true OK +Glob.eval "<*ab?cd*>" "abcd" = false OK +Glob.eval "<*ab?cd*>" "aaaaabcdababcd" = false OK +Glob.eval "<*this*is*a*test*>" "this is a test" = true OK +Glob.eval "<*this*is*a*test*>" "You know this is a test really" = true OK +Glob.eval "<*this*is*a*test*>" "thisisatest" = true OK +Glob.eval "<*this*is*a*test*>" "thisatest" = false OK +Glob.eval "<*this*is*a*test*>" "this is a test" = true OK +Glob.eval "<*this*is*a*test*>" "You know this is a test really" = true OK +Glob.eval "<*this*is*a*test*>" "thisisatest" = true OK +Glob.eval "<*this*is*a*test*>" "thisatest" = false OK +Glob.eval "<*this*is*a*test*>" "this is a test" = true OK +Glob.eval "<*this*is*a*test*>" "You know this is a test really" = true OK +Glob.eval "<*this*is*a*test*>" "thisisatest" = true OK +Glob.eval "<*this*is*a*test*>" "thisatest" = false OK +Glob.eval "" "bxx" = true OK +Glob.eval "" "bx" = true OK +Glob.eval "" "aaab" = false OK +Glob.eval "" "" = false OK +Glob.eval "" "bxx" = true OK +Glob.eval "" "bx" = true OK +Glob.eval "" "aaab" = false OK +Glob.eval "" "" = false OK +Glob.eval "" "bxx" = true OK +Glob.eval "" "bx" = true OK +Glob.eval "" "aaab" = false OK +Glob.eval "" "" = false OK +Glob.eval "<*>" "" = true OK +Glob.eval "<*>" "a" = true OK +Glob.eval "<*>" "aaa" = true OK +Glob.eval "<*>" "aaaaa" = true OK +Glob.eval "<*>" "" = true OK +Glob.eval "<*>" "a" = true OK +Glob.eval "<*>" "aaa" = true OK +Glob.eval "<*>" "aaaaa" = true OK +Glob.eval "<*>" "" = true OK +Glob.eval "<*>" "a" = true OK +Glob.eval "<*>" "aaa" = true OK +Glob.eval "<*>" "aaaaa" = true OK +Glob.eval "" "a" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "aaa" = false OK +Glob.eval "" "aaaaa" = false OK +Glob.eval "" "a" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "aaa" = false OK +Glob.eval "" "aaaaa" = false OK +Glob.eval "" "a" = true OK +Glob.eval "" "" = false OK +Glob.eval "" "aaa" = false OK +Glob.eval "" "aaaaa" = false OK +Glob.eval "<{a,b}>" "a" = true OK +Glob.eval "<{a,b}>" "b" = true OK +Glob.eval "<{a,b}>" "" = false OK +Glob.eval "<{a,b}>" "aa" = false OK +Glob.eval "<{a,b}>" "ab" = false OK +Glob.eval "<{a,b}>" "ba" = false OK +Glob.eval "<{a,b}>" "bb" = false OK +Glob.eval "<{a,b}>" "c" = false OK +Glob.eval "<{a,b}>" "a" = true OK +Glob.eval "<{a,b}>" "b" = true OK +Glob.eval "<{a,b}>" "" = false OK +Glob.eval "<{a,b}>" "aa" = false OK +Glob.eval "<{a,b}>" "ab" = false OK +Glob.eval "<{a,b}>" "ba" = false OK +Glob.eval "<{a,b}>" "bb" = false OK +Glob.eval "<{a,b}>" "c" = false OK +Glob.eval "<{a,b}>" "a" = true OK +Glob.eval "<{a,b}>" "b" = true OK +Glob.eval "<{a,b}>" "" = false OK +Glob.eval "<{a,b}>" "aa" = false OK +Glob.eval "<{a,b}>" "ab" = false OK +Glob.eval "<{a,b}>" "ba" = false OK +Glob.eval "<{a,b}>" "bb" = false OK +Glob.eval "<{a,b}>" "c" = false OK +Glob.eval "" "toto.ml" = true OK +Glob.eval "" "toto.mli" = true OK +Glob.eval "" "toto." = false OK +Glob.eval "" "toto.mll" = false OK +Glob.eval "" "toto.ml" = true OK +Glob.eval "" "toto.mli" = true OK +Glob.eval "" "toto." = false OK +Glob.eval "" "toto.mll" = false OK +Glob.eval "" "toto.ml" = true OK +Glob.eval "" "toto.mli" = true OK +Glob.eval "" "toto." = false OK +Glob.eval "" "toto.mll" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "acf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "acg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "adf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "adg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aef" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aeg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bef" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "beg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "afg" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "af" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aee" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "acf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "acg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "adf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "adg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aef" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aeg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bef" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "beg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "afg" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "af" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aee" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "acf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "acg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "adf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "adg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aef" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aeg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdf" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "bef" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "beg" = true OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "afg" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "af" = false OK +Glob.eval "<{a,b}{c,[de]}{f,g}>" "aee" = false OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.ml" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "b.ml" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "hello.ml" = false OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli.x" = false OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.ml" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "b.ml" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "hello.ml" = false OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli.x" = false OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.ml" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "b.ml" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli" = true OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "hello.ml" = false OK +Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli.x" = false OK +Glob.eval "<*>" "alpha" = true OK +Glob.eval "<*>" "beta" = true OK +Glob.eval "<*>" "alpha/beta" = false OK +Glob.eval "<*>" "gamma/delta" = false OK +Glob.eval "<*>" "alpha" = true OK +Glob.eval "<*>" "beta" = true OK +Glob.eval "<*>" "alpha/beta" = false OK +Glob.eval "<*>" "gamma/delta" = false OK +Glob.eval "<*>" "alpha" = true OK +Glob.eval "<*>" "beta" = true OK +Glob.eval "<*>" "alpha/beta" = false OK +Glob.eval "<*>" "gamma/delta" = false OK +Glob.eval "" "alpha/beta" = true OK +Glob.eval "" "alpha/gamma/beta" = true OK +Glob.eval "" "alpha/gamma/delta/beta" = true OK +Glob.eval "" "alpha" = false OK +Glob.eval "" "beta" = false OK +Glob.eval "" "gamma/delta" = false OK +Glob.eval "" "alpha/beta" = true OK +Glob.eval "" "alpha/gamma/beta" = true OK +Glob.eval "" "alpha/gamma/delta/beta" = true OK +Glob.eval "" "alpha" = false OK +Glob.eval "" "beta" = false OK +Glob.eval "" "gamma/delta" = false OK +Glob.eval "" "alpha/beta" = true OK +Glob.eval "" "alpha/gamma/beta" = true OK +Glob.eval "" "alpha/gamma/delta/beta" = true OK +Glob.eval "" "alpha" = false OK +Glob.eval "" "beta" = false OK +Glob.eval "" "gamma/delta" = false OK +Glob.eval "<**/*.ml>" "toto.ml" = true OK +Glob.eval "<**/*.ml>" "toto/tata.ml" = true OK +Glob.eval "<**/*.ml>" "alpha/gamma/delta/beta.ml" = true OK +Glob.eval "<**/*.ml>" "toto.mli" = false OK +Glob.eval "<**/*.ml>" "toto.ml" = true OK +Glob.eval "<**/*.ml>" "toto/tata.ml" = true OK +Glob.eval "<**/*.ml>" "alpha/gamma/delta/beta.ml" = true OK +Glob.eval "<**/*.ml>" "toto.mli" = false OK +Glob.eval "<**/*.ml>" "toto.ml" = true OK +Glob.eval "<**/*.ml>" "toto/tata.ml" = true OK +Glob.eval "<**/*.ml>" "alpha/gamma/delta/beta.ml" = true OK +Glob.eval "<**/*.ml>" "toto.mli" = false OK +Glob.eval "" "toto/" = true OK +Glob.eval "" "toto/tata" = true OK +Glob.eval "" "toto/alpha/gamma/delta/beta.ml" = true OK +Glob.eval "" "toto" = true OK +Glob.eval "" "toto2/tata" = false OK +Glob.eval "" "tata/titi" = false OK +Glob.eval "" "toto/" = true OK +Glob.eval "" "toto/tata" = true OK +Glob.eval "" "toto/alpha/gamma/delta/beta.ml" = true OK +Glob.eval "" "toto" = true OK +Glob.eval "" "toto2/tata" = false OK +Glob.eval "" "tata/titi" = false OK +Glob.eval "" "toto/" = true OK +Glob.eval "" "toto/tata" = true OK +Glob.eval "" "toto/alpha/gamma/delta/beta.ml" = true OK +Glob.eval "" "toto" = true OK +Glob.eval "" "toto2/tata" = false OK +Glob.eval "" "tata/titi" = false OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/bar/libfoo.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibs/unix/libunix.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibsliblib/unlibix/libunix.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo/libbar.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/libfoo/boo/libbar.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "bar" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libbar/foo.a" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.b.a" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/bar/libfoo.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibs/unix/libunix.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibsliblib/unlibix/libunix.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo/libbar.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/libfoo/boo/libbar.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "bar" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libbar/foo.a" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.b.a" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/bar/libfoo.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibs/unix/libunix.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibsliblib/unlibix/libunix.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo/libbar.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/libfoo/boo/libbar.a" OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "bar" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libbar/foo.a" = None OK +Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.b.a" = None OK + _____ _ __ ___ _ _ +|_ _|__ ___| |_ \ \ / (_)_ __| |_ _ _ __ _| | + | |/ _ \/ __| __| \ \ / /| | '__| __| | | |/ _` | | + | | __/\__ \ |_ \ V / | | | | |_| |_| | (_| | | + |_|\___||___/\__| \_/ |_|_| \__|\__,_|\__,_|_| + + _____ _ +|_ _|_ _ _ __ __ _ ___| |_ ___ + | |/ _` | '__/ _` |/ _ \ __/ __| + | | (_| | | | (_| | __/ |_\__ \ + |_|\__,_|_| \__, |\___|\__|___/ + |___/ ++ CMDOPTS= ++ BUILD='../../_build/ocamlbuild.native bar -no-skip -classic-display ' ++ BUILD1='../../_build/ocamlbuild.native bar -no-skip -classic-display ' ++ BUILD2='../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt ' ++ rm -rf _build ++ cp foo1 foo ++ ../../_build/ocamlbuild.native bar -no-skip -classic-display +ocamlopt.opt -I /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild unix.cmxa /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuildlib.cmxa myocamlbuild.ml /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuild.cmx -o myocamlbuild +cp foo bar ++ ../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] cp foo bar ++ cp foo2 foo ++ ../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 +cp foo bar ++ ../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt +[cache hit] cp foo bar ++ rm foo diff --git a/ocamlbuild/test/runtest.sh b/ocamlbuild/test/runtest.sh new file mode 100755 index 00000000..215360fb --- /dev/null +++ b/ocamlbuild/test/runtest.sh @@ -0,0 +1,36 @@ +#!/bin/sh +set -e +cd `dirname $0` + +myfiglet() { + figlet $@ | sed 's/ *$//' +} + +if figlet ""; then + BANNER=myfiglet +else + echo "Install figlet to have a better output, press enter to continue with echo" + read + BANNER=echo +fi + +HERE=`pwd` + +$BANNER Test2 +./test2/test.sh $@ +$BANNER Test3 +./test3/test.sh $@ +$BANNER Test4 +./test4/test.sh $@ +$BANNER Test5 +./test5/test.sh $@ +$BANNER Test6 +./test6/test.sh $@ +$BANNER Test7 +./test7/test.sh $@ +$BANNER Test8 +./test8/test.sh $@ +$BANNER Test9 +./test9/test.sh $@ +$BANNER Test Virtual Targets +./test_virtual/test.sh $@ diff --git a/ocamlbuild/test/test1/foo.ml b/ocamlbuild/test/test1/foo.ml new file mode 100644 index 00000000..43a51065 --- /dev/null +++ b/ocamlbuild/test/test1/foo.ml @@ -0,0 +1 @@ +module MA1 = A1 diff --git a/ocamlbuild/test/test10/dbdi b/ocamlbuild/test/test10/dbdi new file mode 100644 index 00000000..7f548108 --- /dev/null +++ b/ocamlbuild/test/test10/dbdi @@ -0,0 +1,12 @@ +#load "discard_printf.cmo";; +#load "debug.cmo";; +#load "unix.cma";; +#load "str.cma";; +#load "my_unix.cmo";; +#load "bool.cmo";; +#load "glob_ast.cmo";; +#load "glob_lexer.cmo";; +#load "glob.cmo";; +#load "lexers.cmo";; +#load "my_std.cmo";; +#load "tags.cmo";; diff --git a/ocamlbuild/test/test10/test.sh b/ocamlbuild/test/test10/test.sh new file mode 100755 index 00000000..1f96443c --- /dev/null +++ b/ocamlbuild/test/test10/test.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -e +set -x +cd `dirname $0`/../.. +./_build/ocamlbuild.native -quiet -build-dir _buildtest -no-links test/test9/testglob.native +./_buildtest/test/test9/testglob.native diff --git a/ocamlbuild/test/test11/_tags b/ocamlbuild/test/test11/_tags new file mode 100644 index 00000000..7e620a91 --- /dev/null +++ b/ocamlbuild/test/test11/_tags @@ -0,0 +1,2 @@ +# a comment +"a/aa.byte" or "a/aa.native": use_libb diff --git a/ocamlbuild/test/test11/a/aa.ml b/ocamlbuild/test/test11/a/aa.ml new file mode 100644 index 00000000..411d29bf --- /dev/null +++ b/ocamlbuild/test/test11/a/aa.ml @@ -0,0 +1 @@ +let bar = 3 + List.length Bb.foo diff --git a/ocamlbuild/test/test11/a/aa.mli b/ocamlbuild/test/test11/a/aa.mli new file mode 100644 index 00000000..20f3c52a --- /dev/null +++ b/ocamlbuild/test/test11/a/aa.mli @@ -0,0 +1 @@ +val bar : int diff --git a/ocamlbuild/test/test11/b/bb.ml b/ocamlbuild/test/test11/b/bb.ml new file mode 100644 index 00000000..fa80dc4b --- /dev/null +++ b/ocamlbuild/test/test11/b/bb.ml @@ -0,0 +1 @@ +let foo = [2.2] diff --git a/ocamlbuild/test/test11/b/libb.mllib b/ocamlbuild/test/test11/b/libb.mllib new file mode 100644 index 00000000..d0acbb70 --- /dev/null +++ b/ocamlbuild/test/test11/b/libb.mllib @@ -0,0 +1 @@ +Bb diff --git a/ocamlbuild/test/test11/myocamlbuild.ml b/ocamlbuild/test/test11/myocamlbuild.ml new file mode 100644 index 00000000..b6966c7d --- /dev/null +++ b/ocamlbuild/test/test11/myocamlbuild.ml @@ -0,0 +1,5 @@ +open Ocamlbuild_plugin;; +dispatch begin function +| After_rules -> ocaml_lib "b/libb" +| _ -> () +end diff --git a/ocamlbuild/test/test11/test.sh b/ocamlbuild/test/test11/test.sh new file mode 100755 index 00000000..ed3f9087 --- /dev/null +++ b/ocamlbuild/test/test11/test.sh @@ -0,0 +1,13 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOTPS="" # -- command args +BUILD="../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +$BUILD1 +echo looks if libs are there +ls _build/b/libb.cma _build/b/libb.cmxa _build/b/libb.a +$BUILD2 diff --git a/ocamlbuild/test/test2/_tags b/ocamlbuild/test/test2/_tags new file mode 100644 index 00000000..fc23589a --- /dev/null +++ b/ocamlbuild/test/test2/_tags @@ -0,0 +1,3 @@ +"vivi.ml": camlp4o + +# , some_useless_tag, \ more_useless_tags diff --git a/ocamlbuild/test/test2/tata.ml b/ocamlbuild/test/test2/tata.ml new file mode 100644 index 00000000..361fadd3 --- /dev/null +++ b/ocamlbuild/test/test2/tata.ml @@ -0,0 +1 @@ +let tata = "TATA2" diff --git a/ocamlbuild/test/test2/tata.mli b/ocamlbuild/test/test2/tata.mli new file mode 100644 index 00000000..7c7175c9 --- /dev/null +++ b/ocamlbuild/test/test2/tata.mli @@ -0,0 +1,2 @@ +(* a comment *) +val tata : string diff --git a/ocamlbuild/test/test2/test.sh b/ocamlbuild/test/test2/test.sh new file mode 100755 index 00000000..8bbd7c7a --- /dev/null +++ b/ocamlbuild/test/test2/test.sh @@ -0,0 +1,18 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOPTS="-- -help" +BUILD="../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +cp vivi1.ml vivi.ml +$BUILD1 +$BUILD2 +cp vivi2.ml vivi.ml +$BUILD1 +$BUILD2 +cp vivi3.ml vivi.ml +$BUILD1 +$BUILD2 diff --git a/ocamlbuild/test/test2/titi.ml b/ocamlbuild/test/test2/titi.ml new file mode 100644 index 00000000..3abbf1d2 --- /dev/null +++ b/ocamlbuild/test/test2/titi.ml @@ -0,0 +1 @@ +let titi = [] diff --git a/ocamlbuild/test/test2/toto.ml b/ocamlbuild/test/test2/toto.ml new file mode 100644 index 00000000..dbb5a43d --- /dev/null +++ b/ocamlbuild/test/test2/toto.ml @@ -0,0 +1,5 @@ +let i = Tutu.tutu + 10 +let s = Tata.tata ^ ".ml" +let l = 3 :: Titi.titi +let () = Format.printf "toto.native: %s: Hello world!!!@." Sys.argv.(0) +let () = Format.printf "Tutu.tutu => %d@.Tata.tata => %S@." Tutu.tutu Tata.tata diff --git a/ocamlbuild/test/test2/tutu.ml b/ocamlbuild/test/test2/tutu.ml new file mode 100644 index 00000000..2e8015b7 --- /dev/null +++ b/ocamlbuild/test/test2/tutu.ml @@ -0,0 +1,2 @@ +let tutu = (Array.length Vivi.vivi : Tyty.t) +let tutu' = 2.0 +. float_of_int tutu diff --git a/ocamlbuild/test/test2/tutu.mli b/ocamlbuild/test/test2/tutu.mli new file mode 100644 index 00000000..26657f87 --- /dev/null +++ b/ocamlbuild/test/test2/tutu.mli @@ -0,0 +1,3 @@ +(* a comment *) +val tutu : int +val tutu' : float diff --git a/ocamlbuild/test/test2/tyty.mli b/ocamlbuild/test/test2/tyty.mli new file mode 100644 index 00000000..975adb53 --- /dev/null +++ b/ocamlbuild/test/test2/tyty.mli @@ -0,0 +1 @@ +type t = int diff --git a/ocamlbuild/test/test2/vivi1.ml b/ocamlbuild/test/test2/vivi1.ml new file mode 100644 index 00000000..1c0517e0 --- /dev/null +++ b/ocamlbuild/test/test2/vivi1.ml @@ -0,0 +1,2 @@ +let rec p i = [< '1; '2; p (i + 1) >] +let vivi = [|2|] diff --git a/ocamlbuild/test/test2/vivi2.ml b/ocamlbuild/test/test2/vivi2.ml new file mode 100644 index 00000000..1fb48c17 --- /dev/null +++ b/ocamlbuild/test/test2/vivi2.ml @@ -0,0 +1,2 @@ +let rec p i = [< '1; '2; p (i + 1) >] +let vivi = [|3|] diff --git a/ocamlbuild/test/test2/vivi3.ml b/ocamlbuild/test/test2/vivi3.ml new file mode 100644 index 00000000..7849fad6 --- /dev/null +++ b/ocamlbuild/test/test2/vivi3.ml @@ -0,0 +1,2 @@ +let rec p i = [< '1; '2; p (i + 1) >] +let vivi = [|2.1; 1.1|] diff --git a/ocamlbuild/test/test3/_tags b/ocamlbuild/test/test3/_tags new file mode 100644 index 00000000..4505f13f --- /dev/null +++ b/ocamlbuild/test/test3/_tags @@ -0,0 +1 @@ +"a.byte" or "a.native": use_unix diff --git a/ocamlbuild/test/test3/a.ml b/ocamlbuild/test/test3/a.ml new file mode 100644 index 00000000..d4586eae --- /dev/null +++ b/ocamlbuild/test/test3/a.ml @@ -0,0 +1 @@ +module X = B diff --git a/ocamlbuild/test/test3/a.mli b/ocamlbuild/test/test3/a.mli new file mode 100644 index 00000000..c17617a6 --- /dev/null +++ b/ocamlbuild/test/test3/a.mli @@ -0,0 +1 @@ +(* Nothing *) diff --git a/ocamlbuild/test/test3/b.ml b/ocamlbuild/test/test3/b.ml new file mode 100644 index 00000000..58c510c1 --- /dev/null +++ b/ocamlbuild/test/test3/b.ml @@ -0,0 +1 @@ +module X = C diff --git a/ocamlbuild/test/test3/b.mli b/ocamlbuild/test/test3/b.mli new file mode 100644 index 00000000..5eea4809 --- /dev/null +++ b/ocamlbuild/test/test3/b.mli @@ -0,0 +1 @@ +(* nothing *) diff --git a/ocamlbuild/test/test3/c.ml b/ocamlbuild/test/test3/c.ml new file mode 100644 index 00000000..06f0fd91 --- /dev/null +++ b/ocamlbuild/test/test3/c.ml @@ -0,0 +1 @@ +module X = D diff --git a/ocamlbuild/test/test3/c.mli b/ocamlbuild/test/test3/c.mli new file mode 100644 index 00000000..5eea4809 --- /dev/null +++ b/ocamlbuild/test/test3/c.mli @@ -0,0 +1 @@ +(* nothing *) diff --git a/ocamlbuild/test/test3/d.ml b/ocamlbuild/test/test3/d.ml new file mode 100644 index 00000000..42ab7242 --- /dev/null +++ b/ocamlbuild/test/test3/d.ml @@ -0,0 +1 @@ +module X = E diff --git a/ocamlbuild/test/test3/d.mli b/ocamlbuild/test/test3/d.mli new file mode 100644 index 00000000..5eea4809 --- /dev/null +++ b/ocamlbuild/test/test3/d.mli @@ -0,0 +1 @@ +(* nothing *) diff --git a/ocamlbuild/test/test3/e.ml b/ocamlbuild/test/test3/e.ml new file mode 100644 index 00000000..863ea00c --- /dev/null +++ b/ocamlbuild/test/test3/e.ml @@ -0,0 +1 @@ +module X = F diff --git a/ocamlbuild/test/test3/e.mli b/ocamlbuild/test/test3/e.mli new file mode 100644 index 00000000..5eea4809 --- /dev/null +++ b/ocamlbuild/test/test3/e.mli @@ -0,0 +1 @@ +(* nothing *) diff --git a/ocamlbuild/test/test3/f.ml b/ocamlbuild/test/test3/f.ml new file mode 100644 index 00000000..00915fdc --- /dev/null +++ b/ocamlbuild/test/test3/f.ml @@ -0,0 +1,2 @@ +(* nothing *) +let _ = Unix.stat diff --git a/ocamlbuild/test/test3/f.mli b/ocamlbuild/test/test3/f.mli new file mode 100644 index 00000000..5eea4809 --- /dev/null +++ b/ocamlbuild/test/test3/f.mli @@ -0,0 +1 @@ +(* nothing *) diff --git a/ocamlbuild/test/test3/proj.odocl b/ocamlbuild/test/test3/proj.odocl new file mode 100644 index 00000000..532c7203 --- /dev/null +++ b/ocamlbuild/test/test3/proj.odocl @@ -0,0 +1 @@ +A B C D E F diff --git a/ocamlbuild/test/test3/test.sh b/ocamlbuild/test/test3/test.sh new file mode 100755 index 00000000..396aaf2a --- /dev/null +++ b/ocamlbuild/test/test3/test.sh @@ -0,0 +1,11 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOTPS="" # -- command args +BUILD="../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +$BUILD1 +$BUILD2 diff --git a/ocamlbuild/test/test4/_tags b/ocamlbuild/test/test4/_tags new file mode 100644 index 00000000..4b6e7986 --- /dev/null +++ b/ocamlbuild/test/test4/_tags @@ -0,0 +1,2 @@ +# a comment +"a/aa.byte" or "a/aa.native": use_str diff --git a/ocamlbuild/test/test4/a/aa.ml b/ocamlbuild/test/test4/a/aa.ml new file mode 100644 index 00000000..411d29bf --- /dev/null +++ b/ocamlbuild/test/test4/a/aa.ml @@ -0,0 +1 @@ +let bar = 3 + List.length Bb.foo diff --git a/ocamlbuild/test/test4/a/aa.mli b/ocamlbuild/test/test4/a/aa.mli new file mode 100644 index 00000000..20f3c52a --- /dev/null +++ b/ocamlbuild/test/test4/a/aa.mli @@ -0,0 +1 @@ +val bar : int diff --git a/ocamlbuild/test/test4/b/bb.ml b/ocamlbuild/test/test4/b/bb.ml new file mode 100644 index 00000000..031031fb --- /dev/null +++ b/ocamlbuild/test/test4/b/bb.ml @@ -0,0 +1,2 @@ +let r = Str.regexp "r" +let foo = [2.2] diff --git a/ocamlbuild/test/test4/test.sh b/ocamlbuild/test/test4/test.sh new file mode 100755 index 00000000..4b2580a8 --- /dev/null +++ b/ocamlbuild/test/test4/test.sh @@ -0,0 +1,11 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOTPS="" # -- command args +BUILD="../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +$BUILD1 +$BUILD2 diff --git a/ocamlbuild/test/test5/_tags b/ocamlbuild/test/test5/_tags new file mode 100644 index 00000000..2f66a28c --- /dev/null +++ b/ocamlbuild/test/test5/_tags @@ -0,0 +1 @@ +"a.cmx" or "b.cmx": for-pack(C) diff --git a/ocamlbuild/test/test5/a.ml b/ocamlbuild/test/test5/a.ml new file mode 100644 index 00000000..e659e732 --- /dev/null +++ b/ocamlbuild/test/test5/a.ml @@ -0,0 +1 @@ +let a = 42 + Stack.stack diff --git a/ocamlbuild/test/test5/a.mli b/ocamlbuild/test/test5/a.mli new file mode 100644 index 00000000..3f79c814 --- /dev/null +++ b/ocamlbuild/test/test5/a.mli @@ -0,0 +1 @@ +val a : int diff --git a/ocamlbuild/test/test5/b.ml b/ocamlbuild/test/test5/b.ml new file mode 100644 index 00000000..8db5ca3b --- /dev/null +++ b/ocamlbuild/test/test5/b.ml @@ -0,0 +1 @@ +let b = A.a + 1 diff --git a/ocamlbuild/test/test5/c.mlpack b/ocamlbuild/test/test5/c.mlpack new file mode 100644 index 00000000..5decc2b6 --- /dev/null +++ b/ocamlbuild/test/test5/c.mlpack @@ -0,0 +1 @@ +A B diff --git a/ocamlbuild/test/test5/d.ml b/ocamlbuild/test/test5/d.ml new file mode 100644 index 00000000..a5ec4329 --- /dev/null +++ b/ocamlbuild/test/test5/d.ml @@ -0,0 +1 @@ +Format.printf "C.B.b = %d@." C.B.b diff --git a/ocamlbuild/test/test5/stack.ml b/ocamlbuild/test/test5/stack.ml new file mode 100644 index 00000000..1820f857 --- /dev/null +++ b/ocamlbuild/test/test5/stack.ml @@ -0,0 +1 @@ +let stack = 42 diff --git a/ocamlbuild/test/test5/test.sh b/ocamlbuild/test/test5/test.sh new file mode 100755 index 00000000..9d78f199 --- /dev/null +++ b/ocamlbuild/test/test5/test.sh @@ -0,0 +1,11 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOPTS="" # -- command args +BUILD="../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +$BUILD1 +$BUILD2 diff --git a/ocamlbuild/test/test6/a.ml b/ocamlbuild/test/test6/a.ml new file mode 100644 index 00000000..e09e5d02 --- /dev/null +++ b/ocamlbuild/test/test6/a.ml @@ -0,0 +1 @@ +let a = B.b diff --git a/ocamlbuild/test/test6/a.mli b/ocamlbuild/test/test6/a.mli new file mode 100644 index 00000000..451c586e --- /dev/null +++ b/ocamlbuild/test/test6/a.mli @@ -0,0 +1 @@ +val a : 'a -> 'a diff --git a/ocamlbuild/test/test6/b.ml b/ocamlbuild/test/test6/b.ml new file mode 100644 index 00000000..362c8fc1 --- /dev/null +++ b/ocamlbuild/test/test6/b.ml @@ -0,0 +1 @@ +let b = D.d diff --git a/ocamlbuild/test/test6/b.mli b/ocamlbuild/test/test6/b.mli new file mode 100644 index 00000000..685b7906 --- /dev/null +++ b/ocamlbuild/test/test6/b.mli @@ -0,0 +1 @@ +val b : 'a -> 'a diff --git a/ocamlbuild/test/test6/b.mli.v1 b/ocamlbuild/test/test6/b.mli.v1 new file mode 100644 index 00000000..685b7906 --- /dev/null +++ b/ocamlbuild/test/test6/b.mli.v1 @@ -0,0 +1 @@ +val b : 'a -> 'a diff --git a/ocamlbuild/test/test6/b.mli.v2 b/ocamlbuild/test/test6/b.mli.v2 new file mode 100644 index 00000000..a4316983 --- /dev/null +++ b/ocamlbuild/test/test6/b.mli.v2 @@ -0,0 +1,2 @@ +.... +val b : 'a -> 'a diff --git a/ocamlbuild/test/test6/d.ml b/ocamlbuild/test/test6/d.ml new file mode 100644 index 00000000..61c7a9c6 --- /dev/null +++ b/ocamlbuild/test/test6/d.ml @@ -0,0 +1,2 @@ +type t +let d x = x diff --git a/ocamlbuild/test/test6/d.mli b/ocamlbuild/test/test6/d.mli new file mode 100644 index 00000000..1db89bbe --- /dev/null +++ b/ocamlbuild/test/test6/d.mli @@ -0,0 +1 @@ +val d : 'a -> 'a diff --git a/ocamlbuild/test/test6/d.mli.v1 b/ocamlbuild/test/test6/d.mli.v1 new file mode 100644 index 00000000..12fea1c1 --- /dev/null +++ b/ocamlbuild/test/test6/d.mli.v1 @@ -0,0 +1,2 @@ +type t +val d : 'a -> 'a diff --git a/ocamlbuild/test/test6/d.mli.v2 b/ocamlbuild/test/test6/d.mli.v2 new file mode 100644 index 00000000..1db89bbe --- /dev/null +++ b/ocamlbuild/test/test6/d.mli.v2 @@ -0,0 +1 @@ +val d : 'a -> 'a diff --git a/ocamlbuild/test/test6/main.ml b/ocamlbuild/test/test6/main.ml new file mode 100644 index 00000000..61acf128 --- /dev/null +++ b/ocamlbuild/test/test6/main.ml @@ -0,0 +1 @@ +A.a 2. +. D.d 1. diff --git a/ocamlbuild/test/test6/main.mli b/ocamlbuild/test/test6/main.mli new file mode 100644 index 00000000..5eea4809 --- /dev/null +++ b/ocamlbuild/test/test6/main.mli @@ -0,0 +1 @@ +(* nothing *) diff --git a/ocamlbuild/test/test6/test.sh b/ocamlbuild/test/test6/test.sh new file mode 100755 index 00000000..fedbc9c9 --- /dev/null +++ b/ocamlbuild/test/test6/test.sh @@ -0,0 +1,26 @@ +#!/bin/sh +cd `dirname $0` +set -x +rm -rf _build +CMDOPTS="" # -- command args +BUILD="../../_build/ocamlbuild.native -no-skip main.byte -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +cp b.mli.v1 b.mli +cp d.mli.v1 d.mli +$BUILD1 +$BUILD2 +cp b.mli.v2 b.mli +cp d.mli.v2 d.mli +$BUILD1 +cp b.mli.v1 b.mli +if $BUILD1; then + if $BUILD2; then + echo PASS + else + echo "FAIL (-nothing-should-be-rebuilt)" + fi +else + echo FAIL +fi + diff --git a/ocamlbuild/test/test7/_tags b/ocamlbuild/test/test7/_tags new file mode 100644 index 00000000..8501e328 --- /dev/null +++ b/ocamlbuild/test/test7/_tags @@ -0,0 +1 @@ +"main.byte": my_cool_plugin diff --git a/ocamlbuild/test/test7/aa.ml b/ocamlbuild/test/test7/aa.ml new file mode 100644 index 00000000..877d0af1 --- /dev/null +++ b/ocamlbuild/test/test7/aa.ml @@ -0,0 +1 @@ +let aa = "aa" diff --git a/ocamlbuild/test/test7/bb.mli b/ocamlbuild/test/test7/bb.mli new file mode 100644 index 00000000..9256de2b --- /dev/null +++ b/ocamlbuild/test/test7/bb.mli @@ -0,0 +1 @@ +val bb : int diff --git a/ocamlbuild/test/test7/bb1.ml b/ocamlbuild/test/test7/bb1.ml new file mode 100644 index 00000000..9ac2d596 --- /dev/null +++ b/ocamlbuild/test/test7/bb1.ml @@ -0,0 +1 @@ +let bb = 43 diff --git a/ocamlbuild/test/test7/bb2.ml b/ocamlbuild/test/test7/bb2.ml new file mode 100644 index 00000000..2f91b988 --- /dev/null +++ b/ocamlbuild/test/test7/bb2.ml @@ -0,0 +1,3 @@ +let bb = 43 +let f x = x + 1 +let () = incr (ref 0) diff --git a/ocamlbuild/test/test7/bb3.ml b/ocamlbuild/test/test7/bb3.ml new file mode 100644 index 00000000..b7ad4b5c --- /dev/null +++ b/ocamlbuild/test/test7/bb3.ml @@ -0,0 +1,3 @@ +let bb = 43 +let f x = x + 1 +let () = incr (ref 1) diff --git a/ocamlbuild/test/test7/bbcc.mllib b/ocamlbuild/test/test7/bbcc.mllib new file mode 100644 index 00000000..a97a0e6c --- /dev/null +++ b/ocamlbuild/test/test7/bbcc.mllib @@ -0,0 +1 @@ +Bb Cc diff --git a/ocamlbuild/test/test7/c2.ml b/ocamlbuild/test/test7/c2.ml new file mode 100644 index 00000000..36ff6d6f --- /dev/null +++ b/ocamlbuild/test/test7/c2.ml @@ -0,0 +1 @@ +let c2 = 12 diff --git a/ocamlbuild/test/test7/c2.mli b/ocamlbuild/test/test7/c2.mli new file mode 100644 index 00000000..19fe565d --- /dev/null +++ b/ocamlbuild/test/test7/c2.mli @@ -0,0 +1 @@ +val c2 : int diff --git a/ocamlbuild/test/test7/c3.ml b/ocamlbuild/test/test7/c3.ml new file mode 100644 index 00000000..277e1ee0 --- /dev/null +++ b/ocamlbuild/test/test7/c3.ml @@ -0,0 +1 @@ +let c3 = Bb.bb + 13 diff --git a/ocamlbuild/test/test7/cc.ml b/ocamlbuild/test/test7/cc.ml new file mode 100644 index 00000000..b39ef21d --- /dev/null +++ b/ocamlbuild/test/test7/cc.ml @@ -0,0 +1 @@ +let cc = (String.length Aa.aa) + Bb.bb + C2.c2 diff --git a/ocamlbuild/test/test7/cool_plugin.ml b/ocamlbuild/test/test7/cool_plugin.ml new file mode 100644 index 00000000..32251868 --- /dev/null +++ b/ocamlbuild/test/test7/cool_plugin.ml @@ -0,0 +1 @@ +print_endline "I am a cool plugin" diff --git a/ocamlbuild/test/test7/main.ml b/ocamlbuild/test/test7/main.ml new file mode 100644 index 00000000..f1219596 --- /dev/null +++ b/ocamlbuild/test/test7/main.ml @@ -0,0 +1 @@ +let main = String.length Aa.aa - Bb.bb - C3.c3 - Cc.cc - 1 diff --git a/ocamlbuild/test/test7/myocamlbuild.ml b/ocamlbuild/test/test7/myocamlbuild.ml new file mode 100644 index 00000000..ab6a4b1e --- /dev/null +++ b/ocamlbuild/test/test7/myocamlbuild.ml @@ -0,0 +1,7 @@ +open Ocamlbuild_plugin;; +dispatch begin function +| After_rules -> + use_lib "main" "bbcc"; + dep ["ocaml"; "link"; "byte"; "my_cool_plugin"] ["cool_plugin.cmo"]; +| _ -> () +end diff --git a/ocamlbuild/test/test7/test.sh b/ocamlbuild/test/test7/test.sh new file mode 100755 index 00000000..1bbda4cd --- /dev/null +++ b/ocamlbuild/test/test7/test.sh @@ -0,0 +1,18 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOPTS="" # -- command args +BUILD="../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display $@" +BUILD1="$BUILD $CMDARGS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDARGS" +rm -rf _build +cp bb1.ml bb.ml +$BUILD1 +$BUILD2 +cp bb2.ml bb.ml +$BUILD1 -verbose 0 +$BUILD2 +cp bb3.ml bb.ml +$BUILD1 -verbose 0 +$BUILD2 diff --git a/ocamlbuild/test/test8/a.ml b/ocamlbuild/test/test8/a.ml new file mode 100644 index 00000000..35ac7499 --- /dev/null +++ b/ocamlbuild/test/test8/a.ml @@ -0,0 +1 @@ +print_endline Myconfig.version;; diff --git a/ocamlbuild/test/test8/myocamlbuild.ml b/ocamlbuild/test/test8/myocamlbuild.ml new file mode 100644 index 00000000..f2818b65 --- /dev/null +++ b/ocamlbuild/test/test8/myocamlbuild.ml @@ -0,0 +1,16 @@ +open Ocamlbuild_plugin;; +let version = "0.1";; +dispatch begin function + | After_rules -> + rule "myconfig.ml" + ~prod:"myconfig.ml" + begin fun _ _ -> + Echo(["let version = \""; version; "\";;\n"], "myconfig.ml") + end; + + copy_rule "copy byte-code executables" "%(path).byte" "%(path:not <**/*.*>)"; + copy_rule "copy native executables" "%(path).native" "%(path:not <**/*.*>).opt"; + copy_rule "copy binaries to bin" "%(basename).%(extension)" + "bin/%(basename).%(extension:<{byte,native}>)"; + | _ -> () +end diff --git a/ocamlbuild/test/test8/test.sh b/ocamlbuild/test/test8/test.sh new file mode 100755 index 00000000..28825eaa --- /dev/null +++ b/ocamlbuild/test/test8/test.sh @@ -0,0 +1,11 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOPTS="" # -- command args +BUILD="../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +$BUILD1 +$BUILD2 diff --git a/ocamlbuild/test/test9/dbgl b/ocamlbuild/test/test9/dbgl new file mode 100644 index 00000000..ac61a3d5 --- /dev/null +++ b/ocamlbuild/test/test9/dbgl @@ -0,0 +1,10 @@ +#load "unix.cma";; +#load "str.cma";; +#load "discard_printf.cmo";; +#load "debug.cmo";; +#load "bool.cmo";; +#load "glob_ast.cmo";; +#load "glob_lexer.cmo";; +#load "my_unix.cmo";; +#use "glob.ml";; +#install_printer print_is;; diff --git a/ocamlbuild/test/test9/test.sh b/ocamlbuild/test/test9/test.sh new file mode 100755 index 00000000..0feded20 --- /dev/null +++ b/ocamlbuild/test/test9/test.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -e +set -x +cd `dirname $0`/../.. +./_build/ocamlbuild.native -quiet -build-dir _buildtest -no-links test/test9/testglob.native $@ +./_buildtest/test/test9/testglob.native diff --git a/ocamlbuild/test/test9/testglob.ml b/ocamlbuild/test/test9/testglob.ml new file mode 100644 index 00000000..80f3466c --- /dev/null +++ b/ocamlbuild/test/test9/testglob.ml @@ -0,0 +1,134 @@ +(* Testglob *) + +open Bool;; +open Glob;; + +let yep f x = + try + ignore (f x); + true + with + | _ -> false +;; + +let tests1 = [ + "\"hello\"", true; + "", true; + "", true; + " and or ", true; + " titi", false +];; + +let tests2 = [ + "<[a]>", ["a"], ["b"]; + "<[a-z]>", ["a";"e";"k";"z"], ["0";"A";"~"]; + "<[a-z][0-9]>", ["a0";"b9"], ["a00";"a0a";"b0a";"isduis";""]; + "", ["hello"], ["helli"]; + "\"hello\"", ["hello"], ["heidi"]; + "<*>", ["";"a";"ax"], []; + "", ["ab";"acb";"axxxxxb";"ababbababb"], ["abx";"xxxxxab";"xab"]; + "<*.ml>", ["hello.ml";".ml"], ["ml"; ""; "toto.mli"]; + "", ["a"], ["";"aa";"ba";"ab";"abaa"]; + "", ["ab"], ["";"abab";"aba";"abx"]; + "", ["abac";"abxc"], ["abab";"ababab";"ababa"]; + "<*ab?cd*>", ["123abecd345";"abccd";"abccd345";"ababcababccdab"], ["abcd";"aaaaabcdababcd"]; + "<*this*is*a*test*>", ["this is a test";"You know this is a test really";"thisisatest"], ["thisatest"]; + "", ["bxx";"bx"], ["aaab";""]; + "<*>", ["";"a";"aaa";"aaaaa"], []; + "", ["a"],["";"aaa";"aaaaa"]; + "<{a,b}>", ["a";"b"],["";"aa";"ab";"ba";"bb";"c"]; + "", ["toto.ml";"toto.mli"],["toto.";"toto.mll"]; + "<{a,b}{c,[de]}{f,g}>", ["acf";"acg";"adf";"adg";"aef";"aeg";"bcf";"bcg";"bdf";"bdg";"bef";"beg"], + ["afg";"af";"aee"]; + "(<*.ml> or <*.mli>) and not \"hello.ml\"", + ["a.ml"; "b.ml"; "a.mli"], + ["hello.ml"; "a.mli.x"]; + "<*>", ["alpha";"beta"], ["alpha/beta";"gamma/delta"]; + "", ["alpha/beta";"alpha/gamma/beta";"alpha/gamma/delta/beta"], + ["alpha";"beta";"gamma/delta"]; + "<**/*.ml>", ["toto.ml";"toto/tata.ml";"alpha/gamma/delta/beta.ml"], + ["toto.mli"]; + "", ["toto/";"toto/tata";"toto/alpha/gamma/delta/beta.ml";"toto"], + ["toto2/tata"; "tata/titi"] +];; + +let tests3 = [ + "%(path:<**/>)lib%(libname:<*> and not <*.*>).a", + ["libfoo.a","","foo"; + "src/bar/libfoo.a","src/bar/","foo"; + "otherlibs/unix/libunix.a","otherlibs/unix/","unix"; + "otherlibsliblib/unlibix/libunix.a","otherlibsliblib/unlibix/","unix"; + "libfoo/libbar.a","libfoo/","bar"; + "src/libfoo/boo/libbar.a","src/libfoo/boo/","bar"; + ], + ["bar"; "libbar/foo.a"; "libfoo.b.a"] +];; + +let _ = + let times = 3 in + List.iter + begin fun (str, ast) -> + let ast' = yep Glob.parse str in + if ast <> ast' then + begin + Printf.printf "Globexp parsing failed for %S.\n%!" str; + exit 1 + end + else + Printf.printf "Globexp for %S OK\n%!" str + end + tests1; + List.iter + begin fun (gstr, yes, no) -> + let globber = Glob.parse gstr in + let check polarity = + List.iter + begin fun y -> + if Glob.eval globber y = polarity then + Printf.printf "Glob.eval %S %S = %b OK\n%!" gstr y polarity + else + begin + Printf.printf "Glob.eval %S %S = %b FAIL\n%!" gstr y (not polarity); + exit 1 + end + end + in + for k = 1 to times do + check true yes; + check false no + done + end + tests2; + List.iter begin fun (str, yes, no) -> + let resource = Resource.import_pattern str in + for k = 1 to times do + List.iter begin fun (y, path, libname) -> + let resource' = Resource.import y in + match Resource.matchit resource resource' with + | Some env -> + let path' = Resource.subst env "%(path)" in + let libname' = Resource.subst env "%(libname)" in + if path' = path && libname = libname' then + Printf.printf "Resource.matchit %S %S OK\n%!" str y + else begin + Printf.printf "Resource.matchit %S %S FAIL\n%!" str y; + exit 1 + end + | None -> + begin + Printf.printf "Resource.matchit %S %S = None FAIL\n%!" str y; + exit 1 + end + end yes; + List.iter begin fun y -> + let resource' = Resource.import y in + if Resource.matchit resource resource' = None then + Printf.printf "Resource.matchit %S %S = None OK\n%!" str y + else begin + Printf.printf "Resource.matchit %S %S <> None FAIL\n%!" str y; + exit 1 + end + end no + done + end tests3 +;; diff --git a/ocamlbuild/test/test_virtual/foo.itarget b/ocamlbuild/test/test_virtual/foo.itarget new file mode 100644 index 00000000..257cc564 --- /dev/null +++ b/ocamlbuild/test/test_virtual/foo.itarget @@ -0,0 +1 @@ +foo diff --git a/ocamlbuild/test/test_virtual/foo1 b/ocamlbuild/test/test_virtual/foo1 new file mode 100644 index 00000000..1715acd6 --- /dev/null +++ b/ocamlbuild/test/test_virtual/foo1 @@ -0,0 +1 @@ +foo1 diff --git a/ocamlbuild/test/test_virtual/foo2 b/ocamlbuild/test/test_virtual/foo2 new file mode 100644 index 00000000..54b060ee --- /dev/null +++ b/ocamlbuild/test/test_virtual/foo2 @@ -0,0 +1 @@ +foo2 diff --git a/ocamlbuild/test/test_virtual/myocamlbuild.ml b/ocamlbuild/test/test_virtual/myocamlbuild.ml new file mode 100644 index 00000000..0c43d4ce --- /dev/null +++ b/ocamlbuild/test/test_virtual/myocamlbuild.ml @@ -0,0 +1,11 @@ +open Ocamlbuild_plugin;; +dispatch begin function + | After_rules -> + rule "copy foo" + ~prod:"bar" + ~dep:"foo.otarget" + begin fun _env _build -> + cp "foo" "bar" + end + | _ -> () +end diff --git a/ocamlbuild/test/test_virtual/test.sh b/ocamlbuild/test/test_virtual/test.sh new file mode 100644 index 00000000..dbb2be75 --- /dev/null +++ b/ocamlbuild/test/test_virtual/test.sh @@ -0,0 +1,16 @@ +#!/bin/sh +cd `dirname $0` +set -e +set -x +CMDOPTS="" # -- command args +BUILD="../../_build/ocamlbuild.native bar -no-skip -classic-display $@" +BUILD1="$BUILD $CMDOPTS" +BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS" +rm -rf _build +cp foo1 foo +$BUILD1 +$BUILD2 +cp foo2 foo +$BUILD1 -verbose 0 +$BUILD2 +rm foo diff --git a/testlabl/.cvsignore b/testlabl/.cvsignore new file mode 100644 index 00000000..4c57147b --- /dev/null +++ b/testlabl/.cvsignore @@ -0,0 +1 @@ +*.out *.out2 \ No newline at end of file diff --git a/testlabl/coerce.diffs b/testlabl/coerce.diffs new file mode 100644 index 00000000..e90e1fc9 --- /dev/null +++ b/testlabl/coerce.diffs @@ -0,0 +1,93 @@ +Index: typing/ctype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v +retrieving revision 1.201 +diff -u -r1.201 ctype.ml +--- typing/ctype.ml 5 Apr 2006 02:28:13 -0000 1.201 ++++ typing/ctype.ml 17 May 2006 23:48:22 -0000 +@@ -490,6 +490,31 @@ + unmark_class_signature sign; + Some reason + ++(* Variant for checking principality *) ++ ++let rec free_nodes_rec ty = ++ let ty = repr ty in ++ if ty.level >= lowest_level then begin ++ if ty.level <= !current_level then raise Exit; ++ ty.level <- pivot_level - ty.level; ++ begin match ty.desc with ++ Tvar -> ++ raise Exit ++ | Tobject (ty, _) -> ++ free_nodes_rec ty ++ | Tfield (_, _, ty1, ty2) -> ++ free_nodes_rec ty1; free_nodes_rec ty2 ++ | Tvariant row -> ++ let row = row_repr row in ++ iter_row free_nodes_rec {row with row_bound = []}; ++ if not (static_row row) then free_nodes_rec row.row_more ++ | _ -> ++ iter_type_expr free_nodes_rec ty ++ end; ++ end ++ ++let has_free_nodes ty = ++ try free_nodes_rec ty; false with Exit -> true + + (**********************) + (* Type duplication *) +Index: typing/ctype.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.mli,v +retrieving revision 1.54 +diff -u -r1.54 ctype.mli +--- typing/ctype.mli 5 Apr 2006 02:28:13 -0000 1.54 ++++ typing/ctype.mli 17 May 2006 23:48:22 -0000 +@@ -228,6 +228,9 @@ + val closed_class: + type_expr list -> class_signature -> closed_class_failure option + (* Check whether all type variables are bound *) ++val has_free_nodes: type_expr -> bool ++ (* Check whether there are free type variables, or nodes with ++ level lower or equal to !current_level *) + + val unalias: type_expr -> type_expr + val signature_of_class_type: class_type -> class_signature +Index: typing/typecore.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v +retrieving revision 1.181 +diff -u -r1.181 typecore.ml +--- typing/typecore.ml 16 Apr 2006 23:28:22 -0000 1.181 ++++ typing/typecore.ml 17 May 2006 23:48:22 -0000 +@@ -1183,12 +1183,29 @@ + let (ty', force) = + Typetexp.transl_simple_type_delayed env sty' + in ++ if !Clflags.principal then begin_def (); + let arg = type_exp env sarg in ++ let has_fv = ++ if !Clflags.principal then begin ++ end_def (); ++ let b = has_free_nodes arg.exp_type in ++ Ctype.unify env arg.exp_type (newvar ()); ++ b ++ end else ++ free_variables arg.exp_type <> [] ++ in + begin match arg.exp_desc, !self_coercion, (repr ty').desc with + Texp_ident(_, {val_kind=Val_self _}), (path,r) :: _, + Tconstr(path',_,_) when Path.same path path' -> + r := sexp.pexp_loc :: !r; + force () ++ | _ when not has_fv -> ++ begin try ++ let force' = subtype env arg.exp_type ty' in ++ force (); force' () ++ with Subtype (tr1, tr2) -> ++ raise(Error(sexp.pexp_loc, Not_subtype(tr1, tr2))) ++ end + | _ -> + let ty, b = enlarge_type env ty' in + force (); diff --git a/testlabl/dirs_multimatch b/testlabl/dirs_multimatch new file mode 100644 index 00000000..b4495146 --- /dev/null +++ b/testlabl/dirs_multimatch @@ -0,0 +1 @@ +parsing typing bytecomp driver toplevel \ No newline at end of file diff --git a/testlabl/dirs_poly b/testlabl/dirs_poly new file mode 100644 index 00000000..3aec606e --- /dev/null +++ b/testlabl/dirs_poly @@ -0,0 +1 @@ +bytecomp byterun driver parsing stdlib tools toplevel typing utils otherlibs/labltk/browser/searchpos.ml diff --git a/testlabl/els.ml b/testlabl/els.ml new file mode 100644 index 00000000..fdd292d6 --- /dev/null +++ b/testlabl/els.ml @@ -0,0 +1,92 @@ +(* Adapted from: An Expressive Language of Signatures + by Norman Ramsey, Kathleen Fisher and Paul Govereau *) + +module type VALUE = sig + type value (* a Lua value *) + type state (* the state of a Lua interpreter *) + type usert (* a user-defined value *) +end + +module type CORE0 = sig + module V : VALUE + val setglobal : V.state -> string -> V.value -> unit + (* five more functions common to core and evaluator *) +end + +module type CORE = sig + include CORE0 + val apply : V.value -> V.state -> V.value list -> V.value + (* apply function f in state s to list of args *) +end + +module type AST = sig + module Value : VALUE + type chunk + type program + val get_value : chunk -> Value.value +end + +module type EVALUATOR = sig + module Value : VALUE + module Ast : (AST with module Value := Value) + type state = Value.state + type value = Value.value + exception Error of string + val compile : Ast.program -> string + include CORE0 with module V := Value +end + +module type PARSER = sig + type chunk + val parse : string -> chunk +end + +module type INTERP = sig + include EVALUATOR + module Parser : PARSER with type chunk = Ast.chunk + val dostring : state -> string -> value list + val mk : unit -> state +end + +module type USERTYPE = sig + type t + val eq : t -> t -> bool + val to_string : t -> string +end + +module type TYPEVIEW = sig + type combined + type t + val map : (combined -> t) * (t -> combined) +end + +module type COMBINED_COMMON = sig + module T : sig type t end + module TV1 : TYPEVIEW with type combined := T.t + module TV2 : TYPEVIEW with type combined := T.t +end + +module type COMBINED_TYPE = sig + module T : USERTYPE + include COMBINED_COMMON with module T := T +end + +module type BARECODE = sig + type state + val init : state -> unit +end + +module USERCODE(X : TYPEVIEW) = struct + module type F = + functor (C : CORE with type V.usert = X.combined) -> + BARECODE with type state := C.V.state +end + +module Weapon = struct type t end + +module type WEAPON_LIB = sig + type t = Weapon.t + module T : USERTYPE with type t = t + module Make : + functor (TV : TYPEVIEW with type t = t) -> USERCODE(TV).F +end diff --git a/testlabl/fixedtypes.ml b/testlabl/fixedtypes.ml new file mode 100644 index 00000000..a7d7ca4a --- /dev/null +++ b/testlabl/fixedtypes.ml @@ -0,0 +1,77 @@ +(* cvs update -r fixedtypes parsing typing *) + +(* recursive types *) +class c = object (self) method m = 1 method s = self end +module type S = sig type t = private #c end;; + +module M : S = struct type t = c end +module type S' = S with type t = c;; + +class d = object inherit c method n = 2 end +module type S2 = S with type t = private #d;; +module M2 : S = struct type t = d end;; +module M3 : S = struct type t = private #d end;; + +module T1 = struct + type ('a,'b) a = [`A of 'a | `B of 'b] + type ('a,'b) b = [`Z | ('a,'b) a] +end +module type T2 = sig + type a and b + val evala : a -> int + val evalb : b -> int +end +module type T3 = sig + type a0 = private [> (a0,b0) T1.a] + and b0 = private [> (a0,b0) T1.b] +end +module type T4 = sig + include T3 + include T2 with type a = a0 and type b = b0 +end +module F(X:T4) = struct + type a = X.a and b = X.b + let a = X.evala (`B `Z) + let b = X.evalb (`A(`B `Z)) + let a2b (x : a) : b = `A x + let b2a (x : b) : a = `B x +end +module M4 = struct + type a = [`A of a | `B of b | `ZA] + and b = [`A of a | `B of b | `Z] + type a0 = a + type b0 = b + let rec eval0 = function + `A a -> evala a + | `B b -> evalb b + and evala : a -> int = function + #T1.a as x -> 1 + eval0 x + | `ZA -> 3 + and evalb : b -> int = function + #T1.a as x -> 1 + eval0 x + | `Z -> 7 +end +module M5 = F(M4) + +module M6 : sig + class ci : int -> + object + val x : int + method x : int + method move : int -> unit + end + type c = private #ci + val create : int -> c +end = struct + class ci x = object + val mutable x : int = x + method x = x + method move d = x <- x+d + end + type c = ci + let create = new ci +end +let f (x : M6.c) = x#move 3; x#x;; + +module M : sig type t = private [> `A of bool] end = + struct type t = [`A of int] end diff --git a/testlabl/marshal_objects.diffs b/testlabl/marshal_objects.diffs new file mode 100644 index 00000000..bb9b4dd7 --- /dev/null +++ b/testlabl/marshal_objects.diffs @@ -0,0 +1,800 @@ +? bytecomp/alpha_eq.ml +Index: bytecomp/lambda.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/lambda.ml,v +retrieving revision 1.44 +diff -u -r1.44 lambda.ml +--- bytecomp/lambda.ml 25 Aug 2005 15:35:16 -0000 1.44 ++++ bytecomp/lambda.ml 2 Feb 2006 05:08:56 -0000 +@@ -287,9 +287,10 @@ + let compare = compare + end) + +-let free_ids get l = ++let free_ids get used l = + let fv = ref IdentSet.empty in + let rec free l = ++ let old = !fv in + iter free l; + fv := List.fold_right IdentSet.add (get l) !fv; + match l with +@@ -307,17 +308,20 @@ + fv := IdentSet.remove v !fv + | Lassign(id, e) -> + fv := IdentSet.add id !fv ++ | Lifused(id, e) -> ++ if used && not (IdentSet.mem id old) then fv := IdentSet.remove id !fv + | Lvar _ | Lconst _ | Lapply _ + | Lprim _ | Lswitch _ | Lstaticraise _ + | Lifthenelse _ | Lsequence _ | Lwhile _ +- | Lsend _ | Levent _ | Lifused _ -> () ++ | Lsend _ | Levent _ -> () + in free l; !fv + +-let free_variables l = +- free_ids (function Lvar id -> [id] | _ -> []) l ++let free_variables ?(ifused=false) l = ++ free_ids (function Lvar id -> [id] | _ -> []) ifused l + + let free_methods l = +- free_ids (function Lsend(Self, Lvar meth, obj, _) -> [meth] | _ -> []) l ++ free_ids (function Lsend(Self, Lvar meth, obj, _) -> [meth] | _ -> []) ++ false l + + (* Check if an action has a "when" guard *) + let raise_count = ref 0 +Index: bytecomp/lambda.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/lambda.mli,v +retrieving revision 1.42 +diff -u -r1.42 lambda.mli +--- bytecomp/lambda.mli 25 Aug 2005 15:35:16 -0000 1.42 ++++ bytecomp/lambda.mli 2 Feb 2006 05:08:56 -0000 +@@ -177,7 +177,7 @@ + + val iter: (lambda -> unit) -> lambda -> unit + module IdentSet: Set.S with type elt = Ident.t +-val free_variables: lambda -> IdentSet.t ++val free_variables: ?ifused:bool -> lambda -> IdentSet.t + val free_methods: lambda -> IdentSet.t + + val transl_path: Path.t -> lambda +Index: bytecomp/translclass.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translclass.ml,v +retrieving revision 1.38 +diff -u -r1.38 translclass.ml +--- bytecomp/translclass.ml 13 Aug 2005 20:59:37 -0000 1.38 ++++ bytecomp/translclass.ml 2 Feb 2006 05:08:56 -0000 +@@ -46,6 +46,10 @@ + + let lfield v i = Lprim(Pfield i, [Lvar v]) + ++let ltuple l = Lprim(Pmakeblock(0,Immutable), l) ++ ++let lprim name args = Lapply(oo_prim name, args) ++ + let transl_label l = share (Const_immstring l) + + let rec transl_meth_list lst = +@@ -68,8 +72,8 @@ + Lvar offset])])])) + + let transl_val tbl create name = +- Lapply (oo_prim (if create then "new_variable" else "get_variable"), +- [Lvar tbl; transl_label name]) ++ lprim (if create then "new_variable" else "get_variable") ++ [Lvar tbl; transl_label name] + + let transl_vals tbl create vals rem = + List.fold_right +@@ -82,7 +86,7 @@ + (fun (nm, id) rem -> + try + (nm, id, +- Lapply(oo_prim "get_method", [Lvar tbl; Lvar (Meths.find nm meths)])) ++ lprim "get_method" [Lvar tbl; Lvar (Meths.find nm meths)]) + :: rem + with Not_found -> rem) + inh_meths [] +@@ -97,17 +101,15 @@ + let (inh_init, obj_init, has_init) = init obj' in + if obj_init = lambda_unit then + (inh_init, +- Lapply (oo_prim (if has_init then "create_object_and_run_initializers" +- else"create_object_opt"), +- [obj; Lvar cl])) ++ lprim (if has_init then "create_object_and_run_initializers" ++ else"create_object_opt") ++ [obj; Lvar cl]) + else begin + (inh_init, +- Llet(Strict, obj', +- Lapply (oo_prim "create_object_opt", [obj; Lvar cl]), ++ Llet(Strict, obj', lprim "create_object_opt" [obj; Lvar cl], + Lsequence(obj_init, + if not has_init then Lvar obj' else +- Lapply (oo_prim "run_initializers_opt", +- [obj; Lvar obj'; Lvar cl])))) ++ lprim "run_initializers_opt" [obj; Lvar obj'; Lvar cl]))) + end + + let rec build_object_init cl_table obj params inh_init obj_init cl = +@@ -203,14 +205,13 @@ + + + let bind_method tbl lab id cl_init = +- Llet(StrictOpt, id, Lapply (oo_prim "get_method_label", +- [Lvar tbl; transl_label lab]), ++ Llet(StrictOpt, id, lprim "get_method_label" [Lvar tbl; transl_label lab], + cl_init) + +-let bind_methods tbl meths vals cl_init = +- let methl = Meths.fold (fun lab id tl -> (lab,id) :: tl) meths [] in ++let bind_methods tbl methl vals cl_init = + let len = List.length methl and nvals = List.length vals in +- if len < 2 && nvals = 0 then Meths.fold (bind_method tbl) meths cl_init else ++ if len < 2 && nvals = 0 then ++ List.fold_right (fun (n,i) -> bind_method tbl n i) methl cl_init else + if len = 0 && nvals < 2 then transl_vals tbl true vals cl_init else + let ids = Ident.create "ids" in + let i = ref len in +@@ -229,21 +230,19 @@ + vals' cl_init) + in + Llet(StrictOpt, ids, +- Lapply (oo_prim getter, +- [Lvar tbl; transl_meth_list (List.map fst methl)] @ names), ++ lprim getter ++ ([Lvar tbl; transl_meth_list (List.map fst methl)] @ names), + List.fold_right +- (fun (lab,id) lam -> decr i; Llet(StrictOpt, id, lfield ids !i, lam)) ++ (fun (lab,id) lam -> decr i; Llet(Alias, id, lfield ids !i, lam)) + methl cl_init) + + let output_methods tbl methods lam = + match methods with + [] -> lam + | [lab; code] -> +- lsequence (Lapply(oo_prim "set_method", [Lvar tbl; lab; code])) lam ++ lsequence (lprim "set_method" [Lvar tbl; lab; code]) lam + | _ -> +- lsequence (Lapply(oo_prim "set_methods", +- [Lvar tbl; Lprim(Pmakeblock(0,Immutable), methods)])) +- lam ++ lsequence (lprim "set_methods" [Lvar tbl; ltuple methods]) lam + + let rec ignore_cstrs cl = + match cl.cl_desc with +@@ -266,7 +265,8 @@ + Llet (Strict, obj_init, + Lapply(Lprim(Pfield 1, [lpath]), Lvar cla :: + if top then [Lprim(Pfield 3, [lpath])] else []), +- bind_super cla super cl_init)) ++ bind_super cla super cl_init), ++ [], []) + | _ -> + assert false + end +@@ -278,10 +278,11 @@ + match field with + Cf_inher (cl, vals, meths) -> + let cl_init = output_methods cla methods cl_init in +- let inh_init, cl_init = ++ let (inh_init, cl_init, meths', vals') = + build_class_init cla false + (vals, meths_super cla str.cl_meths meths) + inh_init cl_init msubst top cl in ++ let cl_init = bind_methods cla meths' vals' cl_init in + (inh_init, cl_init, [], values) + | Cf_val (name, id, exp) -> + (inh_init, cl_init, methods, (name, id)::values) +@@ -304,29 +305,37 @@ + (inh_init, cl_init, methods, vals @ values) + | Cf_init exp -> + (inh_init, +- Lsequence(Lapply (oo_prim "add_initializer", +- Lvar cla :: msubst false (transl_exp exp)), ++ Lsequence(lprim "add_initializer" ++ (Lvar cla :: msubst false (transl_exp exp)), + cl_init), + methods, values)) + str.cl_field + (inh_init, cl_init, [], []) + in + let cl_init = output_methods cla methods cl_init in +- (inh_init, bind_methods cla str.cl_meths values cl_init) ++ (* inh_init, bind_methods cla str.cl_meths values cl_init *) ++ let methods = Meths.fold (fun n i l -> (n,i)::l) str.cl_meths [] in ++ (inh_init, cl_init, methods, values) + | Tclass_fun (pat, vals, cl, _) -> +- let (inh_init, cl_init) = ++ let (inh_init, cl_init, methods, values) = + build_class_init cla cstr super inh_init cl_init msubst top cl + in ++ let fv = free_variables ~ifused:true cl_init in ++ let vals = List.filter (fun (id,_) -> IdentSet.mem id fv) vals in + let vals = List.map (function (id, _) -> (Ident.name id, id)) vals in +- (inh_init, transl_vals cla true vals cl_init) ++ (* inh_init, transl_vals cla true vals cl_init *) ++ (inh_init, cl_init, methods, vals @ values) + | Tclass_apply (cl, exprs) -> + build_class_init cla cstr super inh_init cl_init msubst top cl + | Tclass_let (rec_flag, defs, vals, cl) -> +- let (inh_init, cl_init) = ++ let (inh_init, cl_init, methods, values) = + build_class_init cla cstr super inh_init cl_init msubst top cl + in ++ let fv = free_variables ~ifused:true cl_init in ++ let vals = List.filter (fun (id,_) -> IdentSet.mem id fv) vals in + let vals = List.map (function (id, _) -> (Ident.name id, id)) vals in +- (inh_init, transl_vals cla true vals cl_init) ++ (* inh_init, transl_vals cla true vals cl_init *) ++ (inh_init, cl_init, methods, vals @ values) + | Tclass_constraint (cl, vals, meths, concr_meths) -> + let virt_meths = + List.filter (fun lab -> not (Concr.mem lab concr_meths)) meths in +@@ -358,23 +367,34 @@ + cl_init valids in + (inh_init, + Llet (Strict, inh, +- Lapply(oo_prim "inherits", narrow_args @ +- [lpath; Lconst(Const_pointer(if top then 1 else 0))]), ++ lprim "inherits" ++ (narrow_args @ ++ [lpath; Lconst(Const_pointer(if top then 1 else 0))]), + Llet(StrictOpt, obj_init, lfield inh 0, + Llet(Alias, inh_vals, lfield inh 1, +- Llet(Alias, inh_meths, lfield inh 2, cl_init))))) ++ Llet(Alias, inh_meths, lfield inh 2, cl_init)))), ++ [], []) + | _ -> + let core cl_init = + build_class_init cla true super inh_init cl_init msubst top cl + in + if cstr then core cl_init else +- let (inh_init, cl_init) = +- core (Lsequence (Lapply (oo_prim "widen", [Lvar cla]), cl_init)) ++ let (inh_init, cl_init, methods, values) = ++ core (Lsequence (lprim "widen" [Lvar cla], cl_init)) + in +- (inh_init, +- Lsequence(Lapply (oo_prim "narrow", narrow_args), cl_init)) ++ let cl_init = bind_methods cla methods values cl_init in ++ (inh_init, Lsequence(lprim "narrow" narrow_args, cl_init), [], []) + end + ++let build_class_init cla env inh_init obj_init msubst top cl = ++ let inh_init = List.rev inh_init in ++ let (inh_init, cl_init, methods, values) = ++ build_class_init cla true ([],[]) inh_init obj_init msubst top cl in ++ assert (inh_init = []); ++ if IdentSet.mem env (free_variables ~ifused:true cl_init) ++ then bind_methods cla methods (("", env) :: values) cl_init ++ else Llet(Alias, env, lambda_unit, bind_methods cla methods values cl_init) ++ + let rec build_class_lets cl = + match cl.cl_desc with + Tclass_let (rec_flag, defs, vals, cl) -> +@@ -459,16 +479,16 @@ + Strict, new_init, lfunction [obj_init] obj_init', + Llet( + Alias, cla, transl_path path, +- Lprim(Pmakeblock(0, Immutable), +- [Lapply(Lvar new_init, [lfield cla 0]); +- lfunction [table] +- (Llet(Strict, env_init, +- Lapply(lfield cla 1, [Lvar table]), +- lfunction [envs] +- (Lapply(Lvar new_init, +- [Lapply(Lvar env_init, [Lvar envs])])))); +- lfield cla 2; +- lfield cla 3]))) ++ ltuple ++ [Lapply(Lvar new_init, [lfield cla 0]); ++ lfunction [table] ++ (Llet(Strict, env_init, ++ Lapply(lfield cla 1, [Lvar table]), ++ lfunction [envs] ++ (Lapply(Lvar new_init, ++ [Lapply(Lvar env_init, [Lvar envs])])))); ++ lfield cla 2; ++ lfield cla 3])) + with Exit -> + lambda_unit + +@@ -541,7 +561,7 @@ + open CamlinternalOO + let builtin_meths arr self env env2 body = + let builtin, args = builtin_meths self env env2 body in +- if not arr then [Lapply(oo_prim builtin, args)] else ++ if not arr then [lprim builtin args] else + let tag = match builtin with + "get_const" -> GetConst + | "get_var" -> GetVar +@@ -599,7 +619,8 @@ + + (* Prepare for heavy environment handling *) + let tables = Ident.create (Ident.name cl_id ^ "_tables") in +- let (top_env, req) = oo_add_class tables in ++ let table_init = ref None in ++ let (top_env, req) = oo_add_class tables table_init in + let top = not req in + let cl_env, llets = build_class_lets cl in + let new_ids = if top then [] else Env.diff top_env cl_env in +@@ -633,6 +654,7 @@ + begin try + (* Doesn't seem to improve size for bytecode *) + (* if not !Clflags.native_code then raise Not_found; *) ++ if !Clflags.debug then raise Not_found; + builtin_meths arr [self] env env2 (lfunction args body') + with Not_found -> + [lfunction (self :: args) +@@ -665,15 +687,8 @@ + build_object_init_0 cla [] cl copy_env subst_env top ids in + if not (Translcore.check_recursive_lambda ids obj_init) then + raise(Error(cl.cl_loc, Illegal_class_expr)); +- 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 +- in +- assert (inh_init' = []); +- let table = Ident.create "table" +- and class_init = Ident.create (Ident.name cl_id ^ "_init") +- and env_init = Ident.create "env_init" +- and obj_init = Ident.create "obj_init" in ++ let cl_init = build_class_init cla env2 inh_init obj_init msubst top cl in ++ let obj_init = Ident.create "obj_init" in + let pub_meths = + List.sort + (fun s s' -> compare (Btype.hash_variant s) (Btype.hash_variant s')) +@@ -685,42 +700,44 @@ + let name' = List.assoc tag rev_map in + if name' <> name then raise(Error(cl.cl_loc, Tags(name, name')))) + tags pub_meths; ++ let pos = cl.cl_loc.Location.loc_end in ++ let filepos = [transl_label pos.Lexing.pos_fname; ++ Lconst(Const_base(Const_int pos.Lexing.pos_cnum))] in + let ltable table lam = +- Llet(Strict, table, +- Lapply (oo_prim "create_table", [transl_meth_list pub_meths]), lam) ++ Llet(Strict, table, lprim "create_table" [transl_meth_list pub_meths], lam) + and ldirect obj_init = + Llet(Strict, obj_init, cl_init, +- Lsequence(Lapply (oo_prim "init_class", [Lvar cla]), ++ Lsequence(lprim "init_class_shared" (Lvar cla :: filepos), + Lapply(Lvar obj_init, [lambda_unit]))) + in + (* Simplest case: an object defined at toplevel (ids=[]) *) + if top && ids = [] then llets (ltable cla (ldirect obj_init)) else + ++ let table = Ident.create "table" ++ and class_init = Ident.create (Ident.name cl_id ^ "_init") ++ and env_init = Ident.create (Ident.name cl_id ^ "_env_init") in ++ let cl_init_fun = Lfunction(Curried, [cla], cl_init) in + let concrete = + ids = [] || + Typeclass.virtual_methods (Ctype.signature_of_class_type cl.cl_type) = [] +- and lclass lam = +- let cl_init = llets (Lfunction(Curried, [cla], cl_init)) in ++ and lclass cl_init lam = + Llet(Strict, class_init, cl_init, lam (free_variables cl_init)) + and lbody fv = + if List.for_all (fun id -> not (IdentSet.mem id fv)) ids then +- Lapply (oo_prim "make_class",[transl_meth_list pub_meths; +- Lvar class_init]) ++ lprim "make_class" ++ (transl_meth_list pub_meths :: Lvar class_init :: filepos) + else + ltable table ( + Llet( + Strict, env_init, Lapply(Lvar class_init, [Lvar table]), +- Lsequence( +- Lapply (oo_prim "init_class", [Lvar table]), +- Lprim(Pmakeblock(0, Immutable), +- [Lapply(Lvar env_init, [lambda_unit]); +- Lvar class_init; Lvar env_init; lambda_unit])))) ++ Lsequence(lprim "init_class_shared" (Lvar table :: filepos), ++ ltuple [Lapply(Lvar env_init, [lambda_unit]); ++ Lvar class_init; Lvar env_init; lambda_unit]))) + and lbody_virt lenvs = +- Lprim(Pmakeblock(0, Immutable), +- [lambda_unit; Lfunction(Curried,[cla], cl_init); lambda_unit; lenvs]) ++ ltuple [lambda_unit; cl_init_fun; lambda_unit; lenvs] + in + (* Still easy: a class defined at toplevel *) +- if top && concrete then lclass lbody else ++ if top && concrete then lclass (llets cl_init_fun) lbody else + if top then llets (lbody_virt lambda_unit) else + + (* Now for the hard stuff: prepare for table cacheing *) +@@ -733,23 +750,16 @@ + let lenv = + let menv = + if !new_ids_meths = [] then lambda_unit else +- Lprim(Pmakeblock(0, Immutable), +- List.map (fun id -> Lvar id) !new_ids_meths) in ++ ltuple (List.map (fun id -> Lvar id) !new_ids_meths) in + if !new_ids_init = [] then menv else +- Lprim(Pmakeblock(0, Immutable), +- menv :: List.map (fun id -> Lvar id) !new_ids_init) ++ ltuple (menv :: List.map (fun id -> Lvar id) !new_ids_init) + and linh_envs = + List.map (fun (_, p) -> Lprim(Pfield 3, [transl_path p])) + (List.rev inh_init) + in + let make_envs lam = + Llet(StrictOpt, envs, +- (if linh_envs = [] then lenv else +- Lprim(Pmakeblock(0, Immutable), lenv :: linh_envs)), +- lam) +- and def_ids cla lam = +- Llet(StrictOpt, env2, +- Lapply (oo_prim "new_variable", [Lvar cla; transl_label ""]), ++ (if linh_envs = [] then lenv else ltuple (lenv :: linh_envs)), + lam) + in + let inh_paths = +@@ -757,46 +767,53 @@ + (fun (_,path) -> List.mem (Path.head path) new_ids) inh_init in + let inh_keys = + List.map (fun (_,p) -> Lprim(Pfield 1, [transl_path p])) inh_paths in +- let lclass lam = +- Llet(Strict, class_init, +- Lfunction(Curried, [cla], def_ids cla cl_init), lam) ++ let lclass_init lam = ++ Llet(Strict, class_init, cl_init_fun, lam) + and lcache lam = + if inh_keys = [] then Llet(Alias, cached, Lvar tables, lam) else +- Llet(Strict, cached, +- Lapply(oo_prim "lookup_tables", +- [Lvar tables; Lprim(Pmakeblock(0, Immutable), inh_keys)]), ++ Llet(Strict, cached, lprim "lookup_tables" [Lvar tables; ltuple inh_keys], + lam) + and lset cached i lam = + Lprim(Psetfield(i, true), [Lvar cached; lam]) + in +- let ldirect () = +- ltable cla +- (Llet(Strict, env_init, def_ids cla cl_init, +- Lsequence(Lapply (oo_prim "init_class", [Lvar cla]), +- lset cached 0 (Lvar env_init)))) +- and lclass_virt () = +- lset cached 0 (Lfunction(Curried, [cla], def_ids cla cl_init)) ++ let ldirect prim pos = ++ ltable cla ( ++ Llet(Strict, env_init, cl_init, ++ Lsequence(lprim prim (Lvar cla :: pos), Lvar env_init))) ++ and lclass_concrete cached = ++ ltuple [Lapply (lfield cached 0, [lenvs]); ++ lfield cached 1; lfield cached 0; lenvs] + in ++ + llets ( +- lcache ( +- Lsequence( +- Lifthenelse(lfield cached 0, lambda_unit, +- if ids = [] then ldirect () else +- if not concrete then lclass_virt () else +- lclass ( +- Lapply (oo_prim "make_class_store", +- [transl_meth_list pub_meths; +- Lvar class_init; Lvar cached]))), + make_envs ( +- if ids = [] then Lapply(lfield cached 0, [lenvs]) else +- Lprim(Pmakeblock(0, Immutable), +- if concrete then +- [Lapply(lfield cached 0, [lenvs]); +- lfield cached 1; +- lfield cached 0; +- lenvs] +- else [lambda_unit; lfield cached 0; lambda_unit; lenvs] +- ))))) ++ if inh_paths = [] && concrete then ++ if ids = [] then begin ++ table_init := Some (ldirect "init_class_shared" filepos); ++ Lapply (Lvar tables, [lenvs]) ++ end else begin ++ let init = ++ lclass cl_init_fun (fun _ -> ++ lprim "make_class_env" ++ (transl_meth_list pub_meths :: Lvar class_init :: filepos)) ++ in table_init := Some init; ++ lclass_concrete tables ++ end ++ else begin ++ lcache ( ++ Lsequence( ++ Lifthenelse(lfield cached 0, lambda_unit, ++ if ids = [] then lset cached 0 (ldirect "init_class" []) else ++ if not concrete then lset cached 0 cl_init_fun else ++ lclass_init ( ++ lprim "make_class_store" ++ [transl_meth_list pub_meths; Lvar class_init; Lvar cached])), ++ llets ( ++ make_envs ( ++ if ids = [] then Lapply(lfield cached 0, [lenvs]) else ++ if concrete then lclass_concrete cached else ++ ltuple [lambda_unit; lfield cached 0; lambda_unit; lenvs])))) ++ end)) + + (* Wrapper for class compilation *) + +Index: bytecomp/translobj.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translobj.ml,v +retrieving revision 1.9 +diff -u -r1.9 translobj.ml +--- bytecomp/translobj.ml 26 May 2004 11:10:51 -0000 1.9 ++++ bytecomp/translobj.ml 2 Feb 2006 05:08:56 -0000 +@@ -88,7 +88,6 @@ + + (* Insert labels *) + +-let string s = Lconst (Const_base (Const_string s)) + let int n = Lconst (Const_base (Const_int n)) + + let prim_makearray = +@@ -124,8 +123,8 @@ + let top_env = ref Env.empty + let classes = ref [] + +-let oo_add_class id = +- classes := id :: !classes; ++let oo_add_class id init = ++ classes := (id, init) :: !classes; + (!top_env, !cache_required) + + let oo_wrap env req f x = +@@ -141,10 +140,12 @@ + let lambda = f x in + let lambda = + List.fold_left +- (fun lambda id -> ++ (fun lambda (id, init) -> + Llet(StrictOpt, id, +- Lprim(Pmakeblock(0, Mutable), +- [lambda_unit; lambda_unit; lambda_unit]), ++ (match !init with ++ Some lam -> lam ++ | None -> Lprim(Pmakeblock(0, Mutable), ++ [lambda_unit; lambda_unit; lambda_unit])), + lambda)) + lambda !classes + in +Index: bytecomp/translobj.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translobj.mli,v +retrieving revision 1.6 +diff -u -r1.6 translobj.mli +--- bytecomp/translobj.mli 26 May 2004 11:10:51 -0000 1.6 ++++ bytecomp/translobj.mli 2 Feb 2006 05:08:56 -0000 +@@ -25,4 +25,4 @@ + Ident.t -> int -> ('a -> lambda) -> 'a -> int * lambda + + val oo_wrap: Env.t -> bool -> ('a -> lambda) -> 'a -> lambda +-val oo_add_class: Ident.t -> Env.t * bool ++val oo_add_class: Ident.t -> Lambda.lambda option ref -> Env.t * bool +Index: byterun/compare.h +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/byterun/compare.h,v +retrieving revision 1.2 +diff -u -r1.2 compare.h +--- byterun/compare.h 31 Dec 2003 14:20:35 -0000 1.2 ++++ byterun/compare.h 2 Feb 2006 05:08:56 -0000 +@@ -17,5 +17,6 @@ + #define CAML_COMPARE_H + + CAMLextern int caml_compare_unordered; ++CAMLextern value caml_compare(value, value); + + #endif /* CAML_COMPARE_H */ +Index: byterun/extern.c +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/byterun/extern.c,v +retrieving revision 1.59 +diff -u -r1.59 extern.c +--- byterun/extern.c 4 Jan 2006 16:55:49 -0000 1.59 ++++ byterun/extern.c 2 Feb 2006 05:08:56 -0000 +@@ -411,6 +411,22 @@ + extern_record_location(v); + break; + } ++ case Object_tag: { ++ value field0; ++ mlsize_t i; ++ i = Wosize_val(Field(v, 0)) - 1; ++ field0 = Field(Field(v, 0),i); ++ if (Wosize_val(field0) > 0) { ++ writecode32(CODE_OBJECT, Wosize_hd (hd)); ++ extern_record_location(v); ++ extern_rec(field0); ++ for (i = 1; i < sz - 1; i++) extern_rec(Field(v, i)); ++ v = Field(v, i); ++ goto tailcall; ++ } ++ if (!extern_closures) ++ extern_invalid_argument("output_value: dynamic class"); ++ } /* may fall through */ + default: { + value field0; + mlsize_t i; +Index: byterun/intern.c +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/byterun/intern.c,v +retrieving revision 1.60 +diff -u -r1.60 intern.c +--- byterun/intern.c 22 Sep 2005 14:21:50 -0000 1.60 ++++ byterun/intern.c 2 Feb 2006 05:08:56 -0000 +@@ -28,6 +28,8 @@ + #include "mlvalues.h" + #include "misc.h" + #include "reverse.h" ++#include "callback.h" ++#include "compare.h" + + static unsigned char * intern_src; + /* Reading pointer in block holding input data. */ +@@ -98,6 +100,25 @@ + #define readblock(dest,len) \ + (memmove((dest), intern_src, (len)), intern_src += (len)) + ++static value get_method_table (value key) ++{ ++ static value *classes = NULL; ++ value current; ++ if (classes == NULL) { ++ classes = caml_named_value("caml_oo_classes"); ++ if (classes == NULL) return 0; ++ caml_register_global_root(classes); ++ } ++ for (current = Field(*classes, 0); Is_block(current); ++ current = Field(current, 1)) ++ { ++ value head = Field(current, 0); ++ if (caml_compare(key, Field(head, 0)) == Val_int(0)) ++ return Field(head, 1); ++ } ++ return 0; ++} ++ + static void intern_cleanup(void) + { + if (intern_input_malloced) caml_stat_free(intern_input); +@@ -315,6 +336,24 @@ + Custom_ops_val(v) = ops; + intern_dest += 1 + size; + break; ++ case CODE_OBJECT: ++ size = read32u(); ++ v = Val_hp(intern_dest); ++ *dest = v; ++ if (intern_obj_table != NULL) intern_obj_table[obj_counter++] = v; ++ dest = (value *) (intern_dest + 1); ++ *intern_dest = Make_header(size, Object_tag, intern_color); ++ intern_dest += 1 + size; ++ intern_rec(dest); ++ *dest = get_method_table(*dest); ++ if (*dest == 0) { ++ intern_cleanup(); ++ caml_failwith("input_value: unknown class"); ++ } ++ for(size--, dest++; size > 1; size--, dest++) ++ intern_rec(dest); ++ goto tailcall; ++ + default: + intern_cleanup(); + caml_failwith("input_value: ill-formed message"); +Index: byterun/intext.h +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/byterun/intext.h,v +retrieving revision 1.32 +diff -u -r1.32 intext.h +--- byterun/intext.h 22 Sep 2005 14:21:50 -0000 1.32 ++++ byterun/intext.h 2 Feb 2006 05:08:56 -0000 +@@ -56,6 +56,7 @@ + #define CODE_CODEPOINTER 0x10 + #define CODE_INFIXPOINTER 0x11 + #define CODE_CUSTOM 0x12 ++#define CODE_OBJECT 0x14 + + #if ARCH_FLOAT_ENDIANNESS == 0x76543210 + #define CODE_DOUBLE_NATIVE CODE_DOUBLE_BIG +Index: stdlib/camlinternalOO.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.ml,v +retrieving revision 1.14 +diff -u -r1.14 camlinternalOO.ml +--- stdlib/camlinternalOO.ml 25 Oct 2005 18:34:07 -0000 1.14 ++++ stdlib/camlinternalOO.ml 2 Feb 2006 05:08:56 -0000 +@@ -305,10 +305,38 @@ + public_methods; + table + ++(* ++let create_table_variables pub_meths priv_meths vars = ++ let tbl = create_table pub_meths in ++ let pub_meths = to_array pub_meths ++ and priv_meths = to_array priv_meths ++ and vars = to_array vars in ++ let len = 2 + Array.length pub_meths + Array.length priv_meths in ++ let res = Array.create len tbl in ++ let mv = new_methods_variables tbl pub_meths vars in ++ Array.blit mv 0 res 1; ++ res ++*) ++ + let init_class table = + inst_var_count := !inst_var_count + table.size - 1; + table.initializers <- List.rev table.initializers; +- resize table (3 + magic table.methods.(1) * 16 / Sys.word_size) ++ let len = 3 + magic table.methods.(1) * 16 / Sys.word_size in ++ (* keep 1 more for extra info *) ++ let len = if len > Array.length table.methods then len else len+1 in ++ resize table len ++ ++let classes = ref [] ++let () = Callback.register "caml_oo_classes" classes ++ ++let init_class_shared table (file : string) (pos : int) = ++ init_class table; ++ let rec unique_pos pos = ++ if List.mem_assoc (file, pos) !classes then unique_pos (pos + 0x100000) ++ else pos in ++ let pos = unique_pos pos in ++ table.methods.(Array.length table.methods - 1) <- Obj.magic (file, pos); ++ classes := ((file, pos), table.methods) :: !classes + + let inherits cla vals virt_meths concr_meths (_, super, _, env) top = + narrow cla vals virt_meths concr_meths; +@@ -319,12 +347,18 @@ + Array.map (fun nm -> get_method cla (get_method_label cla nm)) + (to_array concr_meths)) + +-let make_class pub_meths class_init = ++let make_class pub_meths class_init file pos = + let table = create_table pub_meths in + let env_init = class_init table in +- init_class table; ++ init_class_shared table file pos; + (env_init (Obj.repr 0), class_init, env_init, Obj.repr 0) + ++let make_class_env pub_meths class_init file pos = ++ let table = create_table pub_meths in ++ let env_init = class_init table in ++ init_class_shared table file pos; ++ (env_init, class_init) ++ + type init_table = { mutable env_init: t; mutable class_init: table -> t } + + let make_class_store pub_meths class_init init_table = +Index: stdlib/camlinternalOO.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.mli,v +retrieving revision 1.9 +diff -u -r1.9 camlinternalOO.mli +--- stdlib/camlinternalOO.mli 25 Oct 2005 18:34:07 -0000 1.9 ++++ stdlib/camlinternalOO.mli 2 Feb 2006 05:08:56 -0000 +@@ -43,14 +43,20 @@ + val add_initializer : table -> (obj -> unit) -> unit + val dummy_table : table + val create_table : string array -> table ++(* val create_table_variables : ++ string array -> string array -> string array -> table *) + val init_class : table -> unit ++val init_class_shared : table -> string -> int -> unit + val inherits : + table -> string array -> string array -> string array -> + (t * (table -> obj -> Obj.t) * t * obj) -> bool -> + (Obj.t * int array * closure array) + val make_class : +- string array -> (table -> Obj.t -> t) -> ++ string array -> (table -> Obj.t -> t) -> string -> int -> + (t * (table -> Obj.t -> t) * (Obj.t -> t) * Obj.t) ++val make_class_env : ++ string array -> (table -> Obj.t -> t) -> string -> int -> ++ (Obj.t -> t) * (table -> Obj.t -> t) + type init_table + val make_class_store : + string array -> (table -> t) -> init_table -> unit diff --git a/testlabl/multimatch.diffs b/testlabl/multimatch.diffs new file mode 100644 index 00000000..6eb34b72 --- /dev/null +++ b/testlabl/multimatch.diffs @@ -0,0 +1,1418 @@ +Index: parsing/lexer.mll +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/lexer.mll,v +retrieving revision 1.73 +diff -u -r1.73 lexer.mll +--- parsing/lexer.mll 11 Apr 2005 16:44:26 -0000 1.73 ++++ parsing/lexer.mll 2 Feb 2006 06:28:32 -0000 +@@ -63,6 +63,8 @@ + "match", MATCH; + "method", METHOD; + "module", MODULE; ++ "multifun", MULTIFUN; ++ "multimatch", MULTIMATCH; + "mutable", MUTABLE; + "new", NEW; + "object", OBJECT; +Index: parsing/parser.mly +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/parser.mly,v +retrieving revision 1.123 +diff -u -r1.123 parser.mly +--- parsing/parser.mly 23 Mar 2005 03:08:37 -0000 1.123 ++++ parsing/parser.mly 2 Feb 2006 06:28:32 -0000 +@@ -257,6 +257,8 @@ + %token MINUSDOT + %token MINUSGREATER + %token MODULE ++%token MULTIFUN ++%token MULTIMATCH + %token MUTABLE + %token NATIVEINT + %token NEW +@@ -325,7 +327,7 @@ + %nonassoc SEMI /* below EQUAL ({lbl=...; lbl=...}) */ + %nonassoc LET /* above SEMI ( ...; let ... in ...) */ + %nonassoc below_WITH +-%nonassoc FUNCTION WITH /* below BAR (match ... with ...) */ ++%nonassoc FUNCTION WITH MULTIFUN /* below BAR (match ... with ...) */ + %nonassoc AND /* above WITH (module rec A: SIG with ... and ...) */ + %nonassoc THEN /* below ELSE (if ... then ...) */ + %nonassoc ELSE /* (if ... then ... else ...) */ +@@ -804,8 +806,12 @@ + { mkexp(Pexp_function("", None, List.rev $3)) } + | FUN labeled_simple_pattern fun_def + { let (l,o,p) = $2 in mkexp(Pexp_function(l, o, [p, $3])) } ++ | MULTIFUN opt_bar match_cases ++ { mkexp(Pexp_multifun(List.rev $3)) } + | MATCH seq_expr WITH opt_bar match_cases +- { mkexp(Pexp_match($2, List.rev $5)) } ++ { mkexp(Pexp_match($2, List.rev $5, false)) } ++ | MULTIMATCH seq_expr WITH opt_bar match_cases ++ { mkexp(Pexp_match($2, List.rev $5, true)) } + | TRY seq_expr WITH opt_bar match_cases + { mkexp(Pexp_try($2, List.rev $5)) } + | TRY seq_expr WITH error +@@ -1318,10 +1324,10 @@ + | simple_core_type2 { Rinherit $1 } + ; + tag_field: +- name_tag OF opt_ampersand amper_type_list +- { Rtag ($1, $3, List.rev $4) } +- | name_tag +- { Rtag ($1, true, []) } ++ name_tag OF opt_ampersand amper_type_list amper_type_pair_list ++ { Rtag ($1, $3, List.rev $4, $5) } ++ | name_tag amper_type_pair_list ++ { Rtag ($1, true, [], $2) } + ; + opt_ampersand: + AMPERSAND { true } +@@ -1331,6 +1337,11 @@ + core_type { [$1] } + | amper_type_list AMPERSAND core_type { $3 :: $1 } + ; ++amper_type_pair_list: ++ AMPERSAND core_type EQUAL core_type amper_type_pair_list ++ { ($2, $4) :: $5 } ++ | /* empty */ ++ { [] } + opt_present: + LBRACKETGREATER name_tag_list RBRACKET { List.rev $2 } + | /* empty */ { [] } +Index: parsing/parsetree.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/parsetree.mli,v +retrieving revision 1.42 +diff -u -r1.42 parsetree.mli +--- parsing/parsetree.mli 23 Mar 2005 03:08:37 -0000 1.42 ++++ parsing/parsetree.mli 2 Feb 2006 06:28:32 -0000 +@@ -43,7 +43,7 @@ + | Pfield_var + + and row_field = +- Rtag of label * bool * core_type list ++ Rtag of label * bool * core_type list * (core_type * core_type) list + | Rinherit of core_type + + (* XXX Type expressions for the class language *) +@@ -86,7 +86,7 @@ + | Pexp_let of rec_flag * (pattern * expression) list * expression + | Pexp_function of label * expression option * (pattern * expression) list + | Pexp_apply of expression * (label * expression) list +- | Pexp_match of expression * (pattern * expression) list ++ | Pexp_match of expression * (pattern * expression) list * bool + | Pexp_try of expression * (pattern * expression) list + | Pexp_tuple of expression list + | Pexp_construct of Longident.t * expression option * bool +@@ -111,6 +111,7 @@ + | Pexp_lazy of expression + | Pexp_poly of expression * core_type option + | Pexp_object of class_structure ++ | Pexp_multifun of (pattern * expression) list + + (* Value descriptions *) + +Index: parsing/printast.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/printast.ml,v +retrieving revision 1.29 +diff -u -r1.29 printast.ml +--- parsing/printast.ml 4 Jan 2006 16:55:50 -0000 1.29 ++++ parsing/printast.ml 2 Feb 2006 06:28:32 -0000 +@@ -205,10 +205,14 @@ + line i ppf "Pexp_apply\n"; + expression i ppf e; + list i label_x_expression ppf l; +- | Pexp_match (e, l) -> ++ | Pexp_match (e, l, b) -> + line i ppf "Pexp_match\n"; + expression i ppf e; + list i pattern_x_expression_case ppf l; ++ bool i ppf b ++ | Pexp_multifun l -> ++ line i ppf "Pexp_multifun\n"; ++ list i pattern_x_expression_case ppf l; + | Pexp_try (e, l) -> + line i ppf "Pexp_try\n"; + expression i ppf e; +@@ -653,7 +657,7 @@ + + and label_x_bool_x_core_type_list i ppf x = + match x with +- Rtag (l, b, ctl) -> ++ Rtag (l, b, ctl, cstr) -> + line i ppf "Rtag \"%s\" %s\n" l (string_of_bool b); + list (i+1) core_type ppf ctl + | Rinherit (ct) -> +Index: typing/btype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/btype.ml,v +retrieving revision 1.38 +diff -u -r1.38 btype.ml +--- typing/btype.ml 4 Jan 2006 16:55:50 -0000 1.38 ++++ typing/btype.ml 2 Feb 2006 06:28:32 -0000 +@@ -66,16 +66,16 @@ + Clink r when !r <> Cunknown -> commu_repr !r + | c -> c + +-let rec row_field_repr_aux tl = function +- Reither(_, tl', _, {contents = Some fi}) -> +- row_field_repr_aux (tl@tl') fi +- | Reither(c, tl', m, r) -> +- Reither(c, tl@tl', m, r) ++let rec row_field_repr_aux tl tl2 = function ++ Reither(_, tl', _, tl2', {contents = Some fi}) -> ++ row_field_repr_aux (tl@tl') (tl2@tl2') fi ++ | Reither(c, tl', m, tl2', r) -> ++ Reither(c, tl@tl', m, tl2@tl2', r) + | Rpresent (Some _) when tl <> [] -> + Rpresent (Some (List.hd tl)) + | fi -> fi + +-let row_field_repr fi = row_field_repr_aux [] fi ++let row_field_repr fi = row_field_repr_aux [] [] fi + + let rec rev_concat l ll = + match ll with +@@ -170,7 +170,8 @@ + (fun (_, fi) -> + match row_field_repr fi with + | Rpresent(Some ty) -> f ty +- | Reither(_, tl, _, _) -> List.iter f tl ++ | Reither(_, tl, _, tl2, _) -> ++ List.iter f tl; List.iter (fun (t1,t2) -> f t1; f t2) tl2 + | _ -> ()) + row.row_fields; + match (repr row.row_more).desc with +@@ -208,15 +209,17 @@ + (fun (l, fi) -> l, + match row_field_repr fi with + | Rpresent(Some ty) -> Rpresent(Some(f ty)) +- | Reither(c, tl, m, e) -> ++ | Reither(c, tl, m, tpl, e) -> + let e = if keep then e else ref None in + let m = if row.row_fixed then fixed else m in + let tl = List.map f tl in ++ let tl1 = List.map (fun (t1,_) -> repr (f t1)) tpl ++ and tl2 = List.map (fun (_,t2) -> repr (f t2)) tpl in + bound := List.filter + (function {desc=Tconstr(_,[],_)} -> false | _ -> true) +- (List.map repr tl) ++ (List.map repr tl @ tl1 @ tl2) + @ !bound; +- Reither(c, tl, m, e) ++ Reither(c, tl, m, List.combine tl1 tl2, e) + | _ -> fi) + row.row_fields in + let name = +Index: typing/ctype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v +retrieving revision 1.200 +diff -u -r1.200 ctype.ml +--- typing/ctype.ml 6 Jan 2006 02:16:24 -0000 1.200 ++++ typing/ctype.ml 2 Feb 2006 06:28:32 -0000 +@@ -340,7 +340,7 @@ + let fi = filter_row_fields erase fi in + match row_field_repr f with + Rabsent -> fi +- | Reither(_,_,false,e) when erase -> set_row_field e Rabsent; fi ++ | Reither(_,_,false,_,e) when erase -> set_row_field e Rabsent; fi + | _ -> p :: fi + + (**************************************) +@@ -1286,6 +1286,10 @@ + + module TypeMap = Map.Make (TypeOps) + ++ ++(* A list of univars which may appear free in a type, but only if generic *) ++let allowed_univars = ref TypeSet.empty ++ + (* Test the occurence of free univars in a type *) + (* that's way too expansive. Must do some kind of cacheing *) + let occur_univar env ty = +@@ -1307,7 +1311,12 @@ + then + match ty.desc with + Tunivar -> +- if not (TypeSet.mem ty bound) then raise (Unify [ty, newgenvar()]) ++ if TypeSet.mem ty bound then () else ++ if TypeSet.mem ty !allowed_univars && ++ (ty.level = generic_level || ++ ty.level = pivot_level - generic_level) ++ then () ++ else raise (Unify [ty, newgenvar()]) + | Tpoly (ty, tyl) -> + let bound = List.fold_right TypeSet.add (List.map repr tyl) bound in + occur_rec bound ty +@@ -1393,6 +1402,7 @@ + with exn -> univar_pairs := old_univars; raise exn + + let univar_pairs = ref [] ++let delayed_conditionals = ref [] + + + (*****************) +@@ -1691,9 +1701,11 @@ + with Not_found -> (h,l)::hl) + (List.map (fun (l,_) -> (hash_variant l, l)) row1.row_fields) + (List.map fst r2)); ++ let fixed1 = row1.row_fixed || rm1.desc <> Tvar ++ and fixed2 = row2.row_fixed || rm2.desc <> Tvar in + let more = +- if row1.row_fixed then rm1 else +- if row2.row_fixed then rm2 else ++ if fixed1 then rm1 else ++ if fixed2 then rm2 else + newgenvar () + in update_level env (min rm1.level rm2.level) more; + let fixed = row1.row_fixed || row2.row_fixed +@@ -1726,18 +1738,18 @@ + let bound = row1.row_bound @ row2.row_bound in + let row0 = {row_fields = []; row_more = more; row_bound = bound; + row_closed = closed; row_fixed = fixed; row_name = name} in +- let set_more row rest = ++ let set_more row row_fixed rest = + let rest = + if closed then + filter_row_fields row.row_closed rest + else rest in +- if rest <> [] && (row.row_closed || row.row_fixed) +- || closed && row.row_fixed && not row.row_closed then begin ++ if rest <> [] && (row.row_closed || row_fixed) ++ || closed && row_fixed && not row.row_closed then begin + let t1 = mkvariant [] true and t2 = mkvariant rest false in + raise (Unify [if row == row1 then (t1,t2) else (t2,t1)]) + end; + let rm = row_more row in +- if row.row_fixed then ++ if row_fixed then + if row0.row_more == rm then () else + if rm.desc = Tvar then link_type rm row0.row_more else + unify env rm row0.row_more +@@ -1748,11 +1760,11 @@ + in + let md1 = rm1.desc and md2 = rm2.desc in + begin try +- set_more row1 r2; +- set_more row2 r1; ++ set_more row1 fixed1 r2; ++ set_more row2 fixed2 r1; + List.iter + (fun (l,f1,f2) -> +- try unify_row_field env row1.row_fixed row2.row_fixed l f1 f2 ++ try unify_row_field env fixed1 fixed2 row1 row2 l f1 f2 + with Unify trace -> + raise (Unify ((mkvariant [l,f1] true, + mkvariant [l,f2] true) :: trace))) +@@ -1761,13 +1773,13 @@ + log_type rm1; rm1.desc <- md1; log_type rm2; rm2.desc <- md2; raise exn + end + +-and unify_row_field env fixed1 fixed2 l f1 f2 = ++and unify_row_field env fixed1 fixed2 row1 row2 l f1 f2 = + let f1 = row_field_repr f1 and f2 = row_field_repr f2 in + if f1 == f2 then () else + match f1, f2 with + Rpresent(Some t1), Rpresent(Some t2) -> unify env t1 t2 + | Rpresent None, Rpresent None -> () +- | Reither(c1, tl1, m1, e1), Reither(c2, tl2, m2, e2) -> ++ | Reither(c1, tl1, m1, tp1, e1), Reither(c2, tl2, m2, tp2, e2) -> + if e1 == e2 then () else + let redo = + (m1 || m2) && +@@ -1777,32 +1789,70 @@ + List.iter (unify env t1) tl; + !e1 <> None || !e2 <> None + end in +- if redo then unify_row_field env fixed1 fixed2 l f1 f2 else ++ let redo = ++ redo || begin ++ if tp1 = [] && fixed1 then unify_pairs env tp2; ++ if tp2 = [] && fixed2 then unify_pairs env tp1; ++ !e1 <> None || !e2 <> None ++ end ++ in ++ if redo then unify_row_field env fixed1 fixed2 row1 row2 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 repr_pairs = List.map (fun (t1,t2) -> repr t1, repr t2) in ++ let tp1 = repr_pairs tp1 and tp2 = repr_pairs tp2 in ++ let rec rempq tp = function [] -> [] ++ | (t1,t2 as p) :: tp' -> ++ if List.exists (fun (t1',t2') -> t1==t1' && t2==t2') (tp@tp') then ++ rempq tp tp' ++ else p :: rempq tp tp' ++ in ++ let tp1' = ++ if fixed2 then begin ++ delayed_conditionals := ++ (!univar_pairs, tp1, l, row2) :: !delayed_conditionals; ++ [] ++ end else rempq tp2 tp1 ++ and tp2' = ++ if fixed1 then begin ++ delayed_conditionals := ++ (!univar_pairs, tp2, l, row1) :: !delayed_conditionals; ++ [] ++ end else rempq tp1 tp2 ++ in + let e = ref None in +- let f1' = Reither(c1 || c2, tl1', m1 || m2, e) +- and f2' = Reither(c1 || c2, tl2', m1 || m2, e) in +- set_row_field e1 f1'; set_row_field e2 f2'; +- | Reither(_, _, false, e1), Rabsent -> set_row_field e1 f2 +- | Rabsent, Reither(_, _, false, e2) -> set_row_field e2 f1 ++ let f1' = Reither(c1 || c2, tl1', m1 || m2, tp2', e) ++ and f2' = Reither(c1 || c2, tl2', m1 || m2, tp1', e) in ++ set_row_field e1 f1'; set_row_field e2 f2' ++ | Reither(_, _, false, _, e1), Rabsent -> set_row_field e1 f2 ++ | Rabsent, Reither(_, _, false, _, e2) -> set_row_field e2 f1 + | Rabsent, Rabsent -> () +- | Reither(false, tl, _, e1), Rpresent(Some t2) when not fixed1 -> ++ | Reither(false, tl, _, tp, e1), Rpresent(Some t2) when not fixed1 -> + set_row_field e1 f2; +- (try List.iter (fun t1 -> unify env t1 t2) tl ++ begin try ++ List.iter (fun t1 -> unify env t1 t2) tl; ++ List.iter (fun (t1,t2) -> unify env t1 t2) tp ++ with exn -> e1 := None; raise exn ++ end ++ | Rpresent(Some t1), Reither(false, tl, _, tp, e2) when not fixed2 -> ++ set_row_field e2 f1; ++ begin try ++ List.iter (unify env t1) tl; ++ List.iter (fun (t1,t2) -> unify env t1 t2) tp ++ with exn -> e2 := None; raise exn ++ end ++ | Reither(true, [], _, tpl, e1), Rpresent None when not fixed1 -> ++ set_row_field e1 f2; ++ (try List.iter (fun (t1,t2) -> unify env t1 t2) tpl + with exn -> e1 := None; raise exn) +- | Rpresent(Some t1), Reither(false, tl, _, e2) when not fixed2 -> ++ | Rpresent None, Reither(true, [], _, tpl, e2) when not fixed2 -> + set_row_field e2 f1; +- (try List.iter (unify env t1) tl ++ (try List.iter (fun (t1,t2) -> unify env t1 t2) tpl + with exn -> e2 := None; raise exn) +- | Reither(true, [], _, e1), Rpresent None when not fixed1 -> +- set_row_field e1 f2 +- | Rpresent None, Reither(true, [], _, e2) when not fixed2 -> +- set_row_field e2 f1 + | _ -> raise (Unify []) + + +@@ -1920,6 +1970,166 @@ + (* Matching between type schemes *) + (***********************************) + ++(* Forward declaration (order should be reversed...) *) ++let equal' = ref (fun _ -> failwith "Ctype.equal'") ++ ++let make_generics_univars tyl = ++ let polyvars = ref TypeSet.empty in ++ let rec make_rec ty = ++ let ty = repr ty in ++ if ty.level = generic_level then begin ++ if ty.desc = Tvar then begin ++ log_type ty; ++ ty.desc <- Tunivar; ++ polyvars := TypeSet.add ty !polyvars ++ end ++ else if ty.desc = Tunivar then set_level ty (generic_level - 1); ++ ty.level <- pivot_level - generic_level; ++ iter_type_expr make_rec ty ++ end ++ in ++ List.iter make_rec tyl; ++ List.iter unmark_type tyl; ++ !polyvars ++ ++(* New version of moregeneral, using unification *) ++ ++let copy_cond (p,tpl,l,row) = ++ let row = ++ match repr (copy (newgenty (Tvariant row))) with ++ {desc=Tvariant row} -> row ++ | _ -> assert false ++ and pairs = ++ List.map (fun (t1,t2) -> copy t1, copy t2) tpl in ++ (p, pairs, l, row) ++ ++let get_row_field l row = ++ try row_field_repr (List.assoc l (row_repr row).row_fields) ++ with Not_found -> Rabsent ++ ++let rec check_conditional_list env cdtls pattvars tpls = ++ match cdtls with ++ [] -> ++ let finished = ++ List.for_all (fun (_,t1,t2) -> !equal' env false [t1] [t2]) tpls in ++ if not finished then begin ++ let polyvars = make_generics_univars pattvars in ++ delayed_conditionals := []; ++ allowed_univars := polyvars; ++ List.iter (fun (pairs, ty1, ty2) -> unify_pairs env ty1 ty2 pairs) ++ tpls; ++ check_conditionals env polyvars !delayed_conditionals ++ end ++ | (pairs, tpl1, l, row2 as cond) :: cdtls -> ++ let cont = check_conditional_list env cdtls pattvars in ++ let tpl1 = ++ List.filter (fun (t1,t2) -> not (!equal' env false [t1] [t2])) tpl1 in ++ let included = ++ List.for_all ++ (fun (t1,t2) -> ++ List.exists ++ (fun (_,t1',t2') -> !equal' env false [t1;t2] [t1';t2']) ++ tpls) ++ tpl1 in ++ if included then cont tpls else ++ match get_row_field l row2 with ++ Rpresent _ -> ++ cont (List.map (fun (t1,t2) -> (pairs,t1,t2)) tpl1 @ tpls) ++ | Rabsent -> cont tpls ++ | Reither (c, tl2, _, _, _) -> ++ cont tpls; ++ if c && tl2 <> [] then () (* cannot succeed *) else ++ let (pairs, tpl1, l, row2) = copy_cond cond ++ and tpls = List.map (fun (p,t1,t2) -> p, copy t1, copy t2) tpls ++ and pattvars = List.map copy pattvars ++ and cdtls = List.map copy_cond cdtls in ++ cleanup_types (); ++ let tl2, tpl2, e2 = ++ match get_row_field l row2 with ++ Reither (c, tl2, _, tpl2, e2) -> tl2, tpl2, e2 ++ | _ -> assert false ++ in ++ let snap = Btype.snapshot () in ++ let ok = ++ try ++ begin match tl2 with ++ [] -> ++ set_row_field e2 (Rpresent None) ++ | t::tl -> ++ set_row_field e2 (Rpresent (Some t)); ++ List.iter (unify env t) tl ++ end; ++ List.iter (fun (t1,t2) -> unify_pairs env t1 t2 pairs) tpl2; ++ true ++ with exn -> ++ Btype.backtrack snap; ++ false ++ in ++ (* This is not [cont] : types have been copied *) ++ if ok then ++ check_conditional_list env cdtls pattvars ++ (List.map (fun (t1,t2) -> (pairs,t1,t2)) tpl1 @ tpls) ++ ++and check_conditionals env polyvars cdtls = ++ let cdtls = List.map copy_cond cdtls in ++ let pattvars = ref [] in ++ TypeSet.iter ++ (fun ty -> ++ let ty = repr ty in ++ match ty.desc with ++ Tsubst ty -> ++ let ty = repr ty in ++ begin match ty.desc with ++ Tunivar -> ++ log_type ty; ++ ty.desc <- Tvar; ++ pattvars := ty :: !pattvars ++ | Ttuple [tv;_] -> ++ if tv.desc = Tunivar then ++ (log_type tv; tv.desc <- Tvar; pattvars := ty :: !pattvars) ++ else if tv.desc <> Tvar then assert false ++ | Tvar -> () ++ | _ -> assert false ++ end ++ | _ -> ()) ++ polyvars; ++ cleanup_types (); ++ check_conditional_list env cdtls !pattvars [] ++ ++ ++(* Must empty univar_pairs first *) ++let unify_poly env polyvars subj patt = ++ let old_level = !current_level in ++ current_level := generic_level; ++ delayed_conditionals := []; ++ allowed_univars := polyvars; ++ try ++ unify env subj patt; ++ check_conditionals env polyvars !delayed_conditionals; ++ current_level := old_level; ++ allowed_univars := TypeSet.empty; ++ delayed_conditionals := [] ++ with exn -> ++ current_level := old_level; ++ allowed_univars := TypeSet.empty; ++ delayed_conditionals := []; ++ raise exn ++ ++let moregeneral env _ subj patt = ++ let old_level = !current_level in ++ current_level := generic_level; ++ let subj = instance subj ++ and patt = instance patt in ++ let polyvars = make_generics_univars [patt] in ++ current_level := old_level; ++ let snap = Btype.snapshot () in ++ try ++ unify_poly env polyvars subj patt; ++ true ++ with Unify _ -> ++ Btype.backtrack snap; ++ false ++ + (* + Update the level of [ty]. First check that the levels of generic + variables from the subject are not lowered. +@@ -2072,35 +2282,101 @@ + Rpresent(Some t1), Rpresent(Some t2) -> + moregen inst_nongen type_pairs env t1 t2 + | Rpresent None, Rpresent None -> () +- | Reither(false, tl1, _, e1), Rpresent(Some t2) when not univ -> ++ | Reither(false, tl1, _, [], e1), Rpresent(Some t2) when not univ -> + set_row_field e1 f2; + List.iter (fun t1 -> moregen inst_nongen type_pairs env t1 t2) tl1 +- | Reither(c1, tl1, _, e1), Reither(c2, tl2, m2, e2) -> ++ | Reither(c1, tl1, _, tpl1, e1), Reither(c2, tl2, m2, tpl2, e2) -> + if e1 != e2 then begin + if c1 && not c2 then raise(Unify []); +- set_row_field e1 (Reither (c2, [], m2, e2)); +- if List.length tl1 = List.length tl2 then +- List.iter2 (moregen inst_nongen type_pairs env) tl1 tl2 +- else match tl2 with +- t2 :: _ -> ++ let tpl' = if tpl1 = [] then tpl2 else [] in ++ set_row_field e1 (Reither (c2, [], m2, tpl', e2)); ++ begin match tl2 with ++ [t2] -> + List.iter (fun t1 -> moregen inst_nongen type_pairs env t1 t2) + tl1 +- | [] -> +- if tl1 <> [] then raise (Unify []) ++ | _ -> ++ if List.length tl1 <> List.length tl2 then raise (Unify []); ++ List.iter2 (moregen inst_nongen type_pairs env) tl1 tl2 ++ end; ++ if tpl1 <> [] then ++ delayed_conditionals := ++ (!univar_pairs, tpl1, l, row2) :: !delayed_conditionals + end +- | Reither(true, [], _, e1), Rpresent None when not univ -> ++ | Reither(true, [], _, [], e1), Rpresent None when not univ -> + set_row_field e1 f2 +- | Reither(_, _, _, e1), Rabsent when not univ -> ++ | Reither(_, _, _, [], e1), Rabsent when not univ -> + set_row_field e1 f2 + | Rabsent, Rabsent -> () + | _ -> raise (Unify [])) + pairs + ++let check_conditional env (pairs, tpl1, l, row2) tpls cont = ++ let tpl1 = ++ List.filter (fun (t1,t2) -> not (!equal' env false [t1] [t2])) tpl1 in ++ let included = ++ List.for_all ++ (fun (t1,t2) -> ++ List.exists (fun (t1',t2') -> !equal' env false [t1;t2] [t1';t2']) ++ tpls) ++ tpl1 in ++ if tpl1 = [] || included then cont tpls else ++ match get_row_field l row2 with ++ Rpresent _ -> cont (tpl1 @ tpls) ++ | Rabsent -> cont tpls ++ | Reither (c, tl2, _, tpl2, e2) -> ++ if not c || tl2 = [] then begin ++ let snap = Btype.snapshot () in ++ let ok = ++ try ++ begin match tl2 with ++ [] -> ++ set_row_field e2 (Rpresent None) ++ | t::tl -> ++ set_row_field e2 (Rpresent (Some t)); ++ List.iter (unify env t) tl ++ end; ++ List.iter (fun (t1,t2) -> unify_pairs env t1 t2 pairs) tpl2; ++ true ++ with Unify _ -> false ++ in ++ if ok then cont (tpl1 @ tpls); ++ Btype.backtrack snap ++ end; ++ cont tpls ++ ++let rec check_conditionals inst_nongen env cdtls tpls = ++ match cdtls with ++ [] -> ++ let tpls = ++ List.filter (fun (t1,t2) -> not (!equal' env false [t1] [t2])) tpls in ++ if tpls = [] then () else begin ++ delayed_conditionals := []; ++ let tl1, tl2 = List.split tpls in ++ let type_pairs = TypePairs.create 13 in ++ List.iter2 (moregen false type_pairs env) tl2 tl1; ++ check_conditionals inst_nongen env !delayed_conditionals [] ++ end ++ | cdtl :: cdtls -> ++ check_conditional env cdtl tpls ++ (check_conditionals inst_nongen env cdtls) ++ ++ + (* Must empty univar_pairs first *) + let moregen inst_nongen type_pairs env patt subj = + univar_pairs := []; +- moregen inst_nongen type_pairs env patt subj ++ delayed_conditionals := []; ++ try ++ moregen inst_nongen type_pairs env patt subj; ++ check_conditionals inst_nongen env !delayed_conditionals []; ++ univar_pairs := []; ++ delayed_conditionals := [] ++ with exn -> ++ univar_pairs := []; ++ delayed_conditionals := []; ++ raise exn ++ + ++(* old implementation + (* + Non-generic variable can be instanciated only if [inst_nongen] is + true. So, [inst_nongen] should be set to false if the subject might +@@ -2128,6 +2404,7 @@ + in + current_level := old_level; + res ++*) + + + (* Alternative approach: "rigidify" a type scheme, +@@ -2296,30 +2573,36 @@ + {desc=Tvariant row2} -> eqtype_row rename type_pairs subst env row1 row2 + | _ -> raise Cannot_expand + with Cannot_expand -> ++ let eqtype_rec = eqtype rename type_pairs subst env in + let row1 = row_repr row1 and row2 = row_repr row2 in + let r1, r2, pairs = merge_row_fields row1.row_fields row2.row_fields in + if row1.row_closed <> row2.row_closed + || not row1.row_closed && (r1 <> [] || r2 <> []) + || filter_row_fields false (r1 @ r2) <> [] + then raise (Unify []); +- if not (static_row row1) then +- eqtype rename type_pairs subst env row1.row_more row2.row_more; ++ if not (static_row row1) then eqtype_rec row1.row_more row2.row_more; + List.iter + (fun (_,f1,f2) -> + match row_field_repr f1, row_field_repr f2 with + Rpresent(Some t1), Rpresent(Some t2) -> +- eqtype rename type_pairs subst env t1 t2 +- | Reither(true, [], _, _), Reither(true, [], _, _) -> +- () +- | Reither(false, t1::tl1, _, _), Reither(false, t2::tl2, _, _) -> +- eqtype rename type_pairs subst env t1 t2; ++ eqtype_rec t1 t2 ++ | Reither(true, [], _, tp1, _), Reither(true, [], _, tp2, _) -> ++ List.iter2 ++ (fun (t1,t1') (t2,t2') -> eqtype_rec t1 t2; eqtype_rec t1' t2') ++ tp1 tp2 ++ | Reither(false, t1::tl1, _, tpl1, _), ++ Reither(false, t2::tl2, _, tpl2, _) -> ++ eqtype_rec t1 t2; ++ List.iter2 ++ (fun (t1,t1') (t2,t2') -> eqtype_rec t1 t2; eqtype_rec t1' t2') ++ tpl1 tpl2; + if List.length tl1 = List.length tl2 then + (* if same length allow different types (meaning?) *) +- List.iter2 (eqtype rename type_pairs subst env) tl1 tl2 ++ List.iter2 eqtype_rec tl1 tl2 + else begin + (* otherwise everything must be equal *) +- List.iter (eqtype rename type_pairs subst env t1) tl2; +- List.iter (fun t1 -> eqtype rename type_pairs subst env t1 t2) tl1 ++ List.iter (eqtype_rec t1) tl2; ++ List.iter (fun t1 -> eqtype_rec t1 t2) tl1 + end + | Rpresent None, Rpresent None -> () + | Rabsent, Rabsent -> () +@@ -2334,6 +2617,8 @@ + with + Unify _ -> false + ++let () = equal' := equal ++ + (* Must empty univar_pairs first *) + let eqtype rename type_pairs subst env t1 t2 = + univar_pairs := []; +@@ -2770,14 +3055,14 @@ + (fun (l,f as orig) -> match row_field_repr f with + Rpresent None -> + if posi then +- (l, Reither(true, [], false, ref None)), Unchanged ++ (l, Reither(true, [], false, [], ref None)), Unchanged + else + orig, Unchanged + | Rpresent(Some t) -> + let (t', c) = build_subtype env visited loops posi level' t in + if posi && level > 0 then begin + bound := t' :: !bound; +- (l, Reither(false, [t'], false, ref None)), c ++ (l, Reither(false, [t'], false, [], ref None)), c + end else + (l, Rpresent(Some t')), c + | _ -> assert false) +@@ -2960,11 +3245,11 @@ + List.fold_left + (fun cstrs (_,f1,f2) -> + match row_field_repr f1, row_field_repr f2 with +- (Rpresent None|Reither(true,_,_,_)), Rpresent None -> ++ (Rpresent None|Reither(true,_,_,[],_)), Rpresent None -> + cstrs + | Rpresent(Some t1), Rpresent(Some t2) -> + subtype_rec env ((t1, t2)::trace) t1 t2 cstrs +- | Reither(false, t1::_, _, _), Rpresent(Some t2) -> ++ | Reither(false, t1::_, _, [], _), Rpresent(Some t2) -> + subtype_rec env ((t1, t2)::trace) t1 t2 cstrs + | Rabsent, _ -> cstrs + | _ -> raise Exit) +@@ -2977,11 +3262,11 @@ + (fun cstrs (_,f1,f2) -> + match row_field_repr f1, row_field_repr f2 with + Rpresent None, Rpresent None +- | Reither(true,[],_,_), Reither(true,[],_,_) ++ | Reither(true,[],_,[],_), Reither(true,[],_,[],_) + | Rabsent, Rabsent -> + cstrs + | Rpresent(Some t1), Rpresent(Some t2) +- | Reither(false,[t1],_,_), Reither(false,[t2],_,_) -> ++ | Reither(false,[t1],_,[],_), Reither(false,[t2],_,[],_) -> + subtype_rec env ((t1, t2)::trace) t1 t2 cstrs + | _ -> raise Exit) + cstrs pairs +@@ -3079,16 +3364,26 @@ + let fields = List.map + (fun (l,f) -> + let f = row_field_repr f in l, +- match f with Reither(b, ty::(_::_ as tyl), m, e) -> +- let tyl' = +- List.fold_left +- (fun tyl ty -> +- if List.exists (fun ty' -> equal env false [ty] [ty']) tyl +- then tyl else ty::tyl) +- [ty] tyl ++ match f with Reither(b, tyl, m, tp, e) -> ++ let rem_dbl eq l = ++ List.rev ++ (List.fold_left ++ (fun xs x -> if List.exists (eq x) xs then xs else x::xs) ++ [] l) ++ in ++ let tyl' = rem_dbl (fun t1 t2 -> equal env false [t1] [t2]) tyl ++ and tp' = ++ List.filter ++ (fun (ty1,ty2) -> not (equal env false [ty1] [ty2])) tp ++ in ++ let tp' = ++ rem_dbl ++ (fun (t1,t2) (t1',t2') -> equal env false [t1;t2] [t1';t2']) ++ tp' + in +- if List.length tyl' <= List.length tyl then +- let f = Reither(b, List.rev tyl', m, ref None) in ++ if List.length tyl' < List.length tyl ++ || List.length tp' < List.length tp then ++ let f = Reither(b, tyl', m, tp', ref None) in + set_row_field e f; + f + else f +@@ -3344,9 +3639,9 @@ + List.iter + (fun (l,fi) -> + match row_field_repr fi with +- Reither (c, t1::(_::_ as tl), m, e) -> ++ Reither (c, t1::(_::_ as tl), m, tp, e) -> + List.iter (unify env t1) tl; +- set_row_field e (Reither (c, [t1], m, ref None)) ++ set_row_field e (Reither (c, [t1], m, tp, ref None)) + | _ -> + ()) + row.row_fields; +Index: typing/includecore.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/includecore.ml,v +retrieving revision 1.32 +diff -u -r1.32 includecore.ml +--- typing/includecore.ml 8 Aug 2005 05:40:52 -0000 1.32 ++++ typing/includecore.ml 2 Feb 2006 06:28:32 -0000 +@@ -71,10 +71,10 @@ + (fun (_, f1, f2) -> + match Btype.row_field_repr f1, Btype.row_field_repr f2 with + Rpresent(Some t1), +- (Rpresent(Some t2) | Reither(false, [t2], _, _)) -> ++ (Rpresent(Some t2) | Reither(false,[t2],_,[],_)) -> + to_equal := (t1,t2) :: !to_equal; true +- | Rpresent None, (Rpresent None | Reither(true, [], _, _)) -> true +- | Reither(c1,tl1,_,_), Reither(c2,tl2,_,_) ++ | Rpresent None, (Rpresent None | Reither(true,[],_,[],_)) -> true ++ | Reither(c1,tl1,_,[],_), Reither(c2,tl2,_,[],_) + when List.length tl1 = List.length tl2 && c1 = c2 -> + to_equal := List.combine tl1 tl2 @ !to_equal; true + | Rabsent, (Reither _ | Rabsent) -> true +Index: typing/oprint.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/oprint.ml,v +retrieving revision 1.22 +diff -u -r1.22 oprint.ml +--- typing/oprint.ml 23 Mar 2005 03:08:37 -0000 1.22 ++++ typing/oprint.ml 2 Feb 2006 06:28:33 -0000 +@@ -223,14 +223,18 @@ + print_fields rest ppf [] + | (s, t) :: l -> + fprintf ppf "%s : %a;@ %a" s print_out_type t (print_fields rest) l +-and print_row_field ppf (l, opt_amp, tyl) = ++and print_row_field ppf (l, opt_amp, tyl, tpl) = + let pr_of ppf = + if opt_amp then fprintf ppf " of@ &@ " + else if tyl <> [] then fprintf ppf " of@ " +- else fprintf ppf "" +- in +- fprintf ppf "@[`%s%t%a@]" l pr_of (print_typlist print_out_type " &") +- tyl ++ and pr_tp ppf (t1,t2) = ++ fprintf ppf "@[%a =@ %a@]" ++ print_out_type t1 ++ print_out_type t2 ++ in ++ fprintf ppf "@[`%s%t%a%a@]" l pr_of ++ (print_typlist print_out_type " &") tyl ++ (print_list_init pr_tp (fun ppf -> fprintf ppf " &@ ")) tpl + and print_typlist print_elem sep ppf = + function + [] -> () +Index: typing/outcometree.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/outcometree.mli,v +retrieving revision 1.14 +diff -u -r1.14 outcometree.mli +--- typing/outcometree.mli 23 Mar 2005 03:08:37 -0000 1.14 ++++ typing/outcometree.mli 2 Feb 2006 06:28:33 -0000 +@@ -61,7 +61,8 @@ + bool * out_variant * bool * (string list) option + | Otyp_poly of string list * out_type + and out_variant = +- | Ovar_fields of (string * bool * out_type list) list ++ | Ovar_fields of ++ (string * bool * out_type list * (out_type * out_type) list ) list + | Ovar_name of out_ident * out_type list + + type out_class_type = +Index: typing/parmatch.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/parmatch.ml,v +retrieving revision 1.70 +diff -u -r1.70 parmatch.ml +--- typing/parmatch.ml 24 Mar 2005 17:20:54 -0000 1.70 ++++ typing/parmatch.ml 2 Feb 2006 06:28:33 -0000 +@@ -568,11 +568,11 @@ + List.fold_left + (fun nm (tag,f) -> + match Btype.row_field_repr f with +- | Reither(_, _, false, e) -> ++ | Reither(_, _, false, _, e) -> + (* m=false means that this tag is not explicitly matched *) + Btype.set_row_field e Rabsent; + None +- | Rabsent | Reither (_, _, true, _) | Rpresent _ -> nm) ++ | Rabsent | Reither (_, _, true, _, _) | Rpresent _ -> nm) + row.row_name row.row_fields in + if not row.row_closed || nm != row.row_name then begin + (* this unification cannot fail *) +@@ -605,8 +605,8 @@ + List.for_all + (fun (tag,f) -> + match Btype.row_field_repr f with +- Rabsent | Reither(_, _, false, _) -> true +- | Reither (_, _, true, _) ++ Rabsent | Reither(_, _, false, _, _) -> true ++ | Reither (_, _, true, _, _) + (* m=true, do not discard matched tags, rather warn *) + | Rpresent _ -> List.mem tag fields) + row.row_fields +@@ -739,7 +739,7 @@ + match Btype.row_field_repr f with + Rabsent (* | Reither _ *) -> others + (* This one is called after erasing pattern info *) +- | Reither (c, _, _, _) -> make_other_pat tag c :: others ++ | Reither (c, _, _, _, _) -> make_other_pat tag c :: others + | Rpresent arg -> make_other_pat tag (arg = None) :: others) + [] row.row_fields + with +Index: typing/printtyp.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/printtyp.ml,v +retrieving revision 1.140 +diff -u -r1.140 printtyp.ml +--- typing/printtyp.ml 4 Jan 2006 16:55:50 -0000 1.140 ++++ typing/printtyp.ml 2 Feb 2006 06:28:33 -0000 +@@ -157,9 +157,12 @@ + and raw_field ppf = function + Rpresent None -> fprintf ppf "Rpresent None" + | Rpresent (Some t) -> fprintf ppf "@[<1>Rpresent(Some@,%a)@]" raw_type t +- | Reither (c,tl,m,e) -> +- fprintf ppf "@[Reither(%b,@,%a,@,%b,@,@[<1>ref%t@])@]" c +- raw_type_list tl m ++ | Reither (c,tl,m,tpl,e) -> ++ fprintf ppf "@[Reither(%b,@,%a,@,%b,@,%a,@,@[<1>ref%t@])@]" ++ c raw_type_list tl m ++ (raw_list ++ (fun ppf (t1,t2) -> ++ fprintf ppf "@[%a,@,%a@]" raw_type t1 raw_type t2)) tpl + (fun ppf -> + match !e with None -> fprintf ppf " None" + | Some f -> fprintf ppf "@,@[<1>(%a)@]" raw_field f) +@@ -219,8 +222,9 @@ + List.for_all + (fun (_, f) -> + match row_field_repr f with +- | Reither(c, l, _, _) -> +- row.row_closed && if c then l = [] else List.length l = 1 ++ | Reither(c, l, _, pl, _) -> ++ row.row_closed && pl = [] && ++ if c then l = [] else List.length l = 1 + | _ -> true) + row.row_fields + +@@ -392,13 +396,16 @@ + + and tree_of_row_field sch (l, f) = + match row_field_repr f with +- | Rpresent None | Reither(true, [], _, _) -> (l, false, []) +- | Rpresent(Some ty) -> (l, false, [tree_of_typexp sch ty]) +- | Reither(c, tyl, _, _) -> +- if c (* contradiction: un constructeur constant qui a un argument *) +- then (l, true, tree_of_typlist sch tyl) +- else (l, false, tree_of_typlist sch tyl) +- | Rabsent -> (l, false, [] (* une erreur, en fait *)) ++ | Rpresent None | Reither(true, [], _, [], _) -> (l, false, [], []) ++ | Rpresent(Some ty) -> (l, false, [tree_of_typexp sch ty], []) ++ | Reither(c, tyl, _, tpl, _) -> ++ let ttpl = ++ List.map ++ (fun (t1,t2) -> tree_of_typexp sch t1, tree_of_typexp sch t2) ++ tpl ++ in ++ (l, c && tpl = [], tree_of_typlist sch tyl, ttpl) ++ | Rabsent -> (l, false, [], [] (* une erreur, en fait *)) + + and tree_of_typlist sch tyl = + List.map (tree_of_typexp sch) tyl +Index: typing/typeclass.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typeclass.ml,v +retrieving revision 1.85 +diff -u -r1.85 typeclass.ml +--- typing/typeclass.ml 22 Jul 2005 06:42:36 -0000 1.85 ++++ typing/typeclass.ml 2 Feb 2006 06:28:33 -0000 +@@ -727,7 +727,7 @@ + {pexp_loc = loc; pexp_desc = + Pexp_match({pexp_loc = loc; pexp_desc = + Pexp_ident(Longident.Lident"*opt*")}, +- scases)} in ++ scases, false)} in + let sfun = + {pcl_loc = scl.pcl_loc; pcl_desc = + Pcl_fun(l, None, {ppat_loc = loc; ppat_desc = Ppat_var"*opt*"}, +Index: typing/typecore.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v +retrieving revision 1.178 +diff -u -r1.178 typecore.ml +--- typing/typecore.ml 6 Jan 2006 02:25:37 -0000 1.178 ++++ typing/typecore.ml 2 Feb 2006 06:28:33 -0000 +@@ -156,15 +156,21 @@ + let field = row_field tag row in + begin match field 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 -> ++ | Reither (true, [], _, tpl, e) when not row.row_closed -> ++ set_row_field e (Rpresent None); ++ List.iter ++ (fun (t1,t2) -> unify_pat pat.pat_env {pat with pat_type=t1} t2) ++ tpl ++ | Reither (false, ty::tl, _, tpl, e) when not row.row_closed -> + set_row_field e (Rpresent (Some ty)); ++ List.iter ++ (fun (t1,t2) -> unify_pat pat.pat_env {pat with pat_type=t1} t2) ++ tpl; + begin match opat with None -> assert false + | Some pat -> List.iter (unify_pat pat.pat_env pat) (ty::tl) + end +- | Reither (c, l, true, e) when not row.row_fixed -> +- set_row_field e (Reither (c, [], false, ref None)) ++ | Reither (c, l, true, tpl, e) when not row.row_fixed -> ++ set_row_field e (Reither (c, [], false, [], ref None)) + | _ -> () + end; + (* Force check of well-formedness *) +@@ -307,13 +313,13 @@ + match row_field_repr f with + Rpresent None -> + (l,None) :: pats, +- (l, Reither(true,[], true, ref None)) :: fields ++ (l, Reither(true,[], true, [], ref None)) :: fields + | Rpresent (Some ty) -> + bound := ty :: !bound; + (l, Some {pat_desc=Tpat_any; pat_loc=Location.none; pat_env=env; + pat_type=ty}) + :: pats, +- (l, Reither(false, [ty], true, ref None)) :: fields ++ (l, Reither(false, [ty], true, [], ref None)) :: fields + | _ -> pats, fields) + ([],[]) fields in + let row = +@@ -337,6 +343,18 @@ + pat pats in + rp { r with pat_loc = loc } + ++let rec flatten_or_pat pat = ++ match pat.pat_desc with ++ Tpat_or (p1, p2, _) -> ++ flatten_or_pat p1 @ flatten_or_pat p2 ++ | _ -> ++ [pat] ++ ++let all_variants pat = ++ List.for_all ++ (function {pat_desc=Tpat_variant _} -> true | _ -> false) ++ (flatten_or_pat pat) ++ + let rec find_record_qual = function + | [] -> None + | (Longident.Ldot (modname, _), _) :: _ -> Some modname +@@ -423,7 +441,7 @@ + let arg = may_map (type_pat env) sarg in + let arg_type = match arg with None -> [] | Some arg -> [arg.pat_type] in + let row = { row_fields = +- [l, Reither(arg = None, arg_type, true, ref None)]; ++ [l, Reither(arg = None, arg_type, true, [], ref None)]; + row_bound = arg_type; + row_closed = false; + row_more = newvar (); +@@ -788,7 +806,7 @@ + newty (Tarrow(p, type_option (newvar ()), type_approx env e, Cok)) + | Pexp_function (p,_,(_,e)::_) -> + newty (Tarrow(p, newvar (), type_approx env e, Cok)) +- | Pexp_match (_, (_,e)::_) -> type_approx env e ++ | Pexp_match (_, (_,e)::_, false) -> type_approx env e + | Pexp_try (e, _) -> type_approx env e + | Pexp_tuple l -> newty (Ttuple(List.map (type_approx env) l)) + | Pexp_ifthenelse (_,e,_) -> type_approx env e +@@ -939,17 +957,26 @@ + exp_loc = sexp.pexp_loc; + exp_type = ty_res; + exp_env = env } +- | Pexp_match(sarg, caselist) -> ++ | Pexp_match(sarg, caselist, multi) -> + let arg = type_exp env sarg in + let ty_res = newvar() in + let cases, partial = +- type_cases env arg.exp_type ty_res (Some sexp.pexp_loc) caselist ++ type_cases env arg.exp_type ty_res (Some sexp.pexp_loc) caselist ~multi + in + re { + exp_desc = Texp_match(arg, cases, partial); + exp_loc = sexp.pexp_loc; + exp_type = ty_res; + exp_env = env } ++ | Pexp_multifun caselist -> ++ let ty_arg = newvar() and ty_res = newvar() in ++ let cases, partial = ++ type_cases env ty_arg ty_res (Some sexp.pexp_loc) caselist ~multi:true ++ in ++ { exp_desc = Texp_function (cases, partial); ++ exp_loc = sexp.pexp_loc; ++ exp_type = newty (Tarrow ("", ty_arg, ty_res, Cok)); ++ exp_env = env } + | Pexp_try(sbody, caselist) -> + let body = type_exp env sbody in + let cases, _ = +@@ -1758,7 +1785,7 @@ + {pexp_loc = loc; pexp_desc = + Pexp_match({pexp_loc = loc; pexp_desc = + Pexp_ident(Longident.Lident"*opt*")}, +- scases)} in ++ scases, false)} in + let sfun = + {pexp_loc = sexp.pexp_loc; pexp_desc = + Pexp_function(l, None,[{ppat_loc = loc; ppat_desc = Ppat_var"*opt*"}, +@@ -1864,7 +1891,8 @@ + + (* Typing of match cases *) + +-and type_cases ?in_function env ty_arg ty_res partial_loc caselist = ++and type_cases ?in_function ?(multi=false) ++ env ty_arg ty_res partial_loc caselist = + let ty_arg' = newvar () in + let pattern_force = ref [] in + let pat_env_list = +@@ -1898,10 +1926,64 @@ + let cases = + List.map2 + (fun (pat, ext_env) (spat, sexp) -> +- let exp = type_expect ?in_function ext_env sexp ty_res in +- (pat, exp)) +- pat_env_list caselist +- in ++ let add_variant_case lab row ty_res ty_res' = ++ let fi = List.assoc lab (row_repr row).row_fields in ++ begin match row_field_repr fi with ++ Reither (c, _, m, _, e) -> ++ let row' = ++ { row_fields = ++ [lab, Reither(c,[],false,[ty_res,ty_res'], ref None)]; ++ row_more = newvar (); row_bound = [ty_res; ty_res']; ++ row_closed = false; row_fixed = false; row_name = None } ++ in ++ unify_pat ext_env {pat with pat_type= newty (Tvariant row)} ++ (newty (Tvariant row')) ++ | _ -> ++ unify_exp ext_env ++ { exp_desc = Texp_tuple []; exp_type = ty_res; ++ exp_env = ext_env; exp_loc = sexp.pexp_loc } ++ ty_res' ++ end ++ in ++ pat, ++ match pat.pat_desc with ++ _ when multi && all_variants pat -> ++ let ty_res' = newvar () in ++ List.iter ++ (function {pat_desc=Tpat_variant(lab,_,row)} -> ++ add_variant_case lab row ty_res ty_res' ++ | _ -> assert false) ++ (flatten_or_pat pat); ++ type_expect ?in_function ext_env sexp ty_res' ++ | Tpat_alias (p, id) when multi && all_variants p -> ++ let vd = Env.find_value (Path.Pident id) ext_env in ++ let row' = ++ match repr vd.val_type with ++ {desc=Tvariant row'} -> row' ++ | _ -> assert false ++ in ++ begin_def (); ++ let tv = newvar () in ++ let env = Env.add_value id {vd with val_type=tv} ext_env in ++ let exp = type_exp env sexp in ++ end_def (); ++ generalize exp.exp_type; ++ generalize tv; ++ List.iter ++ (function {pat_desc=Tpat_variant(lab,_,row)}, [tv'; ty'] -> ++ let fi' = List.assoc lab (row_repr row').row_fields in ++ let row' = ++ {row' with row_fields=[lab,fi']; row_more=newvar()} in ++ unify_pat ext_env {pat with pat_type=tv'} ++ (newty (Tvariant row')); ++ add_variant_case lab row ty_res ty' ++ | _ -> assert false) ++ (List.map (fun p -> p, instance_list [tv; exp.exp_type]) ++ (flatten_or_pat p)); ++ {exp with exp_type = instance exp.exp_type} ++ | _ -> ++ type_expect ?in_function ext_env sexp ty_res) ++ pat_env_list caselist in + let partial = + match partial_loc with None -> Partial + | Some loc -> Parmatch.check_partial loc cases +Index: typing/typedecl.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typedecl.ml,v +retrieving revision 1.75 +diff -u -r1.75 typedecl.ml +--- typing/typedecl.ml 16 Aug 2005 00:48:56 -0000 1.75 ++++ typing/typedecl.ml 2 Feb 2006 06:28:33 -0000 +@@ -432,8 +432,10 @@ + match Btype.row_field_repr f with + Rpresent (Some ty) -> + compute_same ty +- | Reither (_, tyl, _, _) -> +- List.iter compute_same tyl ++ | Reither (_, tyl, _, tpl, _) -> ++ List.iter compute_same tyl; ++ List.iter (compute_variance_rec true true true) ++ (List.map fst tpl @ List.map snd tpl) + | _ -> ()) + row.row_fields; + compute_same row.row_more +@@ -856,8 +858,8 @@ + explain row.row_fields + (fun (l,f) -> match Btype.row_field_repr f with + Rpresent (Some t) -> t +- | Reither (_,[t],_,_) -> t +- | Reither (_,tl,_,_) -> Btype.newgenty (Ttuple tl) ++ | Reither (_,[t],_,_,_) -> t ++ | Reither (_,tl,_,_,_) -> Btype.newgenty (Ttuple tl) + | _ -> Btype.newgenty (Ttuple[])) + "case" (fun (lab,_) -> "`" ^ lab ^ " of ") + | _ -> trivial ty' +Index: typing/types.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/types.ml,v +retrieving revision 1.25 +diff -u -r1.25 types.ml +--- typing/types.ml 9 Dec 2004 12:40:53 -0000 1.25 ++++ typing/types.ml 2 Feb 2006 06:28:33 -0000 +@@ -48,7 +48,9 @@ + + and row_field = + Rpresent of type_expr option +- | Reither of bool * type_expr list * bool * row_field option ref ++ | Reither of ++ bool * type_expr list * bool * ++ (type_expr * type_expr) list * row_field option ref + | Rabsent + + and abbrev_memo = +Index: typing/types.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/types.mli,v +retrieving revision 1.25 +diff -u -r1.25 types.mli +--- typing/types.mli 9 Dec 2004 12:40:53 -0000 1.25 ++++ typing/types.mli 2 Feb 2006 06:28:33 -0000 +@@ -47,7 +47,9 @@ + + and row_field = + Rpresent of type_expr option +- | Reither of bool * type_expr list * bool * row_field option ref ++ | Reither of ++ bool * type_expr list * bool * ++ (type_expr * type_expr) list * row_field option ref + (* 1st true denotes a constant constructor *) + (* 2nd true denotes a tag in a pattern matching, and + is erased later *) +Index: typing/typetexp.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typetexp.ml,v +retrieving revision 1.54 +diff -u -r1.54 typetexp.ml +--- typing/typetexp.ml 22 Jul 2005 06:42:36 -0000 1.54 ++++ typing/typetexp.ml 2 Feb 2006 06:28:33 -0000 +@@ -207,9 +207,9 @@ + match Btype.row_field_repr f with + | Rpresent (Some ty) -> + bound := ty :: !bound; +- Reither(false, [ty], false, ref None) ++ Reither(false, [ty], false, [], ref None) + | Rpresent None -> +- Reither (true, [], false, ref None) ++ Reither (true, [], false, [], ref None) + | _ -> f) + row.row_fields + in +@@ -273,13 +273,16 @@ + (l, f) :: fields + in + let rec add_field fields = function +- Rtag (l, c, stl) -> ++ Rtag (l, c, stl, stpl) -> + name := None; + let f = match present with + Some present when not (List.mem l present) -> +- let tl = List.map (transl_type env policy) stl in +- bound := tl @ !bound; +- Reither(c, tl, false, ref None) ++ let transl_list = List.map (transl_type env policy) in ++ let tl = transl_list stl in ++ let stpl1, stpl2 = List.split stpl in ++ let tpl1 = transl_list stpl1 and tpl2 = transl_list stpl2 in ++ bound := tl @ tpl1 @ tpl2 @ !bound; ++ Reither(c, tl, false, List.combine tpl1 tpl2, ref None) + | _ -> + if List.length stl > 1 || c && stl <> [] then + raise(Error(styp.ptyp_loc, Present_has_conjunction l)); +@@ -311,9 +314,9 @@ + begin match f with + Rpresent(Some ty) -> + bound := ty :: !bound; +- Reither(false, [ty], false, ref None) ++ Reither(false, [ty], false, [], ref None) + | Rpresent None -> +- Reither(true, [], false, ref None) ++ Reither(true, [], false, [], ref None) + | _ -> + assert false + end +@@ -406,7 +409,8 @@ + {row with row_fixed=true; + row_fields = List.map + (fun (s,f as p) -> match Btype.row_field_repr f with +- Reither (c, tl, m, r) -> s, Reither (c, tl, true, r) ++ Reither (c, tl, m, tpl, r) -> ++ s, Reither (c, tl, true, tpl, r) + | _ -> p) + row.row_fields}; + Btype.iter_row make_fixed_univars row +Index: typing/unused_var.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/unused_var.ml,v +retrieving revision 1.5 +diff -u -r1.5 unused_var.ml +--- typing/unused_var.ml 4 Jan 2006 16:55:50 -0000 1.5 ++++ typing/unused_var.ml 2 Feb 2006 06:28:33 -0000 +@@ -122,9 +122,11 @@ + | Pexp_apply (e, lel) -> + expression ppf tbl e; + List.iter (fun (_, e) -> expression ppf tbl e) lel; +- | Pexp_match (e, pel) -> ++ | Pexp_match (e, pel, _) -> + expression ppf tbl e; + match_pel ppf tbl pel; ++ | Pexp_multifun pel -> ++ match_pel ppf tbl pel; + | Pexp_try (e, pel) -> + expression ppf tbl e; + match_pel ppf tbl pel; +Index: bytecomp/matching.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/matching.ml,v +retrieving revision 1.67 +diff -u -r1.67 matching.ml +--- bytecomp/matching.ml 7 Sep 2005 16:07:48 -0000 1.67 ++++ bytecomp/matching.ml 2 Feb 2006 06:28:33 -0000 +@@ -1991,7 +1991,7 @@ + List.iter + (fun (_, f) -> + match Btype.row_field_repr f with +- Rabsent | Reither(true, _::_, _, _) -> () ++ Rabsent | Reither(true, _::_, _, _, _) -> () + | _ -> incr num_constr) + row.row_fields + else +Index: toplevel/genprintval.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/toplevel/genprintval.ml,v +retrieving revision 1.38 +diff -u -r1.38 genprintval.ml +--- toplevel/genprintval.ml 13 Jun 2005 04:55:53 -0000 1.38 ++++ toplevel/genprintval.ml 2 Feb 2006 06:28:33 -0000 +@@ -293,7 +293,7 @@ + | (l, f) :: fields -> + if Btype.hash_variant l = tag then + match Btype.row_field_repr f with +- | Rpresent(Some ty) | Reither(_,[ty],_,_) -> ++ | Rpresent(Some ty) | Reither(_,[ty],_,_,_) -> + let args = + tree_of_val (depth - 1) (O.field obj 1) ty in + Oval_variant (l, Some args) diff --git a/testlabl/multimatch.ml b/testlabl/multimatch.ml new file mode 100644 index 00000000..7c9aa73f --- /dev/null +++ b/testlabl/multimatch.ml @@ -0,0 +1,158 @@ +(* Simple example *) +let f x = + (multimatch x with `A -> 1 | `B -> true), + (multimatch x with `A -> 1. | `B -> "1");; + +(* OK *) +module M : sig + val f : + [< `A & 'a = int & 'b = float | `B & 'b =string & 'a = bool] -> 'a * 'b +end = struct let f = f end;; + +(* Bad *) +module M : sig + val f : + [< `A & 'a = int & 'b = float | `B & 'b =string & 'a = int] -> 'a * 'b +end = struct let f = f end;; + +(* Should be good! *) +module M : sig + val f : + [< `A & 'a = int * float | `B & 'a = bool * string] -> 'a +end = struct let f = f end;; + +let f = multifun `A|`B as x -> f x;; + +(* Two-level example *) +let f = multifun + `A -> (multifun `C -> 1 | `D -> 1.) + | `B -> (multifun `C -> true | `D -> "1");; + +(* OK *) +module M : sig + val f : + [< `A & 'b = [< `C & 'a = int | `D & 'a = float & 'c = bool] -> 'a + | `B & 'b = [< `C & 'c = bool | `D & 'c = string] -> 'c] -> 'b +end = struct let f = f end;; + +(* Bad *) +module M : sig + val f : + [< `A & 'b = [< `C & 'a = int | `D & 'a = bool] -> 'a + | `B & 'b = [< `C & 'c = bool | `D & 'c = string] -> 'c] -> 'b +end = struct let f = f end;; + +module M : sig + val f : + [< `A & 'b = [< `C & 'a = int | `D] -> 'a + | `B & 'b = [< `C & 'c = bool | `D & 'c = string] -> 'c] -> 'b +end = struct let f = f end;; + + +(* Examples with hidden sharing *) +let r = ref [] +let f = multifun `A -> 1 | `B -> true +let g x = r := [f x];; + +(* Bad! *) +module M : sig + val g : [< `A & 'a = int | `B & 'a = bool] -> unit +end = struct let g = g end;; + +let r = ref [] +let f = multifun `A -> r | `B -> ref [];; +(* Now OK *) +module M : sig + val f : [< `A & 'b = int list ref | `B & 'b = 'c list ref] -> 'b +end = struct let f = f end;; +(* Still OK *) +let l : int list ref = r;; +module M : sig + val f : [< `A & 'b = int list ref | `B & 'b = 'c list ref] -> 'b +end = struct let f = f end;; + + +(* Examples that would need unification *) +let f = multifun `A -> (1, []) | `B -> (true, []) +let g x = fst (f x);; +(* Didn't work, now Ok *) +module M : sig + val g : [< `A & 'a * 'b = int * bool | `B & 'a * 'b = bool * int] -> 'a +end = struct let g = g end;; +let g = multifun (`A|`B) as x -> g x;; + +(* Other examples *) + +let f x = + let a = multimatch x with `A -> 1 | `B -> "1" in + (multifun `A -> print_int | `B -> print_string) x a +;; + +let f = multifun (`A|`B) as x -> f x;; + +type unit_op = [`Set of int | `Move of int] +type int_op = [`Get] + +let op r = + multifun + `Get -> !r + | `Set x -> r := x + | `Move dx -> r := !r + dx +;; + +let rec trace r = function + [] -> [] + | op1 :: ops -> + multimatch op1 with + #int_op as op1 -> + let x = op r op1 in + x :: trace r ops + | #unit_op as op1 -> + op r op1; + trace r ops +;; + +class point x = object + val mutable x : int = x + method get = x + method set y = x <- y + method move dx = x <- x + dx +end;; + +let poly sort coeffs x = + let add, mul, zero = + multimatch sort with + `Int -> (+), ( * ), 0 + | `Float -> (+.), ( *. ), 0. + in + let rec compute = function + [] -> zero + | c :: cs -> add c (mul x (compute cs)) + in + compute coeffs +;; + +module M : sig + val poly : [< `Int & 'a = int | `Float & 'a = float] -> 'a list -> 'a -> 'a +end = struct let poly = poly end;; + +type ('a,'b) num_sort = + 'b constraint 'b = [< `Int & 'a = int | `Float & 'a = float] +module M : sig + val poly : ('a,_) num_sort -> 'a list -> 'a -> 'a +end = struct let poly = poly end;; + + +(* type dispatch *) + +type num = [ `Int | `Float ] +let print0 = multifun + `Int -> print_int + | `Float -> print_float +;; +let print1 = multifun + #num as x -> print0 x + | `List t -> List.iter (print0 t) + | `Pair(t1,t2) -> (fun (x,y) -> print0 t1 x; print0 t2 y) +;; +print1 (`Pair(`Int,`Float)) (1,1.0);; diff --git a/testlabl/newlabels.ps b/testlabl/newlabels.ps new file mode 100644 index 00000000..01eac194 --- /dev/null +++ b/testlabl/newlabels.ps @@ -0,0 +1,1458 @@ +%!PS-Adobe-2.0 +%%Creator: dvipsk 5.78 p1.4 Copyright 1996-98 ASCII Corp.(www-ptex@ascii.co.jp) +%%dvipsk 5.78 Copyright 1998 Radical Eye Software (www.radicaleye.com) +%%Title: newlabels.dvi +%%Pages: 2 0 +%%PageOrder: Ascend +%%BoundingBox: 0 0 596 842 +%%EndComments +%%BeginProcSet: PStoPS 1 15 +userdict begin +[/showpage/erasepage/copypage]{dup where{pop dup load + type/operatortype eq{1 array cvx dup 0 3 index cvx put + bind def}{pop}ifelse}{pop}ifelse}forall +[/letter/legal/executivepage/a4/a4small/b5/com10envelope + /monarchenvelope/c5envelope/dlenvelope/lettersmall/note + /folio/quarto/a5]{dup where{dup wcheck{exch{}put} + {pop{}def}ifelse}{pop}ifelse}forall +/setpagedevice {pop}bind 1 index where{dup wcheck{3 1 roll put} + {pop def}ifelse}{def}ifelse +/PStoPSmatrix matrix currentmatrix def +/PStoPSxform matrix def/PStoPSclip{clippath}def +/defaultmatrix{PStoPSmatrix exch PStoPSxform exch concatmatrix}bind def +/initmatrix{matrix defaultmatrix setmatrix}bind def +/initclip[{matrix currentmatrix PStoPSmatrix setmatrix + [{currentpoint}stopped{$error/newerror false put{newpath}} + {/newpath cvx 3 1 roll/moveto cvx 4 array astore cvx}ifelse] + {[/newpath cvx{/moveto cvx}{/lineto cvx} + {/curveto cvx}{/closepath cvx}pathforall]cvx exch pop} + stopped{$error/errorname get/invalidaccess eq{cleartomark + $error/newerror false put cvx exec}{stop}ifelse}if}bind aload pop + /initclip dup load dup type dup/operatortype eq{pop exch pop} + {dup/arraytype eq exch/packedarraytype eq or + {dup xcheck{exch pop aload pop}{pop cvx}ifelse} + {pop cvx}ifelse}ifelse + {newpath PStoPSclip clip newpath exec setmatrix} bind aload pop]cvx def +/initgraphics{initmatrix newpath initclip 1 setlinewidth + 0 setlinecap 0 setlinejoin []0 setdash 0 setgray + 10 setmiterlimit}bind def +end +%%EndProcSet +%DVIPSCommandLine: dvips -f newlabels +%DVIPSParameters: dpi=300 +%DVIPSSource: TeX output 1999.10.26:1616 +%%BeginProcSet: tex.pro +%! +/TeXDict 300 dict def TeXDict begin /N{def}def /B{bind def}N /S{exch}N +/X{S N}B /TR{translate}N /isls false N /vsize 11 72 mul N /hsize 8.5 72 +mul N /landplus90{false}def /@rigin{isls{[0 landplus90{1 -1}{-1 1} +ifelse 0 0 0]concat}if 72 Resolution div 72 VResolution div neg scale +isls{landplus90{VResolution 72 div vsize mul 0 exch}{Resolution -72 div +hsize mul 0}ifelse TR}if Resolution VResolution vsize -72 div 1 add mul +TR[matrix currentmatrix{dup dup round sub abs 0.00001 lt{round}if} +forall round exch round exch]setmatrix}N /@landscape{/isls true N}B +/@manualfeed{statusdict /manualfeed true put}B /@copies{/#copies X}B +/FMat[1 0 0 -1 0 0]N /FBB[0 0 0 0]N /nn 0 N /IE 0 N /ctr 0 N /df-tail{ +/nn 8 dict N nn begin /FontType 3 N /FontMatrix fntrx N /FontBBox FBB N +string /base X array /BitMaps X /BuildChar{CharBuilder}N /Encoding IE N +end dup{/foo setfont}2 array copy cvx N load 0 nn put /ctr 0 N[}B /df{ +/sf 1 N /fntrx FMat N df-tail}B /dfs{div /sf X /fntrx[sf 0 0 sf neg 0 0] +N df-tail}B /E{pop nn dup definefont setfont}B /ch-width{ch-data dup +length 5 sub get}B /ch-height{ch-data dup length 4 sub get}B /ch-xoff{ +128 ch-data dup length 3 sub get sub}B /ch-yoff{ch-data dup length 2 sub +get 127 sub}B /ch-dx{ch-data dup length 1 sub get}B /ch-image{ch-data +dup type /stringtype ne{ctr get /ctr ctr 1 add N}if}B /id 0 N /rw 0 N +/rc 0 N /gp 0 N /cp 0 N /G 0 N /sf 0 N /CharBuilder{save 3 1 roll S dup +/base get 2 index get S /BitMaps get S get /ch-data X pop /ctr 0 N ch-dx +0 ch-xoff ch-yoff ch-height sub ch-xoff ch-width add ch-yoff +setcachedevice ch-width ch-height true[1 0 0 -1 -.1 ch-xoff sub ch-yoff +.1 sub]{ch-image}imagemask restore}B /D{/cc X dup type /stringtype ne{]} +if nn /base get cc ctr put nn /BitMaps get S ctr S sf 1 ne{dup dup +length 1 sub dup 2 index S get sf div put}if put /ctr ctr 1 add N}B /I{ +cc 1 add D}B /bop{userdict /bop-hook known{bop-hook}if /SI save N @rigin +0 0 moveto /V matrix currentmatrix dup 1 get dup mul exch 0 get dup mul +add .99 lt{/QV}{/RV}ifelse load def pop pop}N /eop{SI restore userdict +/eop-hook known{eop-hook}if showpage}N /@start{userdict /start-hook +known{start-hook}if pop /VResolution X /Resolution X 1000 div /DVImag X +/IE 256 array N 2 string 0 1 255{IE S dup 360 add 36 4 index cvrs cvn +put}for pop 65781.76 div /vsize X 65781.76 div /hsize X}N /p{show}N +/RMat[1 0 0 -1 0 0]N /BDot 260 string N /rulex 0 N /ruley 0 N /v{/ruley +X /rulex X V}B /V{}B /RV statusdict begin /product where{pop false[ +(Display)(NeXT)(LaserWriter 16/600)]{dup length product length le{dup +length product exch 0 exch getinterval eq{pop true exit}if}{pop}ifelse} +forall}{false}ifelse end{{gsave TR -.1 .1 TR 1 1 scale rulex ruley false +RMat{BDot}imagemask grestore}}{{gsave TR -.1 .1 TR rulex ruley scale 1 1 +false RMat{BDot}imagemask grestore}}ifelse B /QV{gsave newpath transform +round exch round exch itransform moveto rulex 0 rlineto 0 ruley neg +rlineto rulex neg 0 rlineto fill grestore}B /a{moveto}B /delta 0 N /tail +{dup /delta X 0 rmoveto}B /M{S p delta add tail}B /b{S p tail}B /c{-4 M} +B /d{-3 M}B /e{-2 M}B /f{-1 M}B /g{0 M}B /h{1 M}B /i{2 M}B /j{3 M}B /k{ +4 M}B /w{0 rmoveto}B /l{p -4 w}B /m{p -3 w}B /n{p -2 w}B /o{p -1 w}B /q{ +p 1 w}B /r{p 2 w}B /s{p 3 w}B /t{p 4 w}B /x{0 S rmoveto}B /y{3 2 roll p +a}B /bos{/SS save N}B /eos{SS restore}B end + +%%EndProcSet +TeXDict begin 39158280 55380996 1000 300 300 (newlabels.dvi) +@start +%DVIPSBitmapFont: Fa cmr6 6 2 +/Fa 2 51 df<187898181818181818181818181818FF08107D8F0F> 49 +D<1F00618040C08060C0600060006000C00180030006000C00102020207FC0FFC00B107F +8F0F> I E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fb cmmi8 8 4 +/Fb 4 111 df 85 D<0300038003000000000000000000000000001C00240046 +0046008C000C0018001800180031003100320032001C0009177F960C> 105 +D<383C1E0044C6630047028100460301008E0703000C0603000C0603000C060300180C06 +00180C0620180C0C20180C0C40301804C0301807001B0E7F8D1F> 109 +D<383C0044C6004702004602008E06000C06000C06000C0600180C00180C401818401818 +80300980300E00120E7F8D15> I E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fc cmbx8 8 4 +/Fc 4 111 df<01800780FF80FF80078007800780078007800780078007800780078007 +800780078007800780FFF8FFF80D157D9414> 49 D<387C7C7C3800000000FCFC3C3C3C +3C3C3C3C3C3C3C3CFFFF08187F970B> 105 D 109 D I +E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fd cmsy8 8 3 +/Fd 3 93 df 0 D<020002000200C218F2783AE00F800F80 +3AE0F278C2180200020002000D0E7E8E12> 3 D<03F8001FFF003C07806000C0C00060C0 +0060C00060C00060C00060C00060C00060C00060C00060C00060C00060C00060C00060C0 +006040002013137E9218> 92 D E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fe cmtt12 12 43 +/Fe 43 125 df<01818003C3C003C3C003C3C003C3C003C3C003C3C07FFFF0FFFFF8FFFF +F87FFFF00787800787800787800F8F800F0F000F0F000F0F000F0F007FFFF0FFFFF8FFFF +F87FFFF01E1E001E1E001E1E001E1E001E1E001E1E000C0C00151E7E9D1A> 35 +D<00E00003F00007F8000738000E1C000E1C000E1C000E1C000E38000E39FC0E71FC07F1 +FC07E1C007C1C00781C00783800F83801FC3803DC70078E70070EE00E07E00E07E00E03C +08E03C1CE07E1C70FF1C7FE7F83FC3F80F00E0161E7F9D1A> 38 +D<0038007800F001E003C007800F000E001C001C0038003800700070007000E000E000E0 +00E000E000E000E000E000E000E000700070007000380038001C001C000E000F00078003 +C001E000F8007800380D2878A21A> 40 D<6000F00078003C001E000F000780038001C0 +01C000E000E0007000700070003800380038003800380038003800380038003800700070 +007000E000E001C001C0038007800F001E003C007800F00060000D287CA21A> I<7FFFC0 +FFFFE0FFFFE07FFFC013047D901A> 45 D<00C001C001C003C007C00FC07FC0FDC071C0 +01C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C0 +7FFF7FFF7FFF101E7B9D1A> 49 D<03F8000FFE001FFF803C07C07801E07000E0E00070 +F00070F000706000700000700000700000E00000E00001C00003C0000780000F00001E00 +003C0000780000F00003E00007C0000F00001E00703C00707FFFF0FFFFF07FFFF0141E7D +9D1A> I<03FC000FFF003FFFC03C03E07800E07800707800700000700000700000E00001 +E00007C003FF8003FF0003FFC00003E00000E0000070000078000038000038600038F000 +38F00078E000707000E07E03E03FFFC00FFF0001FC00151E7E9D1A> I<01FC0007FF001F +FFC01F07C03C01E07800F07000707000707000707800F03800E01E03C00FFF8003FE0007 +FF001F8FC03C01E07800F0700070E00038E00038E00038E00038F000787000707800F03E +03E01FFFC007FF0001FC00151E7E9D1A> 56 D<01F00007FC001FFE003E0F0038078070 +03807001C0E001C0E001C0E001E0E000E0E000E0E001E07001E07803E03C0FE01FFFE00F +FCE003F0E00001C00001C00001C0000380600380F00700F00F00F03E007FFC003FF0000F +C000131E7D9D1A> I<3078FCFC78300000000000000000003078FCFC7830061576941A> +I<183C7E7E3C18000000000000000000183C7E7E3E1E0E0E1C3CF8F060071C77941A> I< +0000C00003E00007E0000FC0003F80007E0000FC0003F80007E0000FC0003F80007E0000 +FC0000FC00007E00003F80000FC00007E00003F80000FC00007E00003F80000FC00007E0 +0003E00000C0131A7D9B1A> I<7FFFF0FFFFF8FFFFF87FFFF00000000000000000000000 +007FFFF0FFFFF8FFFFF87FFFF0150C7E941A> I<600000F80000FC00007E00003F80000F +C00007E00003F80000FC00007E00003F80000FC00007E00007E0000FC0003F80007E0000 +FC0003F80007E0000FC0003F80007E0000FC0000F80000600000131A7D9B1A> I<007C38 +01FF3807FFF80F83F81E00F81C0078380078380038700038700038700000E00000E00000 +E00000E00000E00000E00000E00000E000007000007000387000383800383800381C0070 +1E00F00F83E007FFC001FF80007C00151E7E9D1A> 67 D 78 D<03F8E00FFEE01FFFE03C07E07801E0F001E0E000E0 +E000E0E000E0E000007000007800003F80001FF80007FF00007FC00007E00000F0000070 +000038000038600038E00038E00038E00070F000F0FE01E0FFFFC0EFFF80E1FE00151E7E +9D1A> 83 D<7FFFFEFFFFFEFFFFFEE0380EE0380EE0380EE0380E003800003800003800 +003800003800003800003800003800003800003800003800003800003800003800003800 +00380000380000380000380000380003FF8003FF8003FF80171E7F9D1A> I 91 D 93 D<1FF0003FFC007FFE00780F +00300700000380000380007F8007FF801FFF803F8380780380700380E00380E00380E003 +80700780780F803FFFFC1FFDFC07F0FC16157D941A> 97 D<7E0000FE00007E00000E00 +000E00000E00000E00000E00000E00000E3E000EFF800FFFE00FC1F00F80700F00380E00 +380E001C0E001C0E001C0E001C0E001C0E001C0E001C0F00380F00780F80F00FC1E00FFF +C00EFF80063E00161E7F9D1A> I<00FF8003FFC00FFFE01F01E03C00C078000070000070 +0000E00000E00000E00000E00000E000007000007000007800703C00701F01F00FFFE003 +FFC000FE0014157D941A> I<000FC0001FC0000FC00001C00001C00001C00001C00001C0 +0001C001F1C007FDC00FFFC01E0FC03C07C07803C07001C0E001C0E001C0E001C0E001C0 +E001C0E001C0E001C07003C07003C03807C03E0FC01FFFF807FDFC01F1F8161E7E9D1A> +I<01F80007FF000FFF801E07C03C01C07800E07000E0E00070E00070FFFFF0FFFFF0FFFF +F0E000007000007000007800703C00701F01F00FFFE003FF8000FE0014157D941A> I<00 +07E0001FF0003FF800787800F03000E00000E00000E00000E0007FFFF0FFFFF0FFFFF000 +E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000 +E00000E00000E0003FFF807FFFC03FFF80151E7F9D1A> I<7E0000FE00007E00000E0000 +0E00000E00000E00000E00000E00000E3E000EFF800FFFC00FC1C00F80E00F00E00E00E0 +0E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E07FC3FC +FFE7FE7FC3FC171E7F9D1A> 104 D<00C00001E00001E00000C000000000000000000000 +0000000000000000007FE0007FE0007FE00000E00000E00000E00000E00000E00000E000 +00E00000E00000E00000E00000E00000E00000E00000E00000E0007FFF80FFFFC07FFF80 +121F7C9E1A> I<7FE000FFE0007FE00000E00000E00000E00000E00000E00000E00000E0 +0000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E0 +0000E00000E00000E00000E00000E0007FFFC0FFFFE07FFFC0131E7D9D1A> 108 +D<7CE0E000FFFBF8007FFFF8001F1F1C001E1E1C001E1E1C001C1C1C001C1C1C001C1C1C +001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C +007F1F1F00FFBFBF807F1F1F00191580941A> I<7E3E00FEFF807FFFC00FC1C00F80E00F +00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E +00E07FC3FCFFE7FE7FC3FC17157F941A> I<01F00007FC001FFF003E0F803C07807803C0 +7001C0E000E0E000E0E000E0E000E0E000E0E000E0F001E07001C07803C03C07803E0F80 +1FFF0007FC0001F00013157D941A> I<7E3E00FEFF807FFFE00FC1F00F80700F00380E00 +380E001C0E001C0E001C0E001C0E001C0E001C0E001C0F00380F00780F80F00FC1E00FFF +C00EFF800E3E000E00000E00000E00000E00000E00000E00000E00000E00007FC000FFE0 +007FC00016207F941A> I<7F81F8FF8FFC7F9FFE03FE1E03F80C03E00003E00003C00003 +80000380000380000380000380000380000380000380000380000380007FFF00FFFF007F +FF0017157F941A> 114 D<07FB801FFF807FFF80780780E00380E00380E003807800007F +C0001FFC0007FE00003F800007806001C0E001C0E001C0F003C0FC0780FFFF00EFFE00E3 +F80012157C941A> I<0180000380000380000380000380000380000380007FFFE0FFFFE0 +FFFFE0038000038000038000038000038000038000038000038000038000038000038070 +03807003807003807001C1E001FFE000FF80003F00141C7F9B1A> I<7E07E0FE0FE07E07 +E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00 +E00E00E00E01E00F03E007FFFC03FFFE00FCFC17157F941A> I<7F83FCFFC7FE7F83FC0E +00E00E00E00E00E00701C00701C00701C003838003838003838001C70001C70001C70000 +EE0000EE0000EE00007C00007C0000380017157F941A> I I<7FC7F87FCFFC7FC7F80703C00383 +8003C70001EF0000FE00007C00007800003800007C0000EE0001EE0001C7000383800783 +C00F01C07FC7FCFFC7FE7FC7FC17157F941A> I<7F83FCFFC7FE7F83FC0E00E00E00E007 +00E00701C00701C00381C003838003C38001C38001C70000E70000E70000E60000660000 +6E00003C00003C00003C0000380000380000380000700000700030F00078E00071E0007F +C0003F80001E000017207F941A> I<60F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 +F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F060042775A21A> 124 D +E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Ff cmr8 8 3 +/Ff 3 51 df<003000003000003000003000003000003000003000003000003000003000 +003000FFFFFCFFFFFC003000003000003000003000003000003000003000003000003000 +00300000300016187E931B> 43 D<06000E00FE000E000E000E000E000E000E000E000E +000E000E000E000E000E000E000E000E000E00FFE00B157D9412> 49 +D<0F8030E040708030C038E0384038003800700070006000C00180030006000C08080810 +183FF07FF0FFF00D157E9412> I E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fg cmmi12 12 13 +/Fg 13 121 df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ndDVIPSBitmapFont +%DVIPSBitmapFont: Fh cmti12 12 22 +/Fh 22 122 df 45 D<70F8F8F0E005057A840F> I<00F8 +C00185C00705C00E03800E03801C03803C0380380700780700780700780700F00E00F00E +00F00E00F00E10F01C20701C20703C20305C40308C400F078014157B9419> 97 +D<03C01F8003800380038007000700070007000E000E000E000E001C001CF81D0C1E0E3C +0638073807380F700F700F700F700FE01EE01EE01EE03CE038E038607060E031C01F0010 +237BA216> I<007E0001C1000301800703800E07801C07803C0000380000780000780000 +780000F00000F00000F00000F00000F00100700100700200300C001830000FC00011157B +9416> I<00003C0003F80000380000380000380000700000700000700000700000E00000 +E00000E00000E00001C000F9C00185C00705C00E03800E03801C03803C03803807007807 +00780700780700F00E00F00E00F00E00F00E10F01C20701C20703C20305C40308C400F07 +8016237BA219> I<00F803840E021C023C0238027804F018FFE0F000F000E000E000E000 +E000E002E0026004701830600F800F157A9416> I<00003E0000470000CF00018F000186 +000380000380000380000700000700000700000700000700000E0000FFF0000E00000E00 +000E00001C00001C00001C00001C00001C00003800003800003800003800003800007000 +00700000700000700000700000E00000E00000E00000E00000C00001C00001C000718000 +F18000F300006200003C0000182D82A20F> I<001F180030B800E0B801C07001C0700380 +700780700700E00F00E00F00E00F00E01E01C01E01C01E01C01E01C01E03800E03800E07 +80060B8006170001E700000700000700000E00000E00000E00701C00F01800F0300060E0 +003F8000151F7E9416> I<00C001E001C001C0000000000000000000000000000000001E +002300430043008700870087000E000E001C001C001C0038003800384070807080708071 +0032001C000B217BA00F> 105 D<00F00007E00000E00000E00000E00001C00001C00001 +C00001C0000380000380000380000380000700000701E00702100704700E08F00E10F00E +20600E40001D80001E00001FC0001C7000383800383800381C00381C2070384070384070 +3840701880E01880600F0014237DA216> 107 D<01E00FC001C001C001C0038003800380 +038007000700070007000E000E000E000E001C001C001C001C0038003800380038007000 +700070007100E200E200E200E200640038000B237CA20C> I<1C0F80F8002610C10C0047 +6066060087807807008780780700870070070087007007000E00E00E000E00E00E000E00 +E00E000E00E00E001C01C01C001C01C01C001C01C01C001C01C038203803803840380380 +70403803807080380380308070070031003003001E0023157B9428> I<380F804C30C04E +40608E80708F00708E00708E00701C00E01C00E01C00E01C00E03801C03801C03801C038 +0384700388700308700708700310E003106001E016157B941B> I<007E0001C300038180 +0701C00E01C01C01E03C01E03801E07801E07801E07801E0F003C0F003C0F00380F00780 +700700700E00700C0030180018700007C00013157B9419> I<01C1F002621804741C0878 +0C08700E08700E08701E00E01E00E01E00E01E00E01E01C03C01C03C01C03C01C0780380 +7003807003C0E003C1C0072380071E000700000700000E00000E00000E00000E00001C00 +001C00001C0000FFC000171F7F9419> I<1C1F002620804741C08783C08703C087018087 +00000E00000E00000E00000E00001C00001C00001C00001C000038000038000038000038 +000070000030000012157B9415> 114 D<00FC000183000200800401800C03800C03000C +00000F00000FF00007FC0003FE00003E00000F00000700700700F00600F00600E0040040 +08002030001FC00011157D9414> I<00C001C001C001C001C003800380038003800700FF +F8070007000E000E000E000E001C001C001C001C00380038003800381070207020704070 +8031001E000D1F7C9E10> I<1E0060E02300E0F04380E1F04381C0F08381C0708701C030 +8701C030070380200E0380200E0380200E0380201C0700401C0700401C0700401C070080 +1C0700801C0701001C0F01000C0B02000613840003E0F8001C157B9420> 119 +D<03C1E0046210083470103CF02038F020386020380000700000700000700000700000E0 +0000E00000E00000E02061C040F1C040F1C080E2C100446200383C0014157D9416> I<1E +00302300704380704380E08380E08700E08700E00701C00E01C00E01C00E01C01C03801C +03801C03801C03801C07001C07001C07001C0F000C3E0003CE00000E00000E00001C0060 +1C00F03800F03000E0600080C0004380003E0000141F7B9418> I +E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fi cmbx12 12 20 +/Fi 20 122 df 68 D<01FE0207FF861F01FE3C007E7C001E78000E78000EF80006F80006FC0006 +FC0000FF0000FFE0007FFF007FFFC03FFFF01FFFF80FFFFC03FFFE003FFE0003FE00007F +00003F00003FC0001FC0001FC0001FE0001EE0001EF0003CFC003CFF00F8C7FFE080FF80 +18227DA11F> 83 D<7FFFFFFF807FFFFFFF807E03F80F807803F807807003F803806003 +F80180E003F801C0E003F801C0C003F800C0C003F800C0C003F800C0C003F800C00003F8 +00000003F800000003F800000003F800000003F800000003F800000003F800000003F800 +000003F800000003F800000003F800000003F800000003F800000003F800000003F80000 +0003F800000003F800000003F800000003F800000003F8000001FFFFF00001FFFFF00022 +227EA127> I<0FFC003FFF807E07C07E03E07E01E07E01F03C01F00001F00001F0003FF0 +03FDF01FC1F03F01F07E01F0FC01F0FC01F0FC01F0FC01F07E02F07E0CF81FF87F07E03F +18167E951B> 97 D I<00FF8007FFE00F83F01F03F03E03F07E03F07C01E07C0000 +FC0000FC0000FC0000FC0000FC0000FC00007C00007E00007E00003E00181F00300FC060 +07FFC000FF0015167E9519> I<00FE0007FF800F87C01E01E03E01F07C00F07C00F8FC00 +F8FC00F8FFFFF8FFFFF8FC0000FC0000FC00007C00007C00007E00003E00181F00300FC0 +7003FFC000FF0015167E951A> 101 D<001FC0007FE000F1F001E3F003E3F007C3F007C1 +E007C00007C00007C00007C00007C00007C000FFFE00FFFE0007C00007C00007C00007C0 +0007C00007C00007C00007C00007C00007C00007C00007C00007C00007C00007C00007C0 +0007C00007C0003FFC003FFC00142380A211> I<01FE0F0007FFBF800F87C7801F03E780 +1E01E0003E01F0003E01F0003E01F0003E01F0003E01F0001E01E0001F03E0000F87C000 +0FFF800009FE000018000000180000001C0000001FFFE0000FFFF80007FFFE001FFFFF00 +3C003F0078000F80F0000780F0000780F0000780F000078078000F003C001E001F007C00 +0FFFF80001FFC00019217F951C> I<1C003E007F007F007F003E001C0000000000000000 +00000000000000FF00FF001F001F001F001F001F001F001F001F001F001F001F001F001F +001F001F001F001F001F00FFE0FFE00B247EA310> 105 D 108 +D I I<00FE0007FFC00F83E01E00F03E00F87C00 +7C7C007C7C007CFC007EFC007EFC007EFC007EFC007EFC007EFC007E7C007C7C007C3E00 +F81F01F00F83E007FFC000FE0017167E951C> I I<0FF3003FFF00781F00600700E00300E00300F00300FC00007F +E0007FF8003FFE000FFF0001FF00000F80C00780C00380E00380E00380F00700FC0E00EF +FC00C7F00011167E9516> 115 D<01800001800001800001800003800003800007800007 +80000F80003F8000FFFF00FFFF000F80000F80000F80000F80000F80000F80000F80000F +80000F80000F80000F80000F81800F81800F81800F81800F81800F830007C30003FE0000 +F80011207F9F16> I I 120 D I E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fj cmsy10 12 15 +/Fj 15 107 df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ndDVIPSBitmapFont +%DVIPSBitmapFont: Fk cmr12 12 65 +/Fk 65 125 df<001FC1F00070371800C03E3C01807C3C0380783C070038000700380007 +003800070038000700380007003800070038000700380007003800FFFFFFC00700380007 +003800070038000700380007003800070038000700380007003800070038000700380007 +0038000700380007003800070038000700380007003800070038000700380007003C007F +E1FFC01E2380A21C> 11 D<001FC0000070200000C01000018038000380780007007800 +0700300007000000070000000700000007000000070000000700000007000000FFFFF800 +070078000700380007003800070038000700380007003800070038000700380007003800 +070038000700380007003800070038000700380007003800070038000700380007003800 +070038007FE1FF80192380A21B> I<001FD8000070380000C07800018078000380780007 +0038000700380007003800070038000700380007003800070038000700380007003800FF +FFF800070038000700380007003800070038000700380007003800070038000700380007 +003800070038000700380007003800070038000700380007003800070038000700380007 +003800070038007FF3FF80192380A21B> I<000FC07F00007031C08000E00B004001801E +00E003803E01E007003C01E007001C00C007001C000007001C000007001C000007001C00 +0007001C000007001C000007001C0000FFFFFFFFE007001C01E007001C00E007001C00E0 +07001C00E007001C00E007001C00E007001C00E007001C00E007001C00E007001C00E007 +001C00E007001C00E007001C00E007001C00E007001C00E007001C00E007001C00E00700 +1C00E007001C00E07FF1FFCFFE272380A229> I<70F8FCFC740404040408081010204006 +0F7CA20E> 39 D<00200040008001000300060004000C000C0018001800300030003000 +7000600060006000E000E000E000E000E000E000E000E000E000E000E000E000E000E000 +6000600060007000300030003000180018000C000C000400060003000100008000400020 +0B327CA413> I<800040002000100018000C000400060006000300030001800180018001 +C000C000C000C000E000E000E000E000E000E000E000E000E000E000E000E000E000E000 +C000C000C001C0018001800180030003000600060004000C00180010002000400080000B +327DA413> I<70F8FCFC7404040404080810102040060F7C840E> 44 +D I<70F8F8F87005057C840E> I<01F000071C000C0600180300 +3803803803807001C07001C07001C07001C0F001E0F001E0F001E0F001E0F001E0F001E0 +F001E0F001E0F001E0F001E0F001E0F001E0F001E0F001E07001C07001C07001C07803C0 +3803803803801C07000C0600071C0001F00013227EA018> 48 D<008003800F80F38003 +800380038003800380038003800380038003800380038003800380038003800380038003 +800380038003800380038003800380038007C0FFFE0F217CA018> I<03F0000C1C001007 +002007804003C04003C08003E0F003E0F801E0F801E0F801E02003E00003E00003C00003 +C0000780000700000E00001C0000180000300000600000C0000180000100000200200400 +200800201800603000403FFFC07FFFC0FFFFC013217EA018> I<03F8000C1E00100F0020 +07804007C07807C07803C07807C03807C0000780000780000700000F00000C0000380003 +F000001C00000F000007800007800003C00003C00003E02003E07003E0F803E0F803E0F0 +03C04003C0400780200780100F000C1C0003F00013227EA018> I<000300000300000700 +000700000F00001700001700002700006700004700008700018700010700020700060700 +040700080700080700100700200700200700400700C00700FFFFF8000700000700000700 +000700000700000700000700000F80007FF015217FA018> I<70F8F8F870000000000000 +000000000070F8F8F87005157C940E> 58 D 61 D<07E01838201C400E800FF00FF00FF00F000F000E001C00380030006000C000C0 +00800080018001000100010001000100010000000000000000000000038007C007C007C0 +038010237DA217> 63 D<0001800000018000000180000003C0000003C0000003C00000 +05E0000005E0000009F0000008F0000008F00000107800001078000010780000203C0000 +203C0000203C0000401E0000401E0000C01F0000800F0000800F0001FFFF800100078001 +000780020003C0020003C0020003C0040001E0040001E0040001E0080000F01C0000F03E +0001F8FF800FFF20237EA225> 65 D I<0007E0100038183000E0063001C00170038000F007 +0000F00E0000701E0000701C0000303C0000303C0000307C0000107800001078000010F8 +000000F8000000F8000000F8000000F8000000F8000000F8000000F80000007800000078 +0000107C0000103C0000103C0000101C0000201E0000200E000040070000400380008001 +C0010000E0020000381C000007E0001C247DA223> I I 70 D<0007F008003C0C1800E0021801C0 +01B8038000F8070000780F0000381E0000381E0000183C0000183C0000187C0000087800 +000878000008F8000000F8000000F8000000F8000000F8000000F8000000F8000000F800 +1FFF780000F8780000787C0000783C0000783C0000781E0000781E0000780F0000780700 +0078038000B801C000B800E00318003C0C080007F00020247DA226> I I I 75 +D I +78 D<000FE00000783C0000E00E0003C00780078003C00F0001E00E0000E01E0000F03C +0000783C0000787C00007C7C00007C7800003C7800003CF800003EF800003EF800003EF8 +00003EF800003EF800003EF800003EF800003EF800003E7800003C7C00007C7C00007C3C +0000783E0000F81E0000F00F0001E00F0001E0078003C003C0078000E00E0000783C0000 +0FE0001F247DA226> I I 82 D<03F0200C0C601802603001E07000E0600060E00060E000 +60E00020E00020E00020F00000F000007800007F00003FF0001FFE000FFF0003FF80003F +C00007E00001E00000F00000F0000070800070800070800070800070C00060C00060E000 +C0F000C0C80180C6070081FC0014247DA21B> I<7FFFFFF8780780786007801840078008 +4007800840078008C007800C800780048007800480078004800780040007800000078000 +000780000007800000078000000780000007800000078000000780000007800000078000 +000780000007800000078000000780000007800000078000000780000007800000078000 +00078000000FC00001FFFE001E227EA123> I 86 D I 91 D 93 +D<1FE000303800780C00780E0030070000070000070000070000FF0007C7001E07003C07 +00780700700700F00708F00708F00708F00F087817083C23900FC1E015157E9418> 97 +D<0E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00000E00000E00 +000E00000E00000E1F000E61C00E80600F00300E00380E003C0E001C0E001E0E001E0E00 +1E0E001E0E001E0E001E0E001E0E001C0E003C0E00380F00700C80600C41C0083F001723 +7FA21B> I<01FE000703000C07801C0780380300780000700000F00000F00000F00000F0 +0000F00000F00000F000007000007800403800401C00800C010007060001F80012157E94 +16> I<0000E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00000E0 +0000E00000E00000E001F8E00704E00C02E01C01E03800E07800E07000E0F000E0F000E0 +F000E0F000E0F000E0F000E0F000E07000E07800E03800E01801E00C02E0070CF001F0FE +17237EA21B> I<01FC000707000C03801C01C03801C07801E07000E0F000E0FFFFE0F000 +00F00000F00000F00000F000007000007800203800201C00400E008007030000FC001315 +7F9416> I<003E0000E30001C78003878003078007000007000007000007000007000007 +0000070000070000070000FFF80007000007000007000007000007000007000007000007 +00000700000700000700000700000700000700000700000700000700000700000780007F +F000112380A20F> I<00007003F1980E1E181C0E18380700380700780780780780780780 +7807803807003807001C0E001E1C0033F0002000002000003000003800003FFE001FFFC0 +0FFFE03000F0600030C00018C00018C00018C000186000306000303800E00E038003FE00 +15217F9518> I<0E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00 +000E00000E00000E00000E00000E1F800E60C00E80E00F00700F00700E00700E00700E00 +700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00 +70FFE7FF18237FA21B> I<1C003E003E003E001C00000000000000000000000000000000 +000E007E001E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E +000E000E00FFC00A227FA10E> I<00E001F001F001F000E0000000000000000000000000 +00000000007007F000F00070007000700070007000700070007000700070007000700070 +00700070007000700070007000700070007000706070F0E0F0C061803F000C2C83A10F> +I<0E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00000E00000E00 +000E00000E00000E03FC0E01F00E01C00E01800E02000E04000E08000E10000E38000EF8 +000F1C000E1E000E0E000E07000E07800E03C00E01C00E01E00E00F00E00F8FFE3FE1723 +7FA21A> I<0E00FE001E000E000E000E000E000E000E000E000E000E000E000E000E000E +000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E +00FFE00B237FA20E> I<0E1FC07F00FE60E183801E807201C00F003C00E00F003C00E00E +003800E00E003800E00E003800E00E003800E00E003800E00E003800E00E003800E00E00 +3800E00E003800E00E003800E00E003800E00E003800E00E003800E00E003800E00E0038 +00E0FFE3FF8FFE27157F942A> I<0E1F80FE60C01E80E00F00700F00700E00700E00700E +00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E +0070FFE7FF18157F941B> I<01FC000707000C01801800C03800E0700070700070F00078 +F00078F00078F00078F00078F00078F000787000707800F03800E01C01C00E0380070700 +01FC0015157F9418> I<0E1F00FE61C00E80600F00700E00380E003C0E003C0E001E0E00 +1E0E001E0E001E0E001E0E001E0E001E0E003C0E003C0E00380F00700E80E00E41C00E3F +000E00000E00000E00000E00000E00000E00000E00000E00000E0000FFE000171F7F941B +> I<01F8200704600E02601C01603801E07800E07800E0F000E0F000E0F000E0F000E0F0 +00E0F000E0F000E07800E07800E03801E01C01E00C02E0070CE001F0E00000E00000E000 +00E00000E00000E00000E00000E00000E00000E0000FFE171F7E941A> I<0E3CFE461E8F +0F0F0F060F000E000E000E000E000E000E000E000E000E000E000E000E000E000F00FFF0 +10157F9413> I<0F8830786018C018C008C008E008F0007F003FE00FF001F8003C801C80 +0C800CC00CC008E018D0308FC00E157E9413> I<02000200020002000600060006000E00 +1E003E00FFFC0E000E000E000E000E000E000E000E000E000E000E000E040E040E040E04 +0E040E040708030801F00E1F7F9E13> I<0E0070FE07F01E00F00E00700E00700E00700E +00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00F00E00F006 +017003827800FC7F18157F941B> I I I I I<3FFFC0380380300780200700600E +00401C00403C0040380000700000E00001E00001C0000380400700400F00400E00C01C00 +80380080780180700780FFFF8012157F9416> I 124 +D E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fl cmbx12 14.4 19 +/Fl 19 118 df<00007FE0030007FFFC07001FFFFF0F007FF00F9F00FF0001FF01FC0000 +FF03F800007F07F000003F0FE000001F1FC000001F1FC000000F3F8000000F3F80000007 +7F800000077F800000077F00000000FF00000000FF00000000FF00000000FF00000000FF +00000000FF00000000FF00000000FF00000000FF000000007F000000007F800000007F80 +0000073F800000073F800000071FC00000071FC000000E0FE000000E07F000001C03F800 +003C01FC00007800FF0001F0007FF007C0001FFFFF800007FFFE0000007FF00028297CA8 +31> 67 D +76 D<0000FFC00000000FFFFC0000003F807F000000FE001FC00001F80007E00003F000 +03F00007E00001F8000FE00001FC001FC00000FE001FC00000FE003F8000007F003F8000 +007F007F8000007F807F0000003F807F0000003F807F0000003F80FF0000003FC0FF0000 +003FC0FF0000003FC0FF0000003FC0FF0000003FC0FF0000003FC0FF0000003FC0FF0000 +003FC0FF0000003FC0FF0000003FC07F0000003F807F8000007F807F8000007F803F8000 +007F003F8000007F001FC00000FE001FC00000FE000FE00001FC0007F00003F80003F800 +07F00001FC000FE00000FE001FC000003FC0FF0000000FFFFC00000000FFC000002A297C +A833> 79 D 86 D<03FF80000FFFF0001F01FC003F80FE003F807F003F803F003F803F +801F003F8000003F8000003F8000003F8000003F80003FFF8001FC3F800FE03F801F803F +803F003F807E003F80FC003F80FC003F80FC003F80FC003F80FC005F807E00DF803F839F +FC1FFE0FFC03FC03FC1E1B7E9A21> 97 D I<00007FF000007FF000007FF0000007F0000007F0000007 +F0000007F0000007F0000007F0000007F0000007F0000007F0000007F0000007F0000007 +F0003F87F001FFF7F007F03FF00FC00FF01F8007F03F0007F03F0007F07E0007F07E0007 +F07E0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007 +F07E0007F07E0007F03F0007F03F0007F01F800FF00FC01FF007E07FFF01FFE7FF007F87 +FF202A7EA925> 100 D<003FC00001FFF00003E07C000F803E001F801F001F001F003F00 +0F807E000F807E000FC07E000FC0FE0007C0FE0007C0FFFFFFC0FFFFFFC0FE000000FE00 +0000FE0000007E0000007E0000007F0000003F0001C01F0001C00F80038007C0070003F0 +1E0000FFFC00003FE0001A1B7E9A1F> I<0007F8003FFC007E3E01FC7F03F87F03F07F07 +F07F07F03E07F00007F00007F00007F00007F00007F00007F000FFFFC0FFFFC0FFFFC007 +F00007F00007F00007F00007F00007F00007F00007F00007F00007F00007F00007F00007 +F00007F00007F00007F00007F00007F00007F00007F00007F0007FFF807FFF807FFF8018 +2A7EA915> I +104 D<07000F801FC03FE03FE03FE01FC00F8007000000000000000000000000000000FF +E0FFE0FFE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00F +E00FE00FE00FE00FE00FE0FFFEFFFEFFFE0F2B7EAA12> I 108 D 110 D<003FE00001FFFC0003F07E000FC01F801F80 +0FC03F0007E03F0007E07E0003F07E0003F07E0003F0FE0003F8FE0003F8FE0003F8FE00 +03F8FE0003F8FE0003F8FE0003F8FE0003F87E0003F07E0003F03F0007E03F0007E01F80 +0FC00FC01F8007F07F0001FFFC00003FE0001D1B7E9A22> I I 114 D<03FE300FFFF03E03F078 +00F07000F0F00070F00070F80070FE0000FFE0007FFF007FFFC03FFFE01FFFF007FFF800 +FFF80007FC0000FCE0007CE0003CF0003CF00038F80038FC0070FF01E0E7FFC0C1FF0016 +1B7E9A1B> I<00E00000E00000E00000E00001E00001E00001E00003E00003E00007E000 +0FE0001FFFE0FFFFE0FFFFE00FE0000FE0000FE0000FE0000FE0000FE0000FE0000FE000 +0FE0000FE0000FE0000FE0000FE0000FE0700FE0700FE0700FE0700FE0700FE0700FE070 +07F0E003F0C001FF80007F0014267FA51A> I I E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fm cmr12 14.4 20 +/Fm 20 118 df<78FCFCFEFE7A02020202040404080810204007127B8510> 44 +D<00200000E00001E0000FE000FFE000F1E00001E00001E00001E00001E00001E00001E0 +0001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E0 +0001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E0 +0001E00003F000FFFFC0FFFFC012287BA71D> 49 D<01FC0007FF000C0FC01803E02001 +F06001F04000F84000F8F800FCFC00FCFC007CFC007CFC007C7800FC0000FC0000F80000 +F80001F00001F00003E00003C0000780000700000E00001C0000380000300000600000C0 +000180000300040200040400080800081000082000183FFFF87FFFF0FFFFF0FFFFF01628 +7DA71D> I<000FC0003FF000F01801C01803803C07007C0F007C0E00381E00003C00003C +00003C0000780000780000780000F83F00F8C1C0F900E0FA0070FA0038FC003CFC001EFC +001EF8001EF8001FF8001FF8001FF8001F78001F78001F78001F78001F3C001E3C001E1C +003C1E003C0E007807007003C1E001FFC0007E0018297EA71D> 54 +D<007E0001FF800781C00F00E01E00703C00383C003878003C78003CF8001EF8001EF800 +1EF8001EF8001FF8001FF8001FF8001F78001F78003F78003F3C003F1C005F0E005F0700 +9F03831F00FC1F00001E00001E00001E00003E00003C00003C0000381C00783E00703E00 +E03C01C01803801C0F000FFE0003F80018297EA71D> 57 D<0000FF00100007FFE03000 +1FC07830003E000C7000F80006F001F00003F003E00001F007C00000F00F800000700F80 +0000701F000000303F000000303E000000303E000000107E000000107E000000107C0000 +0000FC00000000FC00000000FC00000000FC00000000FC00000000FC00000000FC000000 +00FC00000000FC0000FFFF7C0000FFFF7E000003F07E000001F03E000001F03E000001F0 +3F000001F01F000001F00F800001F00F800001F007C00001F003E00001F001F00002F000 +F80002F0003E000C70001FC038300007FFE0100000FF8000282B7DA92E> 71 +D<01FFFE01FFFE0007E00003E00003E00003E00003E00003E00003E00003E00003E00003 +E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003 +E00003E00003E00003E00003E00003E00003E00003E03003E07803E0FC03E0FC03E0FC03 +C0F807C0400780200F00300E000C3C0003F000172A7DA81E> 74 +D<0001FF0000000F01E000003C0078000078003C0000E0000E0001E0000F0003C0000780 +07800003C00F800003E01F000001F01F000001F03E000000F83E000000F87E000000FC7E +000000FC7C0000007C7C0000007CFC0000007EFC0000007EFC0000007EFC0000007EFC00 +00007EFC0000007EFC0000007EFC0000007EFC0000007E7C0000007C7E000000FC7E0000 +00FC7E000000FC3E000000F83F000001F81F000001F01F000001F00F800003E007800003 +C007C00007C003E0000F8000F0001E000078003C00003C007800000F01E0000001FF0000 +272B7DA92E> 79 D<03FC00000C070000100380003C01C0003E01E0003E00F0001C00F0 +000800F0000000F0000000F0000000F000007FF00003E0F0000F80F0001E00F0003C00F0 +007C00F0007800F040F800F040F800F040F800F040F801F0407C01F0403C0278801E0C7F +8007F01E001A1A7E991D> 97 D<0F000000FF000000FF0000001F0000000F0000000F00 +00000F0000000F0000000F0000000F0000000F0000000F0000000F0000000F0000000F00 +00000F0000000F07E0000F1838000F600E000F8007000F8007800F0003C00F0003C00F00 +01E00F0001E00F0001F00F0001F00F0001F00F0001F00F0001F00F0001F00F0001F00F00 +01E00F0001E00F0003E00F0003C00F0003800F8007800E800F000E401C000C303800080F +C0001C2A7EA921> I<007F0001C0E00700100E00781E00F83C00F83C00707C0020780000 +F80000F80000F80000F80000F80000F80000F80000F800007800007C00003C00083C0008 +1E00100E002007006001C180007E00151A7E991A> I<00FC000387800701C00E01E01C00 +E03C00F03C00F0780078780078F80078F80078FFFFF8F80000F80000F80000F80000F800 +007800007800003C00083C00081E00100E002007004001C180007E00151A7E991A> 101 +D<00000F0001FC3080070743800E03C3801E03C1003C01E0003C01E0007C01F0007C01F0 +007C01F0007C01F0007C01F0003C01E0003C01E0001E03C0000E0380001707000011FC00 +0030000000300000003000000030000000180000001FFF80000FFFF00007FFF80018007C +0030001E0070000E0060000700E0000700E0000700E0000700E000070070000E0070000E +0038001C001C0038000781E00000FF000019287E9A1D> 103 D<1E003F003F003F003F00 +1E000000000000000000000000000000000000000F00FF00FF001F000F000F000F000F00 +0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00FFF0FFF0 +0C297EA811> 105 D<007E0003C3C00700E00E00701C00383C003C3C003C78001E78001E +F8001FF8001FF8001FF8001FF8001FF8001FF8001FF8001F78001E78001E3C003C3C003C +1C00380E00700700E003C3C0007E00181A7E991D> 111 D<003F010001E0830003804300 +0F0027001E0017001E001F003C000F007C000F007C000F0078000F00F8000F00F8000F00 +F8000F00F8000F00F8000F00F8000F00F8000F007C000F007C000F003C000F003E001F00 +1E001F000F002F0007804F0001C18F00007E0F0000000F0000000F0000000F0000000F00 +00000F0000000F0000000F0000000F0000000F0000000F000000FFF00000FFF01C267E99 +1F> 113 D<0F0F80FF11C0FF23E01F43E00F83E00F81C00F80000F00000F00000F00000F +00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F +00000F8000FFFC00FFFC00131A7E9917> I<07F0801C0D80300380600180E00180E00080 +E00080F00080F800007E00007FE0003FFC001FFE0007FF00003F800007808003C08003C0 +8001C0C001C0C001C0E00180E00380F00300CC0E0083F800121A7E9917> I<0080000080 +000080000080000180000180000180000380000380000780000F80001FFF80FFFF800780 +000780000780000780000780000780000780000780000780000780000780000780000780 +0007804007804007804007804007804007804007804003C08001C08000E100003E001225 +7FA417> I<0F000F00FF00FF00FF00FF001F001F000F000F000F000F000F000F000F000F +000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F +000F000F000F000F000F000F000F001F000F001F0007002F0003804F8001C08FF0007F0F +F01C1A7E9921> I E +%EndDVIPSBitmapFont +%DVIPSBitmapFont: Fn cmr17 20.74 18 +/Fn 18 119 df<000001FF00008000001FFFE0018000007F007801800001F8000E038000 +03E000070780000FC000018780001F000000CF80003E0000006F80007C0000003F8000F8 +0000003F8001F00000001F8003F00000000F8007E00000000F8007C000000007800FC000 +000007800FC000000007801F8000000003801F8000000003803F8000000003803F000000 +0001803F0000000001807F0000000001807F0000000001807E0000000000007E00000000 +0000FE000000000000FE000000000000FE000000000000FE000000000000FE0000000000 +00FE000000000000FE000000000000FE000000000000FE000000000000FE000000000000 +FE0000000000007E0000000000007E0000000000007F0000000000007F0000000001803F +0000000001803F0000000001803F8000000001801F8000000001801F8000000003000FC0 +00000003000FC0000000030007E0000000060007E0000000060003F0000000060001F000 +00000C0000F80000001800007C0000001800003E0000003000001F0000006000000FC000 +01C0000003E0000380000001F8000E000000007F007C000000001FFFF00000000001FF00 +0000313D7CBB39> 67 D 76 D<000003FF00000000001E01E000000000F0003C000000 +03C0000F000000078000078000000F000003C000003E000001F000007C000000F80000F8 +0000007C0001F00000003E0001F00000003E0003E00000001F0007E00000001F8007C000 +00000F800FC00000000FC00F8000000007C01F8000000007E01F8000000007E03F000000 +0003F03F0000000003F03F0000000003F07F0000000003F87E0000000001F87E00000000 +01F87E0000000001F8FE0000000001FCFE0000000001FCFE0000000001FCFE0000000001 +FCFE0000000001FCFE0000000001FCFE0000000001FCFE0000000001FCFE0000000001FC +FE0000000001FCFE0000000001FC7E0000000001F87F0000000003F87F0000000003F87F +0000000003F87F0000000003F83F0000000003F03F8000000007F01F8000000007E01F80 +00000007E01FC00000000FE00FC00000000FC007C00000000F8007E00000001F8003E000 +00001F0001F00000003E0001F80000007E0000F80000007C00007C000000F800003E0000 +01F000000F000003C000000780000780000003E0001F00000000F8007C000000001E01E0 +0000000003FF000000363D7CBB3E> 79 D<003F80000001C0F0000003003C000004001E +00000C000F000018000780001C0007C0003E0003C0003F0003E0003F0003E0003F0003E0 +001E0003E000000003E000000003E000000003E00000003FE000000FF3E000007E03E000 +01F803E00003E003E0000FC003E0001F8003E0003F0003E0003E0003E0007E0003E0007E +0003E060FC0003E060FC0003E060FC0003E060FC0007E060FC0007E0607C000BE0607E00 +0BE0603E0011F0C01F0060F0C007C1807F8000FE003E0023257CA427> 97 +D<03E0000000FFE0000000FFE000000007E000000003E000000003E000000003E0000000 +03E000000003E000000003E000000003E000000003E000000003E000000003E000000003 +E000000003E000000003E000000003E000000003E000000003E000000003E000000003E0 +00000003E000000003E03FC00003E0E0780003E3001C0003E6000F0003E800078003F800 +03C003F00001E003E00001F003E00000F003E00000F803E00000F803E00000FC03E00000 +7C03E000007C03E000007E03E000007E03E000007E03E000007E03E000007E03E000007E +03E000007E03E000007E03E000007E03E000007C03E000007C03E00000FC03E00000F803 +E00000F803E00001F003E00001E003F00003E003D80003C003C80007800384000E000383 +001C000381C0F00003003F8000273C7EBB2C> I<0007F800003C0E0000F0018001E000C0 +03C00060078000300F0000701F0000F81F0001F83E0001F83E0001F87E0000F07C000000 +7C000000FC000000FC000000FC000000FC000000FC000000FC000000FC000000FC000000 +FC0000007C0000007C0000007E0000003E0000003E00000C1F00000C1F0000180F800018 +0780003003C0006001E000C000F00180003C0E000007F8001E257DA423> I<0007F80000 +3C1E0000F0078001C003C003C001E0078000F00F0000F81F0000781E00007C3E00007C3E +00007C7E00003E7C00003E7C00003EFC00003EFC00003EFFFFFFFEFC000000FC000000FC +000000FC000000FC000000FC0000007C0000007C0000007E0000003E0000003E0000061F +0000060F00000C0F80000C0780001803C0003000E00060007000C0001E07000003FC001F +257EA423> 101 D<0000FC0000078300000E0380001C07C0003C0FC000780FC000F80FC0 +00F8078000F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000 +01F0000001F0000001F0000001F0000001F0000001F0000001F00000FFFFFC00FFFFFC00 +01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000 +01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000 +01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000 +01F0000001F0000001F0000001F0000001F0000003F800007FFFE0007FFFE0001A3C7FBB +18> I<07000F801FC01FC01FC00F80070000000000000000000000000000000000000000 +0000000000000007C0FFC0FFC00FC007C007C007C007C007C007C007C007C007C007C007 +C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007 +C007C00FE0FFFEFFFE0F397DB815> 105 D<0003800007C0000FE0000FE0000FE00007C0 +000380000000000000000000000000000000000000000000000000000000000000000000 +0000000000000007E000FFE000FFE0000FE00003E00003E00003E00003E00003E00003E0 +0003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E0 +0003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E0 +0003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E0 +7803C0FC07C0FC0780FC0780FC0F00780E00381C000FE000134A82B818> I<07C0FFC0FF +C00FC007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007 +C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007 +C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007 +C00FE0FFFEFFFE0F3C7DBB15> 108 D<03E01FE0003FC000FFE0607C00C0F800FFE0801E +01003C0007E3000F06001E0003E4000F88001F0003E4000F88001F0003E8000790000F00 +03E80007D0000F8003F00007E0000F8003F00007E0000F8003E00007C0000F8003E00007 +C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F80 +03E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007 +C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F80 +03E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007 +C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F80 +07F0000FE0001FC0FFFF81FFFF03FFFEFFFF81FFFF03FFFE3F257EA443> I<03E01FE000 +FFE0607C00FFE0801E0007E3000F0003E4000F8003E4000F8003E800078003E80007C003 +F00007C003F00007C003E00007C003E00007C003E00007C003E00007C003E00007C003E0 +0007C003E00007C003E00007C003E00007C003E00007C003E00007C003E00007C003E000 +07C003E00007C003E00007C003E00007C003E00007C003E00007C003E00007C003E00007 +C003E00007C003E00007C003E00007C003E00007C007F0000FE0FFFF81FFFFFFFF81FFFF +28257EA42C> I<0007FC0000001C070000007001C00001E000F00003C00078000780003C +000F00001E001F00001F001E00000F003E00000F803E00000F807C000007C07C000007C0 +7C000007C0FC000007E0FC000007E0FC000007E0FC000007E0FC000007E0FC000007E0FC +000007E0FC000007E0FC000007E07C000007C07C000007C07E00000FC03E00000F803E00 +000F801E00000F001F00001F000F00001E000780003C0003C000780001E000F000007001 +C000001C0700000007FC000023257EA427> I<03E03E00FFE0C300FFE1078007E20FC003 +E40FC003E80FC003E8078003E8030003F0000003F0000003F0000003E0000003E0000003 +E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003 +E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003 +E0000003E0000003E0000007F00000FFFFC000FFFFC0001A257EA41E> 114 +D<00FF02000700C6000C002E0010001E0030001E0060000E0060000E00E0000600E00006 +00E0000600F0000600F8000600FC0000007F0000003FF000003FFF80000FFFE00007FFF0 +0001FFFC00003FFE000001FE0000003F00C0001F00C0000F80C0000780E0000380E00003 +80E0000380E0000380F0000300F0000300F8000700F8000600E4000C00E2001800C18070 +00807F800019257DA41F> I<003000000030000000300000003000000030000000300000 +0070000000700000007000000070000000F0000000F0000001F0000001F0000003F00000 +07F000001FFFFE00FFFFFE0001F0000001F0000001F0000001F0000001F0000001F00000 +01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000 +01F0000001F0000001F0000001F0000001F0018001F0018001F0018001F0018001F00180 +01F0018001F0018001F0018001F0018000F0010000F8030000F8030000780200003C0400 +000E08000003F00019357FB41E> I 118 +D E +%EndDVIPSBitmapFont +end +%%EndProlog +%%BeginSetup +%%Feature: *Resolution 300dpi +TeXDict begin +%%PaperSize: a4 + +userdict/PStoPSxform PStoPSmatrix matrix currentmatrix + matrix invertmatrix matrix concatmatrix + matrix invertmatrix put +%%EndSetup +%%Page: (0,1) 1 +userdict/PStoPSsaved save put +PStoPSmatrix setmatrix +595.000000 0.271378 translate +90 rotate +0.706651 dup scale +userdict/PStoPSmatrix matrix currentmatrix put +userdict/PStoPSclip{0 0 moveto + 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto + closepath}put initclip +/showpage{}def/copypage{}def/erasepage{}def +PStoPSxform concat +1 0 bop Fn 281 370 a(Cleaner) p 570 370 a(seman) n(tics) p +927 370 a(for) p 1047 370 a(Ob) t(jectiv) n(e) p 1404 +370 a(Lab) r(el) p Fm 717 518 a(Jacques) p 934 518 a(Garrigue) 719 +634 y(Octob) r(er) p 945 634 a(26,) p 1040 634 a(1999) p +Fl 11 836 a(Credits) p Fk 11 929 a(This) p 122 929 a(prop) q(osal) p +319 929 a(con) o(tains) p 510 929 a(ideas) p 632 929 +a(from) p 747 929 a(Damien) p 928 929 a(Doligez) p 1101 +929 a(and) p 1196 929 a(Pierre) p 1340 929 a(W) l(eis.) p +Fl 11 1073 a(Lab) r(els) p 221 1073 a(and) p 351 1073 +a(optionals) p Fk 11 1165 a(Lab) q(els) p 165 1165 a(and) p +259 1165 a(optional) p 449 1165 a(argumen) o(ts) p 687 +1165 a(had) p 781 1165 a(t) o(w) o(o) p 873 1165 a(problems) p +1082 1165 a(in) p 1139 1165 a(Ob) s(jectiv) o(e) p 1360 +1165 a(Lab) q(el.) p Fj 83 1280 a(\017) p Fk 133 1280 +a(They) p 259 1280 a(w) o(ere) p 372 1280 a(not) p 459 +1280 a(fully) p 570 1280 a(coheren) o(t) p 767 1280 a(with) p +878 1280 a(the) p 963 1280 a(original) p 1139 1280 a(call-b) o(y-v) m +(alue) p 1423 1280 a(seman) o(tics) p 1644 1280 a(of) p +1700 1280 a(the) p 1784 1280 a(lan-) 133 1340 y(guage.) p +303 1340 a(In) p 368 1340 a(some) p 495 1340 a(\(subtle\)) p +681 1340 a(cases,) p 823 1340 a(a) p 868 1340 a(side-e\013ect) p +1099 1340 a(migh) o(t) p 1243 1340 a(get) p 1329 1340 +a(dela) o(y) o(ed) p 1508 1340 a(more) p 1635 1340 a(than) p +1753 1340 a(in) p 1814 1340 a(an) 133 1400 y(un) o(t) o(yp) q(ed) p +322 1400 a(seman) o(tics.) p Fj 83 1502 a(\017) p Fk +133 1502 a(F) l(or) p 220 1502 a(optional) p 410 1502 +a(argumen) o(ts,) p 660 1502 a(no) p 728 1502 a(un) o(t) o(yp) q(ed) p +918 1502 a(seman) o(tics) p 1139 1502 a(existed.) 84 +1616 y(This) p 195 1616 a(new) p 295 1616 a(prop) q(osal) p +492 1616 a(corrects) p 674 1616 a(these) p 799 1616 a(t) o(w) o(o) p +891 1616 a(\015a) o(ws.) p Fi 11 1746 a(Syn) n(tax) p +Fk 11 1838 a(W) l(e) p 95 1838 a(k) o(eep) p 206 1838 +a(Ob) s(jectiv) o(e) p 426 1838 a(Lab) q(el's) p 594 +1838 a(syn) o(tax,) p 764 1838 a(except) p 917 1838 a(for) p +991 1838 a(default) p 1155 1838 a(v) m(alues) p 1301 +1838 a(in) p 1357 1838 a(optional) p 1547 1838 a(argumen) o(ts.) p +Fh 329 1944 a(typ) n(expr) p Fk 528 1944 a(::=) p Fg +634 1944 a(:) p 656 1944 a(:) p 678 1944 a(:) p Fj 579 +2004 a(j) p Fh 634 2004 a(typ) n(expr) p Fj 806 2004 +a(!) p Fh 870 2004 a(typ) n(expr) p Fj 579 2064 a(j) p +Fk 634 2064 a([?]) p Fi(lab) r(el) p Fk 801 2064 a(:) p +Fh(typ) n(expr) p Fj 987 2064 a(!) p Fh 1050 2064 a(typ) n(expr) 391 +2124 y(expr) p Fk 528 2124 a(::=) p Fg 634 2124 a(:) p +656 2124 a(:) p 678 2124 a(:) p Fj 579 2185 a(j) p Fh +634 2185 a(expr) p 746 2185 a(lab) n(ele) n(d-expr) p +Ff 991 2163 a(+) p Fj 579 2245 a(j) p Fe 634 2245 a(fun) p +Fj 728 2245 a(f) p Fh(lab) n(ele) n(d-simple-p) n(attern) p +Fj 1209 2245 a(g) p Ff 1234 2227 a(+) p Fk 1280 2245 +a([) p Fe(when) p Fh 1412 2245 a(expr) p Fk 1507 2245 +a(]) p Fj 1535 2245 a(!) p Fh 1599 2245 a(expr) p Fj +579 2305 a(j) p Fe 634 2305 a(function) p Fh 856 2305 +a(lab) n(ele) n(d-p) n(attern) p Fk 1177 2305 a([) p +Fe(when) p Fh 1309 2305 a(expr) p Fk 1404 2305 a(]) p +Fj 1432 2305 a(!) p Fh 1496 2305 a(expr) p Fj 785 2365 +a(f) p Fe(|) p Fh 851 2365 a(lab) n(ele) n(d-p) n(attern) p +Fk 1172 2365 a([) p Fe(when) p Fg 1305 2365 a(expr) p +Fk 1403 2365 a(]) p Fj 1430 2365 a(!) p Fh 1494 2365 +a(expr) p Fj 1589 2365 a(g) p Fd 1614 2347 a(\003) p +Fh 242 2425 a(lab) n(ele) n(d-expr) p Fk 528 2425 a(::=) p +634 2425 a([?]) p Fh(expr) p Fj 579 2486 a(j) p Fk 634 +2486 a([?]) p Fi(lab) r(el) p Fk 801 2486 a(:) p Fh(expr) 182 +2546 y(lab) n(ele) n(d-p) n(attern) p Fk 528 2546 a(::=) p +Fh 634 2546 a(p) n(attern) p Fj 579 2606 a(j) p Fi 634 +2606 a(lab) r(el) p Fk 751 2606 a(:) p Fh(p) n(attern) p +Fj 579 2666 a(j) p Fk 634 2666 a(?[) p Fe(\() p Fh(expr) p +Fe(\)) p Fk(]) p Fi(lab) r(el) p Fk 943 2666 a(:) p Fh +956 2666 a(p) n(attern) p Fk 926 2937 a(1) p eop +PStoPSsaved restore +userdict/PStoPSsaved save put +PStoPSmatrix setmatrix +595.000000 421.271378 translate +90 rotate +0.706651 dup scale +userdict/PStoPSmatrix matrix currentmatrix put +userdict/PStoPSclip{0 0 moveto + 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto + closepath}put initclip +PStoPSxform concat +2 1 bop Fi 11 168 a(Dynamic) p 247 168 a(seman) n(tics) p +Fj 11 261 a(;) p Fk 52 261 a(is) p 101 261 a(a) p 141 +261 a(notation) p 337 261 a(for) p 411 261 a(the) p 495 +261 a(empt) o(y) p 644 261 a(lab) q(el.) 86 366 y(\() p +Fe(fun) p Fi 198 366 a(l) p Fc 214 373 a(i) p Fk 227 +366 a(:) p Fg(x) p Fj 282 366 a(!) p Fg 346 366 a(e) p +Fk(\)) p Fi 404 366 a(l) p Fc 420 373 a(1) p Fk 442 366 +a(:) p Fg 455 366 a(e) p Ff 478 373 a(1) p Fg 506 366 +a(:) p 528 366 a(:) p 550 366 a(:) p Fi 571 366 a(l) p +Fc 587 373 a(n) p Fk 612 366 a(:) p Fg 625 366 a(e) p +Fb 648 373 a(n) p Fj 515 427 a(!) p Fk 579 427 a(\() p +Fg(e) p Fk([) p Fg(e) p Fb 658 434 a(i) p Fg 671 427 +a(=x) p Fk(]) p Fi 752 427 a(l) p Fc 768 434 a(1) p Fk +790 427 a(:) p Fg(e) p Ff 827 434 a(1) p Fg 855 427 a(:) p +877 427 a(:) p 899 427 a(:) p Fi 920 427 a(l) p Fc 936 +434 a(i) p Fd(\000) p Fc(1) p Fk 997 427 a(:) p Fg 1010 +427 a(e) p Fb 1033 434 a(i) p Fd(\000) p Ff(1) p Fi 1108 +427 a(l) p Fc 1124 434 a(i) p Ff(+) p Fc(1) p Fk 1185 +427 a(:) p Fg(e) p Fb 1222 434 a(i) p Ff(+1) p Fg 1289 +427 a(:) p 1311 427 a(:) p 1333 427 a(:) p Fi 1354 427 +a(l) p Fc 1370 434 a(n) p Fk 1395 427 a(:) p Fg 1408 +427 a(e) p Fb 1431 434 a(n) p Fk 86 487 a(\() p Fe(fun) p +Fk 198 487 a(?) p Fi(l) p Fc 237 494 a(i) p Fk 250 487 +a(:) p Fg(x) p Fj 305 487 a(!) p Fg 369 487 a(e) p Fk(\)) p +Fi 427 487 a(l) p Fc 443 494 a(1) p Fk 465 487 a(:) p +Fg 478 487 a(e) p Ff 501 494 a(1) p Fg 529 487 a(:) p +551 487 a(:) p 573 487 a(:) p Fi 594 487 a(l) p Fc 610 +494 a(n) p Fk 635 487 a(:) p Fg 648 487 a(e) p Fb 671 +494 a(n) p Fj 515 547 a(!) p Fg 579 547 a(e) p Fk([) p +Fe(Some) p Fk 717 547 a(\() p Fg(e) p Fb 759 554 a(i) p +Fk 773 547 a(\)) p Fg(=x) p Fk(]) p Fi 874 547 a(l) p +Fc 890 554 a(1) p Fk 912 547 a(:) p Fg 925 547 a(e) p +Ff 948 554 a(1) p Fg 976 547 a(:) p 998 547 a(:) p 1020 +547 a(:) p Fi 1042 547 a(l) p Fc 1058 554 a(i) p Fd(\000) p +Fc(1) p Fk 1118 547 a(:) p Fg(e) p Fb 1155 554 a(i) p +Fd(\000) p Ff(1) p Fi 1230 547 a(l) p Fc 1246 554 a(i) p +Ff(+) p Fc(1) p Fk 1307 547 a(:) p Fg 1320 547 a(e) p +Fb 1343 554 a(i) p Ff(+1) p Fg 1410 547 a(:) p 1432 547 +a(:) p 1454 547 a(:) p Fi 1476 547 a(l) p Fc 1492 554 +a(n) p Fk 1516 547 a(:) p Fg(e) p Fb 1553 554 a(n) p +Fk 86 607 a(\() p Fe(fun) p Fk 198 607 a(?) p Fi(l) p +Fk(:) p Fg 250 607 a(x) p Fj 292 607 a(!) p Fg 356 607 +a(e) p Fk(\)) p Fi 413 607 a(l) p Fc 429 614 a(1) p Fk +451 607 a(:) p Fg(e) p Ff 488 614 a(1) p Fg 516 607 a(:) p +538 607 a(:) p 560 607 a(:) p Fi 581 607 a(l) p Fc 597 +614 a(n) p Fk 621 607 a(:) p Fg(e) p Fb 658 614 a(n) p +Fk 1154 607 a(when) p Fi 1281 607 a(l) p Fc 1297 614 +a(i) p Fk 1324 607 a(=) p Fj 1376 607 a(;) p Fk 1417 +607 a(and) p Fg 1512 607 a(l) p Fj 1541 607 a(62) p 1588 +607 a(f) p Fi(l) p Fc 1629 614 a(1) p Fg 1660 607 a(:) p +1682 607 a(:) p 1704 607 a(:) p Fi 1725 607 a(l) p Fc +1741 614 a(n) p Fj 1765 607 a(g) 515 667 y(!) p Fg 579 +667 a(e) p Fk([) p Fe(None) p Fg 717 667 a(=x) p Fk(]) p +Fi 799 667 a(l) p Fc 815 674 a(1) p Fk 837 667 a(:) p +Fg(e) p Ff 874 674 a(1) p Fg 901 667 a(:) p 923 667 a(:) p +945 667 a(:) p Fi 967 667 a(l) p Fc 983 674 a(n) p Fk +1007 667 a(:) p Fg(e) p Fb 1044 674 a(n) p Fk 86 728 +a(\(\() p Fe(fun) p Fi 217 728 a(l) p Fk(:) p Fg 246 +728 a(x) p Fj 288 728 a(!) p Fg 352 728 a(e) p Fk(\)) p +Fi 409 728 a(l) p Fc 425 735 a(1) p Fk 447 728 a(:) p +Fg(e) p Ff 484 735 a(1) p Fg 511 728 a(:) p 533 728 a(:) p +555 728 a(:) p Fi 577 728 a(l) p Fc 593 735 a(m) p Fk +629 728 a(:) p Fg 642 728 a(e) p Fb 665 735 a(m) p Fk +698 728 a(\)) p Fi 733 728 a(l) p Fc 749 735 a(m) p Ff(+) p +Fc(1) p Fk 833 728 a(:) p Fg 846 728 a(e) p Fb 869 735 +a(m) p Ff(+1) p Fg 955 728 a(:) p 977 728 a(:) p 999 +728 a(:) p Fi 1021 728 a(l) p Fc 1037 735 a(n) p Fk 1061 +728 a(:) p Fg(e) p Fb 1098 735 a(n) p Fk 1373 728 a(when) p +Fi 1501 728 a(l) p Fj 1530 728 a(62) p 1577 728 a(f) p +Fi(l) p Fc 1618 735 a(1) p Fg 1648 728 a(:) p 1670 728 +a(:) p 1692 728 a(:) p Fi 1714 728 a(l) p Fc 1730 735 +a(m) p Fj 1765 728 a(g) 515 788 y(!) p Fk 579 788 a(\() p +Fe(fun) p Fi 691 788 a(l) p Fk(:) p Fg 720 788 a(x) p +Fj 761 788 a(!) p Fg 825 788 a(e) p Fk(\)) p Fi 883 788 +a(l) p Fc 899 795 a(1) p Fk 921 788 a(:) p Fg 934 788 +a(e) p Ff 957 795 a(1) p Fg 985 788 a(:) p 1007 788 a(:) p +1029 788 a(:) p Fi 1051 788 a(l) p Fc 1067 795 a(n) p +Fk 1091 788 a(:) p Fg 1104 788 a(e) p Fb 1127 795 a(n) p +Fk 86 848 a(\(\() p Fe(fun) p Fk 217 848 a(?) p Fi(l) p +Fk(:) p Fg 269 848 a(x) p Fj 311 848 a(!) p Fg 375 848 +a(e) p Fk(\)) p Fi 432 848 a(l) p Fc 448 855 a(1) p Fk +470 848 a(:) p Fg(e) p Ff 507 855 a(1) p Fg 535 848 a(:) p +557 848 a(:) p 579 848 a(:) p Fi 600 848 a(l) p Fc 616 +855 a(m) p Fk 652 848 a(:) p Fg 665 848 a(e) p Fb 688 +855 a(m) p Fk 721 848 a(\)) p Fi 756 848 a(l) p Fc 772 +855 a(m) p Ff(+) p Fc(1) p Fk 856 848 a(:) p Fg 869 848 +a(e) p Fb 892 855 a(m) p Ff(+1) p Fg 978 848 a(:) p 1000 +848 a(:) p 1022 848 a(:) p Fi 1044 848 a(l) p Fc 1060 +855 a(n) p Fk 1084 848 a(:) p Fg(e) p Fb 1121 855 a(n) p +Fk 1261 848 a(when) p Fj 1388 848 a(f) p Fi(l) p Fg(;) p +Fj 1451 848 a(;g) p 1530 848 a(6) m(\\) p 1577 848 a(f) p +Fi(l) p Fc 1618 855 a(1) p Fg 1648 848 a(:) p 1670 848 +a(:) p 1692 848 a(:) p Fi 1714 848 a(l) p Fc 1730 855 +a(m) p Fj 1765 848 a(g) 515 908 y(!) p Fk 579 908 a(\() p +Fe(fun) p Fk 691 908 a(?) p Fi(l) p Fk(:) p Fg 743 908 +a(x) p Fj 785 908 a(!) p Fg 848 908 a(e) p Fk(\)) p Fi +906 908 a(l) p Fc 922 915 a(1) p Fk 944 908 a(:) p Fg(e) p +Ff 981 915 a(1) p Fg 1008 908 a(:) p 1030 908 a(:) p +1052 908 a(:) p Fi 1074 908 a(l) p Fc 1090 915 a(n) p +Fk 1114 908 a(:) p Fg 1127 908 a(e) p Fb 1150 915 a(n) p +Fi 11 1035 a(T) n(yping) p Fk 11 1127 a(Seman) o(tics) p +240 1127 a(are) p 321 1127 a(k) o(ept) p 430 1127 a(throughout) p +685 1127 a(compilation) p 950 1127 a(b) o(y) p 1018 1127 +a(disallo) o(wing) p 1269 1127 a(lab) q(el) p 1387 1127 +a(comm) o(utation) p 1684 1127 a(for) p 1759 1127 a(func-) 11 +1187 y(tion) p 116 1187 a(t) o(yp) q(es.) p 278 1187 +a(Ho) o(w) o(ev) o(er,) p 494 1187 a(the) p 583 1187 +a(original) p 764 1187 a(comfort) p 949 1187 a(of) p +1009 1187 a(out-of-order) p 1283 1187 a(application) p +1540 1187 a(is) p 1594 1187 a(reco) o(v) o(ered) p 1814 +1187 a(b) o(y) 11 1247 y(allo) o(wing) p 207 1247 a(argumen) o(t) p +431 1247 a(reordering) p 670 1247 a(in) p 732 1247 a(application,) p +1005 1247 a(when) p 1138 1247 a(the) p 1227 1247 a(function's) p +1457 1247 a(t) o(yp) q(e) p 1572 1247 a(is) p Fh 1626 +1247 a(wel) r(l) p 1731 1247 a(known) p Fk 11 1308 a(\() p +Fh(c.f.) p Fk 118 1308 a(p) q(olymorphic) p 400 1308 +a(metho) q(ds\).) p Fl 11 1452 a(V) p 56 1452 a(arian) n(ts) p +Fk 11 1544 a(V) l(arian) o(t) p 187 1544 a(t) o(yping,) p +355 1544 a(as) p 417 1544 a(it) p 468 1544 a(is) p 519 +1544 a(presen) o(ted) p 739 1544 a(in) p 798 1544 a(the) p +884 1544 a(user's) p 1022 1544 a(man) o(ual,) p 1210 +1544 a(is) p 1261 1544 a(not) p 1350 1544 a(principal:) p +1576 1544 a(in) p 1635 1544 a(some) p 1760 1544 a(cases) 11 +1605 y(t) o(ypabilit) o(y) p 239 1605 a(of) p 301 1605 +a(an) p 375 1605 a(expression) p 616 1605 a(ma) o(y) p +728 1605 a(dep) q(end) p 904 1605 a(on) p 978 1605 a(the) p +1069 1605 a(order) p 1202 1605 a(in) p 1265 1605 a(whic) o(h) p +1411 1605 a(the) p 1502 1605 a(t) o(yping) p 1660 1605 +a(algorithm) 11 1665 y(pro) q(ceeds.) p Fe 133 1779 a(#) p +184 1779 a(let) p 286 1779 a(f1) p 363 1779 a(\(x) p +440 1779 a(:) p 491 1779 a([<) p 568 1779 a(a) p 620 +1779 a(b\(int\)]\)) p 850 1779 a(=) p 902 1779 a(\(\)) 184 +1839 y(let) p 286 1839 a(f2) p 363 1839 a(\(x) p 440 +1839 a(:) p 491 1839 a([<) p 568 1839 a(a]\)) p 671 1839 +a(=) p 722 1839 a(\(\)) 184 1899 y(let) p 286 1899 a(f3) p +363 1899 a(\(x) p 440 1899 a(:) p 491 1899 a([<) p 568 +1899 a(a) p 620 1899 a(b\(bool\)]\)) p 876 1899 a(=) p +927 1899 a(\(\);;) 133 1960 y(val) p 235 1960 a(f1) p +312 1960 a(:) p 363 1960 a([<) p 440 1960 a(a) p 491 +1960 a(b\(int\)]) p 696 1960 a(->) p 773 1960 a(unit) p +902 1960 a(=) p 953 1960 a() 133 2020 y(val) p 235 +2020 a(f2) p 312 2020 a(:) p 363 2020 a([<) p 440 2020 +a(a]) p 517 2020 a(->) p 594 2020 a(unit) p 722 2020 +a(=) p 773 2020 a() 133 2080 y(val) p 235 2080 a(f3) p +312 2080 a(:) p 363 2080 a([<) p 440 2080 a(a) p 491 +2080 a(b\(bool\)]) p 722 2080 a(->) p 799 2080 a(unit) p +927 2080 a(=) p 978 2080 a() 133 2140 y(#) p 184 +2140 a(fun) p 286 2140 a(x) p 338 2140 a(->) p 414 2140 +a(f1) p 491 2140 a(x;) p 568 2140 a(f2) p 645 2140 a(x;) p +722 2140 a(f3) p 799 2140 a(x;;) 133 2200 y(-) p 184 +2200 a(:) p 235 2200 a([<) p 312 2200 a(a]) p 389 2200 +a(->) p 466 2200 a(unit) p 594 2200 a(=) p 645 2200 a() 133 +2260 y(#) p 184 2260 a(fun) p 286 2260 a(x) p 338 2260 +a(->) p 414 2260 a(f1) p 491 2260 a(x;) p 568 2260 a(f3) p +645 2260 a(x;;) 133 2321 y(Character) o(s) p 414 2321 +a(18-19:) 133 2381 y(This) p 261 2381 a(expressio) o(n) p +543 2381 a(has) p 645 2381 a(type) p 773 2381 a([<) p +850 2381 a(a) p 902 2381 a(b\(int\)]) p 1107 2381 a(but) p +1209 2381 a(is) p 1286 2381 a(here) p 1414 2381 a(used) p +1542 2381 a(with) p 1670 2381 a(type) 184 2441 y([<) p +261 2441 a(a) p 312 2441 a(b\(bool\)]) p Fk 84 2555 a(Here) p +204 2555 a(the) p 292 2555 a(constrain) o(t) p 526 2555 +a(in) o(tro) q(duced) p 775 2555 a(b) o(y) p Fe 848 2555 +a(f2) p Fk 920 2555 a(hides) p 1049 2555 a(the) p 1138 +2555 a(constructor) p Fe 1401 2555 a(b) p Fk(,) p 1462 +2555 a(and) p 1562 2555 a(a) o(v) o(oids) p 1714 2555 +a(a) p 1760 2555 a(clash) 11 2615 y(b) q(et) o(w) o(een) p +Fe 199 2615 a(int) p Fk 292 2615 a(and) p Fe 387 2615 +a(bool) p Fk(.) 84 2676 y(An) p 163 2676 a(easy) p 270 +2676 a(w) o(a) o(y) p 369 2676 a(to) p 428 2676 a(solv) o(e) p +547 2676 a(this) p 642 2676 a(w) o(ould) p 784 2676 a(b) q(e) p +850 2676 a(to) p 909 2676 a(restrict) p 1077 2676 a(hiding) p +1226 2676 a(absen) o(t) p 1379 2676 a(lab) q(els) p 1515 +2676 a(to) p 1575 2676 a(generic) p 1739 2676 a(t) o(yp) q(es.) 11 +2736 y(This) p 124 2736 a(w) o(a) o(y) p 224 2736 a(the) p +310 2736 a(second) p 469 2736 a(case) p 574 2736 a(w) o(ould) p +718 2736 a(still) p 814 2736 a(fail,) p 913 2736 a(since) p +Fe 1034 2736 a(x) p Fk 1077 2736 a(has) p 1166 2736 a(a) p +1208 2736 a(monorphic) p 1451 2736 a(t) o(yp) q(e.) p +1584 2736 a(This) p 1697 2736 a(solution) 11 2796 y(w) o(ould) p +153 2796 a(b) q(e) p 219 2796 a(correct) p 382 2796 a(and) p +477 2796 a(principal.) 926 2937 y(2) p eop +PStoPSsaved restore +%%Page: (2,3) 2 +userdict/PStoPSsaved save put +PStoPSmatrix setmatrix +595.000000 0.271378 translate +90 rotate +0.706651 dup scale +userdict/PStoPSmatrix matrix currentmatrix put +userdict/PStoPSclip{0 0 moveto + 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto + closepath}put initclip +/showpage{}def/copypage{}def/erasepage{}def +PStoPSxform concat +3 2 bop Fk 84 168 a(Ho) o(w) o(ev) o(er,) p 293 168 a(one) p +382 168 a(can) p 472 168 a(easily) p 606 168 a(see) p +684 168 a(that) p 789 168 a(this) p 884 168 a(solution) p +1068 168 a(is) p 1117 168 a(coun) o(ter-in) o(tuitiv) o(e.) p +1504 168 a(F) l(or) p 1591 168 a(the) p 1675 168 a(user,) p +Fe 1791 168 a(b) p Fk 1833 168 a(is) 11 229 y(already) p +183 229 a(an) p 250 229 a(imp) q(ossible) p 488 229 a(constructor,) p +759 229 a(and) p 854 229 a(ha) o(ving) p 1011 229 a(a) p +1052 229 a(clash) p 1174 229 a(on) p 1242 229 a(it) p +1291 229 a(is) p 1340 229 a(hard) p 1453 229 a(to) p +1513 229 a(understand.) 84 289 y(Another) p 277 289 a(solution) p +463 289 a(is) p 514 289 a(to) p 575 289 a(go) p 642 289 +a(the) p 728 289 a(opp) q(osite) p 924 289 a(w) o(a) o(y) l(.) p +1044 289 a(T) l(o) p 1117 289 a(accept) p 1271 289 a(more) p +1395 289 a(programs.) p 1634 289 a(This) p 1747 289 a(is) p +1798 289 a(the) 11 349 y(w) o(a) o(y) p 109 349 a(w) o(e) p +181 349 a(explore) p 351 349 a(here,) p 470 349 a(with) p +581 349 a(an) p 649 349 a(unc) o(hanged) p 891 349 a(syn) o(tax.) p +Fi 11 479 a(T) n(yping) p Fk 11 571 a(The) p 114 571 +a(idea) p 220 571 a(is) p 273 571 a(to) p 336 571 a(dela) o(y) p +466 571 a(uni\014cation) p 711 571 a(on) p 782 571 a(constructor) p +1043 571 a(un) o(til) p 1161 571 a(they) p 1274 571 a(are) p +1359 571 a(explicitely) p 1595 571 a(kno) o(wn) p 1753 +571 a(to) p 1816 571 a(b) q(e) 11 631 y(presen) o(t.) p +199 631 a(W) l(e) p 280 631 a(k) o(eep) p 390 631 a(the) p +472 631 a(\() p Fg(T) t(;) p 546 631 a(U;) p 601 631 +a(L) p Fk(\)) p 666 631 a(represen) o(tation) p 983 631 +a(of) p 1036 631 a(v) m(arian) o(t) p 1200 631 a(t) o(yp) q(es,) p +1341 631 a(but) p Fg 1428 631 a(T) p Fk 1478 631 a(is) p +1525 631 a(no) p 1591 631 a(longer) p 1735 631 a(a) p +1774 631 a(map) 11 692 y(from) p 126 692 a(constructors) p +403 692 a(to) p 462 692 a(t) o(yp) q(es,) p 605 692 a(but) p +694 692 a(from) p 809 692 a(constructors) p 1086 692 +a(to) p 1146 692 a(sets) p 1241 692 a(of) p 1297 692 +a(t) o(yp) q(es.) 84 752 y(When) p 230 752 a(w) o(e) p +307 752 a(unify) p 436 752 a(t) o(w) o(o) p 532 752 a(v) m(arian) o(t) p +702 752 a(t) o(yp) q(es,) p 850 752 a(the) p 938 752 +a(\014rst) p 1043 752 a(step) p 1150 752 a(is) p 1204 +752 a(just) p 1305 752 a(to) p 1369 752 a(tak) o(e) p +1479 752 a(the) p 1567 752 a(union) p 1707 752 a(of) p +1767 752 a(b) q(oth) 11 812 y(t) o(yping) p 162 812 a(en) o(vironmen) o +(ts,) p 476 812 a(dropping) p 682 812 a(unnecessary) p +952 812 a(t) o(yp) q(es.) 204 932 y(\() p Fg(T) p Ff +252 939 a(1) p Fg 272 932 a(;) p 294 932 a(U) p Ff 327 +939 a(1) p Fg 346 932 a(;) p 368 932 a(L) p Ff 401 939 +a(1) p Fk 421 932 a(\)) p Fj 451 932 a(^) p Fk 495 932 +a(\() p Fg(T) p Ff 543 939 a(2) p Fg 563 932 a(;) p 585 +932 a(U) p Ff 618 939 a(2) p Fg 637 932 a(;) p 659 932 +a(L) p Ff 692 939 a(2) p Fk 712 932 a(\)) p 745 932 a(=) p +797 932 a(\(\() p Fg(T) p Ff 864 939 a(1) p Fj 883 932 +a(j) p Fb 897 939 a(U) p Fa 921 944 a(1) p Fd 938 939 +a(\\) p Fb(U) p Fa 986 944 a(2) p Fk 1005 932 a(\)) p +Fj 1035 932 a([) p Fk 1079 932 a(\() p Fg(T) p Ff 1127 +939 a(2) p Fj 1146 932 a(j) p Fb 1160 939 a(U) p Fa 1184 +944 a(1) p Fd 1201 939 a(\\) p Fb(U) p Fa 1249 944 a(2) p +Fk 1268 932 a(\)) p Fg(;) p 1309 932 a(U) p Ff 1342 939 +a(1) p Fj 1373 932 a(\\) p Fg 1417 932 a(U) p Ff 1450 +939 a(2) p Fg 1470 932 a(;) p 1492 932 a(L) p Ff 1525 +939 a(1) p Fj 1556 932 a([) p Fg 1600 932 a(L) p Ff 1633 +939 a(2) p Fk 1653 932 a(\)) 84 1042 y(Here) p 203 1042 +a(the) p 291 1042 a(union) p 431 1042 a(of) p 490 1042 +a(t) o(w) o(o) p 587 1042 a(t) o(yping) p 742 1042 a(en) o(vironmen) o +(ts) p 1046 1042 a(is) p 1099 1042 a(the) p 1187 1042 +a(p) q(oin) o(t) o(wise) p 1407 1042 a(union) p 1547 +1042 a(of) p 1606 1042 a(their) p 1727 1042 a(sets) p +1826 1042 a(of) 11 1102 y(t) o(yp) q(es) p 140 1102 a(for) p +214 1102 a(eac) o(h) p 324 1102 a(constructor.) 84 1162 +y(This) p 195 1162 a(\014rst) p 296 1162 a(step) p 399 +1162 a(nev) o(er) p 529 1162 a(fails.) 84 1222 y(In) p +145 1222 a(a) p 186 1222 a(second) p 343 1222 a(step,) p +460 1222 a(structural) p 685 1222 a(constrain) o(ts) p +934 1222 a(are) p 1015 1222 a(enforced) p 1209 1222 a(on) p +1277 1222 a(the) p 1361 1222 a(resulting) p 1562 1222 +a(t) o(yp) q(e) p 1672 1222 a(\() p Fg(T) t(;) p 1746 +1222 a(U;) p 1801 1222 a(L) p Fk(\).) 11 1282 y(First,) p +Fg 144 1282 a(L) p Fk 195 1282 a(should) p 351 1282 a(b) q(e) p +418 1282 a(included) p 614 1282 a(in) p Fg 672 1282 a(U) p +Fk 710 1282 a(.) p 749 1282 a(Then,) p 892 1282 a(for) p +967 1282 a(all) p 1036 1282 a(constructors) p 1314 1282 +a(app) q(earing) p 1542 1282 a(in) p Fg 1600 1282 a(L) p +Fk(,) p 1664 1282 a(the) p 1749 1282 a(set) p 1826 1282 +a(of) 11 1343 y(t) o(yp) q(es) p 136 1343 a(asso) q(ciated) p +365 1343 a(with) p 472 1343 a(eac) o(h) p 578 1343 a(constructor) p +833 1343 a(is) p 878 1343 a(collapsed) p 1084 1343 a(b) o(y) p +1148 1343 a(uni\014cation.) p 1407 1343 a(This) p 1515 +1343 a(can) p 1600 1343 a(b) q(e) p 1663 1343 a(expressed) 11 +1403 y(b) o(y) p 78 1403 a(rewriting) p 287 1403 a(rules,) p +417 1403 a(where) p Fg 558 1403 a(e) p Fk 597 1403 a(is) p +646 1403 a(a) p 687 1403 a(m) o(ulti-equation) p 1015 +1403 a(and) p Fg 1109 1403 a(\036) p Fk 1155 1403 a(a) p +1195 1403 a(set) p 1271 1403 a(of) p 1327 1403 a(m) o(ultiequations) 249 +1509 y(if) p Fg 294 1509 a(L) p Fj 341 1509 a(6\032) p +Fg 393 1509 a(U) p Fk 448 1509 a(then) p 559 1509 a(\() p +Fg(T) t(;) p 633 1509 a(U;) p 688 1509 a(L) p Fk(\)) p +753 1509 a(=) p Fg 805 1509 a(e) p Fj 839 1509 a(^) p +Fg 883 1509 a(\036) p Fj 926 1509 a(\000) p 956 1509 +a(!) p 1020 1509 a(?) p Fk 249 1629 a(if) p Fg 294 1629 +a(l) p Fj 323 1629 a(2) p Fg 370 1629 a(L) p Fk 420 1629 +a(and) p Fg 515 1629 a(T) p Fk 551 1629 a(\() p Fg(l) p +Fk 586 1629 a(\)) p 617 1629 a(=) p Fj 669 1629 a(f) p +Fg(\034) p Ff 715 1636 a(1) p Fg 735 1629 a(;) p 757 +1629 a(:) p 779 1629 a(:) p 801 1629 a(:) p 822 1629 +a(;) p 844 1629 a(\034) p Fb 865 1636 a(n) p Fj 889 1629 +a(g) p Fk 930 1629 a(then) 298 1689 y(\() p Fg(T) t(;) p +372 1689 a(U;) p 427 1689 a(L) p Fk(\)) p 492 1689 a(=) p +Fg 544 1689 a(e) p Fj 577 1689 a(^) p Fg 622 1689 a(\036) p +Fj 664 1689 a(\000) p 695 1689 a(!) p Fk 759 1689 a(\() p +Fg(T) p Fj 814 1689 a(f) p Fg(l) p Fj 867 1689 a(7!) p +Fg 931 1689 a(\034) p Ff 952 1696 a(1) p Fj 972 1689 +a(g) p Fg(;) p 1019 1689 a(U;) p 1074 1689 a(L) p Fk(\)) p +1139 1689 a(=) p Fg 1191 1689 a(e) p Fj 1225 1689 a(^) p +Fg 1269 1689 a(\034) p Ff 1290 1696 a(1) p Fk 1324 1689 +a(=) p Fg 1376 1689 a(:) p 1398 1689 a(:) p 1420 1689 +a(:) p Fk 1447 1689 a(=) p Fg 1498 1689 a(\034) p Fb +1519 1696 a(n) p Fj 1554 1689 a(^) p Fg 1598 1689 a(\036) p +Fk 84 1796 a(Optionally) p 331 1796 a(one) p 425 1796 +a(can) p 519 1796 a(add) p 619 1796 a(rules) p 740 1796 +a(that) p 850 1796 a(remo) o(v) o(e) p 1022 1796 a(a) p +1067 1796 a(constructor) p Fg 1329 1796 a(l) p Fk 1366 +1796 a(from) p Fg 1486 1796 a(U) p Fk 1545 1796 a(if) p +1594 1796 a(the) p 1683 1796 a(equation) 11 1856 y(obtained) p +211 1856 a(from) p Fg 326 1856 a(T) p Fk 362 1856 a(\() p +Fg(l) p Fk 397 1856 a(\)) p 431 1856 a(has) p 518 1856 +a(no) p 586 1856 a(solution.) p 790 1856 a(Suc) o(h) p +908 1856 a(rules) p 1024 1856 a(w) o(ould) p 1167 1856 +a(b) q(e) p 1233 1856 a(sound) p 1374 1856 a(and) p 1469 +1856 a(complete.) p Fi 11 1986 a(Syn) n(tax) p 198 1986 +a(of) p 262 1986 a(t) n(yp) r(es) p Fk 11 2078 a(Thanks) p +188 2078 a(to) p 250 2078 a(the) p 336 2078 a(go) q(o) q(d) p +458 2078 a(prop) q(erties) p 689 2078 a(of) p 747 2078 +a(these) p 874 2078 a(constrain) o(ts,) p 1139 2078 a(the) p +1226 2078 a(surface) p 1392 2078 a(syn) o(tax) p 1551 +2078 a(of) p 1608 2078 a(t) o(yp) q(es) p 1740 2078 a(w) o(ould) 11 +2138 y(only) p 118 2138 a(ha) o(v) o(e) p 230 2138 a(to) p +290 2138 a(b) q(e) p 356 2138 a(sligh) o(tly) p 527 2138 +a(extended.) p Fh 590 2244 a(tag-typ) n(e) p Fk 798 2244 +a(::=) p Fh 904 2244 a(ident) p Fj 849 2304 a(j) p Fh +904 2304 a(ident) p Fe 1031 2304 a(\() p Fh(typ) n(expr-list) p +Fe(\)) p Fh 523 2365 a(typ) n(expr-list) p Fk 798 2365 +a(::=) p Fh 904 2365 a(typ) n(expr) p Fj 849 2425 a(j) p +Fh 904 2425 a(typ) n(expr) p Fe 1078 2425 a(&) p Fh 1120 +2425 a(typ) n(expr-list) p Fk 84 2531 a(Notice) p 234 +2531 a(that) p 336 2531 a(a) p 373 2531 a(0-ary) p 496 +2531 a(constructor) p 751 2531 a(and) p 842 2531 a(an) p +907 2531 a(1-ary) p 1030 2531 a(construtor) p 1262 2531 +a(are) p 1340 2531 a(con) o(tradictory) l(,) p 1648 2531 +a(and) p 1740 2531 a(w) o(ould) 11 2592 y(result) p 146 +2592 a(in) p 203 2592 a(the) p 287 2592 a(absence) p +466 2592 a(of) p 522 2592 a(this) p 617 2592 a(constructor.) 926 +2937 y(3) p eop +PStoPSsaved restore +userdict/PStoPSsaved save put +PStoPSmatrix setmatrix +595.000000 421.271378 translate +90 rotate +0.706651 dup scale +userdict/PStoPSmatrix matrix currentmatrix put +userdict/PStoPSclip{0 0 moveto + 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto + closepath}put initclip +PStoPSxform concat +4 3 bop Fi 11 168 a(Discussion) p Fk 11 261 a(Suc) o(h) p +133 261 a(a) p 179 261 a(c) o(hange) p 345 261 a(has) p +436 261 a(the) p 525 261 a(ma) s(jor) p 672 261 a(adv) m(an) o(tage) p +907 261 a(of) p 967 261 a(b) q(oth) p 1087 261 a(reco) o(v) o(ering) p +1324 261 a(principalit) o(y) p 1589 261 a(and) p 1688 +261 a(a) o(v) o(oiding) 11 321 y(unin) o(tuitiv) o(e) p +266 321 a(error) p 392 321 a(messages.) p 640 321 a(Constrain) o(ts) p +909 321 a(created) p 1087 321 a(in) p 1152 321 a(suc) o(h) p +1269 321 a(a) p 1317 321 a(w) o(a) o(y) p 1423 321 a(are) p +1512 321 a(v) o(ery) p 1626 321 a(ligh) o(t:) p 1772 +321 a(they) 11 381 y(alw) o(a) o(ys) p 165 381 a(app) q(ear) p +325 381 a(inside) p 463 381 a(a) p 502 381 a(v) m(arian) o(t) p +666 381 a(t) o(yp) q(e,) p 788 381 a(and) p 882 381 a(if) p +926 381 a(the) p 1008 381 a(v) m(arian) o(t) p 1172 381 +a(t) o(yp) q(e) p 1281 381 a(do) q(es) p 1390 381 a(not) p +1475 381 a(app) q(ear) p 1635 381 a(in) p 1691 381 a(the) p +1774 381 a(\014nal) 11 441 y(t) o(yp) q(e) p 120 441 +a(sc) o(heme,) p 301 441 a(then) p 412 441 a(the) p 496 +441 a(constrain) o(t) p 725 441 a(can) p 815 441 a(b) q(e) p +881 441 a(discarded) p 1098 441 a(safely) l(.) 84 501 +y(On) p 165 501 a(the) p 249 501 a(other) p 376 501 a(hand,) p +512 501 a(there) p 637 501 a(are) p 718 501 a(t) o(w) o(o) p +810 501 a(dra) o(wbac) o(ks.) p Fj 83 616 a(\017) p Fk +133 616 a(Some) p 259 616 a(errors) p 393 616 a(will) p +482 616 a(b) q(e) p 544 616 a(dela) o(y) o(ed) p 715 +616 a(longer) p 858 616 a(than) p 968 616 a(no) o(w,) p +1080 616 a(un) o(til) p 1191 616 a(a) p 1228 616 a(construtor) p +1460 616 a(is) p 1505 616 a(actually) p 1687 616 a(included) 133 +676 y(in) p Fg 189 676 a(L) p Fk(.) p 258 676 a(It) p +311 676 a(is) p 360 676 a(not) p 446 676 a(clear) p 563 +676 a(ho) o(w) p 665 676 a(damageable) p 930 676 a(it) p +979 676 a(is.) p Fj 83 777 a(\017) p Fk 133 777 a(While) p +272 777 a(t) o(yp) q(e) p 378 777 a(inference) p 579 +777 a(is) p 625 777 a(simple) p 774 777 a(and) p 865 +777 a(costless) p 1036 777 a(for) p 1108 777 a(this) p +1200 777 a(extension,) p 1426 777 a(simpli\014cation) p +1724 777 a(of) p 1776 777 a(con-) 133 838 y(strain) o(ts) p +310 838 a(|marking) p 551 838 a(constructors) p 830 838 +a(with) p 943 838 a(unsolv) m(able) p 1182 838 a(constrain) o(ts) p +1432 838 a(as) p 1494 838 a(absen) o(t,) p 1663 838 a(and) p +1760 838 a(elim-) 133 898 y(inating) p 300 898 a(redundan) o(t) p +536 898 a(t) o(yp) q(es) p 667 898 a(in) p 726 898 a(constrain) o(ts|) p +1025 898 a(is) p 1076 898 a(a) p 1119 898 a(bit) p 1197 +898 a(more) p 1320 898 a(exp) q(ensiv) o(e.) p 1565 898 +a(Also,) p 1691 898 a(allo) o(wing) 133 958 y(suc) o(h) p +244 958 a(constrained) p 506 958 a(t) o(yp) q(es) p 637 +958 a(inside) p 777 958 a(signatures) p 1010 958 a(w) o(ould) p +1154 958 a(mean) p 1286 958 a(ha) o(ving) p 1444 958 +a(to) p 1506 958 a(solv) o(e) p 1627 958 a(a) p 1669 +958 a(matc) o(hing) 133 1018 y(problem,) p 333 1018 a(whic) o(h) p +469 1018 a(is) p 514 1018 a(exp) q(onen) o(tial) p 772 +1018 a(in) p 825 1018 a(the) p 906 1018 a(n) o(um) o(b) q(er) p +1080 1018 a(of) p 1132 1018 a(connected) p 1356 1018 +a(constrain) o(ts) p 1600 1018 a(inside) p 1735 1018 +a(a) p 1772 1018 a(t) o(yp) q(e) 133 1078 y(sc) o(heme.) 84 +1193 y(Reasonably) p 340 1193 a(e\016cien) o(t) p 516 +1193 a(algorithms) p 754 1193 a(exist) p 866 1193 a(to) p +922 1193 a(solv) o(e) p 1038 1193 a(these) p 1159 1193 +a(problems,) p 1379 1193 a(so) p 1435 1193 a(the) p 1515 +1193 a(di\016cult) o(y) p 1715 1193 a(is) p 1760 1193 +a(more) 11 1253 y(in) p 67 1253 a(the) p 151 1253 a(increased) p +363 1253 a(complexit) o(y) p 611 1253 a(of) p 667 1253 +a(the) p 751 1253 a(t) o(yp) q(e-c) o(hec) o(k) o(er) p +1031 1253 a(than) p 1145 1253 a(in) p 1202 1253 a(run-time) p +1402 1253 a(cost.) p Fl 11 1397 a(Other) p 205 1397 a(features) p +Fk 11 1490 a(Ob) s(jectiv) o(e) p 238 1490 a(Lab) q(el) p +380 1490 a(con) o(tains) p 579 1490 a(t) o(w) o(o) p +678 1490 a(other) p 812 1490 a(features:) p 1029 1490 +a(p) q(olymorphic) p 1318 1490 a(metho) q(ds) p 1521 +1490 a(and) p 1623 1490 a(t) o(yp) q(e-driv) o(en) 11 +1550 y(access) p 153 1550 a(of) p 208 1550 a(records.) p +394 1550 a(Both) p 514 1550 a(of) p 568 1550 a(them) p +692 1550 a(use) p 775 1550 a(the) p 857 1550 a(same) p +978 1550 a(metho) q(d) p 1154 1550 a(of) p 1209 1550 +a(enforcing) p 1417 1550 a(principalit) o(y) p 1676 1550 +a(of) p 1730 1550 a(t) o(yping) 11 1610 y(through) p +191 1610 a(tracing) p 351 1610 a(user) p 450 1610 a(pro) o(vided) p +647 1610 a(t) o(yp) q(e) p 752 1610 a(information.) p +1034 1610 a(With) p 1155 1610 a(this) p 1246 1610 a(tracing,) p +1422 1610 a(their) p 1534 1610 a(implem) o(en) n(tation) 11 +1670 y(is) p 60 1670 a(v) o(ery) p 167 1670 a(easy) l(,) p +283 1670 a(but) p 373 1670 a(without) p 554 1670 a(it) p +603 1670 a(they) p 713 1670 a(lo) q(ose) p 834 1670 a(principalit) o(y) +l(.) 84 1730 y(While) p 229 1730 a(these) p 357 1730 +a(features) p 543 1730 a(pro) o(vide) p 720 1730 a(some) p +845 1730 a(comfort) p 1029 1730 a(in) p 1089 1730 a(writing) p +1260 1730 a(user) p 1366 1730 a(programs,) p 1598 1730 +a(they) p 1711 1730 a(are) p 1795 1730 a(not) 11 1791 +y(strictly) p 182 1791 a(necessary) p 403 1791 a(for) p +482 1791 a(the) p 571 1791 a(v) m(arious) p 742 1791 +a(libraries) p 934 1791 a(coming) p 1107 1791 a(with) p +1223 1791 a(O'Labl) p 1391 1791 a(\(LablTk,) p 1602 1791 +a(LablGL) p 1787 1791 a(and) 11 1851 y(LablGTK\).) 926 +2937 y(4) p eop +PStoPSsaved restore +%%Trailer +end +userdict /end-hook known{end-hook}if +%%EOF diff --git a/testlabl/objvariant.diffs b/testlabl/objvariant.diffs new file mode 100644 index 00000000..75deb24c --- /dev/null +++ b/testlabl/objvariant.diffs @@ -0,0 +1,354 @@ +? objvariants-3.09.1.diffs +? objvariants.diffs +Index: btype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/btype.ml,v +retrieving revision 1.37.4.1 +diff -u -r1.37.4.1 btype.ml +--- btype.ml 5 Dec 2005 13:18:42 -0000 1.37.4.1 ++++ btype.ml 16 Jan 2006 02:23:14 -0000 +@@ -177,7 +177,8 @@ + Tvariant row -> iter_row f row + | Tvar | Tunivar | Tsubst _ | Tconstr _ -> + Misc.may (fun (_,l) -> List.iter f l) row.row_name; +- List.iter f row.row_bound ++ List.iter f row.row_bound; ++ List.iter (fun (s,k,t) -> f t) row.row_object + | _ -> assert false + + let iter_type_expr f ty = +@@ -224,7 +225,9 @@ + | Some (path, tl) -> Some (path, List.map f tl) in + { row_fields = fields; row_more = more; + row_bound = !bound; row_fixed = row.row_fixed && fixed; +- row_closed = row.row_closed; row_name = name; } ++ row_closed = row.row_closed; row_name = name; ++ row_object = List.map (fun (s,k,t) -> (s,k,f t)) row.row_object; ++ } + + let rec copy_kind = function + Fvar{contents = Some k} -> copy_kind k +Index: ctype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v +retrieving revision 1.197.2.6 +diff -u -r1.197.2.6 ctype.ml +--- ctype.ml 15 Dec 2005 02:28:38 -0000 1.197.2.6 ++++ ctype.ml 16 Jan 2006 02:23:15 -0000 +@@ -1421,7 +1421,7 @@ + newgenty + (Tvariant + {row_fields = fields; row_closed = closed; row_more = newvar(); +- row_bound = []; row_fixed = false; row_name = None }) ++ row_bound = []; row_fixed = false; row_name = None; row_object=[]}) + + (**** Unification ****) + +@@ -1724,8 +1724,11 @@ + else None + in + let bound = row1.row_bound @ row2.row_bound in ++ let opairs, _, miss2 = associate_fields row1.row_object row2.row_object in ++ let row_object = row1.row_object @ miss2 in + let row0 = {row_fields = []; row_more = more; row_bound = bound; +- row_closed = closed; row_fixed = fixed; row_name = name} in ++ row_closed = closed; row_fixed = fixed; row_name = name; ++ row_object = row_object } in + let set_more row rest = + let rest = + if closed then +@@ -1758,6 +1761,18 @@ + raise (Unify ((mkvariant [l,f1] true, + mkvariant [l,f2] true) :: trace))) + pairs; ++ List.iter (fun (s,_,ty1,_,ty2) -> unify env ty1 ty2) opairs; ++ if row_object <> [] then begin ++ List.iter ++ (fun (l,f) -> ++ match row_field_repr f with ++ Rpresent (Some ty) -> ++ let fi = build_fields generic_level row_object (newgenvar()) in ++ unify env (newgenty (Tobject (fi, ref None))) ty ++ | Rpresent None -> raise (Unify []) ++ | _ -> ()) ++ (row_repr row1).row_fields ++ end; + with exn -> + log_type rm1; rm1.desc <- md1; log_type rm2; rm2.desc <- md2; raise exn + end +@@ -2789,7 +2804,8 @@ + let row = + { row_fields = List.map fst fields; row_more = newvar(); + row_bound = !bound; row_closed = posi; row_fixed = false; +- row_name = if c > Unchanged then None else row.row_name } ++ row_name = if c > Unchanged then None else row.row_name; ++ row_object = [] } + in + (newty (Tvariant row), Changed) + | Tobject (t1, _) -> +Index: oprint.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/oprint.ml,v +retrieving revision 1.22 +diff -u -r1.22 oprint.ml +--- oprint.ml 23 Mar 2005 03:08:37 -0000 1.22 ++++ oprint.ml 16 Jan 2006 02:23:15 -0000 +@@ -185,7 +185,7 @@ + fprintf ppf "@[<2>< %a >@]" (print_fields rest) fields + | Otyp_stuff s -> fprintf ppf "%s" s + | Otyp_var (ng, s) -> fprintf ppf "'%s%s" (if ng then "_" else "") s +- | Otyp_variant (non_gen, row_fields, closed, tags) -> ++ | Otyp_variant (non_gen, row_fields, closed, tags, obj) -> + let print_present ppf = + function + None | Some [] -> () +@@ -198,12 +198,17 @@ + ppf fields + | Ovar_name (id, tyl) -> + fprintf ppf "@[%a%a@]" print_typargs tyl print_ident id ++ and print_object ppf obj = ++ if obj <> [] then ++ fprintf ppf "@ as @[<2>< %a >@]" (print_fields (Some false)) obj + in +- fprintf ppf "%s[%s@[@[%a@]%a ]@]" (if non_gen then "_" else "") ++ fprintf ppf "%s[%s@[@[%a@]%a%a ]@]" ++ (if non_gen then "_" else "") + (if closed then if tags = None then " " else "< " + else if tags = None then "> " else "? ") + print_fields row_fields + print_present tags ++ print_object obj + | Otyp_alias _ | Otyp_poly _ | Otyp_arrow _ | Otyp_tuple _ as ty -> + fprintf ppf "@[<1>(%a)@]" print_out_type ty + | Otyp_abstract | Otyp_sum _ | Otyp_record _ | Otyp_manifest (_, _) -> () +Index: outcometree.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/outcometree.mli,v +retrieving revision 1.14 +diff -u -r1.14 outcometree.mli +--- outcometree.mli 23 Mar 2005 03:08:37 -0000 1.14 ++++ outcometree.mli 16 Jan 2006 02:23:15 -0000 +@@ -59,6 +59,7 @@ + | Otyp_var of bool * string + | Otyp_variant of + bool * out_variant * bool * (string list) option ++ * (string * out_type) list + | Otyp_poly of string list * out_type + and out_variant = + | Ovar_fields of (string * bool * out_type list) list +Index: printtyp.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/printtyp.ml,v +retrieving revision 1.139.2.2 +diff -u -r1.139.2.2 printtyp.ml +--- printtyp.ml 7 Dec 2005 23:37:27 -0000 1.139.2.2 ++++ printtyp.ml 16 Jan 2006 02:23:15 -0000 +@@ -244,7 +244,10 @@ + visited_objects := px :: !visited_objects; + match row.row_name with + | Some(p, tyl) when namable_row row -> +- List.iter (mark_loops_rec visited) tyl ++ List.iter (mark_loops_rec visited) tyl; ++ if not (static_row row) then ++ List.iter (fun (s,k,t) -> mark_loops_rec visited t) ++ row.row_object + | _ -> + iter_row (mark_loops_rec visited) {row with row_bound = []} + end +@@ -343,25 +346,27 @@ + | _ -> false) + fields in + let all_present = List.length present = List.length fields in ++ let static = row.row_closed && all_present in ++ let obj = ++ if static then [] else ++ List.map (fun (s,k,t) -> (s, tree_of_typexp sch t)) row.row_object ++ in ++ let tags = if all_present then None else Some (List.map fst present) in + begin match row.row_name with + | Some(p, tyl) when namable_row row -> + let id = tree_of_path p in + let args = tree_of_typlist sch tyl in +- if row.row_closed && all_present then ++ if static then + Otyp_constr (id, args) + else + let non_gen = is_non_gen sch px in +- let tags = +- if all_present then None else Some (List.map fst present) in + Otyp_variant (non_gen, Ovar_name(tree_of_path p, args), +- row.row_closed, tags) ++ row.row_closed, tags, obj) + | _ -> +- let non_gen = +- not (row.row_closed && all_present) && is_non_gen sch px in ++ let non_gen = not static && is_non_gen sch px in + let fields = List.map (tree_of_row_field sch) fields in +- let tags = +- if all_present then None else Some (List.map fst present) in +- Otyp_variant (non_gen, Ovar_fields fields, row.row_closed, tags) ++ Otyp_variant (non_gen, Ovar_fields fields, row.row_closed, ++ tags, obj) + end + | Tobject (fi, nm) -> + tree_of_typobject sch fi nm +Index: typecore.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v +retrieving revision 1.176.2.2 +diff -u -r1.176.2.2 typecore.ml +--- typecore.ml 11 Dec 2005 09:56:33 -0000 1.176.2.2 ++++ typecore.ml 16 Jan 2006 02:23:15 -0000 +@@ -170,7 +170,8 @@ + (* Force check of well-formedness *) + unify_pat pat.pat_env pat + (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false; +- row_bound=[]; row_fixed=false; row_name=None})); ++ row_bound=[]; row_fixed=false; row_name=None; ++ row_object=[]})); + | _ -> () + + let rec iter_pattern f p = +@@ -251,7 +252,7 @@ + let ty = may_map (build_as_type env) p' in + newty (Tvariant{row_fields=[l, Rpresent ty]; row_more=newvar(); + row_bound=[]; row_name=None; +- row_fixed=false; row_closed=false}) ++ row_fixed=false; row_closed=false; row_object=[]}) + | Tpat_record lpl -> + let lbl = fst(List.hd lpl) in + if lbl.lbl_private = Private then p.pat_type else +@@ -318,7 +319,8 @@ + ([],[]) fields in + let row = + { row_fields = List.rev fields; row_more = newvar(); row_bound = !bound; +- row_closed = false; row_fixed = false; row_name = Some (path, tyl) } ++ row_closed = false; row_fixed = false; row_name = Some (path, tyl); ++ row_object = [] } + in + let ty = newty (Tvariant row) in + let gloc = {loc with Location.loc_ghost=true} in +@@ -428,7 +430,8 @@ + row_closed = false; + row_more = newvar (); + row_fixed = false; +- row_name = None } in ++ row_name = None; ++ row_object = [] } in + rp { + pat_desc = Tpat_variant(l, arg, row); + pat_loc = sp.ppat_loc; +@@ -976,7 +979,8 @@ + row_bound = []; + row_closed = false; + row_fixed = false; +- row_name = None}); ++ row_name = None; ++ row_object = []}); + exp_env = env } + | Pexp_record(lid_sexp_list, opt_sexp) -> + let ty = newvar() in +@@ -1261,8 +1265,30 @@ + assert false + end + | _ -> +- (Texp_send(obj, Tmeth_name met), +- filter_method env met Public obj.exp_type) ++ let obj, met_ty = ++ match expand_head env obj.exp_type with ++ {desc = Tvariant _} -> ++ let exp_ty = newvar () in ++ let met_ty = filter_method env met Public exp_ty in ++ let row = ++ {row_fields=[]; row_more=newvar(); ++ row_bound=[]; row_closed=false; ++ row_fixed=false; row_name=None; ++ row_object=[met, Fpresent, met_ty]} in ++ unify_exp env obj (newty (Tvariant row)); ++ let prim = Primitive.parse_declaration 1 ["%field1"] in ++ let ty = newty(Tarrow("", obj.exp_type, exp_ty, Cok)) in ++ let vd = {val_type = ty; val_kind = Val_prim prim} in ++ let esnd = ++ {exp_desc=Texp_ident(Path.Pident(Ident.create"snd"), vd); ++ exp_loc = Location.none; exp_type = ty; exp_env = env} ++ in ++ ({obj with exp_type = exp_ty; ++ exp_desc = Texp_apply(esnd,[Some obj, Required])}, ++ met_ty) ++ | _ -> (obj, filter_method env met Public obj.exp_type) ++ in ++ (Texp_send(obj, Tmeth_name met), met_ty) + in + if !Clflags.principal then begin + end_def (); +Index: types.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/types.ml,v +retrieving revision 1.25 +diff -u -r1.25 types.ml +--- types.ml 9 Dec 2004 12:40:53 -0000 1.25 ++++ types.ml 16 Jan 2006 02:23:15 -0000 +@@ -44,7 +44,9 @@ + row_bound: type_expr list; + row_closed: bool; + row_fixed: bool; +- row_name: (Path.t * type_expr list) option } ++ row_name: (Path.t * type_expr list) option; ++ row_object: (string * field_kind * type_expr) list; ++ } + + and row_field = + Rpresent of type_expr option +Index: types.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/types.mli,v +retrieving revision 1.25 +diff -u -r1.25 types.mli +--- types.mli 9 Dec 2004 12:40:53 -0000 1.25 ++++ types.mli 16 Jan 2006 02:23:15 -0000 +@@ -43,7 +43,9 @@ + row_bound: type_expr list; + row_closed: bool; + row_fixed: bool; +- row_name: (Path.t * type_expr list) option } ++ row_name: (Path.t * type_expr list) option; ++ row_object: (string * field_kind * type_expr) list; ++ } + + and row_field = + Rpresent of type_expr option +Index: typetexp.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typetexp.ml,v +retrieving revision 1.54 +diff -u -r1.54 typetexp.ml +--- typetexp.ml 22 Jul 2005 06:42:36 -0000 1.54 ++++ typetexp.ml 16 Jan 2006 02:23:15 -0000 +@@ -215,7 +215,8 @@ + in + let row = { row_closed = true; row_fields = fields; + row_bound = !bound; row_name = Some (path, args); +- row_fixed = false; row_more = newvar () } in ++ row_fixed = false; row_more = newvar (); ++ row_object = [] } in + let static = Btype.static_row row in + let row = + if static then row else +@@ -262,7 +263,7 @@ + let mkfield l f = + newty (Tvariant {row_fields=[l,f]; row_more=newvar(); + row_bound=[]; row_closed=true; +- row_fixed=false; row_name=None}) in ++ row_fixed=false; row_name=None; row_object=[]}) in + let add_typed_field loc l f fields = + try + let f' = List.assoc l fields in +@@ -345,7 +346,7 @@ + let row = + { row_fields = List.rev fields; row_more = newvar (); + row_bound = !bound; row_closed = closed; +- row_fixed = false; row_name = !name } in ++ row_fixed = false; row_name = !name; row_object = [] } in + let static = Btype.static_row row in + let row = + if static then row else diff --git a/testlabl/objvariant.ml b/testlabl/objvariant.ml new file mode 100644 index 00000000..3233e03c --- /dev/null +++ b/testlabl/objvariant.ml @@ -0,0 +1,42 @@ +(* use with [cvs update -r objvariants typing] *) + +let f (x : [> ]) = x#m 3;; +let o = object method m x = x+2 end;; +f (`A o);; +let l = [`A o; `B(object method m x = x -2 method y = 3 end)];; +List.map f l;; +let g = function `A x -> x#m 3 | `B x -> x#y;; +List.map g l;; +fun x -> ignore (x=f); List.map x l;; +fun (x : [< `A of _ | `B of _] -> int) -> ignore (x=f); List.map x l;; + + +class cvar name = + object + method name = name + method print ppf = Format.pp_print_string ppf name + end + +type var = [`Var of cvar] + +class cint n = + object + method n = n + method print ppf = Format.pp_print_int ppf n + end + +class ['a] cadd (e1 : 'a) (e2 : 'a) = + object + constraint 'a = [> ] + method e1 = e1 + method e2 = e2 + method print ppf = Format.fprintf ppf "(%t, %t)" e1#print e2#print + end + +type 'a expr = [var | `Int of cint | `Add of 'a cadd] + +type expr1 = expr1 expr + +let print = Format.printf "%t@." + +let e1 : expr1 = `Add (new cadd (`Var (new cvar "x")) (`Int (new cint 2))) diff --git a/testlabl/printers.ml b/testlabl/printers.ml new file mode 100644 index 00000000..4a900e46 --- /dev/null +++ b/testlabl/printers.ml @@ -0,0 +1,11 @@ +(* $Id: printers.ml 5492 2003-04-03 02:16:20Z garrigue $ *) + +open Types + +let ignore_abbrevs ppf ab = + let s = match ab with + Mnil -> "Mnil" + | Mlink _ -> "Mlink _" + | Mcons _ -> "Mcons _" + in + Format.pp_print_string ppf s diff --git a/testlabl/sigsubst.ml b/testlabl/sigsubst.ml new file mode 100644 index 00000000..9b6c957b --- /dev/null +++ b/testlabl/sigsubst.ml @@ -0,0 +1,38 @@ +module type Printable = sig + type t + val print : Format.formatter -> t -> unit +end +module type Comparable = sig + type t + val compare : t -> t -> int +end +module type PrintableComparable = sig + include Printable + include Comparable with type t = t +end +module type PrintableComparable = sig + type t + include Printable with type t := t + include Comparable with type t := t +end +module type PrintableComparable = sig + include Printable + include Comparable with type t := t +end +module type ComparableInt = Comparable with type t := int + +module type S = sig type t val f : t -> t end +module type S' = S with type t := int + +module type S = sig type 'a t val map : ('a -> 'b) -> 'a t -> 'b t end +module type S1 = S with type 'a t := 'a list +module type S2 = sig + type 'a dict = (string * 'a) list + include S with type 'a t := 'a dict +end + + +module type S = + sig module T : sig type exp type arg end val f : T.exp -> T.arg end +module M = struct type exp = string type arg = int end +module type S' = S with module T := M diff --git a/testlabl/tests.ml b/testlabl/tests.ml new file mode 100644 index 00000000..4d22a4d0 --- /dev/null +++ b/testlabl/tests.ml @@ -0,0 +1,22 @@ +(* $Id: tests.ml 2745 2000-01-07 16:47:25Z doligez $ *) + +let f1 = function `a x -> x=1 | `b -> true +let f2 = function `a x -> x | `b -> true +let f3 = function `b -> true +let f x = f1 x && f2 x + +let sub s ?:pos{=0} ?:len{=String.length s - pos} () = + String.sub s pos len + +let cCAMLtoTKpack_options w = function + `After v1 -> "-after" + | `Anchor v1 -> "-anchor" + | `Before v1 -> "-before" + | `Expand v1 -> "-expand" + | `Fill v1 -> "-fill" + | `In v1 -> "-in" + | `Ipadx v1 -> "-ipadx" + | `Ipady v1 -> "-ipady" + | `Padx v1 -> "-padx" + | `Pady v1 -> "-pady" + | `Side v1 -> "-side" diff --git a/testlabl/valvirt.diffs b/testlabl/valvirt.diffs new file mode 100644 index 00000000..2cf55742 --- /dev/null +++ b/testlabl/valvirt.diffs @@ -0,0 +1,2349 @@ +Index: utils/warnings.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/utils/warnings.ml,v +retrieving revision 1.23 +diff -u -r1.23 warnings.ml +--- utils/warnings.ml 15 Sep 2005 03:09:26 -0000 1.23 ++++ utils/warnings.ml 5 Apr 2006 02:25:59 -0000 +@@ -26,7 +26,7 @@ + | Statement_type (* S *) + | Unused_match (* U *) + | Unused_pat +- | Hide_instance_variable of string (* V *) ++ | Instance_variable_override of string (* V *) + | Illegal_backslash (* X *) + | Implicit_public_methods of string list + | Unerasable_optional_argument +@@ -54,7 +54,7 @@ + | Statement_type -> 's' + | Unused_match + | Unused_pat -> 'u' +- | Hide_instance_variable _ -> 'v' ++ | Instance_variable_override _ -> 'v' + | Illegal_backslash + | Implicit_public_methods _ + | Unerasable_optional_argument +@@ -126,9 +126,9 @@ + String.concat " " + ("the following methods are overridden \ + by the inherited class:\n " :: slist) +- | Hide_instance_variable lab -> +- "this definition of an instance variable " ^ lab ^ +- " hides a previously\ndefined instance variable of the same name." ++ | Instance_variable_override lab -> ++ "the instance variable " ^ lab ^ " is overridden.\n" ^ ++ "The behaviour changed in ocaml 3.10 (previous behaviour was hiding.)" + | Partial_application -> + "this function application is partial,\n\ + maybe some arguments are missing." +Index: utils/warnings.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/utils/warnings.mli,v +retrieving revision 1.16 +diff -u -r1.16 warnings.mli +--- utils/warnings.mli 15 Sep 2005 03:09:26 -0000 1.16 ++++ utils/warnings.mli 5 Apr 2006 02:25:59 -0000 +@@ -26,7 +26,7 @@ + | Statement_type (* S *) + | Unused_match (* U *) + | Unused_pat +- | Hide_instance_variable of string (* V *) ++ | Instance_variable_override of string (* V *) + | Illegal_backslash (* X *) + | Implicit_public_methods of string list + | Unerasable_optional_argument +Index: parsing/parser.mly +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/parser.mly,v +retrieving revision 1.123 +diff -u -r1.123 parser.mly +--- parsing/parser.mly 23 Mar 2005 03:08:37 -0000 1.123 ++++ parsing/parser.mly 5 Apr 2006 02:25:59 -0000 +@@ -623,6 +623,8 @@ + { [] } + | class_fields INHERIT class_expr parent_binder + { Pcf_inher ($3, $4) :: $1 } ++ | class_fields VAL virtual_value ++ { Pcf_valvirt $3 :: $1 } + | class_fields VAL value + { Pcf_val $3 :: $1 } + | class_fields virtual_method +@@ -638,14 +640,20 @@ + AS LIDENT + { Some $2 } + | /* empty */ +- {None} ++ { None } ++; ++virtual_value: ++ MUTABLE VIRTUAL label COLON core_type ++ { $3, Mutable, $5, symbol_rloc () } ++ | VIRTUAL mutable_flag label COLON core_type ++ { $3, $2, $5, symbol_rloc () } + ; + value: +- mutable_flag label EQUAL seq_expr +- { $2, $1, $4, symbol_rloc () } +- | mutable_flag label type_constraint EQUAL seq_expr +- { $2, $1, (let (t, t') = $3 in ghexp(Pexp_constraint($5, t, t'))), +- symbol_rloc () } ++ mutable_flag label EQUAL seq_expr ++ { $2, $1, $4, symbol_rloc () } ++ | mutable_flag label type_constraint EQUAL seq_expr ++ { $2, $1, (let (t, t') = $3 in ghexp(Pexp_constraint($5, t, t'))), ++ symbol_rloc () } + ; + virtual_method: + METHOD PRIVATE VIRTUAL label COLON poly_type +@@ -711,8 +719,12 @@ + | class_sig_fields CONSTRAINT constrain { Pctf_cstr $3 :: $1 } + ; + value_type: +- mutable_flag label COLON core_type +- { $2, $1, Some $4, symbol_rloc () } ++ VIRTUAL mutable_flag label COLON core_type ++ { $3, $2, Virtual, $5, symbol_rloc () } ++ | MUTABLE virtual_flag label COLON core_type ++ { $3, Mutable, $2, $5, symbol_rloc () } ++ | label COLON core_type ++ { $1, Immutable, Concrete, $3, symbol_rloc () } + ; + method_type: + METHOD private_flag label COLON poly_type +Index: parsing/parsetree.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/parsetree.mli,v +retrieving revision 1.42 +diff -u -r1.42 parsetree.mli +--- parsing/parsetree.mli 23 Mar 2005 03:08:37 -0000 1.42 ++++ parsing/parsetree.mli 5 Apr 2006 02:25:59 -0000 +@@ -152,7 +152,7 @@ + + and class_type_field = + Pctf_inher of class_type +- | Pctf_val of (string * mutable_flag * core_type option * Location.t) ++ | Pctf_val of (string * mutable_flag * virtual_flag * core_type * Location.t) + | Pctf_virt of (string * private_flag * core_type * Location.t) + | Pctf_meth of (string * private_flag * core_type * Location.t) + | Pctf_cstr of (core_type * core_type * Location.t) +@@ -179,6 +179,7 @@ + + and class_field = + Pcf_inher of class_expr * string option ++ | Pcf_valvirt of (string * mutable_flag * core_type * Location.t) + | Pcf_val of (string * mutable_flag * expression * Location.t) + | Pcf_virt of (string * private_flag * core_type * Location.t) + | Pcf_meth of (string * private_flag * expression * Location.t) +Index: parsing/printast.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/parsing/printast.ml,v +retrieving revision 1.29 +diff -u -r1.29 printast.ml +--- parsing/printast.ml 4 Jan 2006 16:55:50 -0000 1.29 ++++ parsing/printast.ml 5 Apr 2006 02:25:59 -0000 +@@ -353,10 +353,11 @@ + | Pctf_inher (ct) -> + line i ppf "Pctf_inher\n"; + class_type i ppf ct; +- | Pctf_val (s, mf, cto, loc) -> ++ | Pctf_val (s, mf, vf, ct, loc) -> + line i ppf +- "Pctf_val \"%s\" %a %a\n" s fmt_mutable_flag mf fmt_location loc; +- option i core_type ppf cto; ++ "Pctf_val \"%s\" %a %a %a\n" s ++ fmt_mutable_flag mf fmt_virtual_flag vf fmt_location loc; ++ core_type (i+1) ppf ct; + | Pctf_virt (s, pf, ct, loc) -> + line i ppf + "Pctf_virt \"%s\" %a %a\n" s fmt_private_flag pf fmt_location loc; +@@ -428,6 +429,10 @@ + line i ppf "Pcf_inher\n"; + class_expr (i+1) ppf ce; + option (i+1) string ppf so; ++ | Pcf_valvirt (s, mf, ct, loc) -> ++ line i ppf ++ "Pcf_valvirt \"%s\" %a %a\n" s fmt_mutable_flag mf fmt_location loc; ++ core_type (i+1) ppf ct; + | Pcf_val (s, mf, e, loc) -> + line i ppf + "Pcf_val \"%s\" %a %a\n" s fmt_mutable_flag mf fmt_location loc; +Index: typing/btype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/btype.ml,v +retrieving revision 1.38 +diff -u -r1.38 btype.ml +--- typing/btype.ml 4 Jan 2006 16:55:50 -0000 1.38 ++++ typing/btype.ml 5 Apr 2006 02:25:59 -0000 +@@ -330,7 +330,7 @@ + + let unmark_class_signature sign = + unmark_type sign.cty_self; +- Vars.iter (fun l (m, t) -> unmark_type t) sign.cty_vars ++ Vars.iter (fun l (m, v, t) -> unmark_type t) sign.cty_vars + + let rec unmark_class_type = + function +Index: typing/ctype.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v +retrieving revision 1.200 +diff -u -r1.200 ctype.ml +--- typing/ctype.ml 6 Jan 2006 02:16:24 -0000 1.200 ++++ typing/ctype.ml 5 Apr 2006 02:25:59 -0000 +@@ -857,7 +857,7 @@ + Tcty_signature + {cty_self = copy sign.cty_self; + cty_vars = +- Vars.map (function (mut, ty) -> (mut, copy ty)) sign.cty_vars; ++ Vars.map (function (m, v, ty) -> (m, v, copy ty)) sign.cty_vars; + cty_concr = sign.cty_concr; + cty_inher = + List.map (fun (p,tl) -> (p, List.map copy tl)) sign.cty_inher} +@@ -2354,10 +2354,11 @@ + | CM_Val_type_mismatch of string * (type_expr * type_expr) list + | CM_Meth_type_mismatch of string * (type_expr * type_expr) list + | CM_Non_mutable_value of string ++ | CM_Non_concrete_value of string + | CM_Missing_value of string + | CM_Missing_method of string + | CM_Hide_public of string +- | CM_Hide_virtual of string ++ | CM_Hide_virtual of string * string + | CM_Public_method of string + | CM_Private_method of string + | CM_Virtual_method of string +@@ -2390,8 +2391,8 @@ + end) + pairs; + Vars.iter +- (fun lab (mut, ty) -> +- let (mut', ty') = Vars.find lab sign1.cty_vars in ++ (fun lab (mut, v, ty) -> ++ let (mut', v', ty') = Vars.find lab sign1.cty_vars in + try moregen true type_pairs env ty' ty with Unify trace -> + raise (Failure [CM_Val_type_mismatch + (lab, expand_trace env trace)])) +@@ -2437,7 +2438,7 @@ + end + in + if Concr.mem lab sign1.cty_concr then err +- else CM_Hide_virtual lab::err) ++ else CM_Hide_virtual ("method", lab) :: err) + miss1 [] + in + let missing_method = List.map (fun (m, _, _) -> m) miss2 in +@@ -2455,11 +2456,13 @@ + in + let error = + Vars.fold +- (fun lab (mut, ty) err -> ++ (fun lab (mut, vr, ty) err -> + try +- let (mut', ty') = Vars.find lab sign1.cty_vars in ++ let (mut', vr', ty') = Vars.find lab sign1.cty_vars in + if mut = Mutable && mut' <> Mutable then + CM_Non_mutable_value lab::err ++ else if vr = Concrete && vr' <> Concrete then ++ CM_Non_concrete_value lab::err + else + err + with Not_found -> +@@ -2467,6 +2470,14 @@ + sign2.cty_vars error + in + let error = ++ Vars.fold ++ (fun lab (_,vr,_) err -> ++ if vr = Virtual && not (Vars.mem lab sign2.cty_vars) then ++ CM_Hide_virtual ("instance variable", lab) :: err ++ else err) ++ sign1.cty_vars error ++ in ++ let error = + List.fold_right + (fun e l -> + if List.mem e missing_method then l else CM_Virtual_method e::l) +@@ -2516,8 +2527,8 @@ + end) + pairs; + Vars.iter +- (fun lab (mut, ty) -> +- let (mut', ty') = Vars.find lab sign1.cty_vars in ++ (fun lab (_, _, ty) -> ++ let (_, _, ty') = Vars.find lab sign1.cty_vars in + try eqtype true type_pairs subst env ty ty' with Unify trace -> + raise (Failure [CM_Val_type_mismatch + (lab, expand_trace env trace)])) +@@ -2554,7 +2565,7 @@ + end + in + if Concr.mem lab sign1.cty_concr then err +- else CM_Hide_virtual lab::err) ++ else CM_Hide_virtual ("method", lab) :: err) + miss1 [] + in + let missing_method = List.map (fun (m, _, _) -> m) miss2 in +@@ -2578,11 +2589,13 @@ + in + let error = + Vars.fold +- (fun lab (mut, ty) err -> ++ (fun lab (mut, vr, ty) err -> + try +- let (mut', ty') = Vars.find lab sign1.cty_vars in ++ let (mut', vr', ty') = Vars.find lab sign1.cty_vars in + if mut = Mutable && mut' <> Mutable then + CM_Non_mutable_value lab::err ++ else if vr = Concrete && vr' <> Concrete then ++ CM_Non_concrete_value lab::err + else + err + with Not_found -> +@@ -2590,6 +2603,14 @@ + sign2.cty_vars error + in + let error = ++ Vars.fold ++ (fun lab (_,vr,_) err -> ++ if vr = Virtual && not (Vars.mem lab sign2.cty_vars) then ++ CM_Hide_virtual ("instance variable", lab) :: err ++ else err) ++ sign1.cty_vars error ++ in ++ let error = + List.fold_right + (fun e l -> + if List.mem e missing_method then l else CM_Virtual_method e::l) +@@ -3279,7 +3300,7 @@ + let nondep_class_signature env id sign = + { cty_self = nondep_type_rec env id sign.cty_self; + cty_vars = +- Vars.map (function (m, t) -> (m, nondep_type_rec env id t)) ++ Vars.map (function (m, v, t) -> (m, v, nondep_type_rec env id t)) + sign.cty_vars; + cty_concr = sign.cty_concr; + cty_inher = +Index: typing/ctype.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.mli,v +retrieving revision 1.53 +diff -u -r1.53 ctype.mli +--- typing/ctype.mli 9 Dec 2004 12:40:53 -0000 1.53 ++++ typing/ctype.mli 5 Apr 2006 02:25:59 -0000 +@@ -170,10 +170,11 @@ + | CM_Val_type_mismatch of string * (type_expr * type_expr) list + | CM_Meth_type_mismatch of string * (type_expr * type_expr) list + | CM_Non_mutable_value of string ++ | CM_Non_concrete_value of string + | CM_Missing_value of string + | CM_Missing_method of string + | CM_Hide_public of string +- | CM_Hide_virtual of string ++ | CM_Hide_virtual of string * string + | CM_Public_method of string + | CM_Private_method of string + | CM_Virtual_method of string +Index: typing/includeclass.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/includeclass.ml,v +retrieving revision 1.7 +diff -u -r1.7 includeclass.ml +--- typing/includeclass.ml 6 Mar 2000 22:11:57 -0000 1.7 ++++ typing/includeclass.ml 5 Apr 2006 02:25:59 -0000 +@@ -78,14 +78,17 @@ + | CM_Non_mutable_value lab -> + fprintf ppf + "@[The non-mutable instance variable %s cannot become mutable@]" lab ++ | CM_Non_concrete_value lab -> ++ fprintf ppf ++ "@[The virtual instance variable %s cannot become concrete@]" lab + | CM_Missing_value lab -> + fprintf ppf "@[The first class type has no instance variable %s@]" lab + | CM_Missing_method lab -> + fprintf ppf "@[The first class type has no method %s@]" lab + | CM_Hide_public lab -> + fprintf ppf "@[The public method %s cannot be hidden@]" lab +- | CM_Hide_virtual lab -> +- fprintf ppf "@[The virtual method %s cannot be hidden@]" lab ++ | CM_Hide_virtual (k, lab) -> ++ fprintf ppf "@[The virtual %s %s cannot be hidden@]" k lab + | CM_Public_method lab -> + fprintf ppf "@[The public method %s cannot become private" lab + | CM_Virtual_method lab -> +Index: typing/oprint.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/oprint.ml,v +retrieving revision 1.22 +diff -u -r1.22 oprint.ml +--- typing/oprint.ml 23 Mar 2005 03:08:37 -0000 1.22 ++++ typing/oprint.ml 5 Apr 2006 02:25:59 -0000 +@@ -291,8 +291,10 @@ + fprintf ppf "@[<2>method %s%s%s :@ %a@]" + (if priv then "private " else "") (if virt then "virtual " else "") + name !out_type ty +- | Ocsg_value (name, mut, ty) -> +- fprintf ppf "@[<2>val %s%s :@ %a@]" (if mut then "mutable " else "") ++ | Ocsg_value (name, mut, vr, ty) -> ++ fprintf ppf "@[<2>val %s%s%s :@ %a@]" ++ (if mut then "mutable " else "") ++ (if vr then "virtual " else "") + name !out_type ty + + let out_class_type = ref print_out_class_type +Index: typing/outcometree.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/outcometree.mli,v +retrieving revision 1.14 +diff -u -r1.14 outcometree.mli +--- typing/outcometree.mli 23 Mar 2005 03:08:37 -0000 1.14 ++++ typing/outcometree.mli 5 Apr 2006 02:25:59 -0000 +@@ -71,7 +71,7 @@ + and out_class_sig_item = + | Ocsg_constraint of out_type * out_type + | Ocsg_method of string * bool * bool * out_type +- | Ocsg_value of string * bool * out_type ++ | Ocsg_value of string * bool * bool * out_type + + type out_module_type = + | Omty_abstract +Index: typing/printtyp.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/printtyp.ml,v +retrieving revision 1.140 +diff -u -r1.140 printtyp.ml +--- typing/printtyp.ml 4 Jan 2006 16:55:50 -0000 1.140 ++++ typing/printtyp.ml 5 Apr 2006 02:26:00 -0000 +@@ -650,7 +650,7 @@ + Ctype.flatten_fields (Ctype.object_fields sign.cty_self) + in + List.iter (fun met -> mark_loops (method_type met)) fields; +- Vars.iter (fun _ (_, ty) -> mark_loops ty) sign.cty_vars ++ Vars.iter (fun _ (_, _, ty) -> mark_loops ty) sign.cty_vars + | Tcty_fun (_, ty, cty) -> + mark_loops ty; + prepare_class_type params cty +@@ -682,13 +682,15 @@ + csil (tree_of_constraints params) + in + let all_vars = +- Vars.fold (fun l (m, t) all -> (l, m, t) :: all) sign.cty_vars [] in ++ Vars.fold (fun l (m, v, t) all -> (l, m, v, t) :: all) sign.cty_vars [] ++ in + (* Consequence of PR#3607: order of Map.fold has changed! *) + let all_vars = List.rev all_vars in + let csil = + List.fold_left +- (fun csil (l, m, t) -> +- Ocsg_value (l, m = Mutable, tree_of_typexp sch t) :: csil) ++ (fun csil (l, m, v, t) -> ++ Ocsg_value (l, m = Mutable, v = Virtual, tree_of_typexp sch t) ++ :: csil) + csil all_vars + in + let csil = +@@ -763,7 +765,9 @@ + List.exists + (fun (lab, _, ty) -> + not (lab = dummy_method || Concr.mem lab sign.cty_concr)) +- fields in ++ fields ++ || Vars.fold (fun _ (_,vr,_) b -> vr = Virtual || b) sign.cty_vars false ++ in + + Osig_class_type + (virt, Ident.name id, +Index: typing/subst.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/subst.ml,v +retrieving revision 1.49 +diff -u -r1.49 subst.ml +--- typing/subst.ml 4 Jan 2006 16:55:50 -0000 1.49 ++++ typing/subst.ml 5 Apr 2006 02:26:00 -0000 +@@ -178,7 +178,8 @@ + + let class_signature s sign = + { cty_self = typexp s sign.cty_self; +- cty_vars = Vars.map (function (m, t) -> (m, typexp s t)) sign.cty_vars; ++ cty_vars = ++ Vars.map (function (m, v, t) -> (m, v, typexp s t)) sign.cty_vars; + cty_concr = sign.cty_concr; + cty_inher = + List.map (fun (p, tl) -> (type_path s p, List.map (typexp s) tl)) +Index: typing/typeclass.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typeclass.ml,v +retrieving revision 1.85 +diff -u -r1.85 typeclass.ml +--- typing/typeclass.ml 22 Jul 2005 06:42:36 -0000 1.85 ++++ typing/typeclass.ml 5 Apr 2006 02:26:00 -0000 +@@ -24,7 +24,7 @@ + + type error = + Unconsistent_constraint of (type_expr * type_expr) list +- | Method_type_mismatch of string * (type_expr * type_expr) list ++ | Field_type_mismatch of string * string * (type_expr * type_expr) list + | Structure_expected of class_type + | Cannot_apply of class_type + | Apply_wrong_label of label +@@ -36,7 +36,7 @@ + | Unbound_class_type_2 of Longident.t + | Abbrev_type_clash of type_expr * type_expr * type_expr + | Constructor_type_mismatch of string * (type_expr * type_expr) list +- | Virtual_class of bool * string list ++ | Virtual_class of bool * string list * string list + | Parameter_arity_mismatch of Longident.t * int * int + | Parameter_mismatch of (type_expr * type_expr) list + | Bad_parameters of Ident.t * type_expr * type_expr +@@ -49,6 +49,7 @@ + | Non_collapsable_conjunction of + Ident.t * Types.class_declaration * (type_expr * type_expr) list + | Final_self_clash of (type_expr * type_expr) list ++ | Mutability_mismatch of string * mutable_flag + + exception Error of Location.t * error + +@@ -90,7 +91,7 @@ + generalize_class_type cty + | Tcty_signature {cty_self = sty; cty_vars = vars; cty_inher = inher} -> + Ctype.generalize sty; +- Vars.iter (fun _ (_, ty) -> Ctype.generalize ty) vars; ++ Vars.iter (fun _ (_, _, ty) -> Ctype.generalize ty) vars; + List.iter (fun (_,tl) -> List.iter Ctype.generalize tl) inher + | Tcty_fun (_, ty, cty) -> + Ctype.generalize ty; +@@ -152,7 +153,7 @@ + | Tcty_signature sign -> + Ctype.closed_schema sign.cty_self + && +- Vars.fold (fun _ (_, ty) cc -> Ctype.closed_schema ty && cc) ++ Vars.fold (fun _ (_, _, ty) cc -> Ctype.closed_schema ty && cc) + sign.cty_vars + true + | Tcty_fun (_, ty, cty) -> +@@ -172,7 +173,7 @@ + limited_generalize rv cty + | Tcty_signature sign -> + Ctype.limited_generalize rv sign.cty_self; +- Vars.iter (fun _ (_, ty) -> Ctype.limited_generalize rv ty) ++ Vars.iter (fun _ (_, _, ty) -> Ctype.limited_generalize rv ty) + sign.cty_vars; + List.iter (fun (_, tl) -> List.iter (Ctype.limited_generalize rv) tl) + sign.cty_inher +@@ -201,11 +202,25 @@ + Env.add_value id {val_type = ty; val_kind = Val_unbound} par_env) + + (* Enter an instance variable in the environment *) +-let enter_val cl_num vars lab mut ty val_env met_env par_env = +- let (id, val_env, met_env, par_env) as result = +- enter_met_env lab (Val_ivar (mut, cl_num)) ty val_env met_env par_env ++let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc = ++ let (id, virt) = ++ try ++ let (id, mut', virt', ty') = Vars.find lab !vars in ++ if mut' <> mut then raise (Error(loc, Mutability_mismatch(lab, mut))); ++ Ctype.unify val_env (Ctype.instance ty) (Ctype.instance ty'); ++ (if not inh then Some id else None), ++ (if virt' = Concrete then virt' else virt) ++ with ++ Ctype.Unify tr -> ++ raise (Error(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) ++ | None -> ++ enter_met_env lab (Val_ivar (mut, cl_num)) ty val_env met_env par_env + in +- vars := Vars.add lab (id, mut, ty) !vars; ++ vars := Vars.add lab (id, mut, virt, ty) !vars; + result + + let inheritance self_type env concr_meths warn_meths loc parent = +@@ -218,7 +233,7 @@ + with Ctype.Unify trace -> + match trace with + _::_::_::({desc = Tfield(n, _, _, _)}, _)::rem -> +- raise(Error(loc, Method_type_mismatch (n, rem))) ++ raise(Error(loc, Field_type_mismatch ("method", n, rem))) + | _ -> + assert false + end; +@@ -243,7 +258,7 @@ + in + let ty = transl_simple_type val_env false sty in + try Ctype.unify val_env ty ty' with Ctype.Unify trace -> +- raise(Error(loc, Method_type_mismatch (lab, trace))) ++ raise(Error(loc, Field_type_mismatch ("method", lab, trace))) + + let delayed_meth_specs = ref [] + +@@ -253,7 +268,7 @@ + in + let unif ty = + try Ctype.unify val_env ty ty' with Ctype.Unify trace -> +- raise(Error(loc, Method_type_mismatch (lab, trace))) ++ raise(Error(loc, Field_type_mismatch ("method", lab, trace))) + in + match sty.ptyp_desc, priv with + Ptyp_poly ([],sty), Public -> +@@ -279,6 +294,15 @@ + + (*******************************) + ++let add_val env loc lab (mut, virt, ty) val_sig = ++ let virt = ++ try ++ let (mut', virt', ty') = Vars.find lab val_sig in ++ if virt' = Concrete then virt' else virt ++ with Not_found -> virt ++ in ++ Vars.add lab (mut, virt, ty) val_sig ++ + let rec class_type_field env self_type meths (val_sig, concr_meths, inher) = + function + Pctf_inher sparent -> +@@ -293,25 +317,12 @@ + parent + in + let val_sig = +- Vars.fold +- (fun lab (mut, ty) val_sig -> Vars.add lab (mut, ty) val_sig) +- cl_sig.cty_vars val_sig +- in ++ Vars.fold (add_val env sparent.pcty_loc) cl_sig.cty_vars val_sig in + (val_sig, concr_meths, inher) + +- | Pctf_val (lab, mut, sty_opt, loc) -> +- let (mut, ty) = +- match sty_opt with +- None -> +- let (mut', ty) = +- try Vars.find lab val_sig with Not_found -> +- raise(Error(loc, Unbound_val lab)) +- in +- (if mut = Mutable then mut' else Immutable), ty +- | Some sty -> +- mut, transl_simple_type env false sty +- in +- (Vars.add lab (mut, ty) val_sig, concr_meths, inher) ++ | Pctf_val (lab, mut, virt, sty, loc) -> ++ let ty = transl_simple_type env false sty in ++ (add_val env loc lab (mut, virt, ty) val_sig, concr_meths, inher) + + | Pctf_virt (lab, priv, sty, loc) -> + declare_method env meths self_type lab priv sty loc; +@@ -397,7 +408,7 @@ + + let rec class_field cl_num self_type meths vars + (val_env, met_env, par_env, fields, concr_meths, warn_meths, +- inh_vals, inher) = ++ warn_vals, inher) = + function + Pcf_inher (sparent, super) -> + let parent = class_expr cl_num val_env par_env sparent in +@@ -411,18 +422,23 @@ + parent.cl_type + in + (* Variables *) +- let (val_env, met_env, par_env, inh_vars, inh_vals) = ++ let (val_env, met_env, par_env, inh_vars, warn_vals) = + Vars.fold +- (fun lab (mut, ty) (val_env, met_env, par_env, inh_vars, inh_vals) -> ++ (fun lab info (val_env, met_env, par_env, inh_vars, warn_vals) -> ++ let mut, vr, ty = info in + let (id, val_env, met_env, par_env) = +- enter_val cl_num vars lab mut ty 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 + in +- if StringSet.mem lab inh_vals then +- Location.prerr_warning sparent.pcl_loc +- (Warnings.Hide_instance_variable lab); +- (val_env, met_env, par_env, (lab, id) :: inh_vars, +- StringSet.add lab inh_vals)) +- cl_sig.cty_vars (val_env, met_env, par_env, [], inh_vals) ++ let warn_vals = ++ if vr = Virtual then warn_vals else ++ if StringSet.mem lab warn_vals then ++ (Location.prerr_warning sparent.pcl_loc ++ (Warnings.Instance_variable_override lab); warn_vals) ++ else StringSet.add lab warn_vals ++ in ++ (val_env, met_env, par_env, (lab, id) :: inh_vars, warn_vals)) ++ cl_sig.cty_vars (val_env, met_env, par_env, [], warn_vals) + in + (* Inherited concrete methods *) + let inh_meths = +@@ -443,11 +459,26 @@ + in + (val_env, met_env, par_env, + lazy(Cf_inher (parent, inh_vars, inh_meths))::fields, +- concr_meths, warn_meths, inh_vals, inher) ++ concr_meths, warn_meths, warn_vals, inher) ++ ++ | Pcf_valvirt (lab, mut, styp, loc) -> ++ if !Clflags.principal then Ctype.begin_def (); ++ let ty = Typetexp.transl_simple_type val_env false styp in ++ if !Clflags.principal then begin ++ Ctype.end_def (); ++ Ctype.generalize_structure ty ++ end; ++ let (id, val_env, met_env', par_env) = ++ enter_val cl_num vars false lab mut Virtual ty ++ val_env met_env par_env loc ++ in ++ (val_env, met_env', par_env, ++ lazy(Cf_val (lab, id, None, met_env' == met_env)) :: fields, ++ concr_meths, warn_meths, StringSet.remove lab warn_vals, inher) + + | Pcf_val (lab, mut, sexp, loc) -> +- if StringSet.mem lab inh_vals then +- Location.prerr_warning loc (Warnings.Hide_instance_variable lab); ++ if StringSet.mem lab warn_vals then ++ Location.prerr_warning loc (Warnings.Instance_variable_override lab); + if !Clflags.principal then Ctype.begin_def (); + let exp = + try type_exp val_env sexp with Ctype.Unify [(ty, _)] -> +@@ -457,17 +488,19 @@ + Ctype.end_def (); + Ctype.generalize_structure exp.exp_type + end; +- let (id, val_env, met_env, par_env) = +- enter_val cl_num vars lab mut exp.exp_type val_env met_env par_env +- in +- (val_env, met_env, par_env, lazy(Cf_val (lab, id, exp)) :: fields, +- concr_meths, warn_meths, inh_vals, inher) ++ let (id, val_env, met_env', par_env) = ++ enter_val cl_num vars false lab mut Concrete exp.exp_type ++ val_env met_env par_env loc ++ in ++ (val_env, met_env', par_env, ++ lazy(Cf_val (lab, id, Some exp, met_env' == met_env)) :: fields, ++ concr_meths, warn_meths, StringSet.add lab warn_vals, inher) + + | Pcf_virt (lab, priv, sty, loc) -> + virtual_method val_env meths self_type lab priv sty loc; + let warn_meths = Concr.remove lab warn_meths in + (val_env, met_env, par_env, fields, concr_meths, warn_meths, +- inh_vals, inher) ++ warn_vals, inher) + + | Pcf_meth (lab, priv, expr, loc) -> + let (_, ty) = +@@ -493,7 +526,7 @@ + end + | _ -> assert false + with Ctype.Unify trace -> +- raise(Error(loc, Method_type_mismatch (lab, trace))) ++ raise(Error(loc, Field_type_mismatch ("method", lab, trace))) + end; + let meth_expr = make_method cl_num expr in + (* backup variables for Pexp_override *) +@@ -510,12 +543,12 @@ + Cf_meth (lab, texp) + end in + (val_env, met_env, par_env, field::fields, +- Concr.add lab concr_meths, Concr.add lab warn_meths, inh_vals, inher) ++ Concr.add lab concr_meths, Concr.add lab warn_meths, warn_vals, inher) + + | Pcf_cstr (sty, sty', loc) -> + type_constraint val_env sty sty' loc; + (val_env, met_env, par_env, fields, concr_meths, warn_meths, +- inh_vals, inher) ++ warn_vals, inher) + + | Pcf_let (rec_flag, sdefs, loc) -> + let (defs, val_env) = +@@ -545,7 +578,7 @@ + ([], met_env, par_env) + in + (val_env, met_env, par_env, lazy(Cf_let(rec_flag, defs, vals))::fields, +- concr_meths, warn_meths, inh_vals, inher) ++ concr_meths, warn_meths, warn_vals, inher) + + | Pcf_init expr -> + let expr = make_method cl_num expr in +@@ -562,7 +595,7 @@ + Cf_init texp + end in + (val_env, met_env, par_env, field::fields, +- concr_meths, warn_meths, inh_vals, inher) ++ concr_meths, warn_meths, warn_vals, inher) + + and class_structure cl_num final val_env met_env loc (spat, str) = + (* Environment for substructures *) +@@ -616,7 +649,7 @@ + Ctype.unify val_env self_type (Ctype.newvar ()); + let sign = + {cty_self = public_self; +- cty_vars = Vars.map (function (id, mut, ty) -> (mut, ty)) !vars; ++ cty_vars = Vars.map (fun (id, mut, vr, ty) -> (mut, vr, ty)) !vars; + cty_concr = concr_meths; + cty_inher = inher} in + let methods = get_methods self_type in +@@ -628,7 +661,11 @@ + be modified after this point *) + Ctype.close_object self_type; + let mets = virtual_methods {sign with cty_self = self_type} in +- if mets <> [] then raise(Error(loc, Virtual_class(true, mets))); ++ let vals = ++ Vars.fold ++ (fun name (mut, vr, ty) l -> if vr = Virtual then name :: l else l) ++ sign.cty_vars [] in ++ if mets <> [] then raise(Error(loc, Virtual_class(true, mets, vals))); + let self_methods = + List.fold_right + (fun (lab,kind,ty) rem -> +@@ -1135,9 +1172,14 @@ + in + + if cl.pci_virt = Concrete then begin +- match virtual_methods (Ctype.signature_of_class_type typ) with +- [] -> () +- | mets -> raise(Error(cl.pci_loc, Virtual_class(define_class, mets))) ++ let sign = Ctype.signature_of_class_type typ in ++ let mets = virtual_methods sign in ++ let vals = ++ Vars.fold ++ (fun name (mut, vr, ty) l -> if vr = Virtual then name :: l else l) ++ sign.cty_vars [] in ++ if mets <> [] || vals <> [] then ++ raise(Error(cl.pci_loc, Virtual_class(true, mets, vals))); + end; + + (* Misc. *) +@@ -1400,10 +1442,10 @@ + Printtyp.report_unification_error ppf trace + (fun ppf -> fprintf ppf "Type") + (fun ppf -> fprintf ppf "is not compatible with type") +- | Method_type_mismatch (m, trace) -> ++ | Field_type_mismatch (k, m, trace) -> + Printtyp.report_unification_error ppf trace + (function ppf -> +- fprintf ppf "The method %s@ has type" m) ++ fprintf ppf "The %s %s@ has type" k m) + (function ppf -> + fprintf ppf "but is expected to have type") + | Structure_expected clty -> +@@ -1451,15 +1493,20 @@ + fprintf ppf "The expression \"new %s\" has type" c) + (function ppf -> + fprintf ppf "but is used with type") +- | Virtual_class (cl, mets) -> ++ | Virtual_class (cl, mets, vals) -> + let print_mets ppf mets = + List.iter (function met -> fprintf ppf "@ %s" met) mets in + let cl_mark = if cl then "" else " type" in ++ let missings = ++ match mets, vals with ++ [], _ -> "variables" ++ | _, [] -> "methods" ++ | _ -> "methods and variables" ++ in + fprintf ppf +- "@[This class%s should be virtual@ \ +- @[<2>The following methods are undefined :%a@] +- @]" +- cl_mark print_mets mets ++ "@[This class%s should be virtual.@ \ ++ @[<2>The following %s are undefined :%a@]@]" ++ cl_mark missings print_mets (mets @ vals) + | Parameter_arity_mismatch(lid, expected, provided) -> + fprintf ppf + "@[The class constructor %a@ expects %i type argument(s),@ \ +@@ -1532,3 +1579,10 @@ + fprintf ppf "This object is expected to have type") + (function ppf -> + fprintf ppf "but has actually type") ++ | Mutability_mismatch (lab, mut) -> ++ let mut1, mut2 = ++ if mut = Immutable then "mutable", "immutable" ++ else "immutable", "mutable" in ++ fprintf ppf ++ "@[The instance variable is %s,@ it cannot be redefined as %s@]" ++ mut1 mut2 +Index: typing/typeclass.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typeclass.mli,v +retrieving revision 1.18 +diff -u -r1.18 typeclass.mli +--- typing/typeclass.mli 1 Dec 2003 00:32:11 -0000 1.18 ++++ typing/typeclass.mli 5 Apr 2006 02:26:00 -0000 +@@ -49,7 +49,7 @@ + + type error = + Unconsistent_constraint of (type_expr * type_expr) list +- | Method_type_mismatch of string * (type_expr * type_expr) list ++ | Field_type_mismatch of string * string * (type_expr * type_expr) list + | Structure_expected of class_type + | Cannot_apply of class_type + | Apply_wrong_label of label +@@ -61,7 +61,7 @@ + | Unbound_class_type_2 of Longident.t + | Abbrev_type_clash of type_expr * type_expr * type_expr + | Constructor_type_mismatch of string * (type_expr * type_expr) list +- | Virtual_class of bool * string list ++ | Virtual_class of bool * string list * string list + | Parameter_arity_mismatch of Longident.t * int * int + | Parameter_mismatch of (type_expr * type_expr) list + | Bad_parameters of Ident.t * type_expr * type_expr +@@ -74,6 +74,7 @@ + | Non_collapsable_conjunction of + Ident.t * Types.class_declaration * (type_expr * type_expr) list + | Final_self_clash of (type_expr * type_expr) list ++ | Mutability_mismatch of string * mutable_flag + + exception Error of Location.t * error + +Index: typing/typecore.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v +retrieving revision 1.178 +diff -u -r1.178 typecore.ml +--- typing/typecore.ml 6 Jan 2006 02:25:37 -0000 1.178 ++++ typing/typecore.ml 5 Apr 2006 02:26:00 -0000 +@@ -611,11 +611,11 @@ + List.for_all + (function + Cf_meth _ -> true +- | Cf_val (_,_,e) -> incr count; is_nonexpansive e ++ | Cf_val (_,_,e,_) -> incr count; is_nonexpansive_opt e + | Cf_init e -> is_nonexpansive e + | Cf_inher _ | Cf_let _ -> false) + fields && +- Vars.fold (fun _ (mut,_) b -> decr count; b && mut = Immutable) ++ Vars.fold (fun _ (mut,_,_) b -> decr count; b && mut = Immutable) + vars true && + !count = 0 + | _ -> false +@@ -1356,7 +1356,7 @@ + (path_self, _) -> + let type_override (lab, snewval) = + begin try +- let (id, _, ty) = Vars.find lab !vars in ++ let (id, _, _, ty) = Vars.find lab !vars in + (Path.Pident id, type_expect env snewval (instance ty)) + with + Not_found -> +Index: typing/typecore.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.mli,v +retrieving revision 1.37 +diff -u -r1.37 typecore.mli +--- typing/typecore.mli 4 Mar 2005 14:51:31 -0000 1.37 ++++ typing/typecore.mli 5 Apr 2006 02:26:00 -0000 +@@ -38,7 +38,8 @@ + string -> type_expr -> Env.t -> Env.t -> Env.t -> Parsetree.pattern -> + Typedtree.pattern * + (Ident.t * type_expr) Meths.t ref * +- (Ident.t * Asttypes.mutable_flag * type_expr) Vars.t ref * ++ (Ident.t * Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) ++ Vars.t ref * + Env.t * Env.t * Env.t + val type_expect: + ?in_function:(Location.t * type_expr) -> +Index: typing/typedtree.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typedtree.ml,v +retrieving revision 1.36 +diff -u -r1.36 typedtree.ml +--- typing/typedtree.ml 25 Nov 2003 09:20:43 -0000 1.36 ++++ typing/typedtree.ml 5 Apr 2006 02:26:00 -0000 +@@ -106,7 +106,7 @@ + + and class_field = + Cf_inher of class_expr * (string * Ident.t) list * (string * Ident.t) list +- | Cf_val of string * Ident.t * expression ++ | Cf_val of string * Ident.t * expression option * bool + | Cf_meth of string * expression + | Cf_let of rec_flag * (pattern * expression) list * + (Ident.t * expression) list +@@ -140,7 +140,8 @@ + | Tstr_recmodule of (Ident.t * module_expr) list + | Tstr_modtype of Ident.t * module_type + | Tstr_open of Path.t +- | Tstr_class of (Ident.t * int * string list * class_expr) list ++ | Tstr_class of ++ (Ident.t * int * string list * class_expr * virtual_flag) list + | Tstr_cltype of (Ident.t * cltype_declaration) list + | Tstr_include of module_expr * Ident.t list + +Index: typing/typedtree.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typedtree.mli,v +retrieving revision 1.34 +diff -u -r1.34 typedtree.mli +--- typing/typedtree.mli 25 Nov 2003 09:20:43 -0000 1.34 ++++ typing/typedtree.mli 5 Apr 2006 02:26:00 -0000 +@@ -107,7 +107,8 @@ + and class_field = + Cf_inher of class_expr * (string * Ident.t) list * (string * Ident.t) list + (* Inherited instance variables and concrete methods *) +- | Cf_val of string * Ident.t * expression ++ | Cf_val of string * Ident.t * expression option * bool ++ (* None = virtual, true = override *) + | Cf_meth of string * expression + | Cf_let of rec_flag * (pattern * expression) list * + (Ident.t * expression) list +@@ -141,7 +142,8 @@ + | Tstr_recmodule of (Ident.t * module_expr) list + | Tstr_modtype of Ident.t * module_type + | Tstr_open of Path.t +- | Tstr_class of (Ident.t * int * string list * class_expr) list ++ | Tstr_class of ++ (Ident.t * int * string list * class_expr * virtual_flag) list + | Tstr_cltype of (Ident.t * cltype_declaration) list + | Tstr_include of module_expr * Ident.t list + +Index: typing/typemod.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/typemod.ml,v +retrieving revision 1.73 +diff -u -r1.73 typemod.ml +--- typing/typemod.ml 8 Aug 2005 09:41:51 -0000 1.73 ++++ typing/typemod.ml 5 Apr 2006 02:26:00 -0000 +@@ -17,6 +17,7 @@ + open Misc + open Longident + open Path ++open Asttypes + open Parsetree + open Types + open Typedtree +@@ -667,8 +668,9 @@ + let (classes, new_env) = Typeclass.class_declarations env cl in + let (str_rem, sig_rem, final_env) = type_struct new_env srem in + (Tstr_class +- (List.map (fun (i, _,_,_,_,_,_,_, s, m, c) -> +- (i, s, m, c)) classes) :: ++ (List.map (fun (i, d, _,_,_,_,_,_, s, m, c) -> ++ let vf = if d.cty_new = None then Virtual else Concrete in ++ (i, s, m, c, vf)) classes) :: + Tstr_cltype + (List.map (fun (_,_, i, d, _,_,_,_,_,_,_) -> (i, d)) classes) :: + Tstr_type +Index: typing/types.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/types.ml,v +retrieving revision 1.25 +diff -u -r1.25 types.ml +--- typing/types.ml 9 Dec 2004 12:40:53 -0000 1.25 ++++ typing/types.ml 5 Apr 2006 02:26:00 -0000 +@@ -90,7 +90,8 @@ + | Val_prim of Primitive.description (* Primitive *) + | Val_ivar of mutable_flag * string (* Instance variable (mutable ?) *) + | Val_self of (Ident.t * type_expr) Meths.t ref * +- (Ident.t * Asttypes.mutable_flag * type_expr) Vars.t ref * ++ (Ident.t * Asttypes.mutable_flag * ++ Asttypes.virtual_flag * type_expr) Vars.t ref * + string * type_expr + (* Self *) + | Val_anc of (string * Ident.t) list * string +@@ -156,7 +157,8 @@ + + and class_signature = + { cty_self: type_expr; +- cty_vars: (Asttypes.mutable_flag * type_expr) Vars.t; ++ cty_vars: ++ (Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) Vars.t; + cty_concr: Concr.t; + cty_inher: (Path.t * type_expr list) list } + +Index: typing/types.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/types.mli,v +retrieving revision 1.25 +diff -u -r1.25 types.mli +--- typing/types.mli 9 Dec 2004 12:40:53 -0000 1.25 ++++ typing/types.mli 5 Apr 2006 02:26:00 -0000 +@@ -91,7 +91,8 @@ + | Val_prim of Primitive.description (* Primitive *) + | Val_ivar of mutable_flag * string (* Instance variable (mutable ?) *) + | Val_self of (Ident.t * type_expr) Meths.t ref * +- (Ident.t * Asttypes.mutable_flag * type_expr) Vars.t ref * ++ (Ident.t * Asttypes.mutable_flag * ++ Asttypes.virtual_flag * type_expr) Vars.t ref * + string * type_expr + (* Self *) + | Val_anc of (string * Ident.t) list * string +@@ -158,7 +159,8 @@ + + and class_signature = + { cty_self: type_expr; +- cty_vars: (Asttypes.mutable_flag * type_expr) Vars.t; ++ cty_vars: ++ (Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) Vars.t; + cty_concr: Concr.t; + cty_inher: (Path.t * type_expr list) list } + +Index: typing/unused_var.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/typing/unused_var.ml,v +retrieving revision 1.5 +diff -u -r1.5 unused_var.ml +--- typing/unused_var.ml 4 Jan 2006 16:55:50 -0000 1.5 ++++ typing/unused_var.ml 5 Apr 2006 02:26:00 -0000 +@@ -245,7 +245,7 @@ + match cf with + | Pcf_inher (ce, _) -> class_expr ppf tbl ce; + | Pcf_val (_, _, e, _) -> expression ppf tbl e; +- | Pcf_virt _ -> () ++ | Pcf_virt _ | Pcf_valvirt _ -> () + | Pcf_meth (_, _, e, _) -> expression ppf tbl e; + | Pcf_cstr _ -> () + | Pcf_let (recflag, pel, _) -> let_pel ppf tbl recflag pel None; +Index: bytecomp/translclass.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translclass.ml,v +retrieving revision 1.38 +diff -u -r1.38 translclass.ml +--- bytecomp/translclass.ml 13 Aug 2005 20:59:37 -0000 1.38 ++++ bytecomp/translclass.ml 5 Apr 2006 02:26:00 -0000 +@@ -133,10 +133,10 @@ + (fun _ -> lambda_unit) cl + in + (inh_init, lsequence obj_init' obj_init, true) +- | Cf_val (_, id, exp) -> ++ | Cf_val (_, id, Some exp, _) -> + (inh_init, lsequence (set_inst_var obj id exp) obj_init, + has_init) +- | Cf_meth _ -> ++ | Cf_meth _ | Cf_val _ -> + (inh_init, obj_init, has_init) + | Cf_init _ -> + (inh_init, obj_init, true) +@@ -213,27 +213,17 @@ + if len < 2 && nvals = 0 then Meths.fold (bind_method tbl) meths cl_init else + if len = 0 && nvals < 2 then transl_vals tbl true vals cl_init else + let ids = Ident.create "ids" in +- let i = ref len in +- let getter, names, cl_init = +- match vals with [] -> "get_method_labels", [], cl_init +- | (_,id0)::vals' -> +- incr i; +- let i = ref (List.length vals) in +- "new_methods_variables", +- [transl_meth_list (List.map fst vals)], +- Llet(Strict, id0, lfield ids 0, +- List.fold_right +- (fun (name,id) rem -> +- decr i; +- Llet(Alias, id, Lprim(Poffsetint !i, [Lvar id0]), rem)) +- vals' cl_init) ++ let i = ref (len + nvals) in ++ let getter, names = ++ if nvals = 0 then "get_method_labels", [] else ++ "new_methods_variables", [transl_meth_list (List.map fst vals)] + in + Llet(StrictOpt, ids, + Lapply (oo_prim getter, + [Lvar tbl; transl_meth_list (List.map fst methl)] @ names), + List.fold_right + (fun (lab,id) lam -> decr i; Llet(StrictOpt, id, lfield ids !i, lam)) +- methl cl_init) ++ (methl @ vals) cl_init) + + let output_methods tbl methods lam = + match methods with +@@ -283,8 +273,9 @@ + (vals, meths_super cla str.cl_meths meths) + inh_init cl_init msubst top cl in + (inh_init, cl_init, [], values) +- | Cf_val (name, id, exp) -> +- (inh_init, cl_init, methods, (name, id)::values) ++ | Cf_val (name, id, exp, over) -> ++ let values = if over then values else (name, id) :: values in ++ (inh_init, cl_init, methods, values) + | Cf_meth (name, exp) -> + let met_code = msubst true (transl_exp exp) in + let met_code = +@@ -342,27 +333,24 @@ + assert (Path.same path path'); + let lpath = transl_path path in + let inh = Ident.create "inh" +- and inh_vals = Ident.create "vals" +- and inh_meths = Ident.create "meths" ++ and ofs = List.length vals + 1 + and valids, methids = super in + let cl_init = + List.fold_left + (fun init (nm, id, _) -> +- Llet(StrictOpt, id, lfield inh_meths (index nm concr_meths), ++ Llet(StrictOpt, id, lfield inh (index nm concr_meths + ofs), + init)) + cl_init methids in + let cl_init = + List.fold_left + (fun init (nm, id) -> +- Llet(StrictOpt, id, lfield inh_vals (index nm vals), init)) ++ Llet(StrictOpt, id, lfield inh (index nm vals + 1), init)) + cl_init valids in + (inh_init, + Llet (Strict, inh, + Lapply(oo_prim "inherits", narrow_args @ + [lpath; Lconst(Const_pointer(if top then 1 else 0))]), +- Llet(StrictOpt, obj_init, lfield inh 0, +- Llet(Alias, inh_vals, lfield inh 1, +- Llet(Alias, inh_meths, lfield inh 2, cl_init))))) ++ Llet(StrictOpt, obj_init, lfield inh 0, cl_init))) + | _ -> + let core cl_init = + build_class_init cla true super inh_init cl_init msubst top cl +@@ -397,12 +385,16 @@ + XXX Il devrait etre peu couteux d'ecrire des classes : + class c x y = d e f + *) +-let rec transl_class_rebind obj_init cl = ++let rec transl_class_rebind obj_init cl vf = + match cl.cl_desc with + Tclass_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; + (path, obj_init) + | Tclass_fun (pat, _, cl, partial) -> +- let path, obj_init = transl_class_rebind obj_init cl in ++ let path, obj_init = transl_class_rebind obj_init cl vf in + let build params rem = + let param = name_pattern "param" [pat, ()] in + Lfunction (Curried, param::params, +@@ -414,14 +406,14 @@ + Lfunction (Curried, params, rem) -> build params rem + | rem -> build [] rem) + | Tclass_apply (cl, oexprs) -> +- let path, obj_init = transl_class_rebind obj_init cl in ++ let path, obj_init = transl_class_rebind obj_init cl vf in + (path, transl_apply obj_init oexprs) + | Tclass_let (rec_flag, defs, vals, cl) -> +- let path, obj_init = transl_class_rebind obj_init cl in ++ let path, obj_init = transl_class_rebind obj_init cl vf in + (path, Translcore.transl_let rec_flag defs obj_init) + | Tclass_structure _ -> raise Exit + | Tclass_constraint (cl', _, _, _) -> +- let path, obj_init = transl_class_rebind obj_init cl' in ++ let path, obj_init = transl_class_rebind obj_init cl' vf in + let rec check_constraint = function + Tcty_constr(path', _, _) when Path.same path path' -> () + | Tcty_fun (_, _, cty) -> check_constraint cty +@@ -430,21 +422,21 @@ + check_constraint cl.cl_type; + (path, obj_init) + +-let rec transl_class_rebind_0 self obj_init cl = ++let rec transl_class_rebind_0 self obj_init cl vf = + match cl.cl_desc with + Tclass_let (rec_flag, defs, vals, cl) -> +- let path, obj_init = transl_class_rebind_0 self obj_init cl in ++ let path, obj_init = transl_class_rebind_0 self obj_init cl vf in + (path, Translcore.transl_let rec_flag defs obj_init) + | _ -> +- let path, obj_init = transl_class_rebind obj_init cl in ++ let path, obj_init = transl_class_rebind obj_init cl vf in + (path, lfunction [self] obj_init) + +-let transl_class_rebind ids cl = ++let transl_class_rebind ids cl vf = + try + let obj_init = Ident.create "obj_init" + and self = Ident.create "self" in + let obj_init0 = lapply (Lvar obj_init) [Lvar self] in +- let path, obj_init' = transl_class_rebind_0 self obj_init0 cl in ++ let path, obj_init' = transl_class_rebind_0 self obj_init0 cl vf in + if not (Translcore.check_recursive_lambda ids obj_init') then + raise(Error(cl.cl_loc, Illegal_class_expr)); + let id = (obj_init' = lfunction [self] obj_init0) in +@@ -592,9 +584,9 @@ + *) + + +-let transl_class ids cl_id arity pub_meths cl = ++let transl_class ids cl_id arity pub_meths cl vflag = + (* First check if it is not only a rebind *) +- let rebind = transl_class_rebind ids cl in ++ let rebind = transl_class_rebind ids cl vflag in + if rebind <> lambda_unit then rebind else + + (* Prepare for heavy environment handling *) +@@ -696,9 +688,7 @@ + (* Simplest case: an object defined at toplevel (ids=[]) *) + if top && ids = [] then llets (ltable cla (ldirect obj_init)) else + +- let concrete = +- ids = [] || +- Typeclass.virtual_methods (Ctype.signature_of_class_type cl.cl_type) = [] ++ let concrete = (vflag = Concrete) + and lclass lam = + let cl_init = llets (Lfunction(Curried, [cla], cl_init)) in + Llet(Strict, class_init, cl_init, lam (free_variables cl_init)) +@@ -800,11 +790,11 @@ + + (* Wrapper for class compilation *) + +-let transl_class ids cl_id arity pub_meths cl = +- oo_wrap cl.cl_env false (transl_class ids cl_id arity pub_meths) cl ++let transl_class ids cl_id arity pub_meths cl vf = ++ oo_wrap cl.cl_env false (transl_class ids cl_id arity pub_meths cl) vf + + let () = +- transl_object := (fun id meths cl -> transl_class [] id 0 meths cl) ++ transl_object := (fun id meths cl -> transl_class [] id 0 meths cl Concrete) + + (* Error report *) + +Index: bytecomp/translclass.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translclass.mli,v +retrieving revision 1.11 +diff -u -r1.11 translclass.mli +--- bytecomp/translclass.mli 12 Aug 2004 12:55:11 -0000 1.11 ++++ bytecomp/translclass.mli 5 Apr 2006 02:26:00 -0000 +@@ -16,7 +16,8 @@ + open Lambda + + val transl_class : +- Ident.t list -> Ident.t -> int -> string list -> class_expr -> lambda;; ++ Ident.t list -> Ident.t -> ++ int -> string list -> class_expr -> Asttypes.virtual_flag -> lambda;; + + type error = Illegal_class_expr | Tags of string * string + +Index: bytecomp/translmod.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translmod.ml,v +retrieving revision 1.51 +diff -u -r1.51 translmod.ml +--- bytecomp/translmod.ml 12 Aug 2004 12:55:11 -0000 1.51 ++++ bytecomp/translmod.ml 5 Apr 2006 02:26:00 -0000 +@@ -317,10 +317,10 @@ + | Tstr_open path :: rem -> + transl_structure fields cc rootpath rem + | Tstr_class cl_list :: rem -> +- let ids = List.map (fun (i, _, _, _) -> i) cl_list in ++ let ids = List.map (fun (i, _, _, _, _) -> i) cl_list in + Lletrec(List.map +- (fun (id, arity, meths, cl) -> +- (id, transl_class ids id arity meths cl)) ++ (fun (id, arity, meths, cl, vf) -> ++ (id, transl_class ids id arity meths cl vf)) + cl_list, + transl_structure (List.rev ids @ fields) cc rootpath rem) + | Tstr_cltype cl_list :: rem -> +@@ -414,11 +414,11 @@ + | Tstr_open path :: rem -> + transl_store subst rem + | Tstr_class cl_list :: rem -> +- let ids = List.map (fun (i, _, _, _) -> i) cl_list in ++ let ids = List.map (fun (i, _, _, _, _) -> i) cl_list in + let lam = + Lletrec(List.map +- (fun (id, arity, meths, cl) -> +- (id, transl_class ids id arity meths cl)) ++ (fun (id, arity, meths, cl, vf) -> ++ (id, transl_class ids id arity meths cl vf)) + cl_list, + store_idents ids) in + Lsequence(subst_lambda subst lam, +@@ -485,7 +485,7 @@ + | Tstr_modtype(id, decl) :: rem -> defined_idents rem + | Tstr_open path :: rem -> defined_idents rem + | Tstr_class cl_list :: rem -> +- List.map (fun (i, _, _, _) -> i) cl_list @ defined_idents rem ++ List.map (fun (i, _, _, _, _) -> i) cl_list @ defined_idents rem + | Tstr_cltype cl_list :: rem -> defined_idents rem + | Tstr_include(modl, ids) :: rem -> ids @ defined_idents rem + +@@ -603,14 +603,14 @@ + | Tstr_class cl_list -> + (* we need to use unique names for the classes because there might + be a value named identically *) +- let ids = List.map (fun (i, _, _, _) -> i) cl_list in ++ let ids = List.map (fun (i, _, _, _, _) -> i) cl_list in + List.iter set_toplevel_unique_name ids; + Lletrec(List.map +- (fun (id, arity, meths, cl) -> +- (id, transl_class ids id arity meths cl)) ++ (fun (id, arity, meths, cl, vf) -> ++ (id, transl_class ids id arity meths cl vf)) + cl_list, + make_sequence +- (fun (id, _, _, _) -> toploop_setvalue_id id) ++ (fun (id, _, _, _, _) -> toploop_setvalue_id id) + cl_list) + | Tstr_cltype cl_list -> + lambda_unit +Index: driver/main_args.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/driver/main_args.ml,v +retrieving revision 1.48 +diff -u -r1.48 main_args.ml +--- driver/main_args.ml 4 Jan 2006 16:55:49 -0000 1.48 ++++ driver/main_args.ml 5 Apr 2006 02:26:00 -0000 +@@ -136,11 +136,11 @@ + \032 E/e enable/disable fragile match\n\ + \032 F/f enable/disable partially applied function\n\ + \032 L/l enable/disable labels omitted in application\n\ +- \032 M/m enable/disable overridden method\n\ ++ \032 M/m enable/disable overridden methods\n\ + \032 P/p enable/disable partial match\n\ + \032 S/s enable/disable non-unit statement\n\ + \032 U/u enable/disable unused match case\n\ +- \032 V/v enable/disable hidden instance variable\n\ ++ \032 V/v enable/disable overridden instance variables\n\ + \032 Y/y enable/disable suspicious unused variables\n\ + \032 Z/z enable/disable all other unused variables\n\ + \032 X/x enable/disable all other warnings\n\ +Index: driver/optmain.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/driver/optmain.ml,v +retrieving revision 1.87 +diff -u -r1.87 optmain.ml +--- driver/optmain.ml 4 Jan 2006 16:55:49 -0000 1.87 ++++ driver/optmain.ml 5 Apr 2006 02:26:00 -0000 +@@ -173,7 +173,7 @@ + \032 P/p enable/disable partial match\n\ + \032 S/s enable/disable non-unit statement\n\ + \032 U/u enable/disable unused match case\n\ +- \032 V/v enable/disable hidden instance variables\n\ ++ \032 V/v enable/disable overridden instance variables\n\ + \032 Y/y enable/disable suspicious unused variables\n\ + \032 Z/z enable/disable all other unused variables\n\ + \032 X/x enable/disable all other warnings\n\ +Index: stdlib/camlinternalOO.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.ml,v +retrieving revision 1.14 +diff -u -r1.14 camlinternalOO.ml +--- stdlib/camlinternalOO.ml 25 Oct 2005 18:34:07 -0000 1.14 ++++ stdlib/camlinternalOO.ml 5 Apr 2006 02:26:00 -0000 +@@ -206,7 +206,11 @@ + (table.methods_by_name, table.methods_by_label, table.hidden_meths, + table.vars, virt_meth_labs, vars) + :: table.previous_states; +- table.vars <- Vars.empty; ++ table.vars <- ++ Vars.fold ++ (fun lab info tvars -> ++ if List.mem lab vars then Vars.add lab info tvars else tvars) ++ table.vars Vars.empty; + let by_name = ref Meths.empty in + let by_label = ref Labs.empty in + List.iter2 +@@ -255,9 +259,11 @@ + index + + let new_variable table name = +- let index = new_slot table in +- table.vars <- Vars.add name index table.vars; +- index ++ try Vars.find name table.vars ++ with Not_found -> ++ let index = new_slot table in ++ table.vars <- Vars.add name index table.vars; ++ index + + let to_array arr = + if arr = Obj.magic 0 then [||] else arr +@@ -265,16 +271,17 @@ + let new_methods_variables table meths vals = + let meths = to_array meths in + let nmeths = Array.length meths and nvals = Array.length vals in +- let index = new_variable table vals.(0) in +- let res = Array.create (nmeths + 1) index in +- for i = 1 to nvals - 1 do ignore (new_variable table vals.(i)) done; ++ let res = Array.create (nmeths + nvals) 0 in + for i = 0 to nmeths - 1 do +- res.(i+1) <- get_method_label table meths.(i) ++ res.(i) <- get_method_label table meths.(i) ++ done; ++ for i = 0 to nvals - 1 do ++ res.(i+nmeths) <- new_variable table vals.(i) + done; + res + + let get_variable table name = +- Vars.find name table.vars ++ try Vars.find name table.vars with Not_found -> assert false + + let get_variables table names = + Array.map (get_variable table) names +@@ -315,9 +322,12 @@ + let init = + if top then super cla env else Obj.repr (super cla) in + widen cla; +- (init, Array.map (get_variable cla) (to_array vals), +- Array.map (fun nm -> get_method cla (get_method_label cla nm)) +- (to_array concr_meths)) ++ Array.concat ++ [[| repr init |]; ++ magic (Array.map (get_variable cla) (to_array vals) : int array); ++ Array.map ++ (fun nm -> repr (get_method cla (get_method_label cla nm) : closure)) ++ (to_array concr_meths) ] + + let make_class pub_meths class_init = + let table = create_table pub_meths in +Index: stdlib/camlinternalOO.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.mli,v +retrieving revision 1.9 +diff -u -r1.9 camlinternalOO.mli +--- stdlib/camlinternalOO.mli 25 Oct 2005 18:34:07 -0000 1.9 ++++ stdlib/camlinternalOO.mli 5 Apr 2006 02:26:00 -0000 +@@ -46,8 +46,7 @@ + val init_class : table -> unit + val inherits : + table -> string array -> string array -> string array -> +- (t * (table -> obj -> Obj.t) * t * obj) -> bool -> +- (Obj.t * int array * closure array) ++ (t * (table -> obj -> Obj.t) * t * obj) -> bool -> Obj.t array + val make_class : + string array -> (table -> Obj.t -> t) -> + (t * (table -> Obj.t -> t) * (Obj.t -> t) * Obj.t) +@@ -79,6 +78,7 @@ + + (** {6 Builtins to reduce code size} *) + ++(* + val get_const : t -> closure + val get_var : int -> closure + val get_env : int -> int -> closure +@@ -103,6 +103,7 @@ + val send_var : tag -> int -> int -> closure + val send_env : tag -> int -> int -> int -> closure + val send_meth : tag -> label -> int -> closure ++*) + + type impl = + GetConst +Index: stdlib/sys.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/stdlib/sys.ml,v +retrieving revision 1.142 +diff -u -r1.142 sys.ml +--- stdlib/sys.ml 22 Mar 2006 12:39:39 -0000 1.142 ++++ stdlib/sys.ml 5 Apr 2006 02:26:00 -0000 +@@ -78,4 +78,4 @@ + + (* OCaml version string, must be in the format described in sys.mli. *) + +-let ocaml_version = "3.10+dev4 (2006-03-22)";; ++let ocaml_version = "3.10+dev5 (2006-04-05)";; +Index: tools/depend.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/tools/depend.ml,v +retrieving revision 1.9 +diff -u -r1.9 depend.ml +--- tools/depend.ml 23 Mar 2005 03:08:37 -0000 1.9 ++++ tools/depend.ml 5 Apr 2006 02:26:00 -0000 +@@ -87,7 +87,7 @@ + + and add_class_type_field bv = function + Pctf_inher cty -> add_class_type bv cty +- | Pctf_val(_, _, oty, _) -> add_opt add_type bv oty ++ | Pctf_val(_, _, _, ty, _) -> add_type bv ty + | Pctf_virt(_, _, ty, _) -> add_type bv ty + | Pctf_meth(_, _, ty, _) -> add_type bv ty + | Pctf_cstr(ty1, ty2, _) -> add_type bv ty1; add_type bv ty2 +@@ -280,6 +280,7 @@ + and add_class_field bv = function + Pcf_inher(ce, _) -> add_class_expr bv ce + | Pcf_val(_, _, e, _) -> add_expr bv e ++ | Pcf_valvirt(_, _, ty, _) + | Pcf_virt(_, _, ty, _) -> add_type bv ty + | Pcf_meth(_, _, e, _) -> add_expr bv e + | Pcf_cstr(ty1, ty2, _) -> add_type bv ty1; add_type bv ty2 +Index: tools/ocamlprof.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/tools/ocamlprof.ml,v +retrieving revision 1.38 +diff -u -r1.38 ocamlprof.ml +--- tools/ocamlprof.ml 24 Mar 2005 17:20:54 -0000 1.38 ++++ tools/ocamlprof.ml 5 Apr 2006 02:26:00 -0000 +@@ -328,7 +328,7 @@ + rewrite_patexp_list iflag spat_sexp_list + | Pcf_init sexp -> + rewrite_exp iflag sexp +- | Pcf_virt _ | Pcf_cstr _ -> () ++ | Pcf_valvirt _ | Pcf_virt _ | Pcf_cstr _ -> () + + and rewrite_class_expr iflag cexpr = + match cexpr.pcl_desc with +Index: otherlibs/labltk/browser/searchpos.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/otherlibs/labltk/browser/searchpos.ml,v +retrieving revision 1.48 +diff -u -r1.48 searchpos.ml +--- otherlibs/labltk/browser/searchpos.ml 23 Mar 2005 03:08:37 -0000 1.48 ++++ otherlibs/labltk/browser/searchpos.ml 5 Apr 2006 02:26:01 -0000 +@@ -141,9 +141,8 @@ + List.iter cfl ~f: + begin function + Pctf_inher cty -> search_pos_class_type cty ~pos ~env +- | Pctf_val (_, _, Some ty, loc) -> ++ | Pctf_val (_, _, _, ty, loc) -> + if in_loc loc ~pos then search_pos_type ty ~pos ~env +- | Pctf_val _ -> () + | Pctf_virt (_, _, ty, loc) -> + if in_loc loc ~pos then search_pos_type ty ~pos ~env + | Pctf_meth (_, _, ty, loc) -> +@@ -675,7 +674,7 @@ + | Tstr_modtype _ -> () + | Tstr_open _ -> () + | Tstr_class l -> +- List.iter l ~f:(fun (id, _, _, cl) -> search_pos_class_expr cl ~pos) ++ List.iter l ~f:(fun (id, _, _, cl, _) -> search_pos_class_expr cl ~pos) + | Tstr_cltype _ -> () + | Tstr_include (m, _) -> search_pos_module_expr m ~pos + end +@@ -685,7 +684,8 @@ + begin function + Cf_inher (cl, _, _) -> + search_pos_class_expr cl ~pos +- | Cf_val (_, _, exp) -> search_pos_expr exp ~pos ++ | Cf_val (_, _, Some exp, _) -> search_pos_expr exp ~pos ++ | Cf_val _ -> () + | Cf_meth (_, exp) -> search_pos_expr exp ~pos + | Cf_let (_, pel, iel) -> + List.iter pel ~f: +Index: ocamldoc/Makefile +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/ocamldoc/Makefile,v +retrieving revision 1.61 +diff -u -r1.61 Makefile +--- ocamldoc/Makefile 4 Jan 2006 16:55:49 -0000 1.61 ++++ ocamldoc/Makefile 5 Apr 2006 02:26:01 -0000 +@@ -31,7 +31,7 @@ + MKDIR=mkdir -p + CP=cp -f + OCAMLDOC=ocamldoc +-OCAMLDOC_RUN=sh ./runocamldoc $(SUPPORTS_SHARED_LIBRARIES) ++OCAMLDOC_RUN=./ocamldoc.opt #sh ./runocamldoc $(SUPPORTS_SHARED_LIBRARIES) + OCAMLDOC_OPT=$(OCAMLDOC).opt + OCAMLDOC_LIBCMA=odoc_info.cma + OCAMLDOC_LIBCMI=odoc_info.cmi +@@ -188,12 +188,12 @@ + ../otherlibs/num/num.mli + + all: exe lib +- $(MAKE) manpages + + exe: $(OCAMLDOC) + lib: $(OCAMLDOC_LIBCMA) $(OCAMLDOC_LIBCMI) $(ODOC_TEST) + + opt.opt: exeopt libopt ++ $(MAKE) manpages + exeopt: $(OCAMLDOC_OPT) + libopt: $(OCAMLDOC_LIBCMXA) $(OCAMLDOC_LIBCMI) + debug: +Index: ocamldoc/odoc_ast.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/ocamldoc/odoc_ast.ml,v +retrieving revision 1.27 +diff -u -r1.27 odoc_ast.ml +--- ocamldoc/odoc_ast.ml 4 Jan 2006 16:55:49 -0000 1.27 ++++ ocamldoc/odoc_ast.ml 5 Apr 2006 02:26:01 -0000 +@@ -88,7 +88,7 @@ + ident_type_decl_list + | Typedtree.Tstr_class info_list -> + List.iter +- (fun ((id,_,_,_) as ci) -> ++ (fun ((id,_,_,_,_) as ci) -> + Hashtbl.add table (C (Name.from_ident id)) + (Typedtree.Tstr_class [ci])) + info_list +@@ -146,7 +146,7 @@ + + let search_class_exp table name = + match Hashtbl.find table (C name) with +- | (Typedtree.Tstr_class [(_,_,_,ce)]) -> ++ | (Typedtree.Tstr_class [(_,_,_,ce,_)]) -> + ( + try + let type_decl = search_type_declaration table name in +@@ -184,7 +184,7 @@ + let rec iter = function + | [] -> + raise Not_found +- | Typedtree.Cf_val (_, ident, exp) :: q ++ | Typedtree.Cf_val (_, ident, Some exp, _) :: q + when Name.from_ident ident = name -> + exp.Typedtree.exp_type + | _ :: q -> +@@ -523,7 +523,8 @@ + p_clexp.Parsetree.pcl_loc.Location.loc_end.Lexing.pos_cnum + q + +- | (Parsetree.Pcf_val (label, mutable_flag, expression, loc)) :: q -> ++ | (Parsetree.Pcf_val (label, mutable_flag, _, loc) | ++ Parsetree.Pcf_valvirt (label, mutable_flag, _, loc)) :: q -> + let complete_name = Name.concat current_class_name label in + let (info_opt, ele_comments) = get_comments_in_class last_pos loc.Location.loc_start.Lexing.pos_cnum in + let type_exp = +Index: ocamldoc/odoc_sig.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/ocamldoc/odoc_sig.ml,v +retrieving revision 1.37 +diff -u -r1.37 odoc_sig.ml +--- ocamldoc/odoc_sig.ml 4 Jan 2006 16:55:50 -0000 1.37 ++++ ocamldoc/odoc_sig.ml 5 Apr 2006 02:26:01 -0000 +@@ -107,7 +107,7 @@ + | _ -> assert false + + let search_attribute_type name class_sig = +- let (_, type_expr) = Types.Vars.find name class_sig.Types.cty_vars in ++ let (_, _, type_expr) = Types.Vars.find name class_sig.Types.cty_vars in + type_expr + + let search_method_type name class_sig = +@@ -269,7 +269,7 @@ + [] -> pos_limit + | ele2 :: _ -> + match ele2 with +- Parsetree.Pctf_val (_, _, _, loc) ++ Parsetree.Pctf_val (_, _, _, _, loc) + | Parsetree.Pctf_virt (_, _, _, loc) + | Parsetree.Pctf_meth (_, _, _, loc) + | Parsetree.Pctf_cstr (_, _, loc) -> loc.Location.loc_start.Lexing.pos_cnum +@@ -330,7 +330,7 @@ + in + ([], ele_comments) + +- | Parsetree.Pctf_val (name, mutable_flag, _, loc) :: q -> ++ | Parsetree.Pctf_val (name, mutable_flag, _, _, loc) :: q -> + (* of (string * mutable_flag * core_type option * Location.t)*) + let (comment_opt, eles_comments) = get_comments_in_class last_pos loc.Location.loc_start.Lexing.pos_cnum in + let complete_name = Name.concat current_class_name name in +Index: camlp4/camlp4/ast2pt.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/camlp4/ast2pt.ml,v +retrieving revision 1.36 +diff -u -r1.36 ast2pt.ml +--- camlp4/camlp4/ast2pt.ml 29 Jun 2005 04:11:26 -0000 1.36 ++++ camlp4/camlp4/ast2pt.ml 5 Apr 2006 02:26:01 -0000 +@@ -244,6 +244,7 @@ + ; + value mkmutable m = if m then Mutable else Immutable; + value mkprivate m = if m then Private else Public; ++value mkvirtual m = if m then Virtual else Concrete; + value mktrecord (loc, n, m, t) = + (n, mkmutable m, ctyp (mkpolytype t), mkloc loc); + value mkvariant (loc, c, tl) = (c, List.map ctyp tl, mkloc loc); +@@ -862,8 +863,8 @@ + | CgInh loc ct -> [Pctf_inher (class_type ct) :: l] + | CgMth loc s pf t -> + [Pctf_meth (s, mkprivate pf, ctyp (mkpolytype t), mkloc loc) :: l] +- | CgVal loc s b t -> +- [Pctf_val (s, mkmutable b, Some (ctyp t), mkloc loc) :: l] ++ | CgVal loc s b v t -> ++ [Pctf_val (s, mkmutable b, mkvirtual v, ctyp t, mkloc loc) :: l] + | CgVir loc s b t -> + [Pctf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l] ] + and class_expr = +@@ -907,7 +908,9 @@ + [Pcf_meth (s, mkprivate b, e, mkloc loc) :: l] + | CrVal loc s b e -> [Pcf_val (s, mkmutable b, expr e, mkloc loc) :: l] + | CrVir loc s b t -> +- [Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l] ] ++ [Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l] ++ | CrVvr loc s b t -> ++ [Pcf_valvirt (s, mkmutable b, ctyp t, mkloc loc) :: l] ] + ; + + value interf ast = List.fold_right sig_item ast []; +Index: camlp4/camlp4/mLast.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/camlp4/mLast.mli,v +retrieving revision 1.18 +diff -u -r1.18 mLast.mli +--- camlp4/camlp4/mLast.mli 29 Jun 2005 04:11:26 -0000 1.18 ++++ camlp4/camlp4/mLast.mli 5 Apr 2006 02:26:01 -0000 +@@ -180,7 +180,7 @@ + | CgDcl of loc and list class_sig_item + | CgInh of loc and class_type + | CgMth of loc and string and bool and ctyp +- | CgVal of loc and string and bool and ctyp ++ | CgVal of loc and string and bool and bool and ctyp + | CgVir of loc and string and bool and ctyp ] + and class_expr = + [ CeApp of loc and class_expr and expr +@@ -196,7 +196,8 @@ + | CrIni of loc and expr + | CrMth of loc and string and bool and expr and option ctyp + | CrVal of loc and string and bool and expr +- | CrVir of loc and string and bool and ctyp ] ++ | CrVir of loc and string and bool and ctyp ++ | CrVvr of loc and string and bool and ctyp ] + ; + + external loc_of_ctyp : ctyp -> loc = "%field0"; +Index: camlp4/camlp4/reloc.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/camlp4/reloc.ml,v +retrieving revision 1.18 +diff -u -r1.18 reloc.ml +--- camlp4/camlp4/reloc.ml 29 Jun 2005 04:11:26 -0000 1.18 ++++ camlp4/camlp4/reloc.ml 5 Apr 2006 02:26:01 -0000 +@@ -350,7 +350,7 @@ + | CgDcl loc x1 -> let nloc = floc loc in CgDcl nloc (List.map (class_sig_item floc sh) x1) + | CgInh loc x1 -> let nloc = floc loc in CgInh nloc (class_type floc sh x1) + | CgMth loc x1 x2 x3 -> let nloc = floc loc in CgMth nloc x1 x2 (ctyp floc sh x3) +- | CgVal loc x1 x2 x3 -> let nloc = floc loc in CgVal nloc x1 x2 (ctyp floc sh x3) ++ | CgVal loc x1 x2 x3 x4 -> let nloc = floc loc in CgVal nloc x1 x2 x3 (ctyp floc sh x4) + | CgVir loc x1 x2 x3 -> let nloc = floc loc in CgVir nloc x1 x2 (ctyp floc sh x3) ] + and class_expr floc sh = + self where rec self = +@@ -377,5 +377,6 @@ + | CrMth loc x1 x2 x3 x4 -> + let nloc = floc loc in CrMth nloc x1 x2 (expr floc sh x3) (option_map (ctyp floc sh) x4) + | CrVal loc x1 x2 x3 -> let nloc = floc loc in CrVal nloc x1 x2 (expr floc sh x3) +- | CrVir loc x1 x2 x3 -> let nloc = floc loc in CrVir nloc x1 x2 (ctyp floc sh x3) ] ++ | CrVir loc x1 x2 x3 -> let nloc = floc loc in CrVir nloc x1 x2 (ctyp floc sh x3) ++ | CrVvr loc x1 x2 x3 -> let nloc = floc loc in CrVvr nloc x1 x2 (ctyp floc sh x3) ] + ; +Index: camlp4/etc/pa_o.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/etc/pa_o.ml,v +retrieving revision 1.66 +diff -u -r1.66 pa_o.ml +--- camlp4/etc/pa_o.ml 29 Jun 2005 04:11:26 -0000 1.66 ++++ camlp4/etc/pa_o.ml 5 Apr 2006 02:26:01 -0000 +@@ -1037,8 +1037,14 @@ + class_str_item: + [ [ "inherit"; ce = class_expr; pb = OPT [ "as"; i = LIDENT -> i ] -> + <:class_str_item< inherit $ce$ $opt:pb$ >> +- | "val"; mf = OPT "mutable"; lab = label; e = cvalue_binding -> +- <:class_str_item< value $opt:o2b mf$ $lab$ = $e$ >> ++ | "val"; "mutable"; lab = label; e = cvalue_binding -> ++ <:class_str_item< value mutable $lab$ = $e$ >> ++ | "val"; lab = label; e = cvalue_binding -> ++ <:class_str_item< value $lab$ = $e$ >> ++ | "val"; "mutable"; "virtual"; lab = label; ":"; t = ctyp -> ++ <:class_str_item< value virtual mutable $lab$ : $t$ >> ++ | "val"; "virtual"; mf = OPT "mutable"; lab = label; ":"; t = ctyp -> ++ <:class_str_item< value virtual $opt:o2b mf$ $lab$ : $t$ >> + | "method"; "private"; "virtual"; l = label; ":"; t = poly_type -> + <:class_str_item< method virtual private $l$ : $t$ >> + | "method"; "virtual"; "private"; l = label; ":"; t = poly_type -> +@@ -1087,8 +1093,9 @@ + ; + class_sig_item: + [ [ "inherit"; cs = class_signature -> <:class_sig_item< inherit $cs$ >> +- | "val"; mf = OPT "mutable"; l = label; ":"; t = ctyp -> +- <:class_sig_item< value $opt:o2b mf$ $l$ : $t$ >> ++ | "val"; mf = OPT "mutable"; vf = OPT "virtual"; ++ l = label; ":"; t = ctyp -> ++ <:class_sig_item< value $opt:o2b mf$ $opt:o2b vf$ $l$ : $t$ >> + | "method"; "private"; "virtual"; l = label; ":"; t = poly_type -> + <:class_sig_item< method virtual private $l$ : $t$ >> + | "method"; "virtual"; "private"; l = label; ":"; t = poly_type -> +Index: camlp4/etc/pr_o.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/etc/pr_o.ml,v +retrieving revision 1.51 +diff -u -r1.51 pr_o.ml +--- camlp4/etc/pr_o.ml 5 Jan 2006 10:44:29 -0000 1.51 ++++ camlp4/etc/pr_o.ml 5 Apr 2006 02:26:01 -0000 +@@ -1768,10 +1768,11 @@ + [: `S LR "method"; private_flag pf; `label lab; + `S LR ":" :]; + `ctyp t "" k :] +- | MLast.CgVal _ lab mf t -> ++ | MLast.CgVal _ lab mf vf t -> + fun curr next dg k -> + [: `HVbox +- [: `S LR "val"; mutable_flag mf; `label lab; `S LR ":" :]; ++ [: `S LR "val"; mutable_flag mf; virtual_flag vf; ++ `label lab; `S LR ":" :]; + `ctyp t "" k :] + | MLast.CgVir _ lab pf t -> + fun curr next dg k -> +Index: camlp4/meta/pa_r.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/meta/pa_r.ml,v +retrieving revision 1.64 +diff -u -r1.64 pa_r.ml +--- camlp4/meta/pa_r.ml 29 Jun 2005 04:11:26 -0000 1.64 ++++ camlp4/meta/pa_r.ml 5 Apr 2006 02:26:01 -0000 +@@ -658,7 +658,9 @@ + | "inherit"; ce = class_expr; pb = OPT as_lident -> + <:class_str_item< inherit $ce$ $opt:pb$ >> + | "value"; mf = OPT "mutable"; lab = label; e = cvalue_binding -> +- <:class_str_item< value $opt:o2b mf$ $lab$ = $e$ >> ++ <:class_str_item< value $opt:o2b mf$ $lab$ = $e$ >> ++ | "value"; "virtual"; mf = OPT "mutable"; l = label; ":"; t = ctyp -> ++ <:class_str_item< value virtual $opt:o2b mf$ $l$ : $t$ >> + | "method"; "virtual"; pf = OPT "private"; l = label; ":"; t = ctyp -> + <:class_str_item< method virtual $opt:o2b pf$ $l$ : $t$ >> + | "method"; pf = OPT "private"; l = label; topt = OPT polyt; +@@ -701,8 +703,9 @@ + [ [ "declare"; st = LIST0 [ s = class_sig_item; ";" -> s ]; "end" -> + <:class_sig_item< declare $list:st$ end >> + | "inherit"; cs = class_type -> <:class_sig_item< inherit $cs$ >> +- | "value"; mf = OPT "mutable"; l = label; ":"; t = ctyp -> +- <:class_sig_item< value $opt:o2b mf$ $l$ : $t$ >> ++ | "value"; mf = OPT "mutable"; vf = OPT "virtual"; ++ l = label; ":"; t = ctyp -> ++ <:class_sig_item< value $opt:o2b mf$ $opt:o2b vf$ $l$ : $t$ >> + | "method"; "virtual"; pf = OPT "private"; l = label; ":"; t = ctyp -> + <:class_sig_item< method virtual $opt:o2b pf$ $l$ : $t$ >> + | "method"; pf = OPT "private"; l = label; ":"; t = ctyp -> +Index: camlp4/meta/q_MLast.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/meta/q_MLast.ml,v +retrieving revision 1.60 +diff -u -r1.60 q_MLast.ml +--- camlp4/meta/q_MLast.ml 29 Jun 2005 04:11:26 -0000 1.60 ++++ camlp4/meta/q_MLast.ml 5 Apr 2006 02:26:01 -0000 +@@ -947,6 +947,8 @@ + Qast.Node "CrDcl" [Qast.Loc; st] + | "inherit"; ce = class_expr; pb = SOPT as_lident -> + Qast.Node "CrInh" [Qast.Loc; ce; pb] ++ | "value"; "virtual"; mf = SOPT "mutable"; l = label; ":"; t = ctyp -> ++ Qast.Node "CrVvr" [Qast.Loc; l; o2b mf; t] + | "value"; mf = SOPT "mutable"; lab = label; e = cvalue_binding -> + Qast.Node "CrVal" [Qast.Loc; lab; o2b mf; e] + | "method"; "virtual"; pf = SOPT "private"; l = label; ":"; t = ctyp -> +@@ -992,8 +994,9 @@ + [ [ "declare"; st = SLIST0 [ s = class_sig_item; ";" -> s ]; "end" -> + Qast.Node "CgDcl" [Qast.Loc; st] + | "inherit"; cs = class_type -> Qast.Node "CgInh" [Qast.Loc; cs] +- | "value"; mf = SOPT "mutable"; l = label; ":"; t = ctyp -> +- Qast.Node "CgVal" [Qast.Loc; l; o2b mf; t] ++ | "value"; mf = SOPT "mutable"; vf = SOPT "virtual"; ++ l = label; ":"; t = ctyp -> ++ Qast.Node "CgVal" [Qast.Loc; l; o2b mf; o2b vf; t] + | "method"; "virtual"; pf = SOPT "private"; l = label; ":"; t = ctyp -> + Qast.Node "CgVir" [Qast.Loc; l; o2b pf; t] + | "method"; pf = SOPT "private"; l = label; ":"; t = ctyp -> +Index: camlp4/ocaml_src/camlp4/ast2pt.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/camlp4/ast2pt.ml,v +retrieving revision 1.36 +diff -u -r1.36 ast2pt.ml +--- camlp4/ocaml_src/camlp4/ast2pt.ml 29 Jun 2005 04:11:26 -0000 1.36 ++++ camlp4/ocaml_src/camlp4/ast2pt.ml 5 Apr 2006 02:26:01 -0000 +@@ -227,6 +227,7 @@ + ;; + let mkmutable m = if m then Mutable else Immutable;; + let mkprivate m = if m then Private else Public;; ++let mkvirtual m = if m then Virtual else Concrete;; + let mktrecord (loc, n, m, t) = + n, mkmutable m, ctyp (mkpolytype t), mkloc loc + ;; +@@ -878,8 +879,8 @@ + | CgInh (loc, ct) -> Pctf_inher (class_type ct) :: l + | CgMth (loc, s, pf, t) -> + Pctf_meth (s, mkprivate pf, ctyp (mkpolytype t), mkloc loc) :: l +- | CgVal (loc, s, b, t) -> +- Pctf_val (s, mkmutable b, Some (ctyp t), mkloc loc) :: l ++ | CgVal (loc, s, b, v, t) -> ++ Pctf_val (s, mkmutable b, mkvirtual v, ctyp t, mkloc loc) :: l + | CgVir (loc, s, b, t) -> + Pctf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l + and class_expr = +@@ -923,6 +924,8 @@ + | CrVal (loc, s, b, e) -> Pcf_val (s, mkmutable b, expr e, mkloc loc) :: l + | CrVir (loc, s, b, t) -> + Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l ++ | CrVvr (loc, s, b, t) -> ++ Pcf_valvirt (s, mkmutable b, ctyp t, mkloc loc) :: l + ;; + + let interf ast = List.fold_right sig_item ast [];; +Index: camlp4/ocaml_src/camlp4/mLast.mli +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/camlp4/mLast.mli,v +retrieving revision 1.20 +diff -u -r1.20 mLast.mli +--- camlp4/ocaml_src/camlp4/mLast.mli 29 Jun 2005 04:11:26 -0000 1.20 ++++ camlp4/ocaml_src/camlp4/mLast.mli 5 Apr 2006 02:26:01 -0000 +@@ -180,7 +180,7 @@ + | CgDcl of loc * class_sig_item list + | CgInh of loc * class_type + | CgMth of loc * string * bool * ctyp +- | CgVal of loc * string * bool * ctyp ++ | CgVal of loc * string * bool * bool * ctyp + | CgVir of loc * string * bool * ctyp + and class_expr = + CeApp of loc * class_expr * expr +@@ -197,6 +197,7 @@ + | CrMth of loc * string * bool * expr * ctyp option + | CrVal of loc * string * bool * expr + | CrVir of loc * string * bool * ctyp ++ | CrVvr of loc * string * bool * ctyp + ;; + + external loc_of_ctyp : ctyp -> loc = "%field0";; +Index: camlp4/ocaml_src/camlp4/reloc.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/camlp4/reloc.ml,v +retrieving revision 1.20 +diff -u -r1.20 reloc.ml +--- camlp4/ocaml_src/camlp4/reloc.ml 29 Jun 2005 04:11:26 -0000 1.20 ++++ camlp4/ocaml_src/camlp4/reloc.ml 5 Apr 2006 02:26:01 -0000 +@@ -430,8 +430,8 @@ + let nloc = floc loc in CgInh (nloc, class_type floc sh x1) + | CgMth (loc, x1, x2, x3) -> + let nloc = floc loc in CgMth (nloc, x1, x2, ctyp floc sh x3) +- | CgVal (loc, x1, x2, x3) -> +- let nloc = floc loc in CgVal (nloc, x1, x2, ctyp floc sh x3) ++ | CgVal (loc, x1, x2, x3, x4) -> ++ let nloc = floc loc in CgVal (nloc, x1, x2, x3, ctyp floc sh x4) + | CgVir (loc, x1, x2, x3) -> + let nloc = floc loc in CgVir (nloc, x1, x2, ctyp floc sh x3) + in +@@ -478,6 +478,8 @@ + let nloc = floc loc in CrVal (nloc, x1, x2, expr floc sh x3) + | CrVir (loc, x1, x2, x3) -> + let nloc = floc loc in CrVir (nloc, x1, x2, ctyp floc sh x3) ++ | CrVvr (loc, x1, x2, x3) -> ++ let nloc = floc loc in CrVvr (nloc, x1, x2, ctyp floc sh x3) + in + self + ;; +Index: camlp4/ocaml_src/meta/pa_r.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/meta/pa_r.ml,v +retrieving revision 1.59 +diff -u -r1.59 pa_r.ml +--- camlp4/ocaml_src/meta/pa_r.ml 29 Jun 2005 04:11:26 -0000 1.59 ++++ camlp4/ocaml_src/meta/pa_r.ml 5 Apr 2006 02:26:01 -0000 +@@ -2161,6 +2161,15 @@ + (fun (t : 'ctyp) _ (l : 'label) (pf : string option) _ _ + (_loc : Lexing.position * Lexing.position) -> + (MLast.CrVir (_loc, l, o2b pf, t) : 'class_str_item)); ++ [Gramext.Stoken ("", "value"); Gramext.Stoken ("", "virtual"); ++ Gramext.Sopt (Gramext.Stoken ("", "mutable")); ++ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e)); ++ Gramext.Stoken ("", ":"); ++ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))], ++ Gramext.action ++ (fun (t : 'ctyp) _ (l : 'label) (mf : string option) _ _ ++ (_loc : Lexing.position * Lexing.position) -> ++ (MLast.CrVvr (_loc, l, o2b mf, t) : 'class_str_item)); + [Gramext.Stoken ("", "value"); + Gramext.Sopt (Gramext.Stoken ("", "mutable")); + Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e)); +@@ -2338,13 +2347,15 @@ + (MLast.CgVir (_loc, l, o2b pf, t) : 'class_sig_item)); + [Gramext.Stoken ("", "value"); + Gramext.Sopt (Gramext.Stoken ("", "mutable")); ++ Gramext.Sopt (Gramext.Stoken ("", "virtual")); + Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e)); + Gramext.Stoken ("", ":"); + Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))], + Gramext.action +- (fun (t : 'ctyp) _ (l : 'label) (mf : string option) _ ++ (fun (t : 'ctyp) _ (l : 'label) (vf : string option) ++ (mf : string option) _ + (_loc : Lexing.position * Lexing.position) -> +- (MLast.CgVal (_loc, l, o2b mf, t) : 'class_sig_item)); ++ (MLast.CgVal (_loc, l, o2b mf, o2b vf, t) : 'class_sig_item)); + [Gramext.Stoken ("", "inherit"); + Gramext.Snterm + (Grammar.Entry.obj (class_type : 'class_type Grammar.Entry.e))], +Index: camlp4/ocaml_src/meta/q_MLast.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/meta/q_MLast.ml,v +retrieving revision 1.65 +diff -u -r1.65 q_MLast.ml +--- camlp4/ocaml_src/meta/q_MLast.ml 12 Jan 2006 08:54:21 -0000 1.65 ++++ camlp4/ocaml_src/meta/q_MLast.ml 5 Apr 2006 02:26:01 -0000 +@@ -3152,9 +3152,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__17))])], ++ (Qast.Str x : 'e__18))])], + Gramext.action +- (fun (a : 'e__17 option) ++ (fun (a : 'e__18 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3191,9 +3191,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__16))])], ++ (Qast.Str x : 'e__17))])], + Gramext.action +- (fun (a : 'e__16 option) ++ (fun (a : 'e__17 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3216,9 +3216,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__15))])], ++ (Qast.Str x : 'e__16))])], + Gramext.action +- (fun (a : 'e__15 option) ++ (fun (a : 'e__16 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3235,6 +3235,31 @@ + (_loc : Lexing.position * Lexing.position) -> + (Qast.Node ("CrVal", [Qast.Loc; lab; o2b mf; e]) : + 'class_str_item)); ++ [Gramext.Stoken ("", "value"); Gramext.Stoken ("", "virtual"); ++ Gramext.srules ++ [[Gramext.Sopt ++ (Gramext.srules ++ [[Gramext.Stoken ("", "mutable")], ++ Gramext.action ++ (fun (x : string) ++ (_loc : Lexing.position * Lexing.position) -> ++ (Qast.Str x : 'e__15))])], ++ Gramext.action ++ (fun (a : 'e__15 option) ++ (_loc : Lexing.position * Lexing.position) -> ++ (Qast.Option a : 'a_opt)); ++ [Gramext.Snterm ++ (Grammar.Entry.obj (a_opt : 'a_opt Grammar.Entry.e))], ++ Gramext.action ++ (fun (a : 'a_opt) (_loc : Lexing.position * Lexing.position) -> ++ (a : 'a_opt))]; ++ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e)); ++ Gramext.Stoken ("", ":"); ++ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))], ++ Gramext.action ++ (fun (t : 'ctyp) _ (l : 'label) (mf : 'a_opt) _ _ ++ (_loc : Lexing.position * Lexing.position) -> ++ (Qast.Node ("CrVvr", [Qast.Loc; l; o2b mf; t]) : 'class_str_item)); + [Gramext.Stoken ("", "inherit"); + Gramext.Snterm + (Grammar.Entry.obj (class_expr : 'class_expr Grammar.Entry.e)); +@@ -3366,9 +3391,9 @@ + Gramext.action + (fun _ (csf : 'class_sig_item) + (_loc : Lexing.position * Lexing.position) -> +- (csf : 'e__18))])], ++ (csf : 'e__19))])], + Gramext.action +- (fun (a : 'e__18 list) ++ (fun (a : 'e__19 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -3446,9 +3471,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__22))])], ++ (Qast.Str x : 'e__24))])], + Gramext.action +- (fun (a : 'e__22 option) ++ (fun (a : 'e__24 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3471,9 +3496,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__21))])], ++ (Qast.Str x : 'e__23))])], + Gramext.action +- (fun (a : 'e__21 option) ++ (fun (a : 'e__23 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3496,9 +3521,26 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__20))])], ++ (Qast.Str x : 'e__21))])], + Gramext.action +- (fun (a : 'e__20 option) ++ (fun (a : 'e__21 option) ++ (_loc : Lexing.position * Lexing.position) -> ++ (Qast.Option a : 'a_opt)); ++ [Gramext.Snterm ++ (Grammar.Entry.obj (a_opt : 'a_opt Grammar.Entry.e))], ++ Gramext.action ++ (fun (a : 'a_opt) (_loc : Lexing.position * Lexing.position) -> ++ (a : 'a_opt))]; ++ Gramext.srules ++ [[Gramext.Sopt ++ (Gramext.srules ++ [[Gramext.Stoken ("", "virtual")], ++ Gramext.action ++ (fun (x : string) ++ (_loc : Lexing.position * Lexing.position) -> ++ (Qast.Str x : 'e__22))])], ++ Gramext.action ++ (fun (a : 'e__22 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3510,9 +3552,10 @@ + Gramext.Stoken ("", ":"); + Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))], + Gramext.action +- (fun (t : 'ctyp) _ (l : 'label) (mf : 'a_opt) _ ++ (fun (t : 'ctyp) _ (l : 'label) (vf : 'a_opt) (mf : 'a_opt) _ + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Node ("CgVal", [Qast.Loc; l; o2b mf; t]) : 'class_sig_item)); ++ (Qast.Node ("CgVal", [Qast.Loc; l; o2b mf; o2b vf; t]) : ++ 'class_sig_item)); + [Gramext.Stoken ("", "inherit"); + Gramext.Snterm + (Grammar.Entry.obj (class_type : 'class_type Grammar.Entry.e))], +@@ -3531,9 +3574,9 @@ + Gramext.action + (fun _ (s : 'class_sig_item) + (_loc : Lexing.position * Lexing.position) -> +- (s : 'e__19))])], ++ (s : 'e__20))])], + Gramext.action +- (fun (a : 'e__19 list) ++ (fun (a : 'e__20 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -3556,9 +3599,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__23))])], ++ (Qast.Str x : 'e__25))])], + Gramext.action +- (fun (a : 'e__23 option) ++ (fun (a : 'e__25 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3593,9 +3636,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__24))])], ++ (Qast.Str x : 'e__26))])], + Gramext.action +- (fun (a : 'e__24 option) ++ (fun (a : 'e__26 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3713,9 +3756,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__25))])], ++ (Qast.Str x : 'e__27))])], + Gramext.action +- (fun (a : 'e__25 option) ++ (fun (a : 'e__27 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -3922,9 +3965,9 @@ + Gramext.action + (fun (x : string) + (_loc : Lexing.position * Lexing.position) -> +- (Qast.Str x : 'e__26))])], ++ (Qast.Str x : 'e__28))])], + Gramext.action +- (fun (a : 'e__26 option) ++ (fun (a : 'e__28 option) + (_loc : Lexing.position * Lexing.position) -> + (Qast.Option a : 'a_opt)); + [Gramext.Snterm +@@ -4390,9 +4433,9 @@ + Gramext.action + (fun _ (e : 'expr) + (_loc : Lexing.position * Lexing.position) -> +- (e : 'e__29))])], ++ (e : 'e__31))])], + Gramext.action +- (fun (a : 'e__29 list) ++ (fun (a : 'e__31 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -4425,9 +4468,9 @@ + Gramext.action + (fun _ (e : 'expr) + (_loc : Lexing.position * Lexing.position) -> +- (e : 'e__28))])], ++ (e : 'e__30))])], + Gramext.action +- (fun (a : 'e__28 list) ++ (fun (a : 'e__30 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -4454,9 +4497,9 @@ + Gramext.action + (fun _ (e : 'expr) + (_loc : Lexing.position * Lexing.position) -> +- (e : 'e__27))])], ++ (e : 'e__29))])], + Gramext.action +- (fun (a : 'e__27 list) ++ (fun (a : 'e__29 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -4547,9 +4590,9 @@ + Gramext.action + (fun _ (cf : 'class_str_item) + (_loc : Lexing.position * Lexing.position) -> +- (cf : 'e__30))])], ++ (cf : 'e__32))])], + Gramext.action +- (fun (a : 'e__30 list) ++ (fun (a : 'e__32 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -4592,9 +4635,9 @@ + Gramext.action + (fun _ (csf : 'class_sig_item) + (_loc : Lexing.position * Lexing.position) -> +- (csf : 'e__32))])], ++ (csf : 'e__34))])], + Gramext.action +- (fun (a : 'e__32 list) ++ (fun (a : 'e__34 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +@@ -4623,9 +4666,9 @@ + Gramext.action + (fun _ (csf : 'class_sig_item) + (_loc : Lexing.position * Lexing.position) -> +- (csf : 'e__31))])], ++ (csf : 'e__33))])], + Gramext.action +- (fun (a : 'e__31 list) ++ (fun (a : 'e__33 list) + (_loc : Lexing.position * Lexing.position) -> + (Qast.List a : 'a_list)); + [Gramext.Snterm +Index: camlp4/top/rprint.ml +=================================================================== +RCS file: /net/yquem/devel/caml/repository/csl/camlp4/top/rprint.ml,v +retrieving revision 1.18 +diff -u -r1.18 rprint.ml +--- camlp4/top/rprint.ml 29 Jun 2005 04:11:26 -0000 1.18 ++++ camlp4/top/rprint.ml 5 Apr 2006 02:26:01 -0000 +@@ -288,8 +288,9 @@ + fprintf ppf "@[<2>method %s%s%s :@ %a;@]" + (if priv then "private " else "") (if virt then "virtual " else "") + name Toploop.print_out_type.val ty +- | Ocsg_value name mut ty -> +- fprintf ppf "@[<2>value %s%s :@ %a;@]" (if mut then "mutable " else "") ++ | Ocsg_value name mut virt ty -> ++ fprintf ppf "@[<2>value %s%s%s :@ %a;@]" ++ (if mut then "mutable " else "") (if virt then "virtual " else "") + name Toploop.print_out_type.val ty ] + ; + diff --git a/testlabl/varunion.ml b/testlabl/varunion.ml new file mode 100644 index 00000000..30a410f2 --- /dev/null +++ b/testlabl/varunion.ml @@ -0,0 +1,435 @@ +(* cvs update -r varunion parsing typing bytecomp toplevel *) + +type t = private [> ];; +type u = private [> ] ~ [t];; +type v = [t | u];; +let f x = (x : t :> v);; + +(* bad *) +module Mix(X: sig type t = private [> ] end) + (Y: sig type t = private [> ] end) = + struct type t = [X.t | Y.t] end;; + +(* bad *) +module Mix(X: sig type t = private [> `A of int ] end) + (Y: sig type t = private [> `A of bool] ~ [X.t] end) = + struct type t = [X.t | Y.t] end;; + +(* ok *) +module Mix(X: sig type t = private [> `A of int ] end) + (Y: sig type t = private [> `A of int] ~ [X.t] end) = + struct type t = [X.t | Y.t] end;; + +(* bad *) +module Mix(X: sig type t = private [> `A of int ] end) + (Y: sig type t = private [> `B of bool] ~ [X.t] end) = + struct type t = [X.t | Y.t] end;; + +type 'a t = private [> `L of 'a] ~ [`L];; + +(* ok *) +module Mix(X: sig type t = private [> `A of int ] ~ [`B] end) + (Y: sig type t = private [> `B of bool] ~ [X.t] end) = + struct type t = [X.t | Y.t] let is_t = function #t -> true | _ -> false end;; + +module Mix(X: sig type t = private [> `A of int ] ~ [`B] end) + (Y: sig type t = private [> `B of bool] ~ [X.t] end) = + struct + type t = [X.t | Y.t] + let which = function #X.t -> `X | #Y.t -> `Y + end;; + +module Mix(I: sig type t = private [> ] ~ [`A;`B] end) + (X: sig type t = private [> I.t | `A of int ] ~ [`B] end) + (Y: sig type t = private [> I.t | `B of bool] ~ [X.t] end) = + struct + type t = [X.t | Y.t] + let which = function #X.t -> `X | #Y.t -> `Y + end;; + +(* ok *) +module M = + Mix(struct type t = [`C of char] end) + (struct type t = [`A of int | `C of char] end) + (struct type t = [`B of bool | `C of char] end);; + +(* bad *) +module M = + Mix(struct type t = [`B of bool] end) + (struct type t = [`A of int | `B of bool] end) + (struct type t = [`B of bool | `C of char] end);; + +(* ok *) +module M1 = struct type t = [`A of int | `C of char] end +module M2 = struct type t = [`B of bool | `C of char] end +module I = struct type t = [`C of char] end +module M = Mix(I)(M1)(M2) ;; + +let c = (`C 'c' : M.t) ;; + +module M(X : sig type t = private [> `A] end) = + struct let f (#X.t as x) = x end;; + +(* code generation *) +type t = private [> `A ] ~ [`B];; +match `B with #t -> 1 | `B -> 2;; + +module M : sig type t = private [> `A of int | `B] ~ [`C] end = + struct type t = [`A of int | `B | `D of bool] end;; +let f = function (`C | #M.t) -> 1+1 ;; +let f = function (`A _ | `B #M.t) -> 1+1 ;; + +(* expression *) +module Mix(X:sig type t = private [> ] val show: t -> string end) + (Y:sig type t = private [> ] ~ [X.t] val show: t -> string end) = + struct + type t = [X.t | Y.t] + let show : t -> string = function + #X.t as x -> X.show x + | #Y.t as y -> Y.show y + end;; + +module EStr = struct + type t = [`Str of string] + let show (`Str s) = s +end +module EInt = struct + type t = [`Int of int] + let show (`Int i) = string_of_int i +end +module M = Mix(EStr)(EInt);; + +module type T = sig type t = private [> ] val show: t -> string end +module Mix(X:T)(Y:T with type t = private [> ] ~ [X.t]) : + T with type t = [X.t | Y.t] = + struct + type t = [X.t | Y.t] + let show = function + #X.t as x -> X.show x + | #Y.t as y -> Y.show y + end;; +module M = Mix(EStr)(EInt);; + +(* deep *) +module M : sig type t = private [> `A] end = struct type t = [`A] end +module M' : sig type t = private [> ] end = struct type t = [M.t | `A] end;; + +(* bad *) +type t = private [> ] +type u = private [> `A of int] ~ [t] ;; + +(* ok *) +type t = private [> `A of int] +type u = private [> `A of int] ~ [t] ;; + +module F(X: sig + type t = private [> ] ~ [`A;`B;`C;`D] + type u = private [> `A|`B|`C] ~ [t; `D] +end) : sig type v = private [< X.t | X.u | `D] end = struct + open X + let f = function #u -> 1 | #t -> 2 | `D -> 3 + let g = function #u|#t|`D -> 2 + type v = [t|u|`D] +end + +(* ok *) +module M = struct type t = private [> `A] end;; +module M' : sig type t = private [> ] ~ [`A] end = M;; + +(* ok *) +module type T = sig type t = private [> ] ~ [`A] end;; +module type T' = T with type t = private [> `A];; + +(* ok *) +type t = private [> ] ~ [`A] +let f = function `A x -> x | #t -> 0 +type t' = private [< `A of int | t];; + +(* should be ok *) +module F(X:sig end) : + sig type t = private [> ] type u = private [> ] ~ [t] end = + struct type t = [ `A] type u = [`B] end +module M = F(String) +let f = function #M.t -> 1 | #M.u -> 2 +let f = function #M.t -> 1 | _ -> 2 +type t = [M.t | M.u] +let f = function #t -> 1 | _ -> 2;; +module G(X : sig type t = private [> ] type u = private [> ] ~ [t] end) = + struct let f = function #X.t -> 1 | _ -> 2 end;; +module M1 = G(struct module N = F(String) type t = N.t type u = N.u end) ;; +module M1 = G(struct type t = M.t type u = M.u end) ;; +(* bad *) +let f = function #F(String).t -> 1 | _ -> 2;; +type t = [F(String).t | M.u] +let f = function #t -> 1 | _ -> 2;; +module N : sig type t = private [> ] end = + struct type t = [F(String).t | M.u] end;; + +(* compatibility improvement *) +type a = [`A of int | `B] +type b = [`A of bool | `B] +type c = private [> ] ~ [a;b] +let f = function #c -> 1 | `A x -> truncate x +type d = private [> ] ~ [a] +let g = function #d -> 1 | `A x -> truncate x;; + + +(* Expression Problem: functorial form *) + +type num = [ `Num of int ] + +module type Exp = sig + type t = private [> num] + val eval : t -> t + val show : t -> string +end + +module Num(X : Exp) = struct + type t = num + let eval (`Num _ as x) : X.t = x + let show (`Num n) = string_of_int n +end + +type 'a add = [ `Add of 'a * 'a ] + +module Add(X : Exp with type t = private [> num | 'a add] as 'a) = struct + type t = X.t add + let show (`Add(e1, e2) : t) = "("^ X.show e1 ^"+"^ X.show e2 ^")" + let eval (`Add(e1, e2) : t) = + let e1 = X.eval e1 and e2 = X.eval e2 in + match e1, e2 with + `Num n1, `Num n2 -> `Num (n1+n2) + | `Num 0, e | e, `Num 0 -> e + | e12 -> `Add e12 +end + +type 'a mul = [`Mul of 'a * 'a] + +module Mul(X : Exp with type t = private [> num | 'a mul] as 'a) = struct + type t = X.t mul + let show (`Mul(e1, e2) : t) = "("^ X.show e1 ^"*"^ X.show e2 ^")" + let eval (`Mul(e1, e2) : t) = + let e1 = X.eval e1 and e2 = X.eval e2 in + match e1, e2 with + `Num n1, `Num n2 -> `Num (n1*n2) + | `Num 0, e | e, `Num 0 -> `Num 0 + | `Num 1, e | e, `Num 1 -> e + | e12 -> `Mul e12 +end + +module Ext(X : sig type t = private [> ] end)(Y : sig type t end) = struct + module type S = + sig + type t = private [> ] ~ [ X.t ] + val eval : t -> Y.t + val show : t -> string + end +end + +module Dummy = struct type t = [`Dummy] end + +module Mix(E : Exp)(E1 : Ext(Dummy)(E).S)(E2 : Ext(E1)(E).S) = + struct + type t = [E1.t | E2.t] + let eval = function + #E1.t as x -> E1.eval x + | #E2.t as x -> E2.eval x + let show = function + #E1.t as x -> E1.show x + | #E2.t as x -> E2.show x + end + +module rec EAdd : (Exp with type t = [num | EAdd.t add]) = + Mix(EAdd)(Num(EAdd))(Add(EAdd)) + +(* A bit heavy: one must pass E to everybody *) +module rec E : Exp with type t = [num | E.t add | E.t mul] = + Mix(E)(Mix(E)(Num(E))(Add(E)))(Mul(E)) + +let e = E.eval (`Add(`Mul(`Num 2,`Num 3),`Num 1)) + +(* Alternatives *) +(* Direct approach, no need of Mix *) +module rec E : (Exp with type t = [num | E.t add | E.t mul]) = + struct + module E1 = Num(E) + module E2 = Add(E) + module E3 = Mul(E) + type t = E.t + let show = function + | #num as x -> E1.show x + | #add as x -> E2.show x + | #mul as x -> E3.show x + let eval = function + | #num as x -> E1.eval x + | #add as x -> E2.eval x + | #mul as x -> E3.eval x + end + +(* Do functor applications in Mix *) +module type T = sig type t = private [> ] end +module type Tnum = sig type t = private [> num] end + +module Ext(E : Tnum) = struct + module type S = functor (Y : Exp with type t = E.t) -> + sig + type t = private [> num] + val eval : t -> Y.t + val show : t -> string + end +end + +module Ext'(E : Tnum)(X : T) = struct + module type S = functor (Y : Exp with type t = E.t) -> + sig + type t = private [> ] ~ [ X.t ] + val eval : t -> Y.t + val show : t -> string + end +end + +module Mix(E : Exp)(F1 : Ext(E).S)(F2 : Ext'(E)(F1(E)).S) = + struct + module E1 = F1(E) + module E2 = F2(E) + type t = [E1.t | E2.t] + let eval = function + #E1.t as x -> E1.eval x + | #E2.t as x -> E2.eval x + let show = function + #E1.t as x -> E1.show x + | #E2.t as x -> E2.show x + end + +module Join(E : Exp)(F1 : Ext(E).S)(F2 : Ext'(E)(F1(E)).S) + (E' : Exp with type t = E.t) = + Mix(E)(F1)(F2) + +module rec EAdd : (Exp with type t = [num | EAdd.t add]) = + Mix(EAdd)(Num)(Add) + +module rec EMul : (Exp with type t = [num | EMul.t mul]) = + Mix(EMul)(Num)(Mul) + +module rec E : (Exp with type t = [num | E.t add | E.t mul]) = + Mix(E)(Join(E)(Num)(Add))(Mul) + +(* Linear extension by the end: not so nice *) +module LExt(X : T) = struct + module type S = + sig + type t + val eval : t -> X.t + val show : t -> string + end +end +module LNum(E: Exp)(X : LExt(E).S with type t = private [> ] ~ [num]) = + struct + type t = [num | X.t] + let show = function + `Num n -> string_of_int n + | #X.t as x -> X.show x + let eval = function + #num as x -> x + | #X.t as x -> X.eval x + end +module LAdd(E : Exp with type t = private [> num | 'a add] as 'a) + (X : LExt(E).S with type t = private [> ] ~ [add]) = + struct + type t = [E.t add | X.t] + let show = function + `Add(e1,e2) -> "("^ E.show e1 ^"+"^ E.show e2 ^")" + | #X.t as x -> X.show x + let eval = function + `Add(e1,e2) -> + let e1 = E.eval e1 and e2 = E.eval e2 in + begin match e1, e2 with + `Num n1, `Num n2 -> `Num (n1+n2) + | `Num 0, e | e, `Num 0 -> e + | e12 -> `Add e12 + end + | #X.t as x -> X.eval x + end +module LEnd = struct + type t = [`Dummy] + let show `Dummy = "" + let eval `Dummy = `Dummy +end +module rec L : Exp with type t = [num | L.t add | `Dummy] = + LAdd(L)(LNum(L)(LEnd)) + +(* Back to first form, but add map *) + +module Num(X : Exp) = struct + type t = num + let map f x = x + let eval1 (`Num _ as x) : X.t = x + let show (`Num n) = string_of_int n +end + +module Add(X : Exp with type t = private [> num | 'a add] as 'a) = struct + type t = X.t add + let show (`Add(e1, e2) : t) = "("^ X.show e1 ^"+"^ X.show e2 ^")" + let map f (`Add(e1, e2) : t) = `Add(f e1, f e2) + let eval1 (`Add(e1, e2) as e : t) = + match e1, e2 with + `Num n1, `Num n2 -> `Num (n1+n2) + | `Num 0, e | e, `Num 0 -> e + | _ -> e +end + +module Mul(X : Exp with type t = private [> num | 'a mul] as 'a) = struct + type t = X.t mul + let show (`Mul(e1, e2) : t) = "("^ X.show e1 ^"*"^ X.show e2 ^")" + let map f (`Mul(e1, e2) : t) = `Mul(f e1, f e2) + let eval1 (`Mul(e1, e2) as e : t) = + match e1, e2 with + `Num n1, `Num n2 -> `Num (n1*n2) + | `Num 0, e | e, `Num 0 -> `Num 0 + | `Num 1, e | e, `Num 1 -> e + | _ -> e +end + +module Ext(X : sig type t = private [> ] end)(Y : sig type t end) = struct + module type S = + sig + type t = private [> ] ~ [ X.t ] + val map : (Y.t -> Y.t) -> t -> t + val eval1 : t -> Y.t + val show : t -> string + end +end + +module Mix(E : Exp)(E1 : Ext(Dummy)(E).S)(E2 : Ext(E1)(E).S) = + struct + type t = [E1.t | E2.t] + let map f = function + #E1.t as x -> (E1.map f x : E1.t :> t) + | #E2.t as x -> (E2.map f x : E2.t :> t) + let eval1 = function + #E1.t as x -> E1.eval1 x + | #E2.t as x -> E2.eval1 x + let show = function + #E1.t as x -> E1.show x + | #E2.t as x -> E2.show x + end + +module type ET = sig + type t + val map : (t -> t) -> t -> t + val eval1 : t -> t + val show : t -> string +end + +module Fin(E : ET) = struct + include E + let rec eval e = eval1 (map eval e) +end + +module rec EAdd : (Exp with type t = [num | EAdd.t add]) = + Fin(Mix(EAdd)(Num(EAdd))(Add(EAdd))) + +module rec E : Exp with type t = [num | E.t add | E.t mul] = + Fin(Mix(E)(Mix(E)(Num(E))(Add(E)))(Mul(E))) + +let e = E.eval (`Add(`Mul(`Num 2,`Num 3),`Num 1)) diff --git a/typing/unused_var.ml b/typing/unused_var.ml index ce845760..b966a6dc 100644 --- a/typing/unused_var.ml +++ b/typing/unused_var.ml @@ -10,7 +10,7 @@ (* *) (***********************************************************************) -(* $Id: unused_var.ml 10250 2010-04-08 03:58:41Z garrigue $ *) +(* $Id: unused_var.ml 11110 2011-07-04 21:15:01Z doligez $ *) open Parsetree @@ -105,7 +105,7 @@ and structure_item ppf tbl s = | Pstr_open _ -> () | Pstr_class cdl -> List.iter (class_declaration ppf tbl) cdl; | Pstr_class_type _ -> () - | Pstr_include _ -> () + | Pstr_include me -> module_expr ppf tbl me; and expression ppf tbl e = match e.pexp_desc with -- 2.30.2