open-src/common/Makefile.init

	Makefile.init revision 1628
# -*- Makefile -*- rules commonly shared among X consolidation open source dirs
# Makefile.init has definitions that are needed before the module/modtype rules
#
# Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
#

# Use ksh93 for shell commands in Makefiles so that builds are the same
# on Nevada (where /bin/sh is still ancient Bourne shell) and Indiana
# (where /bin/sh is ksh93)
SHELL=/usr/bin/ksh93

# Borrowed from Solaris OS/Net makefile.master:
# 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.init.
#
PRE_POUND=              pre\#
POUND_SIGN=             $(PRE_POUND:pre\%=%)

# Set default build target to all
default: all

# The infrastructure in the main tree requires Solaris make
$(error You must use Solaris make, not GNU make in this build - make sure /usr/ccs/bin or /usr/bin is ahead of /usr/gnu/bin in $$PATH)

### Build options

# Different builders want different settings for various options such
# as branding or download sites.  The top-level "make setup" command
# sets the Makefile.options link to point to a included Makefile to
# set these up.

$(TOP)/open-src/common/Makefile.options:
    cd $(TOP) ; $(MAKE) $(MAKEFLAGS) setup

include "Makefile.options"

###  Machine architecture macros

# MACH will be either "sparc" or "i386"
MACH=$(TARGET_ARCH:-%=%)

MACH32_sparc    = sparc
MACH64_sparc    = sparcv9
MACH32_i386 = i386
MACH64_i386     = amd64

MACH32= $(MACH32_$(MACH))
MACH64= $(MACH64_$(MACH))

# Architecture subdirectories

SUBDIR32_sparc  = sparcv7
SUBDIR64_sparc  = sparcv9
SUBDIR32_i386   = i86
SUBDIR64_i386   = amd64

SUBDIR32    = $(SUBDIR32_$(MACH))
SUBDIR64    = $(SUBDIR64_$(MACH))

LIBSUBDIR   = $(LIBSUBDIR_$(BUILD_TYPE))
LIBSUBDIR_32    = # None
LIBSUBDIR_64    = /$(SUBDIR64)
ARCHLIBSUBDIR   = $(LIBSUBDIR)

### Default compiler & options

# Our default compiler is Solaris Studio, but if you want to default to GNU
# compilers, you can change this here - some modules with specific
# requirements override this in their makefiles with MODULE_COMPILER.
DEFAULT_COMPILER     = suncc

# Flags used by either compiler in debug builds
DEBUG_FLAGS_common   = -g $(MODTYPE_DEBUG_FLAGS) $(MODULE_DEBUG_FLAGS)

## Solaris Studio compilers
CC_suncc         = cc
CXX_suncc        = CC
OPT_FLAGS_suncc      = -xO4 -xbuiltin=%none -xlibmil -xprefetch -xdepend
OPT_FLAGS_suncc     += -xspace -W0,-xglobalstatic
DEBUG_FLAGS_suncc    = $(DEBUG_FLAGS_common)
$(BUILD_DEBUG:yes=) DEBUG_OR_OPT_FLAGS_suncc = $(DEBUG_FLAGS_suncc)
$(BUILD_DEBUG:yes=$(POUND_SIGN)) DEBUG_OR_OPT_FLAGS_suncc = $(OPT_FLAGS_suncc)

CFLAGS_suncc         = $(DEBUG_OR_OPT_FLAGS_suncc)
CFLAGS_suncc        += -v -fd -features=extensions,conststrings
CXXFLAGS_suncc       = $(DEBUG_OR_OPT_FLAGS_suncc)
CXXFLAGS_suncc      += +w2 -norunpath -features=extensions

# -D__<arch>__ flags are to match gcc definitions that are used in much
# of the upstream open source code base
ARCH_FLAGS_sparc_suncc      = -xarch=sparc -D__sparc__
ARCH32_FLAGS_sparc_suncc    = -m32
ARCH64_FLAGS_sparc_suncc    = -m64

# -xregs=no%frameptr is required on x86 when compiling at -xO4 or higher to
# avoid losing stack frame pointers so you can't get stack traces or debug
ARCH_FLAGS_i386_suncc       = -xregs=no%frameptr
ARCH32_FLAGS_i386_suncc     = -m32 -xarch=sse2 -D__i386__
ARCH64_FLAGS_i386_suncc     = -m64 -xarch=sse2 -D__amd64__

