~ubuntu-branches/ubuntu/trusty/enigma/trusty-proposed

« back to all changes in this revision

Viewing changes to lib-src/enet/configure

  • Committer: Package Import Robot
  • Author(s): Erich Schubert
  • Date: 2013-04-06 14:54:02 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20130406145402-jgjrtk7hac8gtvza
Tags: 1.20-dfsg.1-1
* New upstream release (Closes: #704595)
  (Repacked: dropped zipios++ source and main menu music)
* Update watch file, sf.net again.
* Fix documentation links (Closes: #653508)
* Conflict with enigma-level-previews to encourage deinstallation
  (Pregenerated level previews were only used with version 1.01)
* Use dh7 for building instead of CDBS
* Update to policy 3.9.4.0 (no changes)
* Register documentation with doc-base

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#! /bin/sh
2
2
# Guess values for system-dependent variables and create Makefiles.
3
 
# Generated by GNU Autoconf 2.69 for libenet 1.0.
4
 
#
5
 
#
6
 
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
 
3
# Generated by GNU Autoconf 2.67 for libenet 1.0.
 
4
#
 
5
#
 
6
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
 
7
# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
 
8
# Foundation, Inc.
7
9
#
8
10
#
9
11
# This configure script is free software; the Free Software Foundation
87
89
IFS=" ""        $as_nl"
88
90
 
89
91
# Find who we are.  Look in the path if we contain no directory separator.
90
 
as_myself=
91
92
case $0 in #((
92
93
  *[\\/]* ) as_myself=$0 ;;
93
94
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
132
133
# CDPATH.
133
134
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
134
135
 
135
 
# Use a proper internal environment variable to ensure we don't fall
136
 
  # into an infinite loop, continuously re-executing ourselves.
137
 
  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
138
 
    _as_can_reexec=no; export _as_can_reexec;
139
 
    # We cannot yet assume a decent shell, so we have to provide a
140
 
# neutralization value for shells without unset; and this also
141
 
# works around shells that cannot unset nonexistent variables.
142
 
# Preserve -v and -x to the replacement shell.
143
 
BASH_ENV=/dev/null
144
 
ENV=/dev/null
145
 
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
146
 
case $- in # ((((
147
 
  *v*x* | *x*v* ) as_opts=-vx ;;
148
 
  *v* ) as_opts=-v ;;
149
 
  *x* ) as_opts=-x ;;
150
 
  * ) as_opts= ;;
151
 
esac
152
 
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
153
 
# Admittedly, this is quite paranoid, since all the known shells bail
154
 
# out after a failed `exec'.
155
 
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
156
 
as_fn_exit 255
157
 
  fi
158
 
  # We don't want this to propagate to other subprocesses.
159
 
          { _as_can_reexec=; unset _as_can_reexec;}
160
136
if test "x$CONFIG_SHELL" = x; then
161
137
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
162
138
  emulate sh
190
166
else
191
167
  exitcode=1; echo positional parameters were not saved.
192
168
fi
193
 
test x\$exitcode = x0 || exit 1
194
 
test -x / || exit 1"
 
169
test x\$exitcode = x0 || exit 1"
195
170
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
196
171
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
197
172
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
236
211
 
237
212
 
238
213
      if test "x$CONFIG_SHELL" != x; then :
239
 
  export CONFIG_SHELL
240
 
             # We cannot yet assume a decent shell, so we have to provide a
241
 
# neutralization value for shells without unset; and this also
242
 
# works around shells that cannot unset nonexistent variables.
243
 
# Preserve -v and -x to the replacement shell.
244
 
BASH_ENV=/dev/null
245
 
ENV=/dev/null
246
 
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
247
 
case $- in # ((((
248
 
  *v*x* | *x*v* ) as_opts=-vx ;;
249
 
  *v* ) as_opts=-v ;;
250
 
  *x* ) as_opts=-x ;;
251
 
  * ) as_opts= ;;
252
 
esac
253
 
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
254
 
# Admittedly, this is quite paranoid, since all the known shells bail
255
 
# out after a failed `exec'.
256
 
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
257
 
exit 255
 
214
  # We cannot yet assume a decent shell, so we have to provide a
 
215
        # neutralization value for shells without unset; and this also
 
216
        # works around shells that cannot unset nonexistent variables.
 
217
        BASH_ENV=/dev/null
 
218
        ENV=/dev/null
 
219
        (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 
220
        export CONFIG_SHELL
 
221
        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
258
222
fi
259
223
 
260
224
    if test x$as_have_required = xno; then :
356
320
 
357
321
 
358
322
} # as_fn_mkdir_p
359
 
 
360
 
# as_fn_executable_p FILE
361
 
# -----------------------
362
 
# Test if FILE is an executable regular file.
363
 
as_fn_executable_p ()
364
 
{
365
 
  test -f "$1" && test -x "$1"
366
 
} # as_fn_executable_p
367
323
# as_fn_append VAR VALUE
368
324
# ----------------------
369
325
# Append the text in VALUE to the end of the definition contained in VAR. Take
485
441
  chmod +x "$as_me.lineno" ||
486
442
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
487
443
 
488
 
  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
489
 
  # already done that, so ensure we don't try to do so again and fall
490
 
  # in an infinite loop.  This has already happened in practice.
491
 
  _as_can_reexec=no; export _as_can_reexec
492
444
  # Don't try to exec as it changes $[0], causing all sort of problems
493
445
  # (the dirname of $[0] is not the place where we might find the
494
446
  # original and so on.  Autoconf is especially sensitive to this).
