ocaml/Makefile.Mac

# The main Makefile

MacVersion = "mac.3"

CAMLC = :boot:ocamlrun :boot:ocamlc -I :boot:
COMPFLAGS = {INCLUDES}
LINKFLAGS =
CAMLYACC = :boot:ocamlyacc
YACCFLAGS =
CAMLLEX = :boot:ocamlrun :boot:ocamllex
CAMLDEP = :boot:ocamlrun :tools:ocamldep
DEPFLAGS = {INCLUDES}
CAMLRUN = :byterun:ocamlrun

INCLUDES = -I :utils: -I :parsing: -I :typing: -I :bytecomp: <20>
           -I :driver: -I :toplevel:

UTILS = :utils:misc.cmo :utils:tbl.cmo :utils:config.cmo <20>
        :utils:clflags.cmo :utils:terminfo.cmo :utils:ccomp.cmo

PARSING = :parsing:linenum.cmo :parsing:location.cmo :parsing:longident.cmo <20>
          :parsing:pstream.cmo :parsing:parser.cmo :parsing:lexer.cmo <20>
          :parsing:parse.cmo

TYPING = :typing:ident.cmo :typing:path.cmo <20>
  :typing:primitive.cmo :typing:types.cmo <20>
  :typing:btype.cmo <20>
  :typing:subst.cmo :typing:predef.cmo <20>
  :typing:datarepr.cmo :typing:env.cmo <20>
  :typing:typedtree.cmo <20>
  :typing:ctype.cmo :typing:printtyp.cmo <20>
  :typing:mtype.cmo :typing:includecore.cmo <20>
  :typing:includemod.cmo :typing:parmatch.cmo <20>
  :typing:typetexp.cmo :typing:typecore.cmo <20>
  :typing:typedecl.cmo :typing:typeclass.cmo <20>
  :typing:typemod.cmo

COMP = :bytecomp:lambda.cmo :bytecomp:printlambda.cmo <20>
  :bytecomp:translobj.cmo :bytecomp:matching.cmo :bytecomp:translcore.cmo <20>
  :bytecomp:translclass.cmo :bytecomp:translmod.cmo <20>
  :bytecomp:simplif.cmo :bytecomp:runtimedef.cmo

BYTECOMP = :bytecomp:meta.cmo :bytecomp:instruct.cmo :bytecomp:bytegen.cmo <20>
  :bytecomp:printinstr.cmo :bytecomp:opcodes.cmo :bytecomp:emitcode.cmo <20>
  :bytecomp:symtable.cmo :bytecomp:bytelibrarian.cmo :bytecomp:bytelink.cmo

DRIVER = :driver:errors.cmo :driver:compile.cmo :driver:main.cmo

TOPLEVEL = :driver:errors.cmo :driver:compile.cmo <20>
  :toplevel:genprintval.cmo <20>
  :toplevel:printval.cmo :toplevel:toploop.cmo <20>
  :toplevel:trace.cmo :toplevel:topdirs.cmo

TOPLEVELMAIN = :toplevel:topmain.cmo

COMPOBJS = {UTILS} {PARSING} {TYPING} {COMP} {BYTECOMP} {DRIVER}

TOPLIB = {UTILS} {PARSING} {TYPING} {COMP} {BYTECOMP} {TOPLEVEL}

EXPUNGEOBJS = :utils:misc.cmo :utils:tbl.cmo <20>
  :utils:config.cmo :utils:clflags.cmo <20>
  :typing:ident.cmo :typing:types.cmo :typing:btype.cmo :typing:predef.cmo <20>
  :bytecomp:runtimedef.cmo :bytecomp:symtable.cmo <20>
  :toplevel:expunge.cmo

PERVASIVES = arg array char digest filename format gc hashtbl lexing list map <20>
  obj parsing pervasives printexc printf queue random set sort <20>
  stack string stream sys oo genlex topdirs weak

# Recompile the system using the bootstrap compiler
all <EFBFBD> runtime ocamlc ocamllex ocamlyacc ocamltools library ocaml otherlibraries

