make/autoconf/util_paths.m4

#
# Copyright (c) 2011, 2025, 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.
#

################################################################################
# Appends a string to a path variable, only adding the : when needed.
AC_DEFUN([UTIL_APPEND_TO_PATH],
[
  if test "x$2" != x; then
    if test "x[$]$1" = x; then
      $1="$2"
    else
      $1="[$]$1:$2"
    fi
  fi
])

################################################################################
# Prepends a string to a path variable, only adding the : when needed.
AC_DEFUN([UTIL_PREPEND_TO_PATH],
[
  if test "x$2" != x; then
    if test "x[$]$1" = x; then
      $1="$2"
    else
      $1="$2:[$]$1"
    fi
  fi
])

################################################################################
# This will make sure the given variable points to a full and proper
# path. This means:
# 1) There will be no spaces in the path. On unix platforms,
#    spaces in the path will result in an error. On Windows,
#    the path will be rewritten using short-style to be space-free.
# 2) The path will be absolute, and it will be in unix-style (on
#     cygwin).
# $1: The name of the variable to fix
# $2: if NOFAIL, if the path cannot be resolved then errors will not be
#     reported and an empty path will be set
AC_DEFUN([UTIL_FIXUP_PATH],
[
  # Only process if variable expands to non-empty
  path="[$]$1"
  if test "x$path" != x; then
    if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
      imported_path=`$FIXPATH_BASE -q import "$path"`
      if test $? -ne 0 || test ! -e $imported_path; then
        if test "x$2" != "xNOFAIL"; then
          AC_MSG_NOTICE([The path of $1, which is given as "$path", can not be properly resolved.])
          AC_MSG_NOTICE([Please see the section "Special Considerations" in building.md.])
          AC_MSG_NOTICE([This is the error message given by fixpath:])
          # Rerun fixpath without -q to get an error message
          $FIXPATH_BASE import "$path"
          AC_MSG_ERROR([Cannot continue])
        else
          imported_path=""
        fi
      fi

      $FIXPATH_BASE -q verify "$imported_path"
      if test $? -ne 0; then
        if test "x$2" != "xNOFAIL"; then
          AC_MSG_ERROR([The path of $1, which resolves as "$path", could not be verified.])
        else
          imported_path=""
        fi
      fi
      [ imported_path_lower=`$ECHO $imported_path | $TR '[:upper:]' '[:lower:]'` ]
      [ orig_path_lower=`$ECHO $path | $TR '[:upper:]' '[:lower:]'` ]
      # If only case differs, keep original path
      if test "x$imported_path_lower" != "x$orig_path_lower"; then
        $1="$imported_path"
      fi
    else # non-Windows
      [ if [[ "$path" =~ " " ]]; then ]
        if test "x$2" != "xNOFAIL"; then
          AC_MSG_NOTICE([The path of $1, which resolves as "$path", is invalid.])
          AC_MSG_ERROR([Spaces are not allowed in this path.])
        else
          path=""
        fi
      fi

      # Use eval to expand a potential ~.
      eval new_path="$path"
      if test ! -e "$new_path"; then
        if test "x$2" != "xNOFAIL"; then
          AC_MSG_ERROR([The path of $1, which resolves as "$new_path", is not found.])
        else
          new_path=""
        fi
      fi

      # Make the path absolute
      if test "x$new_path" != x; then
        if test -d "$new_path"; then
          path="`cd "$new_path"; pwd -L`"
        else
          dir="`$DIRNAME "$new_path"`"
          base="`$BASENAME "$new_path"`"
          path="`cd "$dir"; pwd -L`/$base"
        fi
      else
        path=""
      fi

      $1="$path"
    fi
  fi
])

################################################################################
# Fixup path to be a Windows full long path
# Note: Only supported with cygwin/msys2 (cygpath tool)
AC_DEFUN([UTIL_FIXUP_WIN_LONG_PATH],
[
  # Only process if variable expands to non-empty
  path="[$]$1"
  if test "x$path" != x; then
    if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
      win_path=$($PATHTOOL -wl "$path")
      if test "x$win_path" != "x$path"; then
        $1="$win_path"
      fi
    fi
  fi
])


