#

# 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) 2010, 2015, Oracle and/or its affiliates. All rights reserved.

#

PATH=/usr/bin:/usr/gnu/bin

# 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 = 

# 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)

ifneq   ($(strip $(EXTERNAL_ARCHIVE_MIRROR)),)

export DOWNLOAD_SEARCH_PATH +=	$(EXTERNAL_ARCHIVE_MIRROR)

endif

# The workspace starts at the parent of the make-rules directory,

# unless someone already supplied the top.

ifeq ($(origin WS_TOP), undefined)

export WS_TOP := $(realpath $(dir $(realpath $(dir $(filter \

			%/make-rules/shared-macros.mk,$(MAKEFILE_LIST))))))

endif

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

# This can be overridden to avoid rebuilding when you touch a Makefile

MAKEFILE_PREREQ =	Makefile

# some things don't build properly in non-C locales,

# so lets stay there

export LC_ALL=C

SHELL=	/bin/bash

# We want "nightly" as our publisher, to match other consolidations and

# facilitate migrations.  G11N wants $(CONSOLIDATION)-localizable for

# the localizable publisher.

CONSOLIDATION =	userland

PUBLISHER ?=	nightly

PUBLISHER_LOCALIZABLE ?=	$(CONSOLIDATION)-localizable

ROOT =			/

# The changset and external source repo used in building the packages.

CONSOLIDATION_CHANGESET=$(shell hg identify -i)

CONSOLIDATION_REPOSITORY_URL=https://hg.java.net/hg/solaris-userland~gate

# Native OS version

OS_VERSION :=		$(shell uname -r)

SOLARIS_VERSION =	$(OS_VERSION:5.%=2.%)

# Target OS version

PKG_SOLARIS_VERSION ?= 5.12

include $(WS_MAKE_RULES)/ips-buildinfo.mk

COMPILER ?=		studio

BITS =			32

# The default version should go last.

PYTHON_VERSION =	2.7

PYTHON2_VERSIONS =	2.6 2.7

PYTHON3_VERSIONS =	3.4

PYTHON_VERSIONS =	$(PYTHON3_VERSIONS) $(PYTHON2_VERSIONS)

BASS_O_MATIC =	$(WS_TOOLS)/bass-o-matic

CLONEY =	$(WS_TOOLS)/cloney

CONFIG_SHELL =	/bin/bash

PKG_REPO =	file:$(WS_REPO)

COMPONENT_SRC_NAME =	$(COMPONENT_NAME)

COMPONENT_DIR :=	$(shell pwd)

SOURCE_DIR =	$(COMPONENT_DIR)/$(COMPONENT_SRC)

BUILD_DIR =	$(COMPONENT_DIR)/build

PROTO_DIR =	$(BUILD_DIR)/prototype/$(MACH)

ETCDIR =	/etc

USRDIR =	/usr

BINDIR =	/bin

SBINDIR =	/sbin

LIBDIR =	/lib

USRBINDIR =	$(USRDIR)/bin

USRBINDIR64 =	$(USRDIR)/bin/$(MACH64)

USRSBINDIR =	$(USRDIR)/sbin

USRLIBDIR =	$(USRDIR)/lib

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

USRLIBDIR64 =	$(USRDIR)/lib/$(MACH64)

PROTOBINDIR =	$(PROTO_DIR)/$(BINDIR)

PROTOETCDIR =	$(PROTO_DIR)/$(ETCDIR)

PROTOETCSECDIR = $(PROTO_DIR)/$(ETCDIR)/security

PROTOUSRDIR =	$(PROTO_DIR)/$(USRDIR)

PROTOLIBDIR =	$(PROTO_DIR)/$(LIBDIR)

PROTOUSRBINDIR =	$(PROTO_DIR)/$(USRBINDIR)

PROTOUSRBINDIR64 =	$(PROTO_DIR)/$(USRBINDIR64)

PROTOUSRSBINDIR =	$(PROTO_DIR)/$(USRSBINDIR)

PROTOUSRLIBDIR =	$(PROTO_DIR)/$(USRLIBDIR)

PROTOUSRLIBDIR64 =	$(PROTO_DIR)/$(USRLIBDIR64)

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)

PROTOUSRSHARELOCALEDIR =	$(PROTO_DIR)/$(USRSHARELOCALEDIR)