523
475
    # ... but there are two gotchas:
524
476
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
525
477
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
526
 
    # In both cases, we have to default to `cp -pR'.
 
478
    # In both cases, we have to default to `cp -p'.
527
479
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
528
 
      as_ln_s='cp -pR'
 
480
      as_ln_s='cp -p'
529
481
  elif ln conf$$.file conf$$ 2>/dev/null; then
530
482
    as_ln_s=ln
531
483
  else
532
 
    as_ln_s='cp -pR'
 
484
    as_ln_s='cp -p'
533
485
  fi
534
486
else
535
 
  as_ln_s='cp -pR'
 
487
  as_ln_s='cp -p'
536
488
fi
537
489
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
538
490
rmdir conf$$.dir 2>/dev/null
544
496
  as_mkdir_p=false
545
497
fi
546
498
 
547
 
as_test_x='test -x'
548
 
as_executable_p=as_fn_executable_p
 
499
if test -x / >/dev/null 2>&1; then
 
500
  as_test_x='test -x'
 
501
else
 
502
  if ls -dL / >/dev/null 2>&1; then
 
503
    as_ls_L_option=L
 
504
  else
 
505
    as_ls_L_option=
 
506
  fi
 
507
  as_test_x='
 
508
    eval sh -c '\''
 
509
      if test -d "$1"; then
 
510
        test -d "$1/.";
 
511
      else
 
512
        case $1 in #(
 
513
        -*)set "./$1";;
 
514
        esac;
 
515
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
 
516
        ???[sx]*):;;*)false;;esac;fi
 
517
    '\'' sh
 
518
  '
 
519
fi
 
520
as_executable_p=$as_test_x
549
521
 
550
522
# Sed expression to map a string onto a valid CPP name.
551
523
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
593
565
am__fastdepCC_FALSE
594
566
am__fastdepCC_TRUE
595
567
CCDEPMODE
596
 
am__nodep
597
568
AMDEPBACKSLASH
598
569
AMDEP_FALSE
599
570
AMDEP_TRUE
1086
1057
    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1087
1058
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1088
1059
      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1089
 
    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
 
1060
    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
1090
1061
    ;;
1091
1062
 
1092
1063
  esac
1137
1108
if test "x$host_alias" != x; then
1138
1109
  if test "x$build_alias" = x; then
1139
1110
    cross_compiling=maybe
 
1111
    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
 
1112
    If a cross compiler is detected then cross compile mode will be used" >&2
1140
1113
  elif test "x$build_alias" != "x$host_alias"; then
1141
1114
    cross_compiling=yes
1142
1115
  fi
1376
1349
if $ac_init_version; then
1377
1350
  cat <<\_ACEOF
1378
1351
libenet configure 1.0
1379
 
generated by GNU Autoconf 2.69
 
1352
generated by GNU Autoconf 2.67
1380
1353
 
1381
 
Copyright (C) 2012 Free Software Foundation, Inc.
 
1354
Copyright (C) 2010 Free Software Foundation, Inc.
1382
1355
This configure script is free software; the Free Software Foundation
1383
1356
gives unlimited permission to copy, distribute and modify it.
1384
1357
_ACEOF
1422
1395
 
1423
1396
        ac_retval=1
1424
1397
fi
1425
 
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
1398
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1426
1399
  as_fn_set_status $ac_retval
1427
1400
 
1428
1401
} # ac_fn_c_try_compile
1454
1427
         test ! -s conftest.err
1455
1428
       } && test -s conftest$ac_exeext && {
1456
1429
         test "$cross_compiling" = yes ||
1457
 
         test -x conftest$ac_exeext
 
1430
         $as_test_x conftest$ac_exeext
1458
1431
       }; then :
1459
1432
  ac_retval=0
1460
1433
else
1468
1441
  # interfere with the next link command; also delete a directory that is
1469
1442
  # left behind by Apple's compiler.  We do this before executing the actions.
1470
1443
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1471
 
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
1444
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1472
1445
  as_fn_set_status $ac_retval
1473
1446
 
1474
1447
} # ac_fn_c_try_link
1481
1454
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1482
1455
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1483
1456
$as_echo_n "checking for $2... " >&6; }
1484
 
if eval \${$3+:} false; then :
 
1457
if eval "test \"\${$3+set}\"" = set; then :
1485
1458
  $as_echo_n "(cached) " >&6
1486
1459
else
1487
1460
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1536
1509
eval ac_res=\$$3
1537
1510
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1538
1511
$as_echo "$ac_res" >&6; }
1539
 
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
1512
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1540
1513
 
1541
1514
} # ac_fn_c_check_func
1542
1515
 
1549
1522
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1550
1523
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5
1551
1524
$as_echo_n "checking for $2.$3... " >&6; }
1552
 
if eval \${$4+:} false; then :
 
1525
if eval "test \"\${$4+set}\"" = set; then :
1553
1526
  $as_echo_n "(cached) " >&6
1554
1527
else
1555
1528
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1593
1566
eval ac_res=\$$4
1594
1567
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1595
1568
$as_echo "$ac_res" >&6; }
1596
 
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
1569
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1597
1570
 
1598
1571
} # ac_fn_c_check_member
1599
1572
 
1606
1579
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1607
1580
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1608
1581
$as_echo_n "checking for $2... " >&6; }
1609
 
if eval \${$3+:} false; then :
 
1582
if eval "test \"\${$3+set}\"" = set; then :
1610
1583
  $as_echo_n "(cached) " >&6
1611
1584
else
1612
1585
  eval "$3=no"