################################################################################
# Check if the given file is a unix-style or windows-style executable, that is,
# if it expects paths in unix-style or windows-style.
# Returns "windows" or "unix" in $RESULT.
AC_DEFUN([UTIL_CHECK_WINENV_EXEC_TYPE],
[
  # For cygwin and msys2, if it's linked with the correct helper lib, it
  # accept unix paths
  if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin" || \
      test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys2"; then
    linked_libs=`$LDD $1 2>&1`
    if test $? -ne 0; then
      # Non-binary files (e.g. shell scripts) are unix files
      RESULT=unix
    else
      [ if [[ "$linked_libs" =~ $WINENV_MARKER_DLL ]]; then ]
        RESULT=unix
      else
        RESULT=windows
      fi
    fi
  elif test "x$OPENJDK_BUILD_OS" = "xwindows"; then
    # On WSL, we can check if it is a PE file
    file_type=`$FILE -b $1 2>&1`
    [ if [[ $file_type =~ PE.*Windows ]]; then ]
      RESULT=windows
    else
      RESULT=unix
    fi
  else
    RESULT=unix
  fi
])

################################################################################
# This will make sure the given variable points to a executable
# with a full and proper path. This means:
# 1) There will be no spaces in the path. On unix platforms,
#    spaces in the path will result in an error. On Windows,
#    the path will be rewritten using short-style to be space-free.
# 2) The path will be absolute, and it will be in unix-style (on
#     cygwin).
# Any arguments given to the executable is preserved.
# If the input variable does not have a directory specification, then
# it need to be in the PATH.
# $1: The name of the variable to fix
# $2: Where to look for the command (replaces $PATH)
AC_DEFUN([UTIL_FIXUP_EXECUTABLE],
[
  input="[$]$1"

  # Only process if variable expands to non-empty
  if test "x$input" != x; then
    # First separate the path from the arguments. This will split at the first
    # space.
    [ if [[ "$OPENJDK_BUILD_OS" = "windows" && input =~ ^$FIXPATH ]]; then
      line="${input#$FIXPATH }"
      fixpath_prefix="$FIXPATH "
    else
      line="$input"
      fixpath_prefix=""
    fi ]
    path="${line%% *}"
    arguments="${line#"$path"}"

    [ if ! [[ "$path" =~ /|\\ ]]; then ]
      # This is a command without path (e.g. "gcc" or "echo")
      command_type=`type -t "$path"`
      if test "x$command_type" = xbuiltin || test "x$command_type" = xkeyword; then
        # Shell builtin or keyword; we're done here
        new_path="$path"
      else
        # Search in $PATH using bash built-in 'type -p'.
        saved_path="$PATH"
        if test "x$2" != x; then
          PATH="$2"
        fi
        new_path=`type -p "$path"`
        if test "x$new_path" = x && test "x$OPENJDK_BUILD_OS" = "xwindows"; then
          # Try again with .exe
          new_path="`type -p "$path.exe"`"
        fi
        PATH="$saved_path"

        if test "x$new_path" = x; then
          AC_MSG_NOTICE([The command for $1, which resolves as "$input", is not found in the PATH.])
          AC_MSG_ERROR([Cannot locate $path])
        fi
      fi
    else
      # This is a path with slashes, don't look at $PATH
      if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
        # fixpath.sh import will do all heavy lifting for us
        new_path=`$FIXPATH_BASE -q import "$path"`

        if test $? -ne 0 || test ! -e $new_path; then
          # It failed, but maybe spaces were part of the path and not separating
          # the command and argument. Retry using that assumption.
          new_path=`$FIXPATH_BASE -q import "$input"`
          if test $? -ne 0 || test ! -e $new_path; then
            AC_MSG_NOTICE([The command for $1, which is given as "$input", can not be properly resolved.])
            AC_MSG_NOTICE([Please see the section "Special Considerations" in building.md.])
            AC_MSG_NOTICE([This is the error message given by fixpath:])
            # Rerun fixpath without -q to get an error message
            $FIXPATH_BASE import "$input"
            AC_MSG_ERROR([Cannot continue])
          fi
          # It worked, clear all "arguments"
          arguments=""
        fi
      else # on unix
        # Make absolute
        $1="$path"
        UTIL_FIXUP_PATH($1, NOFAIL)
        new_path="[$]$1"

        if test ! -e $new_path; then
          AC_MSG_NOTICE([The command for $1, which resolves as "$input", is not found])
          [ if [[ "$path" =~ " " ]]; then ]
            AC_MSG_NOTICE([This might be caused by spaces in the path, which is not allowed.])
          fi
          AC_MSG_ERROR([Cannot locate $path])
        fi
        if test ! -x $new_path; then
          AC_MSG_NOTICE([The command for $1, which resolves as "$input", is not executable.])
          AC_MSG_ERROR([Cannot execute command at $path])
        fi
      fi # end on unix
    fi # end with or without slashes

    # Now we have a usable command as new_path, with arguments in arguments
    if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
      if test "x$fixpath_prefix" = x; then
        # Only mess around if fixpath_prefix was not given
        UTIL_CHECK_WINENV_EXEC_TYPE("$new_path")
        if test "x$RESULT" = xwindows; then
          fixpath_prefix="$FIXPATH "
          # make sure we have an .exe suffix (but not two)
          new_path="${new_path%.exe}.exe"
        else
          # If we have gotten a .exe suffix, remove it
          new_path="${new_path%.exe}"
        fi
      fi
    fi

    # Now join together the path and the arguments once again
    new_complete="$fixpath_prefix$new_path$arguments"
    $1="$new_complete"
  fi
])

