~ubuntu-branches/ubuntu/lucid/mew-beta/lucid

« back to all changes in this revision

Viewing changes to bin/configure

  • Committer: Bazaar Package Importer
  • Author(s): Tatsuya Kinoshita
  • Date: 2006-10-31 22:07:48 UTC
  • mfrom: (1.1.6 upstream) (2.1.2 etch)
  • Revision ID: james.westby@ubuntu.com-20061031220748-iq1bg528g9nt2l57
Tags: 5.1.52~0.20061031-1
New upstream release. (CVS trunk on 2006-10-31)

Show diffs side-by-side

added added

removed removed

Lines of Context:
5321
5321
  $ac_cs_success || { (exit 1); exit 1; }
5322
5322
fi
5323
5323
 
 
5324
          ac_config_files="$ac_config_files mew-pinentry"
 
5325
cat >confcache <<\_ACEOF
 
5326
# This file is a shell script that caches the results of configure
 
5327
# tests run on this system so they can be shared between configure
 
5328
# scripts and configure runs, see configure's option --config-cache.
 
5329
# It is not useful on other systems.  If it contains results you don't
 
5330
# want to keep, you may remove or edit it.
 
5331
#
 
5332
# config.status only pays attention to the cache file if you give it
 
5333
# the --recheck option to rerun configure.
 
5334
#
 
5335
# `ac_cv_env_foo' variables (set or unset) will be overridden when
 
5336
# loading this file, other *unset* `ac_cv_foo' will be assigned the
 
5337
# following values.
 
5338
 
 
5339
_ACEOF
 
5340
 
 
5341
# The following way of writing the cache mishandles newlines in values,
 
5342
# but we know of no workaround that is simple, portable, and efficient.
 
5343
# So, don't put newlines in cache variables' values.
 
5344
# Ultrix sh set writes to stderr and can't be redirected directly,
 
5345
# and sets the high bit in the cache file unless we assign to the vars.
 
5346
{
 
5347
  (set) 2>&1 |
 
5348
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
 
5349
    *ac_space=\ *)
 
5350
      # `set' does not quote correctly, so add quotes (double-quote
 
5351
      # substitution turns \\\\ into \\, and sed turns \\ into \).
 
5352
      sed -n \
 
5353
        "s/'/'\\\\''/g;
 
5354
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
 
5355
      ;;
 
5356
    *)
 
5357
      # `set' quotes correctly as required by POSIX, so do not add quotes.
 
5358
      sed -n \
 
5359
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
 
5360
      ;;
 
5361
    esac;
 
5362
} |
 
5363
  sed '
 
5364
     t clear
 
5365
     : clear
 
5366
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
 
5367
     t end
 
5368
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
 
5369
     : end' >>confcache
 
5370
if diff $cache_file confcache >/dev/null 2>&1; then :; else
 
5371
  if test -w $cache_file; then
 
5372
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
 
5373
    cat confcache >$cache_file
 
5374
  else
 
5375
    echo "not updating unwritable cache $cache_file"
 
5376
  fi
 
5377
fi
 
5378
rm -f confcache
 
5379
 
 
5380
test "x$prefix" = xNONE && prefix=$ac_default_prefix
 
5381
# Let make expand exec_prefix.
 
5382
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
 
5383
 
 
5384
# VPATH may cause trouble with some makes, so we remove $(srcdir),
 
5385
# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
 
5386
# trailing colons and then remove the whole line if VPATH becomes empty
 
5387
# (actually we leave an empty line to preserve line numbers).
 
5388
if test "x$srcdir" = x.; then
 
5389
  ac_vpsub='/^[  ]*VPATH[        ]*=/{
 
5390
s/:*\$(srcdir):*/:/;
 
5391
s/:*\${srcdir}:*/:/;
 
5392
s/:*@srcdir@:*/:/;
 
5393
s/^\([^=]*=[     ]*\):*/\1/;
 
5394
s/:*$//;
 
5395
s/^[^=]*=[       ]*$//;
 
5396
}'
 
5397
fi
 
5398
 
 
5399
DEFS=-DHAVE_CONFIG_H
 
5400
 
 
5401
ac_libobjs=
 
5402
ac_ltlibobjs=
 
5403
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
 
5404
  # 1. Remove the extension, and $U if already installed.
 
5405
  ac_i=`echo "$ac_i" |
 
5406
         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
 
5407
  # 2. Add them.
 
5408
  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
 
5409
  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
 
5410
done
 
5411
LIBOBJS=$ac_libobjs
 
5412
 
 
5413
LTLIBOBJS=$ac_ltlibobjs
 
5414
 
 
5415
 
 
5416
 
 
5417
: ${CONFIG_STATUS=./config.status}
 
5418
ac_clean_files_save=$ac_clean_files
 
5419
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
 
5420
{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
 
5421
echo "$as_me: creating $CONFIG_STATUS" >&6;}
 
5422
cat >$CONFIG_STATUS <<_ACEOF
 
5423
#! $SHELL
 
5424
# Generated by $as_me.
 
5425
# Run this file to recreate the current configuration.
 
5426
# Compiler output produced by configure, useful for debugging
 
5427
# configure, is in config.log if it exists.
 
5428
 
 
5429
debug=false
 
5430
ac_cs_recheck=false
 
5431
ac_cs_silent=false
 
5432
SHELL=\${CONFIG_SHELL-$SHELL}
 
5433
_ACEOF
 
5434
 
 
5435
cat >>$CONFIG_STATUS <<\_ACEOF
 
5436
## --------------------- ##
 
5437
## M4sh Initialization.  ##
 
5438
## --------------------- ##
 
5439
 
 
5440
# Be Bourne compatible
 
5441
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 
5442
  emulate sh
 
5443
  NULLCMD=:
 
5444
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
 
5445
  # is contrary to our usage.  Disable this feature.
 
5446
  alias -g '${1+"$@"}'='"$@"'
 
5447
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
 
5448
  set -o posix
 
5449
fi
 
5450
DUALCASE=1; export DUALCASE # for MKS sh
 
5451
 
 
5452
# Support unset when possible.
 
5453
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
 
5454
  as_unset=unset
 
5455
else
 
5456
  as_unset=false
 
5457
fi
 
5458
 
 
5459
 
 
5460
# Work around bugs in pre-3.0 UWIN ksh.
 
5461
$as_unset ENV MAIL MAILPATH
 
5462
PS1='$ '
 
5463
PS2='> '
 
5464
PS4='+ '
 
5465
 
 
5466
# NLS nuisances.
 
5467
for as_var in \
 
5468
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
 
5469
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
 
5470
  LC_TELEPHONE LC_TIME
 
5471
do
 
5472
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
 
5473
    eval $as_var=C; export $as_var
 
5474
  else
 
5475
    $as_unset $as_var
 
5476
  fi
 
5477
done
 
5478
 
 
5479
# Required to use basename.
 
5480
if expr a : '\(a\)' >/dev/null 2>&1; then
 
5481
  as_expr=expr
 
5482
else
 
5483
  as_expr=false
 
5484
fi
 
5485
 
 
5486
if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
 
5487
  as_basename=basename
 
5488
else
 
5489
  as_basename=false
 
5490
fi
 
5491
 
 
5492
 
 
5493
# Name of the executable.
 
5494
as_me=`$as_basename "$0" ||
 
