1. camlspotter
  2. mutated_ocaml

Commits

camlspotter  committed af504eb

removed ocamlspot part

  • Participants
  • Parent commits f0def12
  • Branches gcaml

Comments (0)

Files changed (144)

File .depend

View file
  • Ignore whitespace
 typing/primitive.cmi: 
 typing/printtyp.cmi: typing/types.cmi typing/path.cmi typing/outcometree.cmi \
     parsing/longident.cmi typing/ident.cmi 
-typing/spot.cmi: typing/types.cmi typing/typedtree.cmi typing/path.cmi \
-    parsing/location.cmi typing/ident.cmi 
 typing/stypes.cmi: typing/typedtree.cmi parsing/location.cmi typing/annot.cmi 
 typing/subst.cmi: typing/types.cmi typing/path.cmi typing/ident.cmi 
 typing/typeclass.cmi: typing/types.cmi typing/typedtree.cmi \
     parsing/asttypes.cmi typing/datarepr.cmi 
 typing/dispatch.cmo: typing/types.cmi typing/typedtree.cmi \
     typing/printtyp.cmi typing/path.cmi parsing/parsetree.cmi \
-    typing/mtype.cmi utils/misc.cmi parsing/location.cmi typing/ident.cmi \
-    typing/env.cmi typing/ctype.cmi typing/btype.cmi parsing/asttypes.cmi \
-    typing/dispatch.cmi 
+    typing/mtype.cmi utils/misc.cmi parsing/longident.cmi \
+    parsing/location.cmi typing/ident.cmi typing/env.cmi typing/ctype.cmi \
+    typing/btype.cmi parsing/asttypes.cmi typing/dispatch.cmi 
 typing/dispatch.cmx: typing/types.cmx typing/typedtree.cmx \
     typing/printtyp.cmx typing/path.cmx parsing/parsetree.cmi \
-    typing/mtype.cmx utils/misc.cmx parsing/location.cmx typing/ident.cmx \
-    typing/env.cmx typing/ctype.cmx typing/btype.cmx parsing/asttypes.cmi \
-    typing/dispatch.cmi 
+    typing/mtype.cmx utils/misc.cmx parsing/longident.cmx \
+    parsing/location.cmx typing/ident.cmx typing/env.cmx typing/ctype.cmx \
+    typing/btype.cmx parsing/asttypes.cmi typing/dispatch.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 \
     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/spot.cmo: typing/types.cmi typing/typedtree.cmi typing/printtyp.cmi \
-    typing/path.cmi typing/mtype.cmi parsing/location.cmi typing/ident.cmi \
-    typing/ctype.cmi utils/config.cmi utils/clflags.cmi typing/spot.cmi 
-typing/spot.cmx: typing/types.cmx typing/typedtree.cmx typing/printtyp.cmx \
-    typing/path.cmx typing/mtype.cmx parsing/location.cmx typing/ident.cmx \
-    typing/ctype.cmx utils/config.cmx utils/clflags.cmx typing/spot.cmi 
 typing/stypes.cmo: typing/typedtree.cmi typing/printtyp.cmi \
     parsing/location.cmi utils/clflags.cmi typing/annot.cmi typing/stypes.cmi 
 typing/stypes.cmx: typing/typedtree.cmx typing/printtyp.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/spot.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.cmi typing/btype.cmi \
-    parsing/asttypes.cmi typing/typeclass.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.cmi \
+    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/spot.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/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/spot.cmi \
-    typing/printtyp.cmi typing/primitive.cmi typing/predef.cmi \
-    typing/path.cmi parsing/parsetree.cmi typing/parmatch.cmi utils/misc.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/dispatch.cmi typing/ctype.cmi utils/clflags.cmi \
     typing/btype.cmi parsing/asttypes.cmi typing/annot.cmi \
     typing/typecore.cmi 
 typing/typecore.cmx: utils/warnings.cmx typing/typetexp.cmx typing/types.cmx \
-    typing/typedtree.cmx typing/stypes.cmx typing/spot.cmx \
-    typing/printtyp.cmx typing/primitive.cmx typing/predef.cmx \
-    typing/path.cmx parsing/parsetree.cmi typing/parmatch.cmx utils/misc.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/dispatch.cmx typing/ctype.cmx utils/clflags.cmx \
     typing/btype.cmx parsing/asttypes.cmi typing/annot.cmi \
     typing/typecore.cmi 
 typing/typedecl.cmo: typing/typetexp.cmi typing/types.cmi \
-    typing/typedtree.cmi typing/subst.cmi typing/spot.cmi typing/printtyp.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.cmi \
     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/spot.cmx typing/printtyp.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 \
     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/spot.cmi typing/printtyp.cmi typing/path.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 \
     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/spot.cmx typing/printtyp.cmx typing/path.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 \
 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/spot.cmi typing/printtyp.cmi typing/path.cmi parsing/parsetree.cmi \
-    utils/misc.cmi parsing/longident.cmi parsing/location.cmi typing/env.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 utils/clflags.cmi typing/btype.cmi typing/typetexp.cmi 
 typing/typetexp.cmx: utils/warnings.cmx typing/types.cmx utils/tbl.cmx \
-    typing/spot.cmx typing/printtyp.cmx typing/path.cmx parsing/parsetree.cmi \
-    utils/misc.cmx parsing/longident.cmx parsing/location.cmx typing/env.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 utils/clflags.cmx typing/btype.cmx typing/typetexp.cmi 
 typing/unused_var.cmo: utils/warnings.cmi parsing/parsetree.cmi \
     parsing/longident.cmi parsing/location.cmi parsing/asttypes.cmi \
     utils/clflags.cmx utils/ccomp.cmx bytecomp/bytesections.cmx \
     bytecomp/bytelink.cmi 
 bytecomp/bytepackager.cmo: typing/typemod.cmi bytecomp/translmod.cmi \
-    typing/subst.cmi typing/spot.cmi typing/path.cmi utils/misc.cmi \
-    bytecomp/instruct.cmi typing/ident.cmi typing/env.cmi \
-    bytecomp/emitcode.cmi utils/config.cmi bytecomp/cmo_format.cmi \
-    utils/clflags.cmi bytecomp/bytelink.cmi bytecomp/bytegen.cmi \
-    bytecomp/bytepackager.cmi 
+    typing/subst.cmi typing/path.cmi utils/misc.cmi bytecomp/instruct.cmi \
+    typing/ident.cmi typing/env.cmi bytecomp/emitcode.cmi utils/config.cmi \
+    bytecomp/cmo_format.cmi utils/clflags.cmi bytecomp/bytelink.cmi \
+    bytecomp/bytegen.cmi bytecomp/bytepackager.cmi 
 bytecomp/bytepackager.cmx: typing/typemod.cmx bytecomp/translmod.cmx \
