# # Copyright (C) 1989,1990,1991,1992 by
#	Wilfried Koch, Andreas Lampen, Axel Mahler, Juergen Nickelsen,
#	Wolfgang Obst and Ulrich Pralle 
# 
# This file is part of shapeTools.
#
# 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 rcs2atfs
#
# $Header: Makefile[1.15] Wed Mar 11 14:17:01 1992 nickel@cs.tu-berlin.de accessed $
#

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

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

BASE = /home/stone/shape/development

# Path of a subsystem relative to the root of the system hierarchy
# (e.g. vc/save)

NODEPATH = src/vc/rcs2atfs

# A short name for the (sub)system (used for building the release ID)

NODENAME = rcs2atfs

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

HOSTSYSTEM = s-sunos_4

# The processor type.

HOSTTYPE = sun4

# Preprocessor switches. (eg. -DSTATISTICS)

SWITCHES = 

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

INSTALLBASE = /usr/local
INSTALLBINPATH = $(INSTALLBASE)/bin
INSTALLBINMODE = 755
INSTALLINCPATH = $(INSTALLBASE)/include
INSTALLINCMODE = 444
INSTALLLIBPATH = $(INSTALLBASE)/lib/shape
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.

TARGET1 = rcs2atfs
TARGET2 = utime

TARGET = $(TARGET1) $(TARGET2)

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

VERSIONFILE = 	version.c
VERSIONOBJECT =	version.o

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

RSOURCES = afind.c main.c out.c readin.c utils.c
USOURCES = utime.c 
SOURCES = $(RSOURCES) $(USOURCES)

HEADERS = functions.h rcs2atfs.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 =

# Interface header files. These are the heder files to be installed
# together with eg. a library. $(IFHEADERS) usually is a subset of
# $(HEADERS).

IFHEADERS = 

# The manuals

MANUALS = $(MAN1) $(MAN3) $(MAN4) $(MAN5) $(MAN6) $(MAN7) $(MAN8)
MAN1 = rcs2atfs.1 utime.1
MAN3 = 
MAN4 = 
MAN5 = 
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 autamatically produced during
# a build process should be listed here.

OBJECTS1 = afind.o main.o out.o readin.o utils.o $(VERSIONOBJECT)
OBJECTS2 = utime.o

OBJECTS = $(OBJECTS1) $(OBJECTS2)

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

MAKE = make
SHELL = /bin/sh
CC = cc
CFLAGS  = -I$(INCLUDEPATH) $(SWITCHES) -O
LDFLAGS = -s
RANLIB  = /usr/bin/ranlib

# System libraries, local libraries and lint libraries.

SYSLIBS   =
LOCALLIBS = $(LIBPATH)/libatfstk.a $(LIBPATH)/libatfs.a
LINTLIBS  =

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

# The default action (do not change)

all: +all $(ALLTARGETS)

funcs:	$(RSOURCES) rcs2atfs.h $(VERSIONFILE)
	touch functions.h
	cextract -I$(INCLUDEPATH) +scm -E -o new_functions.h $(RSOURCES) \
		$(VERSIONFILE)
	mv new_functions.h functions.h

tags:	$(SOURCES) $(HEADERS) $(VERSIONFILE)
	etags $(SOURCES) $(HEADERS) $(VERSIONFILE) \
	$(PARTIALRELEASEBASE)/src/atfs/*.c $(PARTIALRELEASEBASE)/src/atfstk/*.c

# The final system building action.

targets: $(TARGET1) $(TARGET2)

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

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

# Construction of a library would look like:
#$(TARGET): $(OBJECTS)
#	@ar ruv $(TARGET) $(OBJECTS); \
#	($(RANLIB) $(TARGET)) 2> /dev/null

installtargets: $(INSTALLBINPATH)/$(TARGET1) $(INSTALLBINPATH)/$(TARGET2)

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

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

# Installing a library
#installtargets: $(INSTALLLIBPATH)/$(TARGET) installincludes
#
#$(INSTALLLIBPATH)/$(TARGET): $(TARGET)
#	@-echo "installing $(TARGET) in $(INSTALLLIBPATH)"; \
#	if [ -f $(INSTALLLIBPATH)/$(TARGET) ] ;\
#	then \
#	mv -f $(INSTALLLIBPATH)/$(TARGET) \
#	      $(INSTALLLIBPATH)/$(TARGET).old;\
#	fi; \
#	cp $(TARGET) $(INSTALLLIBPATH)/$(TARGET); \
#	chmod $(INSTALLLIBMODE) $(INSTALLLIBPATH)/$(TARGET); \
#	($(RANLIB) $(INSTALLLIBPATH)/$(TARGET)) 2> /dev/null

installmanuals: $(MANUALS)
	@-_manuals="$(MAN1)"; \
	for i in $$_manuals; \
	do \
	  echo "installing $$i in $(INSTALLMANPATH)/man1"; \
	  if [ -f $(INSTALLMANPATH)/man1/$$i ] && \
	     [ ! -w $(INSTALLMANPATH)/man1/$$i ]; \
	  then \
	    chmod u+w $(INSTALLMANPATH)/man1/$$i; \
	  fi; \
	  cp $$i $(INSTALLMANPATH)/man1/$$i; \
	  chmod $(INSTALLMANMODE) $(INSTALLMANPATH)/man1/$$i; \
	done

installincludes: $(IFHEADERS)
	@-_includes="$(IFHEADERS)"; \
	for i in $$_includes; \
	do \
	  echo "installing $$i in $(INSTALLINCPATH)"; \
	  if [ -f $(INSTALLINCPATH)/$$i ] && \
	     [ ! -w $(INSTALLINCPATH)/$$i ]; \
	  then \
	    chmod u+w $(INSTALLINCPATH)/$$i; \
	  fi; \
	  cp $$i $(INSTALLINCPATH)/$$i; \
	  chmod $(INSTALLINCMODE) $(INSTALLINCPATH)/$$i; \
	done

# The cleanup action. Removes all automatically rederivable files.

doclean:
	rm -f $(TARGET) $(ALIASES) $(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) \
		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)" \
		BINDDEFAULT=$(BINDDEFAULT) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) \
		ALLTARGETS= \
		MAINTARGET= \
		$(MAINTARGET) ); \
	done

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

install: +install $(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)" \
		BINDDEFAULT=$(BINDDEFAULT) \
		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)" \
		BINDDEFAULT=$(BINDDEFAULT) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) install; \
	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)" \
		BINDDEFAULT=$(BINDDEFAULT) \
		COMPILER=$(COMPILER) \
		QUALITY=$(QUALITY) \
		TOTALRELEASEBASE=$(TOTALRELEASEBASE) \
		PARTIALRELEASEBASE=$(PARTIALRELEASEBASE) \
		SHAPELIBPATH=$(SHAPELIBPATH) clean; \
	fi