5495
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 
5496
         X"$0" : 'X\(//\)$' \| \
 
5497
         X"$0" : 'X\(/\)$' \| \
 
5498
         .     : '\(.\)' 2>/dev/null ||
 
5499
echo X/"$0" |
 
5500
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
 
5501
          /^X\/\(\/\/\)$/{ s//\1/; q; }
 
5502
          /^X\/\(\/\).*/{ s//\1/; q; }
 
5503
          s/.*/./; q'`
 
5504
 
 
5505
 
 
5506
# PATH needs CR, and LINENO needs CR and PATH.
 
5507
# Avoid depending upon Character Ranges.
 
5508
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 
5509
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
5510
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 
5511
as_cr_digits='0123456789'
 
5512
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
5513
 
 
5514
# The user is always right.
 
5515
if test "${PATH_SEPARATOR+set}" != set; then
 
5516
  echo "#! /bin/sh" >conf$$.sh
 
5517
  echo  "exit 0"   >>conf$$.sh
 
5518
  chmod +x conf$$.sh
 
5519
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
 
5520
    PATH_SEPARATOR=';'
 
5521
  else
 
5522
    PATH_SEPARATOR=:
 
5523
  fi
 
5524
  rm -f conf$$.sh
 
5525
fi
 
5526
 
 
5527
 
 
5528
  as_lineno_1=$LINENO
 
5529
  as_lineno_2=$LINENO
 
5530
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 
5531
  test "x$as_lineno_1" != "x$as_lineno_2" &&
 
5532
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 
5533
  # Find who we are.  Look in the path if we contain no path at all
 
5534
  # relative or not.
 
5535
  case $0 in
 
5536
    *[\\/]* ) as_myself=$0 ;;
 
5537
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
5538
for as_dir in $PATH
 
5539
do
 
5540
  IFS=$as_save_IFS
 
5541
  test -z "$as_dir" && as_dir=.
 
5542
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 
5543
done
 
5544
 
 
5545
       ;;
 
5546
  esac
 
5547
  # We did not find ourselves, most probably we were run as `sh COMMAND'
 
5548
  # in which case we are not to be found in the path.
 
5549
  if test "x$as_myself" = x; then
 
5550
    as_myself=$0
 
5551
  fi
 
5552
  if test ! -f "$as_myself"; then
 
5553
    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
 
5554
echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
 
5555
   { (exit 1); exit 1; }; }
 
5556
  fi
 
5557
  case $CONFIG_SHELL in
 
5558
  '')
 
5559
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
5560
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 
5561
do
 
5562
  IFS=$as_save_IFS
 
5563
  test -z "$as_dir" && as_dir=.
 
5564
  for as_base in sh bash ksh sh5; do
 
5565
         case $as_dir in
 
