# # 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) 1989, 2010, Oracle and/or its affiliates. All rights reserved. # Copyright (c) 2012 by Delphix. All rights reserved. # Copyright 2014 Garrett D'Amore # Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. # Copyright 2015 Gary Mills # Copyright 2015 Igor Kozhukhov # Copyright 2016 Toomas Soome # Copyright 2018 OmniOS Community Edition (OmniOSce) Association. # Copyright (c) 2019, Joyent, Inc. # # # Makefile.master, global definitions for system source # ROOT= /proto # # Adjunct root, containing an additional proto area to be used for headers # and libraries. # ADJUNCT_PROTO= # # Adjunct for building things that run on the build machine. # NATIVE_ADJUNCT= /usr # # RELEASE_BUILD should be cleared for final release builds. # NOT_RELEASE_BUILD is exactly what the name implies. # # __GNUC toggles the building of ON components using gcc and related tools. # Normally set to `#', set it to `' to do gcc build. # # The declaration POUND_SIGN is always '#'. This is needed to get around the # make feature that '#' is always a comment delimiter, even when escaped or # quoted. We use this macro expansion method to get POUND_SIGN rather than # always breaking out a shell because the general case can cause a noticable # slowdown in build times when so many Makefiles include Makefile.master. # # While the majority of users are expected to override the setting below # with an env file (via nightly or bldenv), if you aren't building that way # (ie, you're using "ws" or some other bootstrapping method) then you need # this definition in order to avoid the subshell invocation mentioned above. # PRE_POUND= pre\# POUND_SIGN= $(PRE_POUND:pre\%=%) NOT_RELEASE_BUILD= RELEASE_BUILD= $(POUND_SIGN) $(RELEASE_BUILD)NOT_RELEASE_BUILD= $(POUND_SIGN) PATCH_BUILD= $(POUND_SIGN) # 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=) # The variables below control the compilers used during the build. # There are a number of permutations. # # __GNUC and __SUNC control (and indicate) the primary compiler. Whichever # one is not POUND_SIGN is the primary, with the other as the shadow. They # may also be used to control entirely compiler-specific Makefile assignments. # __GNUC and GCC are the default. # # __GNUC64 indicates that the 64bit build should use the GNU C compiler. # There is no Sun C analogue. # # The following version-specific options are operative regardless of which # compiler is primary, and control the versions of the given compilers to be # used. They also allow compiler-version specific Makefile fragments. # __SUNC= $(POUND_SIGN) $(__SUNC)__GNUC= $(POUND_SIGN) __GNUC64= $(__GNUC) # Allow build-time "configuration" to enable or disable some things. # The default is POUND_SIGN, meaning "not enabled". If the environment # passes in an override like ENABLE_SMB_PRINTING= (empty) that will # uncomment things in the lower Makefiles to enable the feature. ENABLE_SMB_PRINTING= $(POUND_SIGN) # CLOSED is the root of the tree that contains source which isn't released # as open source CLOSED= $(SRC)/../closed # 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 # define runtime JAVA_HOME, primarily for cmd/pools/poold JAVA_HOME= /usr/java # define buildtime JAVA_ROOT JAVA_ROOT= /usr/java # Build uses java7 by default. Pass one the variables below set to empty # string in the environment to override. BLD_JAVA_6= $(POUND_SIGN) BLD_JAVA_8= $(POUND_SIGN) GNUC_ROOT= /opt/gcc/4.4.4 GCCLIBDIR= $(GNUC_ROOT)/lib GCCLIBDIR64= $(GNUC_ROOT)/lib/$(MACH64) DOCBOOK_XSL_ROOT= /usr/share/sgml/docbook/xsl-stylesheets RPCGEN= /usr/bin/rpcgen STABS= $(ONBLD_TOOLS)/bin/$(MACH)/stabs ELFEXTRACT= $(ONBLD_TOOLS)/bin/$(MACH)/elfextract MBH_PATCH= $(ONBLD_TOOLS)/bin/$(MACH)/mbh_patch BTXLD= $(ONBLD_TOOLS)/bin/$(MACH)/btxld VTFONTCVT= $(ONBLD_TOOLS)/bin/$(MACH)/vtfontcvt # echo(1) and true(1) are specified without absolute paths, so that the shell # spawned by make(1) may use the built-in versions. This is minimally # problematic, as the shell spawned by make(1) is known and under control, the # only risk being if the shell falls back to $PATH. # # We specifically want an echo(1) that does interpolation of escape sequences, # which ksh93, /bin/sh, and bash will all provide. ECHO= echo TRUE= true INS= $(ONBLD_TOOLS)/bin/$(MACH)/install SYMLINK= /usr/bin/ln -s LN= /usr/bin/ln MKDIR= /usr/bin/mkdir CHMOD= /usr/bin/chmod MV= /usr/bin/mv -f RM= /usr/bin/rm -f CUT= /usr/bin/cut NM= /usr/ccs/bin/nm DIFF= /usr/bin/diff GREP= /usr/bin/grep EGREP= /usr/bin/egrep ELFWRAP= /usr/bin/elfwrap KSH93= /usr/bin/ksh93 SED= /usr/bin/sed AWK= /usr/bin/nawk CP= /usr/bin/cp -f MCS= /usr/ccs/bin/mcs CAT= /usr/bin/cat ELFDUMP= /usr/ccs/bin/elfdump M4= /usr/bin/m4 GM4= /usr/bin/gm4 STRIP= /usr/ccs/bin/strip LEX= /usr/ccs/bin/lex FLEX= /usr/bin/flex YACC= /usr/ccs/bin/yacc BISON= /usr/bin/bison CPP= /usr/lib/cpp ANSI_CPP= $(GNUC_ROOT)/bin/cpp 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 CTFCONVERT= $(ONBLD_TOOLS)/bin/$(MACH)/ctfconvert CTFDIFF= $(ONBLD_TOOLS)/bin/$(MACH)/ctfdiff CTFMERGE= $(ONBLD_TOOLS)/bin/$(MACH)/ctfmerge CTFSTABS= $(ONBLD_TOOLS)/bin/$(MACH)/ctfstabs CTFSTRIP= $(ONBLD_TOOLS)/bin/$(MACH)/ctfstrip NDRGEN= $(ONBLD_TOOLS)/bin/$(MACH)/ndrgen GENOFFSETS= $(ONBLD_TOOLS)/bin/genoffsets XREF= $(ONBLD_TOOLS)/bin/xref FIND= /usr/bin/find PERL= /usr/bin/perl PERL_VERSION= 5.10.0 PERL_PKGVERS= -510 PERL_ARCH = i86pc-solaris-64int $(SPARC_BLD)PERL_ARCH = sun4-solaris-64int PYTHON_VERSION= 2.7 PYTHON_PKGVERS= -27 PYTHON_SUFFIX= PYTHON= /usr/bin/python$(PYTHON_VERSION) PYTHON3_VERSION= 3.5 PYTHON3_PKGVERS= -35 PYTHON3_SUFFIX= m PYTHON3= /usr/bin/python$(PYTHON3_VERSION) $(BUILDPY3TOOLS)TOOLS_PYTHON= $(PYTHON3) $(BUILDPY2TOOLS)TOOLS_PYTHON= $(PYTHON) SORT= /usr/bin/sort TR= /usr/bin/tr TOUCH= /usr/bin/touch WC= /usr/bin/wc XARGS= /usr/bin/xargs ELFEDIT= /usr/bin/elfedit DTRACE= /usr/sbin/dtrace -xnolibs UNIQ= /usr/bin/uniq TAR= /usr/bin/tar ASTBINDIR= /usr/ast/bin MSGCC= $(ASTBINDIR)/msgcc MSGFMT= /usr/bin/msgfmt -s LCDEF= $(ONBLD_TOOLS)/bin/$(MACH)/localedef TIC= $(ONBLD_TOOLS)/bin/$(MACH)/tic ZIC= $(ONBLD_TOOLS)/bin/$(MACH)/zic OPENSSL= /usr/bin/openssl CPCGEN= $(ONBLD_TOOLS)/bin/$(MACH)/cpcgen FILEMODE= 644 DIRMODE= 755 # Declare that nothing should be built in parallel. # Individual Makefiles can use the .PARALLEL target to declare otherwise. .NO_PARALLEL: # For stylistic checks # # Note that the X and C checks are not used at this time and may need # modification when they are actually used. # CSTYLE= $(ONBLD_TOOLS)/bin/cstyle CSTYLE_TAIL= HDRCHK= $(ONBLD_TOOLS)/bin/hdrchk HDRCHK_TAIL= JSTYLE= $(ONBLD_TOOLS)/bin/jstyle DOT_H_CHECK= \ @$(ECHO) "checking $<"; $(CSTYLE) $< $(CSTYLE_TAIL); \ $(HDRCHK) $< $(HDRCHK_TAIL) DOT_X_CHECK= \ @$(ECHO) "checking $<"; $(RPCGEN) -C -h $< | $(CSTYLE) $(CSTYLE_TAIL); \ $(RPCGEN) -C -h $< | $(HDRCHK) $< $(HDRCHK_TAIL) DOT_C_CHECK= \ @$(ECHO) "checking $<"; $(CSTYLE) $< $(CSTYLE_TAIL) MANIFEST_CHECK= \ @$(ECHO) "checking $<"; \ SVCCFG_DTD=$(SRC)/cmd/svc/dtd/service_bundle.dtd.1 \ SVCCFG_REPOSITORY=$(SRC)/cmd/svc/seed/global.db \ SVCCFG_CONFIGD_PATH=$(SRC)/cmd/svc/configd/svc.configd-native \ $(SRC)/cmd/svc/svccfg/svccfg-native validate $< 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)/$( $@; $(CHMOD) $(FILEMODE) $@; $(TOUCH) -r $< $@ # 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, and BUILD64 is set to `#' for # architectures on which we do not build 64-bit versions. # (There are no such architectures at the moment.) # # Set BUILD64=# in the environment to disable 64-bit amd64 # builds on i386 machines. MACH64_1= $(MACH:sparc=sparcv9) MACH64= $(MACH64_1:i386=amd64) MACH32_1= $(MACH:sparc=sparcv7) MACH32= $(MACH32_1:i386=i86) sparc_BUILD64= i386_BUILD64= BUILD64= $($(MACH)_BUILD64) # # C compiler mode. Future compilers may change the default on us, # so force extended ANSI 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= -v # set this to the secret flag "-Wc,-Qiselect-v9abiwarn=1" to get warnings # from the compiler about places the -xarch=v9 may differ from -xarch=v9c. V9ABIWARN= # set this to the secret flag "-Wc,-Qiselect-regsym=0" to disable register # symbols (used to detect conflicts between objects that use global registers) # we disable this now for safety, and because genunix doesn't link with # this feature (the v9 default) enabled. # # REGSYM is separate since the C++ driver syntax is different. CCREGSYM= -Wc,-Qiselect-regsym=0 CCCREGSYM= -Qoption cg -Qiselect-regsym=0 # Prevent the removal of static symbols by the SPARC code generator (cg). # The x86 code generator (ube) does not remove such symbols and as such # using this workaround is not applicable for x86. # CCSTATICSYM= -Wc,-Qassembler-ounrefsym=0 # # generate 32-bit addresses in the v9 kernel. Saves memory. CCABS32= -Wc,-xcode=abs32 # # generate v9 code which tolerates callers using the v7 ABI, for the sake of # system calls. CC32BITCALLERS= -_gcc=-massume-32bit-callers # GCC, especially, is increasingly beginning to auto-inline functions and # sadly does so separately not under the general -fno-inline-functions # Additionally, we wish to prevent optimisations which cause GCC to clone # functions -- in particular, these may cause unhelpful symbols to be # emitted instead of function names CCNOAUTOINLINE= \ -_gcc=-fno-inline-small-functions \ -_gcc=-fno-inline-functions-called-once \ -_gcc=-fno-ipa-cp \ -_gcc7=-fno-ipa-icf \ -_gcc8=-fno-ipa-icf \ -_gcc7=-fno-clone-functions \ -_gcc8=-fno-clone-functions # GCC may put functions in different named sub-sections of .text based on # their presumed calling frequency. At least in the kernel, where we actually # deliver relocatable objects, we don't want this to happen. # # Since at present we don't benefit from this even in userland, we disable it globally, # but the application of this may move into usr/src/uts/ in future. CCNOREORDER= \ -_gcc7=-fno-reorder-functions \ -_gcc8=-fno-reorder-functions # # gcc has a rather aggressive optimization on by default that infers loop # bounds based on undefined behavior (!!). This can lead to some VERY # surprising optimizations -- ones that may be technically correct in the # strictest sense but also result in incorrect program behavior. We turn # this optimization off, with extreme prejudice. # CCNOAGGRESSIVELOOPS= \ -_gcc7=-fno-aggressive-loop-optimizations \ -_gcc8=-fno-aggressive-loop-optimizations # One optimization the compiler might perform is to turn this: # #pragma weak foo # extern int foo; # if (&foo) # foo = 5; # into # foo = 5; # Since we do some of this (foo might be referenced in common kernel code # but provided only for some cpu modules or platforms), we disable this # optimization. # sparc_CCUNBOUND = -Wd,-xsafe=unboundsym i386_CCUNBOUND = CCUNBOUND = $($(MACH)_CCUNBOUND) # # compiler '-xarch' flag. This is here to centralize it and make it # overridable for testing. sparc_XARCH= -m32 sparcv9_XARCH= -m64 i386_XARCH= -m32 amd64_XARCH= -m64 -Ui386 -U__i386 # assembler '-xarch' flag. Different from compiler '-xarch' flag. sparc_AS_XARCH= -xarch=v8plus sparcv9_AS_XARCH= -xarch=v9 i386_AS_XARCH= amd64_AS_XARCH= -xarch=amd64 -P -Ui386 -U__i386 # # These flags define what we need to be 'standalone' i.e. -not- part # of the rather more cosy userland environment. This basically means # the kernel. # # XX64 future versions of gcc will make -mcmodel=kernel imply -mno-red-zone # sparc_STAND_FLAGS= -_gcc=-ffreestanding sparcv9_STAND_FLAGS= -_gcc=-ffreestanding # Disabling MMX also disables 3DNow, disabling SSE also disables all later # additions to SSE (SSE2, AVX ,etc.) NO_SIMD= -_gcc=-mno-mmx -_gcc=-mno-sse i386_STAND_FLAGS= -_gcc=-ffreestanding $(NO_SIMD) amd64_STAND_FLAGS= -xmodel=kernel $(NO_SIMD) SAVEARGS= -Wu,-save_args amd64_STAND_FLAGS += $(SAVEARGS) STAND_FLAGS_32 = $($(MACH)_STAND_FLAGS) STAND_FLAGS_64 = $($(MACH64)_STAND_FLAGS) # # disable the incremental linker ILDOFF= -xildoff # XFFLAG= -xF=%all XESS= -xs XSTRCONST= -xstrconst # # turn warnings into errors (C) CERRWARN = -errtags=yes -errwarn=%all CERRWARN += -erroff=E_EMPTY_TRANSLATION_UNIT CERRWARN += -erroff=E_STATEMENT_NOT_REACHED CERRWARN += -_gcc=-Wno-missing-braces CERRWARN += -_gcc=-Wno-sign-compare CERRWARN += -_gcc=-Wno-unknown-pragmas CERRWARN += -_gcc=-Wno-unused-parameter CERRWARN += -_gcc=-Wno-missing-field-initializers # Unfortunately, this option can misfire very easily and unfixably. CERRWARN += -_gcc=-Wno-array-bounds CERRWARN += -_smatch=-p=illumos_user include $(SRC)/Makefile.smatch # # turn warnings into errors (C++) CCERRWARN= -xwe # C standard. Keep Studio flags until we get rid of lint. CSTD_GNU89= -xc99=%none CSTD_GNU99= -xc99=%all CSTD= $(CSTD_GNU89) C99LMODE= $(CSTD:-xc99%=-Xc99%) # In most places, assignments to these macros should be appended with += # (CPPFLAGS.first allows values to be prepended to CPPFLAGS). sparc_CFLAGS= $(sparc_XARCH) $(CCSTATICSYM) sparcv9_CFLAGS= $(sparcv9_XARCH) -dalign $(CCVERBOSE) $(V9ABIWARN) $(CCREGSYM) \ $(CCSTATICSYM) i386_CFLAGS= $(i386_XARCH) amd64_CFLAGS= $(amd64_XARCH) sparc_ASFLAGS= $(sparc_AS_XARCH) sparcv9_ASFLAGS=$(sparcv9_AS_XARCH) i386_ASFLAGS= $(i386_AS_XARCH) amd64_ASFLAGS= $(amd64_AS_XARCH) # sparc_COPTFLAG= -xO3 sparcv9_COPTFLAG= -xO3 i386_COPTFLAG= -O amd64_COPTFLAG= -xO3 COPTFLAG= $($(MACH)_COPTFLAG) COPTFLAG64= $($(MACH64)_COPTFLAG) # When -g is used, the compiler globalizes static objects # (gives them a unique prefix). Disable that. CNOGLOBAL= -W0,-noglobal # Direct the Sun Studio compiler to use a static globalization prefix based on the # name of the module rather than something unique. Otherwise, objects # will not build deterministically, as subsequent compilations of identical # source will yeild objects that always look different. # # In the same spirit, this will also remove the date from the N_OPT stab. CGLOBALSTATIC= -W0,-xglobalstatic # Sometimes we want all symbols and types in debugging information even # if they aren't used. CALLSYMS= -W0,-xdbggen=no%usedonly # # We force the compilers to generate the debugging information best understood # by the CTF tools. With Sun Studio this is stabs due to bugs in the Studio # compilers. With GCC this is DWARF v2. # DEBUGFORMAT= -_cc=-xdebugformat=stabs -_gcc=-gdwarf-2 # # Ask the compiler to include debugging information # CCGDEBUG= -g $(DEBUGFORMAT) # # Flags used to build in debug mode for ctf generation. # CTF_FLAGS_sparc = $(CCGDEBUG) -Wc,-Qiselect-T1 $(CSTD) $(CNOGLOBAL) CTF_FLAGS_i386 = $(CCGDEBUG) $(CSTD) $(CNOGLOBAL) CTF_FLAGS_sparcv9 = $(CTF_FLAGS_sparc) CTF_FLAGS_amd64 = $(CTF_FLAGS_i386) # Sun Studio produces broken userland code when saving arguments. $(__GNUC)CTF_FLAGS_amd64 += $(SAVEARGS) CTF_FLAGS_32 = $(CTF_FLAGS_$(MACH)) CTF_FLAGS_64 = $(CTF_FLAGS_$(MACH64)) CTF_FLAGS = $(CTF_FLAGS_32) # # Flags used with genoffsets # GENOFFSETS_FLAGS = $(CALLSYMS) OFFSETS_CREATE = $(GENOFFSETS) -s $(CTFSTABS) -r $(CTFCONVERT) \ $(CW) --noecho $(CW_CC_COMPILERS) -- $(GENOFFSETS_FLAGS) \ $(CFLAGS) $(CPPFLAGS) OFFSETS_CREATE64 = $(GENOFFSETS) -s $(CTFSTABS) -r $(CTFCONVERT) \ $(CW) --noecho $(CW_CC_COMPILERS) -- $(GENOFFSETS_FLAGS) \ $(CFLAGS64) $(CPPFLAGS) # # 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) # # 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) sparc_XREGSFLAG = -xregs=no%appl sparcv9_XREGSFLAG = -xregs=no%appl i386_XREGSFLAG = amd64_XREGSFLAG = XREGSFLAG = $($(MACH)_XREGSFLAG) XREGSFLAG64 = $($(MACH64)_XREGSFLAG) # dmake SOURCEDEBUG=yes ... enables source-level debugging information, and # avoids stripping it. SOURCEDEBUG = $(POUND_SIGN) SRCDBGBLD = $(SOURCEDEBUG:yes=) # # These variables are intended ONLY for use by developers to safely pass extra # flags to the compilers without unintentionally overriding Makefile-set # flags. They should NEVER be set to any value in a Makefile. # # They come last in the associated FLAGS variable such that they can # explicitly override things if necessary, there are gaps in this, but it's # the best we can manage. # CUSERFLAGS = CUSERFLAGS64 = $(CUSERFLAGS) CCUSERFLAGS = CCUSERFLAGS64 = $(CCUSERFLAGS) CSOURCEDEBUGFLAGS = CCSOURCEDEBUGFLAGS = $(SRCDBGBLD)CSOURCEDEBUGFLAGS = $(CCGDEBUG) -xs $(SRCDBGBLD)CCSOURCEDEBUGFLAGS = $(CCGDEBUG) -xs CFLAGS= $(COPTFLAG) $($(MACH)_CFLAGS) $(SPACEFLAG) $(CCMODE) \ $(ILDOFF) $(CERRWARN) $(CSTD) $(CCUNBOUND) $(IROPTFLAG) \ $(CGLOBALSTATIC) $(CCNOAUTOINLINE) $(CCNOREORDER) \ $(CCNOAGGRESSIVELOOPS) \ $(CSOURCEDEBUGFLAGS) $(CUSERFLAGS) CFLAGS64= $(COPTFLAG64) $($(MACH64)_CFLAGS) $(SPACEFLAG64) $(CCMODE64) \ $(ILDOFF) $(CERRWARN) $(CSTD) $(CCUNBOUND) $(IROPTFLAG64) \ $(CGLOBALSTATIC) $(CCNOAUTOINLINE) $(CCNOREORDER) \ $(CCNOAGGRESSIVELOOPS) \ $(CSOURCEDEBUGFLAGS) $(CUSERFLAGS64) # # Flags that are used to build parts of the code that are subsequently # run on the build machine (also known as the NATIVE_BUILD). # NATIVE_CFLAGS= $(COPTFLAG) $($(NATIVE_MACH)_CFLAGS) $(CCMODE) \ $(ILDOFF) $(CERRWARN) $(CSTD) $($(NATIVE_MACH)_CCUNBOUND) \ $(IROPTFLAG) $(CGLOBALSTATIC) $(CCNOAUTOINLINE) \ $(CCNOREORDER) $(CSOURCEDEBUGFLAGS) $(CUSERFLAGS) DTEXTDOM=-DTEXT_DOMAIN=\"$(TEXT_DOMAIN)\" # For messaging. DTS_ERRNO=-D_TS_ERRNO CPPFLAGS.first= # Please keep empty. Only lower makefiles should set this. CPPFLAGS.master=$(DTEXTDOM) $(DTS_ERRNO) \ $(ENVCPPFLAGS1) $(ENVCPPFLAGS2) $(ENVCPPFLAGS3) $(ENVCPPFLAGS4) \ $(ADJUNCT_PROTO:%=-I%/usr/include) CPPFLAGS.native=$(ENVCPPFLAGS1) $(ENVCPPFLAGS2) $(ENVCPPFLAGS3) \ $(ENVCPPFLAGS4) -I$(NATIVE_ADJUNCT)/include CPPFLAGS= $(CPPFLAGS.first) $(CPPFLAGS.master) AS_CPPFLAGS= $(CPPFLAGS.first) $(CPPFLAGS.master) JAVAFLAGS= -source 1.6 -target 1.6 -Xlint:deprecation,-options # # For source message catalogue # .SUFFIXES: $(SUFFIXES) .i .po MSGROOT= $(ROOT)/catalog MSGDOMAIN= $(MSGROOT)/$(TEXT_DOMAIN) MSGDOMAINPOFILE = $(MSGDOMAIN)/$(POFILE) DCMSGDOMAIN= $(MSGROOT)/LC_TIME/$(TEXT_DOMAIN) DCMSGDOMAINPOFILE = $(DCMSGDOMAIN)/$(DCFILE:.dc=.po) CLOBBERFILES += $(POFILE) $(POFILES) COMPILE.cpp= $(CC) -E -C $(CFLAGS) $(CPPFLAGS) XGETTEXT= /usr/bin/xgettext XGETFLAGS= -c TRANSLATION_NOTE GNUXGETTEXT= /usr/gnu/bin/xgettext GNUXGETFLAGS= --add-comments=TRANSLATION_NOTE --keyword=_ \ --strict --no-location --omit-header BUILD.po= $(XGETTEXT) $(XGETFLAGS) -d $( $@ ;\ $(RM) $( $*.c $(LINK.c) -o $@ $*.c -ll $(LDLIBS) $(POST_PROCESS) $(RM) $*.c .l.o: $(RM) $*.c $(LEX.l) $< > $*.c $(COMPILE.c) -o $@ $*.c $(CTFCONVERT_HOOK) $(POST_PROCESS_O) $(RM) $*.c .bin.o: $(COMPILE.b) -o $@ $< $(POST_PROCESS_O) .java.class: $(COMPILE.java) $< # Bourne and Korn shell script message catalog build rules. # We extract all gettext strings with sed(1) (being careful to permit # multiple gettext strings on the same line), weed out the dups, and # build the catalogue with awk(1). .sh.po .ksh.po: $(SED) -n -e ":a" \ -e "h" \ -e "s/.*gettext *\(\"[^\"]*\"\).*/\1/p" \ -e "x" \ -e "s/\(.*\)gettext *\"[^\"]*\"\(.*\)/\1\2/" \ -e "t a" \ $< | sort -u | $(AWK) '{ print "msgid\t" $$0 "\nmsgstr" }' > $@ # # Python and Perl executable and message catalog build rules. # .SUFFIXES: .pl .pm .py .pyc .pl: $(RM) $@; $(SED) -e "s@TEXT_DOMAIN@\"$(TEXT_DOMAIN)\"@" $< > $@; $(CHMOD) +x $@ .py: $(RM) $@; $(SED) \ -e "1s:^\#!@PYTHON@:\#!$(PYSHEBANG):" \ -e "1s:^\#!@TOOLS_PYTHON@:\#!$(TOOLS_PYTHON):" \ < $< > $@; $(CHMOD) +x $@ .py.pyc: $(RM) $@ $(PYTHON) -mpy_compile $< @[ $(<)c = $@ ] || $(MV) $(<)c $@ .py.po: $(GNUXGETTEXT) $(GNUXGETFLAGS) -d $( $@ ; $(RM) $( $@ .h.i: $(CPPFORPO) $< > $@ .y.i: $(YACC) -d $< $(CPPFORPO) y.tab.c > $@ $(RM) y.tab.c .l.i: $(LEX) $< $(CPPFORPO) lex.yy.c > $@ $(RM) lex.yy.c .c.po: $(CPPFORPO) $< > $<.i $(BUILD.po) .cc.po: $(CPPFORPO) $< > $<.i $(BUILD.po) .y.po: $(YACC) -d $< $(CPPFORPO) y.tab.c > $<.i $(BUILD.po) $(RM) y.tab.c .l.po: $(LEX) $< $(CPPFORPO) lex.yy.c > $<.i $(BUILD.po) $(RM) lex.yy.c # # Rules to perform stylistic checks # .SUFFIXES: .x .xml .check .xmlchk .h.check: $(DOT_H_CHECK) .x.check: $(DOT_X_CHECK) .xml.xmlchk: $(MANIFEST_CHECK) # # Include rules to render automated sccs get rules "safe". # include $(SRC)/Makefile.noget