1#! /bin/sh 2## DO NOT EDIT - This file generated from build-aux/bootstrap.in 3## by inline-source v2019-02-19.15 4 5# Bootstrap an Autotooled package from checked-out sources. 6# Written by Gary V. Vaughan, 2010 7# Inspired by a script written by Paul Eggert. 8 9# This is free software. There is NO warranty; not even for 10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 11# 12# Copyright (C) 2010-2019 Bootstrap Authors 13# 14# This file is dual licensed under the terms of the MIT license 15# <https://opensource.org/license/MIT>, and GPL version 2 or later 16# <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of 17# these licenses when using or redistributing this software or any of 18# the files within it. See the URLs above, or the file `LICENSE` 19# included in the Bootstrap distribution for the full license texts. 20 21# You should place a copy of this script under version control in the 22# top-level directory of your project. The intent is that all 23# customization can be done with a `bootstrap.conf` file also maintained 24# in your version control. 25 26# Please report bugs or propose patches to: 27# <https://github.com/gnulib-modules/bootstrap/issues> 28 29 30## ------ ## 31## Usage. ## 32## ------ ## 33 34# Most GNUish projects do not keep all of the generated Autotool 35# files under version control, but running all of the right tools 36# with the right arguments, in the correct order to regenerate 37# all of those files in readiness for configuration and building 38# can be surprisingly involved! Many projects have a 'bootstrap' 39# script under version control to invoke Autotools and perform 40# other assorted book-keeping with version numbers and the like. 41# 42# This bootstrap script aims to probe the configure.ac and top 43# Makefile.am of your project to automatically determine what 44# the correct ordering and arguments are and then run the tools for 45# you. In order to use it, you can generate an initial standalone 46# script with: 47# 48# gl/build-aux/inline-source gl/build-aux/bootstrap.in > bootstrap 49# 50# You should then store than script in version control for other 51# developers in you project. It will give you instructions about 52# how to keep it up to date if the sources change. 53# 54# See gl/doc/bootstrap.texi for documentation on how to write 55# a bootstrap.conf to customize it for your project's 56# idiosyncracies. 57 58 59## ================================================================== ## 60## ## 61## DO NOT EDIT THIS FILE, CUSTOMIZE IT USING A BOOTSTRAP.CONF ## 62## ## 63## ================================================================== ## 64 65## ------------------------------- ## 66## User overridable command paths. ## 67## ------------------------------- ## 68 69# All uppercase denotes values stored in the environment. These 70# variables should generally be overridden by the user - however, we do 71# set them to 'true' in some parts of this script to prevent them being 72# called at the wrong time by other tools that we call ('autoreconf', 73# for example). 74# 75# We also allow 'LIBTOOLIZE', 'M4', 'SHA1SUM' and some others to be 76# overridden, and export the result for child processes, but they are 77# handled by the function 'func_find_tool' and not defaulted in this 78# section. 79 80: ${ACLOCAL="aclocal"} 81: ${AUTOCONF="autoconf"} 82: ${AUTOHEADER="autoheader"} 83: ${AUTOM4TE="autom4te"} 84: ${AUTOHEADER="autoheader"} 85: ${AUTOMAKE="automake"} 86: ${AUTOPOINT="autopoint"} 87: ${AUTORECONF="autoreconf"} 88: ${CMP="cmp"} 89: ${CONFIG_SHELL="/bin/sh"} 90: ${DIFF="diff"} 91: ${GIT="git"} 92: ${LN_S="ln -s"} 93: ${RM="rm"} 94 95export ACLOCAL 96export AUTOCONF 97export AUTOHEADER 98export AUTOM4TE 99export AUTOHEADER 100export AUTOMAKE 101export AUTOPOINT 102export AUTORECONF 103export CONFIG_SHELL 104 105 106## -------------- ## 107## Configuration. ## 108## -------------- ## 109 110# A newline delimited list of triples of programs (that respond to 111# --version), the minimum version numbers required (or just '-' in the 112# version field if any version will be sufficient) and homepage URLs 113# to help locate missing packages. 114buildreq= 115 116# Name of a file containing instructions on installing missing packages 117# required in 'buildreq'. 118buildreq_readme=README-hacking 119 120# These are extracted from AC_INIT in configure.ac, though you can 121# override those values in 'bootstrap.conf' if you prefer. 122build_aux= 123macro_dir= 124package= 125package_name= 126package_version= 127package_bugreport= 128 129# These are extracted from 'gnulib-cache.m4', or else fall-back 130# automatically on the gnulib defaults; unless you set the values 131# manually in 'bootstrap.conf'. 132doc_base= 133gnulib_mk= 134gnulib_name= 135local_gl_path= 136source_base= 137tests_base= 138 139# The list of gnulib modules required at 'gnulib-tool' time. If you 140# check 'gnulib-cache.m4' into your repository, then this list will be 141# extracted automatically. 142gnulib_modules= 143 144# Extra gnulib files that are not in modules, which override files of 145# the same name installed by other bootstrap tools. 146gnulib_non_module_files=" 147 build-aux/compile 148 build-aux/install-sh 149 build-aux/mdate-sh 150 build-aux/texinfo.tex 151 build-aux/depcomp 152 build-aux/config.guess 153 build-aux/config.sub 154 doc/INSTALL 155" 156 157# Relative path to the local gnulib submodule, and url to the upstream 158# git repository. If you have a gnulib entry in your .gitmodules file, 159# these values are ignored. 160gnulib_path= 161gnulib_url= 162 163# Date from which to clone github, to avoid a full clone. 164gnulib_clone_since= 165 166# Additional gnulib-tool options to use. 167gnulib_tool_options=" 168 --no-changelog 169" 170 171# bootstrap removes any macro-files that are not included by aclocal.m4, 172# except for files listed in this variable that are always kept. 173gnulib_precious=" 174 gnulib-tool.m4 175" 176 177# When truncating long commands for display, always allow at least this 178# many characters before truncating. 179min_cmd_len=160 180 181# The command to download all .po files for a specified domain into 182# a specified directory. Fill in the first %s is the domain name, and 183# the second with the destination directory. Use rsync's -L and -r 184# options because the latest/%s directory and the .po files within are 185# all symlinks. 186po_download_command_format=\ 187"rsync --delete --exclude '*.s1' -Lrtvz \ 188'translationproject.org::tp/latest/%s/' '%s'" 189 190# Other locale categories that need message catalogs. 191extra_locale_categories= 192 193# Additional xgettext options to use. Gnulib might provide you with an 194# extensive list of additional options to append to this, but gettext 195# 0.16.1 and newer appends them automaticaly, so you can safely ignore 196# the complaints from 'gnulib-tool' if your $configure_ac states: 197# 198# AM_GNU_GETTEXT_VERSION([0.16.1]) 199xgettext_options=" 200 --flag=_:1:pass-c-format 201 --flag=N_:1:pass-c-format 202" 203 204# Package copyright holder for gettext files. Defaults to FSF if unset. 205copyright_holder= 206 207# File that should exist in the top directory of a checked out hierarchy, 208# but not in a distribution tarball. 209checkout_only_file= 210 211# Whether to use copies instead of symlinks by default (if set to true, 212# the --copy option has no effect). 213copy=false 214 215# Set this to ".cvsignore .gitignore" in 'bootstrap.conf' if you want 216# those files to be generated in directories like 'lib/', 'm4/', and 'po/', 217# or set it to "auto" to make this script select what to use based 218# on what version control system (if any) is used in the source directory. 219# Or set it to "none" to ignore VCS ignore files entirely. Default is 220# "auto". 221vc_ignore= 222 223 224## ------------------- ## 225## External Libraries. ## 226## ------------------- ## 227 228# Source required external libraries: 229# Set a version string for this script. 230scriptversion=2019-02-19.15; # UTC 231 232# General shell script boiler plate, and helper functions. 233# Written by Gary V. Vaughan, 2004 234 235# This is free software. There is NO warranty; not even for 236# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 237# 238# Copyright (C) 2004-2019 Bootstrap Authors 239# 240# This file is dual licensed under the terms of the MIT license 241# <https://opensource.org/license/MIT>, and GPL version 2 or later 242# <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of 243# these licenses when using or redistributing this software or any of 244# the files within it. See the URLs above, or the file `LICENSE` 245# included in the Bootstrap distribution for the full license texts. 246 247# Please report bugs or propose patches to: 248# <https://github.com/gnulib-modules/bootstrap/issues> 249 250 251## ------ ## 252## Usage. ## 253## ------ ## 254 255# Evaluate this file near the top of your script to gain access to 256# the functions and variables defined here: 257# 258# . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh 259# 260# If you need to override any of the default environment variable 261# settings, do that before evaluating this file. 262 263 264## -------------------- ## 265## Shell normalisation. ## 266## -------------------- ## 267 268# Some shells need a little help to be as Bourne compatible as possible. 269# Before doing anything else, make sure all that help has been provided! 270 271DUALCASE=1; export DUALCASE # for MKS sh 272if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : 273 emulate sh 274 NULLCMD=: 275 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which 276 # is contrary to our usage. Disable this feature. 277 alias -g '${1+"$@"}'='"$@"' 278 setopt NO_GLOB_SUBST 279else 280 case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac 281fi 282 283# NLS nuisances: We save the old values in case they are required later. 284_G_user_locale= 285_G_safe_locale= 286for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES 287do 288 eval "if test set = \"\${$_G_var+set}\"; then 289 save_$_G_var=\$$_G_var 290 $_G_var=C 291 export $_G_var 292 _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\" 293 _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\" 294 fi" 295done 296 297# Make sure IFS has a sensible default 298sp=' ' 299nl=' 300' 301IFS="$sp $nl" 302 303# There are apparently some retarded systems that use ';' as a PATH separator! 304if test "${PATH_SEPARATOR+set}" != set; then 305 PATH_SEPARATOR=: 306 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { 307 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || 308 PATH_SEPARATOR=';' 309 } 310fi 311 312 313# func_unset VAR 314# -------------- 315# Portably unset VAR. 316# In some shells, an 'unset VAR' statement leaves a non-zero return 317# status if VAR is already unset, which might be problematic if the 318# statement is used at the end of a function (thus poisoning its return 319# value) or when 'set -e' is active (causing even a spurious abort of 320# the script in this case). 321func_unset () 322{ 323 { eval $1=; (eval unset $1) >/dev/null 2>&1 && eval unset $1 || : ; } 324} 325 326 327# Make sure CDPATH doesn't cause `cd` commands to output the target dir. 328func_unset CDPATH 329 330# Make sure ${,E,F}GREP behave sanely. 331func_unset GREP_OPTIONS 332 333 334## ------------------------- ## 335## Locate command utilities. ## 336## ------------------------- ## 337 338 339# func_executable_p FILE 340# ---------------------- 341# Check that FILE is an executable regular file. 342func_executable_p () 343{ 344 test -f "$1" && test -x "$1" 345} 346 347 348# func_path_progs PROGS_LIST CHECK_FUNC [PATH] 349# -------------------------------------------- 350# Search for either a program that responds to --version with output 351# containing "GNU", or else returned by CHECK_FUNC otherwise, by 352# trying all the directories in PATH with each of the elements of 353# PROGS_LIST. 354# 355# CHECK_FUNC should accept the path to a candidate program, and 356# set $func_check_prog_result if it truncates its output less than 357# $_G_path_prog_max characters. 358func_path_progs () 359{ 360 _G_progs_list=$1 361 _G_check_func=$2 362 _G_PATH=${3-"$PATH"} 363 364 _G_path_prog_max=0 365 _G_path_prog_found=false 366 _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:} 367 for _G_dir in $_G_PATH; do 368 IFS=$_G_save_IFS 369 test -z "$_G_dir" && _G_dir=. 370 for _G_prog_name in $_G_progs_list; do 371 for _exeext in '' .EXE; do 372 _G_path_prog=$_G_dir/$_G_prog_name$_exeext 373 func_executable_p "$_G_path_prog" || continue 374 case `"$_G_path_prog" --version 2>&1` in 375 *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;; 376 *) $_G_check_func $_G_path_prog 377 func_path_progs_result=$func_check_prog_result 378 ;; 379 esac 380 $_G_path_prog_found && break 3 381 done 382 done 383 done 384 IFS=$_G_save_IFS 385 test -z "$func_path_progs_result" && { 386 echo "no acceptable sed could be found in \$PATH" >&2 387 exit 1 388 } 389} 390 391 392# We want to be able to use the functions in this file before configure 393# has figured out where the best binaries are kept, which means we have 394# to search for them ourselves - except when the results are already set 395# where we skip the searches. 396 397# Unless the user overrides by setting SED, search the path for either GNU 398# sed, or the sed that truncates its output the least. 399test -z "$SED" && { 400 _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ 401 for _G_i in 1 2 3 4 5 6 7; do 402 _G_sed_script=$_G_sed_script$nl$_G_sed_script 403 done 404 echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed 405 _G_sed_script= 406 407 func_check_prog_sed () 408 { 409 _G_path_prog=$1 410 411 _G_count=0 412 printf 0123456789 >conftest.in 413 while : 414 do 415 cat conftest.in conftest.in >conftest.tmp 416 mv conftest.tmp conftest.in 417 cp conftest.in conftest.nl 418 echo '' >> conftest.nl 419 "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break 420 diff conftest.out conftest.nl >/dev/null 2>&1 || break 421 _G_count=`expr $_G_count + 1` 422 if test "$_G_count" -gt "$_G_path_prog_max"; then 423 # Best one so far, save it but keep looking for a better one 424 func_check_prog_result=$_G_path_prog 425 _G_path_prog_max=$_G_count 426 fi 427 # 10*(2^10) chars as input seems more than enough 428 test 10 -lt "$_G_count" && break 429 done 430 rm -f conftest.in conftest.tmp conftest.nl conftest.out 431 } 432 433 func_path_progs "sed gsed" func_check_prog_sed "$PATH:/usr/xpg4/bin" 434 rm -f conftest.sed 435 SED=$func_path_progs_result 436} 437 438 439# Unless the user overrides by setting GREP, search the path for either GNU 440# grep, or the grep that truncates its output the least. 441test -z "$GREP" && { 442 func_check_prog_grep () 443 { 444 _G_path_prog=$1 445 446 _G_count=0 447 _G_path_prog_max=0 448 printf 0123456789 >conftest.in 449 while : 450 do 451 cat conftest.in conftest.in >conftest.tmp 452 mv conftest.tmp conftest.in 453 cp conftest.in conftest.nl 454 echo 'GREP' >> conftest.nl 455 "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break 456 diff conftest.out conftest.nl >/dev/null 2>&1 || break 457 _G_count=`expr $_G_count + 1` 458 if test "$_G_count" -gt "$_G_path_prog_max"; then 459 # Best one so far, save it but keep looking for a better one 460 func_check_prog_result=$_G_path_prog 461 _G_path_prog_max=$_G_count 462 fi 463 # 10*(2^10) chars as input seems more than enough 464 test 10 -lt "$_G_count" && break 465 done 466 rm -f conftest.in conftest.tmp conftest.nl conftest.out 467 } 468 469 func_path_progs "grep ggrep" func_check_prog_grep "$PATH:/usr/xpg4/bin" 470 GREP=$func_path_progs_result 471} 472 473 474## ------------------------------- ## 475## User overridable command paths. ## 476## ------------------------------- ## 477 478# All uppercase variable names are used for environment variables. These 479# variables can be overridden by the user before calling a script that 480# uses them if a suitable command of that name is not already available 481# in the command search PATH. 482 483: ${CP="cp -f"} 484: ${ECHO="printf %s\n"} 485: ${EGREP="$GREP -E"} 486: ${FGREP="$GREP -F"} 487: ${LN_S="ln -s"} 488: ${MAKE="make"} 489: ${MKDIR="mkdir"} 490: ${MV="mv -f"} 491: ${RM="rm -f"} 492: ${SHELL="${CONFIG_SHELL-/bin/sh}"} 493 494 495## -------------------- ## 496## Useful sed snippets. ## 497## -------------------- ## 498 499sed_dirname='s|/[^/]*$||' 500sed_basename='s|^.*/||' 501 502# Sed substitution that helps us do robust quoting. It backslashifies 503# metacharacters that are still active within double-quoted strings. 504sed_quote_subst='s|\([`"$\\]\)|\\\1|g' 505 506# Same as above, but do not quote variable references. 507sed_double_quote_subst='s/\(["`\\]\)/\\\1/g' 508 509# Sed substitution that turns a string into a regex matching for the 510# string literally. 511sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g' 512 513# Sed substitution that converts a w32 file name or path 514# that contains forward slashes, into one that contains 515# (escaped) backslashes. A very naive implementation. 516sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' 517 518# Re-'\' parameter expansions in output of sed_double_quote_subst that 519# were '\'-ed in input to the same. If an odd number of '\' preceded a 520# '$' in input to sed_double_quote_subst, that '$' was protected from 521# expansion. Since each input '\' is now two '\'s, look for any number 522# of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'. 523_G_bs='\\' 524_G_bs2='\\\\' 525_G_bs4='\\\\\\\\' 526_G_dollar='\$' 527sed_double_backslash="\ 528 s/$_G_bs4/&\\ 529/g 530 s/^$_G_bs2$_G_dollar/$_G_bs&/ 531 s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g 532 s/\n//g" 533 534 535## ----------------- ## 536## Global variables. ## 537## ----------------- ## 538 539# Except for the global variables explicitly listed below, the following 540# functions in the '^func_' namespace, and the '^require_' namespace 541# variables initialised in the 'Resource management' section, sourcing 542# this file will not pollute your global namespace with anything 543# else. There's no portable way to scope variables in Bourne shell 544# though, so actually running these functions will sometimes place 545# results into a variable named after the function, and often use 546# temporary variables in the '^_G_' namespace. If you are careful to 547# avoid using those namespaces casually in your sourcing script, things 548# should continue to work as you expect. And, of course, you can freely 549# overwrite any of the functions or variables defined here before 550# calling anything to customize them. 551 552EXIT_SUCCESS=0 553EXIT_FAILURE=1 554EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. 555EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. 556 557# Allow overriding, eg assuming that you follow the convention of 558# putting '$debug_cmd' at the start of all your functions, you can get 559# bash to show function call trace with: 560# 561# debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name 562debug_cmd=${debug_cmd-":"} 563exit_cmd=: 564 565# By convention, finish your script with: 566# 567# exit $exit_status 568# 569# so that you can set exit_status to non-zero if you want to indicate 570# something went wrong during execution without actually bailing out at 571# the point of failure. 572exit_status=$EXIT_SUCCESS 573 574# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh 575# is ksh but when the shell is invoked as "sh" and the current value of 576# the _XPG environment variable is not equal to 1 (one), the special 577# positional parameter $0, within a function call, is the name of the 578# function. 579progpath=$0 580 581# The name of this program. 582progname=`$ECHO "$progpath" |$SED "$sed_basename"` 583 584# Make sure we have an absolute progpath for reexecution: 585case $progpath in 586 [\\/]*|[A-Za-z]:\\*) ;; 587 *[\\/]*) 588 progdir=`$ECHO "$progpath" |$SED "$sed_dirname"` 589 progdir=`cd "$progdir" && pwd` 590 progpath=$progdir/$progname 591 ;; 592 *) 593 _G_IFS=$IFS 594 IFS=${PATH_SEPARATOR-:} 595 for progdir in $PATH; do 596 IFS=$_G_IFS 597 test -x "$progdir/$progname" && break 598 done 599 IFS=$_G_IFS 600 test -n "$progdir" || progdir=`pwd` 601 progpath=$progdir/$progname 602 ;; 603esac 604 605 606## ----------------- ## 607## Standard options. ## 608## ----------------- ## 609 610# The following options affect the operation of the functions defined 611# below, and should be set appropriately depending on run-time para- 612# meters passed on the command line. 613 614opt_dry_run=false 615opt_quiet=false 616opt_verbose=false 617 618# Categories 'all' and 'none' are always available. Append any others 619# you will pass as the first argument to func_warning from your own 620# code. 621warning_categories= 622 623# By default, display warnings according to 'opt_warning_types'. Set 624# 'warning_func' to ':' to elide all warnings, or func_fatal_error to 625# treat the next displayed warning as a fatal error. 626warning_func=func_warn_and_continue 627 628# Set to 'all' to display all warnings, 'none' to suppress all 629# warnings, or a space delimited list of some subset of 630# 'warning_categories' to display only the listed warnings. 631opt_warning_types=all 632 633 634## -------------------- ## 635## Resource management. ## 636## -------------------- ## 637 638# This section contains definitions for functions that each ensure a 639# particular resource (a file, or a non-empty configuration variable for 640# example) is available, and if appropriate to extract default values 641# from pertinent package files. Call them using their associated 642# 'require_*' variable to ensure that they are executed, at most, once. 643# 644# It's entirely deliberate that calling these functions can set 645# variables that don't obey the namespace limitations obeyed by the rest 646# of this file, in order that that they be as useful as possible to 647# callers. 648 649 650# require_term_colors 651# ------------------- 652# Allow display of bold text on terminals that support it. 653require_term_colors=func_require_term_colors 654func_require_term_colors () 655{ 656 $debug_cmd 657 658 test -t 1 && { 659 # COLORTERM and USE_ANSI_COLORS environment variables take 660 # precedence, because most terminfo databases neglect to describe 661 # whether color sequences are supported. 662 test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"} 663 664 if test 1 = "$USE_ANSI_COLORS"; then 665 # Standard ANSI escape sequences 666 tc_reset='[0m' 667 tc_bold='[1m'; tc_standout='[7m' 668 tc_red='[31m'; tc_green='[32m' 669 tc_blue='[34m'; tc_cyan='[36m' 670 else 671 # Otherwise trust the terminfo database after all. 672 test -n "`tput sgr0 2>/dev/null`" && { 673 tc_reset=`tput sgr0` 674 test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold` 675 tc_standout=$tc_bold 676 test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso` 677 test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1` 678 test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2` 679 test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4` 680 test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5` 681 } 682 fi 683 } 684 685 require_term_colors=: 686} 687 688 689## ----------------- ## 690## Function library. ## 691## ----------------- ## 692 693# This section contains a variety of useful functions to call in your 694# scripts. Take note of the portable wrappers for features provided by 695# some modern shells, which will fall back to slower equivalents on 696# less featureful shells. 697 698 699# func_append VAR VALUE 700# --------------------- 701# Append VALUE onto the existing contents of VAR. 702 703 # We should try to minimise forks, especially on Windows where they are 704 # unreasonably slow, so skip the feature probes when bash or zsh are 705 # being used: 706 if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then 707 : ${_G_HAVE_ARITH_OP="yes"} 708 : ${_G_HAVE_XSI_OPS="yes"} 709 # The += operator was introduced in bash 3.1 710 case $BASH_VERSION in 711 [12].* | 3.0 | 3.0*) ;; 712 *) 713 : ${_G_HAVE_PLUSEQ_OP="yes"} 714 ;; 715 esac 716 fi 717 718 # _G_HAVE_PLUSEQ_OP 719 # Can be empty, in which case the shell is probed, "yes" if += is 720 # useable or anything else if it does not work. 721 test -z "$_G_HAVE_PLUSEQ_OP" \ 722 && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \ 723 && _G_HAVE_PLUSEQ_OP=yes 724 725if test yes = "$_G_HAVE_PLUSEQ_OP" 726then 727 # This is an XSI compatible shell, allowing a faster implementation... 728 eval 'func_append () 729 { 730 $debug_cmd 731 732 eval "$1+=\$2" 733 }' 734else 735 # ...otherwise fall back to using expr, which is often a shell builtin. 736 func_append () 737 { 738 $debug_cmd 739 740 eval "$1=\$$1\$2" 741 } 742fi 743 744 745# func_append_quoted VAR VALUE 746# ---------------------------- 747# Quote VALUE and append to the end of shell variable VAR, separated 748# by a space. 749if test yes = "$_G_HAVE_PLUSEQ_OP"; then 750 eval 'func_append_quoted () 751 { 752 $debug_cmd 753 754 func_quote_arg pretty "$2" 755 eval "$1+=\\ \$func_quote_arg_result" 756 }' 757else 758 func_append_quoted () 759 { 760 $debug_cmd 761 762 func_quote_arg pretty "$2" 763 eval "$1=\$$1\\ \$func_quote_arg_result" 764 } 765fi 766 767 768# func_append_uniq VAR VALUE 769# -------------------------- 770# Append unique VALUE onto the existing contents of VAR, assuming 771# entries are delimited by the first character of VALUE. For example: 772# 773# func_append_uniq options " --another-option option-argument" 774# 775# will only append to $options if " --another-option option-argument " 776# is not already present somewhere in $options already (note spaces at 777# each end implied by leading space in second argument). 778func_append_uniq () 779{ 780 $debug_cmd 781 782 eval _G_current_value='`$ECHO $'$1'`' 783 _G_delim=`expr "$2" : '\(.\)'` 784 785 case $_G_delim$_G_current_value$_G_delim in 786 *"$2$_G_delim"*) ;; 787 *) func_append "$@" ;; 788 esac 789} 790 791 792# func_arith TERM... 793# ------------------ 794# Set func_arith_result to the result of evaluating TERMs. 795 test -z "$_G_HAVE_ARITH_OP" \ 796 && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \ 797 && _G_HAVE_ARITH_OP=yes 798 799if test yes = "$_G_HAVE_ARITH_OP"; then 800 eval 'func_arith () 801 { 802 $debug_cmd 803 804 func_arith_result=$(( $* )) 805 }' 806else 807 func_arith () 808 { 809 $debug_cmd 810 811 func_arith_result=`expr "$@"` 812 } 813fi 814 815 816# func_basename FILE 817# ------------------ 818# Set func_basename_result to FILE with everything up to and including 819# the last / stripped. 820if test yes = "$_G_HAVE_XSI_OPS"; then 821 # If this shell supports suffix pattern removal, then use it to avoid 822 # forking. Hide the definitions single quotes in case the shell chokes 823 # on unsupported syntax... 824 _b='func_basename_result=${1##*/}' 825 _d='case $1 in 826 */*) func_dirname_result=${1%/*}$2 ;; 827 * ) func_dirname_result=$3 ;; 828 esac' 829 830else 831 # ...otherwise fall back to using sed. 832 _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`' 833 _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"` 834 if test "X$func_dirname_result" = "X$1"; then 835 func_dirname_result=$3 836 else 837 func_append func_dirname_result "$2" 838 fi' 839fi 840 841eval 'func_basename () 842{ 843 $debug_cmd 844 845 '"$_b"' 846}' 847 848 849# func_dirname FILE APPEND NONDIR_REPLACEMENT 850# ------------------------------------------- 851# Compute the dirname of FILE. If nonempty, add APPEND to the result, 852# otherwise set result to NONDIR_REPLACEMENT. 853eval 'func_dirname () 854{ 855 $debug_cmd 856 857 '"$_d"' 858}' 859 860 861# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT 862# -------------------------------------------------------- 863# Perform func_basename and func_dirname in a single function 864# call: 865# dirname: Compute the dirname of FILE. If nonempty, 866# add APPEND to the result, otherwise set result 867# to NONDIR_REPLACEMENT. 868# value returned in "$func_dirname_result" 869# basename: Compute filename of FILE. 870# value retuned in "$func_basename_result" 871# For efficiency, we do not delegate to the functions above but instead 872# duplicate the functionality here. 873eval 'func_dirname_and_basename () 874{ 875 $debug_cmd 876 877 '"$_b"' 878 '"$_d"' 879}' 880 881 882# func_echo ARG... 883# ---------------- 884# Echo program name prefixed message. 885func_echo () 886{ 887 $debug_cmd 888 889 _G_message=$* 890 891 func_echo_IFS=$IFS 892 IFS=$nl 893 for _G_line in $_G_message; do 894 IFS=$func_echo_IFS 895 $ECHO "$progname: $_G_line" 896 done 897 IFS=$func_echo_IFS 898} 899 900 901# func_echo_all ARG... 902# -------------------- 903# Invoke $ECHO with all args, space-separated. 904func_echo_all () 905{ 906 $ECHO "$*" 907} 908 909 910# func_echo_infix_1 INFIX ARG... 911# ------------------------------ 912# Echo program name, followed by INFIX on the first line, with any 913# additional lines not showing INFIX. 914func_echo_infix_1 () 915{ 916 $debug_cmd 917 918 $require_term_colors 919 920 _G_infix=$1; shift 921 _G_indent=$_G_infix 922 _G_prefix="$progname: $_G_infix: " 923 _G_message=$* 924 925 # Strip color escape sequences before counting printable length 926 for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan" 927 do 928 test -n "$_G_tc" && { 929 _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"` 930 _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"` 931 } 932 done 933 _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes 934 935 func_echo_infix_1_IFS=$IFS 936 IFS=$nl 937 for _G_line in $_G_message; do 938 IFS=$func_echo_infix_1_IFS 939 $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2 940 _G_prefix=$_G_indent 941 done 942 IFS=$func_echo_infix_1_IFS 943} 944 945 946# func_error ARG... 947# ----------------- 948# Echo program name prefixed message to standard error. 949func_error () 950{ 951 $debug_cmd 952 953 $require_term_colors 954 955 func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2 956} 957 958 959# func_fatal_error ARG... 960# ----------------------- 961# Echo program name prefixed message to standard error, and exit. 962func_fatal_error () 963{ 964 $debug_cmd 965 966 func_error "$*" 967 exit $EXIT_FAILURE 968} 969 970 971# func_grep EXPRESSION FILENAME 972# ----------------------------- 973# Check whether EXPRESSION matches any line of FILENAME, without output. 974func_grep () 975{ 976 $debug_cmd 977 978 $GREP "$1" "$2" >/dev/null 2>&1 979} 980 981 982# func_len STRING 983# --------------- 984# Set func_len_result to the length of STRING. STRING may not 985# start with a hyphen. 986 test -z "$_G_HAVE_XSI_OPS" \ 987 && (eval 'x=a/b/c; 988 test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ 989 && _G_HAVE_XSI_OPS=yes 990 991if test yes = "$_G_HAVE_XSI_OPS"; then 992 eval 'func_len () 993 { 994 $debug_cmd 995 996 func_len_result=${#1} 997 }' 998else 999 func_len () 1000 { 1001 $debug_cmd 1002 1003 func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len` 1004 } 1005fi 1006 1007 1008# func_mkdir_p DIRECTORY-PATH 1009# --------------------------- 1010# Make sure the entire path to DIRECTORY-PATH is available. 1011func_mkdir_p () 1012{ 1013 $debug_cmd 1014 1015 _G_directory_path=$1 1016 _G_dir_list= 1017 1018 if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then 1019 1020 # Protect directory names starting with '-' 1021 case $_G_directory_path in 1022 -*) _G_directory_path=./$_G_directory_path ;; 1023 esac 1024 1025 # While some portion of DIR does not yet exist... 1026 while test ! -d "$_G_directory_path"; do 1027 # ...make a list in topmost first order. Use a colon delimited 1028 # list incase some portion of path contains whitespace. 1029 _G_dir_list=$_G_directory_path:$_G_dir_list 1030 1031 # If the last portion added has no slash in it, the list is done 1032 case $_G_directory_path in */*) ;; *) break ;; esac 1033 1034 # ...otherwise throw away the child directory and loop 1035 _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"` 1036 done 1037 _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'` 1038 1039 func_mkdir_p_IFS=$IFS; IFS=: 1040 for _G_dir in $_G_dir_list; do 1041 IFS=$func_mkdir_p_IFS 1042 # mkdir can fail with a 'File exist' error if two processes 1043 # try to create one of the directories concurrently. Don't 1044 # stop in that case! 1045 $MKDIR "$_G_dir" 2>/dev/null || : 1046 done 1047 IFS=$func_mkdir_p_IFS 1048 1049 # Bail out if we (or some other process) failed to create a directory. 1050 test -d "$_G_directory_path" || \ 1051 func_fatal_error "Failed to create '$1'" 1052 fi 1053} 1054 1055 1056# func_mktempdir [BASENAME] 1057# ------------------------- 1058# Make a temporary directory that won't clash with other running 1059# libtool processes, and avoids race conditions if possible. If 1060# given, BASENAME is the basename for that directory. 1061func_mktempdir () 1062{ 1063 $debug_cmd 1064 1065 _G_template=${TMPDIR-/tmp}/${1-$progname} 1066 1067 if test : = "$opt_dry_run"; then 1068 # Return a directory name, but don't create it in dry-run mode 1069 _G_tmpdir=$_G_template-$$ 1070 else 1071 1072 # If mktemp works, use that first and foremost 1073 _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null` 1074 1075 if test ! -d "$_G_tmpdir"; then 1076 # Failing that, at least try and use $RANDOM to avoid a race 1077 _G_tmpdir=$_G_template-${RANDOM-0}$$ 1078 1079 func_mktempdir_umask=`umask` 1080 umask 0077 1081 $MKDIR "$_G_tmpdir" 1082 umask $func_mktempdir_umask 1083 fi 1084 1085 # If we're not in dry-run mode, bomb out on failure 1086 test -d "$_G_tmpdir" || \ 1087 func_fatal_error "cannot create temporary directory '$_G_tmpdir'" 1088 fi 1089 1090 $ECHO "$_G_tmpdir" 1091} 1092 1093 1094# func_normal_abspath PATH 1095# ------------------------ 1096# Remove doubled-up and trailing slashes, "." path components, 1097# and cancel out any ".." path components in PATH after making 1098# it an absolute path. 1099func_normal_abspath () 1100{ 1101 $debug_cmd 1102 1103 # These SED scripts presuppose an absolute path with a trailing slash. 1104 _G_pathcar='s|^/\([^/]*\).*$|\1|' 1105 _G_pathcdr='s|^/[^/]*||' 1106 _G_removedotparts=':dotsl 1107 s|/\./|/|g 1108 t dotsl 1109 s|/\.$|/|' 1110 _G_collapseslashes='s|/\{1,\}|/|g' 1111 _G_finalslash='s|/*$|/|' 1112 1113 # Start from root dir and reassemble the path. 1114 func_normal_abspath_result= 1115 func_normal_abspath_tpath=$1 1116 func_normal_abspath_altnamespace= 1117 case $func_normal_abspath_tpath in 1118 "") 1119 # Empty path, that just means $cwd. 1120 func_stripname '' '/' "`pwd`" 1121 func_normal_abspath_result=$func_stripname_result 1122 return 1123 ;; 1124 # The next three entries are used to spot a run of precisely 1125 # two leading slashes without using negated character classes; 1126 # we take advantage of case's first-match behaviour. 1127 ///*) 1128 # Unusual form of absolute path, do nothing. 1129 ;; 1130 //*) 1131 # Not necessarily an ordinary path; POSIX reserves leading '//' 1132 # and for example Cygwin uses it to access remote file shares 1133 # over CIFS/SMB, so we conserve a leading double slash if found. 1134 func_normal_abspath_altnamespace=/ 1135 ;; 1136 /*) 1137 # Absolute path, do nothing. 1138 ;; 1139 *) 1140 # Relative path, prepend $cwd. 1141 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath 1142 ;; 1143 esac 1144 1145 # Cancel out all the simple stuff to save iterations. We also want 1146 # the path to end with a slash for ease of parsing, so make sure 1147 # there is one (and only one) here. 1148 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ 1149 -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"` 1150 while :; do 1151 # Processed it all yet? 1152 if test / = "$func_normal_abspath_tpath"; then 1153 # If we ascended to the root using ".." the result may be empty now. 1154 if test -z "$func_normal_abspath_result"; then 1155 func_normal_abspath_result=/ 1156 fi 1157 break 1158 fi 1159 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ 1160 -e "$_G_pathcar"` 1161 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ 1162 -e "$_G_pathcdr"` 1163 # Figure out what to do with it 1164 case $func_normal_abspath_tcomponent in 1165 "") 1166 # Trailing empty path component, ignore it. 1167 ;; 1168 ..) 1169 # Parent dir; strip last assembled component from result. 1170 func_dirname "$func_normal_abspath_result" 1171 func_normal_abspath_result=$func_dirname_result 1172 ;; 1173 *) 1174 # Actual path component, append it. 1175 func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent" 1176 ;; 1177 esac 1178 done 1179 # Restore leading double-slash if one was found on entry. 1180 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result 1181} 1182 1183 1184# func_notquiet ARG... 1185# -------------------- 1186# Echo program name prefixed message only when not in quiet mode. 1187func_notquiet () 1188{ 1189 $debug_cmd 1190 1191 $opt_quiet || func_echo ${1+"$@"} 1192 1193 # A bug in bash halts the script if the last line of a function 1194 # fails when set -e is in force, so we need another command to 1195 # work around that: 1196 : 1197} 1198 1199 1200# func_relative_path SRCDIR DSTDIR 1201# -------------------------------- 1202# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR. 1203func_relative_path () 1204{ 1205 $debug_cmd 1206 1207 func_relative_path_result= 1208 func_normal_abspath "$1" 1209 func_relative_path_tlibdir=$func_normal_abspath_result 1210 func_normal_abspath "$2" 1211 func_relative_path_tbindir=$func_normal_abspath_result 1212 1213 # Ascend the tree starting from libdir 1214 while :; do 1215 # check if we have found a prefix of bindir 1216 case $func_relative_path_tbindir in 1217 $func_relative_path_tlibdir) 1218 # found an exact match 1219 func_relative_path_tcancelled= 1220 break 1221 ;; 1222 $func_relative_path_tlibdir*) 1223 # found a matching prefix 1224 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" 1225 func_relative_path_tcancelled=$func_stripname_result 1226 if test -z "$func_relative_path_result"; then 1227 func_relative_path_result=. 1228 fi 1229 break 1230 ;; 1231 *) 1232 func_dirname $func_relative_path_tlibdir 1233 func_relative_path_tlibdir=$func_dirname_result 1234 if test -z "$func_relative_path_tlibdir"; then 1235 # Have to descend all the way to the root! 1236 func_relative_path_result=../$func_relative_path_result 1237 func_relative_path_tcancelled=$func_relative_path_tbindir 1238 break 1239 fi 1240 func_relative_path_result=../$func_relative_path_result 1241 ;; 1242 esac 1243 done 1244 1245 # Now calculate path; take care to avoid doubling-up slashes. 1246 func_stripname '' '/' "$func_relative_path_result" 1247 func_relative_path_result=$func_stripname_result 1248 func_stripname '/' '/' "$func_relative_path_tcancelled" 1249 if test -n "$func_stripname_result"; then 1250 func_append func_relative_path_result "/$func_stripname_result" 1251 fi 1252 1253 # Normalisation. If bindir is libdir, return '.' else relative path. 1254 if test -n "$func_relative_path_result"; then 1255 func_stripname './' '' "$func_relative_path_result" 1256 func_relative_path_result=$func_stripname_result 1257 fi 1258 1259 test -n "$func_relative_path_result" || func_relative_path_result=. 1260 1261 : 1262} 1263 1264 1265# func_quote_portable EVAL ARG 1266# ---------------------------- 1267# Internal function to portably implement func_quote_arg. Note that we still 1268# keep attention to performance here so we as much as possible try to avoid 1269# calling sed binary (so far O(N) complexity as long as func_append is O(1)). 1270func_quote_portable () 1271{ 1272 $debug_cmd 1273 1274 func_quote_portable_result=$2 1275 1276 # one-time-loop (easy break) 1277 while true 1278 do 1279 if $1; then 1280 func_quote_portable_result=`$ECHO "$2" | $SED \ 1281 -e "$sed_double_quote_subst" -e "$sed_double_backslash"` 1282 break 1283 fi 1284 1285 # Quote for eval. 1286 case $func_quote_portable_result in 1287 *[\\\`\"\$]*) 1288 case $func_quote_portable_result in 1289 *[\[\*\?]*) 1290 func_quote_portable_result=`$ECHO "$func_quote_portable_result" \ 1291 | $SED "$sed_quote_subst"` 1292 break 1293 ;; 1294 esac 1295 1296 func_quote_portable_old_IFS=$IFS 1297 for _G_char in '\' '`' '"' '$' 1298 do 1299 # STATE($1) PREV($2) SEPARATOR($3) 1300 set start "" "" 1301 func_quote_portable_result=dummy"$_G_char$func_quote_portable_result$_G_char"dummy 1302 IFS=$_G_char 1303 for _G_part in $func_quote_portable_result 1304 do 1305 case $1 in 1306 quote) 1307 func_append func_quote_portable_result "$3$2" 1308 set quote "$_G_part" "\\$_G_char" 1309 ;; 1310 start) 1311 set first "" "" 1312 func_quote_portable_result= 1313 ;; 1314 first) 1315 set quote "$_G_part" "" 1316 ;; 1317 esac 1318 done 1319 done 1320 IFS=$func_quote_portable_old_IFS 1321 ;; 1322 *) ;; 1323 esac 1324 break 1325 done 1326 1327 func_quote_portable_unquoted_result=$func_quote_portable_result 1328 case $func_quote_portable_result in 1329 # double-quote args containing shell metacharacters to delay 1330 # word splitting, command substitution and variable expansion 1331 # for a subsequent eval. 1332 # many bourne shells cannot handle close brackets correctly 1333 # in scan sets, so we specify it separately. 1334 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") 1335 func_quote_portable_result=\"$func_quote_portable_result\" 1336 ;; 1337 esac 1338} 1339 1340 1341# func_quotefast_eval ARG 1342# ----------------------- 1343# Quote one ARG (internal). This is equivalent to 'func_quote_arg eval ARG', 1344# but optimized for speed. Result is stored in $func_quotefast_eval. 1345if test xyes = `(x=; printf -v x %q yes; echo x"$x") 2>/dev/null`; then 1346 printf -v _GL_test_printf_tilde %q '~' 1347 if test '\~' = "$_GL_test_printf_tilde"; then 1348 func_quotefast_eval () 1349 { 1350 printf -v func_quotefast_eval_result %q "$1" 1351 } 1352 else 1353 # Broken older Bash implementations. Make those faster too if possible. 1354 func_quotefast_eval () 1355 { 1356 case $1 in 1357 '~'*) 1358 func_quote_portable false "$1" 1359 func_quotefast_eval_result=$func_quote_portable_result 1360 ;; 1361 *) 1362 printf -v func_quotefast_eval_result %q "$1" 1363 ;; 1364 esac 1365 } 1366 fi 1367else 1368 func_quotefast_eval () 1369 { 1370 func_quote_portable false "$1" 1371 func_quotefast_eval_result=$func_quote_portable_result 1372 } 1373fi 1374 1375 1376# func_quote_arg MODEs ARG 1377# ------------------------ 1378# Quote one ARG to be evaled later. MODEs argument may contain zero or more 1379# specifiers listed below separated by ',' character. This function returns two 1380# values: 1381# i) func_quote_arg_result 1382# double-quoted (when needed), suitable for a subsequent eval 1383# ii) func_quote_arg_unquoted_result 1384# has all characters that are still active within double 1385# quotes backslashified. Available only if 'unquoted' is specified. 1386# 1387# Available modes: 1388# ---------------- 1389# 'eval' (default) 1390# - escape shell special characters 1391# 'expand' 1392# - the same as 'eval'; but do not quote variable references 1393# 'pretty' 1394# - request aesthetic output, i.e. '"a b"' instead of 'a\ b'. This might 1395# be used later in func_quote to get output like: 'echo "a b"' instead 1396# of 'echo a\ b'. This is slower than default on some shells. 1397# 'unquoted' 1398# - produce also $func_quote_arg_unquoted_result which does not contain 1399# wrapping double-quotes. 1400# 1401# Examples for 'func_quote_arg pretty,unquoted string': 1402# 1403# string | *_result | *_unquoted_result 1404# ------------+-----------------------+------------------- 1405# " | \" | \" 1406# a b | "a b" | a b 1407# "a b" | "\"a b\"" | \"a b\" 1408# * | "*" | * 1409# z="${x-$y}" | "z=\"\${x-\$y}\"" | z=\"\${x-\$y}\" 1410# 1411# Examples for 'func_quote_arg pretty,unquoted,expand string': 1412# 1413# string | *_result | *_unquoted_result 1414# --------------+---------------------+-------------------- 1415# z="${x-$y}" | "z=\"${x-$y}\"" | z=\"${x-$y}\" 1416func_quote_arg () 1417{ 1418 _G_quote_expand=false 1419 case ,$1, in 1420 *,expand,*) 1421 _G_quote_expand=: 1422 ;; 1423 esac 1424 1425 case ,$1, in 1426 *,pretty,*|*,expand,*|*,unquoted,*) 1427 func_quote_portable $_G_quote_expand "$2" 1428 func_quote_arg_result=$func_quote_portable_result 1429 func_quote_arg_unquoted_result=$func_quote_portable_unquoted_result 1430 ;; 1431 *) 1432 # Faster quote-for-eval for some shells. 1433 func_quotefast_eval "$2" 1434 func_quote_arg_result=$func_quotefast_eval_result 1435 ;; 1436 esac 1437} 1438 1439 1440# func_quote MODEs ARGs... 1441# ------------------------ 1442# Quote all ARGs to be evaled later and join them into single command. See 1443# func_quote_arg's description for more info. 1444func_quote () 1445{ 1446 $debug_cmd 1447 _G_func_quote_mode=$1 ; shift 1448 func_quote_result= 1449 while test 0 -lt $#; do 1450 func_quote_arg "$_G_func_quote_mode" "$1" 1451 if test -n "$func_quote_result"; then 1452 func_append func_quote_result " $func_quote_arg_result" 1453 else 1454 func_append func_quote_result "$func_quote_arg_result" 1455 fi 1456 shift 1457 done 1458} 1459 1460 1461# func_stripname PREFIX SUFFIX NAME 1462# --------------------------------- 1463# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result. 1464# PREFIX and SUFFIX must not contain globbing or regex special 1465# characters, hashes, percent signs, but SUFFIX may contain a leading 1466# dot (in which case that matches only a dot). 1467if test yes = "$_G_HAVE_XSI_OPS"; then 1468 eval 'func_stripname () 1469 { 1470 $debug_cmd 1471 1472 # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are 1473 # positional parameters, so assign one to ordinary variable first. 1474 func_stripname_result=$3 1475 func_stripname_result=${func_stripname_result#"$1"} 1476 func_stripname_result=${func_stripname_result%"$2"} 1477 }' 1478else 1479 func_stripname () 1480 { 1481 $debug_cmd 1482 1483 case $2 in 1484 .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;; 1485 *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;; 1486 esac 1487 } 1488fi 1489 1490 1491# func_show_eval CMD [FAIL_EXP] 1492# ----------------------------- 1493# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is 1494# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP 1495# is given, then evaluate it. 1496func_show_eval () 1497{ 1498 $debug_cmd 1499 1500 _G_cmd=$1 1501 _G_fail_exp=${2-':'} 1502 1503 func_quote_arg pretty,expand "$_G_cmd" 1504 eval "func_notquiet $func_quote_arg_result" 1505 1506 $opt_dry_run || { 1507 eval "$_G_cmd" 1508 _G_status=$? 1509 if test 0 -ne "$_G_status"; then 1510 eval "(exit $_G_status); $_G_fail_exp" 1511 fi 1512 } 1513} 1514 1515 1516# func_show_eval_locale CMD [FAIL_EXP] 1517# ------------------------------------ 1518# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is 1519# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP 1520# is given, then evaluate it. Use the saved locale for evaluation. 1521func_show_eval_locale () 1522{ 1523 $debug_cmd 1524 1525 _G_cmd=$1 1526 _G_fail_exp=${2-':'} 1527 1528 $opt_quiet || { 1529 func_quote_arg expand,pretty "$_G_cmd" 1530 eval "func_echo $func_quote_arg_result" 1531 } 1532 1533 $opt_dry_run || { 1534 eval "$_G_user_locale 1535 $_G_cmd" 1536 _G_status=$? 1537 eval "$_G_safe_locale" 1538 if test 0 -ne "$_G_status"; then 1539 eval "(exit $_G_status); $_G_fail_exp" 1540 fi 1541 } 1542} 1543 1544 1545# func_tr_sh 1546# ---------- 1547# Turn $1 into a string suitable for a shell variable name. 1548# Result is stored in $func_tr_sh_result. All characters 1549# not in the set a-zA-Z0-9_ are replaced with '_'. Further, 1550# if $1 begins with a digit, a '_' is prepended as well. 1551func_tr_sh () 1552{ 1553 $debug_cmd 1554 1555 case $1 in 1556 [0-9]* | *[!a-zA-Z0-9_]*) 1557 func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'` 1558 ;; 1559 * ) 1560 func_tr_sh_result=$1 1561 ;; 1562 esac 1563} 1564 1565 1566# func_verbose ARG... 1567# ------------------- 1568# Echo program name prefixed message in verbose mode only. 1569func_verbose () 1570{ 1571 $debug_cmd 1572 1573 $opt_verbose && func_echo "$*" 1574 1575 : 1576} 1577 1578 1579# func_warn_and_continue ARG... 1580# ----------------------------- 1581# Echo program name prefixed warning message to standard error. 1582func_warn_and_continue () 1583{ 1584 $debug_cmd 1585 1586 $require_term_colors 1587 1588 func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2 1589} 1590 1591 1592# func_warning CATEGORY ARG... 1593# ---------------------------- 1594# Echo program name prefixed warning message to standard error. Warning 1595# messages can be filtered according to CATEGORY, where this function 1596# elides messages where CATEGORY is not listed in the global variable 1597# 'opt_warning_types'. 1598func_warning () 1599{ 1600 $debug_cmd 1601 1602 # CATEGORY must be in the warning_categories list! 1603 case " $warning_categories " in 1604 *" $1 "*) ;; 1605 *) func_internal_error "invalid warning category '$1'" ;; 1606 esac 1607 1608 _G_category=$1 1609 shift 1610 1611 case " $opt_warning_types " in 1612 *" $_G_category "*) $warning_func ${1+"$@"} ;; 1613 esac 1614} 1615 1616 1617# func_sort_ver VER1 VER2 1618# ----------------------- 1619# 'sort -V' is not generally available. 1620# Note this deviates from the version comparison in automake 1621# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a 1622# but this should suffice as we won't be specifying old 1623# version formats or redundant trailing .0 in bootstrap.conf. 1624# If we did want full compatibility then we should probably 1625# use m4_version_compare from autoconf. 1626func_sort_ver () 1627{ 1628 $debug_cmd 1629 1630 printf '%s\n%s\n' "$1" "$2" \ 1631 | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n 1632} 1633 1634# func_lt_ver PREV CURR 1635# --------------------- 1636# Return true if PREV and CURR are in the correct order according to 1637# func_sort_ver, otherwise false. Use it like this: 1638# 1639# func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..." 1640func_lt_ver () 1641{ 1642 $debug_cmd 1643 1644 test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q` 1645} 1646 1647 1648# Local variables: 1649# mode: shell-script 1650# sh-indentation: 2 1651# eval: (add-hook 'before-save-hook 'time-stamp) 1652# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" 1653# time-stamp-time-zone: "UTC" 1654# End: 1655#! /bin/sh 1656 1657# A portable, pluggable option parser for Bourne shell. 1658# Written by Gary V. Vaughan, 2010 1659 1660# This is free software. There is NO warranty; not even for 1661# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 1662# 1663# Copyright (C) 2010-2019 Bootstrap Authors 1664# 1665# This file is dual licensed under the terms of the MIT license 1666# <https://opensource.org/license/MIT>, and GPL version 2 or later 1667# <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of 1668# these licenses when using or redistributing this software or any of 1669# the files within it. See the URLs above, or the file `LICENSE` 1670# included in the Bootstrap distribution for the full license texts. 1671 1672# Please report bugs or propose patches to: 1673# <https://github.com/gnulib-modules/bootstrap/issues> 1674 1675# Set a version string for this script. 1676scriptversion=2019-02-19.15; # UTC 1677 1678 1679## ------ ## 1680## Usage. ## 1681## ------ ## 1682 1683# This file is a library for parsing options in your shell scripts along 1684# with assorted other useful supporting features that you can make use 1685# of too. 1686# 1687# For the simplest scripts you might need only: 1688# 1689# #!/bin/sh 1690# . relative/path/to/funclib.sh 1691# . relative/path/to/options-parser 1692# scriptversion=1.0 1693# func_options ${1+"$@"} 1694# eval set dummy "$func_options_result"; shift 1695# ...rest of your script... 1696# 1697# In order for the '--version' option to work, you will need to have a 1698# suitably formatted comment like the one at the top of this file 1699# starting with '# Written by ' and ending with '# Copyright'. 1700# 1701# For '-h' and '--help' to work, you will also need a one line 1702# description of your script's purpose in a comment directly above the 1703# '# Written by ' line, like the one at the top of this file. 1704# 1705# The default options also support '--debug', which will turn on shell 1706# execution tracing (see the comment above debug_cmd below for another 1707# use), and '--verbose' and the func_verbose function to allow your script 1708# to display verbose messages only when your user has specified 1709# '--verbose'. 1710# 1711# After sourcing this file, you can plug in processing for additional 1712# options by amending the variables from the 'Configuration' section 1713# below, and following the instructions in the 'Option parsing' 1714# section further down. 1715 1716## -------------- ## 1717## Configuration. ## 1718## -------------- ## 1719 1720# You should override these variables in your script after sourcing this 1721# file so that they reflect the customisations you have added to the 1722# option parser. 1723 1724# The usage line for option parsing errors and the start of '-h' and 1725# '--help' output messages. You can embed shell variables for delayed 1726# expansion at the time the message is displayed, but you will need to 1727# quote other shell meta-characters carefully to prevent them being 1728# expanded when the contents are evaled. 1729usage='$progpath [OPTION]...' 1730 1731# Short help message in response to '-h' and '--help'. Add to this or 1732# override it after sourcing this library to reflect the full set of 1733# options your script accepts. 1734usage_message="\ 1735 --debug enable verbose shell tracing 1736 -W, --warnings=CATEGORY 1737 report the warnings falling in CATEGORY [all] 1738 -v, --verbose verbosely report processing 1739 --version print version information and exit 1740 -h, --help print short or long help message and exit 1741" 1742 1743# Additional text appended to 'usage_message' in response to '--help'. 1744long_help_message=" 1745Warning categories include: 1746 'all' show all warnings 1747 'none' turn off all the warnings 1748 'error' warnings are treated as fatal errors" 1749 1750# Help message printed before fatal option parsing errors. 1751fatal_help="Try '\$progname --help' for more information." 1752 1753 1754 1755## ------------------------- ## 1756## Hook function management. ## 1757## ------------------------- ## 1758 1759# This section contains functions for adding, removing, and running hooks 1760# in the main code. A hook is just a list of function names that can be 1761# run in order later on. 1762 1763# func_hookable FUNC_NAME 1764# ----------------------- 1765# Declare that FUNC_NAME will run hooks added with 1766# 'func_add_hook FUNC_NAME ...'. 1767func_hookable () 1768{ 1769 $debug_cmd 1770 1771 func_append hookable_fns " $1" 1772} 1773 1774 1775# func_add_hook FUNC_NAME HOOK_FUNC 1776# --------------------------------- 1777# Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must 1778# first have been declared "hookable" by a call to 'func_hookable'. 1779func_add_hook () 1780{ 1781 $debug_cmd 1782 1783 case " $hookable_fns " in 1784 *" $1 "*) ;; 1785 *) func_fatal_error "'$1' does not accept hook functions." ;; 1786 esac 1787 1788 eval func_append ${1}_hooks '" $2"' 1789} 1790 1791 1792# func_remove_hook FUNC_NAME HOOK_FUNC 1793# ------------------------------------ 1794# Remove HOOK_FUNC from the list of hook functions to be called by 1795# FUNC_NAME. 1796func_remove_hook () 1797{ 1798 $debug_cmd 1799 1800 eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`' 1801} 1802 1803 1804# func_propagate_result FUNC_NAME_A FUNC_NAME_B 1805# --------------------------------------------- 1806# If the *_result variable of FUNC_NAME_A _is set_, assign its value to 1807# *_result variable of FUNC_NAME_B. 1808func_propagate_result () 1809{ 1810 $debug_cmd 1811 1812 func_propagate_result_result=: 1813 if eval "test \"\${${1}_result+set}\" = set" 1814 then 1815 eval "${2}_result=\$${1}_result" 1816 else 1817 func_propagate_result_result=false 1818 fi 1819} 1820 1821 1822# func_run_hooks FUNC_NAME [ARG]... 1823# --------------------------------- 1824# Run all hook functions registered to FUNC_NAME. 1825# It's assumed that the list of hook functions contains nothing more 1826# than a whitespace-delimited list of legal shell function names, and 1827# no effort is wasted trying to catch shell meta-characters or preserve 1828# whitespace. 1829func_run_hooks () 1830{ 1831 $debug_cmd 1832 1833 case " $hookable_fns " in 1834 *" $1 "*) ;; 1835 *) func_fatal_error "'$1' does not support hook functions." ;; 1836 esac 1837 1838 eval _G_hook_fns=\$$1_hooks; shift 1839 1840 for _G_hook in $_G_hook_fns; do 1841 func_unset "${_G_hook}_result" 1842 eval $_G_hook '${1+"$@"}' 1843 func_propagate_result $_G_hook func_run_hooks 1844 if $func_propagate_result_result; then 1845 eval set dummy "$func_run_hooks_result"; shift 1846 fi 1847 done 1848} 1849 1850 1851 1852## --------------- ## 1853## Option parsing. ## 1854## --------------- ## 1855 1856# In order to add your own option parsing hooks, you must accept the 1857# full positional parameter list from your hook function. You may remove 1858# or edit any options that you action, and then pass back the remaining 1859# unprocessed options in '<hooked_function_name>_result', escaped 1860# suitably for 'eval'. 1861# 1862# The '<hooked_function_name>_result' variable is automatically unset 1863# before your hook gets called; for best performance, only set the 1864# *_result variable when necessary (i.e. don't call the 'func_quote' 1865# function unnecessarily because it can be an expensive operation on some 1866# machines). 1867# 1868# Like this: 1869# 1870# my_options_prep () 1871# { 1872# $debug_cmd 1873# 1874# # Extend the existing usage message. 1875# usage_message=$usage_message' 1876# -s, --silent don'\''t print informational messages 1877# ' 1878# # No change in '$@' (ignored completely by this hook). Leave 1879# # my_options_prep_result variable intact. 1880# } 1881# func_add_hook func_options_prep my_options_prep 1882# 1883# 1884# my_silent_option () 1885# { 1886# $debug_cmd 1887# 1888# args_changed=false 1889# 1890# # Note that, for efficiency, we parse as many options as we can 1891# # recognise in a loop before passing the remainder back to the 1892# # caller on the first unrecognised argument we encounter. 1893# while test $# -gt 0; do 1894# opt=$1; shift 1895# case $opt in 1896# --silent|-s) opt_silent=: 1897# args_changed=: 1898# ;; 1899# # Separate non-argument short options: 1900# -s*) func_split_short_opt "$_G_opt" 1901# set dummy "$func_split_short_opt_name" \ 1902# "-$func_split_short_opt_arg" ${1+"$@"} 1903# shift 1904# args_changed=: 1905# ;; 1906# *) # Make sure the first unrecognised option "$_G_opt" 1907# # is added back to "$@" in case we need it later, 1908# # if $args_changed was set to 'true'. 1909# set dummy "$_G_opt" ${1+"$@"}; shift; break ;; 1910# esac 1911# done 1912# 1913# # Only call 'func_quote' here if we processed at least one argument. 1914# if $args_changed; then 1915# func_quote eval ${1+"$@"} 1916# my_silent_option_result=$func_quote_result 1917# fi 1918# } 1919# func_add_hook func_parse_options my_silent_option 1920# 1921# 1922# my_option_validation () 1923# { 1924# $debug_cmd 1925# 1926# $opt_silent && $opt_verbose && func_fatal_help "\ 1927# '--silent' and '--verbose' options are mutually exclusive." 1928# } 1929# func_add_hook func_validate_options my_option_validation 1930# 1931# You'll also need to manually amend $usage_message to reflect the extra 1932# options you parse. It's preferable to append if you can, so that 1933# multiple option parsing hooks can be added safely. 1934 1935 1936# func_options_finish [ARG]... 1937# ---------------------------- 1938# Finishing the option parse loop (call 'func_options' hooks ATM). 1939func_options_finish () 1940{ 1941 $debug_cmd 1942 1943 func_run_hooks func_options ${1+"$@"} 1944 func_propagate_result func_run_hooks func_options_finish 1945} 1946 1947 1948# func_options [ARG]... 1949# --------------------- 1950# All the functions called inside func_options are hookable. See the 1951# individual implementations for details. 1952func_hookable func_options 1953func_options () 1954{ 1955 $debug_cmd 1956 1957 _G_options_quoted=false 1958 1959 for my_func in options_prep parse_options validate_options options_finish 1960 do 1961 func_unset func_${my_func}_result 1962 func_unset func_run_hooks_result 1963 eval func_$my_func '${1+"$@"}' 1964 func_propagate_result func_$my_func func_options 1965 if $func_propagate_result_result; then 1966 eval set dummy "$func_options_result"; shift 1967 _G_options_quoted=: 1968 fi 1969 done 1970 1971 $_G_options_quoted || { 1972 # As we (func_options) are top-level options-parser function and 1973 # nobody quoted "$@" for us yet, we need to do it explicitly for 1974 # caller. 1975 func_quote eval ${1+"$@"} 1976 func_options_result=$func_quote_result 1977 } 1978} 1979 1980 1981# func_options_prep [ARG]... 1982# -------------------------- 1983# All initialisations required before starting the option parse loop. 1984# Note that when calling hook functions, we pass through the list of 1985# positional parameters. If a hook function modifies that list, and 1986# needs to propagate that back to rest of this script, then the complete 1987# modified list must be put in 'func_run_hooks_result' before returning. 1988func_hookable func_options_prep 1989func_options_prep () 1990{ 1991 $debug_cmd 1992 1993 # Option defaults: 1994 opt_verbose=false 1995 opt_warning_types= 1996 1997 func_run_hooks func_options_prep ${1+"$@"} 1998 func_propagate_result func_run_hooks func_options_prep 1999} 2000 2001 2002# func_parse_options [ARG]... 2003# --------------------------- 2004# The main option parsing loop. 2005func_hookable func_parse_options 2006func_parse_options () 2007{ 2008 $debug_cmd 2009 2010 _G_parse_options_requote=false 2011 # this just eases exit handling 2012 while test $# -gt 0; do 2013 # Defer to hook functions for initial option parsing, so they 2014 # get priority in the event of reusing an option name. 2015 func_run_hooks func_parse_options ${1+"$@"} 2016 func_propagate_result func_run_hooks func_parse_options 2017 if $func_propagate_result_result; then 2018 eval set dummy "$func_parse_options_result"; shift 2019 # Even though we may have changed "$@", we passed the "$@" array 2020 # down into the hook and it quoted it for us (because we are in 2021 # this if-branch). No need to quote it again. 2022 _G_parse_options_requote=false 2023 fi 2024 2025 # Break out of the loop if we already parsed every option. 2026 test $# -gt 0 || break 2027 2028 # We expect that one of the options parsed in this function matches 2029 # and thus we remove _G_opt from "$@" and need to re-quote. 2030 _G_match_parse_options=: 2031 _G_opt=$1 2032 shift 2033 case $_G_opt in 2034 --debug|-x) debug_cmd='set -x' 2035 func_echo "enabling shell trace mode" >&2 2036 $debug_cmd 2037 ;; 2038 2039 --no-warnings|--no-warning|--no-warn) 2040 set dummy --warnings none ${1+"$@"} 2041 shift 2042 ;; 2043 2044 --warnings|--warning|-W) 2045 if test $# = 0 && func_missing_arg $_G_opt; then 2046 _G_parse_options_requote=: 2047 break 2048 fi 2049 case " $warning_categories $1" in 2050 *" $1 "*) 2051 # trailing space prevents matching last $1 above 2052 func_append_uniq opt_warning_types " $1" 2053 ;; 2054 *all) 2055 opt_warning_types=$warning_categories 2056 ;; 2057 *none) 2058 opt_warning_types=none 2059 warning_func=: 2060 ;; 2061 *error) 2062 opt_warning_types=$warning_categories 2063 warning_func=func_fatal_error 2064 ;; 2065 *) 2066 func_fatal_error \ 2067 "unsupported warning category: '$1'" 2068 ;; 2069 esac 2070 shift 2071 ;; 2072 2073 --verbose|-v) opt_verbose=: ;; 2074 --version) func_version ;; 2075 -\?|-h) func_usage ;; 2076 --help) func_help ;; 2077 2078 # Separate optargs to long options (plugins may need this): 2079 --*=*) func_split_equals "$_G_opt" 2080 set dummy "$func_split_equals_lhs" \ 2081 "$func_split_equals_rhs" ${1+"$@"} 2082 shift 2083 ;; 2084 2085 # Separate optargs to short options: 2086 -W*) 2087 func_split_short_opt "$_G_opt" 2088 set dummy "$func_split_short_opt_name" \ 2089 "$func_split_short_opt_arg" ${1+"$@"} 2090 shift 2091 ;; 2092 2093 # Separate non-argument short options: 2094 -\?*|-h*|-v*|-x*) 2095 func_split_short_opt "$_G_opt" 2096 set dummy "$func_split_short_opt_name" \ 2097 "-$func_split_short_opt_arg" ${1+"$@"} 2098 shift 2099 ;; 2100 2101 --) _G_parse_options_requote=: ; break ;; 2102 -*) func_fatal_help "unrecognised option: '$_G_opt'" ;; 2103 *) set dummy "$_G_opt" ${1+"$@"}; shift 2104 _G_match_parse_options=false 2105 break 2106 ;; 2107 esac 2108 2109 if $_G_match_parse_options; then 2110 _G_parse_options_requote=: 2111 fi 2112 done 2113 2114 if $_G_parse_options_requote; then 2115 # save modified positional parameters for caller 2116 func_quote eval ${1+"$@"} 2117 func_parse_options_result=$func_quote_result 2118 fi 2119} 2120 2121 2122# func_validate_options [ARG]... 2123# ------------------------------ 2124# Perform any sanity checks on option settings and/or unconsumed 2125# arguments. 2126func_hookable func_validate_options 2127func_validate_options () 2128{ 2129 $debug_cmd 2130 2131 # Display all warnings if -W was not given. 2132 test -n "$opt_warning_types" || opt_warning_types=" $warning_categories" 2133 2134 func_run_hooks func_validate_options ${1+"$@"} 2135 func_propagate_result func_run_hooks func_validate_options 2136 2137 # Bail if the options were screwed! 2138 $exit_cmd $EXIT_FAILURE 2139} 2140 2141 2142 2143## ----------------- ## 2144## Helper functions. ## 2145## ----------------- ## 2146 2147# This section contains the helper functions used by the rest of the 2148# hookable option parser framework in ascii-betical order. 2149 2150 2151# func_fatal_help ARG... 2152# ---------------------- 2153# Echo program name prefixed message to standard error, followed by 2154# a help hint, and exit. 2155func_fatal_help () 2156{ 2157 $debug_cmd 2158 2159 eval \$ECHO \""Usage: $usage"\" 2160 eval \$ECHO \""$fatal_help"\" 2161 func_error ${1+"$@"} 2162 exit $EXIT_FAILURE 2163} 2164 2165 2166# func_help 2167# --------- 2168# Echo long help message to standard output and exit. 2169func_help () 2170{ 2171 $debug_cmd 2172 2173 func_usage_message 2174 $ECHO "$long_help_message" 2175 exit 0 2176} 2177 2178 2179# func_missing_arg ARGNAME 2180# ------------------------ 2181# Echo program name prefixed message to standard error and set global 2182# exit_cmd. 2183func_missing_arg () 2184{ 2185 $debug_cmd 2186 2187 func_error "Missing argument for '$1'." 2188 exit_cmd=exit 2189} 2190 2191 2192# func_split_equals STRING 2193# ------------------------ 2194# Set func_split_equals_lhs and func_split_equals_rhs shell variables 2195# after splitting STRING at the '=' sign. 2196test -z "$_G_HAVE_XSI_OPS" \ 2197 && (eval 'x=a/b/c; 2198 test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ 2199 && _G_HAVE_XSI_OPS=yes 2200 2201if test yes = "$_G_HAVE_XSI_OPS" 2202then 2203 # This is an XSI compatible shell, allowing a faster implementation... 2204 eval 'func_split_equals () 2205 { 2206 $debug_cmd 2207 2208 func_split_equals_lhs=${1%%=*} 2209 func_split_equals_rhs=${1#*=} 2210 if test "x$func_split_equals_lhs" = "x$1"; then 2211 func_split_equals_rhs= 2212 fi 2213 }' 2214else 2215 # ...otherwise fall back to using expr, which is often a shell builtin. 2216 func_split_equals () 2217 { 2218 $debug_cmd 2219 2220 func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'` 2221 func_split_equals_rhs= 2222 test "x$func_split_equals_lhs" = "x$1" \ 2223 || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'` 2224 } 2225fi #func_split_equals 2226 2227 2228# func_split_short_opt SHORTOPT 2229# ----------------------------- 2230# Set func_split_short_opt_name and func_split_short_opt_arg shell 2231# variables after splitting SHORTOPT after the 2nd character. 2232if test yes = "$_G_HAVE_XSI_OPS" 2233then 2234 # This is an XSI compatible shell, allowing a faster implementation... 2235 eval 'func_split_short_opt () 2236 { 2237 $debug_cmd 2238 2239 func_split_short_opt_arg=${1#??} 2240 func_split_short_opt_name=${1%"$func_split_short_opt_arg"} 2241 }' 2242else 2243 # ...otherwise fall back to using expr, which is often a shell builtin. 2244 func_split_short_opt () 2245 { 2246 $debug_cmd 2247 2248 func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'` 2249 func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'` 2250 } 2251fi #func_split_short_opt 2252 2253 2254# func_usage 2255# ---------- 2256# Echo short help message to standard output and exit. 2257func_usage () 2258{ 2259 $debug_cmd 2260 2261 func_usage_message 2262 $ECHO "Run '$progname --help |${PAGER-more}' for full usage" 2263 exit 0 2264} 2265 2266 2267# func_usage_message 2268# ------------------ 2269# Echo short help message to standard output. 2270func_usage_message () 2271{ 2272 $debug_cmd 2273 2274 eval \$ECHO \""Usage: $usage"\" 2275 echo 2276 $SED -n 's|^# || 2277 /^Written by/{ 2278 x;p;x 2279 } 2280 h 2281 /^Written by/q' < "$progpath" 2282 echo 2283 eval \$ECHO \""$usage_message"\" 2284} 2285 2286 2287# func_version 2288# ------------ 2289# Echo version message to standard output and exit. 2290# The version message is extracted from the calling file's header 2291# comments, with leading '# ' stripped: 2292# 1. First display the progname and version 2293# 2. Followed by the header comment line matching /^# Written by / 2294# 3. Then a blank line followed by the first following line matching 2295# /^# Copyright / 2296# 4. Immediately followed by any lines between the previous matches, 2297# except lines preceding the intervening completely blank line. 2298# For example, see the header comments of this file. 2299func_version () 2300{ 2301 $debug_cmd 2302 2303 printf '%s\n' "$progname $scriptversion" 2304 $SED -n ' 2305 /^# Written by /!b 2306 s|^# ||; p; n 2307 2308 :fwd2blnk 2309 /./ { 2310 n 2311 b fwd2blnk 2312 } 2313 p; n 2314 2315 :holdwrnt 2316 s|^# || 2317 s|^# *$|| 2318 /^Copyright /!{ 2319 /./H 2320 n 2321 b holdwrnt 2322 } 2323 2324 s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2| 2325 G 2326 s|\(\n\)\n*|\1|g 2327 p; q' < "$progpath" 2328 2329 exit $? 2330} 2331 2332 2333# Local variables: 2334# mode: shell-script 2335# sh-indentation: 2 2336# eval: (add-hook 'before-save-hook 'time-stamp) 2337# time-stamp-pattern: "30/scriptversion=%:y-%02m-%02d.%02H; # UTC" 2338# time-stamp-time-zone: "UTC" 2339# End: 2340#! /bin/sh 2341 2342# Extract macro arguments from autotools input with GNU M4. 2343# Written by Gary V. Vaughan, 2010 2344# 2345# This is free software. There is NO warranty; not even for 2346# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 2347# 2348# Copyright (C) 2010-2019 Bootstrap Authors 2349# 2350# This file is dual licensed under the terms of the MIT license 2351# <https://opensource.org/license/MIT>, and GPL version 2 or later 2352# <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of 2353# these licenses when using or redistributing this software or any of 2354# the files within it. See the URLs above, or the file `LICENSE` 2355# included in the Bootstrap distribution for the full license texts. 2356 2357# Please report bugs or propose patches to: 2358# <https://github.com/gnulib-modules/bootstrap/issues> 2359 2360# Make sure we've evaluated scripts we depend on. 2361test -z "$progpath" && . `echo "$0" |${SED-sed} 's|[^/]*$||'`/funclib.sh 2362test extract-trace = "$progname" && . `echo "$0" |${SED-sed} 's|[^/]*$||'`/options-parser 2363 2364# Set a version string. 2365scriptversion=2019-02-19.15; # UTC 2366 2367 2368## ------ ## 2369## Usage. ## 2370## ------ ## 2371 2372# Run './extract-trace --help' for help with using this script from the 2373# command line. 2374# 2375# Or source first 'options-parser' and then this file into your own 2376# scripts in order to make use of the function and variable framework 2377# they define, and also to avoid the overhead of forking to run this 2378# script in its own process on every call. 2379 2380 2381 2382## ----------------- ## 2383## Helper functions. ## 2384## ----------------- ## 2385 2386# This section contains the helper functions used by the rest of 2387# 'extract-trace'. 2388 2389 2390# func_autoconf_configure MAYBE-CONFIGURE-FILE 2391# -------------------------------------------- 2392# Ensure that MAYBE-CONFIGURE-FILE is the name of a file in the current 2393# directory that contains an uncommented call to AC_INIT. 2394func_autoconf_configure () 2395{ 2396 $debug_cmd 2397 2398 _G_sed_no_comment=' 2399 s|#.*$|| 2400 s|^dnl .*$|| 2401 s| dnl .*$||' 2402 _G_ac_init= 2403 2404 # If we were passed a genuine file, make sure it calls AC_INIT. 2405 test -f "$1" \ 2406 && _G_ac_init=`$SED "$_G_sed_no_comment" "$1" |$GREP AC_INIT` 2407 2408 # Otherwise it is not a genuine Autoconf input file. 2409 test -n "$_G_ac_init" 2410 _G_status=$? 2411 2412 test 0 -ne "$_G_status" \ 2413 && func_verbose "'$1' not using Autoconf" 2414 2415 (exit $_G_status) 2416} 2417 2418 2419# func_tool_version_output CMD [FATAL-ERROR-MSG] 2420# ---------------------------------------------- 2421# Attempt to run 'CMD --version', discarding errors. The output can be 2422# ignored by redirecting stdout, and this function used simply to test 2423# whether the command exists and exits normally when passed a 2424# '--version' argument. 2425# When FATAL-ERROR-MSG is given, then this function will display the 2426# message and exit if running 'CMD --version' returns a non-zero exit 2427# status. 2428func_tool_version_output () 2429{ 2430 $debug_cmd 2431 2432 _G_cmd=$1 2433 _G_fatal_error_msg=$2 2434 2435 # Some tools, like 'git2cl' produce thousands of lines of output 2436 # unless stdin is /dev/null - in that case we want to return 2437 # successfully without saving all of that output. Other tools, 2438 # such as 'help2man' exit with a non-zero status when stdin comes 2439 # from /dev/null, so we re-execute without /dev/null if that 2440 # happens. This means that occasionally, the output from both calls 2441 # ends up in the result, but the alternative would be to discard the 2442 # output from one call, and hope the other produces something useful. 2443 { $_G_cmd --version </dev/null || $_G_cmd --version; } 2>/dev/null 2444 _G_status=$? 2445 2446 test 0 -ne "$_G_status" && test -n "$_G_fatal_error_msg" \ 2447 && func_fatal_error "$_G_fatal_error_msg" 2448 2449 (exit $_G_status) 2450} 2451 2452 2453# func_tool_version_number CMD [FATAL-ERROR-MSG] 2454# ---------------------------------------------- 2455# Pass arguments to func_tool_version_output, but set 2456# $func_tool_version_number_result to the last dot delimited digit string 2457# on the first line of output. 2458func_tool_version_number () 2459{ 2460 $debug_cmd 2461 2462 _G_verout=`func_tool_version_output "$@"` 2463 _G_status=$? 2464 2465 # A version number starts with a digit following a space on the first 2466 # line of output from `--version`. 2467 _G_verout=`echo "$_G_verout" |sed 1q` 2468 if test -n "$_G_verout"; then 2469 _G_vernum=`expr "$_G_verout" : '.* \([0-9][^ ]*\)'` 2470 fi 2471 2472 if test -n "$_G_vernum"; then 2473 printf '%s\n' "$_G_vernum" 2474 else 2475 printf '%s\n' "$_G_verout" 2476 fi 2477 2478 (exit $_G_status) 2479} 2480 2481 2482# func_find_tool ENVVAR NAMES... 2483# ------------------------------ 2484# Search for a required program. Use the value of ENVVAR, if set, 2485# otherwise find the first of the NAMES that can be run (i.e., 2486# supports --version). If found, set ENVVAR to the program name, 2487# die otherwise. 2488func_find_tool () 2489{ 2490 $debug_cmd 2491 2492 _G_find_tool_envvar=$1 2493 shift 2494 _G_find_tool_names=$@ 2495 eval "_G_find_tool_res=\$$_G_find_tool_envvar" 2496 if test -n "$_G_find_tool_res"; then 2497 _G_find_tool_error_prefix="\$$find_tool_envvar: " 2498 else 2499 _G_find_tool_res= 2500 _G_bestver= 2501 for _G_prog 2502 do 2503 _G_find_tool_save_IFS=$IFS 2504 IFS=${PATH_SEPARATOR-:} 2505 for _G_dir in $PATH; do 2506 IFS=$_G_find_tool_save_IFS 2507 _G_progpath=$_G_dir/$_G_prog 2508 test -r "$_G_progpath" && { 2509 _G_curver=`func_tool_version_number $_G_progpath` 2510 case $_G_bestver,$_G_curver in 2511 ,) 2512 # first non--version responsive prog sticks! 2513 test -n "$_G_progpath" || _G_find_tool_res=$_G_progpath 2514 ;; 2515 ,*) 2516 # first --version responsive prog beats non--version responsive! 2517 _G_find_tool_res=$_G_progpath 2518 _G_bestver=$_G_curver 2519 ;; 2520 *,*) 2521 # another --version responsive prog must be newer to beat previous one! 2522 test "x$_G_curver" = "x$_G_bestver" \ 2523 || func_lt_ver "$_G_curver" "$_G_bestver" \ 2524 || { 2525 _G_find_tool_res=$_G_progpath 2526 _G_bestver=$_G_curver 2527 } 2528 ;; 2529 esac 2530 } 2531 done 2532 IFS=$_G_find_tool_save_IFS 2533 done 2534 fi 2535 if test -n "$_G_find_tool_res"; then 2536 func_tool_version_number >/dev/null $_G_find_tool_res "\ 2537${_G_find_tool_error_prefix}Cannot run '$_G_find_tool_res --version'" 2538 2539 # Make sure the result is exported to the environment for children 2540 # to use. 2541 eval "$_G_find_tool_envvar=\$_G_find_tool_res" 2542 eval "export $_G_find_tool_envvar" 2543 else 2544 func_error "\ 2545One of these is required: 2546 $_G_find_tool_names" 2547 fi 2548} 2549 2550 2551 2552## -------------------- ## 2553## Resource management. ## 2554## -------------------- ## 2555 2556# This section contains definitions for functions that each ensure a 2557# particular resource (a file, or a non-empty configuration variable for 2558# example) is available, and if appropriate to extract default values 2559# from pertinent package files. Where a variable already has a non- 2560# empty value (as set by the package's 'bootstrap.conf'), that value is 2561# used in preference to deriving the default. Call them using their 2562# associated 'require_*' variable to ensure that they are executed, at 2563# most, once. 2564# 2565# It's entirely deliberate that calling these functions can set 2566# variables that don't obey the namespace limitations obeyed by the rest 2567# of this file, in order that that they be as useful as possible to 2568# callers. 2569 2570 2571# require_configure_ac 2572# -------------------- 2573# Ensure that there is a 'configure.ac' or 'configure.in' file in the 2574# current directory that contains an uncommented call to AC_INIT, and 2575# that '$configure_ac' contains its name. 2576require_configure_ac=func_require_configure_ac 2577func_require_configure_ac () 2578{ 2579 $debug_cmd 2580 2581 test -z "$configure_ac" \ 2582 && func_autoconf_configure configure.ac && configure_ac=configure.ac 2583 test -z "$configure_ac" \ 2584 && func_autoconf_configure configure.in && configure_ac=configure.in 2585 test -z "$configure_ac" \ 2586 || func_verbose "found '$configure_ac'" 2587 2588 require_configure_ac=: 2589} 2590 2591 2592# require_gnu_m4 2593# -------------- 2594# Search for GNU M4, and export it in $M4. 2595require_gnu_m4=func_require_gnu_m4 2596func_require_gnu_m4 () 2597{ 2598 $debug_cmd 2599 2600 test -n "$M4" || { 2601 # Find the first m4 binary that responds to --version. 2602 func_find_tool M4 gm4 gnum4 m4 2603 } 2604 2605 test -n "$M4" || func_fatal_error "\ 2606Please install GNU M4, or 'export M4=/path/to/gnu/m4'." 2607 2608 func_verbose "export M4='$M4'" 2609 2610 # Make sure the search result is visible to subshells 2611 export M4 2612 2613 require_gnu_m4=: 2614} 2615 2616 2617## --------------- ## 2618## Core functions. ## 2619## --------------- ## 2620 2621# This section contains the high level functions used when calling this 2622# file as a script. 'func_extract_trace' is probably the only one that you 2623# won't want to replace if you source this file into your own script. 2624 2625 2626# func_extract_trace MACRO_NAMES [FILENAME]... 2627# -------------------------------------------- 2628# set '$func_extract_trace_result' to a colon delimited list of arguments 2629# to any of the comma separated list of MACRO_NAMES in FILENAME. If no 2630# FILENAME is given, then '$configure_ac' is assumed. 2631func_extract_trace () 2632{ 2633 $debug_cmd 2634 2635 $require_configure_ac 2636 $require_gnu_m4 2637 2638 _G_m4_traces=`$ECHO "--trace=$1" |$SED 's%,% --trace=%g'` 2639 _G_re_macros=`$ECHO "($1)" |$SED 's%,%|%g'` 2640 _G_macros="$1"; shift 2641 test $# -gt 0 || { 2642 set dummy $configure_ac 2643 shift 2644 } 2645 2646 # Generate an error if the first file is missing 2647 <"$1" 2648 2649 # Sadly, we can't use 'autom4te' tracing to extract macro arguments, 2650 # because it complains about things we want to ignore at bootstrap 2651 # time - like missing m4_include files; AC_PREREQ being newer than 2652 # the installed autoconf; and returns nothing when tracing 2653 # 'AM_INIT_AUTOMAKE' when aclocal hasn't been generated yet. 2654 # 2655 # The following tries to emulate a less persnickety version of (and 2656 # due to not having to wait for Perl startup on every invocation, 2657 # it's probably faster too): 2658 # 2659 # autom4te --language=Autoconf --trace=$my_macro:\$% "$@" 2660 # 2661 # First we give a minimal set of macro declarations to M4 to prime 2662 # it for reading Autoconf macros, while still providing some of the 2663 # functionality generally used at m4-time to supply dynamic 2664 # arguments to Autocof functions, but without following 2665 # 'm4_s?include' files. 2666 _G_mini=' 2667 dnl Initialisation. 2668 m4_changequote([,]) 2669 m4_define([m4_copy], [m4_define([$2], m4_defn([$1]))]) 2670 m4_define([m4_rename], [m4_copy([$1], [$2])m4_undefine([$1])]) 2671 2672 dnl Replace macros which may abort m4 with a no-op variant. 2673 m4_pushdef([m4_assert]) 2674 m4_pushdef([m4_exit]) 2675 m4_pushdef([m4_fatal]) 2676 m4_pushdef([m4_m4exit]) 2677 2678 dnl Replace macros that might break stderr of m4. 2679 m4_pushdef([m4_errprint]) 2680 m4_pushdef([m4_errprintn]) 2681 m4_pushdef([m4_include]) 2682 m4_pushdef([m4_warn]) 2683 2684 dnl Avoid side-effects of tracing by extract-trace. 2685 m4_pushdef([m4_maketemp]) 2686 m4_pushdef([m4_mkstemp]) 2687 2688 dnl TODO: reasons for this 2689 m4_pushdef([m4_dnl]) 2690 m4_pushdef([m4_m4wrap]) 2691 2692 dnl Copy and rename macros not handled by "m4 --prefix". 2693 m4_define([dnl], [m4_builtin([dnl])]) 2694 m4_copy([m4_define], [m4_defun]) 2695 m4_rename([m4_ifelse], [m4_if]) 2696 m4_rename([m4_patsubst], [m4_bpatsubst]) 2697 m4_rename([m4_regexp], [m4_bregexp]) 2698 2699 dnl "m4sugar.mini" - useful m4-time macros for dynamic arguments. 2700 dnl If we discover packages that need more m4 macros defined in 2701 dnl order to bootstrap correctly, add them here: 2702 m4_define([m4_bmatch], 2703 [m4_if([$#], 0, [], [$#], 1, [], [$#], 2, [$2], 2704 [m4_if(m4_bregexp([$1], [$2]), -1, 2705 [$0([$1], m4_shift3($@))], [$3])])]) 2706 m4_define([m4_ifndef], [m4_ifdef([$1], [$3], [$2])]) 2707 m4_define([m4_ifset], 2708 [m4_ifdef([$1], [m4_ifval(m4_defn([$1]), [$2], [$3])], [$3])]) 2709 m4_define([m4_require], [$1]) 2710 m4_define([m4_shift3], [m4_shift(m4shift(m4shift($@)))]) 2711 2712 dnl "autoconf.mini" - things from autoconf macros we care about. 2713 m4_copy([m4_defun], [AC_DEFUN]) 2714 2715 dnl Dummy definitions for the macros we want to trace. 2716 dnl AM_INIT_AUTOMAKE at least produces no trace without this. 2717 ' 2718 2719 _G_save=$IFS 2720 IFS=, 2721 for _G_macro in $_G_macros; do 2722 IFS=$_G_save 2723 func_append _G_mini "AC_DEFUN([$_G_macro])$nl" 2724 done 2725 IFS=$_G_save 2726 2727 # We discard M4's stdout, but the M4 trace output from reading our 2728 # "autoconf.mini" followed by any other files passed to this 2729 # function is then scanned by sed to transform it into a colon 2730 # delimited argument list assigned to a shell variable. 2731 _G_transform='s|#.*$||; s|^dnl .*$||; s| dnl .*$||;' 2732 2733 # Unfortunately, alternation in regexp addresses doesn't work in at 2734 # least BSD (and hence Mac OS X) sed, so we have to append a capture 2735 # and print block for each traced macro to the sed transform script. 2736 _G_save=$IFS 2737 IFS=, 2738 for _G_macro in $_G_macros; do 2739 IFS=$_G_save 2740 func_append _G_transform ' 2741 /^m4trace: -1- '"$_G_macro"'/ { 2742 s|^m4trace: -1- '"$_G_macro"'[([]*|| 2743 s|], [[]|:|g 2744 s|[])]*$|:| 2745 s|\(.\):$|\1| 2746 p 2747 }' 2748 done 2749 IFS=$_G_save 2750 2751 # Save the command pipeline results for further use by callers of 2752 # this function. 2753 func_extract_trace_result=`$ECHO "$_G_mini" \ 2754 |$M4 -daq --prefix $_G_m4_traces - "$@" 2>&1 1>/dev/null \ 2755 |$SED -n -e "$_G_transform"` 2756} 2757 2758 2759# func_extract_trace_first MACRO_NAMES [FILENAME]... 2760# -------------------------------------------------- 2761# Exactly like func_extract_trace, except that only the first argument 2762# to the first invocation of one of the comma separated MACRO_NAMES is 2763# returned in '$func_extract_trace_first_result'. 2764func_extract_trace_first () 2765{ 2766 $debug_cmd 2767 2768 func_extract_trace ${1+"$@"} 2769 func_extract_trace_first_result=`$ECHO "$func_extract_trace_result" \ 2770 |$SED -e 's|:.*$||g' -e 1q` 2771} 2772 2773 2774# func_main [ARG]... 2775# ------------------ 2776func_main () 2777{ 2778 $debug_cmd 2779 2780 # Configuration. 2781 usage='$progname MACRO_NAME FILE [...]' 2782 2783 long_help_message=' 2784The first argument to this program is the name of an autotools macro 2785whose arguments you want to extract by examining the files listed in the 2786remaining arguments using the same tool that Autoconf and Automake use, 2787GNU M4. 2788 2789The arguments are returned separated by colons, with each traced call 2790on a separate line.' 2791 2792 # Option processing. 2793 func_options "$@" 2794 eval set dummy "$func_options_result"; shift 2795 2796 # Validate remaining non-option arguments. 2797 test $# -gt 1 \ 2798 || func_fatal_help "not enough arguments" 2799 2800 # Pass non-option arguments to extraction function. 2801 func_extract_trace "$@" 2802 2803 # Display results. 2804 test -n "$func_extract_trace_result" \ 2805 && $ECHO "$func_extract_trace_result" 2806 2807 # The End. 2808 exit $EXIT_SUCCESS 2809} 2810 2811 2812## --------------------------- ## 2813## Actually perform the trace. ## 2814## --------------------------- ## 2815 2816# Only call 'func_main' if this script was called directly. 2817test extract-trace = "$progname" && func_main "$@" 2818 2819# Local variables: 2820# mode: shell-script 2821# sh-indentation: 2 2822# eval: (add-hook 'before-save-hook 'time-stamp) 2823# time-stamp-pattern: "50/scriptversion=%:y-%02m-%02d.%02H; # UTC" 2824# time-stamp-time-zone: "UTC" 2825# End: 2826 2827# Set a version string for *this* script. 2828scriptversion=2019-03-22.11; # UTC 2829 2830 2831## ------------------- ## 2832## Hookable functions. ## 2833## ------------------- ## 2834 2835# After 'bootstrap.conf' has been sourced, execution proceeds by calling 2836# 'func_bootstrap'. Wherever a function is decorated with 2837# 'func_hookable func_name', you will find a matching 'func_run_hooks 2838# func_name', which executes all functions added with 'func_add_hook 2839# func_name my_func'. 2840# 2841# You might notice that many of these functions begin with a series of 2842# '$require_foo' lines. See the docu-comments at the start of the 2843# 'Resource management' section for a description of what these are. 2844 2845 2846# func_bootstrap [ARG]... 2847# ----------------------- 2848# All the functions called inside func_bootstrap are hookable. See the 2849# the individual implementations for details. 2850func_bootstrap () 2851{ 2852 $debug_cmd 2853 2854 # Save the current positional parameters to prevent them being 2855 # corrupted by calls to 'set' in 'func_init'. 2856 func_quote eval ${1+"$@"} 2857 _G_saved_positional_parameters=$func_quote_result 2858 2859 # Initialisation. 2860 func_init 2861 2862 # Option processing. 2863 eval func_options "$_G_saved_positional_parameters" 2864 2865 # Post-option preparation. 2866 func_prep 2867 2868 # Reconfigure the package. 2869 func_reconfigure 2870 2871 # Ensure .version is up-to-date. 2872 func_update_dotversion 2873 2874 # Finalisation. 2875 func_fini 2876} 2877 2878 2879# func_init 2880# --------- 2881# Any early initialisations can be hooked to this function. Consider 2882# whether you can hook onto 'func_prep' instead, because if you hook 2883# any slow to execute code in here, it will also add to the time before 2884# './bootstrap --version' can respond. 2885func_hookable func_init 2886func_init () 2887{ 2888 $debug_cmd 2889 2890 func_run_hooks func_init 2891} 2892 2893 2894# func_prep 2895# --------- 2896# Function to perform preparation for remaining bootstrap process. If 2897# your hooked code relies on the outcome of 'func_options' hook it here 2898# rather than to 'func_init'. 2899# 2900# All the functions called inside func_prep are hookable. See the 2901# individual implementations for details. 2902func_hookable func_prep 2903func_prep () 2904{ 2905 $debug_cmd 2906 2907 $require_buildtools_uptodate 2908 $require_checkout_only_file 2909 2910 $require_gnulib_merge_changelog 2911 2912 # Report the results of SED and GREP searches from funclib.sh. 2913 func_verbose "GREP='$GREP'" 2914 func_verbose "SED='$SED'" 2915 2916 # fetch update files from the translation project 2917 func_update_translations 2918 2919 func_run_hooks func_prep 2920} 2921 2922 2923# func_update_translations 2924# ------------------------ 2925# Update package po files and translations. 2926func_hookable func_update_translations 2927func_update_translations () 2928{ 2929 $debug_cmd 2930 2931 $opt_skip_po || { 2932 test -d po && { 2933 $require_package 2934 2935 func_update_po_files po $package || exit $? 2936 } 2937 2938 func_run_hooks func_update_translations 2939 } 2940} 2941 2942 2943# func_reconfigure 2944# ---------------- 2945# Reconfigure the current package by running the appropriate autotools in a 2946# suitable order. 2947func_hookable func_reconfigure 2948func_reconfigure () 2949{ 2950 $debug_cmd 2951 2952 $require_automake_options 2953 2954 # Automake (without 'foreign' option) requires that NEWS & README exist. 2955 case " $automake_options " in 2956 " foreign ") ;; 2957 *) 2958 func_ensure_NEWS 2959 func_ensure_README 2960 ;; 2961 esac 2962 2963 # Ensure ChangeLog presence. 2964 if test -n "$gnulib_modules"; then 2965 func_ifcontains "$gnulib_modules" gitlog-to-changelog \ 2966 func_ensure_changelog 2967 else 2968 $require_gnulib_cache 2969 if $SED -n '/^gl_MODULES(\[/,/^])$/p' $gnulib_cache 2>/dev/null | 2970 func_grep_q gitlog-to-changelog 2971 then 2972 func_ensure_changelog 2973 fi 2974 fi 2975 2976 # Released 'autopoint' has the tendency to install macros that have 2977 # been obsoleted in current 'gnulib', so run this before 'gnulib-tool'. 2978 func_autopoint 2979 2980 # Autoreconf runs 'aclocal' before 'libtoolize', which causes spurious 2981 # warnings if the initial 'aclocal' is confused by the libtoolized 2982 # (or worse: out-of-date) macro directory. 2983 func_libtoolize 2984 2985 # If you need to do anything after 'gnulib-tool' is done, but before 2986 # 'autoreconf' runs, you don't need to override this whole function, 2987 # because 'func_gnulib_tool' is hookable. 2988 func_gnulib_tool 2989 2990 func_autoreconf 2991 2992 func_run_hooks func_reconfigure 2993} 2994 2995 2996# func_gnulib_tool 2997# ---------------- 2998# Run 'gnulib-tool' to fetch gnulib modules into the current package. 2999# 3000# It's assumed that since you are using gnulib's 'bootstrap' script, 3001# you're also using gnulib elsewhere in your package. If not, then 3002# you can replace this function in 'bootstrap.conf' with: 3003# 3004# func_gnulib_tool () { :; } 3005# 3006# (although the function returns immediately if $gnulib_tool is set to 3007# true in any case). 3008func_hookable func_gnulib_tool 3009func_gnulib_tool () 3010{ 3011 $debug_cmd 3012 3013 $require_gnulib_tool 3014 $require_libtoolize 3015 3016 test true = "$gnulib_tool" || { 3017 $require_gnulib_git_submodules 3018 3019 # bootstrap.conf written for gnulib bootstrap expects 3020 # gnulib_tool_option_extras to which --no-changelog is appended, 3021 # but libtool bootstrap expects you to append to gnulib_tool_options 3022 # so that you can override the --no-changelog default: make sure we 3023 # support both styles so users can migrate between them easily. 3024 gnulib_tool_all_options="$gnulib_tool_options $gnulib_tool_option_extras" 3025 3026 if test -n "$gnulib_modules"; then 3027 $require_gnulib_cache 3028 $require_gnulib_tool_base_options 3029 3030 gnulib_mode=--import 3031 3032 # Try not to pick up any stale values from 'gnulib-cache.m4'. 3033 rm -f "$gnulib_cache" 3034 3035 test -n "$gnulib_tool_base_options" \ 3036 && func_append_uniq gnulib_tool_all_options " $gnulib_tool_base_options" 3037 test -n "$gnulib_mk" \ 3038 && func_append_uniq gnulib_tool_all_options " --makefile-name=$gnulib_mk" 3039 test -n "$tests_base" && { 3040 func_append_uniq gnulib_tool_all_options " --tests-base=$tests_base" 3041 func_append_uniq gnulib_tool_all_options " --with-tests" 3042 } 3043 else 3044 3045 # 'gnulib_modules' and others are cached in 'gnulib-cache.m4': 3046 # Use 'gnulib --update' to fetch gnulib modules. 3047 gnulib_mode=--update 3048 fi 3049 3050 # Add a sensible default libtool option to gnulib_tool_options. 3051 # The embedded echo is to squash whitespace before globbing. 3052 case `echo " "$gnulib_tool_all_options" "` in 3053 *" --no-libtool "*|*" --libtool "*) ;; 3054 *) if test true = "$LIBTOOLIZE"; then 3055 func_append_uniq gnulib_tool_all_options " --no-libtool" 3056 else 3057 func_append_uniq gnulib_tool_all_options " --libtool" 3058 fi 3059 ;; 3060 esac 3061 3062 $opt_copy || func_append_uniq gnulib_tool_all_options " --symlink" 3063 3064 func_append_uniq gnulib_tool_all_options " $gnulib_mode" 3065 func_append gnulib_tool_all_options " $gnulib_modules" 3066 3067 # The embedded echo is to squash whitespace before display. 3068 gnulib_cmd=`echo $gnulib_tool $gnulib_tool_all_options` 3069 3070 func_show_eval "$gnulib_cmd" 'exit $?' 3071 3072 # Use 'gnulib-tool --copy-file' to install non-module files. 3073 func_install_gnulib_non_module_files 3074 } 3075 3076 func_run_hooks func_gnulib_tool 3077} 3078 3079 3080# func_fini 3081# --------- 3082# Function to perform all finalisation for the bootstrap process. 3083func_hookable func_fini 3084func_fini () 3085{ 3086 $debug_cmd 3087 3088 func_gettext_configuration 3089 func_clean_dangling_symlinks 3090 func_clean_unused_macros 3091 func_skip_po_recommendation 3092 3093 func_run_hooks func_fini 3094 3095 $require_bootstrap_uptodate 3096 3097 func_echo "Done. Now you can run './configure'." 3098} 3099 3100 3101# func_gettext_configuration 3102# -------------------------- 3103# Edit configuration values into po/Makevars. 3104func_hookable func_gettext_configuration 3105func_gettext_configuration () 3106{ 3107 $debug_cmd 3108 3109 $require_autopoint 3110 3111 test true = "$AUTOPOINT" || { 3112 $require_copyright_holder 3113 $require_extra_locale_categories 3114 $require_package_bugreport 3115 3116 # Escape xgettext options for sed Makevars generation below. 3117 # We have to delete blank lines in a separate script so that we don't 3118 # append \\\ to the penultimate line, and then delete the last empty 3119 # line, which messes up the variable substitution later in this 3120 # function. Note that adding a literal \\\ requires double escaping 3121 # here, once for the execution subshell, and again for the assignment, 3122 # which is why there are actually 12 (!!) backslashes in the script. 3123 _G_xgettext_options=`echo "$xgettext_options$nl" |$SED '/^$/d' |$SED ' 3124 $b 3125 s|$| \\\\\\\\\\\\|'` 3126 3127 # Create gettext configuration. 3128 func_echo "Creating po/Makevars from po/Makevars.template ..." 3129 $RM -f po/Makevars 3130 $SED ' 3131 /^EXTRA_LOCALE_CATEGORIES *=/s|=.*|= '"$extra_locale_categories"'| 3132 /^COPYRIGHT_HOLDER *=/s|=.*|= '"$copyright_holder"'| 3133 /^MSGID_BUGS_ADDRESS *=/s|=.*|= '"$package_bugreport"'| 3134 /^XGETTEXT_OPTIONS *=/{ 3135 s|$| \\| 3136 a\ 3137 '"$_G_xgettext_options"' \\\ 3138 $${end_of_xgettext_options+} 3139 } 3140 s/ *$// 3141 ' po/Makevars.template >po/Makevars || exit 1 3142 } 3143 3144 func_run_hooks func_gettext_configuration 3145} 3146 3147 3148 3149## --------------- ## 3150## Core functions. ## 3151## --------------- ## 3152 3153# This section contains the main functions called from the 'Hookable 3154# functions' (shown above), and are the ones you're most likely 3155# to want to replace with your own implementations in 'bootstrap.conf'. 3156 3157 3158# func_autopoint 3159# -------------- 3160# If this package uses gettext, then run 'autopoint'. 3161func_autopoint () 3162{ 3163 $debug_cmd 3164 3165 $require_autopoint 3166 3167 test true = "$AUTOPOINT" \ 3168 || func_show_eval "$AUTOPOINT --force" 'exit $?' 3169} 3170 3171 3172# func_libtoolize 3173# --------------- 3174# If this package uses libtool, then run 'libtoolize'. 3175func_libtoolize () 3176{ 3177 $debug_cmd 3178 3179 $require_libtoolize 3180 3181 test true = "$LIBTOOLIZE" || { 3182 _G_libtoolize_options= 3183 $opt_copy && func_append _G_libtoolize_options " --copy" 3184 $opt_force && func_append _G_libtoolize_options " --force" 3185 $opt_verbose || func_append _G_libtoolize_options " --quiet" 3186 func_show_eval "$LIBTOOLIZE$_G_libtoolize_options" 'exit $?' 3187 } 3188} 3189 3190 3191# func_gnulib_tool_copy_file SRC DEST 3192# ----------------------------------- 3193# Copy SRC, a path relative to the gnulib sub-tree, to DEST, a path 3194# relative to the top-level source directory using gnulib-tool so that 3195# any patches or replacements in $local_gl_path are applied. 3196func_gnulib_tool_copy_file () 3197{ 3198 $debug_cmd 3199 3200 $require_gnulib_tool 3201 $require_patch 3202 3203 if test true = "$gnulib_tool"; then 3204 # If gnulib-tool is not available (e.g. bootstrapping in a 3205 # distribution tarball), make sure that at least we have some 3206 # version of the required file already in place. 3207 test -f "$2" || func_fatal_error "\ 3208Can't find, copy or download '$2', a required 3209gnulib supplied file, please provide the location of a 3210complete 'gnulib' tree by setting 'gnulib_path' in your 3211'bootstrap.conf' or with the '--gnulib-srcdir' option - 3212or else specify the location of your 'git' binary by 3213setting 'GIT' in the environment so that a fresh 3214'gnulib' submodule can be cloned." 3215 else 3216 $require_gnulib_copy_cmd 3217 3218 $gnulib_copy_cmd $1 $2 2>/dev/null || { 3219 $require_gnulib_path 3220 3221 func_error "'$gnulib_path/$1' does not exist" 3222 return 1 3223 } 3224 fi 3225} 3226 3227 3228# func_install_gnulib_non_module_files 3229# ------------------------------------ 3230# Get additional non-module files from gnulib, overriding existing files. 3231func_install_gnulib_non_module_files () 3232{ 3233 $debug_cmd 3234 3235 $require_build_aux 3236 $require_gnulib_tool 3237 3238 test -n "$gnulib_non_module_files" && { 3239 maybe_exit_cmd=: 3240 3241 for file in $gnulib_non_module_files; do 3242 case $file in 3243 */COPYING*) dest=COPYING;; 3244 */INSTALL) dest=INSTALL;; 3245 build-aux/missing) dest= 3246 func_warning settings "\ 3247Please remove build-aux/missing from gnulib_module_files in 3248'bootstrap.conf', as it may clash with Automake's version." 3249 ;; 3250 build-aux/*) dest=$build_aux/`expr "$file" : 'build-aux/\(.*\)'`;; 3251 *) dest=$file;; 3252 esac 3253 3254 # Be sure to show all copying errors before bailing out 3255 test -z "$dest" \ 3256 || func_gnulib_tool_copy_file "$file" "$dest" \ 3257 || maybe_exit_cmd="exit $EXIT_FAILURE" 3258 done 3259 3260 $maybe_exit_cmd 3261 } 3262} 3263 3264 3265# func_ensure_changelog 3266# --------------------- 3267# Even with 'gitlog-to-changelog' generated ChangeLogs, automake 3268# will not run to completion with no ChangeLog file. 3269func_ensure_changelog () 3270{ 3271 $debug_cmd 3272 3273 test -f ChangeLog && mv -f ChangeLog ChangeLog~ 3274 3275 cat >ChangeLog <<'EOT' 3276## ---------------------- ## 3277## DO NOT EDIT THIS FILE! ## 3278## ---------------------- ## 3279 3280ChangeLog is generated by gitlog-to-changelog. 3281EOT 3282 3283 _G_message="creating dummy 'ChangeLog'" 3284 test -f ChangeLog~ \ 3285 && func_append _G_message ' (backup in ChangeLog~)' 3286 func_verbose "$_G_message" 3287 3288 return 0 3289} 3290 3291 3292# func_ensure_NEWS 3293# ---------------- 3294# Without AM_INIT_AUTOMAKE([foreign]), automake will not run to 3295# completion with no NEWS file, even though NEWS.md or NEWS.txt 3296# is often preferable. 3297func_ensure_NEWS () 3298{ 3299 $debug_cmd 3300 3301 test -f NEWS || { 3302 _G_NEWS= 3303 for _G_news in NEWS.txt NEWS.md NEWS.rst; do 3304 test -f "$_G_news" && break 3305 done 3306 3307 test -f "$_G_news" && $LN_S $_G_news NEWS 3308 func_verbose "$LN_S $_G_news NEWS" 3309 } 3310 3311 return 0 3312} 3313 3314 3315# func_ensure_README 3316# ------------------ 3317# Without AM_INIT_AUTOMAKE([foreign]), automake will not run to 3318# completion with no README file, even though README.md or README.txt 3319# is often preferable. 3320func_ensure_README () 3321{ 3322 $debug_cmd 3323 3324 test -f README || { 3325 _G_README= 3326 for _G_readme in README.txt README.md README.rst; do 3327 test -f "$_G_readme" && break 3328 done 3329 3330 test -f "$_G_readme" && $LN_S $_G_readme README 3331 func_verbose "$LN_S $_G_readme README" 3332 } 3333 3334 return 0 3335} 3336 3337 3338# func_autoreconf [SUBDIR] 3339# ------------------------ 3340# Being careful not to re-run 'autopoint' or 'libtoolize', and not to 3341# try to run 'autopoint', 'libtoolize' or 'autoheader' on packages that 3342# don't use them, defer to 'autoreconf' for execution of the remaining 3343# autotools to bootstrap this package. 3344# 3345# Projects with multiple trees to reconfigure can hook another call to 3346# this function onto func_reconfigure: 3347# 3348# my_autoreconf_foo () 3349# { 3350# func_autoreconf foo 3351# } 3352# func_add_hook func_reconfigure my_autoreconf_foo 3353func_autoreconf () 3354{ 3355 $debug_cmd 3356 3357 $require_autoheader 3358 $require_build_aux # automake and others put files in here 3359 $require_macro_dir # aclocal and others put files in here 3360 3361 # We ran these manually already, and autoreconf won't exec ':' 3362 save_AUTOPOINT=$AUTOPOINT; AUTOPOINT=true 3363 save_LIBTOOLIZE=$LIBTOOLIZE; LIBTOOLIZE=true 3364 3365 _G_autoreconf_options= 3366 $opt_copy || func_append _G_autoreconf_options " --symlink" 3367 $opt_force && func_append _G_autoreconf_options " --force" 3368 $opt_verbose && func_append _G_autoreconf_options " --verbose" 3369 func_show_eval "$AUTORECONF$_G_autoreconf_options --install${1+ $1}" 'exit $?' 3370 3371 AUTOPOINT=$save_AUTOPOINT 3372 LIBTOOLIZE=$save_LIBTOOLIZE 3373} 3374 3375 3376# func_check_configuration VARNAME [CONFIGURE_MACRO] 3377# -------------------------------------------------- 3378# Exit with a suitable diagnostic for an important configuration change 3379# that needs to be made before bootstrap can run correctly. 3380func_check_configuration () 3381{ 3382 $debug_cmd 3383 3384 $require_configure_ac 3385 3386 eval 'test -n "$'$1'"' || { 3387 _G_error_msg="please set '$1' in 'bootstrap.conf'" 3388 if test -n "$configure_ac" && test -n "$2"; then 3389 func_append _G_error_msg " 3390or add the following (or similar) to your '$configure_ac': 3391$2" 3392 fi 3393 3394 func_fatal_error "$_G_error_msg" 3395 } 3396} 3397 3398 3399# func_clean_dangling_symlinks 3400# ---------------------------- 3401# Remove any dangling symlink matching "*.m4" or "*.[ch]" in some 3402# gnulib-populated directories. Such .m4 files would cause aclocal to 3403# fail. The following requires GNU find 4.2.3 or newer. Considering 3404# the usual portability constraints of this script, that may seem a very 3405# demanding requirement, but it should be ok. Ignore any failure, 3406# which is fine, since this is only a convenience to help developers 3407# avoid the relatively unusual case where a symlinked-to .m4 file is 3408# git-removed from gnulib between successive runs of this script. 3409func_clean_dangling_symlinks () 3410{ 3411 $debug_cmd 3412 3413 $require_macro_dir 3414 $require_source_base 3415 3416 func_verbose "cleaning dangling symlinks" 3417 3418 find "$macro_dir" "$source_base" \ 3419 -depth \( -name '*.m4' -o -name '*.[ch]' \) \ 3420 -type l -xtype l -delete > /dev/null 2>&1 3421} 3422 3423 3424# func_clean_unused_macros 3425# ------------------------ 3426# Autopoint can result in over-zealously adding macros into $macro_dir 3427# even though they are not actually used, for example tests to help 3428# build the 'intl' directory even though you have specified 3429# 'AM_GNU_GETTEXT([external])' in your configure.ac. This function 3430# looks removes any macro files that can be found in gnulib, but 3431# are not 'm4_include'd by 'aclocal.m4'. 3432func_clean_unused_macros () 3433{ 3434 $debug_cmd 3435 3436 $require_gnulib_path 3437 $require_macro_dir 3438 3439 test -n "$gnulib_path" && test -f aclocal.m4 && { 3440 aclocal_m4s=`find . -name aclocal.m4 -print` 3441 3442 # We use 'ls|grep' instead of 'ls *.m4' to avoid exceeding 3443 # command line length limits in some shells. 3444 for file in `cd "$macro_dir" && ls -1 |$GREP '\.m4$'`; do 3445 3446 # Remove a macro file when aclocal.m4 does not m4_include it... 3447 func_grep_q 'm4_include([[]'$macro_dir/$file'])' $aclocal_m4s \ 3448 || test ! -f "$gnulib_path/m4/$file" || { 3449 3450 # ...and there is an identical file in gnulib... 3451 if func_cmp_s "$gnulib_path/m4/$file" "$macro_dir/$file"; then 3452 3453 # ...and it's not in the precious list ('echo' is needed 3454 # here to squash whitespace for the match expression). 3455 case " "`echo $gnulib_precious`" " in 3456 *" $file "*) ;; 3457 *) rm -f "$macro_dir/$file" 3458 func_verbose \ 3459 "removing unused gnulib file '$macro_dir/$file'" 3460 esac 3461 fi 3462 } 3463 done 3464 } 3465} 3466 3467 3468# func_skip_po_recommendation 3469# --------------------------- 3470# If there is a po directory, and '--skip-po' wasn't passed, let the 3471# user know that they can use '--skip-po' on subsequent invocations. 3472func_skip_po_recommendation () 3473{ 3474 $debug_cmd 3475 3476 test ! -d po \ 3477 || $opt_skip_po \ 3478 || func_warning recommend "\ 3479If your pofiles are up-to-date, you can rerun bootstrap 3480as '$progname --skip-po' to avoid redownloading." 3481} 3482 3483 3484# func_update_dotversion 3485# ---------------------- 3486# Even with 'gitlog-to-changelog' generated ChangeLogs, automake 3487# will not run to completion with no ChangeLog file. 3488func_update_dotversion () 3489{ 3490 $debug_cmd 3491 3492 test -f "$build_aux/git-version-gen" && { 3493 _G_message="updating .version" 3494 test -f .version && { 3495 mv .version .version~ 3496 func_append _G_message " (backup in .version~)" 3497 } 3498 func_verbose "updating .version" 3499 3500 $build_aux/git-version-gen dummy-arg > .version 3501 } 3502} 3503 3504 3505 3506## -------------------- ## 3507## Resource management. ## 3508## -------------------- ## 3509 3510# This section contains definitions for functions that each ensure a 3511# particular resource (a file, or a non-empty configuration variable for 3512# example) is available, and if appropriate to extract default values 3513# from pertinent package files. Where a variable already has a non- 3514# empty value (as set by the package's 'bootstrap.conf'), that value is 3515# used in preference to deriving the default. Call them using their 3516# associated 'require_*' variable to ensure that they are executed, at 3517# most, once. 3518 3519 3520# require_gnulib_git_submodules 3521# ----------------------------- 3522# Initialize all git modules from $gnulib_git_submodules before we 3523# run 'gnulib-tool'. 3524require_gnulib_git_submodules=func_require_gnulib_git_submodules 3525func_require_gnulib_git_submodules () 3526{ 3527 test -n "$gnulib_git_submodules" && { 3528 for _G_submodule in $gnulib_git_submodules 3529 do 3530 func_show_eval "git submodule init -- $_G_submodule" \ 3531 && func_show_eval "git submodule update -- $_G_submodule" \ 3532 || func_fatal_error "Unable to init git module '$_G_submodule'." 3533 done 3534 } 3535 3536 require_gnulib_git_submodules=: 3537} 3538 3539 3540# require_checkout_only_file 3541# -------------------------- 3542# Bail out if this package only bootstraps properly from a repository 3543# checkout. 3544require_checkout_only_file=func_require_checkout_only_file 3545func_require_checkout_only_file () 3546{ 3547 $debug_cmd 3548 3549 $opt_force || { 3550 test -n "$checkout_only_file" && test ! -f "$checkout_only_file" \ 3551 && func_fatal_error "\ 3552Bootstrapping from a non-checked-out distribution is risky. 3553If you wish to bootstrap anyway, use the '--force' option." 3554 } 3555 3556 require_checkout_only_file=: 3557} 3558 3559 3560# require_aclocal_amflags 3561# ----------------------- 3562# Ensure '$aclocal_amflags' has a sensible default, extracted from 3563# 'Makefile.am' if necessary. 3564require_aclocal_amflags=func_require_aclocal_amflags 3565func_require_aclocal_amflags () 3566{ 3567 $debug_cmd 3568 3569 $require_makefile_am 3570 3571 _G_sed_extract_aclocal_amflags='s|#.*$|| 3572 /^[ ]*ACLOCAL_AMFLAGS[ ]*=/ { 3573 s|^.*=[ ]*\(.*\)|aclocal_amflags="\1"| 3574 p 3575 }' 3576 3577 _G_aclocal_flags_cmd=`$SED -n "$_G_sed_extract_aclocal_amflags" \ 3578 "$makefile_am"` 3579 eval "$_G_aclocal_flags_cmd" 3580 3581 func_verbose "ACLOCAL_AMFLAGS='$aclocal_amflags'" 3582 3583 require_aclocal_amflags=: 3584} 3585 3586 3587# require_autoheader 3588# ------------------ 3589# Skip autoheader if it's not needed. 3590require_autoheader=func_require_autoheader 3591func_require_autoheader () 3592{ 3593 $debug_cmd 3594 3595 test true = "$AUTOHEADER" || { 3596 func_extract_trace AC_CONFIG_HEADERS 3597 test -n "$func_extract_trace_result" \ 3598 || func_extract_trace AC_CONFIG_HEADER 3599 3600 test -n "$func_extract_trace_result" || { 3601 AUTOHEADER=true 3602 3603 func_verbose "export AUTOHEADER='$AUTOHEADER'" 3604 3605 # Make sure the search result is visible to subshells 3606 export AUTOHEADER 3607 } 3608 } 3609 3610 require_autoheader=: 3611} 3612 3613 3614# require_automake_options 3615# ------------------------ 3616# Extract options from AM_AUTOMAKE_INIT. 3617require_automake_options=func_require_automake_options 3618func_require_automake_options () 3619{ 3620 $debug_cmd 3621 3622 func_extract_trace AM_INIT_AUTOMAKE 3623 automake_options=$func_extract_trace_result 3624 3625 require_automake_options=: 3626} 3627 3628 3629# require_autopoint 3630# ----------------- 3631# Skip autopoint if it's not needed. 3632require_autopoint=func_require_autopoint 3633func_require_autopoint () 3634{ 3635 $debug_cmd 3636 3637 test true = "$AUTOPOINT" || { 3638 func_extract_trace AM_GNU_GETTEXT_VERSION 3639 3640 test -n "$func_extract_trace_result" || { 3641 AUTOPOINT=true 3642 3643 func_verbose "export AUTOPOINT='$AUTOPOINT'" 3644 3645 # Make sure the search result is visible to subshells 3646 export AUTOPOINT 3647 } 3648 } 3649 3650 require_autopoint=: 3651} 3652 3653 3654# require_bootstrap_uptodate 3655# -------------------------- 3656# Complain if the version of bootstrap in the gnulib directory differs 3657# from the one we are running. 3658require_bootstrap_uptodate=func_require_bootstrap_uptodate 3659func_require_bootstrap_uptodate () 3660{ 3661 $debug_cmd 3662 3663 $require_build_aux 3664 3665 _G_bootstrap_sources=" 3666 $build_aux/bootstrap.in 3667 $build_aux/extract-trace 3668 $build_aux/funclib.sh 3669 $build_aux/options-parser 3670 " 3671 3672 _G_missing_bootstrap_sources=false 3673 for _G_src in $_G_bootstrap_sources; do 3674 test -f "$_G_src" || _G_missing_bootstrap_sources=: 3675 done 3676 3677 if $_G_missing_bootstrap_sources; then 3678 func_warning upgrade "\ 3679Please add bootstrap to your gnulib_modules list in 3680'bootstrap.conf', so that I can tell you when there are 3681updates available." 3682 else 3683 rm -f bootstrap.new 3684 $build_aux/inline-source $build_aux/bootstrap.in > bootstrap.new 3685 3686 if func_cmp_s "$progpath" bootstrap.new; then 3687 rm -f bootstrap.new 3688 func_verbose "bootstrap script up to date" 3689 else 3690 chmod 555 bootstrap.new 3691 func_warning upgrade "\ 3692An updated bootstrap script has been generated for you in 3693'bootstrap.new'. After you've verified that you want 3694the changes, you can update with: 3695 mv -f bootstrap.new $progname 3696 ./$progname 3697 3698Or you can disable this check permanently by adding the 3699following to 'bootstrap.conf': 3700 require_bootstrap_uptodate=:" 3701 fi 3702 fi 3703 3704 require_bootstrap_uptodate=: 3705} 3706 3707 3708# require_build_aux 3709# ----------------- 3710# Ensure that '$build_aux' is set, and if it doesn't already point to an 3711# existing directory, create one. 3712require_build_aux=func_require_build_aux 3713func_require_build_aux () 3714{ 3715 $debug_cmd 3716 3717 test -n "$build_aux" || { 3718 func_extract_trace_first AC_CONFIG_AUX_DIR 3719 build_aux=$func_extract_trace_first_result 3720 func_check_configuration build_aux \ 3721 "AC_CONFIG_AUX_DIR([name of a directory for build scripts])" 3722 3723 func_verbose "build_aux='$build_aux'" 3724 } 3725 3726 $require_vc_ignore_files 3727 3728 # If the build_aux directory doesn't exist, create it now, and mark it 3729 # as ignored for the VCS. 3730 if test ! -d "$build_aux"; then 3731 func_show_eval "mkdir '$build_aux'" 3732 3733 test -n "$vc_ignore_files" \ 3734 || func_insert_if_absent "$build_aux" $vc_ignore_files 3735 fi 3736 3737 require_build_aux=: 3738} 3739 3740 3741# require_buildreq_autobuild 3742# -------------------------- 3743# Try to find whether the bootstrap requires autobuild. 3744require_buildreq_autobuild=func_require_buildreq_autobuild 3745func_require_buildreq_autobuild () 3746{ 3747 $debug_cmd 3748 3749 $require_macro_dir 3750 3751 test -f "$macro_dir/autobuild.m4" \ 3752 || printf '%s\n' "$buildreq" |func_grep_q '^[ ]*autobuild' \ 3753 || { 3754 func_extract_trace AB_INIT 3755 test -n "$func_extract_trace_result" && { 3756 func_append buildreq 'autobuild - http://josefsson.org/autobuild/ 3757' 3758 func_verbose "auto-adding 'autobuild' to build requirements" 3759 } 3760 } 3761 3762 require_buildreq_autobuild=: 3763} 3764 3765 3766# require_buildreq_autoconf 3767# require_buildreq_autopoint 3768# require_buildreq_libtoolize 3769# --------------------------- 3770# Try to find the minimum compatible version of autoconf/libtool 3771# required to bootstrap successfully, and add it to '$buildreq'. 3772for tool in autoconf libtoolize autopoint; do 3773 b=$tool 3774 v=require_buildreq_${tool} 3775 f=func_$v 3776 case $tool in 3777 autoconf) m=AC_PREREQ ;; 3778 libtoolize) m=LT_PREREQ; b=libtool ;; 3779 autopoint) m=AM_GNU_GETTEXT_VERSION b=gettext ;; 3780 esac 3781 3782 eval $v'='$f' 3783 '$f' () 3784 { 3785 $debug_cmd 3786 3787 # The following is ignored if undefined, but might be necessary 3788 # in order for `func_find_tool` to run. 3789 ${require_'$tool'-:} 3790 3791 printf '\''%s\n'\'' "$buildreq" |func_grep_q '\''^[ ]*'$tool\'' || { 3792 func_extract_trace '$m' 3793 _G_version=$func_extract_trace_result 3794 test -n "$_G_version" && { 3795 func_append buildreq "\ 3796 '$tool' $_G_version http://www.gnu.org/s/'$b' 3797" 3798 func_verbose \ 3799 "auto-adding '\'$tool'-$_G_version'\'' to build requirements" 3800 } 3801 } 3802 3803 '$v'=: 3804 } 3805' 3806done 3807 3808 3809# require_buildreq_automake 3810# ------------------------- 3811# Try to find the minimum compatible version of automake required to 3812# bootstrap successfully, and add it to '$buildreq'. 3813require_buildreq_automake=func_require_buildreq_automake 3814func_require_buildreq_automake () 3815{ 3816 $debug_cmd 3817 3818 # if automake is not already listed in $buildreq... 3819 printf '%s\n' "$buildreq" |func_grep_q automake || { 3820 func_extract_trace AM_INIT_AUTOMAKE 3821 3822 # ...and AM_INIT_AUTOMAKE is declared... 3823 test -n "$func_extract_trace_result" && { 3824 automake_version=`$ECHO "$func_extract_trace_result" \ 3825 |$SED -e 's|[^0-9]*||' -e 's| .*$||'` 3826 test -n "$automake_version" || automake_version=- 3827 3828 func_append buildreq "\ 3829 automake $automake_version http://www.gnu.org/s/automake 3830" 3831 func_verbose \ 3832 "auto-adding 'automake-$automake_version' to build requirements" 3833 } 3834 } 3835 3836 require_buildreq_automake=: 3837} 3838 3839 3840# require_buildreq_patch 3841# ---------------------- 3842# Automatically add a patch build-requirement if there are diff files 3843# in $local_gl_path. 3844require_buildreq_patch=func_require_buildreq_patch 3845func_require_buildreq_patch () 3846{ 3847 $debug_cmd 3848 3849 $require_local_gl_path 3850 3851 # This ensures PATCH is set appropriately by the time 3852 # func_check_versions enforces $buildreq. 3853 $require_patch 3854 3855 # If patch is not already listed in $buildreq... 3856 printf '%s\n' "$buildreq" |func_grep_q '^[ ]*patch' || { 3857 eval "set dummy $local_gl_path_quoted" ; shift 3858 3859 for _G_dir 3860 do 3861 # The ugly find invocation is necessary to exit with non-zero 3862 # status for old find binaries that don't support -exec fully. 3863 if test ! -d "$_G_dir" \ 3864 || find "$_G_dir" -name "*.diff" -exec false {} \; ; then : 3865 else 3866 func_append buildreq "patch - http://www.gnu.org/s/patch$nl" 3867 break 3868 fi 3869 done 3870 } 3871 3872 require_buildreq_patch=: 3873} 3874 3875 3876# require_buildtools_uptodate 3877# --------------------------- 3878# Ensure all the packages listed in BUILDREQS are available on the build 3879# machine at the minimum versions or better. 3880require_buildtools_uptodate=func_require_buildtools_uptodate 3881func_require_buildtools_uptodate () 3882{ 3883 $debug_cmd 3884 3885 $require_buildreq_autobuild 3886 $require_buildreq_autoconf 3887 $require_buildreq_automake 3888 $require_buildreq_libtoolize 3889 $require_buildreq_autopoint 3890 $require_buildreq_patch 3891 3892 test -n "$buildreq" && { 3893 _G_error_hdr= 3894 3895 func_check_versions $buildreq 3896 $func_check_versions_result || { 3897 test -n "$buildreq_readme" \ 3898 && test -f "$buildreq_readme" \ 3899 && _G_error_hdr="\ 3900$buildreq_readme explains how to obtain these prerequisite programs: 3901" 3902 func_strtable 0 11 12 36 \ 3903 "Program" "Min_version" "Homepage" $buildreq 3904 func_fatal_error "$_G_error_hdr$func_strtable_result" 3905 } 3906 } 3907 3908 require_buildtools_uptodate=: 3909} 3910 3911 3912# require_copyright_holder 3913# ------------------------ 3914# Ensure there is a sensible non-empty default value in '$copyright_holder'. 3915require_copyright_holder=func_require_copyright_holder 3916func_require_copyright_holder () 3917{ 3918 $debug_cmd 3919 3920 test -n "$copyright_holder" || { 3921 copyright_holder='Free Software Foundation, Inc.' 3922 func_warning settings "\ 3923Please set copyright_holder explicitly in 'bootstrap.conf'; 3924defaulting to '$copyright_holder'." 3925 } 3926 3927 require_copyright_holder=: 3928} 3929 3930 3931# require_doc_base 3932# ---------------- 3933# Ensure doc_base has a sensible value, extracted from 'gnulib-cache.m4' 3934# if possible, otherwise letting 'gnulib-tool' pick a default. 3935require_doc_base=func_require_doc_base 3936func_require_doc_base () 3937{ 3938 $debug_cmd 3939 3940 $require_gnulib_cache 3941 3942 test -f "$gnulib_cache" && test -z "$doc_base" && { 3943 func_extract_trace_first "gl_DOC_BASE" "$gnulib_cache" 3944 doc_base=$func_extract_trace_first_result 3945 3946 test -n "$doc_base" && func_verbose "doc_base='$doc_base'" 3947 } 3948 3949 require_doc_base=: 3950} 3951 3952 3953# require_dotgitmodules 3954# --------------------- 3955# Ensure we have a '.gitmodules' file, with appropriate 'gnulib' settings. 3956require_dotgitmodules=func_require_dotgitmodules 3957func_require_dotgitmodules () 3958{ 3959 $debug_cmd 3960 3961 $require_git 3962 3963 test true = "$GIT" || { 3964 # A gnulib entry in .gitmodules always takes precedence. 3965 _G_path=`$GIT config --file .gitmodules submodule.gnulib.path 2>/dev/null` 3966 3967 test -n "$_G_path" || { 3968 $require_vc_ignore_files 3969 3970 func_verbose "creating '.gitmodules'" 3971 3972 # If the .gitmodules file doesn't exist, create it now, and mark 3973 # it as ignored for the VCS. 3974 test -n "$gnulib_path" || gnulib_path=gnulib 3975 test -n "$gnulib_url" || gnulib_url=git://git.sv.gnu.org/gnulib 3976 3977 { 3978 echo '[submodule "gnulib"]' 3979 echo " path = $gnulib_path" 3980 echo " url = $gnulib_url" 3981 } >> .gitmodules 3982 3983 test -n "$vc_ignore_files" \ 3984 || func_insert_if_absent ".gitmodules" $vc_ignore_files 3985 } 3986 } 3987 3988 require_dotgitmodules=: 3989} 3990 3991 3992# require_extra_locale_categories 3993# ------------------------------- 3994# Ensure there is a default value in '$extra_locale_categories' 3995require_extra_locale_categories=func_require_extra_locale_categories 3996func_require_extra_locale_categories () 3997{ 3998 $debug_cmd 3999 4000 # Defaults to empty, so run with whatever value may have been set in 4001 # 'bootstrap.conf'. 4002 require_extra_locale_categories=: 4003} 4004 4005 4006# require_git 4007# ----------- 4008# Ignore git if it's not available, or we're not in a git checkout tree. 4009require_git=func_require_git 4010func_require_git () 4011{ 4012 $debug_cmd 4013 4014 $opt_skip_git && GIT=true 4015 4016 test true = "$GIT" || { 4017 if test -d .git/.; then 4018 ($GIT --version) >/dev/null 2>&1 || GIT=true 4019 fi 4020 } 4021 4022 func_verbose "GIT='$GIT'" 4023 4024 require_git=: 4025} 4026 4027 4028# require_gnulib_cache 4029# -------------------- 4030# Ensure there is a non-empty default for '$gnulib_cache', and that it 4031# names an existing file. 4032require_gnulib_cache=func_require_gnulib_cache 4033func_require_gnulib_cache () 4034{ 4035 $debug_cmd 4036 4037 $require_macro_dir 4038 4039 test -n "$gnulib_cache" \ 4040 || gnulib_cache=$macro_dir/gnulib-cache.m4 4041 4042 func_verbose "found '$gnulib_cache'" 4043 4044 require_gnulib_cache=: 4045} 4046 4047 4048# require_gnulib_copy_cmd 4049# ----------------------- 4050# Only calculate the options for copying files with gnulib once. 4051require_gnulib_copy_cmd=func_require_gnulib_copy_cmd 4052func_require_gnulib_copy_cmd () 4053{ 4054 $debug_cmd 4055 4056 $require_gnulib_tool 4057 $require_gnulib_tool_base_options 4058 4059 gnulib_copy_cmd="$gnulib_tool $gnulib_tool_base_options --copy-file" 4060 $opt_copy || func_append gnulib_copy_cmd " --symlink" 4061 $opt_quiet || func_append gnulib_copy_cmd " --verbose" 4062 4063 require_gnulib_copy_cmd=: 4064} 4065 4066 4067# require_gnulib_merge_changelog 4068# ------------------------------ 4069# See if we can use gnulib's git-merge-changelog merge driver. 4070require_gnulib_merge_changelog=func_require_gnulib_merge_changelog 4071func_require_gnulib_merge_changelog () 4072{ 4073 $debug_cmd 4074 4075 test -f ChangeLog && { 4076 $require_git 4077 4078 func_grep_q '^\(/\|\)ChangeLog$' .gitignore || test true = "$GIT" || { 4079 if $GIT config merge.merge-changelog.driver >/dev/null; then 4080 : 4081 elif (git-merge-changelog --version) >/dev/null 2>&1; then 4082 func_echo "initializing git-merge-changelog driver" 4083 $GIT config merge.merge-changelog.name 'GNU-style ChangeLog merge driver' 4084 $GIT config merge.merge-changelog.driver 'git-merge-changelog %O %A %B' 4085 else 4086 func_warning recommend \ 4087 "Consider installing git-merge-changelog from gnulib." 4088 fi 4089 } 4090 } 4091 4092 require_gnulib_merge_changelog=: 4093} 4094 4095 4096# require_gnulib_mk 4097# ----------------- 4098# Ensure gnulib_mk has a sensible value, extracted from 'gnulib-cache.m4' 4099# if possible, otherwise letting 'gnulib-tool' pick a default. 4100require_gnulib_mk=func_require_gnulib_mk 4101func_require_gnulib_mk () 4102{ 4103 $debug_cmd 4104 4105 $require_gnulib_cache 4106 4107 test -f "$gnulib_cache" && test -z "$gnulib_mk" && { 4108 func_extract_trace_first "gl_MAKEFILE_NAME" "$gnulib_cache" 4109 gnulib_mk=$func_extract_trace_first_result 4110 4111 test -n "$gnulib_mk" && func_verbose "gnulib_mk='$gnulib_mk'" 4112 } 4113 4114 require_gnulib_mk=: 4115} 4116 4117 4118# require_gnulib_name 4119# ------------------- 4120# Ensure gnulib_name has a sensible value, extracted from 'gnulib-cache.m4' 4121# if possible, otherwise letting 'gnulib-tool' pick a default. 4122require_gnulib_name=func_require_gnulib_name 4123func_require_gnulib_name () 4124{ 4125 $debug_cmd 4126 4127 $require_gnulib_cache 4128 4129 test -f "$gnulib_cache" && test -z "$gnulib_name" && { 4130 func_extract_trace_first "gl_LIB" "$gnulib_cache" 4131 gnulib_name=$func_extract_trace_first_result 4132 4133 test -n "$gnulib_name" && func_verbose "gnulib_name='$gnulib_name'" 4134 } 4135 4136 require_gnulib_name=: 4137} 4138 4139 4140# require_gnulib_path 4141# require_gnulib_url 4142# ------------------- 4143# Ensure 'gnulib_path' and 'gnulib_url' are set. 4144require_gnulib_path=func_require_dotgitmodules_parameters 4145require_gnulib_url=func_require_dotgitmodules_parameters 4146func_require_dotgitmodules_parameters () 4147{ 4148 $debug_cmd 4149 4150 $require_git 4151 4152 test true = "$GIT" && { 4153 # If we can't find git (or if the user specified '--skip-git'), 4154 # then use an existing gnulib directory specified with 4155 # '--gnulib-srcdir' if possible. 4156 test -n "$gnulib_path" \ 4157 || test ! -x "$opt_gnulib_srcdir/gnulib-tool" \ 4158 || gnulib_path=$opt_gnulib_srcdir 4159 } 4160 4161 4162 $require_dotgitmodules 4163 4164 test -f .gitmodules && { 4165 # Extract the parameters with sed, since git may be missing 4166 test -n "$gnulib_path" \ 4167 || gnulib_path=`$SED -e '/^.submodule "gnulib".$/,${ 4168 /[ ]*path *= */{ 4169 s|[ ]*||g;s|^[^=]*=||;p 4170 } 4171 } 4172 d' .gitmodules |$SED 1q` 4173 test -n "$gnulib_url" \ 4174 || gnulib_url=`$SED -e '/^.submodule "gnulib".$/,${ 4175 /[ ]*url *= */{ 4176 s|[ ]*||g;s|^[^=]*=||;p 4177 } 4178 } 4179 d' .gitmodules |$SED 1q` 4180 4181 func_verbose "gnulib_path='$gnulib_path'" 4182 func_verbose "gnulib_url='$gnulib_url'" 4183 } 4184 4185 require_gnulib_path=: 4186 require_gnulib_url=: 4187} 4188 4189 4190# require_gnulib_submodule 4191# ------------------------ 4192# Ensure that there is a current gnulib submodule at '$gnulib_path'. 4193require_gnulib_submodule=func_require_gnulib_submodule 4194func_require_gnulib_submodule () 4195{ 4196 $debug_cmd 4197 4198 $require_git 4199 4200 if test true = "$GIT"; then 4201 func_warning recommend \ 4202 "No 'git' found; imported gnulib modules may be outdated." 4203 else 4204 $require_gnulib_path 4205 $require_gnulib_url 4206 4207 if test -f .gitmodules && test -f "$gnulib_path/gnulib-tool"; then 4208 : All present and correct. 4209 4210 elif test -n "$opt_gnulib_srcdir"; then 4211 # Older git can't clone into an empty directory. 4212 rmdir "$gnulib_path" 2>/dev/null 4213 func_show_eval "$GIT clone --reference '$opt_gnulib_srcdir' \ 4214 '$gnulib_url' '$gnulib_path'" \ 4215 || func_fatal_error "Unable to fetch gnulib submodule." 4216 4217 # Without --gnulib-srcdir, and no existing checked out submodule, we 4218 # create a new shallow clone of the remote gnulib repository. 4219 else 4220 trap func_cleanup_gnulib 1 2 13 15 4221 4222 shallow= 4223 test -n "$gnulib_clone_since" && \ 4224 $GIT clone -h 2>&1 |func_grep_q -- --shallow-since \ 4225 && shallow="--shallow-since=$gnulib_clone_since" 4226 4227 func_show_eval "$GIT clone $shallow '$gnulib_url' '$gnulib_path'" \ 4228 func_cleanup_gnulib 4229 4230 # FIXME: Solaris /bin/sh will try to execute '-' if any of 4231 # these signals are caught after this. 4232 trap - 1 2 13 15 4233 fi 4234 4235 # Make sure we've checked out the correct revision of gnulib. 4236 func_show_eval "$GIT submodule init -- $gnulib_path" \ 4237 && func_show_eval "$GIT submodule update -- $gnulib_path" \ 4238 || func_fatal_error "Unable to update gnulib submodule." 4239 fi 4240 4241 require_gnulib_submodule=: 4242} 4243 4244 4245# require_gnulib_tool 4246# ------------------- 4247# Ensure that '$gnulib_tool' is set, and points to an executable file, 4248# or else fall back to using the binary 'true' if the main gnulib 4249# files appear to have been imported already. 4250require_gnulib_tool=func_require_gnulib_tool 4251func_require_gnulib_tool () 4252{ 4253 $debug_cmd 4254 4255 test true = "$gnulib_tool" || { 4256 $require_gnulib_submodule 4257 $require_gnulib_path 4258 4259 test -n "$gnulib_tool" \ 4260 || gnulib_tool=$gnulib_path/gnulib-tool 4261 4262 test -x "$gnulib_tool" || { 4263 gnulib_tool=true 4264 func_warning recommend \ 4265 "No 'gnulib-tool' found; gnulib modules may be missing." 4266 } 4267 4268 test true = "$gnulib_tool" \ 4269 || func_verbose "found '$gnulib_tool'" 4270 } 4271 4272 require_gnulib_tool=: 4273} 4274 4275 4276# require_gnulib_tool_base_options 4277# -------------------------------- 4278# Ensure that '$gnulib_tool_base_options' contains all the base options 4279# required according to user configuration from bootstrap.conf. 4280require_gnulib_tool_base_options=func_require_gnulib_tool_base_options 4281func_require_gnulib_tool_base_options () 4282{ 4283 $debug_cmd 4284 4285 $require_gnulib_tool 4286 4287 gnulib_tool_base_options= 4288 4289 test true = "$gnulib_tool" || { 4290 # 'gnulib_modules' and others are maintained in 'bootstrap.conf': 4291 # Use 'gnulib --import' to fetch gnulib modules. 4292 $require_build_aux 4293 test -n "$build_aux" \ 4294 && func_append_uniq gnulib_tool_base_options " --aux-dir=$build_aux" 4295 $require_macro_dir 4296 test -n "$macro_dir" \ 4297 && func_append_uniq gnulib_tool_base_options " --m4-base=$macro_dir" 4298 $require_doc_base 4299 test -n "$doc_base" \ 4300 && func_append_uniq gnulib_tool_base_options " --doc-base=$doc_base" 4301 $require_gnulib_name 4302 test -n "$gnulib_name" \ 4303 && func_append_uniq gnulib_tool_base_options " --lib=$gnulib_name" 4304 $require_local_gl_path 4305 test -n "$local_gl_path" && { 4306 eval "set dummy $local_gl_path_quoted" ; shift 4307 for _G_dir 4308 do 4309 func_append_uniq gnulib_tool_base_options " --local-dir=$_G_dir" 4310 done 4311 } 4312 $require_source_base 4313 test -n "$source_base" \ 4314 && func_append_uniq gnulib_tool_base_options " --source-base=$source_base" 4315 } 4316 4317 require_gnulib_tool_base_options=: 4318} 4319 4320 4321# require_libtoolize 4322# ------------------ 4323# Skip libtoolize if it's not needed. 4324require_libtoolize=func_require_libtoolize 4325func_require_libtoolize () 4326{ 4327 $debug_cmd 4328 4329 # Unless we're not searching for libtool use by this package, set 4330 # LIBTOOLIZE to true if none of 'LT_INIT', 'AC_PROG_LIBTOOL' and 4331 # 'AM_PROG_LIBTOOL' are used in configure. 4332 test true = "$LIBTOOLIZE" || { 4333 func_extract_trace LT_INIT 4334 test -n "$func_extract_trace_result" || func_extract_trace AC_PROG_LIBTOOL 4335 test -n "$func_extract_trace_result" || func_extract_trace AM_PROG_LIBTOOL 4336 test -n "$func_extract_trace_result" || LIBTOOLIZE=true 4337 } 4338 4339 test -n "$LIBTOOLIZE" || { 4340 # Find libtoolize, named glibtoolize in Mac Ports, but prefer 4341 # user-installed libtoolize to ancient glibtoolize shipped by 4342 # Apple with Mac OS X when Mac Ports is not installed. 4343 func_find_tool LIBTOOLIZE libtoolize glibtoolize 4344 } 4345 4346 test -n "$LIBTOOLIZE" || func_fatal_error "\ 4347Please install GNU Libtool, or 'export LIBTOOLIZE=/path/to/libtoolize'." 4348 4349 func_verbose "export LIBTOOLIZE='$LIBTOOLIZE'" 4350 4351 # Make sure the search result is visible to subshells 4352 export LIBTOOLIZE 4353 4354 require_libtoolize=: 4355} 4356 4357 4358# require_local_gl_path 4359# --------------------- 4360# Ensure local_gl_path has a sensible value, extracted from 'gnulib-cache.m4' if 4361# possible, otherwise letting 'gnulib-tool' pick a default. 4362require_local_gl_path=func_require_local_gl_path 4363func_require_local_gl_path () 4364{ 4365 $debug_cmd 4366 4367 $require_gnulib_cache 4368 4369 # Compat with older bootstrap versions. 4370 test -n "$local_gl_dir" && { 4371 func_warning settings "\ 4372Please use 'local_gl_path' instead of 'local_gl_dir' in your 4373'bootstrap.conf' file." 4374 local_gl_path=$local_gl_dir 4375 local_gl_dir= 4376 } 4377 4378 test -f "$gnulib_cache" && test -z "$local_gl_path" && { 4379 func_extract_trace_first "gl_LOCAL_DIR" "$gnulib_cache" 4380 local_gl_path=$func_extract_trace_first_result 4381 test -n "$local_gl_path" && func_verbose "local_gl_path='$local_gl_path'" 4382 } 4383 4384 test -z "$local_gl_path_quoted" && test -n "$local_gl_path" && { 4385 save_IFS=$IFS 4386 set dummy 4387 # Don't use PATH_SEPARATOR here, gnulib must be fixed to store only ':' as 4388 # path separator into gnulib-cache.m4 (consistency reasons among systems). 4389 IFS=: 4390 for _G_dir in $local_gl_path 4391 do 4392 set "$@" "$_G_dir" 4393 done 4394 shift 4395 IFS=$save_IFS 4396 func_quote eval "$@" 4397 local_gl_path_quoted=$func_quote_result 4398 } 4399 4400 require_local_gl_path=: 4401} 4402 4403 4404# require_macro_dir 4405# ----------------- 4406# Ensure that '$macro_dir' is set, and if it doesn't already point to an 4407# existing directory, create one. 4408require_macro_dir=func_require_macro_dir 4409func_require_macro_dir () 4410{ 4411 $debug_cmd 4412 4413 # Sometimes this is stored in 'configure.ac'. 4414 test -n "$macro_dir" || { 4415 # AC_CONFIG_MACRO_DIRS takes a space delimited list of directories, 4416 # but we only care about the first one in bootstrap. 4417 func_extract_trace_first AC_CONFIG_MACRO_DIRS 4418 macro_dir=`expr "x$func_extract_trace_first_result" : 'x\([^ ]*\)'` 4419 } 4420 test -n "$macro_dir" || { 4421 func_extract_trace_first AC_CONFIG_MACRO_DIR 4422 macro_dir=$func_extract_trace_first_result 4423 } 4424 4425 # Otherwise we might find it in 'Makefile.am'. 4426 test -n "$macro_dir" || { 4427 $require_aclocal_amflags 4428 4429 # Take the argument following the first '-I', if any. 4430 _G_minus_I_seen=false 4431 for _G_arg in $aclocal_amflags; do 4432 case $_G_minus_I_seen,$_G_arg in 4433 :,*) macro_dir=$_G_arg; break ;; 4434 *,-I) _G_minus_I_seen=: ;; 4435 *,-I*) macro_dir=`expr x$_G_arg : 'x-I\(.*\)$'`; break ;; 4436 esac 4437 done 4438 } 4439 4440 func_verbose "macro_dir='$macro_dir'" 4441 4442 func_check_configuration macro_dir \ 4443 "AC_CONFIG_MACRO_DIRS([name of a directory for configure m4 files])" 4444 4445 $require_vc_ignore_files 4446 4447 # If the macro_dir directory doesn't exist, create it now, and mark it 4448 # as ignored for the VCS. 4449 if test ! -d "$macro_dir"; then 4450 mkdir "$macro_dir" || func_permissions_error "$macro_dir" 4451 4452 test -n "$vc_ignore_files" \ 4453 || func_insert_if_absent "$macro_dir" $vc_ignore_files 4454 fi 4455 4456 require_macro_dir=: 4457} 4458 4459 4460# require_makefile_am 4461# ------------------- 4462# Ensure there is a 'Makefile.am' in the current directory. 4463require_makefile_am=func_require_makefile_am 4464func_require_makefile_am () 4465{ 4466 $debug_cmd 4467 4468 test -n "$makefile_am" \ 4469 || makefile_am=Makefile.am 4470 4471 <"$makefile_am" 4472 4473 func_verbose "found '$makefile_am'" 4474 4475 require_makefile_am=: 4476} 4477 4478 4479# require_package 4480# --------------- 4481# Ensure that '$package' contains a sensible default value. 4482require_package=func_require_package 4483func_require_package () 4484{ 4485 $debug_cmd 4486 4487 test -n "$package" || { 4488 $require_package_name 4489 4490 package=`echo "$package_name" \ 4491 |$SED -e 's/GNU //' \ 4492 -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'` 4493 } 4494 4495 func_verbose "package='$package'" 4496 4497 require_package=: 4498} 4499 4500 4501# require_package_bugreport 4502# ------------------------- 4503# Ensure that this has a sensible value, extracted from 'configure.ac' 4504# if appropriate (and possible!). 4505require_package_bugreport=func_require_package_bugreport 4506func_require_package_bugreport () 4507{ 4508 $debug_cmd 4509 4510 func_extract_trace AC_INIT 4511 4512 save_ifs=$IFS 4513 IFS=: 4514 set dummy $func_extract_trace_result 4515 IFS=$save_ifs 4516 shift 4517 4518 test -n "$package_bugreport" || package_bugreport=$3 4519 func_check_configuration package_bugreport \ 4520 "AC_INIT([$package_name], [$package_version], [bug-$package@gnu.org])" 4521 func_verbose "package_bugreport='$package_bugreport'" 4522 4523 require_package_bugreport=: 4524} 4525 4526 4527# require_package_name 4528# -------------------- 4529# Ensure that this has a sensible value, extracted from 'configure.ac' 4530# if appropriate (and possible!). 4531require_package_name=func_require_package_name 4532func_require_package_name () 4533{ 4534 $debug_cmd 4535 4536 func_extract_trace AC_INIT 4537 4538 save_ifs=$IFS 4539 IFS=: 4540 set dummy $func_extract_trace_result 4541 IFS=$save_ifs 4542 shift 4543 4544 test -n "$package_name" || package_name=$1 4545 func_check_configuration package_name \ 4546 "AC_INIT([name of your package], [package version number])" 4547 func_verbose "package_name='$package_name'" 4548 4549 require_package_name=: 4550} 4551 4552 4553# require_package_version 4554# ----------------------- 4555# Ensure that this has a sensible value, extracted from 'configure.ac' 4556# if appropriate (and possible!). While we might have set all the 4557# parameters extracted from AC_INIT at once, 'package_version' in 4558# particular is not necessarily available as early as the others, since 4559# 'git-version-gen' is often involved, and until then we can't rely on 4560# getting a correct version number from an AC_INIT extraction. 4561require_package_version=func_require_package_version 4562func_require_package_version () 4563{ 4564 $debug_cmd 4565 4566 func_extract_trace AC_INIT 4567 4568 save_ifs=$IFS 4569 IFS=: 4570 set dummy $func_extract_trace_result 4571 IFS=$save_ifs 4572 shift 4573 4574 test -n "$package_version" || package_version=$2 4575 test -n "$package_version" || { 4576 # The embedded echo is to squash whitespace before globbing. 4577 case " "`echo $gnulib_modules`" " in 4578 *" git-version-gen "*) 4579 func_fatal_error "\ 4580cannot \$require_package_version in bootstrap.conf before 4581func_gnulib_tool has installed the 'git-version-gen' script." 4582 ;; 4583 *) 4584 func_check_configuration package_version \ 4585 "AC_INIT([name of your package], [package version number])" 4586 ;; 4587 esac 4588 } 4589 func_verbose "package_version='$package_version'" 4590 4591 require_package_version=: 4592} 4593 4594 4595# require_patch 4596# ------------- 4597# Find patch, according to the PATCH environment variable, or else 4598# searching the user's PATH. 4599require_patch=func_require_patch 4600func_require_patch () 4601{ 4602 $debug_cmd 4603 4604 test -n "$PATCH" || { 4605 # Find a patch program, preferring gpatch, which is usually better 4606 # than the vendor patch. 4607 func_find_tool PATCH gpatch patch 4608 } 4609 4610 test -n "$PATCH" || func_fatal_error "\ 4611Please install GNU Patch, or 'export PATCH=/path/to/gnu/patch'." 4612 4613 func_verbose "export PATCH='$PATCH'" 4614 4615 # Make sure the search result is visible to subshells 4616 export PATCH 4617 4618 require_patch=: 4619} 4620 4621 4622# require_source_base 4623# ------------------- 4624# Ensure that source_base has a sensible value, extracted from 4625# 'gnulib-cache.m4' if possible. 4626require_source_base=func_require_source_base 4627func_require_source_base () 4628{ 4629 $debug_cmd 4630 4631 $require_gnulib_cache 4632 4633 test -f "$gnulib_cache" && test -z "$source_base" && { 4634 func_extract_trace_first "gl_SOURCE_BASE" "$gnulib_cache" 4635 4636 source_base=$func_extract_trace_first_result 4637 4638 func_verbose "source_base='$source_base'" 4639 } 4640 4641 require_source_base=: 4642} 4643 4644 4645# require_vc_ignore_files 4646# ----------------------- 4647# Ensure that '$vc_ignore' has been processed to list VCS ignore files 4648# in '$vc_ignore_files' 4649require_vc_ignore_files=func_require_vc_ignore_files 4650func_require_vc_ignore_files () 4651{ 4652 $debug_cmd 4653 4654 test -n "$vc_ignore" || vc_ignore=auto 4655 4656 if test auto = "$vc_ignore" && test -z "$vc_ignore_files"; then 4657 vc_ignore_files= 4658 test -d .git && vc_ignore_files=.gitignore 4659 test -d CVS && vc_ignore_files="$vc_ignore_files .cvsignore" 4660 else 4661 vc_ignore_files=$vc_ignore 4662 fi 4663 4664 func_verbose "vc_ignore_files='$vc_ignore_files'" 4665 4666 require_vc_ignore_files=: 4667} 4668 4669 4670## ----------------- ## 4671## Helper functions. ## 4672## ----------------- ## 4673 4674# This section contains the helper functions used by the rest of 'bootstrap'. 4675 4676# func_len STRING 4677# --------------- 4678# STRING may not start with a hyphen. 4679if (eval 'x=123; test x${#x} = "x3"') 2>/dev/null 4680then 4681 # This is an XSI compatible shell, allowing a faster implementation... 4682 eval 'func_len () 4683 { 4684 $debug_cmd 4685 4686 func_len_result=${#1} 4687 }' 4688else 4689 # ...otherwise fall back to using expr, which is often a shell builtin. 4690 func_len () 4691 { 4692 $debug_cmd 4693 4694 func_len_result=`expr "$1" : ".*" 2>/dev/null || echo 0` 4695 } 4696fi 4697 4698 4699# func_cmp_s FILE1 FILE2 4700# ---------------------- 4701# Return non-zero exit status unless FILE1 and FILE2 are identical, without 4702# any output at all, even error messages. 4703func_cmp_s () 4704{ 4705 $debug_cmd 4706 4707 # This function relies on non-zero exit status, which will cause the 4708 # program to exit when running in 'set -e' mode. 4709 $CMP "$@" >/dev/null 2>&1 4710} 4711 4712 4713# func_grep_q EXPRESSION [FILENAME..] 4714# ----------------------------------- 4715# Check whether EXPRESSION matches any line of any listed FILENAME, 4716# without any output at all, even error messages. 4717func_grep_q () 4718{ 4719 $debug_cmd 4720 4721 # This function relies on non-zero exit status, which will cause the 4722 # program to exit when running in 'set -e' mode. 4723 $GREP "$@" >/dev/null 2>&1 4724} 4725 4726 4727# func_ifcontains LIST MEMBER YES-CMD [NO-CMD] 4728# -------------------------------------------- 4729# If whitespace-separated LIST contains MEMBER then execute YES-CMD, 4730# otherwise if NO-CMD was given, execute that. 4731func_ifcontains () 4732{ 4733 $debug_cmd 4734 4735 _G_wslist=$1 4736 _G_member=$2 4737 _G_yes_cmd=$3 4738 _G_no_cmd=${4-":"} 4739 4740 _G_found=false 4741 for _G_item in $_G_wslist; do 4742 test "x$_G_item" = "x$_G_member" && { 4743 _G_found=: 4744 break 4745 } 4746 done 4747 if $_G_found; then 4748 eval "$_G_yes_cmd" 4749 _G_status=$? 4750 else 4751 eval "$_G_no_cmd" 4752 _G_status=$? 4753 fi 4754 4755 test 0 -eq "$_G_status" || exit $_G_status 4756} 4757 4758 4759# func_strpad STR WIDTH CHAR 4760# -------------------------- 4761# Trim STR, or pad with CHAR to force a total length of WIDTH. 4762func_strpad () 4763{ 4764 $debug_cmd 4765 4766 _G_width=`expr "$2" - 1` 4767 func_strpad_result=`$ECHO "$1" |$SED ' 4768 :a 4769 s|^.\{0,'"$_G_width"'\}$|&'"$3"'| 4770 ta 4771 '` 4772} 4773 4774 4775# func_strrpad STR WIDTH CHAR 4776# --------------------------- 4777# Trim STR, or right-justify-pad with CHAR to force a total length of 4778# WIDTH. 4779func_strrpad () 4780{ 4781 $debug_cmd 4782 4783 _G_width=`expr "$2" - 1` 4784 func_strrpad_result=`$ECHO "$1" |$SED ' 4785 :a 4786 s|^.\{0,'"$_G_width"'\}$|'"$3"'&| 4787 ta 4788 '` 4789} 4790 4791 4792# func_strrow INDENT FIELD WIDTH [FIELDn WIDTHn]... 4793# ------------------------------------------------- 4794# Return a string containing each FIELD left justified to WIDTH, with 4795# the whole thing indented by INDENT spaces. This function is used to 4796# render one row of aligned columns for a table by func_strtable(). 4797func_strrow () 4798{ 4799 $debug_cmd 4800 4801 func_strrow_linelen=$1; shift 4802 4803 _G_row= 4804 while test $# -gt 0; do 4805 func_strrow_linelen=`expr $func_strrow_linelen + $2` 4806 func_strpad "$1" $2 " " 4807 func_append _G_row "$func_strpad_result" 4808 shift; shift 4809 done 4810 4811 func_strrpad "$_G_row" $func_strrow_linelen " " 4812 func_strrow_result=$func_strrpad_result 4813} 4814 4815 4816# func_strtable INDENT WIDTH1...WIDTHn HEADER1...HEADERn FIELD1...FIELDn 4817# ---------------------------------------------------------------------- 4818# Generate a string of newline-separated rows arranged in lined-up 4819# columns of the given WIDTHs, with the entire table indented by INDENT 4820# spaces. The number of columns is determined by the number of integer 4821# valued WIDTH arguments following INDENT. The next set (i.e. a number 4822# of arguments equal to the number of WIDTH arguments) of fields are 4823# treated as the table's column HEADERs, and are separated from the 4824# remainder of the table by an indented row of '-' characters. Remaining 4825# arguments are each aligned below the next available header, wrapping 4826# to a new row as necessary. Finally another row of '-' characters is 4827# added to mark the end of the table. 4828# 4829# For example an unindented 3 column table with 2 rows of data would be 4830# generated by this call: 4831# 4832# func_strtable 3 20 10 25 \ 4833# Header1 Header2 Header3 \ 4834# Row1Col1 Row1Col2 Row1Col3 \ 4835# Row2Col1 Row2Col2 Row2Col3 4836# 4837# returning the following string: 4838# 4839# " Header1 Header2 Header3 4840# ------------------------------------------------------- 4841# Row1Col1 Row1Col2 Row1Col3 4842# Row2Col1 Row2Col2 Row2Col3 4843# -------------------------------------------------------" 4844func_strtable () 4845{ 4846 $debug_cmd 4847 4848 # Save the indent value, we'll need it for each row we render. 4849 _G_indent=$1; shift 4850 4851 # Collect remaining numeric args into a list for reuse between 4852 # members of each row when we call func_strrow later. 4853 _G_widths=$1; shift 4854 while test 0 -lt `expr "$1" : '[1-9][0-9]*$'`; do 4855 func_append _G_widths " $1"; shift 4856 done 4857 4858 # Extract the same number of positional parameters as there are 4859 # width elements - we'll do the header rows separately so that 4860 # we can insert a divider line. 4861 _G_header=$_G_indent 4862 for _G_width in $_G_widths; do 4863 func_append _G_header " $1 $_G_width"; shift 4864 done 4865 func_strrow $_G_header 4866 4867 # Strip off the indent, and make a divider with '-' chars, then 4868 # reindent. 4869 _G_divider=`$ECHO "$func_strrow_result" \ 4870 |$SED 's|[^ ]|-|g 4871 :a 4872 s|- |--|g 4873 ta 4874 '` 4875 4876 # Append the header and divider to the running result. 4877 func_append func_strtable_result "\ 4878$func_strrow_result 4879$_G_divider 4880" 4881 4882 # The remaining rows are zipped between the width values we 4883 # unwound earlier just like the header row above. 4884 while test $# -gt 0; do 4885 _G_row=$_G_indent 4886 for _G_width in $_G_widths; do 4887 func_append _G_row " $1 $_G_width"; shift 4888 done 4889 func_strrow $_G_row 4890 func_append func_strtable_result "\ 4891$func_strrow_result 4892" 4893 done 4894 4895 # Mark the end of the table with a final divider line. 4896 func_append func_strtable_result "$_G_divider" 4897} 4898 4899 4900# func_internal_error ARG... 4901# -------------------------- 4902# Echo program name prefixed message to standard error, and exit. 4903func_internal_error () 4904{ 4905 func_fatal_error "\ 4906INTERNAL: " ${1+"$@"} " 4907 Please report this bug to 'bug-gnulib@gnu.org' 4908 in as much detail as possible." 4909} 4910 4911 4912# func_permissions_error FILE-OR-DIRECTORY 4913# ---------------------------------------- 4914# Echo program name prefixed permissions error message to standard 4915# error, and exit. 4916func_permissions_error () 4917{ 4918 $debug_cmd 4919 4920 func_fatal_error "Failed to create '$1', check permissions." 4921} 4922 4923 4924# func_show_eval CMD [FAIL_EXP] 4925# ----------------------------- 4926# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is 4927# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP 4928# is given, then evaluate it. 4929func_show_eval () 4930{ 4931 $debug_cmd 4932 4933 $require_term_colors 4934 4935 _G_cmd=$1 4936 _G_fail_exp=${2-':'} 4937 4938 ${opt_silent-'false'} || { 4939 func_quote eval $_G_cmd 4940 eval func_truncate_cmd $func_quote_result 4941 func_echo "running: $tc_bold$func_truncate_cmd_result$tc_reset" 4942 } 4943 4944 ${opt_dry_run-'false'} || { 4945 eval "$_G_cmd" 4946 _G_status=$? 4947 test 0 -eq "$_G_status" || eval "(exit $_G_status); $_G_fail_exp" 4948 } 4949} 4950 4951 4952# func_truncate_cmd CMD [ARG]... 4953# ------------------------------ 4954# For unreasonably long commands (such as a gnulib-tool invocation with 4955# the full module list for import), truncate CMD after the second non- 4956# option ARG. 4957func_truncate_cmd () 4958{ 4959 $debug_cmd 4960 4961 _G_last_arg_opt_p=false 4962 func_truncate_cmd_result= 4963 4964 set dummy "$@"; shift 4965 4966 while test $# -gt 0; do 4967 _G_opt=$1; shift 4968 4969 test -n "$func_truncate_cmd_result" \ 4970 && func_append func_truncate_cmd_result ' ' 4971 func_append func_truncate_cmd_result "$_G_opt" 4972 4973 func_len "x$func_truncate_cmd_result" 4974 4975 case $_G_opt in 4976 -*) _G_last_arg_opt_p=: ;; 4977 *) $_G_last_arg_opt_p \ 4978 || test "$min_cmd_len" -gt "$func_len_result" \ 4979 || break 4980 _G_last_arg_opt_p=false 4981 ;; 4982 esac 4983 done 4984 4985 test $# -gt 0 && func_append func_truncate_cmd_result "..." 4986} 4987 4988 4989# func_gitignore_entries FILE... 4990# ------------------------------ 4991# Strip blank and comment lines to leave significant entries. 4992func_gitignore_entries () 4993{ 4994 $debug_cmd 4995 4996 $SED -e '/^#/d' -e '/^$/d' "$@" 4997} 4998 4999 5000# func_insert_if_absent STR FILE... 5001# --------------------------------- 5002# If $STR is not already on a line by itself in $FILE, insert it, at the 5003# start. Entries are inserted at the start of the ignore list to ensure 5004# existing entries starting with ! are not overridden. Such entries 5005# support whilelisting exceptions after a more generic blacklist pattern. 5006# sorting the new contents of the file and replacing $FILE with the result. 5007func_insert_if_absent () 5008{ 5009 $debug_cmd 5010 5011 str=$1 5012 shift 5013 5014 for file 5015 do 5016 test -f "$file" || touch "$file" 5017 5018 duplicate_entries=`func_gitignore_entries "$file" |sort |uniq -d` 5019 test -n "$duplicate_entries" \ 5020 && func_error "duplicate entries in $file: " $duplicate_entries 5021 5022 func_grep_q "^$str\$" "$file" \ 5023 || func_verbose "inserting '$str' into '$file'" 5024 5025 linesold=`func_gitignore_entries "$file" |wc -l` 5026 linesnew=`{ $ECHO "$str"; cat "$file"; } \ 5027 |func_gitignore_entries |sort -u |wc -l` 5028 test "$linesold" -eq "$linesnew" \ 5029 || { $SED "1i\\$nl$str$nl" "$file" >"$file"T && mv "$file"T "$file"; } \ 5030 || func_permissions_error "$file" 5031 done 5032} 5033 5034 5035# func_get_version APP 5036# -------------------- 5037# echo the version number (if any) of APP, which is looked up along your 5038# PATH. 5039func_get_version () 5040{ 5041 $debug_cmd 5042 5043 _G_app=$1 5044 5045 # Rather than uncomment the sed script in-situ, strip the comments 5046 # programatically before passing the result to $SED for evaluation. 5047 sed_get_version=`$ECHO '# extract version within line 5048 s|.*[v ]\{1,\}\([0-9]\{1,\}\.[.a-z0-9-]*\).*|\1| 5049 t done 5050 5051 # extract version at start of line 5052 s|^\([0-9]\{1,\}\.[.a-z0-9-]*\).*|\1| 5053 t done 5054 5055 d 5056 5057 :done 5058 # the following essentially does s|5.005|5.5| 5059 s|\.0*\([1-9]\)|.\1|g 5060 p 5061 q' \ 5062 |$SED '/^[ ]*#.*$/d'` 5063 5064 func_tool_version_output $_G_app >/dev/null 5065 _G_status=$? 5066 5067 test 0 -ne "$_G_status" \ 5068 || $_G_app --version 2>&1 |$SED -n "$sed_get_version" 5069 5070 (exit $_G_status) 5071} 5072 5073 5074# func_check_tool APP 5075# ------------------- 5076# Search PATH for an executable at APP. 5077func_check_tool () 5078{ 5079 $debug_cmd 5080 5081 func_check_tool_result= 5082 5083 case $1 in 5084 *[\\/]*) 5085 test -x "$1" && func_check_tool_result=$1 5086 ;; 5087 *) 5088 save_IFS=$IFS 5089 IFS=${PATH_SEPARATOR-:} 5090 for _G_check_tool_path in $PATH; do 5091 IFS=$save_IFS 5092 if test -x "$_G_check_tool_path/$1"; then 5093 func_check_tool_result=$_G_check_tool_path/$1 5094 break 5095 fi 5096 done 5097 IFS=$save_IFS 5098 ;; 5099 esac 5100} 5101 5102 5103# func_check_versions APP1 VER1 URL1 ...[APPN VERN URLN] 5104# ------------------------------------------------------ 5105func_check_versions () 5106{ 5107 $debug_cmd 5108 5109 func_check_versions_result=: 5110 5111 while test $# -gt 0; do 5112 _G_app=$1; shift 5113 _G_reqver=$1; shift 5114 _G_url=$1; shift 5115 5116 # Diagnose bad buildreq formatting. 5117 case $_G_url in 5118 [a-z]*://*) ;; # looks like a url 5119 *) func_fatal_error "\ 5120'$_G_url' from the buildreq table in 5121'bootstrap.conf' does not look like the URL for downloading 5122$_G_app. Please ensure that buildreq is a strict newline 5123delimited list of triples; 'program min-version url'." 5124 ;; 5125 esac 5126 5127 # Honor $APP variables ($TAR, $AUTOCONF, etc.) 5128 _G_appvar=`echo $_G_app |tr '[a-z]' '[A-Z]'` 5129 test TAR = "$_G_appvar" && _G_appvar=AMTAR 5130 eval "_G_app=\${$_G_appvar-$_G_app}" 5131 5132 # Fail if no version specified, but the program can't be found. 5133 if test x- = "x$_G_reqver"; then 5134 func_check_tool $_G_app 5135 if test -z "$func_check_tool_result"; then 5136 func_error "Prerequisite '$_G_app' not not found. Please install it, or 5137'export $_G_appvar=/path/to/$_G_app'." 5138 func_check_versions_result=false 5139 else 5140 func_verbose "found '$func_check_tool_result' for $_G_appvar." 5141 fi 5142 else 5143 _G_instver=`func_get_version $_G_app` 5144 5145 # Fail if --version didn't work. 5146 if test -z "$_G_instver"; then 5147 func_error "Prerequisite '$_G_app' not found. Please install it, or 5148'export $_G_appvar=/path/to/$_G_app'." 5149 func_check_versions_result=false 5150 5151 # Fail if a newer version than what we have is required. 5152 else 5153 func_verbose "found '$_G_app' version $_G_instver." 5154 5155 case $_G_reqver in 5156 =*) 5157 # If $buildreq version starts with '=', version must 5158 # match the installed program exactly. 5159 test "x$_G_reqver" = "x=$_G_instver" || { 5160 func_error "\ 5161 '$_G_app' version == $_G_instver is too old 5162 'exactly $_G_app-$_G_reqver is required" 5163 func_check_versions_result=false 5164 } 5165 ;; 5166 *) 5167 # Otherwise, anything that is not older is a match. 5168 func_lt_ver "$_G_reqver" "$_G_instver" || { 5169 func_error "\ 5170 '$_G_app' version == $_G_instver is too old 5171 '$_G_app' version >= $_G_reqver is required" 5172 func_check_versions_result=false 5173 } 5174 ;; 5175 esac 5176 fi 5177 fi 5178 done 5179} 5180 5181 5182# func_cleanup_gnulib 5183# ------------------- 5184# Recursively delete everything below the path in the global variable 5185# GNULIB_PATH. 5186func_cleanup_gnulib () 5187{ 5188 $debug_cmd 5189 5190 _G_status=$? 5191 $RM -fr "$gnulib_path" 5192 exit $_G_status 5193} 5194 5195 5196# func_download_po_files SUBDIR DOMAIN 5197# ------------------------------------ 5198func_download_po_files () 5199{ 5200 $debug_cmd 5201 5202 func_echo "getting translations into $1 for $2..." 5203 _G_cmd=`printf "$po_download_command_format" "$2" "$1"` 5204 eval "$_G_cmd" 5205} 5206 5207 5208# func_update_po_files PO_DIR DOMAIN 5209# ---------------------------------- 5210# Mirror .po files to $po_dir/.reference and copy only the new 5211# or modified ones into $po_dir. Also update $po_dir/LINGUAS. 5212# Note po files that exist locally only are left in $po_dir but will 5213# not be included in LINGUAS and hence will not be distributed. 5214func_update_po_files () 5215{ 5216 $debug_cmd 5217 5218 # Directory containing primary .po files. 5219 # Overwrite them only when we're sure a .po file is new. 5220 _G_po_dir=$1 5221 _G_domain=$2 5222 5223 # Mirror *.po files into this dir. 5224 # Usually contains *.s1 checksum files. 5225 _G_ref_po_dir=$_G_po_dir/.reference 5226 5227 test -d "$_G_ref_po_dir" || mkdir $_G_ref_po_dir || return 5228 func_download_po_files $_G_ref_po_dir $_G_domain \ 5229 && ls "$_G_ref_po_dir"/*.po 2>/dev/null \ 5230 |$SED -e 's|.*/||' -e 's|\.po$||' > "$_G_po_dir/LINGUAS" || return 5231 5232 # Find sha1sum, named gsha1sum on MacPorts, and shasum on MacOS 10.6+. 5233 func_find_tool SHA1SUM sha1sum gsha1sum shasum sha1 5234 5235 test -n "$SHA1SUM" || func_fatal_error "\ 5236Please install GNU Coreutils, or 'export SHA1SUM=/path/to/sha1sum'." 5237 5238 _G_langs=`cd $_G_ref_po_dir && echo *.po|$SED 's|\.po||g'` 5239 test '*' = "$_G_langs" && _G_langs=x 5240 for _G_po in $_G_langs; do 5241 case $_G_po in x) continue;; esac 5242 _G_new_po=$_G_ref_po_dir/$_G_po.po 5243 _G_cksum_file=$_G_ref_po_dir/$_G_po.s1 5244 if ! test -f "$_G_cksum_file" || 5245 ! test -f "$_G_po_dir/$_G_po.po" || 5246 ! $SHA1SUM -c "$_G_cksum_file" \ 5247 < "$_G_new_po" > /dev/null; then 5248 echo "updated $_G_po_dir/$_G_po.po..." 5249 cp "$_G_new_po" "$_G_po_dir/$_G_po.po" \ 5250 && $SHA1SUM < "$_G_new_po" > "$_G_cksum_file" || return 5251 fi 5252 done 5253} 5254 5255 5256 5257## --------------- ## 5258## Option parsing. ## 5259## --------------- ## 5260 5261# Hook in the functions to make sure our own options are parsed during 5262# the option parsing loop. 5263 5264usage='$progpath [OPTION]...' 5265 5266# Short help message in response to '-h'. Add to this in 'bootstrap.conf' 5267# if you accept any additional options. 5268usage_message="Common Bootstrap Options: 5269 -c, --copy copy files instead of creating symbolic links. 5270 --debug enable verbose shell tracing 5271 -n, --dry-run print commands rather than running them 5272 -f, --force attempt to bootstrap even if the sources seem not 5273 to have been checked out. 5274 --gnulib-srcdir=DIRNAME 5275 specify a local directory where gnulib sources 5276 reside. Use this if you already have the gnulib 5277 sources on your machine, and don't want to waste 5278 your bandwidth downloading them again. Defaults to 5279 \$GNULIB_SRCDIR. 5280 --no-warnings equivalent to '-Wnone' 5281 --skip-git do not fetch files from remote repositories 5282 --skip-po do not download po files. 5283 -v, --verbose verbosely report processing 5284 --version print version information and exit 5285 -W, --warnings=CATEGORY 5286 report the warnings falling in CATEGORY [all] 5287 -h, --help print short or long help message and exit 5288" 5289 5290# Additional text appended to 'usage_message' in response to '--help'. 5291long_help_message=$long_help_message" 5292 'recommend' show warnings about missing recommended packages 5293 'settings' show warnings about missing '$progname.conf' settings 5294 'upgrade' show warnings about out-dated files 5295 5296If the file '$progname.conf' exists in the same directory as this 5297script, its contents are read as shell variables to configure the 5298bootstrap. 5299 5300For build prerequisites, environment variables like \$AUTOCONF and 5301\$AMTAR are honored. 5302 5303Running without arguments will suffice in most cases. 5304" 5305 5306# Warning categories used by 'bootstrap', append others if you use them 5307# in your 'bootstrap.conf'. 5308warning_categories='recommend settings upgrade' 5309 5310 5311# bootstrap_options_prep [ARG]... 5312# ------------------------------- 5313# Preparation for options parsed by Bootstrap. 5314bootstrap_options_prep () 5315{ 5316 $debug_cmd 5317 5318 # Option defaults: 5319 opt_copy=${copy-'false'} 5320 opt_dry_run=false 5321 opt_force=false 5322 opt_gnulib_srcdir=$GNULIB_SRCDIR 5323 opt_skip_git=false 5324 opt_skip_po=false 5325 5326 # Pass back the list of options we consumed. 5327 func_quote eval ${1+"$@"} 5328 bootstrap_options_prep_result=$func_quote_result 5329} 5330func_add_hook func_options_prep bootstrap_options_prep 5331 5332 5333# bootstrap_parse_options [ARG]... 5334# -------------------------------- 5335# Provide handling for Bootstrap specific options. 5336bootstrap_parse_options () 5337{ 5338 $debug_cmd 5339 5340 # Perform our own loop to consume as many options as possible in 5341 # each iteration. 5342 while test $# -gt 0; do 5343 _G_opt=$1 5344 shift 5345 case $_G_opt in 5346 --dry-run|--dryrun|-n) 5347 opt_dry_run=: ;; 5348 --copy|-c) opt_copy=: ;; 5349 --force|-f) opt_force=: ;; 5350 5351 --gnulib-srcdir) 5352 test $# = 0 && func_missing_arg $_G_opt && break 5353 opt_gnulib_srcdir=$1 5354 shift 5355 ;; 5356 5357 --skip-git|--no-git) 5358 opt_skip_git=: 5359 ;; 5360 5361 --skip-po|--no-po) 5362 opt_skip_po=: 5363 ;; 5364 5365 # Separate non-argument short options: 5366 -c*|-f*|-n*) 5367 func_split_short_opt "$_G_opt" 5368 set dummy "$func_split_short_opt_name" \ 5369 "-$func_split_short_opt_arg" ${1+"$@"} 5370 shift 5371 ;; 5372 5373 *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; 5374 esac 5375 done 5376 5377 # save modified positional parameters for caller 5378 func_quote eval ${1+"$@"} 5379 bootstrap_parse_options_result=$func_quote_result 5380} 5381func_add_hook func_parse_options bootstrap_parse_options 5382 5383 5384# bootstrap_validate_options [ARG]... 5385# ----------------------------------- 5386# Perform any sanity checks on option settings and/or unconsumed 5387# arguments. 5388bootstrap_validate_options () 5389{ 5390 $debug_cmd 5391 5392 # Validate options. 5393 test $# -gt 0 \ 5394 && func_fatal_help "too many arguments" 5395 5396 # Pass back the (empty) list of unconsumed options. 5397 func_quote eval ${1+"$@"} 5398 bootstrap_validate_options_result=$func_quote_result 5399} 5400func_add_hook func_validate_options bootstrap_validate_options 5401 5402 5403## -------------------------------------------------- ## 5404## Source package customisations in 'bootstrap.conf'. ## 5405## -------------------------------------------------- ## 5406 5407# Override the default configuration, if necessary. 5408# Make sure that bootstrap.conf is sourced from the current directory 5409# if we were invoked as "sh bootstrap". 5410case $0 in 5411 */*) test -r "$0.conf" && . "$0.conf" ;; 5412 *) test -r "$0.conf" && . ./"$0.conf" ;; 5413esac 5414 5415 5416## ------------------------------- ## 5417## Actually perform the bootstrap. ## 5418## ------------------------------- ## 5419 5420func_bootstrap ${1+"$@"} 5421 5422# The End. 5423exit ${exit_status-$EXIT_SUCCESS} 5424 5425# Local variables: 5426# mode: shell-script 5427# sh-indentation: 2 5428# eval: (add-hook 'before-save-hook 'time-stamp) 5429# time-stamp-pattern: "500/scriptversion=%:y-%02m-%02d.%02H; # UTC" 5430# time-stamp-time-zone: "UTC" 5431# End: 5432