## Copyright (C) 1993,1994 by the author(s).
# 
# This software is published in the hope that it will be useful, but
# WITHOUT ANY WARRANTY for any part of this software to work correctly
# or as described in the manuals. See the ShapeTools Public License
# for details.
#
# Permission is granted to use, copy, modify, or distribute any part of
# this software but only under the conditions described in the ShapeTools 
# Public License. A copy of this license is supposed to have been given
# to you along with ShapeTools in a file named LICENSE. Among other
# things, this copyright notice and the Public License must be
# preserved on all copies.

#
# Makefile for AtFS
#
# Authors: Andreas Lampen (Andreas.Lampen@cs.tu-berlin.de)
#          Axel Mahler (Axel.Mahler@cs.tu-berlin.de)
#
# $Header: Makefile[7.0] Thu Jan 20 21:10:59 1994 andy@cs.tu-berlin.de frozen $
#

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

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

BASE = /home/stone/shape/development

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

NODEPATH = src/atfs

# A short name for this node system

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 -DATFS_OWN_LOCKING

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

INSTALLBASE = /home/stone/shape
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.

LOCALLIBPATH     = $(BASE)/lib
LOCALINCLUDEPATH = $(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 PROGTARGET LIBTARGET or any better names). In this case you 
# have to adjust the system building actions accordingly.

LIBTARGET = libAtFS.a
BINTARGET = atfsrepair
CACHETARGET = cacheadm
SHTARGET = mkatfs

# 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).

LIBALIASES =
BINALIASES =
SHALIASES =

# The regular source and header files.

SHSOURCES = mkatfs.sh

SOURCES = afarchive.c afarlock.c afattrs.c afcache.c afcompar.c afdelta.c \
	afdeltaproc.c afenviron.c aferror.c affiles.c afkeys.c \
	aflib.c aflock.c afmemory.c afnames.c afobjcache.c afretr.c \
	afsattrs.c afsets.c afstates.c afstore.c afsymtab.c aftime.c \
	aftmpfiles.c aftransact.c afudattrs.c afvers.c \
	atfsrepair.c cacheadm.c config.c $(SHSOURCES)

HEADERS = atfs.h afsys.h afarchive.h atfsrepair.h config.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 = 

AUXHEADERS = 

# Sources of variant source components stored under equal names in
# different locations. During system builds, only one of each (equally
# named) group is chosen. Source distributions need all of them.

VARIANTSOURCES =

VARIANTHEADERS =

# The manuals

MANUALS = $(MAN1) $(MAN3) $(MAN4) $(MAN5) $(MAN6) $(MAN7) $(MAN8)
MAN1 = man/man1/atfsrepair.1 man/man1/cacheadm.1 man/man1/mkatfs.1
MAN3 = man/man3/af_intro.3 \
	man/man3/af_attrs.3 man/man3/af_cache.3 man/man3/af_error.3 \
	man/man3/af_files.3 man/man3/af_history.3 man/man3/af_lock.3 \
	man/man3/af_misc.3 man/man3/af_note.3 man/man3/af_protect.3 \
	man/man3/af_retrieve.3 man/man3/af_sets.3 \
	man/man3/af_transact.3 man/man3/af_version.3 
MAN4 = 
MAN5 = man/man5/af_archive.5
MAN6 = 
MAN7 = 
MAN8 = 

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

COMPONENTS = $(SOURCES) $(HEADERS) $(MANUALS) Shapefile Makefile Dependencies

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

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

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


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

MAKE = make
SHELL = /bin/sh

INCLUDES = -I$(LOCALINCLUDEPATH)
MAKECFLAGS = -g
MAKELDFLAGS = -g

CC = cc
CFLAGS  = $(INCLUDES) $(MAKECFLAGS) -D$(HOSTSYSTEM) $(SWITCHES)
LDFLAGS = $(MAKELDFLAGS)

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) $(CACHETARGET) $(SHTARGET)

$(LIBTARGET): $(LIBOBJECTS)
	-ar ruv $(LIBTARGET) $(LIBOBJECTS)
	@-($(RANLIB) $(LIBTARGET)) 2> /dev/null; true
	@_aliases="$(LIBALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $$i; \
	  echo linking $(LIBTARGET) to $$i; \
	  ln $(LIBTARGET) $$i; \
	done

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