1647
1620
eval ac_res=\$$3
1648
1621
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1649
1622
$as_echo "$ac_res" >&6; }
1650
 
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
1623
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1651
1624
 
1652
1625
} # ac_fn_c_check_type
1653
1626
 
1683
1656
 
1684
1657
    ac_retval=1
1685
1658
fi
1686
 
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
1659
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1687
1660
  as_fn_set_status $ac_retval
1688
1661
 
1689
1662
} # ac_fn_c_try_cpp
1692
1665
running configure, to aid debugging if configure makes a mistake.
1693
1666
 
1694
1667
It was created by libenet $as_me 1.0, which was
1695
 
generated by GNU Autoconf 2.69.  Invocation command line was
 
1668
generated by GNU Autoconf 2.67.  Invocation command line was
1696
1669
 
1697
1670
  $ $0 $@
1698
1671
 
1950
1923
      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
1951
1924
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
1952
1925
as_fn_error $? "failed to load site script $ac_site_file
1953
 
See \`config.log' for more details" "$LINENO" 5; }
 
1926
See \`config.log' for more details" "$LINENO" 5 ; }
1954
1927
  fi
1955
1928
done
1956
1929
 
2087
2060
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
2088
2061
$as_echo_n "checking for a BSD-compatible install... " >&6; }
2089
2062
if test -z "$INSTALL"; then
2090
 
if ${ac_cv_path_install+:} false; then :
 
2063
if test "${ac_cv_path_install+set}" = set; then :
2091
2064
  $as_echo_n "(cached) " >&6
2092
2065
else
2093
2066
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2107
2080
    # by default.
2108
2081
    for ac_prog in ginstall scoinst install; do
2109
2082
      for ac_exec_ext in '' $ac_executable_extensions; do
2110
 
        if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
 
2083
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
2111
2084
          if test $ac_prog = install &&
2112
2085
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
2113
2086
            # AIX install.  It has an incompatible calling convention.
2174
2147
'
2175
2148
case `pwd` in
2176
2149
  *[\\\"\#\$\&\'\`$am_lf]*)
2177
 
    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
 
2150
    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5 ;;
2178
2151
esac
2179
2152
case $srcdir in
2180
2153
  *[\\\"\#\$\&\'\`$am_lf\ \     ]*)
2181
 
    as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
 
2154
    as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5 ;;
2182
2155
esac
2183
2156
 
2184
2157
# Do `set' in a subshell so we don't clobber the current shell's
2264
2237
set dummy ${ac_tool_prefix}strip; ac_word=$2
2265
2238
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2266
2239
$as_echo_n "checking for $ac_word... " >&6; }
2267
 
if ${ac_cv_prog_STRIP+:} false; then :
 
2240
if test "${ac_cv_prog_STRIP+set}" = set; then :
2268
2241
  $as_echo_n "(cached) " >&6
2269
2242
else
2270
2243
  if test -n "$STRIP"; then
2276
2249
  IFS=$as_save_IFS
2277
2250
  test -z "$as_dir" && as_dir=.
2278
2251
    for ac_exec_ext in '' $ac_executable_extensions; do
2279
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2252
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2280
2253
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2281
2254
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2282
2255
    break 2
2304
2277
set dummy strip; ac_word=$2
2305
2278
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2306
2279
$as_echo_n "checking for $ac_word... " >&6; }
2307
 
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
 
2280
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then :
2308
2281
  $as_echo_n "(cached) " >&6
2309
2282
else
2310
2283
  if test -n "$ac_ct_STRIP"; then
2316
2289
  IFS=$as_save_IFS
2317
2290
  test -z "$as_dir" && as_dir=.
2318
2291
    for ac_exec_ext in '' $ac_executable_extensions; do
2319
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2292
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2320
2293
    ac_cv_prog_ac_ct_STRIP="strip"
2321
2294
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2322
2295
    break 2
2357
2330
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
2358
2331
$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
2359
2332
if test -z "$MKDIR_P"; then
2360
 
  if ${ac_cv_path_mkdir+:} false; then :
 
2333
  if test "${ac_cv_path_mkdir+set}" = set; then :
2361
2334
  $as_echo_n "(cached) " >&6
2362
2335
else
2363
2336
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2367
2340
  test -z "$as_dir" && as_dir=.
2368
2341
    for ac_prog in mkdir gmkdir; do
2369
2342
         for ac_exec_ext in '' $ac_executable_extensions; do
2370
 
           as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
 
2343
           { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue
2371
2344
           case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
2372
2345
             'mkdir (GNU coreutils) '* | \
2373
2346
             'mkdir (coreutils) '* | \
2408
2381
set dummy $ac_prog; ac_word=$2
2409
2382
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2410
2383
$as_echo_n "checking for $ac_word... " >&6; }
2411
 
if ${ac_cv_prog_AWK+:} false; then :
 
2384
if test "${ac_cv_prog_AWK+set}" = set; then :
2412
2385
  $as_echo_n "(cached) " >&6
2413
2386
else
2414
2387
  if test -n "$AWK"; then
2420
2393
  IFS=$as_save_IFS
2421
2394
  test -z "$as_dir" && as_dir=.
2422
2395
    for ac_exec_ext in '' $ac_executable_extensions; do
2423
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2396
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2424
2397
    ac_cv_prog_AWK="$ac_prog"
2425
2398
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2426
2399
    break 2
2448
2421
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
2449
2422
set x ${MAKE-make}
2450
2423
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
2451
 
if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
 
2424
if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\"" = set; then :
2452
2425
  $as_echo_n "(cached) " >&6
