--- ocaml-3.08.2/.depend	2004-07-09 16:55:09.000000000 +0100
+++ fresh-ocaml-3.08.2/.depend	2005-01-10 14:06:36.000000000 +0000
@@ -1,6 +1,6 @@
-utils/ccomp.cmo: utils/clflags.cmo utils/config.cmi utils/misc.cmi \
+utils/ccomp.cmo: utils/misc.cmi utils/config.cmi utils/clflags.cmo \
     utils/ccomp.cmi 
-utils/ccomp.cmx: utils/clflags.cmx utils/config.cmx utils/misc.cmx \
+utils/ccomp.cmx: utils/misc.cmx utils/config.cmx utils/clflags.cmx \
     utils/ccomp.cmi 
 utils/clflags.cmo: utils/config.cmi 
 utils/clflags.cmx: utils/config.cmx 
@@ -16,763 +16,759 @@
 utils/terminfo.cmx: utils/terminfo.cmi 
 utils/warnings.cmo: utils/warnings.cmi 
 utils/warnings.cmx: utils/warnings.cmi 
-parsing/lexer.cmi: parsing/location.cmi parsing/parser.cmi 
+parsing/lexer.cmi: parsing/parser.cmi parsing/location.cmi 
 parsing/location.cmi: utils/warnings.cmi 
 parsing/parse.cmi: parsing/parsetree.cmi 
 parsing/parser.cmi: parsing/parsetree.cmi 
-parsing/parsetree.cmi: parsing/asttypes.cmi parsing/location.cmi \
-    parsing/longident.cmi 
+parsing/parsetree.cmi: parsing/longident.cmi parsing/location.cmi \
+    parsing/asttypes.cmi 
 parsing/printast.cmi: parsing/parsetree.cmi 
 parsing/syntaxerr.cmi: parsing/location.cmi 
-parsing/lexer.cmo: parsing/location.cmi utils/misc.cmi parsing/parser.cmi \
-    utils/warnings.cmi parsing/lexer.cmi 
-parsing/lexer.cmx: parsing/location.cmx utils/misc.cmx parsing/parser.cmx \
-    utils/warnings.cmx parsing/lexer.cmi 
+parsing/lexer.cmo: utils/warnings.cmi parsing/parser.cmi utils/misc.cmi \
+    parsing/location.cmi parsing/lexer.cmi 
+parsing/lexer.cmx: utils/warnings.cmx parsing/parser.cmx utils/misc.cmx \
+    parsing/location.cmx parsing/lexer.cmi 
 parsing/linenum.cmo: utils/misc.cmi parsing/linenum.cmi 
 parsing/linenum.cmx: utils/misc.cmx parsing/linenum.cmi 
-parsing/location.cmo: parsing/linenum.cmi utils/terminfo.cmi \
-    utils/warnings.cmi parsing/location.cmi 
-parsing/location.cmx: parsing/linenum.cmx utils/terminfo.cmx \
-    utils/warnings.cmx parsing/location.cmi 
+parsing/location.cmo: utils/warnings.cmi utils/terminfo.cmi \
+    parsing/linenum.cmi parsing/location.cmi 
+parsing/location.cmx: utils/warnings.cmx utils/terminfo.cmx \
+    parsing/linenum.cmx parsing/location.cmi 
 parsing/longident.cmo: utils/misc.cmi parsing/longident.cmi 
 parsing/longident.cmx: utils/misc.cmx parsing/longident.cmi 
-parsing/parse.cmo: parsing/lexer.cmi parsing/location.cmi parsing/parser.cmi \
-    parsing/syntaxerr.cmi parsing/parse.cmi 
-parsing/parse.cmx: parsing/lexer.cmx parsing/location.cmx parsing/parser.cmx \
-    parsing/syntaxerr.cmx parsing/parse.cmi 
-parsing/parser.cmo: parsing/asttypes.cmi utils/clflags.cmo \
-    parsing/location.cmi parsing/longident.cmi parsing/parsetree.cmi \
-    parsing/syntaxerr.cmi parsing/parser.cmi 
-parsing/parser.cmx: parsing/asttypes.cmi utils/clflags.cmx \
-    parsing/location.cmx parsing/longident.cmx parsing/parsetree.cmi \
-    parsing/syntaxerr.cmx parsing/parser.cmi 
-parsing/printast.cmo: parsing/asttypes.cmi parsing/location.cmi \
-    parsing/longident.cmi parsing/parsetree.cmi parsing/printast.cmi 
-parsing/printast.cmx: parsing/asttypes.cmi parsing/location.cmx \
-    parsing/longident.cmx parsing/parsetree.cmi parsing/printast.cmi 
+parsing/parse.cmo: parsing/syntaxerr.cmi parsing/parser.cmi \
+    parsing/location.cmi parsing/lexer.cmi parsing/parse.cmi 
+parsing/parse.cmx: parsing/syntaxerr.cmx parsing/parser.cmx \
+    parsing/location.cmx parsing/lexer.cmx parsing/parse.cmi 
+parsing/parser.cmo: parsing/syntaxerr.cmi parsing/parsetree.cmi \
+    parsing/longident.cmi parsing/location.cmi utils/clflags.cmo \
+    parsing/asttypes.cmi parsing/parser.cmi 
+parsing/parser.cmx: parsing/syntaxerr.cmx parsing/parsetree.cmi \
+    parsing/longident.cmx parsing/location.cmx utils/clflags.cmx \
+    parsing/asttypes.cmi parsing/parser.cmi 
+parsing/printast.cmo: parsing/parsetree.cmi parsing/longident.cmi \
+    parsing/location.cmi parsing/asttypes.cmi parsing/printast.cmi 
+parsing/printast.cmx: parsing/parsetree.cmi parsing/longident.cmx \
+    parsing/location.cmx parsing/asttypes.cmi parsing/printast.cmi 
 parsing/syntaxerr.cmo: parsing/location.cmi parsing/syntaxerr.cmi 
 parsing/syntaxerr.cmx: parsing/location.cmx parsing/syntaxerr.cmi 
-typing/btype.cmi: parsing/asttypes.cmi typing/path.cmi typing/types.cmi 
-typing/ctype.cmi: parsing/asttypes.cmi typing/env.cmi typing/ident.cmi \
-    typing/path.cmi typing/types.cmi 
-typing/datarepr.cmi: parsing/asttypes.cmi typing/path.cmi typing/types.cmi 
-typing/env.cmi: utils/consistbl.cmi typing/ident.cmi parsing/longident.cmi \
-    typing/path.cmi typing/types.cmi 
-typing/includeclass.cmi: typing/ctype.cmi typing/env.cmi typing/typedtree.cmi \
-    typing/types.cmi 
-typing/includecore.cmi: typing/env.cmi typing/ident.cmi typing/typedtree.cmi \
-    typing/types.cmi 
-typing/includemod.cmi: typing/ctype.cmi typing/env.cmi typing/ident.cmi \
-    typing/typedtree.cmi typing/types.cmi 
-typing/mtype.cmi: typing/env.cmi typing/ident.cmi typing/path.cmi \
-    typing/types.cmi 
+typing/btype.cmi: typing/types.cmi typing/path.cmi parsing/asttypes.cmi 
+typing/ctype.cmi: typing/types.cmi typing/path.cmi typing/ident.cmi \
+    typing/env.cmi parsing/asttypes.cmi 
+typing/datarepr.cmi: typing/types.cmi typing/path.cmi parsing/asttypes.cmi 
+typing/env.cmi: typing/types.cmi typing/path.cmi parsing/longident.cmi \
+    typing/ident.cmi utils/consistbl.cmi 
+typing/includeclass.cmi: typing/types.cmi typing/typedtree.cmi typing/env.cmi \
+    typing/ctype.cmi 
+typing/includecore.cmi: typing/types.cmi typing/typedtree.cmi \
+    typing/ident.cmi typing/env.cmi 
+typing/includemod.cmi: typing/types.cmi typing/typedtree.cmi typing/ident.cmi \
+    typing/env.cmi typing/ctype.cmi 
+typing/mtype.cmi: typing/types.cmi typing/path.cmi typing/ident.cmi \
+    typing/env.cmi 
 typing/oprint.cmi: typing/outcometree.cmi 
 typing/outcometree.cmi: parsing/asttypes.cmi 
-typing/parmatch.cmi: typing/env.cmi parsing/location.cmi typing/typedtree.cmi \
-    typing/types.cmi 
+typing/parmatch.cmi: typing/types.cmi typing/typedtree.cmi \
+    parsing/location.cmi typing/env.cmi 
 typing/path.cmi: typing/ident.cmi 
-typing/predef.cmi: typing/ident.cmi typing/path.cmi typing/types.cmi 
-typing/printtyp.cmi: typing/ident.cmi parsing/longident.cmi \
-    typing/outcometree.cmi typing/path.cmi typing/types.cmi 
-typing/stypes.cmi: parsing/location.cmi typing/typedtree.cmi 
-typing/subst.cmi: typing/ident.cmi typing/path.cmi typing/types.cmi 
-typing/typeclass.cmi: parsing/asttypes.cmi typing/ctype.cmi typing/env.cmi \
-    typing/ident.cmi parsing/location.cmi parsing/longident.cmi \
-    parsing/parsetree.cmi typing/typedtree.cmi typing/types.cmi 
-typing/typecore.cmi: parsing/asttypes.cmi typing/env.cmi typing/ident.cmi \
-    parsing/location.cmi parsing/longident.cmi parsing/parsetree.cmi \
-    typing/path.cmi typing/typedtree.cmi typing/types.cmi 
-typing/typedecl.cmi: typing/env.cmi typing/ident.cmi parsing/location.cmi \
-    parsing/longident.cmi parsing/parsetree.cmi typing/path.cmi \
-    typing/types.cmi 
-typing/typedtree.cmi: parsing/asttypes.cmi typing/env.cmi typing/ident.cmi \
-    parsing/location.cmi typing/path.cmi typing/primitive.cmi \
-    typing/types.cmi 
-typing/typemod.cmi: typing/env.cmi typing/ident.cmi typing/includemod.cmi \
-    parsing/location.cmi parsing/longident.cmi parsing/parsetree.cmi \
-    typing/typedtree.cmi typing/types.cmi 
-typing/types.cmi: parsing/asttypes.cmi typing/ident.cmi typing/path.cmi \
-    typing/primitive.cmi 
-typing/typetexp.cmi: typing/env.cmi parsing/location.cmi \
-    parsing/longident.cmi parsing/parsetree.cmi typing/path.cmi \
-    typing/types.cmi 
-typing/btype.cmo: utils/misc.cmi typing/path.cmi typing/types.cmi \
+typing/predef.cmi: typing/types.cmi typing/path.cmi typing/ident.cmi 
+typing/printtyp.cmi: typing/types.cmi typing/path.cmi typing/outcometree.cmi \
+    parsing/longident.cmi typing/ident.cmi 
+typing/stypes.cmi: typing/typedtree.cmi parsing/location.cmi 
+typing/subst.cmi: typing/types.cmi typing/path.cmi typing/ident.cmi 
+typing/typeclass.cmi: typing/types.cmi typing/typedtree.cmi \
+    parsing/parsetree.cmi parsing/longident.cmi parsing/location.cmi \
+    typing/ident.cmi typing/env.cmi typing/ctype.cmi parsing/asttypes.cmi 
+typing/typecore.cmi: typing/types.cmi typing/typedtree.cmi typing/path.cmi \
+    parsing/parsetree.cmi parsing/longident.cmi parsing/location.cmi \
+    typing/ident.cmi typing/env.cmi parsing/asttypes.cmi 
+typing/typedecl.cmi: typing/types.cmi typing/path.cmi parsing/parsetree.cmi \
+    parsing/longident.cmi parsing/location.cmi typing/ident.cmi \
+    typing/env.cmi 
+typing/typedtree.cmi: typing/types.cmi typing/primitive.cmi typing/path.cmi \
+    parsing/location.cmi typing/ident.cmi typing/env.cmi parsing/asttypes.cmi 
+typing/typemod.cmi: typing/types.cmi typing/typedtree.cmi \
+    parsing/parsetree.cmi parsing/longident.cmi parsing/location.cmi \
+    typing/includemod.cmi typing/ident.cmi typing/env.cmi 
+typing/types.cmi: typing/primitive.cmi typing/path.cmi typing/ident.cmi \
+    parsing/asttypes.cmi 
+typing/typetexp.cmi: typing/types.cmi typing/path.cmi parsing/parsetree.cmi \
+    parsing/longident.cmi parsing/location.cmi typing/env.cmi 
+typing/btype.cmo: typing/types.cmi typing/path.cmi utils/misc.cmi \
     typing/btype.cmi 
-typing/btype.cmx: utils/misc.cmx typing/path.cmx typing/types.cmx \
+typing/btype.cmx: typing/types.cmx typing/path.cmx utils/misc.cmx \
     typing/btype.cmi 
-typing/ctype.cmo: parsing/asttypes.cmi typing/btype.cmi utils/clflags.cmo \
-    typing/env.cmi typing/ident.cmi parsing/longident.cmi utils/misc.cmi \
-    typing/path.cmi typing/subst.cmi typing/types.cmi typing/ctype.cmi 
-typing/ctype.cmx: parsing/asttypes.cmi typing/btype.cmx utils/clflags.cmx \
-    typing/env.cmx typing/ident.cmx parsing/longident.cmx utils/misc.cmx \
-    typing/path.cmx typing/subst.cmx typing/types.cmx typing/ctype.cmi 
-typing/datarepr.cmo: parsing/asttypes.cmi utils/misc.cmi typing/predef.cmi \
-    typing/types.cmi typing/datarepr.cmi 
-typing/datarepr.cmx: parsing/asttypes.cmi utils/misc.cmx typing/predef.cmx \
-    typing/types.cmx typing/datarepr.cmi 
-typing/env.cmo: parsing/asttypes.cmi typing/btype.cmi utils/config.cmi \
-    utils/consistbl.cmi typing/datarepr.cmi typing/ident.cmi \
-    parsing/longident.cmi utils/misc.cmi typing/path.cmi typing/predef.cmi \
-    typing/subst.cmi utils/tbl.cmi typing/types.cmi typing/env.cmi 
-typing/env.cmx: parsing/asttypes.cmi typing/btype.cmx utils/config.cmx \
-    utils/consistbl.cmx typing/datarepr.cmx typing/ident.cmx \
-    parsing/longident.cmx utils/misc.cmx typing/path.cmx typing/predef.cmx \
-    typing/subst.cmx utils/tbl.cmx typing/types.cmx typing/env.cmi 
+typing/ctype.cmo: typing/types.cmi typing/subst.cmi typing/path.cmi \
+    utils/misc.cmi parsing/longident.cmi typing/ident.cmi typing/env.cmi \
+    utils/clflags.cmo typing/btype.cmi parsing/asttypes.cmi typing/ctype.cmi 
+typing/ctype.cmx: typing/types.cmx typing/subst.cmx typing/path.cmx \
+    utils/misc.cmx parsing/longident.cmx typing/ident.cmx typing/env.cmx \
+    utils/clflags.cmx typing/btype.cmx parsing/asttypes.cmi typing/ctype.cmi 
+typing/datarepr.cmo: typing/types.cmi typing/predef.cmi utils/misc.cmi \
+    parsing/asttypes.cmi typing/datarepr.cmi 
+typing/datarepr.cmx: typing/types.cmx typing/predef.cmx utils/misc.cmx \
+    parsing/asttypes.cmi typing/datarepr.cmi 
+typing/env.cmo: typing/types.cmi utils/tbl.cmi typing/subst.cmi \
+    typing/predef.cmi typing/path.cmi utils/misc.cmi parsing/longident.cmi \
+    typing/ident.cmi typing/datarepr.cmi utils/consistbl.cmi utils/config.cmi \
+    typing/btype.cmi parsing/asttypes.cmi typing/env.cmi 
+typing/env.cmx: typing/types.cmx utils/tbl.cmx typing/subst.cmx \
+    typing/predef.cmx typing/path.cmx utils/misc.cmx parsing/longident.cmx \
+    typing/ident.cmx typing/datarepr.cmx utils/consistbl.cmx utils/config.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/env.cmi 
 typing/ident.cmo: typing/ident.cmi 
 typing/ident.cmx: typing/ident.cmi 
-typing/includeclass.cmo: typing/ctype.cmi typing/printtyp.cmi \
-    typing/types.cmi typing/includeclass.cmi 
-typing/includeclass.cmx: typing/ctype.cmx typing/printtyp.cmx \
-    typing/types.cmx typing/includeclass.cmi 
-typing/includecore.cmo: parsing/asttypes.cmi typing/btype.cmi \
-    typing/ctype.cmi utils/misc.cmi typing/path.cmi typing/predef.cmi \
-    typing/typedtree.cmi typing/types.cmi typing/includecore.cmi 
-typing/includecore.cmx: parsing/asttypes.cmi typing/btype.cmx \
-    typing/ctype.cmx utils/misc.cmx typing/path.cmx typing/predef.cmx \
-    typing/typedtree.cmx typing/types.cmx typing/includecore.cmi 
-typing/includemod.cmo: typing/ctype.cmi typing/env.cmi typing/ident.cmi \
-    typing/includeclass.cmi typing/includecore.cmi utils/misc.cmi \
-    typing/mtype.cmi typing/path.cmi typing/printtyp.cmi typing/subst.cmi \
-    utils/tbl.cmi typing/typedtree.cmi typing/types.cmi typing/includemod.cmi 
-typing/includemod.cmx: typing/ctype.cmx typing/env.cmx typing/ident.cmx \
-    typing/includeclass.cmx typing/includecore.cmx utils/misc.cmx \
-    typing/mtype.cmx typing/path.cmx typing/printtyp.cmx typing/subst.cmx \
-    utils/tbl.cmx typing/typedtree.cmx typing/types.cmx typing/includemod.cmi 
-typing/mtype.cmo: typing/btype.cmi typing/ctype.cmi typing/env.cmi \
-    typing/ident.cmi typing/path.cmi typing/subst.cmi typing/types.cmi \
+typing/includeclass.cmo: typing/types.cmi typing/printtyp.cmi \
+    typing/ctype.cmi typing/includeclass.cmi 
+typing/includeclass.cmx: typing/types.cmx typing/printtyp.cmx \
+    typing/ctype.cmx typing/includeclass.cmi 
+typing/includecore.cmo: typing/types.cmi typing/typedtree.cmi \
+    typing/predef.cmi typing/path.cmi utils/misc.cmi typing/ctype.cmi \
+    typing/btype.cmi parsing/asttypes.cmi typing/includecore.cmi 
+typing/includecore.cmx: typing/types.cmx typing/typedtree.cmx \
+    typing/predef.cmx typing/path.cmx utils/misc.cmx typing/ctype.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/includecore.cmi 
+typing/includemod.cmo: typing/types.cmi typing/typedtree.cmi utils/tbl.cmi \
+    typing/subst.cmi typing/printtyp.cmi typing/path.cmi typing/mtype.cmi \
+    utils/misc.cmi typing/includecore.cmi typing/includeclass.cmi \
+    typing/ident.cmi typing/env.cmi typing/ctype.cmi typing/includemod.cmi 
+typing/includemod.cmx: typing/types.cmx typing/typedtree.cmx utils/tbl.cmx \
+    typing/subst.cmx typing/printtyp.cmx typing/path.cmx typing/mtype.cmx \
+    utils/misc.cmx typing/includecore.cmx typing/includeclass.cmx \
+    typing/ident.cmx typing/env.cmx typing/ctype.cmx typing/includemod.cmi 
+typing/mtype.cmo: typing/types.cmi typing/subst.cmi typing/path.cmi \
+    typing/ident.cmi typing/env.cmi typing/ctype.cmi typing/btype.cmi \
     typing/mtype.cmi 
-typing/mtype.cmx: typing/btype.cmx typing/ctype.cmx typing/env.cmx \
-    typing/ident.cmx typing/path.cmx typing/subst.cmx typing/types.cmx \
+typing/mtype.cmx: typing/types.cmx typing/subst.cmx typing/path.cmx \
+    typing/ident.cmx typing/env.cmx typing/ctype.cmx typing/btype.cmx \
     typing/mtype.cmi 
-typing/oprint.cmo: parsing/asttypes.cmi typing/outcometree.cmi \
+typing/oprint.cmo: typing/outcometree.cmi parsing/asttypes.cmi \
     typing/oprint.cmi 
-typing/oprint.cmx: parsing/asttypes.cmi typing/outcometree.cmi \
+typing/oprint.cmx: typing/outcometree.cmi parsing/asttypes.cmi \
     typing/oprint.cmi 
-typing/parmatch.cmo: parsing/asttypes.cmi typing/btype.cmi typing/ctype.cmi \
-    typing/datarepr.cmi typing/env.cmi typing/ident.cmi parsing/location.cmi \
-    utils/misc.cmi typing/path.cmi typing/predef.cmi typing/typedtree.cmi \
-    typing/types.cmi utils/warnings.cmi typing/parmatch.cmi 
-typing/parmatch.cmx: parsing/asttypes.cmi typing/btype.cmx typing/ctype.cmx \
-    typing/datarepr.cmx typing/env.cmx typing/ident.cmx parsing/location.cmx \
-    utils/misc.cmx typing/path.cmx typing/predef.cmx typing/typedtree.cmx \
-    typing/types.cmx utils/warnings.cmx typing/parmatch.cmi 
+typing/parmatch.cmo: utils/warnings.cmi typing/types.cmi typing/typedtree.cmi \
+    typing/predef.cmi typing/path.cmi utils/misc.cmi parsing/location.cmi \
+    typing/ident.cmi typing/env.cmi typing/datarepr.cmi typing/ctype.cmi \
+    typing/btype.cmi parsing/asttypes.cmi typing/parmatch.cmi 
+typing/parmatch.cmx: utils/warnings.cmx typing/types.cmx typing/typedtree.cmx \
+    typing/predef.cmx typing/path.cmx utils/misc.cmx parsing/location.cmx \
+    typing/ident.cmx typing/env.cmx typing/datarepr.cmx typing/ctype.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/parmatch.cmi 
 typing/path.cmo: typing/ident.cmi typing/path.cmi 
 typing/path.cmx: typing/ident.cmx typing/path.cmi 
-typing/predef.cmo: parsing/asttypes.cmi typing/btype.cmi typing/ident.cmi \
-    typing/path.cmi typing/types.cmi typing/predef.cmi 
-typing/predef.cmx: parsing/asttypes.cmi typing/btype.cmx typing/ident.cmx \
-    typing/path.cmx typing/types.cmx typing/predef.cmi 
+typing/predef.cmo: typing/types.cmi typing/path.cmi typing/ident.cmi \
+    typing/btype.cmi parsing/asttypes.cmi typing/predef.cmi 
+typing/predef.cmx: typing/types.cmx typing/path.cmx typing/ident.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/predef.cmi 
 typing/primitive.cmo: utils/misc.cmi typing/primitive.cmi 
 typing/primitive.cmx: utils/misc.cmx typing/primitive.cmi 
-typing/printtyp.cmo: parsing/asttypes.cmi typing/btype.cmi utils/clflags.cmo \
-    typing/ctype.cmi typing/env.cmi typing/ident.cmi parsing/longident.cmi \
-    utils/misc.cmi typing/oprint.cmi typing/outcometree.cmi typing/path.cmi \
-    typing/predef.cmi typing/primitive.cmi typing/types.cmi \
+typing/printtyp.cmo: typing/types.cmi typing/primitive.cmi typing/predef.cmi \
+    typing/path.cmi typing/outcometree.cmi typing/oprint.cmi utils/misc.cmi \
+    parsing/longident.cmi typing/ident.cmi typing/env.cmi typing/ctype.cmi \
+    utils/clflags.cmo typing/btype.cmi parsing/asttypes.cmi \
     typing/printtyp.cmi 
-typing/printtyp.cmx: parsing/asttypes.cmi typing/btype.cmx utils/clflags.cmx \
-    typing/ctype.cmx typing/env.cmx typing/ident.cmx parsing/longident.cmx \
-    utils/misc.cmx typing/oprint.cmx typing/outcometree.cmi typing/path.cmx \
-    typing/predef.cmx typing/primitive.cmx typing/types.cmx \
+typing/printtyp.cmx: typing/types.cmx typing/primitive.cmx typing/predef.cmx \
+    typing/path.cmx typing/outcometree.cmi typing/oprint.cmx utils/misc.cmx \
+    parsing/longident.cmx typing/ident.cmx typing/env.cmx typing/ctype.cmx \
+    utils/clflags.cmx typing/btype.cmx parsing/asttypes.cmi \
     typing/printtyp.cmi 
-typing/stypes.cmo: utils/clflags.cmo parsing/location.cmi typing/printtyp.cmi \
-    typing/typedtree.cmi typing/stypes.cmi 
-typing/stypes.cmx: utils/clflags.cmx parsing/location.cmx typing/printtyp.cmx \
-    typing/typedtree.cmx typing/stypes.cmi 
-typing/subst.cmo: typing/btype.cmi typing/ident.cmi utils/misc.cmi \
-    typing/path.cmi utils/tbl.cmi typing/types.cmi typing/subst.cmi 
-typing/subst.cmx: typing/btype.cmx typing/ident.cmx utils/misc.cmx \
-    typing/path.cmx utils/tbl.cmx typing/types.cmx typing/subst.cmi 
-typing/typeclass.cmo: parsing/asttypes.cmi typing/btype.cmi utils/clflags.cmo \
-    typing/ctype.cmi typing/env.cmi typing/ident.cmi typing/includeclass.cmi \
-    parsing/location.cmi parsing/longident.cmi utils/misc.cmi \
-    typing/parmatch.cmi parsing/parsetree.cmi typing/path.cmi \
-    typing/predef.cmi typing/printtyp.cmi typing/stypes.cmi typing/subst.cmi \
-    typing/typecore.cmi typing/typedecl.cmi typing/typedtree.cmi \
-    typing/types.cmi typing/typetexp.cmi utils/warnings.cmi \
-    typing/typeclass.cmi 
-typing/typeclass.cmx: parsing/asttypes.cmi typing/btype.cmx utils/clflags.cmx \
-    typing/ctype.cmx typing/env.cmx typing/ident.cmx typing/includeclass.cmx \
-    parsing/location.cmx parsing/longident.cmx utils/misc.cmx \
-    typing/parmatch.cmx parsing/parsetree.cmi typing/path.cmx \
-    typing/predef.cmx typing/printtyp.cmx typing/stypes.cmx typing/subst.cmx \
-    typing/typecore.cmx typing/typedecl.cmx typing/typedtree.cmx \
-    typing/types.cmx typing/typetexp.cmx utils/warnings.cmx \
-    typing/typeclass.cmi 
-typing/typecore.cmo: parsing/asttypes.cmi typing/btype.cmi utils/clflags.cmo \
-    typing/ctype.cmi typing/env.cmi typing/ident.cmi parsing/location.cmi \
-    parsing/longident.cmi utils/misc.cmi typing/parmatch.cmi \
-    parsing/parsetree.cmi typing/path.cmi typing/predef.cmi \
-    typing/primitive.cmi typing/printtyp.cmi typing/stypes.cmi \
-    typing/typedtree.cmi typing/types.cmi typing/typetexp.cmi \
-    utils/warnings.cmi typing/typecore.cmi 
-typing/typecore.cmx: parsing/asttypes.cmi typing/btype.cmx utils/clflags.cmx \
-    typing/ctype.cmx typing/env.cmx typing/ident.cmx parsing/location.cmx \
-    parsing/longident.cmx utils/misc.cmx typing/parmatch.cmx \
-    parsing/parsetree.cmi typing/path.cmx typing/predef.cmx \
-    typing/primitive.cmx typing/printtyp.cmx typing/stypes.cmx \
-    typing/typedtree.cmx typing/types.cmx typing/typetexp.cmx \
-    utils/warnings.cmx typing/typecore.cmi 
-typing/typedecl.cmo: parsing/asttypes.cmi typing/btype.cmi utils/clflags.cmo \
-    utils/config.cmi typing/ctype.cmi typing/env.cmi typing/ident.cmi \
-    typing/includecore.cmi parsing/location.cmi parsing/longident.cmi \
-    utils/misc.cmi parsing/parsetree.cmi typing/path.cmi typing/predef.cmi \
-    typing/primitive.cmi typing/printtyp.cmi typing/subst.cmi \
-    typing/typedtree.cmi typing/types.cmi typing/typetexp.cmi \
-    typing/typedecl.cmi 
-typing/typedecl.cmx: parsing/asttypes.cmi typing/btype.cmx utils/clflags.cmx \
-    utils/config.cmx typing/ctype.cmx typing/env.cmx typing/ident.cmx \
-    typing/includecore.cmx parsing/location.cmx parsing/longident.cmx \
-    utils/misc.cmx parsing/parsetree.cmi typing/path.cmx typing/predef.cmx \
-    typing/primitive.cmx typing/printtyp.cmx typing/subst.cmx \
-    typing/typedtree.cmx typing/types.cmx typing/typetexp.cmx \
-    typing/typedecl.cmi 
-typing/typedtree.cmo: parsing/asttypes.cmi typing/env.cmi typing/ident.cmi \
-    parsing/location.cmi utils/misc.cmi typing/path.cmi typing/primitive.cmi \
-    typing/types.cmi typing/typedtree.cmi 
-typing/typedtree.cmx: parsing/asttypes.cmi typing/env.cmx typing/ident.cmx \
-    parsing/location.cmx utils/misc.cmx typing/path.cmx typing/primitive.cmx \
-    typing/types.cmx typing/typedtree.cmi 
-typing/typemod.cmo: utils/clflags.cmo utils/config.cmi typing/ctype.cmi \
-    typing/env.cmi typing/ident.cmi typing/includemod.cmi \
-    parsing/location.cmi parsing/longident.cmi utils/misc.cmi \
-    typing/mtype.cmi parsing/parsetree.cmi typing/path.cmi \
-    typing/printtyp.cmi typing/stypes.cmi typing/subst.cmi \
-    typing/typeclass.cmi typing/typecore.cmi typing/typedecl.cmi \
-    typing/typedtree.cmi typing/types.cmi typing/typemod.cmi 
-typing/typemod.cmx: utils/clflags.cmx utils/config.cmx typing/ctype.cmx \
-    typing/env.cmx typing/ident.cmx typing/includemod.cmx \
-    parsing/location.cmx parsing/longident.cmx utils/misc.cmx \
-    typing/mtype.cmx parsing/parsetree.cmi typing/path.cmx \
-    typing/printtyp.cmx typing/stypes.cmx typing/subst.cmx \
-    typing/typeclass.cmx typing/typecore.cmx typing/typedecl.cmx \
-    typing/typedtree.cmx typing/types.cmx typing/typemod.cmi 
-typing/types.cmo: parsing/asttypes.cmi typing/ident.cmi utils/misc.cmi \
-    typing/path.cmi typing/primitive.cmi typing/types.cmi 
-typing/types.cmx: parsing/asttypes.cmi typing/ident.cmx utils/misc.cmx \
-    typing/path.cmx typing/primitive.cmx typing/types.cmi 
-typing/typetexp.cmo: typing/btype.cmi typing/ctype.cmi typing/env.cmi \
-    parsing/location.cmi parsing/longident.cmi utils/misc.cmi \
-    parsing/parsetree.cmi typing/path.cmi typing/printtyp.cmi utils/tbl.cmi \
-    typing/types.cmi utils/warnings.cmi typing/typetexp.cmi 
-typing/typetexp.cmx: typing/btype.cmx typing/ctype.cmx typing/env.cmx \
-    parsing/location.cmx parsing/longident.cmx utils/misc.cmx \
-    parsing/parsetree.cmi typing/path.cmx typing/printtyp.cmx utils/tbl.cmx \
-    typing/types.cmx utils/warnings.cmx typing/typetexp.cmi 
-bytecomp/bytegen.cmi: bytecomp/instruct.cmi bytecomp/lambda.cmi 
-bytecomp/bytelink.cmi: bytecomp/emitcode.cmi bytecomp/symtable.cmi 
+typing/stypes.cmo: typing/typedtree.cmi typing/printtyp.cmi \
+    parsing/location.cmi utils/clflags.cmo typing/stypes.cmi 
+typing/stypes.cmx: typing/typedtree.cmx typing/printtyp.cmx \
+    parsing/location.cmx utils/clflags.cmx typing/stypes.cmi 
+typing/subst.cmo: typing/types.cmi utils/tbl.cmi typing/path.cmi \
+    utils/misc.cmi typing/ident.cmi typing/btype.cmi typing/subst.cmi 
+typing/subst.cmx: typing/types.cmx utils/tbl.cmx typing/path.cmx \
+    utils/misc.cmx typing/ident.cmx typing/btype.cmx typing/subst.cmi 
+typing/typeclass.cmo: utils/warnings.cmi typing/typetexp.cmi typing/types.cmi \
+    typing/typedtree.cmi typing/typedecl.cmi typing/typecore.cmi \
+    typing/subst.cmi typing/stypes.cmi typing/printtyp.cmi typing/predef.cmi \
+    typing/path.cmi parsing/parsetree.cmi typing/parmatch.cmi utils/misc.cmi \
+    parsing/longident.cmi parsing/location.cmi typing/includeclass.cmi \
+    typing/ident.cmi typing/env.cmi typing/ctype.cmi utils/clflags.cmo \
+    typing/btype.cmi parsing/asttypes.cmi typing/typeclass.cmi 
+typing/typeclass.cmx: utils/warnings.cmx typing/typetexp.cmx typing/types.cmx \
+    typing/typedtree.cmx typing/typedecl.cmx typing/typecore.cmx \
+    typing/subst.cmx typing/stypes.cmx typing/printtyp.cmx typing/predef.cmx \
+    typing/path.cmx parsing/parsetree.cmi typing/parmatch.cmx utils/misc.cmx \
+    parsing/longident.cmx parsing/location.cmx typing/includeclass.cmx \
+    typing/ident.cmx typing/env.cmx typing/ctype.cmx utils/clflags.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/typeclass.cmi 
+typing/typecore.cmo: utils/warnings.cmi typing/typetexp.cmi typing/types.cmi \
+    typing/typedtree.cmi typing/stypes.cmi typing/printtyp.cmi \
+    typing/primitive.cmi typing/predef.cmi typing/path.cmi \
+    parsing/parsetree.cmi typing/parmatch.cmi utils/misc.cmi \
+    parsing/longident.cmi parsing/location.cmi typing/ident.cmi \
+    typing/env.cmi typing/ctype.cmi utils/clflags.cmo typing/btype.cmi \
+    parsing/asttypes.cmi typing/typecore.cmi 
+typing/typecore.cmx: utils/warnings.cmx typing/typetexp.cmx typing/types.cmx \
+    typing/typedtree.cmx typing/stypes.cmx typing/printtyp.cmx \
+    typing/primitive.cmx typing/predef.cmx typing/path.cmx \
+    parsing/parsetree.cmi typing/parmatch.cmx utils/misc.cmx \
+    parsing/longident.cmx parsing/location.cmx typing/ident.cmx \
+    typing/env.cmx typing/ctype.cmx utils/clflags.cmx typing/btype.cmx \
+    parsing/asttypes.cmi typing/typecore.cmi 
+typing/typedecl.cmo: typing/typetexp.cmi typing/types.cmi \
+    typing/typedtree.cmi typing/subst.cmi typing/printtyp.cmi \
+    typing/primitive.cmi typing/predef.cmi typing/path.cmi \
+    parsing/parsetree.cmi utils/misc.cmi parsing/longident.cmi \
+    parsing/location.cmi typing/includecore.cmi typing/ident.cmi \
+    typing/env.cmi typing/ctype.cmi utils/config.cmi utils/clflags.cmo \
+    typing/btype.cmi parsing/asttypes.cmi typing/typedecl.cmi 
+typing/typedecl.cmx: typing/typetexp.cmx typing/types.cmx \
+    typing/typedtree.cmx typing/subst.cmx typing/printtyp.cmx \
+    typing/primitive.cmx typing/predef.cmx typing/path.cmx \
+    parsing/parsetree.cmi utils/misc.cmx parsing/longident.cmx \
+    parsing/location.cmx typing/includecore.cmx typing/ident.cmx \
+    typing/env.cmx typing/ctype.cmx utils/config.cmx utils/clflags.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/typedecl.cmi 
+typing/typedtree.cmo: typing/types.cmi typing/primitive.cmi typing/path.cmi \
+    utils/misc.cmi parsing/location.cmi typing/ident.cmi typing/env.cmi \
+    parsing/asttypes.cmi typing/typedtree.cmi 
+typing/typedtree.cmx: typing/types.cmx typing/primitive.cmx typing/path.cmx \
+    utils/misc.cmx parsing/location.cmx typing/ident.cmx typing/env.cmx \
+    parsing/asttypes.cmi typing/typedtree.cmi 
+typing/typemod.cmo: typing/types.cmi typing/typedtree.cmi typing/typedecl.cmi \
+    typing/typecore.cmi typing/typeclass.cmi typing/subst.cmi \
+    typing/stypes.cmi typing/printtyp.cmi typing/path.cmi \
+    parsing/parsetree.cmi typing/mtype.cmi utils/misc.cmi \
+    parsing/longident.cmi parsing/location.cmi typing/includemod.cmi \
+    typing/ident.cmi typing/env.cmi typing/ctype.cmi utils/config.cmi \
+    utils/clflags.cmo typing/typemod.cmi 
+typing/typemod.cmx: typing/types.cmx typing/typedtree.cmx typing/typedecl.cmx \
+    typing/typecore.cmx typing/typeclass.cmx typing/subst.cmx \
+    typing/stypes.cmx typing/printtyp.cmx typing/path.cmx \
+    parsing/parsetree.cmi typing/mtype.cmx utils/misc.cmx \
+    parsing/longident.cmx parsing/location.cmx typing/includemod.cmx \
+    typing/ident.cmx typing/env.cmx typing/ctype.cmx utils/config.cmx \
+    utils/clflags.cmx typing/typemod.cmi 
+typing/types.cmo: typing/primitive.cmi typing/path.cmi utils/misc.cmi \
+    typing/ident.cmi parsing/asttypes.cmi typing/types.cmi 
+typing/types.cmx: typing/primitive.cmx typing/path.cmx utils/misc.cmx \
+    typing/ident.cmx parsing/asttypes.cmi typing/types.cmi 
+typing/typetexp.cmo: utils/warnings.cmi typing/types.cmi utils/tbl.cmi \
+    typing/printtyp.cmi typing/path.cmi parsing/parsetree.cmi utils/misc.cmi \
+    parsing/longident.cmi parsing/location.cmi typing/env.cmi \
+    typing/ctype.cmi typing/btype.cmi typing/typetexp.cmi 
+typing/typetexp.cmx: utils/warnings.cmx typing/types.cmx utils/tbl.cmx \
+    typing/printtyp.cmx typing/path.cmx parsing/parsetree.cmi utils/misc.cmx \
+    parsing/longident.cmx parsing/location.cmx typing/env.cmx \
+    typing/ctype.cmx typing/btype.cmx typing/typetexp.cmi 
+bytecomp/bytegen.cmi: bytecomp/lambda.cmi bytecomp/instruct.cmi 
+bytecomp/bytelink.cmi: bytecomp/symtable.cmi bytecomp/emitcode.cmi 
 bytecomp/bytepackager.cmi: typing/ident.cmi 
