#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at src/sun_nws/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at src/sun_nws/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
#ident	"@(#)Makefile.common	1.40	08/02/15 SMI"
#
# src/sun_nws/Makefile.commmon

.KEEP_STATE:

.KEEP_STATE_FILE:	.make.state.$(MACH)$(BUILD_TYPE)

$(BUIILD32)CLOBBERFILES += $(OBJ32)
$(BUIILD64)CLOBBERFILES += $(OBJ64)

sparc_ASM_CODE	= $(ON_REF_GATE)/usr/src/uts/sparc/ml/sparc.il
i386_ASM_CODE	=
ASM_CODE	= $($(MACH)_ASM_CODE)

#
# Standard Targets
#

all:		$(ALLPREQ)

install: 	$(INSTALLPREQ)

pkg: 		$(AWKPKGINFO) $(PKGPREQ)

$(DIRS):
	mkdir -p $@

# -----------------------------------------------------------------------------
#                      Module lint library construction targets
# -----------------------------------------------------------------------------

lint:=          DEBUG = -DDEBUG

# ON lint libraries
# ----------------- 
UNIX_LINT_LIB32 = $(ON_REF_GATE)/usr/src/uts/$(ARCH)/lint-libs/debug32/llib-lunix.ln
sparc_GENUNIX_LINT_LIB32 = $(ON_REF_GATE)/usr/src/uts/$(ARCH)/lint-libs/debug32/llib-lgenunix.ln
i386_GENUNIX_LINT_LIB32 = $(ON_REF_GATE)/usr/src/uts/intel/lint-libs/debug32/llib-lgenunix.ln
GENUNIX_LINT_LIB32 = $($(MACH)_GENUNIX_LINT_LIB32)

UNIX_LINT_LIB64 = $(ON_REF_GATE)/usr/src/uts/$(ARCH)/lint-libs/debug64/llib-lunix.ln
sparc_GENUNIX_LINT_LIB64 = $(ON_REF_GATE)/usr/src/uts/$(ARCH)/lint-libs/debug64/llib-lgenunix.ln
i386_GENUNIX_LINT_LIB64 = $(ON_REF_GATE)/usr/src/uts/intel/lint-libs/debug64/llib-lgenunix.ln
GENUNIX_LINT_LIB64 = $($(MACH)_GENUNIX_LINT_LIB64)

LINT_LIB_DIR   = $(PROJAREA)/lint_lib
LINT_LIB_DIR32 = $(LINT_LIB_DIR)/$(DBG32)
LINT_LIB_DIR64 = $(LINT_LIB_DIR)/$(DBG64)

LINTS_32 = $(MODULE_SRC:%.c=$(DBG32)/%.ln)
LINTS_64 = $(MODULE_SRC:%.c=$(DBG64)/%.ln)

MOD_LINT_SUFFIXE32 = $(MODULE)-$(MACH32)
MOD_LINT_SUFFIXE64 = $(MODULE)-$(MACH64)
MOD_LINT_LIB32 = llib-l$(MOD_LINT_SUFFIXE32).ln
MOD_LINT_LIB64 = llib-l$(MOD_LINT_SUFFIXE64).ln
MOD_LINT_LIB32_EXP = $(LINT_LIB_DIR32)/llib-l$(MODULE).ln
MOD_LINT_LIB64_EXP = $(LINT_LIB_DIR64)/llib-l$(MODULE).ln

LIB_LINT_SUFFIXE32 = $(LIBNAME)-$(MACH32)
LIB_LINT_SUFFIXE64 = $(LIBNAME)-$(MACH64)
LIB_LINT_LIB32 = llib-l$(LIB_LINT_SUFFIXE32).ln
LIB_LINT_LIB64 = llib-l$(LIB_LINT_SUFFIXE64).ln
LIB_LINT_LIB32_EXP = $(LINT_LIB_DIR32)/llib-l$(LIBNAME).ln
LIB_LINT_LIB64_EXP = $(LINT_LIB_DIR64)/llib-l$(LIBNAME).ln