2453
2426
else
2454
2427
  cat >conftest.make <<\_ACEOF
2536
2509
 
2537
2510
# We need awk for the "check" target.  The system "awk" is bad on
2538
2511
# some platforms.
2539
 
# Always define AMTAR for backward compatibility.  Yes, it's still used
2540
 
# in the wild :-(  We should find a proper way to deprecate it ...
2541
 
AMTAR='$${TAR-tar}'
2542
 
 
2543
 
am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
 
2512
# Always define AMTAR for backward compatibility.
 
2513
 
 
2514
AMTAR=${AMTAR-"${am_missing_run}tar"}
 
2515
 
 
2516
am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
2544
2517
 
2545
2518
 
2546
2519
 
2557
2530
set dummy ${ac_tool_prefix}gcc; ac_word=$2
2558
2531
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2559
2532
$as_echo_n "checking for $ac_word... " >&6; }
2560
 
if ${ac_cv_prog_CC+:} false; then :
 
2533
if test "${ac_cv_prog_CC+set}" = set; then :
2561
2534
  $as_echo_n "(cached) " >&6
2562
2535
else
2563
2536
  if test -n "$CC"; then
2569
2542
  IFS=$as_save_IFS
2570
2543
  test -z "$as_dir" && as_dir=.
2571
2544
    for ac_exec_ext in '' $ac_executable_extensions; do
2572
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2545
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2573
2546
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
2574
2547
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2575
2548
    break 2
2597
2570
set dummy gcc; ac_word=$2
2598
2571
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2599
2572
$as_echo_n "checking for $ac_word... " >&6; }
2600
 
if ${ac_cv_prog_ac_ct_CC+:} false; then :
 
2573
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
2601
2574
  $as_echo_n "(cached) " >&6
2602
2575
else
2603
2576
  if test -n "$ac_ct_CC"; then
2609
2582
  IFS=$as_save_IFS
2610
2583
  test -z "$as_dir" && as_dir=.
2611
2584
    for ac_exec_ext in '' $ac_executable_extensions; do
2612
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2585
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2613
2586
    ac_cv_prog_ac_ct_CC="gcc"
2614
2587
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2615
2588
    break 2
2650
2623
set dummy ${ac_tool_prefix}cc; ac_word=$2
2651
2624
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2652
2625
$as_echo_n "checking for $ac_word... " >&6; }
2653
 
if ${ac_cv_prog_CC+:} false; then :
 
2626
if test "${ac_cv_prog_CC+set}" = set; then :
2654
2627
  $as_echo_n "(cached) " >&6
2655
2628
else
2656
2629
  if test -n "$CC"; then
2662
2635
  IFS=$as_save_IFS
2663
2636
  test -z "$as_dir" && as_dir=.
2664
2637
    for ac_exec_ext in '' $ac_executable_extensions; do
2665
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2638
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2666
2639
    ac_cv_prog_CC="${ac_tool_prefix}cc"
2667
2640
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2668
2641
    break 2
2690
2663
set dummy cc; ac_word=$2
2691
2664
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2692
2665
$as_echo_n "checking for $ac_word... " >&6; }
2693
 
if ${ac_cv_prog_CC+:} false; then :
 
2666
if test "${ac_cv_prog_CC+set}" = set; then :
2694
2667
  $as_echo_n "(cached) " >&6
2695
2668
else
2696
2669
  if test -n "$CC"; then
2703
2676
  IFS=$as_save_IFS
2704
2677
  test -z "$as_dir" && as_dir=.
2705
2678
    for ac_exec_ext in '' $ac_executable_extensions; do
2706
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2679
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2707
2680
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2708
2681
       ac_prog_rejected=yes
2709
2682
       continue
2749
2722
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2750
2723
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2751
2724
$as_echo_n "checking for $ac_word... " >&6; }
2752
 
if ${ac_cv_prog_CC+:} false; then :
 
2725
if test "${ac_cv_prog_CC+set}" = set; then :
2753
2726
  $as_echo_n "(cached) " >&6
2754
2727
else
2755
2728
  if test -n "$CC"; then
2761
2734
  IFS=$as_save_IFS
2762
2735
  test -z "$as_dir" && as_dir=.
2763
2736
    for ac_exec_ext in '' $ac_executable_extensions; do
2764
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2737
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2765
2738
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2766
2739
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2767
2740
    break 2
2793
2766
set dummy $ac_prog; ac_word=$2
2794
2767
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2795
2768
$as_echo_n "checking for $ac_word... " >&6; }
2796
 
if ${ac_cv_prog_ac_ct_CC+:} false; then :
 
2769
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
2797
2770
  $as_echo_n "(cached) " >&6
2798
2771
else
2799
2772
  if test -n "$ac_ct_CC"; then
2805
2778
  IFS=$as_save_IFS
2806
2779
  test -z "$as_dir" && as_dir=.
2807
2780
    for ac_exec_ext in '' $ac_executable_extensions; do
2808
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
2781
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2809
2782
    ac_cv_prog_ac_ct_CC="$ac_prog"
2810
2783
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2811
2784
    break 2
2848
2821
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2849
2822
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2850
2823
as_fn_error $? "no acceptable C compiler found in \$PATH
2851
 