-    typing/subst.cmx typing/spot.cmx typing/path.cmx utils/misc.cmx \
-    bytecomp/instruct.cmx typing/ident.cmx typing/env.cmx \
-    bytecomp/emitcode.cmx utils/config.cmx bytecomp/cmo_format.cmi \
-    utils/clflags.cmx bytecomp/bytelink.cmx bytecomp/bytegen.cmx \
-    bytecomp/bytepackager.cmi 
+    typing/subst.cmx typing/path.cmx utils/misc.cmx bytecomp/instruct.cmx \
+    typing/ident.cmx typing/env.cmx bytecomp/emitcode.cmx utils/config.cmx \
+    bytecomp/cmo_format.cmi 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/misc.cmi utils/config.cmi bytecomp/dll.cmi 
 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 utils/config.cmi 
-asmcomp/arch.cmx: utils/misc.cmx utils/config.cmx 
+asmcomp/arch.cmo: 
+asmcomp/arch.cmx: 
 asmcomp/asmgen.cmo: bytecomp/translmod.cmi 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/cmmgen.cmx utils/clflags.cmx utils/ccomp.cmx asmcomp/asmgen.cmx \
     asmcomp/asmlink.cmi 
 asmcomp/asmpackager.cmo: typing/typemod.cmi bytecomp/translmod.cmi \
-    typing/spot.cmi utils/misc.cmi parsing/location.cmi bytecomp/lambda.cmi \
-    typing/ident.cmi typing/env.cmi utils/config.cmi asmcomp/compilenv.cmi \
-    utils/clflags.cmi asmcomp/clambda.cmi utils/ccomp.cmi asmcomp/asmlink.cmi \
+    utils/misc.cmi parsing/location.cmi bytecomp/lambda.cmi typing/ident.cmi \
+    typing/env.cmi utils/config.cmi asmcomp/compilenv.cmi utils/clflags.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 \
-    typing/spot.cmx utils/misc.cmx parsing/location.cmx bytecomp/lambda.cmx \
-    typing/ident.cmx typing/env.cmx utils/config.cmx asmcomp/compilenv.cmx \
-    utils/clflags.cmx asmcomp/clambda.cmx utils/ccomp.cmx asmcomp/asmlink.cmx \
+    utils/misc.cmx parsing/location.cmx bytecomp/lambda.cmx typing/ident.cmx \
+    typing/env.cmx utils/config.cmx asmcomp/compilenv.cmx utils/clflags.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 \
     asmcomp/debuginfo.cmi parsing/asttypes.cmi asmcomp/clambda.cmi 
 asmcomp/debuginfo.cmx: parsing/location.cmx bytecomp/lambda.cmx \
     asmcomp/debuginfo.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 asmcomp/debuginfo.cmi utils/config.cmi \
-    asmcomp/compilenv.cmi asmcomp/cmm.cmi utils/clflags.cmi asmcomp/arch.cmo \
-    asmcomp/emit.cmi 
+    asmcomp/mach.cmi asmcomp/linearize.cmi asmcomp/emitaux.cmi \
+    asmcomp/debuginfo.cmi utils/config.cmi asmcomp/compilenv.cmi \
+    asmcomp/cmm.cmi utils/clflags.cmi 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 asmcomp/debuginfo.cmx utils/config.cmx \
-    asmcomp/compilenv.cmx asmcomp/cmm.cmx utils/clflags.cmx asmcomp/arch.cmx \
-    asmcomp/emit.cmi 
+    asmcomp/mach.cmx asmcomp/linearize.cmx asmcomp/emitaux.cmx \
+    asmcomp/debuginfo.cmx utils/config.cmx asmcomp/compilenv.cmx \
+    asmcomp/cmm.cmx utils/clflags.cmx asmcomp/arch.cmx asmcomp/emit.cmi 
 asmcomp/emitaux.cmo: asmcomp/reg.cmi asmcomp/linearize.cmi \
     asmcomp/debuginfo.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
     asmcomp/emitaux.cmi 
     asmcomp/mach.cmx asmcomp/debuginfo.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.cmi utils/ccomp.cmi \
-    asmcomp/arch.cmo asmcomp/proc.cmi 
+    utils/config.cmi asmcomp/cmm.cmi 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 
+    utils/config.cmx asmcomp/cmm.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/reg.cmi asmcomp/mach.cmi \
-    asmcomp/cmm.cmi asmcomp/arch.cmo asmcomp/reload.cmi 
+    asmcomp/cmm.cmi utils/clflags.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/cmm.cmx utils/clflags.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/reg.cmx utils/misc.cmx asmcomp/mach.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/debuginfo.cmi asmcomp/cmm.cmi \
-    asmcomp/arch.cmo asmcomp/selection.cmi 
+    utils/clflags.cmi asmcomp/arch.cmo asmcomp/selection.cmi 
 asmcomp/selection.cmx: asmcomp/selectgen.cmx asmcomp/reg.cmx asmcomp/proc.cmx \
     utils/misc.cmx asmcomp/mach.cmx asmcomp/debuginfo.cmx asmcomp/cmm.cmx \
-    asmcomp/arch.cmx asmcomp/selection.cmi 
+    utils/clflags.cmx asmcomp/arch.cmx asmcomp/selection.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 \
 driver/pparse.cmi: 
 driver/compile.cmo: utils/warnings.cmi typing/unused_var.cmi \
     typing/typemod.cmi typing/typedtree.cmi bytecomp/translmod.cmi \
-    typing/stypes.cmi typing/spot.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 \
-    parsing/location.cmi typing/ident.cmi typing/env.cmi \
-    bytecomp/emitcode.cmi utils/config.cmi utils/clflags.cmi utils/ccomp.cmi \
-    bytecomp/bytegen.cmi driver/compile.cmi 
+    typing/stypes.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 parsing/location.cmi \
+    typing/ident.cmi typing/env.cmi bytecomp/emitcode.cmi utils/config.cmi \
+    utils/clflags.cmi utils/ccomp.cmi bytecomp/bytegen.cmi driver/compile.cmi 
 driver/compile.cmx: utils/warnings.cmx typing/unused_var.cmx \
     typing/typemod.cmx typing/typedtree.cmx bytecomp/translmod.cmx \
-    typing/stypes.cmx typing/spot.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 \
-    parsing/location.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 
+    typing/stypes.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 parsing/location.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 \
 driver/main_args.cmx: driver/main_args.cmi 
 driver/optcompile.cmo: utils/warnings.cmi typing/unused_var.cmi \
     typing/typemod.cmi typing/typedtree.cmi bytecomp/translmod.cmi \
-    typing/stypes.cmi typing/spot.cmi bytecomp/simplif.cmi \
-    typing/printtyp.cmi bytecomp/printlambda.cmi parsing/printast.cmi \
-    driver/pparse.cmi parsing/parse.cmi utils/misc.cmi parsing/location.cmi \
-    typing/ident.cmi typing/env.cmi utils/config.cmi asmcomp/compilenv.cmi \
-    utils/clflags.cmi utils/ccomp.cmi asmcomp/asmgen.cmi \
-    driver/optcompile.cmi 
+    typing/stypes.cmi bytecomp/simplif.cmi typing/printtyp.cmi \
+    bytecomp/printlambda.cmi parsing/printast.cmi driver/pparse.cmi \
+    parsing/parse.cmi utils/misc.cmi parsing/location.cmi typing/ident.cmi \
+    typing/env.cmi utils/config.cmi asmcomp/compilenv.cmi utils/clflags.cmi \
+    utils/ccomp.cmi asmcomp/asmgen.cmi driver/optcompile.cmi 
 driver/optcompile.cmx: utils/warnings.cmx typing/unused_var.cmx \
     typing/typemod.cmx typing/typedtree.cmx bytecomp/translmod.cmx \
