lib/m4sugar/m4sh.m4

   1 # This file is part of Autoconf.                          -*- Autoconf -*-
   2 # M4 sugar for common shell constructs.
   3 # Requires GNU M4 and M4sugar.
   4 #
   5 # Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   6 # Free Software Foundation, Inc.
   7 #
   8 # This program is free software: you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2, or (at your option)
  11 # any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 # 02110-1301, USA.
  22 #
  23 # As a special exception, the Free Software Foundation gives unlimited
  24 # permission to copy, distribute and modify the configure scripts that
  25 # are the output of Autoconf.  You need not follow the terms of the GNU
  26 # General Public License when using or distributing such scripts, even
  27 # though portions of the text of Autoconf appear in them.  The GNU
  28 # General Public License (GPL) does govern all other use of the material
  29 # that constitutes the Autoconf program.
  30 #
  31 # Certain portions of the Autoconf source text are designed to be copied
  32 # (in certain cases, depending on the input) into the output of
  33 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
  34 # source text consists of comments plus executable code that decides which
  35 # of the data portions to output in any given case.  We call these
  36 # comments and executable code the "non-data" portions.  Autoconf never
  37 # copies any of the non-data portions into its output.
  38 #
  39 # This special exception to the GPL applies to versions of Autoconf
  40 # released by the Free Software Foundation.  When you make and
  41 # distribute a modified version of Autoconf, you may extend this special
  42 # exception to the GPL to apply to your modified version as well, *unless*
  43 # your modified version has the potential to copy into its output some
  44 # of the text that was the non-data portion of the version that you started
  45 # with.  (In other words, unless your change moves or copies text from
  46 # the non-data portions to the data portions.)  If your modification has
  47 # such potential, you must delete any notice of this special exception
  48 # to the GPL from your modified version.
  49 #
  50 # Written by Akim Demaille, Pavel Roskin, Alexandre Oliva, Lars J. Aas
  51 # and many other people.
  52
  53
  54 # We heavily use m4's diversions both for the initializations and for
  55 # required macros, because in both cases we have to issue soon in
  56 # output something which is discovered late.
  57 #
  58 #
  59 # KILL is only used to suppress output.
  60 #
  61 # - BINSH
  62 #   AC_REQUIRE'd #! /bin/sh line
  63 # - HEADER-REVISION
  64 #   RCS keywords etc.
  65 # - HEADER-COMMENT
  66 #   Purpose of the script etc.
  67 # - HEADER-COPYRIGHT
  68 #   Copyright notice(s)
  69 # - M4SH-SANITIZE
  70 #   M4sh's shell setup
  71 # - M4SH-INIT-FN
  72 #   M4sh initialization (shell functions)
  73 # - M4SH-INIT
  74 #   M4sh initialization (detection code)
  75 # - BODY
  76 #   The body of the script.
  77
  78
  79 # _m4_divert(DIVERSION-NAME)
  80 # --------------------------
  81 # Convert a diversion name into its number.  Otherwise, return
  82 # DIVERSION-NAME which is supposed to be an actual diversion number.
  83 # Of course it would be nicer to use m4_case here, instead of zillions
  84 # of little macros, but it then takes twice longer to run `autoconf'!
  85 m4_define([_m4_divert(BINSH)],             0)
  86 m4_define([_m4_divert(HEADER-REVISION)],   1)
  87 m4_define([_m4_divert(HEADER-COMMENT)],    2)
  88 m4_define([_m4_divert(HEADER-COPYRIGHT)],  3)
  89 m4_define([_m4_divert(M4SH-SANITIZE)],     4)
  90 m4_define([_m4_divert(M4SH-INIT-FN)],      5)
  91 m4_define([_m4_divert(M4SH-INIT)],         6)
  92 m4_define([_m4_divert(BODY)],           1000)
  93
  94 # Aaarg.  Yet it starts with compatibility issues...  Libtool wants to
  95 # use NOTICE to insert its own LIBTOOL-INIT stuff.  People should ask
  96 # before diving into our internals :(
  97 m4_copy([_m4_divert(M4SH-INIT)], [_m4_divert(NOTICE)])
  98
  99
 100
 101 ## ------------------------- ##
 102 ## 1. Sanitizing the shell.  ##
 103 ## ------------------------- ##
 104 # Please maintain lexicographic sorting of this section, ignoring leading _.
 105
 106 # AS_BOURNE_COMPATIBLE
 107 # --------------------
 108 # Try to be as Bourne and/or POSIX as possible.
 109 #
 110 # This does not set BIN_SH, due to the problems described in
 111 # <http://lists.gnu.org/archive/html/autoconf-patches/2006-03/msg00081.html>.
 112 # People who need BIN_SH should set it in their environment before invoking
 113 # configure; apparently this would include UnixWare, as described in
 114 # <http://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00025.html>.
 115 m4_define([AS_BOURNE_COMPATIBLE],
 116 [# Be more Bourne compatible
 117 DUALCASE=1; export DUALCASE # for MKS sh
 118 _$0
 119 ])
 120
 121 # _AS_BOURNE_COMPATIBLE
 122 # ---------------------
 123 # This is the part of AS_BOURNE_COMPATIBLE which has to be repeated inside
 124 # each instance.
 125 m4_define([_AS_BOURNE_COMPATIBLE],
 126 [AS_IF([test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1],
 127  [emulate sh
 128   NULLCMD=:
 129   [#] Pre-4.2 versions of Zsh do word splitting on ${1+"$[@]"}, which
 130   # is contrary to our usage.  Disable this feature.
 131   alias -g '${1+"$[@]"}'='"$[@]"'
 132   setopt NO_GLOB_SUBST],
 133  [AS_CASE([`(set -o) 2>/dev/null`], [*posix*], [set -o posix])])
 134 ])
 135
 136
 137 # _AS_CLEANUP
 138 # -----------
 139 # Expanded as the last thing before m4sugar cleanup begins.  Macros
 140 # may append m4sh cleanup hooks to this as appropriate.
 141 m4_define([_AS_CLEANUP],
 142 [m4_divert_text([M4SH-SANITIZE], [_AS_DETECT_BETTER_SHELL])])
 143
 144
 145 # AS_COPYRIGHT(TEXT)
 146 # ------------------
 147 # Emit TEXT, a copyright notice, as a shell comment near the top of the
 148 # script.  TEXT is evaluated once; to accomplish that, we do not prepend
 149 # `# ' but `@%:@ '.
 150 m4_define([AS_COPYRIGHT],
 151 [m4_divert_text([HEADER-COPYRIGHT],
 152 [m4_bpatsubst([
 153 $1], [^], [@%:@ ])])])
 154
 155
 156 # _AS_DETECT_REQUIRED(TEST)
 157 # -------------------------
 158 # Refuse to execute under a shell that does not pass the given TEST.
 159 # Does not do AS_REQUIRE for the better-shell detection code.
 160 m4_defun([_AS_DETECT_REQUIRED],
 161 [m4_set_add([_AS_DETECT_REQUIRED_BODY],
 162            [($1) || AS_EXIT(1)
 163 ])])
 164
 165
 166 # _AS_DETECT_SUGGESTED(TEST)
 167 # --------------------------
 168 # Prefer to execute under a shell that passes the given TEST.
 169 # Does not do AS_REQUIRE for the better-shell detection code.
 170 m4_defun([_AS_DETECT_SUGGESTED],
 171 [m4_set_add([_AS_DETECT_SUGGESTED_BODY],
 172            [($1) || AS_EXIT(1)
 173 ])])
 174
 175
 176 # _AS_DETECT_BETTER_SHELL
 177 # -----------------------
 178 # The real workhorse for detecting a shell with the correct
 179 # features.
 180 #
 181 # In previous versions, we prepended /usr/posix/bin to the path, but that
 182 # caused a regression on OpenServer 6.0.0
 183 # <http://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00017.html>
 184 # and on HP-UX 11.11, see the failure of test 120 in
 185 # <http://lists.gnu.org/archive/html/bug-autoconf/2006-10/msg00003.html>
 186 #
 187 # FIXME: The code should test for the OSF bug described in
 188 # <http://lists.gnu.org/archive/html/autoconf-patches/2006-03/msg00081.html>.
 189 #
 190 m4_defun([_AS_DETECT_BETTER_SHELL],
 191 [if test "x$CONFIG_SHELL" = x; then
 192 dnl Remove any tests from suggested that are also required
 193   m4_set_foreach([_AS_DETECT_SUGGESTED_BODY], [AS_snippet],
 194                  [m4_set_contains([_AS_DETECT_REQUIRED_BODY],
 195                                   _m4_defn([AS_snippet]),
 196                                   [m4_set_remove([_AS_DETECT_SUGGESTED_BODY],
 197                                                  _m4_defn([AS_snippet]))])])dnl
 198   m4_set_empty([_AS_DETECT_REQUIRED_BODY], [as_have_required=yes],
 199     [as_bourne_compatible="AS_ESCAPE(m4_expand([_AS_BOURNE_COMPATIBLE]))"
 200     as_required="AS_ESCAPE(m4_expand(m4_set_contents([_AS_DETECT_REQUIRED_BODY])))"
 201     as_suggested="AS_ESCAPE(m4_expand(m4_set_contents([_AS_DETECT_SUGGESTED_BODY])))"
 202     AS_IF([_AS_RUN(["$as_required"])],
 203           [as_have_required=yes],
 204           [as_have_required=no])])
 205   AS_IF([test x$as_have_required = xyes && _AS_RUN(["$as_suggested"])],
 206     [],
 207     [as_candidate_shells=
 208     _AS_PATH_WALK([/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH],
 209       [case $as_dir in
 210          /*)
 211            for as_base in sh bash ksh sh5; do
 212              as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
 213            done;;
 214        esac])
 215
 216       for as_shell in $as_candidate_shells $SHELL; do
 217          # Try only shells that exist, to save several forks.
 218          AS_IF([{ test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 219                 _AS_RUN(["$as_required"], ["$as_shell"])],
 220                [CONFIG_SHELL=$as_shell
 221                as_have_required=yes
 222                m4_set_empty([_AS_DETECT_SUGGESTED_BODY], [break],
 223                  [AS_IF([_AS_RUN(["$as_suggested"], ["$as_shell"])], [break])])])
 224       done
 225
 226       AS_IF([test "x$CONFIG_SHELL" != x],
 227         [for as_var in BASH_ENV ENV
 228         do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
 229         done
 230         export CONFIG_SHELL
 231         exec "$CONFIG_SHELL" "$as_myself" ${1+"$[@]"}])
 232
 233     AS_IF([test x$as_have_required = xno],
 234       [echo This script requires a shell more modern than all the
 235       echo shells that I found on your system.  Please install a
 236       echo modern shell, or manually run the script under such a
 237       echo shell if you do have one.
 238       AS_EXIT(1)])
 239     ])
 240 fi
 241 ])# _AS_DETECT_BETTER_SHELL
 242
 243
 244 # _AS_PREPARE
 245 # -----------
 246 # This macro has a very special status.  Normal use of M4sh relies
 247 # heavily on AS_REQUIRE, so that needed initializations (such as
 248 # _AS_TEST_PREPARE) are performed on need, not on demand.  But
 249 # Autoconf is the first client of M4sh, and for two reasons: configure
 250 # and config.status.  Relying on AS_REQUIRE is of course fine for
 251 # configure, but fails for config.status (which is created by
 252 # configure).  So we need a means to force the inclusion of the
 253 # various _AS_PREPARE_* on top of config.status.  That's basically why
 254 # there are so many _AS_PREPARE_* below, and that's also why it is
 255 # important not to forget some: config.status needs them.
 256 m4_defun([_AS_PREPARE],
 257 [as_func_mkdir_p ()
 258 {
 259   _AS_MKDIR_P
 260 }
 261
 262 _AS_EXPR_PREPARE
 263 _AS_BASENAME_PREPARE
 264 _AS_DIRNAME_PREPARE
 265 _AS_ME_PREPARE
 266 _AS_LINENO_PREPARE
 267 _AS_ECHO_N_PREPARE[]dnl We do not need this ourselves but user code might.
 268 _AS_LN_S_PREPARE
 269 _AS_MKDIR_P_PREPARE
 270 _AS_TEST_PREPARE
 271 _AS_TR_CPP_PREPARE
 272 _AS_TR_SH_PREPARE
 273 ])
 274
 275 # AS_PREPARE
 276 # ----------
 277 # Output all the M4sh possible initialization into the initialization
 278 # diversion.  We do not use _AS_PREPARE so that the m4_provide symbols for
 279 # AS_REQUIRE and AS_REQUIRE_SHELL_FN are defined properly, and so that
 280 # shell functions are placed in M4SH-INIT-FN.
 281 m4_defun([AS_PREPARE],
 282 [AS_REQUIRE([_AS_EXPR_PREPARE])
 283 AS_REQUIRE([_AS_BASENAME_PREPARE])
 284 AS_REQUIRE([_AS_DIRNAME_PREPARE])
 285 AS_REQUIRE([_AS_ME_PREPARE])
 286 AS_REQUIRE([_AS_LINENO_PREPARE])
 287 AS_REQUIRE([_AS_ECHO_N_PREPARE])
 288 AS_REQUIRE([_AS_LN_S_PREPARE])
 289 AS_REQUIRE([_AS_MKDIR_P_PREPARE])
 290 AS_REQUIRE([_AS_TEST_PREPARE])
 291 AS_REQUIRE([_AS_TR_CPP_PREPARE])
 292 AS_REQUIRE([_AS_TR_SH_PREPARE])
 293 ])
 294
 295
 296 # AS_REQUIRE(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK],
 297 #            [DIVERSION = M4SH-INIT])
 298 # -----------------------------------------------------------
 299 # BODY-TO-EXPAND is some initialization which must be expanded in the
 300 # given diversion when expanded (required or not).  The expansion
 301 # goes in the named diversion or an earlier one.
 302 #
 303 m4_defun([AS_REQUIRE],
 304 [m4_define([_m4_divert_desired], [m4_default_quoted([$3], [M4SH-INIT])])dnl
 305 m4_if(m4_eval(_m4_divert(_m4_divert_dump) <= _m4_divert(_m4_divert_desired)), 1,
 306       [m4_require([$1], [$2])],
 307       [m4_divert_require([_m4_divert_desired], [$1], [$2])])])
 308
 309
 310 # AS_REQUIRE_SHELL_FN(NAME-TO-CHECK, BODY-TO-EXPAND,
 311 #                     [DIVERSION = M4SH-INIT-FN])
 312 # --------------------------------------------------
 313 # BODY-TO-EXPAND is the body of a shell function to be emitted in the
 314 # given diversion when expanded (required or not).  Unlike other
 315 # xx_REQUIRE macros, BODY-TO-EXPAND is mandatory.
 316 #
 317 m4_define([AS_REQUIRE_SHELL_FN],
 318 [_AS_DETECT_REQUIRED([_AS_SHELL_FN_WORK])dnl
 319 AS_REQUIRE([AS_SHELL_FN_$1], [m4_provide([AS_SHELL_FN_$1])$1 ()
 320 {
 321 $2
 322 }], m4_default_quoted([$3], [M4SH-INIT-FN]))])
 323
 324
 325 # _AS_RUN(TEST, [SHELL])
 326 # ----------------------
 327 # Run TEST under the current shell (if one parameter is used)
 328 # or under the given SHELL, protecting it from syntax errors.
 329 m4_define([_AS_RUN],
 330 [m4_ifval([$2], [{ $as_echo "$as_bourne_compatible"$1 | ($2); }],
 331                 [(eval $1)]) 2>/dev/null])
 332
 333
 334 # _AS_SHELL_FN_WORK
 335 # -----------------
 336 # This is a spy to detect "in the wild" shells that do not support shell
 337 # functions correctly.  It is based on the m4sh.at Autotest testcases.
 338 m4_define([_AS_SHELL_FN_WORK],
 339 [as_func_return ()
 340 {
 341   (exit [$]1)
 342 }
 343 as_func_success ()
 344 {
 345   as_func_return 0
 346 }
 347 as_func_failure ()
 348 {
 349   as_func_return 1
 350 }
 351 as_func_ret_success ()
 352 {
 353   return 0
 354 }
 355 as_func_ret_failure ()
 356 {
 357   return 1
 358 }
 359
 360 exitcode=0
 361 AS_IF([as_func_success], [],
 362   [exitcode=1
 363   echo as_func_success failed.])
 364 AS_IF([as_func_failure],
 365   [exitcode=1
 366   echo as_func_failure succeeded.])
 367 AS_IF([as_func_ret_success], [],
 368   [exitcode=1
 369   echo as_func_ret_success failed.])
 370 AS_IF([as_func_ret_failure],
 371   [exitcode=1
 372   echo as_func_ret_failure succeeded.])
 373 AS_IF([( set x; as_func_ret_success y && test x = "[$]1" )], [],
 374   [exitcode=1
 375   echo positional parameters were not saved.])
 376 test x$exitcode = x0[]dnl
 377 ])# _AS_SHELL_FN_WORK
 378
 379
 380 # _AS_SHELL_SANITIZE
 381 # ------------------
 382 # This is the prolog that is emitted by AS_INIT and AS_INIT_GENERATED.
 383 m4_defun([_AS_SHELL_SANITIZE],
 384 [## --------------------- ##
 385 ## M4sh Initialization.  ##
 386 ## --------------------- ##
 387
 388 AS_BOURNE_COMPATIBLE
 389
 390 # PATH needs CR
 391 _AS_CR_PREPARE
 392 _AS_ECHO_PREPARE
 393 _AS_PATH_SEPARATOR_PREPARE
 394 _AS_UNSET_PREPARE
 395
 396 # IFS
 397 # We need space, tab and new line, in precisely that order.  Quoting is
 398 # there to prevent editors from complaining about space-tab.
 399 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
 400 # splitting by setting IFS to empty value.)
 401 IFS=" ""        $as_nl"
 402
 403 # Find who we are.  Look in the path if we contain no directory separator.
 404 case $[0] in
 405   *[[\\/]]* ) as_myself=$[0] ;;
 406   *) _AS_PATH_WALK([],
 407                    [test -r "$as_dir/$[0]" && as_myself=$as_dir/$[0] && break])
 408      ;;
 409 esac
 410 # We did not find ourselves, most probably we were run as `sh COMMAND'
 411 # in which case we are not to be found in the path.
 412 if test "x$as_myself" = x; then
 413   as_myself=$[0]
 414 fi
 415 if test ! -f "$as_myself"; then
 416   AS_ECHO(["$as_myself: error: cannot find myself; rerun with an absolute file name"]) >&2
 417   AS_EXIT
 418 fi
 419
 420 # Work around bugs in pre-3.0 UWIN ksh.
 421 for as_var in ENV MAIL MAILPATH
 422 do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
 423 done
 424 PS1='$ '
 425 PS2='> '
 426 PS4='+ '
 427
 428 # NLS nuisances.
 429 LC_ALL=C
 430 export LC_ALL
 431 LANGUAGE=C
 432 export LANGUAGE
 433
 434 # CDPATH.
 435 $as_unset CDPATH
 436 ])# _AS_SHELL_SANITIZE
 437
 438
 439 # AS_SHELL_SANITIZE
 440 # -----------------
 441 # This is only needed for the sake of Libtool, which screws up royally
 442 # in its usage of M4sh internals.
 443 m4_define([AS_SHELL_SANITIZE],
 444 [_AS_SHELL_SANITIZE
 445 m4_provide_if([AS_INIT], [],
 446 [m4_provide([AS_INIT])
 447 _AS_DETECT_REQUIRED([_AS_SHELL_FN_WORK])
 448 _AS_DETECT_BETTER_SHELL
 449 ])])
 450
 451
 452 ## ----------------------------- ##
 453 ## 2. Wrappers around builtins.  ##
 454 ## ----------------------------- ##
 455
 456 # This section is lexicographically sorted.
 457
 458
 459 # AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT])
 460 # ----------------------------------------------------
 461 # Expand into
 462 # | case WORD in
 463 # | PATTERN1) IF-MATCHED1 ;;
 464 # | ...
 465 # | *) DEFAULT ;;
 466 # | esac
 467 m4_define([_AS_CASE],
 468 [  $1[)] m4_default([$2], [:]) ;;
 469 ])
 470 m4_define([_AS_CASE_DEFAULT],
 471 [  *[)] $1 ;;
 472 ])
 473 m4_defun([AS_CASE],
 474 [m4_ifval([$2$3],
 475 [case $1 in
 476 m4_transform_pair([_$0], [_$0_DEFAULT], m4_shift($@))dnl
 477 esac
 478 ])dnl
 479 ])# AS_CASE
 480
 481
 482 # AS_EXIT([EXIT-CODE = 1])
 483 # ------------------------
 484 # Exit and set exit code to EXIT-CODE in the way that it's seen
 485 # within "trap 0".
 486 #
 487 # We cannot simply use "exit N" because some shells (zsh and Solaris sh)
 488 # will not set $? to N while running the code set by "trap 0"
 489 # So we set $? by executing "exit N" in the subshell and then exit.
 490 # Other shells don't use `$?' as default for `exit', hence just repeating
 491 # the exit value can only help improving portability.
 492 m4_define([AS_EXIT],
 493 [{ (exit m4_default([$1], 1)); exit m4_default([$1], 1); }])
 494
 495
 496 # AS_IF(TEST1, [IF-TRUE1]...[IF-FALSE])
 497 # -------------------------------------
 498 # Expand into
 499 # | if TEST1; then
 500 # |   IF-TRUE1
 501 # | elif TEST2; then
 502 # |   IF-TRUE2
 503 # [...]
 504 # | else
 505 # |   IF-FALSE
 506 # | fi
 507 # with simplifications if IF-TRUE1 and/or IF-FALSE is empty.
 508 #
 509 m4_define([_AS_IF],
 510 [elif $1; then
 511   m4_default([$2], [:])
 512 ])
 513 m4_define([_AS_IF_ELSE],
 514 [m4_ifvaln([$1],
 515 [else
 516   $1])])
 517 m4_defun([AS_IF],
 518 [m4_ifval([$2$3],
 519 [if $1; then
 520   m4_default([$2], [:])
 521 m4_transform_pair([_$0], [_$0_ELSE], m4_shift2($@))dnl
 522 fi
 523 ])dnl
 524 ])# AS_IF
 525
 526
 527 # _AS_UNSET_PREPARE
 528 # -----------------
 529 # AS_UNSET depends upon $as_unset: compute it.
 530 # Use MAIL to trigger a bug in Bash 2.01;
 531 # the "|| exit" suppresses the resulting "Segmentation fault" message.
 532 # Avoid 'if ((', as that triggers a bug in pdksh 5.2.14.
 533 m4_defun([_AS_UNSET_PREPARE],
 534 [# Support unset when possible.
 535 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
 536   as_unset=unset
 537 else
 538   as_unset=false
 539 fi
 540 ])
 541
 542
 543 # AS_UNSET(VAR, [VALUE-IF-UNSET-NOT-SUPPORTED = `'])
 544 # --------------------------------------------------
 545 # Try to unset the env VAR, otherwise set it to
 546 # VALUE-IF-UNSET-NOT-SUPPORTED.  `as_unset' must have been computed.
 547 m4_defun([AS_UNSET],
 548 [AS_REQUIRE([_AS_UNSET_PREPARE])dnl
 549 $as_unset $1 || test "${$1+set}" != set || { $1=$2; export $1; }])
 550
 551
 552
 553
 554
 555
 556 ## ------------------------------------------ ##
 557 ## 3. Error and warnings at the shell level.  ##
 558 ## ------------------------------------------ ##
 559
 560 # If AS_MESSAGE_LOG_FD is defined, shell messages are duplicated there
 561 # too.
 562
 563
 564 # AS_ESCAPE(STRING, [CHARS = $"`\])
 565 # ---------------------------------
 566 # Escape the CHARS in STRING.
 567 #
 568 # Avoid the m4_bpatsubst if there are no interesting characters to escape.
 569 # _AS_ESCAPE bypasses argument defaulting.
 570 m4_define([AS_ESCAPE],
 571 [_$0([$1], m4_default([$2], [\"$`]))])
 572 m4_define([_AS_ESCAPE],
 573 [m4_if(m4_len([$1]),
 574        m4_len(m4_translit([[$1]], [$2])),
 575        [$1], [m4_bpatsubst([$1], [[$2]], [\\\&])])])
 576
 577
 578 # _AS_QUOTE_IFELSE(STRING, IF-MODERN-QUOTATION, IF-OLD-QUOTATION)
 579 # ---------------------------------------------------------------
 580 # Compatibility glue between the old AS_MSG suite which did not
 581 # quote anything, and the modern suite which quotes the quotes.
 582 # If STRING contains `\\' or `\$', it's modern.
 583 # If STRING contains `\"' or `\`', it's old.
 584 # Otherwise it's modern.
 585 #
 586 # Profiling shows that m4_index is 5 to 8x faster than m4_bregexp.  The
 587 # slower implementation used:
 588 # m4_bmatch([$1],
 589 #           [\\[\\$]], [$2],
 590 #           [\\[`"]], [$3],
 591 #           [$2])
 592 # The current implementation caters to the common case of no backslashes,
 593 # to minimize m4_index expansions (hence the nested if).
 594 m4_define([_AS_QUOTE_IFELSE],
 595 [m4_cond([m4_index([$1], [\])], [-1], [$2],
 596          [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2],
 597          [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2],
 598          [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3],
 599          [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3],
 600          [$2])])
 601
 602
 603 # _AS_QUOTE(STRING, [CHARS = `"])
 604 # -------------------------------
 605 # If there are quoted (via backslash) backquotes do nothing, else
 606 # backslash all the quotes.
 607 m4_define([_AS_QUOTE],
 608 [_AS_QUOTE_IFELSE([$1],
 609                   [_AS_ESCAPE([$1], m4_default([$2], [`""]))],
 610                   [m4_warn([obsolete],
 611            [back quotes and double quotes must not be escaped in: $1])dnl
 612 $1])])
 613
 614
 615 # _AS_ECHO_UNQUOTED(STRING, [FD = AS_MESSAGE_FD])
 616 # -----------------------------------------------
 617 # Perform shell expansions on STRING and echo the string to FD.
 618 m4_define([_AS_ECHO_UNQUOTED],
 619 [AS_ECHO(["$1"]) >&m4_default([$2], [AS_MESSAGE_FD])])
 620
 621
 622 # _AS_ECHO(STRING, [FD = AS_MESSAGE_FD])
 623 # --------------------------------------
 624 # Protect STRING from backquote expansion, echo the result to FD.
 625 m4_define([_AS_ECHO],
 626 [_AS_ECHO_UNQUOTED([_AS_QUOTE([$1])], [$2])])
 627
 628
 629 # _AS_ECHO_LOG(STRING)
 630 # --------------------
 631 # Log the string to AS_MESSAGE_LOG_FD.
 632 m4_define([_AS_ECHO_LOG],
 633 [AS_REQUIRE([_AS_LINENO_PREPARE])dnl
 634 _AS_ECHO([$as_me:${as_lineno-$LINENO}: $1], [AS_MESSAGE_LOG_FD])])
 635
 636
 637 # _AS_ECHO_N_PREPARE
 638 # ------------------
 639 # Check whether to use -n, \c, or newline-tab to separate
 640 # checking messages from result messages.
 641 # Don't try to cache, since the results of this macro are needed to
 642 # display the checking message.  In addition, caching something used once
 643 # has little interest.
 644 # Idea borrowed from dist 3.0.  Use `*c*,', not `*c,' because if `\c'
 645 # failed there is also a newline to match.
 646 m4_defun([_AS_ECHO_N_PREPARE],
 647 [ECHO_C= ECHO_N= ECHO_T=
 648 case `echo -n x` in
 649 -n*)
 650   case `echo 'x\c'` in
 651   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 652   *)   ECHO_C='\c';;
 653   esac;;
 654 *)
 655   ECHO_N='-n';;
 656 esac
 657 ])# _AS_ECHO_N_PREPARE
 658
 659
 660 # _AS_ECHO_N(STRING, [FD = AS_MESSAGE_FD])
 661 # ----------------------------------------
 662 # Same as _AS_ECHO, but echo doesn't return to a new line.
 663 m4_define([_AS_ECHO_N],
 664 [AS_ECHO_N(["_AS_QUOTE([$1])"]) >&m4_default([$2], [AS_MESSAGE_FD])])
 665
 666
 667 # AS_MESSAGE(STRING, [FD = AS_MESSAGE_FD])
 668 # ----------------------------------------
 669 m4_define([AS_MESSAGE],
 670 [AS_REQUIRE([_AS_ME_PREPARE])dnl
 671 m4_ifset([AS_MESSAGE_LOG_FD],
 672           [{ _AS_ECHO_LOG([$1])
 673 _AS_ECHO([$as_me: $1], [$2]);}],
 674           [_AS_ECHO([$as_me: $1], [$2])])[]dnl
 675 ])
 676
 677
 678 # AS_WARN(PROBLEM)
 679 # ----------------
 680 m4_define([AS_WARN],
 681 [AS_MESSAGE([WARNING: $1], [2])])# AS_WARN
 682
 683
 684 # AS_ERROR(ERROR, [EXIT-STATUS = 1])
 685 # ----------------------------------
 686 m4_define([AS_ERROR],
 687 [{ AS_MESSAGE([error: $1], [2])
 688    AS_EXIT([$2]); }[]dnl
 689 ])# AS_ERROR
 690
 691
 692
 693 # AS_LINENO_PUSH([LINENO])
 694 # ------------------------
 695 # If this is the outermost call to AS_LINENO_PUSH, make sure that
 696 # AS_MESSAGE will print LINENO as the line number.
 697 m4_defun([AS_LINENO_PUSH],
 698 [as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack])
 699
 700
 701 # AS_LINENO_POP([LINENO])
 702 # ------------------------
 703 # If this is call balances the outermost call to AS_LINENO_PUSH,
 704 # AS_MESSAGE will restart printing $LINENO as the line number.
 705 m4_defun([AS_LINENO_POP],
 706 [eval $as_lineno_stack; test "x$as_lineno_stack" = x && AS_UNSET([as_lineno])])
 707
 708
 709
 710 ## -------------------------------------- ##
 711 ## 4. Portable versions of common tools.  ##
 712 ## -------------------------------------- ##
 713
 714 # This section is lexicographically sorted.
 715
 716
 717 # AS_BASENAME(FILE-NAME)
 718 # ----------------------
 719 # Simulate the command 'basename FILE-NAME'.  Not all systems have basename.
 720 # Also see the comments for AS_DIRNAME.
 721
 722 m4_defun([_AS_BASENAME_EXPR],
 723 [$as_expr X/[]$1 : '.*/\([[^/][^/]*]\)/*$' \| \
 724          X[]$1 : 'X\(//\)$' \| \
 725          X[]$1 : 'X\(/\)' \| .])
 726
 727 m4_defun([_AS_BASENAME_SED],
 728 [AS_ECHO([X/[]$1]) |
 729     sed ['/^.*\/\([^/][^/]*\)\/*$/{
 730             s//\1/
 731             q
 732           }
 733           /^X\/\(\/\/\)$/{
 734             s//\1/
 735             q
 736           }
 737           /^X\/\(\/\).*/{
 738             s//\1/
 739             q
 740           }
 741           s/.*/./; q']])
 742
 743 m4_defun([AS_BASENAME],
 744 [AS_REQUIRE([_$0_PREPARE])dnl
 745 $as_basename -- $1 ||
 746 _AS_BASENAME_EXPR([$1]) 2>/dev/null ||
 747 _AS_BASENAME_SED([$1])])
 748
 749
 750 # _AS_BASENAME_PREPARE
 751 # --------------------
 752 # Avoid Solaris 9 /usr/ucb/basename, as `basename /' outputs an empty line.
 753 # Also, traditional basename mishandles --.  Require here _AS_EXPR_PREPARE,
 754 # to avoid problems when _AS_BASENAME is called from the M4SH-INIT diversion
 755 # (AS_REQUIRE is nowhere near being as sophisticated as AC_REQUIRE).
 756 m4_defun([_AS_BASENAME_PREPARE],
 757 [AS_REQUIRE([_AS_EXPR_PREPARE])dnl
 758 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 759   as_basename=basename
 760 else
 761   as_basename=false
 762 fi
 763 ])# _AS_BASENAME_PREPARE
 764
 765
 766 # AS_DIRNAME(FILE-NAME)
 767 # ---------------------
 768 # Simulate the command 'dirname FILE-NAME'.  Not all systems have dirname.
 769 # This macro must be usable from inside ` `.
 770 #
 771 # Prefer expr to echo|sed, since expr is usually faster and it handles
 772 # backslashes and newlines correctly.  However, older expr
 773 # implementations (e.g. SunOS 4 expr and Solaris 8 /usr/ucb/expr) have
 774 # a silly length limit that causes expr to fail if the matched
 775 # substring is longer than 120 bytes.  So fall back on echo|sed if
 776 # expr fails.
 777 m4_defun([_AS_DIRNAME_EXPR],
 778 [AS_REQUIRE([_AS_EXPR_PREPARE])dnl
 779 $as_expr X[]$1 : 'X\(.*[[^/]]\)//*[[^/][^/]]*/*$' \| \
 780          X[]$1 : 'X\(//\)[[^/]]' \| \
 781          X[]$1 : 'X\(//\)$' \| \
 782          X[]$1 : 'X\(/\)' \| .])
 783
 784 m4_defun([_AS_DIRNAME_SED],
 785 [AS_ECHO([X[]$1]) |
 786     sed ['/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 787             s//\1/
 788             q
 789           }
 790           /^X\(\/\/\)[^/].*/{
 791             s//\1/
 792             q
 793           }
 794           /^X\(\/\/\)$/{
 795             s//\1/
 796             q
 797           }
 798           /^X\(\/\).*/{
 799             s//\1/
 800             q
 801           }
 802           s/.*/./; q']])
 803
 804 m4_defun([AS_DIRNAME],
 805 [AS_REQUIRE([_$0_PREPARE])dnl
 806 $as_dirname -- $1 ||
 807 _AS_DIRNAME_EXPR([$1]) 2>/dev/null ||
 808 _AS_DIRNAME_SED([$1])])
 809
 810
 811 # _AS_DIRNAME_PREPARE
 812 # --------------------
 813 m4_defun([_AS_DIRNAME_PREPARE],
 814 [AS_REQUIRE([_AS_EXPR_PREPARE])dnl
 815 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 816   as_dirname=dirname
 817 else
 818   as_dirname=false
 819 fi
 820 ])# _AS_DIRNAME_PREPARE
 821
 822
 823 # AS_ECHO(WORD)
 824 # -------------
 825 # Output WORD followed by a newline.  WORD must be a single shell word
 826 # (typically a quoted string).  The bytes of WORD are output as-is, even
 827 # if it starts with "-" or contains "\".
 828 m4_defun([AS_ECHO],
 829 [AS_REQUIRE([_$0_PREPARE])dnl
 830 $as_echo $1])
 831
 832
 833 # AS_ECHO_N(WORD)
 834 # -------------
 835 # Like AS_ECHO(WORD), except do not output the trailing newline.
 836 m4_defun([AS_ECHO_N],
 837 [AS_REQUIRE([_AS_ECHO_PREPARE])dnl
 838 $as_echo_n $1])
 839
 840
 841 # _AS_ECHO_PREPARE
 842 # -----------------
 843 # Arrange for $as_echo 'FOO' to echo FOO without escape-interpretation;
 844 # and similarly for $as_echo_foo, which omits the trailing newline.
 845 # 'FOO' is an optional single argument; a missing FOO is treated as empty.
 846 m4_defun([_AS_ECHO_PREPARE],
 847 [[as_nl='
 848 '
 849 export as_nl
 850 # Printing a long string crashes Solaris 7 /usr/bin/printf.
 851 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
 852 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
 853 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
 854 if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
 855   as_echo='printf %s\n'
 856   as_echo_n='printf %s'
 857 else
 858   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
 859     as_echo_body='eval /usr/ucb/echo -n "$][1$as_nl"'
 860     as_echo_n='/usr/ucb/echo -n'
 861   else
 862     as_echo_body='eval expr "X$][1" : "X\\(.*\\)"'
 863     as_echo_n_body='eval
 864       arg=$][1;
 865       case $arg in
 866       *"$as_nl"*)
 867         expr "X$arg" : "X\\(.*\\)$as_nl";
 868         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
 869       esac;
 870       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
 871     '
 872     export as_echo_n_body
 873     as_echo_n='sh -c $as_echo_n_body as_echo'
 874   fi
 875   export as_echo_body
 876   as_echo='sh -c $as_echo_body as_echo'
 877 fi
 878 ]])# _AS_ECHO_PREPARE
 879
 880
 881 # AS_TEST_X
 882 # ---------
 883 # Check whether a file has executable or search permissions.
 884 m4_defun([AS_TEST_X],
 885 [AS_REQUIRE([_AS_TEST_PREPARE])dnl
 886 $as_test_x $1[]dnl
 887 ])# AS_TEST_X
 888
 889
 890 # AS_EXECUTABLE_P
 891 # ---------------
 892 # Check whether a file is a regular file that has executable permissions.
 893 m4_defun([AS_EXECUTABLE_P],
 894 [AS_REQUIRE([_AS_TEST_PREPARE])dnl
 895 { test -f $1 && AS_TEST_X([$1]); }dnl
 896 ])# AS_EXECUTABLE_P
 897
 898
 899 # _AS_EXPR_PREPARE
 900 # ----------------
 901 # QNX 4.25 expr computes and issue the right result but exits with failure.
 902 # Tru64 expr mishandles leading zeros in numeric strings.
 903 # Detect these flaws.
 904 m4_defun([_AS_EXPR_PREPARE],
 905 [if expr a : '\(a\)' >/dev/null 2>&1 &&
 906    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 907   as_expr=expr
 908 else
 909   as_expr=false
 910 fi
 911 ])# _AS_EXPR_PREPARE
 912
 913
 914 # _AS_ME_PREPARE
 915 # --------------
 916 # Define $as_me to the basename of the executable file's name.
 917 m4_defun([AS_ME_PREPARE], [AS_REQUIRE([_$0])])
 918 m4_defun([_AS_ME_PREPARE],
 919 [AS_REQUIRE([_AS_BASENAME_PREPARE])dnl
 920 as_me=`AS_BASENAME("$[0]")`
 921 ])
 922
 923 # _AS_LINENO_WORKS
 924 # ---------------
 925 # Succeed if the currently executing shell supports LINENO.
 926 # This macro does not expand to a single shell command, so be careful
 927 # when using it.  Surrounding the body of this macro with {} would
 928 # cause "bash -c '_ASLINENO_WORKS'" to fail (with Bash 2.05, anyway),
 929 # but that bug is irrelevant to our use of LINENO.
 930 m4_define([_AS_LINENO_WORKS],
 931 [
 932   as_lineno_1=$LINENO
 933   as_lineno_2=$LINENO
 934   test "x$as_lineno_1" != "x$as_lineno_2" &&
 935   test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2"])
 936
 937
 938 # _AS_LINENO_PREPARE
 939 # ------------------
 940 # If LINENO is not supported by the shell, produce a version of this
 941 # script where LINENO is hard coded.
 942 # Comparing LINENO against _oline_ is not a good solution, since in
 943 # the case of embedded executables (such as config.status within
 944 # configure) you'd compare LINENO wrt config.status vs. _oline_ wrt
 945 # configure.
 946 m4_defun([AS_LINENO_PREPARE], [AS_REQUIRE([_$0])])
 947 m4_defun([_AS_LINENO_PREPARE],
 948 [AS_REQUIRE([_AS_CR_PREPARE])dnl
 949 AS_REQUIRE([_AS_ME_PREPARE])dnl
 950 _AS_DETECT_SUGGESTED([_AS_LINENO_WORKS])dnl
 951 _AS_LINENO_WORKS || {
 952
 953   dnl Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 954   dnl uniformly replaced by the line number.  The first 'sed' inserts a
 955   dnl line-number line after each line using $LINENO; the second 'sed'
 956   dnl does the real work.  The second script uses 'N' to pair each
 957   dnl line-number line with the line containing $LINENO, and appends
 958   dnl trailing '-' during substitution so that $LINENO is not a special
 959   dnl case at line end.  (Raja R Harinath suggested sed '=', and Paul
 960   dnl Eggert wrote the scripts with optimization help from Paolo Bonzini).
 961   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 962   sed -n '
 963     p
 964     /[[$]]LINENO/=
 965   ' <$as_myself |
 966     sed '
 967       s/[[$]]LINENO.*/&-/
 968       t lineno
 969       b
 970       :lineno
 971       N
 972       :loop
 973       s/[[$]]LINENO\([[^'$as_cr_alnum'_]].*\n\)\(.*\)/\2\1\2/
 974       t loop
 975       s/-\n.*//
 976     ' >$as_me.lineno &&
 977   chmod +x "$as_me.lineno" ||
 978     AS_ERROR([cannot create $as_me.lineno; rerun with a POSIX shell])
 979
 980   # Don't try to exec as it changes $[0], causing all sort of problems
 981   # (the dirname of $[0] is not the place where we might find the
 982   # original and so on.  Autoconf is especially sensitive to this).
 983   . "./$as_me.lineno"
 984   # Exit status is that of the last command.
 985   exit
 986 }
 987 ])# _AS_LINENO_PREPARE
 988
 989
 990 # _AS_LN_S_PREPARE
 991 # ----------------
 992 # Don't use conftest.sym to avoid file name issues on DJGPP, where this
 993 # would yield conftest.sym.exe for DJGPP < 2.04.  And don't use `conftest'
 994 # as base name to avoid prohibiting concurrency (e.g., concurrent
 995 # config.statuses).  On read-only media, assume 'cp -p' and hope we
 996 # are just running --help anyway.
 997 m4_defun([_AS_LN_S_PREPARE],
 998 [rm -f conf$$ conf$$.exe conf$$.file
 999 if test -d conf$$.dir; then
1000   rm -f conf$$.dir/conf$$.file
1001 else
1002   rm -f conf$$.dir
1003   mkdir conf$$.dir 2>/dev/null
1004 fi
1005 if (echo >conf$$.file) 2>/dev/null; then
1006   if ln -s conf$$.file conf$$ 2>/dev/null; then
1007     as_ln_s='ln -s'
1008     # ... but there are two gotchas:
1009     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
1010     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
1011     # In both cases, we have to default to `cp -p'.
1012     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
1013       as_ln_s='cp -p'
1014   elif ln conf$$.file conf$$ 2>/dev/null; then
1015     as_ln_s=ln
1016   else
1017     as_ln_s='cp -p'
1018   fi
1019 else
1020   as_ln_s='cp -p'
1021 fi
1022 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
1023 rmdir conf$$.dir 2>/dev/null
1024 ])# _AS_LN_S_PREPARE
1025
1026
1027 # AS_LN_S(FILE, LINK)
1028 # -------------------
1029 # FIXME: Should we add the glue code to handle properly relative symlinks
1030 # simulated with `ln' or `cp'?
1031 m4_defun([AS_LN_S],
1032 [AS_REQUIRE([_AS_LN_S_PREPARE])dnl
1033 $as_ln_s $1 $2
1034 ])
1035
1036
1037 # _AS_MKDIR_P
1038 # -----------
1039 # Emit code that can be used to emulate `mkdir -p` with plain `mkdir';
1040 # the code assumes that "$as_dir" contains the directory to create.
1041 # $as_dir is normalized, so there is no need to worry about using --.
1042 m4_define([_AS_MKDIR_P],
1043 [case $as_dir in #(
1044   -*) as_dir=./$as_dir;;
1045   esac
1046   test -d "$as_dir" || eval $as_mkdir_p || {
1047     as_dirs=
1048     while :; do
1049       case $as_dir in #(
1050       *\'*) as_qdir=`AS_ECHO(["$as_dir"]) | sed "s/'/'\\\\\\\\''/g"`;; #'(
1051       *) as_qdir=$as_dir;;
1052       esac
1053       as_dirs="'$as_qdir' $as_dirs"
1054       as_dir=`AS_DIRNAME("$as_dir")`
1055       test -d "$as_dir" && break
1056     done
1057     test -z "$as_dirs" || eval "mkdir $as_dirs"
1058   } || test -d "$as_dir" || AS_ERROR([cannot create directory $as_dir])
1059 ])
1060
1061 # AS_MKDIR_P(DIR)
1062 # ---------------
1063 # Emulate `mkdir -p' with plain `mkdir' if needed.
1064 m4_define([AS_MKDIR_P],
1065 [AS_REQUIRE([_$0_PREPARE])dnl
1066 as_dir=$1; as_func_mkdir_p])# AS_MKDIR_P
1067
1068
1069 # _AS_MKDIR_P_PREPARE
1070 # -------------------
1071 m4_defun([_AS_MKDIR_P_PREPARE],
1072 [AS_REQUIRE_SHELL_FN([as_func_mkdir_p], [
1073   _AS_MKDIR_P
1074 ])
1075 if mkdir -p . 2>/dev/null; then
1076   as_mkdir_p='mkdir -p "$as_dir"'
1077 else
1078   test -d ./-p && rmdir ./-p
1079   as_mkdir_p=false
1080 fi
1081 ])# _AS_MKDIR_P_PREPARE
1082
1083
1084 # _AS_PATH_SEPARATOR_PREPARE
1085 # --------------------------
1086 # Compute the path separator.
1087 m4_defun([_AS_PATH_SEPARATOR_PREPARE],
1088 [# The user is always right.
1089 if test "${PATH_SEPARATOR+set}" != set; then
1090   PATH_SEPARATOR=:
1091   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
1092     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
1093       PATH_SEPARATOR=';'
1094   }
1095 fi
1096 ])# _AS_PATH_SEPARATOR_PREPARE
1097
1098
1099 # _AS_PATH_WALK([PATH = $PATH], BODY)
1100 # -----------------------------------
1101 # Walk through PATH running BODY for each `as_dir'.
1102 #
1103 # Still very private as its interface looks quite bad.
1104 #
1105 # `$as_dummy' forces splitting on constant user-supplied paths.
1106 # POSIX.2 field splitting is done only on the result of word
1107 # expansions, not on literal text.  This closes a longstanding sh security
1108 # hole.  Optimize it away when not needed, i.e., if there are no literal
1109 # path separators.
1110 m4_define([_AS_PATH_WALK],
1111 [AS_REQUIRE([_AS_PATH_SEPARATOR_PREPARE])dnl
1112 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1113 m4_bmatch([$1], [[:;]],
1114 [as_dummy="$1"
1115 for as_dir in $as_dummy],
1116 [for as_dir in m4_default([$1], [$PATH])])
1117 do
1118   IFS=$as_save_IFS
1119   test -z "$as_dir" && as_dir=.
1120   $2
1121 done
1122 IFS=$as_save_IFS
1123 ])
1124
1125
1126 # AS_SET_CATFILE(VAR, DIR-NAME, FILE-NAME)
1127 # ----------------------------------------
1128 # Set VAR to DIR-NAME/FILE-NAME.
1129 # Optimize the common case where $2 or $3 is '.'.
1130 m4_define([AS_SET_CATFILE],
1131 [case $2 in
1132 .) $1=$3;;
1133 *)
1134   case $3 in
1135   .) $1=$2;;
1136   [[\\/]]* | ?:[[\\/]]* ) $1=$3;;
1137   *) $1=$2/$3;;
1138   esac;;
1139 esac[]dnl
1140 ])# AS_SET_CATFILE
1141
1142
1143 # _AS_TEST_PREPARE
1144 # ----------------
1145 # Find out whether `test -x' works.  If not, prepare a substitute
1146 # that should work well enough for most scripts.
1147 #
1148 # Here are some of the problems with the substitute.
1149 # The 'ls' tests whether the owner, not the current user, can execute/search.
1150 # The eval means '*', '?', and '[' cause inadvertent file name globbing
1151 # after the 'eval', so jam together as many tokens as we can to minimize
1152 # the likelihood that the inadvertent globbing will actually do anything.
1153 # Luckily, this gorp is needed only on really ancient hosts.
1154 #
1155 m4_defun([_AS_TEST_PREPARE],
1156 [if test -x / >/dev/null 2>&1; then
1157   as_test_x='test -x'
1158 else
1159   if ls -dL / >/dev/null 2>&1; then
1160     as_ls_L_option=L
1161   else
1162     as_ls_L_option=
1163   fi
1164   as_test_x='
1165     eval sh -c '\''
1166       if test -d "$[]1"; then
1167         test -d "$[]1/.";
1168       else
1169         case $[]1 in
1170         -*)set "./$[]1";;
1171         esac;
1172         case `ls -ld'$as_ls_L_option' "$[]1" 2>/dev/null` in
1173         ???[[sx]]*):;;*)false;;esac;fi
1174     '\'' sh
1175   '
1176 fi
1177 dnl as_executable_p is present for backward compatibility with Libtool
1178 dnl 1.5.22, but it should go away at some point.
1179 as_executable_p=$as_test_x
1180 ])# _AS_TEST_PREPARE
1181
1182
1183
1184
1185 ## ------------------ ##
1186 ## 5. Common idioms.  ##
1187 ## ------------------ ##
1188
1189 # This section is lexicographically sorted.
1190
1191
1192 # AS_BOX(MESSAGE, [FRAME-CHARACTER = `-'])
1193 # ----------------------------------------
1194 # Output MESSAGE, a single line text, framed with FRAME-CHARACTER (which
1195 # must not be `/').
1196 m4_define([AS_BOX],
1197 [AS_LITERAL_IF([$1],
1198                [_AS_BOX_LITERAL($@)],
1199                [_AS_BOX_INDIR($@)])])
1200
1201
1202 # _AS_BOX_LITERAL(MESSAGE, [FRAME-CHARACTER = `-'])
1203 # -------------------------------------------------
1204 m4_define([_AS_BOX_LITERAL],
1205 [cat <<\_ASBOX
1206 m4_text_box($@)
1207 _ASBOX])
1208
1209
1210 # _AS_BOX_INDIR(MESSAGE, [FRAME-CHARACTER = `-'])
1211 # -----------------------------------------------
1212 m4_define([_AS_BOX_INDIR],
1213 [sed 'h;s/./m4_default([$2], [-])/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX
1214 @%:@@%:@ $1 @%:@@%:@
1215 _ASBOX])
1216
1217
1218 # AS_HELP_STRING(LHS, RHS, [INDENT-COLUMN = 26], [WRAP-COLUMN = 79])
1219 # ------------------------------------------------------------------
1220 #
1221 # Format a help string so that it looks pretty when the user executes
1222 # "script --help".  This macro takes up to four arguments, a
1223 # "left hand side" (LHS), a "right hand side" (RHS), a decimal
1224 # INDENT-COLUMN which is the column where wrapped lines should begin
1225 # (the default of 26 is recommended), and a decimal WRAP-COLUMN which is
1226 # the column where lines should wrap (the default of 79 is recommended).
1227 # LHS is expanded, RHS is not.
1228 #
1229 # For backwards compatibility not documented in the manual, INDENT-COLUMN
1230 # can also be specified as a string of white spaces, whose width
1231 # determines the indentation column.  Using TABs in INDENT-COLUMN is not
1232 # recommended, since screen width of TAB is not computed.
1233 #
1234 # The resulting string is suitable for use in other macros that require
1235 # a help string (e.g. AC_ARG_WITH).
1236 #
1237 # Here is the sample string from the Autoconf manual (Node: External
1238 # Software) which shows the proper spacing for help strings.
1239 #
1240 #    --with-readline         support fancy command line editing
1241 #  ^ ^                       ^
1242 #  | |                       |
1243 #  | column 2                column 26
1244 #  |
1245 #  column 0
1246 #
1247 # A help string is made up of a "left hand side" (LHS) and a "right
1248 # hand side" (RHS).  In the example above, the LHS is
1249 # "--with-readline", while the RHS is "support fancy command line
1250 # editing".
1251 #
1252 # If the LHS contains more than (INDENT-COLUMN - 3) characters, then the
1253 # LHS is terminated with a newline so that the RHS starts on a line of its
1254 # own beginning at INDENT-COLUMN.  In the default case, this corresponds to an
1255 # LHS with more than 23 characters.
1256 #
1257 # Therefore, in the example, if the LHS were instead
1258 # "--with-readline-blah-blah-blah", then the AS_HELP_STRING macro would
1259 # expand into:
1260 #
1261 #
1262 #    --with-readline-blah-blah-blah
1263 #  ^ ^                       support fancy command line editing
1264 #  | |                       ^
1265 #  | column 2                |
1266 #  column 0                  column 26
1267 #
1268 #
1269 # m4_text_wrap hacks^Wworks around the fact that m4_format does not
1270 # know quadrigraphs.
1271 #
1272 m4_define([AS_HELP_STRING],
1273 [m4_text_wrap([$2], m4_cond([[$3]], [], [                          ],
1274                             [m4_eval([$3]+0)], [0], [[$3]],
1275                             [m4_format([[%*s]], [$3], [])]),
1276               m4_expand([  $1 ]), [$4])dnl
1277 ])# AS_HELP_STRING
1278
1279
1280 # AS_IDENTIFIER_IF(EXPRESSION, IF-IDENT, IF-NOT-IDENT)
1281 # ----------------------------------------------------
1282 # If EXPRESSION serves as an identifier (ie, after removal of @&t@, it
1283 # matches the regex `^[a-zA-Z_][a-zA-Z_0-9]*$'), execute IF-IDENT,
1284 # otherwise IF-NOT-IDENT.
1285 #
1286 # This is generally faster than the alternative:
1287 #   m4_bmatch(m4_bpatsubst([[$1]], [@&t@]), ^m4_defn([m4_re_word])$,
1288 #             [$2], [$3])
1289 #
1290 # Rather than expand m4_defn every time AS_IDENTIFIER_IF is expanded, we
1291 # inline its expansion up front.  Only use a regular expression if we
1292 # detect a potential quadrigraph.
1293 #
1294 # First, check if the entire string matches m4_cr_symbol2.  Only then do
1295 # we worry if the first character also matches m4_cr_symbol1 (ie. does not
1296 # match m4_cr_digit).
1297 m4_define([AS_IDENTIFIER_IF],
1298 [m4_if(m4_index([$1], [@]), [-1],
1299        [_$0($@)],
1300        [_$0(m4_bpatsubst([[$1]], [@&t@]), [$2], [$3])])])
1301 m4_define([_AS_IDENTIFIER_IF],
1302 [m4_cond([[$1]], [], [$3],
1303          [m4_eval(m4_len(m4_translit([[$1]], ]]dnl
1304 m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[)) > 0)], [1], [$3],
1305          [m4_len(m4_translit(m4_format([[%.1s]], [$1]), ]]dnl
1306 m4_dquote(m4_dquote(m4_defn([m4_cr_symbols1])))[[))], [0], [$2], [$3])])
1307
1308
1309 # AS_LITERAL_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL)
1310 # -----------------------------------------------------
1311 # If EXPRESSION has shell indirections ($var or `expr`), expand
1312 # IF-INDIR, else IF-NOT-INDIR.
1313 # This is an *approximation*: for instance EXPRESSION = `\$' is
1314 # definitely a literal, but will not be recognized as such.
1315 #
1316 # Why do we reject EXPRESSION expanding with `[' or `]' as a literal?
1317 # Because AS_TR_SH is MUCH faster if it can use m4_translit on literals
1318 # instead of m4_bpatsubst; but m4_translit is much tougher to do safely
1319 # if `[' is translated.
1320 #
1321 # Note that the quadrigraph @S|@ can result in non-literals, but outright
1322 # rejecting all @ would make AC_INIT complain on its bug report address.
1323 #
1324 # We used to use m4_bmatch(m4_quote($1), [[`$]], [$3], [$2]), but
1325 # profiling shows that it is faster to use m4_translit.
1326 #
1327 # Because the translit is stripping quotes, it must also neutralize anything
1328 # that might be in a macro name, as well as comments and commas.  All the
1329 # problem characters are unified so that a single m4_index can scan the
1330 # result.
1331 #
1332 # Rather than expand m4_defn every time AS_LITERAL_IF is expanded, we
1333 # inline its expansion up front.
1334 m4_define([AS_LITERAL_IF],
1335 [m4_cond([m4_eval(m4_index(m4_quote($1), [@S|@]) == -1)], [0], [$3],
1336          [m4_index(m4_translit(m4_quote($1),
1337                                [[]`,#]]]dnl
1338 m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[,
1339                                [$$$]),
1340                    [$])], [-1], [$2],
1341          [$3])])
1342
1343
1344 # AS_TMPDIR(PREFIX, [DIRECTORY = $TMPDIR [= /tmp]])
1345 # -------------------------------------------------
1346 # Create as safely as possible a temporary directory in DIRECTORY
1347 # which name is inspired by PREFIX (should be 2-4 chars max).
1348 m4_define([AS_TMPDIR],
1349 [AS_REQUIRE([_AS_ME_PREPARE])dnl
1350 # Create a (secure) tmp directory for tmp files.
1351 m4_if([$2], [], [: ${TMPDIR=/tmp}])
1352 {
1353   tmp=`(umask 077 && mktemp -d "m4_default([$2], [$TMPDIR])/$1XXXXXX") 2>/dev/null` &&
1354   test -n "$tmp" && test -d "$tmp"
1355 }  ||
1356 {
1357   tmp=m4_default([$2], [$TMPDIR])/$1$$-$RANDOM
1358   (umask 077 && mkdir "$tmp")
1359 } || AS_ERROR([cannot create a temporary directory in m4_default([$2], [$TMPDIR])])dnl
1360 ])# AS_TMPDIR
1361
1362
1363 # AS_UNAME
1364 # --------
1365 # Try to describe this machine.  Meant for logs.
1366 m4_define([AS_UNAME],
1367 [{
1368 cat <<_ASUNAME
1369 m4_text_box([Platform.])
1370
1371 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1372 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1373 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1374 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1375 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1376
1377 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1378 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1379
1380 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1381 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1382 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1383 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
1384 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1385 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1386 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1387
1388 _ASUNAME
1389
1390 _AS_PATH_WALK([$PATH], [AS_ECHO(["PATH: $as_dir"])])
1391 }])
1392
1393
1394 # _AS_VERSION_COMPARE_PREPARE
1395 # ---------------------------
1396 # Output variables for comparing version numbers.
1397 m4_defun([_AS_VERSION_COMPARE_PREPARE],
1398 [[as_awk_strverscmp='
1399   # Use only awk features that work with 7th edition Unix awk (1978).
1400   # My, what an old awk you have, Mr. Solaris!
1401   END {
1402     while (length(v1) && length(v2)) {
1403       # Set d1 to be the next thing to compare from v1, and likewise for d2.
1404       # Normally this is a single character, but if v1 and v2 contain digits,
1405       # compare them as integers and fractions as strverscmp does.
1406       if (v1 ~ /^[0-9]/ && v2 ~ /^[0-9]/) {
1407         # Split v1 and v2 into their leading digit string components d1 and d2,
1408         # and advance v1 and v2 past the leading digit strings.
1409         for (len1 = 1; substr(v1, len1 + 1) ~ /^[0-9]/; len1++) continue
1410         for (len2 = 1; substr(v2, len2 + 1) ~ /^[0-9]/; len2++) continue
1411         d1 = substr(v1, 1, len1); v1 = substr(v1, len1 + 1)
1412         d2 = substr(v2, 1, len2); v2 = substr(v2, len2 + 1)
1413         if (d1 ~ /^0/) {
1414           if (d2 ~ /^0/) {
1415             # Compare two fractions.
1416             while (d1 ~ /^0/ && d2 ~ /^0/) {
1417               d1 = substr(d1, 2); len1--
1418               d2 = substr(d2, 2); len2--
1419             }
1420             if (len1 != len2 && ! (len1 && len2 && substr(d1, 1, 1) == substr(d2, 1, 1))) {
1421               # The two components differ in length, and the common prefix
1422               # contains only leading zeros.  Consider the longer to be less.
1423               d1 = -len1
1424               d2 = -len2
1425             } else {
1426               # Otherwise, compare as strings.
1427               d1 = "x" d1
1428               d2 = "x" d2
1429             }
1430           } else {
1431             # A fraction is less than an integer.
1432             exit 1
1433           }
1434         } else {
1435           if (d2 ~ /^0/) {
1436             # An integer is greater than a fraction.
1437             exit 2
1438           } else {
1439             # Compare two integers.
1440             d1 += 0
1441             d2 += 0
1442           }
1443         }
1444       } else {
1445         # The normal case, without worrying about digits.
1446         d1 = substr(v1, 1, 1); v1 = substr(v1, 2)
1447         d2 = substr(v2, 1, 1); v2 = substr(v2, 2)
1448       }
1449       if (d1 < d2) exit 1
1450       if (d1 > d2) exit 2
1451     }
1452     # Beware Solaris /usr/xgp4/bin/awk (at least through Solaris 10),
1453     # which mishandles some comparisons of empty strings to integers.
1454     if (length(v2)) exit 1
1455     if (length(v1)) exit 2
1456   }
1457 ']])# _AS_VERSION_COMPARE_PREPARE
1458
1459
1460 # AS_VERSION_COMPARE(VERSION-1, VERSION-2,
1461 #                    [ACTION-IF-LESS], [ACTION-IF-EQUAL], [ACTION-IF-GREATER])
1462 # -----------------------------------------------------------------------------
1463 # Compare two strings possibly containing shell variables as version strings.
1464 m4_defun([AS_VERSION_COMPARE],
1465 [AS_REQUIRE([_$0_PREPARE])dnl
1466 as_arg_v1=$1
1467 as_arg_v2=$2
1468 dnl This usage is portable even to ancient awk,
1469 dnl so don't worry about finding a "nice" awk version.
1470 awk "$as_awk_strverscmp" v1="$as_arg_v1" v2="$as_arg_v2" /dev/null
1471 case $? in
1472 1) $3;;
1473 0) $4;;
1474 2) $5;;
1475 esac[]dnl
1476 ])# _AS_VERSION_COMPARE
1477
1478
1479
1480 ## ------------------------------------ ##
1481 ## Common m4/sh character translation.  ##
1482 ## ------------------------------------ ##
1483
1484 # The point of this section is to provide high level macros comparable
1485 # to m4's `translit' primitive, but m4/sh polymorphic.
1486 # Transliteration of literal strings should be handled by m4, while
1487 # shell variables' content will be translated at runtime (tr or sed).
1488
1489
1490 # _AS_CR_PREPARE
1491 # --------------
1492 # Output variables defining common character ranges.
1493 # See m4_cr_letters etc.
1494 m4_defun([_AS_CR_PREPARE],
1495 [# Avoid depending upon Character Ranges.
1496 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
1497 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
1498 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
1499 as_cr_digits='0123456789'
1500 as_cr_alnum=$as_cr_Letters$as_cr_digits
1501 ])
1502
1503
1504 # _AS_TR_SH_PREPARE
1505 # -----------------
1506 m4_defun([_AS_TR_SH_PREPARE],
1507 [AS_REQUIRE([_AS_CR_PREPARE])dnl
1508 # Sed expression to map a string onto a valid variable name.
1509 as_tr_sh="eval sed 'y%*+%pp%;s%[[^_$as_cr_alnum]]%_%g'"
1510 ])
1511
1512
1513 # AS_TR_SH(EXPRESSION)
1514 # --------------------
1515 # Transform EXPRESSION into a valid shell variable name.
1516 # sh/m4 polymorphic.
1517 # Be sure to update the definition of `$as_tr_sh' if you change this.
1518 #
1519 # AS_LITERAL_IF guarantees that a literal does not have any nested quotes,
1520 # once $1 is expanded.  m4_translit silently uses only the first occurrence
1521 # of a character that appears multiple times in argument 2, since we know
1522 # that m4_cr_not_symbols2 also contains [ and ].  m4_translit also silently
1523 # ignores characters in argument 3 that do not match argument 2; we use this
1524 # fact to skip worrying about the length of m4_cr_not_symbols2.
1525 #
1526 # For speed, we inline the literal definitions that can be computed up front.
1527 m4_defun([AS_TR_SH],
1528 [AS_REQUIRE([_$0_PREPARE])dnl
1529 AS_LITERAL_IF([$1],
1530               [m4_translit([$1], [*+[]]]]dnl
1531 m4_dquote(m4_dquote(m4_defn([m4_cr_not_symbols2])))[[,
1532                                  [pp[]]]]dnl
1533 m4_dquote(m4_dquote(m4_for(,1,255,,[[_]])))[[)],
1534               [`AS_ECHO(["$1"]) | $as_tr_sh`])])
1535
1536
1537 # _AS_TR_CPP_PREPARE
1538 # ------------------
1539 m4_defun([_AS_TR_CPP_PREPARE],
1540 [AS_REQUIRE([_AS_CR_PREPARE])dnl
1541 # Sed expression to map a string onto a valid CPP name.
1542 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[[^_$as_cr_alnum]]%_%g'"
1543 ])
1544
1545
1546 # AS_TR_CPP(EXPRESSION)
1547 # ---------------------
1548 # Map EXPRESSION to an upper case string which is valid as rhs for a
1549 # `#define'.  sh/m4 polymorphic.  Be sure to update the definition
1550 # of `$as_tr_cpp' if you change this.
1551 #
1552 # See implementation comments in AS_TR_SH.
1553 m4_defun([AS_TR_CPP],
1554 [AS_REQUIRE([_$0_PREPARE])dnl
1555 AS_LITERAL_IF([$1],
1556               [m4_translit([$1], [*[]]]]dnl
1557 m4_dquote(m4_dquote(m4_defn([m4_cr_letters])m4_defn([m4_cr_not_symbols2])))[[,
1558                                  [P[]]]]dnl
1559 m4_dquote(m4_dquote(m4_defn([m4_cr_LETTERS])m4_for(,1,255,,[[_]])))[[)],
1560               [`AS_ECHO(["$1"]) | $as_tr_cpp`])])
1561
1562
1563 # _AS_TR_PREPARE
1564 # --------------
1565 m4_defun([_AS_TR_PREPARE],
1566 [AS_REQUIRE([_AS_TR_SH_PREPARE])dnl
1567 AS_REQUIRE([_AS_TR_CPP_PREPARE])dnl
1568 ])
1569
1570
1571
1572
1573 ## --------------------------------------------------- ##
1574 ## Common m4/sh handling of variables (indirections).  ##
1575 ## --------------------------------------------------- ##
1576
1577
1578 # The purpose of this section is to provide a uniform API for
1579 # reading/setting sh variables with or without indirection.
1580 # Typically, one can write
1581 #   AS_VAR_SET(var, val)
1582 # or
1583 #   AS_VAR_SET(as_$var, val)
1584 # and expect the right thing to happen.
1585
1586
1587 # AS_VAR_SET(VARIABLE, VALUE)
1588 # ---------------------------
1589 # Set the VALUE of the shell VARIABLE.
1590 # If the variable contains indirections (e.g. `ac_cv_func_$ac_func')
1591 # perform whenever possible at m4 level, otherwise sh level.
1592 m4_define([AS_VAR_SET],
1593 [AS_LITERAL_IF([$1],
1594                [$1=$2],
1595                [eval "$1=AS_ESCAPE([$2])"])])
1596
1597
1598 # AS_VAR_GET(VARIABLE)
1599 # --------------------
1600 # Get the value of the shell VARIABLE.
1601 # Evaluates to $VARIABLE if there are no indirection in VARIABLE,
1602 # else into the appropriate `eval' sequence.
1603 # FIXME: This mishandles values that end in newlines.
1604 # Fixing this will require changing the API.
1605 m4_define([AS_VAR_GET],
1606 [AS_LITERAL_IF([$1],
1607                [$$1],
1608                [`eval 'as_val=${'m4_bpatsubst([$1], [[\\`]], [\\\&])'}
1609                  AS_ECHO(["$as_val"])'`])])
1610
1611
1612 # AS_VAR_TEST_SET(VARIABLE)
1613 # -------------------------
1614 # Expands into the `test' expression which is true if VARIABLE
1615 # is set.  Polymorphic.  Should be dnl'ed.
1616 m4_define([AS_VAR_TEST_SET],
1617 [AS_LITERAL_IF([$1],
1618                [test "${$1+set}" = set],
1619                [{ as_var=$1; eval "test \"\${$as_var+set}\" = set"; }])])
1620
1621
1622 # AS_VAR_SET_IF(VARIABLE, IF-TRUE, IF-FALSE)
1623 # ------------------------------------------
1624 # Implement a shell `if-then-else' depending whether VARIABLE is set
1625 # or not.  Polymorphic.
1626 m4_define([AS_VAR_SET_IF],
1627 [AS_IF([AS_VAR_TEST_SET([$1])], [$2], [$3])])
1628
1629
1630 # AS_VAR_IF(VARIABLE, VALUE, IF-TRUE, IF-FALSE)
1631 # ---------------------------------------------
1632 # Implement a shell `if test $VARIABLE = VALUE; then-else'.
1633 # Polymorphic, and avoids sh expansion error upon interrupt or term signal.
1634 m4_define([AS_VAR_IF],
1635 [AS_LITERAL_IF([$1],
1636   [AS_IF([test "x$$1" = x""$2], [$3], [$4])],
1637   [as_val=AS_VAR_GET([$1])
1638    AS_IF([test "x$as_val" = x""$2], [$3], [$4])])])
1639
1640
1641 # AS_VAR_PUSHDEF and AS_VAR_POPDEF
1642 # --------------------------------
1643 #
1644
1645 # Sometimes we may have to handle literals (e.g. `stdlib.h'), while at
1646 # other moments, the same code may have to get the value from a
1647 # variable (e.g., `ac_header').  To have a uniform handling of both
1648 # cases, when a new value is about to be processed, declare a local
1649 # variable, e.g.:
1650 #
1651 #   AS_VAR_PUSHDEF([header], [ac_cv_header_$1])
1652 #
1653 # and then in the body of the macro, use `header' as is.  It is of
1654 # first importance to use `AS_VAR_*' to access this variable.  Don't
1655 # quote its name: it must be used right away by m4.
1656 #
1657 # If the value `$1' was a literal (e.g. `stdlib.h'), then `header' is
1658 # in fact the value `ac_cv_header_stdlib_h'.  If `$1' was indirect,
1659 # then `header's value in m4 is in fact `$as_header', the shell
1660 # variable that holds all of the magic to get the expansion right.
1661 #
1662 # At the end of the block, free the variable with
1663 #
1664 #   AS_VAR_POPDEF([header])
1665
1666
1667 # AS_VAR_PUSHDEF(VARNAME, VALUE)
1668 # ------------------------------
1669 # Define the m4 macro VARNAME to an accessor to the shell variable
1670 # named VALUE.  VALUE does not need to be a valid shell variable name:
1671 # the transliteration is handled here.  To be dnl'ed.
1672 m4_define([AS_VAR_PUSHDEF],
1673 [AS_LITERAL_IF([$2],
1674                [m4_pushdef([$1], [AS_TR_SH($2)])],
1675                [as_$1=AS_TR_SH($2)
1676 m4_pushdef([$1], [$as_[$1]])])])
1677
1678
1679 # AS_VAR_POPDEF(VARNAME)
1680 # ----------------------
1681 # Free the shell variable accessor VARNAME.  To be dnl'ed.
1682 m4_define([AS_VAR_POPDEF],
1683 [m4_popdef([$1])])
1684
1685
1686 ## ----------------- ##
1687 ## Setting M4sh up.  ##
1688 ## ----------------- ##
1689
1690
1691 # AS_INIT_GENERATED
1692 # -----------------
1693 # Emit m4sh initialization code in a suitable form for a quoted
1694 # here document.  Does not emit the `#!' sequence, which should be
1695 # generated with `#! $SHELL'; see the manual or autoconf/status.m4
1696 # for more detail.
1697 m4_defun([AS_INIT_GENERATED],
1698 [m4_require([AS_PREPARE])dnl
1699 _AS_SHELL_SANITIZE
1700 _AS_PREPARE])
1701
1702 # AS_INIT
1703 # -------
1704 # Initialize m4sh.
1705 m4_define([AS_INIT],
1706 [# Wrap our cleanup prior to m4sugar's cleanup.
1707 m4_wrap([_AS_CLEANUP])
1708 m4_init
1709 m4_provide([AS_INIT])
1710
1711 # Forbidden tokens and exceptions.
1712 m4_pattern_forbid([^_?AS_])
1713
1714 # Bangshe and minimal initialization.
1715 m4_divert_text([BINSH], [@%:@! /bin/sh])
1716 m4_divert_text([HEADER-COMMENT],
1717                [@%:@ Generated from __file__ by m4_PACKAGE_STRING.])
1718 m4_divert_text([M4SH-SANITIZE], [_AS_SHELL_SANITIZE])
1719
1720 # Let's go!
1721 m4_divert_pop([KILL])[]dnl
1722 m4_divert_push([BODY])[]dnl
1723 ])