-bytecomp/emitcode.cmi: typing/ident.cmi bytecomp/instruct.cmi \
-    bytecomp/lambda.cmi 
-bytecomp/instruct.cmi: typing/env.cmi typing/ident.cmi bytecomp/lambda.cmi \
-    typing/types.cmi 
-bytecomp/lambda.cmi: parsing/asttypes.cmi typing/env.cmi typing/ident.cmi \
-    typing/path.cmi typing/primitive.cmi typing/types.cmi 
-bytecomp/matching.cmi: parsing/asttypes.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi parsing/location.cmi typing/typedtree.cmi 
+bytecomp/emitcode.cmi: bytecomp/lambda.cmi bytecomp/instruct.cmi \
+    typing/ident.cmi 
+bytecomp/instruct.cmi: typing/types.cmi bytecomp/lambda.cmi typing/ident.cmi \
+    typing/env.cmi 
+bytecomp/lambda.cmi: typing/types.cmi typing/primitive.cmi typing/path.cmi \
+    typing/ident.cmi typing/env.cmi parsing/asttypes.cmi 
+bytecomp/matching.cmi: typing/typedtree.cmi parsing/location.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi parsing/asttypes.cmi 
 bytecomp/printinstr.cmi: bytecomp/instruct.cmi 
 bytecomp/printlambda.cmi: bytecomp/lambda.cmi 
 bytecomp/simplif.cmi: bytecomp/lambda.cmi 
-bytecomp/symtable.cmi: bytecomp/emitcode.cmi typing/ident.cmi 
-bytecomp/translclass.cmi: typing/ident.cmi bytecomp/lambda.cmi \
-    parsing/location.cmi typing/typedtree.cmi 
-bytecomp/translcore.cmi: parsing/asttypes.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi parsing/location.cmi typing/path.cmi \
-    typing/primitive.cmi typing/typedtree.cmi typing/types.cmi 
-bytecomp/translmod.cmi: typing/ident.cmi bytecomp/lambda.cmi \
-    parsing/location.cmi typing/typedtree.cmi 
-bytecomp/translobj.cmi: typing/env.cmi typing/ident.cmi bytecomp/lambda.cmi 
-bytecomp/typeopt.cmi: bytecomp/lambda.cmi typing/path.cmi \
-    typing/typedtree.cmi 
-bytecomp/bytegen.cmo: parsing/asttypes.cmi utils/config.cmi typing/ident.cmi \
-    bytecomp/instruct.cmi bytecomp/lambda.cmi utils/misc.cmi \
-    typing/primitive.cmi bytecomp/switch.cmi typing/types.cmi \
-    bytecomp/bytegen.cmi 
-bytecomp/bytegen.cmx: parsing/asttypes.cmi utils/config.cmx typing/ident.cmx \
-    bytecomp/instruct.cmx bytecomp/lambda.cmx utils/misc.cmx \
-    typing/primitive.cmx bytecomp/switch.cmx typing/types.cmx \
-    bytecomp/bytegen.cmi 
-bytecomp/bytelibrarian.cmo: bytecomp/bytelink.cmi utils/clflags.cmo \
-    utils/config.cmi bytecomp/emitcode.cmi utils/misc.cmi \
+bytecomp/symtable.cmi: typing/ident.cmi bytecomp/emitcode.cmi 
+bytecomp/translclass.cmi: typing/typedtree.cmi parsing/location.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi 
+bytecomp/translcore.cmi: typing/types.cmi typing/typedtree.cmi \
+    typing/primitive.cmi typing/path.cmi parsing/location.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi parsing/asttypes.cmi 
+bytecomp/translmod.cmi: typing/typedtree.cmi parsing/location.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi 
+bytecomp/translobj.cmi: bytecomp/lambda.cmi typing/ident.cmi typing/env.cmi 
+bytecomp/typeopt.cmi: typing/typedtree.cmi typing/path.cmi \
+    bytecomp/lambda.cmi 
+bytecomp/bytegen.cmo: typing/types.cmi bytecomp/switch.cmi \
+    typing/primitive.cmi utils/misc.cmi bytecomp/lambda.cmi \
+    bytecomp/instruct.cmi typing/ident.cmi utils/config.cmi \
+    parsing/asttypes.cmi bytecomp/bytegen.cmi 
+bytecomp/bytegen.cmx: typing/types.cmx bytecomp/switch.cmx \
+    typing/primitive.cmx utils/misc.cmx bytecomp/lambda.cmx \
+    bytecomp/instruct.cmx typing/ident.cmx utils/config.cmx \
+    parsing/asttypes.cmi bytecomp/bytegen.cmi 
+bytecomp/bytelibrarian.cmo: utils/misc.cmi bytecomp/emitcode.cmi \
+    utils/config.cmi utils/clflags.cmo bytecomp/bytelink.cmi \
     bytecomp/bytelibrarian.cmi 
-bytecomp/bytelibrarian.cmx: bytecomp/bytelink.cmx utils/clflags.cmx \
-    utils/config.cmx bytecomp/emitcode.cmx utils/misc.cmx \
+bytecomp/bytelibrarian.cmx: utils/misc.cmx bytecomp/emitcode.cmx \
+    utils/config.cmx utils/clflags.cmx bytecomp/bytelink.cmx \
     bytecomp/bytelibrarian.cmi 
-bytecomp/bytelink.cmo: bytecomp/bytesections.cmi utils/ccomp.cmi \
-    utils/clflags.cmo utils/config.cmi utils/consistbl.cmi bytecomp/dll.cmi \
-    bytecomp/emitcode.cmi typing/ident.cmi bytecomp/instruct.cmi \
-    utils/misc.cmi bytecomp/opcodes.cmo bytecomp/symtable.cmi \
-    bytecomp/bytelink.cmi 
-bytecomp/bytelink.cmx: bytecomp/bytesections.cmx utils/ccomp.cmx \
-    utils/clflags.cmx utils/config.cmx utils/consistbl.cmx bytecomp/dll.cmx \
-    bytecomp/emitcode.cmx typing/ident.cmx bytecomp/instruct.cmx \
-    utils/misc.cmx bytecomp/opcodes.cmx bytecomp/symtable.cmx \
-    bytecomp/bytelink.cmi 
-bytecomp/bytepackager.cmo: bytecomp/bytegen.cmi bytecomp/bytelink.cmi \
-    utils/clflags.cmo utils/config.cmi bytecomp/emitcode.cmi typing/env.cmi \
-    typing/ident.cmi bytecomp/instruct.cmi utils/misc.cmi \
-    bytecomp/translmod.cmi typing/typemod.cmi bytecomp/bytepackager.cmi 
-bytecomp/bytepackager.cmx: bytecomp/bytegen.cmx bytecomp/bytelink.cmx \
-    utils/clflags.cmx utils/config.cmx bytecomp/emitcode.cmx typing/env.cmx \
-    typing/ident.cmx bytecomp/instruct.cmx utils/misc.cmx \
-    bytecomp/translmod.cmx typing/typemod.cmx bytecomp/bytepackager.cmi 
+bytecomp/bytelink.cmo: bytecomp/symtable.cmi bytecomp/opcodes.cmo \
+    utils/misc.cmi bytecomp/instruct.cmi typing/ident.cmi \
+    bytecomp/emitcode.cmi bytecomp/dll.cmi utils/consistbl.cmi \
+    utils/config.cmi utils/clflags.cmo utils/ccomp.cmi \
+    bytecomp/bytesections.cmi bytecomp/bytelink.cmi 
+bytecomp/bytelink.cmx: bytecomp/symtable.cmx bytecomp/opcodes.cmx \
+    utils/misc.cmx bytecomp/instruct.cmx typing/ident.cmx \
+    bytecomp/emitcode.cmx bytecomp/dll.cmx utils/consistbl.cmx \
+    utils/config.cmx utils/clflags.cmx utils/ccomp.cmx \
+    bytecomp/bytesections.cmx bytecomp/bytelink.cmi 
+bytecomp/bytepackager.cmo: typing/typemod.cmi bytecomp/translmod.cmi \
+    utils/misc.cmi bytecomp/instruct.cmi typing/ident.cmi typing/env.cmi \
+    bytecomp/emitcode.cmi utils/config.cmi utils/clflags.cmo \
+    bytecomp/bytelink.cmi bytecomp/bytegen.cmi bytecomp/bytepackager.cmi 
+bytecomp/bytepackager.cmx: typing/typemod.cmx bytecomp/translmod.cmx \
+    utils/misc.cmx bytecomp/instruct.cmx typing/ident.cmx typing/env.cmx \
+    bytecomp/emitcode.cmx utils/config.cmx utils/clflags.cmx \
+    bytecomp/bytelink.cmx bytecomp/bytegen.cmx bytecomp/bytepackager.cmi 
 bytecomp/bytesections.cmo: utils/config.cmi bytecomp/bytesections.cmi 
 bytecomp/bytesections.cmx: utils/config.cmx bytecomp/bytesections.cmi 
-bytecomp/dll.cmo: utils/config.cmi utils/misc.cmi bytecomp/dll.cmi 
-bytecomp/dll.cmx: utils/config.cmx utils/misc.cmx bytecomp/dll.cmi 
-bytecomp/emitcode.cmo: parsing/asttypes.cmi typing/btype.cmi \
-    utils/clflags.cmo utils/config.cmi typing/env.cmi typing/ident.cmi \
-    bytecomp/instruct.cmi bytecomp/lambda.cmi bytecomp/meta.cmi \
-    utils/misc.cmi bytecomp/opcodes.cmo bytecomp/translmod.cmi \
+bytecomp/dll.cmo: utils/misc.cmi utils/config.cmi bytecomp/dll.cmi 
+bytecomp/dll.cmx: utils/misc.cmx utils/config.cmx bytecomp/dll.cmi 
+bytecomp/emitcode.cmo: bytecomp/translmod.cmi bytecomp/opcodes.cmo \
+    utils/misc.cmi bytecomp/meta.cmi bytecomp/lambda.cmi \
+    bytecomp/instruct.cmi typing/ident.cmi typing/env.cmi utils/config.cmi \
+    utils/clflags.cmo typing/btype.cmi parsing/asttypes.cmi \
     bytecomp/emitcode.cmi 
-bytecomp/emitcode.cmx: parsing/asttypes.cmi typing/btype.cmx \
-    utils/clflags.cmx utils/config.cmx typing/env.cmx typing/ident.cmx \
-    bytecomp/instruct.cmx bytecomp/lambda.cmx bytecomp/meta.cmx \
-    utils/misc.cmx bytecomp/opcodes.cmx bytecomp/translmod.cmx \
+bytecomp/emitcode.cmx: bytecomp/translmod.cmx bytecomp/opcodes.cmx \
+    utils/misc.cmx bytecomp/meta.cmx bytecomp/lambda.cmx \
+    bytecomp/instruct.cmx typing/ident.cmx typing/env.cmx utils/config.cmx \
+    utils/clflags.cmx typing/btype.cmx parsing/asttypes.cmi \
     bytecomp/emitcode.cmi 
-bytecomp/instruct.cmo: typing/env.cmi typing/ident.cmi bytecomp/lambda.cmi \
-    typing/types.cmi bytecomp/instruct.cmi 
-bytecomp/instruct.cmx: typing/env.cmx typing/ident.cmx bytecomp/lambda.cmx \
-    typing/types.cmx bytecomp/instruct.cmi 
-bytecomp/lambda.cmo: parsing/asttypes.cmi typing/env.cmi typing/ident.cmi \
-    utils/misc.cmi typing/path.cmi typing/primitive.cmi typing/types.cmi \
+bytecomp/instruct.cmo: typing/types.cmi bytecomp/lambda.cmi typing/ident.cmi \
+    typing/env.cmi bytecomp/instruct.cmi 
+bytecomp/instruct.cmx: typing/types.cmx bytecomp/lambda.cmx typing/ident.cmx \
+    typing/env.cmx bytecomp/instruct.cmi 
+bytecomp/lambda.cmo: typing/types.cmi typing/primitive.cmi typing/path.cmi \
+    utils/misc.cmi typing/ident.cmi typing/env.cmi parsing/asttypes.cmi \
     bytecomp/lambda.cmi 
-bytecomp/lambda.cmx: parsing/asttypes.cmi typing/env.cmx typing/ident.cmx \
-    utils/misc.cmx typing/path.cmx typing/primitive.cmx typing/types.cmx \
+bytecomp/lambda.cmx: typing/types.cmx typing/primitive.cmx typing/path.cmx \
+    utils/misc.cmx typing/ident.cmx typing/env.cmx parsing/asttypes.cmi \
     bytecomp/lambda.cmi 
-bytecomp/matching.cmo: parsing/asttypes.cmi typing/btype.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi parsing/location.cmi utils/misc.cmi \
-    typing/parmatch.cmi typing/predef.cmi typing/primitive.cmi \
-    bytecomp/printlambda.cmi bytecomp/switch.cmi typing/typedtree.cmi \
-    bytecomp/typeopt.cmi typing/types.cmi bytecomp/matching.cmi 
-bytecomp/matching.cmx: parsing/asttypes.cmi typing/btype.cmx typing/ident.cmx \
-    bytecomp/lambda.cmx parsing/location.cmx utils/misc.cmx \
-    typing/parmatch.cmx typing/predef.cmx typing/primitive.cmx \
-    bytecomp/printlambda.cmx bytecomp/switch.cmx typing/typedtree.cmx \
-    bytecomp/typeopt.cmx typing/types.cmx bytecomp/matching.cmi 
+bytecomp/matching.cmo: typing/types.cmi bytecomp/typeopt.cmi \
+    typing/typedtree.cmi bytecomp/switch.cmi bytecomp/printlambda.cmi \
+    typing/primitive.cmi typing/predef.cmi typing/parmatch.cmi utils/misc.cmi \
+    parsing/location.cmi bytecomp/lambda.cmi typing/ident.cmi \
+    typing/btype.cmi parsing/asttypes.cmi bytecomp/matching.cmi 
+bytecomp/matching.cmx: typing/types.cmx bytecomp/typeopt.cmx \
+    typing/typedtree.cmx bytecomp/switch.cmx bytecomp/printlambda.cmx \
+    typing/primitive.cmx typing/predef.cmx typing/parmatch.cmx utils/misc.cmx \
+    parsing/location.cmx bytecomp/lambda.cmx typing/ident.cmx \
+    typing/btype.cmx parsing/asttypes.cmi bytecomp/matching.cmi 
 bytecomp/meta.cmo: bytecomp/meta.cmi 
 bytecomp/meta.cmx: bytecomp/meta.cmi 
-bytecomp/printinstr.cmo: typing/ident.cmi bytecomp/instruct.cmi \
-    bytecomp/lambda.cmi bytecomp/printlambda.cmi bytecomp/printinstr.cmi 
-bytecomp/printinstr.cmx: typing/ident.cmx bytecomp/instruct.cmx \
-    bytecomp/lambda.cmx bytecomp/printlambda.cmx bytecomp/printinstr.cmi 
-bytecomp/printlambda.cmo: parsing/asttypes.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi typing/primitive.cmi typing/types.cmi \
+bytecomp/printinstr.cmo: bytecomp/printlambda.cmi bytecomp/lambda.cmi \
+    bytecomp/instruct.cmi typing/ident.cmi bytecomp/printinstr.cmi 
+bytecomp/printinstr.cmx: bytecomp/printlambda.cmx bytecomp/lambda.cmx \
+    bytecomp/instruct.cmx typing/ident.cmx bytecomp/printinstr.cmi 
+bytecomp/printlambda.cmo: typing/types.cmi typing/primitive.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi parsing/asttypes.cmi \
     bytecomp/printlambda.cmi 
-bytecomp/printlambda.cmx: parsing/asttypes.cmi typing/ident.cmx \
-    bytecomp/lambda.cmx typing/primitive.cmx typing/types.cmx \
+bytecomp/printlambda.cmx: typing/types.cmx typing/primitive.cmx \
+    bytecomp/lambda.cmx typing/ident.cmx parsing/asttypes.cmi \
     bytecomp/printlambda.cmi 
 bytecomp/runtimedef.cmo: bytecomp/runtimedef.cmi 
 bytecomp/runtimedef.cmx: bytecomp/runtimedef.cmi 
-bytecomp/simplif.cmo: parsing/asttypes.cmi utils/clflags.cmo typing/ident.cmi \
-    bytecomp/lambda.cmi bytecomp/simplif.cmi 
-bytecomp/simplif.cmx: parsing/asttypes.cmi utils/clflags.cmx typing/ident.cmx \
-    bytecomp/lambda.cmx bytecomp/simplif.cmi 
+bytecomp/simplif.cmo: bytecomp/lambda.cmi typing/ident.cmi utils/clflags.cmo \
+    parsing/asttypes.cmi bytecomp/simplif.cmi 
+bytecomp/simplif.cmx: bytecomp/lambda.cmx typing/ident.cmx utils/clflags.cmx \
+    parsing/asttypes.cmi bytecomp/simplif.cmi 
 bytecomp/switch.cmo: bytecomp/switch.cmi 
 bytecomp/switch.cmx: bytecomp/switch.cmi 
-bytecomp/symtable.cmo: parsing/asttypes.cmi bytecomp/bytesections.cmi \
-    utils/clflags.cmo bytecomp/dll.cmi bytecomp/emitcode.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi bytecomp/meta.cmi utils/misc.cmi typing/predef.cmi \
-    bytecomp/runtimedef.cmi utils/tbl.cmi bytecomp/symtable.cmi 
-bytecomp/symtable.cmx: parsing/asttypes.cmi bytecomp/bytesections.cmx \
-    utils/clflags.cmx bytecomp/dll.cmx bytecomp/emitcode.cmx typing/ident.cmx \
-    bytecomp/lambda.cmx bytecomp/meta.cmx utils/misc.cmx typing/predef.cmx \
-    bytecomp/runtimedef.cmx utils/tbl.cmx bytecomp/symtable.cmi 
-bytecomp/translclass.cmo: parsing/asttypes.cmi typing/btype.cmi \
-    utils/clflags.cmo typing/ctype.cmi typing/env.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi parsing/location.cmi bytecomp/matching.cmi \
-    utils/misc.cmi typing/path.cmi bytecomp/translcore.cmi \
-    bytecomp/translobj.cmi typing/typeclass.cmi typing/typedtree.cmi \
-    bytecomp/typeopt.cmi typing/types.cmi bytecomp/translclass.cmi 
-bytecomp/translclass.cmx: parsing/asttypes.cmi typing/btype.cmx \
-    utils/clflags.cmx typing/ctype.cmx typing/env.cmx typing/ident.cmx \
-    bytecomp/lambda.cmx parsing/location.cmx bytecomp/matching.cmx \
-    utils/misc.cmx typing/path.cmx bytecomp/translcore.cmx \
-    bytecomp/translobj.cmx typing/typeclass.cmx typing/typedtree.cmx \
-    bytecomp/typeopt.cmx typing/types.cmx bytecomp/translclass.cmi 
-bytecomp/translcore.cmo: parsing/asttypes.cmi typing/btype.cmi \
-    utils/clflags.cmo utils/config.cmi typing/env.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi parsing/location.cmi bytecomp/matching.cmi \
-    utils/misc.cmi typing/path.cmi typing/predef.cmi typing/primitive.cmi \
-    bytecomp/translobj.cmi typing/typedtree.cmi bytecomp/typeopt.cmi \
-    typing/types.cmi bytecomp/translcore.cmi 
-bytecomp/translcore.cmx: parsing/asttypes.cmi typing/btype.cmx \
-    utils/clflags.cmx utils/config.cmx typing/env.cmx typing/ident.cmx \
-    bytecomp/lambda.cmx parsing/location.cmx bytecomp/matching.cmx \
-    utils/misc.cmx typing/path.cmx typing/predef.cmx typing/primitive.cmx \
-    bytecomp/translobj.cmx typing/typedtree.cmx bytecomp/typeopt.cmx \
-    typing/types.cmx bytecomp/translcore.cmi 
-bytecomp/translmod.cmo: parsing/asttypes.cmi utils/config.cmi \
-    typing/ctype.cmi typing/env.cmi typing/ident.cmi bytecomp/lambda.cmi \
-    parsing/location.cmi utils/misc.cmi typing/mtype.cmi typing/path.cmi \
-    typing/predef.cmi typing/primitive.cmi typing/printtyp.cmi \
-    bytecomp/translclass.cmi bytecomp/translcore.cmi bytecomp/translobj.cmi \
-    typing/typedtree.cmi typing/types.cmi bytecomp/translmod.cmi 
-bytecomp/translmod.cmx: parsing/asttypes.cmi utils/config.cmx \
-    typing/ctype.cmx typing/env.cmx typing/ident.cmx bytecomp/lambda.cmx \
-    parsing/location.cmx utils/misc.cmx typing/mtype.cmx typing/path.cmx \
-    typing/predef.cmx typing/primitive.cmx typing/printtyp.cmx \
-    bytecomp/translclass.cmx bytecomp/translcore.cmx bytecomp/translobj.cmx \
-    typing/typedtree.cmx typing/types.cmx bytecomp/translmod.cmi 
-bytecomp/translobj.cmo: parsing/asttypes.cmi typing/btype.cmi \
-    utils/clflags.cmo typing/env.cmi typing/ident.cmi bytecomp/lambda.cmi \
-    parsing/longident.cmi utils/misc.cmi typing/primitive.cmi \
+bytecomp/symtable.cmo: utils/tbl.cmi bytecomp/runtimedef.cmi \
+    typing/predef.cmi utils/misc.cmi bytecomp/meta.cmi bytecomp/lambda.cmi \
+    typing/ident.cmi bytecomp/emitcode.cmi bytecomp/dll.cmi utils/clflags.cmo \
+    bytecomp/bytesections.cmi parsing/asttypes.cmi bytecomp/symtable.cmi 
+bytecomp/symtable.cmx: utils/tbl.cmx bytecomp/runtimedef.cmx \
+    typing/predef.cmx utils/misc.cmx bytecomp/meta.cmx bytecomp/lambda.cmx \
+    typing/ident.cmx bytecomp/emitcode.cmx bytecomp/dll.cmx utils/clflags.cmx \
+    bytecomp/bytesections.cmx parsing/asttypes.cmi bytecomp/symtable.cmi 
+bytecomp/translclass.cmo: typing/types.cmi bytecomp/typeopt.cmi \
+    typing/typedtree.cmi typing/typeclass.cmi bytecomp/translobj.cmi \
+    bytecomp/translcore.cmi typing/path.cmi utils/misc.cmi \
+    bytecomp/matching.cmi parsing/location.cmi bytecomp/lambda.cmi \
+    typing/ident.cmi typing/env.cmi typing/ctype.cmi utils/clflags.cmo \
+    typing/btype.cmi parsing/asttypes.cmi bytecomp/translclass.cmi 
+bytecomp/translclass.cmx: typing/types.cmx bytecomp/typeopt.cmx \
+    typing/typedtree.cmx typing/typeclass.cmx bytecomp/translobj.cmx \
+    bytecomp/translcore.cmx typing/path.cmx utils/misc.cmx \
+    bytecomp/matching.cmx parsing/location.cmx bytecomp/lambda.cmx \
+    typing/ident.cmx typing/env.cmx typing/ctype.cmx utils/clflags.cmx \
+    typing/btype.cmx parsing/asttypes.cmi bytecomp/translclass.cmi 
+bytecomp/translcore.cmo: typing/types.cmi bytecomp/typeopt.cmi \
+    typing/typedtree.cmi bytecomp/translobj.cmi typing/primitive.cmi \
+    typing/predef.cmi typing/path.cmi utils/misc.cmi bytecomp/matching.cmi \
+    parsing/location.cmi bytecomp/lambda.cmi typing/ident.cmi typing/env.cmi \
+    utils/config.cmi utils/clflags.cmo typing/btype.cmi parsing/asttypes.cmi \
+    bytecomp/translcore.cmi 
+bytecomp/translcore.cmx: typing/types.cmx bytecomp/typeopt.cmx \
+    typing/typedtree.cmx bytecomp/translobj.cmx typing/primitive.cmx \
+    typing/predef.cmx typing/path.cmx utils/misc.cmx bytecomp/matching.cmx \
+    parsing/location.cmx bytecomp/lambda.cmx typing/ident.cmx typing/env.cmx \
+    utils/config.cmx utils/clflags.cmx typing/btype.cmx parsing/asttypes.cmi \
+    bytecomp/translcore.cmi 
+bytecomp/translmod.cmo: typing/types.cmi typing/typedtree.cmi \
+    bytecomp/translobj.cmi bytecomp/translcore.cmi bytecomp/translclass.cmi \
+    typing/printtyp.cmi typing/primitive.cmi typing/predef.cmi \
+    typing/path.cmi typing/mtype.cmi utils/misc.cmi parsing/location.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi typing/env.cmi typing/ctype.cmi \
+    utils/config.cmi parsing/asttypes.cmi bytecomp/translmod.cmi 
+bytecomp/translmod.cmx: typing/types.cmx typing/typedtree.cmx \
+    bytecomp/translobj.cmx bytecomp/translcore.cmx bytecomp/translclass.cmx \
+    typing/printtyp.cmx typing/primitive.cmx typing/predef.cmx \
+    typing/path.cmx typing/mtype.cmx utils/misc.cmx parsing/location.cmx \
+    bytecomp/lambda.cmx typing/ident.cmx typing/env.cmx typing/ctype.cmx \
+    utils/config.cmx parsing/asttypes.cmi bytecomp/translmod.cmi 
+bytecomp/translobj.cmo: typing/primitive.cmi utils/misc.cmi \
+    parsing/longident.cmi bytecomp/lambda.cmi typing/ident.cmi typing/env.cmi \
+    utils/clflags.cmo typing/btype.cmi parsing/asttypes.cmi \
     bytecomp/translobj.cmi 
-bytecomp/translobj.cmx: parsing/asttypes.cmi typing/btype.cmx \
-    utils/clflags.cmx typing/env.cmx typing/ident.cmx bytecomp/lambda.cmx \
-    parsing/longident.cmx utils/misc.cmx typing/primitive.cmx \
+bytecomp/translobj.cmx: typing/primitive.cmx utils/misc.cmx \
+    parsing/longident.cmx bytecomp/lambda.cmx typing/ident.cmx typing/env.cmx \
+    utils/clflags.cmx typing/btype.cmx parsing/asttypes.cmi \
     bytecomp/translobj.cmi 
-bytecomp/typeopt.cmo: parsing/asttypes.cmi typing/ctype.cmi typing/env.cmi \
-    typing/ident.cmi bytecomp/lambda.cmi utils/misc.cmi typing/path.cmi \
-    typing/predef.cmi typing/primitive.cmi typing/typedtree.cmi \
-    typing/types.cmi bytecomp/typeopt.cmi 
-bytecomp/typeopt.cmx: parsing/asttypes.cmi typing/ctype.cmx typing/env.cmx \
-    typing/ident.cmx bytecomp/lambda.cmx utils/misc.cmx typing/path.cmx \
-    typing/predef.cmx typing/primitive.cmx typing/typedtree.cmx \
-    typing/types.cmx bytecomp/typeopt.cmi 
-asmcomp/asmgen.cmi: asmcomp/cmm.cmi bytecomp/lambda.cmi 
+bytecomp/typeopt.cmo: typing/types.cmi typing/typedtree.cmi \
+    typing/primitive.cmi typing/predef.cmi typing/path.cmi utils/misc.cmi \
+    bytecomp/lambda.cmi typing/ident.cmi typing/env.cmi typing/ctype.cmi \
+    parsing/asttypes.cmi bytecomp/typeopt.cmi 
+bytecomp/typeopt.cmx: typing/types.cmx typing/typedtree.cmx \
+    typing/primitive.cmx typing/predef.cmx typing/path.cmx utils/misc.cmx \
+    bytecomp/lambda.cmx typing/ident.cmx typing/env.cmx typing/ctype.cmx \
+    parsing/asttypes.cmi bytecomp/typeopt.cmi 
+asmcomp/asmgen.cmi: bytecomp/lambda.cmi asmcomp/cmm.cmi 
 asmcomp/asmlink.cmi: asmcomp/compilenv.cmi 
-asmcomp/clambda.cmi: parsing/asttypes.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi 
-asmcomp/closure.cmi: asmcomp/clambda.cmi bytecomp/lambda.cmi 
+asmcomp/clambda.cmi: bytecomp/lambda.cmi typing/ident.cmi \
+    parsing/asttypes.cmi 
+asmcomp/closure.cmi: bytecomp/lambda.cmi asmcomp/clambda.cmi 
 asmcomp/cmm.cmi: typing/ident.cmi 
-asmcomp/cmmgen.cmi: asmcomp/clambda.cmi asmcomp/cmm.cmi 
+asmcomp/cmmgen.cmi: asmcomp/cmm.cmi asmcomp/clambda.cmi 
 asmcomp/codegen.cmi: asmcomp/cmm.cmi 
 asmcomp/comballoc.cmi: asmcomp/mach.cmi 
-asmcomp/compilenv.cmi: asmcomp/clambda.cmi typing/ident.cmi 
-asmcomp/emit.cmi: asmcomp/cmm.cmi asmcomp/linearize.cmi 
+asmcomp/compilenv.cmi: typing/ident.cmi asmcomp/clambda.cmi 
+asmcomp/emit.cmi: asmcomp/linearize.cmi asmcomp/cmm.cmi 
 asmcomp/interf.cmi: asmcomp/mach.cmi 
-asmcomp/linearize.cmi: asmcomp/mach.cmi asmcomp/reg.cmi 
+asmcomp/linearize.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
 asmcomp/liveness.cmi: asmcomp/mach.cmi 
-asmcomp/mach.cmi: asmcomp/arch.cmo asmcomp/cmm.cmi asmcomp/reg.cmi 
+asmcomp/mach.cmi: asmcomp/reg.cmi asmcomp/cmm.cmi asmcomp/arch.cmo 
 asmcomp/printcmm.cmi: asmcomp/cmm.cmi 
 asmcomp/printlinear.cmi: asmcomp/linearize.cmi 
-asmcomp/printmach.cmi: asmcomp/mach.cmi asmcomp/reg.cmi 
-asmcomp/proc.cmi: asmcomp/mach.cmi asmcomp/reg.cmi 
+asmcomp/printmach.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
+asmcomp/proc.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
 asmcomp/reg.cmi: asmcomp/cmm.cmi 
 asmcomp/reload.cmi: asmcomp/mach.cmi 
-asmcomp/reloadgen.cmi: asmcomp/mach.cmi asmcomp/reg.cmi 
-asmcomp/schedgen.cmi: asmcomp/linearize.cmi asmcomp/mach.cmi 
+asmcomp/reloadgen.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
+asmcomp/schedgen.cmi: asmcomp/mach.cmi asmcomp/linearize.cmi 
 asmcomp/scheduling.cmi: asmcomp/linearize.cmi 
-asmcomp/selectgen.cmi: asmcomp/arch.cmo asmcomp/cmm.cmi typing/ident.cmi \
-    asmcomp/mach.cmi asmcomp/reg.cmi utils/tbl.cmi 
-asmcomp/selection.cmi: asmcomp/cmm.cmi asmcomp/mach.cmi 
+asmcomp/selectgen.cmi: utils/tbl.cmi asmcomp/reg.cmi asmcomp/mach.cmi \
+    typing/ident.cmi asmcomp/cmm.cmi asmcomp/arch.cmo 
+asmcomp/selection.cmi: asmcomp/mach.cmi asmcomp/cmm.cmi 
 asmcomp/spill.cmi: asmcomp/mach.cmi 
 asmcomp/split.cmi: asmcomp/mach.cmi 
 asmcomp/arch.cmo: utils/misc.cmi 
 asmcomp/arch.cmx: utils/misc.cmx 