# SPARC ABI requires system libraries not use application registers
ARCH_LIB_FLAGS_sparc_suncc  = -xregs=no%appl
ARCH_LIB_FLAGS_i386_suncc   =

# Flags to specify which language version to support, default to C11/C++11
C_VERSION_FLAGS_suncc       = -std=c11 -xlang=c11
CXX_VERSION_FLAGS_suncc     = -std=c++11 -xlang=c99

## GNU Compilers
GCC_VERSION             = 4.8
GCC             = /usr/gcc/$(GCC_VERSION)/bin/gcc
GXX             = /usr/gcc/$(GCC_VERSION)/bin/g++
CC_gcc              = $(GCC)
CXX_gcc             = $(GXX)
OPT_FLAGS_gcc           = -O3
DEBUG_FLAGS_gcc         = $(DEBUG_FLAGS_common)
$(BUILD_DEBUG:yes=) DEBUG_OR_OPT_FLAGS_gcc = $(DEBUG_FLAGS_gcc)
$(BUILD_DEBUG:yes=$(POUND_SIGN)) DEBUG_OR_OPT_FLAGS_gcc = $(OPT_FLAGS_gcc)
WARNFLAGS_gcc           = -Wall -Wno-unknown-pragmas
CFLAGS_gcc          = $(DEBUG_OR_OPT_FLAGS_gcc) \
                  -fno-omit-frame-pointer $(WARNFLAGS_gcc)
CXXFLAGS_gcc            = $(DEBUG_OR_OPT_FLAGS_gcc) \
                  -fno-omit-frame-pointer $(WARNFLAGS_gcc)

ARCH32_FLAGS_sparc_gcc      = -mcpu=ultrasparc -m32
ARCH64_FLAGS_sparc_gcc      = -mcpu=ultrasparc -m64
ARCH32_FLAGS_i386_gcc       = -march=pentium4 -m32
ARCH64_FLAGS_i386_gcc       = -march=opteron -m64

# SPARC ABI requires system libraries not use application registers
ARCH_LIB_FLAGS_sparc_gcc    = -mno-app-regs
ARCH_LIB_FLAGS_i386_gcc     =

# Default to C11 plus GNU extensions, since we primarily use gcc for code
# that requires the GNU extensions.
C_VERSION_FLAGS_gcc     = -std=gnu11
CXX_VERSION_FLAGS_gcc       = -std=gnu++11

## Parfait wrappers
CC_suncc_parfait    = parfait-cc
CXX_suncc_parfait   = parfait-CC
CC_gcc_parfait      = parfait-gcc
CXX_gcc_parfait     = parfait-g++
AR_parfait      = parfait-ar
AS_parfait      = parfait-as
LD_parfait      = parfait-ld

# If USE_PARFAIT is yes, use _parfait variants
PARFAIT_1 = $(USE_PARFAIT:no=)
PARFAIT_2 = $(PARFAIT_1:yes=$(POUND_SIGN))
$(PARFAIT_2)    WITH_PARFAIT=$(POUND_SIGN)
$(WITH_PARFAIT) WITHOUT_PARFAIT=$(POUND_SIGN)

$(WITH_PARFAIT)     CHOSEN_COMPILER=$(MODULE_COMPILER)_parfait
$(WITHOUT_PARFAIT)  CHOSEN_COMPILER=$(MODULE_COMPILER)
$(WITH_PARFAIT)     AR=$(AR_parfait)
$(WITHOUT_PARFAIT)  AR=/usr/bin/ar
$(WITH_PARFAIT)     AS=$(AS_parfait)
$(WITHOUT_PARFAIT)  AS=/usr/bin/as
$(WITH_PARFAIT)     LD=$(LD_parfait)
$(WITHOUT_PARFAIT)  LD=/usr/bin/ld

# Additional environment variables needed to build with parfait
PARFAIT_ENV_gcc     = PARFAIT_NATIVEGCC="$(GCC)"
PARFAIT_ENV_gcc        += PARFAIT_NATIVEGXX="$(GXX)"
PARFAIT_ENV     = $(PARFAIT_ENV_$(MODULE_COMPILER))
# Output shorter error messages when parfait-wrapped compilers fail,
# unless building with V=1 to be more verbose
PARFAIT_QUIET_ENV_V_1   = # parfait is noisy unless you tell it to be quiet
PARFAIT_QUIET_ENV_V_0   = PARFAIT_WRAPPER_QUIETNATIVE=1
PARFAIT_QUIET_ENV_V_    = $(PARFAIT_QUIET_ENV_V_0)
PARFAIT_QUIET_ENV   = $(PARFAIT_QUIET_ENV_V_$(V))
PARFAIT_ENV            += $(PARFAIT_QUIET_ENV)