-    typing/stypes.cmx typing/spot.cmx bytecomp/simplif.cmx \
-    typing/printtyp.cmx bytecomp/printlambda.cmx parsing/printast.cmx \
-    driver/pparse.cmx parsing/parse.cmx utils/misc.cmx parsing/location.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 
+    typing/stypes.cmx bytecomp/simplif.cmx typing/printtyp.cmx \
+    bytecomp/printlambda.cmx parsing/printast.cmx driver/pparse.cmx \
+    parsing/parse.cmx utils/misc.cmx parsing/location.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 \

File .hgtags

View file
  • Ignore whitespace
 10f98a71c87760184281b6e695b323f2d64968c9 ocaml3111
 ae6728f0e0439d38ee8522c4d7386b5f742ec9d1 ocaml3112
 682f910ff10a427a3a4b9ef2f207262751b8abf0 ocaml3112
-8d6b593f5cf22a2289403e41e37344dc3a00f4d2 ocamlspotter1.1rc2
+682f910ff10a427a3a4b9ef2f207262751b8abf0 ocaml3112
+f520050fb285ce7a85ca4f3612fa7b61248dd494 ocaml3112

File Makefile

View file
  • Ignore whitespace
 
 CAMLC=boot/ocamlrun boot/ocamlc -nostdlib -I boot
 CAMLOPT=boot/ocamlrun ./ocamlopt -nostdlib -I stdlib -I otherlibs/dynlink
-COMPFLAGS=-warn-error A $(INCLUDES) -annot
+COMPFLAGS=-warn-error A $(INCLUDES)
 LINKFLAGS=
 
 CAMLYACC=boot/ocamlyacc
   typing/datarepr.cmo typing/env.cmo \
   typing/typedtree.cmo typing/ctype.cmo \
   typing/printtyp.cmo typing/includeclass.cmo \
-  typing/mtype.cmo typing/spot.cmo typing/includecore.cmo \
+  typing/mtype.cmo typing/includecore.cmo \
   typing/includemod.cmo typing/parmatch.cmo \
   typing/typetexp.cmo typing/stypes.cmo typing/dispatch.cmo typing/typecore.cmo \
   typing/typedecl.cmo typing/typeclass.cmo \
 
 # Recompile the system using the bootstrap compiler
 all: runtime ocamlc ocamllex ocamlyacc ocamltools library ocaml \
-  otherlibraries ocamlbuild.byte camlp4out $(DEBUGGER) ocamldoc ocamlspot
+  otherlibraries ocamlbuild.byte camlp4out $(DEBUGGER) ocamldoc
 
 # Compile everything the first time
 world:
 opt.opt: checkstack runtime core ocaml opt-core ocamlc.opt otherlibraries \
          ocamlbuild.byte camlp4out $(DEBUGGER) ocamldoc ocamlopt.opt \
          otherlibrariesopt \
-         ocamllex.opt ocamltoolsopt.opt ocamlbuild.native camlp4opt \
-	 ocamldoc.opt ocamlspot.opt
+         ocamllex.opt ocamltoolsopt.opt ocamlbuild.native camlp4opt ocamldoc.opt
 
 # Installation
 install:
           (cd otherlibs/$$i; $(MAKE) install) || exit $$?; \
         done
 	cd ocamldoc; $(MAKE) install
-	cd ocamlspot; $(MAKE) install
 	if test -f ocamlopt; then $(MAKE) installopt; else :; fi
 	if test -f debugger/ocamldebug; then (cd debugger; $(MAKE) install); \
 	   else :; fi
 	cp ocamlopt $(BINDIR)/ocamlopt$(EXE)
 	cd stdlib; $(MAKE) installopt
 	cd ocamldoc; $(MAKE) installopt
-	cd ocamlspot; $(MAKE) installopt
 	for i in $(OTHERLIBRARIES); \
 	  do (cd otherlibs/$$i; $(MAKE) installopt) || exit $$?; done
 	if test -f ocamlc.opt; \
 alldepend::
 	cd ocamldoc && $(MAKE) depend
 
-# OCamlSpot
-
-ocamlspot: ocamlc ocamlyacc ocamllex otherlibraries
-	cd ocamlspot && $(MAKE) all
-
-ocamlspot.opt: ocamlc.opt ocamlyacc ocamllex
-	cd ocamlspot && $(MAKE) opt.opt
-
-partialclean::
-	cd ocamlspot && $(MAKE) clean
-
-alldepend::
-	cd ocamlspot && $(MAKE) depend
-
 # The extra libraries
 
 otherlibraries: ocamltools
 
 partialclean::
 	for d in utils parsing typing bytecomp asmcomp driver toplevel tools; \