################################################################################
# Setup a tool for the given variable. If correctly specified by the user,
# use that value, otherwise search for the tool using the supplied code snippet.
# $1: variable to set
# $2: code snippet to call to look for the tool
# $3: code snippet to call if variable was used to find tool
AC_DEFUN([UTIL_SETUP_TOOL],
[
  # Publish this variable in the help.
  AC_ARG_VAR($1, [Override default value for $1])

  if [[ -z "${$1+x}" ]]; then
    # The variable is not set by user, try to locate tool using the code snippet
    $2
  else
    # The variable is set, but is it from the command line or the environment?

    # Try to remove the string !$1! from our list.
    try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!$1!/}
    if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
      # If it failed, the variable was not from the command line. Ignore it,
      # but warn the user (except for BASH, which is always set by the calling BASH).
      if test "x$1" != xBASH; then
        AC_MSG_WARN([Ignoring value of $1 from the environment. Use command line variables instead.])
      fi
      # Try to locate tool using the code snippet
      $2
    else
      # If it succeeded, then it was overridden by the user. We will use it
      # for the tool.

      # First remove it from the list of overridden variables, so we can test
      # for unknown variables in the end.
      CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"

      tool_override=[$]$1

      # Check if we try to supply an empty value
      if test "x$tool_override" = x; then
        AC_MSG_CHECKING([for $1])
        AC_MSG_RESULT([[[disabled by user]]])
      else
        # Split up override in command part and argument part
        tool_and_args=($tool_override)
        [ tool_command=${tool_and_args[0]} ]
        [ unset 'tool_and_args[0]' ]
        [ tool_args=${tool_and_args[@]} ]

        # Check if the provided tool contains a complete path.
        tool_basename="${tool_command##*/}"
        if test "x$tool_basename" = "x$tool_command"; then
          # A command without a complete path is provided, search $PATH.
          AC_MSG_NOTICE([Will search for user supplied tool "$tool_basename"])
          AC_PATH_PROGS($1, $tool_basename ${tool_basename}.exe)
          tool_command="[$]$1"
          if test "x$tool_command" = x; then
            AC_MSG_ERROR([User supplied tool $1="$tool_basename" could not be found in PATH])
          fi
        else
          # Otherwise we believe it is a complete path. Use it as it is.
          if test ! -x "$tool_command" && test ! -x "${tool_command}.exe"; then
            # Maybe the path had spaces in it; try again with the entire argument
            if test ! -x "$tool_override" && test ! -x "${tool_override}.exe"; then
              AC_MSG_ERROR([User supplied tool $1="$tool_override" does not exist or is not executable])
            else
              # We successfully located the executable assuming the spaces were part of the path.
              # We can't combine using paths with spaces and arguments, so assume tool_args is empty.
              tool_command="$tool_override"
              tool_args=""
            fi
          fi
          if test ! -x "$tool_command"; then
            tool_command="${tool_command}.exe"
          fi
          $1="$tool_command"
        fi
        # Make sure we add fixpath if needed
        UTIL_FIXUP_EXECUTABLE($1)
        if test "x$tool_args" != x; then
          # If we got arguments, re-append them to the command after the fixup.
          $1="[$]$1 $tool_args"
        fi
        AC_MSG_CHECKING([for $1])
        AC_MSG_RESULT([[$]$1 [[user supplied]]])
      fi
    fi
    $3
  fi
])

