#
# 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 usr/src/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 usr/src/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 (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
#
#pragma ident	"@(#)Makefile.master	1.47	10/03/31 SMI"
#
# Makefile.master, global definitions for system source
#
ROOT=		/proto

# RELEASE_BUILD should be cleared for final release builds. This is completely
# independent of CH. NOT_RELEASE_BUILD is exactly what the name implies.
#
# INTERNAL_RELEASE_BUILD is a subset of RELEASE_BUILD. It mostly controls
# identification strings. Enabling RELEASE_BUILD automatically enables
# INTERNAL_RELEASE_BUILD.
#
# STRIP_COMMENTS toggles comment section striping. Generally the same setting
# as INTERNAL_RELEASE_BUILD.
#
# STRIPFLAG is similar. It is set to a unique value depending upon the
# value of CH. It is set here for use in lower level Makefiles to allow
# a single point change to effect the entire build.
#
POUND_SIGN:sh=				echo \\043

NOT_RELEASE_BUILD=
INTERNAL_RELEASE_BUILD:sh=		echo \\043
RELEASE_BUILD:sh=			echo \\043
$(RELEASE_BUILD)NOT_RELEASE_BUILD:sh=	echo \\043
$(RELEASE_BUILD)INTERNAL_RELEASE_BUILD=

# SPARC_BLD is '#' for an Intel build.
# INTEL_BLD is '#' for a Sparc build.
SPARC_BLD_1=    $(MACH:i386=$(POUND_SIGN))
SPARC_BLD=      $(SPARC_BLD_1:sparc=)
INTEL_BLD_1=    $(MACH:sparc=$(POUND_SIGN))
INTEL_BLD=      $(INTEL_BLD_1:i386=)

MACH_TYPE_i386	= pc
MACH_TYPE_sparc	= sun
MACH_TYPE	= $(MACH_TYPE_$(MACH))

STRIP_COMMENTS=	$(INTERNAL_RELEASE_BUILD)

STRIPFLAG=	-s

# BUILD_TOOLS is the root of all tools including compilers.
# ONBLD_TOOLS is the root of all the tools that are part of SUNWonbld.

BUILD_TOOLS=	/ws/onnv-tools
ONBLD_TOOLS=	$(BUILD_TOOLS)/onbld

# at least one thing still can't be built with 1.6,
# so make 1.6 the default but overridable. However,
# if you're having trouble compiling with java 1.6 and
# have found java 1.5 here and want to use it, think
# again - that's the last resort, first look at java
# options like -source.
JAVA5_ROOT=	/usr/jdk/instances/jdk1.5.0
JAVA6_ROOT=	/usr/jdk/instances/jdk1.6.0
JAVA_ROOT=	$(JAVA6_ROOT)

MAKEFILE=	-f Makefile.sfw

SFW_STAMP_UNPACKED=     .unpacked
SFW_STAMP_PATCHED=      .patched
SFW_STAMP_PATCHES=      .patches

# this can help catch problems if sh is ksh93
KSH93=/usr/bin/ksh93
BASH=/usr/bin/bash
SHELL=$(KSH93)
CONFIG_SHELL=$(BASH)
GPATCH=		/usr/bin/gpatch
GPATCH_FLAGS=	-p0
METAINFO_FILE=	METADATA
METAINFO=	$(PERL) $(SRC)/tools/metainfo.pl --file $(METAINFO_FILE)
METACHECK=	$(METAINFO) --validate
COMPONENT_NAME=		$(METAINFO) --key NAME
COMPONENT_VERSION=	$(METAINFO) --key VERSION
COMPONENT_PACKAGES=	$(METAINFO) --key PACKAGE
COMPONENT_ARCHIVE=	$(METAINFO) --archive-name SOURCE_DOWNLOAD
INSTALL_PROTO=	$(SRC)/tools/install-proto
STRIPBINS=	$(SRC)/tools/stripbins
INCREFIXUP=	$(SRC)/tools/increfixup
UNPACKARCHIVE=	$(SRC)/tools/unpack-archive
INSTALL=$(INSTALL_PROTO)

SFW_CHECK_DEPS=	$(PERL) $(SRC)/tools/check-deps.pl \
	-e $(SRC)/tools/exception_list.check-deps \
	-d $(PKGARCHIVE) -p $(SFW_PKGDB)