$(CACHETARGET): cacheadm.o $(LIBTARGET)
	$(CC) $(LDFLAGS) -o $(CACHETARGET) cacheadm.o $(LIBTARGET) $(SYSLIBS)
	@_aliases="$(CACHEALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $$i; \
	  echo linking $(CACHETARGET) to $$i; \
	  ln $(CACHETARGET) $$i; \
	done

$(SHTARGET): $(SHSOURCES)
	@rm -f $(SHTARGET); \
	if [ $(HOSTSYSTEM) = s_ultrix ]; \
	then \
	  echo '#!/bin/sh5' > $(SHTARGET); \
	else \
	  echo '#!/bin/sh' > $(SHTARGET); \
	fi
	cat $(SHSOURCES) >> $(SHTARGET);
	@chmod +x $(SHTARGET)

localinstalltargets: $(LOCALLIBPATH)/$(LIBTARGET) \
	$(LOCALINCLUDEPATH)/atfs.h \
	$(LOCALINCLUDEPATH)/afsys.h \
	$(LOCALINCLUDEPATH)/config.h \
	$(BINTARGET) $(CACHETARGET) $(SHTARGET)

$(LOCALLIBPATH)/$(LIBTARGET): $(LIBTARGET)
	@-echo "Copying $(LIBTARGET) to $(LOCALLIBPATH)"; \
	if [ -f $(LOCALLIBPATH)/$(LIBTARGET) ] ;\
	then \
	mv -f $(LOCALLIBPATH)/$(LIBTARGET) \
	      $(LOCALLIBPATH)/$(LIBTARGET).old;\
	fi; \
	cp $(LIBTARGET) $(LOCALLIBPATH)/$(LIBTARGET); \
	chmod $(INSTALLLIBMODE) $(LOCALLIBPATH)/$(LIBTARGET); \
	($(RANLIB) $(LOCALLIBPATH)/$(LIBTARGET)) 2> /dev/null; \
	_aliases="$(LIBALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $(LOCALLIBPATH)/$$i; \
	  echo "linking $(LOCALLIBPATH)/$(LIBTARGET) to $(LOCALLIBPATH)/$$i"; \
	  ln $(LOCALLIBPATH)/$(LIBTARGET) $(LOCALLIBPATH)/$$i; \
	done

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

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

$(LOCALINCLUDEPATH)/config.h: config.h
	@-echo "Copying config.h to $(LOCALINCLUDEPATH)"; \
	mv config.h config.h.orig; \
	sed -e s/_system_/$(HOSTSYSTEM)/ config.h.orig > config.h; \
	if [ -f $(LOCALINCLUDEPATH)/config.h ] && \
	   [ ! -w $(LOCALINCLUDEPATH)/config.h ]; \
	then \
	  chmod u+w $(LOCALINCLUDEPATH)/config.h; \
	fi; \
	cp config.h $(LOCALINCLUDEPATH)/config.h; \
	chmod $(INSTALLINCMODE) $(LOCALINCLUDEPATH)/config.h; \
	rm -f config.h; \
	mv config.h.orig config.h

installtargets: $(INSTALLLIBPATH)/$(LIBTARGET) $(INSTALLINCPATH)/atfs.h \
        $(INSTALLINCPATH)/afsys.h $(INSTALLINCPATH)/config.h \
	$(INSTALLBINPATH)/$(BINTARGET) $(INSTALLBINPATH)/$(CACHETARGET) \
	$(INSTALLBINPATH)/$(SHTARGET)

