### makefile to create byacc3.0 for amiga-os
### this only works with sas-c 6.5x installed

### $VER byacc_smakefile 3.01 (19 Aug 1996)  koessi

### usage:
###   smake        - to create all dirs and build executable
###                  MUST be called first!
###   smake exe    - to build executable for any 680x0 cpu
###   smake exe020 - to build executable for >=68020 cpu
###   smake difs   - to build diffs-file
###   smake pats   - to build and archive patch-files
###   smake srcs   - to apply the patches
###   smake clean  - to remove all created dirs and files
###                  newly created exe-files are kept

### local scoptions used:
###
###   MATH=STANDARD
###   NOSTACKCHECK
###   NOCHECKABORT
###   ERRORREXX
###   NOMULTIPLEINCLUDES
###   OPTIMIZE
###   NOWARNVOIDRETURN
###   SMALLCODE
###   SMALLDATA
###   VERBOSE
###   STRIPDEBUG
###   NOVERSION
###   NOICONS
###   NOGENPROTODATAITEMS
###   DEFINE _AMIGA

### def macros

YACC   = byacc-3.0

OBJD   = obj
OBJD2  = $(OBJD)/020
PROD   = protos
PATD   = pch
YACD   = $(YACC)

BAT    = tmp.bat
DIFS   = amiga.diffs
PARC   = pch.lha
YARC   = $(YACC).lha

EXE    = byacc

CP     = c:copy
RN     = c:rename
RM     = c:delete QUIET
RMDIR  = c:delete QUIET ALL
MKDIR  = c:makedir
EXEC   = c:execute
LS     = c:list
CHMOD  = c:protect
LHA    = lha

XTRARC = $(LHA) -IT x
UPDARC = $(LHA) -Imxr u

CC     = sc:c/sc
CMP    = sc:c/scompare
DIFF   = sc:c/diff
LD     = sc:c/slink
MAKE   = sc:c/smake
PATCH  = sc:c/spatch

CPU    = ANY
CFLAGS = OBJNAME $(OBJD)/ CPU $(CPU) NOLINK
LOPTS  = LINK PNAME $(EXE)
POPTS  = NOMINC GPROTO GPFILE

PROTOS = $(PROD)/closure_protos.h \
         $(PROD)/error_protos.h \
         $(PROD)/lalr_protos.h \
         $(PROD)/lr0_protos.h \
         $(PROD)/main_protos.h \
         $(PROD)/mkpar_protos.h \
         $(PROD)/output_protos.h \
         $(PROD)/reader_protos.h \
         $(PROD)/skeleton_protos.h \
         $(PROD)/symtab_protos.h \
         $(PROD)/verbose_protos.h \
         $(PROD)/warshall_protos.h

OBJS   = $(OBJD)/closure.o \
         $(OBJD)/error.o \
         $(OBJD)/lalr.o \
         $(OBJD)/lr0.o \
         $(OBJD)/main.o \
         $(OBJD)/mkpar.o \
         $(OBJD)/output.o \
         $(OBJD)/reader.o \
         $(OBJD)/skeleton.o \
         $(OBJD)/symtab.o \
         $(OBJD)/verbose.o \
         $(OBJD)/warshall.o

SRCS   = defs.h \
         closure.c \
         error.c \
         lalr.c \
         lr0.c \
         main.c \
         mkpar.c \
         output.c \
         reader.c \
         skeleton.c \
         symtab.c \
         verbose.c \
         warshall.c


### cmdline options

all         : $(OBJD) $(PROD) $(YACD) $(PATD)
        $(MAKE) exe

exe         : $(EXE)

exe020      : $(OBJD) $(PROD) $(YACD) $(PATD)
        -$(RM) $(EXE).000
        -$(RN) $(EXE) AS $(EXE).000
        $(MAKE) exe CPU=68020 OBJD=$(OBJD2)
        -$(RM) $(EXE).020
        -$(RN) $(EXE) AS $(EXE).020
        -$(RN) $(EXE).000 AS $(EXE)


difs        : $(DIFS)

srcs        : $(SRCS)

pats        :
        -$(CMP) -o$(PATD)/defs.pch     $(YACD)/defs.h     defs.h
        -$(CMP) -o$(PATD)/closure.pch  $(YACD)/closure.c  closure.c
        -$(CMP) -o$(PATD)/error.pch    $(YACD)/error.c    error.c
        -$(CMP) -o$(PATD)/lalr.pch     $(YACD)/lalr.c     lalr.c
        -$(CMP) -o$(PATD)/lr0.pch      $(YACD)/lr0.c      lr0.c
        -$(CMP) -o$(PATD)/main.pch     $(YACD)/main.c     main.c
        -$(CMP) -o$(PATD)/mkpar.pch    $(YACD)/mkpar.c    mkpar.c
        -$(CMP) -o$(PATD)/output.pch   $(YACD)/output.c   output.c
        -$(CMP) -o$(PATD)/reader.pch   $(YACD)/reader.c   reader.c
        -$(CMP) -o$(PATD)/skeleton.pch $(YACD)/skeleton.c skeleton.c
        -$(CMP) -o$(PATD)/symtab.pch   $(YACD)/symtab.c   symtab.c
        -$(CMP) -o$(PATD)/verbose.pch  $(YACD)/verbose.c  verbose.c
        -$(CMP) -o$(PATD)/warshall.pch $(YACD)/warshall.c warshall.c
        $(UPDARC) $(PARC) $(PATD)/\#?