SFW_RUN_CHECK_DEPS=	$(POUND_SIGN)
RPCGEN=		/usr/bin/rpcgen
AWK=		/usr/bin/awk
ECHO=		echo
INS=		install
TRUE=		true
SYMLINK=	/usr/bin/ln -s
LN=		/usr/bin/ln
SH=		/usr/bin/sh
CHMOD=		/usr/bin/chmod
CHOWN=		$(TRUE)
CHGRP=		$(TRUE)
MV=		/usr/bin/mv -f
RMDIR=		/usr/bin/rmdir
MKDIR=		/usr/bin/mkdir
TOUCH=		/usr/bin/touch
RM=		/usr/bin/rm -f
GREP=		/usr/bin/grep
SED=		/usr/bin/sed
CP=		/usr/bin/cp
LORDER=		/usr/ccs/bin/lorder
MCS=		/usr/ccs/bin/mcs
CAT=		/usr/bin/cat
M4=		/usr/ccs/bin/m4
STRIP=		/usr/ccs/bin/strip
TSORT=		/usr/ccs/bin/tsort
JAVAC=		$(JAVA_ROOT)/bin/javac
JAVAH=		$(JAVA_ROOT)/bin/javah
JAVADOC=	$(JAVA_ROOT)/bin/javadoc
RMIC=		$(JAVA_ROOT)/bin/rmic
JAR=		$(JAVA_ROOT)/bin/jar
GMAKE=		/usr/sfw/bin/gmake
CCSMAKE=	/usr/ccs/bin/make
XREF=		$(ONBLD_TOOLS)/bin/xref
PERL=		/usr/perl5/bin/perl
FIND=		/usr/bin/find
XARGS=		/usr/bin/xargs
TAR=		/usr/bin/tar
GTAR=		/usr/sfw/bin/gtar
PYTHON=		/usr/bin/python
PYTHON_64=	/usr/bin/$(MACH64)/python
PYTHON24=	/usr/bin/python2.4
PYTHON24_64=	/usr/bin/$(MACH64)/python2.4
PYTHON26=	/usr/bin/python2.6
PYTHON26_64=	/usr/bin/$(MACH64)/python2.6
ELFEDIT=	/usr/bin/elfedit
GINSTALL=	/usr/bin/ginstall



FILEMODE=	644
DIRMODE=	755
OWNER=		root
GROUP=		bin

# Paths, relative to proto root.
#
# Suitable for passing to things like configure scripts which
# use the path for compiled in default file location information
CFGPREFIX=	/usr
CFGBIN=		$(CFGPREFIX)/bin
CFGLIB=		$(CFGPREFIX)/lib
CFGSBIN=	/sbin
CFGINC=		$(CFGPREFIX)/include
CFGUSRSBIN=	$(CFGPREFIX)/sbin
CFGLOCALE=	$(CFGPREFIX)/share/locale
CFGINFO=	$(CFGPREFIX)/share/info
CFGETC=		/etc
CFGBIN32=	$(CFGBIN)/$(MACH32)
CFGBIN64=	$(CFGBIN)/$(MACH64)
CFGLIB64=	$(CFGLIB)/$(MACH64)
CFGUSRSBIN32=	$(CFGUSRSBIN)/$(MACH32)
CFGUSRSBIN64=	$(CFGUSRSBIN)/$(MACH64)
CFGMAN=		$(CFGPREFIX)/share/man
CFGMAN1=	$(CFGMAN)/man1
CFGMAN3=	$(CFGMAN)/man3
CFGMAN5=	$(CFGMAN)/man5
CFGMAN6=	$(CFGMAN)/man6
CFGDOC=		$(CFGPREFIX)/share/doc
CFGUSRDEMO=	$(CFGPREFIX)/demo

COMPONENT_TOP:sh =	pwd
MANSCRIPT =	$(COMPONENT_TOP)/sunman-stability

# Common configure options with common values
CONFIGURE_OPTIONS =	--prefix=$(CFGPREFIX)
CONFIGURE_OPTIONS +=	--mandir=$(CFGMAN)

ROOTBIN=	$(ROOT)$(CFGBIN)
ROOTLIB=	$(ROOT)$(CFGLIB)
ROOTSBIN=	$(ROOT)$(CFGSBIN)
ROOTUSRSBIN=	$(ROOT)$(CFGUSRSBIN)
ROOTINFO=	$(ROOT)$(CFGINFO)
ROOTETC=	$(ROOT)$(CFGETC)
ROOTBIN32=	$(ROOT)$(CFGBIN32)
ROOTBIN64=	$(ROOT)$(CFGBIN64)
ROOTLIB64=	$(ROOT)$(CFGLIB64)
ROOTUSRSBIN32=	$(ROOT)$(CFGUSRSBIN32)
ROOTUSRSBIN64=	$(ROOT)$(CFGUSRSBIN64)
ROOTMAN1=	$(ROOT)$(CFGMAN1)
ROOTMAN3=	$(ROOT)$(CFGMAN3)
ROOTMAN5=	$(ROOT)$(CFGMAN5)
ROOTMAN6=	$(ROOT)$(CFGMAN6)
ROOTDOC=	$(ROOT)$(CFGDOC)
ROOTUSRDEMO=	$(ROOT)$(CFGUSRDEMO)
ROOTINCLUDE=	$(ROOT)$(CFGINC)