5566
         /*)
 
5567
           if ("$as_dir/$as_base" -c '
 
5568
  as_lineno_1=$LINENO
 
5569
  as_lineno_2=$LINENO
 
5570
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 
5571
  test "x$as_lineno_1" != "x$as_lineno_2" &&
 
5572
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 
5573
             $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 
5574
             $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 
5575
             CONFIG_SHELL=$as_dir/$as_base
 
5576
             export CONFIG_SHELL
 
5577
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 
5578
           fi;;
 
5579
         esac
 
5580
       done
 
5581
done
 
5582
;;
 
5583
  esac
 
5584
 
 
5585
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 
5586
  # uniformly replaced by the line number.  The first 'sed' inserts a
 
5587
  # line-number line before each line; the second 'sed' does the real
 
5588
  # work.  The second script uses 'N' to pair each line-number line
 
5589
  # with the numbered line, and appends trailing '-' during
 
5590
  # substitution so that $LINENO is not a special case at line end.
 
5591
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 
5592
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 
5593
  sed '=' <$as_myself |
 
5594
    sed '
 
5595
      N
 
5596
      s,$,-,
 
5597
      : loop
 
5598
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 
5599
      t loop
 
5600
      s,-$,,
 
5601
      s,^['$as_cr_digits']*\n,,
 
5602
    ' >$as_me.lineno &&
 
5603
  chmod +x $as_me.lineno ||
 
5604
    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
 
5605
echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
 
5606
   { (exit 1); exit 1; }; }
 
5607
 
 
5608
  # Don't try to exec as it changes $[0], causing all sort of problems
 
5609
  # (the dirname of $[0] is not the place where we might find the
 
5610
  # original and so on.  Autoconf is especially sensible to this).
 
5611
  . ./$as_me.lineno
 
5612
  # Exit status is that of the last command.
 
5613
  exit
 
5614
}
 
5615
 
 
5616
 
 
5617
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 
5618
  *c*,-n*) ECHO_N= ECHO_C='
 
5619
' ECHO_T='      ' ;;
 
5620
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 
5621
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 
5622
esac
 
5623
 
 
5624
if expr a : '\(a\)' >/dev/null 2>&1; then
 
5625
  as_expr=expr
 
5626
else
 
5627
  as_expr=false
 
5628
fi
 
5629
 
 
5630
rm -f conf$$ conf$$.exe conf$$.file
 
5631
echo >conf$$.file
 
5632
if ln -s conf$$.file conf$$ 2>/dev/null; then
 
5633
  # We could just check for DJGPP; but this test a) works b) is more generic
 
5634
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 
5635
  if test -f conf$$.exe; then
 
5636
    # Don't use ln at all; we don't have any links
 
5637
    as_ln_s='cp -p'
 
5638
  else
 
5639
    as_ln_s='ln -s'
 
5640
  fi
 
5641
elif ln conf$$.file conf$$ 2>/dev/null; then
 
5642
  as_ln_s=ln
 
5643
else
 
5644
  as_ln_s='cp -p'
 
5645
fi
 
5646
rm -f conf$$ conf$$.exe conf$$.file
 
5647
 
 
5648
if mkdir -p . 2>/dev/null; then
 
5649
  as_mkdir_p=:
 
5650
else
 
5651
  test -d ./-p && rmdir ./-p
 
5652
  as_mkdir_p=false
 
5653
fi
 
5654
 
 
5655
as_executable_p="test -f"
 
5656
 
 
5657
# Sed expression to map a string onto a valid CPP name.
 
5658
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 
5659
 
 
5660
# Sed expression to map a string onto a valid variable name.
 
5661
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 
5662
 
 
5663
 
 
5664
# IFS
 
5665
# We need space, tab and new line, in precisely that order.
 
5666
as_nl='
 
5667
'
 
5668
IFS="   $as_nl"
 
5669
 
 
5670
# CDPATH.
 
5671
$as_unset CDPATH
 
5672
 
 
5673
exec 6>&1
 
5674
 
 
5675
# Open the log real soon, to keep \$[0] and so on meaningful, and to
 
5676
# report actual input values of CONFIG_FILES etc. instead of their
 
5677
# values after options handling.  Logging --version etc. is OK.
 
5678
exec 5>>config.log
 
5679
{
 
5680
  echo
 
5681
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
 
5682
## Running $as_me. ##
 
5683
_ASBOX
 
5684
} >&5
 
5685
cat >&5 <<_CSEOF
 
5686
 
 
5687
This file was extended by $as_me, which was
 
5688
generated by GNU Autoconf 2.59.  Invocation command line was
 
5689
 
 
5690
  CONFIG_FILES    = $CONFIG_FILES
 
5691
  CONFIG_HEADERS  = $CONFIG_HEADERS
 
5692
  CONFIG_LINKS    = $CONFIG_LINKS
 
5693
  CONFIG_COMMANDS = $CONFIG_COMMANDS
 
5694
  $ $0 $@
 
5695
 
 
5696
_CSEOF
 
5697
echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
 
5698
echo >&5
 
5699
_ACEOF
 
5700
 
 
5701
# Files that config.status was made for.
 
5702
if test -n "$ac_config_files"; then
 
5703
  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
 
5704
fi
 
5705
 
 
5706
if test -n "$ac_config_headers"; then
 
5707
  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
 
5708
fi
 
5709
 
 
5710
if test -n "$ac_config_links"; then
 
5711
  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
 
5712
fi
 
5713
 
 
5714
if test -n "$ac_config_commands"; then
 
5715
  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
 
5716
fi
 
5717
 
 
5718
cat >>$CONFIG_STATUS <<\_ACEOF
 
5719
 
 
5720
ac_cs_usage="\
 
5721
\`$as_me' instantiates files from templates according to the
 
5722
current configuration.
 
5723
 
 
5724
Usage: $0 [OPTIONS] [FILE]...
 
5725
 
 
5726
  -h, --help       print this help, then exit
 
5727
  -V, --version    print version number, then exit
 
5728
  -q, --quiet      do not print progress messages
 
5729
  -d, --debug      don't remove temporary files
 
5730
      --recheck    update $as_me by reconfiguring in the same conditions
 
5731
  --file=FILE[:TEMPLATE]
 
5732
                   instantiate the configuration file FILE
 
5733
  --header=FILE[:TEMPLATE]
 
5734
                   instantiate the configuration header FILE
 
5735
 
 
5736
Configuration files:
 
5737
$config_files
 
5738
 
 
5739
Configuration headers:
 
5740
$config_headers
 
5741
 
 
5742
Report bugs to <bug-autoconf@gnu.org>."
 
5743
_ACEOF
 
5744
 
 
5745
cat >>$CONFIG_STATUS <<_ACEOF
 
5746
ac_cs_version="\\
 
5747
config.status
 
5748
configured by $0, generated by GNU Autoconf 2.59,
 
5749
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
 
5750
 
 
5751
Copyright (C) 2003 Free Software Foundation, Inc.
 
5752
This config.status script is free software; the Free Software Foundation
 
5753
gives unlimited permission to copy, distribute and modify it."
 
5754
srcdir=$srcdir
 
5755
INSTALL="$INSTALL"
 
5756
_ACEOF
 
5757
 
 
5758
cat >>$CONFIG_STATUS <<\_ACEOF
 
5759
# If no file are specified by the user, then we need to provide default
 
5760
# value.  By we need to know if files were specified by the user.
 
5761
ac_need_defaults=:
 
5762
while test $# != 0
 
5763
do
 
5764
  case $1 in
 
5765
  --*=*)
 
5766
    ac_option=`expr "x$1" : 'x\([^=]*\)='`
 
5767
    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
 
5768
    ac_shift=:
 
5769
    ;;
 
5770
  -*)
 
5771
    ac_option=$1
 
5772
    ac_optarg=$2
 
5773
    ac_shift=shift
 
5774
    ;;
 
5775
  *) # This is not an option, so the user has probably given explicit
 
5776
     # arguments.
 
5777
     ac_option=$1
 
5778
     ac_need_defaults=false;;
 
5779
  esac
 
5780
 
 
5781
  case $ac_option in
 
5782
  # Handling of the options.
 
5783
_ACEOF
 
5784
cat >>$CONFIG_STATUS <<\_ACEOF
 
5785
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
 
5786
    ac_cs_recheck=: ;;
 
5787
  --version | --vers* | -V )
 
5788
    echo "$ac_cs_version"; exit 0 ;;
 
5789
  --he | --h)
 
5790
    # Conflict between --help and --header
 
5791
    { { echo "$as_me:$LINENO: error: ambiguous option: $1
 
5792
Try \`$0 --help' for more information." >&5
 
5793
echo "$as_me: error: ambiguous option: $1
 
5794
Try \`$0 --help' for more information." >&2;}
 
5795
   { (exit 1); exit 1; }; };;
 
5796
  --help | --hel | -h )
 
5797
    echo "$ac_cs_usage"; exit 0 ;;
 
5798
  --debug | --d* | -d )
 
5799
    debug=: ;;
 
5800
  --file | --fil | --fi | --f )
 
5801
    $ac_shift
 
5802
    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
 
5803
    ac_need_defaults=false;;
 
5804
  --header | --heade | --head | --hea )
 
5805
    $ac_shift
 
5806
    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
 
5807
    ac_need_defaults=false;;
 
5808
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 
5809
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
 
5810
    ac_cs_silent=: ;;
 
5811
 
 
5812
  # This is an error.
 
5813
  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
 
5814
Try \`$0 --help' for more information." >&5
 
5815
echo "$as_me: error: unrecognized option: $1
 
5816
Try \`$0 --help' for more information." >&2;}
 
5817
   { (exit 1); exit 1; }; } ;;
 
5818
 
 
5819
  *) ac_config_targets="$ac_config_targets $1" ;;
 
5820
 
 
5821
  esac
 
5822
  shift
 
5823
done
 
5824
 
 
5825
ac_configure_extra_args=
 
5826
 
 
5827
if $ac_cs_silent; then
 
5828
  exec 6>/dev/null
 
5829
  ac_configure_extra_args="$ac_configure_extra_args --silent"
 
5830
fi
 
5831
 
 
5832
_ACEOF
 
5833
cat >>$CONFIG_STATUS <<_ACEOF
 
5834
if \$ac_cs_recheck; then
 
5835
  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
 
5836
  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
 
5837
fi
 
5838
 
 
5839
_ACEOF
 
5840
 
 
5841
 
 
5842
 
 
5843
 
 
5844
 
 
5845
cat >>$CONFIG_STATUS <<\_ACEOF
 
5846
for ac_config_target in $ac_config_targets
 
5847
do
 
5848
  case "$ac_config_target" in
 
5849
  # Handling of arguments.
 
5850
  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
 
5851
  "mew-pinentry" ) CONFIG_FILES="$CONFIG_FILES mew-pinentry" ;;
 
5852
  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
 
5853
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
 
5854
echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
 
5855
   { (exit 1); exit 1; }; };;
 
5856
  esac
 
5857
done
 
5858
 
 
5859
# If the user did not use the arguments to specify the items to instantiate,
 
5860
# then the envvar interface is used.  Set only those that are not.
 
5861
# We use the long form for the default assignment because of an extremely
 
5862
# bizarre bug on SunOS 4.1.3.
 
5863
if $ac_need_defaults; then
 
5864
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
 
5865
  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
 
5866
fi
 
5867
 
 
5868
# Have a temporary directory for convenience.  Make it in the build tree
 
5869
# simply because there is no reason to put it here, and in addition,
 
5870
# creating and moving files from /tmp can sometimes cause problems.
 
5871
# Create a temporary directory, and hook for its removal unless debugging.
 
5872
$debug ||
 
5873
{
 
5874
  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
 
5875
  trap '{ (exit 1); exit 1; }' 1 2 13 15
 
5876
}
 
5877
 
 
5878
# Create a (secure) tmp directory for tmp files.
 
5879
 
 
5880
{
 
5881
  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
 
5882
  test -n "$tmp" && test -d "$tmp"
 
5883
}  ||
 
5884
{
 
5885
  tmp=./confstat$$-$RANDOM
 
5886
  (umask 077 && mkdir $tmp)
 
5887
} ||
 
5888
{
 
5889
   echo "$me: cannot create a temporary directory in ." >&2
 
5890
   { (exit 1); exit 1; }
 
5891
}
 
5892
 
 
5893
_ACEOF
 
5894
 
 
5895
cat >>$CONFIG_STATUS <<_ACEOF
 
5896
 
 
5897
#
 
5898
# CONFIG_FILES section.
 
5899
#
 
5900
 
 
5901
# No need to generate the scripts if there are no CONFIG_FILES.
 
5902
# This happens for instance when ./config.status config.h
 
5903
if test -n "\$CONFIG_FILES"; then
 
5904
  # Protect against being on the right side of a sed subst in config.status.
 
5905
  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
 
5906
   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
 
5907
s,@SHELL@,$SHELL,;t t
 
5908
s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
 
5909
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
 
5910
s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
 
5911
s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
 
5912
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
 
5913
s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
 
5914
s,@exec_prefix@,$exec_prefix,;t t
 
5915
s,@prefix@,$prefix,;t t
 
5916
s,@program_transform_name@,$program_transform_name,;t t
 
5917
s,@bindir@,$bindir,;t t
 
5918
s,@sbindir@,$sbindir,;t t
 
5919
s,@libexecdir@,$libexecdir,;t t
 
5920
s,@datadir@,$datadir,;t t
 
5921
s,@sysconfdir@,$sysconfdir,;t t
 
5922
s,@sharedstatedir@,$sharedstatedir,;t t
 
5923
s,@localstatedir@,$localstatedir,;t t
 
5924
s,@libdir@,$libdir,;t t
 
5925
s,@includedir@,$includedir,;t t
 
5926
s,@oldincludedir@,$oldincludedir,;t t
 
5927
s,@infodir@,$infodir,;t t
 
5928
s,@mandir@,$mandir,;t t
 
5929
s,@build_alias@,$build_alias,;t t
 
5930
s,@host_alias@,$host_alias,;t t
 
5931
s,@target_alias@,$target_alias,;t t
 
5932
s,@DEFS@,$DEFS,;t t
 
5933
s,@ECHO_C@,$ECHO_C,;t t
 
5934
s,@ECHO_N@,$ECHO_N,;t t
 
5935
s,@ECHO_T@,$ECHO_T,;t t
 
5936
s,@LIBS@,$LIBS,;t t
 
5937
s,@CC@,$CC,;t t
 
5938
s,@CFLAGS@,$CFLAGS,;t t
 
5939
s,@LDFLAGS@,$LDFLAGS,;t t
 
5940
s,@CPPFLAGS@,$CPPFLAGS,;t t
 
5941
s,@ac_ct_CC@,$ac_ct_CC,;t t
 
5942
s,@EXEEXT@,$EXEEXT,;t t
 
5943
s,@OBJEXT@,$OBJEXT,;t t
 
5944
s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
 
5945
s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
 
5946
s,@INSTALL_DATA@,$INSTALL_DATA,;t t
 
5947
s,@CPP@,$CPP,;t t
 
5948
s,@EGREP@,$EGREP,;t t
 
5949
s,@LIBOBJS@,$LIBOBJS,;t t
 
5950
s,@LTLIBOBJS@,$LTLIBOBJS,;t t
 
5951
CEOF
 
5952
 
 
5953
_ACEOF
 
5954
 
 
5955
  cat >>$CONFIG_STATUS <<\_ACEOF
 
5956
  # Split the substitutions into bite-sized pieces for seds with
 
5957
  # small command number limits, like on Digital OSF/1 and HP-UX.
 
5958
  ac_max_sed_lines=48
 
5959
  ac_sed_frag=1 # Number of current file.
 
5960
  ac_beg=1 # First line for current file.
 
5961
  ac_end=$ac_max_sed_lines # Line after last line for current file.
 
5962
  ac_more_lines=:
 
5963
  ac_sed_cmds=
 
5964
  while $ac_more_lines; do
 
5965
    if test $ac_beg -gt 1; then
 
5966
      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
 
5967
    else
 
5968
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
 
5969
    fi
 
5970
    if test ! -s $tmp/subs.frag; then
 
5971
      ac_more_lines=false
 
5972
    else
 
5973
      # The purpose of the label and of the branching condition is to
 
5974
      # speed up the sed processing (if there are no `@' at all, there
 
5975
      # is no need to browse any of the substitutions).
 
5976
      # These are the two extra sed commands mentioned above.
 
5977
      (echo ':t
 
5978
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
 
5979
      if test -z "$ac_sed_cmds"; then
 
5980
        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
 
5981
      else
 
5982
        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
 
5983
      fi
 
5984
      ac_sed_frag=`expr $ac_sed_frag + 1`
 
5985
      ac_beg=$ac_end
 
5986
      ac_end=`expr $ac_end + $ac_max_sed_lines`
 
5987
    fi
 
5988
  done
 
5989
  if test -z "$ac_sed_cmds"; then
 
5990
    ac_sed_cmds=cat
 
5991
  fi
 
5992
fi # test -n "$CONFIG_FILES"
 
5993
 
 
5994
_ACEOF
 
5995
cat >>$CONFIG_STATUS <<\_ACEOF
 
5996
for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
 
5997
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
 
5998
  case $ac_file in
 
5999
  - | *:- | *:-:* ) # input from stdin
 
6000
        cat >$tmp/stdin
 
6001
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
6002
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
6003
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
6004
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
6005
  * )   ac_file_in=$ac_file.in ;;
 
6006
  esac
 
6007
 
 
6008
  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
 
6009
  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
 
6010
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
6011
         X"$ac_file" : 'X\(//\)[^/]' \| \
 
6012
         X"$ac_file" : 'X\(//\)$' \| \
 
6013
         X"$ac_file" : 'X\(/\)' \| \
 
6014
         .     : '\(.\)' 2>/dev/null ||
 
6015
echo X"$ac_file" |
 
6016
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
6017
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
6018
          /^X\(\/\/\)$/{ s//\1/; q; }
 
6019
          /^X\(\/\).*/{ s//\1/; q; }
 
6020
          s/.*/./; q'`
 
6021
  { if $as_mkdir_p; then
 
6022
    mkdir -p "$ac_dir"
 
6023
  else
 
6024
    as_dir="$ac_dir"
 
6025
    as_dirs=
 
6026
    while test ! -d "$as_dir"; do
 
6027
      as_dirs="$as_dir $as_dirs"
 
6028
      as_dir=`(dirname "$as_dir") 2>/dev/null ||
 
6029
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
6030
         X"$as_dir" : 'X\(//\)[^/]' \| \
 
6031
         X"$as_dir" : 'X\(//\)$' \| \
 
6032
         X"$as_dir" : 'X\(/\)' \| \
 
6033
         .     : '\(.\)' 2>/dev/null ||
 
6034
echo X"$as_dir" |
 
6035
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
6036
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
6037
          /^X\(\/\/\)$/{ s//\1/; q; }
 
6038
          /^X\(\/\).*/{ s//\1/; q; }
 
6039
          s/.*/./; q'`
 
6040
    done
 
6041
    test ! -n "$as_dirs" || mkdir $as_dirs
 
6042
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
 
6043
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
 
6044
   { (exit 1); exit 1; }; }; }
 