$(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; \
	_aliases="$(LIBALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $(INSTALLLIBPATH)/$$i; \
	  echo "linking $(INSTALLLIBPATH)/$(LIBTARGET) to $(INSTALLLIBPATH)/$$i"; \
	  ln $(INSTALLLIBPATH)/$(LIBTARGET) $(INSTALLLIBPATH)/$$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: config.h
	@-echo "Installing config.h in $(INSTALLINCPATH)"; \
	mv config.h config.h.orig; \
	sed -e s/_system_/$(HOSTSYSTEM)/ config.h.orig > config.h; \
	if [ -f $(INSTALLINCPATH)/config.h ] && \
	   [ ! -w $(INSTALLINCPATH)/config.h ]; \
	then \
	  chmod u+w $(INSTALLINCPATH)/config.h; \
	fi; \
	cp config.h $(INSTALLINCPATH)/config.h; \
	chmod $(INSTALLINCMODE) $(INSTALLINCPATH)/config.h; \
	rm -f config.h; \
	mv config.h.orig config.h

$(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="$(BINALIASES)"; \
	for i in $$_aliases; \
	do \
	  rm -f $(INSTALLBINPATH)/$$i; \
	  echo "linking $(INSTALLBINPATH)/$(BINTARGET) to $(INSTALLBINPATH)/$$i"; \
	  ln $(INSTALLBINPATH)/$(BINTARGET) $(INSTALLBINPATH)/$$i; \
	done

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

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

installmanuals:
	@-_manuals="$(MAN1)"; \
	for i in $$_manuals; \
	do \
	  _current=`basename $$i`; \
	  echo "Installing $$_current in $(INSTALLMANPATH)/man1"; \
	  if [ -f $(INSTALLMANPATH)/man1/$$_current ] && \
	     [ ! -w $(INSTALLMANPATH)/man1/$$_current ]; \
	  then \
	    chmod u+w $(INSTALLMANPATH)/man1/$$_current; \
	  fi; \
	  cp $(BASE)/$$i $(INSTALLMANPATH)/man1/$$_current; \
	  chmod $(INSTALLMANMODE) $(INSTALLMANPATH)/man1/$$_current; \
	done; \
	_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

# Do not install libraries

noinstall: $(INSTALLBINPATH)/$(BINTARGET) $(INSTALLBINPATH)/$(CACHETARGET) \
	$(INSTALLBINPATH)/$(SHTARGET)

# The cleanup action. Removes all automatically rederivable files.

doclean:
	rm -f $(LIBTARGET) $(BINTARGET) $(CACHETARGET) $(SHTARGET) \
	$(LIBALIASES) $(BINALIASES) $(SHALIASES) $(OBJECTS)

# Recursive builds. Performed *before* building $(TARGET)

subsystems:
	@_subsystems="$(SUBSYSTEMS)"; \
	for i in $$_subsystems; \
	do \
	  echo cd $$i; \
	  (cd $$i; $(MAKE) \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LOCALLIBPATH=$(LOCALLIBPATH) \
		LOCALINCLUDEPATH=$(LOCALINCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" \
		BINDDEFAULT=$(BINDDEFAULT) \
		BINDINSTALL=$(BINDINSTALL) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) \
		ALLTARGETS= \
		MAINTARGET= \
		$(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) \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LOCALLIBPATH=$(LOCALLIBPATH) \
		LOCALINCLUDEPATH=$(LOCALINCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" all; \
	fi

+install:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems installtargets" \
		MAINTARGET=install \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LOCALLIBPATH=$(LOCALLIBPATH) \
		LOCALINCLUDEPATH=$(LOCALINCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" install; \
	fi

+localinstall:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems localinstalltargets" \
		MAINTARGET=install \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		INSTALLBASE=$(BASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LOCALLIBPATH=$(LOCALLIBPATH) \
		LOCALINCLUDEPATH=$(LOCALINCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" localinstall; \
	fi

+clean:
	@-if [ -n "$(ALLTARGETS)" ]; \
	then : ; \
	else \
	  $(MAKE) ALLTARGETS="subsystems doclean" MAINTARGET=clean \
		BASE=$(BASE) \
		HOSTSYSTEM=$(HOSTSYSTEM) \
		HOSTTYPE=$(HOSTTYPE) \
		INSTALLBASE=$(INSTALLBASE) \
		INSTALLBINPATH=$(INSTALLBINPATH) \
		INSTALLBINMODE=$(INSTALLBINMODE) \
		INSTALLINCPATH=$(INSTALLINCPATH) \
		INSTALLINCMODE=$(INSTALLINCMODE) \
		INSTALLLIBPATH=$(INSTALLLIBPATH) \
		INSTALLLIBMODE=$(INSTALLLIBMODE) \
		INSTALLMANPATH=$(INSTALLMANPATH) \
		INSTALLMANMODE=$(INSTALLMANMODE) \
		LOCALLIBPATH=$(LOCALLIBPATH) \
		LOCALINCLUDEPATH=$(LOCALINCLUDEPATH) \
		MAKE="$(MAKE)" \
		SHELL="$(SHELL)" \
		CC="$(CC)" \
		CFLAGS="$(CFLAGS)" \
		LDFLAGS="$(LDFLAGS)" \
		RANLIB="$(RANLIB)" \
		SYSLIBS="$(SYSLIBS)" clean; \
	fi
