#

# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# This code is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 2 only, as

# published by the Free Software Foundation.  Oracle designates this

# particular file as subject to the "Classpath" exception as provided

# by Oracle in the LICENSE file that accompanied this code.

#

# This code is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# version 2 for more details (a copy is included in the LICENSE file that

# accompanied this code).

#

# You should have received a copy of the GNU General Public License version

# 2 along with this work; if not, write to the Free Software Foundation,

# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

#

#

# Definitions for all platforms.

#

# Normally the convention is that these alternate definitions of

#   primary make variables are never defined inside the Makefiles anywhere

#   but are defined via environment variables or set on the make command

#   line. So you should never see an ALT_* variable defined in any

#   makefiles, just used. This is the convention and there are some

#   exceptions, either mistakes or unusual circumstances.

#

# The naming convention for the default value of one of these variables

#   that has an ALT_* override capability is to name the default value with a

#   leading underscore (_). So for XXX you would have:

#      _XXX      default value

#      ALT_XXX   any override the user is providing if any

#      XXX       the final value, either the default _XXX or the ALT_XXX value.

#

# On Directory names. In very rare cases should the Windows directory

#    names use the backslash, please use the C:/ style of windows paths.

#    Avoid duplicating the // characters in paths, this has known to cause

#    strange problems with jar and other utilities, e.g. /a//b/ != /a/b/.

#    Some of these variables have an explicit trailing / character, but in

#    general, they should NOT have the trailing / character.

# Get shared system utilities macros defined

include $(JDK_MAKE_SHARED_DIR)/Defs-utils.gmk

# Assumes ARCH, PLATFORM, ARCH_VM_SUBDIR, JDK_TOPDIR, etc. have been defined.

# Simple pwd path

# NOTE: Just use the shell's cd and pwd here, more reliable at sanity time.

define PwdPath

$(shell cd $1 2> $(DEV_NULL) && pwd)

endef

define AbsPwdPathCheck

$(shell cd .. 2> $(DEV_NULL) && cd $1 2> $(DEV_NULL) && pwd)

endef

# Checks an ALT value for spaces (should be one word), 

#       warns and returns Check_ALT_$1 if spaces

define AltCheckSpaces

$(if $(word 2,$($1)),$(warning "WARNING: Value of $1 contains a space: '$($1)', check or set ALT_$1")Check_ALT_$1,$($1))

endef

# Checks an ALT value for empty, warns and returns Check_ALT_$1 if empty

define AltCheckValue

$(if $($1),$($1),$(warning "WARNING: Value of $1 cannot be empty, check or set ALT_$1")Check_ALT_$1)

endef

# Checks any value for empty, warns and returns $2 if empty

define CheckValue

$(if $($1),$($1),$(warning "WARNING: Value of $1 cannot be empty, will use '$2'")$2)

endef

# Prefix for a utility prefix path, if empty leave alone, otherwise end with a /

define PrefixPath

