default : opt 

opt   : $(EXEC:=.opt)\
	$(LIB:=.opt)\
	$(PLUGIN:=.opt)\

debug : $(EXEC:=.dbg)\
	$(LIB:=.dbg)\
	$(PLUGIN:=.dbg)\

cleandepend : cleandependopt cleandependdbg

cleandependopt :
	[ -d $(OPTDIR) ] && cd $(OPTDIR); rm -f Makedepend; rm -rf .depend

cleandependdbg :
	[ -d $(DEBUGDIR) ] && cd $(DEBUGDIR); rm -f Makedepend; rm -rf .depend

cleantarget : cleantargetopt cleantargetdbg

cleantargetopt : 
	@[ -d $(OPTDIR) ] && cd $(OPTDIR); rm -f $(EXEC) $(LIB) $(PLUGIN)

cleantargetdbg : 
	@[ -d $(DEBUGDIR) ] && cd $(DEBUGDIR); rm -f $(EXEC) $(LIB) $(PLUGIN)

clean : cleanopt cleandbg

cleanopt : 
	[ -d $(OPTDIR) ] && cd $(OPTDIR); rm -f $(OBJS) Makedepend; rm -rf .depend

cleandbg : 
	[ -d $(DEBUGDIR) ] && cd $(DEBUGDIR); rm -f $(OBJS) Makedepend; rm -rf .depend

clobber : clobberdbg clobberopt

clobberopt : 
	rm -rf $(OPTDIR)

clobberdbg : 
	rm -rf $(DEBUGDIR)


beautify : 
	for f in *.cpp ; do mv $$f $$f.bak; bcpp $$f.bak $$f; rm $$f.bak; done
	for f in *.h ; do mv $$f $$f.bak; bcpp $$f.bak $$f; rm $$f.bak; done