$(LINT_LIB_DIR32) $(LINT_LIB_DIR64):
	- mkdir -p $@ 2> /dev/null

$(MOD_LINT_LIB32_EXP):	$(MOD_LINT_LIB32)
	$(MV) $(MOD_LINT_LIB32) $@

$(MOD_LINT_LIB32):	$(DBG32) .WAIT $(LINTS_32)
	@$(ECHO) "\n$(DBG32)/$(MODULE): (library construction):"
	@$(LINT32) -o $(MOD_LINT_SUFFIXE32) $(LFLAGS32) $(LINTS_32)

$(MOD_LINT_LIB64_EXP): $(MOD_LINT_LIB64)
	$(MV) $(MOD_LINT_LIB64) $@

$(MOD_LINT_LIB64): $(DBG64) .WAIT $(LINTS_64)
	@$(ECHO) "\n$(DBG64)/$(MODULE): (library construction):"
	@$(LINT64) -o $(MOD_LINT_SUFFIXE64) $(LFLAGS64) $(LINTS_64)

$(LIB_LINT_LIB32_EXP):	$(LIB_LINT_LIB32)
	$(MV) $(LIB_LINT_LIB32) $@

$(LIB_LINT_LIB32): $(DBG32) .WAIT $(MODULE_SRC:%=$(SRC_DIR)/%)
	@$(ECHO) "\n$(LIBNAME): (library construction):"
	@$(LINT32) $(LFLAGS32) $(INCLUDES) $(LDEF32) -o $(LIB_LINT_SUFFIXE32) $(MODULE_SRC:%=$(SRC_DIR)/%)

$(LIB_LINT_LIB64_EXP): $(LIB_LINT_LIB64)
	$(MV) $(LIB_LINT_LIB64) $@

$(LIB_LINT_LIB64): $(DBG64) .WAIT $(MODULE_SRC:%=$(SRC_DIR)/%)
	@$(ECHO) "\n$(LIBNAME): (library construction):"
	@$(LINT64) $(LFLAGS64) $(INCLUDES) $(LDEF64) -o $(LIB_LINT_SUFFIXE64) $(MODULE_SRC:%=$(SRC_DIR)/%)

lint:	$(LINT_TARGETS)

lint32: $(LINT_LIB_DIR32) .WAIT $(MOD_LINT_LIB32_EXP)
	@$(ECHO) "\n$(DBG32)/$(MODULE): global crosschecks:"
	@$(LINT32) $(LFLAGS32) $(MOD_LINT_LIB32_EXP) $(UNIX_LINT_LIB32) $(GENUNIX_LINT_LIB32) 2> $(DBG32)/$(MODULE)-lint-msg
	@if \
		$(GREP) $(CODEMGR_WS) $(DBG32)/$(MODULE)-lint-msg > /dev/null ; \
	then \
		$(ECHO) "*** Error Lint Global Crosschecks ***" ; \
		$(GREP) $(CODEMGR_WS) $(DBG32)/$(MODULE)-lint-msg ; \
	fi

lint64: $(LINT_LIB_DIR64) .WAIT $(MOD_LINT_LIB64_EXP)
	@$(ECHO) "\n$(DBG64)/$(MODULE): global crosschecks:"
	@$(LINT64) $(LFLAGS64) $(MOD_LINT_LIB64_EXP) $(UNIX_LINT_LIB64) $(GENUNIX_LINT_LIB64) 2> $(DBG64)/$(MODULE)-lint-msg
	@if \
		$(GREP) $(CODEMGR_WS) $(DBG64)/$(MODULE)-lint-msg > /dev/null ; \
	then \
		$(ECHO) "*** Error Lint Global Crosschecks ***" ; \
		$(GREP) $(CODEMGR_WS) $(DBG64)/$(MODULE)-lint-msg ; \
	fi