-asmcomp/asmgen.cmo: utils/clflags.cmo asmcomp/closure.cmi asmcomp/cmm.cmi \
-    asmcomp/cmmgen.cmi asmcomp/coloring.cmi asmcomp/comballoc.cmi \
-    utils/config.cmi asmcomp/emit.cmi asmcomp/emitaux.cmi asmcomp/interf.cmi \
-    asmcomp/linearize.cmi asmcomp/liveness.cmi asmcomp/mach.cmi \
-    utils/misc.cmi asmcomp/printcmm.cmi asmcomp/printlinear.cmi \
-    asmcomp/printmach.cmi asmcomp/proc.cmi asmcomp/reg.cmi asmcomp/reload.cmi \
-    asmcomp/scheduling.cmi asmcomp/selection.cmi asmcomp/spill.cmi \
-    asmcomp/split.cmi asmcomp/asmgen.cmi 
-asmcomp/asmgen.cmx: utils/clflags.cmx asmcomp/closure.cmx asmcomp/cmm.cmx \
-    asmcomp/cmmgen.cmx asmcomp/coloring.cmx asmcomp/comballoc.cmx \
-    utils/config.cmx asmcomp/emit.cmx asmcomp/emitaux.cmx asmcomp/interf.cmx \
-    asmcomp/linearize.cmx asmcomp/liveness.cmx asmcomp/mach.cmx \
-    utils/misc.cmx asmcomp/printcmm.cmx asmcomp/printlinear.cmx \
-    asmcomp/printmach.cmx asmcomp/proc.cmx asmcomp/reg.cmx asmcomp/reload.cmx \
-    asmcomp/scheduling.cmx asmcomp/selection.cmx asmcomp/spill.cmx \
-    asmcomp/split.cmx asmcomp/asmgen.cmi 
-asmcomp/asmlibrarian.cmo: asmcomp/asmlink.cmi utils/ccomp.cmi \
-    asmcomp/clambda.cmi utils/clflags.cmo asmcomp/compilenv.cmi \
-    utils/config.cmi utils/misc.cmi asmcomp/asmlibrarian.cmi 
-asmcomp/asmlibrarian.cmx: asmcomp/asmlink.cmx utils/ccomp.cmx \
-    asmcomp/clambda.cmx utils/clflags.cmx asmcomp/compilenv.cmx \
-    utils/config.cmx utils/misc.cmx asmcomp/asmlibrarian.cmi 
-asmcomp/asmlink.cmo: asmcomp/asmgen.cmi utils/ccomp.cmi utils/clflags.cmo \
-    asmcomp/cmmgen.cmi asmcomp/compilenv.cmi utils/config.cmi \
-    utils/consistbl.cmi asmcomp/emit.cmi asmcomp/emitaux.cmi \
-    parsing/location.cmi utils/misc.cmi asmcomp/proc.cmi \
-    bytecomp/runtimedef.cmi asmcomp/asmlink.cmi 
-asmcomp/asmlink.cmx: asmcomp/asmgen.cmx utils/ccomp.cmx utils/clflags.cmx \
-    asmcomp/cmmgen.cmx asmcomp/compilenv.cmx utils/config.cmx \
-    utils/consistbl.cmx asmcomp/emit.cmx asmcomp/emitaux.cmx \
-    parsing/location.cmx utils/misc.cmx asmcomp/proc.cmx \
-    bytecomp/runtimedef.cmx asmcomp/asmlink.cmi 
-asmcomp/asmpackager.cmo: asmcomp/asmgen.cmi asmcomp/asmlink.cmi \
-    utils/ccomp.cmi asmcomp/clambda.cmi asmcomp/compilenv.cmi \
-    utils/config.cmi typing/env.cmi typing/ident.cmi bytecomp/lambda.cmi \
-    parsing/location.cmi utils/misc.cmi utils/tbl.cmi bytecomp/translmod.cmi \
-    typing/typemod.cmi asmcomp/asmpackager.cmi 
-asmcomp/asmpackager.cmx: asmcomp/asmgen.cmx asmcomp/asmlink.cmx \
-    utils/ccomp.cmx asmcomp/clambda.cmx asmcomp/compilenv.cmx \
-    utils/config.cmx typing/env.cmx typing/ident.cmx bytecomp/lambda.cmx \
-    parsing/location.cmx utils/misc.cmx utils/tbl.cmx bytecomp/translmod.cmx \
-    typing/typemod.cmx asmcomp/asmpackager.cmi 
-asmcomp/clambda.cmo: parsing/asttypes.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi asmcomp/clambda.cmi 
-asmcomp/clambda.cmx: parsing/asttypes.cmi typing/ident.cmx \
-    bytecomp/lambda.cmx asmcomp/clambda.cmi 
-asmcomp/closure.cmo: parsing/asttypes.cmi asmcomp/clambda.cmi \
-    utils/clflags.cmo asmcomp/compilenv.cmi typing/ident.cmi \
-    bytecomp/lambda.cmi utils/misc.cmi typing/primitive.cmi \
-    bytecomp/switch.cmi utils/tbl.cmi asmcomp/closure.cmi 
-asmcomp/closure.cmx: parsing/asttypes.cmi asmcomp/clambda.cmx \
-    utils/clflags.cmx asmcomp/compilenv.cmx typing/ident.cmx \
-    bytecomp/lambda.cmx utils/misc.cmx typing/primitive.cmx \
-    bytecomp/switch.cmx utils/tbl.cmx asmcomp/closure.cmi 
-asmcomp/cmm.cmo: asmcomp/arch.cmo typing/ident.cmi asmcomp/cmm.cmi 
-asmcomp/cmm.cmx: asmcomp/arch.cmx typing/ident.cmx asmcomp/cmm.cmi 
-asmcomp/cmmgen.cmo: asmcomp/arch.cmo parsing/asttypes.cmi asmcomp/clambda.cmi \
-    utils/clflags.cmo asmcomp/cmm.cmi asmcomp/compilenv.cmi utils/config.cmi \
-    typing/ident.cmi bytecomp/lambda.cmi utils/misc.cmi typing/primitive.cmi \
-    asmcomp/proc.cmi bytecomp/switch.cmi typing/types.cmi asmcomp/cmmgen.cmi 
-asmcomp/cmmgen.cmx: asmcomp/arch.cmx parsing/asttypes.cmi asmcomp/clambda.cmx \
-    utils/clflags.cmx asmcomp/cmm.cmx asmcomp/compilenv.cmx utils/config.cmx \
-    typing/ident.cmx bytecomp/lambda.cmx utils/misc.cmx typing/primitive.cmx \
-    asmcomp/proc.cmx bytecomp/switch.cmx typing/types.cmx asmcomp/cmmgen.cmi 
-asmcomp/codegen.cmo: asmcomp/cmm.cmi asmcomp/coloring.cmi asmcomp/emit.cmi \
-    asmcomp/interf.cmi asmcomp/linearize.cmi asmcomp/liveness.cmi \
-    asmcomp/printcmm.cmi asmcomp/printlinear.cmi asmcomp/printmach.cmi \
-    asmcomp/reg.cmi asmcomp/reload.cmi asmcomp/spill.cmi asmcomp/split.cmi \
+asmcomp/asmgen.cmo: asmcomp/split.cmi asmcomp/spill.cmi asmcomp/selection.cmi \
+    asmcomp/scheduling.cmi asmcomp/reload.cmi asmcomp/reg.cmi \
+    asmcomp/proc.cmi asmcomp/printmach.cmi asmcomp/printlinear.cmi \
+    asmcomp/printcmm.cmi utils/misc.cmi asmcomp/mach.cmi asmcomp/liveness.cmi \
+    asmcomp/linearize.cmi asmcomp/interf.cmi asmcomp/emitaux.cmi \
+    asmcomp/emit.cmi utils/config.cmi asmcomp/comballoc.cmi \
+    asmcomp/coloring.cmi asmcomp/cmmgen.cmi asmcomp/cmm.cmi \
+    asmcomp/closure.cmi utils/clflags.cmo asmcomp/asmgen.cmi 
+asmcomp/asmgen.cmx: asmcomp/split.cmx asmcomp/spill.cmx asmcomp/selection.cmx \
+    asmcomp/scheduling.cmx asmcomp/reload.cmx asmcomp/reg.cmx \
+    asmcomp/proc.cmx asmcomp/printmach.cmx asmcomp/printlinear.cmx \
+    asmcomp/printcmm.cmx utils/misc.cmx asmcomp/mach.cmx asmcomp/liveness.cmx \
+    asmcomp/linearize.cmx asmcomp/interf.cmx asmcomp/emitaux.cmx \
+    asmcomp/emit.cmx utils/config.cmx asmcomp/comballoc.cmx \
+    asmcomp/coloring.cmx asmcomp/cmmgen.cmx asmcomp/cmm.cmx \
+    asmcomp/closure.cmx utils/clflags.cmx asmcomp/asmgen.cmi 
+asmcomp/asmlibrarian.cmo: utils/misc.cmi utils/config.cmi \
+    asmcomp/compilenv.cmi utils/clflags.cmo asmcomp/clambda.cmi \
+    utils/ccomp.cmi asmcomp/asmlink.cmi asmcomp/asmlibrarian.cmi 
+asmcomp/asmlibrarian.cmx: utils/misc.cmx utils/config.cmx \
+    asmcomp/compilenv.cmx utils/clflags.cmx asmcomp/clambda.cmx \
+    utils/ccomp.cmx asmcomp/asmlink.cmx asmcomp/asmlibrarian.cmi 
+asmcomp/asmlink.cmo: bytecomp/runtimedef.cmi asmcomp/proc.cmi utils/misc.cmi \
+    parsing/location.cmi asmcomp/emitaux.cmi asmcomp/emit.cmi \
+    utils/consistbl.cmi utils/config.cmi asmcomp/compilenv.cmi \
+    asmcomp/cmmgen.cmi utils/clflags.cmo utils/ccomp.cmi asmcomp/asmgen.cmi \
+    asmcomp/asmlink.cmi 
+asmcomp/asmlink.cmx: bytecomp/runtimedef.cmx asmcomp/proc.cmx utils/misc.cmx \
+    parsing/location.cmx asmcomp/emitaux.cmx asmcomp/emit.cmx \
+    utils/consistbl.cmx utils/config.cmx asmcomp/compilenv.cmx \
+    asmcomp/cmmgen.cmx utils/clflags.cmx utils/ccomp.cmx asmcomp/asmgen.cmx \
+    asmcomp/asmlink.cmi 
+asmcomp/asmpackager.cmo: typing/typemod.cmi bytecomp/translmod.cmi \
+    utils/tbl.cmi utils/misc.cmi parsing/location.cmi bytecomp/lambda.cmi \
+    typing/ident.cmi typing/env.cmi utils/config.cmi asmcomp/compilenv.cmi \
+    asmcomp/clambda.cmi utils/ccomp.cmi asmcomp/asmlink.cmi \
+    asmcomp/asmgen.cmi asmcomp/asmpackager.cmi 
+asmcomp/asmpackager.cmx: typing/typemod.cmx bytecomp/translmod.cmx \
+    utils/tbl.cmx utils/misc.cmx parsing/location.cmx bytecomp/lambda.cmx \
+    typing/ident.cmx typing/env.cmx utils/config.cmx asmcomp/compilenv.cmx \
+    asmcomp/clambda.cmx utils/ccomp.cmx asmcomp/asmlink.cmx \
+    asmcomp/asmgen.cmx asmcomp/asmpackager.cmi 
+asmcomp/clambda.cmo: bytecomp/lambda.cmi typing/ident.cmi \
+    parsing/asttypes.cmi asmcomp/clambda.cmi 
+asmcomp/clambda.cmx: bytecomp/lambda.cmx typing/ident.cmx \
+    parsing/asttypes.cmi asmcomp/clambda.cmi 
+asmcomp/closure.cmo: utils/tbl.cmi bytecomp/switch.cmi typing/primitive.cmi \
+    utils/misc.cmi bytecomp/lambda.cmi typing/ident.cmi asmcomp/compilenv.cmi \
+    utils/clflags.cmo asmcomp/clambda.cmi parsing/asttypes.cmi \
+    asmcomp/closure.cmi 
+asmcomp/closure.cmx: utils/tbl.cmx bytecomp/switch.cmx typing/primitive.cmx \
+    utils/misc.cmx bytecomp/lambda.cmx typing/ident.cmx asmcomp/compilenv.cmx \
+    utils/clflags.cmx asmcomp/clambda.cmx parsing/asttypes.cmi \
+    asmcomp/closure.cmi 
+asmcomp/cmm.cmo: typing/ident.cmi asmcomp/arch.cmo asmcomp/cmm.cmi 
+asmcomp/cmm.cmx: typing/ident.cmx asmcomp/arch.cmx asmcomp/cmm.cmi 
+asmcomp/cmmgen.cmo: typing/types.cmi bytecomp/switch.cmi asmcomp/proc.cmi \
+    typing/primitive.cmi utils/misc.cmi bytecomp/lambda.cmi typing/ident.cmi \
+    utils/config.cmi asmcomp/compilenv.cmi asmcomp/cmm.cmi utils/clflags.cmo \
+    asmcomp/clambda.cmi parsing/asttypes.cmi asmcomp/arch.cmo \
+    asmcomp/cmmgen.cmi 
+asmcomp/cmmgen.cmx: typing/types.cmx bytecomp/switch.cmx asmcomp/proc.cmx \
+    typing/primitive.cmx utils/misc.cmx bytecomp/lambda.cmx typing/ident.cmx \
+    utils/config.cmx asmcomp/compilenv.cmx asmcomp/cmm.cmx utils/clflags.cmx \
+    asmcomp/clambda.cmx parsing/asttypes.cmi asmcomp/arch.cmx \
+    asmcomp/cmmgen.cmi 
+asmcomp/codegen.cmo: asmcomp/split.cmi asmcomp/spill.cmi asmcomp/reload.cmi \
+    asmcomp/reg.cmi asmcomp/printmach.cmi asmcomp/printlinear.cmi \
+    asmcomp/printcmm.cmi asmcomp/liveness.cmi asmcomp/linearize.cmi \
+    asmcomp/interf.cmi asmcomp/emit.cmi asmcomp/coloring.cmi asmcomp/cmm.cmi \
     asmcomp/codegen.cmi 
-asmcomp/codegen.cmx: asmcomp/cmm.cmx asmcomp/coloring.cmx asmcomp/emit.cmx \
-    asmcomp/interf.cmx asmcomp/linearize.cmx asmcomp/liveness.cmx \
-    asmcomp/printcmm.cmx asmcomp/printlinear.cmx asmcomp/printmach.cmx \
-    asmcomp/reg.cmx asmcomp/reload.cmx asmcomp/spill.cmx asmcomp/split.cmx \
+asmcomp/codegen.cmx: asmcomp/split.cmx asmcomp/spill.cmx asmcomp/reload.cmx \
+    asmcomp/reg.cmx asmcomp/printmach.cmx asmcomp/printlinear.cmx \
+    asmcomp/printcmm.cmx asmcomp/liveness.cmx asmcomp/linearize.cmx \
+    asmcomp/interf.cmx asmcomp/emit.cmx asmcomp/coloring.cmx asmcomp/cmm.cmx \
     asmcomp/codegen.cmi 
-asmcomp/coloring.cmo: asmcomp/proc.cmi asmcomp/reg.cmi asmcomp/coloring.cmi 
-asmcomp/coloring.cmx: asmcomp/proc.cmx asmcomp/reg.cmx asmcomp/coloring.cmi 
-asmcomp/comballoc.cmo: utils/config.cmi asmcomp/mach.cmi asmcomp/reg.cmi \
+asmcomp/coloring.cmo: asmcomp/reg.cmi asmcomp/proc.cmi asmcomp/coloring.cmi 
+asmcomp/coloring.cmx: asmcomp/reg.cmx asmcomp/proc.cmx asmcomp/coloring.cmi 
+asmcomp/comballoc.cmo: asmcomp/reg.cmi asmcomp/mach.cmi utils/config.cmi \
     asmcomp/comballoc.cmi 
-asmcomp/comballoc.cmx: utils/config.cmx asmcomp/mach.cmx asmcomp/reg.cmx \
+asmcomp/comballoc.cmx: asmcomp/reg.cmx asmcomp/mach.cmx utils/config.cmx \
     asmcomp/comballoc.cmi 
-asmcomp/compilenv.cmo: asmcomp/clambda.cmi utils/config.cmi typing/env.cmi \
-    typing/ident.cmi utils/misc.cmi asmcomp/compilenv.cmi 
-asmcomp/compilenv.cmx: asmcomp/clambda.cmx utils/config.cmx typing/env.cmx \
-    typing/ident.cmx utils/misc.cmx asmcomp/compilenv.cmi 
-asmcomp/emit.cmo: asmcomp/arch.cmo asmcomp/cmm.cmi asmcomp/compilenv.cmi \
-    utils/config.cmi asmcomp/emitaux.cmi asmcomp/linearize.cmi \
-    parsing/location.cmi asmcomp/mach.cmi utils/misc.cmi asmcomp/proc.cmi \
-    asmcomp/reg.cmi asmcomp/emit.cmi 
-asmcomp/emit.cmx: asmcomp/arch.cmx asmcomp/cmm.cmx asmcomp/compilenv.cmx \
-    utils/config.cmx asmcomp/emitaux.cmx asmcomp/linearize.cmx \
-    parsing/location.cmx asmcomp/mach.cmx utils/misc.cmx asmcomp/proc.cmx \
-    asmcomp/reg.cmx asmcomp/emit.cmi 
+asmcomp/compilenv.cmo: utils/misc.cmi typing/ident.cmi typing/env.cmi \
+    utils/config.cmi asmcomp/clambda.cmi asmcomp/compilenv.cmi 
+asmcomp/compilenv.cmx: utils/misc.cmx typing/ident.cmx typing/env.cmx \
+    utils/config.cmx asmcomp/clambda.cmx asmcomp/compilenv.cmi 
+asmcomp/emit.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
+    asmcomp/mach.cmi parsing/location.cmi asmcomp/linearize.cmi \
+    asmcomp/emitaux.cmi utils/config.cmi asmcomp/compilenv.cmi \
+    asmcomp/cmm.cmi utils/clflags.cmo asmcomp/arch.cmo asmcomp/emit.cmi 
+asmcomp/emit.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
+    asmcomp/mach.cmx parsing/location.cmx asmcomp/linearize.cmx \
+    asmcomp/emitaux.cmx utils/config.cmx asmcomp/compilenv.cmx \
+    asmcomp/cmm.cmx utils/clflags.cmx asmcomp/arch.cmx asmcomp/emit.cmi 
 asmcomp/emitaux.cmo: asmcomp/emitaux.cmi 
 asmcomp/emitaux.cmx: asmcomp/emitaux.cmi 
-asmcomp/interf.cmo: asmcomp/mach.cmi utils/misc.cmi asmcomp/proc.cmi \
-    asmcomp/reg.cmi asmcomp/interf.cmi 
-asmcomp/interf.cmx: asmcomp/mach.cmx utils/misc.cmx asmcomp/proc.cmx \
-    asmcomp/reg.cmx asmcomp/interf.cmi 
-asmcomp/linearize.cmo: asmcomp/cmm.cmi asmcomp/mach.cmi utils/misc.cmi \
-    asmcomp/proc.cmi asmcomp/reg.cmi asmcomp/linearize.cmi 
-asmcomp/linearize.cmx: asmcomp/cmm.cmx asmcomp/mach.cmx utils/misc.cmx \
-    asmcomp/proc.cmx asmcomp/reg.cmx asmcomp/linearize.cmi 
-asmcomp/liveness.cmo: asmcomp/mach.cmi utils/misc.cmi asmcomp/printmach.cmi \
-    asmcomp/proc.cmi asmcomp/reg.cmi asmcomp/liveness.cmi 
-asmcomp/liveness.cmx: asmcomp/mach.cmx utils/misc.cmx asmcomp/printmach.cmx \
-    asmcomp/proc.cmx asmcomp/reg.cmx asmcomp/liveness.cmi 
-asmcomp/mach.cmo: asmcomp/arch.cmo asmcomp/cmm.cmi asmcomp/reg.cmi \
+asmcomp/interf.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
+    asmcomp/mach.cmi asmcomp/interf.cmi 
+asmcomp/interf.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
+    asmcomp/mach.cmx asmcomp/interf.cmi 
+asmcomp/linearize.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
+    asmcomp/mach.cmi asmcomp/cmm.cmi asmcomp/linearize.cmi 
+asmcomp/linearize.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
+    asmcomp/mach.cmx asmcomp/cmm.cmx asmcomp/linearize.cmi 
+asmcomp/liveness.cmo: asmcomp/reg.cmi asmcomp/proc.cmi asmcomp/printmach.cmi \
+    utils/misc.cmi asmcomp/mach.cmi asmcomp/liveness.cmi 
+asmcomp/liveness.cmx: asmcomp/reg.cmx asmcomp/proc.cmx asmcomp/printmach.cmx \
+    utils/misc.cmx asmcomp/mach.cmx asmcomp/liveness.cmi 
+asmcomp/mach.cmo: asmcomp/reg.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
     asmcomp/mach.cmi 
-asmcomp/mach.cmx: asmcomp/arch.cmx asmcomp/cmm.cmx asmcomp/reg.cmx \
+asmcomp/mach.cmx: asmcomp/reg.cmx asmcomp/cmm.cmx asmcomp/arch.cmx \
     asmcomp/mach.cmi 
-asmcomp/printcmm.cmo: asmcomp/cmm.cmi typing/ident.cmi asmcomp/printcmm.cmi 
-asmcomp/printcmm.cmx: asmcomp/cmm.cmx typing/ident.cmx asmcomp/printcmm.cmi 
-asmcomp/printlinear.cmo: asmcomp/linearize.cmi asmcomp/mach.cmi \
-    asmcomp/printmach.cmi asmcomp/printlinear.cmi 
-asmcomp/printlinear.cmx: asmcomp/linearize.cmx asmcomp/mach.cmx \
-    asmcomp/printmach.cmx asmcomp/printlinear.cmi 
-asmcomp/printmach.cmo: asmcomp/arch.cmo asmcomp/cmm.cmi asmcomp/mach.cmi \
-    asmcomp/printcmm.cmi asmcomp/proc.cmi asmcomp/reg.cmi \
-    asmcomp/printmach.cmi 
-asmcomp/printmach.cmx: asmcomp/arch.cmx asmcomp/cmm.cmx asmcomp/mach.cmx \
-    asmcomp/printcmm.cmx asmcomp/proc.cmx asmcomp/reg.cmx \
-    asmcomp/printmach.cmi 
-asmcomp/proc.cmo: asmcomp/arch.cmo utils/ccomp.cmi utils/clflags.cmo \
-    asmcomp/cmm.cmi utils/config.cmi asmcomp/mach.cmi utils/misc.cmi \
-    asmcomp/reg.cmi asmcomp/proc.cmi 
-asmcomp/proc.cmx: asmcomp/arch.cmx utils/ccomp.cmx utils/clflags.cmx \
-    asmcomp/cmm.cmx utils/config.cmx asmcomp/mach.cmx utils/misc.cmx \
-    asmcomp/reg.cmx asmcomp/proc.cmi 
+asmcomp/printcmm.cmo: typing/ident.cmi asmcomp/cmm.cmi asmcomp/printcmm.cmi 
+asmcomp/printcmm.cmx: typing/ident.cmx asmcomp/cmm.cmx asmcomp/printcmm.cmi 
+asmcomp/printlinear.cmo: asmcomp/printmach.cmi asmcomp/mach.cmi \
+    asmcomp/linearize.cmi asmcomp/printlinear.cmi 
+asmcomp/printlinear.cmx: asmcomp/printmach.cmx asmcomp/mach.cmx \
+    asmcomp/linearize.cmx asmcomp/printlinear.cmi 
+asmcomp/printmach.cmo: asmcomp/reg.cmi asmcomp/proc.cmi asmcomp/printcmm.cmi \
+    asmcomp/mach.cmi asmcomp/cmm.cmi asmcomp/arch.cmo asmcomp/printmach.cmi 
+asmcomp/printmach.cmx: asmcomp/reg.cmx asmcomp/proc.cmx asmcomp/printcmm.cmx \
+    asmcomp/mach.cmx asmcomp/cmm.cmx asmcomp/arch.cmx asmcomp/printmach.cmi 
+asmcomp/proc.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
+    utils/config.cmi asmcomp/cmm.cmi utils/clflags.cmo utils/ccomp.cmi \
+    asmcomp/arch.cmo asmcomp/proc.cmi 
+asmcomp/proc.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
+    utils/config.cmx asmcomp/cmm.cmx utils/clflags.cmx utils/ccomp.cmx \
+    asmcomp/arch.cmx asmcomp/proc.cmi 
 asmcomp/reg.cmo: asmcomp/cmm.cmi asmcomp/reg.cmi 
 asmcomp/reg.cmx: asmcomp/cmm.cmx asmcomp/reg.cmi 
-asmcomp/reload.cmo: asmcomp/reloadgen.cmi asmcomp/reload.cmi 
-asmcomp/reload.cmx: asmcomp/reloadgen.cmx asmcomp/reload.cmi 
-asmcomp/reloadgen.cmo: asmcomp/mach.cmi utils/misc.cmi asmcomp/reg.cmi \
+asmcomp/reload.cmo: asmcomp/reloadgen.cmi asmcomp/reg.cmi asmcomp/mach.cmi \
+    asmcomp/cmm.cmi asmcomp/arch.cmo asmcomp/reload.cmi 
+asmcomp/reload.cmx: asmcomp/reloadgen.cmx asmcomp/reg.cmx asmcomp/mach.cmx \
+    asmcomp/cmm.cmx asmcomp/arch.cmx asmcomp/reload.cmi 
+asmcomp/reloadgen.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
     asmcomp/reloadgen.cmi 
-asmcomp/reloadgen.cmx: asmcomp/mach.cmx utils/misc.cmx asmcomp/reg.cmx \
+asmcomp/reloadgen.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
     asmcomp/reloadgen.cmi 
-asmcomp/schedgen.cmo: asmcomp/arch.cmo asmcomp/cmm.cmi asmcomp/linearize.cmi \
-    asmcomp/mach.cmi utils/misc.cmi asmcomp/reg.cmi asmcomp/schedgen.cmi 
-asmcomp/schedgen.cmx: asmcomp/arch.cmx asmcomp/cmm.cmx asmcomp/linearize.cmx \
-    asmcomp/mach.cmx utils/misc.cmx asmcomp/reg.cmx asmcomp/schedgen.cmi 
-asmcomp/scheduling.cmo: asmcomp/arch.cmo asmcomp/mach.cmi \
-    asmcomp/schedgen.cmi asmcomp/scheduling.cmi 
-asmcomp/scheduling.cmx: asmcomp/arch.cmx asmcomp/mach.cmx \
-    asmcomp/schedgen.cmx asmcomp/scheduling.cmi 
-asmcomp/selectgen.cmo: asmcomp/arch.cmo asmcomp/cmm.cmi typing/ident.cmi \
-    asmcomp/mach.cmi utils/misc.cmi asmcomp/proc.cmi asmcomp/reg.cmi \
-    utils/tbl.cmi asmcomp/selectgen.cmi 
-asmcomp/selectgen.cmx: asmcomp/arch.cmx asmcomp/cmm.cmx typing/ident.cmx \
-    asmcomp/mach.cmx utils/misc.cmx asmcomp/proc.cmx asmcomp/reg.cmx \
-    utils/tbl.cmx asmcomp/selectgen.cmi 
-asmcomp/selection.cmo: asmcomp/arch.cmo asmcomp/cmm.cmi asmcomp/mach.cmi \
-    utils/misc.cmi asmcomp/reg.cmi asmcomp/selectgen.cmi \
+asmcomp/schedgen.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
+    asmcomp/linearize.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
+    asmcomp/schedgen.cmi 
+asmcomp/schedgen.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
+    asmcomp/linearize.cmx asmcomp/cmm.cmx asmcomp/arch.cmx \
+    asmcomp/schedgen.cmi 
+asmcomp/scheduling.cmo: asmcomp/schedgen.cmi asmcomp/scheduling.cmi 
+asmcomp/scheduling.cmx: asmcomp/schedgen.cmx asmcomp/scheduling.cmi 
+asmcomp/selectgen.cmo: utils/tbl.cmi asmcomp/reg.cmi asmcomp/proc.cmi \
+    utils/misc.cmi asmcomp/mach.cmi typing/ident.cmi asmcomp/cmm.cmi \
+    asmcomp/arch.cmo asmcomp/selectgen.cmi 
+asmcomp/selectgen.cmx: utils/tbl.cmx asmcomp/reg.cmx asmcomp/proc.cmx \
+    utils/misc.cmx asmcomp/mach.cmx typing/ident.cmx asmcomp/cmm.cmx \
+    asmcomp/arch.cmx asmcomp/selectgen.cmi 
+asmcomp/selection.cmo: asmcomp/selectgen.cmi asmcomp/reg.cmi asmcomp/proc.cmi \
+    utils/misc.cmi asmcomp/mach.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
     asmcomp/selection.cmi 
-asmcomp/selection.cmx: asmcomp/arch.cmx asmcomp/cmm.cmx asmcomp/mach.cmx \
-    utils/misc.cmx asmcomp/reg.cmx asmcomp/selectgen.cmx \
+asmcomp/selection.cmx: asmcomp/selectgen.cmx asmcomp/reg.cmx asmcomp/proc.cmx \
+    utils/misc.cmx asmcomp/mach.cmx asmcomp/cmm.cmx asmcomp/arch.cmx \
     asmcomp/selection.cmi 
-asmcomp/spill.cmo: asmcomp/mach.cmi utils/misc.cmi asmcomp/proc.cmi \
-    asmcomp/reg.cmi asmcomp/spill.cmi 
-asmcomp/spill.cmx: asmcomp/mach.cmx utils/misc.cmx asmcomp/proc.cmx \
-    asmcomp/reg.cmx asmcomp/spill.cmi 
-asmcomp/split.cmo: asmcomp/mach.cmi utils/misc.cmi asmcomp/reg.cmi \
+asmcomp/spill.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
+    asmcomp/mach.cmi asmcomp/spill.cmi 
+asmcomp/spill.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
+    asmcomp/mach.cmx asmcomp/spill.cmi 
+asmcomp/split.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
     asmcomp/split.cmi 
-asmcomp/split.cmx: asmcomp/mach.cmx utils/misc.cmx asmcomp/reg.cmx \
+asmcomp/split.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
     asmcomp/split.cmi 
 driver/compile.cmi: typing/env.cmi 
 driver/optcompile.cmi: typing/env.cmi 
-driver/compile.cmo: bytecomp/bytegen.cmi utils/ccomp.cmi utils/clflags.cmo \
-    utils/config.cmi bytecomp/emitcode.cmi typing/env.cmi typing/ident.cmi \
-    utils/misc.cmi parsing/parse.cmi driver/pparse.cmi parsing/printast.cmi \
-    bytecomp/printinstr.cmi bytecomp/printlambda.cmi typing/printtyp.cmi \
-    bytecomp/simplif.cmi bytecomp/translmod.cmi typing/typedtree.cmi \
-    typing/typemod.cmi utils/warnings.cmi driver/compile.cmi 
-driver/compile.cmx: bytecomp/bytegen.cmx utils/ccomp.cmx utils/clflags.cmx \
-    utils/config.cmx bytecomp/emitcode.cmx typing/env.cmx typing/ident.cmx \
-    utils/misc.cmx parsing/parse.cmx driver/pparse.cmx parsing/printast.cmx \
-    bytecomp/printinstr.cmx bytecomp/printlambda.cmx typing/printtyp.cmx \
-    bytecomp/simplif.cmx bytecomp/translmod.cmx typing/typedtree.cmx \
-    typing/typemod.cmx utils/warnings.cmx driver/compile.cmi 
-driver/errors.cmo: bytecomp/bytelibrarian.cmi bytecomp/bytelink.cmi \
-    bytecomp/bytepackager.cmi typing/ctype.cmi typing/env.cmi \
-    typing/includemod.cmi parsing/lexer.cmi parsing/location.cmi \
-    driver/pparse.cmi bytecomp/symtable.cmi parsing/syntaxerr.cmi \
-    bytecomp/translclass.cmi bytecomp/translcore.cmi bytecomp/translmod.cmi \
-    typing/typeclass.cmi typing/typecore.cmi typing/typedecl.cmi \
-    typing/typemod.cmi typing/typetexp.cmi utils/warnings.cmi \
-    driver/errors.cmi 
-driver/errors.cmx: bytecomp/bytelibrarian.cmx bytecomp/bytelink.cmx \
-    bytecomp/bytepackager.cmx typing/ctype.cmx typing/env.cmx \
-    typing/includemod.cmx parsing/lexer.cmx parsing/location.cmx \
-    driver/pparse.cmx bytecomp/symtable.cmx parsing/syntaxerr.cmx \
-    bytecomp/translclass.cmx bytecomp/translcore.cmx bytecomp/translmod.cmx \
-    typing/typeclass.cmx typing/typecore.cmx typing/typedecl.cmx \
-    typing/typemod.cmx typing/typetexp.cmx utils/warnings.cmx \
-    driver/errors.cmi 
-driver/main.cmo: bytecomp/bytelibrarian.cmi bytecomp/bytelink.cmi \
-    bytecomp/bytepackager.cmi utils/clflags.cmo driver/compile.cmi \
-    utils/config.cmi driver/errors.cmi driver/main_args.cmi utils/misc.cmi \
-    utils/warnings.cmi driver/main.cmi 
-driver/main.cmx: bytecomp/bytelibrarian.cmx bytecomp/bytelink.cmx \
-    bytecomp/bytepackager.cmx utils/clflags.cmx driver/compile.cmx \
-    utils/config.cmx driver/errors.cmx driver/main_args.cmx utils/misc.cmx \
-    utils/warnings.cmx driver/main.cmi 
+driver/compile.cmo: utils/warnings.cmi typing/typemod.cmi \
+    typing/typedtree.cmi bytecomp/translmod.cmi bytecomp/simplif.cmi \
+    typing/printtyp.cmi bytecomp/printlambda.cmi bytecomp/printinstr.cmi \
+    parsing/printast.cmi driver/pparse.cmi parsing/parse.cmi utils/misc.cmi \
+    typing/ident.cmi typing/env.cmi bytecomp/emitcode.cmi utils/config.cmi \
+    utils/clflags.cmo utils/ccomp.cmi bytecomp/bytegen.cmi driver/compile.cmi 
+driver/compile.cmx: utils/warnings.cmx typing/typemod.cmx \
+    typing/typedtree.cmx bytecomp/translmod.cmx bytecomp/simplif.cmx \
+    typing/printtyp.cmx bytecomp/printlambda.cmx bytecomp/printinstr.cmx \
+    parsing/printast.cmx driver/pparse.cmx parsing/parse.cmx utils/misc.cmx \
+    typing/ident.cmx typing/env.cmx bytecomp/emitcode.cmx utils/config.cmx \
+    utils/clflags.cmx utils/ccomp.cmx bytecomp/bytegen.cmx driver/compile.cmi 
+driver/errors.cmo: utils/warnings.cmi typing/typetexp.cmi typing/typemod.cmi \
+    typing/typedecl.cmi typing/typecore.cmi typing/typeclass.cmi \
+    bytecomp/translmod.cmi bytecomp/translcore.cmi bytecomp/translclass.cmi \
+    parsing/syntaxerr.cmi bytecomp/symtable.cmi driver/pparse.cmi \
+    parsing/location.cmi parsing/lexer.cmi typing/includemod.cmi \
+    typing/env.cmi typing/ctype.cmi bytecomp/bytepackager.cmi \
+    bytecomp/bytelink.cmi bytecomp/bytelibrarian.cmi driver/errors.cmi 
+driver/errors.cmx: utils/warnings.cmx typing/typetexp.cmx typing/typemod.cmx \
+    typing/typedecl.cmx typing/typecore.cmx typing/typeclass.cmx \
+    bytecomp/translmod.cmx bytecomp/translcore.cmx bytecomp/translclass.cmx \
+    parsing/syntaxerr.cmx bytecomp/symtable.cmx driver/pparse.cmx \
+    parsing/location.cmx parsing/lexer.cmx typing/includemod.cmx \
+    typing/env.cmx typing/ctype.cmx bytecomp/bytepackager.cmx \
+    bytecomp/bytelink.cmx bytecomp/bytelibrarian.cmx driver/errors.cmi 
+driver/main.cmo: utils/warnings.cmi utils/misc.cmi driver/main_args.cmi \
+    driver/errors.cmi utils/config.cmi driver/compile.cmi utils/clflags.cmo \
+    bytecomp/bytepackager.cmi bytecomp/bytelink.cmi \
+    bytecomp/bytelibrarian.cmi driver/main.cmi 
+driver/main.cmx: utils/warnings.cmx utils/misc.cmx driver/main_args.cmx \
+    driver/errors.cmx utils/config.cmx driver/compile.cmx utils/clflags.cmx \
+    bytecomp/bytepackager.cmx bytecomp/bytelink.cmx \
+    bytecomp/bytelibrarian.cmx driver/main.cmi 
 driver/main_args.cmo: driver/main_args.cmi 
 driver/main_args.cmx: driver/main_args.cmi 