See \`config.log' for more details" "$LINENO" 5; }
 
2824
See \`config.log' for more details" "$LINENO" 5 ; }
2852
2825
 
2853
2826
# Provide some information about the compiler.
2854
2827
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
2963
2936
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2964
2937
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2965
2938
as_fn_error 77 "C compiler cannot create executables
2966
 
See \`config.log' for more details" "$LINENO" 5; }
 
2939
See \`config.log' for more details" "$LINENO" 5 ; }
2967
2940
else
2968
2941
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
2969
2942
$as_echo "yes" >&6; }
3006
2979
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3007
2980
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3008
2981
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
3009
 
See \`config.log' for more details" "$LINENO" 5; }
 
2982
See \`config.log' for more details" "$LINENO" 5 ; }
3010
2983
fi
3011
2984
rm -f conftest conftest$ac_cv_exeext
3012
2985
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3065
3038
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3066
3039
as_fn_error $? "cannot run C compiled programs.
3067
3040
If you meant to cross compile, use \`--host'.
3068
 
See \`config.log' for more details" "$LINENO" 5; }
 
3041
See \`config.log' for more details" "$LINENO" 5 ; }
3069
3042
    fi
3070
3043
  fi
3071
3044
fi
3076
3049
ac_clean_files=$ac_clean_files_save
3077
3050
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3078
3051
$as_echo_n "checking for suffix of object files... " >&6; }
3079
 
if ${ac_cv_objext+:} false; then :
 
3052
if test "${ac_cv_objext+set}" = set; then :
3080
3053
  $as_echo_n "(cached) " >&6
3081
3054
else
3082
3055
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3117
3090
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3118
3091
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3119
3092
as_fn_error $? "cannot compute suffix of object files: cannot compile
3120
 
See \`config.log' for more details" "$LINENO" 5; }
 
3093
See \`config.log' for more details" "$LINENO" 5 ; }
3121
3094
fi
3122
3095
rm -f conftest.$ac_cv_objext conftest.$ac_ext
3123
3096
fi
3127
3100
ac_objext=$OBJEXT
3128
3101
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
3129
3102
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3130
 
if ${ac_cv_c_compiler_gnu+:} false; then :
 
3103
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
3131
3104
  $as_echo_n "(cached) " >&6
3132
3105
else
3133
3106
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3164
3137
ac_save_CFLAGS=$CFLAGS
3165
3138
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
3166
3139
$as_echo_n "checking whether $CC accepts -g... " >&6; }
3167
 
if ${ac_cv_prog_cc_g+:} false; then :
 
3140
if test "${ac_cv_prog_cc_g+set}" = set; then :
3168
3141
  $as_echo_n "(cached) " >&6
3169
3142
else
3170
3143
  ac_save_c_werror_flag=$ac_c_werror_flag
3242
3215
fi
3243
3216
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
3244
3217
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
3245
 
if ${ac_cv_prog_cc_c89+:} false; then :
 
3218
if test "${ac_cv_prog_cc_c89+set}" = set; then :
3246
3219
  $as_echo_n "(cached) " >&6
3247
3220
else
3248
3221
  ac_cv_prog_cc_c89=no
3251
3224
/* end confdefs.h.  */
3252
3225
#include <stdarg.h>
3253
3226
#include <stdio.h>
3254
 
struct stat;
 
3227
#include <sys/types.h>
 
3228
#include <sys/stat.h>
3255
3229
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3256
3230
struct buf { int x; };
3257
3231
FILE * (*rcsopen) (struct buf *, struct stat *, int);
3387
3361
if test "x$enable_dependency_tracking" != xno; then
3388
3362
  am_depcomp="$ac_aux_dir/depcomp"
3389
3363
  AMDEPBACKSLASH='\'
3390
 
  am__nodep='_no'
3391
3364
fi
3392
3365
 if test "x$enable_dependency_tracking" != xno; then
3393
3366
  AMDEP_TRUE=
3403
3376
 
3404
3377
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
3405
3378
$as_echo_n "checking dependency style of $depcc... " >&6; }
3406
 
if ${am_cv_CC_dependencies_compiler_type+:} false; then :
 
3379
if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then :
3407
3380
  $as_echo_n "(cached) " >&6
3408
3381
else
3409
3382
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3412
3385
  # instance it was reported that on HP-UX the gcc test will end up
3413
3386
  # making a dummy file named `D' -- because `-MD' means `put the output
3414
3387
  # in D'.
3415
 
  rm -rf conftest.dir
3416
3388
  mkdir conftest.dir
3417
3389
  # Copy depcomp to subdir because otherwise we won't find it if we're
3418
3390
  # using a relative directory.
3472
3444
        break
3473
3445
      fi
3474
3446
      ;;
3475
 
    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
 
3447
    msvisualcpp | msvcmsys)
3476
3448
      # This compiler won't grok `-c -o', but also, the minuso test has
3477
3449
      # not run yet.  These depmodes are late enough in the game, and
3478
3450
      # so weak that their functioning should not be impacted.
3532
3504
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3533
3505
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3534
3506
$as_echo_n "checking for $ac_word... " >&6; }
3535
 
if ${ac_cv_prog_RANLIB+:} false; then :
 
3507
if test "${ac_cv_prog_RANLIB+set}" = set; then :
3536
3508
  $as_echo_n "(cached) " >&6
3537
3509
else
3538
3510
  if test -n "$RANLIB"; then
3544
3516
  IFS=$as_save_IFS
3545
3517
  test -z "$as_dir" && as_dir=.
3546
3518
    for ac_exec_ext in '' $ac_executable_extensions; do
3547
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3519
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3548
3520
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3549
3521
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3550
3522
    break 2
3572
3544
set dummy ranlib; ac_word=$2
3573
3545
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3574
3546
$as_echo_n "checking for $ac_word... " >&6; }
3575
 
if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
 