enhanced_lint32: $(DBG32)
	@$(LINT32) -dirout=$(DBG32) $(LFLAGS32) $(LDEF32) $(DEBUG) $(CPPFLAGS32) $(INCLUDES) \
	    -errchk=%all -errhdr=%all -Ncheck=%all -errsecurity=standard \
	    -erroff=E_TYPEDEF_UNUSE \
	    -erroff=E_ENUM_UNUSE \
	    $(MODULE_SRC:%=$(SRC_DIR)/%) 2> $(DBG32)/$(MODULE)-lint-msg
	@if \
		$(GREP) $(CODEMGR_WS) $(DBG32)/$(MODULE)-lint-msg > /dev/null ; \
	then \
		$(ECHO) "*** Error Lint Global Crosschecks ***" ; \
		$(GREP) $(CODEMGR_WS) $(DBG32)/$(MODULE)-lint-msg ; \
	fi

enhanced_lint64: $(DBG64)
	@($(LINT64) -dirout=$(DBG64) $(LFLAGS64) $(LDEF64) $(DEBUG) $(CPPFLAGS64) $(INCLUDES) \
	    -errchk=%all -errhdr=%all -Ncheck=%all -errsecurity=standard \
	    -erroff=E_TYPEDEF_UNUSE \
	    -erroff=E_ENUM_UNUSE \
	    -Nlevel=$(ENHANCED_LINT_LEVEL) \
	    $(MODULE_SRC:%=$(SRC_DIR)/%) 2> $(DBG64)/$(MODULE)-lint-msg)
	@if \
		$(GREP) $(CODEMGR_WS) $(DBG64)/$(MODULE)-lint-msg > /dev/null ; \
	then \
		$(ECHO) "*** Error Lint Global Crosschecks ***" ; \
		$(GREP) $(CODEMGR_WS) $(DBG64)/$(MODULE)-lint-msg ; \
	fi

lib_lint32: $(LINT_LIB_DIR32) .WAIT $(LIB_LINT_LIB32_EXP)

lib_lint64: $(LINT_LIB_DIR64) .WAIT $(LIB_LINT_LIB64_EXP)

cmd_lint32: $(DBG32) .WAIT $(LINTS_32)

cmd_lint64: $(DBG64) .WAIT $(LINTS_64)

