###############################################################################
#
#    Makefile for NXLIB    
#    Copyright (C) 1993 A. Bode, S. Lamberts, T. Ludwig, G. Stellner
#
#    This file is part of NXLIB (Paragon(TM) message passing on workstations)
#
#    NXLIB is free software; you can redistribute it and/or
#    modify it under the terms of the GNU Library General Public
#    License as published by the Free Software Foundation; either
#    version 2 of the License, or (at your option) any later version.
#
#    NXLIB is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#    Library General Public License for more details.
#
#    You should have received a copy of the GNU Library General Public
#    License along with this library; if not, write to the Free
#    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
#    Contact to the authors:
#
#    electronic mail: nxlib@informatik.tu-muenchen.de
#
#    paper mail:      Prof. Dr. A. Bode
#                     Lehrstuhl f"ur Rechnertechnik und Rechnerorganisation
#                     Institut f"ur Informatik
#                     Technische Universit"at M"unchen
#                     80290 M"unchen
#                     Germany
#
#    Paragon(TM) is a trademark of Intel Corporation.
#
###############################################################################
#
# Makefile,v
# 1995/02/10 16:14:01
# 1.23
# Exp
# lamberts
#
# Authors: Stefan Lamberts
#
# Description:
#
#   Makefile for NXLIB
#
###############################################################################
#
# rcs_id: "Makefile,v 1.23 1995/02/10 16:14:01 lamberts Exp"
#

###############################################################################
# DO NOT MODIFY THIS FILE
###############################################################################


include Makefile.config

# The shell which is used by the makefile
SHELL = /bin/sh

AR = ar
ARFLAGS = rv

LEX = lex
LFLAGS =

YACC = yacc
YFLAGS =

LINT = lint

RM = rm -f

.SUFFIXES: .ln $(SUFFIXES)

.c.o:
	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<

.c.ln:
	$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(LINT_ln) $<

.c.a:
	$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $% $<
	$(AR) $(ARFLAGS) $@ $%
	$(RM) $%

include Makefile.$(ARCH)

#CFLAGS = -g

CPPFLAGS = $(XPAR) $(DHALT) $(AHALT) -D$(ARCH) -DMAIN_TMPL=$(MAIN_TMPL) $(ARCHCPPFLAGS)

LINTDIR = LINT

ARCH_FILE = .arch

NXLIBDIR_FILE = .nxlibdir

LIBDIR = $(NXLIBDIR)/lib

BINDIR = $(NXLIBDIR)/bin

INCDIR = $(NXLIBDIR)/include

LIBNX = $(LIBDIR)/libnx.a

DAEMON_DIR = daemon

MAIN_DIR = main

TOOL_DIR = tools

LIBNX_DIRS =\
	additions\
	addresses\
	buffer\
	fortran\
	global\
	local\
	nxcalls\
	reliable\
	remote\
	signal\
	startup\
	tcp



all: check libnx mains nxdaemon tool includes

check: check_arch check_nxlibdir

check_arch:
	@if [ -f $(ARCH_FILE) ] ;\
	then\
		arch=`cat $(ARCH_FILE)` ;\
		if [ $$arch != $(ARCH) ] ;\
		then \
			echo "Cleaning due to wrong $(ARCH_FILE)" ;\
			$(MAKE) $(MFLAGS) clean\
				"RM = $(RM)" ;\
			echo $(ARCH) > $(ARCH_FILE) ;\
		fi \
	else\
		echo $(ARCH) > $(ARCH_FILE) ;\
	fi

check_nxlibdir:
	@if [ -f $(NXLIBDIR_FILE) ] ;\
	then\
		nxlibdir=`cat $(NXLIBDIR_FILE)` ;\
		if [ $$nxlibdir != $(NXLIBDIR) ] ;\
		then \
			echo "Cleaning $(TOOL_DIR) due to wrong $(NXLIBDIR_FILE)" ;\
			(	cd $(TOOL_DIR);\
				$(MAKE) $(MFLAGS) clean\
					"RM = $(RM)"\
			);\
			echo $(NXLIBDIR) > $(NXLIBDIR_FILE) ;\
		fi \
	else\
		echo $(NXLIBDIR) > $(NXLIBDIR_FILE) ;\
	fi

xpall: xpar
	$(MAKE) $(MFLAGS) "XPAR = -DXPARAGON" all

noxpall: xpar
	$(MAKE) $(MFLAGS) all

nohalt: a_halt d_halt
	$(MAKE) $(MFLAGS) all

adhalt: a_halt d_halt
	$(MAKE) $(MFLAGS) "AHALT = -DHALTAPPL" "DHALT = -DHALTDAEMON" all

ahalt: a_halt d_halt
	$(MAKE) $(MFLAGS) "AHALT = -DHALTAPPL" all

dhalt: a_halt d_halt
	$(MAKE) $(MFLAGS) "DHALT = -DHALTDAEMON" all

xpar:
	touch buffer/buf_send.c
	touch nxcalls/nxinit.c

a_halt:
	touch startup/applproc.c