#
# Begin /usr/sfw freeware rules for freeware that has "External"
# taxonomy stability level.
#
CFGSFW=		/usr/sfw
CFGSFWBIN=	/usr/sfw/bin
CFGSFWSBIN=	/usr/sfw/sbin
CFGSFWSHARE=	/usr/sfw/share
CFGSFWINFO=	/usr/sfw/share/info
CFGSFWINCLUDE=	/usr/sfw/include
CFGSFWLIB=	/usr/sfw/lib
CFGLIBEXEC=	/usr/sfw/libexec
CFGSFWMAN=	/usr/sfw/share/man
CFGSFWMANN=	/usr/sfw/share/mann
CFGSFWMAN1=	/usr/sfw/share/man/man1
CFGSFWMAN1M=	/usr/sfw/share/man/man1m
CFGSFWMAN3=	/usr/sfw/share/man/man3
CFGSFWMAN4=	/usr/sfw/share/man/man4
CFGSFWMAN5=	/usr/sfw/share/man/man5
CFGSFWMAN7=	/usr/sfw/share/man/man7

ROOTSFW=	$(ROOT)$(CFGSFW)
ROOTSFWBIN=	$(ROOT)$(CFGSFWBIN)
ROOTSFWSBIN=	$(ROOT)$(CFGSFWSBIN)
ROOTSFWSHARE=	$(ROOT)$(CFGSFWSHARE)
ROOTSFWINFO=	$(ROOT)$(CFGSFWINFO)
ROOTSFWINCLUDE=	$(ROOT)$(CFGSFWINCLUDE)
ROOTSFWLIB=	$(ROOT)$(CFGSFWLIB)
ROOTLIBEXEC=	$(ROOT)$(CFGLIBEXEC)
ROOTSFWMAN=	$(ROOT)$(CFGSFWMAN)
ROOTSFWMANN=	$(ROOT)$(CFGSFWMANN)
ROOTSFWMAN1=	$(ROOT)$(CFGSFWMAN1)
ROOTSFWMAN1M=	$(ROOT)$(CFGSFWMAN1M)
ROOTSFWMAN3=	$(ROOT)$(CFGSFWMAN3)
ROOTSFWMAN4=	$(ROOT)$(CFGSFWMAN4)
ROOTSFWMAN5=	$(ROOT)$(CFGSFWMAN5)
ROOTSFWMAN7=	$(ROOT)$(CFGSFWMAN7)

#
# End /usr/sfw freeware rules
#

#
# Begin /usr/gnu freeware rules.
#
CFGGNU= 	/usr/gnu
CFGGNUBIN=	/usr/gnu/bin
CFGGNUSHARE=	/usr/gnu/share
CFGGNUMAN=	/usr/gnu/share/man
CFGGNUMAN1=	/usr/gnu/share/man/man1

ROOTGNU=	$(ROOT)$(CFGGNU)
ROOTGNUBIN=	$(ROOT)$(CFGGNUBIN)
ROOTGNUSHARE=	$(ROOT)$(CFGGNUSHARE)
ROOTGNUMAN=	$(ROOT)$(CFGGNUMAN)
ROOTGNUMAN1=	$(ROOT)$(CFGGNUMAN1)

#
# End /usr/gnu freeware rules
#

# overridable
SFW_MAKE=	$(CCSMAKE)

# default env settings if you need them
SFW_ENV =	PATH=$(SFW_PATH)
SFW_ENV +=	CONFIG_SHELL=$(CONFIG_SHELL)
SFW_ENV +=	MAKE=$(SFW_MAKE)

# Declare that nothing should be built in parallel.
# Individual Makefiles can use the .PARALLEL target to declare otherwise.
.NO_PARALLEL:

ROOTPROG=	$(PROG:%=$(ROOTBIN)/%)
ROOTSHFILES=	$(SHFILES:%=$(ROOTBIN)/%)
ROOTLIBPROG=	$(PROG:%=$(ROOTLIB)/%)
ROOTLIBSHFILES= $(SHFILES:%=$(ROOTLIB)/%)
ROOTSBINPROG=	$(PROG:%=$(ROOTSBIN)/%)
ROOTUSRSBINPROG=$(PROG:%=$(ROOTUSRSBIN)/%)
ROOTETCPROG=	$(PROG:%=$(ROOTETC)/%)
ROOTPROG64=	$(PROG:%=$(ROOTBIN64)/%)
ROOTPROG32=	$(PROG:%=$(ROOTBIN32)/%)
ROOTUSRSBINPROG32=	$(PROG:%=$(ROOTUSRSBIN32)/%)
ROOTUSRSBINPROG64=	$(PROG:%=$(ROOTUSRSBIN64)/%)

ROOTMAN1FILES=$(MAN1FILES:%=$(ROOTMAN1)/%)
$(ROOTMAN1FILES) := FILEMODE = 444
$(ROOTMAN1FILES) := OWNER = root
$(ROOTMAN1FILES) := GROUP = bin

