# # 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 2017,2022 Gary Mills # Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved. # # These symbols should be used in component Makefiles # whenever PATH is to be defined there: # PATH = $(PATH.illumos) # PATH = $(PATH.gnu) PATH.illumos = $(subst $(space),:,$(strip $(PATH.prepend))):$(USRBINDIR$(BITS)):$(USRBINDIR):$(GNUBIN):$(USRSBINDIR$(BITS)):$(USRSBINDIR) PATH.gnu = $(subst $(space),:,$(strip $(PATH.prepend))):$(GNUBIN):$(USRBINDIR$(BITS)):$(USRBINDIR):$(USRSBINDIR$(BITS)):$(USRSBINDIR) # Default PATH PATH = $(PATH.illumos) # The location of an internal mirror of community source archives that we build # in this gate. This mirror has been seeded to include "custom" source archives # for a few components where the communities either no longer provide matching # source archives or we have changes that aren't reflected in their archives or # anywhere else. #INTERNAL_ARCHIVE_MIRROR = http://userland.us.oracle.com/source-archives # The location of an external mirror of community source archives that we build # in this gate. The external mirror is a replica of the internal mirror. #EXTERNAL_ARCHIVE_MIRROR = \ # http://static.opensolaris.org/action/browse/userland/tarball/userland DLC_ARCHIVE_MIRROR = https://dlc.openindiana.org/oi-userland/source-archives # Default to looking for source archives on the internal mirror and the external # mirror before we hammer on the community source archive repositories. #export DOWNLOAD_SEARCH_PATH += $(INTERNAL_ARCHIVE_MIRROR) #export DOWNLOAD_SEARCH_PATH += $(EXTERNAL_ARCHIVE_MIRROR) # Look for file at DLC server as last resort export DOWNLOAD_FALLBACK_PATH = $(DLC_ARCHIVE_MIRROR) # The workspace starts at the mercurial root ifeq ($(origin WS_TOP), undefined) export WS_TOP := \ $(shell git rev-parse --show-toplevel || hg root 2>/dev/null) endif USERLAND_ARCHIVES ?= $(WS_TOP)/archives/ WS_MACH = $(WS_TOP)/$(MACH) WS_LOGS = $(WS_MACH)/logs WS_REPO = $(WS_MACH)/repo WS_TOOLS = $(WS_TOP)/tools WS_MAKE_RULES = $(WS_TOP)/make-rules WS_COMPONENTS = $(WS_TOP)/components WS_LICENSES = $(WS_TOP)/licenses WS_INCORPORATIONS = $(WS_TOP)/incorporations WS_LINT_CACHE = $(WS_MACH)/pkglint-cache # we want our pkg piplines to fail if there is an error # (like if pkgdepend fails in the middle of a pipe), but # we don't want the builds or ./configure's failing as well. # so we only set pipefail for the publish target and have # to reset it for the others since they might be invoked # as dependencies of publish. export SHELLOPTS build: SHELLOPTS= test: SHELLOPTS= install: SHELLOPTS= publish: SHELLOPTS=pipefail SHELL= /bin/bash # This can be overridden to avoid rebuilding when you touch a Makefile MAKEFILE_PREREQ = Makefile CONSOLIDATION = userland PUBLISHER ?= $(CONSOLIDATION) PUBLISHER_LOCALIZABLE ?= $(CONSOLIDATION)-localizable # Defines $(space) as a single blank space, so we can use it to convert # space-separated paths to colon-separated paths in variables with # $(subst $(space),:,$(strip $(SPATHS))) empty := space := $(empty) $(empty) # Define $(comma) as single comma so we can use it in text transforming functions comma = , # Define $(newline) as single newline so we can embed newline into make variables define newline endef ROOT = / # Distribution name and version # Note, this determines /etc/release file contents. # Some OI-specific software (like slim installer or openindiana-welcome) # currently rely on format of first line in this file # to determine the distribution version # (it should look like OpenIndiana Hipster YYYY.MM). DISTRIBUTION_NAME = OpenIndiana Hipster DISTRIBUTION_VERSION = 2024.10 # Native OS version OS_VERSION := $(shell uname -r) SOLARIS_VERSION = $(OS_VERSION:5.%=2.%) # Target OS version PKG_SOLARIS_VERSION ?= 5.11 PKG_OS_VERSION ?= 0.$(PKG_SOLARIS_VERSION) # GNU target triplet GNU_TRIPLET=$(GNU_CPU)-$(GNU_VENDOR)-$(GNU_OS) # The cpu part of the triplet is basically the same as $(MACH): # i386 - for x86 and GCC version older than 9 # x86_64 - for x86 and GCC version 9 and newer # sparc - for SPARC GNU_CPU = $(if $(filter $(GCC_VERSION),3 4 7),$(MACH),$(MACH:i386=x86_64)) # The vendor part of the triplet is: # pc - for x86 # sun - for SPARC GNU_VENDOR.i386 = pc GNU_VENDOR.sparc = sun GNU_VENDOR = $(GNU_VENDOR.$(MACH)) # The os part of the triplet is solaris2.11 GNU_OS = solaris$(SOLARIS_VERSION) include $(WS_MAKE_RULES)/ips-buildinfo.mk COMPILER = gcc LINKER = gcc # The value of BITS is set automatically during the build process to either 32 # or 64 as needed. # This macro makes it possible to determine which components are only built # 64-bit (default) and allow other make-rules files to adjust accordingly. # Possible values are: '32', '64', '32_and_64', '64_and_32', and 'NO_ARCH' (the # orderings specify build preference). BUILD_BITS ?= 64 # Based on BUILD_BITS, determine which binaries are preferred for a build. # This macro is for the convenience of other make-rules files and should not be # overridden by developers. ifeq ($(strip $(BUILD_BITS)),64) PREFERRED_BITS=64 endif # Now we prefer 64-bit ifeq ($(strip $(BUILD_BITS)),64_and_32) PREFERRED_BITS=64 endif PREFERRED_BITS ?= 32 # Map target build to macro/variable naming conventions. This macro is for the # convenience of other make-rules files and should not be overridden by # developers. ifeq ($(BUILD_BITS),64_and_32) MK_BITS=32_and_64 else MK_BITS=$(strip $(BUILD_BITS)) endif # # Upstream support for Python is by default 5 years after the first release. # We will start to obsolete Python versions according the following table: # # +----------------+----------------+ # | Python version | Obsolete after | # +----------------+----------------+ # | 3.9 | 2025-10 | # +----------------+----------------+ # # See https://devguide.python.org/versions/ # PYTHON_VERSION = 3.9 PYTHON_VERSIONS = 3.9 # Python up to 2.7 was built both 32-bit and 64-bit. Starting with Python 3.x # the python package is built 64-bit only. So now all PYTHON_VERSIONS are # 64-bit only. PYTHON_64_ONLY_VERSIONS = $(PYTHON_VERSIONS) # List of python versions we are currently obsoleting. We no longer build any # packages for these python versions, but there still might be hanging some not # obsoleted yet versioned packages built for PYTHON_VERSIONS_OBSOLETING python # versions. Or there is just the versioned runtime/python package still # available. # # This list should be usually empty. Intersection of # PYTHON_VERSIONS_OBSOLETING and PYTHON_VERSIONS lists MUST be always empty. PYTHON_VERSIONS_OBSOLETING = 2.7 3.7 # PYTHON3_SOABI variable defines the naming scheme # of python3 extension libraries: cpython or abi3. # Currently, most of the components use cpython naming scheme by default, # only python/xattr and python/cryptography require abi3 naming. PYTHON3_SOABI ?= cpython ifeq ($(PYTHON3_SOABI),cpython) PY3_CPYTHON_NAMING= PY3_ABI3_NAMING=\# else ifeq ($(PYTHON3_SOABI),abi3) PY3_CPYTHON_NAMING=\# PY3_ABI3_NAMING= else $(error "Invalid python naming scheme '$(PYTHON3_SOABI)' selected!") endif BASS_O_MATIC = $(WS_TOOLS)/bass-o-matic CLONEY = $(WS_TOOLS)/cloney CONFIG_SHELL = /bin/bash PKG_REPO = file:$(WS_REPO) COMPONENT = $(COMPONENT_DIR:$(WS_TOP)/components/%=%) HUMAN_VERSION ?= $(COMPONENT_VERSION) COMPONENT_SRC_NAME = $(COMPONENT_NAME) COMPONENT_LICENSE_FILE ?= $(COMPONENT_NAME).license COMPONENT_DIR := $(shell pwd) SOURCE_DIR = $(COMPONENT_DIR)/$(COMPONENT_SRC) BUILD_DIR = $(COMPONENT_DIR)/build PROTO_DIR = $(BUILD_DIR)/prototype/$(MACH) ARCHLIBSUBDIR32 = ARCHLIBSUBDIR64 = $(MACH64) ARCHLIBSUBDIR = $(ARCHLIBSUBDIR$(BITS)) ETCDIR = /etc USRDIR = /usr BINDIR = /bin SBINDIR = /sbin LIBDIR = /lib LIBEXECDIR = /libexec VARDIR = /var KERNELDRVDIR = /kernel/drv KERNELDRVDIR32 = /kernel/drv KERNELDRVDIR64 = /kernel/drv/$(MACH64) USRBINDIR = $(USRDIR)/bin USRBINDIR32 = $(USRDIR)/bin/$(MACH32) USRBINDIR64 = $(USRDIR)/bin/$(MACH64) USRSBINDIR = $(USRDIR)/sbin USRSBINDIR32 = $(USRDIR)/sbin/$(MACH32) USRSBINDIR64 = $(USRDIR)/sbin/$(MACH64) USRLIBDIR = $(USRDIR)/lib USRLIBDIR32 = $(USRDIR)/lib USRLIBDIR64 = $(USRDIR)/lib/$(MACH64) USRLIBEXECDIR = $(USRDIR)/libexec USRLIBEXECDIR32 = $(USRDIR)/libexec USRLIBEXECDIR64 = $(USRDIR)/libexec/$(MACH64) USRSHAREDIR = $(USRDIR)/share USRINCDIR = $(USRDIR)/include USRSHARELOCALEDIR = $(USRSHAREDIR)/locale USRSHAREMANDIR = $(USRSHAREDIR)/man USRSHAREDOCDIR = $(USRSHAREDIR)/doc USRSHARELIBDIR = $(USRSHAREDIR)/lib USRSHAREMAN1DIR = $(USRSHAREMANDIR)/man1 USRSHAREMAN1MDIR = $(USRSHAREMANDIR)/man1m USRSHAREMAN3DIR = $(USRSHAREMANDIR)/man3 USRSHAREMAN4DIR = $(USRSHAREMANDIR)/man4 USRSHAREMAN5DIR = $(USRSHAREMANDIR)/man5 USRSHAREMAN7DIR = $(USRSHAREMANDIR)/man7 USRSHAREMAN8DIR = $(USRSHAREMANDIR)/man8 USRKERNELDRVDIR = $(USRDIR)/kernel/drv USRKERNELDRVDIR32 = $(USRDIR)/kernel/drv USRKERNELDRVDIR64 = $(USRDIR)/kernel/drv/$(MACH64) # The *.$(BITS) variables are different from those above (better suited for # isaexec wrapper), and allow for default 32-bit vs. nondefault 64-bit setups USRBINDIR.32 = $(USRBINDIR) USRBINDIR.64 = $(USRBINDIR64) USRSBINDIR.32 = $(USRSBINDIR) USRSBINDIR.64 = $(USRSBINDIR64) USRLIBDIR.32 = $(USRLIBDIR) USRLIBDIR.64 = $(USRLIBDIR64) USRLIBEXECDIR.32 = $(USRLIBEXECDIR) USRLIBEXECDIR.64 = $(USRLIBEXECDIR64) PROTOETCDIR = $(PROTO_DIR)/$(ETCDIR) PROTOETCSECDIR = $(PROTO_DIR)/$(ETCDIR)/security PROTOUSRDIR = $(PROTO_DIR)/$(USRDIR) PROTOBINDIR = $(PROTO_DIR)/$(BINDIR) PROTOSBINDIR = $(PROTO_DIR)/$(SBINDIR) PROTOLIBDIR = $(PROTO_DIR)/$(LIBDIR) PROTOLIBEXECDIR = $(PROTO_DIR)/$(LIBEXECDIR) PROTOVARDIR = $(PROTO_DIR)/$(VARDIR) PROTOKERNELDRVDIR = $(PROTO_DIR)/$(KERNELDRVDIR) PROTOKERNELDRVDIR32 = $(PROTO_DIR)/$(KERNELDRVDIR32) PROTOKERNELDRVDIR64 = $(PROTO_DIR)/$(KERNELDRVDIR64) PROTOUSRBINDIR = $(PROTO_DIR)/$(USRBINDIR) PROTOUSRBINDIR32 = $(PROTO_DIR)/$(USRBINDIR32) PROTOUSRBINDIR64 = $(PROTO_DIR)/$(USRBINDIR64) PROTOUSRSBINDIR = $(PROTO_DIR)/$(USRSBINDIR) PROTOUSRSBINDIR32 = $(PROTO_DIR)/$(USRSBINDIR32) PROTOUSRSBINDIR64 = $(PROTO_DIR)/$(USRSBINDIR64) PROTOUSRLIBDIR = $(PROTO_DIR)/$(USRLIBDIR) PROTOUSRLIBDIR32 = $(PROTO_DIR)/$(USRLIBDIR32) PROTOUSRLIBDIR64 = $(PROTO_DIR)/$(USRLIBDIR64) PROTOUSRLIBEXECDIR = $(PROTO_DIR)/$(USRLIBEXECDIR) PROTOUSRLIBEXECDIR32 = $(PROTO_DIR)/$(USRLIBEXECDIR32) PROTOUSRLIBEXECDIR64 = $(PROTO_DIR)/$(USRLIBEXECDIR64) PROTOUSRINCDIR = $(PROTO_DIR)/$(USRINCDIR) PROTOUSRSHAREDIR = $(PROTO_DIR)/$(USRSHAREDIR) PROTOUSRSHARELIBDIR = $(PROTO_DIR)/$(USRSHARELIBDIR) PROTOUSRSHAREMANDIR = $(PROTO_DIR)/$(USRSHAREMANDIR) PROTOUSRSHAREDOCDIR = $(PROTO_DIR)/$(USRSHAREDOCDIR) PROTOUSRSHAREMAN1DIR = $(PROTO_DIR)/$(USRSHAREMAN1DIR) PROTOUSRSHAREMAN1MDIR = $(PROTO_DIR)/$(USRSHAREMAN1MDIR) PROTOUSRSHAREMAN3DIR = $(PROTO_DIR)/$(USRSHAREMAN3DIR) PROTOUSRSHAREMAN4DIR = $(PROTO_DIR)/$(USRSHAREMAN4DIR) PROTOUSRSHAREMAN5DIR = $(PROTO_DIR)/$(USRSHAREMAN5DIR) PROTOUSRSHAREMAN8DIR = $(PROTO_DIR)/$(USRSHAREMAN8DIR) PROTOUSRSHARELOCALEDIR = $(PROTO_DIR)/$(USRSHARELOCALEDIR) PROTOUSRKERNELDRVDIR = $(PROTO_DIR)/$(USRKERNELDRVDIR) PROTOUSRKERNELDRVDIR32 = $(PROTO_DIR)/$(USRKERNELDRVDIR32) PROTOUSRKERNELDRVDIR64 = $(PROTO_DIR)/$(USRKERNELDRVDIR64) PROTOUSRBINDIR.32 = $(PROTOUSRBINDIR) PROTOUSRBINDIR.64 = $(PROTOUSRBINDIR64) PROTOUSRSBINDIR.32 = $(PROTOUSRSBINDIR) PROTOUSRSBINDIR.64 = $(PROTOUSRSBINDIR64) PROTOUSRLIBDIR.32 = $(PROTOUSRLIBDIR) PROTOUSRLIBDIR.64 = $(PROTOUSRLIBDIR64) PROTOUSRLIBEXECDIR.32 = $(PROTOUSRLIBEXECDIR) PROTOUSRLIBEXECDIR.64 = $(PROTOUSRLIBEXECDIR64) # NOTE: We do not build SFW contents # /usr/sfw/bin is just a historic artefact, containing symlinks SFWBIN = /usr/sfw/bin SFWBIN32 = $(SFWBIN) SFWBIN64 = $(SFWBIN)/$(MACH64) SFWSBIN = /usr/sfw/sbin SFWSBIN32 = $(SFWSBIN) SFWSBIN64 = $(SFWSBIN)/$(MACH64) SFWINCLUDE = /usr/sfw/include SFWLIB = /usr/sfw/lib SFWLIB32 = $(SFWLIB) SFWLIB64 = $(SFWLIB)/$(MACH64) SFWSHARE = /usr/sfw/share SFWSHAREMAN = $(SFWSHARE)/man SFWSHAREMAN1 = $(SFWSHAREMAN)/man1 PROTOSFWBIN = $(PROTO_DIR)/$(SFWBIN) PROTOSFWBIN32 = $(PROTO_DIR)/$(SFWBIN32) PROTOSFWBIN64 = $(PROTO_DIR)/$(SFWBIN64) PROTOSFWSBIN = $(PROTO_DIR)/$(SFWSBIN) PROTOSFWSBIN32 = $(PROTO_DIR)/$(SFWSBIN32) PROTOSFWSBIN64 = $(PROTO_DIR)/$(SFWSBIN64) PROTOSFWLIB = $(PROTO_DIR)/$(SFWLIB) PROTOSFWLIB32 = $(PROTO_DIR)/$(SFWLIB32) PROTOSFWLIB64 = $(PROTO_DIR)/$(SFWLIB64) PROTOSFWSHARE = $(PROTO_DIR)/$(SFWSHARE) PROTOSFWSHAREMAN = $(PROTO_DIR)/$(SFWSHAREMAN) PROTOSFWSHAREMAN1 = $(PROTO_DIR)/$(SFWSHAREMAN1) PROTOSFWINCLUDE = $(PROTO_DIR)/$(SFWINCLUDE) # The *.$(BITS) variables are different from those above (better suited for # isaexec wrapper), and allow for default 32-bit vs. nondefault 64-bit setups SFWBIN.32 = $(SFWBIN) SFWBIN.64 = $(SFWBIN64) SFWSBIN.32 = $(SFWSBIN) SFWSBIN.64 = $(SFWSBIN64) SFWLIB.32 = $(SFWLIB) SFWLIB.64 = $(SFWLIB64) PROTOSFWBIN.32 = $(PROTOSFWBIN) PROTOSFWBIN.64 = $(PROTOSFWBIN64) PROTOSFWSBIN.32 = $(PROTOSFWSBIN) PROTOSFWSBIN.64 = $(PROTOSFWSBIN64) PROTOSFWLIB.32 = $(PROTOSFWLIB) PROTOSFWLIB.64 = $(PROTOSFWLIB64) CLDIR = /usr/share/common-lisp PROTOCLDIR = $(PROTO_DIR)/$(CLDIR) GNUDIR = /usr/gnu GNUBIN = $(GNUDIR)/bin GNUBIN32 = $(GNUBIN)/$(MACH32) GNUBIN64 = $(GNUBIN)/$(MACH64) GNUSBIN = $(GNUDIR)/sbin GNUSBIN32 = $(GNUSBIN)/$(MACH32) GNUSBIN64 = $(GNUSBIN)/$(MACH64) GNULIB = $(GNUDIR)/lib GNULIB32 = $(GNULIB) GNULIB64 = $(GNULIB)/$(MACH64) GNUSHARE = $(GNUDIR)/share GNUSHAREMAN = $(GNUSHARE)/man GNUSHAREMAN1 = $(GNUSHAREMAN)/man1 PROTOGNUBIN = $(PROTO_DIR)/$(GNUBIN) PROTOGNUBIN32 = $(PROTO_DIR)/$(GNUBIN32) PROTOGNUBIN64 = $(PROTO_DIR)/$(GNUBIN64) PROTOGNUSBIN = $(PROTO_DIR)/$(GNUSBIN) PROTOGNUSBIN32 = $(PROTO_DIR)/$(GNUSBIN32) PROTOGNUSBIN64 = $(PROTO_DIR)/$(GNUSBIN64) PROTOGNULIB = $(PROTO_DIR)/$(GNULIB) PROTOGNULIB32 = $(PROTO_DIR)/$(GNULIB32) PROTOGNULIB64 = $(PROTO_DIR)/$(GNULIB64) PROTOGNUSHARE = $(PROTO_DIR)/$(GNUSHARE) PROTOGNUSHAREMAN = $(PROTO_DIR)/$(GNUSHAREMAN) PROTOGNUSHAREMAN1 = $(PROTO_DIR)/$(GNUSHAREMAN1) # The *.$(BITS) variables are different from those above (better suited for # isaexec wrapper), and allow for default 32-bit vs. nondefault 64-bit setups GNUBIN.32 = $(GNUBIN) GNUBIN.64 = $(GNUBIN64) GNUSBIN.32 = $(GNUSBIN) GNUSBIN.64 = $(GNUSBIN64) GNULIB.32 = $(GNULIB) GNULIB.64 = $(GNULIB64) PROTOGNUBIN.32 = $(PROTOGNUBIN) PROTOGNUBIN.64 = $(PROTOGNUBIN64) PROTOGNUSBIN.32 = $(PROTOGNUSBIN) PROTOGNUSBIN.64 = $(PROTOGNUSBIN64) PROTOGNULIB.32 = $(PROTOGNULIB) PROTOGNULIB.64 = $(PROTOGNULIB64) # 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 {CONFIGURE|BUILD|INSTALL}_ENV CONSTANT_TIME = LD_PRELOAD_32=$(WS_TOOLS)/time-$(MACH32).so CONSTANT_TIME += LD_PRELOAD_64=$(WS_TOOLS)/time-$(MACH64).so CONSTANT_TIME += TIME_CONSTANT=$(TIME_CONSTANT) # List known architectures MACH_LIST = sparc i386 # set MACH from uname -p to either sparc or i386 MACH := $(shell uname -p) # set MACH32 from MACH to either sparcv7 or i86 MACH32_1 = $(MACH:sparc=sparcv7) MACH32 = $(MACH32_1:i386=i86) # set MACH64 from MACH to either sparcv9 or amd64 MACH64_1 = $(MACH:sparc=sparcv9) MACH64 = $(MACH64_1:i386=amd64) CONFIGURE_NO_ARCH = $(BUILD_DIR_NO_ARCH)/.configured CONFIGURE_32 = $(BUILD_DIR_32)/.configured CONFIGURE_64 = $(BUILD_DIR_64)/.configured BUILD_DIR_NO_ARCH = $(BUILD_DIR)/$(MACH) BUILD_DIR_32 = $(BUILD_DIR)/$(MACH32) BUILD_DIR_64 = $(BUILD_DIR)/$(MACH64) BUILD_NO_ARCH = $(BUILD_DIR_NO_ARCH)/.built BUILD_32 = $(BUILD_DIR_32)/.built BUILD_64 = $(BUILD_DIR_64)/.built BUILD_32_and_64 = $(BUILD_32) $(BUILD_64) $(BUILD_DIR_NO_ARCH)/.built: BITS=32 $(BUILD_DIR_32)/.built: BITS=32 $(BUILD_DIR_64)/.built: BITS=64 INSTALL_NO_ARCH = $(BUILD_DIR_NO_ARCH)/.installed INSTALL_32 = $(BUILD_DIR_32)/.installed INSTALL_64 = $(BUILD_DIR_64)/.installed INSTALL_32_and_64 = $(INSTALL_32) $(INSTALL_64) $(BUILD_DIR_32)/.installed: BITS=32 $(BUILD_DIR_64)/.installed: BITS=64 # If we are building both 32 and 64 bit then make sure we install in the # desired order: the preferred one last ifeq ($(strip $(BUILD_BITS)),64_and_32) $(INSTALL_64): $(INSTALL_32) endif ifeq ($(strip $(BUILD_BITS)),32_and_64) $(INSTALL_32): $(INSTALL_64) endif # set the default target for installation of the component COMPONENT_INSTALL_TARGETS = install # set the default build test results directory COMPONENT_TEST_BUILD_DIR = $(BUILD_DIR)/test/$(MACH$(BITS)) # set the default master test results directory COMPONENT_TEST_RESULTS_DIR = $(COMPONENT_DIR)/test # set the default master test results file USE_COMMON_TEST_MASTER ?= yes ifeq ($(strip $(USE_COMMON_TEST_MASTER)),yes) COMPONENT_TEST_MASTER = $(COMPONENT_TEST_RESULTS_DIR)/results-all.master else COMPONENT_TEST_MASTER = $(COMPONENT_TEST_RESULTS_DIR)/results-$(BITS).master endif # set the default test results output file COMPONENT_TEST_OUTPUT = $(COMPONENT_TEST_BUILD_DIR)/test-$(BITS)-results # set the default test results comparison diffs file COMPONENT_TEST_DIFFS = $(COMPONENT_TEST_BUILD_DIR)/test-$(BITS)-diffs # set the default test snapshot file COMPONENT_TEST_SNAPSHOT = $(COMPONENT_TEST_BUILD_DIR)/results-$(BITS).snapshot # Normally $(GSED) is simplest, but some results files need more power. COMPONENT_TEST_TRANSFORMER = $(GSED) # The set of default transforms to be applied to the test results to try # to normalize them. COMPONENT_TEST_TRANSFORMS = \ '-e "s|$(@D)|\\$$(@D)|g" ' \ '-e "s|$(PERL)|\\$$(PERL)|g" ' \ '-e "s|$(PYTHON)|\\$$(PYTHON)|g" ' \ '-e "s|$(SOURCE_DIR)|\\$$(SOURCE_DIR)|g" ' COMPONENT_TEST_TRANSFORMS += "-e 's|$(PROTO_DIR)|\$$(PROTO_DIR)|g'" COMPONENT_TEST_TRANSFORMS += "-e 's|$(BUILD_DIR)|\$$(BUILD_DIR)|g'" # set the default commands used to generate the file containing the set # of transforms to be applied to the test results to try to normalize them. COMPONENT_TEST_CREATE_TRANSFORMS = \ print "\#!/bin/sh" > $(COMPONENT_TEST_TRANSFORM_CMD); \ print '$(CAT) $(COMPONENT_TEST_OUTPUT) | \\' \ >> $(COMPONENT_TEST_TRANSFORM_CMD); \ print '$(COMPONENT_TEST_TRANSFORMER) ' \ $(COMPONENT_TEST_TRANSFORMS) \ ' \\' >> $(COMPONENT_TEST_TRANSFORM_CMD); \ print '> $(COMPONENT_TEST_SNAPSHOT)' \ >> $(COMPONENT_TEST_TRANSFORM_CMD); \ # set the default command for performing any test result munging COMPONENT_TEST_TRANSFORM_CMD = $(COMPONENT_TEST_BUILD_DIR)/transform-$(BITS)-results # set the default operation to run to perform test result normalization COMPONENT_TEST_PERFORM_TRANSFORM = \ $(SHELL) $(COMPONENT_TEST_TRANSFORM_CMD); \ # set the default command used to compare the master results with the snapshot COMPONENT_TEST_COMPARE_CMD = $(GDIFF) -uNb # set the default way that master and snapshot test results are compared COMPONENT_TEST_COMPARE = \ [ -e $(COMPONENT_TEST_MASTER) ] || exit 1; \ $(COMPONENT_TEST_COMPARE_CMD) \ $(COMPONENT_TEST_MASTER) $(COMPONENT_TEST_SNAPSHOT) \ > $(COMPONENT_TEST_DIFFS); \ print "Test results in $(COMPONENT_TEST_OUTPUT)"; \ if [ -s $(COMPONENT_TEST_DIFFS) ]; \ then \ print "Differences found."; \ $(CAT) $(COMPONENT_TEST_DIFFS); \ exit 2; \ else \ print "No differences found."; \ fi # set the default env command to use for test of the component COMPONENT_TEST_ENV_CMD = $(ENV) # set the default command to use for test of the component COMPONENT_TEST_CMD = $(GMAKE) # set the default target for test of the component COMPONENT_TEST_TARGETS = check # set the default directory for test of the component COMPONENT_TEST_DIR = $(@D) # prepare the testing environment before we run tests COMPONENT_TEST_DEP += component-test-environment-prep # we test built components COMPONENT_TEST_DEP += $(BUILD_DIR)/%/.built # determine the type of tests we want to run. ifeq ($(strip $(wildcard $(COMPONENT_TEST_RESULTS_DIR)/results-*.master)),) TEST_NO_ARCH = $(BUILD_DIR_NO_ARCH)/.tested TEST_32 = $(BUILD_DIR_32)/.tested TEST_64 = $(BUILD_DIR_64)/.tested else TEST_NO_ARCH = $(BUILD_DIR_NO_ARCH)/.tested-and-compared TEST_32 = $(BUILD_DIR_32)/.tested-and-compared TEST_64 = $(BUILD_DIR_64)/.tested-and-compared endif TEST_32_and_64 = $(TEST_32) $(TEST_64) $(BUILD_DIR_NO_ARCH)/.tested-and-compared: BITS=32 $(BUILD_DIR_32)/.tested: BITS=32 $(BUILD_DIR_64)/.tested: BITS=64 $(BUILD_DIR_32)/.tested-and-compared: BITS=32 $(BUILD_DIR_64)/.tested-and-compared: BITS=64 # BUILD_TOOLS is the root of all tools not normally installed on the system. BUILD_TOOLS ?= /opt # # The CCACHE makefile variable should evaluate to empty string or a pathname # like /usr/bin/ccache depending on your PATH value and "which" implementation. # The assignment via ":=" is important, to only do this once in a Makefile, # and not on every reference to the value as "=" assignment would result in. # Review `man ccache` for optional configuration tuning, like cache size etc. # # For production builds or suspected errors you can disable this feature by # setting ENABLE_CCACHE=false (as makefile or environment variable, which # is currently the default) to not even define the usage of wrapper in the # userland-building makefile system. # If you want to speed up your re-builds, you must set ENABLE_CCACHE=true. # For legacy reasons, the CCACHE_DISABLE and CCACHE_NODISABLE variables (from # configuration of the "ccache" program itself) are also supported, but direct # use is discouraged, since their syntax and usage are counter-intuitive. # # Still, absence of ccache in PATH is not considered a fatal error since the # build would just proceed well with original compiler. # Note: In code below we fast-track if the makefile CCACHE variable is defined # but fall back to shell executability tests if just envvar CCACHE is passed. # export CCACHE := $(shell \ if test -n "$(CCACHE)" ; then \ echo "$(CCACHE)"; \ else \ if test x"$${CCACHE_DISABLE-}" != x -o x"$(CCACHE_DISABLE)" != x \ -o x"$${ENABLE_CCACHE-}" = xfalse -o x"$(ENABLE_CCACHE)" = xfalse \ ; then \ echo "NOT USING CCACHE FOR OI-USERLAND because explicitly disabled" >&2 ; \ else \ if test x"$${CCACHE_NODISABLE-}" != x -o x"$(CCACHE_NODISABLE)" != x \ -o x"$${ENABLE_CCACHE-}" = xtrue -o x"$(ENABLE_CCACHE)" = xtrue \ ; then \ for F in \ "$$CCACHE" \ `which ccache 2>/dev/null | egrep '^/'` \ /usr/bin/ccache \ ; do if test -n "$$F" && test -x "$$F" ; then \ echo "$$F" ; \ echo "USING CCACHE FOR OI-USERLAND: $$F" >&2 ; \ if test x"$${CCACHE_DISABLE-}" != x ; then \ echo "WARNING: envvar CCACHE_DISABLE is set, so effectively ccache will not act!" >&2 ; \ fi; \ exit 0; \ fi; \ done; \ echo "NOT USING CCACHE FOR OI-USERLAND because not found" >&2 ; \ fi; \ fi; \ fi) GCC_DEFAULT = 13 GCC_VERSION ?= $(GCC_DEFAULT) GCC_ROOT = /usr/gcc/$(GCC_VERSION) # If a component asked for non-default gcc version we need to make sure it is # installed USERLAND_REQUIRED_PACKAGES += $(if $(filter-out $(GCC_DEFAULT),$(GCC_VERSION)),developer/gcc-$(GCC_VERSION)) # Define runtime package names to be used in dependencies GCC_RUNTIME_PKG = system/library/gcc-$(GCC_VERSION)-runtime GXX_RUNTIME_PKG = system/library/g++-$(GCC_VERSION)-runtime GCCGO_RUNTIME_PKG = system/library/gccgo-$(GCC_VERSION)-runtime GFORTRAN_RUNTIME_PKG = system/library/gfortran-$(GCC_VERSION)-runtime GOBJC_RUNTIME_PKG = system/library/gobjc-$(GCC_VERSION)-runtime CC.gcc.32 = $(GCC_ROOT)/bin/gcc CXX.gcc.32 = $(GCC_ROOT)/bin/g++ F77.gcc.32 = $(GCC_ROOT)/bin/gfortran FC.gcc.32 = $(GCC_ROOT)/bin/gfortran CC.gcc.64 = $(GCC_ROOT)/bin/gcc CXX.gcc.64 = $(GCC_ROOT)/bin/g++ F77.gcc.64 = $(GCC_ROOT)/bin/gfortran FC.gcc.64 = $(GCC_ROOT)/bin/gfortran # GCC directory macros GCC_FULL_VERSION = $(shell $(GCC_ROOT)/bin/gcc -dumpversion) GCC_GNU_TRIPLET = $(GNU_TRIPLET) GCC_BINDIR = $(GCC_ROOT)/bin GCC_LIBDIR.32 = $(GCC_ROOT)/lib GCC_LIBDIR.64 = $(GCC_ROOT)/lib/$(MACH64) GCC_LIBDIR = $(GCC_LIBDIR.$(BITS)) GCC_INCDIR = $(GCC_ROOT)/include GCC_LIBGCCDIR = $(GCC_ROOT)/lib/gcc GCC_INCGXXDIR = $(GCC_ROOT)/include/c++/$(GCC_FULL_VERSION) PATH.prepend += $(GCC_BINDIR) ifneq ($(strip $(CCACHE)),) CCACHE_WRAP_ROOT = $(WS_TOOLS)/ccache-wrap export CC_gcc_32 := $(CC.gcc.32) export CC_gcc_64 := $(CC.gcc.64) export CXX_gcc_32 := $(CXX.gcc.32) export CXX_gcc_64 := $(CXX.gcc.64) CC.gcc.32 := $(CCACHE_WRAP_ROOT)/CC.gcc.32 CC.gcc.64 := $(CCACHE_WRAP_ROOT)/CC.gcc.64 CXX.gcc.32 := $(CCACHE_WRAP_ROOT)/CXX.gcc.32 CXX.gcc.64 := $(CCACHE_WRAP_ROOT)/CXX.gcc.64 ifneq ($(strip $(CCACHE_DIR)),) export CCACHE_DIR := $(CCACHE_DIR) endif ifneq ($(strip $(CCACHE_LOGFILE)),) export CCACHE_LOGFILE := $(CCACHE_LOGFILE) endif endif LD = /usr/bin/ld # Clang definitions (we only have 64 bit clang) CLANG_DEFAULT = 18 CLANG_VERSION ?= $(CLANG_DEFAULT) CLANG_PREFIX = /usr/clang/$(CLANG_VERSION) CLANG_BINDIR = $(CLANG_PREFIX)/bin CLANG_LIBDIR = $(CLANG_PREFIX)/lib CLANG_DEVELOPER_PKG = developer/clang-$(CLANG_VERSION) CLANG_RUNTIME_PKG = runtime/clang-$(CLANG_VERSION) REQUIRED_PACKAGES_SUBST += CLANG_DEVELOPER_PKG REQUIRED_PACKAGES_SUBST += CLANG_RUNTIME_PKG PATH.prepend += $(CLANG_BINDIR) # If a component asked for non-default clang version we need to make sure it is # installed USERLAND_REQUIRED_PACKAGES += $(if $(filter-out $(CLANG_DEFAULT),$(CLANG_VERSION)),$(CLANG_DEVELOPER_PKG)) # Python definitions PYTHON.3.9.VENDOR_PACKAGES.64 = /usr/lib/python3.9/vendor-packages PYTHON.3.9.VENDOR_PACKAGES.32 = /usr/lib/python3.9/vendor-packages PYTHON.3.9.VENDOR_PACKAGES = $(PYTHON.3.9.VENDOR_PACKAGES.$(BITS)) CC = $(CC.$(COMPILER).$(BITS)) CXX = $(CXX.$(COMPILER).$(BITS)) F77 = $(F77.$(COMPILER).$(BITS)) FC = $(FC.$(COMPILER).$(BITS)) # # We will start to obsolete major Ruby versions according the following table: # # +--------------+----------------+ # | Ruby version | Obsolete after | # +--------------+----------------+ # | 2.3 | 2019-03-31 | # | 3.2 | 2026-03-31 | # +--------------+----------------+ # # See https://www.ruby-lang.org/en/downloads/branches/ # RUBY_VERSION = 3.2 RUBY_LIB_VERSION.2.3 = 2.3.0 RUBY_LIB_VERSION.3.2 = 3.2.0 RUBY.2.3 = /usr/ruby/2.3/bin/ruby RUBY.3.2 = /usr/ruby/3.2/bin/ruby RUBY = $(RUBY.$(RUBY_VERSION)) RUBY_LIB_VERSION = $(RUBY_LIB_VERSION.$(RUBY_VERSION)) # Transform Ruby scripts to call the supported # version-specific ruby; used in multiple *.mk files RUBY_SCRIPT_FIX_FUNC = \ $(GNU_GREP) -Rl '^\#! */usr/bin/env ruby' | \ /usr/bin/xargs -I\{\} $(GSED) -i -e \ '1s%^\#! */usr/bin/env ruby%\#!/usr/ruby/$(RUBY_VERSION)/bin/ruby%' \ \{\} # Use the ruby lib versions to represent the RUBY_VERSIONS that # need to get built. This is done because during package transformations # both the ruby version and the ruby library version are needed. RUBY_VERSIONS = $(RUBY_LIB_VERSION) PYTHON_VENDOR_PACKAGES.32 = $(PYTHON.$(PYTHON_VERSION).VENDOR_PACKAGES.32) PYTHON_VENDOR_PACKAGES.64 = $(PYTHON.$(PYTHON_VERSION).VENDOR_PACKAGES.64) PYTHON_VENDOR_PACKAGES = $(PYTHON_VENDOR_PACKAGES.$(BITS)) # python2 was built for both 32- and 64-bits. # python3 is built for 64-bits only. PYTHON.3.9 = /usr/bin/python3.9 PYTHON.3.9.64 = $(PYTHON.3.9) PYTHON.64 = $(PYTHON.$(PYTHON_VERSION).64) PYTHON = $(PYTHON.$(PYTHON_VERSION)) TOX.3.9 = /usr/bin/tox-3.9 TOX = $(TOX.$(PYTHON_VERSION)) # The default is site-packages, but that directory belongs to the end-user. # Modules which are shipped by the OS but not with the core Python distribution # belong in vendor-packages. PYTHON_DIR= /usr/lib/python$(PYTHON_VERSION) PYTHON_LIB= $(PYTHON_DIR)/vendor-packages PYTHON_DATA= $(PYTHON_LIB) # If the component has python scripts then the first line should probably # point at the python version currently set by the $(PYTHON) variable so # as not to be influenced by the ips python mediator. # In the component's Makefile define PYTHON_SCRIPTS with a list of files # to be edited. # Edit the leading #!/usr/bin/python line in python scripts to use the # BUILD's $(PYTHON). The source file must be recompiled after that, as # the corresponding .pyc file is outdated now. PYTHON_SCRIPT_SHEBANG_FIX_FUNC = \ $(GSED) -i \ -e '1s@/usr/bin/python3\{0,1\}$$@$(PYTHON)@' \ -e '1s@/usr/bin/python3\{0,1\} @$(PYTHON) @' \ -e '1s@/usr/bin/env python3\.[0-9]\{1,\}@$(PYTHON)@' \ -e '1s@/usr/bin/env python3\{0,1\}@$(PYTHON)@' \ $(PROTO_DIR)/$(1); \ $(PYTHON) -m compileall $(PROTO_DIR)/$(1); # PYTHON_SCRIPTS is a list of files from the calling Makefile. PYTHON_SCRIPTS_PROCESS= \ $(foreach s,$(PYTHON_SCRIPTS), \ $(call PYTHON_SCRIPT_SHEBANG_FIX_FUNC,$(s))) # Finally if PYTHON_SCRIPTS is defined in a Makefile then process them here. # If multiple installs in the component then clear # COMPONENT_POST_INSTALL_ACTION = # and re-add $(PYTHON_SCRIPTS_PROCESS) COMPONENT_POST_INSTALL_ACTION += $(PYTHON_SCRIPTS_PROCESS) JAVA8_HOME = /usr/jdk/openjdk1.8.0 JAVA11_HOME = /usr/jdk/openjdk11 JAVA17_HOME = /usr/jdk/openjdk17 JAVA21_HOME = /usr/jdk/openjdk21 JAVA_HOME = $(JAVA17_HOME) # QT macros # We deliver version 5 in 32- and 64-bit variants. QT5_VERSION = 5.15 QT5_BASEDIR = $(USRLIBDIR)/qt/$(QT5_VERSION) QT5_BINDIR.32 = $(QT5_BASEDIR)/bin QT5_LIBDIR.32 = $(QT5_BASEDIR)/lib QT5_BINDIR.64 = $(QT5_BASEDIR)/bin/$(MACH64) QT5_LIBDIR.64 = $(QT5_BASEDIR)/lib/$(MACH64) QT5_BINDIR = $(QT5_BINDIR.$(BITS)) QT5_LIBDIR = $(QT5_LIBDIR.$(BITS)) QT5_INCDIR = $(QT5_BASEDIR)/include QT5_PKG_CONFIG_PATH = $(QT5_LIBDIR)/pkgconfig # We deliver version 6 only in a 64-bit variant. QT6_VERSION = 6.6 QT6_BASEDIR = $(USRLIBDIR)/qt/$(QT6_VERSION) QT6_BINDIR = $(QT6_BASEDIR)/bin/$(MACH64) QT6_LIBDIR = $(QT6_BASEDIR)/lib/$(MACH64) QT6_PKG_CONFIG_PATH = $(QT6_LIBDIR)/pkgconfig # # Upstream officially supports two recent major Perl versions. They also aim # to provide critical security fixes for major Perl versions whose 5.x.0 # release was within the past three years. # # We support union of both sets. IOW, we will start to obsolete a major Perl # version if its 5.x.0 was released longer than three years ago AND there are # already released two newer major Perl versions. # # See https://perldoc.perl.org/perlpolicy # # # We will start to obsolete major Perl versions according the following table: # # +--------------+----------------+ # | Perl version | Obsolete after | # +--------------+----------------+ # | 5.36 | 2025-05-28 | # | 5.38 | 2026-07-02 | # | 5.40 | 2027-06-09 | # +--------------+----------------+ # # See https://www.cpan.org/src/README.html # # This is the default version of Perl PERL_VERSION = 5.40 # The PERL_VERSIONS list should always be in ascending order (newest version # last) PERL_VERSIONS = 5.36 5.38 5.40 # Perl up to 5.22 was built 32-bit only. Starting with 5.24 the perl package # is built 64-bit only. So now all PERL_VERSIONS are 64-bit only. PERL_64_ONLY_VERSIONS = $(PERL_VERSIONS) # List of perl versions we are currently obsoleting. We no longer build any # packages for these perl versions, but there still might be hanging some not # obsoleted yet versioned packages built for PERL_VERSIONS_OBSOLETING perl # versions. Or there is just the versioned runtime/perl package still # available. # # This list should be usually empty. Intersection of PERL_VERSIONS_OBSOLETING # and PERL_VERSIONS lists MUST be always empty. PERL_VERSIONS_OBSOLETING = define perl-path-rule PERL.$(1) = /usr/perl5/$(1)/bin/perl POD2MAN.$(1) = /usr/perl5/$(1)/bin/pod2man PERL5BINDIR.$(1) = /usr/perl5/$(1)/bin endef $(foreach perlver,$(PERL_VERSIONS),$(eval $(call perl-path-rule,$(perlver)))) PERL5BINDIR = $(PERL5BINDIR.$(PERL_VERSION)) PERL = $(PERL.$(PERL_VERSION)) POD2MAN = $(POD2MAN.$(PERL_VERSION)) PERL_ARCH := $(shell $(PERL) -e 'use Config; print $$Config{archname}') PERL_ARCH_FUNC= $(shell $(1) -e 'use Config; print $$Config{archname}') # Optimally we should ask perl which C compiler was used but it doesn't # result in a full path name. Only "c" is being recorded # inside perl builds while we actually need a full path to # the compiler. #PERL_CC := $(shell $(PERL) -e 'use Config; print $$Config{cc}') PKG_MACROS += PERL_ARCH=$(PERL_ARCH) PKG_MACROS += PERL_VERSION=$(PERL_VERSION) # # Upstream supports major PostgreSQL versions for 5 years after its initial # release. After that one last minor version is released and then the major # version is considered EOL. # # We will start to obsolete PostgreSQL versions according the following table: # # +--------------------+----------------+ # | PostgreSQL version | Obsolete after | # +--------------------+----------------+ # | 12 | 2024-11-14 | # | 14 | 2026-11-12 | # | 15 | 2027-11-11 | # | 16 | 2028-11-09 | # +--------------------+----------------+ # # See https://www.postgresql.org/support/versioning/ # # Config magic for Postgres/EnterpriseDB/... # Default DB version should be the newest one we do have so we detect any # incompatibilities as soon as possible. Components could override this when # they are not ready yet to compile with so new version. PG_VERSION ?= 16 PG_IMPLEM ?= postgres PG_VERNUM = $(subst .,,$(PG_VERSION)) # For dependencies, including REQUIRED_PACKAGES if needed PG_BASEPKG = database/$(PG_IMPLEM)-$(PG_VERNUM) PG_CLIENT_PKG = $(PG_BASEPKG)/client PG_DEVELOPER_PKG = $(PG_BASEPKG)/developer PG_LIBRARY_PKG = $(PG_BASEPKG)/library PG_SERVICE_PKG = service/$(PG_BASEPKG) REQUIRED_PACKAGES_SUBST+= PG_CLIENT_PKG REQUIRED_PACKAGES_SUBST+= PG_DEVELOPER_PKG REQUIRED_PACKAGES_SUBST+= PG_LIBRARY_PKG REQUIRED_PACKAGES_SUBST+= PG_SERVICE_PKG PG_HOME = $(USRDIR)/$(PG_IMPLEM)/$(PG_VERSION) PG_BINDIR.32 = $(PG_HOME)/bin/$(MACH32) PG_BINDIR.64 = $(PG_HOME)/bin PG_BINDIR = $(PG_BINDIR.$(BITS)) PG_INCDIR = $(PG_HOME)/include PG_MANDIR = $(PG_HOME)/man PG_SHAREDIR = $(PG_HOME)/share PG_DOCDIR = $(PG_HOME)/doc PG_LIBDIR.32 = $(PG_HOME)/lib PG_LIBDIR.64 = $(PG_HOME)/lib/$(MACH64) PG_LIBDIR = $(PG_LIBDIR.$(BITS)) PG_CONFIG.32 = $(PG_BINDIR.32)/pg_config PG_CONFIG.64 = $(PG_BINDIR.64)/pg_config PG_CONFIG = $(PG_CONFIG.$(BITS)) PATH.prepend += $(PG_BINDIR) PKG_MACROS += PG_VERSION=$(PG_VERSION) PKG_MACROS += PG_VERNUM=$(PG_VERNUM) PKG_MACROS += PG_BASEPKG=$(PG_BASEPKG) # # Upstream maintains long-term MariaDB releases for at least 5 years and # short-term MariaDB releases for at least one year. # # We will start to obsolete MariaDB versions according the following table: # # +-----------------+----------------+ # | MariaDB version | Obsolete after | # +-----------------+----------------+ # | 10.6 | 2026-07 | # +-----------------+----------------+ # # See https://mariadb.org/about/#maintenance-policy # # Config magic for MySQL/MariaDB/Percona/... # Default DB version should be the newest one we do have so we detect any # incompatibilities as soon as possible. Components could override this when # they are not ready yet to compile with so new version. # NOTE: At this time the gate does not provide a recipe for actual "mysql" # The "/usr/mysql/*" trees are mediated to preferred MariaDB or Percona variant MYSQL_VERSION ?= 10.6 MYSQL_IMPLEM ?= mariadb MYSQL_VERNUM = $(subst .,,$(MYSQL_VERSION)) MYSQL_MINOR = $(word 2,$(subst .,$(space),$(MYSQL_VERSION))) # Beginning with mariadb 10.6 we only ship 64 bit versions. That changes the paths. $(if $(shell [ $(MYSQL_MINOR) -ge 6 ] && echo "OK"), \ $(eval MYSQL_64_BIT_ONLY := true), \ $(eval MYSQL_64_BIT_ONLY := false)) # For dependencies, including REQUIRED_PACKAGES if needed MYSQL_BASEPKG = database/$(MYSQL_IMPLEM)-$(MYSQL_VERNUM) MYSQL_CLIENT_PKG = $(MYSQL_BASEPKG)/client MYSQL_DEVELOPER_PKG = $(MYSQL_BASEPKG)/developer MYSQL_LIBRARY_PKG = $(MYSQL_BASEPKG)/library REQUIRED_PACKAGES_SUBST+= MYSQL_CLIENT_PKG REQUIRED_PACKAGES_SUBST+= MYSQL_DEVELOPER_PKG REQUIRED_PACKAGES_SUBST+= MYSQL_LIBRARY_PKG MYSQL_HOME = $(USRDIR)/$(MYSQL_IMPLEM)/$(MYSQL_VERSION) ifeq ($(strip $(MYSQL_64_BIT_ONLY)),false) MYSQL_BINDIR.32 = $(MYSQL_HOME)/bin MYSQL_BINDIR.64 = $(MYSQL_HOME)/bin/$(MACH64) else MYSQL_BINDIR.64 = $(MYSQL_HOME)/bin endif MYSQL_BINDIR = $(MYSQL_BINDIR.$(BITS)) MYSQL_INCDIR = $(MYSQL_HOME)/include MYSQL_MANDIR = $(MYSQL_HOME)/man MYSQL_SHAREDIR = $(MYSQL_HOME)/share MYSQL_DOCDIR = $(MYSQL_HOME)/doc MYSQL_LIBDIR.32 = $(MYSQL_HOME)/lib MYSQL_LIBDIR.64 = $(MYSQL_HOME)/lib/$(MACH64) MYSQL_LIBDIR = $(MYSQL_LIBDIR.$(BITS)) MYSQL_CONFIG.32 = $(MYSQL_BINDIR.32)/mysql_config MYSQL_CONFIG.64 = $(MYSQL_BINDIR.64)/mysql_config MYSQL_CONFIG = $(MYSQL_CONFIG.$(BITS)) MYSQL_PKG_CONFIG_PATH = $(MYSQL_LIBDIR)/pkgconfig PATH.prepend += $(MYSQL_BINDIR) PKG_CONFIG_PATH.prepend += $(MYSQL_PKG_CONFIG_PATH) PKG_MACROS += MYSQL_VERSION=$(MYSQL_VERSION) PKG_MACROS += MYSQL_VERNUM=$(MYSQL_VERNUM) PKG_MACROS += MYSQL_BASEPKG=$(MYSQL_BASEPKG) # Default libjpeg implementation layout JPEG_DEFAULT = 8 JPEG_VERSION ?= $(JPEG_DEFAULT) JPEG_IMPLEM = libjpeg$(JPEG_VERSION)-turbo JPEG_HOME = $(if $(filter $(JPEG_DEFAULT),$(JPEG_VERSION)),$(USRDIR),$(USRLIBDIR)/$(JPEG_IMPLEM)) JPEG_INCDIR = $(if $(filter $(JPEG_DEFAULT),$(JPEG_VERSION)),$(USRINCDIR),$(USRINCDIR)/$(JPEG_IMPLEM)) JPEG_LIBDIR.32 = $(JPEG_HOME)/lib JPEG_LIBDIR.64 = $(JPEG_HOME)/lib/$(MACH64) JPEG_LIBDIR = $(JPEG_LIBDIR.$(BITS)) JPEG_CPPFLAGS = -I$(JPEG_INCDIR) JPEG_CFLAGS.32 = -Wl,-L$(JPEG_LIBDIR.32) -Wl,-R$(JPEG_LIBDIR.32) JPEG_CFLAGS.64 = -Wl,-L$(JPEG_LIBDIR.64) -Wl,-R$(JPEG_LIBDIR.64) JPEG_CFLAGS = $(JPEG_CFLAGS.$(BITS)) JPEG_CXXFLAGS.32 = -Wl,-L$(JPEG_LIBDIR.32) -Wl,-R$(JPEG_LIBDIR.32) JPEG_CXXFLAGS.64 = -Wl,-L$(JPEG_LIBDIR.64) -Wl,-R$(JPEG_LIBDIR.64) JPEG_CXXFLAGS = $(JPEG_CXXFLAGS.$(BITS)) JPEG_LDFLAGS.32 = -L$(JPEG_LIBDIR.32) -R$(JPEG_LIBDIR.32) JPEG_LDFLAGS.64 = -L$(JPEG_LIBDIR.64) -R$(JPEG_LIBDIR.64) JPEG_LDFLAGS = $(JPEG_LDFLAGS.$(BITS)) PKG_CONFIG_PATH.prepend += $(if $(filter $(JPEG_DEFAULT),$(JPEG_VERSION)),,$(JPEG_LIBDIR)/pkgconfig) JPEG_IMPLEM_PKG = image/library/$(JPEG_IMPLEM) REQUIRED_PACKAGES_SUBST += JPEG_IMPLEM_PKG # This is the default BUILD version of tcl # Not necessarily the system's default version, i.e. /usr/bin/tclsh TCL_VERSION = 8.6 TCLSH.8.6.i386.32 = /usr/bin/i86/tclsh8.6 TCLSH.8.6.i386.64 = /usr/bin/amd64/tclsh8.6 TCLSH.8.6.sparc.32 = /usr/bin/sparcv7/tclsh8.6 TCLSH.8.6.sparc.64 = /usr/bin/sparcv9/tclsh8.6 TCLSH = $(TCLSH.$(TCL_VERSION).$(MACH).$(BITS)) # ICU library ICU_VERSION = 76 ICU_LIBRARY_PKG = library/icu-$(ICU_VERSION) REQUIRED_PACKAGES_SUBST += ICU_LIBRARY_PKG # GNU readline READLINE_VERSION = 8 READLINE_PKG = library/readline-$(READLINE_VERSION) REQUIRED_PACKAGES_SUBST += READLINE_PKG CCSMAKE = /usr/ccs/bin/make GMAKE = /usr/gnu/bin/make GPATCH = /usr/gnu/bin/patch PATCH_LEVEL = 1 GPATCH_BACKUP = --backup --version-control=numbered GPATCH_FLAGS = -p$(PATCH_LEVEL) $(GPATCH_BACKUP) GSED = /usr/gnu/bin/sed GDIFF = /usr/gnu/bin/diff GSORT = /usr/gnu/bin/sort GUNZIP = /usr/bin/gunzip SORT = LC_ALL=C /usr/bin/sort PKGREPO = /usr/bin/pkgrepo PKGSEND = /usr/bin/pkgsend ifeq ($(strip $(PKGLINT_COMPONENT)),) PKGLINT = /usr/bin/python /usr/bin/pkglint else PKGLINT = ${WS_TOOLS}/pkglint endif ACLOCAL = /usr/bin/aclocal-1.16 AUTOMAKE = /usr/bin/automake-1.16 AUTORECONF = /usr/bin/autoreconf KSH93 = /usr/bin/ksh93 TOUCH = /usr/bin/touch MKDIR = /bin/mkdir -p RM = /bin/rm -f CP = /bin/cp -f MV = /bin/mv -f LN = /bin/ln CAT = /bin/cat SYMLINK = /bin/ln -s ENV = /usr/bin/env -i FIND = /usr/bin/find INSTALL = /usr/bin/ginstall GNU_GREP = /usr/gnu/bin/grep CHMOD = /usr/bin/chmod NAWK = /usr/bin/nawk TEE = /usr/bin/tee GAS = /usr/gnu/bin/as GTAR = /usr/gnu/bin/tar STRIP = /usr/bin/strip IPS2TGZ = $(WS_TOOLS)/ips2tgz JQ = /usr/bin/jq DOS2UNIX = /usr/bin/dos2unix TAC = /usr/bin/tac QUILT = /usr/bin/quilt CTFCONVERT = /opt/onbld/bin/$(MACH)/ctfconvert ELFEDIT = /usr/bin/elfedit INS.dir= $(INSTALL) -d $@ INS.file= $(INSTALL) -m 444 $< $(@D) # OpenSSL macros OPENSSL_DEFAULT = 3.1 ifeq ($(strip $(USE_OPENSSL11)),yes) OPENSSL_VERSION = 1.1 else ifeq ($(strip $(USE_OPENSSL10)),yes) OPENSSL_VERSION = 1.0 else OPENSSL_VERSION ?= $(OPENSSL_DEFAULT) endif endif PATH.prepend+=$(OPENSSL_BINDIR) OPENSSL_PREFIX= $(USRDIR)/openssl/$(OPENSSL_VERSION) OPENSSL_BINDIR.64= $(OPENSSL_PREFIX)/bin OPENSSL_BINDIR.32= $(OPENSSL_PREFIX)/bin/$(MACH32) OPENSSL_BINDIR= $(OPENSSL_BINDIR.$(BITS)) OPENSSL_LIBDIR.64= $(OPENSSL_PREFIX)/lib/64 OPENSSL_LIBDIR.32= $(OPENSSL_PREFIX)/lib OPENSSL_LIBDIR= $(OPENSSL_LIBDIR.$(BITS)) OPENSSL_PKG_CONFIG_PATH.32= $(OPENSSL_PREFIX)/lib/pkgconfig OPENSSL_PKG_CONFIG_PATH.64= $(OPENSSL_PREFIX)/lib/64/pkgconfig OPENSSL_PKG_CONFIG_PATH= $(OPENSSL_PKG_CONFIG_PATH.$(BITS)) OPENSSL_INCDIR=$(OPENSSL_PREFIX)/include PKG_CONFIG_PATH.prepend += $(OPENSSL_PKG_CONFIG_PATH) # The OpenSSL 1.0 package is without the version suffix so it needs special handling OPENSSL_PKG = library/security/openssl$(subst -10,,-$(subst .,,$(OPENSSL_VERSION))) REQUIRED_PACKAGES_SUBST += OPENSSL_PKG # Pkg-config paths PKG_CONFIG_PATH.32 = /usr/lib/pkgconfig PKG_CONFIG_PATH.64 = /usr/lib/$(MACH64)/pkgconfig PKG_CONFIG_PATH = $(subst $(space),:,$(strip $(PKG_CONFIG_PATH.prepend))):$(PKG_CONFIG_PATH.$(BITS)):$(PKG_CONFIG_PATH.32) # Set default path for environment modules MODULE_VERSION = 3.2.10 MODULE_PATH = /usr/share/Modules/modulefiles MODULE_VERSIONS_PATH = /usr/share/Modules/versions # Path to bash completions BASH_COMPLETIONS_PATH = /usr/share/bash-completion/completions # # C preprocessor flag sets to ease feature selection. Add the required # feature to your Makefile with CPPFLAGS += $(FEATURE_MACRO) and add to # the component build with CONFIGURE_OPTIONS += CPPFLAGS="$(CPPFLAGS)" or # similiar. # # Enables visibility of some c99 math functions that aren't visible by default. # What other side-effects are there? CPP_C99_EXTENDED_MATH = -D_STDC_99 # Enables large file support for components that have no other means of doing # so. Use CPP_LARGEFILES and not the .32/.64 variety directly CPP_LARGEFILES.32 := $(shell getconf LFS_CFLAGS) CPP_LARGEFILES.64 := $(shell getconf LFS64_CFLAGS) CPP_LARGEFILES = $(CPP_LARGEFILES.$(BITS)) # Enables some #pragma redefine_extname to POSIX-compliant Standard C Library # functions. Also avoids the component's #define _POSIX_C_SOURCE to some value # we currently do not support. CPP_POSIX = -D_POSIX_C_SOURCE=200112L -D_POSIX_PTHREAD_SEMANTICS # XPG8 mode. This option enables XPG8 conformance, plus extensions. CPP_XPG8MODE= -D_XOPEN_SOURCE=800 -D__EXTENSIONS__=1 -D_XPG8 # XPG7 mode. This option enables XPG7 conformance, plus extensions. CPP_XPG7MODE= -D_XOPEN_SOURCE=700 -D__EXTENSIONS__=1 -D_XPG7 # 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. Add CPP_XPG6MODE to # CFLAGS instead of using this directly CPP_XPG6MODE= -D_XOPEN_SOURCE=600 -D__EXTENSIONS__=1 -D_XPG6 # XPG5 mode. These options are specific for C++, where _XPG6, # _XOPEN_SOURCE=600 and C99 are illegal. -D__EXTENSIONS__=1 is legal in C++. CPP_XPG5MODE= -D_XOPEN_SOURCE=500 -D__EXTENSIONS__=1 -D_XPG5 # Generate 32/64 bit objects CC_BITS = -m$(BITS) # Turn on C99 for gcc gcc_C99_ENABLE = -std=c99 # Control register usage for generated code. SPARC ABI requires system # libraries not to use application registers. gcc_XREGS.sparc = -mno-app-regs gcc_XREGS.i386 = gcc_XREGS = $(gcc_XREGS.$(MACH)) # See CPP_XPG8MODE comment above. XPG8MODE = $(CPP_XPG8MODE) # See CPP_XPG7MODE comment above. XPG7MODE = $(CPP_XPG7MODE) # See CPP_XPG6MODE comment above. XPG6MODE = $(CPP_XPG6MODE) # See CPP_XPG5MODE comment above. You can only use this in C++, not in C99. XPG5MODE = $(CPP_XPG5MODE) # # GNU C compiler flag sets to ease feature selection. Add the required # feature to your Makefile with CFLAGS += $(FEATURE_MACRO) and add to the # component build with CONFIGURE_OPTIONS += CFLAGS="$(CFLAGS)" or similiar. # # Control the GCC optimization level. gcc_OPT.sparc.32 = -O3 -mcpu=ultrasparc -mvis -mfsmuld gcc_OPT.sparc.64 = -O3 -mcpu=ultrasparc -mvis -mfsmuld gcc_OPT.i386.32 = -O3 gcc_OPT.i386.64 = -O3 gcc_OPT = $(gcc_OPT.$(MACH).$(BITS)) # GCC PIC code generation. Use CC_PIC instead to select PIC code generation. gcc_PIC = -fPIC -DPIC # Generic macro for PIC code generation. Use this macro instead of the # compiler specific variant. CC_PIC = $($(COMPILER)_PIC) # Default GNU C compiler flags. Add the required feature to your Makefile # with CFLAGS += $(FEATURE_MACRO) and add to the component build with # CONFIGURE_OPTIONS += CFLAGS="$(CFLAGS)" or similiar. In most cases, it # should not be necessary to add CFLAGS to any environment other than the # configure environment. CFLAGS.gcc += $(gcc_OPT) CFLAGS.gcc += $(gcc_XREGS) # Default GNU C++ compiler flags. Add the required feature to your Makefile # with CXXFLAGS += $(FEATURE_MACRO) and add to the component build with # CONFIGURE_OPTIONS += CXXFLAGS="$(CXXFLAGS)" or similiar. In most cases, it # should not be necessary to add CXXFLAGS to any environment other than the # configure environment. CXXFLAGS.gcc += $(gcc_OPT) CXXFLAGS.gcc += $(gcc_XREGS) # Default GNU FORTRAN compiler flags. Add the required feature to your Makefile # with FCFLAGS += $(FEATURE_MACRO) and add to the component build with # CONFIGURE_OPTIONS += FCFLAGS="$(FCFLAGS)" or similiar. In most cases, it # should not be necessary to add FCFLAGS to any environment other than the # configure environment. FCFLAGS.gcc += $(gcc_OPT) FCFLAGS.gcc += $(gcc_XREGS) # Build 32 or 64 bit objects. CFLAGS += $(CC_BITS) # Add compiler specific 'default' features CFLAGS += $(CFLAGS.$(COMPILER)) # Per-compiler CFLAGS to use when building for CTF. Currently only defined # for gcc; could be made to work with other compilers. # -gdwarf-4 is the newest DWARF revision understood by illumos libctf # # -gstrict-dwarf prevents the compiler from including newer DWARF features CTF_CFLAGS.gcc = -g -gdwarf-4 -gstrict-dwarf # -msave-args makes it possible for debugging tools (specifically pstack and # mdb) to retrieve function arguments, and is required for the python pstack # hooks. CTF_CFLAGS.gcc += -msave-args # By default, GCC may put parts of functions in different named sub-sections # of .text based on their presumed or measured calling frequency. This is not # currently handled by libctf and other illumos tools which assume that a # function's text lies in a single contiguous range of virtual addresses. # Disable this optimization if building with CTF. CTF_CFLAGS.gcc += -fno-reorder-functions -fno-reorder-blocks-and-partition # Enable CTF if desired ifeq ($(strip $(USE_CTF)),yes) CFLAGS += $(if $(CTF_CFLAGS.$(COMPILER)), \ $(CTF_CFLAGS.$(COMPILER)), \ $(error Error: CTF_CFLAGS.$(COMPILER) must be defined to use CTF with $(COMPILER))) endif # Build 32 or 64 bit objects in C++ as well. CXXFLAGS += $(CC_BITS) # Add compiler specific 'default' features CXXFLAGS += $(CXXFLAGS.$(COMPILER)) # Build 32 or 64 bit objects in FORTRAN as well. F77FLAGS += $(CC_BITS) FCFLAGS += $(CC_BITS) # Add compiler specific 'default' features F77FLAGS += $(FCFLAGS.$(COMPILER)) FCFLAGS += $(FCFLAGS.$(COMPILER)) # # Solaris linker flag sets to ease feature selection. Add the required # feature to your Makefile with LDFLAGS += $(FEATURE_MACRO) and add to the # component build with CONFIGURE_OPTIONS += LDFLAGS="$(LDFLAGS)" or similiar. # # set the bittedness that we want to link ccs.ld.64 = -64 gcc.ld.32 = -m32 gcc.ld.64 = -m64 LD_BITS = $($(LINKER).ld.$(BITS)) LDFLAGS = $(LD_BITS) # Reduce the symbol table size, effectively conflicting with -g. We should # get linker guidance here. LD_Z_REDLOCSYM = -z redlocsym # Cause the linker to rescan archive libraries and resolve remaining unresolved # symbols recursively until all symbols are resolved. Components should be # linking in the libraries they need, in the required order. This should # only be required if the component's native build is horribly broken. LD_Z_RESCAN_NOW = -z rescan-now LD_Z_TEXT = -z direct # make sure that -lc is always present when building shared objects. LD_DEF_LIBS += -lc # make sure all symbols are defined. LD_Z_DEFS = -z defs # eliminate unreferenced dynamic dependencies LD_Z_IGNORE = -z ignore # use direct binding LD_B_DIRECT = -Bdirect # use generic macro names for enabling/disabling ASLR ASLR_ENABLE = -z aslr=enable ASLR_DISABLE = -z aslr=disable ASLR_MODE = $(ASLR_DISABLE) # by default, turn off Address Space Layout Randomization for ELF executables; # to explicitly enable ASLR, set ASLR_MODE = $(ASLR_ENABLE) # in that component's Makefile LD_Z_ASLR = $(ASLR_MODE) # Define SSP library link flag for 32-bit objects LD_SSP.32 = -lssp_ns LD_SSP.64 = LD_SSP = $(LD_SSP.$(BITS)) # # More Solaris linker flags that we want to be sure that everyone gets. This # is automatically added to the calling environment during the 'build' and # 'install' phases of the component build. Each individual feature can be # turned off by adding FEATURE_MACRO= to the component Makefile. # # Create a non-executable stack when linking. LD_MAP_NOEXSTK.i386 = -M /usr/lib/ld/map.noexstk LD_MAP_NOEXSTK.sparc = -M /usr/lib/ld/map.noexstk # Create a non-executable bss segment when linking. LD_MAP_NOEXBSS = -M /usr/lib/ld/map.noexbss # Create a non-executable data segment when linking. Due to PLT needs, the # data segment must be executable on sparc, but the bss does not. # see mapfile comments for more information LD_MAP_NOEXDATA.i386 = -M /usr/lib/ld/map.noexdata LD_MAP_NOEXDATA.sparc = $(LD_MAP_NOEXBSS) # Page alignment LD_MAP_PAGEALIGN = -M /usr/lib/ld/map.pagealign # Linker options to add when only building libraries LD_OPTIONS_SO += $(LD_Z_TEXT) $(LD_Z_DEFS) $(LD_DEF_LIBS) # Default linker options that everyone should get. Do not add additional # libraries to this macro, as it will apply to everything linked during the # component build. LD_OPTIONS += $(LD_MAP_NOEXSTK.$(MACH)) $(LD_MAP_NOEXDATA.$(MACH)) \ $(LD_MAP_PAGEALIGN) $(LD_B_DIRECT) $(LD_Z_IGNORE) # only used on executables LD_EXEC_OPTIONS = $(LD_Z_ASLR) # Environment variables and arguments passed into the build and install # environment(s). These are the initial settings. COMPONENT_BUILD_ENV= \ LD_OPTIONS="$(LD_OPTIONS)" \ LD_EXEC_OPTIONS="$(LD_EXEC_OPTIONS)" COMPONENT_INSTALL_ENV= \ LD_OPTIONS="$(LD_OPTIONS)" \ LD_EXEC_OPTIONS="$(LD_EXEC_OPTIONS)" # PATH should be always set COMPONENT_BUILD_ENV += PATH="$(PATH)" COMPONENT_INSTALL_ENV += PATH="$(PATH)" COMPONENT_TEST_ENV += PATH="$(PATH)" # PERL options which depend on C options should be placed here PERL_OPTIMIZE := $(shell $(PERL) -e 'use Config; print $$Config{optimize}') # Rewrite absolute source-code paths into relative for ccache, so that any # workspace with a shared CCACHE_DIR can benefit when compiling a component ifneq ($(strip $(CCACHE)),) export CCACHE_BASEDIR = $(BUILD_DIR_$(BITS)) COMPONENT_BUILD_ENV += CCACHE="$(CCACHE)" COMPONENT_INSTALL_ENV += CCACHE="$(CCACHE)" COMPONENT_TEST_ENV += CCACHE="$(CCACHE)" COMPONENT_BUILD_ENV += CC_gcc_32="$(CC_gcc_32)" COMPONENT_BUILD_ENV += CC_gcc_64="$(CC_gcc_64)" COMPONENT_BUILD_ENV += CXX_gcc_32="$(CXX_gcc_32)" COMPONENT_BUILD_ENV += CXX_gcc_64="$(CXX_gcc_64)" COMPONENT_INSTALL_ENV += CC_gcc_32="$(CC_gcc_32)" COMPONENT_INSTALL_ENV += CC_gcc_64="$(CC_gcc_64)" COMPONENT_INSTALL_ENV += CXX_gcc_32="$(CXX_gcc_32)" COMPONENT_INSTALL_ENV += CXX_gcc_64="$(CXX_gcc_64)" COMPONENT_TEST_ENV += CC_gcc_32="$(CC_gcc_32)" COMPONENT_TEST_ENV += CC_gcc_64="$(CC_gcc_64)" COMPONENT_TEST_ENV += CXX_gcc_32="$(CXX_gcc_32)" COMPONENT_TEST_ENV += CXX_gcc_64="$(CXX_gcc_64)" COMPONENT_BUILD_ENV.$(BITS) += CCACHE_BASEDIR="$(BUILD_DIR_$(BITS))" COMPONENT_INSTALL_ENV.$(BITS) += CCACHE_BASEDIR="$(BUILD_DIR_$(BITS))" COMPONENT_TEST_ENV.$(BITS) += CCACHE_BASEDIR="$(BUILD_DIR_$(BITS))" ifneq ($(strip $(CCACHE_DIR)),) COMPONENT_BUILD_ENV += CCACHE_DIR="$(CCACHE_DIR)" COMPONENT_INSTALL_ENV += CCACHE_DIR="$(CCACHE_DIR)" COMPONENT_TEST_ENV += CCACHE_DIR="$(CCACHE_DIR)" endif ifneq ($(strip $(CCACHE_LOGFILE)),) COMPONENT_BUILD_ENV += CCACHE_LOGFILE="$(CCACHE_LOGFILE)" COMPONENT_INSTALL_ENV += CCACHE_LOGFILE="$(CCACHE_LOGFILE)" COMPONENT_TEST_ENV += CCACHE_LOGFILE="$(CCACHE_LOGFILE)" endif endif # Add any bit-specific settings COMPONENT_BUILD_ENV += $(COMPONENT_BUILD_ENV.$(BITS)) COMPONENT_BUILD_ARGS += $(COMPONENT_BUILD_ARGS.$(BITS)) COMPONENT_INSTALL_ENV += $(COMPONENT_INSTALL_ENV.$(BITS)) COMPONENT_INSTALL_ARGS += $(COMPONENT_INSTALL_ARGS.$(BITS)) # declare these phony so that we avoid filesystem conflicts. .PHONY: prep build install publish test clean clobber # If there are no tests to execute NO_TESTS = test-nothing test-nothing: @echo "There are no tests available at this time." # default behaviour for 'component-hook' target is to echo the component # name and version information, but more complex behaviour can be implemented # via command line setting of the COMPONENT_HOOK macro. COMPONENT_HOOK ?= echo $(COMPONENT_NAME) $(COMPONENT_VERSION) component-hook: @$(COMPONENT_HOOK) # We need shell/ksh93 to be able to run scripts in the tools directory USERLAND_REQUIRED_PACKAGES += shell/ksh93 # # Packages with tools that are required to build Userland components # USERLAND_REQUIRED_PACKAGES += metapackages/build-essential # Define substitution rules for some packages. # Such package names may change and would be better defined with a macro to # avoid mass modification of the Makefiles. # Runtime package names are changed at compiler version major bumps. REQUIRED_PACKAGES_SUBST+= GCC_RUNTIME_PKG REQUIRED_PACKAGES_SUBST+= GXX_RUNTIME_PKG REQUIRED_PACKAGES_SUBST+= GCCGO_RUNTIME_PKG REQUIRED_PACKAGES_SUBST+= GFORTRAN_RUNTIME_PKG REQUIRED_PACKAGES_SUBST+= GOBJC_RUNTIME_PKG # Generate requirements on all built python version variants for given packages USERLAND_REQUIRED_PACKAGES += $(foreach ver,$(PYTHON_VERSIONS),$(USERLAND_REQUIRED_PACKAGES.python:%=%-$(subst .,,$(ver)))) REQUIRED_PACKAGES += $(foreach ver,$(PYTHON_VERSIONS),$(PYTHON_REQUIRED_PACKAGES:%=%-$(subst .,,$(ver)))) TEST_REQUIRED_PACKAGES += $(foreach ver,$(PYTHON_VERSIONS),$(TEST_REQUIRED_PACKAGES.python:%=%-$(subst .,,$(ver)))) # Generate requirements on all built perl version variants for given packages USERLAND_REQUIRED_PACKAGES += $(foreach ver,$(PERL_VERSIONS),$(USERLAND_REQUIRED_PACKAGES.perl:%=%-$(subst .,,$(ver)))) REQUIRED_PACKAGES += $(foreach ver,$(PERL_VERSIONS),$(PERL_REQUIRED_PACKAGES:%=%-$(subst .,,$(ver)))) TEST_REQUIRED_PACKAGES += $(foreach ver,$(PERL_VERSIONS),$(TEST_REQUIRED_PACKAGES.perl:%=%-$(subst .,,$(ver)))) # Generate conflicting packages for all built python version variants for given package TEST_CONFLICTING_PACKAGES += $(foreach ver,$(PYTHON_VERSIONS),$(TEST_CONFLICTING_PACKAGES.python:%=%-$(subst .,,$(ver)))) # Targets for some tools rarely used by the build framework. We do not add # these tools to USERLAND_REQUIRED_PACKAGES to do not pollute it. $(QUILT): @echo @echo "$(QUILT) is missing" @echo "Please install developer/quilt package" @echo @exit 1 include $(WS_MAKE_RULES)/environment.mk include $(WS_MAKE_RULES)/depend.mk include $(WS_MAKE_RULES)/component.mk