# The compilation of ocaml will fail if the runtime has changed.
# Never mind, just do make bootstrap to reach fixpoint again.

# Compile everything the first time
world <EFBFBD>
    domake coldstart
    domake all

# Complete bootstrapping cycle
bootstrap <EFBFBD>
      # Save the original bootstrap compiler
    domake backup
      # Promote the new compiler but keep the old runtime
      # This compiler runs on :boot:ocamlrun and produces bytecode for
      # :byterun:ocamlrun
    domake promote-cross
      # Rebuild ocamlc and ocamllex (run on :byterun:ocamlrun)
    domake partialclean
    domake ocamlc ocamllex
      # Rebuild the library (using :byterun:ocamlrun :ocamlc)
    domake library-cross
      # Promote the new compiler and the new runtime
    domake promote
      # Rebuild everything, including ocaml and the tools
    domake partialclean
    domake all
      # Check if fixpoint reached
    domake compare
    beep

LIBFILES = :stdlib.cma :std_exit.cmo :<3A>.cmi camlheader

# Start up the system from the distribution compiler
coldstart <EFBFBD>
    directory :byterun; domake all; directory ::
    duplicate -y :byterun:ocamlrun :boot:ocamlrun
    directory :yacc; domake all; directory ::
    duplicate -y :yacc:ocamlyacc :boot:ocamlyacc
    directory :stdlib
    domake -d COMPILER=::boot:ocamlc all
    duplicate -y {LIBFILES} ::boot:
    directory ::

# Save the current bootstrap compiler
backup <EFBFBD>
    if `exists -d :boot:Saved:` == ""
      newfolder :boot:Saved:
    end
    move :boot:Saved: :boot:Saved.prev:
    newfolder :boot:Saved:
    move :boot:Saved.prev: :boot:Saved:Saved.prev:
    duplicate -y :boot:ocamlrun :boot:Saved:
    move :boot:ocamlc :boot:ocamllex :boot:ocamlyacc :boot:Saved:
    directory :boot; duplicate -y {LIBFILES} :Saved:; directory ::

# Promote the newly compiled system to the rank of cross compiler
# (Runs on the old runtime, produces code for the new runtime)
promote-cross <EFBFBD>
    duplicate -y :ocamlc :boot:ocamlc
    duplicate -y :lex:ocamllex :boot:ocamllex
    duplicate -y :yacc:ocamlyacc :boot:ocamlyacc
    directory :stdlib
    duplicate -y {LIBFILES} ::boot: || set status 0
    directory ::

# Promote the newly compiled system to the rank of bootstrap compiler
# (Runs on the new runtime, produces code for the new runtime)
promote <EFBFBD> promote-cross
    duplicate -y :byterun:ocamlrun :boot:ocamlrun

clean <EFBFBD><EFBFBD>
    delete -i :boot:<3A>.cm[aio] || set status 0
    delete -i :boot:camlheader :boot:ocamlrun :boot:ocamlyacc

# Restore the saved bootstrap compiler if a problem arises
restore <EFBFBD>
    move -y :boot:Saved:<3A> :boot:
    delete -y :boot:Saved:
    move -y :boot:Saved.prev: :boot:Saved:

# Check if fixpoint reached
compare <EFBFBD>
    set exit 0
    equal -q :boot:ocamlc :ocamlc && equal -q :boot:ocamllex :lex:ocamllex
    if {status}
      echo "<22>nFixpoint not reached, try one more bootstrapping cycle.<2E>n"
    else
      echo "<22>nFixpoint reached, bootstrap succeeded.<2E>n"
    end

# Remove old bootstrap compilers
cleanboot <EFBFBD>
    delete -i -y :boot:Saved:Saved.prev:<3A> || set status 0

