#
# $__copyright$
#
# Makefile for AtFS
#
# $Header: Makefile[1.35] Thu Apr  9 17:49:49 1992 andy@cs.tu-berlin.de accessed $
#

# --------------------------------------------------------------------
#		locations and general macros
# --------------------------------------------------------------------

# The base directory of the project's source repository area.

BASE = /home/stone/shape/development

# Path to this node system relative to the root of the source
# repository defined above (e.g. vc/save).

NODEPATH = src/atfs

# A short name for this node

NODENAME = AtFS

# The operating system, $(TARGET) shall be built for.

HOSTSYSTEM = s-sunos_4

# The processor type.

HOSTTYPE = sun4

# Preprocessor switches. (eg. -DDEBUG)

SWITCHES = -DSYSLOG -Iconf/$(HOSTSYSTEM)

# Locations and modes for the installation of executables, header
# files, libraries and manuals.

INSTALLBASE = $(BASE)
INSTALLBINPATH = $(INSTALLBASE)/bin
INSTALLBINMODE = 755
INSTALLINCPATH = $(INSTALLBASE)/include
INSTALLINCMODE = 444
INSTALLLIBPATH = $(INSTALLBASE)/lib
INSTALLLIBMODE = 644
INSTALLMANPATH = $(INSTALLBASE)/man
INSTALLMANMODE = 444

# Directories, where local libraries and header files are to be
# installed for project wide use.

LIBPATH     = $(BASE)/lib
INCLUDEPATH = $(BASE)/include

# --------------------------------------------------------------------
#		the system's components
# --------------------------------------------------------------------

#
# The system (program, library, etc.) to be built. If you want to
# manage multiple programs, you should introduce multiple targets
# (like TARGET1 TARGET2 or any better names). In this case you 
# have to adjust the system building actions accordingly.

LIBTARGET = libatfs.a
BINTARGET = atfsrepair

# The release number generator. The version number of this file will
# be used as release identifier for the whole system.

VERSIONFILE = af_version.c # source
VERSIONOBJECT =	af_version.o # derived (if source contains program code)

# The names of the subdirectories containing subsystems which are also
# to be built.

SUBSYSTEMS = 

# Aliases for (filesystem links to) $(TARGET).

ALIASES = 

# The regular source and header files.

SOURCES = aferror.c aftime.c afsymtab.c afudattrs.c aftmpfiles.c \
	aflib.c afdeltaproc.c afenviron.c afnames.c afmemory.c afkeys.c \
	afarchive.c afbpool.c afcache.c afdelta.c afstore.c afreadname.c \
	afcattrs.c afcompar.c affiles.c aflock.c afretr.c afsattrs.c \
	afsets.c atfsrepair.c afstat.c afstates.c afvers.c afdbm.c \
	aftransact.c afattrs.c

HEADERS = atfs.h afsys.h afarchive.h atfsrepair.h afdbm.h afdelta.h

# Auxiliary source and header files that are not genuine part of the
# system (eg. a test environment). These will also be processed on
# system building, but will *not* be included in releases.

AUXSOURCES = testmain.c testcall.c testfdes.c testkey.c testabuf.c \
	testset.c testvar.c testshow.c conf/$(HOSTSYSTEM)/config.c

AUXHEADERS = test.h conf/$(HOSTSYSTEM)/config.h

SUBSOURCES = conf/s-aix/config.c \
	conf/s-bsd_4_3/config.c \
	conf/s-hpux/config.c \
	conf/s-irix/config.c \
	conf/s-mach/config.c \
	conf/s-sunos_4/config.c \
	conf/s-svr_3/config.c \
	conf/s-ultrix_4/config.c

SUBHEADERS = conf/s-aix/config.h \
	conf/s-bsd_4_3/config.h \
	conf/s-hpux/config.h \
	conf/s-irix/config.h \
	conf/s-mach/config.h \
	conf/s-sunos_4/config.h \
	conf/s-svr_3/config.h \
	conf/s-ultrix_4/config.h

