Pierre Surply avatar Pierre Surply committed 580b59b

First commit

Comments (0)

Files changed (12)

+ocaml-chip8
+*~
+/src/._d/
+*.cmi
+*.cmo
+##
+## Makefile for OCaml-Chip8 in /home/surply_p
+## 
+## Made by Pierre Surply
+## <pierre.surply@gmail.com>
+## 
+## Started on  Sun Aug  5 13:57:05 2012 Pierre Surply
+## Last update Sun Aug  5 13:57:28 2012 Pierre Surply
+##
+
+SRCDIR = src
+EXECDIR = .
+EXEC = $(EXECDIR)/ocaml-chip8
+MAKESRC = $(MAKE) -C $(SRCDIR) 
+
+all: $(EXEC)
+
+$(EXEC):
+	@$(MAKESRC)
+
+clean:
+	@$(MAKESRC) clean
+##
+## Makefile for OCaml-Chip8 in /home/surply_p
+## 
+## Made by Pierre Surply
+## <pierre.surply@gmail.com>
+## 
+## Started on  Sat Aug  4 20:55:40 2012 Pierre Surply
+## Last update Sun Aug  5 18:31:52 2012 Pierre Surply
+##
+
+EXECDIR = ..
+RESULT  = $(EXECDIR)/ocaml-chip8
+SOURCES = option.ml display.ml events.ml opcode.ml chip8.ml font.ml interpreter.ml main.ml
+LIBS    = bigarray sdl sdlloader
+INCDIRS = +sdl
+
+include OCamlMakefile

src/OCamlMakefile