ROOTMAN3FILES=$(MAN3FILES:%=$(ROOTMAN3)/%)
$(ROOTMAN3FILES) := FILEMODE = 444
$(ROOTMAN3FILES) := OWNER = root
$(ROOTMAN3FILES) := GROUP = bin

ROOTMAN5FILES=$(MAN5FILES:%=$(ROOTMAN5)/%)
$(ROOTMAN5FILES) := FILEMODE = 444
$(ROOTMAN5FILES) := OWNER = root
$(ROOTMAN5FILES) := GROUP = bin

ROOTMAN6FILES=$(MAN6FILES:%=$(ROOTMAN6)/%)
$(ROOTMAN6FILES) := FILEMODE = 444
$(ROOTMAN6FILES) := OWNER = root
$(ROOTMAN6FILES) := GROUP = bin

#
# Begin /usr/sfw freeware rules for freeware that has "External"
# taxonomy stability level.
#
ROOTSFWINFOFILES=$(INFOFILES:%=$(ROOTSFWINFO)/%)
$(ROOTSFWINFOFILES) := FILEMODE = 444
$(ROOTSFWINFOFILES) := OWNER = root
$(ROOTSFWINFOFILES) := GROUP = bin

ROOTSFWMANNFILES=$(MANNFILES:%=$(ROOTSFWMANN)/%)
$(ROOTSFWMANNFILES) := FILEMODE = 444
$(ROOTSFWMANNFILES) := OWNER = root
$(ROOTSFWMANNFILES) := GROUP = bin

ROOTSFWMAN1FILES=$(MAN1FILES:%=$(ROOTSFWMAN1)/%)
$(ROOTSFWMAN1FILES) := FILEMODE = 444
$(ROOTSFWMAN1FILES) := OWNER = root
$(ROOTSFWMAN1FILES) := GROUP = bin

ROOTSFWMAN1MFILES=$(MAN1MFILES:%=$(ROOTSFWMAN1M)/%)
$(ROOTSFWMAN1MFILES) := FILEMODE = 444
$(ROOTSFWMAN1MFILES) := OWNER = root
$(ROOTSFWMAN1MFILES) := GROUP = bin

ROOTSFWMAN3FILES=$(MAN3FILES:%=$(ROOTSFWMAN3)/%)
$(ROOTSFWMAN3FILES) := FILEMODE = 444
$(ROOTSFWMAN3FILES) := OWNER = root
$(ROOTSFWMAN3FILES) := GROUP = bin

ROOTSFWMAN4FILES=$(MAN4FILES:%=$(ROOTSFWMAN4)/%)
$(ROOTSFWMAN4FILES) := FILEMODE = 444
$(ROOTSFWMAN4FILES) := OWNER = root
$(ROOTSFWMAN4FILES) := GROUP = bin

ROOTSFWMAN5FILES=$(MAN5FILES:%=$(ROOTSFWMAN5)/%)
$(ROOTSFWMAN5FILES) := FILEMODE = 444
$(ROOTSFWMAN5FILES) := OWNER = root
$(ROOTSFWMAN5FILES) := GROUP = bin

ROOTSFWMAN7FILES=$(MAN7FILES:%=$(ROOTSFWMAN7)/%)
$(ROOTSFWMAN7FILES) := FILEMODE = 444
$(ROOTSFWMAN7FILES) := OWNER = root
$(ROOTSFWMAN7FILES) := GROUP = bin

ROOTSFWBINPROG=	$(PROG:%=$(ROOTSFWBIN)/%)
$(ROOTSFWBINPROG) := FILEMODE= 555
$(ROOTSFWBINPROG) := OWNER= root
$(ROOTSFWBINPROG) := GROUP= bin

ROOTSFWSBINPROG= $(PROG:%=$(ROOTSFWSBIN)/%)
$(ROOTSFWSBINPROG) := FILEMODE= 555
$(ROOTSFWSBINPROG) := OWNER= root
$(ROOTSFWSBINPROG) := GROUP= bin

#
# End /usr/sfw freeware rules
#


INS.file=	$(RM) $@; $(INS) -s -m $(FILEMODE) -f $(@D) $<
INS.dir=	$(INS) -s -d -m $(DIRMODE) $@
# installs and renames at once
#
INS.rename=	$(INS.file); $(MV) $(@D)/$(<F) $@

# MACH must be set in the shell environment per uname -p on the build host
# More specific architecture variables should be set in lower makefiles.
#
# MACH64 is derived from MACH
#
MACH64_1=	$(MACH:sparc=sparcv9)
MACH64=		$(MACH64_1:i386=amd64)

MACH32_1=	$(MACH:sparc=sparcv7)
MACH32=		$(MACH32_1:i386=i86)

