6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2025-01-26 17:36:57 +00:00
Code Issues Projects Releases Wiki Activity

Replaced whole bunch for Makefiles with a single generic Makefile.

Browse Source 
- Targeting GNU toolchain.
- Modern dependency handling.
- Warning-free build.
- GCC option -Werror set.
- Dynamic search paths.
- Don't write into source directories.
- Easy cleanup by just removing 'wrk'.
This commit is contained in:
Oliver Schmidt 2013-04-27 17:19:52 +02:00
parent ede72d78b2
commit 052b229f86
30 changed files with 76 additions and 2765 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
src/Makefile Normal file
View File

@ -0,0 +1,76 @@
PROGS = ar65 \
ca65 \
cc65 \
cl65 \
co65 \
da65 \
grc65 \
ld65 \
od65 \
sp65
CA65_INC := $(abspath ../asminc)
CC65_INC := $(abspath ../include)
LD65_LIB := $(abspath ../lib)
LD65_OBJ := $(abspath ../lib)
LD65_CFG := $(abspath ../cfg)
CFLAGS += -MMD -MP -O -std=c89 -I common \
-Wall -Wextra -Wno-char-subscripts -Werror \
-DCA65_INC=$(CA65_INC) -DCC65_INC=$(CC65_INC) \
-DLD65_LIB=$(LD65_LIB) -DLD65_OBJ=$(LD65_OBJ) -DLD65_CFG=$(LD65_CFG)
all: $(PROGS)
mostlyclean:
$(RM) -r ../wrk
clean: mostlyclean
$(RM) -r ../bin
.PHONY: all $(PROGS) mostlyclean clean
##########
define OBJS_template =
$(1)_OBJS := $$(addprefix ../wrk/,$$(addsuffix .o,$$(basename $$(wildcard $(1)/*.c))))
$$($(1)_OBJS): | ../wrk/$(1)
../wrk/$(1):
mkdir -p $$@
DEPS += $$($(1)_OBJS:.o=.d)
endef
##########
define PROG_template =
$$(eval $$(call OBJS_template,$(1)))
../bin/$(1): $$($(1)_OBJS) ../wrk/common/common.a | ../bin
$$(CC) $$(LDFLAGS) -o $$@ $$^
$(1): ../bin/$(1)
endef
##########
../wrk/%.o: %.c
@echo $(CC) $<
@$(CC) -c $(CFLAGS) -o $@ $<
../bin:
mkdir $@
$(eval $(call OBJS_template,common))
../wrk/common/common.a: $(common_OBJS)
$(AR) r $@ $^
$(foreach prog,$(PROGS),$(eval $(call PROG_template,$(prog))))
-include $(DEPS)

71
src/ar65/make/gcc.mak
View File

@ -1,71 +0,0 @@
#
# gcc Makefile for ar65
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = ar65
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = add.o \
del.o \
error.o \
exports.o \
extract.o \
fileio.o \
global.o \
library.o \
list.o \
main.o \
objdata.o \
objfile.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

107
src/ar65/make/watcom.mak
View File

@ -1,107 +0,0 @@
#
# ar65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = ar65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All library OBJ files
OBJS = add.obj \
del.obj \
error.obj \
exports.obj \
extract.obj \
fileio.obj \
global.obj \
library.obj \
list.obj \
main.obj \
objdata.obj \
objfile.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS)$(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

102
src/ca65/make/gcc.mak
View File

@ -1,102 +0,0 @@
#
# gcc Makefile for ca65
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = ca65
# Library dir
COMMON = ../common
# Several search paths. You may redefine these on the command line
CA65_INC = \"/usr/lib/cc65/asminc/\"
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
override CFLAGS += -DCA65_INC=$(CA65_INC)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = anonname.o \
asserts.o \
condasm.o \
dbginfo.o \
ea65.o \
easw16.o \
enum.o \
error.o \
expr.o \
feature.o \
filetab.o \
fragment.o \
global.o \
incpath.o \
instr.o \
istack.o \
lineinfo.o \
listing.o \
macro.o \
main.o \
nexttok.o \
objcode.o \
objfile.o \
options.o \
pseudo.o \
repeat.o \
scanner.o \
segdef.o \
segment.o \
sizeof.o \
span.o \
spool.o \
struct.o \
studyexpr.o \
symentry.o \
symbol.o \
symtab.o \
token.o \
toklist.o \
ulabel.o
# -----------------------------------------------------------------------------
# List of all macro files
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(INCS) $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $(OBJS:.o=.c) > .depend

137
src/ca65/make/watcom.mak
View File

@ -1,137 +0,0 @@
#
# CA65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = ca65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All library OBJ files
OBJS = anonname.obj \
asserts.obj \
condasm.obj \
dbginfo.obj \
ea65.obj \
easw16.obj \
enum.obj \
error.obj \
expr.obj \
feature.obj \
filetab.obj \
fragment.obj \
global.obj \
incpath.obj \
instr.obj \
istack.obj \
lineinfo.obj \
listing.obj \
macpack.obj \
macro.obj \
main.obj \
nexttok.obj \
objcode.obj \
objfile.obj \
options.obj \
pseudo.obj \
repeat.obj \
scanner.obj \
segdef.obj \
segment.obj \
sizeof.obj \
span.obj \
spool.obj \
struct.obj \
studyexpr.obj \
symbol.obj \
symentry.obj \
symtab.obj \
token.obj \
toklist.obj \
ulabel.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

40
src/cc65/make/cc65.mak
View File

@ -1,40 +0,0 @@
#
# Makefile for CC65.COM.
#
.SUFFIXES: .o .obj .m65 .c
.c.m65:
@echo $<
@cc65 -I../lib65/ -O -t4 $<
.m65.obj:
../ra65/ra65 -o $@ ../lib65/ace/global.m65 $<
C_SRCS = code-gen.c error.c expr1.c expr2.c expr3.c function.c mem.c loop.c\
globlvar.c io.c scanner.c main.c optimize.c preproc.c\
stmt.c symtab.c util.c declare.c
H_SRCS = cc65.h scanner.h error.h mem.h optimize.h code-gen.h function.h\
preproc.h util.h symtab.h io.h ctrans.h stmt.h declare.h loop.h\
expr.h
M65_FILES = ccmisc.m65 extra.m65 rtextra.m65
OBJS = code-gen.obj error.obj expr1.obj expr2.obj expr3.obj function.obj \
globlvar.obj io.obj scanner.obj main.obj\
optimize.obj preproc.obj stmt.obj symtab.obj declare.obj loop.obj\
ccmisc.obj extra.obj rtextra.obj ctrans.obj mem.obj util.obj
cc65.com: $(OBJS)
@../ra65/link65 -t4 -m -o cc65.com ../lib65/ace/crt0.obj $(OBJS)\
../lib65/ace.olb
.PRECIOUS: $(C_SRCS:.c=.m65)
$(OBJS) : $(H_SRCS)
clean :
rm -f $(OBJS)
rm -f $(C_SRCS:.c=.m65)

135
src/cc65/make/gcc.mak
View File

@ -1,135 +0,0 @@
#
# Makefile for cross-compiler version of CC65.
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = cc65
# Library directories
COMMON = ../common
# The compiler include search path. Default is "/usr/lib/cc65/include/" if
# nothing is defined. You may use CC65_INC=foo on the command line to override it.
CC65_INC = \"/usr/lib/cc65/include/\"
#
CC = gcc
CFLAGS = -O2 -g -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
override CFLAGS += -DCC65_INC=$(CC65_INC)
EBIND = emxbind
LDFLAGS = -lm
# ------------------------------------------------------------------------------
# Object files and libraries to link
OBJS = anonname.o \
asmcode.o \
asmlabel.o \
asmstmt.o \
assignment.o \
casenode.o \
codeent.o \
codegen.o \
codelab.o \
codeinfo.o \
codeopt.o \
codeseg.o \
compile.o \
coptadd.o \
coptc02.o \
coptcmp.o \
coptind.o \
coptneg.o \
coptptrload.o \
coptptrstore.o \
coptpush.o \
coptshift.o \
coptsize.o \
coptstop.o \
coptstore.o \
coptsub.o \
copttest.o \
dataseg.o \
datatype.o \
declare.o \
declattr.o \
error.o \
expr.o \
exprdesc.o \
funcdesc.o \
function.o \
global.o \
goto.o \
hexval.o \
ident.o \
incpath.o \
input.o \
lineinfo.o \
litpool.o \
loadexpr.o \
locals.o \
loop.o \
macrotab.o \
main.o \
opcodes.o \
output.o \
preproc.o \
pragma.o \
reginfo.o \
scanner.o \
scanstrbuf.o \
segments.o \
shiftexpr.o \
stackptr.o \
standard.o \
stdfunc.o \
stdnames.o \
stmt.o \
swstmt.o \
symentry.o \
symtab.o \
testexpr.o \
textseg.o \
typecmp.o \
typeconv.o \
util.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $(OBJS) $(LIBS) -lm -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) $(OBJS) $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) -I$(COMMON) -MM $^ > .depend

190
src/cc65/make/watcom.mak
View File

@ -1,190 +0,0 @@
#
# CC65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = cc65.exe
# Determine the svn version number if possible
ifneq "$(shell which svnversion 2>/dev/null)" ""
SVNVERSION=$(shell svnversion)
ifeq "$(SVNVERSION)" "exported"
SVNVERSION=unknown
endif
ifeq "$(SVNVERSION)" "Unversioned directory"
SVNVERSION=unknown
endif
else
SVNVERSION=unknown
endif
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = anonname.obj \
asmcode.obj \
asmlabel.obj \
asmstmt.obj \
assignment.obj \
casenode.obj \
codeent.obj \
codegen.obj \
codelab.obj \
codeinfo.obj \
codeopt.obj \
codeseg.obj \
compile.obj \
coptadd.obj \
coptc02.obj \
coptcmp.obj \
coptind.obj \
coptneg.obj \
coptptrload.obj \
coptptrstore.obj\
coptpush.obj \
coptshift.obj \
coptsize.obj \
coptstop.obj \
coptstore.obj \
coptsub.obj \
copttest.obj \
dataseg.obj \
datatype.obj \
declare.obj \
declattr.obj \
error.obj \
expr.obj \
exprdesc.obj \
funcdesc.obj \
function.obj \
global.obj \
goto.obj \
hexval.obj \
ident.obj \
incpath.obj \
input.obj \
lineinfo.obj \
litpool.obj \
loadexpr.obj \
locals.obj \
loop.obj \
macrotab.obj \
main.obj \
opcodes.obj \
output.obj \
preproc.obj \
pragma.obj \
reginfo.obj \
scanner.obj \
scanstrbuf.obj \
segments.obj \
shiftexpr.obj \
stackptr.obj \
standard.obj \
stdfunc.obj \
stdnames.obj \
stmt.obj \
svnversion.obj \
swstmt.obj \
symentry.obj \
symtab.obj \
testexpr.obj \
textseg.obj \
typecmp.obj \
typeconv.obj \
util.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: svnversion $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
.PHONY: svnversion
svnversion:
@$(RM) svnversion.c
@echo "/* This file is auto-generated - do not modify! */" >> svnversion.c
@echo "" >> svnversion.c
@echo "const char SVNVersion[] = \"$(SVNVERSION)\";" >> svnversion.c
svnversion.c: svnversion
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map) svnversion.c
strip:
@-$(WSTRIP) $(EXE)

62
src/chrcvt/make/gcc.mak
View File

@ -1,62 +0,0 @@
#
# Makefile for the chrcvt vector font converter
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = chrcvt
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -O2 -g -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = error.o \
main.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $^ $(LDFLAGS) -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

98
src/chrcvt/make/watcom.mak
View File

@ -1,98 +0,0 @@
#
# chrcvt Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = chrcvt.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = error.obj \
main.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

65
src/cl65/make/gcc.mak
View File

@ -1,65 +0,0 @@
#
# Makefile for the cl65 compile&link utility
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = cl65
# Library dir
COMMON = ../common
# Type of spawn function to use
SPAWN = SPAWN_UNIX
ifneq ($(Kickstart),)
SPAWN = SPAWN_AMIGA
endif
#
CC = gcc
CFLAGS = -O2 -g -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
override CFLAGS += -D$(SPAWN)
EBIND = emxbind
LDFLAGS =
OBJS = error.o \
global.o \
main.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -D$(SPAWN) -MM $^ > .depend

99
src/cl65/make/watcom.mak
View File

@ -1,99 +0,0 @@
#
# CL65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = cl65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = error.obj \
global.obj \
main.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

64
src/co65/make/gcc.mak
View File

@ -1,64 +0,0 @@
#
# gcc Makefile for co65
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = co65
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = convert.o \
error.o \
fileio.o \
global.o \
main.o \
model.o \
o65.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

103
src/co65/make/watcom.mak
View File

@ -1,103 +0,0 @@
#
# CO65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = co65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All library OBJ files
OBJS = convert.obj \
error.obj \
fileio.obj \
global.obj \
main.obj \
model.obj \
o65.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

104
src/common/make/cc65.mak
View File

@ -1,104 +0,0 @@
#
# cc65 Makefile for the cc65 common directory
#
RM = rm -f
SYS = c64
CFLAGS = -g -T -t $(SYS) -Oirs --standard c89
AS = ../ca65/ca65
AR = ../ar65/ar65
CC = ../cc65/cc65
LDFLAGS =
LIB = common.lib
# --------------------------------------------------------------------------
# Generic rules
.c.o:
@echo $<
@$(CC) $(CFLAGS) $<
@$(AS) $(basename $<).s
.s.o:
@echo $<
@$(AS) $(MY_ASM) -t $(SYS) $<
.o:
@$(LD) -t $(SYS) -m $(basename $@).map -o $@ $^ $(CLIB)
# --------------------------------------------------------------------------
# Object files for the library
OBJS = abend.o \
addrsize.o \
assertion.o \
bitops.o \
chartype.o \
check.o \
cmdline.o \
coll.o \
cpu.o \
debugflag.o \
exprdefs.o \
filepos.o \
filetype.o \
fname.o \
fp.o \
hashstr.o \
hashtab.o \
intstack.o \
matchpat.o \
mmodel.o \
print.o \
searchpath.o \
segdefs.o \
segnames.o \
shift.o \
strbuf.o \
strpool.o \
strstack.o \
strutil.o \
target.o \
tgttrans.o \
version.o \
xmalloc.o \
xsprintf.o
# ------------------------------------------------------------------------------
# Dummy targets
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: lib
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
.PHONY: lib
lib: $(LIB)
$(LIB): $(OBJS)
$(AR) a $(LIB) $?
clean:
$(RM) *~ core *.map
zap: clean
$(RM) *.o $(LIB) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

88
src/common/make/gcc.mak
View File

@ -1,88 +0,0 @@
#
# gcc Makefile for the cc65 common directory
#
RM = rm -f
AR = ar
CFLAGS = -g -O2 -Wall -W -std=c89
CC = gcc
LDFLAGS =
LIB = common.a
# ------------------------------------------------------------------------------
# Object files for the library
OBJS = abend.o \
addrsize.o \
alignment.o \
assertion.o \
bitops.o \
chartype.o \
check.o \
cmdline.o \
coll.o \
cpu.o \
debugflag.o \
exprdefs.o \
fileid.o \
filepos.o \
filestat.o \
filetime.o \
filetype.o \
fname.o \
fp.o \
gentype.o \
hashfunc.o \
hashtab.o \
intstack.o \
matchpat.o \
mmodel.o \
print.o \
searchpath.o \
segnames.o \
shift.o \
strbuf.o \
strpool.o \
strstack.o \
strutil.o \
target.o \
tgttrans.o \
version.o \
xmalloc.o \
xsprintf.o
# ------------------------------------------------------------------------------
# Dummy targets
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: lib
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
.PHONY: lib
lib: $(LIB)
$(LIB): $(OBJS)
$(AR) rs $(LIB) $?
clean:
$(RM) *~ core *.map
zap: clean
$(RM) *.o $(LIB) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

125
src/common/make/watcom.mak
View File

@ -1,125 +0,0 @@
#
# CC65 Makefile for the Watcom compiler (using GNU make) and wine
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
LIB = common.lib
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All library OBJ files
OBJS = abend.obj \
addrsize.obj \
alignment.obj \
assertion.obj \
bitops.obj \
chartype.obj \
check.obj \
cmdline.obj \
coll.obj \
cpu.obj \
debugflag.obj \
exprdefs.obj \
fileid.obj \
filepos.obj \
filestat.obj \
filetime.obj \
filetype.obj \
fname.obj \
fp.obj \
gentype.obj \
hashfunc.obj \
hashtab.obj \
intstack.obj \
matchpat.obj \
mmodel.obj \
print.obj \
searchpath.obj \
segnames.obj \
shift.obj \
strbuf.obj \
strpool.obj \
strstack.obj \
strutil.obj \
target.obj \
tgttrans.obj \
version.obj \
wildargv.obj \
xmalloc.obj \
xsprintf.obj
# ------------------------------------------------------------------------------
# Main targets
all: lib
lib: $(LIB)
$(LIB): $(OBJS)
@echo Creating library...
$(AR) -q -b -P=32 $(LIB) $(foreach OBJ, $(OBJS), +-$(OBJ))
@echo Done!
wildargv.obj:
$(CC) $(CFLAGS) -fo=$@ $(WATCOM)\\src\\startup\\wildargv.c
clean:
@rm -f *~ core
zap: clean
@rm -f *.obj $(LIB)
strip:
@true

81
src/da65/make/gcc.mak
View File

@ -1,81 +0,0 @@
#
# gcc Makefile for da65
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = da65
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = asminc.o \
attrtab.o \
code.o \
comments.o \
data.o \
error.o \
global.o \
handler.o \
infofile.o \
labels.o \
main.o \
opc6502.o \
opc6502x.o \
opc65816.o \
opc65c02.o \
opc65sc02.o \
opchuc6280.o \
opcm740.o \
opctable.o \
output.o \
scanner.o \
segment.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

119
src/da65/make/watcom.mak
View File

@ -1,119 +0,0 @@
#
# da65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = da65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = asminc.obj \
attrtab.obj \
code.obj \
comments.obj \
data.obj \
error.obj \
global.obj \
handler.obj \
infofile.obj \
labels.obj \
main.obj \
opc6502.obj \
opc6502x.obj \
opc65816.obj \
opc65c02.obj \
opc65sc02.obj \
opchuc6280.obj \
opcm740.obj \
opctable.obj \
output.obj \
scanner.obj \
segment.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

62
src/dbginfo/make/gcc.mak
View File

@ -1,62 +0,0 @@
#
# Makefile for the debug info test executable
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = dbgsh
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# ------------------------------------------------------------------------------
# Object files to link
OBJS = dbginfo.o \
dbgsh.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) $(OBJS) $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) -MM $^ > .depend

94
src/dbginfo/make/watcom.mak
View File

@ -1,94 +0,0 @@
#
# Makefile for the debug info test executable
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2
# Target files
EXE = dbgtest.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# Object files to link
OBJS = dbginfo.obj \
dbgtest.obj
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

58
src/grc65/make/gcc.mak
View File

@ -1,58 +0,0 @@
#
# gcc Makefile for grc
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = grc65
COMMON = ../common
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
LDFLAGS =
EBIND = emxbind
# -----------------------------------------------------------------------------
# List of all object files
OBJS = main.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

97
src/grc65/make/watcom.mak
View File

@ -1,97 +0,0 @@
#
# GRC Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = grc65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = main.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

97
src/ld65/make/gcc.mak
View File

@ -1,97 +0,0 @@
#
# gcc Makefile for ld65
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = ld65
# Library dir
COMMON = ../common
# Several search paths. You may redefine these on the command line
LD65_LIB = \"/usr/lib/cc65/lib/\"
LD65_OBJ = \"/usr/lib/cc65/lib/\"
LD65_CFG = \"/usr/lib/cc65/cfg/\"
#
CC = gcc
CFLAGS = -g -O2 -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
override CFLAGS += -DLD65_LIB=$(LD65_LIB) -DLD65_OBJ=$(LD65_OBJ) -DLD65_CFG=$(LD65_CFG)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = asserts.o \
bin.o \
binfmt.o \
cfgexpr.o \
condes.o \
config.o \
dbgfile.o \
dbgsyms.o \
error.o \
exports.o \
expr.o \
extsyms.o \
fileinfo.o \
fileio.o \
filepath.o \
fragment.o \
global.o \
library.o \
lineinfo.o \
main.o \
mapfile.o \
memarea.o \
o65.o \
objdata.o \
objfile.o \
scanner.o \
scopes.o \
segments.o \
span.o \
spool.o \
tgtcfg.o \
tpool.o
# -----------------------------------------------------------------------------
# List of all config includes
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(INCS) $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $(OBJS:.o=.c) > .depend

128
src/ld65/make/watcom.mak
View File

@ -1,128 +0,0 @@
#
# ld65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = ld65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = asserts.obj \
bin.obj \
binfmt.obj \
cfgexpr.obj \
condes.obj \
config.obj \
dbgfile.obj \
dbgsyms.obj \
error.obj \
exports.obj \
expr.obj \
extsyms.obj \
fileinfo.obj \
fileio.obj \
filepath.obj \
fragment.obj \
global.obj \
library.obj \
lineinfo.obj \
main.obj \
mapfile.obj \
memarea.obj \
o65.obj \
objdata.obj \
objfile.obj \
scanner.obj \
scopes.obj \
segments.obj \
span.obj \
spool.obj \
tgtcfg.obj \
tpool.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

65
src/od65/make/gcc.mak
View File

@ -1,65 +0,0 @@
#
# Makefile for the od65 object file dump utility
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = od65
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -O2 -g -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = dump.o \
error.o \
fileio.o \
global.o \
main.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

101
src/od65/make/watcom.mak
View File

@ -1,101 +0,0 @@
#
# OD65 Makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = od65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = dump.obj \
error.obj \
fileio.obj \
global.obj \
main.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)