# The manuals

MANUALS = $(MAN1) $(MAN3) $(MAN4) $(MAN5) $(MAN6) $(MAN7) $(MAN8)
MAN1 = 
MAN3 = man/man3/afattrs.3 man/man3/affiles.3 man/man3/afintro.3 \
	man/man3/aflock.3 man/man3/afmisc.3 \
	man/man3/afperm.3 man/man3/afretrieve.3 man/man3/afsets.3 \
	man/man3/afversions.3 man/man3/aftransact.3
MAN4 = 
MAN5 = man/man5/afarchive.5
MAN6 = 
MAN7 = 
MAN8 = man/man8/atfsrepair.8

# All source components of the system (should not be changed)

COMPONENTS = $(SOURCES) $(HEADERS) $(SUBSOURCES) $(SUBHEADERS) \
	$(MANUALS) Shapefile Makefile Dependencies

# The derived files. All files, that are autamatically produced during
# a build process should be listed here.

OBJECTS = $(LIBOBJECTS) atfsrepair.o $(TESTOBJECTS)

BINOBJECTS = atfsrepair.o aferror.o aftime.o afsymtab.o aflib.o \
	afdeltaproc.o afenviron.o afnames.o afreadname.o afstat.o \
	$(VERSIONOBJECT) config.o

LIBOBJECTS = aferror.o aftime.o afsymtab.o afudattrs.o aftmpfiles.o \
	aflib.o afdeltaproc.o afenviron.o afnames.o afmemory.o afkeys.o \
	afarchive.o afbpool.o afcache.o afdelta.o afstore.o afreadname.o \
	afcattrs.o afcompar.o affiles.o aflock.o afretr.o afsattrs.o \
	afsets.o afstat.o afstates.o afvers.o afdbm.o aftransact.o \
	afattrs.o $(VERSIONOBJECT) config.o

TESTOBJECTS = testmain.o testcall.o testshow.o testvar.o testkey.o \
	testset.o testabuf.o testfdes.o


# --------------------------------------------------------------------
#		tools, flags, libraries etc.
# --------------------------------------------------------------------

CC = cc
CFLAGS  = $(SWITCHES) -I$(INCLUDEPATH) -g
LDFLAGS = -g

RANLIB  = /usr/bin/ranlib

# System libraries, local libraries and lint libraries.

SYSLIBS   = 
LOCALLIBS =
LINTLIBS  =

# --------------------------------------------------------------------
#			the targets
# --------------------------------------------------------------------

# The default action (do not change)

all: +all $(ALLTARGETS)

targets: $(LIBTARGET) $(BINTARGET) $(TESTTARGET)

$(LIBTARGET): $(LIBOBJECTS)
	-ar ruv $(LIBTARGET) $(LIBOBJECTS)
	@-($(RANLIB) $(LIBTARGET)) 2> /dev/null

$(BINTARGET): $(LOCALLIBS) $(BINOBJECTS)
	$(CC) $(LDFLAGS) -o $(BINTARGET) $(BINOBJECTS) $(LOCALLIBS) $(SYSLIBS)
	@_aliases="$(ALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $$i; \
	  echo linking $(BINTARGET) to $$i; \
	  ln $(BINTARGET) $$i; \
	done

config.o : conf/$(HOSTSYSTEM)/config.c  conf/$(HOSTSYSTEM)/config.h
	$(CC) -c $(CFLAGS) conf/$(HOSTSYSTEM)/config.c

localinstalltargets: $(INSTALLLIBPATH)/$(LIBTARGET) $(INSTALLINCPATH)/atfs.h \
	$(INSTALLINCPATH)/afsys.h $(INSTALLINCPATH)/config.h $(BINTARGET)

installtargets: $(INSTALLBINPATH)/$(BINTARGET)