3547
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then :
3576
3548
  $as_echo_n "(cached) " >&6
3577
3549
else
3578
3550
  if test -n "$ac_ct_RANLIB"; then
3584
3556
  IFS=$as_save_IFS
3585
3557
  test -z "$as_dir" && as_dir=.
3586
3558
    for ac_exec_ext in '' $ac_executable_extensions; do
3587
 
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3559
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3588
3560
    ac_cv_prog_ac_ct_RANLIB="ranlib"
3589
3561
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3590
3562
    break 2
3622
3594
 
3623
3595
 
3624
3596
ac_fn_c_check_func "$LINENO" "gethostbyaddr_r" "ac_cv_func_gethostbyaddr_r"
3625
 
if test "x$ac_cv_func_gethostbyaddr_r" = xyes; then :
 
3597
if test "x$ac_cv_func_gethostbyaddr_r" = x""yes; then :
3626
3598
  $as_echo "#define HAS_GETHOSTBYADDR_R 1" >>confdefs.h
3627
3599
 
3628
3600
fi
3629
3601
 
3630
3602
ac_fn_c_check_func "$LINENO" "gethostbyname_r" "ac_cv_func_gethostbyname_r"
3631
 
if test "x$ac_cv_func_gethostbyname_r" = xyes; then :
 
3603
if test "x$ac_cv_func_gethostbyname_r" = x""yes; then :
3632
3604
  $as_echo "#define HAS_GETHOSTBYNAME_R 1" >>confdefs.h
3633
3605
 
3634
3606
fi
3635
3607
 
3636
3608
ac_fn_c_check_func "$LINENO" "poll" "ac_cv_func_poll"
3637
 
if test "x$ac_cv_func_poll" = xyes; then :
 
3609
if test "x$ac_cv_func_poll" = x""yes; then :
3638
3610
  $as_echo "#define HAS_POLL 1" >>confdefs.h
3639
3611
 
3640
3612
fi
3641
3613
 
3642
3614
ac_fn_c_check_func "$LINENO" "fcntl" "ac_cv_func_fcntl"
3643
 
if test "x$ac_cv_func_fcntl" = xyes; then :
 
3615
if test "x$ac_cv_func_fcntl" = x""yes; then :
3644
3616
  $as_echo "#define HAS_FCNTL 1" >>confdefs.h
3645
3617
 
3646
3618
fi
3647
3619
 
3648
3620
ac_fn_c_check_func "$LINENO" "inet_pton" "ac_cv_func_inet_pton"
3649
 
if test "x$ac_cv_func_inet_pton" = xyes; then :
 
3621
if test "x$ac_cv_func_inet_pton" = x""yes; then :
3650
3622
  $as_echo "#define HAS_INET_PTON 1" >>confdefs.h
3651
3623
 
3652
3624
fi
3653
3625
 
3654
3626
ac_fn_c_check_func "$LINENO" "inet_ntop" "ac_cv_func_inet_ntop"
3655
 
if test "x$ac_cv_func_inet_ntop" = xyes; then :
 
3627
if test "x$ac_cv_func_inet_ntop" = x""yes; then :
3656
3628
  $as_echo "#define HAS_INET_NTOP 1" >>confdefs.h
3657
3629
 
3658
3630
fi
3660
3632
 
3661
3633
ac_fn_c_check_member "$LINENO" "struct msghdr" "msg_flags" "ac_cv_member_struct_msghdr_msg_flags" "#include <sys/socket.h>
3662
3634
"
3663
 
if test "x$ac_cv_member_struct_msghdr_msg_flags" = xyes; then :
 
3635
if test "x$ac_cv_member_struct_msghdr_msg_flags" = x""yes; then :
3664
3636
  $as_echo "#define HAS_MSGHDR_FLAGS 1" >>confdefs.h
3665
3637
 
3666
3638
fi
3670
3642
              #include <sys/socket.h>
3671
3643
 
3672
3644
"
3673
 
if test "x$ac_cv_type_socklen_t" = xyes; then :
 
3645
if test "x$ac_cv_type_socklen_t" = x""yes; then :
3674
3646
  $as_echo "#define HAS_SOCKLEN_T 1" >>confdefs.h
3675
3647
 
3676
3648
fi
3688
3660
  CPP=
3689
3661
fi
3690
3662
if test -z "$CPP"; then
3691
 
  if ${ac_cv_prog_CPP+:} false; then :
 
3663
  if test "${ac_cv_prog_CPP+set}" = set; then :
3692
3664
  $as_echo_n "(cached) " >&6
3693
3665
else
3694
3666
      # Double quotes because CPP needs to be expanded
3804
3776
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3805
3777
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3806
3778
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
3807
 