6045
 
 
6046
  ac_builddir=.
 
6047
 
 
6048
if test "$ac_dir" != .; then
 
6049
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 
6050
  # A "../" for each directory in $ac_dir_suffix.
 
6051
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 
6052
else
 
6053
  ac_dir_suffix= ac_top_builddir=
 
6054
fi
 
6055
 
 
6056
case $srcdir in
 
6057
  .)  # No --srcdir option.  We are building in place.
 
6058
    ac_srcdir=.
 
6059
    if test -z "$ac_top_builddir"; then
 
6060
       ac_top_srcdir=.
 
6061
    else
 
6062
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 
6063
    fi ;;
 
6064
  [\\/]* | ?:[\\/]* )  # Absolute path.
 
6065
    ac_srcdir=$srcdir$ac_dir_suffix;
 
6066
    ac_top_srcdir=$srcdir ;;
 
6067
  *) # Relative path.
 
6068
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 
6069
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
 
6070
esac
 
6071
 
 
6072
# Do not use `cd foo && pwd` to compute absolute paths, because
 
6073
# the directories may not exist.
 
6074
case `pwd` in
 
6075
.) ac_abs_builddir="$ac_dir";;
 
6076
*)
 
6077
  case "$ac_dir" in
 
6078
  .) ac_abs_builddir=`pwd`;;
 
