include ../make.rules

EXECUTABLES     = gm2l gm2lcc m2f gm2lgen yac gm2lsub m2m                         \
                  gm2-i386-gas gm2-i386-masm gm2-apu gm2-i386-bas

CLIBRARYFILES   = Selective.c UnixArgs.c  libc.h                                  \
                  LowLevel.c  TimeDate.c  libc.c  wrapc.c

DEFFILES        = ASCII.def	 Environment.def  Math.def	   StrLib.def     \
                  Args.def	 FIO.def	  NumberIO.def	                  \
                  Assertion.def	 FileSystem.def	  SYSTEM.def       TimeDate.def   \
                  Break.def	 FpuIO.def	  Scan.def	   TimeString.def \
                          	 IO.def		  Selective.def	   UnixArgs.def   \
                  CmdArgs.def	 LowLevel.def	  StdIO.def	   libc.def       \
                  Debug.def	 M2RTS.def	  Storage.def	   wrapc.def      \
                  DebugPMD.def	                  StrCase.def                     \
                  DiskIO.def	 MATH.def	  StrIO.def        MemUtils.def   \
                  SysStorage.def Sort.def         Random.def

MODFILES        = ASCII.mod      Environment.mod  Math.mod         StrLib.mod     \
                  Args.mod       FIO.mod          NumberIO.mod                    \
                  Assertion.mod  FileSystem.mod   SYSTEM.mod                      \
                  Break.mod      FpuIO.mod        Scan.mod         TimeString.mod \
                                 IO.mod                                           \
                  CmdArgs.mod                     StdIO.mod                       \
                  Debug.mod      M2RTS.mod        Storage.mod                     \
                  DebugPMD.mod                    StrCase.mod                     \
                  DiskIO.mod     MATH.mod         StrIO.mod        MemUtils.mod   \
                  SysStorage.mod Sort.mod         Random.mod

MODLIBRARYFILES = $(DEFFILES) $(MODFILES)


help: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@echo " "
	@echo "$$PWD/makefile"
	@echo "knows about:"
	@echo "    all current stage0 stage1 stage2 stage3"
	@echo "    tools"
	@echo "    stage1.exe stage2.exe stage3.exe"
	@echo "    stage1.libs stage2.libs stage3.libs"
	@echo "    verify"
	@echo "    clean"
	@echo "    release"
	@echo "    install"
	@echo "    archive"
	@echo "    floppyarchive"
	@echo "    binary.release"
	@echo "    libs"

current: force
	@if [ -f $(STAGEFILE) ] ; then                          \
             number=`cat $(STAGEFILE)`                        ; \
             $(MAKE) stage$$number                            ; \
        else                                                    \
             echo "$$LOGNAME I don't know what stage you are currently building" ; \
             echo "try make stage0 stage1 stage2 or stage3"   ; \
        fi

all: checkBinDir stage0 stage1 stage2 stage3 # stage4
	@echo "made stage1 stage2 stage3 and stage4"

elisp: force
	@emacs -batch -q -l el/g-mode.el -f byte-compile

libs: force
	@cd libs ; $(MAKE) "GM2_2=m2f" -f makefile.stage3 all

libs.clean: force
	@cd libs ; $(MAKE) "GM2_2=m2f" -f makefile.stage3 clean

clean.libs: force
	@cd libs ; $(MAKE) "GM2_2=m2f" -f makefile.stage3 clean

tools: checkBinDir force
	@cd tools ; $(MAKE) all