See \`config.log' for more details" "$LINENO" 5; }
 
3779
See \`config.log' for more details" "$LINENO" 5 ; }
3808
3780
fi
3809
3781
 
3810
3782
ac_ext=c
3816
3788
 
3817
3789
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
3818
3790
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
3819
 
if ${ac_cv_path_GREP+:} false; then :
 
3791
if test "${ac_cv_path_GREP+set}" = set; then :
3820
3792
  $as_echo_n "(cached) " >&6
3821
3793
else
3822
3794
  if test -z "$GREP"; then
3830
3802
    for ac_prog in grep ggrep; do
3831
3803
    for ac_exec_ext in '' $ac_executable_extensions; do
3832
3804
      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
3833
 
      as_fn_executable_p "$ac_path_GREP" || continue
 
3805
      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
3834
3806
# Check for GNU ac_path_GREP and select it if it is found.
3835
3807
  # Check for GNU $ac_path_GREP
3836
3808
case `"$ac_path_GREP" --version 2>&1` in
3879
3851
 
3880
3852
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
3881
3853
$as_echo_n "checking for egrep... " >&6; }
3882
 
if ${ac_cv_path_EGREP+:} false; then :
 
3854
if test "${ac_cv_path_EGREP+set}" = set; then :
3883
3855
  $as_echo_n "(cached) " >&6
3884
3856
else
3885
3857
  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
3896
3868
    for ac_prog in egrep; do
3897
3869
    for ac_exec_ext in '' $ac_executable_extensions; do
3898
3870
      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
3899
 
      as_fn_executable_p "$ac_path_EGREP" || continue
 
3871
      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
3900
3872
# Check for GNU ac_path_EGREP and select it if it is found.
3901
3873
  # Check for GNU $ac_path_EGREP
3902
3874
case `"$ac_path_EGREP" --version 2>&1` in
4035
4007
     :end' >>confcache
4036
4008
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
4037
4009
  if test -w "$cache_file"; then
4038
 
    if test "x$cache_file" != "x/dev/null"; then
 
4010
    test "x$cache_file" != "x/dev/null" &&
4039
4011
      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
4040
4012
$as_echo "$as_me: updating cache $cache_file" >&6;}
4041
 
      if test ! -f "$cache_file" || test -h "$cache_file"; then
4042
 
        cat confcache >"$cache_file"
4043
 
      else
4044
 
        case $cache_file in #(
4045
 
        */* | ?:*)
4046
 
          mv -f confcache "$cache_file"$$ &&
4047
 
          mv -f "$cache_file"$$ "$cache_file" ;; #(
4048
 
        *)
4049
 
          mv -f confcache "$cache_file" ;;
4050
 
        esac
4051
 
      fi
4052
 
    fi
 
4013
    cat confcache >$cache_file
4053
4014
  else
4054
4015
    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
4055
4016
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
4133
4094
Usually this means the macro was only invoked conditionally." "$LINENO" 5
4134
4095
fi
4135
4096
 
4136
 
: "${CONFIG_STATUS=./config.status}"
 
4097
: ${CONFIG_STATUS=./config.status}
4137
4098
ac_write_fail=0
4138
4099
ac_clean_files_save=$ac_clean_files
4139
4100
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
4234
4195
IFS=" ""        $as_nl"
4235
4196
 
4236
4197
# Find who we are.  Look in the path if we contain no directory separator.
4237
 
as_myself=
4238
4198
case $0 in #((
4239
4199
  *[\\/]* ) as_myself=$0 ;;
4240
4200
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4430
4390
    # ... but there are two gotchas:
4431
4391
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
4432
4392
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
4433
 
    # In both cases, we have to default to `cp -pR'.
 
4393
    # In both cases, we have to default to `cp -p'.
4434
4394
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
4435
 
      as_ln_s='cp -pR'
 
4395
      as_ln_s='cp -p'
4436
4396
  elif ln conf$$.file conf$$ 2>/dev/null; then
4437
4397
    as_ln_s=ln
4438
4398
  else
4439
 
    as_ln_s='cp -pR'
 
4399
    as_ln_s='cp -p'
4440
4400
  fi
4441
4401
else
4442
 
  as_ln_s='cp -pR'
 
4402
  as_ln_s='cp -p'
4443
4403
fi
4444
4404
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
4445
4405
rmdir conf$$.dir 2>/dev/null
4499
4459
  as_mkdir_p=false
4500
4460
fi
4501
4461
 
4502
 
 
4503
 
# as_fn_executable_p FILE
4504
 
# -----------------------
4505
 
# Test if FILE is an executable regular file.
4506
 
as_fn_executable_p ()
4507
 
{
4508
 
  test -f "$1" && test -x "$1"
4509
 
} # as_fn_executable_p
4510
 
as_test_x='test -x'
4511
 
as_executable_p=as_fn_executable_p
 
4462
if test -x / >/dev/null 2>&1; then
 
4463
  as_test_x='test -x'
 
4464
else
 
4465
  if ls -dL / >/dev/null 2>&1; then
 
4466
    as_ls_L_option=L
 
4467
  else
 
4468
    as_ls_L_option=
 
4469
  fi
 
4470
  as_test_x='
 
4471
    eval sh -c '\''
 
4472
      if test -d "$1"; then
 
4473
        test -d "$1/.";
 
4474
      else
 
4475
        case $1 in #(
 
4476
        -*)set "./$1";;
 
4477
        esac;
 
4478
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
 
4479
        ???[sx]*):;;*)false;;esac;fi
 
4480
    '\'' sh
 
4481
  '
 
4482
fi
 
4483
as_executable_p=$as_test_x
4512
4484
 
4513
4485
# Sed expression to map a string onto a valid CPP name.
4514
4486
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
4530
4502
# values after options handling.
4531
4503
ac_log="
4532
4504
This file was extended by libenet $as_me 1.0, which was
4533
 
generated by GNU Autoconf 2.69.  Invocation command line was
 
4505
generated by GNU Autoconf 2.67.  Invocation command line was
4534
4506
 
4535
4507
  CONFIG_FILES    = $CONFIG_FILES
4536
4508
  CONFIG_HEADERS  = $CONFIG_HEADERS
4587
4559
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
4588
4560
ac_cs_version="\\
4589
4561
libenet config.status 1.0
4590
 
configured by $0, generated by GNU Autoconf 2.69,
 