# Allow modules to override default language choices
C_VERSION_DEFAULT   = $(C_VERSION_FLAGS_SET:yes=$(POUND_SIGN))
$(C_VERSION_DEFAULT)    C_VERSION_FLAGS = $(C_VERSION_FLAGS_$(MODULE_COMPILER))
CXX_VERSION_DEFAULT = $(CXX_VERSION_FLAGS_SET:yes=$(POUND_SIGN))
$(CXX_VERSION_DEFAULT)  CXX_VERSION_FLAGS = $(CXX_VERSION_FLAGS_$(MODULE_COMPILER))


## Set common variables based on above rules
# Architecture & version flags affect how compiler links to C & C++ runtimes
# so need to be included in $(CC) and $(CXX) when passed to configure to make
# sure configure tests are run against the right versions.
CC          = $(CC_$(CHOSEN_COMPILER))
CC                 += $(ARCH_FLAGS) $(C_VERSION_FLAGS)
CXX         = $(CXX_$(CHOSEN_COMPILER))
CXX                += $(ARCH_FLAGS) $(CXX_VERSION_FLAGS)
CFLAGS          = $(CFLAGS_$(MODULE_COMPILER)) $(ARCH_FLAGS)
CFLAGS                 += $(C_VERSION_FLAGS)
CXXFLAGS        = $(CXXFLAGS_$(MODULE_COMPILER)) $(ARCH_FLAGS)
CXXFLAGS           += $(CXX_VERSION_FLAGS)
ARCH32_FLAGS        = $(ARCH32_FLAGS_$(MACH)_$(MODULE_COMPILER))
ARCH32_FLAGS           += $(ARCH_FLAGS_$(MACH)_$(MODULE_COMPILER))
ARCH64_FLAGS        = $(ARCH64_FLAGS_$(MACH)_$(MODULE_COMPILER))
ARCH64_FLAGS           += $(ARCH_FLAGS_$(MACH)_$(MODULE_COMPILER))
ARCH_LIB_FLAGS      = $(ARCH_LIB_FLAGS_$(MACH)_$(MODULE_COMPILER))

# Flags for specific binary types
LIB_CPPFLAGS        = $(CPPFLAGS)
LIB_CFLAGS      = $(CFLAGS) $(ARCH_LIB_FLAGS)
LIB_CXXFLAGS        = $(CXXFLAGS) $(ARCH_LIB_FLAGS)
PROG_CPPFLAGS       = $(CPPFLAGS) -DFD_SETSIZE=$(FD_SETSIZE)
PROG_CFLAGS     = $(CFLAGS)
PROG_CXXFLAGS       = $(CXXFLAGS)

# Default FD_SETSIZE - 1024 was the 32-bit default and was big enough
# <sys/select.h> makes the 64-bit default be 65536 which is way too big,
# and eats a lot of memory for fd_sets and cpu doing operations on them
FD_SETSIZE_DEFAULT  = $(FD_SETSIZE_SET:yes=$(POUND_SIGN))
$(FD_SETSIZE_DEFAULT)   FD_SETSIZE = 1024

### Linker flags

# Linker mapfiles to link with for better performance & security
# SPARC architecture requires PLT section in .data be executable, so
# we can only make .bss, not all of .data no-exec on SPARC
MAPFILE_NOEXBSS     = -M /usr/lib/ld/map.noexbss
MAPFILE_NOEXDATA_sparc  = $(MAPFILE_NOEXBSS)
MAPFILE_NOEXDATA_i386   = -M /usr/lib/ld/map.noexdata
MAPFILE_NOEXDATA    = $(MAPFILE_NOEXDATA_$(MACH))
MAPFILE_PAGEALIGN   = -M /usr/lib/ld/map.pagealign
MAPFILE_HEAPALIGN   = -M /usr/lib/ld/map.bssalign

MAPFILES_FOR_ALL    = $(MAPFILE_PAGEALIGN) $(MAPFILE_NOEXDATA)
MAPFILES_FOR_PROGS  = $(MAPFILE_HEAPALIGN) $(MAPFILE_NOEXBSS)