$(INSTALLLIBPATH)/$(LIBTARGET): $(LIBTARGET)
	@-echo "Installing $(LIBTARGET) in $(INSTALLLIBPATH)"; \
	if [ -f $(INSTALLLIBPATH)/$(LIBTARGET) ] ;\
	then \
	mv -f $(INSTALLLIBPATH)/$(LIBTARGET) \
	      $(INSTALLLIBPATH)/$(LIBTARGET).old;\
	fi; \
	cp $(LIBTARGET) $(INSTALLLIBPATH)/$(LIBTARGET); \
	chmod $(INSTALLLIBMODE) $(INSTALLLIBPATH)/$(LIBTARGET); \
	($(RANLIB) $(INSTALLLIBPATH)/$(LIBTARGET)) 2> /dev/null

$(INSTALLBINPATH)/$(BINTARGET): $(BINTARGET)
	@-echo "Installing $(BINTARGET) in $(INSTALLBINPATH)"; \
	if [ -f $(INSTALLBINPATH)/$(BINTARGET) ] && \
	   [ ! -w $(INSTALLBINPATH)/$(BINTARGET) ]; \
	then \
	  chmod u+w $(INSTALLBINPATH)/$(BINTARGET); \
	fi; \
	cp $(BINTARGET) $(INSTALLBINPATH)/$(BINTARGET); \
	chmod $(INSTALLBINMODE) $(INSTALLBINPATH)/$(BINTARGET); \
	_aliases="$(ALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $(INSTALLBINPATH)/$$i; \
	  echo "linking $(INSTALLBINPATH)/$(BINTARGET) to $(INSTALLBINPATH)/$$i"; \
	  ln $(INSTALLBINPATH)/$(BINTARGET) $(INSTALLBINPATH)/$$i; \
	done

$(INSTALLINCPATH)/atfs.h: atfs.h
	@-echo "Installing atfs.h in $(INSTALLINCPATH)"; \
	if [ -f $(INSTALLINCPATH)/atfs.h ] && \
	   [ ! -w $(INSTALLINCPATH)/atfs.h ]; \
	then \
	  chmod u+w $(INSTALLINCPATH)/atfs.h; \
	fi; \
	cp atfs.h $(INSTALLINCPATH)/atfs.h; \
	chmod $(INSTALLINCMODE) $(INSTALLINCPATH)/atfs.h

$(INSTALLINCPATH)/afsys.h: afsys.h
	@-echo "Installing afsys.h in $(INSTALLINCPATH)"; \
	if [ -f $(INSTALLINCPATH)/afsys.h ] && \
	   [ ! -w $(INSTALLINCPATH)/afsys.h ]; \
	then \
	  chmod u+w $(INSTALLINCPATH)/afsys.h; \
	fi; \
	cp afsys.h $(INSTALLINCPATH)/afsys.h; \
	chmod $(INSTALLINCMODE) $(INSTALLINCPATH)/afsys.h

$(INSTALLINCPATH)/config.h: conf/$(HOSTSYSTEM)/config.h
	@-echo "Installing conf/$(HOSTSYSTEM)/config.h in $(INSTALLINCPATH)"; \
	if [ -f $(INSTALLINCPATH)/config.h ] && \
	   [ ! -w $(INSTALLINCPATH)/config.h ]; \
	then \
	  chmod u+w $(INSTALLINCPATH)/config.h; \
	fi; \
	cp conf/$(HOSTSYSTEM)/config.h $(INSTALLINCPATH)/config.h; \
	chmod $(INSTALLINCMODE) $(INSTALLINCPATH)/config.h