$(if $1,$(subst //,/,$1/),)

endef

# Select a directory if it exists, or the alternate 2 or the alternate 3

define DirExists

$(shell \

  if [ -d "$1" ]; then  \

    echo "$1"; \

  elif [ -d "$2" ]; then \

    echo "$2"; \

  else \

    echo "$3"; \

  fi)

endef

# Select a directory if it exists, or the alternate 2, or the alternate 3, or the alternate 4

define DirExists4

$(shell \

  if [ -d "$1" ]; then  \

    echo "$1"; \

  elif [ -d "$2" ]; then \

    echo "$2"; \

  elif [ -d "$3" ]; then \

    echo "$3"; \

  else \

    echo "$4"; \

  fi)

endef

# Select a writable directory if it exists and is writable, or the alternate

define WriteDirExists

$(shell \

  if [ -d "$1" -a -w "$1" ]; then  \

    echo "$1"; \

  else \

    echo "$2"; \

  fi)

endef

# Select a file if it exists, or the alternate 1, or the alternate 2

define FileExists

$(shell \

  if [ -r "$1" ]; then \

    echo "$1"; \

  elif [ -r "$2" ]; then \

    echo "$2"; \

  else \

    echo "NO_FILE_EXISTS"; \

  fi)

endef

# Given a line of text, get the version number from it

define GetVersion

$(shell echo $1 | sed -e 's@[^0-9]*\([0-9][0-9]*\.[0-9][.0-9]*\).*@\1@' )

endef

# Return one part of the version numbers, watch out for non digits.

define VersionWord # Number Version

$(word $1,$(subst ., ,$(subst -, ,$2)))

endef

# Given a major.minor.micro version, return the major, minor, or micro number

define MajorVersion

$(if $(call VersionWord,1,$1),$(call VersionWord,1,$1),0)

endef

define MinorVersion

$(if $(call VersionWord,2,$1),$(call VersionWord,2,$1),0)

endef

define MicroVersion

$(if $(call VersionWord,3,$1),$(call VersionWord,3,$1),0)

endef

# Macro that returns missing, same, newer, or older $1=version $2=required

define CheckVersions

$(shell \

  if [ "$1" = "" -o "$2" = "" ]; then \

    echo missing; \

  elif [ "$1" = "$2" ]; then \

    echo same; \

  elif [ $(call MajorVersion,$1) -lt $(call MajorVersion,$2) ] ; then \

    echo older; \

  elif [ $(call MajorVersion,$1) -gt $(call MajorVersion,$2) ] ; then \

    echo newer; \

  elif [ $(call MinorVersion,$1) -lt $(call MinorVersion,$2) ]; then \

    echo older; \

  elif [ $(call MinorVersion,$1) -gt $(call MinorVersion,$2) ]; then \

    echo newer; \

  elif [ $(call MicroVersion,$1) -lt $(call MicroVersion,$2) ]; then \

    echo older; \

  elif [ $(call MicroVersion,$1) -gt $(call MicroVersion,$2) ]; then \

    echo newer; \

  else \

    echo same; \

  fi)

endef

# Make sure certain variables are non-empty at this point

_check_values:=\

$(call CheckValue,ARCH,),\

$(call CheckValue,ARCH_DATA_MODEL,),\

$(call CheckValue,ARCH_VM_SUBDIR,),\

$(call CheckValue,JDK_TOPDIR,),\

$(call CheckValue,JDK_MAKE_SHARED_DIR,),\

$(call CheckValue,VARIANT,),\

$(call CheckValue,PLATFORM,)

# Misc common settings for all workspaces

#   This determines the version of the product, and the previous version or boot

ifndef JDK_MAJOR_VERSION

  JDK_MAJOR_VERSION      = 1

  PREVIOUS_MAJOR_VERSION = 1

endif

ifndef JDK_MINOR_VERSION

  JDK_MINOR_VERSION      = 7

  PREVIOUS_MINOR_VERSION = 6

endif

ifndef JDK_MICRO_VERSION

  JDK_MICRO_VERSION      = 0

  PREVIOUS_MICRO_VERSION = 0

endif

ifndef MILESTONE

  MILESTONE = internal

endif

# Default names

ifdef OPENJDK

  LAUNCHER_NAME = openjdk

  PRODUCT_NAME = OpenJDK

  PRODUCT_SUFFIX = Runtime Environment

  JDK_RC_PLATFORM_NAME = Platform

  COMPANY_NAME = N/A

else

  LAUNCHER_NAME = java

  PRODUCT_NAME = Java(TM)

  ifeq ($(J4B), true)

    PRODUCT_SUFFIX = SE Runtime Environment for Business

  else

    PRODUCT_SUFFIX = SE Runtime Environment

  endif

  JDK_RC_PLATFORM_NAME = Platform SE

  COMPANY_NAME = Oracle Corporation

endif

RUNTIME_NAME = $(PRODUCT_NAME) $(PRODUCT_SUFFIX)

ifndef BUILD_NUMBER

  JDK_BUILD_NUMBER = b00

else

  ifndef JDK_BUILD_NUMBER

    JDK_BUILD_NUMBER = $(BUILD_NUMBER)

  endif

endif

# Default variant is the optimized version of everything

#    can be OPT or DBG,  default is OPT

#    Determine the extra pattern to add to the release name for debug/fastdebug.

#    Determine the JDK_IMPORT_VARIANT, so we get the right VM files copied over.

#    Determine suffix for obj directory or OBJDIR, for .o files.

#    (by keeping .o files separate, just .o files, they don't clobber each

#     other, however, the library files will clobber each other).

#

ifeq ($(VARIANT), DBG)

  BUILD_VARIANT_RELEASE=-debug

  OBJDIRNAME_SUFFIX=_g

else

  BUILD_VARIANT_RELEASE=

  OBJDIRNAME_SUFFIX=

endif

ifeq ($(FASTDEBUG), true)

  VARIANT=DBG

  BUILD_VARIANT_RELEASE=-fastdebug

  OBJDIRNAME_SUFFIX=_gO

  _JDK_IMPORT_VARIANT=/fastdebug

endif

# Depending on the flavor of the build, add a -debug or -fastdebug to the name

ifdef DEBUG_NAME

  BUILD_VARIANT_RELEASE=-$(DEBUG_NAME)

endif

# These default values are redefined during a release build.

#    CTE can set JDK_UPDATE_VERSION during the update release

ifdef JDK_UPDATE_VERSION

  JDK_VERSION  = $(JDK_MAJOR_VERSION).$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION)_$(JDK_UPDATE_VERSION)

  MARKETING_NUMBER := $(shell \

	$(ECHO) $(JDK_UPDATE_VERSION) | $(NAWK) '{if (substr($$0,1,1)=="0") print substr($$0, 2); else print $$0;}')

  MARKET_NAME= $(shell $(ECHO) " Update $(MARKETING_NUMBER)")

  JDK_MKTG_VERSION  = $(JDK_MINOR_VERSION)u$(MARKETING_NUMBER)

else

  JDK_VERSION  = $(JDK_MAJOR_VERSION).$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION)

  JDK_MKTG_VERSION  = $(JDK_MINOR_VERSION)

  MARKET_NAME=