# Security Extensions file tagging.
#
# Security Extensions  can be explicitly controlled at the binary level via
# tagging. Binaries built with -z <extension>=enable will have the extension
# enabled in the 'tagged-files' model, while binaries built with
# -z <extension>=disable will have it disabled regardless of the model.
#
# Currently supported extensions are:
#  -z aslr      Address Space Layout Randomization
#  -z nxstack   Non-executable Stack
#  -z nxheap    Non-executable Heap
#
# -z aslr|nxstack|nxheap are only valid when linking executables.

ZASLR_ENABLE=       -z aslr=enable
ZASLR_DISABLE=      -z aslr=disable
ZASLR=          $(ZASLR_ENABLE)

ZNXSTACK_ENABLE=    -z nxstack=enable
ZNXSTACK_DISABLE=   -z nxstack=disable
ZNXSTACK=       $(ZNXSTACK_ENABLE)

ZNXHEAP_ENABLE=     -z nxheap=enable
ZNXHEAP_DISABLE=    -z nxheap=disable
ZNXHEAP=        $(ZNXHEAP_ENABLE)

# Flags to discard at link time unnecessary dependencies, .o files or
# ELF sections that upstream may have included that we don't use.
ZDISCARD_UNUSED_DEP = -zdiscard-unused=dependencies
ZDISCARD_UNUSED_FIL = -zdiscard-unused=files
ZDISCARD_UNUSED_SEC = -zdiscard-unused=sections

# Common flags for all binaries
DEFAULT_LD_OPTIONS  = -z lazyload -B direct -z guidance
DEFAULT_LD_OPTIONS     += $(MAPFILES_FOR_ALL)
DEFAULT_LD_OPTIONS     += -L$(PROTODIR)/usr/lib$(LIBSUBDIR)

# Strip debug info out of non-debug builds
$(BUILD_DEBUG:yes=$(POUND_SIGN))  DEFAULT_LD_OPTIONS += -z strip-class=debug

# gcc often links with libgcc.a and/or libgcc_s.so whether it's needed or not
DEFAULT_LD_OPTIONS_gcc  = $(ZDISCARD_UNUSED_DEP) $(ZDISCARD_UNUSED_FIL)

DEFAULT_LD_OPTIONS     += $(DEFAULT_LD_OPTIONS_$(MODULE_COMPILER))

# Ensure required flags for .so's are applied, despite libtool interference
DEFAULT_LD_SHARED_OPTIONS = -z text -z defs

# Ensure we do ASLR tagging & mark stacks/heaps non-executable on programs
DEFAULT_LD_EXEC_OPTIONS = $(ZASLR) $(ZNXHEAP) $(ZNXSTACK) $(MAPFILES_FOR_PROGS)

## Commonly added options

# Link with X server private libraries like libXfont & libfontenc
X11_SERVERLIBS_LDFLAGS= -L$(PROTODIR)$(X11_SERVERLIBS_DIR)$(ARCHLIBSUBDIR) \
            -R$(X11_SERVERLIBS_DIR)$(ARCHLIBSUBDIR)


### Directory paths

# Proto directory to install into for packaging
PROTOTOP=$(TOP)/proto
PROTODIR=$(PROTOTOP)/root_$(MACH)
PROTODIR_DEBUG=$(PROTOTOP)/root_$(MACH)-debug
PROTOMETA=$(PROTOTOP)/metadata_$(MACH)

# Standard paths for modules to install into, relative to $(MODULE_PREFIX)
# See also MODULE_DOC_DIR & MODULE_PKGCONFIG_DIR in Makefile.defs
MODULE_BIN_DIR      = $(MODULE_PREFIX)/bin
MODULE_INCLUDES_DIR = $(MODULE_PREFIX)/include
MODULE_LIB_DIR      = $(MODULE_PREFIX)/lib
MODULE_FULLARCH_LIB_DIR = $(MODULE_LIB_DIR)$(MODULE_ADD_LIB_SUBDIR)$(ARCHLIBSUBDIR)
MODULE_DATA_DIR     = $(MODULE_PREFIX)/share
MODULE_LOCALE_DIR   = $(MODULE_PREFIX)/share/locale
MODULE_LC_MESSAGES_DIR  = $(MODULE_LOCALE_DIR)/C/LC_MESSAGES
MODULE_MAN_DIR      = $(MODULE_PREFIX)/share/man
MODULE_SBIN_DIR     = $(MODULE_PREFIX)/sbin