clean       :
        -$(RMDIR) $(YACD)
        -$(RMDIR) $(PROD)
        -$(RMDIR) $(OBJD)
        -$(RMDIR) $(PATD)
        -$(RM) $(SRCS)
        -$(RM) $(EXE).lnk

### do macros

$(EXE)      : $(SRCS) $(PROTOS) $(OBJS)
        $(CC) $(LOPTS) WITH <<
$(OBJS)
<

$(DIFS)     :
        -$(RM) $(DIFS)
        $(LS) $(YACD)/\#?.[ch] LFORMAT="$(DIFF) >>$(DIFS) -w -q %n $(YACD)/%n" >$(BAT)
        -$(EXEC) $(BAT)
        -$(RM) $(BAT)

$(OBJD)     :
        -$(MKDIR) $(OBJD)
        -$(MKDIR) $(OBJD2)

$(PROD)     :
        -$(MKDIR) $(PROD)

$(PATD)     :
        $(XTRARC) $(PARC)

$(YACD)     :
        $(XTRARC) $(YARC)
        $(CHMOD) $(YACC) rwed ADD



### rules to create the patched sources
### used to resolve the $(SRCS)-dependencies

.pch.c:
        -$(PATCH) -p$*.pch -o$>.c $(YACD)/$>.c

.pch.h:
        -$(PATCH) -p$*.pch -o$>.h $(YACD)/$>.h


### *.o : *.c

$(OBJD)/closure.o   : closure.c

$(OBJD)/derives.o   : derives.c

$(OBJD)/error.o     : error.c

$(OBJD)/lalr.o      : lalr.c

$(OBJD)/lr0.o       : lr0.c

$(OBJD)/main.o      : main.c

$(OBJD)/mkpar.o     : mkpar.c

$(OBJD)/nullable.o  : nullable.c

$(OBJD)/output.o    : output.c

$(OBJD)/reader.o    : reader.c

$(OBJD)/skeleton.o  : skeleton.c

$(OBJD)/symtab.o    : symtab.c

$(OBJD)/verbose.o   : verbose.c

$(OBJD)/warshall.o  : warshall.c


### *.[hc] : *.pch

defs.h      : $(PATD)/defs.pch

closure.c   : $(PATD)/closure.pch

derives.c   : $(PATD)/derives.pch

error.c     : $(PATD)/error.pch

lalr.c      : $(PATD)/lalr.pch

lr0.c       : $(PATD)/lr0.pch

main.c      : $(PATD)/main.pch

mkpar.c     : $(PATD)/mkpar.pch

nullable.c  : $(PATD)/nullable.pch

output.c    : $(PATD)/output.pch

reader.c    : $(PATD)/reader.pch

skeleton.c  : $(PATD)/skeleton.pch

symtab.c    : $(PATD)/symtab.pch

verbose.c   : $(PATD)/verbose.pch

warshall.c  : $(PATD)/warshall.pch


### *_protos.h : *.c

$(PROD)/closure_protos.h   : closure.c
         $(CC) $< $(POPTS) $@

$(PROD)/derives_protos.h   : derives.c
         $(CC) $< $(POPTS) $@

$(PROD)/error_protos.h     : error.c
         $(CC) $< $(POPTS) $@

$(PROD)/lalr_protos.h      : lalr.c
         $(CC) $< $(POPTS) $@

$(PROD)/lr0_protos.h       : lr0.c
         $(CC) $< $(POPTS) $@

$(PROD)/main_protos.h      : main.c
         $(CC) $< $(POPTS) $@

$(PROD)/mkpar_protos.h     : mkpar.c
         $(CC) $< $(POPTS) $@

$(PROD)/nullable_protos.h  : nullable.c
         $(CC) $< $(POPTS) $@

$(PROD)/output_protos.h    : output.c
         $(CC) $< $(POPTS) $@

$(PROD)/reader_protos.h    : reader.c
         $(CC) $< $(POPTS) $@

$(PROD)/skeleton_protos.h  : skeleton.c
         $(CC) $< $(POPTS) $@

$(PROD)/symtab_protos.h    : symtab.c
         $(CC) $< $(POPTS) $@

$(PROD)/verbose_protos.h   : verbose.c
         $(CC) $< $(POPTS) $@

$(PROD)/warshall_protos.h  : warshall.c
         $(CC) $< $(POPTS) $@