endif

JDK_UNDERSCORE_VERSION =  $(subst .,_,$(JDK_VERSION))

JDK_MKTG_UNDERSCORE_VERSION =  $(subst .,_,$(JDK_MKTG_VERSION))

# RELEASE is JDK_VERSION and -MILESTONE if MILESTONE is set

ifneq ($(MILESTONE),fcs)

  RELEASE      = $(JDK_VERSION)-$(MILESTONE)$(BUILD_VARIANT_RELEASE)

else

  RELEASE      = $(JDK_VERSION)$(BUILD_VARIANT_RELEASE)

endif

# FULL_VERSION is RELEASE and -BUILD_NUMBER if BUILD_NUMBER is set

ifdef BUILD_NUMBER

  FULL_VERSION = $(RELEASE)-$(BUILD_NUMBER)

else

  BUILD_NUMBER = b00

  ifndef USER_RELEASE_SUFFIX

    BUILD_DATE := $(shell $(DATE) '+%Y_%m_%d_%H_%M')

    CLEAN_USERNAME := $(shell $(ECHO) "$(USER)" | $(TR) -d -c '[:alnum:]')

    USER_RELEASE_SUFFIX := $(shell $(ECHO) "$(CLEAN_USERNAME)_$(BUILD_DATE)" | $(TR) '[:upper:]' '[:lower:]' )

  endif

  export USER_RELEASE_SUFFIX

  FULL_VERSION = $(RELEASE)-$(USER_RELEASE_SUFFIX)-$(BUILD_NUMBER)

endif

# Promoted build location