6079
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
 
6080
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
 
6081
  esac;;
 
6082
esac
 
6083
case $ac_abs_builddir in
 
6084
.) ac_abs_top_builddir=${ac_top_builddir}.;;
 
6085
*)
 
6086
  case ${ac_top_builddir}. in
 
6087
  .) ac_abs_top_builddir=$ac_abs_builddir;;
 
6088
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
 
6089
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
 
6090
  esac;;
 
6091
esac
 
6092
case $ac_abs_builddir in
 
6093
.) ac_abs_srcdir=$ac_srcdir;;
 
6094
*)
 
6095
  case $ac_srcdir in
 
6096
  .) ac_abs_srcdir=$ac_abs_builddir;;
 
6097
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
 
6098
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
 
6099
  esac;;
 
6100
esac
 
6101
case $ac_abs_builddir in
 
6102
.) ac_abs_top_srcdir=$ac_top_srcdir;;
 
6103
*)
 
6104
  case $ac_top_srcdir in
 
6105
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
 
6106
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
 
6107
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
 
6108
  esac;;
 
6109
esac
 
6110
 
 
6111
 
 
6112
  case $INSTALL in
 
6113
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
 
6114
  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
 
6115
  esac
 
6116
 
 
6117
  if test x"$ac_file" != x-; then
 