################################################################################
# Locate a tool using proper methods.
# $1: variable to set
# $2: executable name (or list of names) to look for
# $3: [path]
AC_DEFUN([UTIL_LOOKUP_PROGS],
[
  UTIL_SETUP_TOOL($1, [
    $1=""

    if test "x$3" != x; then
      old_path="$PATH"
      PATH="$3"
    fi

    for name in $2; do
      AC_MSG_CHECKING(for $name)

      command_type=`type -t "$name"`
      if test "x$command_type" = xbuiltin || test "x$command_type" = xkeyword; then
        # Shell builtin or keyword; we're done here
        full_path="$name"
        $1="$full_path"
        AC_MSG_RESULT([[$full_path [builtin]]])
        break
      else
        # Search in $PATH
        old_ifs="$IFS"
        IFS=":"
        for elem in $PATH; do
          IFS="$old_ifs"
          if test "x$elem" = x; then
            continue
          fi
          full_path="$elem/$name"
          if test ! -e "$full_path" && test "x$OPENJDK_BUILD_OS" = "xwindows"; then
            # Try again with .exe
            full_path="$elem/$name.exe"
          fi
          if test -x "$full_path" && test ! -d "$full_path" ; then
            $1="$full_path"
            UTIL_FIXUP_EXECUTABLE($1, $3, $4)
            result="[$]$1"

            # If we have FIXPATH enabled, strip all instances of it and prepend
            # a single one, to avoid double fixpath prefixing.
            [ if [[ $FIXPATH != "" && $result =~ ^"$FIXPATH " ]]; then ]
              result="\$FIXPATH ${result#"$FIXPATH "}"
            fi
            AC_MSG_RESULT([$result])
            break 2;
          fi
        done
        IFS="$old_ifs"
      fi
      AC_MSG_RESULT([[[not found]]])
    done

    if test "x$3" != x; then
      PATH="$old_path"
    fi
  ])
])

################################################################################
# Call UTIL_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool. This will look
# first for cross-compilation tools.
# $1: variable to set
# $2: executable name (or list of names) to look for
# $3: [path]
AC_DEFUN([UTIL_LOOKUP_TOOLCHAIN_PROGS],
[
  if test "x$ac_tool_prefix" = x; then
    UTIL_LOOKUP_PROGS($1, $2, $3)
  else
    prefixed_names=$(for name in $2; do echo ${ac_tool_prefix}${name} $name; done)
    UTIL_LOOKUP_PROGS($1, $prefixed_names, $3)
  fi
])

################################################################################
# Test that variable $1 denoting a program is not empty. If empty, exit with an error.
# $1: variable to check
AC_DEFUN([UTIL_CHECK_NONEMPTY],
[
  if test "x[$]$1" = x; then
    AC_MSG_ERROR([Could not find required tool for $1])
  fi
])

################################################################################
# Like UTIL_LOOKUP_PROGS but fails if no tool was found.
# $1: variable to set
# $2: executable name (or list of names) to look for
# $3: [path]
AC_DEFUN([UTIL_REQUIRE_PROGS],
[
  UTIL_LOOKUP_PROGS($1, $2, $3)
  UTIL_CHECK_NONEMPTY($1)
])