#
# C compiler mode. Future compilers may change the default on us,
# so force transition mode globally. Lower level makefiles can
# override this by setting CCMODE.
#
CCMODE=		-Xa
CCMODE64=	-Xa

#
# C compiler verbose mode. This is so we can enable it globally,
# but turn it off in the lower level makefiles of things we cannot
# (or aren't going to) fix.
#
CCVERBOSE=

#
# compiler 32/64 bit flag, in case it changes again (and needed
# since lint doesn't really want the extra bits in XARCH).
CCBITS32=	-m32
CCBITS64=	-m64

#
#
# compiler '-xarch' flag. This is here to centralize it and make it
# overridable for testing.
sparc_XARCH=	$(CCBITS32) -xarch=sparc
sparcv9_XARCH=	$(CCBITS64) -xcode=abs64
i386_XARCH=	$(CCBITS32) -xchip=pentium
amd64_XARCH=	$(CCBITS64) -xarch=generic -Ui386 -U__i386

#
# disable the incremental linker
ILDOFF=		-xildoff

# C99 mode
C99_ENABLE=	-xc99=all
C99_DISABLE=	-xc99=none
C99MODE=	$(C99_ENABLE)
C99LMODE=	$(C99MODE:-xc99%=-Xc99%)

# XPG6 mode.  This option enables XPG6 conformance, plus extensions.
# Amongst other things, this option will cause system calls like
# popen (3C) and system (3C) to invoke the standards-conforming
# shell, /usr/xpg4/bin/sh, instead of /usr/bin/sh.
XPG6MODE=	$(C99MODE) -D_XOPEN_SOURCE=600 -D__EXTENSIONS__=1

#
# The Sun Studio 11 compiler has changed the behaviour of integer
# wrap arounds and so a flag is needed to use the legacy behaviour
# (without this flag panics/hangs could be exposed within the source).
#
sparc_IROPTFLAG         = -W2,-xwrap_int
sparcv9_IROPTFLAG       = -W2,-xwrap_int
i386_IROPTFLAG          =
amd64_IROPTFLAG         =
 
IROPTFLAG               = $($(MACH)_IROPTFLAG)
IROPTFLAG64             = $($(MACH64)_IROPTFLAG)

# In most places, assignments to these macros should be appended with +=
# (CPPFLAGS.master allows values to be prepended to CPPFLAGS).
sparc_CFLAGS=	$(sparc_XARCH)
sparcv9_CFLAGS=	$(sparcv9_XARCH) -dalign $(CCVERBOSE)
i386_CFLAGS=	$(i386_XARCH)
amd64_CFLAGS=	$(amd64_XARCH)

#
sparc_COPTFLAG=		-xO3
sparcv9_COPTFLAG=	-xO3
i386_COPTFLAG=		-xO3
amd64_COPTFLAG=		-xO3
COPTFLAG= $($(MACH)_COPTFLAG)
COPTFLAG64= $($(MACH64)_COPTFLAG)

#
# tradeoff time for space (smaller is better)
#
sparc_SPACEFLAG		= -xspace -W0,-Lt
sparcv9_SPACEFLAG	= -xspace -W0,-Lt
i386_SPACEFLAG		= -xspace
amd64_SPACEFLAG		=
SPACEFLAG		= $($(MACH)_SPACEFLAG)
SPACEFLAG64		= $($(MACH64)_SPACEFLAG)

sparc_XREGSFLAG         = -xregs=no%appl
sparcv9_XREGSFLAG       = -xregs=no%appl
i386_XREGSFLAG          =
amd64_XREGSFLAG         =
XREGSFLAG               = $($(MACH)_XREGSFLAG)
XREGSFLAG64             = $($(MACH64)_XREGSFLAG)

CFLAGS=         $(COPTFLAG) $($(MACH)_CFLAGS) $(SPACEFLAG) $(CCMODE) \
		$(ILDOFF) $(C99MODE) $(IROPTFLAG)
	
CFLAGS64=       $(COPTFLAG64) $($(MACH64)_CFLAGS) $(SPACEFLAG64) $(CCMODE64) \
		$(ILDOFF) $(C99MODE) $(IROPTFLAG64)

DTEXTDOM=-DTEXT_DOMAIN=\"$(TEXT_DOMAIN)\"	# For messaging.
CPPFLAGS.master=$(DTEXTDOM) \
	-I$(ROOTINCLUDE) \
	-I$(ROOTSFWINCLUDE) \
	$(ENVCPPFLAGS1) $(ENVCPPFLAGS2) $(ENVCPPFLAGS3) $(ENVCPPFLAGS4)
CPPFLAGS=	$(CPPFLAGS.master)
AS_CPPFLAGS=	$(CPPFLAGS.master)
JAVAFLAGS=	-deprecation