6118
    { echo "$as_me:$LINENO: creating $ac_file" >&5
 
6119
echo "$as_me: creating $ac_file" >&6;}
 
6120
    rm -f "$ac_file"
 
6121
  fi
 
6122
  # Let's still pretend it is `configure' which instantiates (i.e., don't
 
6123
  # use $as_me), people would be surprised to read:
 
6124
  #    /* config.h.  Generated by config.status.  */
 
6125
  if test x"$ac_file" = x-; then
 
6126
    configure_input=
 
6127
  else
 
6128
    configure_input="$ac_file.  "
 
6129
  fi
 
6130
  configure_input=$configure_input"Generated from `echo $ac_file_in |
 
6131
                                     sed 's,.*/,,'` by configure."
 
6132
 
 
6133
  # First look for the input files in the build tree, otherwise in the
 
6134
  # src tree.
 
6135
  ac_file_inputs=`IFS=:
 
6136
    for f in $ac_file_in; do
 
6137
      case $f in
 
6138
      -) echo $tmp/stdin ;;
 
6139
      [\\/$]*)
 
6140
         # Absolute (can't be DOS-style, as IFS=:)
 
6141
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
6142
echo "$as_me: error: cannot find input file: $f" >&2;}
 
6143
   { (exit 1); exit 1; }; }
 
6144
         echo "$f";;
 
6145
      *) # Relative
 
6146
         if test -f "$f"; then
 
6147
           # Build tree
 
6148
           echo "$f"
 
6149
         elif test -f "$srcdir/$f"; then
 
6150
           # Source tree
 
6151
           echo "$srcdir/$f"
 
6152
         else
 
6153
           # /dev/null tree
 
6154
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
6155
echo "$as_me: error: cannot find input file: $f" >&2;}
 
6156
   { (exit 1); exit 1; }; }
 
6157
         fi;;
 
6158
      esac
 