4562
configured by $0, generated by GNU Autoconf 2.67,
4591
4563
  with options \\"\$ac_cs_config\\"
4592
4564
 
4593
 
Copyright (C) 2012 Free Software Foundation, Inc.
 
4565
Copyright (C) 2010 Free Software Foundation, Inc.
4594
4566
This config.status script is free software; the Free Software Foundation
4595
4567
gives unlimited permission to copy, distribute and modify it."
4596
4568
 
4670
4642
_ACEOF
4671
4643
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
4672
4644
if \$ac_cs_recheck; then
4673
 
  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
 
4645
  set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
4674
4646
  shift
4675
4647
  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
4676
4648
  CONFIG_SHELL='$SHELL'
4709
4681
    "include/Makefile") CONFIG_FILES="$CONFIG_FILES include/Makefile" ;;
4710
4682
    "include/enet/Makefile") CONFIG_FILES="$CONFIG_FILES include/enet/Makefile" ;;
4711
4683
 
4712
 
  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
 
4684
  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;;
4713
4685
  esac
4714
4686
done
4715
4687
 
4731
4703
# after its creation but before its name has been assigned to `$tmp'.
4732
4704
$debug ||
4733
4705
{
4734
 
  tmp= ac_tmp=
 
4706
  tmp=
4735
4707
  trap 'exit_status=$?
4736
 
  : "${ac_tmp:=$tmp}"
4737
 
  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
 
4708
  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
4738
4709
' 0
4739
4710
  trap 'as_fn_exit 1' 1 2 13 15
4740
4711
}
4742
4713
 
4743
4714
{
4744
4715
  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
4745
 
  test -d "$tmp"
 
4716
  test -n "$tmp" && test -d "$tmp"
4746
4717
}  ||
4747
4718
{
4748
4719
  tmp=./conf$$-$RANDOM
4749
4720
  (umask 077 && mkdir "$tmp")
4750
4721
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
4751
 
ac_tmp=$tmp
4752
4722
 
4753
4723
# Set up the scripts for CONFIG_FILES section.
4754
4724
# No need to generate them if there are no CONFIG_FILES.
4770
4740
  ac_cs_awk_cr=$ac_cr
4771
4741
fi
4772
4742
 
4773
 
echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
 
4743
echo 'BEGIN {' >"$tmp/subs1.awk" &&
4774
4744
_ACEOF
4775
4745
 
4776
4746
 
4798
4768
rm -f conf$$subs.sh
4799
4769
 
4800
4770
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
4801
 
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
 
4771
cat >>"\$tmp/subs1.awk" <<\\_ACAWK &&
4802
4772
_ACEOF
4803
4773
sed -n '
4804
4774
h
4846
4816
rm -f conf$$subs.awk
4847
4817
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
4848
4818
_ACAWK
4849
 
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
 
4819
cat >>"\$tmp/subs1.awk" <<_ACAWK &&
4850
4820
  for (key in S) S_is_set[key] = 1
4851
4821
  FS = ""
4852
4822
 
4878
4848
  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
4879
4849
else
4880
4850
  cat
4881
 
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
 
4851
fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
4882
4852
  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
4883
4853
_ACEOF
4884
4854
 
4918
4888
  esac
4919
4889
  case $ac_mode$ac_tag in
4920
4890
  :[FHL]*:*);;
4921
 
  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
 
4891
  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;;
4922
4892
  :[FH]-) ac_tag=-:-;;
4923
4893
  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
4924
4894
  esac
4937
4907
    for ac_f
4938
4908
    do
4939
4909
      case $ac_f in
4940
 
      -) ac_f="$ac_tmp/stdin";;
 
4910
      -) ac_f="$tmp/stdin";;
4941
4911
      *) # Look for the file first in the build tree, then in the source tree
4942
4912
         # (if the path is not absolute).  The absolute path cannot be DOS-style,
4943
4913
         # because $ac_f cannot contain `:'.
4946
4916
           [\\/$]*) false;;
4947
4917
           *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
4948
4918
           esac ||
4949
 
           as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
 
4919
           as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;;
4950
4920
      esac
4951
4921
      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
4952
4922
      as_fn_append ac_file_inputs " '$ac_f'"
4972
4942
    esac
4973
4943
 
4974
4944
    case $ac_tag in
4975
 
    *:-:* | *:-) cat >"$ac_tmp/stdin" \
4976
 
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
 
4945
    *:-:* | *:-) cat >"$tmp/stdin" \
 
4946
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5  ;;
4977
4947
    esac
4978
4948
    ;;
4979
4949
  esac
5109
5079
s&@MKDIR_P@&$ac_MKDIR_P&;t t
5110
5080
$ac_datarootdir_hack
5111
5081
"
5112
 
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
5113
 
  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
 
5082
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
 
5083
  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
5114
5084
 
5115
5085
test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
5116
 
  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
5117
 
  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' \
5118
 
      "$ac_tmp/out"`; test -z "$ac_out"; } &&
 
5086
  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
 
5087
  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
5119
5088
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
5120
5089
which seems to be undefined.  Please make sure it is defined" >&5
5121
5090
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
5122
5091
which seems to be undefined.  Please make sure it is defined" >&2;}
5123
5092
 
5124
 
  rm -f "$ac_tmp/stdin"
 
5093
  rm -f "$tmp/stdin"
5125
5094
  case $ac_file in
5126
 
  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
5127
 
  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
 
5095
  -) cat "$tmp/out" && rm -f "$tmp/out";;
 
5096
  *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
5128
5097
  esac \
5129
5098
  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
5130
5099
 ;;