installmanuals:
	@-_manuals="$(MAN3)"; \
	for i in $$_manuals; \
	do \
	  _current=`basename $$i`; \
	  echo "Installing $$_current in $(INSTALLMANPATH)/man3"; \
	  if [ -f $(INSTALLMANPATH)/man3/$$_current ] && \
	     [ ! -w $(INSTALLMANPATH)/man3/$$_current ]; \
	  then \
	    chmod u+w $(INSTALLMANPATH)/man3/$$_current; \
	  fi; \
	  cp $(BASE)/$$i $(INSTALLMANPATH)/man3/$$_current; \
	  chmod $(INSTALLMANMODE) $(INSTALLMANPATH)/man3/$$_current; \
	done; \
	_manuals="$(MAN5)"; \
	for i in $$_manuals; \
	do \
	  _current=`basename $$i`; \
	  echo "Installing $$_current in $(INSTALLMANPATH)/man5"; \
	  if [ -f $(INSTALLMANPATH)/man5/$$_current ] && \
	     [ ! -w $(INSTALLMANPATH)/man5/$$_current ]; \
	  then \
	    chmod u+w $(INSTALLMANPATH)/man5/$$_current; \
	  fi; \
	  cp $(BASE)/$$i $(INSTALLMANPATH)/man5/$$_current; \
	  chmod $(INSTALLMANMODE) $(INSTALLMANPATH)/man5/$$_current; \
	done; \
	_manuals="$(MAN8)"; \
	for i in $$_manuals; \
	do \
	  _current=`basename $$i`; \
	  echo "Installing $$_current in $(INSTALLMANPATH)/man8"; \
	  if [ -f $(INSTALLMANPATH)/man8/$$_current ] && \
	     [ ! -w $(INSTALLMANPATH)/man8/$$_current ]; \
	  then \
	    chmod u+w $(INSTALLMANPATH)/man8/$$_current; \
	  fi; \
	  cp $(BASE)/$$i $(INSTALLMANPATH)/man8/$$_current; \
	  chmod $(INSTALLMANMODE) $(INSTALLMANPATH)/man8/$$_current; \
	done

# The cleanup action. Removes all automatically rederivable files.

doclean:
	rm -f $(LIBTARGET) $(BINTARGET) $(TESTTARGET) $(ALIASES) $(OBJECTS)

# Recursive builds. Performed *before* building targets

subsystems:
	@_subsystems="$(SUBSYSTEMS)"; \
	for i in $$_subsystems; \
	do \
	  echo $$i; \
	  (cd $$i; $(MAKE) \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		SWITCHES="$(SWITCHES)" \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LIBPATH=$(LIBPATH) \
		INCLUDEPATH=$(INCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" \
		VERSIONBINDING=$(VERSIONBINDING) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		ALLTARGETS= \
		MAINTARGET= \
		SHAPELIBPATH=$(SHAPELIBPATH) $(MAINTARGET) ); \
	done

# --------------------------------------------------------------------
#			internals (do not modify)
# --------------------------------------------------------------------

install: +install $(ALLTARGETS)

localinstall: +localinstall $(ALLTARGETS)

clean: +clean $(ALLTARGETS)

+all:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems targets" MAINTARGET=all \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		SWITCHES="$(SWITCHES)" \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LIBPATH=$(LIBPATH) \
		INCLUDEPATH=$(INCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" \
		VERSIONBINDING=$(VERSIONBINDING) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) all; \
	fi

+install:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems installtargets" \
		MAINTARGET=install \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		SWITCHES="$(SWITCHES)" \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LIBPATH=$(LIBPATH) \
		INCLUDEPATH=$(INCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" \
		VERSIONBINDING=$(VERSIONBINDING) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) install; \
	fi

+localinstall:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems localinstalltargets" \
		MAINTARGET=install \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		SWITCHES="$(SWITCHES)" \
		INSTALLBASE=$(BASE) \
		LIBPATH=$(LIBPATH) \
		INCLUDEPATH=$(INCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" \
		VERSIONBINDING=$(VERSIONBINDING) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) localinstall; \
	fi

+clean:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems doclean" MAINTARGET=clean \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		SWITCHES="$(SWITCHES)" \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LIBPATH=$(LIBPATH) \
		INCLUDEPATH=$(INCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" \
		VERSIONBINDING=$(VERSIONBINDING) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) clean; \
	fi