stage0: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@$(RM) bin/*
	@cd p2c ; $(MAKE) all

stage0.clean: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd p2c   ; $(MAKE) clean

stage1: tools minor version config
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	-$(RM) bin1/gm2* bin1/m2* bin1/ya*
	@( cd libs ; $(MAKE) -f makefile.stage1 link )
	@if [ ! -f $(STAGEFILE) ] ; then                                 \
	    cd libs ; $(MAKE) -f makefile.stage1 clean ; cd ..         ; \
	    cd gm2s ; $(MAKE) -f makefile.stage1 clean ; cd ..         ; \
         else                                                            \
            number=`cat $(STAGEFILE)`                                  ; \
            if [ "$$number" != "1" ] ; then                              \
                if [ "$(DISKSPACE)" = "tight" ] ; then                   \
                    cd libs ; $(MAKE) -f makefile.stage1 clean ; cd .. ; \
                    cd gm2s ; $(MAKE) -f makefile.stage1 clean ; cd .. ; \
                fi                                                     ; \
            fi                                                         ; \
         fi
	@echo "1" > $(STAGEFILE)
	@cd libs ; $(MAKE) -f makefile.stage1 all
	@cd gm2s ; $(MAKE) -f makefile.stage1 all

stage1.exe: tools
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd gm2s ; $(MAKE) -f makefile.stage1 exe

stage1.libs: tools
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage1 all

stage1.clean: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage1 clean ; cd ..
	@cd gm2s ; $(MAKE) -f makefile.stage1 clean ; cd ..
	@$(RM) gm2s/386-gas/M2Configure.def   # built by tools/makeconfigure

stage2.test: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@echo "BINDIR1 = $(BINDIR1)"
	@cd libs ; $(MAKE) -f makefile.stage2 test
	@cd gm2s ; $(MAKE) -f makefile.stage2 test

stage2: minor version config
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	-$(RM) bin2/gm2* bin2/m2* bin2/ya*
	@if [ ! -f $(STAGEFILE) ] ; then                                 \
            echo "no stage found we will clean stage 1"                ; \
	    cd libs ; $(MAKE) -f makefile.stage1 clean ; cd ..         ; \
	    cd gm2s ; $(MAKE) -f makefile.stage1 clean ; cd ..         ; \
         else                                                            \
            number=`cat $(STAGEFILE)`                                  ; \
            if [ "$$number" != "2" ] ; then                              \
                if [ "$(DISKSPACE)" = "tight" ] ; then                   \
                    cd libs ; $(MAKE) -f makefile.stage1 clean ; cd .. ; \
                    cd gm2s ; $(MAKE) -f makefile.stage1 clean ; cd .. ; \
                fi                                                     ; \
            fi                                                         ; \
         fi                                                            ; \
	echo "2" > $(STAGEFILE)
	@echo "    now build $@ *.o files"
	@cd libs ; $(MAKE) -f makefile.stage1 link
	@cd gm2s ; $(MAKE) -f makefile.stage1 links
	@cd libs ; $(MAKE) -f makefile.stage2 all
	@cd gm2s ; $(MAKE) -f makefile.stage2 all

stage2.exe: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd gm2s ; $(MAKE) -f makefile.stage2 exe

stage2.libs: tools
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage2 all

stage2.clean: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage2 clean
	@cd gm2s ; $(MAKE) -f makefile.stage2 clean
	@$(RM) gm2s/386-gas/M2Configure.def   # built by MAKECONFIGURE

stage3: minor version config
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	-$(RM) bin3/gm2* bin3/m2* bin3/ya*
	@if [ "$(ARCH)" = "i386" ] ; then                                    \
            if [ ! -f $(STAGEFILE) ] ; then                                  \
                cd libs ; $(MAKE) -f makefile.stage2 clean ; cd ..         ; \
                cd gm2s ; $(MAKE) -f makefile.stage2 clean ; cd ..         ; \
            else                                                             \
                number=`cat $(STAGEFILE)`                                  ; \
                if [ "$$number" != "3" ] ; then                              \
                    if [ "$(DISKSPACE)" = "tight" ] ; then                   \
                        cd libs ; $(MAKE) -f makefile.stage2 clean ; cd .. ; \
                        cd gm2s ; $(MAKE) -f makefile.stage2 clean ; cd .. ; \
                    fi                                                     ; \
                fi                                                         ; \
            fi                                                             ; \
            echo "3" > $(STAGEFILE)                                        ; \
            cd libs ; $(MAKE) -f makefile.stage3 all   ; cd ..             ; \
            cd gm2s ; $(MAKE) -f makefile.stage3 all   ; cd ..             ; \
        else                                                                 \
            echo "cannot build stage3 on $(ARCH)"                          ; \
        fi

stage3.exe: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@if [ $(ARCH) = "i386" ] ; then                   \
	    cd gm2s ; $(MAKE) -f makefile.stage3 exe    ; \
        else                                              \
            echo "cannot build stage3 on $(ARCH)"       ; \
        fi

stage4: minor version config checkBinDir
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	-$(RM) bin4/gm2* bin4/m2* bin4/ya*
	@if [ "$(ARCH)" = "i386" ] ; then                                    \
            if [ ! -f $(STAGEFILE) ] ; then                                  \
                cd libs ; $(MAKE) -f makefile.stage4 clean ; cd ..         ; \
                cd gm2s ; $(MAKE) -f makefile.stage4 clean ; cd ..         ; \
            else                                                             \
                number=`cat $(STAGEFILE)`                                  ; \
                if [ "$$number" != "4" ] ; then                              \
                    if [ "$(DISKSPACE)" = "tight" ] ; then                   \
                        cd libs ; $(MAKE) -f makefile.stage4 clean ; cd .. ; \
                        cd gm2s ; $(MAKE) -f makefile.stage4 clean ; cd .. ; \
                    fi                                                     ; \
                fi                                                         ; \
            fi                                                             ; \
            echo "4" > $(STAGEFILE)                                        ; \
            cd libs ; $(MAKE) -f makefile.stage4 all   ; cd ..             ; \
            cd gm2s ; $(MAKE) -f makefile.stage4 all   ; cd ..             ; \
        else                                                                 \
            echo "cannot build stage4 on $(ARCH)"                          ; \
        fi

86: force
	@echo "---------------------------------------"
	@echo "           quick $@"
	@echo "---------------------------------------"
	@if [ $(ARCH) = "i386" ] ; then                   \
	    cd gm2s ; $(MAKE) -f makefile.stage3          \
                              gm2-i386-bas              ; \
        else                                              \
            echo "cannot build stage3 86 on $(ARCH)"    ; \
        fi

stage3.clean: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage3 clean
	@cd gm2s ; $(MAKE) -f makefile.stage3 clean
	@$(RM) gm2s/386-gas/M2Configure.def   # built by MAKECONFIGURE

stage3.libs: tools
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage3 all

stage4.clean: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.stage4 clean
	@cd gm2s ; $(MAKE) -f makefile.stage4 clean

verify: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd libs ; $(MAKE) -f makefile.verify all
	@cd gm2s ; $(MAKE) -f makefile.verify all

verifydynamic: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@export DYNAMIC=yes ; cd libs ; $(MAKE) -f makefile.verify all
	@export DYNAMIC=yes ; cd gm2s ; $(MAKE) -f makefile.verify all

reconfig: force
	@$(RM) gm2s/386-gas/M2Configure.def
	@$(MAKE) config

config: force
	@if [ ! -f gm2s/386-gas/M2Configure.def ] ; then \
              echo "---------------------------------------" ; \
              echo "                $@" ; \
              echo "---------------------------------------" ; \
              cd gm2s/386-gas ; \
              echo $(RELEASEROOT)/libs > librarydirectory ; \
              $(MAKECONFIGURE) ; \
              $(RM) librarydirectory ; \
         fi

version: force
	@cd gm2s ; \
	$(MAKEVERSION) "`cat $(MAJORFILE)`.`cat $(MINORFILE)`.`cat $(STAGEFILE)`" ; \
	cd ..
	@if [ "${M2OPTIONS}" != "" ] ; then \
	    echo " " ; \
	    echo " M2OPTIONS are:" ${M2OPTIONS} ; \
	    echo " " ; \
        fi
	@for i in ${M2OPTIONS} ; do \
            if [ $$i = "-g" ] ; then \
                echo "  ***** Note -g will generate static binaries *****" ; \
            fi ; \
        done

clean: cleanFiles cleanBinDir
	( cd man ; make clean )
	@find . -name 'core' -exec rm -f {} \;
	@find . -name '#*' -exec rm -f {} \;
	@find . -name 'gmon.out' -exec rm -f {} \;

cleanFiles: force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@cd tools     ; $(MAKE) clean
	@cd libs      ; $(MAKE) -f makefile.stage1 clean
	@cd gm2s      ; $(MAKE) -f makefile.stage1 clean
	@cd libs      ; $(MAKE) -f makefile.stage2 clean
	@cd gm2s      ; $(MAKE) -f makefile.stage2 clean
	@cd libs      ; $(MAKE) -f makefile.stage3 clean
	@cd gm2s      ; $(MAKE) -f makefile.stage3 clean
	@cd libs      ; $(MAKE) -f makefile.stage4 clean
	@cd gm2s      ; $(MAKE) -f makefile.stage4 clean
	@cd libs      ; $(MAKE) -f makefile.verify clean
	@cd gm2s      ; $(MAKE) -f makefile.verify clean
	@cd p2c       ; $(MAKE) clean
	@cd autotest  ; $(MAKE) clean
	@cd test      ; $(MAKE) clean
	@$(RM) gm2s/386-gas/M2Configure.def   # built by MAKECONFIGURE
	@$(RM) gm2s/M2Version.mod             # built by tools/makeversion
	@$(RM) testus.c testus.s $(STAGEFILE) *~

release: force
	@NAME=m2f-`cat .major`.`cat .minor` ; \
	echo "---------------------------------------" ; \
	echo "                $@  $$NAME" ; \
	echo "---------------------------------------" ; \
        rm -rf $(SOURCEDIR)/$$NAME ; rm -f $(SOURCEDIR)/$$NAME.tar.gz ; \
	mkdir -p $(SOURCEDIR)/$$NAME ; \
        cp ../make.rules  $(SOURCEDIR)/$$NAME ; \
        cp ../makefile $(SOURCEDIR)/$$NAME ; \
        cp README $(SOURCEDIR)/$$NAME ; \
        cp COPYING $(SOURCEDIR)/$$NAME ; \
        cd .. ; tar cf - comp | ( cd $(SOURCEDIR)/$$NAME ; tar xf - ) ; \
        cd $(SOURCEDIR) ; tar cf $$NAME.tar $$NAME ; gzip -9 $$NAME.tar

install: installdirs force
	@echo "---------------------------------------"
	@echo "                $@"
	@echo "---------------------------------------"
	@createLink () {                                                              \
            if [ -f $$1 ] ; then                                                      \
                if [ -f $$2 ] ; then                                                  \
                    $(RM) $$2                                                       ; \
                fi                                                                  ; \
                chmod +X $$1                                                        ; \
                cp $$1 $$2                                                          ; \
                if [ -x $$2 ] ; then                                                  \
                   strip $$2                                                        ; \
                   $(RM) $(PUBLICBIN)/`basename $$2`                                ; \
                   $(LN) -sf $$2 $(PUBLICBIN)/`basename $$2`                        ; \
                fi                                                                  ; \
            else                                                                      \
                echo " "                                                            ; \
                echo -n "file cannot be found ($$1)"                                ; \
            fi                                                                        \
        }                                                                           ; \
                                                                                      \
        echo "installing compiler into:" $(RELEASEROOT)                             ; \
        echo -n "installing binaries    : "                                         ; \
        for i in $(EXECUTABLES) ; do                                                  \
            createLink `pwd`/bin3/$$i $(RELEASEROOT)/bin/$$i                        ; \
            echo -n " $$i"                                                          ; \
        done                                                                        ; \
        echo " "                                                                    ; \
        echo "manual page            :  m2f"                                        ; \
        groff -Tascii -man man/m2f.L > man/m2f.cat                                  ; \
        createLink `pwd`/man/m2f.cat $(RELEASEROOT)/man/cat1/m2f.1                  ; \
        $(RM) -f /usr/man/man1/m2f.1                                                ; \
        $(LN) -sf $(RELEASEROOT)/man/cat1/m2f.1 /usr/man/man1/m2f.1                 ; \
        if [ -f /usr/man/whatis ] ; then                                              \
            if ! grep m2f /usr/man/whatis | grep compiler ; then                      \
                $(COPY) /usr/man/whatis /usr/man/whatis.old                         ; \
                grep -v m2f /usr/man/whatis > /tmp/whatis.m2f                       ; \
                echo "m2f (1)              - modula-2 compiler" >> /tmp/whatis.m2f  ; \
                $(COPY) /tmp/whatis.m2f /usr/man/whatis                             ; \
            fi                                                                      ; \
        fi                                                                          ; \
        echo "source library modules :"                                             ; \
        j=0                                                                         ; \
        for i in $(CLIBRARYFILES) $(MODLIBRARYFILES) ; do                             \
            echo -n "$$i	"                                                   ; \
            if [ ! -f libs/$$i ] && [ ! -L libs/$$i ] ; then                          \
                echo "error cannot find $$i"                                        ; \
                exit 1                                                              ; \
            fi                                                                      ; \
            cp libs/$$i $(RELEASEROOT)/libs                                         ; \
            j=`expr $$j + 1`                                                        ; \
            if [ "`expr $$j % 4`" = "0" ] ; then                                      \
                echo ""                                                             ; \
            fi                                                                      ; \
       done                                                                         ; \
       echo ""                                                                      ; \
       echo "objects for library modules:"                                          ; \
       j=0                                                                          ; \
       for i in libs/*.o ; do                                                         \
           echo -n "$$i	"                                                           ; \
           if [ ! -f $$i ] && [ ! -L $$i ] ; then                                     \
               echo "error cannot find $$i"                                         ; \
               exit 1                                                               ; \
           fi                                                                       ; \
           cp $$i $(RELEASEROOT)/libs                                               ; \
           j=`expr $$j + 1`                                                         ; \
           if [ "`expr $$j % 4`" = "0" ] ; then                                       \
               echo ""                                                              ; \
           fi                                                                       ; \
       done                                                                         ; \
       echo " " ; echo "install complete"

installdirs: force
	@if [ "$(RELEASEROOT)" = "" ] ; then                                          \
            echo "$(LOGNAME) you need to set the RELEASEROOT environment variable"  ; \
            exit 1                                                                  ; \
        fi                                                                          ; \
        if [ ! -d $(RELEASEROOT) ] ; then                                             \
            mkdir $(RELEASEROOT)                                                    ; \
        fi                                                                          ; \
        if [ ! -d $(RELEASEROOT)/bin ] ; then                                         \
            mkdir $(RELEASEROOT)/bin                                                ; \
        fi                                                                          ; \
        if [ ! -d $(RELEASEROOT)/libs ] ; then                                        \
            mkdir $(RELEASEROOT)/libs                                               ; \
        fi                                                                          ; \
        if [ ! -d $(RELEASEROOT)/man ] ; then                                         \
            mkdir $(RELEASEROOT)/man                                                ; \
        fi                                                                          ; \
        if [ ! -d $(RELEASEROOT)/man/cat1 ] ; then                                    \
            mkdir $(RELEASEROOT)/man/cat1                                           ; \
        fi

binary.install: force
	@echo "-----------------------------------------------------------------------"
	@echo "$@  -  (assumes install or release has been performed by root)"
	@echo "-----------------------------------------------------------------------"
	@cd ..                                                                      ; \
	CURRENTDIR=`pwd`                                                            ; \
        ARCHIVENAME=`basename $$CURRENTDIR`.bin.tgz                                 ; \
        cd /                                                                        ; \
        echo "creating $$CURRENTDIR/$$ARCHIVENAME"                                  ; \
        tar cf - $(RELEASEROOT)                                                       \
                 $(PUBLICBIN)/gm2l                                                    \
                 $(PUBLICBIN)/gm2lcc                                                  \
                 $(PUBLICBIN)/m2f                                                     \
                 $(PUBLICBIN)/gm2lgen                                                 \
                 $(PUBLICBIN)/yac                                                     \
                 $(PUBLICBIN)/gm2lsub                                                 \
                 $(PUBLICBIN)/m2m                                                     \
                 $(PUBLICBIN)/gm2-i386-gas                                            \
                 $(PUBLICBIN)/gm2-i386-masm                                           \
                 $(PUBLICBIN)/gm2-apu                                                 \
                 $(PUBLICBIN)/gm2-i386-bas                                            \
                 /usr/man/man1/m2f.1 | gzip -9 > $$CURRENTDIR/$$ARCHIVENAME

minor: force
	@$(INCFILE) $(MINORFILE)

major: force
	@$(INCFILE) $(MAJORFILE)

archive: force
	@cd .. ; make archive

floppyarchive: force
	@cd .. ; make floppyarchive

checkBinDir:
	@if [ ! -d $(BINDIR) ]  ; \
	then                      \
           mkdir $(BINDIR)      ; \
        fi
	@if [ ! -d $(BINDIR1) ] ; \
	then                      \
           mkdir $(BINDIR1)     ; \
        fi
	@if [ ! -d $(BINDIR2) ] ; \
	then                      \
           mkdir $(BINDIR2)     ; \
        fi
	@if [ ! -d $(BINDIR3) ] ; \
	then                      \
           mkdir $(BINDIR3)     ; \
        fi
	@if [ ! -d $(BINDIR4) ] ; \
	then                      \
           mkdir $(BINDIR4)     ; \
        fi

cleanBinDir:
	-@if [ -d $(BINDIR) ]   ; \
	then                      \
           for i in $(BINDIR)/* ; do \
              if [ ! -d $$i ] ; then \
	         $(RM) $$i      ; \
              fi                ; \
           done                 ; \
	fi
	-@if [ -d $(BINDIR1) ]  ; \
	then                      \
           for i in $(BINDIR1)/* ; do \
              if [ ! -d $$i ] ; then \
	         $(RM) $$i      ; \
              fi                ; \
           done                 ; \
	fi
	-@if [ -d $(BINDIR2) ]  ; \
	then                      \
           for i in $(BINDIR2)/* ; do \
              if [ ! -d $$i ] ; then \
	         $(RM) $$i      ; \
              fi                ; \
           done                 ; \
	fi
	-@if [ -d $(BINDIR3) ]  ; \
	then                      \
           for i in $(BINDIR3)/* ; do \
              if [ ! -d $$i ] ; then \
	         $(RM) $$i      ; \
              fi                ; \
           done                 ; \
	fi
	-@if [ -d $(BINDIR4) ]  ; \
	then                      \
           for i in $(BINDIR4)/* ; do \
              if [ ! -d $$i ] ; then \
	         $(RM) $$i      ; \
              fi                ; \
           done                 ; \
	fi
	-@rmdir $(BINDIR)
	-@rmdir $(BINDIR1)
	-@rmdir $(BINDIR2)
	-@rmdir $(BINDIR3)
	-@rmdir $(BINDIR4)

force:
	