d_halt:
	touch daemon/nxdaemon.c

tool: bindir
	@echo "Making tools"
	@( \
		cd $(TOOL_DIR); \
		$(MAKE) $(MFLAGS) all \
			"CXX = $(CXX)" \
			"CC = $(CC)" \
			"FC = $(FC)" \
			"NXLDLIBS = $(NXLDLIBS)" \
			"NXFFLAGS = $(NXFFLAGS)" \
			"NXFLDLIBS = $(NXFLDLIBS)" \
			"NXFLIBS_CG87 = $(NXFLIBS_CG87)" \
			"NXFLIBS_CG89 = $(NXFLIBS_CG89)" \
			"NXFLIBS_CG92 = $(NXFLIBS_CG92)" \
			"DEBUGGER = $(DEBUGGER)" \
			"NXLIBDIR = $(NXLIBDIR)" \
			"FMAIN_TMPL = $(FMAIN_TMPL)" \
			"MAIN_TMPL = $(MAIN_TMPL)" \
			"RM = $(RM)"\
			"CPLUSPLUS = $(CPLUSPLUS)"\
			"MKNOD_TMPL = $(MKNOD_TMPL)"\
			"SIGINT_TMPL = $(SIGINT_TMPL)"\
	)
	
	@if [ "$(CPLUSPLUS)" = "YES" ]; then cp $(TOOL_DIR)/vpCC $(BINDIR); fi
	@cp $(TOOL_DIR)/vpcc $(BINDIR)
	@cp $(TOOL_DIR)/vpf77 $(BINDIR)
	@cp $(TOOL_DIR)/ddbg $(BINDIR)
	@cp $(TOOL_DIR)/adbg $(BINDIR)
	@cp $(TOOL_DIR)/nxlstdin $(BINDIR)


nxdaemon: bindir
	@echo "Making nxdaemon for $(ARCH)";
	@( \
		cd $(DAEMON_DIR); \
		$(MAKE) $(MFLAGS) nxdaemon \
			"CC = $(CC)" \
			"CFLAGS = $(CFLAGS)" \
			"CPPFLAGS = $(CPPFLAGS)" \
			"NXLDLIBS = $(NXLDLIBS)" \
			"LIBDIR = $(LIBDIR)" \
			"LIBNX = $(LIBNX)" \
	)
	
	@cp $(DAEMON_DIR)/nxdaemon $(BINDIR)


