#!/bin/sh
# install-reloc - install a program in a way that it will find its shared
#                 libraries even when relocated,
#                 - either including a relocating wrapper,
#                 - or using Mac OS X specific tools.
# Copyright (C) 2003-2019 Free Software Foundation, Inc.
# Written by Bruno Haible <bruno@clisp.org>, 2003.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program 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 for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

# Usage 1:
#   install-reloc -- 'wrapper' \
#                    library_path_var library_path_value prefix destdir \
#                    compile_command srcdir builddir config_h_dir exeext \
#                    strip_command \
#                    install_command... destprog
#   install-reloc -- 'macosx' \
#                    prefix destdir \
#                    strip_command \
#                    install_command... destprog
# where
#   - library_path_var is the platform dependent runtime library path variable
#   - library_path_value is a colon separated list of directories that contain
#     the libraries at installation time (use this instead of -rpath)
#   - prefix is the base directory at installation time
#   - destdir is a string that is prepended to all file names at installation
#     time; it is already prepended to destprog but not to library_path_value
#     and prefix
#   - compile_command is a C compiler compilation and linking command
#   - srcdir is the directory where to find relocwrapper.c and its dependencies
#   - builddir is the directory where to find built dependencies (namely,
#     alloca.h and stdbool.h)
#   - config_h_dir is the directory where to find config.h
#   - exeext is platform dependent suffix of executables
#   - strip_command is the command for stripping executables, or : if no
#     stripping is desired
#   - install_command is the install command line, excluding the final destprog
#   - destprog is the destination program name
# Usage 2:
#   env RELOC_MODE='wrapper' \
#       RELOC_LIBRARY_PATH_VAR=library_path_var \
#       RELOC_LIBRARY_PATH_VALUE=library_path_value \
#       RELOC_PREFIX=prefix \
#       RELOC_DESTDIR=destdir \
#       RELOC_COMPILE_COMMAND=compile_command \
#       RELOC_SRCDIR=srcdir \
#       RELOC_BUILDDIR=builddir \
#       RELOC_CONFIG_H_DIR=config_h_dir \
#       RELOC_EXEEXT=exeext \
#       RELOC_STRIP_PROG=strip_command \
#       RELOC_INSTALL_PROG=install_command... \
#     install-reloc prog1 ... destprog
#   env RELOC_MODE='macosx' \
#       RELOC_PREFIX=prefix \
#       RELOC_DESTDIR=destdir \
#       RELOC_STRIP_PROG=strip_command \
#       RELOC_INSTALL_PROG=install_command... \
#     install-reloc prog1 ... destprog
#   where destprog is either the destination program name (when only one program
#   is specified) or the destination directory for all programs.
# In the 'wrapper' mode, install-reloc renames destprog to destprog.bin and
# installs a relocating wrapper in the place of destprog.

progname=$0

func_usage ()
{
  echo "Usage: $0 -- 'wrapper'" \
       "library_path_var library_path_value prefix destdir" \
       "compile_command srcdir builddir config_h_dir exeext" \
       "strip_command" \
       "install_command... destprog"
  echo "Usage: $0 -- 'macosx'" \
       "prefix destdir" \
       "strip_command" \
       "install_command... destprog"
}

if test "x$1" = "x--"; then
  # Get fixed position arguments.
  case "$2" in
    wrapper)
      if test $# -ge 13; then
        mode=$2
        shift
        shift
        library_path_var=$1
        library_path_value=$2
        prefix=$3
        destdir=$4
        shift
        shift
        shift
        shift
        compile_command=$1
        srcdir=$2
        builddir=$3
        config_h_dir=$4
        exeext=$5
        shift
        shift
        shift
        shift
        shift
        strip_prog=$1
        shift
        install_prog=$1 # maybe not including the "-c" option
        shift
      else
        func_usage 1>&2; exit 1
      fi
      ;;
    macosx)
      if test $# -ge 6; then
        mode=$2
        shift
        shift
        prefix=$1
        destdir=$2
        shift
        shift
        exeext=
        strip_prog=$1
        shift
        install_prog=$1 # maybe not including the "-c" option
        shift
      else
        func_usage 1>&2; exit 1
      fi
      ;;
    *)
      func_usage 1>&2; exit 1
      ;;
  esac