77
src/sim65/make/gcc.mak
View File

@ -1,77 +0,0 @@
#
# gcc Makefile for sim65
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = sim65
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -g -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS = -ldl
# -----------------------------------------------------------------------------
# List of all object files
OBJS = addrspace.o \
callback.o \
cfgdata.o \
chip.o \
chippath.o \
config.o \
cpu-6502.o \
cpucore.o \
cputype.o \
error.o \
global.o \
location.o \
main.o \
scanner.o \
system.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE) chips
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
.PHONY: chips
chips:
@$(MAKE) -C chips -f make/gcc.mak
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

80
src/sp65/make/gcc.mak
View File

@ -1,80 +0,0 @@
#
# Makefile for the sp65 sprite and bitmap utility utility
#
# ------------------------------------------------------------------------------
# The executable to build
EXE = sp65
# Library dir
COMMON = ../common
#
CC = gcc
CFLAGS = -O2 -g -Wall -W -std=c89
override CFLAGS += -I$(COMMON)
EBIND = emxbind
LDFLAGS =
# -----------------------------------------------------------------------------
# List of all object files
OBJS = asm.o \
attr.o \
bin.o \
bitmap.o \
c.o \
color.o \
convert.o \
error.o \
fileio.o \
geosbitmap.o \
geosicon.o \
input.o \
koala.o \
lynxsprite.o \
main.o \
output.o \
palette.o \
pcx.o \
raw.o \
vic2sprite.o
LIBS = $(COMMON)/common.a
# ------------------------------------------------------------------------------
# Makefile targets
# Main target - must be first
.PHONY: all
ifeq (.depend,$(wildcard .depend))
all: $(EXE)
include .depend
else
all: depend
@$(MAKE) -f make/gcc.mak all
endif
$(EXE): $(OBJS) $(LIBS)
$(CC) $(LDFLAGS) $^ -o $@
@if [ $(OS2_SHELL) ] ; then $(EBIND) $(EXE) ; fi
clean:
$(RM) *~ core.* *.map
zap: clean
$(RM) *.o $(EXE) .depend
# ------------------------------------------------------------------------------
# Make the dependencies
.PHONY: depend dep
depend dep: $(OBJS:.o=.c)
@echo "Creating dependency information"
$(CC) $(CFLAGS) -MM $^ > .depend