#
# For source message catalogue
#
.SUFFIXES: $(SUFFIXES) .po
MSGROOT= $(ROOT)/catalog
MSGDOMAIN= $(MSGROOT)/$(TEXT_DOMAIN)
COMPILE.cpp= $(CC) -E -C $(CFLAGS) $(CPPFLAGS)
XGETTEXT= xgettext
XGETFLAGS= -c TRANSLATION_NOTE
BUILD.po= $(XGETTEXT) $(XGETFLAGS) $<.i ;\
	$(RM)	$@ ;\
	sed "/^domain/d" < messages.po  > $@ ;\
	$(RM) messages.po $<.i
#
# This is overwritten by local Makefile when PROG is a list.
#
POFILE= $(PROG).po

COMPAT_VERSION= 4

sparc_CCFLAGS=		-compat=$(COMPAT_VERSION) \
			-Qoption ccfe -messages=no%anachronism
sparcv9_CCFLAGS=	$(sparcv9_XARCH) -dalign -compat=5 \
			-Qoption ccfe -messages=no%anachronism \
			-Qoption ccfe -features=no%conststrings
i386_CCFLAGS=		-compat=$(COMPAT_VERSION) \
			-Qoption ccfe -messages=no%anachronism \
			-Qoption ccfe -features=no%conststrings
amd64_CCFLAGS=		$(amd64_XARCH) -compat=5 \
			-Qoption ccfe -messages=no%anachronism \
			-Qoption ccfe -features=no%conststrings

sparc_CCOPTFLAG=	-xO3
sparcv9_CCOPTFLAG=	-xO3
i386_CCOPTFLAG=		-xO3
amd64_CCOPTFLAG=	-xO3

CCOPTFLAG=	$($(MACH)_CCOPTFLAG)
CCOPTFLAG64=	$($(MACH64)_CCOPTFLAG)
CCFLAGS=	$(CCOPTFLAG) $($(MACH)_CCFLAGS)
CCFLAGS64=	$(CCOPTFLAG64) $($(MACH64)_CCFLAGS)
#
# 
LDLIBS.cmd = 	$(ENVLDLIBS1)  $(ENVLDLIBS2)  $(ENVLDLIBS3)
LDFLAGS.cmd =	-L$(ROOTSFWLIB) -R/usr/sfw/lib
LDFLAGS.cmd +=  $(STRIPFLAG) $(ENVLDFLAGS1) $(ENVLDFLAGS2) $(ENVLDFLAGS3)
LDFLAGS.lib =	-L$(ROOTSFWLIB) -R/usr/sfw/lib
LDLIBS.lib =	$(ENVLDLIBS1)  $(ENVLDLIBS2)  $(ENVLDLIBS3)
#
# Define compilation macros.
#
COMPILE.c=	$(CC) $(CFLAGS) $(CPPFLAGS) -c
COMPILE64.c=	$(CC64) $(CFLAGS64) $(CPPFLAGS) -c
COMPILE.cc=	$(CCC) $(CCFLAGS) $(CPPFLAGS) -c
COMPILE64.cc=	$(CCC64) $(CCFLAGS64) $(CPPFLAGS) -c
COMPILE.s=	$(AS) $(ASFLAGS) $(AS_CPPFLAGS)

CLASSPATH=	.:$(WEBSTART_HOME)/classes
COMPILE.java=	$(JAVAC) $(JAVAFLAGS) -classpath $(CLASSPATH)

#
# Link time macros
#
CCNEEDED	= -lC -lc
COMPILE64.s=	$(AS) $(ASFLAGS) $($(MACH64)_XARCH) $(AS_CPPFLAGS)
LINK.c=		$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)
LINK64.c=	$(CC64) $(CFLAGS64) $(CPPFLAGS) $(LDFLAGS)
LINK.cc=	$(CCC) $(CCFLAGS) $(CPPFLAGS) -norunpath -nolib $(LDFLAGS) $(CCNEEDED)
LINK64.cc=	$(CCC64) $(CCFLAGS64) $(CPPFLAGS) -norunpath -nolib $(LDFLAGS) $(CCNEEDED)
LINT.c=		$(LINT) $(LINTFLAGS) $(CPPFLAGS)
LINT64.c=	$(LINT) $(LINTFLAGS64) $(CPPFLAGS)

# For some future builds, NATIVE_MACH and MACH might be different.
# Therefore, NATIVE_MACH needs to be redefined in the
# environment as `uname -p` to override this macro.
#
# For now at least, we cross-compile amd64 on i386 machines.
NATIVE_MACH=    $(MACH:amd64=i386)

# Define native compilation macros
#

# Base directory where compilers are loaded.
# Defined here so it can be overridden by developer.
#
SPRO_ROOT=		$(BUILD_TOOLS)/SUNWspro
SPRO_VROOT=		$(SPRO_ROOT)/SS12