else
  if test $# -ge 2; then
    # Get arguments from environment variables.
    mode=$RELOC_MODE
    case "$mode" in
      wrapper)
        library_path_var=$RELOC_LIBRARY_PATH_VAR
        library_path_value=$RELOC_LIBRARY_PATH_VALUE
        prefix=$RELOC_PREFIX
        destdir=$RELOC_DESTDIR
        compile_command=$RELOC_COMPILE_COMMAND
        srcdir=$RELOC_SRCDIR
        builddir=$RELOC_BUILDDIR
        config_h_dir=$RELOC_CONFIG_H_DIR
        exeext=$RELOC_EXEEXT
        strip_prog=$RELOC_STRIP_PROG
        install_prog=$RELOC_INSTALL_PROG # including the "-c" option
        ;;
      macosx)
        prefix=$RELOC_PREFIX
        destdir=$RELOC_DESTDIR
        exeext=
        strip_prog=$RELOC_STRIP_PROG
        install_prog=$RELOC_INSTALL_PROG # including the "-c" option
        ;;
      *)
        func_usage 1>&2; exit 1
        ;;
    esac
  else
    func_usage 1>&2; exit 1
  fi
fi

# Get destprog, last argument.
destprog=
for arg
do
  destprog=$arg
done
# Determine whether destprog is a program name or a directory name.
if test -d "$destprog"; then
  sed_remove_trailing_slashes='s|//*$||'
  destprog_directory=`echo "$destprog" | sed -e "$sed_remove_trailing_slashes"`
  if test -z "$destprog_directory"; then
    destprog_directory='/'
  fi
else
  destprog_directory=
fi
# Prepare for remove trailing $exeext, if present.
if test -n "$exeext"; then
  sed_quote='s,\.,\\.,g'
  sed_remove_exeext='s|'`echo "$exeext" | sed -e "$sed_quote"`'$||'
fi
if test -z "$destprog_directory"; then
  # Remove trailing $exeext, if present.
  if test -n "$exeext"; then
    destprog=`echo "$destprog" | sed -e "$sed_remove_exeext"`
  fi
fi

# Outputs a command and runs it.
func_verbose ()
{
  echo "$@"
  "$@"
}

# Run install_command.
func_verbose $install_prog "$@" || exit $?

# Iterate over all destination program names.
# func_iterate f
# applies f to each destination program names, after setting destprog.
sed_basename_of_file='s|^.*/||'
func_iterate ()
{
  if test -n "$destprog_directory"; then
    prev_arg=
    for arg
    do
      if test -n "prev_arg"; then
        destprog="$destprog_directory"/`echo "$prev_arg" | sed -e "$sed_basename_of_file"`
        $1
      fi
      prev_arg="$arg"
    done
  else
    $1
  fi
}

# Run strip_command.
func_strip ()
{
  # Remove trailing $exeext, if present.
  if test -n "$exeext"; then
    destprog=`echo "$destprog" | sed -e "$sed_remove_exeext"`
  fi
  func_verbose "$strip_prog" "$destprog$exeext" || exit $?
}
if test "$strip_prog" != ':'; then
  func_iterate func_strip
fi

# Determine installdir from destprog, removing a leading destdir if present.
if test -n "$destprog_directory"; then
  # There's possibly multiple programs to install, but all go into the same
  # directory.
  installdir="$destprog_directory"
else
  # There's only one program to install.
  installdir=`echo "$destprog" | sed -e 's,/[^/]*$,,'`
fi
if test -n "$destdir"; then
  sed_quote='s,\([|.\*^$[]\),\\\1,g'
  sed_remove_destdir='s|^'`echo "$destdir" | sed -e "$sed_quote"`'||'
  installdir=`echo "$installdir" | sed -e "$sed_remove_destdir"`
fi

# func_relativize DIR1 DIR2
# computes a relative pathname RELDIR such that DIR1/RELDIR = DIR2.
# Input:
# - DIR1            relative pathname, relative to the current directory
# - DIR2            relative pathname, relative to the current directory
# Output:
# - reldir          relative pathname of DIR2, relative to DIR1
func_relativize ()
{
  dir0=`pwd`
  dir1="$1"
  dir2="$2"
  sed_first='s,^\([^/]*\)/.*$,\1,'
  sed_rest='s,^[^/]*/*,,'
  sed_last='s,^.*/\([^/]*\)$,\1,'
  sed_butlast='s,/*[^/]*$,,'
  while test -n "$dir1"; do
    first=`echo "$dir1" | sed -e "$sed_first"`
    if test "$first" != "."; then
      if test "$first" = ".."; then
        dir2=`echo "$dir0" | sed -e "$sed_last"`/"$dir2"
        dir0=`echo "$dir0" | sed -e "$sed_butlast"`
      else
        first2=`echo "$dir2" | sed -e "$sed_first"`
        if test "$first2" = "$first"; then
          dir2=`echo "$dir2" | sed -e "$sed_rest"`
        else
          dir2="../$dir2"
        fi
        dir0="$dir0"/"$first"
      fi
    fi
    dir1=`echo "$dir1" | sed -e "$sed_rest"`
  done
  reldir="$dir2"
}