# Installation
install <EFBFBD> $OutOfDate
    flush
    for i in "{BINDIR}" "{LIBDIR}"
      if "`exists -d "{i}"`" == ""
        newfolder "{i}"
      end
    end
    directory :byterun:
    domake install
    directory ::
    duplicate -y :ocamlc "{BINDIR}ocamlc"
    duplicate -y :ocaml "{BINDIR}ocaml"
    directory :stdlib:
    domake install
    directory ::
    duplicate -y :lex:ocamllex "{BINDIR}ocamllex"
    duplicate -y :yacc:ocamlyacc "{BINDIR}ocamlyacc"
    duplicate -y toplevellib.cma expunge "{LIBDIR}"
    duplicate -y :toplevel:topmain.cmo "{LIBDIR}topmain.cmo"
    duplicate -y :toplevel:toploop.cmi :toplevel:topdirs.cmi "{LIBDIR}"
    directory :tools:
    domake install
    directory ::
    duplicate -y :man:ocaml.help "{HELPFILE}"
    for i in {OTHERLIBRARIES}
      directory :otherlibs:{i}
      domake install
      directory :::
    end

clean <EFBFBD><EFBFBD> partialclean

# The compiler

ocamlc <EFBFBD> {COMPOBJS}
    {CAMLC} {LINKFLAGS} -o ocamlc {COMPOBJS}

partialclean <EFBFBD><EFBFBD>
    delete -i ocamlc

# The toplevel

ocaml <EFBFBD> toplevellib.cma {TOPLEVELMAIN} expunge
    {CAMLC} {LINKFLAGS} -linkall -o ocaml.tmp toplevellib.cma {TOPLEVELMAIN}
    {CAMLRUN} :expunge ocaml.tmp ocaml {PERVASIVES} || set status 0
    delete -i ocaml.tmp

toplevellib.cma <EFBFBD> {TOPLIB}
    {CAMLC} -a -o toplevellib.cma {TOPLIB}

partialclean <EFBFBD><EFBFBD>
    delete -i ocaml toplevellib.cma

# The configuration file

:utils:config.ml <20> :utils:config.mlp :config:config.Mac
    delete -i :utils:config.ml
    streamedit -e "/let version =/ replace /<2F><><EFBFBD>"<EFBFBD>/ <20>"/{MacVersion}<7D><><EFBFBD>"<EFBFBD>"" <20>
               -e "1,$ replace /%%LIBDIR%%/ <20>"{LIBDIR}<EFBFBD>"" <20>
               -e "1,$ replace /%%EXT_OBJ%%/ '.o'" <20>
               -e "1,$ replace /%%EXT_LIB%%/ '.x'" <20>
               :utils:config.mlp > :utils:config.ml

partialclean <EFBFBD><EFBFBD>
    delete -i :utils:config.ml

beforedepend <20><> :utils:config.ml

# The parser

:parsing:parser.mli <20> :parsing:parser.ml
    echo -n

:parsing:parser.ml <20> :parsing:parser.mly
    {CAMLYACC} {YACCFLAGS} :parsing:parser.mly

partialclean <EFBFBD><EFBFBD>
    delete -i :parsing:parser.mli :parsing:parser.ml :parsing:parser.output

beforedepend <20><> :parsing:parser.mli :parsing:parser.ml

# The lexer

:parsing:lexer.ml <20> :parsing:lexer.mll
    {CAMLLEX} :parsing:lexer.mll

partialclean <EFBFBD><EFBFBD>
    delete -i :parsing:lexer.ml

beforedepend <20><> :parsing:lexer.ml

# The auxiliary lexer for counting line numbers

:parsing:linenum.ml <20> :parsing:linenum.mll
    {CAMLLEX} :parsing:linenum.mll

partialclean <EFBFBD><EFBFBD>
    delete -i :parsing:linenum.ml

beforedepend <20><> :parsing:linenum.ml

# The numeric opcodes

:bytecomp:opcodes.ml <20> :byterun:instruct.h
    :tools:make-opcodes.Mac :byterun:instruct.h :bytecomp:opcodes.ml

partialclean <EFBFBD><EFBFBD>
    delete -i :bytecomp:opcodes.ml

beforedepend <20><> :bytecomp:opcodes.ml

# The predefined exceptions and primitives

:byterun:primitives <20>
    directory :byterun:
    domake primitives
    directory ::