PROMOTED_RE_AREA = $(SLASH_JAVA)/re/jdk/$(JDK_VERSION)/promoted

PROMOTED_BUILD_LATEST = latest

PROMOTED_BUILD_BASEDIR = $(PROMOTED_RE_AREA)/$(PROMOTED_BUILD_LATEST)

PROMOTED_BUILD_DISTDIR = $(PROMOTED_BUILD_BASEDIR)/dist/$(PLATFORM)-$(ARCH)

PROMOTED_BUILD_BINARIES = $(PROMOTED_BUILD_BASEDIR)/binaries

# PARALLEL_COMPILE_JOBS: is the number of compiles done in parallel.

#  If the user sets ALT_PARALLEL_COMPILE_JOBS, then COMPILE_APPROACH is set

#  to parallel.

#

#  Recommended setting: 2 seems to be ideal for single cpu machines,

#                       2 times the number of CPU's is a basic formula, 

#                       but probably not more than 4 if the machine is 

#                       being shared by others, or the machine is limited 

#                       in RAM or swap.

#

ifdef ALT_PARALLEL_COMPILE_JOBS

  PARALLEL_COMPILE_JOBS=$(ALT_PARALLEL_COMPILE_JOBS)

else

  PARALLEL_COMPILE_JOBS=2

endif

# Previous JDK release (version of BOOTDIR version)

ifdef ALT_PREVIOUS_JDK_VERSION

  PREVIOUS_JDK_VERSION = $(ALT_PREVIOUS_JDK_VERSION)

else

  PREVIOUS_JDK_VERSION  = $(PREVIOUS_MAJOR_VERSION).$(PREVIOUS_MINOR_VERSION).$(PREVIOUS_MICRO_VERSION)

endif

export PREVIOUS_JDK_VERSION

PREVIOUS_JDK_VERSION:=$(call AltCheckSpaces,PREVIOUS_JDK_VERSION)

PREVIOUS_JDK_VERSION:=$(call AltCheckValue,PREVIOUS_JDK_VERSION)

# Version with _ instead of . in number

ifeq ($(PREVIOUS_MINOR_VERSION),5)

  PREVIOUS_JDK_UNDERSCORE_VERSION =  $(subst .,_,$(PREVIOUS_JDK_VERSION))

else

  PREVIOUS_JDK_UNDERSCORE_VERSION = $(PREVIOUS_MINOR_VERSION)

endif

# Include any private definitions for this set of workspaces

_PRIVATE_DEFS_FILE=$(JDK_MAKE_SHARED_DIR)/PrivateDefs.gmk

ifeq ($(USING_PRIVATE_DEFS),)

  USING_PRIVATE_DEFS:=$(shell if [ -f $(_PRIVATE_DEFS_FILE) ]; then echo true; else echo false; fi)

endif

ifeq ($(USING_PRIVATE_DEFS),true)

dummy:=$(warning "WARNING: Using definitions from $(_PRIVATE_DEFS_FILE)")

include $(_PRIVATE_DEFS_FILE)

endif

# OUTPUTDIR: Location of all output for the build

ifdef ALT_OUTPUTDIR

  OUTPUTDIR:=$(subst \,/,$(ALT_OUTPUTDIR))

  # Assumes this is absolute (checks later)

  ABS_OUTPUTDIR:=$(OUTPUTDIR)

else

  ifndef _OUTPUTDIR

    # Default:  Get "build" parent directory, which should always exist

    ifndef BUILD_PARENT_DIRECTORY

      BUILD_PARENT_DIRECTORY=$(BUILDDIR)/..

    endif

    ifdef OPENJDK

      _OUTPUTDIRNAME=$(PLATFORM)-$(ARCH)$(OPENJDK_SUFFIX)

    else

      _OUTPUTDIRNAME=$(PLATFORM)-$(ARCH)

    endif

    _OUTPUTDIR=$(BUILD_PARENT_DIRECTORY)/build/$(_OUTPUTDIRNAME)

  endif

  OUTPUTDIR:=$(_OUTPUTDIR)

