#

# Copyright 2005-2009 Sun Microsystems, Inc.  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.  Sun designates this

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

# by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

# CA 95054 USA or visit www.sun.com if you need additional information or

# have any questions.

#

#

# Definitions for Windows.

#

# Default for COMPILER_WARNINGS_FATAL on Windows (C++ compiler warnings)

#    Level: Default is 3, 0 means none, 4 is the most but may be unreliable

#    Some makefiles may have set this to 0 to turn off warnings completely,

#    which also effectively creates a COMPILER_WARNINGS_FATAL=false situation.

#    Program.gmk may turn this down to 2 (building .exe's).

#    Windows 64bit platforms are less likely to be warning free.

#    Historically, Windows 32bit builds should be mostly warning free.

ifndef COMPILER_WARNING_LEVEL

  COMPILER_WARNING_LEVEL=3

endif

ifndef COMPILER_WARNINGS_FATAL

  COMPILER_WARNINGS_FATAL=false

endif

# Windows should use parallel compilation for best build times

ifndef COMPILE_APPROACH

  COMPILE_APPROACH = normal

endif

# Indication that we are doing an incremental build.

#    This may trigger the creation of make depend files.

#    (This may not be working on windows yet, always force to false.)

override INCREMENTAL_BUILD = false

# WARNING: This is extremely touch stuff, between CYGWIN vs. MKS and all

#          variations of MKS and CYGWIN releases, and 32bit vs 64bit,

#          this file can give you nightmares.

#

# Notes:

#   Keep all paths in the windows "mixed" style except CYGWIN UNXIXCOMMAND_PATH.

#   Use of PrefixPath is critical, some variables must end with / (see NOTE).

#   Use of quotes is critical due to possible spaces in paths coming from

#     the environment variables, be careful.

#   First convert \ to / with subst, keep it quoted due to blanks, then

#     use cygpath -s or dosname -s to get the short non-blank name.

#   If the MKS is old and doesn't have a dosname -s, you will be forced

#     to set ALT variables with the short non-space directory names.

#     If dosname doesn't appear to work, we won't use it.

#     The dosname utility also wants to accept stdin if it is not supplied

#     any path on the command line, this is really dangerous when using

#     make variables that can easily become empty, so I use:

#        echo $1 | dosname -s     instead of    dosname -s $1

#     to prevent dosname from hanging up the make process when $1 is empty.

#     The cygpath utility does not have this problem.

#   The ALT values should never really have spaces or use \.

#   Suspect these environment variables to have spaces and/or \ characters:

#     SYSTEMROOT, SystemRoot, WINDIR, windir, PROGRAMFILES, ProgramFiles,

#     MSTOOLS, Mstools, MSSDK, MSSdk, VC71COMNTOOLS, 

#     MSVCDIR, MSVCDir.

#     So use $(subst \,/,) on them first adding quotes and placing them in

#         their own variable assigned with :=, then use FullPath.

#

# Use FullPath to get C:/ style non-spaces path. Never ends with a /!

ifdef USING_CYGWIN

# We assume cygpath is available in the search path

#    NOTE: Use of 'pwd' with CYGWIN will not get you a mixed style path!

CYGPATH_CMD=cygpath -a -s -m

define FullPath

$(shell $(CYGPATH_CMD) $1 2> $(DEV_NULL))

endef

define OptFullPath

$(shell if [ "$1" != "" -a -d "$1" ]; then $(CYGPATH_CMD) "$1"; else echo "$1"; fi)

endef

else

# Temporary until we upgrade to MKS 8.7, MKS pwd returns mixed mode path

define FullPath

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

endef

define OptFullPath

$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi)

endef

endif

# System drive

ifdef SYSTEMDRIVE

  _system_drive =$(SYSTEMDRIVE)

else

  ifdef SystemDrive

    _system_drive =$(SystemDrive)

  endif

endif

_system_drive:=$(call CheckValue,_system_drive,C:)

# UNIXCOMMAND_PATH: path to where the most common Unix commands are.

#  NOTE: Must end with / so that it could be empty, allowing PATH usage.