mains: libdir
	@echo "Making main for $(ARCH)";
	@( \
		cd $(MAIN_DIR); \
		$(MAKE) $(MFLAGS) all \
			"CXX = $(CXX)" \
			"CXXFLAGS = $(CXXFLAGS)" \
			"CC = $(CC)" \
			"CFLAGS = $(CFLAGS)" \
			"CPPFLAGS = $(CPPFLAGS)" \
			"CPLUSPLUS = $(CPLUSPLUS)"\
	)
	
	@cp $(MAIN_DIR)/*.o $(LIBDIR)


libnx: libdir
	@for dir in $(LIBNX_DIRS); \
	do \
	( \
		echo "Making $(LIBNX) in directory $$dir for $(ARCH)"; \
		cd $$dir; \
		$(MAKE) $(MFLAGS) lib \
			"LIB = $(LIBNX)" \
			"CC = $(CC)" \
			"CFLAGS = $(CFLAGS)" \
			"CPPFLAGS = $(CPPFLAGS)" \
			"AR = $(AR)" \
			"ARFLAGS = $(ARFLAGS)" \
			"LEX = $(LEX)"\
			"LFLAGS = $(LFLAGS)"\
			"YACC = $(YACC)"\
			"YFLAGS = $(YFLAGS)"\
			"RM = $(RM)"\
	) \
	done
	
	@if [ "$(RANLIB)" = "TRUE" ]; \
	then \
		echo "Running ranlib on $(LIBNX)"; \
		ranlib $(LIBNX); \
	fi

includes: incdir
	@echo "Copying include files"
	
	@-cp	include/nx.h\
		include/fnx.h\
		include/errno.h\
		include/nxmalloc.h $(INCDIR)
	
	@-cp	include/sys/nxerrno.h $(INCDIR)/sys
	@-cp	include/sys/nxesize.h $(INCDIR)/sys


nxlibdir:
	@if [ ! -d $(NXLIBDIR) ]; \
	then \
		echo "Creating directory $(NXLIBDIR)"; \
		mkdir $(NXLIBDIR); \
	fi


bindir: nxlibdir
	@if [ ! -d $(BINDIR) ]; \
	then \
		echo "Creating directory $(BINDIR)"; \
		mkdir $(BINDIR); \
	fi

libdir: nxlibdir
	@if [ ! -d $(LIBDIR) ]; \
	then \
		echo "Creating directory $(LIBDIR)"; \
		mkdir $(LIBDIR); \
	fi
	
incdir: nxlibdir
	@if [ ! -d $(INCDIR) ]; \
	then \
		echo "Creating directory $(INCDIR)"; \
		mkdir $(INCDIR); \
	fi
	
	@if [ ! -d $(INCDIR)/sys ]; \
	then \
		echo "Creating directory $(INCDIR)/sys"; \
		mkdir $(INCDIR)/sys; \
	fi

lintdir:
	@if [ ! -d $(LINTDIR) ]; \
	then \
		echo "Creating directory $(LINTDIR)"; \
		mkdir $(LINTDIR); \
	fi

lint: lintdir
	@for dir in $(DAEMON_DIR) $(MAIN_DIR) $(LIBNX_DIRS); \
	do \
	( \
		echo "Making lint in directory $$dir for $(ARCH)"; \
		cd $$dir; \
		$(MAKE) $(MFLAGS) lint \
			"CC = $(CC)" \
			"CFLAGS = $(CFLAGS)" \
			"CPPFLAGS = $(CPPFLAGS)" \
			"LEX = $(LEX)"\
			"LFLAGS = $(LFLAGS)"\
			"YACC = $(YACC)"\
			"YFLAGS = $(YFLAGS)"\
			"LINT = $(LINT)"\
			"LINTFLAGS = $(LINTFLAGS)"\
			"LINT_ln = $(LINT_ln)"\
			"RM = $(RM)"; \
		cp *.ln ../$(LINTDIR) \
	) \
	done
	
	$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(LINTDIR)/*.ln


rcflow:
	@( \
		files="" ; \
		for dir in $(DAEMON_DIR) $(MAIN_DIR) $(LIBNX_DIRS); \
		do \
			files="$$files $$dir/*.c"; \
		done ; \
		echo "Making reverse cflow with $$files"; \
		cflow $(CPPFLAGS) -r -i_ -d50 $$files; \
	)

cflow:
	@( \
		files="" ; \
		for dir in $(DAEMON_DIR) $(MAIN_DIR) $(LIBNX_DIRS); \
		do \
			files="$$files $$dir/*.c"; \
		done ; \
		echo "Making cflow with $$files"; \
		cflow $(CPPFLAGS) -i_  $$files; \
	)

tags:
	( \
		files="" ; \
		for dir in $(DAEMON_DIR) $(MAIN_DIR) $(LIBNX_DIRS); \
		do \
			files="$$files $$dir/*.[ylc]"; \
		done; \
		echo "Making tags with $$files"; \
		etags -t $$files; \
	)

clean:
	@for dir in $(DAEMON_DIR) $(MAIN_DIR) $(TOOL_DIR) $(LIBNX_DIRS); \
	do \
	( \
		echo "Cleaning directory $$dir"; \
		cd $$dir; \
		$(MAKE) $(MFLAGS) clean \
			"RM = $(RM)"\
	) \
	done
	
	@echo "Cleaning $(LINTDIR)"
	@$(RM) $(LINTDIR)/*.ln
	
	$(RM) $(ARCH_FILE) $(NXLIBDIR_FILE)

examplesclean:
	@echo "Cleaning examples"
	@for i in examples/*/*/[Mm]akefile ;\
	do \
	( \
		cd `dirname $$i`; \
		$(MAKE) $(MFLAGS) realclean \
			"RM = $(RM)"\
	) \
	done

realclean: examplesclean
	@for dir in $(DAEMON_DIR) $(MAIN_DIR) $(TOOL_DIR) $(LIBNX_DIRS); \
	do \
	( \
		echo "Cleaning directory $$dir"; \
		cd $$dir; \
		$(MAKE) $(MFLAGS) realclean \
			"RM = $(RM)"\
	) \
	done
	
	@echo "Cleaning directory include"
	@$(RM) include/*~ include/sys/*~
	
	@if [ -d $(LINTDIR) ]; \
	then \
		echo "Cleaning directory $(LINTDIR)"; \
		$(RM) $(LINTDIR)/*.ln; \
		echo "Removing directory $(LINTDIR)"; \
		rmdir $(LINTDIR); \
	fi
	
	@echo "Cleaning ."
	@$(RM) $(ARCH_FILE) $(NXLIBDIR_FILE) TAGS *~


nxclean:
	@if [ -d $(LIBDIR) ]; \
	then \
		echo "Cleaning $(LIBDIR)"; \
		$(RM) $(LIBNX) $(LIBDIR)/*.o; \
	fi
	
	@if [ -d $(BINDIR) ]; \
	then \
		echo "Cleaning $(BINDIR)"; \
		$(RM) $(BINDIR)/nxdaemon; \
		$(RM) $(BINDIR)/vpcc; \
		$(RM) $(BINDIR)/adbg; \
		$(RM) $(BINDIR)/ddbg; \
	fi
	
	@if [ -d $(INCDIR) ]; \
	then \
		echo "Cleaning $(INCDIR)"; \
		$(RM) $(INCDIR)/nx.h; \
		$(RM) $(INCDIR)/fnx.h; \
		$(RM) $(INCDIR)/errno.h; \
		$(RM) $(INCDIR)/sys/nxerrno.h; \
	fi