SFWBIN =	/usr/sfw/bin

SFWINCLUDE =	/usr/sfw/include

SFWLIB =	/usr/sfw/lib

SFWLIB64 =	/usr/sfw/lib/$(MACH64)

SFWSHARE =	/usr/sfw/share

SFWSHAREMAN =	/usr/sfw/share/man

SFWSHAREMAN1 =	/usr/sfw/share/man/man1

PROTOSFWBIN =	$(PROTO_DIR)/$(SFWBIN)

PROTOSFWLIB =	$(PROTO_DIR)/$(SFWLIB)

PROTOSFWLIB64 =	$(PROTO_DIR)/$(SFWLIB64)

PROTOSFWSHARE =	$(PROTO_DIR)/$(SFWSHARE)

PROTOSFWSHAREMAN =	$(PROTO_DIR)/$(SFWSHAREMAN)

PROTOSFWSHAREMAN1 =	$(PROTO_DIR)/$(SFWSHAREMAN1)

PROTOSFWINCLUDE =	$(PROTO_DIR)/$(SFWINCLUDE)

GNUBIN =	/usr/gnu/bin

GNULIB =	/usr/gnu/lib

GNULIB64 =	/usr/gnu/lib/$(MACH64)

GNUSHARE =	/usr/gnu/share

GNUSHAREMAN =	/usr/gnu/share/man

GNUSHAREMAN1 =	/usr/gnu/share/man/man1

PROTOGNUBIN =	$(PROTO_DIR)/$(GNUBIN)

PROTOGNUSHARE =	$(PROTO_DIR)/$(GNUSHARE)

PROTOGNUSHAREMAN =	$(PROTO_DIR)/$(GNUSHAREMAN)

PROTOGNUSHAREMAN1 =	$(PROTO_DIR)/$(GNUSHAREMAN1)

# 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)

# 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

CONFIGURE_32_and_64 =	$(CONFIGURE_32) $(CONFIGURE_64)

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)

# NO_ARCH uses BITS=32 because some path setting macros use $(BITS)

$(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_NO_ARCH)/.installed:  BITS=32

$(BUILD_DIR_32)/.installed:       BITS=32

$(BUILD_DIR_64)/.installed:       BITS=64

# 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

COMPONENT_SYSTEM_TEST_RESULTS_DIR =	$(COMPONENT_DIR)/test

# set the default master test results file

COMPONENT_TEST_MASTER =		$(COMPONENT_TEST_RESULTS_DIR)/results-$(BITS).master

# 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|$(SOURCE_DIR)|\\$$(SOURCE_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 = \

	@if [ -e $(COMPONENT_TEST_MASTER) ]; \

	then \

		print "\#!/bin/sh" > $(COMPONENT_TEST_TRANSFORM_CMD); \

        	print '$(COMPONENT_TEST_TRANSFORMER) ' \

			$(COMPONENT_TEST_TRANSFORMS) \

                	' \\' >> $(COMPONENT_TEST_TRANSFORM_CMD); \

        	print '$(COMPONENT_TEST_OUTPUT) \\' \

                	>> $(COMPONENT_TEST_TRANSFORM_CMD); \

        	print '> $(COMPONENT_TEST_SNAPSHOT)' \

                	>> $(COMPONENT_TEST_TRANSFORM_CMD); \

	else \

		print 'Cannot find $(COMPONENT_TEST_MASTER)'; \

		exit 2; \

	fi

# 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 = \

	@if [ -e $(COMPONENT_TEST_MASTER) ]; \

	then \

		$(SHELL) $(COMPONENT_TEST_TRANSFORM_CMD); \

	else \

		print 'Cannot find $(COMPONENT_TEST_MASTER)'; \

		exit 2; \

	fi

# set the default command used to compare the master results with the snapshot

COMPONENT_TEST_COMPARE_CMD =	$(GDIFF) -uN

# set the default way that master and snapshot test results are compared