# System-wide standard paths that don't differ depending on $(MODULE_PREFIX)
SMF_MANIFEST_DIR    = /lib/svc/manifest
X11_SMF_MANIFEST_DIR    = $(SMF_MANIFEST_DIR)/application/x11
SMF_METHOD_DIR      = /lib/svc/method
SHARE_FONT_DIR      = /usr/share/fonts
TRUETYPE_FONT_DIR   = $(SHARE_FONT_DIR)/TrueType
X11_FONT_DIR        = $(SHARE_FONT_DIR)/X11
X11_FONT_CATALOGUE  = /etc/X11/fontpath.d
X11_ACLOCAL_DIR     = /usr/share/aclocal
X11_BIN_DIR     = /usr/bin
X11_DOC_DIR     = /usr/share/doc/X11
X11_INCLUDES_DIR    = /usr/include
X11_LIB_DIR     = /usr/lib
X11_SGML_DIR        = /usr/share/sgml/X11
X11_X11LIB_DIR      = $(X11_LIB_DIR)/X11
XORG_SDK_INCLUDES_DIR   = $(X11_INCLUDES_DIR)/xorg

# Subdirectory of /usr/lib for X server private libraries
X11_SERVERLIBS_SUBDIR   = /xorg
X11_SERVERLIBS_DIR  = $(X11_LIB_DIR)$(X11_SERVERLIBS_SUBDIR)

# Subdirectory of /usr/lib for X server loadable modules
X11_SERVERMODS_SUBDIR   = /xorg/modules
X11_SERVERMODS_DIR  = $(X11_LIB_DIR)$(X11_SERVERMODS_SUBDIR)
MESA_XSERVERMODS_DIR    = /usr/lib/mesa/modules

# PKGCONFIG_DIR is constructed of _prefix + ARCHLIBSUBDIR + _suffix
PKGCONFIG_DIR_prefix=/usr/lib
PKGCONFIG_DIR_suffix=/pkgconfig
PKGCONFIG_DIR=$(PKGCONFIG_DIR_prefix)$(ARCHLIBSUBDIR)$(PKGCONFIG_DIR_suffix)
PKGCONFIG_DIR_32=$(PKGCONFIG_DIR_prefix)$(PKGCONFIG_DIR_suffix)
PKGCONFIG_DIR_64=$(PKGCONFIG_DIR_prefix)/$(SUBDIR64)$(PKGCONFIG_DIR_suffix)
PKGCONFIG_DIR_SHARE=/usr/share$(PKGCONFIG_DIR_suffix)

# System-wide directory for packaged release notes
RELNOTES_DIR=/usr/share/doc/release-notes

# Directory used for installing tools used during build but not
# delivered in packages
TOOLS_DIR=$(PROTOTOP)/tools_$(MACH)

# Work around _TIME, _DATE, embedded date chatter in component builds
# to use, set TIME_CONSTANT in the component Makefile and add $(CONSTANT_TIME)
# to the appropriate MODULE_CONFIG_ENV/MODULE_BUILD_ENV/MODULE_INSTALL_ENV
CONSTANT_TIME  = LD_PRELOAD_32=$(TOOLS_DIR)/time-$(MACH32).so
CONSTANT_TIME += LD_PRELOAD_64=$(TOOLS_DIR)/time-$(MACH64).so
CONSTANT_TIME += TIME_CONSTANT=$(TIME_CONSTANT)

### Other tools needed to build

## Python tools & paths
# When changing PYTHON_VERSION, check that PYTHON_PKG_VERSION &
# PYTHON_PATH_VERSION are still set correctly in pkg/Makefile
PYTHON_VERSION=3.4
PYTHON=/usr/bin/python$(PYTHON_VERSION)
PYTHON_PATH=$(PROTODIR)/usr/lib/python$(PYTHON_VERSION)/vendor-packages:$(PROTODIR)/usr/lib/python$(PYTHON_VERSION)/site-packages:/usr/lib/python$(PYTHON_VERSION)/vendor-packages:/usr/lib/python$(PYTHON_VERSION)/site-packages
# We want our python modules installed to vendor-packages, not site-packages
PYTHON_VENDOR_DIR = /usr/lib/python$(PYTHON_VERSION)/vendor-packages

## Perl tools & paths
# When changing PERL_VERSION, check that PERL_PKG_VERSION is
# still set correctly in pkg/Makefile
PERL_VERSION = 5.22
PERL = /usr/perl5/$(PERL_VERSION)/bin/perl
# perl -p/-n commands treat missing files as warnings, not fatal errors
# Adding the following raises them to errors so that make detects a problem
PERL_MISSING_FILES_ERROR = -e 'BEGIN {$$SIG{__WARN__} = sub { die $$_[0] };}'