-driver/optcompile.cmo: asmcomp/asmgen.cmi utils/ccomp.cmi utils/clflags.cmo \
-    asmcomp/compilenv.cmi utils/config.cmi typing/env.cmi typing/ident.cmi \
-    utils/misc.cmi parsing/parse.cmi driver/pparse.cmi parsing/printast.cmi \
-    bytecomp/printlambda.cmi typing/printtyp.cmi bytecomp/simplif.cmi \
-    bytecomp/translmod.cmi typing/typedtree.cmi typing/typemod.cmi \
-    utils/warnings.cmi driver/optcompile.cmi 
-driver/optcompile.cmx: asmcomp/asmgen.cmx utils/ccomp.cmx utils/clflags.cmx \
-    asmcomp/compilenv.cmx utils/config.cmx typing/env.cmx typing/ident.cmx \
-    utils/misc.cmx parsing/parse.cmx driver/pparse.cmx parsing/printast.cmx \
-    bytecomp/printlambda.cmx typing/printtyp.cmx bytecomp/simplif.cmx \
-    bytecomp/translmod.cmx typing/typedtree.cmx typing/typemod.cmx \
-    utils/warnings.cmx driver/optcompile.cmi 
-driver/opterrors.cmo: asmcomp/asmgen.cmi asmcomp/asmlibrarian.cmi \
-    asmcomp/asmlink.cmi asmcomp/asmpackager.cmi asmcomp/compilenv.cmi \
-    typing/ctype.cmi typing/env.cmi typing/includemod.cmi parsing/lexer.cmi \
-    parsing/location.cmi driver/pparse.cmi parsing/syntaxerr.cmi \
-    bytecomp/translclass.cmi bytecomp/translcore.cmi bytecomp/translmod.cmi \
-    typing/typeclass.cmi typing/typecore.cmi typing/typedecl.cmi \
-    typing/typemod.cmi typing/typetexp.cmi utils/warnings.cmi \
-    driver/opterrors.cmi 
-driver/opterrors.cmx: asmcomp/asmgen.cmx asmcomp/asmlibrarian.cmx \
-    asmcomp/asmlink.cmx asmcomp/asmpackager.cmx asmcomp/compilenv.cmx \
-    typing/ctype.cmx typing/env.cmx typing/includemod.cmx parsing/lexer.cmx \
-    parsing/location.cmx driver/pparse.cmx parsing/syntaxerr.cmx \
-    bytecomp/translclass.cmx bytecomp/translcore.cmx bytecomp/translmod.cmx \
-    typing/typeclass.cmx typing/typecore.cmx typing/typedecl.cmx \
-    typing/typemod.cmx typing/typetexp.cmx utils/warnings.cmx \
-    driver/opterrors.cmi 
-driver/optmain.cmo: asmcomp/arch.cmo asmcomp/asmlibrarian.cmi \
-    asmcomp/asmlink.cmi asmcomp/asmpackager.cmi utils/clflags.cmo \
-    utils/config.cmi utils/misc.cmi driver/optcompile.cmi \
-    driver/opterrors.cmi asmcomp/printmach.cmi utils/warnings.cmi \
+driver/optcompile.cmo: utils/warnings.cmi typing/typemod.cmi \
+    typing/typedtree.cmi bytecomp/translmod.cmi bytecomp/simplif.cmi \
+    typing/printtyp.cmi bytecomp/printlambda.cmi parsing/printast.cmi \
+    driver/pparse.cmi parsing/parse.cmi utils/misc.cmi typing/ident.cmi \
+    typing/env.cmi utils/config.cmi asmcomp/compilenv.cmi utils/clflags.cmo \
+    utils/ccomp.cmi asmcomp/asmgen.cmi driver/optcompile.cmi 
+driver/optcompile.cmx: utils/warnings.cmx typing/typemod.cmx \
+    typing/typedtree.cmx bytecomp/translmod.cmx bytecomp/simplif.cmx \
+    typing/printtyp.cmx bytecomp/printlambda.cmx parsing/printast.cmx \
+    driver/pparse.cmx parsing/parse.cmx utils/misc.cmx typing/ident.cmx \
+    typing/env.cmx utils/config.cmx asmcomp/compilenv.cmx utils/clflags.cmx \
+    utils/ccomp.cmx asmcomp/asmgen.cmx driver/optcompile.cmi 
+driver/opterrors.cmo: utils/warnings.cmi typing/typetexp.cmi \
+    typing/typemod.cmi typing/typedecl.cmi typing/typecore.cmi \
+    typing/typeclass.cmi bytecomp/translmod.cmi bytecomp/translcore.cmi \
+    bytecomp/translclass.cmi parsing/syntaxerr.cmi driver/pparse.cmi \
+    parsing/location.cmi parsing/lexer.cmi typing/includemod.cmi \
+    typing/env.cmi typing/ctype.cmi asmcomp/compilenv.cmi \
+    asmcomp/asmpackager.cmi asmcomp/asmlink.cmi asmcomp/asmlibrarian.cmi \
+    asmcomp/asmgen.cmi driver/opterrors.cmi 
+driver/opterrors.cmx: utils/warnings.cmx typing/typetexp.cmx \
+    typing/typemod.cmx typing/typedecl.cmx typing/typecore.cmx \
+    typing/typeclass.cmx bytecomp/translmod.cmx bytecomp/translcore.cmx \
+    bytecomp/translclass.cmx parsing/syntaxerr.cmx driver/pparse.cmx \
+    parsing/location.cmx parsing/lexer.cmx typing/includemod.cmx \
+    typing/env.cmx typing/ctype.cmx asmcomp/compilenv.cmx \
+    asmcomp/asmpackager.cmx asmcomp/asmlink.cmx asmcomp/asmlibrarian.cmx \
+    asmcomp/asmgen.cmx driver/opterrors.cmi 
+driver/optmain.cmo: utils/warnings.cmi asmcomp/printmach.cmi \
+    driver/opterrors.cmi driver/optcompile.cmi utils/misc.cmi \
+    utils/config.cmi utils/clflags.cmo asmcomp/asmpackager.cmi \
+    asmcomp/asmlink.cmi asmcomp/asmlibrarian.cmi asmcomp/arch.cmo \
     driver/optmain.cmi 
-driver/optmain.cmx: asmcomp/arch.cmx asmcomp/asmlibrarian.cmx \
-    asmcomp/asmlink.cmx asmcomp/asmpackager.cmx utils/clflags.cmx \
-    utils/config.cmx utils/misc.cmx driver/optcompile.cmx \
-    driver/opterrors.cmx asmcomp/printmach.cmx utils/warnings.cmx \
+driver/optmain.cmx: utils/warnings.cmx asmcomp/printmach.cmx \
+    driver/opterrors.cmx driver/optcompile.cmx utils/misc.cmx \
+    utils/config.cmx utils/clflags.cmx asmcomp/asmpackager.cmx \
+    asmcomp/asmlink.cmx asmcomp/asmlibrarian.cmx asmcomp/arch.cmx \
     driver/optmain.cmi 
-driver/pparse.cmo: utils/ccomp.cmi utils/clflags.cmo parsing/location.cmi \
-    utils/misc.cmi driver/pparse.cmi 
-driver/pparse.cmx: utils/ccomp.cmx utils/clflags.cmx parsing/location.cmx \
-    utils/misc.cmx driver/pparse.cmi 
-toplevel/genprintval.cmi: typing/env.cmi typing/outcometree.cmi \
-    typing/path.cmi typing/types.cmi 
+driver/pparse.cmo: utils/misc.cmi parsing/location.cmi utils/clflags.cmo \
+    utils/ccomp.cmi driver/pparse.cmi 
+driver/pparse.cmx: utils/misc.cmx parsing/location.cmx utils/clflags.cmx \
+    utils/ccomp.cmx driver/pparse.cmi 
+toplevel/genprintval.cmi: typing/types.cmi typing/path.cmi \
+    typing/outcometree.cmi typing/env.cmi 
 toplevel/topdirs.cmi: parsing/longident.cmi 
-toplevel/toploop.cmi: typing/env.cmi parsing/location.cmi \
-    parsing/longident.cmi typing/outcometree.cmi parsing/parsetree.cmi \
-    typing/path.cmi typing/types.cmi utils/warnings.cmi 
-toplevel/trace.cmi: typing/env.cmi parsing/longident.cmi typing/path.cmi \
-    typing/types.cmi 
-toplevel/expunge.cmo: bytecomp/bytesections.cmi typing/ident.cmi \
-    utils/misc.cmi bytecomp/runtimedef.cmi bytecomp/symtable.cmi 
-toplevel/expunge.cmx: bytecomp/bytesections.cmx typing/ident.cmx \
-    utils/misc.cmx bytecomp/runtimedef.cmx bytecomp/symtable.cmx 
-toplevel/genprintval.cmo: typing/btype.cmi typing/ctype.cmi \
-    typing/datarepr.cmi typing/env.cmi typing/ident.cmi parsing/longident.cmi \
-    utils/misc.cmi typing/outcometree.cmi typing/path.cmi typing/predef.cmi \
-    typing/printtyp.cmi typing/types.cmi toplevel/genprintval.cmi 
-toplevel/genprintval.cmx: typing/btype.cmx typing/ctype.cmx \
-    typing/datarepr.cmx typing/env.cmx typing/ident.cmx parsing/longident.cmx \
-    utils/misc.cmx typing/outcometree.cmi typing/path.cmx typing/predef.cmx \
-    typing/printtyp.cmx typing/types.cmx toplevel/genprintval.cmi 
-toplevel/topdirs.cmo: utils/clflags.cmo utils/config.cmi utils/consistbl.cmi \
-    typing/ctype.cmi bytecomp/dll.cmi bytecomp/emitcode.cmi typing/env.cmi \
-    typing/ident.cmi parsing/longident.cmi bytecomp/meta.cmi utils/misc.cmi \
-    bytecomp/opcodes.cmo typing/path.cmi typing/printtyp.cmi \
-    bytecomp/symtable.cmi toplevel/toploop.cmi toplevel/trace.cmi \
-    typing/types.cmi utils/warnings.cmi toplevel/topdirs.cmi 
-toplevel/topdirs.cmx: utils/clflags.cmx utils/config.cmx utils/consistbl.cmx \
-    typing/ctype.cmx bytecomp/dll.cmx bytecomp/emitcode.cmx typing/env.cmx \
-    typing/ident.cmx parsing/longident.cmx bytecomp/meta.cmx utils/misc.cmx \
-    bytecomp/opcodes.cmx typing/path.cmx typing/printtyp.cmx \
-    bytecomp/symtable.cmx toplevel/toploop.cmx toplevel/trace.cmx \
-    typing/types.cmx utils/warnings.cmx toplevel/topdirs.cmi 
-toplevel/toploop.cmo: typing/btype.cmi bytecomp/bytegen.cmi utils/clflags.cmo \
-    driver/compile.cmi utils/config.cmi utils/consistbl.cmi bytecomp/dll.cmi \
-    bytecomp/emitcode.cmi typing/env.cmi driver/errors.cmi \
-    toplevel/genprintval.cmi typing/ident.cmi parsing/lexer.cmi \
-    parsing/location.cmi parsing/longident.cmi bytecomp/meta.cmi \
-    utils/misc.cmi typing/oprint.cmi typing/outcometree.cmi parsing/parse.cmi \
-    parsing/parsetree.cmi typing/path.cmi typing/predef.cmi \
-    parsing/printast.cmi bytecomp/printinstr.cmi bytecomp/printlambda.cmi \
-    typing/printtyp.cmi bytecomp/simplif.cmi bytecomp/symtable.cmi \
-    bytecomp/translmod.cmi typing/typecore.cmi typing/typedtree.cmi \
-    typing/typemod.cmi typing/types.cmi utils/warnings.cmi \
-    toplevel/toploop.cmi 
-toplevel/toploop.cmx: typing/btype.cmx bytecomp/bytegen.cmx utils/clflags.cmx \
-    driver/compile.cmx utils/config.cmx utils/consistbl.cmx bytecomp/dll.cmx \
-    bytecomp/emitcode.cmx typing/env.cmx driver/errors.cmx \
-    toplevel/genprintval.cmx typing/ident.cmx parsing/lexer.cmx \
-    parsing/location.cmx parsing/longident.cmx bytecomp/meta.cmx \
-    utils/misc.cmx typing/oprint.cmx typing/outcometree.cmi parsing/parse.cmx \
-    parsing/parsetree.cmi typing/path.cmx typing/predef.cmx \
-    parsing/printast.cmx bytecomp/printinstr.cmx bytecomp/printlambda.cmx \
-    typing/printtyp.cmx bytecomp/simplif.cmx bytecomp/symtable.cmx \
-    bytecomp/translmod.cmx typing/typecore.cmx typing/typedtree.cmx \
-    typing/typemod.cmx typing/types.cmx utils/warnings.cmx \
-    toplevel/toploop.cmi 
-toplevel/topmain.cmo: utils/clflags.cmo utils/config.cmi driver/errors.cmi \
-    utils/misc.cmi toplevel/topdirs.cmi toplevel/toploop.cmi \
-    utils/warnings.cmi toplevel/topmain.cmi 
-toplevel/topmain.cmx: utils/clflags.cmx utils/config.cmx driver/errors.cmx \
-    utils/misc.cmx toplevel/topdirs.cmx toplevel/toploop.cmx \
-    utils/warnings.cmx toplevel/topmain.cmi 
+toplevel/toploop.cmi: utils/warnings.cmi typing/types.cmi typing/path.cmi \
+    parsing/parsetree.cmi typing/outcometree.cmi parsing/longident.cmi \
+    parsing/location.cmi typing/env.cmi 
+toplevel/trace.cmi: typing/types.cmi typing/path.cmi parsing/longident.cmi \
+    typing/env.cmi 
+toplevel/expunge.cmo: bytecomp/symtable.cmi bytecomp/runtimedef.cmi \
+    utils/misc.cmi typing/ident.cmi bytecomp/bytesections.cmi 
+toplevel/expunge.cmx: bytecomp/symtable.cmx bytecomp/runtimedef.cmx \
+    utils/misc.cmx typing/ident.cmx bytecomp/bytesections.cmx 
+toplevel/genprintval.cmo: typing/types.cmi typing/printtyp.cmi \
+    typing/predef.cmi typing/path.cmi typing/outcometree.cmi utils/misc.cmi \
+    parsing/longident.cmi typing/ident.cmi typing/env.cmi typing/datarepr.cmi \
+    typing/ctype.cmi typing/btype.cmi toplevel/genprintval.cmi 
+toplevel/genprintval.cmx: typing/types.cmx typing/printtyp.cmx \
+    typing/predef.cmx typing/path.cmx typing/outcometree.cmi utils/misc.cmx \
+    parsing/longident.cmx typing/ident.cmx typing/env.cmx typing/datarepr.cmx \
+    typing/ctype.cmx typing/btype.cmx toplevel/genprintval.cmi 
+toplevel/topdirs.cmo: utils/warnings.cmi typing/types.cmi toplevel/trace.cmi \
+    toplevel/toploop.cmi bytecomp/symtable.cmi typing/printtyp.cmi \
+    typing/path.cmi bytecomp/opcodes.cmo utils/misc.cmi bytecomp/meta.cmi \
+    parsing/longident.cmi typing/ident.cmi typing/env.cmi \
+    bytecomp/emitcode.cmi bytecomp/dll.cmi typing/ctype.cmi \
+    utils/consistbl.cmi utils/config.cmi utils/clflags.cmo \
+    toplevel/topdirs.cmi 
+toplevel/topdirs.cmx: utils/warnings.cmx typing/types.cmx toplevel/trace.cmx \
+    toplevel/toploop.cmx bytecomp/symtable.cmx typing/printtyp.cmx \
+    typing/path.cmx bytecomp/opcodes.cmx utils/misc.cmx bytecomp/meta.cmx \
+    parsing/longident.cmx typing/ident.cmx typing/env.cmx \
+    bytecomp/emitcode.cmx bytecomp/dll.cmx typing/ctype.cmx \
+    utils/consistbl.cmx utils/config.cmx utils/clflags.cmx \
+    toplevel/topdirs.cmi 
+toplevel/toploop.cmo: utils/warnings.cmi typing/types.cmi typing/typemod.cmi \
+    typing/typedtree.cmi typing/typecore.cmi bytecomp/translmod.cmi \
+    bytecomp/symtable.cmi bytecomp/simplif.cmi typing/printtyp.cmi \
+    bytecomp/printlambda.cmi bytecomp/printinstr.cmi parsing/printast.cmi \
+    typing/predef.cmi typing/path.cmi parsing/parsetree.cmi parsing/parse.cmi \
+    typing/outcometree.cmi typing/oprint.cmi utils/misc.cmi bytecomp/meta.cmi \
+    parsing/longident.cmi parsing/location.cmi parsing/lexer.cmi \
+    typing/ident.cmi toplevel/genprintval.cmi driver/errors.cmi \
+    typing/env.cmi bytecomp/emitcode.cmi bytecomp/dll.cmi utils/consistbl.cmi \
+    utils/config.cmi driver/compile.cmi utils/clflags.cmo \
+    bytecomp/bytegen.cmi typing/btype.cmi toplevel/toploop.cmi 
+toplevel/toploop.cmx: utils/warnings.cmx typing/types.cmx typing/typemod.cmx \
+    typing/typedtree.cmx typing/typecore.cmx bytecomp/translmod.cmx \
+    bytecomp/symtable.cmx bytecomp/simplif.cmx typing/printtyp.cmx \
+    bytecomp/printlambda.cmx bytecomp/printinstr.cmx parsing/printast.cmx \
+    typing/predef.cmx typing/path.cmx parsing/parsetree.cmi parsing/parse.cmx \
+    typing/outcometree.cmi typing/oprint.cmx utils/misc.cmx bytecomp/meta.cmx \
+    parsing/longident.cmx parsing/location.cmx parsing/lexer.cmx \
+    typing/ident.cmx toplevel/genprintval.cmx driver/errors.cmx \
+    typing/env.cmx bytecomp/emitcode.cmx bytecomp/dll.cmx utils/consistbl.cmx \
+    utils/config.cmx driver/compile.cmx utils/clflags.cmx \
+    bytecomp/bytegen.cmx typing/btype.cmx toplevel/toploop.cmi 
+toplevel/topmain.cmo: utils/warnings.cmi toplevel/toploop.cmi \
+    toplevel/topdirs.cmi utils/misc.cmi driver/errors.cmi utils/config.cmi \
+    utils/clflags.cmo toplevel/topmain.cmi 
+toplevel/topmain.cmx: utils/warnings.cmx toplevel/toploop.cmx \
+    toplevel/topdirs.cmx utils/misc.cmx driver/errors.cmx utils/config.cmx \
+    utils/clflags.cmx toplevel/topmain.cmi 
 toplevel/topstart.cmo: toplevel/topmain.cmi 
 toplevel/topstart.cmx: toplevel/topmain.cmx 
-toplevel/trace.cmo: typing/ctype.cmi parsing/longident.cmi bytecomp/meta.cmi \
-    utils/misc.cmi typing/path.cmi typing/predef.cmi typing/printtyp.cmi \
-    toplevel/toploop.cmi typing/types.cmi toplevel/trace.cmi 
-toplevel/trace.cmx: typing/ctype.cmx parsing/longident.cmx bytecomp/meta.cmx \
-    utils/misc.cmx typing/path.cmx typing/predef.cmx typing/printtyp.cmx \
-    toplevel/toploop.cmx typing/types.cmx toplevel/trace.cmi 
+toplevel/trace.cmo: typing/types.cmi toplevel/toploop.cmi typing/printtyp.cmi \
+    typing/predef.cmi typing/path.cmi utils/misc.cmi bytecomp/meta.cmi \
+    parsing/longident.cmi typing/ctype.cmi toplevel/trace.cmi 
+toplevel/trace.cmx: typing/types.cmx toplevel/toploop.cmx typing/printtyp.cmx \
+    typing/predef.cmx typing/path.cmx utils/misc.cmx bytecomp/meta.cmx \
+    parsing/longident.cmx typing/ctype.cmx toplevel/trace.cmi 
--- ocaml-3.08.2/INSTALL	2004-07-02 12:11:27.000000000 +0100
+++ fresh-ocaml-3.08.2/INSTALL	2005-01-10 14:06:36.000000000 +0000
@@ -1,5 +1,5 @@
-            Installing Objective Caml on a Unix machine
-            -------------------------------------------
+            Installing Fresh Objective Caml on a Unix machine
+            -------------------------------------------------
 
 PREREQUISITES
 
@@ -126,14 +126,14 @@
 
         make world
 
-This builds the Objective Caml bytecode compiler for the first time.
+This builds the Fresh Objective Caml bytecode compiler for the first time.
 This phase is fairly verbose; consider redirecting the output to a file:
 
         make world > log.world 2>&1     # in sh
         make world >& log.world         # in csh
 
 3- (Optional) To be sure everything works well, you can try to
-bootstrap the system --- that is, to recompile all Objective Caml
+bootstrap the system --- that is, to recompile all Fresh Objective Caml
 sources with the newly created compiler. From the top directory, do:
 
         make bootstrap
@@ -152,60 +152,22 @@
 either crash almost immediately, or re-re-compile everything correctly
 and reach the fixpoint.
 
-4- If your platform is supported by the native-code compiler (as
-reported during the autoconfiguration), you can now build the
-native-code compiler. From the top directory, do:
-
-        make opt
-or:
-        make opt > log.opt 2>&1     # in sh
-        make opt >& log.opt         # in csh
-
-5- (Optional) If you want to give the native-code compiler a serious
-test, you can try to compile the Objective Caml compilers with the
-native-code compiler (they are compiled to bytecode by default).
-Just do:
-
-        make opt.opt
-
-Later, you can compile your programs to bytecode using ocamlc.opt
-instead of ocamlc, and to native-code using ocamlopt.opt instead of
-ocamlopt.  The ".opt" compilers should run faster than the normal
-compilers, especially on large input files, but they may take longer
-to start due to increased code size.  If compilation times are an issue on
-your programs, try the ".opt" compilers to see if they make a
-significant difference.
-
-An alternative, and faster approach to steps 2 to 5 is
-
-        make world.opt          # to build using native-code compilers
-
-The result is equivalent to "make world opt opt.opt", but this may
-fail if anything goes wrong in native-code generation.
-
-6- You can now install the Objective Caml system. This will create the
+4- You can now install the Fresh Objective Caml system. This will create the
 following commands (in the binary directory selected during
 autoconfiguration):
 
-        ocamlc           the batch bytecode compiler
-        ocamlopt         the batch native-code compiler (if supported)
-        ocamlrun         the runtime system for the bytecode compiler
-        ocamlyacc        the parser generator
-        ocamllex         the lexer generator
-        ocaml            the interactive, toplevel-based system
-        ocamlmktop       a tool to make toplevel systems that integrate
+        fresh-ocamlc     the batch bytecode compiler
+        fresh-ocamlrun   the runtime system for the bytecode compiler
+        fresh-ocamlyacc  the parser generator
+        fresh-ocamllex   the lexer generator
+        fresh-ocaml      the interactive, toplevel-based system
+        fresh-ocamlmktop a tool to make toplevel systems that integrate
                          user-defined C primitives and Caml code
-        ocamldebug       the source-level replay debugger
-        ocamldep         generator of "make" dependencies for Caml sources
-        ocamldoc         documentation generator
-        ocamlprof        execution count profiler
-        ocamlcp          the bytecode compiler in profiling mode
-
-and also, if you built them during step 5,
-
-        ocamlc.opt       the batch bytecode compiler compiled with ocamlopt
-        ocamlopt.opt     the batch native-code compiler compiled with ocamlopt
-        ocamllex.opt     the lexer generator compiled with ocamlopt
+        fresh-ocamldebug the source-level replay debugger
+        fresh-ocamldep   generator of "make" dependencies for Caml sources
+        fresh-ocamldoc   documentation generator
+        fresh-ocamlprof  execution count profiler
+        fresh-ocamlcp    the bytecode compiler in profiling mode
 
 From the top directory, become superuser and do:
 
--- ocaml-3.08.2/Makefile	2004-07-16 17:11:33.000000000 +0100
+++ fresh-ocaml-3.08.2/Makefile	2005-01-11 16:38:00.000000000 +0000
@@ -17,17 +17,17 @@
 include config/Makefile
 include stdlib/StdlibModules
 
-CAMLC=boot/ocamlrun boot/ocamlc -nostdlib -I boot
-CAMLOPT=boot/ocamlrun ./ocamlopt -nostdlib -I stdlib
+CAMLC=boot/fresh-ocamlrun boot/fresh-ocamlc -nostdlib -I boot
+CAMLOPT=boot/fresh-ocamlrun ./fresh-ocamlopt -nostdlib -I stdlib
 COMPFLAGS=-warn-error A $(INCLUDES)
 LINKFLAGS=
 
-CAMLYACC=boot/ocamlyacc
+CAMLYACC=boot/fresh-ocamlyacc
 YACCFLAGS=-v
-CAMLLEX=boot/ocamlrun boot/ocamllex
-CAMLDEP=boot/ocamlrun tools/ocamldep
+CAMLLEX=boot/fresh-ocamlrun boot/fresh-ocamllex
+CAMLDEP=boot/fresh-ocamlrun tools/fresh-ocamldep
 DEPFLAGS=$(INCLUDES)
-CAMLRUN=byterun/ocamlrun
+CAMLRUN=byterun/fresh-ocamlrun
 SHELL=/bin/sh
 MKDIR=mkdir -p
 
@@ -109,7 +109,7 @@
   typing/predef.cmo bytecomp/runtimedef.cmo bytecomp/bytesections.cmo \
   bytecomp/dll.cmo bytecomp/meta.cmo bytecomp/symtable.cmo toplevel/expunge.cmo
 
-PERVASIVES=$(STDLIB_MODULES) outcometree topdirs toploop
+PERVASIVES=$(STDLIB_MODULES) outcometree topdirs toploop freshness
 
 # For users who don't read the INSTALL file
 defaultentry:
@@ -117,13 +117,14 @@
 	@echo "If you've just unpacked the distribution, something like"
 	@echo "	./configure"
 	@echo "	make world"
-	@echo "	make opt"
 	@echo "	make install"
 	@echo "should work.  But see the file INSTALL for more details."
 
 # Recompile the system using the bootstrap compiler
-all: runtime ocamlc ocamllex ocamlyacc ocamltools library ocaml \
-  otherlibraries camlp4out $(DEBUGGER) ocamldoc
+all: runtime fresh-ocamlc fresh-ocamllex fresh-ocamlyacc ocamltools library fresh-ocaml \
+  otherlibraries $(DEBUGGER) fresh-ocamldoc
+
+#  otherlibraries camlp4out $(DEBUGGER) fresh-ocamldoc
 
 # The compilation of ocaml will fail if the runtime has changed.
 # Never mind, just do make bootstrap to reach fixpoint again.
@@ -144,7 +145,7 @@
 	$(MAKE) promote-cross
 # Rebuild ocamlc and ocamllex (run on byterun/ocamlrun)
 	$(MAKE) partialclean
-	$(MAKE) ocamlc ocamllex
+	$(MAKE) fresh-ocamlc fresh-ocamllex
 # Rebuild the library (using byterun/ocamlrun ./ocamlc)
 	$(MAKE) library-cross
 # Promote the new compiler and the new runtime
@@ -166,10 +167,10 @@
 # Start up the system from the distribution compiler
 coldstart:
 	cd byterun; $(MAKE) all
-	cp byterun/ocamlrun$(EXE) boot/ocamlrun$(EXE)
+	cp byterun/fresh-ocamlrun$(EXE) boot/fresh-ocamlrun$(EXE)
 	cd yacc; $(MAKE) all
-	cp yacc/ocamlyacc$(EXE) boot/ocamlyacc$(EXE)
-	cd stdlib; $(MAKE) COMPILER=../boot/ocamlc all
+	cp yacc/fresh-ocamlyacc$(EXE) boot/fresh-ocamlyacc$(EXE)
+	cd stdlib; $(MAKE) COMPILER=../boot/fresh-ocamlc all
 	cd stdlib; cp $(LIBFILES) ../boot
 	if test -f boot/libcamlrun.a; then :; else \
           ln -s ../byterun/libcamlrun.a boot/libcamlrun.a; fi
@@ -177,7 +178,7 @@
           ln -s ../byterun stdlib/caml; fi
 
 # Build the core system: the minimum needed to make depend and bootstrap
-core : runtime ocamlc ocamllex ocamlyacc ocamltools library
+core : runtime fresh-ocamlc fresh-ocamllex fresh-ocamlyacc ocamltools library
 
 # Save the current bootstrap compiler
 MAXSAVED=boot/Saved/Saved.prev/Saved.prev/Saved.prev/Saved.prev/Saved.prev
@@ -187,22 +188,22 @@
 	mv boot/Saved boot/Saved.prev
 	mkdir boot/Saved
 	mv boot/Saved.prev boot/Saved/Saved.prev
-	cp boot/ocamlrun$(EXE) boot/Saved
-	mv boot/ocamlc boot/ocamllex boot/ocamlyacc$(EXE) boot/Saved
+	cp boot/fresh-ocamlrun$(EXE) boot/Saved
+	mv boot/fresh-ocamlc boot/fresh-ocamllex boot/fresh-ocamlyacc$(EXE) boot/Saved
 	cd boot; cp $(LIBFILES) Saved
 
 # Promote the newly compiled system to the rank of cross compiler
 # (Runs on the old runtime, produces code for the new runtime)
 promote-cross:
-	cp ocamlc boot/ocamlc
-	cp lex/ocamllex boot/ocamllex
-	cp yacc/ocamlyacc$(EXE) boot/ocamlyacc$(EXE)
+	cp fresh-ocamlc boot/fresh-ocamlc
+	cp lex/fresh-ocamllex boot/fresh-ocamllex
+	cp yacc/fresh-ocamlyacc$(EXE) boot/fresh-ocamlyacc$(EXE)
 	cd stdlib; cp $(LIBFILES) ../boot
 
 # Promote the newly compiled system to the rank of bootstrap compiler
 # (Runs on the new runtime, produces code for the new runtime)
 promote: promote-cross
-	cp byterun/ocamlrun$(EXE) boot/ocamlrun$(EXE)
+	cp byterun/fresh-ocamlrun$(EXE) boot/fresh-ocamlrun$(EXE)
 
 # Restore the saved bootstrap compiler if a problem arises
 restore:
@@ -212,7 +213,7 @@
 
 # Check if fixpoint reached
 compare:
-	@if cmp boot/ocamlc ocamlc && cmp boot/ocamllex lex/ocamllex; \
+	@if cmp boot/fresh-ocamlc fresh-ocamlc && cmp boot/fresh-ocamllex lex/fresh-ocamllex; \
 	then echo "Fixpoint reached, bootstrap succeeded."; \
         else echo "Fixpoint not reached, try one more bootstrapping cycle."; \
 	fi