COMPONENT_TEST_COMPARE = \

	@if [ -e $(COMPONENT_TEST_MASTER) ]; \

	then \

		$(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 \

	else \

		print 'Cannot find $(COMPONENT_TEST_MASTER)'; \

		exit 2; \

	fi

# set the default env command to use for test of the component

COMPONENT_TEST_ENV_CMD =        $(ENV)

COMPONENT_SYSTEM_TEST_ENV_CMD =	$(ENV)

# set the default command to use for test of the component

COMPONENT_TEST_CMD =		$(GMAKE)

COMPONENT_SYSTEM_TEST_CMD =	$(GMAKE)

# set the default target for test of the component

COMPONENT_TEST_TARGETS =	check

COMPONENT_SYSTEM_TEST_TARGETS =	check

# set the default directory for test of the component

COMPONENT_TEST_DIR =		$(@D)

COMPONENT_SYSTEM_TEST_DIR =	$(@D)

# determine the type of tests we want to run.

ifeq ($(strip $(wildcard $(COMPONENT_SYSTEM_TEST_RESULTS_DIR)/results-*.master)),)

SYSTEM_TEST_NO_ARCH =		$(BUILD_DIR_NO_ARCH)/.system-tested

SYSTEM_TEST_32 =		$(BUILD_DIR_32)/.system-tested

SYSTEM_TEST_64 =		$(BUILD_DIR_64)/.system-tested

else

SYSTEM_TEST_NO_ARCH =		$(BUILD_DIR_NO_ARCH)/.system-tested-and-compared

SYSTEM_TEST_32 =		$(BUILD_DIR_32)/.system-tested-and-compared

SYSTEM_TEST_64 =		$(BUILD_DIR_64)/.system-tested-and-compared

endif

SYSTEM_TEST_32_and_64 =	$(SYSTEM_TEST_32) $(SYSTEM_TEST_64)

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)

# When running tests at the top level, skip those tests,

# by redefining the above TEST_* targets,

# when a component Makefile includes $(SKIP_TEST_AT_TOP_LEVEL).

# It's done in separate skip-test.mk file, to allow inclusion of 

# a multi-line ifdef statement which is evaluated at the component

# Makefile level

SKIP_TEST_AT_TOP_LEVEL = $(eval include $(WS_MAKE_RULES)/skip-test.mk)

$(BUILD_DIR_NO_ARCH)/.system-tested:			BITS=32

$(BUILD_DIR_32)/.system-tested:				BITS=32

$(BUILD_DIR_64)/.system-tested:				BITS=64

$(BUILD_DIR_NO_ARCH)/.system-tested-and-compared:	BITS=32

$(BUILD_DIR_32)/.system-tested-and-compared:		BITS=32

$(BUILD_DIR_64)/.system-tested-and-compared:		BITS=64

$(BUILD_DIR_NO_ARCH)/.tested:				BITS=32

$(BUILD_DIR_32)/.tested:				BITS=32

$(BUILD_DIR_64)/.tested:				BITS=64

$(BUILD_DIR_NO_ARCH)/.tested-and-compared:		BITS=32

$(BUILD_DIR_32)/.tested-and-compared:			BITS=32

$(BUILD_DIR_64)/.tested-and-compared:			BITS=64

$(BUILD_DIR_NO_ARCH)/.system-tested:			$(BUILD_DIR_32)

$(BUILD_DIR_32)/.system-tested:				$(BUILD_DIR_32)

$(BUILD_DIR_64)/.system-tested:				$(BUILD_DIR_64)

$(BUILD_DIR_NO_ARCH)/.system-tested-and-compared:	$(BUILD_DIR_32)

$(BUILD_DIR_32)/.system-tested-and-compared:		$(BUILD_DIR_32)

$(BUILD_DIR_64)/.system-tested-and-compared:		$(BUILD_DIR_64)

$(BUILD_DIR_32) $(BUILD_DIR_64):

	$(MKDIR) $(@)

# BUILD_TOOLS is the root of all tools not normally installed on the system.

BUILD_TOOLS ?=	/ws/on12-tools

SPRO_ROOT =	$(BUILD_TOOLS)/SUNWspro

SPRO_VROOT =	$(SPRO_ROOT)/solarisstudio12.4

PARFAIT_TOOLS=	$(WS_TOOLS)/$(MACH)/parfait

PARFAIT_TOOLS_GCC3=	$(PARFAIT_TOOLS)/gcc3

PARFAIT= $(PARFAIT_ROOT)/bin/parfait