################################################################################
# Like UTIL_LOOKUP_PROGS but fails if no tool was found.
# $1: variable to set
# $2: executable name (or list of names) to look for
# $3: [path]
AC_DEFUN([UTIL_REQUIRE_TOOLCHAIN_PROGS],
[
  UTIL_LOOKUP_TOOLCHAIN_PROGS($1, $2, $3)
  UTIL_CHECK_NONEMPTY($1)
])


################################################################################
# Like UTIL_SETUP_TOOL but fails if no tool was found.
# $1: variable to set
# $2: autoconf macro to call to look for the special tool
AC_DEFUN([UTIL_REQUIRE_SPECIAL],
[
  UTIL_SETUP_TOOL($1, [$2])
  UTIL_CHECK_NONEMPTY($1)
  # The special macro will return an absolute path, and is only used for
  # unix tools. No further processing needed.
])

################################################################################
# Add FIXPATH prefix to variable. Normally this is done by UTIL_LOOKUP_PROGS
# or UTIL_FIXUP_EXECUTABLE, but in some circumstances this has to be done
# explicitly, such as when the command in question does not exist yet.
#
# $1: variable to add fixpath to
AC_DEFUN([UTIL_ADD_FIXPATH],
[
  if test "x$FIXPATH" != x; then
    $1="$FIXPATH [$]$1"
  fi
])

################################################################################
# Return a path to the executable binary from a command line, stripping away
# any FIXPATH prefix or arguments. The resulting value can be checked for
# existence using "test -e". The result is returned in a variable named
# "$1_EXECUTABLE".
#
# $1: variable describing the command to get the binary for
AC_DEFUN([UTIL_GET_EXECUTABLE],
[
  # Strip the FIXPATH prefix, if any
  fixpath_stripped="[$]$1"
  [ if [[ $FIXPATH != "" && $fixpath_stripped =~ ^"$FIXPATH " ]]; then ]
      fixpath_stripped="${fixpath_stripped#"$FIXPATH "}"
  fi
  # Remove any arguments following the binary
  $1_EXECUTABLE="${fixpath_stripped%% *}"
])

################################################################################
AC_DEFUN([UTIL_REMOVE_SYMBOLIC_LINKS],
[
  if test "x$OPENJDK_BUILD_OS" != xwindows; then
    # Follow a chain of symbolic links. Use readlink
    # where it exists, else fall back to horribly
    # complicated shell code.
    if test "x$READLINK_TESTED" != yes; then
      # On MacOSX there is a readlink tool with a different
      # purpose than the GNU readlink tool. Check the found readlink.
      READLINK_ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
      # If READLINK_ISGNU is empty, then it's a non-GNU readlink. Don't use it.
      READLINK_TESTED=yes
    fi

    if test "x$READLINK" != x && test "x$READLINK_ISGNU" != x; then
      $1=`$READLINK -f [$]$1`
    else
      # Save the current directory for restoring afterwards
      STARTDIR=$PWD
      COUNTER=0
      sym_link_dir=`$DIRNAME [$]$1`
      sym_link_file=`$BASENAME [$]$1`
      cd $sym_link_dir
      # Use -P flag to resolve symlinks in directories.
      cd `pwd -P`
      sym_link_dir=`pwd -P`
      # Resolve file symlinks
      while test $COUNTER -lt 20; do
        ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP -e '->' | $SED -e 's/.*-> \(.*\)/\1/'`
        if test "x$ISLINK" == x; then
          # This is not a symbolic link! We are done!
          break
        fi
        # Again resolve directory symlinks since the target of the just found
        # link could be in a different directory
        cd `$DIRNAME $ISLINK`
        sym_link_dir=`pwd -P`
        sym_link_file=`$BASENAME $ISLINK`
        let COUNTER=COUNTER+1
      done
      cd $STARTDIR
      $1=$sym_link_dir/$sym_link_file
    fi
  fi
])