:bytecomp:runtimedef.ml <20> :byterun:primitives :byterun:fail.h
    (echo 'let builtin_exceptions = [|' ; <20>
     streamedit -d -e '/<2F>/<2F>* (<28>"[A-Za-z_]*<2A>")<29>0 <20>*<2A>/<2F>/ print <20>0 ";"' :byterun:fail.h | <20>
     streamedit -e '$ replace /;<3B>/ "|]"'; <20>
     echo 'let builtin_primitives = [|'; <20>
     streamedit -e "1,$ replace /(<28>)<29>0/ '  <20>"' <20>0 '<EFBFBD>";'" -e '$ replace /;<3B>/ "|]"' :byterun:primitives; <20>
    ) > :bytecomp:runtimedef.ml

partialclean <EFBFBD><EFBFBD>
    delete -i :bytecomp:runtimedef.ml

beforedepend <20><> :bytecomp:runtimedef.ml

# The "expunge" utility

expunge <EFBFBD> {EXPUNGEOBJS}
    {CAMLC} {LINKFLAGS} -o expunge {EXPUNGEOBJS}

partialclean <EFBFBD><EFBFBD>
    delete -i expunge

# The runtime system for the bytecode compiler

runtime <EFBFBD>
    directory :byterun:; domake all; directory ::
clean <EFBFBD><EFBFBD>
    directory :byterun:; domake clean; directory ::
alldepend <EFBFBD><EFBFBD>
    directory :byterun:; domake depend; directory ::

# The library

library <EFBFBD>
    directory :stdlib; domake all; directory ::
library-cross <EFBFBD>
    directory :stdlib; domake -d RUNTIME=::byterun:ocamlrun all; directory ::
partialclean <EFBFBD><EFBFBD>
    directory :stdlib; domake clean; directory ::
alldepend <EFBFBD><EFBFBD>
    directory :stdlib; domake depend; directory ::

# The lexer and parser generators

ocamllex <EFBFBD>
    directory :lex; domake all; directory ::
partialclean <EFBFBD><EFBFBD>
    directory :lex; domake clean; directory ::
alldepend <EFBFBD><EFBFBD>
    directory :lex; domake depend; directory ::

ocamlyacc <EFBFBD>
    directory :yacc; domake all; directory ::
clean <EFBFBD><EFBFBD>
    directory :yacc; domake clean; directory ::

# Tools

ocamltools <EFBFBD>
    directory :tools; domake all; directory ::
partialclean <EFBFBD><EFBFBD>
    directory :tools; domake clean; directory ::
alldepend <EFBFBD><EFBFBD>
    directory :tools; domake depend; directory ::

# The extra libraries

otherlibraries <EFBFBD>
    for i in {OTHERLIBRARIES}
      directory :otherlibs:{i}; domake all; directory :::
    end
partialclean <EFBFBD><EFBFBD>
    for i in {OTHERLIBRARIES}
      directory :otherlibs:{i}; domake partialclean; directory :::
    end
clean <EFBFBD><EFBFBD>
    for i in {OTHERLIBRARIES}
      directory :otherlibs:{i}; domake clean; directory :::
    end
alldepend <EFBFBD><EFBFBD>
    for i in {OTHERLIBRARIES}
      directory :otherlibs:{i}; domake depend; directory :::
    end

# Clean up the test directory

clean <EFBFBD><EFBFBD>
    if `exists :test`
      directory :test; domake clean; directory ::
    end

# Default rules

.cmo <EFBFBD> .ml
    {CAMLC} {COMPFLAGS} -c {depdir}{default}.ml

.cmi <EFBFBD> .mli
    {CAMLC} {COMPFLAGS} -c {depdir}{default}.mli

partialclean <EFBFBD><EFBFBD>
    for i in utils parsing typing bytecomp driver toplevel tools
      delete -i :{i}:<3A>.cm[io] || set status 0
    end

depend <EFBFBD> beforedepend
    for d in utils parsing typing bytecomp driver toplevel
      {CAMLDEP} {DEPFLAGS} :{d}:<3A>.mli :{d}:<3A>.ml
    end > Makefile.Mac.depend

alldepend <EFBFBD><EFBFBD> depend

# Make sure the config file was executed
dummy <EFBFBD> {OTHERLIBRARIES}