ifndef UNIXCOMMAND_PATH

  ifdef ALT_UNIXCOMMAND_PATH

    xALT_UNIXCOMMAND_PATH  :="$(subst \,/,$(ALT_UNIXCOMMAND_PATH))"

    fxALT_UNIXCOMMAND_PATH :=$(call FullPath,$(xALT_UNIXCOMMAND_PATH))

    UNIXCOMMAND_PATH       :=$(call PrefixPath,$(fxALT_UNIXCOMMAND_PATH))

  else

    ifdef USING_CYGWIN

      UNIXCOMMAND_PATH :=$(call PrefixPath,/usr/bin)

    else

      ifdef ROOTDIR

        xROOTDIR :="$(subst \,/,$(ROOTDIR))"

        _rootdir :=$(call FullPath,$(xROOTDIR))

      else

        xROOTDIR :="$(_system_drive)/mksnt"

        _rootdir :=$(call FullPath,$(xROOTDIR))

      endif

      ifneq ($(_rootdir),)

        UNIXCOMMAND_PATH :=$(call PrefixPath,$(_rootdir)/mksnt)

      endif

    endif

  endif

  UNIXCOMMAND_PATH:=$(call AltCheckSpaces,UNIXCOMMAND_PATH)

  export UNIXCOMMAND_PATH

endif

# Get version of MKS or CYGWIN

ifdef USING_CYGWIN

  ifndef CYGWIN_VER

    _CYGWIN_VER :=$(shell $(UNAME))

    CYGWIN_VER  :=$(call GetVersion,$(_CYGWIN_VER))

    export CYGWIN_VER

  endif

else # MKS

_MKS_VER :=$(shell $(MKSINFO) 2>&1 | $(GREP) Release | $(TAIL) -1 | $(SED) -e 's@.*\(Release.*\)@\1@')

MKS_VER  :=$(call GetVersion,$(_MKS_VER))

# At this point, we can re-define FullPath to use DOSNAME_CMD

CHECK_MKS87:=$(call CheckVersions,$(MKS_VER),8.7)

TRY_DOSNAME:=false

ifeq ($(CHECK_MKS87),same)

TRY_DOSNAME:=true

endif

# Newer should be ok

ifeq ($(CHECK_MKS87),newer)

TRY_DOSNAME:=true

endif

ifeq ($(TRY_DOSNAME),true)

ifeq ($(shell $(UNIXCOMMAND_PATH)dosname -s $(_system_drive)/ 2> $(DEV_NULL)),$(_system_drive)/)

_DOSNAME=$(UNIXCOMMAND_PATH)dosname

DOSNAME_CMD:=$(_DOSNAME) -s

define FullPath