# All sub-Makefiles should pass a specific path when building
# (such as with configure/make/perl) to ensure that the right
# compiler above is found rather than one in the build path
# (which might be older/newer depending on what the build machine
# has in /opt/SUNWspro or /opt/teamware). This is the default
# which can be overridden.
#
SFW_PATH=$(SPRO_VROOT)/bin:$(PATH)

# Specify platform compiler versions for languages
# that we use (currently only c and c++).
#
sparc_CC=		$(SPRO_VROOT)/bin/cc
sparc_CCC=		$(SPRO_VROOT)/bin/CC
sparc_AS=		/usr/ccs/bin/as
sparc_LD=		/usr/ccs/bin/ld

sparcv9_CC=		$(SPRO_VROOT)/bin/cc
sparcv9_CCC=		$(SPRO_VROOT)/bin/CC
sparcv9_AS=		/usr/ccs/bin/as
sparcv9_LD=		/usr/ccs/bin/ld

i386_CC=		$(SPRO_VROOT)/bin/cc
i386_CCC=		$(SPRO_VROOT)/bin/CC
i386_AS=		/usr/ccs/bin/as
i386_LD=		/usr/ccs/bin/ld

amd64_CC=		$(SPRO_VROOT)/bin/cc
amd64_CCC=		$(SPRO_VROOT)/bin/CC
amd64_AS=		$(SPRO_VROOT)/bin/as
amd64_LD=		/usr/ccs/bin/ld

NATIVECC=		$($(NATIVE_MACH)_CC)
NATIVECCC=		$($(NATIVE_MACH)_CCC)
NATIVEAS=		$($(NATIVE_MACH)_AS)
NATIVELD=		$($(NATIVE_MACH)_LD)

CC=			$(NATIVECC)
CCC=			$(NATIVECCC)
AS=			$(NATIVEAS)
LD=			$(NATIVELD)

GCC=			/usr/sfw/bin/gcc
GXX=			/usr/sfw/bin/g++

CC64=			$($(MACH64)_CC)
CCC64=			$($(MACH64)_CCC)
AS64=			$($(MACH64)_AS)
LD64=			$($(MACH64)_LD)

#
# Use the same lint as the cc compiler
#
sparc_LINT=		$(SPRO_VROOT)/bin/lint
i386_LINT=		$(SPRO_VROOT)/bin/lint
LINT=			$($(MACH)_LINT)

# Rules (normally from make.rules) and macros which are used for post
# processing files. Normally, these do stripping of the comment section
# automatically.
#    RELEASE_CM:	Should be editted to reflect the release.
#    POST_PROCESS_O:	Post-processing for `.o' files.
#    POST_PROCESS_A:	Post-processing for `.a' files (currently null).
#    POST_PROCESS_SO:	Post-processing for `.so' files.
#    POST_PROCESS:	Post-processing for executable files (no suffix).
# Note that these macros are not completely generalized as they are to be
# used with the file name to be processed following.
#
# It is left as an exercise to Release Engineering to embellish the generation
# of the release comment string.
#
#	If this is a standard development build:
#		compress the comment section (mcs -c)
#		add the standard comment (mcs -a $(RELEASE_CM))
#		add the development specific comment (mcs -a $(DEV_CM))
#
#	If this is an installation build:
#		delete the comment section (mcs -d)
#		add the standard comment (mcs -a $(RELEASE_CM))
#		add the development specific comment (mcs -a $(DEV_CM))
#
#	If this is an release build:
#		delete the comment section (mcs -d)
#		add the standard comment (mcs -a $(RELEASE_CM))
#
#	Sigh,... The declaration POUND_SIGN is always '#'. This is just needed
#	to get around the make **bug** that '#' is always a comment delimiter,
#	even when escaped or quoted.
#
# The following list of macros are used in the definition of RELEASE_CM
# which is used to label all binaries in the build:
#
# 	SFWRELEASE	Specific release of the build, eg: 5.2
#	SFWVERSION	Version of the build (alpha, beta, Generic)
#	PATCHID		If this is a patch this value should contain
#			the patchid value (eg: "Generic 100832-01"), otherwise
#			it will be set to $(SFWVERSION)
#	RELEASE_DATE	Date of the Release Build
#	PATCH_DATE	Date the patch was created, if this is blank it
#			will default to the RELEASE_DATE
#
POUND_SIGN:sh=	echo \\043
SFWVERS=	"11.11.0"
SFWRELEASE=	5.11
SFWVERSION=	SunOS Development
PATCHID=	$(SFWVERSION)
RELEASE_DATE=	October 2007
PATCH_DATE=	$(RELEASE_DATE)
RELEASE_CM=	"@($(POUND_SIGN))SunOS $(SFWRELEASE) $(PATCHID) $(PATCH_DATE)"
DEV_CM=		"@($(POUND_SIGN))SunOS Internal Development: `$(ECHO) $$LOGNAME` `date +%D` `$(ECHO) [\`basename $$CODEMGR_WS\`]`"