-	  do rm -f $$d/*.cm[iox] $$d/*.annot $$d/*.sp*t $$d/*.[so] $$d/*~; done
+	  do rm -f $$d/*.cm[iox] $$d/*.annot $$d/*.[so] $$d/*~; done
 	rm -f *~
 
 depend: beforedepend
 .PHONY: coreboot defaultentry depend distclean install installopt
 .PHONY: library library-cross libraryopt ocamlbuild-mixed-boot
 .PHONY: ocamlbuild.byte ocamlbuild.native ocamldebugger ocamldoc
-.PHONY: ocamldoc.opt ocamlspot ocamlspot.opt ocamllex ocamllex.opt ocamltools ocamltools.opt
+.PHONY: ocamldoc.opt ocamllex ocamllex.opt ocamltools ocamltools.opt
 .PHONY: ocamlyacc opt-core opt opt.opt otherlibraries
 .PHONY: otherlibrariesopt package-macosx promote promote-cross
 .PHONY: restore runtime runtimeopt makeruntimeopt world world.opt

File _tags

View file
  • Ignore whitespace
 true: -traverse
 
 # Traverse only these directories
-<{bytecomp,driver,stdlib,tools,asmcomp,camlp4,ocamlbuild,toplevel,ocamldoc,typing,otherlibs,utils,debugger,lex,parsing,byterun,asmrun,ocamlspot}/**>: traverse
+<{bytecomp,driver,stdlib,tools,asmcomp,camlp4,ocamlbuild,toplevel,ocamldoc,typing,otherlibs,utils,debugger,lex,parsing,byterun,asmrun}/**>: traverse
 
 "boot" or "byterun" or "asmrun": not_hygienic
 

File asmcomp/asmpackager.ml

View file
  • Ignore whitespace
   Compilenv.reset ?packname:!Clflags.for_package targetname;
   try
     let coercion = Typemod.package_units files targetcmi targetname in
-    package_object_files ppf files targetcmx targetobj targetname coercion;
-    Spot.File.dump_package ~prefix ~source:(prefix ^ ".cmx") files
+    package_object_files ppf files targetcmx targetobj targetname coercion
   with x ->
     remove_file targetcmx; remove_file targetobj;
     raise x

File build/partial-install.sh

View file
  • Ignore whitespace
   mkdir -p $CAMLP4DIR/$dir
   installdir     \
     $dir/*.cm*   \
-    $dir/*.sp?t   \
     $dir/*.$O    \
     $CAMLP4DIR/$dir
 done

File bytecomp/bytepackager.ml

View file
  • Ignore whitespace
   let targetname = String.capitalize(Filename.basename prefix) in
   try
     let coercion = Typemod.package_units files targetcmi targetname in
-    package_object_files files targetfile targetname coercion;
-    Spot.File.dump_package ~prefix ~source:(prefix ^ ".cmo") files
+    package_object_files files targetfile targetname coercion
   with x ->
     remove_file targetfile; raise x
 

File bytecomp/translmod.ml

View file
  • Ignore whitespace
               transl_structure (List.rev ids @ fields) cc rootpath rem)
   | Tstr_cltype cl_list :: rem ->
       transl_structure fields cc rootpath rem
-  | Tstr_include(modl, ids, _sg) :: rem ->
+  | Tstr_include(modl, ids) :: rem ->
       let mid = Ident.create "include" in
       let rec rebind_idents pos newfields = function
         [] ->
                 transl_store (add_idents false ids subst) rem)
   | Tstr_cltype cl_list :: rem ->
       transl_store subst rem
-  | Tstr_include(modl, ids, _sg) :: rem ->
+  | Tstr_include(modl, ids) :: rem ->
       let mid = Ident.create "include" in
       let rec store_idents pos = function
         [] -> transl_store (add_idents true ids subst) rem
   | Tstr_class cl_list :: rem ->
       List.map (fun (i, _, _, _, _) -> i) cl_list @ defined_idents rem
   | Tstr_cltype cl_list :: rem -> defined_idents rem
-  | Tstr_include(modl, ids, _sg) :: rem -> ids @ defined_idents rem
+  | Tstr_include(modl, ids) :: rem -> ids @ defined_idents rem
 
 (* Transform a coercion and the list of value identifiers defined by
    a toplevel structure into a table [id -> (pos, coercion)],
                 cl_list)
   | Tstr_cltype cl_list ->
       lambda_unit
-  | Tstr_include(modl, ids, _sg) ->
+  | Tstr_include(modl, ids) ->
       let mid = Ident.create "include" in
       let rec set_idents pos = function
         [] ->

File camlp4/.ocamlspot

  • Ignore whitespace
-build_dir=../_build/camlp4/

File dcaml

  • Ignore whitespace
File contents unchanged.

File dcamlc

  • Ignore whitespace
File contents unchanged.

File debugger/Makefile.shared

View file
  • Ignore whitespace
 
 clean::
 	rm -f ocamldebug$(EXE)
-	rm -f *.cmo *.cmi *.annot *.sp*t
+	rm -f *.cmo *.cmi
 
 .SUFFIXES:
 .SUFFIXES: .ml .cmo .mli .cmi

File driver/compile.ml

View file
  • Ignore whitespace
   with Exit -> ()
 ;;
 
-let protect ~finally f arg =
-  try f arg; finally arg with e -> finally arg; raise e
-
 (* Compile a .mli file *)
 
 let interface ppf sourcefile outputprefix =
       Pparse.file ppf inputfile Parse.interface ast_intf_magic_number in
     if !Clflags.dump_parsetree then fprintf ppf "%a@." Printast.interface ast;
     let sg = Typemod.transl_signature (initial_env()) ast in
-    Spot.Top.record_signature sg;
     if !Clflags.print_types then
       fprintf std_formatter "%a@." Printtyp.signature
                                    (Typemod.simplify_signature sg);
     Pparse.remove_preprocessed_if_ast inputfile;
     raise e
 
-let interface ppf sourcefile outputprefix =
-  protect ~finally:(fun () ->  
-    Spot.File.dump ~source:(Some sourcefile) (outputprefix ^ ".spit"))
-    (fun () -> interface ppf sourcefile outputprefix)
-    ()
-
 (* Compile a .ml file *)
 
 let print_if ppf flag printer arg =
       Warnings.check_fatal ();
       close_out oc;
       Pparse.remove_preprocessed inputfile;
-      Stypes.dump (outputprefix ^ ".annot")
+      Stypes.dump (outputprefix ^ ".annot");
     with x ->
       close_out oc;
       remove_file objfile;
       raise x
   end
 
-let implementation ppf sourcefile outputprefix =
-  protect ~finally:(fun () ->
-    Spot.File.dump ~source:(Some sourcefile) (outputprefix ^ ".spot"))
-    (fun () -> implementation ppf sourcefile outputprefix) ()
-    
 let c_file name =
   Location.input_name := name;
   if Ccomp.compile_file name <> 0 then exit 2

File driver/ocamlcomp.sh.in

View file
  • Ignore whitespace
 
 topdir=`dirname $0`
 
-exec @compiler@ -nostdlib -I $topdir/stdlib -annot "$@"
+exec @compiler@ -nostdlib -I $topdir/stdlib "$@"

File driver/optcompile.ml

View file
  • Ignore whitespace
       Env.save_signature sg modulename (outputprefix ^ ".cmi");
     Pparse.remove_preprocessed inputfile;
     Stypes.dump (outputprefix ^ ".annot");
-    Spot.File.dump ~source:(Some sourcefile) (outputprefix ^ ".spit");
   with e ->
     Pparse.remove_preprocessed_if_ast inputfile;
     Stypes.dump (outputprefix ^ ".annot");
-    Spot.File.dump ~source:(Some sourcefile) (outputprefix ^ ".spit");
     raise e
 
 (* Compile a .ml file *)
     Warnings.check_fatal ();
     Pparse.remove_preprocessed inputfile;
     Stypes.dump (outputprefix ^ ".annot");
-    Spot.File.dump ~source:(Some sourcefile) (outputprefix ^ ".spot");
   with x ->
     remove_file objfile;
     remove_file cmxfile;
     Pparse.remove_preprocessed_if_ast inputfile;
     Stypes.dump (outputprefix ^ ".annot");
-    Spot.File.dump ~source:(Some sourcefile) (outputprefix ^ ".spot");
     raise x
 
 let c_file name =

File myocamlbuild.ml

View file
  • Ignore whitespace
     if mixed then
       let patt = String.concat ","
         ["asmcomp"; "bytecomp"; "debugger"; "driver";
-         "lex"; "ocamldoc"; "ocamlspot"; "otherlibs"; "parsing"; "stdlib"; "tools";
+         "lex"; "ocamldoc"; "otherlibs"; "parsing"; "stdlib"; "tools";
          "toplevel"; "typing"; "utils"]
       in Ocamlbuild_pack.Configuration.parse_string
            (sprintf "<{%s}/**>: not_hygienic, -traverse" patt)
 Pathname.define_context "parsing" ["parsing"; "utils"; "stdlib"];;
 Pathname.define_context "typing" ["typing"; "parsing"; "utils"; "stdlib"];;
 Pathname.define_context "ocamldoc" ["typing"; "parsing"; "utils"; "tools"; "bytecomp"; "stdlib"];;
-Pathname.define_context "ocamlspot" ["typing"; "parsing"; "utils"; "tools"; "bytecomp"; "stdlib"];;
 Pathname.define_context "bytecomp" ["bytecomp"; "parsing"; "typing"; "utils"; "stdlib"];;
 Pathname.define_context "tools" ["tools"; (* "toplevel"; *) "parsing"; "utils"; "driver"; "bytecomp"; "asmcomp"; "typing"; "stdlib"];;
 Pathname.define_context "toplevel" ["toplevel"; "parsing"; "typing"; "bytecomp"; "utils"; "driver"; "stdlib"];;

File ocamldoc/Makefile

View file
  • Ignore whitespace
 	$(OCAMLSRCDIR)/typing/oprint.cmo \
 	$(OCAMLSRCDIR)/typing/printtyp.cmo \
 	$(OCAMLSRCDIR)/typing/includecore.cmo \
+	$(OCAMLSRCDIR)/typing/typetexp.cmo \
 	$(OCAMLSRCDIR)/typing/typedtree.cmo \
 	$(OCAMLSRCDIR)/typing/parmatch.cmo \
 	$(OCAMLSRCDIR)/typing/stypes.cmo \
-	$(OCAMLSRCDIR)/typing/includeclass.cmo \
 	$(OCAMLSRCDIR)/typing/mtype.cmo \
-	$(OCAMLSRCDIR)/typing/spot.cmo \
-	$(OCAMLSRCDIR)/typing/typetexp.cmo \
-	$(OCAMLSRCDIR)/typing/typedecl.cmo \
 	$(OCAMLSRCDIR)/typing/dispatch.cmo \
 	$(OCAMLSRCDIR)/typing/typecore.cmo \
+	$(OCAMLSRCDIR)/typing/includeclass.cmo \
+	$(OCAMLSRCDIR)/typing/typedecl.cmo \
 	$(OCAMLSRCDIR)/typing/typeclass.cmo \
 	$(OCAMLSRCDIR)/typing/includemod.cmo \
 	$(OCAMLSRCDIR)/typing/typemod.cmo \
 clean:: dummy
 	@rm -f *~ \#*\#
 	@rm -f $(OCAMLDOC) $(OCAMLDOC_OPT) *.cma *.cmxa *.cmo *.cmi *.cmx *.a *.o
-	@rm -f *.annot *.sp*t
 	@rm -f odoc_parser.output odoc_text_parser.output
 	@rm -f odoc_lexer.ml odoc_text_lexer.ml odoc_see_lexer.ml odoc_ocamlhtml.ml
 	@rm -f odoc_parser.ml odoc_parser.mli odoc_text_parser.ml odoc_text_parser.mli

File ocamldoc/odoc_ast.ml

View file
  • Ignore whitespace
     let tt_get_included_module_list tt_structure =
       let f acc item =
         match item with
-          Typedtree.Tstr_include (mod_expr, _, _) ->
+          Typedtree.Tstr_include (mod_expr, _) ->
             acc @ [
                   { (* A VOIR : chercher dans les modules et les module types, avec quel env ? *)
                     im_name = tt_name_from_module_expr mod_expr ;

File ocamlspot/.depend

  • Ignore whitespace
-command.cmi: 
-treeset.cmi: xset.cmo 
-command.cmo: command.cmi 
-command.cmx: command.cmi 
-dotfile.cmo: 
-dotfile.cmx: 
-ocamlspot.cmo: utils.cmo ../typing/types.cmi treeset.cmi ../typing/spot.cmi \
-    ../typing/printtyp.cmi ../typing/predef.cmi ../typing/path.cmi \
-    ../typing/ident.cmi dotfile.cmo command.cmi ../typing/btype.cmi \
-    ../typing/annot.cmi 
-ocamlspot.cmx: utils.cmx ../typing/types.cmx treeset.cmx ../typing/spot.cmx \
-    ../typing/printtyp.cmx ../typing/predef.cmx ../typing/path.cmx \
-    ../typing/ident.cmx dotfile.cmx command.cmx ../typing/btype.cmx \
-    ../typing/annot.cmi 
-treeset.cmo: xset.cmo treeset.cmi 
-treeset.cmx: xset.cmx treeset.cmi 
-tst.cmo: 
-tst.cmx: 
-utils.cmo: 
-utils.cmx: 
-xset.cmo: 
-xset.cmx: 

File ocamlspot/BRAIN_DEAD_INSTALL.sh

  • Ignore whitespace
-#!/bin/sh
-# No warranty, no question. Just for brain-dead people.
-set -e
-svn checkout http://caml.inria.fr/svn/ocaml/release/3.11.2 .
-patch -p1 < compiler_patch.diff
-./configure
-make core coreboot world
-cp boot/myocamlbuild boot/myocamlbuild.boot
-make opt opt.opt
-echo ===================== congrats ======================
-echo Now you can type make intall
-echo Do not forget to install the elisp file, ocamlspot/ocamlspot.el
-echo and configure your .emacs

File ocamlspot/Bugs

  • Ignore whitespace
-- this will be filled with bugs YOU find and report to jun.furuse@gmail.com.

File ocamlspot/Changes

  • Ignore whitespace
-1.1
------
-
-Bug fix
-
-- if x.spot file was obsolete, ocamlspot searched x.spit file instead, 
-  which was not a correct behavior.
-- exceptions in pattern were not browsable.
-- ocamldoc recorded top structures.
-- fix for predefined exception
-
-New feature
-
-- added -n option which does not analyze definition position.
-- ocamlspot-type function is added for type query in ocamlspot.el
-- ocamlspot-use function is added for use query in ocamlspot.el
-- supports a new position format l<line>c<column in bytes> 
-- supports a new query file:kind:path
-- more spots are saved
-- Work around for ocamlbuild. If .ocamlspot file with the text build_dir=dirname
-  is placed in a directory $DIR, then spot files of source files under $DIR 
-  ex. $DIR/subdir/source.ml is searched in $DIR/dirname/subdir/. See an example
-  at camlp4/.ocamlspot
-
-
-ocamlspot.el
-* ocamlspot-path is now ocamlspot-command. Please fix your .emacs.
-- defcustom'ed and code clean-ups (thanks to Sam Steingold) 
-- various elisp bug fixes
-- multi-byte character support in emacs
-
-1.0
----
-
-Complete rewrite.
-
-beta3
------
-
-Clean-ups:
-- Annotation data type simplification
-
-Features:
-- Spot file version number is introduced
-- New browsables:
-    - Data type names to their type defs
-    - Module names to their defs (preliminary support)
-
-beta2p1
--------
-
-Features:
-- New browsables: variants and record labels to their type defs
-
-beta2:
-------
-
-Complete rewrite.
-
-Features:
-- Enhanced spot file search: if ocamlspot finds no .spot in the load paths 
-  but the corresponding symlinked .cmi, it also searches the .spot file 
-  in the linked directory. 
-
-beta1:
-------
-
-Clean-up and announce.
-
-alpha3:
--------
-
-Features:
-- File time stamp check
-- .spot file versioning
-
-alpha2:
--------
-
-Features:
-- Support spotting externals.
-- Enhanced elisp display
-- ocamlopt creates .annot and .spot too
-
-Performance:
-- Things are evaluated more lazily.
-
-Clean-up:
-- Less verbose messages.
-- Removed unnecessary files
-
-Bug-fixes:
-- Location order was mis-defined.
-
-alpha1:
--------
-
-The first release
-

File ocamlspot/INSTALL-ocamlspot.txt

  • Ignore whitespace
-0. If you have no time to read the following, just try the script in the package:
-  
-    $ ./BRAIN_DEAD_INSTALL.sh
-
-  It will clone the official 3.11.2 source in the current directory, 
-  then apply the patch, and compile with the default configuration. 
-  Jump to 8 for the emacs lisp installation.
-
-1. Ok, you are not brain dead. Download OCaml compiler version 3.11.2.
-
-  - grab it from http://caml.inria.fr/pub/distrib/ocaml-3.11/ocaml-3.11.2.tar.gz
-  - You can also use the SVN version
-    ( svn checkout http://caml.inria.fr/svn/ocaml/release/3.11.2 )
-
-2. Extract the compiler source.
-
-  - tar zxvf ocaml-3.11.2.tar.gz
-  - cd ocaml-3.11.2                   # do not forget this
-
-3. Extract ocamlspot.tgz and Apply the patch
-
-  - tar zxvf ocamlspotter-1.1.tgz
-  - mv ocamlspotter-1.1/* .
-  - patch -p1 < compiler_patch.diff
-
-  Check your patched source tree. It should have ocamlspot directory with
-  the original files like INSTALL, LICENSE and VERSION.
-
-4. Build a bytecode compiler
-
-  - ./configure
-  - make core coreboot
-  - make world
-
-5. Manual ocamlbuild bootstrap:
-
-   Do not forget the following after make world:
- 
-  - cp boot/myocamlbuild boot/myocamlbuild.boot
-
-6. Build native code compilers
-
-  - make opt
-  - make opt.opt
-
-7. Install it
-
-  - make install
-
-8. Emacs interface
-
-  Write the following into your .emacs:
-
-  ; load-path
-  (setq load-path (cons "WHERE-YOU-HAVE-INSTALLED-THE-ELISP" load-path))
- 
-  ; set the path of the ocamlspot binary
-  (setq ocamlspot-path "WHERE-YOU-HAVE-INSTALLED-THE-BINARIES/ocamlspot")
- 
-  ; autoload
-  (autoload 'ocamlspot-query "ocamlspot" "OCamlSpot")
- 
-  ; tuareg mode hook (use caml-mode-hook instead if you use caml-mode)
-    (add-hook 'tuareg-mode-hook 
-    	  '(lambda ()
-  	     (local-set-key "\C-c;" 'ocamlspot-query)
-  	     (local-set-key "\C-c\C-t" 'ocamlspot-type)
-             (local-set-key "\C-c\C-y" 'ocamlspot-type-and-copy)
-  	     (local-set-key "\C-c\C-u" 'ocamlspot-use)
-  	     (local-set-key "\C-ct" 'caml-types-show-type)))
- 
-9. How to use
-
-  Compiler your ML project by this patched compiler with -annot option 
-  to create .spot files. Open one of the source files in Emacs and place 
-  the cursor at the name whose definition is in question. Type C-c; will 
-  show you the defintion.
-
-10. bug report
-
-  Please report bugs to jun.furuse at gmail.

File ocamlspot/LICENSE

  • Ignore whitespace
-In the following, "the Library" refers to all files marked "Copyright
-Jun FURUSE" in this directory.
-
-and "the Patch" refers to the file named "ocamldpot.diff" in this directory.
-
-The Patch is distributed under the terms of the Q Public License
-version 1.0 with a change to choice of law (included below), following
-the license of the patch target, OCaml compiler, copyrighted INRIA.
-
-The Library is distributed under the terms of the GNU Library General
-Public License version 2 (included below).
-
-As a special exception to the Q Public Licence, you may develop
-application programs, reusable components and other software items
-that link with the original or modified versions of the Compiler
-and are not made available to the general public, without any of the
-additional requirements listed in clause 6c of the Q Public licence.
-
-As a special exception to the GNU Library General Public License, you
-may link, statically or dynamically, a "work that uses the Library"
-with a publicly distributed version of the Library to produce an
-executable file containing portions of the Library, and distribute
-that executable file under terms of your choice, without any of the
-additional requirements listed in clause 6 of the GNU Library General
-Public License.  By "a publicly distributed version of the Library",
-we mean either the unmodified Library as distributed by INRIA, or a
-modified version of the Library that is distributed under the
-conditions defined in clause 2 of the GNU Library General Public
-License.  This exception does not however invalidate any other reasons
-why the executable file might be covered by the GNU Library General
-Public License.
-
-----------------------------------------------------------------------
-
-                   THE Q PUBLIC LICENSE version 1.0
-
-              Copyright (C) 1999 Troll Tech AS, Norway.
-                  Everyone is permitted to copy and
-                  distribute this license document.
-
-The intent of this license is to establish freedom to share and change
-the software regulated by this license under the open source model.
-
-This license applies to any software containing a notice placed by the
-copyright holder saying that it may be distributed under the terms of
-the Q Public License version 1.0. Such software is herein referred to
-as the Software. This license covers modification and distribution of
-the Software, use of third-party application programs based on the
-Software, and development of free software which uses the Software.
-
-                            Granted Rights
-
-1. You are granted the non-exclusive rights set forth in this license
-provided you agree to and comply with any and all conditions in this
-license. Whole or partial distribution of the Software, or software
-items that link with the Software, in any form signifies acceptance of
-this license.
-
-2. You may copy and distribute the Software in unmodified form
-provided that the entire package, including - but not restricted to -
-copyright, trademark notices and disclaimers, as released by the
-initial developer of the Software, is distributed.
-
-3. You may make modifications to the Software and distribute your
-modifications, in a form that is separate from the Software, such as
-patches. The following restrictions apply to modifications:
-
-      a. Modifications must not alter or remove any copyright notices
-      in the Software.
-
-      b. When modifications to the Software are released under this
-      license, a non-exclusive royalty-free right is granted to the
-      initial developer of the Software to distribute your
-      modification in future versions of the Software provided such
-      versions remain available under these terms in addition to any
-      other license(s) of the initial developer.
-
-4. You may distribute machine-executable forms of the Software or
-machine-executable forms of modified versions of the Software,
-provided that you meet these restrictions:
-
-      a. You must include this license document in the distribution.
-
-      b. You must ensure that all recipients of the machine-executable
-      forms are also able to receive the complete machine-readable
-      source code to the distributed Software, including all
-      modifications, without any charge beyond the costs of data
-      transfer, and place prominent notices in the distribution
-      explaining this.
-
-      c. You must ensure that all modifications included in the
-      machine-executable forms are available under the terms of this
-      license.
-
-5. You may use the original or modified versions of the Software to
-compile, link and run application programs legally developed by you or
-by others.
-
-6. You may develop application programs, reusable components and other
-software items that link with the original or modified versions of the
-Software. These items, when distributed, are subject to the following
-requirements:
-
-      a. You must ensure that all recipients of machine-executable
-      forms of these items are also able to receive and use the
-      complete machine-readable source code to the items without any
-      charge beyond the costs of data transfer.
-
-      b. You must explicitly license all recipients of your items to
-      use and re-distribute original and modified versions of the
-      items in both machine-executable and source code forms. The
-      recipients must be able to do so without any charges whatsoever,
-      and they must be able to re-distribute to anyone they choose.
-
-      c. If the items are not available to the general public, and the
-      initial developer of the Software requests a copy of the items,
-      then you must supply one.
-
-                       Limitations of Liability
-
-In no event shall the initial developers or copyright holders be
-liable for any damages whatsoever, including - but not restricted to -
-lost revenue or profits or other direct, indirect, special, incidental
-or consequential damages, even if they have been advised of the
-possibility of such damages, except to the extent invariable law, if
-any, provides otherwise.
-
-                             No Warranty
-
-The Software and this license document are provided AS IS with NO
-WARRANTY OF ANY KIND, INCLUDING THE WARRANTY OF DESIGN,
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-
-                            Choice of Law
-
-This license is governed by the Laws of France.
-
-----------------------------------------------------------------------
-
-                  GNU LIBRARY GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-                  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-     Appendix: How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-    MA 02111-1307, USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

File ocamlspot/Makefile

  • Ignore whitespace
-#########################################################################
-#                                                                       #
-#                             OCamlSpotter                              #
-#                                                                       #
-#                              Jun FURUSE                               #
-#                                                                       #
-#     Copyright 2008 Jun Furuse. All rights reserved.                   #
-#     This file is distributed under the terms of the GNU Library       #
-#     General Public License, with the special exception on linking     #
-#     described in file LICENSE.                                        #
-#                                                                       #
-#########################################################################
-
-include ../config/Makefile
-
-# Various commands and dir
-##########################
-CAMLRUN=../boot/ocamlrun
-OCAMLC   = ../ocamlcomp.sh -annot -w Ae -warn-error Ae
-OCAMLOPT = ../ocamlcompopt.sh
-OCAMLDEP = $(CAMLRUN) ../tools/ocamldep
-OCAMLLEX = $(CAMLRUN) ../boot/ocamllex
-OCAMLYACC= ../boot/ocamlyacc
-OCAMLLIB = $(LIBDIR)
-OCAMLBIN = $(BINDIR)
-
-# Compilation
-#############
-OCAMLSRCDIR=..
-INCLUDES_DEP=-I $(OCAMLSRCDIR)/parsing \
-	-I $(OCAMLSRCDIR)/utils \
-	-I $(OCAMLSRCDIR)/typing \
-	-I $(OCAMLSRCDIR)/driver \
-	-I $(OCAMLSRCDIR)/bytecomp \
-	-I $(OCAMLSRCDIR)/tools \
-	-I $(OCAMLSRCDIR)/toplevel/ 
-
-OTHERS=../otherlibs
-
-# Requires unix!
-COMPFLAGS= $(INCLUDES_DEP) -I $(OTHERS)/unix
-
-MODULES= utils dotfile xset treeset command ocamlspot
-
-UTILS=utils/misc utils/tbl utils/config \
-  utils/clflags utils/terminfo utils/ccomp utils/warnings \
-  utils/consistbl
-
-PARSING=parsing/linenum parsing/location parsing/longident \
-  parsing/syntaxerr parsing/parser \
-  parsing/lexer parsing/parse parsing/printast
-
-TYPING=typing/unused_var typing/ident typing/path \
-  typing/primitive typing/types \
-  typing/btype typing/oprint \
-  typing/subst typing/predef \
-  typing/datarepr typing/env \
-  typing/typedtree typing/ctype \
-  typing/printtyp typing/includeclass \
-  typing/mtype typing/spot typing/includecore \
-  typing/includemod typing/parmatch \
-  typing/typetexp typing/stypes typing/dispatch typing/typecore \
-  typing/typedecl typing/typeclass \
-  typing/typemod
-
-COMPMODULES=  $(addprefix ../, $(UTILS) $(PARSING) $(TYPING)) 
-
-OBJS=		$(addsuffix .cmo, $(MODULES))
-COMPOBJS=	$(addsuffix .cmo, $(COMPMODULES))
-
-XOBJS=		$(addsuffix .cmx, $(MODULES))
-COMPXOBJS=	$(addsuffix .cmx, $(COMPMODULES))
-
-all: ocamlspot 
-
-.PHONY: test
-
-tests:
-	(cd tests; $(MAKE))
-
-ocamlspot: $(COMPOBJS) $(OBJS)
-	$(OCAMLC) -o $@ $(COMPFLAGS) $(COMPOBJS) unix.cma $(OBJS)
-
-opt.opt: ocamlspot.opt
-
-ocamlspot.opt: $(COMPXOBJS) $(XOBJS)
-	$(OCAMLOPT) -o $@ $(COMPFLAGS) $(COMPXOBJS) unix.cmxa $(XOBJS)
-
-opt: ocamlspot.opt
-
-.PHONY: opt opt.opt
-
-clean:
-	rm -f ocamlspot ocamlspot.opt *.cm* *.o *.annot *.sp*t 
-	(cd tests; $(MAKE) clean)
-
-# generic rules :
-#################
-
-.SUFFIXES: .mll .mly .ml .mli .cmo .cmi .cmx
-
-.ml.cmo:
-	$(OCAMLC) $(OCAMLPP) $(COMPFLAGS) -c $<
-
-.mli.cmi:
-	$(OCAMLC) $(OCAMLPP) $(COMPFLAGS) -c $<
-
-.ml.cmx:
-	$(OCAMLOPT) $(OCAMLPP) $(COMPFLAGS) -c $<
-
-.mll.ml:
-	$(OCAMLLEX) $<
-
-.mly.ml:
-	$(OCAMLYACC) -v $<
-
-.mly.mli:
-	$(OCAMLYACC) -v $<
-
-beforedepend::
-
-depend: beforedepend
-	$(CAMLRUN) ../tools/ocamldep $(INCLUDES) -I ../typing *.mli *.ml > .depend
-
-.PHONY: clean install installopt beforedepend depend test
-
-# elisp
-
-EMACS=emacs
-
-ELISPS=ocamlspot.el
-
-COMPILECMD=(progn \
-		(setq load-path (cons "." load-path)) \
-		(byte-compile-file "ocamlspot.el"))
-
-install-elisp:
-	@if test "$(EMACSDIR)" = ""; then \
-          set xxx `($(EMACS) --batch --eval "(mapcar 'print load-path)") \
-                   2>/dev/null | \
-                   sed -n -e '/\/site-lisp/s/"//gp'`; \
-          if test "$$2" = ""; then \
-            echo "Cannot determine Emacs site-lisp directory"; \
-            exit 2; \
-          else \
-            $(MAKE) EMACSDIR="$$2" simple-install; \
-	  fi; \
-        else \
-          $(MAKE) simple-install; \
-        fi
-
-# install the .el files, but do not compile them.
-install-el:
-	$(MAKE) NOCOMPILE=true install
-
-simple-install:
-	@echo "Installing in $(EMACSDIR)..."
-	if test -d $(EMACSDIR); then : ; else mkdir -p $(EMACSDIR); fi
-	cp $(ELISPS) $(EMACSDIR)
-	if [ -z "$(NOCOMPILE)" ]; then \
-	  cd $(EMACSDIR); $(EMACS) --batch --eval '$(COMPILECMD)'; \
-	fi
-
-install installopt::
-	cp ocamlspot $(BINDIR)/ocamlspot$(EXE)
-	if test -f ocamlspot.opt; \
-	  then cp ocamlspot.opt $(BINDIR)/ocamlspot.opt$(EXE); else :; fi
-	# The following is optional
-	# $(MAKE) install-emacs-lisp
-
-test: ocamlspot ocamlspot.cmo
-	tests/auto-test.pl ocamlspot.ml treeset.ml xset.ml 
-
-include .depend

File ocamlspot/README.txt

  • Ignore whitespace
-OCamlSpotter : OCaml source browsing
-====================================
-
-  Camel spotter: Oh, it was extremely interesting, very, very -
-    quite... it was dull; dull, dull, dull, oh God it was dull. 
-    Sitting in the Waterloo waiting room. ...
-
-                                     from You're No Fun Anymore, 
-                                    Monty Python's Flying Circus
-
-OCaml module language is powerful. So extremely powerful that you can
-be lost yourself easily inside a huge OCaml project with tons of
-modules and functors. Spotting the definition of a variable is
-sometimes "extremely interesting". Let's see such an example:
-
-  include M
-  open N
-  open O
-  let _ = f 1
-
-Suppose you are not familiar with the function f and want to spot its
-definition. Where to find it? Just from the code you are looking at,
-it is not sure: if you are enough lucky it may be f in m.ml, n.ml or
-o.ml in your current working directory. Otherwise, it may be O.f in
-n.ml. Or probably N.O.f in m.ml. If you are unlucky and the project is
-so sophisticated, there could be complex module operations in m.ml
-(i.e includes, functor applications) and therefore the definition
-might be found somewhere completely unexpected. Module packing, module
-load paths and library installation without .ml files complicate the
-situation even worse.
-
-You first days after joining a large OCaml project should be this kind
-of manual value definition spotting with find + grep commands. Yes,
-actually it is very educational: you can learn a lot about the project
-struggling in the source tree (only if your collegues have organized
-things very well :-P), but it is still a dull job...
-
-To say short, OCamlSpotter is a tool which does this dull job
-automatically for you and permits your energy for something more
-"interesting" like Yeti spotting:
-
- - The -annot option of ocamlc and ocamlopt is extended and creates 
-   <module>.spot files (<module>.spit for .mli), which record the
-   location information of the names defined and used in the module.
-
- - A small application ocamlspot provides automatic where-about
-   spotting of the definition of the name you are interested in.
-
- - ocamlspot.el provides interactive ocaml-spotting of definition 
-   locations in emacs.
-
- - Interfaces for other editors such as vi can be built easily, if you
-   want. I do not want.
-   
-Spotting / Definition analysis
-==============================
-
-SYNOPSIS
-
-      ocamlspot [search]
-            search ::= [file] | [file]:[pos] | [file]:[kind]:[path]
-            pos ::= l[line]c[column_bytes] | b[bytes] | [bytes]
-            kind ::= v|t|e|m|mt|c|ct
-
-DESCRIPTION
-
-      Retrieve various annotation information from .spot or .spit files
-      of the source code position or identifier, specified by the
-      search spec. Information is prited to stdout. They are:
-
-      Spot: file:pos
-          The definition position of the object which the search spec
-          points to, if available.
-
-      Type: type
-      XType: type     
-          The type of the object which the search spec points to, if
-          available. In XType, paths are printed with position
-          informaiton: for example, "unit__6" instead of "unit".
-
-SEARCH
-
-      Three kinds of searches are available: file-name-only, 
-      by-position and by-path:
-
-      File-name-only search show the position independent information
-      of the module specified by [file].
-
-        Example:
-
-	$ ocamlspot -i ocamlspot.ml
-	Compile: ../ocamlc -nostdlib -I ../stdlib -annot -annot -w Ae -warn-error Ae -I ../parsing -I ../utils -I ../typing -I ../driver -I ../bytecomp -I ../tools -I ../toplevel/ -I ../otherlibs/unix -c ocamlspot.ml
-	Included_dirs:
-	  /..../ocaml/ocamlspot/
-	  /..../ocaml/ocamlspot/../stdlib
-	  /..../ocaml/ocamlspot/../parsing
-	  /..../ocaml/ocamlspot/../utils
-	  /..../ocaml/ocamlspot/../typing
-	  /..../ocaml/ocamlspot/../driver
-	  /..../ocaml/ocamlspot/../bytecomp
-	  /..../ocaml/ocamlspot/../tools
-	  /..../ocaml/ocamlspot/../toplevel/
-	  /..../ocaml/ocamlspot/../otherlibs/unix
-	BYE!
-
-      By-position search has the form [file]:[pos]. [file] is the path
-      of the target ml/mli file and [pos] is the position in the
-      target file. [pos] has three formats: l[line]c[column_bytes] by the
-      line number and column bytes, b[bytes] (and [bytes] for backward
-      compatibility) by the bytes from the beginning of the source
-      code. 
-
-        Example:
-
-	$ ocamlspot ocamlspot.ml:l129c14
-	Tree: l129c8b4035:l129c28b4055           # pos of the inner most node
-	In_module: With_pos.Fix
-	Use: Type, Path__360.t__G
-	Type: Path.t
-	XType: Path__360.t__G                    # type with ident id numbers
-	Spot: /..../ocaml/typing/path.ml:l15c5b875:l18c19b949 # the definition
-	BYE!
-
-      Note that bytes are not chars in multi-byte-character
-      environment. OCaml is completely free from such mess and you
-      might need to count chars by yourself.
-
-
-      By-path search shows the definition spot of the given path 
-      with ident id numbers. It will be useful with conjunction with 
-      the path names obtained from XType: fields. No fancy elisp wrapper
-      is not available for it, though.
-
-        Example:
-
-	# checking a type named Path__360.t__G
-	$ ocamlspot ocamlspot.ml:t:Path__360.t__G  
-	Spot: /..../ocaml/typing/path.ml:l15c5b875:l18c19b949
-	BYE!
-
-OPTIONS
-  
-      -n  
-          Skips the spotting, which may takes time. Useful if you are
-          interested in other things than the definition analysis,
-          i.e. types, paths, etc.
-    
-Bugs and future works
-=====================
-
-This software contain lots of bugs and todos.
-
-License
-=======