# Script used to install files in proto area
INSTALL_SCRIPT=$(TOP)/open-src/common/install-sh -c

# Some modules (such as FreeType 2) require GNU make
GNUMAKE = gmake

# Pick a version of GNU automake, since Solaris includes multiple ones
AUTOMAKE_VERSION=1.15

# Directory to find tools used during build, even when installing to a
# temporary dest dir, such as during 'make manifest'
PROTOTOOLSDIR       = $(PROTODIR)
PROTOTOOLS_BIN_DIR  = $(PROTODIR)/usr/bin

# Some modules use lndir to merge in sources from Sun specific directories
LNDIR           = $(PROTOTOOLS_BIN_DIR)/lndir

# Commands to run font utilities from proto area
MKFONTSCALE     = $(PROTOTOOLS_BIN_DIR)/mkfontscale
INSTALLALIAS        = $(PROTOTOOLSDIR)$(X11_X11LIB_DIR)/installalias
FC_QUERY        = $(PROTOTOOLS_BIN_DIR)/fc-query
FC_SCAN         = $(PROTOTOOLS_BIN_DIR)/fc-scan
# mkfontdir is just a shell wrapper around /usr/bin/mkfontscale, so we call
# it directly here, instead of futzing with command paths in the script
MKFONTDIR=$(MKFONTSCALE) -b -s -l

# Script fragment to start echoing commands in shell sequences in make rules
# Sets PS4 to "" so output isn't prepended with "+ " and looks like normal
# make output
START_CMD_ECHO = PS4="" ; set -x

### Sources, in-tree and upstream

TARBALLDIR=$(TOP)/open-src/tarballs
WGET=/usr/bin/wget --no-check-certificate
GIT=git

# If you need to use a closer mirror for X.Org or SourceForge, override
# these in your Makefile.options file
XRU_DEFAULT = $(XORG_RELEASES_URL_SET:yes=$(POUND_SIGN))
$(XRU_DEFAULT)  XORG_RELEASES_URL=http://www.x.org/releases/individual
SFU_DEFAULT = $(SF_DOWNLOADS_URL_SET:yes=$(POUND_SIGN))
$(SFU_DEFAULT)  SF_DOWNLOADS_URL=http://downloads.sourceforge.net/project

# Git repositories hosted on freedesktop.org (X.Org, Mesa, pixman, etc.)
FDO_GIT_DEFAULT     = $(FDO_GIT_URL_SET:yes=$(POUND_SIGN))
$(FDO_GIT_DEFAULT)  FDO_GIT_URL=http://anongit.freedesktop.org/git
XORG_GIT_DEFAULT    = $(XORG_GIT_URL_SET:yes=$(POUND_SIGN))
$(XORG_GIT_DEFAULT) XORG_GIT_URL=$(FDO_GIT_URL)/xorg

# Target created when sources are unpacked
UNPACK_FILE = .unpack_done
UNPACK_TARGET = $(SOURCE_DIR)/$(UNPACK_FILE)

# Most module versions are in the individual makefiles, but the Xserver is
# referenced in multiple places, so it's kept here for easy sharing.
#
# Current Xorg server source tarball to use sources from:
XORGSERVER_VERS=1.17.2
# Minimum Xorg server version that we expect to be ABI compatible with.
# Usually .99 of the previous minor release series, as that's the convention
# for the development snapshots of the next release series.
MIN_XSERVER_VERS=1.16.99
# Next highest Xorg server version that we expect to be ABI incompatible with.
# Usually .99 of the current release series, as Xorg tends to break ABI's
# in each minor release train (1.8, 1.9, etc.)
NEXT_XSERVER_VERS=1.18.99

# Version of pkgfmt output rules to apply
PKGFMT_OUTPUT=v2
PKGFMT= PKGFMT_OUTPUT=$(PKGFMT_OUTPUT) /usr/bin/pkgfmt

### Misc rules

# For use in debugging or calling from scripts like the code review helper
# Use such as: make print_make_vars VARS="MODTYPE MODULE_NAME"
# or: make print_make_vars BUILD_TYPE=32 VARS=SOURCE_DIR
print_make_var-%:
    @print -n ' $(@:print_make_var-%=%)="$($(@:print_make_var-%=%))"'

print_make_vars: $(VARS:%=print_make_var-%)
    @print '\n'