6159
    done` || { (exit 1); exit 1; }
 
6160
_ACEOF
 
6161
cat >>$CONFIG_STATUS <<_ACEOF
 
6162
  sed "$ac_vpsub
 
6163
$extrasub
 
6164
_ACEOF
 
6165
cat >>$CONFIG_STATUS <<\_ACEOF
 
6166
:t
 
6167
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
 
6168
s,@configure_input@,$configure_input,;t t
 
6169
s,@srcdir@,$ac_srcdir,;t t
 
6170
s,@abs_srcdir@,$ac_abs_srcdir,;t t
 
6171
s,@top_srcdir@,$ac_top_srcdir,;t t
 
6172
s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
 
6173
s,@builddir@,$ac_builddir,;t t
 
6174
s,@abs_builddir@,$ac_abs_builddir,;t t
 
6175
s,@top_builddir@,$ac_top_builddir,;t t
 
6176
s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
 
6177
s,@INSTALL@,$ac_INSTALL,;t t
 
6178
" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
 
6179
  rm -f $tmp/stdin
 
6180
  if test x"$ac_file" != x-; then
 
6181
    mv $tmp/out $ac_file
 
6182
  else
 
6183
    cat $tmp/out
 
6184
    rm -f $tmp/out
 
6185
  fi
 
6186
 
 
6187
done
 
6188
_ACEOF
 
6189
cat >>$CONFIG_STATUS <<\_ACEOF
 
6190
 
 
6191
#
 
6192
# CONFIG_HEADER section.
 
6193
#
 
6194
 
 
6195
# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
 
6196
# NAME is the cpp macro being defined and VALUE is the value it is being given.
 
6197
#
 
6198
# ac_d sets the value in "#define NAME VALUE" lines.
 
6199
ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
 
6200
ac_dB='[         ].*$,\1#\2'
 
6201
ac_dC=' '
 
6202
ac_dD=',;t'
 
6203
# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
 
6204
ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
 
6205
ac_uB='$,\1#\2define\3'
 
6206
ac_uC=' '
 
6207
ac_uD=',;t'
 
6208
 
 
6209
for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
 
6210
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
 
6211
  case $ac_file in
 
6212
  - | *:- | *:-:* ) # input from stdin
 
6213
        cat >$tmp/stdin
 
6214
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
6215
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
6216
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
6217
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
6218
  * )   ac_file_in=$ac_file.in ;;
 
6219
  esac
 
6220
 
 
6221
  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
 
6222
echo "$as_me: creating $ac_file" >&6;}
 
6223
 
 
6224
  # First look for the input files in the build tree, otherwise in the
 
6225
  # src tree.
 
6226
  ac_file_inputs=`IFS=:
 
6227
    for f in $ac_file_in; do
 
6228
      case $f in
 
6229
      -) echo $tmp/stdin ;;
 
6230
      [\\/$]*)
 
6231
         # Absolute (can't be DOS-style, as IFS=:)
 
6232
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
6233
echo "$as_me: error: cannot find input file: $f" >&2;}
 
6234
   { (exit 1); exit 1; }; }
 
6235
         # Do quote $f, to prevent DOS paths from being IFS'd.
 
6236
         echo "$f";;
 
6237
      *) # Relative
 
6238
         if test -f "$f"; then
 
6239
           # Build tree
 
6240
           echo "$f"
 
6241
         elif test -f "$srcdir/$f"; then
 
6242
           # Source tree
 
6243
           echo "$srcdir/$f"
 
6244
         else
 
6245
           # /dev/null tree
 
6246
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
6247
echo "$as_me: error: cannot find input file: $f" >&2;}
 
6248
   { (exit 1); exit 1; }; }
 
6249
         fi;;
 
6250
      esac
 
6251
    done` || { (exit 1); exit 1; }
 
6252
  # Remove the trailing spaces.
 
6253
  sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
 
6254
 
 
6255
_ACEOF
 
6256
 
 
6257
# Transform confdefs.h into two sed scripts, `conftest.defines' and
 
6258
# `conftest.undefs', that substitutes the proper values into
 
6259
# config.h.in to produce config.h.  The first handles `#define'
 
6260
# templates, and the second `#undef' templates.
 
6261
# And first: Protect against being on the right side of a sed subst in
 
6262
# config.status.  Protect against being in an unquoted here document
 
6263
# in config.status.
 
6264
rm -f conftest.defines conftest.undefs
 
6265
# Using a here document instead of a string reduces the quoting nightmare.
 
6266
# Putting comments in sed scripts is not portable.
 
6267
#
 
6268
# `end' is used to avoid that the second main sed command (meant for
 
6269
# 0-ary CPP macros) applies to n-ary macro definitions.
 
6270
# See the Autoconf documentation for `clear'.
 
6271
cat >confdef2sed.sed <<\_ACEOF
 
6272
s/[\\&,]/\\&/g
 