case "$mode" in

  wrapper)
    # If the platform doesn't support LD_LIBRARY_PATH or similar, we cannot
    # build a wrapper.
    test -n "$library_path_var" || exit 0

    libdirs=
    save_IFS="$IFS"; IFS=":"
    for dir in $library_path_value; do
      IFS="$save_IFS"
      if test -n "$dir"; then
        case "$libdirs" in
          *"\"$dir\""*) ;; # remove duplicate
          *) libdirs="$libdirs\"$dir\"," ;;
        esac
      fi
    done
    IFS="$save_IFS"
    # If there are no library directories to add at runtime, we don't need a
    # wrapper.
    test -n "$libdirs" || exit 0

    # Compile and install wrapper.
    func_create_wrapper ()
    {
      # Remove trailing $exeext, if present.
      if test -n "$exeext"; then
        destprog=`echo "$destprog" | sed -e "$sed_remove_exeext"`
      fi

      # Compile wrapper.
      func_verbose $compile_command \
                   -I"$builddir" -I"$srcdir" -I"$config_h_dir" \
                   -DHAVE_CONFIG_H -DIN_RELOCWRAPPER -DNO_XMALLOC \
                   -D"INSTALLPREFIX=\"$prefix\"" -D"INSTALLDIR=\"$installdir\"" \
                   -D"LIBPATHVAR=\"$library_path_var\"" -D"LIBDIRS=$libdirs" \
                   -D"EXEEXT=\"$exeext\"" \
                   "$srcdir"/relocwrapper.c \
                   "$srcdir"/progname.c \
                   "$srcdir"/progreloc.c \
                   "$srcdir"/areadlink.c \
                   "$srcdir"/careadlinkat.c \
                   "$srcdir"/allocator.c \
                   "$srcdir"/readlink.c \
                   "$srcdir"/stat.c \
                   "$srcdir"/canonicalize-lgpl.c \
                   "$srcdir"/malloca.c \
                   "$srcdir"/lstat.c \
                   "$srcdir"/relocatable.c \
                   "$srcdir"/setenv.c \
                   "$srcdir"/c-ctype.c \
                   -o "$destprog.wrapper$exeext"
      rc=$?
      # Clean up object files left over in the current directory by the native C
      # compilers on Solaris, HP-UX, OSF/1, IRIX.
      rm -f relocwrapper.o \
            progname.o \
            progreloc.o \
            areadlink.o \
            careadlinkat.o \
            allocator.o \
            readlink.o \
            stat.o \
            canonicalize-lgpl.o \
            malloca.o \
            lstat.o \
            relocatable.o \
            setenv.o \
            c-ctype.o
      test $rc = 0 || exit $?
      # Clean up debugging information left over by the native C compiler on
      # Mac OS X.
      rm -rf "$destprog.wrapper$exeext.dSYM"
      test $rc = 0 || exit $?

      # Strip wrapper.
      test "$strip_prog" = ':' || func_verbose "$strip_prog" "$destprog.wrapper$exeext" || exit $?

      # Rename $destprog.wrapper -> $destprog -> $destprog.bin.
      ln -f "$destprog$exeext" "$destprog.bin$exeext" \
        || { rm -f "$destprog.bin$exeext" \
             && cp -p "$destprog$exeext" "$destprog.bin$exeext"; } \
        || exit 1
      mv "$destprog.wrapper$exeext" "$destprog$exeext" || exit 1
    }
    func_iterate func_create_wrapper
    ;;

  macosx)
    # Insert a reference to @loader_path in selected shared library references.
    # For executables, @executable_path is equivalent to @loader_path.
    func_reference_loader_path ()
    {
      # For using 'install_name_tool -change ...' we need to know the precise
      # library version of each reference. The linker command line does not give
      # us the information; only 'otool' provides it.
      # Documentation:
      # <https://www.manpagez.com/man/1/otool/>
      # <https://www.unix.com/man-page/osx/1/otool/>
      # The install_name_tool exists in versions without and with rpath support:
      # <https://www.manpagez.com/man/1/install_name_tool/>
      # <https://www.unix.com/man-page/osx/1/install_name_tool/>
      otool -L "$destprog" | sed -e '/:$/d' -e 's/^[ 	]*//' -e 's/ (.*$//' | \
        while read libfilename; do
          case "$libfilename" in
            "$prefix"/* )
              func_relativize "$installdir" "$libfilename"
              new_libfilename="@loader_path/$reldir"
              func_verbose install_name_tool -change "$libfilename" "$new_libfilename" "$destprog"
              ;;
          esac
        done
    }
    func_iterate func_reference_loader_path
    ;;

esac

exit 0