# Rules
# -----
$(OBJ32)/%.o: $(SRC_DIR)/%.c
	$(CC) $(CFLAGS32) $(DEBUG) $(CPPFLAGS32) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ32)/%.o: $(COMMON_DIR)/%.c
	$(CC) $(CFLAGS32) $(DEBUG) $(CPPFLAGS32) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ32)/%.o: $(COM_SRC_ISCSI)/%.c
	$(CC) $(CFLAGS32) $(DEBUG) $(CPPFLAGS32) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ32)/%.o: $(COM_SRC_CMDPARSE)/%.c
	$(CC) $(CFLAGS32) $(DEBUG) $(CPPFLAGS32) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ32)/%.o: $(SRC_DIR)/%.cc
	$(CCC) $(CCFLAGS32) $(DEBUG) $(CPPFLAGS32) $(CCINCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(DBG32)/%.ln: $(SRC_DIR)/%.c
	@$(ECHO) "\n$@"
	@$(LINT32) -c -dirout=$(DBG32) $(LFLAGS32) $(LDEF32) $(DEBUG) $(CPPFLAGS32) $(INCLUDES) $<

$(OBJ32)/$(MODULE)	: $(MODULE_OBJ_32)
	$(DTRACE32)
	$(LINK32)
	$(CTFMERGE32)

$(OBJ64)/%.o: $(SRC_DIR)/%.c
	$(CC) $(CFLAGS64) $(DEBUG) $(CPPFLAGS64) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ64)/%.o: $(COMMON_DIR)/%.c
	$(CC) $(CFLAGS64) $(DEBUG) $(CPPFLAGS64) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ64)/%.o: $(COM_SRC_ISCSI)/%.c
	$(CC) $(CFLAGS64) $(DEBUG) $(CPPFLAGS64) $(INCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(OBJ64)/%.o: $(SRC_DIR)/%.cc
	$(CCC) $(CCFLAGS64) $(DEBUG) $(CCINCLUDES) -c -o $@ $<
	$(CTFCONVERT)

$(DBG64)/%.ln: $(SRC_DIR)/%.c
	@$(ECHO) "\n$@"
	@$(LINT64) -c -dirout=$(DBG64) $(LFLAGS64) $(LDEF64) $(DEBUG) $(CPPFLAGS64) $(INCLUDES) $<
                    
$(OBJ64)/$(MODULE): $(MODULE_OBJ_64)
	$(DTRACE64)
	$(LINK64)
	$(CTFMERGE64)

# Define a setting for installations into the proto.  
# If the uid = root, the user and group settings are provided to the 
# install program.

CONFFILEPERM   =	644
PERMS          =        755
MODULEUSER     =        root
MODULEGRP      =        sys

MORTAL_USER : sh = if [ "$LOGNAME" = "root" ]; \
then \
	echo "$(POUND_SIGN)"; \
fi;

ROOT_USER : sh = if [ "$LOGNAME" != "root" ]; \
then \
	echo "$(POUND_SIGN)"; \
fi;

# install targets

$(MORTAL_USER)INSTALL_CMD       =       $(INSTALL) -s -m $(PERMS)
$(ROOT_USER)INSTALL_CMD         =       $(INSTALL) -s -m $(PERMS) -u $(MODULEUSER) -g $(MODULEGRP)


$(STAGING32)/$(CONFFILE) := PERMS = $(CONFFILEPERM)

$(STAGING32)/$(CONFFILE) :  $(STAGING32) $(SRC_DIR)/$(CONFFILE)
	$(INSTALL_CMD)  -f $(STAGING32) $(SRC_DIR)/$(CONFFILE)
 
$(STAGING32)/$(MODULE) : $(OBJ32)/$(MODULE)
	$(INSTALL_CMD) -f $(STAGING32) $(OBJ32)/$(MODULE)

$(STAGING64)/$(MODULE) : $(OBJ64)/$(MODULE)
	$(INSTALL_CMD) -f $(STAGING64) $(OBJ64)/$(MODULE)

$(STAGING32)/$(LIBLINKS):     $(STAGING32)/$(DYNLIB)
	$(RM) $(STAGING32)/$(LIBLINKS)
	$(LN) -s $(DYNLIB) $(STAGING32)/$(LIBLINKS) 

$(STAGING64)/$(LIBLINKS):     $(STAGING64)/$(DYNLIB)
	$(RM) $(STAGING64)/$(LIBLINKS)
	$(LN) -s $(DYNLIB) $(STAGING64)/$(LIBLINKS) 

$(OBJ32)/$(LIBLINKS):	$(OBJ32)/$(DYNLIB)
	$(RM) $(OBJ32)/$(LIBLINKS)
	$(LN) -s $(DYNLIB) $(OBJ32)/$(LIBLINKS) 

$(OBJ64)/$(LIBLINKS):	$(OBJ64)/$(DYNLIB)
	$(RM) $(OBJ64)/$(LIBLINKS)
	$(LN) -s $(DYNLIB) $(OBJ64)/$(LIBLINKS) 

$(COMPONENTS): 
	cd $(PROJAREA)/$@; pwd ; $(MAKE) all
		
$(COMPONENTS:%=%_installed): 
	cd $(PROJAREA)/${@:%_installed=%}; pwd ; $(MAKE) install

#
#
# Maintenance targets.
#

clean:
	rm -rf $(CLEANFILES)

clobber:
	rm -rf $(CLOBBERFILES)

nuke:
	rm -rf $(NUKEFILES)

# Packaging targets.
#

$(PKGAREA)/%: $(INSTALLPREQ)
	@(cd $(PKGS)/$(@F) ; \
	rm -rf $(MACH)$(BUILD_TYPE); mkdir -p $(MACH)$(BUILD_TYPE) ; \
	cp $(COPYRIGHT) $(MACH)$(BUILD_TYPE)/copyright ; \
	if [ "$(LIC_PKG)" = $(@F) ] ; then \
	  if [ -z "$(LIC_FILES)" ] ; then \
	    filelist="" ; \
	  else \
	    filelist=`echo $(LIC_FILES)` ; \
	  fi ; \
	  for lic_file in $$filelist ; do \
	    if [ ! -f $$lic_file ] ; then \
	      echo "Missing license file(s) in "$$filelist ; \
	      exit 1 ; \
	    fi ; \
	  done ; \
	  cp $(LIC_FILES) ./$(MACH)$(BUILD_TYPE) ; \
	fi ; \
	cp `ls -F | grep -v /` ./$(MACH)$(BUILD_TYPE) ; \
	if [ ! -f SCCS/s.depend ] ; then  \
	  rm -f $(MACH)$(BUILD_TYPE)/depend ; \
	  cp $(PKGDEPEND) $(MACH)$(BUILD_TYPE)/depend ; \
	fi ; \
	cd $(MACH)$(BUILD_TYPE) ; \
	for class_action in  $(CLASS_ACTIONS) ; do \
	  if [ $$class_action != none ] ; then \
	    clsactname=`basename $$class_action` ; \
	    rm -f $$clsactname ; cp $$class_action $$clsactname ; \
	  fi ; \
	done  ; \
	ksh $(BLDAWKPKGINFO) -m $(MACH) -p "$(RELEASE)/$(VERSION)" \
	-o awk_pkginfo -v $(ONVERS) ; \
	$(NAWK) -f awk_pkginfo pkginfo.tmpl > pkginfo ; \
	$(PKGMK) -f prototype_$(MACH) -d $(PKGAREA) -r $(PROTO_ROOT) -o $(@F) )

#
# End package targets
#

#
# MDB Macro targets
#

$(MDBMODS32)	: $(OBJ32) $(MDBMODS32:$(OBJ32)/%.so=$(MDB_SRC_DIR)/%.c)
	$(CC) $(MDBMODCFLAGS) $(MDBMODCPPFLAGS) $(MACROINCLUDES) \
	    -c -o $(OBJ32)/$(@F:%.so=%.o) $(MDB_SRC_DIR)/$(@F:%.so=%.c)
	$(CC) $(MDBMODCFLAGS) -G -o $(OBJ32)/$(@F) $(OBJ32)/$(@F:%.so=%.o) \
	    $(MDBMODLDFLAGS)

$(STAGINGMDB32)/%: $(STAGINGMDB32) $(OBJ32)/%
	$(INSTALL) -s -m 644 -f $(STAGINGMDB32) $(OBJ32)/$(@F)

$(MDBMODS64)	: $(OBJ64) $(MDBMODS64:$(OBJ64)/%.so=$(MDB_SRC_DIR)/%.c)
	$(CC) $(MDBMODCFLAGS64) $(MDBMODCPPFLAGS64) $(MACROINCLUDES) \
	    -c -o $(OBJ64)/$(@F:%.so=%.o) $(MDB_SRC_DIR)/$(@F:%.so=%.c)
	$(CC) $(MDBMODCFLAGS64) -G -o $(OBJ64)/$(@F) \
	    $(OBJ64)/$(@F:%.so=%.o) $(MDBMODLDFLAGS64)

$(STAGINGMDB64)/%: $(STAGINGMDB64) $(OBJ64)/%
	$(INSTALL) -s -m 644 -f $(STAGINGMDB64) $(OBJ64)/$(@F)

#
# End MDB macros
#
#
# Dtrace
#
$(DTRACE_HEADER):     src/$(DTRACE_PROVIDER)
	$(DTRACE) -h -s $? -o $@

include $(PROJAREA)/Makefile.help