PROCESS_COMMENT=		   @?${MCS} -c -a $(RELEASE_CM) -a $(DEV_CM)
$(STRIP_COMMENTS)PROCESS_COMMENT=  @?${MCS} -d -a $(RELEASE_CM) -a $(DEV_CM)
$(RELEASE_BUILD)PROCESS_COMMENT=   @?${MCS} -d -a $(RELEASE_CM)

POST_PROCESS_O=		$(PROCESS_COMMENT) $@
POST_PROCESS_A=
POST_PROCESS_SO=	$(PROCESS_COMMENT) $@
POST_PROCESS=		$(PROCESS_COMMENT) $@

#	Default build rules which perform comment section post-processing.
#
.c:
	$(LINK.c) -o $@ $< $(LDLIBS)
	$(POST_PROCESS)
.c.o:
	$(COMPILE.c) $(OUTPUT_OPTION) $<
	$(POST_PROCESS_O)
.c.a:
	$(COMPILE.c) -o $% $<
	$(PROCESS_COMMENT) $%
	$(AR) $(ARFLAGS) $@ $%
	$(RM) $%
.s.o:
	$(COMPILE.s) -o $@ $<
	$(POST_PROCESS_O)
.s.a:
	$(COMPILE.s) -o $% $<
	$(PROCESS_COMMENT) $%
	$(AR) $(ARFLAGS) $@ $%
	$(RM) $%
.cc:
	$(LINK.cc) -o $@ $< $(LDLIBS)
	$(POST_PROCESS)
.cc.o:
	$(COMPILE.cc) $(OUTPUT_OPTION) $<
	$(POST_PROCESS_O)
.cc.a:
	$(COMPILE.cc) -o $% $<
	$(AR) $(ARFLAGS) $@ $%
	$(PROCESS_COMMENT) $%
	$(RM) $%
.y:
	$(YACC.y) $<
	$(LINK.c) -o $@ y.tab.c $(LDLIBS)
	$(POST_PROCESS)
	$(RM) y.tab.c
.y.o:
	$(YACC.y) $<
	$(COMPILE.c) -o $@ y.tab.c
	$(POST_PROCESS_O)
	$(RM) y.tab.c
.l:
	$(RM) $*.c
	$(LEX.l) $< > $*.c
	$(LINK.c) -o $@ $*.c -ll $(LDLIBS)
	$(POST_PROCESS)
	$(RM) $*.c
.l.o:
	$(RM) $*.c
	$(LEX.l) $< > $*.c
	$(COMPILE.c) -o $@ $*.c
	$(POST_PROCESS_O)
	$(RM) $*.c

.java.class:
	$(COMPILE.java) $<

#
# Rules to create message catalogue files from
#	.c, .y and .l files
#
.c.po:
	$(COMPILE.cpp) $<  > $<.i
	$(BUILD.po)

.y.po:
	yacc -d $<
	$(COMPILE.cpp) y.tab.c  > $<.i
	$(BUILD.po)
	$(RM) y.tab.c 

.l.po:
	lex $<
	$(COMPILE.cpp) lex.yy.c  > $<.i
	$(BUILD.po)
	$(RM) lex.yy.c

#
# Rules to perform stylistic checks
#
.SUFFIXES: $(SUFFIXES) .x

$(ROOTBIN)/%: %
	$(INS.file)

$(ROOTLIB)/%: %
	$(INS.file)

$(ROOTBIN64)/%: %
	$(INS.file)

$(ROOTLIB64)/%: %
	$(INS.file)

$(ROOTBIN32)/%: %
	$(INS.file)

$(ROOTSBIN)/%: %
	$(INS.file)

$(ROOTUSRSBIN)/%: %
	$(INS.file)

$(ROOTUSRSBIN32)/%: %
	$(INS.file)

$(ROOTUSRSBIN64)/%: %
	$(INS.file)

$(ROOTETC)/%: %
	$(INS.file)

$(ROOTSFWBIN)/%: %
	$(INS.file)

$(ROOTSFWSBIN)/%: %
	$(INS.file)

$(ROOTSFWINFO)/%: %
	$(INS.file)

$(ROOTSFWLIB)/%: %
	$(INS.file)

$(ROOTLIBEXEC)/%: %
	$(INS.file)

$(ROOTSFWMAN1)/%: %
	$(INS.file)

$(ROOTSFWMAN1M)/%: %
	$(INS.file)

$(ROOTSFWMANN)/%: %
	$(INS.file)

$(ROOTSFWMAN3)/%: %
	$(INS.file)

$(ROOTSFWMAN4)/%: %
	$(INS.file)

$(ROOTSFWMAN5)/%: %
	$(INS.file)

$(ROOTSFWMAN7)/%: %
	$(INS.file)

$(ROOTSFWSHARE)/%: %
	$(INS.file)