| # ============================================================================== | |
| # https://www.gnu.org/software/autoconf-archive/ax_compute_relative_paths.html | |
| # ============================================================================== | |
| # | |
| # SYNOPSIS | |
| # | |
| # AX_COMPUTE_RELATIVE_PATHS(PATH_LIST) | |
| # | |
| # DESCRIPTION | |
| # | |
| # PATH_LIST is a space-separated list of colon-separated triplets of the | |
| # form 'FROM:TO:RESULT'. This function iterates over these triplets and | |
| # set $RESULT to the relative path from $FROM to $TO. Note that $FROM and | |
| # $TO needs to be absolute filenames for this macro to success. | |
| # | |
| # For instance, | |
| # | |
| # first=/usr/local/bin | |
| # second=/usr/local/share | |
| # AX_COMPUTE_RELATIVE_PATHS([first:second:fs second:first:sf]) | |
| # # $fs is set to ../share | |
| # # $sf is set to ../bin | |
| # | |
| # $FROM and $TO are both eval'ed recursively and normalized, this means | |
| # that you can call this macro with autoconf's dirnames like `prefix' or | |
| # `datadir'. For example: | |
| # | |
| # AX_COMPUTE_RELATIVE_PATHS([bindir:datadir:bin_to_data]) | |
| # | |
| # AX_COMPUTE_RELATIVE_PATHS should also works with DOS filenames. | |
| # | |
| # You may want to use this macro in order to make your package | |
| # relocatable. Instead of hardcoding $datadir into your programs just | |
| # encode $bin_to_data and try to determine $bindir at run-time. | |
| # | |
| # This macro requires AX_NORMALIZE_PATH and AX_RECURSIVE_EVAL. | |
| # | |
| # LICENSE | |
| # | |
| # Copyright (c) 2008 Alexandre Duret-Lutz <adl@gnu.org> | |
| # | |
| # 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 2 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/>. | |
| # | |
| # As a special exception, the respective Autoconf Macro's copyright owner | |
| # gives unlimited permission to copy, distribute and modify the configure | |
| # scripts that are the output of Autoconf when processing the Macro. You | |
| # need not follow the terms of the GNU General Public License when using | |
| # or distributing such scripts, even though portions of the text of the | |
| # Macro appear in them. The GNU General Public License (GPL) does govern | |
| # all other use of the material that constitutes the Autoconf Macro. | |
| # | |
| # This special exception to the GPL applies to versions of the Autoconf | |
| # Macro released by the Autoconf Archive. When you make and distribute a | |
| # modified version of the Autoconf Macro, you may extend this special | |
| # exception to the GPL to apply to your modified version as well. | |
| #serial 12 | |
| AU_ALIAS([ADL_COMPUTE_RELATIVE_PATHS], [AX_COMPUTE_RELATIVE_PATHS]) | |
| AC_DEFUN([AX_COMPUTE_RELATIVE_PATHS], | |
| [for _lcl_i in $1; do | |
| _lcl_from=\[$]`echo "[$]_lcl_i" | sed 's,:.*$,,'` | |
| _lcl_to=\[$]`echo "[$]_lcl_i" | sed 's,^[[^:]]*:,,' | sed 's,:[[^:]]*$,,'` | |
| _lcl_result_var=`echo "[$]_lcl_i" | sed 's,^.*:,,'` | |
| AX_RECURSIVE_EVAL([[$]_lcl_from], [_lcl_from]) | |
| AX_RECURSIVE_EVAL([[$]_lcl_to], [_lcl_to]) | |
| _lcl_notation="$_lcl_from$_lcl_to" | |
| AX_NORMALIZE_PATH([_lcl_from],['/']) | |
| AX_NORMALIZE_PATH([_lcl_to],['/']) | |
| AX_COMPUTE_RELATIVE_PATH([_lcl_from], [_lcl_to], [_lcl_result_tmp]) | |
| AX_NORMALIZE_PATH([_lcl_result_tmp],["[$]_lcl_notation"]) | |
| eval $_lcl_result_var='[$]_lcl_result_tmp' | |
| done]) | |
| ## Note: | |
| ## ***** | |
| ## The following helper macros are too fragile to be used out | |
| ## of AX_COMPUTE_RELATIVE_PATHS (mainly because they assume that | |
| ## paths are normalized), that's why I'm keeping them in the same file. | |
| ## Still, some of them maybe worth to reuse. | |
| dnl AX_COMPUTE_RELATIVE_PATH(FROM, TO, RESULT) | |
| dnl =========================================== | |
| dnl Compute the relative path to go from $FROM to $TO and set the value | |
| dnl of $RESULT to that value. This function work on raw filenames | |
| dnl (for instead it will considerate /usr//local and /usr/local as | |
| dnl two distinct paths), you should really use AX_COMPUTE_RELATIVE_PATHS | |
| dnl instead to have the paths sanitized automatically. | |
| dnl | |
| dnl For instance: | |
| dnl first_dir=/somewhere/on/my/disk/bin | |
| dnl second_dir=/somewhere/on/another/disk/share | |
| dnl AX_COMPUTE_RELATIVE_PATH(first_dir, second_dir, first_to_second) | |
| dnl will set $first_to_second to '../../../another/disk/share'. | |
| AC_DEFUN([AX_COMPUTE_RELATIVE_PATH], | |
| [AX_COMPUTE_COMMON_PATH([$1], [$2], [_lcl_common_prefix]) | |
| AX_COMPUTE_BACK_PATH([$1], [_lcl_common_prefix], [_lcl_first_rel]) | |
| AX_COMPUTE_SUFFIX_PATH([$2], [_lcl_common_prefix], [_lcl_second_suffix]) | |
| $3="[$]_lcl_first_rel[$]_lcl_second_suffix"]) | |
| dnl AX_COMPUTE_COMMON_PATH(LEFT, RIGHT, RESULT) | |
| dnl ============================================ | |
| dnl Compute the common path to $LEFT and $RIGHT and set the result to $RESULT. | |
| dnl | |
| dnl For instance: | |
| dnl first_path=/somewhere/on/my/disk/bin | |
| dnl second_path=/somewhere/on/another/disk/share | |
| dnl AX_COMPUTE_COMMON_PATH(first_path, second_path, common_path) | |
| dnl will set $common_path to '/somewhere/on'. | |
| AC_DEFUN([AX_COMPUTE_COMMON_PATH], | |
| [$3='' | |
| _lcl_second_prefix_match='' | |
| while test "[$]_lcl_second_prefix_match" != 0; do | |
| _lcl_first_prefix=`expr "x[$]$1" : "x\([$]$3/*[[^/]]*\)"` | |
| _lcl_second_prefix_match=`expr "x[$]$2" : "x[$]_lcl_first_prefix"` | |
| if test "[$]_lcl_second_prefix_match" != 0; then | |
| if test "[$]_lcl_first_prefix" != "[$]$3"; then | |
| $3="[$]_lcl_first_prefix" | |
| else | |
| _lcl_second_prefix_match=0 | |
| fi | |
| fi | |
| done]) | |
| dnl AX_COMPUTE_SUFFIX_PATH(PATH, SUBPATH, RESULT) | |
| dnl ============================================== | |
| dnl Subtract $SUBPATH from $PATH, and set the resulting suffix | |
| dnl (or the empty string if $SUBPATH is not a subpath of $PATH) | |
| dnl to $RESULT. | |
| dnl | |
| dnl For instance: | |
| dnl first_path=/somewhere/on/my/disk/bin | |
| dnl second_path=/somewhere/on | |
| dnl AX_COMPUTE_SUFFIX_PATH(first_path, second_path, common_path) | |
| dnl will set $common_path to '/my/disk/bin'. | |
| AC_DEFUN([AX_COMPUTE_SUFFIX_PATH], | |
| [$3=`expr "x[$]$1" : "x[$]$2/*\(.*\)"`]) | |
| dnl AX_COMPUTE_BACK_PATH(PATH, SUBPATH, RESULT) | |
| dnl ============================================ | |
| dnl Compute the relative path to go from $PATH to $SUBPATH, knowing that | |
| dnl $SUBPATH is a subpath of $PATH (any other words, only repeated '../' | |
| dnl should be needed to move from $PATH to $SUBPATH) and set the value | |
| dnl of $RESULT to that value. If $SUBPATH is not a subpath of PATH, | |
| dnl set $RESULT to the empty string. | |
| dnl | |
| dnl For instance: | |
| dnl first_path=/somewhere/on/my/disk/bin | |
| dnl second_path=/somewhere/on | |
| dnl AX_COMPUTE_BACK_PATH(first_path, second_path, back_path) | |
| dnl will set $back_path to '../../../'. | |
| AC_DEFUN([AX_COMPUTE_BACK_PATH], | |
| [AX_COMPUTE_SUFFIX_PATH([$1], [$2], [_lcl_first_suffix]) | |
| $3='' | |
| _lcl_tmp='xxx' | |
| while test "[$]_lcl_tmp" != ''; do | |
| _lcl_tmp=`expr "x[$]_lcl_first_suffix" : "x[[^/]]*/*\(.*\)"` | |
| if test "[$]_lcl_first_suffix" != ''; then | |
| _lcl_first_suffix="[$]_lcl_tmp" | |
| $3="../[$]$3" | |
| fi | |
| done]) |