+###########################################################################
+#                              OCamlMakefile
+#                  Copyright (C) 1999-  Markus Mottl
+#
+#                             For updates see:
+#                http://www.ocaml.info/home/ocaml_sources.html
+#
+###########################################################################
+
+# Modified by damien for .glade.ml compilation
+
+# Set these variables to the names of the sources to be processed and
+# the result variable. Order matters during linkage!
+
+ifndef SOURCES
+  SOURCES := foo.ml
+endif
+export SOURCES
+
+ifndef RES_CLIB_SUF
+  RES_CLIB_SUF := _stubs
+endif
+export RES_CLIB_SUF
+
+ifndef RESULT
+  RESULT := foo
+endif
+export RESULT := $(strip $(RESULT))
+
+export LIB_PACK_NAME
+
+ifndef DOC_FILES
+  DOC_FILES := $(filter %.mli, $(SOURCES))
+endif
+export DOC_FILES
+FIRST_DOC_FILE := $(firstword $(DOC_FILES))
+
+export BCSUFFIX
+export NCSUFFIX
+
+ifndef TOPSUFFIX
+  TOPSUFFIX := .top
+endif
+export TOPSUFFIX
+
+# Eventually set include- and library-paths, libraries to link,
+# additional compilation-, link- and ocamlyacc-flags
+# Path- and library information needs not be written with "-I" and such...
+# Define THREADS if you need it, otherwise leave it unset (same for
+# USE_CAMLP4)!
+
+export THREADS
+export VMTHREADS
+export ANNOTATE
+export USE_CAMLP4
+
+export INCDIRS
+export LIBDIRS
+export EXTLIBDIRS
+export RESULTDEPS
+export OCAML_DEFAULT_DIRS
+
+export LIBS
+export CLIBS
+export CFRAMEWORKS
+
+export OCAMLFLAGS
+export OCAMLNCFLAGS
+export OCAMLBCFLAGS
+
+export OCAMLLDFLAGS
+export OCAMLNLDFLAGS
+export OCAMLBLDFLAGS
+
+export OCAMLMKLIB_FLAGS
+
+ifndef OCAMLCPFLAGS
+  OCAMLCPFLAGS := a
+endif
+export OCAMLCPFLAGS
+
+ifndef DOC_DIR
+  DOC_DIR := doc
+endif
+export DOC_DIR
+
+export PPFLAGS
+
+export LFLAGS
+export YFLAGS
+export IDLFLAGS
+
+export OCAMLDOCFLAGS
+
+export OCAMLFIND_INSTFLAGS
+
+export DVIPSFLAGS
+
+export STATIC
+
+# Add a list of optional trash files that should be deleted by "make clean"
+export TRASH
+
+ECHO := echo
+
+ifdef REALLY_QUIET
+  export REALLY_QUIET
+  ECHO := true
+  LFLAGS := $(LFLAGS) -q
+  YFLAGS := $(YFLAGS) -q
+endif
+
+####################  variables depending on your OCaml-installation
+
+SYSTEM := $(shell ocamlc -config 2>/dev/null | grep system | sed 's/system: //')
+    # This may be
+    # - mingw
+    # - win32
+    # - cygwin
+    # - some other string means Unix
+    # - empty means ocamlc does not support -config
+
+ifeq ($(SYSTEM),mingw)
+  MINGW=1
+endif
+ifeq ($(SYSTEM),win32)
+  MSVC=1
+endif
+
+ifdef MINGW
+  export MINGW
+  WIN32 := 1
+  # We are compiling with cygwin tools:
+  CFLAGS_WIN32 := -mno-cygwin
+  # The default value 'cc' makes 'ocamlc -cc "cc"' raises the error 'The
+  # NTVDM CPU has encountered an illegal instruction'.
+  CC := gcc
+  # The OCaml C header files use this flag:
+  CFLAGS += -D__MINGW32__
+endif
+ifdef MSVC
+  export MSVC
+  WIN32   := 1
+  ifndef STATIC
+    CPPFLAGS_WIN32 := -DCAML_DLL
+  endif
+  CFLAGS_WIN32 += -nologo
+  EXT_OBJ := obj
+  EXT_LIB := lib
+  ifeq ($(CC),gcc)
+    # work around GNU Make default value
+    ifdef THREADS
+      CC := cl -MT
+    else
+      CC := cl
+    endif
+  endif
+  ifeq ($(CXX),g++)
+    # work around GNU Make default value
+    CXX := $(CC)
+  endif
+  CFLAG_O := -Fo
+endif
+ifdef WIN32
+  EXT_CXX := cpp
+  EXE     := .exe
+endif
+
+ifndef EXT_OBJ
+  EXT_OBJ := o
+endif
+ifndef EXT_LIB
+  EXT_LIB := a
+endif
+ifndef EXT_CXX
+  EXT_CXX := cc
+endif
+ifndef EXE
+  EXE := # empty
+endif
+ifndef CFLAG_O
+  CFLAG_O := -o # do not delete this comment (preserves trailing whitespace)!
+endif
+
+export CC
+export CXX
+export CFLAGS
+export CXXFLAGS
+export LDFLAGS
+export CPPFLAGS
+
+ifndef RPATH_FLAG
+  ifdef ELF_RPATH_FLAG
+    RPATH_FLAG := $(ELF_RPATH_FLAG)
+  else
+    RPATH_FLAG := -R
+  endif
+endif
+export RPATH_FLAG
+
+ifndef MSVC
+ifndef PIC_CFLAGS
+  PIC_CFLAGS := -fPIC
+endif
+ifndef PIC_CPPFLAGS
+  PIC_CPPFLAGS := -DPIC
+endif
+endif
+
+export PIC_CFLAGS
+export PIC_CPPFLAGS
+
+BCRESULT  := $(addsuffix $(BCSUFFIX), $(RESULT))
+NCRESULT  := $(addsuffix $(NCSUFFIX), $(RESULT))
+TOPRESULT := $(addsuffix $(TOPSUFFIX), $(RESULT))
+
+ifndef OCAMLFIND
+  OCAMLFIND := ocamlfind
+endif
+export OCAMLFIND
+
+ifndef OCAML
+  OCAML := ocaml
+endif
+export OCAML
+
+ifndef OCAMLC
+  OCAMLC := ocamlc
+endif
+export OCAMLC
+
+ifndef OCAMLOPT
+  OCAMLOPT := ocamlopt
+endif
+export OCAMLOPT
+
+ifndef OCAMLMKTOP
+  OCAMLMKTOP := ocamlmktop
+endif
+export OCAMLMKTOP
+
+ifndef OCAMLCP
+  OCAMLCP := ocamlcp
+endif
+export OCAMLCP
+
+ifndef OCAMLDEP
+  OCAMLDEP := ocamldep
+endif
+export OCAMLDEP
+
+ifndef OCAMLLEX
+  OCAMLLEX := ocamllex
+endif
+export OCAMLLEX
+
+ifndef OCAMLYACC
+  OCAMLYACC := ocamlyacc
+endif
+export OCAMLYACC
+
+ifndef OCAMLMKLIB
+  OCAMLMKLIB := ocamlmklib
+endif
+export OCAMLMKLIB
+
+ifndef OCAML_GLADECC
+  OCAML_GLADECC := lablgladecc2
+endif
+export OCAML_GLADECC
+
+ifndef OCAML_GLADECC_FLAGS
+  OCAML_GLADECC_FLAGS :=
+endif
+export OCAML_GLADECC_FLAGS
+
+ifndef CAMELEON_REPORT
+  CAMELEON_REPORT := report
+endif
+export CAMELEON_REPORT
+
+ifndef CAMELEON_REPORT_FLAGS
+  CAMELEON_REPORT_FLAGS :=
+endif
+export CAMELEON_REPORT_FLAGS
+
+ifndef CAMELEON_ZOGGY
+  CAMELEON_ZOGGY := camlp4o pa_zog.cma pr_o.cmo
+endif
+export CAMELEON_ZOGGY
+
+ifndef CAMELEON_ZOGGY_FLAGS
+  CAMELEON_ZOGGY_FLAGS :=
+endif
+export CAMELEON_ZOGGY_FLAGS
+
+ifndef OXRIDL
+  OXRIDL := oxridl
+endif
+export OXRIDL
+
+ifndef CAMLIDL
+  CAMLIDL := camlidl
+endif
+export CAMLIDL
+
+ifndef CAMLIDLDLL
+  CAMLIDLDLL := camlidldll
+endif
+export CAMLIDLDLL
+
+ifndef NOIDLHEADER
+  MAYBE_IDL_HEADER := -header
+endif
+export NOIDLHEADER
+
+export NO_CUSTOM
+
+ifndef CAMLP4
+  CAMLP4 := camlp4
+endif
+export CAMLP4
+
+ifndef REAL_OCAMLFIND
+  ifdef PACKS
+    ifndef CREATE_LIB
+      ifdef THREADS
+	PACKS += threads
+      endif
+    endif
+    empty :=
+    space := $(empty) $(empty)
+    comma := ,
+    ifdef PREDS
+      PRE_OCAML_FIND_PREDICATES := $(subst $(space),$(comma),$(PREDS))
+      PRE_OCAML_FIND_PACKAGES := $(subst $(space),$(comma),$(PACKS))
+      OCAML_FIND_PREDICATES := -predicates $(PRE_OCAML_FIND_PREDICATES)
+  #    OCAML_DEP_PREDICATES := -syntax $(PRE_OCAML_FIND_PREDICATES)
+      OCAML_FIND_PACKAGES := $(OCAML_FIND_PREDICATES) -package $(PRE_OCAML_FIND_PACKAGES)
+      OCAML_DEP_PACKAGES := $(OCAML_DEP_PREDICATES) -package $(PRE_OCAML_FIND_PACKAGES)
+    else
+      OCAML_FIND_PACKAGES := -package $(subst $(space),$(comma),$(PACKS))
+      OCAML_DEP_PACKAGES :=
+    endif
+    OCAML_FIND_LINKPKG := -linkpkg
+    REAL_OCAMLFIND := $(OCAMLFIND)
+  endif
+endif
+
+export OCAML_FIND_PACKAGES
+export OCAML_DEP_PACKAGES
+export OCAML_FIND_LINKPKG
+export REAL_OCAMLFIND
+
+ifndef OCAMLDOC
+  OCAMLDOC := ocamldoc
+endif
+export OCAMLDOC
+
+ifndef LATEX
+  LATEX := latex
+endif
+export LATEX
+
+ifndef DVIPS
+  DVIPS := dvips
+endif
+export DVIPS
+
+ifndef PS2PDF
+  PS2PDF := ps2pdf
+endif
+export PS2PDF
+
+ifndef OCAMLMAKEFILE
+  OCAMLMAKEFILE := OCamlMakefile
+endif
+export OCAMLMAKEFILE
+
+ifndef OCAMLLIBPATH
+  OCAMLLIBPATH := \
+    $(shell $(OCAMLC) 2>/dev/null -where || echo /usr/local/lib/ocaml)
+endif
+export OCAMLLIBPATH
+
+ifndef OCAML_LIB_INSTALL
+  OCAML_LIB_INSTALL := $(OCAMLLIBPATH)/contrib
+endif
+export OCAML_LIB_INSTALL
+
+###########################################################################
+
+####################  change following sections only if
+####################    you know what you are doing!
+
+# delete target files when a build command fails
+.PHONY: .DELETE_ON_ERROR
+.DELETE_ON_ERROR:
+
+# for pedants using "--warn-undefined-variables"
+export MAYBE_IDL
+export REAL_RESULT
+export CAMLIDLFLAGS
+export THREAD_FLAG
+export RES_CLIB
+export MAKEDLL
+export ANNOT_FLAG
+export C_OXRIDL
+export SUBPROJS
+export CFLAGS_WIN32
+export CPPFLAGS_WIN32
+
+INCFLAGS :=
+
+SHELL := /bin/sh
+
+MLDEPDIR := ._d
+BCDIDIR  := ._bcdi
+NCDIDIR  := ._ncdi
+
+FILTER_EXTNS := %.mli %.ml %.mll %.mly %.idl %.oxridl %.c %.m %.$(EXT_CXX) %.rep %.zog %.glade
+
+FILTERED     := $(filter $(FILTER_EXTNS), $(SOURCES))
+SOURCE_DIRS  := $(filter-out ./, $(sort $(dir $(FILTERED))))
+
+FILTERED_REP := $(filter %.rep, $(FILTERED))
+DEP_REP      := $(FILTERED_REP:%.rep=$(MLDEPDIR)/%.d)
+AUTO_REP     := $(FILTERED_REP:.rep=.ml)
+
+FILTERED_ZOG := $(filter %.zog, $(FILTERED))
+DEP_ZOG      := $(FILTERED_ZOG:%.zog=$(MLDEPDIR)/%.d)
+AUTO_ZOG     := $(FILTERED_ZOG:.zog=.ml)
+
+FILTERED_GLADE := $(filter %.glade, $(FILTERED))
+DEP_GLADE      := $(FILTERED_GLADE:%.glade=$(MLDEPDIR)/%.d)
+AUTO_GLADE     := $(FILTERED_GLADE:.glade=.ml)
+
+FILTERED_ML  := $(filter %.ml, $(FILTERED))
+DEP_ML       := $(FILTERED_ML:%.ml=$(MLDEPDIR)/%.d)
+
+FILTERED_MLI := $(filter %.mli, $(FILTERED))
+DEP_MLI      := $(FILTERED_MLI:.mli=.di)
+
+FILTERED_MLL := $(filter %.mll, $(FILTERED))
+DEP_MLL      := $(FILTERED_MLL:%.mll=$(MLDEPDIR)/%.d)
+AUTO_MLL     := $(FILTERED_MLL:.mll=.ml)
+
+FILTERED_MLY := $(filter %.mly, $(FILTERED))
+DEP_MLY      := $(FILTERED_MLY:%.mly=$(MLDEPDIR)/%.d) $(FILTERED_MLY:.mly=.di)
+AUTO_MLY     := $(FILTERED_MLY:.mly=.mli) $(FILTERED_MLY:.mly=.ml)
+
+FILTERED_IDL := $(filter %.idl, $(FILTERED))
+DEP_IDL      := $(FILTERED_IDL:%.idl=$(MLDEPDIR)/%.d) $(FILTERED_IDL:.idl=.di)
+C_IDL        := $(FILTERED_IDL:%.idl=%_stubs.c)
+ifndef NOIDLHEADER
+ C_IDL += $(FILTERED_IDL:.idl=.h)
+endif
+OBJ_C_IDL    := $(FILTERED_IDL:%.idl=%_stubs.$(EXT_OBJ))
+AUTO_IDL     := $(FILTERED_IDL:.idl=.mli) $(FILTERED_IDL:.idl=.ml) $(C_IDL)
+
+FILTERED_OXRIDL := $(filter %.oxridl, $(FILTERED))
+DEP_OXRIDL      := $(FILTERED_OXRIDL:%.oxridl=$(MLDEPDIR)/%.d) $(FILTERED_OXRIDL:.oxridl=.di)
+AUTO_OXRIDL     := $(FILTERED_OXRIDL:.oxridl=.mli) $(FILTERED_OXRIDL:.oxridl=.ml) $(C_OXRIDL)
+
+FILTERED_C_CXX := $(filter %.c %.m %.$(EXT_CXX), $(FILTERED))
+OBJ_C_CXX      := $(FILTERED_C_CXX:.c=.$(EXT_OBJ))
+OBJ_C_CXX      := $(OBJ_C_CXX:.m=.$(EXT_OBJ))
+OBJ_C_CXX      := $(OBJ_C_CXX:.$(EXT_CXX)=.$(EXT_OBJ))
+
+PRE_TARGETS  += $(AUTO_MLL) $(AUTO_MLY) $(AUTO_IDL) $(AUTO_OXRIDL) $(AUTO_ZOG) $(AUTO_REP) $(AUTO_GLADE)
+
+ALL_DEPS     := $(DEP_ML) $(DEP_MLI) $(DEP_MLL) $(DEP_MLY) $(DEP_IDL) $(DEP_OXRIDL) $(DEP_ZOG) $(DEP_REP) $(DEP_GLADE)
+
+MLDEPS       := $(filter %.d, $(ALL_DEPS))
+MLIDEPS      := $(filter %.di, $(ALL_DEPS))
+BCDEPIS      := $(MLIDEPS:%.di=$(BCDIDIR)/%.di)
+NCDEPIS      := $(MLIDEPS:%.di=$(NCDIDIR)/%.di)
+
+ALLML        := $(filter %.mli %.ml %.mll %.mly %.idl %.oxridl %.rep %.zog %.glade, $(FILTERED))
+
+IMPLO_INTF   := $(ALLML:%.mli=%.mli.__)
+IMPLO_INTF   := $(foreach file, $(IMPLO_INTF), \
+                  $(basename $(file)).cmi $(basename $(file)).cmo)
+IMPLO_INTF   := $(filter-out %.mli.cmo, $(IMPLO_INTF))
+IMPLO_INTF   := $(IMPLO_INTF:%.mli.cmi=%.cmi)
+
+IMPLX_INTF   := $(IMPLO_INTF:.cmo=.cmx)
+
+INTF         := $(filter %.cmi, $(IMPLO_INTF))
+IMPL_CMO     := $(filter %.cmo, $(IMPLO_INTF))
+IMPL_CMX     := $(IMPL_CMO:.cmo=.cmx)
+IMPL_ASM     := $(IMPL_CMO:.cmo=.asm)
+IMPL_S       := $(IMPL_CMO:.cmo=.s)
+
+OBJ_LINK     := $(OBJ_C_IDL) $(OBJ_C_CXX)
+OBJ_FILES    := $(IMPL_CMO:.cmo=.$(EXT_OBJ)) $(OBJ_LINK)
+
+EXECS        := $(addsuffix $(EXE), \
+                            $(sort $(TOPRESULT) $(BCRESULT) $(NCRESULT)))
+ifdef WIN32
+  EXECS      += $(BCRESULT).dll $(NCRESULT).dll
+endif
+
+CLIB_BASE    := $(RESULT)$(RES_CLIB_SUF)
+ifneq ($(strip $(OBJ_LINK)),)
+  RES_CLIB     := lib$(CLIB_BASE).$(EXT_LIB)
+endif
+
+ifdef WIN32
+DLLSONAME := dll$(CLIB_BASE).dll
+else
+DLLSONAME := dll$(CLIB_BASE).so
+endif
+
+NONEXECS     := $(INTF) $(IMPL_CMO) $(IMPL_CMX) $(IMPL_ASM) $(IMPL_S) \
+		$(OBJ_FILES) $(PRE_TARGETS) $(BCRESULT).cma $(NCRESULT).cmxa \
+		$(NCRESULT).$(EXT_LIB) $(BCRESULT).cmi $(BCRESULT).cmo \
+		$(NCRESULT).cmi $(NCRESULT).cmx $(NCRESULT).$(EXT_OBJ) \
+		$(RES_CLIB) $(IMPL_CMO:.cmo=.annot) \
+		$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmo $(LIB_PACK_NAME).cmx \
+		$(LIB_PACK_NAME).$(EXT_OBJ)
+
+ifndef STATIC
+  NONEXECS += $(DLLSONAME)
+endif
+
+ifndef LIBINSTALL_FILES
+  LIBINSTALL_FILES := $(RESULT).mli $(RESULT).cmi $(RESULT).cma \
+		      $(RESULT).cmxa $(RESULT).$(EXT_LIB) $(RES_CLIB)
+  ifndef STATIC
+    ifneq ($(strip $(OBJ_LINK)),)
+      LIBINSTALL_FILES += $(DLLSONAME)
+    endif
+  endif
+endif
+
+export LIBINSTALL_FILES
+
+ifdef WIN32
+  # some extra stuff is created while linking DLLs
+  NONEXECS   += $(BCRESULT).$(EXT_LIB) $(BCRESULT).exp $(NCRESULT).exp $(CLIB_BASE).exp $(CLIB_BASE).lib
+endif
+
+TARGETS      := $(EXECS) $(NONEXECS)
+
+# If there are IDL-files
+ifneq ($(strip $(FILTERED_IDL)),)
+  MAYBE_IDL := -cclib -lcamlidl
+endif
+
+ifdef USE_CAMLP4
+  CAMLP4PATH := \
+    $(shell $(CAMLP4) -where 2>/dev/null || echo /usr/local/lib/camlp4)
+  INCFLAGS := -I $(CAMLP4PATH)
+  CINCFLAGS := -I$(CAMLP4PATH)
+endif
+
+DINCFLAGS := $(INCFLAGS) $(SOURCE_DIRS:%=-I %) $(OCAML_DEFAULT_DIRS:%=-I %)
+INCFLAGS := $(DINCFLAGS) $(INCDIRS:%=-I %)
+CINCFLAGS += $(SOURCE_DIRS:%=-I%) $(INCDIRS:%=-I%) $(OCAML_DEFAULT_DIRS:%=-I%)
+
+ifndef MSVC
+  CLIBFLAGS += $(SOURCE_DIRS:%=-L%) $(LIBDIRS:%=-L%) \
+               $(EXTLIBDIRS:%=-L%) $(OCAML_DEFAULT_DIRS:%=-L%)
+
+  ifeq ($(ELF_RPATH), yes)
+    CLIBFLAGS += $(EXTLIBDIRS:%=-Wl,$(RPATH_FLAG)%)
+  endif
+endif
+
+ifndef PROFILING
+  INTF_OCAMLC := $(OCAMLC)
+else
+  ifndef THREADS
+    INTF_OCAMLC := $(OCAMLCP) -p $(OCAMLCPFLAGS)
+  else
+    # OCaml does not support profiling byte code
+    # with threads (yet), therefore we force an error.
+    ifndef REAL_OCAMLC
+      $(error Profiling of multithreaded byte code not yet supported by OCaml)
+    endif
+    INTF_OCAMLC := $(OCAMLC)
+  endif
+endif
+
+ifndef MSVC
+  COMMON_LDFLAGS := $(LDFLAGS:%=-ccopt %) $(SOURCE_DIRS:%=-ccopt -L%) \
+		    $(LIBDIRS:%=-ccopt -L%) $(EXTLIBDIRS:%=-ccopt -L%) \
+		    $(EXTLIBDIRS:%=-ccopt -Wl $(OCAML_DEFAULT_DIRS:%=-ccopt -L%))
+
+  ifeq ($(ELF_RPATH),yes)
+    COMMON_LDFLAGS += $(EXTLIBDIRS:%=-ccopt -Wl,$(RPATH_FLAG)%)
+  endif
+else
+  COMMON_LDFLAGS := -ccopt "/link -NODEFAULTLIB:LIBC $(LDFLAGS:%=%) $(SOURCE_DIRS:%=-LIBPATH:%) \
+		    $(LIBDIRS:%=-LIBPATH:%) $(EXTLIBDIRS:%=-LIBPATH:%) \
+		    $(OCAML_DEFAULT_DIRS:%=-LIBPATH:%) "
+endif
+
+CLIBS_OPTS := $(CLIBS:%=-cclib -l%) $(CFRAMEWORKS:%=-cclib '-framework %')
+ifdef MSVC
+  ifndef STATIC
+  # MSVC libraries do not have 'lib' prefix
+  CLIBS_OPTS := $(CLIBS:%=-cclib %.lib)
+  endif
+endif
+
+ifneq ($(strip $(OBJ_LINK)),)
+  ifdef CREATE_LIB
+    OBJS_LIBS := -cclib -l$(CLIB_BASE) $(CLIBS_OPTS) $(MAYBE_IDL)
+  else
+    OBJS_LIBS := $(OBJ_LINK) $(CLIBS_OPTS) $(MAYBE_IDL)
+  endif
+else
+  OBJS_LIBS := $(CLIBS_OPTS) $(MAYBE_IDL)
+endif
+
+ifdef LIB_PACK_NAME
+  FOR_PACK_NAME := $(shell echo $(LIB_PACK_NAME) | awk '{print toupper(substr($$0,1,1))substr($$0,2)}')
+endif
+
+# If we have to make byte-code
+ifndef REAL_OCAMLC
+  BYTE_OCAML := y
+
+  # EXTRADEPS is added dependencies we have to insert for all
+  # executable files we generate.  Ideally it should be all of the
+  # libraries we use, but it's hard to find the ones that get searched on
+  # the path since I don't know the paths built into the compiler, so
+  # just include the ones with slashes in their names.
+  EXTRADEPS := $(addsuffix .cma,$(foreach i,$(LIBS),$(if $(findstring /,$(i)),$(i))))
+
+
+  ifndef LIB_PACK_NAME
+    SPECIAL_OCAMLFLAGS := $(OCAMLBCFLAGS)
+  else	
+    SPECIAL_OCAMLFLAGS := -for-pack $(FOR_PACK_NAME) $(OCAMLBCFLAGS)
+  endif
+
+  REAL_OCAMLC := $(INTF_OCAMLC)
+
+  REAL_IMPL := $(IMPL_CMO)
+  REAL_IMPL_INTF := $(IMPLO_INTF)
+  IMPL_SUF := .cmo
+
+  DEPFLAGS  :=
+  MAKE_DEPS := $(MLDEPS) $(BCDEPIS)
+
+  ifdef CREATE_LIB
+    override CFLAGS := $(PIC_CFLAGS) $(CFLAGS)
+    override CPPFLAGS := $(PIC_CPPFLAGS) $(CPPFLAGS)
+    ifndef STATIC
+      ifneq ($(strip $(OBJ_LINK)),)
+	MAKEDLL := $(DLLSONAME)
+	ALL_LDFLAGS := -dllib $(DLLSONAME)
+      endif
+    endif
+  endif
+
+  ifndef NO_CUSTOM
+    ifneq "$(strip $(OBJ_LINK) $(THREADS) $(MAYBE_IDL) $(CLIBS) $(CFRAMEWORKS))" ""
+      ALL_LDFLAGS += -custom
+    endif
+  endif
+
+  ALL_LDFLAGS += $(INCFLAGS) $(OCAMLLDFLAGS) $(OCAMLBLDFLAGS) \
+                 $(COMMON_LDFLAGS) $(LIBS:%=%.cma)
+  CAMLIDLDLLFLAGS :=
+
+  ifdef THREADS
+    ifdef VMTHREADS
+      THREAD_FLAG := -vmthread
+    else
+      THREAD_FLAG := -thread
+    endif
+    ALL_LDFLAGS := $(THREAD_FLAG) $(ALL_LDFLAGS)
+    ifndef CREATE_LIB
+      ifndef REAL_OCAMLFIND
+        ALL_LDFLAGS := unix.cma threads.cma $(ALL_LDFLAGS)
+      endif
+    endif
+  endif
+
+# we have to make native-code
+else
+  EXTRADEPS := $(addsuffix .cmxa,$(foreach i,$(LIBS),$(if $(findstring /,$(i)),$(i))))
+  ifndef PROFILING
+    SPECIAL_OCAMLFLAGS := $(OCAMLNCFLAGS)
+    PLDFLAGS :=
+  else
+    SPECIAL_OCAMLFLAGS := -p $(OCAMLNCFLAGS)
+    PLDFLAGS := -p
+  endif
+
+  ifndef LIB_PACK_NAME
+    SPECIAL_OCAMLFLAGS := $(OCAMLNCFLAGS)
+  else	
+    SPECIAL_OCAMLFLAGS := -for-pack $(FOR_PACK_NAME) $(OCAMLNCFLAGS)
+  endif
+  REAL_IMPL := $(IMPL_CMX)
+  REAL_IMPL_INTF := $(IMPLX_INTF)
+  IMPL_SUF := .cmx
+
+  override CPPFLAGS := -DNATIVE_CODE $(CPPFLAGS)
+
+  DEPFLAGS  := -native
+  MAKE_DEPS := $(MLDEPS) $(NCDEPIS)
+
+  ALL_LDFLAGS := $(PLDFLAGS) $(INCFLAGS) $(OCAMLLDFLAGS) \
+                 $(OCAMLNLDFLAGS) $(COMMON_LDFLAGS)
+  CAMLIDLDLLFLAGS := -opt
+
+  ifndef CREATE_LIB
+    ALL_LDFLAGS += $(LIBS:%=%.cmxa)
+  else
+    override CFLAGS := $(PIC_CFLAGS) $(CFLAGS)
+    override CPPFLAGS := $(PIC_CPPFLAGS) $(CPPFLAGS)
+  endif
+
+  ifdef THREADS
+    THREAD_FLAG := -thread
+    ALL_LDFLAGS := $(THREAD_FLAG) $(ALL_LDFLAGS)
+    ifndef CREATE_LIB
+      ifndef REAL_OCAMLFIND
+        ALL_LDFLAGS := unix.cmxa threads.cmxa $(ALL_LDFLAGS)
+      endif
+    endif
+  endif
+endif
+
+export MAKE_DEPS
+
+ifdef ANNOTATE
+  ANNOT_FLAG := -dtypes
+else
+endif
+
+ALL_OCAMLCFLAGS := $(THREAD_FLAG) $(ANNOT_FLAG) $(OCAMLFLAGS) \
+                   $(INCFLAGS) $(SPECIAL_OCAMLFLAGS)
+
+ifdef make_deps
+  -include $(MAKE_DEPS)
+  PRE_TARGETS :=
+endif
+
+###########################################################################
+# USER RULES
+
+# Call "OCamlMakefile QUIET=" to get rid of all of the @'s.
+QUIET=@
+
+# generates byte-code (default)
+byte-code:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT) \
+				REAL_RESULT="$(BCRESULT)" make_deps=yes
+bc:	byte-code
+
+byte-code-nolink:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
+				REAL_RESULT="$(BCRESULT)" make_deps=yes
+bcnl:	byte-code-nolink
+
+top:			$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(TOPRESULT) \
+				REAL_RESULT="$(BCRESULT)" make_deps=yes
+
+# generates native-code
+
+native-code:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(NCRESULT) \
+				REAL_RESULT="$(NCRESULT)" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				make_deps=yes
+nc:	native-code
+
+native-code-nolink:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
+				REAL_RESULT="$(NCRESULT)" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				make_deps=yes
+ncnl:	native-code-nolink
+
+# generates byte-code libraries
+byte-code-library:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(BCRESULT).cma \
+				REAL_RESULT="$(BCRESULT)" \
+				CREATE_LIB=yes \
+				make_deps=yes
+bcl:	byte-code-library
+
+# generates native-code libraries
+native-code-library:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(NCRESULT).cmxa \
+				REAL_RESULT="$(NCRESULT)" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				CREATE_LIB=yes \
+				make_deps=yes
+ncl:	native-code-library
+
+ifdef WIN32
+# generates byte-code dll
+byte-code-dll:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(BCRESULT).dll \
+				REAL_RESULT="$(BCRESULT)" \
+				make_deps=yes
+bcd:	byte-code-dll
+
+# generates native-code dll
+native-code-dll:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(NCRESULT).dll \
+				REAL_RESULT="$(NCRESULT)" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				make_deps=yes
+ncd:	native-code-dll
+endif
+
+# generates byte-code with debugging information
+debug-code:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT) \
+				REAL_RESULT="$(BCRESULT)" make_deps=yes \
+				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
+				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
+dc:	debug-code
+
+debug-code-nolink:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
+				REAL_RESULT="$(BCRESULT)" make_deps=yes \
+				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
+				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
+dcnl:	debug-code-nolink
+
+# generates byte-code with debugging information (native code)
+debug-native-code:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(NCRESULT) \
+				REAL_RESULT="$(NCRESULT)" make_deps=yes \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
+				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
+dnc:	debug-native-code
+
+debug-native-code-nolink:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
+				REAL_RESULT="$(NCRESULT)" make_deps=yes \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
+				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
+dncnl:	debug-native-code-nolink
+
+# generates byte-code libraries with debugging information
+debug-code-library:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(BCRESULT).cma \
+				REAL_RESULT="$(BCRESULT)" make_deps=yes \
+				CREATE_LIB=yes \
+				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
+				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
+dcl:	debug-code-library
+
+# generates byte-code libraries with debugging information (native code)
+debug-native-code-library:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(NCRESULT).cma \
+				REAL_RESULT="$(NCRESULT)" make_deps=yes \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				CREATE_LIB=yes \
+				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
+				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
+dncl:	debug-native-code-library
+
+# generates byte-code for profiling
+profiling-byte-code:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT) \
+				REAL_RESULT="$(BCRESULT)" PROFILING="y" \
+				make_deps=yes
+pbc:	profiling-byte-code
+
+# generates native-code
+
+profiling-native-code:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(NCRESULT) \
+				REAL_RESULT="$(NCRESULT)" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				PROFILING="y" \
+				make_deps=yes
+pnc:	profiling-native-code
+
+# generates byte-code libraries
+profiling-byte-code-library:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(BCRESULT).cma \
+				REAL_RESULT="$(BCRESULT)" PROFILING="y" \
+				CREATE_LIB=yes \
+				make_deps=yes
+pbcl:	profiling-byte-code-library
+
+# generates native-code libraries
+profiling-native-code-library:	$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(RES_CLIB) $(NCRESULT).cmxa \
+				REAL_RESULT="$(NCRESULT)" PROFILING="y" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				CREATE_LIB=yes \
+				make_deps=yes
+pncl:	profiling-native-code-library
+
+# packs byte-code objects
+pack-byte-code:			$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT).cmo \
+				REAL_RESULT="$(BCRESULT)" \
+				PACK_LIB=yes make_deps=yes
+pabc:	pack-byte-code
+
+# packs native-code objects
+pack-native-code:		$(PRE_TARGETS)
+			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
+				$(NCRESULT).cmx $(NCRESULT).$(EXT_OBJ) \
+				REAL_RESULT="$(NCRESULT)" \
+				REAL_OCAMLC="$(OCAMLOPT)" \
+				PACK_LIB=yes make_deps=yes
+panc:	pack-native-code
+
+# generates HTML-documentation
+htdoc:	$(DOC_DIR)/$(RESULT)/html/index.html
+
+# generates Latex-documentation
+ladoc:	$(DOC_DIR)/$(RESULT)/latex/doc.tex
+
+# generates PostScript-documentation
+psdoc:	$(DOC_DIR)/$(RESULT)/latex/doc.ps
+
+# generates PDF-documentation
+pdfdoc:	$(DOC_DIR)/$(RESULT)/latex/doc.pdf
+
+# generates all supported forms of documentation
+doc: htdoc ladoc psdoc pdfdoc
+
+###########################################################################
+# LOW LEVEL RULES
+
+$(REAL_RESULT):		$(REAL_IMPL_INTF) $(OBJ_LINK) $(EXTRADEPS) $(RESULTDEPS)
+			$(REAL_OCAMLFIND) $(REAL_OCAMLC) \
+				$(OCAML_FIND_PACKAGES) $(OCAML_FIND_LINKPKG) \
+				$(ALL_LDFLAGS) $(OBJS_LIBS) -o $@$(EXE) \
+				$(REAL_IMPL)
+
+nolink:			$(REAL_IMPL_INTF) $(OBJ_LINK)
+
+ifdef WIN32
+$(REAL_RESULT).dll:	$(REAL_IMPL_INTF) $(OBJ_LINK)
+			$(CAMLIDLDLL) $(CAMLIDLDLLFLAGS) $(OBJ_LINK) $(CLIBS) \
+				-o $@ $(REAL_IMPL)
+endif
+
+%$(TOPSUFFIX):		$(REAL_IMPL_INTF) $(OBJ_LINK) $(EXTRADEPS)
+			$(REAL_OCAMLFIND) $(OCAMLMKTOP) \
+				$(OCAML_FIND_PACKAGES) $(OCAML_FIND_LINKPKG) \
+				$(ALL_LDFLAGS) $(OBJS_LIBS) -o $@$(EXE) \
+				$(REAL_IMPL)
+
+.SUFFIXES:		.mli .ml .cmi .cmo .cmx .cma .cmxa .$(EXT_OBJ) \
+                        .mly .di .d .$(EXT_LIB) .idl %.oxridl .c .m .$(EXT_CXX) .h .so \
+                        .rep .zog .glade
+
+ifndef STATIC
+ifdef MINGW
+# From OCaml 3.11.0, ocamlmklib is available on windows
+OCAMLMLIB_EXISTS = $(shell which $(OCAMLMKLIB))
+ifeq ($(strip $(OCAMLMLIB_EXISTS)),)
+$(DLLSONAME):		$(OBJ_LINK)
+			$(CC) $(CFLAGS) $(CFLAGS_WIN32) $(OBJ_LINK) -shared -o $@ \
+			$(wildcard $(foreach dir,$(LIBDIRS),$(CLIBS:%=$(dir)/lib%.a))) \
+			 '$(OCAMLLIBPATH)/ocamlrun.a' \
+			-Wl,--whole-archive \
+			-Wl,--export-all-symbols \
+			-Wl,--allow-multiple-definition \
+			-Wl,--enable-auto-import
+else
+$(DLLSONAME):		$(OBJ_LINK)
+			$(OCAMLMKLIB) $(INCFLAGS) $(CLIBFLAGS) \
+				-o $(CLIB_BASE) $(OBJ_LINK) $(CLIBS:%=-l%) \
+				$(CFRAMEWORKS:%=-framework %) \
+				$(OCAMLMKLIB_FLAGS)
+endif
+else
+ifdef MSVC
+$(DLLSONAME):		$(OBJ_LINK)
+			link /NOLOGO /DLL /OUT:$@ $(OBJ_LINK) \
+			 $(wildcard $(foreach dir,$(LIBDIRS),$(CLIBS:%=$(dir)/%.lib))) \
+			 '$(OCAMLLIBPATH)/ocamlrun.lib'
+
+else
+$(DLLSONAME):		$(OBJ_LINK)
+			$(OCAMLMKLIB) $(INCFLAGS) $(CLIBFLAGS) \
+				-o $(CLIB_BASE) $(OBJ_LINK) $(CLIBS:%=-l%) $(CFRAMEWORKS:%=-framework %) \
+				$(OCAMLMKLIB_FLAGS)
+endif
+endif
+endif
+
+ifndef LIB_PACK_NAME
+$(RESULT).cma:		$(REAL_IMPL_INTF) $(MAKEDLL) $(EXTRADEPS) $(RESULTDEPS)
+			$(REAL_OCAMLFIND) $(REAL_OCAMLC) -a $(ALL_LDFLAGS) $(OBJS_LIBS) -o $@ $(REAL_IMPL)
+
+$(RESULT).cmxa $(RESULT).$(EXT_LIB):	$(REAL_IMPL_INTF) $(EXTRADEPS) $(RESULTDEPS)
+			$(REAL_OCAMLFIND) $(OCAMLOPT) -a $(ALL_LDFLAGS) $(OBJS_LIBS) -o $@ $(REAL_IMPL)
+else
+# Packing a bytecode library
+LIB_PACK_NAME_MLI = $(wildcard $(LIB_PACK_NAME).mli)
+ifeq ($(LIB_PACK_NAME_MLI),)
+LIB_PACK_NAME_CMI = $(LIB_PACK_NAME).cmi
+else
+# $(LIB_PACK_NAME).mli exists, it likely depends on other compiled interfaces
+LIB_PACK_NAME_CMI =
+$(LIB_PACK_NAME).cmi: $(REAL_IMPL_INTF)
+endif
+ifdef BYTE_OCAML
+$(LIB_PACK_NAME_CMI) $(LIB_PACK_NAME).cmo: $(REAL_IMPL_INTF)
+			$(REAL_OCAMLFIND) $(REAL_OCAMLC) -pack -o $(LIB_PACK_NAME).cmo $(OCAMLLDFLAGS) $(REAL_IMPL)
+# Packing into a unit which can be transformed into a library
+# Remember the .ml's must have been compiled with -for-pack $(LIB_PACK_NAME)
+else
+$(LIB_PACK_NAME_CMI) $(LIB_PACK_NAME).cmx: $(REAL_IMPL_INTF)
+			$(REAL_OCAMLFIND) $(OCAMLOPT) -pack -o $(LIB_PACK_NAME).cmx  $(OCAMLLDFLAGS) $(REAL_IMPL)
+endif
+
+$(RESULT).cma:		$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmo $(MAKEDLL) $(EXTRADEPS) $(RESULTDEPS)
+			$(REAL_OCAMLFIND) $(REAL_OCAMLC) -a $(ALL_LDFLAGS) $(OBJS_LIBS) -o $@ $(LIB_PACK_NAME).cmo
+
+$(RESULT).cmxa $(RESULT).$(EXT_LIB):	$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmx $(EXTRADEPS) $(RESULTDEPS)
+			$(REAL_OCAMLFIND) $(OCAMLOPT) -a $(filter-out -custom, $(ALL_LDFLAGS)) $(OBJS_LIBS) -o $@ $(LIB_PACK_NAME).cmx
+endif
+
+$(RES_CLIB): 		$(OBJ_LINK)
+ifndef MSVC
+  ifneq ($(strip $(OBJ_LINK)),)
+		      $(AR) rcs $@ $(OBJ_LINK)
+  endif
+else
+  ifneq ($(strip $(OBJ_LINK)),)
+			lib -nologo -debugtype:cv -out:$(RES_CLIB) $(OBJ_LINK)
+  endif
+endif
+
+.mli.cmi: $(EXTRADEPS)
+			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
+			if [ -z "$$pp" ]; then \
+			  $(ECHO) $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c $(THREAD_FLAG) $(ANNOT_FLAG) \
+				$(OCAMLFLAGS) $(INCFLAGS) $<; \
+			  $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c $(THREAD_FLAG) $(ANNOT_FLAG) \
+				$(OCAMLFLAGS) $(INCFLAGS) $<; \
+			else \
+			    $(ECHO) $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c -pp \"$$pp $(PPFLAGS)\" $(THREAD_FLAG) $(ANNOT_FLAG) \
+				$(OCAMLFLAGS) $(INCFLAGS) $<; \
+			    $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c -pp "$$pp $(PPFLAGS)" $(THREAD_FLAG) $(ANNOT_FLAG) \
+				$(OCAMLFLAGS) $(INCFLAGS) $<; \
+			fi
+
+.ml.cmi .ml.$(EXT_OBJ) .ml.cmx .ml.cmo: $(EXTRADEPS)
+			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
+			if [ -z "$$pp" ]; then \
+			  $(ECHO) $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c $(ALL_OCAMLCFLAGS) $<; \
+			  $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c $(ALL_OCAMLCFLAGS) $<; \
+			else \
+			  $(ECHO) $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c -pp \"$$pp $(PPFLAGS)\" $(ALL_OCAMLCFLAGS) $<; \
+			  $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
+				-c -pp "$$pp $(PPFLAGS)" $(ALL_OCAMLCFLAGS) $<; \
+			fi
+
+.PRECIOUS:		%.ml
+%.ml:			%.mll
+			$(OCAMLLEX) $(LFLAGS) $<
+
+.PRECIOUS:              %.ml %.mli
+%.ml %.mli:             %.mly
+			$(OCAMLYACC) $(YFLAGS) $<
+			$(QUIET)pp=`sed -n -e 's/.*(\*pp \([^*]*\) \*).*/\1/p;q' $<`; \
+			if [ ! -z "$$pp" ]; then \
+			  mv $*.ml $*.ml.temporary; \
+			  echo "(*pp $$pp $(PPFLAGS)*)" > $*.ml; \
+			  cat $*.ml.temporary >> $*.ml; \
+			  rm $*.ml.temporary; \
+			  mv $*.mli $*.mli.temporary; \
+			  echo "(*pp $$pp $(PPFLAGS)*)" > $*.mli; \
+			  cat $*.mli.temporary >> $*.mli; \
+			  rm $*.mli.temporary; \
+			fi
+
+
+.PRECIOUS:		%.ml
+%.ml:			%.rep
+			$(CAMELEON_REPORT) $(CAMELEON_REPORT_FLAGS) -gen $<
+
+.PRECIOUS:		%.ml
+%.ml:			%.zog
+			$(CAMELEON_ZOGGY)  $(CAMELEON_ZOGGY_FLAGS) -impl $< > $@
+
+.PRECIOUS:		%.ml
+%.ml:			%.glade
+			$(OCAML_GLADECC)  $(OCAML_GLADECC_FLAGS) $< > $@
+
+.PRECIOUS:		%.ml %.mli
+%.ml %.mli:		%.oxridl
+			$(OXRIDL) $<
+
+.PRECIOUS:		%.ml %.mli %_stubs.c %.h
+%.ml %.mli %_stubs.c %.h:		%.idl
+			$(CAMLIDL) $(MAYBE_IDL_HEADER) $(IDLFLAGS) \
+				$(CAMLIDLFLAGS) $<
+			$(QUIET)if [ $(NOIDLHEADER) ]; then touch $*.h; fi
+
+.c.$(EXT_OBJ):
+			$(OCAMLC) -c -cc "$(CC)" -ccopt "$(CFLAGS) \
+				$(CPPFLAGS) $(CPPFLAGS_WIN32) \
+				$(CFLAGS_WIN32) $(CINCFLAGS) $(CFLAG_O)$@ " $<
+
+.m.$(EXT_OBJ):
+			$(CC) -c $(CFLAGS) $(CINCFLAGS) $(CPPFLAGS) \
+				-I'$(OCAMLLIBPATH)' \
+				$< $(CFLAG_O)$@
+
+.$(EXT_CXX).$(EXT_OBJ):
+			$(CXX) -c $(CXXFLAGS) $(CINCFLAGS) $(CPPFLAGS) \
+				-I'$(OCAMLLIBPATH)' \
+				$< $(CFLAG_O)$@
+
+$(MLDEPDIR)/%.d:	%.ml
+			$(QUIET)if [ ! -d $(@D) ]; then mkdir -p $(@D); fi
+			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
+			if [ -z "$$pp" ]; then \
+			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
+				$(DINCFLAGS) $< \> $@; \
+			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
+				$(DINCFLAGS) $< > $@; \
+			else \
+			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
+				-pp \"$$pp $(PPFLAGS)\" $(DINCFLAGS) $< \> $@; \
+			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
+				-pp "$$pp $(PPFLAGS)" $(DINCFLAGS) $< > $@; \
+			fi
+
+$(BCDIDIR)/%.di $(NCDIDIR)/%.di:	%.mli
+			$(QUIET)if [ ! -d $(@D) ]; then mkdir -p $(@D); fi
+			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
+			if [ -z "$$pp" ]; then \
+			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) $(DINCFLAGS) $< \> $@; \
+			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) $(DINCFLAGS) $< > $@; \
+			else \
+			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) \
+			    -pp \"$$pp $(PPFLAGS)\" $(DINCFLAGS) $< \> $@; \
+			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) \
+			    -pp "$$pp $(PPFLAGS)" $(DINCFLAGS) $< > $@; \
+			fi
+
+$(DOC_DIR)/$(RESULT)/html:
+	mkdir -p $@
+
+$(DOC_DIR)/$(RESULT)/html/index.html: $(DOC_DIR)/$(RESULT)/html $(DOC_FILES)
+	rm -rf $</*
+	$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $(FIRST_DOC_FILE)`; \
+	if [ -z "$$pp" ]; then \
+	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -html -d $< $(OCAMLDOCFLAGS) $(INCFLAGS) $(DOC_FILES); \
+	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -html -d $< $(OCAMLDOCFLAGS) $(INCFLAGS) $(DOC_FILES); \
+	else \
+	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp \"$$pp $(PPFLAGS)\" -html -d $< $(OCAMLDOCFLAGS) \
+	  	$(INCFLAGS) $(DOC_FILES); \
+	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp "$$pp $(PPFLAGS)" -html -d $< $(OCAMLDOCFLAGS) \
+	  	$(INCFLAGS) $(DOC_FILES); \
+	fi
+
+$(DOC_DIR)/$(RESULT)/latex:
+	mkdir -p $@
+
+$(DOC_DIR)/$(RESULT)/latex/doc.tex: $(DOC_DIR)/$(RESULT)/latex $(DOC_FILES)
+	rm -rf $</*
+	$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $(FIRST_DOC_FILE)`; \
+	if [ -z "$$pp" ]; then \
+	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -latex $(OCAMLDOCFLAGS) $(INCFLAGS) \
+	  	$(DOC_FILES) -o $@; \
+	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -latex $(OCAMLDOCFLAGS) $(INCFLAGS) $(DOC_FILES) \
+	  	-o $@; \
+	else \
+	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp \"$$pp $(PPFLAGS)\" -latex $(OCAMLDOCFLAGS) \
+	  	$(INCFLAGS) $(DOC_FILES) -o $@; \
+	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp "$$pp $(PPFLAGS)" -latex $(OCAMLDOCFLAGS) \
+	  	$(INCFLAGS) $(DOC_FILES) -o $@; \
+	fi
+
+$(DOC_DIR)/$(RESULT)/latex/doc.ps: $(DOC_DIR)/$(RESULT)/latex/doc.tex
+	cd $(DOC_DIR)/$(RESULT)/latex && \
+	  $(LATEX) doc.tex && \
+	  $(LATEX) doc.tex && \
+	  $(DVIPS) $(DVIPSFLAGS) doc.dvi -o $(@F)
+
+$(DOC_DIR)/$(RESULT)/latex/doc.pdf: $(DOC_DIR)/$(RESULT)/latex/doc.ps
+	cd $(DOC_DIR)/$(RESULT)/latex && $(PS2PDF) $(<F)
+
+define make_subproj
+.PHONY:
+subproj_$(1):
+	$$(eval $$(call PROJ_$(1)))
+	$(QUIET)if [ "$(SUBTARGET)" != "all" ]; then \
+	  $(MAKE) -f $(OCAMLMAKEFILE) $(SUBTARGET); \
+	fi
+endef
+
+$(foreach subproj,$(SUBPROJS),$(eval $(call make_subproj,$(subproj))))
+
+.PHONY:
+subprojs: $(SUBPROJS:%=subproj_%)
+
+###########################################################################
+# (UN)INSTALL RULES FOR LIBRARIES
+
+.PHONY: libinstall
+libinstall:	all
+	$(QUIET)printf "\nInstalling library with ocamlfind\n"
+	$(OCAMLFIND) install $(OCAMLFIND_INSTFLAGS) $(RESULT) META $(LIBINSTALL_FILES)
+	$(QUIET)printf "\nInstallation successful.\n"
+
+.PHONY: libinstall-byte-code
+libinstall-byte-code:	all
+	$(QUIET)printf "\nInstalling byte-code library with ocamlfind\n"
+	$(OCAMLFIND) install $(OCAMLFIND_INSTFLAGS) $(RESULT) META \
+	  $(filter-out $(RESULT).$(EXT_LIB) $(RESULT).cmxa, $(LIBINSTALL_FILES))
+	$(QUIET)printf "\nInstallation successful.\n"
+
+.PHONY: libinstall-native-code
+libinstall-native-code:	all
+	$(QUIET)printf "\nInstalling native-code library with ocamlfind\n"
+	$(OCAMLFIND) install $(OCAMLFIND_INSTFLAGS) $(RESULT) META \
+	  $(filter-out $(DLLSONAME) $(RESULT).cma, $(LIBINSTALL_FILES))
+	$(QUIET)printf "\nInstallation successful.\n"
+
+.PHONY: libuninstall
+libuninstall:
+	$(QUIET)printf "\nUninstalling library with ocamlfind\n"
+	$(OCAMLFIND) remove $(OCAMLFIND_INSTFLAGS) $(RESULT)
+	$(QUIET)printf "\nUninstallation successful.\n"
+
+.PHONY: rawinstall
+rawinstall:	all
+	$(QUIET)printf "\nInstalling library to: $(OCAML_LIB_INSTALL)\n"
+	-install -d $(OCAML_LIB_INSTALL)
+	for i in $(LIBINSTALL_FILES); do \
+	  if [ -f $$i ]; then \
+	    install -c -m 0644 $$i $(OCAML_LIB_INSTALL); \
+	  fi; \
+	done
+	$(QUIET)printf "\nInstallation successful.\n"
+
+.PHONY: rawuninstall
+rawuninstall:
+	$(QUIET)printf "\nUninstalling library from: $(OCAML_LIB_INSTALL)\n"
+	cd $(OCAML_LIB_INSTALL) && rm $(notdir $(LIBINSTALL_FILES))
+	$(QUIET)printf "\nUninstallation successful.\n"
+
+###########################################################################
+# MAINTENANCE RULES
+
+.PHONY:	clean
+clean::
+	rm -f $(TARGETS) $(TRASH)
+	rm -rf $(BCDIDIR) $(NCDIDIR) $(MLDEPDIR)
+
+.PHONY:	cleanup
+cleanup::
+	rm -f $(NONEXECS) $(TRASH)
+	rm -rf $(BCDIDIR) $(NCDIDIR) $(MLDEPDIR)
+
+.PHONY: clean-doc
+clean-doc::
+	rm -rf $(DOC_DIR)/$(RESULT)
+
+.PHONY: clean-all
+clean-all:: clean clean-doc
+
+.PHONY: nobackup
+nobackup:
+	rm -f *.bak *~ *.dup
+(*
+** chip8.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sat Aug  4 21:06:50 2012 Pierre Surply
+** Last update Sun Aug  5 18:11:13 2012 Pierre Surply
+*)
+
+open Opcode
+open Display
+open Events
+
+let _ = Random.self_init ()
+
+let mem_size =		0xFFF
+let start_addr =	0x200
+
+type t_chip8 =
+    {
+      mutable mem :	int array;
+      mutable v:	int array;
+      mutable i:	int;
+      mutable pc:	int;
+      mutable sp:	int;
+      mutable stack:	int array;
+      mutable dt:	int;
+      mutable st:	int
+    }
+
+let chip8 = 
+{
+  mem =	[||];
+  v = [||];
+  i = 0;
+  pc = 0;
+  sp = 0;
+  stack = [||];
+  dt = 0;
+  st = 0
+}
+
+let init_chip8 () = 
+  begin
+    chip8.mem <- Array.make mem_size 0;
+    chip8.v <- Array.make 16 0;
+    chip8.i <- 0;
+    chip8.pc <- start_addr;
+    chip8.sp <- 0;
+    chip8.stack <- Array.make 16 0;
+    chip8.dt <- 0;
+    chip8.st <- 0;
+    init_opcodes ()
+  end
+
+let count () =
+  if chip8.dt > 0 then
+    chip8.dt <- chip8.dt - 1;
+  if chip8.st > 0 then
+    chip8.st <- chip8.st - 1
+
+let print_debug () =
+  let _ = Sys.command "clear" in
+  print_string "*** OCaml-Chip8 Debug ***\n\n";
+  for i=0 to 0xF do
+    Printf.printf "V%X: %02X " i chip8.v.(i)
+  done;
+  print_newline ();
+  Printf.printf "I: %02X SP: %X DT: %02X ST: %02X\n" chip8.i chip8.sp chip8.dt chip8.st;
+  Printf.printf "PC: %03X  -- Mem : %02X%02X [ %02X%02X ] %02X%02X %02X%02X %02X%02X %02X%02X" 
+    chip8.pc
+    chip8.mem.(chip8.pc - 2)
+    chip8.mem.(chip8.pc - 1)
+    chip8.mem.(chip8.pc)
+    chip8.mem.(chip8.pc + 1)
+    chip8.mem.(chip8.pc + 2)
+    chip8.mem.(chip8.pc + 3)
+    chip8.mem.(chip8.pc + 4)
+    chip8.mem.(chip8.pc + 5)
+    chip8.mem.(chip8.pc + 6)
+    chip8.mem.(chip8.pc + 7)
+    chip8.mem.(chip8.pc + 8)
+    chip8.mem.(chip8.pc + 9);
+  print_newline ()
+
+let getopcode () = 
+  (chip8.mem.(chip8.pc) lsl 8) + chip8.mem.(chip8.pc+1)
+
+let check_overflow x =
+  if chip8.v.(x) > 0xFF then
+    begin
+      chip8.v.(x) <- chip8.v.(x) - 0x100;
+      chip8.v.(0xF) <- 1
+    end
+  else
+    chip8.v.(0xF) <- 0
+
+let cls () = 
+  clear_screen()
+
+let ret () =
+  if chip8.sp > 0 then
+    begin
+      chip8.sp <- chip8.sp - 1;
+      chip8.pc <- chip8.stack.(chip8.sp)
+    end
+
+let jmp_addr nnn =
+  chip8.pc <- nnn-2
+
+let call_addr nnn =
+  chip8.stack.(chip8.sp) <- chip8.pc;
+  if chip8.sp < 15 then
+    chip8.sp <- chip8.sp + 1;
+  jmp_addr nnn
+
+let se_vx_byte x kk = 
+  if chip8.v.(x) = kk then
+    chip8.pc <- chip8.pc + 2
+
+let sne_vx_byte x kk = 
+  if chip8.v.(x) != kk then
+    chip8.pc <- chip8.pc + 2
+
+let se_vx_vy x y =
+  if chip8.v.(x) = chip8.v.(y) then
+    chip8.pc <- chip8.pc + 2
+
+let ld_vx_byte x kk =
+  chip8.v.(x) <- kk
+
+let add_vx_byte x kk =
+  chip8.v.(x) <- chip8.v.(x) + kk;
+  check_overflow x
+
+let ld_vx_vy x y =
+  chip8.v.(x) <- chip8.v.(y)
+
+let or_vx_vy x y =
+  chip8.v.(x) <- chip8.v.(x) lor chip8.v.(y)
+
+let and_vx_vy x y =
+  chip8.v.(x) <- chip8.v.(x) land chip8.v.(y)
+
+let xor_vx_vy x y =
+  chip8.v.(x) <- chip8.v.(x) lxor chip8.v.(y)
+
+let add_vx_vy x y =
+  chip8.v.(x) <- chip8.v.(x) + chip8.v.(y);
+  check_overflow x
+
+let sub_vx_vy x y =
+  if chip8.v.(x) > chip8.v.(y) then
+      chip8.v.(0xF) <- 1
+  else
+    chip8.v.(0xF) <- 0;
+  chip8.v.(x) <- chip8.v.(x) - chip8.v.(y)
+
+let shr_vx_vy x y =
+  if chip8.v.(x) mod 2 = 1 then
+    chip8.v.(0xF) <- 1
+  else
+    chip8.v.(0xF) <- 0;
+  chip8.v.(x) <- chip8.v.(y) / 2
+
+let subn_vx_vy x y =
+  if chip8.v.(x) < chip8.v.(y) then
+    begin
+      chip8.v.(0xF) <- 1
+    end
+  else
+    chip8.v.(0xF) <- 0;
+  chip8.v.(x) <- chip8.v.(y) - chip8.v.(x)
+
+let shl_vx_vy x y =
+  if (chip8.v.(x) lsr 7) = 1 then
+    chip8.v.(0xF) <- 1
+  else
+    chip8.v.(0xF) <- 0;
+  chip8.v.(x) <- chip8.v.(x) * 2
+
+let sne_vx_vy x y =
+  if chip8.v.(x) != chip8.v.(y) then
+    chip8.pc <- chip8.pc + 2
+
+let ld_i_addr nnn =
+  chip8.i <- nnn
+
+let jp_v0_addr nnn =
+  chip8.pc <- chip8.v.(0) + nnn
+
+let rnd_vx_byte x kk =
+  chip8.v.(x) <- (Random.int 256) land kk
+
+let drw_vx_vy_nibble x y n = 
+  (*chip8.v.(0xF) <- 0;
+  for k = 0 to n-1 do
+    let code = chip8.mem.(chip8.i+k) in
+    let py = (chip8.v.(y)+k) mod h in
+    for j = 0 to 7 do
+      let px = (chip8.v.(x)+j) mod w in
+      let b = code land (1 lsl (7-j)) != 0 in
+      let lp = display.pixels.(px + py*w) in
+      display.pixels.(px + py*w) <- b;
+      if display.pixels.(px + py*w) != lp then
+	chip8.v.(0xF) <- 1
+    done
+  done*)
+  chip8.v.(0xF) <- 0;
+  for k = 0 to n-1 do
+    let code = chip8.mem.(chip8.i+k) in
+    let y = (chip8.v.(y)+k) mod h in
+    for j = 0 to 7 do
+      let x = (chip8.v.(x)+j) mod w in
+      if (code land (1 lsl (7-j))) != 0 then
+	if display.pixels.(x + y*w) then
+	  begin
+	    display.pixels.(x + y*w) <- false;
+	    chip8.v.(0xF) <- 1
+	  end
+	else
+	  display.pixels.(x + y*w) <- true
+    done
+  done
+
+let skp_vx x =
+  if events.keys.(chip8.v.(x)) then
+    chip8.pc <- chip8.pc + 2
+
+let sknp_vx x =
+  if not (events.keys.(chip8.v.(x))) then
+    chip8.pc <- chip8.pc + 2
+
+let ld_vx_dt x =
+  chip8.v.(x) <- chip8.dt
+
+let ld_vx_k x =
+  chip8.v.(x) <- wait_events ()
+
+let ld_dt_vx x =
+  chip8.dt <- chip8.v.(x)
+
+let ld_st_vx x =
+  chip8.st <- chip8.v.(x)
+
+let add_i_vx x =
+  chip8.i <- chip8.i + chip8.v.(x)
+
+let ld_f_vx x = 
+  chip8.i <- chip8.v.(x) * 5
+
+let ld_b_vx x =
+  chip8.mem.(chip8.i) <- chip8.v.(x) / 100;
+  chip8.mem.(chip8.i + 1) <- (chip8.v.(x) / 10) mod 10;
+  chip8.mem.(chip8.i + 2) <- chip8.v.(x) mod 10
+
+let ld_mem_vx x = 
+  for i = 0 to x do
+    chip8.mem.(chip8.i + i) <- chip8.v.(i)
+  done
+
+let ld_vx_mem x =
+  for i = 0 to x do
+    chip8.v.(i) <- chip8.mem.(chip8.i + i)
+  done
+(*
+** display.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sat Aug  4 21:38:12 2012 Pierre Surply
+** Last update Sun Aug  5 10:55:48 2012 Pierre Surply
+*)
+
+let w = 64
+let h = 32
+let dim_pixel = 8
+let s_w = w*dim_pixel
+let s_h = h*dim_pixel
+
+type t_display = 
+  {
+    mutable screen :	Sdlvideo.surface;
+    mutable pixels :	bool array;
+    mutable px_b :	Sdlvideo.surface;
+    mutable px_w :	Sdlvideo.surface;
+  }
+
+let display = 
+{
+  screen = Sdlvideo.set_video_mode s_w s_h [`HWSURFACE];
+  pixels = [||];
+  px_b = Sdlvideo.create_RGB_surface [`HWSURFACE] dim_pixel dim_pixel 32 0l 0l 0l 0l;
+  px_w = Sdlvideo.create_RGB_surface [`HWSURFACE] dim_pixel dim_pixel 32 0l 0l 0l 0l
+}
+
+let init_display () = 
+  begin
+    Sdlwm.set_caption "OCaml-Chip8 - Pierre Surply" "";
+    display.pixels <- Array.make (64*32) false;
+    Sdlvideo.fill_rect display.px_b (Sdlvideo.map_RGB display.px_b (0, 0, 0));
+    Sdlvideo.fill_rect display.px_w (Sdlvideo.map_RGB display.px_w (0xFF, 0xFF, 0xFF))
+  end
+
+let clear_screen () =
+  begin
+    for y = 0 to h-1 do
+      for x = 0 to w-1 do
+	display.pixels.(x + y*w) <- false
+      done;
+    done
+  end
+
+let update_screen () =
+  begin
+    for y = 0 to h-1 do
+      for x = 0 to w-1 do
+	Sdlvideo.blit_surface ~dst_rect:(Sdlvideo.rect (x*dim_pixel) (y*dim_pixel) 0 0)
+	  ~src:(if display.pixels.(x + y*w) then display.px_w else display.px_b)
+	  ~dst:(display.screen) ()
+      done;
+    done;
+    Sdlvideo.flip display.screen
+  end
+(*
+** events.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sat Aug  4 22:15:13 2012 Pierre Surply
+** Last update Sun Aug  5 15:40:40 2012 Pierre Surply
+*)
+
+type t_events =
+  {
+    mutable keys : bool array;
+    mutable quit : bool
+  }
+
+let events = 
+{
+  keys = [||];
+  quit = false
+}
+
+let init_events () =
+  begin
+    events.keys <- Array.make 16 false;
+    events.quit <- false
+  end
+
+
+let keysym2id = function
+  | Sdlkey.KEY_KP0 ->		0x0
+  | Sdlkey.KEY_KP7 ->		0x1
+  | Sdlkey.KEY_KP8 ->		0x2
+  | Sdlkey.KEY_KP9 ->		0x3
+  | Sdlkey.KEY_KP4 ->		0x4
+  | Sdlkey.KEY_KP5 ->		0x5
+  | Sdlkey.KEY_KP6 ->		0x6
+  | Sdlkey.KEY_KP1 ->		0x7
+  | Sdlkey.KEY_KP2 ->		0x8
+  | Sdlkey.KEY_KP3 ->		0x9
+  | Sdlkey.KEY_KP_PERIOD ->	0xA
+  | Sdlkey.KEY_KP_DIVIDE ->	0xB
+  | Sdlkey.KEY_KP_MULTIPLY ->	0xC
+  | Sdlkey.KEY_KP_MINUS ->	0xD
+  | Sdlkey.KEY_KP_PLUS ->	0xE
+  | Sdlkey.KEY_KP_ENTER ->	0xF
+  | _ ->			-1
+
+let rec update_events () = 
+  begin
+    let event = Sdlevent.poll () in
+    if Option.is_some event then
+      begin
+	begin
+	  match Option.get event with
+	    | Sdlevent.QUIT -> events.quit <- true
+	    | Sdlevent.KEYDOWN kevent ->
+	      let id = keysym2id (kevent.Sdlevent.keysym) in
+	      if id >= 0 then
+		events.keys.(id) <- true
+	    | Sdlevent.KEYUP kevent ->
+	      let id = keysym2id (kevent.Sdlevent.keysym) in
+	      if id >= 0 then
+		events.keys.(id) <- false
+	    | _ -> ()
+	end;
+	update_events ()
+      end
+  end
+
+let rec wait_events () = 
+  begin
+    let event = Sdlevent.poll () in
+    if Option.is_some event then
+      begin
+	match Option.get event with
+	  | Sdlevent.QUIT -> events.quit <- true; 0xF
+	  | Sdlevent.KEYDOWN kevent ->
+	    let id = keysym2id (kevent.Sdlevent.keysym) in
+	    if id >= 0 then
+	      begin
+		events.keys.(id) <- true;
+		id
+	      end
+	    else
+	      wait_events ()
+	  | _ -> wait_events ()
+      end
+    else
+      wait_events ()
+  end
+(*
+** font.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sun Aug  5 18:19:12 2012 Pierre Surply
+** Last update Sun Aug  5 18:34:11 2012 Pierre Surply
+*)
+
+open Chip8
+
+let init_font () = 
+  (* 0 *)
+  chip8.mem.(0) <- 0xF0;
+  chip8.mem.(1) <- 0x90;
+  chip8.mem.(2) <- 0x90;
+  chip8.mem.(3) <- 0x90;
+  chip8.mem.(4) <- 0xF0; 
+  
+  (* 1 *)
+  chip8.mem.(5) <- 0x20;
+  chip8.mem.(6) <- 0x60;
+  chip8.mem.(7) <- 0x20;
+  chip8.mem.(8) <- 0x20;
+  chip8.mem.(9) <- 0x70; 
+
+  (* 2 *)
+  chip8.mem.(10) <- 0xF0;
+  chip8.mem.(11) <- 0x10;
+  chip8.mem.(12) <- 0xF0;
+  chip8.mem.(13) <- 0x80;
+  chip8.mem.(14) <- 0xF0; 
+  
+  (* 3 *)
+  chip8.mem.(15) <- 0xF0;
+  chip8.mem.(16) <- 0x10;
+  chip8.mem.(17) <- 0xF0;
+  chip8.mem.(18) <- 0x10;
+  chip8.mem.(19) <- 0xF0; 
+
+  (* 4 *)
+  chip8.mem.(20) <- 0x90;
+  chip8.mem.(21) <- 0x90;
+  chip8.mem.(22) <- 0xF0;
+  chip8.mem.(23) <- 0x10;
+  chip8.mem.(24) <- 0x10; 
+  
+  (* 5 *)
+  chip8.mem.(25) <- 0xF0;
+  chip8.mem.(26) <- 0x80;
+  chip8.mem.(27) <- 0xF0;
+  chip8.mem.(28) <- 0x10;
+  chip8.mem.(29) <- 0xF0; 
+
+  (* 6 *)
+  chip8.mem.(30) <- 0xF0;
+  chip8.mem.(31) <- 0x80;
+  chip8.mem.(32) <- 0xF0;
+  chip8.mem.(33) <- 0x90;
+  chip8.mem.(34) <- 0xF0; 
+  
+  (* 7 *)
+  chip8.mem.(35) <- 0xF0;
+  chip8.mem.(36) <- 0x10;
+  chip8.mem.(37) <- 0x20;
+  chip8.mem.(38) <- 0x40;
+  chip8.mem.(39) <- 0x40; 
+
+  (* 8 *)
+  chip8.mem.(40) <- 0xF0;
+  chip8.mem.(41) <- 0x90;
+  chip8.mem.(42) <- 0xF0;
+  chip8.mem.(43) <- 0x90;
+  chip8.mem.(44) <- 0xF0; 
+  
+  (* 9 *)
+  chip8.mem.(45) <- 0xF0;
+  chip8.mem.(46) <- 0x90;
+  chip8.mem.(47) <- 0xF0;
+  chip8.mem.(48) <- 0x10;
+  chip8.mem.(49) <- 0xF0; 
+
+  (* A *)
+  chip8.mem.(50) <- 0xF0;
+  chip8.mem.(51) <- 0x90;
+  chip8.mem.(52) <- 0xF0;
+  chip8.mem.(53) <- 0x90;
+  chip8.mem.(54) <- 0x90; 
+  
+  (* B *)
+  chip8.mem.(55) <- 0xE0;
+  chip8.mem.(56) <- 0x90;
+  chip8.mem.(57) <- 0xE0;
+  chip8.mem.(58) <- 0x90;
+  chip8.mem.(59) <- 0xE0; 
+
+  (* C *)
+  chip8.mem.(60) <- 0xF0;
+  chip8.mem.(61) <- 0x80;
+  chip8.mem.(62) <- 0x80;
+  chip8.mem.(63) <- 0x80;
+  chip8.mem.(64) <- 0xF0; 
+  
+  (* D *)
+  chip8.mem.(65) <- 0xE0;
+  chip8.mem.(66) <- 0x90;
+  chip8.mem.(67) <- 0x90;
+  chip8.mem.(68) <- 0x90;
+  chip8.mem.(69) <- 0xE0; 
+
+  (* E *)
+  chip8.mem.(70) <- 0xF0;
+  chip8.mem.(71) <- 0x80;
+  chip8.mem.(72) <- 0xF0;
+  chip8.mem.(73) <- 0x80;
+  chip8.mem.(74) <- 0xF0; 
+  
+  (* F *)
+  chip8.mem.(75) <- 0xF0;
+  chip8.mem.(76) <- 0x80;
+  chip8.mem.(77) <- 0xF0;
+  chip8.mem.(78) <- 0x80;
+  chip8.mem.(79) <- 0x80; 

src/interpreter.ml

+(*
+** interpreter.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sun Aug  5 12:31:47 2012 Pierre Surply
+** Last update Sun Aug  5 17:13:51 2012 Pierre Surply
+*)
+
+open Chip8
+open Opcode
+
+let load_game str =
+  let f = open_in str in
+  let rec r_read n = 
+    try
+      let b = input_byte f in
+      chip8.mem.(n + start_addr) <- b;
+      r_read (n + 1)
+    with End_of_file -> close_in f
+  in
+  r_read 0
+
+let get_cmd op =
+  let rec r_get_cmd op = function
+    | -1 -> -1
+    | x -> 
+      if (opcodes.(x).mask land op) = opcodes.(x).id 
+      then x 
+      else r_get_cmd op (x-1)
+  in
+  r_get_cmd op (nb_opcode-1)
+
+let interpret op = 
+  let n = op land 0x000F in
+  let y = (op land 0x00F0) lsr 4 in
+  let x = (op land 0x0F00) lsr 8 in
+  let kk = op land 0x00FF in
+  let nnn = op land 0x0FFF in
+  begin
+    match get_cmd op with
+      | 0  -> ();
+      | 1  -> cls ();
+      | 2  -> ret ();
+      | 3  -> jmp_addr nnn;
+      | 4  -> call_addr nnn;
+      | 5  -> se_vx_byte x kk;
+      | 6  -> sne_vx_byte x kk;
+      | 7  -> se_vx_vy x y;
+      | 8  -> ld_vx_byte x kk;
+      | 9  -> add_vx_byte x kk;
+      | 10 -> ld_vx_vy x y;
+      | 11 -> or_vx_vy x y;
+      | 12 -> and_vx_vy x y;
+      | 13 -> xor_vx_vy x y;
+      | 14 -> add_vx_vy x y;
+      | 15 -> sub_vx_vy x y;
+      | 16 -> shr_vx_vy x y;
+      | 17 -> subn_vx_vy x y;
+      | 18 -> shl_vx_vy x y;
+      | 19 -> sne_vx_vy x y;
+      | 20 -> ld_i_addr nnn;
+      | 21 -> jp_v0_addr nnn;
+      | 22 -> rnd_vx_byte x kk;
+      | 23 -> drw_vx_vy_nibble x y n;
+      | 24 -> skp_vx x;
+      | 25 -> sknp_vx x;
+      | 26 -> ld_vx_dt x;
+      | 27 -> ld_vx_k x;
+      | 28 -> ld_dt_vx x;
+      | 29 -> ld_st_vx x;
+      | 30 -> add_i_vx x;
+      | 31 -> ld_f_vx x;
+      | 32 -> ld_b_vx x;
+      | 33 -> ld_mem_vx x;
+      | 34 -> ld_vx_mem x;
+      | _ -> ()
+  end;
+  chip8.pc <- chip8.pc + 2
+(*
+** main.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sat Aug  4 20:56:34 2012 Pierre Surply
+** Last update Sun Aug  5 18:34:42 2012 Pierre Surply
+*)
+
+open Chip8
+open Display
+open Events
+open Interpreter
+open Font
+
+let cpuspeed = 8
+let debug = false
+
+let init_sdl () = 
+  Sdl.init [`VIDEO]
+
+let quit_sdl () = 
+  Sdl.quit ()
+
+let main () = 
+  init_sdl ();
+  init_chip8 ();
+  init_font ();
+  init_display ();
+  init_events ();
+
+  if Array.length Sys.argv > 1 then
+    load_game Sys.argv.(1)
+  else
+    failwith "Usage : ./ocaml-chip8 ROM";
+  
+  while not(events.quit) do
+    update_events ();
+    for i=1 to cpuspeed do
+      interpret (getopcode ());
+    done;
+    if debug then
+      print_debug ();
+    update_screen ();
+    count ();
+  done;
+
+  quit_sdl ()
+
+
+let _ = main ()
+(*
+** opcode.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sat Aug  4 22:45:03 2012 Pierre Surply
+** Last update Sun Aug  5 16:40:58 2012 Pierre Surply
+*)
+
+let nb_opcode = 35
+
+type t_opcode = 
+{
+  mask :	int;
+  id :		int
+}
+
+let opcodes = Array.make 35 {mask = 0; id = 0}
+
+let init_opcodes () =
+  opcodes.(0)  <- {mask = 0xF000; id=0x0000};
+  opcodes.(1)  <- {mask = 0xFFFF; id=0x00E0};
+  opcodes.(2)  <- {mask = 0xFFFF; id=0x00EE};
+  opcodes.(3)  <- {mask = 0xF000; id=0x1000};
+  opcodes.(4)  <- {mask = 0xF000; id=0x2000};
+  opcodes.(5)  <- {mask = 0xF000; id=0x3000};
+  opcodes.(6)  <- {mask = 0xF000; id=0x4000};
+  opcodes.(7)  <- {mask = 0xF00F; id=0x5000};
+  opcodes.(8)  <- {mask = 0xF000; id=0x6000};
+  opcodes.(9)  <- {mask = 0xF000; id=0x7000};
+  opcodes.(10) <- {mask = 0xF00F; id=0x8000};
+  opcodes.(11) <- {mask = 0xF00F; id=0x8001};
+  opcodes.(12) <- {mask = 0xF00F; id=0x8002};
+  opcodes.(13) <- {mask = 0xF00F; id=0x8003};
+  opcodes.(14) <- {mask = 0xF00F; id=0x8004};
+  opcodes.(15) <- {mask = 0xF00F; id=0x8005};
+  opcodes.(16) <- {mask = 0xF00F; id=0x8006};
+  opcodes.(17) <- {mask = 0xF00F; id=0x8007};
+  opcodes.(18) <- {mask = 0xF00F; id=0x800E};
+  opcodes.(19) <- {mask = 0xF00F; id=0x9000};
+  opcodes.(20) <- {mask = 0xF000; id=0xA000};
+  opcodes.(21) <- {mask = 0xF000; id=0xB000};
+  opcodes.(22) <- {mask = 0xF000; id=0xC000};
+  opcodes.(23) <- {mask = 0xF000; id=0xD000};
+  opcodes.(24) <- {mask = 0xF0FF; id=0xE09E};
+  opcodes.(25) <- {mask = 0xF0FF; id=0xE0A1};
+  opcodes.(26) <- {mask = 0xF0FF; id=0xF007};
+  opcodes.(27) <- {mask = 0xF0FF; id=0xF00A};
+  opcodes.(28) <- {mask = 0xF0FF; id=0xF015};
+  opcodes.(29) <- {mask = 0xF0FF; id=0xF018};
+  opcodes.(30) <- {mask = 0xF0FF; id=0xF01E};
+  opcodes.(31) <- {mask = 0xF0FF; id=0xF029};
+  opcodes.(32) <- {mask = 0xF0FF; id=0xF033};
+  opcodes.(33) <- {mask = 0xF0FF; id=0xF055};
+  opcodes.(34) <- {mask = 0xF0FF; id=0xF065}
+(*
+** option.ml for OCaml-Chip8 in /home/surply_p
+** 
+** Made by Pierre Surply
+** <pierre.surply@gmail.com>
+** 
+** Started on  Sat Aug  4 22:28:30 2012 Pierre Surply
+** Last update Sat Aug  4 22:28:49 2012 Pierre Surply
+*)
+
+let is_some = function
+  | Some _ -> true
+  | _ -> false
+
+let get = function
+  | Some x -> x
+  | _ -> failwith "None option"
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.