endif

# Check for spaces and null value

OUTPUTDIR:=$(call AltCheckSpaces,OUTPUTDIR)

OUTPUTDIR:=$(call AltCheckValue,OUTPUTDIR)

# Get platform specific settings

# NB: OUTPUTDIR must be defined. Otherwise hotspot import detection will not work correctly

# On other hand this must be included early as it provides platform specific defines such as FullPath

include $(JDK_MAKE_SHARED_DIR)/Defs-versions.gmk

# Get platform specific settings (defines COMPILER_PATH)

include $(JDK_MAKE_SHARED_DIR)/Defs-$(PLATFORM).gmk

# Components

ifdef ALT_LANGTOOLS_DIST

  LANGTOOLS_DIST :=$(call FullPath,$(ALT_LANGTOOLS_DIST))

else

  LANGTOOLS_DIST =

endif

ifdef ALT_CORBA_DIST

  CORBA_DIST :=$(call FullPath,$(ALT_CORBA_DIST))

else

  CORBA_DIST =

endif

ifdef ALT_JAXP_DIST

  JAXP_DIST :=$(call FullPath,$(ALT_JAXP_DIST))

else

  JAXP_DIST =

endif

ifdef ALT_JAXWS_DIST

  JAXWS_DIST :=$(call FullPath,$(ALT_JAXWS_DIST))

else

  JAXWS_DIST =

endif

# HOTSPOT_DOCS_IMPORT_PATH: Path to hotspot docs files to import into the docs generation

ifdef ALT_HOTSPOT_DOCS_IMPORT_PATH

  HOTSPOT_DOCS_IMPORT_PATH :=$(call FullPath,$(ALT_HOTSPOT_DOCS_IMPORT_PATH))

else

  HOTSPOT_DOCS_IMPORT_PATH :=$(call DirExists,$(HOTSPOT_IMPORT_PATH)/docs,$(PROMOTED_BUILD_BASEDIR)/docs,/NO_DOCS_DIR)

endif

# These are the same on all platforms but require the above platform include 1st

# BOOTDIR: Bootstrap JDK, previous released JDK.

#   _BOOTDIR1 and _BOOTDIR2 picked by platform

#   Platform may optionally define _BOOTDIR3 as well.

ifdef ALT_BOOTDIR

  BOOTDIR =$(ALT_BOOTDIR)

else

  ifdef _BOOTDIR3

    BOOTDIR  :=$(call DirExists4,$(_BOOTDIR1),$(_BOOTDIR2),$(_BOOTDIR3),/NO_BOOTDIR)

  else

    BOOTDIR  :=$(call DirExists,$(_BOOTDIR1),$(_BOOTDIR2),/NO_BOOTDIR)

  endif

endif

export BOOTDIR

BOOTDIR:=$(call AltCheckSpaces,BOOTDIR)

BOOTDIR:=$(call AltCheckValue,BOOTDIR)

# PREVIOUS_FCS_RE_AREA: re path to where previous release binaries/bundles are

PREVIOUS_FCS_RE_AREA = $(SLASH_JAVA)/re/jdk/$(PREVIOUS_JDK_VERSION)/archive/fcs

# PREVIOUS_RELEASE_IMAGE: Previous install image to compare against

ifdef ALT_PREVIOUS_RELEASE_IMAGE

  # Explicit image provided, no bundle access needed

  PREVIOUS_RELEASE_IMAGE :=$(call FullPath,$(ALT_PREVIOUS_RELEASE_IMAGE))