116
src/sp65/make/watcom.mak
View File

@ -1,116 +0,0 @@
#
# sp65 makefile for the Watcom compiler (using GNU make)
#
# ------------------------------------------------------------------------------
# Generic stuff
# Environment variables for the watcom compiler
export WATCOM = c:\\watcom
export INCLUDE = $(WATCOM)\\h
# We will use the windows compiler under linux (define as empty for windows)
export WINEDEBUG=fixme-all
WINE = wine
# Programs
AR = $(WINE) wlib
CC = $(WINE) wcc386
LD = $(WINE) wlink
WSTRIP = $(WINE) wstrip -q
LNKCFG = ld.tmp
# Program arguments
CFLAGS = -d1 -obeilr -zp4 -5 -zq -w2 -i=..\\common
# Target files
EXE = sp65.exe
# Create NT programs by default
ifndef TARGET
TARGET = NT
endif
# --------------------- OS2 ---------------------
ifeq ($(TARGET),OS2)
SYSTEM = os2v2
CFLAGS += -bt=$(TARGET)
endif
# -------------------- DOS4G --------------------
ifeq ($(TARGET),DOS32)
SYSTEM = dos4g
CFLAGS += -bt=$(TARGET)
endif
# --------------------- NT ----------------------
ifeq ($(TARGET),NT)
SYSTEM = nt
CFLAGS += -bt=$(TARGET)
endif
# ------------------------------------------------------------------------------
# Implicit rules
%.obj: %.c
$(CC) $(CFLAGS) -fo=$@ $^
# ------------------------------------------------------------------------------
# All OBJ files
OBJS = asm.obj \
attr.obj \
bin.obj \
bitmap.obj \
c.obj \
color.obj \
convert.obj \
error.obj \
fileio.obj \
geosbitmap.obj \
geosicon.obj \
input.obj \
koala.obj \
lynxsprite.obj \
main.obj \
output.obj \
palette.obj \
pcx.obj \
raw.obj \
vic2sprite.obj
LIBS = ../common/common.lib
# ------------------------------------------------------------------------------
# Main targets
all: $(EXE)
# ------------------------------------------------------------------------------
# Other targets
$(EXE): $(OBJS) $(LIBS)
@echo "DEBUG ALL" > $(LNKCFG)
@echo "OPTION QUIET" >> $(LNKCFG)
@echo "OPTION MAP" >> $(LNKCFG)
@echo "OPTION STACK=65536" >> $(LNKCFG)
@echo "NAME $@" >> $(LNKCFG)
@for i in $(OBJS); do echo "FILE $${i}"; done >> $(LNKCFG)
@for i in $(LIBS); do echo "LIBRARY $${i}"; done >> $(LNKCFG)
@$(LD) system $(SYSTEM) @$(LNKCFG)
@rm $(LNKCFG)
clean:
@rm -f *~ core
zap: clean
@rm -f $(OBJS) $(EXE) $(EXE:.exe=.map)
strip:
@-$(WSTRIP) $(EXE)