@@ -222,13 +223,18 @@
 	rm -rf boot/Saved/Saved.prev/*
 
 # Compile the native-code compiler
-opt-core:runtimeopt ocamlopt libraryopt
-opt: runtimeopt ocamlopt libraryopt otherlibrariesopt camlp4opt
+opt-core:runtimeopt fresh-ocamlopt libraryopt
+opt: runtimeopt fresh-ocamlopt libraryopt otherlibrariesopt
+#camlp4opt
 
 # Native-code versions of the tools
-opt.opt: checkstack core ocaml opt-core ocamlc.opt otherlibraries camlp4out \
-	 $(DEBUGGER) ocamldoc ocamlopt.opt otherlibrariesopt \
-	 camlp4opt ocamllex.opt ocamltoolsopt.opt camlp4optopt ocamldoc.opt
+opt.opt: checkstack core fresh-ocaml opt-core \
+         fresh-ocamlc.opt otherlibraries \
+	 $(DEBUGGER) ocamldoc fresh-ocamlopt.opt otherlibrariesopt \
+	 fresh-ocamllex.opt ocamltoolsopt.opt \
+	 ocamldoc.opt
+#	 camlp4opt fresh-ocamllex.opt ocamltoolsopt.opt \
+#	 camlp4optopt ocamldoc.opt
 
 # Installation
 install: FORCE
@@ -240,11 +246,11 @@
           dllthreads.so dllunix.so dllgraphics.so dllmldbm.so dllstr.so \
           dlltkanim.so
 	cd byterun; $(MAKE) install
-	cp ocamlc $(BINDIR)/ocamlc$(EXE)
-	cp ocaml $(BINDIR)/ocaml$(EXE)
+	cp fresh-ocamlc $(BINDIR)/fresh-ocamlc$(EXE)
+	cp fresh-ocaml $(BINDIR)/fresh-ocaml$(EXE)
 	cd stdlib; $(MAKE) install
-	cp lex/ocamllex $(BINDIR)/ocamllex$(EXE)
-	cp yacc/ocamlyacc$(EXE) $(BINDIR)/ocamlyacc$(EXE)
+	cp lex/fresh-ocamllex $(BINDIR)/fresh-ocamllex$(EXE)
+	cp yacc/fresh-ocamlyacc$(EXE) $(BINDIR)/fresh-ocamlyacc$(EXE)
 	cp toplevel/toplevellib.cma $(LIBDIR)/toplevellib.cma
 	cp expunge $(LIBDIR)/expunge$(EXE)
 	cp typing/outcometree.cmi typing/outcometree.mli $(LIBDIR)
@@ -256,61 +262,61 @@
           (cd otherlibs/$$i; $(MAKE) install) || exit $$?; \
         done
 	cd ocamldoc; $(MAKE) install
-	if test -f ocamlopt; then $(MAKE) installopt; else :; fi
-	cd camlp4; $(MAKE) install BINDIR=$(BINDIR) LIBDIR=$(LIBDIR) MANDIR=$(MANDIR)
-	if test -f debugger/ocamldebug; then (cd debugger; $(MAKE) install); \
+	if test -f fresh-ocamlopt; then $(MAKE) installopt; else :; fi
+#	cd camlp4; $(MAKE) install BINDIR=$(BINDIR) LIBDIR=$(LIBDIR) MANDIR=$(MANDIR)
+	if test -f debugger/fresh-ocamldebug; then (cd debugger; $(MAKE) install); \
 	   else :; fi
 
 # Installation of the native-code compiler
 installopt:
 	cd asmrun; $(MAKE) install
-	cp ocamlopt $(BINDIR)/ocamlopt$(EXE)
+	cp fresh-ocamlopt $(BINDIR)/fresh-ocamlopt$(EXE)
 	cd stdlib; $(MAKE) installopt
 	cd ocamldoc; $(MAKE) installopt
 	for i in $(OTHERLIBRARIES); do (cd otherlibs/$$i; $(MAKE) installopt) || exit $$?; done
-	if test -f ocamlc.opt; \
-	  then cp ocamlc.opt $(BINDIR)/ocamlc.opt$(EXE); else :; fi
-	if test -f ocamlopt.opt; \
-	  then cp ocamlopt.opt $(BINDIR)/ocamlopt.opt$(EXE); else :; fi
-	if test -f lex/ocamllex.opt; \
-	  then cp lex/ocamllex.opt $(BINDIR)/ocamllex.opt$(EXE); else :; fi
+	if test -f fresh-ocamlc.opt; \
+	  then cp fresh-ocamlc.opt $(BINDIR)/fresh-ocamlc.opt$(EXE); else :; fi
+	if test -f fresh-ocamlopt.opt; \
+	  then cp fresh-ocamlopt.opt $(BINDIR)/fresh-ocamlopt.opt$(EXE); else :; fi
+	if test -f lex/fresh-ocamllex.opt; \
+	  then cp lex/fresh-ocamllex.opt $(BINDIR)/fresh-ocamllex.opt$(EXE); else :; fi
 
 clean:: partialclean
 
 # The compiler
 
-ocamlc: $(COMPOBJS)
-	$(CAMLC) $(LINKFLAGS) -o ocamlc $(COMPOBJS)
-	@sed -e 's|@compiler@|$$topdir/boot/ocamlrun $$topdir/ocamlc|' \
+fresh-ocamlc: $(COMPOBJS)
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamlc $(COMPOBJS)
+	@sed -e 's|@compiler@|$$topdir/boot/fresh-ocamlrun $$topdir/fresh-ocamlc|' \
 	  driver/ocamlcomp.sh.in > ocamlcomp.sh
 	@chmod +x ocamlcomp.sh
 
 partialclean::
-	rm -f ocamlc ocamlcomp.sh
+	rm -f fresh-ocamlc ocamlcomp.sh
 
 # The native-code compiler
 
-ocamlopt: $(OPTOBJS)
-	$(CAMLC) $(LINKFLAGS) -o ocamlopt $(OPTOBJS)
-	@sed -e 's|@compiler@|$$topdir/boot/ocamlrun $$topdir/ocamlopt|' \
+fresh-ocamlopt: $(OPTOBJS)
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamlopt $(OPTOBJS)
+	@sed -e 's|@compiler@|$$topdir/boot/fresh-ocamlrun $$topdir/fresh-ocamlopt|' \
 	  driver/ocamlcomp.sh.in > ocamlcompopt.sh
 	@chmod +x ocamlcompopt.sh
 
 partialclean::
-	rm -f ocamlopt ocamlcompopt.sh
+	rm -f fresh-ocamlopt ocamlcompopt.sh
 
 # The toplevel
 
-ocaml: $(TOPOBJS) expunge
-	$(CAMLC) $(LINKFLAGS) -linkall -o ocaml.tmp $(TOPOBJS)
-	- $(CAMLRUN) ./expunge ocaml.tmp ocaml $(PERVASIVES)
+fresh-ocaml: $(TOPOBJS) expunge
+	$(CAMLC) $(LINKFLAGS) -linkall -o fresh-ocaml.tmp $(TOPOBJS)
+	- $(CAMLRUN) ./expunge fresh-ocaml.tmp fresh-ocaml $(PERVASIVES)
 	rm -f ocaml.tmp
 
 toplevel/toplevellib.cma: $(TOPLIB)
 	$(CAMLC) -a -o $@ $(TOPLIB)
 
 partialclean::
-	rm -f ocaml toplevel/toplevellib.cma
+	rm -f fresh-ocaml toplevel/toplevellib.cma
 
 # The configuration file
 
@@ -378,12 +384,12 @@
 
 # The bytecode compiler compiled with the native-code compiler
 
-ocamlc.opt: $(COMPOBJS:.cmo=.cmx)
+fresh-ocamlc.opt: $(COMPOBJS:.cmo=.cmx)
 	cd asmrun; $(MAKE) meta.o dynlink.o
-	$(CAMLOPT) $(LINKFLAGS) -ccopt "$(BYTECCLINKOPTS)" -o ocamlc.opt \
+	$(CAMLOPT) $(LINKFLAGS) -ccopt "$(BYTECCLINKOPTS)" -o fresh-ocamlc.opt \
           $(COMPOBJS:.cmo=.cmx) \
           asmrun/meta.o asmrun/dynlink.o -cclib "$(BYTECCLIBS)"
-	@sed -e 's|@compiler@|$$topdir/ocamlc.opt|' \
+	@sed -e 's|@compiler@|$$topdir/fresh-ocamlc.opt|' \
 	  driver/ocamlcomp.sh.in > ocamlcomp.sh
 	@chmod +x ocamlcomp.sh
 
@@ -392,16 +398,16 @@
 
 # The native-code compiler compiled with itself
 
-ocamlopt.opt: $(OPTOBJS:.cmo=.cmx)
-	$(CAMLOPT) $(LINKFLAGS) -o ocamlopt.opt $(OPTOBJS:.cmo=.cmx)
-	@sed -e 's|@compiler@|$$topdir/ocamlopt.opt|' \
+fresh-ocamlopt.opt: $(OPTOBJS:.cmo=.cmx)
+	$(CAMLOPT) $(LINKFLAGS) -o fresh-ocamlopt.opt $(OPTOBJS:.cmo=.cmx)
+	@sed -e 's|@compiler@|$$topdir/fresh-ocamlopt.opt|' \
 	  driver/ocamlcomp.sh.in > ocamlcompopt.sh
 	@chmod +x ocamlcompopt.sh
 
 partialclean::
-	rm -f ocamlopt.opt
+	rm -f fresh-ocamlopt.opt
 
-$(OPTOBJS:.cmo=.cmx): ocamlopt
+$(OPTOBJS:.cmo=.cmx): fresh-ocamlopt
 
 # The numeric opcodes
 
@@ -487,7 +493,7 @@
 beforedepend:: asmcomp/emit.ml
 
 tools/cvt_emit: tools/cvt_emit.mll
-	cd tools; $(MAKE) CAMLC="../$(CAMLRUN) ../ocamlc -I ../stdlib" cvt_emit
+	cd tools; $(MAKE) CAMLC="../$(CAMLRUN) ../fresh-ocamlc -I ../stdlib" cvt_emit
 
 # The "expunge" utility
 
@@ -524,10 +530,10 @@
 
 # The library
 
-library: ocamlc
+library: fresh-ocamlc
 	cd stdlib; $(MAKE) all
 library-cross:
-	cd stdlib; $(MAKE) RUNTIME=../byterun/ocamlrun all
+	cd stdlib; $(MAKE) RUNTIME=../byterun/fresh-ocamlrun all
 libraryopt:
 	cd stdlib; $(MAKE) allopt
 partialclean::
@@ -537,25 +543,25 @@
 
 # The lexer and parser generators
 
-ocamllex: ocamlyacc ocamlc
+fresh-ocamllex: fresh-ocamlyacc fresh-ocamlc
 	cd lex; $(MAKE) all
-ocamllex.opt: ocamlopt
+fresh-ocamllex.opt: fresh-ocamlopt
 	cd lex; $(MAKE) allopt
 partialclean::
 	cd lex; $(MAKE) clean
 alldepend::
 	cd lex; $(MAKE) depend
 
-ocamlyacc:
+fresh-ocamlyacc:
 	cd yacc; $(MAKE) all
 clean::
 	cd yacc; $(MAKE) clean
 
 # Tools
 
-ocamltools: ocamlc ocamlyacc ocamllex
+ocamltools: fresh-ocamlc fresh-ocamlyacc fresh-ocamllex
 	cd tools; $(MAKE) all
-ocamltoolsopt.opt: ocamlc.opt ocamlyacc ocamllex
+ocamltoolsopt.opt: fresh-ocamlc.opt fresh-ocamlyacc fresh-ocamllex
 	cd tools; $(MAKE) opt.opt
 partialclean::
 	cd tools; $(MAKE) clean
@@ -564,9 +570,9 @@
 
 # OCamldoc
 
-ocamldoc: ocamlc ocamlyacc ocamllex
+fresh-ocamldoc: fresh-ocamlc fresh-ocamlyacc fresh-ocamllex
 	cd ocamldoc && $(MAKE) all
-ocamldoc.opt: ocamlc.opt ocamlyacc ocamllex
+ocamldoc.opt: fresh-ocamlc.opt fresh-ocamlyacc fresh-ocamllex
 	cd ocamldoc && $(MAKE) opt.opt
 partialclean::
 	cd ocamldoc && $(MAKE) clean
@@ -594,7 +600,7 @@
 
 # The replay debugger
 
-ocamldebugger: ocamlc ocamlyacc ocamllex
+ocamldebugger: fresh-ocamlc fresh-ocamlyacc fresh-ocamllex
 	cd debugger; $(MAKE) all
 partialclean::
 	cd debugger; $(MAKE) clean
@@ -603,7 +609,7 @@
 
 # Camlp4
 
-camlp4out: ocamlc
+camlp4out: fresh-ocamlc
 	cd camlp4; $(MAKE) all
 camlp4opt: ocamlopt
 	cd camlp4; $(MAKE) opt
--- ocaml-3.08.2/asmcomp/cmmgen.ml	2004-05-26 12:10:27.000000000 +0100
+++ fresh-ocaml-3.08.2/asmcomp/cmmgen.ml	2005-01-11 16:51:59.000000000 +0000
@@ -630,6 +630,11 @@
       Pccall (default_prim ("bigarray_get_" ^ string_of_int n))
   | Pbigarrayset(n, kind, Pbigarray_unknown_layout) ->
       Pccall (default_prim ("bigarray_set_" ^ string_of_int n))
+  | Pswapatoms -> Pccall (default_prim "fresh_swap_atoms")
+  | Pfreshen -> Pccall (default_prim "fresh_throughout")
+  | Pnewatom -> Pccall (default_prim "fresh_new_atom")
+  | Pfreshfor -> Pccall (default_prim "fresh_freshfor")
+  | Pcreateabst -> Pccall (default_prim "fresh_create_abstraction")
   | p ->
       if size_int = 8 then p else simplif_primitive_32bits p
 
--- ocaml-3.08.2/asmrun/Makefile	2004-05-09 16:19:16.000000000 +0100
+++ fresh-ocaml-3.08.2/asmrun/Makefile	2005-01-11 16:30:57.000000000 +0000
@@ -26,7 +26,8 @@
   misc.o freelist.o major_gc.o minor_gc.o memory.o alloc.o compare.o ints.o \
   floats.o str.o array.o io.o extern.o intern.o hash.o sys.o parsing.o \
   gc_ctrl.o terminfo.o md5.o obj.o lexing.o printexc.o callback.o weak.o \
-  compact.o finalise.o custom.o unix.o
+  compact.o finalise.o custom.o unix.o freshness.o hashtable_cwc22.o \
+  hashtable_itr_cwc22.o
 
 ASMOBJS=$(ARCH).o
 
@@ -118,6 +119,12 @@
 	ln -s ../byterun/md5.c md5.c
 obj.c: ../byterun/obj.c
 	ln -s ../byterun/obj.c obj.c
+freshness.c: ../byterun/freshness.c
+	ln -s ../byterun/freshness.c freshness.c
+hashtable_itr_cwc22.c: ../byterun/hashtable_itr_cwc22.c
+	ln -s ../byterun/hashtable_itr_cwc22.c hashtable_itr_cwc22.c
+hashtable_cwc22.c: ../byterun/hashtable_cwc22.c
+	ln -s ../byterun/hashtable_cwc22.c hashtable_cwc22.c
 lexing.c: ../byterun/lexing.c
 	ln -s ../byterun/lexing.c lexing.c
 printexc.c: ../byterun/printexc.c
@@ -145,7 +152,7 @@
   compare.c ints.c floats.c str.c io.c extern.c intern.c hash.c sys.c \
   parsing.c gc_ctrl.c terminfo.c md5.c obj.c lexing.c printexc.c callback.c \
   weak.c compact.c finalise.c meta.c custom.c main.c globroots.c unix.c \
-  dynlink.c
+  dynlink.c freshness.c hashtable_cwc22.c hashtable_itr_cwc22.c
 
 clean::
 	rm -f $(LINKEDFILES)
--- ocaml-3.08.2/bytecomp/bytegen.ml	2004-07-07 17:49:51.000000000 +0100
+++ fresh-ocaml-3.08.2/bytecomp/bytegen.ml	2005-01-10 14:06:36.000000000 +0000
@@ -353,6 +353,11 @@
   | Pbintcomp(bi, Cge) -> Kccall("caml_greaterequal", 2)
   | Pbigarrayref(n, _, _) -> Kccall("bigarray_get_" ^ string_of_int n, n + 1)
   | Pbigarrayset(n, _, _) -> Kccall("bigarray_set_" ^ string_of_int n, n + 2)
+  | Pswapatoms -> Kccall("fresh_swap_atoms", 3)
+  | Pfreshen -> Kccall("fresh_throughout", 1)
+  | Pnewatom -> Kccall("fresh_new_atom", 1)
+  | Pfreshfor -> Kccall("fresh_freshfor", 2)
+  | Pcreateabst -> Kccall("fresh_create_abstraction", 2)
   | _ -> fatal_error "Bytegen.comp_primitive"
 
 let is_immed n = immed_min <= n && n <= immed_max
--- ocaml-3.08.2/bytecomp/lambda.ml	2004-07-07 17:49:51.000000000 +0100
+++ fresh-ocaml-3.08.2/bytecomp/lambda.ml	2005-01-11 16:46:34.000000000 +0000
@@ -81,6 +81,12 @@
   (* Operations on big arrays *)
   | Pbigarrayref of int * bigarray_kind * bigarray_layout
   | Pbigarrayset of int * bigarray_kind * bigarray_layout
+  (* Freshness operations *)
+  | Pswapatoms   (* arity 3 *)
+  | Pfreshen     (* arity 1 *)
+  | Pnewatom	 (* arity 1 *)
+  | Pfreshfor	 (* arity 2 *)
+  | Pcreateabst  (* arity 2 *)
 
 and comparison =
     Ceq | Cneq | Clt | Cgt | Cle | Cge
--- ocaml-3.08.2/bytecomp/lambda.mli	2004-07-07 17:49:53.000000000 +0100
+++ fresh-ocaml-3.08.2/bytecomp/lambda.mli	2005-01-10 14:06:36.000000000 +0000
@@ -81,6 +81,12 @@
   (* Operations on big arrays *)
   | Pbigarrayref of int * bigarray_kind * bigarray_layout
   | Pbigarrayset of int * bigarray_kind * bigarray_layout
+  (* Freshness operations *)
+  | Pswapatoms
+  | Pfreshen
+  | Pnewatom
+  | Pfreshfor
+  | Pcreateabst
 
 and comparison =
     Ceq | Cneq | Clt | Cgt | Cle | Cge
--- ocaml-3.08.2/bytecomp/matching.ml	2004-04-29 13:38:11.000000000 +0100
+++ fresh-ocaml-3.08.2/bytecomp/matching.ml	2005-01-10 14:06:36.000000000 +0000
@@ -193,6 +193,10 @@
       (fun q rem -> match q.pat_desc with
       | Tpat_tuple args -> p,args @ rem
       | _          -> p, omegas @ rem)
+  | Tpat_abst (o1, o2) ->
+      (fun q rem -> match q.pat_desc with
+        Tpat_abst (p1, p2) -> p, [p1; p2] @ rem
+      | _ -> p, [o1; o2] @ rem)
   | Tpat_record l -> (* Records are normalized *)
       (fun q rem -> match q.pat_desc with
       | Tpat_record l' ->
@@ -613,6 +617,7 @@
     List.fold_left extract_vars r pats
 | Tpat_variant (_,Some p, _) -> extract_vars r p
 | Tpat_or (p,_,_) -> extract_vars r p
+| Tpat_abst (p1, p2) -> List.fold_left extract_vars r [p1; p2]
 | Tpat_constant _|Tpat_any|Tpat_variant (_,None,_) -> r
 
 exception Cannot_flatten
@@ -679,6 +684,10 @@
   | {pat_desc=Tpat_array _} -> true
   | _ -> false
 
+and group_abst = function
+  | {pat_desc=Tpat_abst _} -> true
+  | _ -> false
+
 let get_group p = match p.pat_desc with
 | Tpat_any -> group_var
 | Tpat_constant _ -> group_constant
@@ -687,6 +696,7 @@
 | Tpat_record _ -> group_record
 | Tpat_array _ -> group_array
 | Tpat_variant (_,_,_) -> group_variant
+| Tpat_abst _ -> group_abst
 |  _ -> fatal_error "Matching.get_group"
 
 
@@ -1265,7 +1275,7 @@
   divide cl
 
 (*
-  Three ``no-test'' cases
+  Four ``no-test'' cases
   *)
 
 (* Matching against a variable *)
@@ -1283,6 +1293,35 @@
 let divide_var ctx pm =
   divide_line ctx_lshift make_var_matching get_args_var omega ctx pm
 
+(* Matching against an abstraction pattern *)
+let get_args_abst p rem =
+  match p with
+    {pat_desc = Tpat_any} -> omegas 2 @ rem
+  | {pat_desc = Tpat_abst (p1, p2)} -> p1::p2::rem
+  | _ -> assert false
+
+let matcher_abst p rem =
+  match p.pat_desc with
+    Tpat_or (_, _, _) -> raise OrPat
+  | Tpat_var _ -> get_args_abst omega rem
+  | _ -> get_args_abst p rem
+
+let make_abst_matching def = function
+    (arg, mut) :: argl ->
+      let arglist = (Lprim (Pfield 0, [arg]), Alias) ::
+                    (Lprim (Pfield 1, [arg]), Alias) :: argl in
+        {cases = [];
+         args = arglist;
+         default = make_default matcher_abst def}
+  | _ -> fatal_error "Matching.make_abst_matching"
+
+let divide_abst p ctxt pm =
+  divide_line
+    (filter_ctx p)
+    make_abst_matching
+    get_args_abst
+    p ctxt pm
+
 (* Matching against a tuple pattern *)
 
 
@@ -2336,6 +2375,9 @@
         (divide_variant row)
         (combine_variant row arg partial)
         ctx pm
+  | Tpat_abst (p1, p2) ->
+      compile_no_test
+        (divide_abst (normalize_pat pat)) ctx_combine repr partial ctx pm
   | _ -> assert false
   end
 | PmVar {inside=pmh ; var_arg=arg} ->
@@ -2352,6 +2394,19 @@
   lambda, jumps_map up_ctx total
 
 
+(* Determine if a pattern contains an abstraction pattern. *)
+let rec pat_has_abstractions pat =
+  match pat.pat_desc with
+    Tpat_alias (p, _) -> pat_has_abstractions p
+  | Tpat_tuple ps -> List.exists pat_has_abstractions ps
+  | Tpat_construct (_, ps) -> List.exists pat_has_abstractions ps
+  | Tpat_variant (_, Some p, _) -> pat_has_abstractions p
+  | Tpat_record lps -> List.exists (fun (_, p) -> pat_has_abstractions p) lps
+  | Tpat_array ps -> List.exists pat_has_abstractions ps
+  | Tpat_or (p1, p2, _) -> (pat_has_abstractions p1) ||
+                           (pat_has_abstractions p2)
+  | Tpat_abst _ -> true
+  | _ -> false
 
 
 (* The entry points *)
@@ -2368,13 +2423,19 @@
     Lstaticcatch(lambda, (i,[]), handler_fun())
   end
 
+
+
 let compile_matching loc repr handler_fun arg pat_act_list partial =
   match partial with
   | Partial ->
       let raise_num = next_raise_count () in
       let pm =
         { cases = List.map (fun (pat, act) -> ([pat], act)) pat_act_list;
-          args = [arg, Strict] ;
+          args =
+        (*    if List.exists (fun (pat, _) -> pat_has_abstractions pat)
+                           pat_act_list
+            then [Lprim (Pfreshen, [arg]), Strict]
+            else *) [arg, Strict];
           default = [[[omega]],raise_num]} in
       begin try
         let (lambda, total) = compile_match repr partial (start_ctx 1) pm in
@@ -2385,7 +2446,11 @@
   | Total ->
       let pm =
         { cases = List.map (fun (pat, act) -> ([pat], act)) pat_act_list;
-          args = [arg, Strict] ;
+          args =
+           (* if List.exists (fun (pat, _) -> pat_has_abstractions pat)
+                           pat_act_list
+            then [Lprim (Pfreshen, [arg]), Strict]
+            else *) [arg, Strict];
           default = []} in
       let (lambda, total) = compile_match repr partial (start_ctx 1) pm in
       assert (jumps_is_empty total) ;
--- ocaml-3.08.2/bytecomp/printlambda.ml	2004-05-26 12:10:50.000000000 +0100
+++ fresh-ocaml-3.08.2/bytecomp/printlambda.ml	2005-01-10 14:06:36.000000000 +0000
@@ -171,6 +171,11 @@
   | Pbintcomp(bi, Cge) -> print_boxed_integer ">=" ppf bi
   | Pbigarrayref(n, kind, layout) -> print_bigarray "get" kind ppf layout
   | Pbigarrayset(n, kind, layout) -> print_bigarray "set" kind ppf layout
+  | Pswapatoms -> fprintf ppf "swap_atoms"
+  | Pfreshen -> fprintf ppf "freshen"
+  | Pnewatom -> fprintf ppf "newatom"
+  | Pfreshfor -> fprintf ppf "freshfor"
+  | Pcreateabst -> fprintf ppf "createabst"
 
 let rec lam ppf = function
   | Lvar id ->
--- ocaml-3.08.2/bytecomp/translcore.ml	2004-05-26 12:10:50.000000000 +0100
+++ fresh-ocaml-3.08.2/bytecomp/translcore.ml	2005-01-10 14:06:36.000000000 +0000
@@ -133,7 +133,7 @@
               prim_native_float = false})
 ]
 
-let primitives_table = create_hashtable 57 [
+let primitives_table = create_hashtable 62 [
   "%identity", Pidentity;
   "%ignore", Pignore;
   "%field0", Pfield 0;
@@ -248,7 +248,12 @@
   "%bigarray_ref_3", Pbigarrayref(3, Pbigarray_unknown, Pbigarray_c_layout);
   "%bigarray_set_1", Pbigarrayset(1, Pbigarray_unknown, Pbigarray_c_layout);
   "%bigarray_set_2", Pbigarrayset(2, Pbigarray_unknown, Pbigarray_c_layout);
-  "%bigarray_set_3", Pbigarrayset(3, Pbigarray_unknown, Pbigarray_c_layout)
+  "%bigarray_set_3", Pbigarrayset(3, Pbigarray_unknown, Pbigarray_c_layout);
+  "%fresh_swap_atoms", Pswapatoms;
+  "%fresh_throughout", Pfreshen;
+  "%fresh_new_atom", Pnewatom;
+  "%fresh_freshfor", Pfreshfor;
+  "%fresh_create_abstraction", Pcreateabst
 ]
 
 let prim_makearray =
@@ -503,6 +508,131 @@
                Const_base(Const_int char)]))])])
 ;;
 
+(* Generate lambda-code to create a new atom value. *)
+let new_atom () = Lprim (Pnewatom, [Lconst const_unit])
+
+(* Generate lambda-code to swap two atoms throughout a value. *)
+let swap_atoms a a' v = Lprim (Pswapatoms, [a; a'; v])
+
+(* Determine if a pattern contains an abstraction pattern. *)
+let rec pat_has_abstractions pat =
+  match pat.pat_desc with
+    Tpat_alias (p, _) -> pat_has_abstractions p
+  | Tpat_tuple ps -> List.exists pat_has_abstractions ps
+  | Tpat_construct (_, ps) -> List.exists pat_has_abstractions ps
+  | Tpat_variant (_, Some p, _) -> pat_has_abstractions p
+  | Tpat_record lps -> List.exists (fun (_, p) -> pat_has_abstractions p) lps
+  | Tpat_array ps -> List.exists pat_has_abstractions ps
+  | Tpat_or (p1, p2, _) -> (pat_has_abstractions p1) ||
+                           (pat_has_abstractions p2)
+  | Tpat_abst _ -> true
+  | _ -> false
+
+(* Rewrite a pattern to turn all instances of abstraction patterns therein
+   into pair patterns. *)
+let rec rewrite_abstractions pat =
+  match pat.pat_desc with
+    Tpat_alias (p, i) ->
+      {pat with pat_desc = Tpat_alias (rewrite_abstractions p, i)}
+  | Tpat_tuple ps ->
+      {pat with pat_desc = Tpat_tuple (List.map rewrite_abstractions ps)}
+  | Tpat_construct (cd, ps) ->
+      {pat with
+       pat_desc = Tpat_construct (cd, List.map rewrite_abstractions ps)}
+  | Tpat_variant (l, Some p, rd) ->
+      {pat with pat_desc = Tpat_variant (l, Some (rewrite_abstractions p), rd)}
+  | Tpat_record lps ->
+      {pat with
+       pat_desc = Tpat_record (List.map (fun (l, p) ->
+                                         (l, rewrite_abstractions p)) lps)}
+  | Tpat_array ps ->
+      {pat with pat_desc = Tpat_array (List.map rewrite_abstractions ps)}
+  | Tpat_or (p1, p2, path_opt) ->
+      {pat with
+       pat_desc = Tpat_or (rewrite_abstractions p1, rewrite_abstractions p2,
+                           path_opt)}
+  | Tpat_abst (p1, p2) ->
+      {pat with pat_desc = Tpat_tuple [p1; p2]}
+  | _ -> pat
+  
+let rec rewrite_abstractions_2 pat =
+  match pat.pat_desc with
+    Tpat_var _ -> { pat with pat_desc = Tpat_any }
+  | Tpat_alias (p, i) -> p
+  | Tpat_tuple ps ->
+      {pat with pat_desc = Tpat_tuple (List.map rewrite_abstractions_2 ps)}
+  | Tpat_construct (cd, ps) ->
+      {pat with
+       pat_desc = Tpat_construct (cd, List.map rewrite_abstractions_2 ps)}
+  | Tpat_variant (l, Some p, rd) ->
+      {pat with pat_desc =
+       Tpat_variant (l, Some (rewrite_abstractions_2 p), rd)}
+  | Tpat_record lps ->
+      {pat with
+       pat_desc = Tpat_record (List.map (fun (l, p) ->
+                                         (l, rewrite_abstractions_2 p)) lps)}
+  | Tpat_array ps ->
+      {pat with pat_desc = Tpat_array (List.map rewrite_abstractions_2 ps)}
+  | Tpat_or (p1, p2, path_opt) ->
+      {pat with
+       pat_desc = Tpat_or (rewrite_abstractions_2 p1, rewrite_abstractions p2,
+                           path_opt)}
+  | Tpat_abst (p1, p2) ->
+      {pat with pat_desc = Tpat_tuple [rewrite_abstractions_2 p1;
+                                       rewrite_abstractions_2 p2]}
+  | _ -> pat
+
+(* Insertion of "freshening" code for abstraction patterns. *)
+let rec insert_freshening loc pat e =
+  match pat.pat_desc with
+    Tpat_alias (p, i) ->
+      let p', e' = insert_freshening loc p e in
+        ({pat with pat_desc = Tpat_alias (p', i)}, e')
+  | Tpat_tuple ps ->
+      let ps', e' = insert_freshening_list loc ps e in
+        ({pat with pat_desc = Tpat_tuple ps'}, e')
+  | Tpat_construct (cd, ps) ->
+      let ps', e' = insert_freshening_list loc ps e in
+        ({pat with pat_desc = Tpat_construct (cd, ps')}, e')
+  | Tpat_variant (l, Some p, rd) ->
+      let p', e' = insert_freshening loc p e in
+        ({pat with pat_desc = Tpat_variant (l, Some p', rd)}, e')
+  | Tpat_record lps ->
+      let lps', e' = insert_freshening_record loc lps e in
+        ({pat with pat_desc = Tpat_record lps'}, e')
+  | Tpat_array ps ->
+      let ps', e' = insert_freshening_list loc ps e in
+        ({pat with pat_desc = Tpat_array (ps')}, e')
+  | Tpat_or (p1, p2, path_opt) ->
+      let p1', e1 = insert_freshening loc p1 e in
+      let p2', e2 = insert_freshening loc p2 e1 in
+        ({pat with pat_desc = Tpat_or (p1', p2', path_opt)}, e2)
+  | Tpat_abst (p1, p2) ->
+      (* rewrite <<p1>>p2 to turn all abstraction patterns into pair
+         patterns *)
+      let pat'' = rewrite_abstractions pat in
+      let pat_no_ids = rewrite_abstractions_2 pat in
+      (* the pattern <<p1>>p2 is replaced with an alias pattern *)
+      let x = Ident.create "alias" in
+      let pat' = {pat with pat_desc = Tpat_alias (pat_no_ids, x)} in
+      (* generate code to freshen x *)
+      let freshen = Lprim (Pfreshen, [Lvar x]) in
+      (* assemble new expression *)
+        (pat', Matching.for_function loc None freshen [(pat'', e)] Partial)
+  | _ -> (pat, e)
+
+and insert_freshening_list loc ps e =
+    List.fold_right (fun cur_p ->
+                     fun (ps_acc, e_acc) ->
+                       let p_new, e_new = insert_freshening loc cur_p e_acc in
+                         p_new :: ps_acc, e_new) ps ([], e)
+
+and insert_freshening_record loc lps e =
+    List.fold_right (fun (l, cur_p) ->
+                     fun (lps_acc, e_acc) ->
+                       let p_new, e_new = insert_freshening loc cur_p e_acc in
+                         (l, p_new) :: lps_acc, e_new) lps ([], e)
+
 (* Translation of expressions *)
 
 let rec transl_exp e =
@@ -576,14 +706,17 @@
       event_after e (transl_apply (transl_exp funct) oargs)
   | Texp_match({exp_desc = Texp_tuple argl} as arg, pat_expr_list, partial) ->
       Matching.for_multiple_match e.exp_loc
-        (transl_list argl) (transl_cases pat_expr_list) partial
+        (transl_list argl)
+        (transl_cases e.exp_loc pat_expr_list) partial
   | Texp_match(arg, pat_expr_list, partial) ->
       Matching.for_function e.exp_loc None
-        (transl_exp arg) (transl_cases pat_expr_list) partial
+        (transl_exp arg)
+        (transl_cases e.exp_loc pat_expr_list) partial
   | Texp_try(body, pat_expr_list) ->
       let id = name_pattern "exn" pat_expr_list in
       Ltrywith(transl_exp body, id,
-               Matching.for_trywith (Lvar id) (transl_cases pat_expr_list))
+               Matching.for_trywith (Lvar id)
+                                    (transl_cases e.exp_loc pat_expr_list))
   | Texp_tuple el ->
       let ll = transl_list el in
       begin try
@@ -715,17 +848,29 @@
           cl_loc = e.exp_loc;
           cl_type = Tcty_signature cty;
           cl_env = e.exp_env }
+   | Texp_abst (e1, e2) ->
+       Lprim (Pcreateabst, transl_list [e1; e2])
+   | Texp_swap (e1, e2, body) ->
+       swap_atoms (transl_exp e1) (transl_exp e2) (transl_exp body)
+   | Texp_fresh ->
+       new_atom ()
+   | Texp_freshfor (e1, e2) ->
+       Lprim (Pfreshfor, transl_list [e1; e2])
+   | Texp_customswap (e1, e2) ->
+       Lprim (Pmakeblock (243, Immutable), transl_list [e1; e2])
 
 and transl_list expr_list =
   List.map transl_exp expr_list
 
-and transl_cases pat_expr_list =
+and transl_cases loc pat_expr_list =
   List.map
-    (fun (pat, expr) -> (pat, event_before expr (transl_exp expr)))
+    (fun (pat, expr) ->
+       insert_freshening loc pat (event_before expr (transl_exp expr)))
     pat_expr_list
 
-and transl_tupled_cases patl_expr_list =
-  List.map (fun (patl, expr) -> (patl, transl_exp expr)) patl_expr_list
+and transl_tupled_cases loc patl_expr_list =
+  List.map (fun (patl, expr) ->
+              insert_freshening_list loc patl (transl_exp expr)) patl_expr_list
 
 and transl_apply lam sargs =
   let lapply funct args =
@@ -783,8 +928,9 @@
       let param = name_pattern "param" pat_expr_list in
       let ((_, params), body) =
         transl_function exp.exp_loc false repr partial' pl in
+      let pat', body' = insert_freshening loc pat body in
       ((Curried, param :: params),
-       Matching.for_function loc None (Lvar param) [pat, body] partial)
+       Matching.for_function loc None (Lvar param) [pat', body'] partial)
   | ({pat_desc = Tpat_tuple pl}, _) :: _ when untuplify_fn ->
       begin try
         let size = List.length pl in
@@ -795,18 +941,18 @@
         let params = List.map (fun p -> Ident.create "param") pl in
         ((Tupled, params),
          Matching.for_tupled_function loc params
-           (transl_tupled_cases pats_expr_list) partial)
+           (transl_tupled_cases loc pats_expr_list) partial)
       with Matching.Cannot_flatten ->
         let param = name_pattern "param" pat_expr_list in
         ((Curried, [param]),
          Matching.for_function loc repr (Lvar param)
-           (transl_cases pat_expr_list) partial)
+           (transl_cases loc pat_expr_list) partial)
       end
   | _ ->
       let param = name_pattern "param" pat_expr_list in
       ((Curried, [param]),
        Matching.for_function loc repr (Lvar param)
-         (transl_cases pat_expr_list) partial)
+         (transl_cases loc pat_expr_list) partial)
 
 and transl_let rec_flag pat_expr_list body =
   match rec_flag with
@@ -815,6 +961,14 @@
         [] ->
           body
       | (pat, expr) :: rem ->
+          if pat_has_abstractions pat then
+            (* rewrite abstraction patterns to pair patterns and
+               freshen the right-hand side of the let *)
+            let pat' = rewrite_abstractions pat in
+            let expr' = Lprim (Pfreshen, [transl_exp expr]) in
+              Matching.for_let pat.pat_loc expr' pat' (transl rem)
+          else
+            (* no abstraction patterns present *)
           Matching.for_let pat.pat_loc (transl_exp expr) pat (transl rem)
       in transl pat_expr_list
   | Recursive ->
--- ocaml-3.08.2/byterun/Makefile	2004-08-20 16:11:36.000000000 +0100
+++ fresh-ocaml-3.08.2/byterun/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -15,7 +15,7 @@
 
 include ../config/Makefile
 
-CC=$(BYTECC)
+CC=$(BYTECC) -g
 CFLAGS=-DCAML_NAME_SPACE -O $(BYTECCCOMPOPTS)
 DFLAGS=-DCAML_NAME_SPACE -g -DDEBUG $(BYTECCCOMPOPTS)
 
@@ -25,30 +25,30 @@
   compare.o ints.o floats.o str.o array.o io.o extern.o intern.o \
   hash.o sys.o meta.o parsing.o gc_ctrl.o terminfo.o md5.o obj.o \
   lexing.o callback.o debugger.o weak.o compact.o finalise.o custom.o \
-  dynlink.o unix.o
+  dynlink.o unix.o freshness.o hashtable_cwc22.o hashtable_itr_cwc22.o
 
 DOBJS=$(OBJS:.o=.d.o) instrtrace.d.o
 
 PRIMS=alloc.c array.c compare.c extern.c floats.c gc_ctrl.c hash.c \
   intern.c interp.c ints.c io.c lexing.c md5.c meta.c obj.c parsing.c \
   signals.c str.c sys.c terminfo.c callback.c weak.c finalise.c stacks.c \
-  dynlink.c
+  dynlink.c freshness.c hashtable_cwc22.c hashtable_itr_cwc22.c
 
 PUBLIC_INCLUDES=alloc.h callback.h config.h custom.h fail.h intext.h \
   memory.h misc.h mlvalues.h printexc.h signals.h compatibility.h
 
-all: ocamlrun$(EXE) ld.conf
+all: fresh-ocamlrun$(EXE) ld.conf
 
-ocamlrun$(EXE): libcamlrun.a prims.o
-	$(BYTECC) $(BYTECCCOMPOPTS) $(BYTECCLINKOPTS) -o ocamlrun$(EXE) \
+fresh-ocamlrun$(EXE): libcamlrun.a prims.o
+	$(BYTECC) $(BYTECCCOMPOPTS) $(BYTECCLINKOPTS) -o fresh-ocamlrun$(EXE) \
 	          prims.o libcamlrun.a $(BYTECCLIBS)
 
-ocamlrund$(EXE): libcamlrund.a prims.o
-	$(BYTECC) -g $(BYTECCCOMPOPTS) $(BYTECCLINKOPTS) -o ocamlrund$(EXE) \
+fresh-ocamlrund$(EXE): libcamlrund.a prims.o
+	$(BYTECC) -g $(BYTECCCOMPOPTS) $(BYTECCLINKOPTS) -o fresh-ocamlrund$(EXE) \
 	          prims.o libcamlrund.a $(BYTECCLIBS)
 
 install:
-	cp ocamlrun$(EXE) $(BINDIR)/ocamlrun$(EXE)
+	cp fresh-ocamlrun$(EXE) $(BINDIR)/fresh-ocamlrun$(EXE)
 	cp libcamlrun.a $(LIBDIR)/libcamlrun.a
 	cd $(LIBDIR); $(RANLIB) libcamlrun.a
 	if test -d $(LIBDIR)/caml; then : ; else mkdir $(LIBDIR)/caml; fi
@@ -70,7 +70,7 @@
 	$(RANLIB) libcamlrund.a
 
 clean:
-	rm -f ocamlrun$(EXE) ocamlrund$(EXE) *.o lib*.a
+	rm -f fresh-ocamlrun$(EXE) fresh-ocamlrund$(EXE) *.o lib*.a
 	rm -f primitives prims.c opnames.h jumptbl.h ld.conf
 
 primitives : $(PRIMS)
--- ocaml-3.08.2/byterun/compare.c	2004-07-07 17:48:46.000000000 +0100
+++ fresh-ocaml-3.08.2/byterun/compare.c	2005-01-10 14:06:36.000000000 +0000
@@ -20,6 +20,7 @@
 #include "memory.h"
 #include "misc.h"
 #include "mlvalues.h"
+#include "freshness.h"
 
 /* Structural comparison on trees. */
 
@@ -96,6 +97,22 @@
   struct compare_item * sp;
   tag_t t1, t2;
 