else

  # PREVIOUS_RELEASE_PATH: path to where previous release bundles are

  ifdef ALT_PREVIOUS_RELEASE_PATH

    PREVIOUS_RELEASE_PATH :=$(call OptFullPath,$(ALT_PREVIOUS_RELEASE_PATH))

  else

    PREVIOUS_RELEASE_PATH := \

	$(call DirExists,$(PREVIOUS_FCS_RE_AREA)/bundles/$(PLATFORM)-$(ARCH),,)

  endif

  # Depending on if we have access to these bundles

  ifeq ($(PREVIOUS_RELEASE_PATH),)

    # Use images in re area or BOOTDIR (which is normally the previous release)

    PREVIOUS_RELEASE_IMAGE := \

         $(call DirExists,$(PREVIOUS_FCS_RE_AREA)/binaries/$(PLATFORM)-$(ARCH),$(BOOTDIR),)

  else

    # Get names of and paths to bundles

    PREVIOUS_RELEASE_PATH:=$(call AltCheckSpaces,PREVIOUS_RELEASE_PATH)

    PREVIOUS_RELEASE_PATH:=$(call AltCheckValue,PREVIOUS_RELEASE_PATH)

    export PREVIOUS_RELEASE_PATH

    # PREVIOUS_JDK_FILE: filename of install bundle for previous JDK

    ifdef ALT_PREVIOUS_JDK_FILE

      PREVIOUS_JDK_FILE  =$(ALT_PREVIOUS_JDK_FILE)

    else

      PREVIOUS_JDK_FILE = \

	  jdk-$(PREVIOUS_JDK_UNDERSCORE_VERSION)-$(PLATFORM)-$(ARCH)$(BUNDLE_FILE_SUFFIX)

    endif

    export PREVIOUS_JDK_FILE

    PREVIOUS_JDK_FILE:=$(call AltCheckSpaces,PREVIOUS_JDK_FILE)

    PREVIOUS_JDK_FILE:=$(call AltCheckValue,PREVIOUS_JDK_FILE)

    # PREVIOUS_JRE_FILE: filename of install bundle for previous JRE

    ifdef ALT_PREVIOUS_JRE_FILE

      PREVIOUS_JRE_FILE  =$(ALT_PREVIOUS_JRE_FILE)

    else

      PREVIOUS_JRE_FILE = \

	  jre-$(PREVIOUS_JDK_UNDERSCORE_VERSION)-$(PLATFORM)-$(ARCH)$(BUNDLE_FILE_SUFFIX)

    endif

    export PREVIOUS_JRE_FILE

    PREVIOUS_JRE_FILE:=$(call AltCheckSpaces,PREVIOUS_JRE_FILE)

    PREVIOUS_JRE_FILE:=$(call AltCheckValue,PREVIOUS_JRE_FILE)

    # Paths to these bundles

    PREVIOUS_JRE_BUNDLE = $(PREVIOUS_RELEASE_PATH)/$(PREVIOUS_JRE_FILE)

    PREVIOUS_JDK_BUNDLE = $(PREVIOUS_RELEASE_PATH)/$(PREVIOUS_JDK_FILE)

  endif

endif

# Indicate we are using an image comparison

ifneq ($(PREVIOUS_RELEASE_IMAGE),)

    PREVIOUS_RELEASE_PATH = USING-PREVIOUS_RELEASE_IMAGE

    PREVIOUS_JRE_BUNDLE   = USING-PREVIOUS_RELEASE_IMAGE

    PREVIOUS_JDK_BUNDLE   = USING-PREVIOUS_RELEASE_IMAGE

endif

# CACERTS_FILE: if OPENJDK is false and the internal version of the file 

#		(that is, non-empty) is available, use it, otherwise use an 

#		empty keystore.

#

# We put this variable here for sanity checks and in case another

# components will need to know which cacerts file is being used.

#

ifdef ALT_CACERTS_FILE

  CACERTS_FILE = $(ALT_CACERTS_FILE)

else

  CACERTS_EXT   = $(SHARE_SRC)/lib/security/cacerts

  ifdef OPENJDK

    CACERTS_FILE  :=$(CACERTS_EXT)

  else # (!OPENJDK)

    CACERTS_INT   = $(CLOSED_SHARE_SRC)/lib/security/cacerts.internal