docs:
	[ "$(TARGET_BASENAME)" != "" ] && \
	mkdir -p $(TOPDIR)/doc/doc++/$(TARGET_BASENAME) && \
	doc++ -d $(TOPDIR)/doc/doc++/$(TARGET_BASENAME) -H -A \
	    $(TOPDIR)/include/$(TARGET_BASENAME)/* && \
	echo "$(TARGET_BASENAME) HTML documentation created in "\
	     "$(TOPDIR)/doc/doc++/$(TARGET_BASENAME)"


$(EXEC) : $(OBJS) 
	$(C++) $(LDFLAGS) $(OBJS) $(LIBS) -o $@


## Mac OSX makes the distinction between -dynamiclib and -bundle
## causing us to have to make a special case here, rather than 
## just redefining the SHARED argument.

ifeq ($(OS),Darwin)

$(LIB) : $(OBJS)
	$(C++) $(LDFLAGS) -dynamiclib $(OBJS) $(LIBS) -o $@

$(PLUGIN) : $(OBJS)
	$(C++) $(LDFLAGS) -bundle $(OBJS) $(LIBS) -o $@
else
ifeq ($(OS),HP-UX)
# we need to explicitly tell the linker the library name - else it will
# include paths like ../../../libosg.sl into executables
$(LIB) $(PLUGIN) : $(OBJS)
	$(C++) $(LDFLAGS) $(SHARED) $(OBJS) $(LIBS) -Wl,+h -Wl,$@ -o $@
else
$(LIB) $(PLUGIN) : $(OBJS)
	$(C++) $(LDFLAGS) $(SHARED) $(OBJS) $(LIBS) -o $@

endif # not HP-UX
endif # not Darwin

$(EXEC:=.dbg) :
	@[ -d $(DEBUGDIR) ] || mkdir $(DEBUGDIR)
	@cd $(DEBUGDIR); \
	  $(MAKE) -f ../GNUmakefile "DOF=$(DBGF)"  TOPDIR=../${TOPDIR} \
	      THISDIR=../$(THISDIR)\
	      MAKEDEPEND=Makedepend $(EXEC)
	@$(MAKE) LNSRC=$(DEBUGDIR)/$(EXEC) LNDEST=$(BININST)/$(EXEC) __link

$(LIB:=.dbg) : $(PLUGIN:=.dbg)
	@[ -d $(DEBUGDIR) ] || mkdir $(DEBUGDIR)
	@cd $(DEBUGDIR);\
	  $(MAKE) -f ../GNUmakefile "DOF=$(DBGF)"  TOPDIR=../${TOPDIR} \
	      THISDIR=../$(THISDIR)\
	      MAKEDEPEND=Makedepend $(LIB)
	@$(MAKE) LNSRC=$(DEBUGDIR)/$(LIB) LNDEST=$(LIBINST)/$(LIB) __link

$(PLUGIN:=.dbg) : 
	@[ -d $(DEBUGDIR) ] || mkdir $(DEBUGDIR)
	@cd $(DEBUGDIR); \
	  $(MAKE) -f ../GNUmakefile "DOF=$(DBGF)"  TOPDIR=../${TOPDIR} \
	      THISDIR=../$(THISDIR)\
	      MAKEDEPEND=Makedepend $(PLUGIN)
	@$(MAKE) LNSRC=$(DEBUGDIR)/$(PLUGIN) LNDEST=$(PLUGININST)/$(PLUGIN) __link

$(EXEC:=.opt) : 
	@[ -d $(OPTDIR) ] || mkdir $(OPTDIR)
	@cd $(OPTDIR); \
	  $(MAKE) -f ../GNUmakefile DOF=$(OPTF)  TOPDIR=../${TOPDIR} \
	      THISDIR=../$(THISDIR)\
	      MAKEDEPEND=Makedepend $(EXEC)
	@$(MAKE) LNSRC=$(OPTDIR)/$(EXEC) LNDEST=$(BININST)/$(EXEC) __link


$(LIB:=.opt) : 
	@[ -d $(OPTDIR) ] || mkdir -p $(OPTDIR)
	@cd $(OPTDIR);\
	  $(MAKE) -f ../GNUmakefile DOF=$(OPTF) TOPDIR=../${TOPDIR} \
	        THISDIR=../$(THISDIR)\
	        MAKEDEPEND=Makedepend $(LIB)
	@$(MAKE) LNSRC=$(OPTDIR)/$(LIB) LNDEST=$(LIBINST)/$(LIB) __link

$(PLUGIN:=.opt) : 
	@[ -d $(OPTDIR) ] || mkdir -p $(OPTDIR)
	@cd $(OPTDIR); \
	  $(MAKE) -f ../GNUmakefile DOF=$(OPTF) TOPDIR=../${TOPDIR} \
	    THISDIR=../$(THISDIR)\
	               MAKEDEPEND=Makedepend $(PLUGIN)
	@$(MAKE) LNSRC=$(OPTDIR)/$(PLUGIN) LNDEST=$(PLUGININST)/$(PLUGIN) __link


## Revamped method for making Makedepend files
## Under this method, Makedepend simply includes
## all dependency files which are built for each 
## individual source file.  At update, only the individual
## dependency file is updated rather than the whole of Makedepend

Makedepend : $(CXXFILES) $(CFILES)
ifeq ($(OS),IRIX)
	touch $@
else
	@ touch $@
	@if [ ! -d .depend ] ; then  \
		mkdir .depend;\
		depfiles="$+";\
	else\
		depfiles="$?";\
	fi;\
	if [ ! -z "$$depfiles" ]; then\
	for f in $$depfiles; do \
		echo "$(C++) $(DEPARG) $(INC) $$f  pipeto .depend/`basename $$f`"; \
		$(C++) $(DEPARG) $(INC) $$f > .depend/`basename $$f`; \
		grep $$f $@ || echo include .depend/`basename $$f` >> Makedepend ;\
	done;\
	fi
endif


ifeq (0,1) ##### OLD WAY : Keep until we've proven that this doesn't trip up
           ##### on other OS's.
    Makedepend : $(CXXFILES) $(CFILES) 
    ifeq ($(OS),IRIX)   
    	touch $@
    else
    ifeq (0,1) # This is an experiment
    	@ [ -d depend ] || mkdir depend
    	@ rm -f $@;
    	 for f in $?; do \
    	    ff=`basename $$f`;\
    	    $(C++) $(INC) $(DEPARG) > depend/$$ff ;\
    	    echo "include depend/$$ff" >> $@;\
    	done
    else
    	$(C++) $(INC) $(DEPARG) $^ > $(MAKEDEPEND)
    endif
    endif

endif


.SUFFIXES: .cpp .o
.cpp.o:
	$(C++) $(CXXFLAGS) -c $<

depend : $(MAKEDEPEND)


###############################################################################
#
#  Ok.. If  you are looking hard at the following lines of gnarled code, you 
#  deserve an explanation.  This target makes a link from the installed 
#  directories (Assumed to be rooted at $(TOPDIR), usually $(TOPDIR)/bin or 
#  $(TOPDIR)/lib) to a just-built target. Both LNSRC (Link source) and LNDEST 
#  (Link destination) must be defined before calling 'make __link'.  
#  
#  The first four lines check to see that both LNSRC and LNDEST have been 
#  defined.
#  
#  The (very long) following 'if' statement reads in pseudo-code like this:
#  
#     if the current link is not pointing to the intended destination
#      then
#          announce (echo) intentions to reset link
#          compute the link path by the following steps
#  	    a) define SRCDIR as the current absolute directory 
#  	       appended by the directory of the intended source of the link
#  	    b) define DESTDIR as the absolute path of $(TOPDIR) appended by
#  	       the directory of the intended destination of the link
#  	    c) define a temproary variable T to be the absolute path of
#  	       the destination directory less the prefix of the absolute
#  	       path of $(TOPDIR)
#  	         e.g.   /root/work/thisdir/bin/ - /root/work/thisdir/ = bin/
#           d) Run a loop, truncating the path represented by T until 
#              'dirname' returns '.'.  On each iteration increment PFX 
#              (Prefix) by '../'  This will define the prefix for the path 
#              of the link.  
#  	         e.g. If DESTDIR is lib/osgPlugins, PFX is ../../
#  	    e) Define the link as a concatenation of PFX and the absolute 
#              path of the source directory less the absolute path of 
#              $(TOPDIR)
#  
#          Change directories in to the link destination directory 
#  	   run the link command
#
###############################################################################

__link : 
	@[ -n "$(LNSRC)" ] || echo "Internal error (LNSRC definition)"
	@[ -n "$(LNSRC)" ] && echo > /dev/null
	@[ -n "$(LNDEST)" ] || echo "Internal error (LNDEST definition)"
	@[ -n "$(LNDEST)" ] && echo > /dev/null
	@if diff -s $(TOPDIR)/$(LNDEST) $(LNSRC) >/dev/null 2>&1;\
	  then\
	    echo "  =====> $(LNSRC) and $(TOPDIR)/$(LNDEST) are in sync";\
	  else\
	    echo "  =====> resetting $(TOPDIR)/$(LNDEST) to point to $(LNSRC)";\
	    SRCDIR=`pwd`/`dirname $(LNSRC)`;\
	    cd $(TOPDIR);\
	    ROOTDIR=`pwd`;\
	    DESTDIR=`dirname $$ROOTDIR/$(LNDEST)`;\
	    T=`echo $$DESTDIR $$ROOTDIR | \
	    	awk '{print substr($$1,length($$2)+2,512)}'`;\
	    while [ "$$T" != "." ]; do T=`dirname $$T`;PFX=../"$$PFX";done;\
	    LINK="$$PFX"`echo $$SRCDIR $$ROOTDIR  | awk \
	      '{ print substr($$1,length($$2)+2,512) }'`/`basename $(LNDEST)`;\
	    cd `dirname $(LNDEST)`;\
	    rm -f `basename $(LNDEST)`;\
	    $(LINK) $$LINK `basename $(LNDEST)`;\
	 fi
		
__instfiles :
	@echo $(INSTFILES)

sinclude $(MAKEDEPEND)