$(subst //,/,$(shell echo $1 | $(DOSNAME_CMD) 2> $(DEV_NULL)))

endef

endif # test dosname -s

endif # TRY_DOSNAME

endif # MKS

# We try to get references to what we need via the default component

#    environment variables, or what was used historically.

# Process Windows values into FullPath values, these paths may have \ chars

# Program Files directory

ifndef SHORTPROGRAMFILES

  ifdef PROGRAMFILES

    xPROGRAMFILES      :="$(subst \,/,$(PROGRAMFILES))"

  else

    ifeq ($(ARCH_DATA_MODEL), 32)

      xPROGRAMFILES    :="$(_system_drive)/Program Files"

    else

      xPROGRAMFILES    :="$(_system_drive)/Program Files (x86)"

    endif

  endif

  ifeq ($(ARCH_DATA_MODEL), 32)

    SHORTPROGRAMFILES  :=$(call FullPath,$(xPROGRAMFILES))

  else

    ifdef PROGRAMW6432

      xPROGRAMW6432    :="$(subst \,/,$(PROGRAMW6432))"

    else

      xPROGRAMW6432    :="$(_system_drive)/Program Files"

    endif

    SHORTPROGRAMFILES  :=$(call FullPath,$(xPROGRAMW6432))

  endif

  ifneq ($(word 1,$(SHORTPROGRAMFILES)),$(SHORTPROGRAMFILES))

    SHORTPROGRAMFILES  :=

  endif

  export SHORTPROGRAMFILES

endif

# Compilers, SDK, and Visual Studio (MSDEV) [32bit is different from 64bit]

ifeq ($(ARCH_DATA_MODEL), 32)

  ifndef SHORTMSVCDIR

    # Try looking in MSVCDIR or MSVCDir area first (set by vcvars32.bat)

    ifdef MSVCDIR

      xMSVCDIR         :="$(subst \,/,$(MSVCDIR))"

      SHORTMSVCDIR     :=$(call FullPath,$(xMSVCDIR))

    else

      ifdef MSVCDir

        xMSVCDIR       :="$(subst \,/,$(MSVCDir))"

        SHORTMSVCDIR   :=$(call FullPath,$(xMSVCDIR))

      else

        ifneq ($(SHORTPROGRAMFILES),)

          xMSVCDIR     :="$(SHORTPROGRAMFILES)/Microsoft Visual Studio .NET 2003/Vc7"

          SHORTMSVCDIR :=$(call FullPath,$(xMSVCDIR))

        endif

      endif

    endif

    ifneq ($(subst MSDev98,OLDOLDOLD,$(SHORTMSVCDIR)),$(SHORTMSVCDIR))

      SHORTMSVCDIR     :=

    endif

    # If we still don't have it, look for VS71COMNTOOLS, setup by installer?

    ifeq ($(SHORTMSVCDIR),)

      ifdef VS71COMNTOOLS  # /Common/Tools directory, use ../../Vc7

        xVS71COMNTOOLS :="$(subst \,/,$(VS71COMNTOOLS))"

        _vs71tools     :=$(call FullPath,$(xVS71COMNTOOLS))

      endif

      ifneq ($(_vs71tools),)

        SHORTMSVCDIR   :=$(_vs71tools)/../../Vc7

      endif

    endif

    export SHORTMSVCDIR

  endif

  ifneq ($(SHORTMSVCDIR),)

    SHORTCOMPILERBIN   :=$(SHORTMSVCDIR)/Bin

    SHORTPSDK          :=$(SHORTMSVCDIR)/PlatformSDK

    export SHORTCOMPILERBIN

    export SHORTPSDK

  endif

endif

# The Microsoft Platform SDK installed by itself

ifneq ($(SHORTPROGRAMFILES),)

  ifndef SHORTPSDK

    xPSDK       :="$(SHORTPROGRAMFILES)/Microsoft Platform SDK"

    SHORTPSDK   :=$(call FullPath,$(xPSDK))

    ifeq ($(SHORTPSDK),)

      xPSDK     :="$(SHORTPROGRAMFILES)/Microsoft SDK"

      SHORTPSDK :=$(call FullPath,$(xMSSDK))

    endif

    export SHORTPSDK

  endif

endif

# If no SDK found yet, look in other places

ifndef SHORTPSDK

  ifdef MSSDK

    xMSSDK      :="$(subst \,/,$(MSSDK))"

    SHORTPSDK   :=$(call FullPath,$(xMSSDK))

  else

    ifdef MSSdk

      xMSSDK    :="$(subst \,/,$(MSSdk))"

      SHORTPSDK :=$(call FullPath,$(xMSSDK))

    endif

  endif

  export SHORTPSDK

endif

# Compilers for 64bit are from SDK

ifeq ($(ARCH_DATA_MODEL), 64)

  ifndef SHORTCOMPILERBIN

    xMSSDK61 :="C:/Program Files/Microsoft SDKs/Windows/v6.1/"

    MSSDK61 :=$(call FullPath,$(xMSSDK61))

    xVS2008 :="C:/Program Files (x86)/Microsoft Visual Studio 9.0/"

    _vs2008 :=$(call FullPath,$(xVS2008))

    ifneq ($(_vs2008),)

      ifeq ($(ARCH), ia64)

        SHORTCOMPILERBIN :=$(_vs2008)/VC/Bin/x86_ia64

      endif

      ifeq ($(ARCH), amd64)

        SHORTCOMPILERBIN :=$(_vs2008)/VC/Bin/$(ARCH)

      endif

    else

      ifneq ($(SHORTPSDK),)

        ifeq ($(ARCH), ia64)

          SHORTCOMPILERBIN :=$(SHORTPSDK)/Bin/Win64

        endif

        ifeq ($(ARCH), amd64)

          SHORTCOMPILERBIN :=$(SHORTPSDK)/Bin/Win64/x86/$(ARCH)

        endif

      endif

    endif

    export SHORTCOMPILERBIN

  endif

endif

# Location on system where jdk installs might be

ifneq ($(SHORTPROGRAMFILES),)

  USRJDKINSTANCES_PATH =$(SHORTPROGRAMFILES)/Java

else

  USRJDKINSTANCES_PATH =$(_system_drive)/

endif

# SLASH_JAVA: location of all network accessable files

ifndef SLASH_JAVA

  ifdef ALT_SLASH_JAVA

    xALT_SLASH_JAVA :="$(subst \,/,$(ALT_SLASH_JAVA))"

    SLASH_JAVA      :=$(call FullPath,$(xALT_SLASH_JAVA))

  else

    ifdef ALT_JDK_JAVA_DRIVE

      SLASH_JAVA  =$(JDK_JAVA_DRIVE)

    else

      SLASH_JAVA  =J:

    endif

  endif

  SLASH_JAVA:=$(call AltCheckSpaces,SLASH_JAVA)

  SLASH_JAVA:=$(call AltCheckValue,SLASH_JAVA)

  export SLASH_JAVA

endif

# JDK_DEVTOOLS_DIR: common path for all the java devtools

ifndef JDK_DEVTOOLS_DIR

  ifdef ALT_JDK_DEVTOOLS_DIR

    xALT_JDK_DEVTOOLS_DIR :="$(subst \,/,$(ALT_JDK_DEVTOOLS_DIR))"

    JDK_DEVTOOLS_DIR      :=$(call FullPath,$(xALT_JDK_DEVTOOLS_DIR))

  else

    JDK_DEVTOOLS_DIR =$(SLASH_JAVA)/devtools

  endif

  JDK_DEVTOOLS_DIR:=$(call AltCheckSpaces,JDK_DEVTOOLS_DIR)

  JDK_DEVTOOLS_DIR:=$(call AltCheckValue,JDK_DEVTOOLS_DIR)

  export JDK_DEVTOOLS_DIR

endif

# COMPILER_PATH: path to where the compiler and tools are installed.

#  NOTE: Must end with / so that it could be empty, allowing PATH usage.

ifndef COMPILER_PATH

  ifdef ALT_COMPILER_PATH

    xALT_COMPILER_PATH  :="$(subst \,/,$(ALT_COMPILER_PATH))"

    fxALT_COMPILER_PATH :=$(call FullPath,$(xALT_COMPILER_PATH))

    COMPILER_PATH       :=$(call PrefixPath,$(fxALT_COMPILER_PATH))

  else

    COMPILER_PATH :=$(call PrefixPath,$(SHORTCOMPILERBIN))

  endif

  COMPILER_PATH :=$(call AltCheckSpaces,COMPILER_PATH)

  export COMPILER_PATH

endif

# MSDEVTOOLS_PATH: path to where the additional MS Compiler tools are.

#  NOTE: Must end with / so that it could be empty, allowing PATH usage.

ifndef MSDEVTOOLS_PATH

  ifdef ALT_MSDEVTOOLS_PATH

    xALT_MSDEVTOOLS_PATH  :="$(subst \,/,$(ALT_MSDEVTOOLS_PATH))"

    fxALT_MSDEVTOOLS_PATH :=$(call FullPath,$(xALT_MSDEVTOOLS_PATH))

    MSDEVTOOLS_PATH       :=$(call PrefixPath,$(fxALT_MSDEVTOOLS_PATH))

  else

    ifeq ($(ARCH_DATA_MODEL), 64)

      ifdef MSTOOLS

        xMSTOOLS  :="$(subst \,/,$(MSTOOLS))"

        _ms_tools :=$(call FullPath,$(xMSTOOLS))

      else

        ifdef Mstools

          xMSTOOLS  :="$(subst \,/,$(Mstools))"

          _ms_tools :=$(call FullPath,$(xMSTOOLS))

        else

          _ms_tools :=

        endif

      endif

      ifneq ($(_ms_tools),)

        _ms_tools_bin :=$(_ms_tools)/Bin

      else

        # Assumes compiler bin is .../Bin/win64/x86/AMD64, rc.exe is 3 levels up

        _ms_tools_bin :=$(SHORTCOMPILERBIN)/../../..

      endif

    else

      _ms_tools_bin :=$(SHORTCOMPILERBIN)

    endif

    MSDEVTOOLS_PATH :=$(call PrefixPath,$(_ms_tools_bin))

  endif

  MSDEVTOOLS_PATH:=$(call AltCheckSpaces,MSDEVTOOLS_PATH)

  export MSDEVTOOLS_PATH

endif

# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.)

#  NOTE: Must end with / so that it could be empty, allowing PATH usage.

ifndef DEVTOOLS_PATH

  ifdef ALT_DEVTOOLS_PATH

    xALT_DEVTOOLS_PATH  :="$(subst \,/,$(ALT_DEVTOOLS_PATH))"

    fxALT_DEVTOOLS_PATH :=$(call FullPath,$(xALT_DEVTOOLS_PATH))

    DEVTOOLS_PATH       :=$(call PrefixPath,$(fxALT_DEVTOOLS_PATH))

  else

    ifdef USING_CYGWIN

      DEVTOOLS_PATH :=$(UNIXCOMMAND_PATH)

    else

      xDEVTOOLS_PATH  :="$(_system_drive)/utils"

      fxDEVTOOLS_PATH :=$(call FullPath,$(xDEVTOOLS_PATH))

      DEVTOOLS_PATH  :=$(call PrefixPath,$(fxDEVTOOLS_PATH))

    endif

  endif

  DEVTOOLS_PATH:=$(call AltCheckSpaces,DEVTOOLS_PATH)

  export DEVTOOLS_PATH

endif

# _BOOTDIR1: First choice for a Bootstrap JDK, previous released JDK.

# _BOOTDIR2: Second choice

ifndef ALT_BOOTDIR

  _BOOTDIR1  =$(_system_drive)/jdk$(PREVIOUS_JDK_VERSION)

  _BOOTDIR2  =$(USRJDKINSTANCES_PATH)/jdk$(PREVIOUS_JDK_VERSION)

endif

# Import JDK images allow for partial builds, components not built are

#    imported (or copied from) these import areas when needed.

# BUILD_JDK_IMPORT_PATH: location of JDK install trees to import for

#   multiple platforms, e.g. windows-i586, solaris-sparc, linux-586, etc.

ifndef BUILD_JDK_IMPORT_PATH

  ifdef ALT_BUILD_JDK_IMPORT_PATH

    BUILD_JDK_IMPORT_PATH  :=$(call FullPath,$(ALT_BUILD_JDK_IMPORT_PATH))

  else

    BUILD_JDK_IMPORT_PATH   = $(PROMOTED_BUILD_BINARIES)

  endif

  BUILD_JDK_IMPORT_PATH:=$(call AltCheckSpaces,BUILD_JDK_IMPORT_PATH)

  BUILD_JDK_IMPORT_PATH:=$(call AltCheckValue,BUILD_JDK_IMPORT_PATH)

  export BUILD_JDK_IMPORT_PATH

endif

# JDK_IMPORT_PATH: location of previously built JDK (this version) to import

ifndef JDK_IMPORT_PATH

  ifdef ALT_JDK_IMPORT_PATH

    JDK_IMPORT_PATH  :=$(call FullPath,$(ALT_JDK_IMPORT_PATH))

  else

    JDK_IMPORT_PATH   = $(BUILD_JDK_IMPORT_PATH)/$(PLATFORM)-$(ARCH)$(_JDK_IMPORT_VARIANT)

  endif

  JDK_IMPORT_PATH:=$(call AltCheckSpaces,JDK_IMPORT_PATH)

  JDK_IMPORT_PATH:=$(call AltCheckValue,JDK_IMPORT_PATH)

  export JDK_IMPORT_PATH

endif