export PARFAIT_NATIVESUNCC=$(SPRO_VROOT)/bin/cc

export PARFAIT_NATIVESUNCXX=$(SPRO_VROOT)/bin/CC

export PARFAIT_NATIVEGCC=$(GCC_ROOT)/bin/gcc

export PARFAIT_NATIVEGXX=$(GCC_ROOT)/bin/g++

GCC_ROOT =	/usr/gcc/4.8

GCC3_ROOT =	/usr/gcc/3.4

CC.studio.32 =	$(SPRO_VROOT)/bin/cc

CXX.studio.32 =	$(SPRO_VROOT)/bin/CC

CC.studio.64 =	$(SPRO_VROOT)/bin/cc

CXX.studio.64 =	$(SPRO_VROOT)/bin/CC

CC.gcc.32 =	$(GCC_ROOT)/bin/gcc

CXX.gcc.32 =	$(GCC_ROOT)/bin/g++

CC.gcc.64 =	$(GCC_ROOT)/bin/gcc

CXX.gcc.64 =	$(GCC_ROOT)/bin/g++

CC.gcc3.32 =	$(GCC3_ROOT)/bin/gcc

CXX.gcc3.32 =	$(GCC3_ROOT)/bin/g++

CC.gcc3.64 =	$(GCC3_ROOT)/bin/gcc

CXX.gcc3.64 =	$(GCC3_ROOT)/bin/g++

lint.32 =	$(SPRO_VROOT)/bin/lint -m32

lint.64 =	$(SPRO_VROOT)/bin/lint -m64

LINT =		$(lint.$(BITS))

LD =		/usr/bin/ld

ifeq   ($(strip $(PARFAIT_BUILD)),yes)

CC.studio.32 =	$(PARFAIT_TOOLS)/cc

CXX.studio.32 =	$(PARFAIT_TOOLS)/CC

CC.studio.64 =	$(PARFAIT_TOOLS)/cc

CXX.studio.64 =	$(PARFAIT_TOOLS)/CC

CC.gcc.32 =	$(PARFAIT_TOOLS)/gcc

CXX.gcc.32 =	$(PARFAIT_TOOLS)/g++

CC.gcc.64 =	$(PARFAIT_TOOLS)/gcc

CXX.gcc.64 =	$(PARFAIT_TOOLS)/g++

CC.gcc3.32 =	$(PARFAIT_TOOLS_GCC3)/gcc

CXX.gcc3.32 =	$(PARFAIT_TOOLS_GCC3)/g++

CC.gcc3.64 =	$(PARFAIT_TOOLS_GCC3)/gcc

CXX.gcc3.64 =	$(PARFAIT_TOOLS_GCC3)/g++

LD =		$(PARFAIT_TOOLS)/ld

endif

CC =		$(CC.$(COMPILER).$(BITS))

CXX =		$(CXX.$(COMPILER).$(BITS))

RUBY_VERSION =	1.9

RUBY_LIB_VERSION =	1.9.1

RUBY.1.8 =	/usr/ruby/1.8/bin/ruby

RUBY.1.9 =	/usr/ruby/1.9/bin/ruby

RUBY =		$(RUBY.$(RUBY_VERSION))

# 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.2.6.VENDOR_PACKAGES.32 = /usr/lib/python2.6/vendor-packages

PYTHON.2.6.VENDOR_PACKAGES.64 = /usr/lib/python2.6/vendor-packages/64

PYTHON.2.6.VENDOR_PACKAGES = $(PYTHON.2.6.VENDOR_PACKAGES.$(BITS))

PYTHON.2.7.VENDOR_PACKAGES.32 = /usr/lib/python2.7/vendor-packages

PYTHON.2.7.VENDOR_PACKAGES.64 = /usr/lib/python2.7/vendor-packages/64

PYTHON.2.7.VENDOR_PACKAGES = $(PYTHON.2.7.VENDOR_PACKAGES.$(BITS))

PYTHON.3.4.VENDOR_PACKAGES.64 = /usr/lib/python3.4/vendor-packages/64

PYTHON.3.4.VENDOR_PACKAGES = $(PYTHON.3.4.VENDOR_PACKAGES.$(BITS))

PYTHON_VENDOR_PACKAGES.32 = /usr/lib/python$(PYTHON_VERSION)/vendor-packages