+  if (Is_block(v1) && Tag_val(v1) == Custom_swap_tag) {
+      return compare_val(Field(v1, 1), v2, total);
+  }
+  if (Is_block(v2) && Tag_val(v2) == Custom_swap_tag) {
+      return compare_val(v1, Field(v2, 1), total);
+  }
+  /*
+  if (Is_block(v1) && (Tag_val(v1) == Custom_swap_tag ||
+                       Tag_val(v1) == No_bind_tag)) {
+      return compare_val(Field(v1, 1), v2);
+  }
+  if (Is_block(v2) && (Tag_val(v2) == Custom_swap_tag ||
+                       Tag_val(v2) == No_bind_tag)) {
+      return compare_val(v1, Field(v2, 1));
+  }*/
+
   sp = compare_stack;
   while (1) {
     if (v1 == v2 && total) goto next_item;
@@ -134,6 +151,13 @@
     if (t2 == Forward_tag) { v2 = Forward_val (v2); continue; }
     if (t1 != t2) return (long)t1 - (long)t2;
     switch(t1) {
+    case Atom_tag: {
+      long l1 = (long) Field(v1, 0);
+      long l2 = (long) Field(v2, 0);
+      if (l1 < l2) return -1;
+      if (l1 > l2) return 1;
+      return 0;
+    }
     case String_tag: {
       mlsize_t len1, len2, len;
       unsigned char * p1, * p2;
@@ -206,6 +230,8 @@
       if (res != 0) return res;
       break;
     }
+    case Abst_tag:
+      return fresh_compare_abstractions(v1, v2);
     default: {
       mlsize_t sz1 = Wosize_val(v1);
       mlsize_t sz2 = Wosize_val(v2);
@@ -264,28 +290,48 @@
 
 CAMLprim value caml_lessthan(value v1, value v2)
 {
-  long res = compare_val(v1, v2, 0);
+  long res;
+  if ((Is_block(v1) && Tag_val(v1) == Atom_tag) ||
+      (Is_block(v2) && Tag_val(v2) == Atom_tag)) {
+    caml_invalid_argument("cannot perform less-than operation on atoms");
+  }
+  res = compare_val(v1, v2, 0);
   if (compare_stack != compare_stack_init) compare_free_stack();
   return Val_int(res - 1 < -1);
 }
 
 CAMLprim value caml_lessequal(value v1, value v2)
 {
-  long res = compare_val(v1, v2, 0);
+  long res;
+  if ((Is_block(v1) && Tag_val(v1) == Atom_tag) ||
+      (Is_block(v2) && Tag_val(v2) == Atom_tag)) {
+    caml_invalid_argument("cannot perform less-than-or-equal operation on atoms");
+  }
+  res = compare_val(v1, v2, 0);
   if (compare_stack != compare_stack_init) compare_free_stack();
   return Val_int(res - 1 <= -1);
 }
 
 CAMLprim value caml_greaterthan(value v1, value v2)
 {
-  long res = compare_val(v1, v2, 0);
+  long res;
+  if ((Is_block(v1) && Tag_val(v1) == Atom_tag) ||
+      (Is_block(v2) && Tag_val(v2) == Atom_tag)) {
+    caml_invalid_argument("cannot perform greater-than operation on atoms");
+  }
+  res = compare_val(v1, v2, 0);
   if (compare_stack != compare_stack_init) compare_free_stack();
   return Val_int(res > 0);
 }
 
 CAMLprim value caml_greaterequal(value v1, value v2)
 {
-  long res = compare_val(v1, v2, 0);
+  long res;
+  if ((Is_block(v1) && Tag_val(v1) == Atom_tag) ||
+      (Is_block(v2) && Tag_val(v2) == Atom_tag)) {
+    caml_invalid_argument("cannot perform greater-than-or-equal operation on atoms");
+  }
+  res = compare_val(v1, v2, 0);
   if (compare_stack != compare_stack_init) compare_free_stack();
   return Val_int(res >= 0);
 }
--- ocaml-3.08.2/byterun/hash.c	2004-01-02 19:23:22.000000000 +0000
+++ fresh-ocaml-3.08.2/byterun/hash.c	2005-01-10 14:06:36.000000000 +0000
@@ -115,6 +115,10 @@
       hash_univ_count--;
       Combine(Oid_val(obj));
       break;
+    case Atom_tag: {
+      Combine(Field(obj, 0));
+      break;
+    }
     case Custom_tag:
       /* If no hashing function provided, do nothing */
       if (Custom_ops_val(obj)->hash != NULL) {
--- ocaml-3.08.2/byterun/mlvalues.h	2004-07-07 02:14:43.000000000 +0100
+++ fresh-ocaml-3.08.2/byterun/mlvalues.h	2005-01-11 20:00:36.000000000 +0000
@@ -198,6 +198,19 @@
    See major_gc.c and stdlib/lazy.ml. */
 #define Lazy_tag 246
 
+/* Tag for semantic atoms. */
+#define Atom_tag 245
+
+/* Tag for abstraction values. */
+#define Abst_tag 244
+
+/* Tag for "custom swap" values. */
+#define Custom_swap_tag 243
+
+/* Tags for "no bind" and "no swap" values. */
+#define No_bind_tag 242
+#define No_swap_tag 241
+
 /* Another special case: variants */
 CAMLextern value caml_hash_variant(char * tag);
 
--- ocaml-3.08.2/byterun/roots.c	2004-01-05 20:25:59.000000000 +0000
+++ fresh-ocaml-3.08.2/byterun/roots.c	2005-01-10 14:06:36.000000000 +0000
@@ -82,6 +82,7 @@
 
   /* Global C roots */
   for (gr = caml_global_roots.forward[0]; gr != NULL; gr = gr->forward[0]) {
+    value old_v = *(gr->root);
     f(*(gr->root), gr->root);
   }
   /* Finalised values */
--- ocaml-3.08.2/camlp4/Makefile	2004-07-07 17:41:58.000000000 +0100
+++ fresh-ocaml-3.08.2/camlp4/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -8,7 +8,7 @@
 SHELL=/bin/sh
 COLD_FILES=ocaml_src/camlp4/argl.ml ocaml_src/camlp4/ast2pt.ml ocaml_src/camlp4/ast2pt.mli ocaml_src/camlp4/mLast.mli ocaml_src/camlp4/pcaml.ml ocaml_src/camlp4/pcaml.mli ocaml_src/camlp4/quotation.ml ocaml_src/camlp4/quotation.mli ocaml_src/camlp4/reloc.ml ocaml_src/camlp4/reloc.mli ocaml_src/camlp4/spretty.ml ocaml_src/camlp4/spretty.mli ocaml_src/lib/extfun.ml ocaml_src/lib/extfun.mli ocaml_src/lib/fstream.ml ocaml_src/lib/fstream.mli ocaml_src/lib/gramext.ml ocaml_src/lib/gramext.mli ocaml_src/lib/grammar.ml ocaml_src/lib/grammar.mli ocaml_src/lib/plexer.ml ocaml_src/lib/plexer.mli ocaml_src/lib/stdpp.ml ocaml_src/lib/stdpp.mli ocaml_src/lib/token.ml ocaml_src/lib/token.mli ocaml_src/meta/pa_extend.ml ocaml_src/meta/pa_extend_m.ml ocaml_src/meta/pa_macro.ml ocaml_src/meta/pa_r.ml ocaml_src/meta/pa_rp.ml ocaml_src/meta/pr_dump.ml ocaml_src/meta/q_MLast.ml ocaml_src/odyl/odyl_main.ml ocaml_src/odyl/odyl_main.mli ocaml_src/odyl/odyl.ml
 
-all: boot/camlp4$(EXE)
+all: boot/fresh-camlp4$(EXE)
 	set -e; for i in $(DIRS); do cd $$i; $(MAKE) all; cd ..; done
 
 opt:
@@ -17,7 +17,7 @@
 opt.opt:
 	set -e; for i in $(OPTDIRS); do cd $$i; $(MAKE) opt; cd ..; done
 
-boot/camlp4$(EXE): $(COLD_FILES)
+boot/fresh-camlp4$(EXE): $(COLD_FILES)
 	$(MAKE) clean_cold library_cold compile_cold
 	$(MAKE) promote_cold
 	$(MAKE) clean_cold clean_hot library
@@ -33,11 +33,11 @@
 
 uninstall:
 	rm -rf "$(LIBDIR)/camlp4"
-	cd "$(BINDIR)"; rm -f *camlp4* odyl ocpp
+	cd "$(BINDIR)"; rm -f *camlp4* fresh-odyl fresh-ocpp
 
 clean::
 	$(MAKE) clean_hot clean_cold
-	rm -f boot/*.cm[oi] boot/camlp4*
+	rm -f boot/*.cm[oi] boot/fresh-camlp4*
 	rm -rf boot/SAVED
 
 scratch: clean
@@ -80,7 +80,7 @@
 
 bootstrap_core: backup promote clean_hot core compare
 
-core: boot/camlp4$(EXE)
+core: boot/fresh-camlp4$(EXE)
 	set -e; for i in $(FDIRS); do cd $$i; $(MAKE) all; cd ..; done
 
 clean_core:
--- ocaml-3.08.2/camlp4/camlp4/Makefile	2004-07-28 14:43:16.000000000 +0100
+++ fresh-ocaml-3.08.2/camlp4/camlp4/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -14,7 +14,7 @@
 OBJS=../odyl/odyl.cma camlp4.cma
 CAMLP4M=
 
-CAMLP4=camlp4$(EXE)
+CAMLP4=fresh-camlp4$(EXE)
 CAMLP4OPT=phony
 
 all: $(CAMLP4)
--- ocaml-3.08.2/camlp4/compile/Makefile	2004-06-23 12:54:57.000000000 +0100
+++ fresh-ocaml-3.08.2/camlp4/compile/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -11,12 +11,12 @@
 
 all: out
 
-out: camlp4$D.fast
+out: fresh-camlp4$D.fast
 opt: camlp4$D.fast.opt
 
-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"
+fresh-camlp4$D.fast: pa_$D_fast.cmo
+	rm -f fresh-camlp4$D.fast
+	cd ../camlp4; $(MAKE) CAMLP4=../compile/fresh-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
--- ocaml-3.08.2/camlp4/etc/Makefile	2004-07-07 17:22:23.000000000 +0100
+++ fresh-ocaml-3.08.2/camlp4/etc/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -11,7 +11,7 @@
 CAMLP4OM=pa_o.cmo pa_op.cmo ../meta/pr_dump.cmo
 CAMLP4OMX=$(CAMLP4OM:.cmo=.cmx)
 SHELL=/bin/sh
-COUT=$(OBJS) camlp4o$(EXE)
+COUT=$(OBJS) fresh-camlp4o$(EXE)
 COPT=$(OBJSX) camlp4o.opt
 
 all: $(COUT) mkcamlp4.sh
@@ -33,9 +33,9 @@
 	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$(EXE): ../camlp4/fresh-camlp4$(EXE) $(CAMLP4OM)
+	rm -f fresh-camlp4o$(EXE)
+	cd ../camlp4; $(MAKE) CAMLP4=../etc/fresh-camlp4o$(EXE) CAMLP4M="-I ../etc $(CAMLP4OM)"
 
 camlp4o.opt: $(CAMLP4OMX)
 	rm -f camlp4o.opt
@@ -45,13 +45,13 @@
 	sed -e "s!LIBDIR!$(LIBDIR)!g" mkcamlp4.sh.tpl > mkcamlp4.sh
 
 bootstrap_l:
-	../boot/camlp4 ./pa_$Lr.cmo ./q_phony.cmo -I ../boot pa_extend.cmo ./pr_r.cmo ./pr_extend.cmo ./pr_rp.cmo pa_$L.ml > tmp
+	../boot/fresh-camlp4 ./pa_$Lr.cmo ./q_phony.cmo -I ../boot pa_extend.cmo ./pr_r.cmo ./pr_extend.cmo ./pr_rp.cmo pa_$L.ml > tmp
 	mv pa_$Lr.ml pa_$Lr.ml.old
 	sed -e 's/^;; \(.*\)$$/(* \1 *)/' -e 's/^; \(.*\)$$/(* \1 *)/' -e 's|./pa_$Lr.cmo|pa_r.cmo pa_rp.cmo|' -e 's/$$Id.*\$$/File generated by pretty print; do not edit!/' tmp > pa_$Lr.ml
 	rm -f tmp
 
 compare_l:
-	../boot/camlp4 ./pa_$Lr.cmo ./q_phony.cmo -I ../boot pa_extend.cmo ./pr_r.cmo ./pr_extend.cmo ./pr_rp.cmo pa_$L.ml | sed -e 's/^;; \(.*\)$$/(* \1 *)/' -e 's/^; \(.*\)$$/(* \1 *)/' -e 's|./pa_$Lr.cmo|pa_r.cmo pa_rp.cmo|' -e 's/$$Id.*\$$/File generated by pretty print; do not edit!/' | diff -c pa_$Lr.ml -
+	../boot/fresh-camlp4 ./pa_$Lr.cmo ./q_phony.cmo -I ../boot pa_extend.cmo ./pr_r.cmo ./pr_extend.cmo ./pr_rp.cmo pa_$L.ml | sed -e 's/^;; \(.*\)$$/(* \1 *)/' -e 's/^; \(.*\)$$/(* \1 *)/' -e 's|./pa_$Lr.cmo|pa_r.cmo pa_rp.cmo|' -e 's/$$Id.*\$$/File generated by pretty print; do not edit!/' | diff -c pa_$Lr.ml -
 
 clean::
 	rm -f *.cm* *.pp[io] *.$(O) *.bak .*.bak *.out *.opt
@@ -71,7 +71,7 @@
 	-$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)"
 	cp $(OBJS) "$(LIBDIR)/camlp4/."
 	cp $(INTF) "$(LIBDIR)/camlp4/."
-	cp camlp4o$(EXE) "$(BINDIR)/."
+	cp fresh-camlp4o$(EXE) "$(BINDIR)/."
 	if test -f camlp4o.opt; then \
 	  cp camlp4o.opt "$(BINDIR)/camlp4o.opt$(EXE)"; \
 	  cp $(OBJSX) "$(LIBDIR)/camlp4/."; \
--- ocaml-3.08.2/debugger/Makefile	2004-02-22 15:07:51.000000000 +0000
+++ fresh-ocaml-3.08.2/debugger/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -17,10 +17,10 @@
 CAMLC=../ocamlcomp.sh
 COMPFLAGS=-warn-error A $(INCLUDES)
 LINKFLAGS=-linkall -I ../otherlibs/unix
-CAMLYACC=../boot/ocamlyacc
+CAMLYACC=../boot/fresh-ocamlyacc
 YACCFLAGS=
-CAMLLEX=../boot/ocamlrun ../boot/ocamllex
-CAMLDEP=../boot/ocamlrun ../tools/ocamldep
+CAMLLEX=../boot/fresh-ocamlrun ../boot/fresh-ocamllex
+CAMLDEP=../boot/fresh-ocamlrun ../tools/fresh-ocamldep
 DEPFLAGS=$(INCLUDES)
 
 INCLUDES=\
@@ -75,16 +75,16 @@
 	command_line.cmo \
 	main.cmo
 
-all: ocamldebug$(EXE)
+all: fresh-ocamldebug$(EXE)
 
-ocamldebug$(EXE): $(OBJS) $(OTHEROBJS)
-	$(CAMLC) $(LINKFLAGS) -o ocamldebug$(EXE) -linkall $(OTHEROBJS) $(OBJS)
+fresh-ocamldebug$(EXE): $(OBJS) $(OTHEROBJS)
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamldebug$(EXE) -linkall $(OTHEROBJS) $(OBJS)
 
 install:
-	cp ocamldebug$(EXE) $(BINDIR)/ocamldebug$(EXE)
+	cp fresh-ocamldebug$(EXE) $(BINDIR)/fresh-ocamldebug$(EXE)
 
 clean::
-	rm -f ocamldebug$(EXE)
+	rm -f fresh-ocamldebug$(EXE)
 	rm -f *.cmo *.cmi
 
 .SUFFIXES:
--- ocaml-3.08.2/driver/main.ml	2004-06-13 13:46:41.000000000 +0100
+++ fresh-ocaml-3.08.2/driver/main.ml	2005-01-11 17:08:17.000000000 +0000
@@ -61,7 +61,7 @@
     raise(Arg.Bad("don't know what to do with " ^ name))
 
 let print_version_and_library () =
-  print_string "The Objective Caml compiler, version ";
+  print_string "The Fresh Objective Caml compiler, version ";
   print_string Config.version; print_newline();
   print_string "Standard library directory: ";
   print_string Config.standard_library; print_newline();
@@ -73,7 +73,7 @@
 let print_standard_library () =
   print_string Config.standard_library; print_newline(); exit 0
 
-let usage = "Usage: ocamlc <options> <files>\nOptions are:"
+let usage = "Usage: fresh-ocamlc <options> <files>\nOptions are:"
 
 (* Error messages to standard error formatter *)
 let anonymous = process_file Format.err_formatter;;
--- ocaml-3.08.2/driver/optmain.ml	2004-06-13 13:46:41.000000000 +0100
+++ fresh-ocaml-3.08.2/driver/optmain.ml	2005-01-11 16:42:18.000000000 +0000
@@ -59,7 +59,7 @@
     raise(Arg.Bad("don't know what to do with " ^ name))
 
 let print_version_and_library () =
-  print_string "The Objective Caml native-code compiler, version ";
+  print_string "The Fresh Objective Caml native-code compiler, version ";
   print_string Config.version; print_newline();
   print_string "Standard library directory: ";
   print_string Config.standard_library; print_newline();
@@ -82,7 +82,7 @@
   | Some s -> s
   | None -> Config.default_executable_name
 
-let usage = "Usage: ocamlopt <options> <files>\nOptions are:"
+let usage = "Usage: fresh-ocamlopt <options> <files>\nOptions are:"
 
 let main () =
   native_code := true;
--- ocaml-3.08.2/emacs/README	2002-08-05 03:05:42.000000000 +0100
+++ fresh-ocaml-3.08.2/emacs/README	2005-01-10 14:06:36.000000000 +0000
@@ -1,4 +1,4 @@
-        O'Caml emacs mode, snapshot of $Date: 2002/08/05 02:05:42 $
+        O'Caml emacs mode, snapshot of $Date: 2004/06/09 10:38:03 $
 
 The files in this archive define a caml-mode for emacs, for editing
 Objective Caml and Objective Label programs, as well as an
--- ocaml-3.08.2/lex/Makefile	2002-11-01 15:31:11.000000000 +0000
+++ fresh-ocaml-3.08.2/lex/Makefile	2005-01-11 16:36:19.000000000 +0000
@@ -10,31 +10,30 @@
 #                                                                       #
 #########################################################################
 
-# $Id: Makefile,v 1.17 2002/11/01 15:31:11 doligez Exp $
+# $Id: Makefile,v 1.2 2004/06/09 10:56:19 mark Exp $
 
 # The lexer generator
-CAMLC=../boot/ocamlrun ../boot/ocamlc -nostdlib -I ../boot
-CAMLOPT=../boot/ocamlrun ../ocamlopt -nostdlib -I ../stdlib
+CAMLC=../boot/fresh-ocamlrun ../boot/fresh-ocamlc -nostdlib -I ../boot
 COMPFLAGS=-warn-error A
-CAMLYACC=../boot/ocamlyacc
+CAMLYACC=../boot/fresh-ocamlyacc
 YACCFLAGS=-v
-CAMLLEX=../boot/ocamlrun ../boot/ocamllex
-CAMLDEP=../boot/ocamlrun ../tools/ocamldep
+CAMLLEX=../boot/fresh-ocamlrun ../boot/fresh-ocamllex
+CAMLDEP=../boot/fresh-ocamlrun ../tools/fresh-ocamldep
 
 
 OBJS=cset.cmo syntax.cmo parser.cmo lexer.cmo table.cmo lexgen.cmo compact.cmo common.cmo output.cmo outputbis.cmo main.cmo
 
-all: ocamllex
-allopt: ocamllex.opt
+all: fresh-ocamllex
+allopt: fresh-ocamllex.opt
 
-ocamllex: $(OBJS)
-	$(CAMLC) $(LINKFLAGS) -o ocamllex $(OBJS)
+fresh-ocamllex: $(OBJS)
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamllex $(OBJS)
 
-ocamllex.opt: $(OBJS:.cmo=.cmx)
-	$(CAMLOPT) -o ocamllex.opt $(OBJS:.cmo=.cmx)
+fresh-ocamllex.opt: $(OBJS:.cmo=.cmx)
+	$(CAMLOPT) -o fresh-ocamllex.opt $(OBJS:.cmo=.cmx)
 
 clean::
-	rm -f ocamllex ocamllex.opt
+	rm -f fresh-ocamllex
 	rm -f *.cmo *.cmi *.cmx *.o *~
 
 parser.ml parser.mli: parser.mly
@@ -62,9 +61,6 @@
 .mli.cmi:
 	$(CAMLC) -c $(COMPFLAGS) $<
 
-.ml.cmx:
-	$(CAMLOPT) -c $(COMPFLAGS) $<
-
 depend: beforedepend
 	$(CAMLDEP) *.mli *.ml > .depend
 
--- ocaml-3.08.2/ocamldoc/Makefile	2004-04-23 15:10:51.000000000 +0100
+++ fresh-ocaml-3.08.2/ocamldoc/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -15,12 +15,12 @@
 
 # Various commands and dir
 ##########################
-CAMLRUN=../boot/ocamlrun
+CAMLRUN=../boot/fresh-ocamlrun
 OCAMLC   = ../ocamlcomp.sh
 OCAMLOPT = ../ocamlcompopt.sh
-OCAMLDEP = $(CAMLRUN) ../tools/ocamldep
-OCAMLLEX = $(CAMLRUN) ../boot/ocamllex
-OCAMLYACC= ../boot/ocamlyacc
+OCAMLDEP = $(CAMLRUN) ../tools/fresh-ocamldep
+OCAMLLEX = $(CAMLRUN) ../boot/fresh-ocamllex
+OCAMLYACC= ../boot/fresh-ocamlyacc
 OCAMLLIB = $(LIBDIR)
 OCAMLBIN = $(BINDIR)
 
--- ocaml-3.08.2/ocamldoc/odoc_misc.ml	2004-10-01 10:43:24.000000000 +0100
+++ fresh-ocaml-3.08.2/ocamldoc/odoc_misc.ml	2005-01-10 14:06:36.000000000 +0000
@@ -459,6 +459,7 @@
     | Types.Ttuple _
     | Types.Tobject _
     | Types.Tfield _
+    | Types.Tabst _
     | Types.Tnil
     | Types.Tvariant _ -> t
     | Types.Tlink t2
--- ocaml-3.08.2/ocamldoc/odoc_str.ml	2004-11-03 08:16:49.000000000 +0000
+++ fresh-ocaml-3.08.2/ocamldoc/odoc_str.ml	2005-01-10 14:06:36.000000000 +0000
@@ -30,7 +30,7 @@
     Types.Tarrow _ -> true
   | Types.Tlink t2 | Types.Tsubst t2 -> is_arrow_type t2
   | Types.Ttuple _
-  | Types.Tconstr _
+  | Types.Tconstr _ | Types.Tabst _
   | Types.Tvar | Types.Tunivar | Types.Tobject _ | Types.Tpoly _
   | Types.Tfield _ | Types.Tnil | Types.Tvariant _ -> false
 
@@ -44,6 +44,7 @@
     | Types.Tconstr _ ->
         false
     | Types.Tvar | Types.Tunivar | Types.Tobject _ | Types.Tpoly _
+    | Types.Tabst _
     | Types.Tfield _ | Types.Tnil | Types.Tvariant _ -> false
   in
   let print_one_type variance t =
--- ocaml-3.08.2/ocamldoc/odoc_value.ml	2004-07-02 13:59:49.000000000 +0100
+++ fresh-ocaml-3.08.2/ocamldoc/odoc_value.ml	2005-01-10 14:06:36.000000000 +0000
@@ -83,6 +83,7 @@
     | Types.Tfield _ 
     | Types.Tnil
     | Types.Tunivar
+    | Types.Tabst _
     | Types.Tvariant _ ->
         []
   in
--- ocaml-3.08.2/ocamldoc/runocamldoc	2002-07-23 15:11:53.000000000 +0100
+++ fresh-ocaml-3.08.2/ocamldoc/runocamldoc	2005-01-10 14:06:36.000000000 +0000
@@ -3,7 +3,7 @@
 
 case "$1" in
   true) shift
-        exec ../boot/ocamlrun  -I ../otherlibs/unix -I ../otherlibs/str \
+        exec ../boot/fresh-ocamlrun  -I ../otherlibs/unix -I ../otherlibs/str \
              ./ocamldoc "$@"
         ;;
      *) shift
--- ocaml-3.08.2/otherlibs/bigarray/Makefile	2002-06-27 12:36:00.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/bigarray/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -19,7 +19,7 @@
 CFLAGS=-I../../byterun -g -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS)
 CAMLC=../../ocamlcomp.sh -I ../unix
 CAMLOPT=../../ocamlcompopt.sh -I ../unix
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 C_OBJS=bigarray_stubs.o mmap_unix.o
--- ocaml-3.08.2/otherlibs/dbm/Makefile	2002-06-27 12:36:01.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/dbm/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -21,7 +21,7 @@
 CC=$(BYTECC) -g
 CAMLC=../../ocamlcomp.sh
 CAMLOPT=../../ocamlcompopt.sh
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 CFLAGS=$(DBM_INCLUDES) -I../../byterun -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS)
--- ocaml-3.08.2/otherlibs/dynlink/Makefile	2004-02-22 15:07:51.000000000 +0000
+++ fresh-ocaml-3.08.2/otherlibs/dynlink/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -17,7 +17,7 @@
 
 include ../../config/Makefile
 
-CAMLC=../../boot/ocamlrun ../../ocamlc
+CAMLC=../../boot/fresh-ocamlrun ../../fresh-ocamlc
 INCLUDES=-I ../../utils -I ../../typing -I ../../bytecomp
 COMPFLAGS=-warn-error A -I ../../stdlib $(INCLUDES)
 
--- ocaml-3.08.2/otherlibs/graph/Makefile	2003-08-05 14:39:33.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/graph/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -21,7 +21,7 @@
 CFLAGS=-I../../byterun $(X11_INCLUDES) -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS)
 CAMLC=../../ocamlcomp.sh
 CAMLOPT=../../ocamlcompopt.sh
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 OBJS=open.o draw.o fill.o color.o text.o \
--- ocaml-3.08.2/otherlibs/labltk/browser/searchid.ml	2004-06-12 09:55:46.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/labltk/browser/searchid.ml	2005-01-10 14:06:36.000000000 +0000
@@ -421,6 +421,7 @@
   | Ppat_or (pat1,pat2) ->
       bound_variables pat1 @ bound_variables pat2
   | Ppat_constraint (pat,_) -> bound_variables pat
+  | Ppat_abst (p1, p2) -> bound_variables p1 @ bound_variables p2
 
 let search_structure str ~name ~kind ~prefix =
   let loc = ref 0 in
--- ocaml-3.08.2/otherlibs/labltk/browser/searchpos.ml	2004-06-29 02:50:19.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/labltk/browser/searchpos.ml	2005-01-10 14:06:36.000000000 +0000
@@ -130,6 +130,8 @@
       add_found_sig (`Type, lid) ~env ~loc:t.ptyp_loc
   | Ptyp_alias (t, _)
   | Ptyp_poly (_, t) -> search_pos_type ~pos ~env t
+  | Ptyp_abst (t1, t2) -> search_pos_type t1 ~pos ~env;
+                          search_pos_type t2 ~pos ~env
   end
 
 let rec search_pos_class_type cl ~pos ~env =
@@ -811,6 +813,16 @@
       search_pos_expr exp ~pos
   | Texp_lazy exp ->
       search_pos_expr exp ~pos
+  | Texp_abst (exp1, exp2) -> search_pos_expr exp1 ~pos;
+                              search_pos_expr exp2 ~pos
+  | Texp_swap (exp1, exp2, exp3) -> search_pos_expr exp1 ~pos;
+                                    search_pos_expr exp2 ~pos;
+                                   search_pos_expr exp3 ~pos
+  | Texp_fresh -> ()
+  | Texp_freshfor (exp1, exp2) -> search_pos_expr exp1 ~pos;
+                                  search_pos_expr exp2 ~pos
+  | Texp_customswap (exp1, exp2) -> search_pos_expr exp1 ~pos;
+                                    search_pos_expr exp2 ~pos
   | Texp_object (cls, _, _) ->
       	search_pos_class_structure ~pos cls
   end;
@@ -841,6 +853,8 @@
       search_pos_pat a ~pos ~env; search_pos_pat b ~pos ~env
   | Tpat_or (_, _, Some _) ->
       ()
+  | Tpat_abst (p1, p2) -> search_pos_pat p1 ~pos ~env;
+                          search_pos_pat p2 ~pos ~env
   end;
   add_found_str (`Exp(`Pat, pat.pat_type)) ~env ~loc:pat.pat_loc
   end
--- ocaml-3.08.2/otherlibs/labltk/camltk/Makefile.gen	2004-07-12 10:38:05.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/labltk/camltk/Makefile.gen	2005-01-10 14:06:36.000000000 +0000
@@ -32,7 +32,7 @@
 	 cat _tkfgen.ml; \
 	 echo ; \
 	) > _cTk.ml
-	../../../boot/ocamlrun ../compiler/pp < _cTk.ml > cTk.ml
+	../../../boot/fresh-ocamlrun ../compiler/pp < _cTk.ml > cTk.ml
 	rm -f _cTk.ml
 	$(CAMLDEP) -I ../support [a-z]*.mli [a-z]*.ml > .depend
 
--- ocaml-3.08.2/otherlibs/labltk/labltk/Makefile.gen	2004-07-12 10:38:05.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/labltk/labltk/Makefile.gen	2005-01-10 14:06:36.000000000 +0000
@@ -31,7 +31,7 @@
 	 cat _tkfgen.ml; \
 	 echo ; \
 	) > _tk.ml
-	../../../boot/ocamlrun ../compiler/pp < _tk.ml > tk.ml
+	../../../boot/fresh-ocamlrun ../compiler/pp < _tk.ml > tk.ml
 	rm -f _tk.ml
 	$(CAMLDEP) -I ../support [a-z]*.mli [a-z]*.ml > .depend
 
--- ocaml-3.08.2/otherlibs/labltk/support/Makefile.common	2004-07-12 10:38:05.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/labltk/support/Makefile.common	2005-01-10 14:06:36.000000000 +0000
@@ -12,16 +12,16 @@
 
 ## Tools from the Objective Caml distribution
 
-CAMLRUN=$(TOPDIR)/boot/ocamlrun
+CAMLRUN=$(TOPDIR)/boot/fresh-ocamlrun
 CAMLC=$(TOPDIR)/ocamlcomp.sh
 CAMLOPT=$(TOPDIR)/ocamlcompopt.sh
 CAMLCOMP=$(CAMLC) -c -warn-error A
-CAMLYACC=$(TOPDIR)/boot/ocamlyacc -v
-CAMLLEX=$(CAMLRUN) $(TOPDIR)/boot/ocamllex
+CAMLYACC=$(TOPDIR)/boot/fresh-ocamlyacc -v
+CAMLLEX=$(CAMLRUN) $(TOPDIR)/boot/fresh-ocamllex
 CAMLLIBR=$(CAMLC) -a
-CAMLDEP=$(CAMLRUN) $(TOPDIR)/tools/ocamldep
+CAMLDEP=$(CAMLRUN) $(TOPDIR)/tools/fresh-ocamldep
 COMPFLAGS=
 LINKFLAGS=
 CAMLOPTLIBR=$(CAMLOPT) -a
-MKLIB=$(CAMLRUN) $(TOPDIR)/tools/ocamlmklib
-CAMLRUNGEN=../../boot/ocamlrun
+MKLIB=$(CAMLRUN) $(TOPDIR)/tools/fresh-ocamlmklib
+CAMLRUNGEN=../../boot/fresh-ocamlrun
--- ocaml-3.08.2/otherlibs/num/Makefile	2003-10-24 10:17:31.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/num/Makefile	2005-01-11 16:34:12.000000000 +0000
@@ -23,7 +23,7 @@
           -DBNG_ARCH_$(BNG_ARCH) -DBNG_ASM_LEVEL=$(BNG_ASM_LEVEL)
 CAMLC=../../ocamlcomp.sh -w s
 CAMLOPT=../../ocamlcompopt.sh -w s
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 CAMLOBJS=int_misc.cmo string_misc.cmo nat.cmo big_int.cmo arith_flags.cmo \
@@ -46,7 +46,7 @@
 libnums.a: $(COBJS)
 	$(MKLIB) -o nums $(COBJS)
 
-$(CAMLOBJS:.cmo=.cmx): ../../ocamlopt
+$(CAMLOBJS:.cmo=.cmx): ../../fresh-ocamlopt
 
 install:
 	if test -f dllnums.so; then cp dllnums.so $(STUBLIBDIR)/dllnums.so; fi
--- ocaml-3.08.2/otherlibs/str/Makefile	2002-12-09 14:05:18.000000000 +0000
+++ fresh-ocaml-3.08.2/otherlibs/str/Makefile	2005-01-11 16:33:56.000000000 +0000
@@ -24,7 +24,7 @@
 CAMLOPT=../../ocamlcompopt.sh
 COMPFLAGS=-warn-error A
 COBJS=strstubs.o
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 
 all: libstr.a str.cmi str.cma
 
@@ -39,7 +39,7 @@
 str.cmxa: str.cmx
 	$(MKLIB) -ocamlopt '$(CAMLOPT)' -o str str.cmx
 
-str.cmx: ../../ocamlopt
+str.cmx: ../../fresh-ocamlopt
 
 partialclean:
 	rm -f *.cm*
--- ocaml-3.08.2/otherlibs/systhreads/Makefile	2003-08-21 14:52:07.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/systhreads/Makefile	2005-01-11 16:34:25.000000000 +0000
@@ -17,7 +17,7 @@
 
 CAMLC=../../ocamlcomp.sh -I ../unix
 CAMLOPT=../../ocamlcompopt.sh -I ../unix
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 BYTECODE_C_OBJS=posix_b.o
@@ -57,7 +57,7 @@
 	$(CAMLOPT) -a -o threads.cmxa $(THREAD_OBJS:.cmo=.cmx) \
           -cclib -lthreadsnat -cclib -lunix -cclib "$(PTHREAD_LINK)"
 
-$(THREAD_OBJS:.cmo=.cmx): ../../ocamlopt
+$(THREAD_OBJS:.cmo=.cmx): ../../fresh-ocamlopt
 
 thread.ml: thread_posix.ml
 	ln -s thread_posix.ml thread.ml
--- ocaml-3.08.2/otherlibs/threads/Makefile	2003-07-17 09:38:28.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/threads/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -18,7 +18,7 @@
 CC=$(BYTECC)
 CFLAGS=-I../../byterun -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS) -g
 CAMLC=../../ocamlcomp.sh -I ../unix
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 C_OBJS=scheduler.o
--- ocaml-3.08.2/otherlibs/unix/Makefile	2004-04-09 14:25:20.000000000 +0100
+++ fresh-ocaml-3.08.2/otherlibs/unix/Makefile	2005-01-11 16:33:44.000000000 +0000
@@ -22,7 +22,7 @@
 CFLAGS=-I../../byterun -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS)
 CAMLC=../../ocamlcomp.sh
 CAMLOPT=../../ocamlcompopt.sh
-MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib
+MKLIB=../../boot/fresh-ocamlrun ../../tools/fresh-ocamlmklib
 COMPFLAGS=-warn-error A
 
 OBJS=accept.o access.o addrofstr.o alarm.o bind.o chdir.o chmod.o \
@@ -57,7 +57,7 @@
 unix.cmxa: $(MLOBJS:.cmo=.cmx)
 	$(MKLIB) -o unix -ocamlopt '$(CAMLOPT)' -linkall $(MLOBJS:.cmo=.cmx)
 
-unix.cmx: ../../ocamlopt
+unix.cmx: ../../fresh-ocamlopt
 
 partialclean:
 	rm -f *.cm*
--- ocaml-3.08.2/parsing/lexer.mll	2004-01-16 15:24:02.000000000 +0000
+++ fresh-ocaml-3.08.2/parsing/lexer.mll	2005-01-10 14:06:36.000000000 +0000
@@ -41,6 +41,7 @@
     "begin", BEGIN;
     "class", CLASS;
     "constraint", CONSTRAINT;
+    "custom_swap", CUSTOMSWAP;
     "do", DO;
     "done", DONE;
     "downto", DOWNTO;
@@ -50,6 +51,8 @@
     "external", EXTERNAL;
     "false", FALSE;
     "for", FOR;
+    "fresh", FRESH;
+    "freshfor", FRESHFOR;
     "fun", FUN;
     "function", FUNCTION;
     "functor", FUNCTOR;
@@ -74,6 +77,7 @@
     "rec", REC;
     "sig", SIG;
     "struct", STRUCT;
+    "swap", SWAP;
     "then", THEN;
     "to", TO;
     "true", TRUE;
@@ -371,6 +375,10 @@
   | ">]" { GREATERRBRACKET }
   | "}"  { RBRACE }
   | ">}" { GREATERRBRACE }
+  | "<<" { LESSLESS }
+  | ">>" { GREATERGREATER }
+  | "<|" { LESSBAR }
+  | "|>" { BARGREATER }
 
   | "!=" { INFIXOP0 "!=" }
   | "+"  { PLUS }
--- ocaml-3.08.2/parsing/parser.mly	2004-05-19 13:15:19.000000000 +0100
+++ fresh-ocaml-3.08.2/parsing/parser.mly	2005-01-10 14:06:36.000000000 +0000
@@ -195,6 +195,7 @@
 %token BACKQUOTE
 %token BAR
 %token BARBAR
+%token BARGREATER
 %token BARRBRACKET
 %token BEGIN
 %token <char> CHAR
@@ -205,6 +206,7 @@
 %token COLONGREATER
 %token COMMA
 %token CONSTRAINT
+%token CUSTOMSWAP
 %token DO
 %token DONE
 %token DOT
@@ -219,10 +221,13 @@
 %token FALSE
 %token <string> FLOAT
 %token FOR
+%token FRESH
+%token FRESHFOR
 %token FUN
 %token FUNCTION
 %token FUNCTOR
 %token GREATER
+%token GREATERGREATER
 %token GREATERRBRACE
 %token GREATERRBRACKET
 %token IF
@@ -247,6 +252,8 @@
 %token LBRACKETLESS
 %token LBRACKETGREATER
 %token LESS
+%token LESSBAR
+%token LESSLESS
 %token LESSMINUS
 %token LET
 %token <string> LIDENT
@@ -283,6 +290,7 @@
 %token STAR
 %token <string> STRING
 %token STRUCT
+%token SWAP
 %token THEN
 %token TILDE
 %token TO
@@ -800,6 +808,8 @@
       { mkexp(Pexp_let($2, List.rev $3, $5)) }
   | LET MODULE UIDENT module_binding IN seq_expr
       { mkexp(Pexp_letmodule($3, $4, $6)) }
+  | CUSTOMSWAP expr IN simple_expr %prec below_SHARP
+      { mkexp(Pexp_customswap($2, $4)) }
   | FUNCTION opt_bar match_cases
       { mkexp(Pexp_function("", None, List.rev $3)) }
   | FUN labeled_simple_pattern fun_def
@@ -880,6 +890,21 @@
       { mkassert $2 }
   | LAZY simple_expr %prec below_SHARP
       { mkexp (Pexp_lazy ($2)) }
+  | LESSLESS expr GREATERGREATER simple_expr %prec below_SHARP
+      { mkexp(Pexp_abst($2, $4)) }
+  | LESSBAR expr BARGREATER simple_expr %prec below_SHARP
+      { mkexp(Pexp_abst($2, $4)) }
+  | FRESH
+      { mkexp(Pexp_fresh) }
+  | SWAP simple_expr AND simple_expr IN expr
+      { mkexp(Pexp_swap ($2, $4, $6)) }
+  | simple_expr FRESHFOR expr %prec below_SHARP
+      { mkexp(Pexp_freshfor ($1, $3)) }
+  | BACKQUOTE BACKQUOTE val_ident DOT expr
+      { mkexp(Pexp_let (Nonrecursive,
+                        [({ppat_desc = Ppat_var $3;
+                           ppat_loc = rhs_loc 1}, mkexp(Pexp_fresh))],
+                        mkexp(Pexp_abst(mkexp(Pexp_ident (Lident $3)), $5)))) }
   | OBJECT class_structure END
       { mkexp (Pexp_object($2)) }
   | OBJECT class_structure error
@@ -1097,6 +1122,10 @@
       { mkpat(Ppat_constraint($2, $4)) }
   | LPAREN pattern COLON core_type error
       { unclosed "(" 1 ")" 5 }
+  | LESSLESS pattern GREATERGREATER simple_pattern
+      { mkpat(Ppat_abst ($2, $4)) }
+  | LESSBAR pattern BARGREATER simple_pattern
+      { mkpat(Ppat_abst ($2, $4)) }
 ;
 
 pattern_comma_list:
@@ -1261,13 +1290,21 @@
       { match $2 with [sty] -> sty | _ -> raise Parse_error }
 ;
 simple_core_type2:
+    LESSLESS core_type GREATERGREATER simple_core_type %prec below_SHARP
+      { mktyp(Ptyp_abst ($2, $4)) }
+  | LESSBAR core_type BARGREATER simple_core_type %prec below_SHARP
+      { mktyp(Ptyp_abst ($2, $4)) }
+  | simple_core_type3 %prec below_SHARP
+      { $1 }
+;
+simple_core_type3:
     QUOTE ident
       { mktyp(Ptyp_var $2) }
   | UNDERSCORE
       { mktyp(Ptyp_any) }
   | type_longident
       { mktyp(Ptyp_constr($1, [])) }
-  | simple_core_type2 type_longident
+  | simple_core_type3 type_longident
       { mktyp(Ptyp_constr($2, [$1])) }
   | LPAREN core_type_comma_list RPAREN type_longident
       { mktyp(Ptyp_constr($4, List.rev $2)) }
@@ -1277,7 +1314,7 @@
       { mktyp(Ptyp_object []) }
   | SHARP class_longident opt_present
       { mktyp(Ptyp_class($2, [], $3)) }
-  | simple_core_type2 SHARP class_longident opt_present
+  | simple_core_type3 SHARP class_longident opt_present
       { mktyp(Ptyp_class($3, [$1], $4)) }
   | LPAREN core_type_comma_list RPAREN SHARP class_longident opt_present
       { mktyp(Ptyp_class($5, List.rev $2, $6)) }
--- ocaml-3.08.2/parsing/parsetree.mli	2003-11-25 08:46:45.000000000 +0000
+++ fresh-ocaml-3.08.2/parsing/parsetree.mli	2005-01-10 14:06:36.000000000 +0000
@@ -33,6 +33,7 @@
   | Ptyp_alias of core_type * string
   | Ptyp_variant of row_field list * bool * label list option
   | Ptyp_poly of string list * core_type
+  | Ptyp_abst of core_type * core_type
 
 and core_field_type =
   { pfield_desc: core_field_desc;
@@ -75,6 +76,7 @@
   | Ppat_or of pattern * pattern
   | Ppat_constraint of pattern * core_type
   | Ppat_type of Longident.t
+  | Ppat_abst of pattern * pattern
 
 type expression =
   { pexp_desc: expression_desc;
@@ -111,6 +113,11 @@
   | Pexp_lazy of expression
   | Pexp_poly of expression * core_type option
   | Pexp_object of class_structure
+  | Pexp_abst of expression * expression
+  | Pexp_swap of expression * expression * expression
+  | Pexp_fresh
+  | Pexp_freshfor of expression * expression
+  | Pexp_customswap of expression * expression
 
 (* Value descriptions *)
 
--- ocaml-3.08.2/parsing/printast.ml	2003-11-25 08:46:45.000000000 +0000
+++ fresh-ocaml-3.08.2/parsing/printast.ml	2005-01-10 14:06:36.000000000 +0000
@@ -139,6 +139,10 @@
       line i ppf "Ptyp_poly%a\n"
         (fun ppf -> List.iter (fun x -> fprintf ppf " '%s" x)) sl;
       core_type i ppf ct;
+  | Ptyp_abst (t1, t2) ->
+      line i ppf "Ptyp_abst\n";
+      core_type i ppf t1;
+      core_type i ppf t2;
 
 and core_field_type i ppf x =
   line i ppf "core_field_type %a\n" fmt_location x.pfield_loc;
@@ -186,6 +190,10 @@
   | Ppat_type li ->
       line i ppf "PPat_type";
       longident i ppf li
+  | Ppat_abst (p1, p2) ->
+      line i ppf "Ppat_abst\n";
+      pattern i ppf p1;
+      pattern i ppf p2
 
 and expression i ppf x =
   line i ppf "expression %a\n" fmt_location x.pexp_loc;
@@ -295,6 +303,25 @@
   | Pexp_object s ->
       line i ppf "Pexp_object";
       class_structure i ppf s
+  | Pexp_abst (e1, e2) ->
+      line i ppf "Pexp_abst\n";
+      expression i ppf e1;
+      expression i ppf e2;
+  | Pexp_swap (e1, e2, e3) ->
+      line i ppf "Pexp_swap\n";
+      expression i ppf e1;
+      expression i ppf e2;
+      expression i ppf e3;
+  | Pexp_fresh ->
+      line i ppf "Pexp_fresh\n";
+  | Pexp_freshfor (e1, e2) ->
+      line i ppf "Pexp_freshfor\n";
+      expression i ppf e1;
+      expression i ppf e2
+  | Pexp_customswap (e1, e2) ->
+      line i ppf "Pexp_customswap\n";
+      expression i ppf e1;
+      expression i ppf e2
 
 and value_description i ppf x =
   line i ppf "value_description\n";
--- ocaml-3.08.2/stdlib/.depend	2004-07-09 16:55:58.000000000 +0100
+++ fresh-ocaml-3.08.2/stdlib/.depend	2005-01-10 14:06:36.000000000 +0000
@@ -1,52 +1,54 @@
 camlinternalOO.cmi: obj.cmi 
 format.cmi: buffer.cmi 
 genlex.cmi: stream.cmi 
-moreLabels.cmi: hashtbl.cmi map.cmi set.cmi 
+moreLabels.cmi: set.cmi map.cmi hashtbl.cmi 
 oo.cmi: camlinternalOO.cmi 
-parsing.cmi: lexing.cmi obj.cmi 
+parsing.cmi: obj.cmi lexing.cmi 
 printf.cmi: buffer.cmi 
-random.cmi: int32.cmi int64.cmi nativeint.cmi 
+random.cmi: nativeint.cmi int64.cmi int32.cmi 
 weak.cmi: hashtbl.cmi 
-arg.cmo: array.cmi buffer.cmi list.cmi printf.cmi string.cmi sys.cmi arg.cmi 
-arg.cmx: array.cmx buffer.cmx list.cmx printf.cmx string.cmx sys.cmx arg.cmi 
+arg.cmo: sys.cmi string.cmi printf.cmi list.cmi buffer.cmi array.cmi arg.cmi 
+arg.cmx: sys.cmx string.cmx printf.cmx list.cmx buffer.cmx array.cmx arg.cmi 
 array.cmo: array.cmi 
 array.cmx: array.cmi 
 arrayLabels.cmo: array.cmi arrayLabels.cmi 
 arrayLabels.cmx: array.cmx arrayLabels.cmi 
-buffer.cmo: string.cmi sys.cmi buffer.cmi 
-buffer.cmx: string.cmx sys.cmx buffer.cmi 
+buffer.cmo: sys.cmi string.cmi buffer.cmi 
+buffer.cmx: sys.cmx string.cmx buffer.cmi 
 callback.cmo: obj.cmi callback.cmi 
 callback.cmx: obj.cmx callback.cmi 
-camlinternalOO.cmo: array.cmi char.cmi list.cmi map.cmi obj.cmi string.cmi \
-    sys.cmi camlinternalOO.cmi 
-camlinternalOO.cmx: array.cmx char.cmx list.cmx map.cmx obj.cmx string.cmx \
-    sys.cmx camlinternalOO.cmi 
+camlinternalOO.cmo: sys.cmi string.cmi obj.cmi map.cmi list.cmi char.cmi \
+    array.cmi camlinternalOO.cmi 
+camlinternalOO.cmx: sys.cmx string.cmx obj.cmx map.cmx list.cmx char.cmx \
+    array.cmx camlinternalOO.cmi 
 char.cmo: char.cmi 
 char.cmx: char.cmi 
 complex.cmo: complex.cmi 
 complex.cmx: complex.cmi 
-digest.cmo: printf.cmi string.cmi digest.cmi 
-digest.cmx: printf.cmx string.cmx digest.cmi 
-filename.cmo: buffer.cmi printf.cmi random.cmi string.cmi sys.cmi \
+digest.cmo: string.cmi printf.cmi digest.cmi 
+digest.cmx: string.cmx printf.cmx digest.cmi 
+filename.cmo: sys.cmi string.cmi random.cmi printf.cmi buffer.cmi \
     filename.cmi 
-filename.cmx: buffer.cmx printf.cmx random.cmx string.cmx sys.cmx \
+filename.cmx: sys.cmx string.cmx random.cmx printf.cmx buffer.cmx \
     filename.cmi 
-format.cmo: buffer.cmi list.cmi obj.cmi printf.cmi string.cmi format.cmi 
-format.cmx: buffer.cmx list.cmx obj.cmx printf.cmx string.cmx format.cmi 
-gc.cmo: printf.cmi sys.cmi gc.cmi 
-gc.cmx: printf.cmx sys.cmx gc.cmi 
-genlex.cmo: char.cmi hashtbl.cmi list.cmi stream.cmi string.cmi genlex.cmi 
-genlex.cmx: char.cmx hashtbl.cmx list.cmx stream.cmx string.cmx genlex.cmi 
-hashtbl.cmo: array.cmi sys.cmi hashtbl.cmi 
-hashtbl.cmx: array.cmx sys.cmx hashtbl.cmi 
+format.cmo: string.cmi printf.cmi obj.cmi list.cmi buffer.cmi format.cmi 
+format.cmx: string.cmx printf.cmx obj.cmx list.cmx buffer.cmx format.cmi 
+freshness.cmo: list.cmi freshness.cmi 
+freshness.cmx: list.cmx freshness.cmi 
+gc.cmo: sys.cmi printf.cmi gc.cmi 
+gc.cmx: sys.cmx printf.cmx gc.cmi 
+genlex.cmo: string.cmi stream.cmi list.cmi hashtbl.cmi char.cmi genlex.cmi 
+genlex.cmx: string.cmx stream.cmx list.cmx hashtbl.cmx char.cmx genlex.cmi 
+hashtbl.cmo: sys.cmi array.cmi hashtbl.cmi 
+hashtbl.cmx: sys.cmx array.cmx hashtbl.cmi 
 int32.cmo: pervasives.cmi int32.cmi 
 int32.cmx: pervasives.cmx int32.cmi 
 int64.cmo: pervasives.cmi int64.cmi 
 int64.cmx: pervasives.cmx int64.cmi 
 lazy.cmo: obj.cmi lazy.cmi 
 lazy.cmx: obj.cmx lazy.cmi 
-lexing.cmo: array.cmi string.cmi sys.cmi lexing.cmi 
-lexing.cmx: array.cmx string.cmx sys.cmx lexing.cmi 
+lexing.cmo: sys.cmi string.cmi array.cmi lexing.cmi 
+lexing.cmx: sys.cmx string.cmx array.cmx lexing.cmi 
 list.cmo: list.cmi 
 list.cmx: list.cmi 
 listLabels.cmo: list.cmi listLabels.cmi 
@@ -55,31 +57,31 @@
 map.cmx: map.cmi 
 marshal.cmo: string.cmi marshal.cmi 
 marshal.cmx: string.cmx marshal.cmi 
-moreLabels.cmo: hashtbl.cmi map.cmi set.cmi moreLabels.cmi 
-moreLabels.cmx: hashtbl.cmx map.cmx set.cmx moreLabels.cmi 
-nativeint.cmo: pervasives.cmi sys.cmi nativeint.cmi 
-nativeint.cmx: pervasives.cmx sys.cmx nativeint.cmi 
+moreLabels.cmo: set.cmi map.cmi hashtbl.cmi moreLabels.cmi 
+moreLabels.cmx: set.cmx map.cmx hashtbl.cmx moreLabels.cmi 
+nativeint.cmo: sys.cmi pervasives.cmi nativeint.cmi 
+nativeint.cmx: sys.cmx pervasives.cmx nativeint.cmi 
 obj.cmo: marshal.cmi obj.cmi 
 obj.cmx: marshal.cmx obj.cmi 
 oo.cmo: camlinternalOO.cmi oo.cmi 
 oo.cmx: camlinternalOO.cmx oo.cmi 
-parsing.cmo: array.cmi lexing.cmi obj.cmi parsing.cmi 
-parsing.cmx: array.cmx lexing.cmx obj.cmx parsing.cmi 
+parsing.cmo: obj.cmi lexing.cmi array.cmi parsing.cmi 
+parsing.cmx: obj.cmx lexing.cmx array.cmx parsing.cmi 
 pervasives.cmo: pervasives.cmi 
 pervasives.cmx: pervasives.cmi 
-printexc.cmo: obj.cmi printf.cmi printexc.cmi 
-printexc.cmx: obj.cmx printf.cmx printexc.cmi 
-printf.cmo: buffer.cmi char.cmi list.cmi obj.cmi string.cmi printf.cmi 
-printf.cmx: buffer.cmx char.cmx list.cmx obj.cmx string.cmx printf.cmi 
+printexc.cmo: printf.cmi obj.cmi printexc.cmi 
+printexc.cmx: printf.cmx obj.cmx printexc.cmi 
+printf.cmo: string.cmi obj.cmi list.cmi char.cmi buffer.cmi printf.cmi 
+printf.cmx: string.cmx obj.cmx list.cmx char.cmx buffer.cmx printf.cmi 
 queue.cmo: obj.cmi queue.cmi 
 queue.cmx: obj.cmx queue.cmi 
-random.cmo: array.cmi char.cmi digest.cmi int32.cmi int64.cmi nativeint.cmi \
-    pervasives.cmi string.cmi random.cmi 
-random.cmx: array.cmx char.cmx digest.cmx int32.cmx int64.cmx nativeint.cmx \
-    pervasives.cmx string.cmx random.cmi 
-scanf.cmo: buffer.cmi hashtbl.cmi list.cmi obj.cmi printf.cmi string.cmi \
+random.cmo: string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \
+    digest.cmi char.cmi array.cmi random.cmi 
+random.cmx: string.cmx pervasives.cmx nativeint.cmx int64.cmx int32.cmx \
+    digest.cmx char.cmx array.cmx random.cmi 
+scanf.cmo: string.cmi printf.cmi obj.cmi list.cmi hashtbl.cmi buffer.cmi \
     scanf.cmi 
-scanf.cmx: buffer.cmx hashtbl.cmx list.cmx obj.cmx printf.cmx string.cmx \
+scanf.cmx: string.cmx printf.cmx obj.cmx list.cmx hashtbl.cmx buffer.cmx \
     scanf.cmi 
 set.cmo: set.cmi 
 set.cmx: set.cmi 
@@ -87,15 +89,15 @@
 sort.cmx: array.cmx sort.cmi 
 stack.cmo: list.cmi stack.cmi 
 stack.cmx: list.cmx stack.cmi 
-stdLabels.cmo: arrayLabels.cmi listLabels.cmi stringLabels.cmi stdLabels.cmi 
-stdLabels.cmx: arrayLabels.cmx listLabels.cmx stringLabels.cmx stdLabels.cmi 
-stream.cmo: list.cmi obj.cmi string.cmi stream.cmi 
-stream.cmx: list.cmx obj.cmx string.cmx stream.cmi 
-string.cmo: char.cmi list.cmi pervasives.cmi string.cmi 
-string.cmx: char.cmx list.cmx pervasives.cmx string.cmi 
+stdLabels.cmo: stringLabels.cmi listLabels.cmi arrayLabels.cmi stdLabels.cmi 
+stdLabels.cmx: stringLabels.cmx listLabels.cmx arrayLabels.cmx stdLabels.cmi 
+stream.cmo: string.cmi obj.cmi list.cmi stream.cmi 
+stream.cmx: string.cmx obj.cmx list.cmx stream.cmi 
+string.cmo: pervasives.cmi list.cmi char.cmi string.cmi 
+string.cmx: pervasives.cmx list.cmx char.cmx string.cmi 
 stringLabels.cmo: string.cmi stringLabels.cmi 
 stringLabels.cmx: string.cmx stringLabels.cmi 
 sys.cmo: sys.cmi 
 sys.cmx: sys.cmi 
-weak.cmo: array.cmi hashtbl.cmi obj.cmi sys.cmi weak.cmi 
-weak.cmx: array.cmx hashtbl.cmx obj.cmx sys.cmx weak.cmi 
+weak.cmo: sys.cmi obj.cmi hashtbl.cmi array.cmi weak.cmi 
+weak.cmx: sys.cmx obj.cmx hashtbl.cmx array.cmx weak.cmi 
--- ocaml-3.08.2/stdlib/Makefile	2004-06-14 13:23:21.000000000 +0100
+++ fresh-ocaml-3.08.2/stdlib/Makefile	2005-01-11 16:21:52.000000000 +0000
@@ -15,14 +15,14 @@
 
 include ../config/Makefile
 
-RUNTIME=../boot/ocamlrun
-COMPILER=../ocamlc
+RUNTIME=../boot/fresh-ocamlrun
+COMPILER=../fresh-ocamlc
 CAMLC=$(RUNTIME) $(COMPILER)
 COMPFLAGS=-g -warn-error A -nostdlib
-OPTCOMPILER=../ocamlopt
+OPTCOMPILER=../fresh-ocamlopt
 CAMLOPT=$(RUNTIME) $(OPTCOMPILER)
 OPTCOMPFLAGS=-warn-error A -nostdlib
-CAMLDEP=../boot/ocamlrun ../tools/ocamldep
+CAMLDEP=../boot/fresh-ocamlrun ../tools/fresh-ocamldep
 
 OBJS=pervasives.cmo $(OTHERS)
 OTHERS=array.cmo list.cmo char.cmo string.cmo sys.cmo \
@@ -35,7 +35,8 @@
   digest.cmo random.cmo callback.cmo camlinternalOO.cmo oo.cmo \
   genlex.cmo weak.cmo \
   lazy.cmo filename.cmo complex.cmo \
-  arrayLabels.cmo listLabels.cmo stringLabels.cmo moreLabels.cmo stdLabels.cmo
+  arrayLabels.cmo listLabels.cmo stringLabels.cmo moreLabels.cmo stdLabels.cmo \
+  freshness.cmo
 
 all: stdlib.cma std_exit.cmo camlheader camlheader_ur
 
@@ -78,11 +79,11 @@
 
 camlheader camlheader_ur: header.c ../config/Makefile
 	if $(SHARPBANGSCRIPTS); then \
-          echo '#!$(BINDIR)/ocamlrun' > camlheader && \
+          echo '#!$(BINDIR)/fresh-ocamlrun' > camlheader && \
           echo '#!' | tr -d '\012' > camlheader_ur; \
         else \
 	  $(BYTECC) $(BYTECCCOMPOPTS) $(BYTECCLINKOPTS) \
-                    -DRUNTIME_NAME='"$(BINDIR)/ocamlrun"' \
+                    -DRUNTIME_NAME='"$(BINDIR)/fresh-ocamlrun"' \
                     header.c -o tmpheader$(EXE) && \
           strip tmpheader$(EXE) && \
 	  mv tmpheader$(EXE) camlheader && \
--- ocaml-3.08.2/stdlib/StdlibModules	2003-11-26 10:57:14.000000000 +0000
+++ fresh-ocaml-3.08.2/stdlib/StdlibModules	2005-01-10 14:06:36.000000000 +0000
@@ -14,6 +14,7 @@
   digest \
   filename \
   format \
+  freshness \
   gc \
   genlex \
   hashtbl \
--- ocaml-3.08.2/stdlib/obj.ml	2004-01-01 16:42:40.000000000 +0000
+++ fresh-ocaml-3.08.2/stdlib/obj.ml	2005-01-11 20:02:04.000000000 +0000
@@ -36,6 +36,11 @@
 let unmarshal str pos =
   (Marshal.from_string str pos, pos + Marshal.total_size str pos)
 
+let no_swap_tag = 241
+let no_bind_tag = 242
+let custom_swap_tag = 243
+let abst_tag = 244
+let atom_tag = 245
 let lazy_tag = 246
 let closure_tag = 247
 let object_tag = 248
--- ocaml-3.08.2/stdlib/obj.mli	2004-01-01 16:42:40.000000000 +0000
+++ fresh-ocaml-3.08.2/stdlib/obj.mli	2005-01-11 20:03:08.000000000 +0000
@@ -34,6 +34,11 @@
 external new_block : int -> int -> t = "caml_obj_block"
 external dup : t -> t = "caml_obj_dup"
 
+val no_swap_tag : int
+val no_bind_tag : int
+val custom_swap_tag : int
+val atom_tag : int
+val abst_tag : int
 val lazy_tag : int
 val closure_tag : int
 val object_tag : int
--- ocaml-3.08.2/stdlib/sort.ml	2004-01-14 17:20:56.000000000 +0000
+++ fresh-ocaml-3.08.2/stdlib/sort.ml	2005-01-10 14:06:36.000000000 +0000
@@ -43,7 +43,7 @@
     | llist -> mergeall (merge2 llist) in
   mergeall(initlist l)
 
-let swap arr i j =
+let exchange arr i j =
   let tmp = unsafe_get arr i in
   unsafe_set arr i (unsafe_get arr j);
   unsafe_set arr j tmp
@@ -60,10 +60,10 @@
          probability of picking a pathological pivot.  It also
          avoids extra comparisons on i and j in the two tight "while"
          loops below. *)
-      if cmp (unsafe_get arr mid) (unsafe_get arr lo) then swap arr mid lo;
+      if cmp (unsafe_get arr mid) (unsafe_get arr lo) then exchange arr mid lo;
       if cmp (unsafe_get arr hi) (unsafe_get arr mid) then begin
-        swap arr mid hi;
-        if cmp (unsafe_get arr mid) (unsafe_get arr lo) then swap arr mid lo
+        exchange arr mid hi;
+        if cmp (unsafe_get arr mid) (unsafe_get arr lo) then exchange arr mid lo
       end;
       let pivot = unsafe_get arr mid in
       let i = ref (lo + 1) and j = ref (hi - 1) in
@@ -73,7 +73,7 @@
       while !i < !j do
         while not (cmp pivot (unsafe_get arr !i)) do incr i done;
         while not (cmp (unsafe_get arr !j) pivot) do decr j done;
-        if !i < !j then swap arr !i !j;
+        if !i < !j then exchange arr !i !j;
         incr i; decr j
       done;
       (* Recursion on smaller half, tail-call on larger half *)
--- ocaml-3.08.2/stdlib/sys.ml	2004-11-22 16:25:38.000000000 +0000
+++ fresh-ocaml-3.08.2/stdlib/sys.ml	2005-01-14 12:52:13.000000000 +0000
@@ -78,4 +78,4 @@
 
 (* OCaml version string, must be in the format described in sys.mli. *)
 
-let ocaml_version = "3.08.2";;
+let ocaml_version = "3.08.2+4";;
--- ocaml-3.08.2/tools/Makefile	2004-06-20 16:26:06.000000000 +0100
+++ fresh-ocaml-3.08.2/tools/Makefile	2005-01-11 16:37:46.000000000 +0000
@@ -14,18 +14,18 @@
 
 include ../config/Makefile
 
-CAMLRUN=../boot/ocamlrun
-CAMLC=$(CAMLRUN) ../boot/ocamlc -nostdlib -I ../boot
-CAMLOPT=$(CAMLRUN) ../ocamlopt -nostdlib -I ../stdlib
-CAMLLEX=$(CAMLRUN) ../boot/ocamllex
+CAMLRUN=../boot/fresh-ocamlrun
+CAMLC=$(CAMLRUN) ../boot/fresh-ocamlc -nostdlib -I ../boot
+CAMLOPT=$(CAMLRUN) ../fresh-ocamlopt -nostdlib -I ../stdlib
+CAMLLEX=$(CAMLRUN) ../boot/fresh-ocamllex
 INCLUDES=-I ../utils -I ../parsing -I ../typing -I ../bytecomp -I ../asmcomp \
          -I ../driver
 COMPFLAGS= -warn-error A $(INCLUDES)
 LINKFLAGS=$(INCLUDES)
 
-all: ocamldep ocamlprof ocamlcp ocamlmktop ocamlmklib scrapelabels addlabels 
+all: fresh-ocamldep fresh-ocamlprof fresh-ocamlcp fresh-ocamlmktop fresh-ocamlmklib scrapelabels addlabels 
 
-opt.opt: ocamldep.opt
+opt.opt: fresh-ocamldep.opt
 
 # The dependency generator
 
@@ -34,23 +34,23 @@
   linenum.cmo warnings.cmo location.cmo longident.cmo \
   syntaxerr.cmo parser.cmo lexer.cmo parse.cmo
 
-ocamldep: depend.cmi $(CAMLDEP_OBJ)
-	$(CAMLC) $(LINKFLAGS) -o ocamldep $(CAMLDEP_IMPORTS) $(CAMLDEP_OBJ)
+fresh-ocamldep: depend.cmi $(CAMLDEP_OBJ)
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamldep $(CAMLDEP_IMPORTS) $(CAMLDEP_OBJ)
 
-ocamldep.opt: depend.cmi $(CAMLDEP_OBJ:.cmo=.cmx)
+fresh-ocamldep.opt: depend.cmi $(CAMLDEP_OBJ:.cmo=.cmx)
 	$(CAMLOPT) $(LINKFLAGS) -o ocamldep.opt $(CAMLDEP_IMPORTS:.cmo=.cmx) \
 	           $(CAMLDEP_OBJ:.cmo=.cmx)
 
 # ocamldep is precious: sometimes we are stuck in the middle of a
 # bootstrap and we need to remake the dependencies
 clean::
-	if test -f ocamldep; then mv -f ocamldep ocamldep.bak; else :; fi
-	rm -f ocamldep.opt
+	if test -f fresh-ocamldep; then mv -f fresh-ocamldep ocamldep.bak; else :; fi
+	rm -f fresh-ocamldep.opt
 
 install::
-	cp ocamldep $(BINDIR)/ocamldep$(EXE)
-	if test -f ocamldep.opt; \
-	  then cp ocamldep.opt $(BINDIR)/ocamldep.opt$(EXE); else :; fi
+	cp fresh-ocamldep $(BINDIR)/fresh-ocamldep$(EXE)
+	if test -f fresh-ocamldep.opt; \
+	  then cp fresh-ocamldep.opt $(BINDIR)/fresh-ocamldep.opt$(EXE); else :; fi
 
 # The profiler
 
@@ -59,42 +59,42 @@
   linenum.cmo warnings.cmo location.cmo longident.cmo \
   syntaxerr.cmo parser.cmo lexer.cmo parse.cmo
 
-ocamlprof: $(CSLPROF) profiling.cmo
-	$(CAMLC) $(LINKFLAGS) -o ocamlprof $(CSLPROF_IMPORTS) $(CSLPROF)
+fresh-ocamlprof: $(CSLPROF) profiling.cmo
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamlprof $(CSLPROF_IMPORTS) $(CSLPROF)
 
-ocamlcp: ocamlcp.cmo
-	$(CAMLC) $(LINKFLAGS) -o ocamlcp main_args.cmo ocamlcp.cmo
+fresh-ocamlcp: ocamlcp.cmo
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamlcp main_args.cmo ocamlcp.cmo
 
 install::
-	cp ocamlprof $(BINDIR)/ocamlprof$(EXE)
-	cp ocamlcp $(BINDIR)/ocamlcp$(EXE)
+	cp fresh-ocamlprof $(BINDIR)/fresh-ocamlprof$(EXE)
+	cp fresh-ocamlcp $(BINDIR)/fresh-ocamlcp$(EXE)
 	cp profiling.cmi profiling.cmo $(LIBDIR)
 
 clean::
-	rm -f ocamlprof ocamlcp
+	rm -f fresh-ocamlprof fresh-ocamlcp
 
 # To make custom toplevels
 
-ocamlmktop: ocamlmktop.tpl ../config/Makefile
-	sed -e 's|%%BINDIR%%|$(BINDIR)|' ocamlmktop.tpl > ocamlmktop
-	chmod +x ocamlmktop
+fresh-ocamlmktop: ocamlmktop.tpl ../config/Makefile
+	sed -e 's|%%BINDIR%%|$(BINDIR)|' ocamlmktop.tpl > fresh-ocamlmktop
+	chmod +x fresh-ocamlmktop
 
 install::
-	cp ocamlmktop $(BINDIR)/ocamlmktop
+	cp fresh-ocamlmktop $(BINDIR)/fresh-ocamlmktop
 
 clean::
-	rm -f ocamlmktop
+	rm -f fresh-ocamlmktop
 
 # To help building mixed-mode libraries (Caml + C)
 
-ocamlmklib: ocamlmklib.cmo
-	$(CAMLC) $(LINKFLAGS) -o ocamlmklib ocamlmklib.cmo
+fresh-ocamlmklib: ocamlmklib.cmo
+	$(CAMLC) $(LINKFLAGS) -o fresh-ocamlmklib ocamlmklib.cmo
 
 install::
-	cp ocamlmklib $(BINDIR)/ocamlmklib
+	cp fresh-ocamlmklib $(BINDIR)/fresh-ocamlmklib
 
 clean::
-	rm -f ocamlmklib
+	rm -f fresh-ocamlmklib
 
 ocamlmklib.ml: ocamlmklib.mlp ../config/Makefile
 	echo '(* THIS FILE IS GENERATED FROM ocamlmklib.mlp *)' >ocamlmklib.ml
--- ocaml-3.08.2/tools/addlabels.ml	2003-11-25 09:20:45.000000000 +0000
+++ fresh-ocaml-3.08.2/tools/addlabels.ml	2005-01-10 14:06:36.000000000 +0000
@@ -65,6 +65,7 @@
   | Ppat_any | Ppat_constant _ | Ppat_construct _ | Ppat_variant _
   | Ppat_type _ ->
       []
+  | Ppat_abst (p1, p2) -> pattern_vars p1 @ pattern_vars p2
 
 let pattern_name pat =
   match pat.ppat_desc with
@@ -275,8 +276,12 @@
       add_labels_rec e3 ~values:(SMap.removes [s] values)
   | Pexp_override lst ->
       List.iter lst ~f:(fun (_,e) -> add_labels_rec e)
+  | Pexp_abst (e1, e2) ->
+      add_labels_rec e1; add_labels_rec e2
+  | Pexp_swap (e1, e2, e3) ->
+      add_labels_rec e1; add_labels_rec e2; add_labels_rec e3
   | Pexp_ident _ | Pexp_constant _ | Pexp_construct _ | Pexp_variant _
-  | Pexp_new _ | Pexp_assertfalse | Pexp_object _ ->
+  | Pexp_new _ | Pexp_assertfalse | Pexp_object _ | Pexp_fresh | Pexp_freshfor _ ->
       ()
 
 let rec add_labels_class ~text ~classes ~values ~methods cl =
--- ocaml-3.08.2/tools/depend.ml	2003-11-25 09:20:45.000000000 +0000
+++ fresh-ocaml-3.08.2/tools/depend.ml	2005-01-10 14:06:36.000000000 +0000
@@ -52,6 +52,7 @@
           | Rinherit sty -> add_type bv sty)
         fl
   | Ptyp_poly(_, t) -> add_type bv t
+  | Ptyp_abst(t1, t2) -> add_type bv t1; add_type bv t2
 
 and add_field_type bv ft =
   match ft.pfield_desc with
@@ -112,6 +113,7 @@
   | Ppat_constraint(p, ty) -> add_pattern bv p; add_type bv ty
   | Ppat_variant(_, op) -> add_opt add_pattern bv op
   | Ppat_type (li) -> add bv li
+  | Ppat_abst (p1, p2) -> add_pattern bv p1; add_pattern bv p2
 
 let rec add_expr bv exp =
   match exp.pexp_desc with
@@ -154,6 +156,12 @@
   | Pexp_assertfalse -> ()
   | Pexp_lazy (e) -> add_expr bv e
   | Pexp_poly (e, t) -> add_expr bv e; add_opt add_type bv t
+  | Pexp_abst (e1, e2) -> add_expr bv e1; add_expr bv e2
+  | Pexp_swap (e1, e2, body) ->
+      add_expr bv e1; add_expr bv e2; add_expr bv body
+  | Pexp_fresh -> ()
+  | Pexp_freshfor (e1, e2) -> add_expr bv e1; add_expr bv e2
+  | Pexp_customswap (e1, e2) -> add_expr bv e1; add_expr bv e2
   | Pexp_object (pat, fieldl) ->
       add_pattern bv pat; List.iter (add_class_field bv) fieldl
 and add_pat_expr_list bv pel =
--- ocaml-3.08.2/tools/ocamlcp.ml	2003-07-17 09:38:28.000000000 +0100
+++ fresh-ocaml-3.08.2/tools/ocamlcp.ml	2005-01-11 17:14:52.000000000 +0000
@@ -35,10 +35,10 @@
   compargs := (Filename.quote filename) :: !compargs
 ;;
 
-let usage = "Usage: ocamlcp <options> <files>\noptions are:"
+let usage = "Usage: fresh-ocamlcp <options> <files>\noptions are:"
 
 let incompatible o =
-  fprintf stderr "ocamlcp: profiling is incompatible with the %s option\n" o;
+  fprintf stderr "fresh-ocamlcp: profiling is incompatible with the %s option\n" o;
   exit 2
 
 let ismultithreaded = ref ""
@@ -108,15 +108,15 @@
 in
 Arg.parse optlist process_file usage;
 if !with_impl && !with_intf then begin
-  fprintf stderr "ocamlcp cannot deal with both \"-impl\" and \"-intf\"\n";
+  fprintf stderr "fresh-ocamlcp cannot deal with both \"-impl\" and \"-intf\"\n";
   fprintf stderr "please compile interfaces and implementations separately\n";
   exit 2;
 end else if !with_impl && !with_mli then begin
-  fprintf stderr "ocamlcp cannot deal with both \"-impl\" and .mli files\n";
+  fprintf stderr "fresh-ocamlcp cannot deal with both \"-impl\" and .mli files\n";
   fprintf stderr "please compile interfaces and implementations separately\n";
   exit 2;
 end else if !with_intf && !with_ml then begin
-  fprintf stderr "ocamlcp cannot deal with both \"-intf\" and .ml files\n";
+  fprintf stderr "fresh-ocamlcp cannot deal with both \"-intf\" and .ml files\n";
   fprintf stderr "please compile interfaces and implementations separately\n";
   exit 2;
 end;
@@ -124,7 +124,7 @@
 if !with_intf then profargs := "-intf" :: !profargs;
 let status =
   Sys.command
-    (Printf.sprintf "ocamlc -pp \"ocamlprof %s -instrument %s\" %s %s"
+    (Printf.sprintf "fresh-ocamlc -pp \"fresh-ocamlprof %s -instrument %s\" %s %s"
         !ismultithreaded
         (String.concat " " (List.rev !profargs))
         (if !make_archive then "" else "profiling.cmo")
--- ocaml-3.08.2/tools/ocamlprof.ml	2004-11-18 23:52:08.000000000 +0000
+++ fresh-ocaml-3.08.2/tools/ocamlprof.ml	2005-01-10 14:06:36.000000000 +0000
@@ -285,6 +285,25 @@
   | Pexp_object (_, fieldl) ->
       List.iter (rewrite_class_field iflag) fieldl
 
+  | Pexp_abst (sexp1, sexp2) ->
+      rewrite_exp iflag sexp1;
+      rewrite_exp iflag sexp2
+
+  | Pexp_swap (sexp1, sexp2, sexp_body) ->
+      rewrite_exp iflag sexp1;
+      rewrite_exp iflag sexp2;
+      rewrite_exp iflag sexp_body
+
+  | Pexp_fresh -> ()
+
+  | Pexp_freshfor (sexp1, sexp2) ->
+      rewrite_exp iflag sexp1;
+      rewrite_exp iflag sexp2
+
+  | Pexp_customswap (sexp1, sexp2) ->
+      rewrite_exp iflag sexp1;
+      rewrite_exp iflag sexp2
+
 and rewrite_ifbody iflag ghost sifbody =
   if !instr_if && not ghost then
     insert_profile rw_exp sifbody
--- ocaml-3.08.2/toplevel/genprintval.ml	2004-06-13 17:23:35.000000000 +0100
+++ fresh-ocaml-3.08.2/toplevel/genprintval.ml	2005-01-11 20:06:56.000000000 +0000
@@ -21,6 +21,8 @@
 open Types
 open Outcometree
 
+external fresh_throughout : 'a -> 'a = "fresh_throughout"
+
 module type OBJ =
   sig
     type t
@@ -171,7 +173,23 @@
     let outval_of_value max_steps max_depth check_depth env obj ty =
 
       let printer_steps = ref max_steps in
+      let atom_map = ref [] in
+      let atom_count = ref 0 in
 
+      let add_or_lookup_atom atm =
+        let rec search l =
+          match l with
+            [] ->
+              let tag = string_of_int !atom_count in
+                incr atom_count;
+                atom_map := (atm, tag) :: !atom_map;
+                tag
+          | ((atm', tag') :: rest) ->
+              if atm = atm' then tag'
+              else search rest
+        in
+          search !atom_map
+      in
       let rec tree_of_val depth obj ty =
         decr printer_steps;
         if !printer_steps < 0 || depth < 0 then Oval_ellipsis
@@ -237,7 +255,13 @@
                 let decl = Env.find_type path env in
                 match decl with
                 | {type_kind = Type_abstract; type_manifest = None} ->
-                    Oval_stuff "<abstr>"
+                    if path = Predef.path_name then
+                      let _ = assert (O.tag obj = Obj.atom_tag) in
+                      let (atm_blk : int) = O.obj (O.field obj 0) in
+                      let atm = add_or_lookup_atom atm_blk in
+                        Oval_stuff ("name_" ^ atm)
+                    else
+                      Oval_stuff ("<abstract type>")
                 | {type_kind = Type_abstract; type_manifest = Some body} ->
                     tree_of_val depth obj
                       (try Ctype.apply env decl.type_params body ty_list with
@@ -245,7 +269,14 @@
                 | {type_kind = Type_variant(constr_list, priv)} ->
                     let tag =
                       if O.is_block obj
-                      then Cstr_block(O.tag obj)
+                      then (
+                        if O.tag obj = Obj.no_bind_tag ||
+			   O.tag obj = Obj.no_swap_tag ||
+                           O.tag obj = Obj.custom_swap_tag then
+                          Cstr_block 0
+                        else
+                          Cstr_block(O.tag obj)
+                      )
                       else Cstr_constant(O.obj obj) in
                     let (constr_name, constr_args) =
                       Datarepr.find_constr_by_tag tag constr_list in
@@ -281,7 +312,7 @@
                     end
               with
                 Not_found ->                (* raised by Env.find_type *)
-                  Oval_stuff "<abstr>"
+                  Oval_stuff "<abstract type>"
               | Datarepr.Constr_not_found -> (* raised by find_constr_by_tag *)
                   Oval_stuff "<unknown constructor>"
               end
@@ -320,6 +351,10 @@
               tree_of_val (depth - 1) obj ty
           | Tunivar ->
               Oval_stuff "<poly>"
+          | Tabst (ty1, ty2) ->
+              let obj' = fresh_throughout (O.obj obj) in
+                Oval_abst (tree_of_val (depth - 1) (O.field obj' 0) ty1,
+                           tree_of_val (depth - 1) (O.field obj' 1) ty2)
         end
 
       and tree_of_val_list start depth obj ty_list =
--- ocaml-3.08.2/toplevel/toploop.ml	2004-06-12 09:55:47.000000000 +0100
+++ fresh-ocaml-3.08.2/toplevel/toploop.ml	2005-01-11 17:08:25.000000000 +0000
@@ -389,7 +389,7 @@
 exception PPerror
 
 let loop ppf =
-  fprintf ppf "        Objective Caml version %s@.@." Config.version;
+  fprintf ppf "        Fresh Objective Caml release %s@.@." Config.version;
   initialize_toplevel_env ();
   let lb = Lexing.from_function refill_lexbuf in
   Location.input_name := "";
--- ocaml-3.08.2/toplevel/topmain.ml	2003-07-25 13:18:25.000000000 +0100
+++ fresh-ocaml-3.08.2/toplevel/topmain.ml	2005-01-10 14:06:36.000000000 +0000
@@ -14,7 +14,7 @@
 
 open Clflags
 
-let usage = "Usage: ocaml <options> <object-files> [script-file]\noptions are:"
+let usage = "Usage: fresh-ocaml <options> <object-files> [script-file]\noptions are:"
 
 let preload_objects = ref []
 
--- ocaml-3.08.2/typing/btype.ml	2004-01-06 13:41:39.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/btype.ml	2005-01-10 14:06:36.000000000 +0000
@@ -174,6 +174,7 @@
   | Tsubst ty           -> f ty
   | Tunivar             -> ()
   | Tpoly (ty, tyl)     -> f ty; List.iter f tyl
+  | Tabst (ty1, ty2)    -> f ty1; f ty2
 
 let rec iter_abbrev f = function
     Mnil                   -> ()
@@ -241,6 +242,7 @@
   | Tpoly (ty, tyl)     ->
       let tyl = List.map (fun x -> norm_univar (f x)) tyl in
       Tpoly (f ty, tyl)
+  | Tabst (ty1, ty2)    -> Tabst (f ty1, f ty2)
 
 
 (* Utilities for copying *)
--- ocaml-3.08.2/typing/ctype.ml	2004-07-07 02:45:21.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/ctype.ml	2005-01-10 14:06:36.000000000 +0000
@@ -1447,6 +1447,9 @@
         end
     | (Ttuple tl1, Ttuple tl2) ->
         unify_list env tl1 tl2
+    | (Tabst (t1, t2), Tabst (t1', t2')) ->
+        unify env t1 t1';
+        unify env t2 t2'
     | (Tconstr (p1, tl1, _), Tconstr (p2, tl2, _)) when Path.same p1 p2 ->
         unify_list env tl1 tl2
     | (Tobject (fi1, nm1), Tobject (fi2, _)) ->
@@ -2197,6 +2200,9 @@
               univar_pairs := old_univars
           | (Tunivar, Tunivar) ->
               unify_univar t1 t2 !univar_pairs
+          | (Tabst (t1, t2), Tabst (t1', t2')) ->
+              eqtype rename type_pairs subst env t1 t1';
+              eqtype rename type_pairs subst env t2 t2'
           | (_, _) ->
               raise (Unify [])
         end
@@ -2752,6 +2758,12 @@
       else (t, Unchanged)
   | Tunivar ->
       (t, Unchanged)
+  | Tabst (t1, t2) ->
+      let (t1', c1) = build_subtype env visited loops posi level t1 in
+      let (t2', c2) = build_subtype env visited loops posi level t2 in
+      let c = max c1 c2 in
+      if c > Unchanged then (newty (Tabst (t1', t2')), c)
+                       else (t, Unchanged)
 
 let enlarge_type env ty =
   warn := false;
--- ocaml-3.08.2/typing/datarepr.ml	2003-07-02 10:14:32.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/datarepr.ml	2005-01-11 20:07:12.000000000 +0000
@@ -38,7 +38,11 @@
           { cstr_res = ty_res;
             cstr_args = ty_args;
             cstr_arity = List.length ty_args;
-            cstr_tag = tag;
+            cstr_tag =
+              if name = "Nobind" then Cstr_block Obj.no_bind_tag
+              else if name = "Noswap" then Cstr_block Obj.no_swap_tag
+              else if name = "Custom_swap" then Cstr_block Obj.custom_swap_tag
+              else tag;
             cstr_consts = !num_consts;
             cstr_nonconsts = !num_nonconsts;
             cstr_private = priv } in
--- ocaml-3.08.2/typing/oprint.ml	2004-06-12 09:55:47.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/oprint.ml	2005-01-10 14:06:36.000000000 +0000
@@ -109,6 +109,8 @@
     | Oval_printer f -> f ppf
     | Oval_tuple tree_list ->
         fprintf ppf "@[<1>(%a)@]" (print_tree_list print_tree_1 ",") tree_list
+    | Oval_abst (t1, t2) ->
+        fprintf ppf "<<%a>>%a" print_simple_tree t1 print_simple_tree t2
     | tree -> fprintf ppf "@[<1>(%a)@]" (cautious print_tree_1) tree
   and print_fields first ppf =
     function
@@ -172,7 +174,12 @@
 and print_out_type_2 ppf =
   function
     Otyp_tuple tyl ->
-      fprintf ppf "@[<0>%a@]" (print_typlist print_simple_out_type " *") tyl
+      fprintf ppf "@[<0>%a@]" (print_typlist print_out_type_3 " *") tyl
+  | ty -> print_out_type_3 ppf ty
+and print_out_type_3 ppf =
+  function
+    Otyp_abst (ty1, ty2) ->
+      fprintf ppf "<<%a>>%a" print_out_type ty1 print_simple_out_type ty2
   | ty -> print_simple_out_type ppf ty
 and print_simple_out_type ppf =
   function
@@ -204,9 +211,11 @@
          else if tags = None then "> " else "? ")
         print_fields row_fields
         print_present tags
-  | Otyp_alias _ | Otyp_poly _ | Otyp_arrow _ | Otyp_tuple _ as ty ->
+  | Otyp_alias _ | Otyp_poly _ | Otyp_arrow _
+  | Otyp_tuple _ | Otyp_abst _ as ty ->
       fprintf ppf "@[<1>(%a)@]" print_out_type ty
   | Otyp_abstract | Otyp_sum _ | Otyp_record _ | Otyp_manifest (_, _) -> ()
+  | Otyp_bindable p -> fprintf ppf "%a" print_ident p
 and print_fields rest ppf =
   function
     [] ->
--- ocaml-3.08.2/typing/outcometree.mli	2004-06-12 09:55:48.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/outcometree.mli	2005-01-10 14:06:36.000000000 +0000
@@ -43,6 +43,7 @@
   | Oval_stuff of string
   | Oval_tuple of out_value list
   | Oval_variant of string * out_value option
+  | Oval_abst of out_value * out_value
 
 type out_type =
   | Otyp_abstract
@@ -60,6 +61,9 @@
   | Otyp_variant of
       bool * out_variant * bool * (string list) option
   | Otyp_poly of string list * out_type
+  | Otyp_abst of out_type * out_type
+  | Otyp_bindable of out_ident
+
 and out_variant =
   | Ovar_fields of (string * bool * out_type list) list
   | Ovar_name of out_ident * out_type list
--- ocaml-3.08.2/typing/parmatch.ml	2004-01-16 14:09:30.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/parmatch.ml	2005-01-10 14:06:36.000000000 +0000
@@ -94,6 +94,8 @@
   | Tpat_array ps, Tpat_array qs ->
       List.length ps = List.length qs &&
       compats ps qs
+  | Tpat_abst (p1, p2), Tpat_abst (p1', p2') ->
+      compat p1 p1' && compat p2 p2'
   | _,_  ->
       assert false
         
@@ -205,6 +207,8 @@
       fprintf ppf "@[(%a@ as %a)@]" pretty_val v Ident.print x
   | Tpat_or (v,w,_)    ->
       fprintf ppf "@[(%a|@,%a)@]" pretty_or v pretty_or w
+  | Tpat_abst (v, w) ->
+      fprintf ppf "<<%a>>%a" pretty_val v pretty_val w
 
 and pretty_car ppf v = match v.pat_desc with
 | Tpat_construct ({cstr_tag=tag}, [_ ; _])
@@ -267,6 +271,7 @@
   | Tpat_constant(c1), Tpat_constant(c2) -> c1 = c2
   | Tpat_tuple _, Tpat_tuple _ -> true
   | Tpat_record _ , Tpat_record _ -> true
+  | Tpat_abst _, Tpat_abst _ -> true
   | Tpat_array p1s, Tpat_array p2s -> List.length p1s = List.length p2s
   | _, (Tpat_any | Tpat_var(_)) -> true
   | _, _ -> false
@@ -324,6 +329,7 @@
 | Tpat_construct(cstr, args) -> args
 | Tpat_variant(lab, Some arg, _) -> [arg]
 | Tpat_tuple(args)  -> args
+| Tpat_abst(a1, a2) -> [a1; a2]
 | Tpat_record(args) ->  extract_fields (record_arg p1) args
 | Tpat_array(args) -> args
 | (Tpat_any | Tpat_var(_)) ->
@@ -331,6 +337,7 @@
       Tpat_construct(_, args) -> omega_list args
     | Tpat_variant(_, Some _, _) -> [omega]
     | Tpat_tuple(args) -> omega_list args
+    | Tpat_abst(a1, a2) -> [omega; omega]
     | Tpat_record(args) ->  omega_list args
     | Tpat_array(args) ->  omega_list args
     | _ -> []
@@ -359,6 +366,8 @@
       make_pat (Tpat_record (List.map (fun (lbl,_) -> lbl,omega) largs))
         q.pat_type q.pat_env
   | Tpat_or _ -> fatal_error "Parmatch.normalize_pat"
+  | Tpat_abst (p1, p2) ->
+      make_pat (Tpat_abst (omega, omega)) q.pat_type q.pat_env
 
 
 (*
@@ -376,6 +385,7 @@
   | ({pat_desc = (Tpat_any | Tpat_var _)}::_)::pss ->
         acc_pat acc pss
   | (({pat_desc = Tpat_tuple _} as p)::_)::_ -> normalize_pat p
+  | (({pat_desc = Tpat_abst _} as p)::_)::_ -> normalize_pat p
   | (({pat_desc = Tpat_record largs} as p)::_)::pss ->
       let new_omegas =
         List.fold_left
@@ -414,6 +424,12 @@
 | {pat_desc = Tpat_tuple omegas} ->
     let args,rest = read_args omegas r in
     make_pat (Tpat_tuple args) q.pat_type q.pat_env::rest
+| {pat_desc = Tpat_abst _} ->
+    begin match r with
+      a1::a2::rest ->
+        make_pat (Tpat_abst (a1, a2)) q.pat_type q.pat_env :: rest
+    | _ -> assert false
+    end
 | {pat_desc = Tpat_record omegas} ->
     let args,rest = read_args omegas r in
     make_pat
@@ -612,6 +628,7 @@
 | ({pat_desc = Tpat_tuple(_)},_) :: _ -> true
 | ({pat_desc = Tpat_record(_)},_) :: _ -> true
 | ({pat_desc = Tpat_array(_)},_) :: _ -> false
+| ({pat_desc = Tpat_abst(_)},_) :: _ -> true
 | _ -> fatal_error "Parmatch.full_match"
 
 let extendable_match env = match env with
@@ -835,6 +852,7 @@
   | Tpat_or (p1,p2,_) -> has_instance p1 || has_instance p2
   | Tpat_construct (_,ps) | Tpat_tuple ps | Tpat_array ps -> has_instances ps
   | Tpat_record lps -> has_instances (List.map snd lps)
+  | Tpat_abst (p1, p2) -> has_instance p1 && has_instance p2
       
 and has_instances = function
   | [] -> true
@@ -1321,6 +1339,8 @@
       l1 = l2
   | Tpat_variant(_,_,_), Tpat_variant(_,_,_) -> false
   | Tpat_tuple(ps), Tpat_tuple(qs) -> le_pats ps qs
+  | Tpat_abst(p1, p2), Tpat_abst(q1, q2) ->
+      le_pat p1 q1 && le_pat p2 q2
   | Tpat_record l1, Tpat_record l2 ->
       let ps,qs = records_args l1 l2 in
       le_pats ps qs
@@ -1376,6 +1396,8 @@
       when List.length ps = List.length qs ->
         let rs = lubs ps qs in
         make_pat (Tpat_array rs) p.pat_type p.pat_env
+| Tpat_abst (p1, p2), Tpat_abst (q1, q2) ->
+    make_pat (Tpat_abst (lub p1 q1, lub p2 q2)) p.pat_type p.pat_env
 | _,_  ->
     raise Empty
 
--- ocaml-3.08.2/typing/predef.ml	2004-01-04 14:32:34.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/predef.ml	2005-01-11 20:06:24.000000000 +0000
@@ -34,6 +34,10 @@
 and ident_int32 = Ident.create "int32"
 and ident_int64 = Ident.create "int64"
 and ident_lazy_t = Ident.create "lazy_t"
+and ident_name = Ident.create "name"
+and ident_no_bind = Ident.create "nobind"
+and ident_no_swap = Ident.create "noswap"
+and ident_custom_swap = Ident.create "custom_swap"
 
 let path_int = Pident ident_int
 and path_char = Pident ident_char
@@ -50,6 +54,10 @@
 and path_int32 = Pident ident_int32
 and path_int64 = Pident ident_int64
 and path_lazy_t = Pident ident_lazy_t
+and path_name = Pident ident_name
+and path_no_bind = Pident ident_no_bind
+and path_no_swap = Pident ident_no_swap
+and path_custom_swap = Pident ident_custom_swap
 
 let type_int = newgenty (Tconstr(path_int, [], ref Mnil))
 and type_char = newgenty (Tconstr(path_char, [], ref Mnil))
@@ -65,6 +73,10 @@
 and type_int32 = newgenty (Tconstr(path_int32, [], ref Mnil))
 and type_int64 = newgenty (Tconstr(path_int64, [], ref Mnil))
 and type_lazy_t t = newgenty (Tconstr(path_lazy_t, [t], ref Mnil))
+and type_name t = newgenty (Tconstr(path_name, [t], ref Mnil))
+and type_no_bind t = newgenty (Tconstr(path_no_bind, [t], ref Mnil))
+and type_no_swap t = newgenty (Tconstr(path_no_swap, [t], ref Mnil))
+and type_custom_swap t = newgenty (Tconstr(path_custom_swap, [t], ref Mnil))
 
 let ident_match_failure = Ident.create_predef_exn "Match_failure"
 and ident_out_of_memory = Ident.create_predef_exn "Out_of_memory"
@@ -145,6 +157,43 @@
      type_kind = Type_abstract;
      type_manifest = None;
      type_variance = [true, false, false]}
+  and decl_name =
+    let tvar = newgenvar() in
+    {type_params = [tvar];
+     type_arity = 1;
+     type_kind = Type_abstract;
+     type_manifest = None;
+     type_variance = [true, false, false]}
+  and decl_no_bind =
+    let tvar = newgenvar() in
+    {type_params = [tvar]; 
+     type_arity = 1;
+     type_kind = Type_variant(["Nobind",[tvar]], Public);
+     type_manifest = None;
+     type_variance = [true, false, false]}
+  and decl_no_swap =
+    let tvar = newgenvar() in
+    {type_params = [tvar]; 
+     type_arity = 1;
+     type_kind = Type_variant(["Noswap",[tvar]], Public);
+     type_manifest = None;
+     type_variance = [true, false, false]}
+  and decl_custom_swap =
+    let tvar1 = newgenvar () in
+    let tvar2 = newgenvar () in
+    let tvar2_name = newgenty (Tconstr (path_name, [tvar2], ref Mnil)) in
+    let tvar2_list = newgenty (Tconstr (path_list, [tvar2_name], ref Mnil)) in
+    let ty = newgenty (Tarrow ("",
+                               newgenty (Ttuple [tvar2_list;
+                                                 tvar2_list;
+                                                 tvar1]),
+                               tvar1, Cok)) in
+    {type_params = [tvar1; tvar2];
+     type_arity = 0;
+     type_kind = Type_variant(["Custom_swap",[tvar1; ty]], Public);
+     type_manifest = None;
+     type_variance = [true, false, false;
+                      true, false, false]}
   in
 
   add_exception ident_match_failure
@@ -166,6 +215,10 @@
   add_type ident_int32 decl_abstr (
   add_type ident_nativeint decl_abstr (
   add_type ident_lazy_t decl_lazy_t (
+  add_type ident_no_bind decl_no_bind (
+  add_type ident_no_swap decl_no_swap (
+  add_type ident_custom_swap decl_custom_swap (
+  add_type ident_name decl_name (
   add_type ident_option decl_option (
   add_type ident_format4 decl_format4 (
   add_type ident_list decl_list (
@@ -177,7 +230,7 @@
   add_type ident_string decl_abstr (
   add_type ident_char decl_abstr (
   add_type ident_int decl_abstr (
-    empty_env)))))))))))))))))))))))))))
+    empty_env)))))))))))))))))))))))))))))))
 
 let builtin_values =
   List.map (fun id -> Ident.make_global id; (Ident.name id, id))
--- ocaml-3.08.2/typing/predef.mli	2003-07-05 12:13:24.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/predef.mli	2005-01-11 20:05:32.000000000 +0000
@@ -30,6 +30,10 @@
 val type_int32: type_expr
 val type_int64: type_expr
 val type_lazy_t: type_expr -> type_expr
+val type_name: type_expr -> type_expr
+val type_no_bind: type_expr -> type_expr
+val type_no_swap: type_expr -> type_expr
+val type_custom_swap: type_expr -> type_expr
 
 val path_int: Path.t
 val path_char: Path.t
@@ -46,6 +50,10 @@
 val path_int32: Path.t
 val path_int64: Path.t
 val path_lazy_t: Path.t
+val path_name: Path.t
+val path_no_bind: Path.t
+val path_no_swap: Path.t
+val path_custom_swap: Path.t
 
 val path_match_failure: Path.t
 val path_assert_failure : Path.t
--- ocaml-3.08.2/typing/printtyp.ml	2004-07-07 02:45:21.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/printtyp.ml	2005-01-10 14:06:36.000000000 +0000
@@ -116,6 +116,8 @@
         (safe_commu_repr [] c)
   | Ttuple tl ->
       fprintf ppf "@[<1>Ttuple@,%a@]" raw_type_list tl
+  | Tabst (t1, t2) ->
+      fprintf ppf "Tabst(%a,%a)" raw_type t1 raw_type t2
   | Tconstr (p, tl, abbrev) ->
       fprintf ppf "@[<hov1>Tconstr(@,%a,@,%a,@,%a)@]" path p
         raw_type_list tl
@@ -276,6 +278,8 @@
         List.iter (fun t -> add_alias t) tyl;
         mark_loops_rec visited ty
     | Tunivar -> ()
+    | Tabst (ty1, ty2) ->
+        mark_loops_rec visited ty1; mark_loops_rec visited ty2
 
 let mark_loops ty =
   normalize_type Env.empty ty;
@@ -381,6 +385,8 @@
         end
     | Tunivar ->
         Otyp_var (false, name_of_type ty)
+    | Tabst (ty1, ty2) ->
+        Otyp_abst (tree_of_typexp sch ty1, tree_of_typexp sch ty2)
   in
   if List.memq px !delayed then delayed := List.filter ((!=) px) !delayed;
   if is_aliased px && ty.desc <> Tvar && ty.desc <> Tunivar then begin
--- ocaml-3.08.2/typing/typecore.ml	2004-06-21 21:36:20.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/typecore.ml	2005-01-10 14:06:36.000000000 +0000
@@ -58,6 +58,7 @@
   | Not_a_variant_type of Longident.t
   | Incoherent_label_order
   | Less_general of string * (type_expr * type_expr) list
+  | Not_a_bindable_type of Longident.t
 
 exception Error of Location.t * error
 
@@ -283,6 +284,8 @@
       end;
       ty1
   | Tpat_any | Tpat_var _ | Tpat_constant _ | Tpat_array _ -> p.pat_type
+  | Tpat_abst (p1, p2) ->
+      newty (Tabst (build_as_type env p1, build_as_type env p2))
 
 let build_or_pat env loc lid =
   let path, decl =
@@ -495,6 +498,13 @@
       p
   | Ppat_type lid ->
       build_or_pat env sp.ppat_loc lid
+  | Ppat_abst (sp1, sp2) ->
+      let p1 = type_pat env sp1 in
+      let p2 = type_pat env sp2 in
+      { pat_desc = Tpat_abst (p1, p2);
+        pat_loc = sp.ppat_loc;
+        pat_type = newty (Tabst (p1.pat_type, p2.pat_type));
+        pat_env = env }
 
 let get_ref r =
   let v = !r in r := []; v
@@ -604,6 +614,7 @@
       true
   (* Note: nonexpansive only means no _observable_ side effects *)
   | Texp_lazy e -> is_nonexpansive e
+  | Texp_abst (e1, e2) -> is_nonexpansive e1 && is_nonexpansive e2
   | Texp_object ({cl_field=fields}, {cty_vars=vars}, _) ->
       let count = ref 0 in
       List.for_all
@@ -761,6 +772,9 @@
         with Unify trace ->
           raise(Error(sexp.pexp_loc, Expr_type_clash trace))
       end
+  | Pexp_abst (e1, e2) ->
+      newty (Tabst (type_approx env e1, type_approx env e2))
+  | Pexp_swap (_, _, e) -> type_approx env e
   | _ -> newvar ()
 
 (* List labels in a function type, and whether return type is a variable *)
@@ -1362,6 +1376,52 @@
       }
   | Pexp_poly _ ->
       assert false
+  | Pexp_abst (sexp1, sexp2) ->
+      let exp1 = type_exp env sexp1 in
+      let exp2 = type_exp env sexp2 in
+      { exp_desc = Texp_abst (exp1, exp2);
+        exp_loc = sexp.pexp_loc;
+        exp_type = newty (Tabst (exp1.exp_type, exp2.exp_type));
+        exp_env = env }
+  | Pexp_swap (sexp1, sexp2, sexp_body) ->
+      let exp1 =
+          type_expect env sexp1 (instance (Predef.type_name (newvar ()))) in
+      let exp2 = type_expect env sexp2 exp1.exp_type in
+      let exp_body = type_exp env sexp_body in
+      { exp_desc = Texp_swap (exp1, exp2, exp_body);
+        exp_loc = sexp.pexp_loc;
+        exp_type = exp_body.exp_type;
+        exp_env = env }
+  | Pexp_fresh ->
+      { exp_desc = Texp_fresh;
+        exp_loc = sexp.pexp_loc;
+        exp_type = instance (Predef.type_name (newvar ()));
+        exp_env = env }
+  | Pexp_freshfor (sexp1, sexp2) ->
+      let exp1 =
+        type_expect env sexp1 (instance (Predef.type_name (newvar ()))) in
+      let exp2 = type_exp env sexp2 in
+      { exp_desc = Texp_freshfor (exp1, exp2);
+        exp_loc = sexp.pexp_loc;
+        exp_type = instance Predef.type_bool;
+        exp_env = env }
+  | Pexp_customswap (sexp1, sexp2) ->
+      (* 'a name *)
+      let alpha_name_ty = instance (Predef.type_name (newvar ())) in
+      (* 'a name list *)
+      let list_ty = instance (Predef.type_list alpha_name_ty) in
+      (* 'b *)
+      let value_ty = newvar () in
+      (* 'a name list * 'a name list * 'b *)
+      let swap_fn_arg_ty = newty (Ttuple [list_ty; list_ty; value_ty]) in
+      (* 'a name list * 'a name list * 'b -> 'b *)
+      let closure_ty = newty (Tarrow ("", swap_fn_arg_ty, value_ty, Cok)) in
+      let exp1 = type_expect env sexp1 closure_ty in
+      let exp2 = type_expect env sexp2 value_ty in
+      { exp_desc = Texp_customswap (exp1, exp2);
+        exp_loc = sexp.pexp_loc;
+	exp_type = value_ty;
+	exp_env = env }
 
 and type_argument env sarg ty_expected' =
   (* ty_expected' may be generic *)
@@ -2039,3 +2099,6 @@
       report_unification_error ppf trace
         (fun ppf -> fprintf ppf "This %s has type" kind)
         (fun ppf -> fprintf ppf "which is less general than")
+  | Not_a_bindable_type lid ->
+      fprintf ppf "The type %a@ is not a type of bindable names" longident lid
+
--- ocaml-3.08.2/typing/typecore.mli	2003-11-25 09:20:42.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/typecore.mli	2005-01-10 14:06:36.000000000 +0000
@@ -95,6 +95,7 @@
   | Not_a_variant_type of Longident.t
   | Incoherent_label_order
   | Less_general of string * (type_expr * type_expr) list
+  | Not_a_bindable_type of Longident.t
 
 exception Error of Location.t * error
 
--- ocaml-3.08.2/typing/typedecl.ml	2003-11-07 00:19:08.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/typedecl.ml	2005-01-10 14:06:36.000000000 +0000
@@ -405,6 +405,9 @@
             (Btype.row_repr row).row_fields
       | Tpoly (ty, _) ->
           compute_same ty
+      | Tabst (ty1, ty2) ->
+          compute_same ty1;
+          compute_same ty2
       | Tvar | Tnil | Tlink _ | Tunivar -> ()
     end
   in
--- ocaml-3.08.2/typing/typedtree.ml	2003-11-25 09:20:43.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/typedtree.ml	2005-01-10 14:06:36.000000000 +0000
@@ -37,6 +37,7 @@
   | Tpat_record of (label_description * pattern) list
   | Tpat_array of pattern list
   | Tpat_or of pattern * pattern * Path.t option
+  | Tpat_abst of pattern * pattern
 
 type partial = Partial | Total
 type optional = Required | Optional
@@ -77,6 +78,11 @@
   | Texp_assert of expression
   | Texp_assertfalse
   | Texp_lazy of expression
+  | Texp_abst of expression * expression
+  | Texp_swap of expression * expression * expression
+  | Texp_fresh
+  | Texp_freshfor of expression * expression
+  | Texp_customswap of expression * expression
   | Texp_object of class_structure * class_signature * string list
 
 and meth =
@@ -164,6 +170,7 @@
   | Tpat_any
   | Tpat_var _
   | Tpat_constant _ -> ()
+  | Tpat_abst (p1, p2) -> f p1; f p2
 
 let map_pattern_desc f d =
   match d with
@@ -185,6 +192,7 @@
   | Tpat_constant _
   | Tpat_any
   | Tpat_variant (_,None,_) -> d
+  | Tpat_abst (p1, p2) -> Tpat_abst (f p1, f p2)
 
 (* List the identifiers bound by a pattern or a let *)
 
--- ocaml-3.08.2/typing/typedtree.mli	2003-11-25 09:20:43.000000000 +0000
+++ fresh-ocaml-3.08.2/typing/typedtree.mli	2005-01-10 14:06:36.000000000 +0000
@@ -36,6 +36,7 @@
   | Tpat_record of (label_description * pattern) list
   | Tpat_array of pattern list
   | Tpat_or of pattern * pattern * Path.t option
+  | Tpat_abst of pattern * pattern
 
 type partial = Partial | Total
 type optional = Required | Optional
@@ -76,6 +77,11 @@
   | Texp_assert of expression
   | Texp_assertfalse
   | Texp_lazy of expression
+  | Texp_abst of expression * expression
+  | Texp_swap of expression * expression * expression
+  | Texp_fresh
+  | Texp_freshfor of expression * expression
+  | Texp_customswap of expression * expression
   | Texp_object of class_structure * class_signature * string list
 
 and meth =
--- ocaml-3.08.2/typing/types.ml	2004-06-12 09:55:49.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/types.ml	2005-01-10 14:06:36.000000000 +0000
@@ -37,6 +37,7 @@
   | Tvariant of row_desc
   | Tunivar
   | Tpoly of type_expr * type_expr list
+  | Tabst of type_expr * type_expr
 
 and row_desc =
     { row_fields: (label * row_field) list;
--- ocaml-3.08.2/typing/types.mli	2004-06-12 09:55:49.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/types.mli	2005-01-10 14:06:36.000000000 +0000
@@ -36,6 +36,7 @@
   | Tvariant of row_desc
   | Tunivar
   | Tpoly of type_expr * type_expr list
+  | Tabst of type_expr * type_expr
 
 and row_desc =
     { row_fields: (label * row_field) list;
--- ocaml-3.08.2/typing/typetexp.ml	2003-06-30 09:04:42.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/typetexp.ml	2005-01-10 14:06:36.000000000 +0000
@@ -25,6 +25,7 @@
     Unbound_type_variable of string
   | Unbound_type_constructor of Longident.t
   | Unbound_type_constructor_2 of Path.t
+  | Unbound_bindable_type of Longident.t
   | Type_arity_mismatch of Longident.t * int * int
   | Bound_type_variable of string
   | Recursive_type
@@ -440,6 +441,9 @@
       let ty' = Btype.newgenty (Tpoly(ty, List.rev ty_list)) in
       unify_var env (newvar()) ty';
       ty'
+   | Ptyp_abst (t, t') ->
+       newty (Tabst (transl_type env policy t,
+                     transl_type env policy t'))
 
 and transl_fields env policy =
   function
@@ -595,3 +599,6 @@
         (if v.desc = Tvar then "it escapes this scope" else
          if v.desc = Tunivar then "it is aliased to another variable"
          else "it is not a variable")
+  | Unbound_bindable_type lid ->
+      fprintf ppf "Unbound type of bindable names `%a'" longident lid
+
--- ocaml-3.08.2/typing/typetexp.mli	2003-05-19 10:21:17.000000000 +0100
+++ fresh-ocaml-3.08.2/typing/typetexp.mli	2005-01-10 14:06:36.000000000 +0000
@@ -40,6 +40,7 @@
     Unbound_type_variable of string
   | Unbound_type_constructor of Longident.t
   | Unbound_type_constructor_2 of Path.t
+  | Unbound_bindable_type of Longident.t
   | Type_arity_mismatch of Longident.t * int * int
   | Bound_type_variable of string
   | Recursive_type
--- ocaml-3.08.2/utils/config.mlp	2004-06-12 09:55:49.000000000 +0100
+++ fresh-ocaml-3.08.2/utils/config.mlp	2005-01-11 20:01:54.000000000 +0000
@@ -52,7 +52,7 @@
 
 let interface_suffix = ref ".mli"
 
-let max_tag = 245
+let max_tag = 240
 (* This is normally the same as in obj.ml, but we have to define it
    separately because it can differ when we're in the middle of a
    bootstrapping phase. *)
--- ocaml-3.08.2/yacc/Makefile	2000-08-10 10:58:08.000000000 +0100
+++ fresh-ocaml-3.08.2/yacc/Makefile	2005-01-10 14:06:36.000000000 +0000
@@ -22,13 +22,13 @@
 OBJS= closure.o error.o lalr.o lr0.o main.o mkpar.o output.o reader.o \
   skeleton.o symtab.o verbose.o warshall.o
 
-all: ocamlyacc$(EXE)
+all: fresh-ocamlyacc$(EXE)
 
-ocamlyacc$(EXE): $(OBJS)
-	$(CC) $(CFLAGS) $(CCLINKFLAGS) -o ocamlyacc $(OBJS)
+fresh-ocamlyacc$(EXE): $(OBJS)
+	$(CC) $(CFLAGS) $(CCLINKFLAGS) -o fresh-ocamlyacc $(OBJS)
 
 clean:
-	rm -f *.o ocamlyacc$(EXE) *~
+	rm -f *.o fresh-ocamlyacc$(EXE) *~
 
 depend:
 