6273
s,[\\$`],\\&,g
 
6274
t clear
 
6275
: clear
 
6276
s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
 
6277
t end
 
6278
s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
 
6279
: end
 
6280
_ACEOF
 
6281
# If some macros were called several times there might be several times
 
6282
# the same #defines, which is useless.  Nevertheless, we may not want to
 
6283
# sort them, since we want the *last* AC-DEFINE to be honored.
 
6284
uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
 
6285
sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
 
6286
rm -f confdef2sed.sed
 
6287
 
 
6288
# This sed command replaces #undef with comments.  This is necessary, for
 
6289
# example, in the case of _POSIX_SOURCE, which is predefined and required
 
6290
# on some systems where configure will not decide to define it.
 
6291
cat >>conftest.undefs <<\_ACEOF
 
6292
s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
 
6293
_ACEOF
 
6294
 
 
6295
# Break up conftest.defines because some shells have a limit on the size
 
6296
# of here documents, and old seds have small limits too (100 cmds).
 
6297
echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
 
6298
echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
 
6299
echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
 
6300
echo '  :' >>$CONFIG_STATUS
 
6301
rm -f conftest.tail
 
6302
while grep . conftest.defines >/dev/null
 
6303
do
 
6304
  # Write a limited-size here document to $tmp/defines.sed.
 
6305
  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
 
6306
  # Speed up: don't consider the non `#define' lines.
 
6307
  echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
 
6308
  # Work around the forget-to-reset-the-flag bug.
 
6309
  echo 't clr' >>$CONFIG_STATUS
 
6310
  echo ': clr' >>$CONFIG_STATUS
 
6311
  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
 
6312
  echo 'CEOF
 
6313
  sed -f $tmp/defines.sed $tmp/in >$tmp/out
 
6314
  rm -f $tmp/in
 
6315
  mv $tmp/out $tmp/in
 
6316
' >>$CONFIG_STATUS
 
6317
  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
 
6318
  rm -f conftest.defines
 
6319
  mv conftest.tail conftest.defines
 
6320
done
 
6321
rm -f conftest.defines
 
6322
echo '  fi # grep' >>$CONFIG_STATUS
 
6323
echo >>$CONFIG_STATUS
 
6324
 
 
6325
# Break up conftest.undefs because some shells have a limit on the size
 
6326
# of here documents, and old seds have small limits too (100 cmds).
 
6327
echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
 
6328
rm -f conftest.tail
 
6329
while grep . conftest.undefs >/dev/null
 
6330
do
 
6331
  # Write a limited-size here document to $tmp/undefs.sed.
 
6332
  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
 
6333
  # Speed up: don't consider the non `#undef'
 
6334
  echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
 
6335
  # Work around the forget-to-reset-the-flag bug.
 
6336
  echo 't clr' >>$CONFIG_STATUS
 
6337
  echo ': clr' >>$CONFIG_STATUS
 
6338
  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
 
6339
  echo 'CEOF
 
6340
  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
 
6341
  rm -f $tmp/in
 
6342
  mv $tmp/out $tmp/in
 
6343
' >>$CONFIG_STATUS
 
6344
  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
 
6345
  rm -f conftest.undefs
 
6346
  mv conftest.tail conftest.undefs
 
6347
done
 
6348
rm -f conftest.undefs
 
6349
 
 
6350
cat >>$CONFIG_STATUS <<\_ACEOF
 
6351
  # Let's still pretend it is `configure' which instantiates (i.e., don't
 
6352
  # use $as_me), people would be surprised to read:
 
6353
  #    /* config.h.  Generated by config.status.  */
 
6354
  if test x"$ac_file" = x-; then
 
6355
    echo "/* Generated by configure.  */" >$tmp/config.h
 
6356
  else
 
6357
    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
 
6358
  fi
 
6359
  cat $tmp/in >>$tmp/config.h
 
6360
  rm -f $tmp/in
 
6361
  if test x"$ac_file" != x-; then
 
6362
    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
 
6363
      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
 
6364
echo "$as_me: $ac_file is unchanged" >&6;}
 
6365
    else
 
6366
      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
 
6367
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
6368
         X"$ac_file" : 'X\(//\)[^/]' \| \
 
6369
         X"$ac_file" : 'X\(//\)$' \| \
 
6370
         X"$ac_file" : 'X\(/\)' \| \
 
6371
         .     : '\(.\)' 2>/dev/null ||
 
6372
echo X"$ac_file" |
 
6373
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
6374
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
6375
          /^X\(\/\/\)$/{ s//\1/; q; }
 
6376
          /^X\(\/\).*/{ s//\1/; q; }
 
6377
          s/.*/./; q'`
 
6378
      { if $as_mkdir_p; then
 
6379
    mkdir -p "$ac_dir"
 
6380
  else
 
6381
    as_dir="$ac_dir"
 
6382
    as_dirs=
 
6383
    while test ! -d "$as_dir"; do
 
6384
      as_dirs="$as_dir $as_dirs"
 
6385
      as_dir=`(dirname "$as_dir") 2>/dev/null ||
 
6386
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
6387
         X"$as_dir" : 'X\(//\)[^/]' \| \
 
6388
         X"$as_dir" : 'X\(//\)$' \| \
 
6389
         X"$as_dir" : 'X\(/\)' \| \
 
6390
         .     : '\(.\)' 2>/dev/null ||
 
6391
echo X"$as_dir" |
 
6392
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
6393
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
6394
          /^X\(\/\/\)$/{ s//\1/; q; }
 
6395
          /^X\(\/\).*/{ s//\1/; q; }
 
6396
          s/.*/./; q'`
 
6397
    done
 
6398
    test ! -n "$as_dirs" || mkdir $as_dirs
 
6399
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
 
6400
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
 
6401
   { (exit 1); exit 1; }; }; }
 
6402
 
 
6403
      rm -f $ac_file
 
6404
      mv $tmp/config.h $ac_file
 
6405
    fi
 
6406
  else
 
6407
    cat $tmp/config.h
 
6408
    rm -f $tmp/config.h
 
6409
  fi
 
6410
done
 
6411
_ACEOF
 
6412
 
 
6413
cat >>$CONFIG_STATUS <<\_ACEOF
 
6414
 
 
6415
{ (exit 0); exit 0; }
 
6416
_ACEOF
 
6417
chmod +x $CONFIG_STATUS
 
6418
ac_clean_files=$ac_clean_files_save
 
6419
 
 
6420
 
 
6421
# configure is writing to config.log, and then calls config.status.
 
6422
# config.status does its own redirection, appending to config.log.
 
6423
# Unfortunately, on DOS this fails, as config.log is still kept open
 
6424
# by configure, so config.status won't be able to write to it; its
 
6425
# output is simply discarded.  So we exec the FD to /dev/null,
 
6426
# effectively closing config.log, so it can be properly (re)opened and
 
6427
# appended to by config.status.  When coming back to configure, we
 
6428
# need to make the FD available again.
 
6429
if test "$no_create" != yes; then
 
6430
  ac_cs_success=:
 
6431
  ac_config_status_args=
 
6432
  test "$silent" = yes &&
 
6433
    ac_config_status_args="$ac_config_status_args --quiet"
 
6434
  exec 5>/dev/null
 
6435
  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
 
6436
  exec 5>>config.log
 
6437
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
 
6438
  # would make configure fail if this is the last instruction.
 
6439
  $ac_cs_success || { (exit 1); exit 1; }
 
6440
fi
 
6441