Changeset 1403 for trunk/configure


Ignore:
Timestamp:
Apr 17, 2009, 1:18:03 PM (11 years ago)
Author:
gah
Message:

Fix for no sysinfo on OSX

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/configure

    r1386 r1403  
    19461946
    19471947
     1948ac_config_headers="$ac_config_headers src/core/config.h"
     1949
    19481950
    19491951#------------------------------------------------------------------------
     
    45644566
    45654567
     4568for ac_func in sysinfo
     4569do
     4570as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
     4571{ $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
     4572$as_echo_n "checking for $ac_func... " >&6; }
     4573if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
     4574  $as_echo_n "(cached) " >&6
     4575else
     4576  cat >conftest.$ac_ext <<_ACEOF
     4577/* confdefs.h.  */
     4578_ACEOF
     4579cat confdefs.h >>conftest.$ac_ext
     4580cat >>conftest.$ac_ext <<_ACEOF
     4581/* end confdefs.h.  */
     4582/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
     4583   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
     4584#define $ac_func innocuous_$ac_func
     4585
     4586/* System header to define __stub macros and hopefully few prototypes,
     4587    which can conflict with char $ac_func (); below.
     4588    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     4589    <limits.h> exists even on freestanding compilers.  */
     4590
     4591#ifdef __STDC__
     4592# include <limits.h>
     4593#else
     4594# include <assert.h>
     4595#endif
     4596
     4597#undef $ac_func
     4598
     4599/* Override any GCC internal prototype to avoid an error.
     4600   Use char because int might match the return type of a GCC
     4601   builtin and then its argument prototype would still apply.  */
     4602#ifdef __cplusplus
     4603extern "C"
     4604#endif
     4605char $ac_func ();
     4606/* The GNU C library defines this for functions which it implements
     4607    to always fail with ENOSYS.  Some functions are actually named
     4608    something starting with __ and the normal name is an alias.  */
     4609#if defined __stub_$ac_func || defined __stub___$ac_func
     4610choke me
     4611#endif
     4612
     4613int
     4614main ()
     4615{
     4616return $ac_func ();
     4617  ;
     4618  return 0;
     4619}
     4620_ACEOF
     4621rm -f conftest.$ac_objext conftest$ac_exeext
     4622if { (ac_try="$ac_link"
     4623case "(($ac_try" in
     4624  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     4625  *) ac_try_echo=$ac_try;;
     4626esac
     4627eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     4628$as_echo "$ac_try_echo") >&5
     4629  (eval "$ac_link") 2>conftest.er1
     4630  ac_status=$?
     4631  grep -v '^ *+' conftest.er1 >conftest.err
     4632  rm -f conftest.er1
     4633  cat conftest.err >&5
     4634  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4635  (exit $ac_status); } && {
     4636         test -z "$ac_cxx_werror_flag" ||
     4637         test ! -s conftest.err
     4638       } && test -s conftest$ac_exeext && {
     4639         test "$cross_compiling" = yes ||
     4640         $as_test_x conftest$ac_exeext
     4641       }; then
     4642  eval "$as_ac_var=yes"
     4643else
     4644  $as_echo "$as_me: failed program was:" >&5
     4645sed 's/^/| /' conftest.$ac_ext >&5
     4646
     4647        eval "$as_ac_var=no"
     4648fi
     4649
     4650rm -rf conftest.dSYM
     4651rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
     4652      conftest$ac_exeext conftest.$ac_ext
     4653fi
     4654ac_res=`eval 'as_val=${'$as_ac_var'}
     4655                 $as_echo "$as_val"'`
     4656               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
     4657$as_echo "$ac_res" >&6; }
     4658as_val=`eval 'as_val=${'$as_ac_var'}
     4659                 $as_echo "$as_val"'`
     4660   if test "x$as_val" = x""yes; then
     4661  cat >>confdefs.h <<_ACEOF
     4662#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
     4663_ACEOF
     4664
     4665fi
     4666done
     4667
     4668# On IRIX 5.3, sys/types and inttypes.h are conflicting.
     4669
     4670
     4671
     4672
     4673
     4674
     4675
     4676
     4677
     4678for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
     4679                  inttypes.h stdint.h unistd.h
     4680do
     4681as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
     4682{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
     4683$as_echo_n "checking for $ac_header... " >&6; }
     4684if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
     4685  $as_echo_n "(cached) " >&6
     4686else
     4687  cat >conftest.$ac_ext <<_ACEOF
     4688/* confdefs.h.  */
     4689_ACEOF
     4690cat confdefs.h >>conftest.$ac_ext
     4691cat >>conftest.$ac_ext <<_ACEOF
     4692/* end confdefs.h.  */
     4693$ac_includes_default
     4694
     4695#include <$ac_header>
     4696_ACEOF
     4697rm -f conftest.$ac_objext
     4698if { (ac_try="$ac_compile"
     4699case "(($ac_try" in
     4700  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     4701  *) ac_try_echo=$ac_try;;
     4702esac
     4703eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     4704$as_echo "$ac_try_echo") >&5
     4705  (eval "$ac_compile") 2>conftest.er1
     4706  ac_status=$?
     4707  grep -v '^ *+' conftest.er1 >conftest.err
     4708  rm -f conftest.er1
     4709  cat conftest.err >&5
     4710  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4711  (exit $ac_status); } && {
     4712         test -z "$ac_cxx_werror_flag" ||
     4713         test ! -s conftest.err
     4714       } && test -s conftest.$ac_objext; then
     4715  eval "$as_ac_Header=yes"
     4716else
     4717  $as_echo "$as_me: failed program was:" >&5
     4718sed 's/^/| /' conftest.$ac_ext >&5
     4719
     4720        eval "$as_ac_Header=no"
     4721fi
     4722
     4723rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     4724fi
     4725ac_res=`eval 'as_val=${'$as_ac_Header'}
     4726                 $as_echo "$as_val"'`
     4727               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
     4728$as_echo "$ac_res" >&6; }
     4729as_val=`eval 'as_val=${'$as_ac_Header'}
     4730                 $as_echo "$as_val"'`
     4731   if test "x$as_val" = x""yes; then
     4732  cat >>confdefs.h <<_ACEOF
     4733#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
     4734_ACEOF
     4735
     4736fi
     4737
     4738done
     4739
     4740
     4741ac_ext=cpp
     4742ac_cpp='$CXXCPP $CPPFLAGS'
     4743ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4744ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4745ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     4746{ $as_echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
     4747$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
     4748if test -z "$CXXCPP"; then
     4749  if test "${ac_cv_prog_CXXCPP+set}" = set; then
     4750  $as_echo_n "(cached) " >&6
     4751else
     4752      # Double quotes because CXXCPP needs to be expanded
     4753    for CXXCPP in "$CXX -E" "/lib/cpp"
     4754    do
     4755      ac_preproc_ok=false
     4756for ac_cxx_preproc_warn_flag in '' yes
     4757do
     4758  # Use a header file that comes with gcc, so configuring glibc
     4759  # with a fresh cross-compiler works.
     4760  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     4761  # <limits.h> exists even on freestanding compilers.
     4762  # On the NeXT, cc -E runs the code through the compiler's parser,
     4763  # not just through cpp. "Syntax error" is here to catch this case.
     4764  cat >conftest.$ac_ext <<_ACEOF
     4765/* confdefs.h.  */
     4766_ACEOF
     4767cat confdefs.h >>conftest.$ac_ext
     4768cat >>conftest.$ac_ext <<_ACEOF
     4769/* end confdefs.h.  */
     4770#ifdef __STDC__
     4771# include <limits.h>
     4772#else
     4773# include <assert.h>
     4774#endif
     4775                     Syntax error
     4776_ACEOF
     4777if { (ac_try="$ac_cpp conftest.$ac_ext"
     4778case "(($ac_try" in
     4779  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     4780  *) ac_try_echo=$ac_try;;
     4781esac
     4782eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     4783$as_echo "$ac_try_echo") >&5
     4784  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     4785  ac_status=$?
     4786  grep -v '^ *+' conftest.er1 >conftest.err
     4787  rm -f conftest.er1
     4788  cat conftest.err >&5
     4789  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4790  (exit $ac_status); } >/dev/null && {
     4791         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
     4792         test ! -s conftest.err
     4793       }; then
     4794  :
     4795else
     4796  $as_echo "$as_me: failed program was:" >&5
     4797sed 's/^/| /' conftest.$ac_ext >&5
     4798
     4799  # Broken: fails on valid input.
     4800continue
     4801fi
     4802
     4803rm -f conftest.err conftest.$ac_ext
     4804
     4805  # OK, works on sane cases.  Now check whether nonexistent headers
     4806  # can be detected and how.
     4807  cat >conftest.$ac_ext <<_ACEOF
     4808/* confdefs.h.  */
     4809_ACEOF
     4810cat confdefs.h >>conftest.$ac_ext
     4811cat >>conftest.$ac_ext <<_ACEOF
     4812/* end confdefs.h.  */
     4813#include <ac_nonexistent.h>
     4814_ACEOF
     4815if { (ac_try="$ac_cpp conftest.$ac_ext"
     4816case "(($ac_try" in
     4817  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     4818  *) ac_try_echo=$ac_try;;
     4819esac
     4820eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     4821$as_echo "$ac_try_echo") >&5
     4822  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     4823  ac_status=$?
     4824  grep -v '^ *+' conftest.er1 >conftest.err
     4825  rm -f conftest.er1
     4826  cat conftest.err >&5
     4827  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4828  (exit $ac_status); } >/dev/null && {
     4829         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
     4830         test ! -s conftest.err
     4831       }; then
     4832  # Broken: success on invalid input.
     4833continue
     4834else
     4835  $as_echo "$as_me: failed program was:" >&5
     4836sed 's/^/| /' conftest.$ac_ext >&5
     4837
     4838  # Passes both tests.
     4839ac_preproc_ok=:
     4840break
     4841fi
     4842
     4843rm -f conftest.err conftest.$ac_ext
     4844
     4845done
     4846# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     4847rm -f conftest.err conftest.$ac_ext
     4848if $ac_preproc_ok; then
     4849  break
     4850fi
     4851
     4852    done
     4853    ac_cv_prog_CXXCPP=$CXXCPP
     4854
     4855fi
     4856  CXXCPP=$ac_cv_prog_CXXCPP
     4857else
     4858  ac_cv_prog_CXXCPP=$CXXCPP
     4859fi
     4860{ $as_echo "$as_me:$LINENO: result: $CXXCPP" >&5
     4861$as_echo "$CXXCPP" >&6; }
     4862ac_preproc_ok=false
     4863for ac_cxx_preproc_warn_flag in '' yes
     4864do
     4865  # Use a header file that comes with gcc, so configuring glibc
     4866  # with a fresh cross-compiler works.
     4867  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     4868  # <limits.h> exists even on freestanding compilers.
     4869  # On the NeXT, cc -E runs the code through the compiler's parser,
     4870  # not just through cpp. "Syntax error" is here to catch this case.
     4871  cat >conftest.$ac_ext <<_ACEOF
     4872/* confdefs.h.  */
     4873_ACEOF
     4874cat confdefs.h >>conftest.$ac_ext
     4875cat >>conftest.$ac_ext <<_ACEOF
     4876/* end confdefs.h.  */
     4877#ifdef __STDC__
     4878# include <limits.h>
     4879#else
     4880# include <assert.h>
     4881#endif
     4882                     Syntax error
     4883_ACEOF
     4884if { (ac_try="$ac_cpp conftest.$ac_ext"
     4885case "(($ac_try" in
     4886  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     4887  *) ac_try_echo=$ac_try;;
     4888esac
     4889eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     4890$as_echo "$ac_try_echo") >&5
     4891  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     4892  ac_status=$?
     4893  grep -v '^ *+' conftest.er1 >conftest.err
     4894  rm -f conftest.er1
     4895  cat conftest.err >&5
     4896  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4897  (exit $ac_status); } >/dev/null && {
     4898         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
     4899         test ! -s conftest.err
     4900       }; then
     4901  :
     4902else
     4903  $as_echo "$as_me: failed program was:" >&5
     4904sed 's/^/| /' conftest.$ac_ext >&5
     4905
     4906  # Broken: fails on valid input.
     4907continue
     4908fi
     4909
     4910rm -f conftest.err conftest.$ac_ext
     4911
     4912  # OK, works on sane cases.  Now check whether nonexistent headers
     4913  # can be detected and how.
     4914  cat >conftest.$ac_ext <<_ACEOF
     4915/* confdefs.h.  */
     4916_ACEOF
     4917cat confdefs.h >>conftest.$ac_ext
     4918cat >>conftest.$ac_ext <<_ACEOF
     4919/* end confdefs.h.  */
     4920#include <ac_nonexistent.h>
     4921_ACEOF
     4922if { (ac_try="$ac_cpp conftest.$ac_ext"
     4923case "(($ac_try" in
     4924  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     4925  *) ac_try_echo=$ac_try;;
     4926esac
     4927eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     4928$as_echo "$ac_try_echo") >&5
     4929  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     4930  ac_status=$?
     4931  grep -v '^ *+' conftest.er1 >conftest.err
     4932  rm -f conftest.er1
     4933  cat conftest.err >&5
     4934  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4935  (exit $ac_status); } >/dev/null && {
     4936         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
     4937         test ! -s conftest.err
     4938       }; then
     4939  # Broken: success on invalid input.
     4940continue
     4941else
     4942  $as_echo "$as_me: failed program was:" >&5
     4943sed 's/^/| /' conftest.$ac_ext >&5
     4944
     4945  # Passes both tests.
     4946ac_preproc_ok=:
     4947break
     4948fi
     4949
     4950rm -f conftest.err conftest.$ac_ext
     4951
     4952done
     4953# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     4954rm -f conftest.err conftest.$ac_ext
     4955if $ac_preproc_ok; then
     4956  :
     4957else
     4958  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
     4959$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
     4960{ { $as_echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
     4961See \`config.log' for more details." >&5
     4962$as_echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
     4963See \`config.log' for more details." >&2;}
     4964   { (exit 1); exit 1; }; }; }
     4965fi
     4966
     4967ac_ext=cpp
     4968ac_cpp='$CXXCPP $CPPFLAGS'
     4969ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4970ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4971ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     4972
     4973
     4974
     4975for ac_header in sys/sysinfo.h
     4976do
     4977as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
     4978if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
     4979  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
     4980$as_echo_n "checking for $ac_header... " >&6; }
     4981if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
     4982  $as_echo_n "(cached) " >&6
     4983fi
     4984ac_res=`eval 'as_val=${'$as_ac_Header'}
     4985                 $as_echo "$as_val"'`
     4986               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
     4987$as_echo "$ac_res" >&6; }
     4988else
     4989  # Is the header compilable?
     4990{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
     4991$as_echo_n "checking $ac_header usability... " >&6; }
     4992cat >conftest.$ac_ext <<_ACEOF
     4993/* confdefs.h.  */
     4994_ACEOF
     4995cat confdefs.h >>conftest.$ac_ext
     4996cat >>conftest.$ac_ext <<_ACEOF
     4997/* end confdefs.h.  */
     4998$ac_includes_default
     4999#include <$ac_header>
     5000_ACEOF
     5001rm -f conftest.$ac_objext
     5002if { (ac_try="$ac_compile"
     5003case "(($ac_try" in
     5004  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     5005  *) ac_try_echo=$ac_try;;
     5006esac
     5007eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     5008$as_echo "$ac_try_echo") >&5
     5009  (eval "$ac_compile") 2>conftest.er1
     5010  ac_status=$?
     5011  grep -v '^ *+' conftest.er1 >conftest.err
     5012  rm -f conftest.er1
     5013  cat conftest.err >&5
     5014  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     5015  (exit $ac_status); } && {
     5016         test -z "$ac_cxx_werror_flag" ||
     5017         test ! -s conftest.err
     5018       } && test -s conftest.$ac_objext; then
     5019  ac_header_compiler=yes
     5020else
     5021  $as_echo "$as_me: failed program was:" >&5
     5022sed 's/^/| /' conftest.$ac_ext >&5
     5023
     5024        ac_header_compiler=no
     5025fi
     5026
     5027rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     5028{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
     5029$as_echo "$ac_header_compiler" >&6; }
     5030
     5031# Is the header present?
     5032{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
     5033$as_echo_n "checking $ac_header presence... " >&6; }
     5034cat >conftest.$ac_ext <<_ACEOF
     5035/* confdefs.h.  */
     5036_ACEOF
     5037cat confdefs.h >>conftest.$ac_ext
     5038cat >>conftest.$ac_ext <<_ACEOF
     5039/* end confdefs.h.  */
     5040#include <$ac_header>
     5041_ACEOF
     5042if { (ac_try="$ac_cpp conftest.$ac_ext"
     5043case "(($ac_try" in
     5044  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     5045  *) ac_try_echo=$ac_try;;
     5046esac
     5047eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     5048$as_echo "$ac_try_echo") >&5
     5049  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     5050  ac_status=$?
     5051  grep -v '^ *+' conftest.er1 >conftest.err
     5052  rm -f conftest.er1
     5053  cat conftest.err >&5
     5054  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     5055  (exit $ac_status); } >/dev/null && {
     5056         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
     5057         test ! -s conftest.err
     5058       }; then
     5059  ac_header_preproc=yes
     5060else
     5061  $as_echo "$as_me: failed program was:" >&5
     5062sed 's/^/| /' conftest.$ac_ext >&5
     5063
     5064  ac_header_preproc=no
     5065fi
     5066
     5067rm -f conftest.err conftest.$ac_ext
     5068{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
     5069$as_echo "$ac_header_preproc" >&6; }
     5070
     5071# So?  What about this header?
     5072case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
     5073  yes:no: )
     5074    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
     5075$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
     5076    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
     5077$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
     5078    ac_header_preproc=yes
     5079    ;;
     5080  no:yes:* )
     5081    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
     5082$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
     5083    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
     5084$as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
     5085    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
     5086$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
     5087    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
     5088$as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
     5089    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
     5090$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
     5091    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
     5092$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
     5093    ( cat <<\_ASBOX
     5094## ----------------------------------- ##
     5095## Report this to rappture@nanohub.org ##
     5096## ----------------------------------- ##
     5097_ASBOX
     5098     ) | sed "s/^/$as_me: WARNING:     /" >&2
     5099    ;;
     5100esac
     5101{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
     5102$as_echo_n "checking for $ac_header... " >&6; }
     5103if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
     5104  $as_echo_n "(cached) " >&6
     5105else
     5106  eval "$as_ac_Header=\$ac_header_preproc"
     5107fi
     5108ac_res=`eval 'as_val=${'$as_ac_Header'}
     5109                 $as_echo "$as_val"'`
     5110               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
     5111$as_echo "$ac_res" >&6; }
     5112
     5113fi
     5114as_val=`eval 'as_val=${'$as_ac_Header'}
     5115                 $as_echo "$as_val"'`
     5116   if test "x$as_val" = x""yes; then
     5117  cat >>confdefs.h <<_ACEOF
     5118#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
     5119_ACEOF
     5120
     5121fi
     5122
     5123done
     5124
     5125
     5126
    45665127{ $as_echo "$as_me:$LINENO: checking for main in -lm" >&5
    45675128$as_echo_n "checking for main in -lm... " >&6; }
     
    47085269   { (exit 1); exit 1; }; }
    47095270fi
    4710 
    4711 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
    4712 
    4713 
    4714 
    4715 
    4716 
    4717 
    4718 
    4719 
    4720 
    4721 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
    4722                   inttypes.h stdint.h unistd.h
    4723 do
    4724 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
    4725 { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
    4726 $as_echo_n "checking for $ac_header... " >&6; }
    4727 if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
    4728   $as_echo_n "(cached) " >&6
    4729 else
    4730   cat >conftest.$ac_ext <<_ACEOF
    4731 /* confdefs.h.  */
    4732 _ACEOF
    4733 cat confdefs.h >>conftest.$ac_ext
    4734 cat >>conftest.$ac_ext <<_ACEOF
    4735 /* end confdefs.h.  */
    4736 $ac_includes_default
    4737 
    4738 #include <$ac_header>
    4739 _ACEOF
    4740 rm -f conftest.$ac_objext
    4741 if { (ac_try="$ac_compile"
    4742 case "(($ac_try" in
    4743   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4744   *) ac_try_echo=$ac_try;;
    4745 esac
    4746 eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
    4747 $as_echo "$ac_try_echo") >&5
    4748   (eval "$ac_compile") 2>conftest.er1
    4749   ac_status=$?
    4750   grep -v '^ *+' conftest.er1 >conftest.err
    4751   rm -f conftest.er1
    4752   cat conftest.err >&5
    4753   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
    4754   (exit $ac_status); } && {
    4755          test -z "$ac_cxx_werror_flag" ||
    4756          test ! -s conftest.err
    4757        } && test -s conftest.$ac_objext; then
    4758   eval "$as_ac_Header=yes"
    4759 else
    4760   $as_echo "$as_me: failed program was:" >&5
    4761 sed 's/^/| /' conftest.$ac_ext >&5
    4762 
    4763         eval "$as_ac_Header=no"
    4764 fi
    4765 
    4766 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    4767 fi
    4768 ac_res=`eval 'as_val=${'$as_ac_Header'}
    4769                  $as_echo "$as_val"'`
    4770                { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
    4771 $as_echo "$ac_res" >&6; }
    4772 as_val=`eval 'as_val=${'$as_ac_Header'}
    4773                  $as_echo "$as_val"'`
    4774    if test "x$as_val" = x""yes; then
    4775   cat >>confdefs.h <<_ACEOF
    4776 #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
    4777 _ACEOF
    4778 
    4779 fi
    4780 
    4781 done
    4782 
    4783 
    4784 ac_ext=cpp
    4785 ac_cpp='$CXXCPP $CPPFLAGS'
    4786 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    4787 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    4788 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    4789 { $as_echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
    4790 $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
    4791 if test -z "$CXXCPP"; then
    4792   if test "${ac_cv_prog_CXXCPP+set}" = set; then
    4793   $as_echo_n "(cached) " >&6
    4794 else
    4795       # Double quotes because CXXCPP needs to be expanded
    4796     for CXXCPP in "$CXX -E" "/lib/cpp"
    4797     do
    4798       ac_preproc_ok=false
    4799 for ac_cxx_preproc_warn_flag in '' yes
    4800 do
    4801   # Use a header file that comes with gcc, so configuring glibc
    4802   # with a fresh cross-compiler works.
    4803   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    4804   # <limits.h> exists even on freestanding compilers.
    4805   # On the NeXT, cc -E runs the code through the compiler's parser,
    4806   # not just through cpp. "Syntax error" is here to catch this case.
    4807   cat >conftest.$ac_ext <<_ACEOF
    4808 /* confdefs.h.  */
    4809 _ACEOF
    4810 cat confdefs.h >>conftest.$ac_ext
    4811 cat >>conftest.$ac_ext <<_ACEOF
    4812 /* end confdefs.h.  */
    4813 #ifdef __STDC__
    4814 # include <limits.h>
    4815 #else
    4816 # include <assert.h>
    4817 #endif
    4818                      Syntax error
    4819 _ACEOF
    4820 if { (ac_try="$ac_cpp conftest.$ac_ext"
    4821 case "(($ac_try" in
    4822   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4823   *) ac_try_echo=$ac_try;;
    4824 esac
    4825 eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
    4826 $as_echo "$ac_try_echo") >&5
    4827   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    4828   ac_status=$?
    4829   grep -v '^ *+' conftest.er1 >conftest.err
    4830   rm -f conftest.er1
    4831   cat conftest.err >&5
    4832   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
    4833   (exit $ac_status); } >/dev/null && {
    4834          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    4835          test ! -s conftest.err
    4836        }; then
    4837   :
    4838 else
    4839   $as_echo "$as_me: failed program was:" >&5
    4840 sed 's/^/| /' conftest.$ac_ext >&5
    4841 
    4842   # Broken: fails on valid input.
    4843 continue
    4844 fi
    4845 
    4846 rm -f conftest.err conftest.$ac_ext
    4847 
    4848   # OK, works on sane cases.  Now check whether nonexistent headers
    4849   # can be detected and how.
    4850   cat >conftest.$ac_ext <<_ACEOF
    4851 /* confdefs.h.  */
    4852 _ACEOF
    4853 cat confdefs.h >>conftest.$ac_ext
    4854 cat >>conftest.$ac_ext <<_ACEOF
    4855 /* end confdefs.h.  */
    4856 #include <ac_nonexistent.h>
    4857 _ACEOF
    4858 if { (ac_try="$ac_cpp conftest.$ac_ext"
    4859 case "(($ac_try" in
    4860   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4861   *) ac_try_echo=$ac_try;;
    4862 esac
    4863 eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
    4864 $as_echo "$ac_try_echo") >&5
    4865   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    4866   ac_status=$?
    4867   grep -v '^ *+' conftest.er1 >conftest.err
    4868   rm -f conftest.er1
    4869   cat conftest.err >&5
    4870   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
    4871   (exit $ac_status); } >/dev/null && {
    4872          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    4873          test ! -s conftest.err
    4874        }; then
    4875   # Broken: success on invalid input.
    4876 continue
    4877 else
    4878   $as_echo "$as_me: failed program was:" >&5
    4879 sed 's/^/| /' conftest.$ac_ext >&5
    4880 
    4881   # Passes both tests.
    4882 ac_preproc_ok=:
    4883 break
    4884 fi
    4885 
    4886 rm -f conftest.err conftest.$ac_ext
    4887 
    4888 done
    4889 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
    4890 rm -f conftest.err conftest.$ac_ext
    4891 if $ac_preproc_ok; then
    4892   break
    4893 fi
    4894 
    4895     done
    4896     ac_cv_prog_CXXCPP=$CXXCPP
    4897 
    4898 fi
    4899   CXXCPP=$ac_cv_prog_CXXCPP
    4900 else
    4901   ac_cv_prog_CXXCPP=$CXXCPP
    4902 fi
    4903 { $as_echo "$as_me:$LINENO: result: $CXXCPP" >&5
    4904 $as_echo "$CXXCPP" >&6; }
    4905 ac_preproc_ok=false
    4906 for ac_cxx_preproc_warn_flag in '' yes
    4907 do
    4908   # Use a header file that comes with gcc, so configuring glibc
    4909   # with a fresh cross-compiler works.
    4910   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    4911   # <limits.h> exists even on freestanding compilers.
    4912   # On the NeXT, cc -E runs the code through the compiler's parser,
    4913   # not just through cpp. "Syntax error" is here to catch this case.
    4914   cat >conftest.$ac_ext <<_ACEOF
    4915 /* confdefs.h.  */
    4916 _ACEOF
    4917 cat confdefs.h >>conftest.$ac_ext
    4918 cat >>conftest.$ac_ext <<_ACEOF
    4919 /* end confdefs.h.  */
    4920 #ifdef __STDC__
    4921 # include <limits.h>
    4922 #else
    4923 # include <assert.h>
    4924 #endif
    4925                      Syntax error
    4926 _ACEOF
    4927 if { (ac_try="$ac_cpp conftest.$ac_ext"
    4928 case "(($ac_try" in
    4929   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4930   *) ac_try_echo=$ac_try;;
    4931 esac
    4932 eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
    4933 $as_echo "$ac_try_echo") >&5
    4934   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    4935   ac_status=$?
    4936   grep -v '^ *+' conftest.er1 >conftest.err
    4937   rm -f conftest.er1
    4938   cat conftest.err >&5
    4939   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
    4940   (exit $ac_status); } >/dev/null && {
    4941          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    4942          test ! -s conftest.err
    4943        }; then
    4944   :
    4945 else
    4946   $as_echo "$as_me: failed program was:" >&5
    4947 sed 's/^/| /' conftest.$ac_ext >&5
    4948 
    4949   # Broken: fails on valid input.
    4950 continue
    4951 fi
    4952 
    4953 rm -f conftest.err conftest.$ac_ext
    4954 
    4955   # OK, works on sane cases.  Now check whether nonexistent headers
    4956   # can be detected and how.
    4957   cat >conftest.$ac_ext <<_ACEOF
    4958 /* confdefs.h.  */
    4959 _ACEOF
    4960 cat confdefs.h >>conftest.$ac_ext
    4961 cat >>conftest.$ac_ext <<_ACEOF
    4962 /* end confdefs.h.  */
    4963 #include <ac_nonexistent.h>
    4964 _ACEOF
    4965 if { (ac_try="$ac_cpp conftest.$ac_ext"
    4966 case "(($ac_try" in
    4967   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4968   *) ac_try_echo=$ac_try;;
    4969 esac
    4970 eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
    4971 $as_echo "$ac_try_echo") >&5
    4972   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    4973   ac_status=$?
    4974   grep -v '^ *+' conftest.er1 >conftest.err
    4975   rm -f conftest.er1
    4976   cat conftest.err >&5
    4977   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
    4978   (exit $ac_status); } >/dev/null && {
    4979          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    4980          test ! -s conftest.err
    4981        }; then
    4982   # Broken: success on invalid input.
    4983 continue
    4984 else
    4985   $as_echo "$as_me: failed program was:" >&5
    4986 sed 's/^/| /' conftest.$ac_ext >&5
    4987 
    4988   # Passes both tests.
    4989 ac_preproc_ok=:
    4990 break
    4991 fi
    4992 
    4993 rm -f conftest.err conftest.$ac_ext
    4994 
    4995 done
    4996 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
    4997 rm -f conftest.err conftest.$ac_ext
    4998 if $ac_preproc_ok; then
    4999   :
    5000 else
    5001   { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
    5002 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    5003 { { $as_echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
    5004 See \`config.log' for more details." >&5
    5005 $as_echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
    5006 See \`config.log' for more details." >&2;}
    5007    { (exit 1); exit 1; }; }; }
    5008 fi
    5009 
    5010 ac_ext=cpp
    5011 ac_cpp='$CXXCPP $CPPFLAGS'
    5012 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    5013 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    5014 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    5015 
    50165271
    50175272
     
    1540215657test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
    1540315658
    15404 # Transform confdefs.h into DEFS.
    15405 # Protect against shell expansion while executing Makefile rules.
    15406 # Protect against Makefile macro expansion.
    15407 #
    15408 # If the first sed substitution is executed (which looks for macros that
    15409 # take arguments), then branch to the quote section.  Otherwise,
    15410 # look for a macro that doesn't take arguments.
    15411 ac_script='
    15412 :mline
    15413 /\\$/{
    15414  N
    15415  s,\\\n,,
    15416  b mline
    15417 }
    15418 t clear
    15419 :clear
    15420 s/^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\)/-D\1=\2/g
    15421 t quote
    15422 s/^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)/-D\1=\2/g
    15423 t quote
    15424 b any
    15425 :quote
    15426 s/[      `~#$^&*(){}\\|;'\''"<>?]/\\&/g
    15427 s/\[/\\&/g
    15428 s/\]/\\&/g
    15429 s/\$/$$/g
    15430 H
    15431 :any
    15432 ${
    15433         g
    15434         s/^\n//
    15435         s/\n/ /g
    15436         p
    15437 }
    15438 '
    15439 DEFS=`sed -n "$ac_script" confdefs.h`
    15440 
     15659DEFS=-DHAVE_CONFIG_H
    1544115660
    1544215661ac_libobjs=
     
    1579716016esac
    1579816017
     16018case $ac_config_headers in *"
     16019"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
     16020esac
    1579916021
    1580016022
     
    1580216024# Files that config.status was made for.
    1580316025config_files="$ac_config_files"
     16026config_headers="$ac_config_headers"
    1580416027
    1580516028_ACEOF
     
    1582016043      --file=FILE[:TEMPLATE]
    1582116044                   instantiate the configuration file FILE
     16045      --header=FILE[:TEMPLATE]
     16046                   instantiate the configuration header FILE
    1582216047
    1582316048Configuration files:
    1582416049$config_files
     16050
     16051Configuration headers:
     16052$config_headers
    1582516053
    1582616054Report bugs to <bug-autoconf@gnu.org>."
     
    1587816106    CONFIG_FILES="$CONFIG_FILES '$ac_optarg'"
    1587916107    ac_need_defaults=false;;
    15880   --he | --h |  --help | --hel | -h )
     16108  --header | --heade | --head | --hea )
     16109    $ac_shift
     16110    case $ac_optarg in
     16111    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
     16112    esac
     16113    CONFIG_HEADERS="$CONFIG_HEADERS '$ac_optarg'"
     16114    ac_need_defaults=false;;
     16115  --he | --h)
     16116    # Conflict between --help and --header
     16117    { $as_echo "$as_me: error: ambiguous option: $1
     16118Try \`$0 --help' for more information." >&2
     16119   { (exit 1); exit 1; }; };;
     16120  --help | --hel | -h )
    1588116121    $as_echo "$ac_cs_usage"; exit ;;
    1588216122  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
     
    1593516175do
    1593616176  case $ac_config_target in
     16177    "src/core/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/core/config.h" ;;
    1593716178    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
    1593816179    "packages/Makefile") CONFIG_FILES="$CONFIG_FILES packages/Makefile" ;;
     
    1604716288if $ac_need_defaults; then
    1604816289  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
     16290  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
    1604916291fi
    1605016292
     
    1623116473fi # test -n "$CONFIG_FILES"
    1623216474
    16233 
    16234 eval set X "  :F $CONFIG_FILES      "
     16475# Set up the scripts for CONFIG_HEADERS section.
     16476# No need to generate them if there are no CONFIG_HEADERS.
     16477# This happens for instance with `./config.status Makefile'.
     16478if test -n "$CONFIG_HEADERS"; then
     16479cat >"$tmp/defines.awk" <<\_ACAWK ||
     16480BEGIN {
     16481_ACEOF
     16482
     16483# Transform confdefs.h into an awk script `defines.awk', embedded as
     16484# here-document in config.status, that substitutes the proper values into
     16485# config.h.in to produce config.h.
     16486
     16487# Create a delimiter string that does not exist in confdefs.h, to ease
     16488# handling of long lines.
     16489ac_delim='%!_!# '
     16490for ac_last_try in false false :; do
     16491  ac_t=`sed -n "/$ac_delim/p" confdefs.h`
     16492  if test -z "$ac_t"; then
     16493    break
     16494  elif $ac_last_try; then
     16495    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_HEADERS" >&5
     16496$as_echo "$as_me: error: could not make $CONFIG_HEADERS" >&2;}
     16497   { (exit 1); exit 1; }; }
     16498  else
     16499    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
     16500  fi
     16501done
     16502
     16503# For the awk script, D is an array of macro values keyed by name,
     16504# likewise P contains macro parameters if any.  Preserve backslash
     16505# newline sequences.
     16506
     16507ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
     16508sed -n '
     16509s/.\{148\}/&'"$ac_delim"'/g
     16510t rset
     16511:rset
     16512s/^[     ]*#[    ]*define[       ][      ]*/ /
     16513t def
     16514d
     16515:def
     16516s/\\$//
     16517t bsnl
     16518s/["\\]/\\&/g
     16519s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
     16520D["\1"]=" \3"/p
     16521s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2"/p
     16522d
     16523:bsnl
     16524s/["\\]/\\&/g
     16525s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
     16526D["\1"]=" \3\\\\\\n"\\/p
     16527t cont
     16528s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
     16529t cont
     16530d
     16531:cont
     16532n
     16533s/.\{148\}/&'"$ac_delim"'/g
     16534t clear
     16535:clear
     16536s/\\$//
     16537t bsnlc
     16538s/["\\]/\\&/g; s/^/"/; s/$/"/p
     16539d
     16540:bsnlc
     16541s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
     16542b cont
     16543' <confdefs.h | sed '
     16544s/'"$ac_delim"'/"\\\
     16545"/g' >>$CONFIG_STATUS || ac_write_fail=1
     16546
     16547cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
     16548  for (key in D) D_is_set[key] = 1
     16549  FS = ""
     16550}
     16551/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
     16552  line = \$ 0
     16553  split(line, arg, " ")
     16554  if (arg[1] == "#") {
     16555    defundef = arg[2]
     16556    mac1 = arg[3]
     16557  } else {
     16558    defundef = substr(arg[1], 2)
     16559    mac1 = arg[2]
     16560  }
     16561  split(mac1, mac2, "(") #)
     16562  macro = mac2[1]
     16563  prefix = substr(line, 1, index(line, defundef) - 1)
     16564  if (D_is_set[macro]) {
     16565    # Preserve the white space surrounding the "#".
     16566    print prefix "define", macro P[macro] D[macro]
     16567    next
     16568  } else {
     16569    # Replace #undef with comments.  This is necessary, for example,
     16570    # in the case of _POSIX_SOURCE, which is predefined and required
     16571    # on some systems where configure will not decide to define it.
     16572    if (defundef == "undef") {
     16573      print "/*", prefix defundef, macro, "*/"
     16574      next
     16575    }
     16576  }
     16577}
     16578{ print }
     16579_ACAWK
     16580_ACEOF
     16581cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
     16582  { { $as_echo "$as_me:$LINENO: error: could not setup config headers machinery" >&5
     16583$as_echo "$as_me: error: could not setup config headers machinery" >&2;}
     16584   { (exit 1); exit 1; }; }
     16585fi # test -n "$CONFIG_HEADERS"
     16586
     16587
     16588eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
    1623516589shift
    1623616590for ac_tag
     
    1650216856   { (exit 1); exit 1; }; }
    1650316857 ;;
    16504 
     16858  :H)
     16859  #
     16860  # CONFIG_HEADER
     16861  #
     16862  if test x"$ac_file" != x-; then
     16863    {
     16864      $as_echo "/* $configure_input  */" \
     16865      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
     16866    } >"$tmp/config.h" \
     16867      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
     16868$as_echo "$as_me: error: could not create $ac_file" >&2;}
     16869   { (exit 1); exit 1; }; }
     16870    if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
     16871      { $as_echo "$as_me:$LINENO: $ac_file is unchanged" >&5
     16872$as_echo "$as_me: $ac_file is unchanged" >&6;}
     16873    else
     16874      rm -f "$ac_file"
     16875      mv "$tmp/config.h" "$ac_file" \
     16876        || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
     16877$as_echo "$as_me: error: could not create $ac_file" >&2;}
     16878   { (exit 1); exit 1; }; }
     16879    fi
     16880  else
     16881    $as_echo "/* $configure_input  */" \
     16882      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
     16883      || { { $as_echo "$as_me:$LINENO: error: could not create -" >&5
     16884$as_echo "$as_me: error: could not create -" >&2;}
     16885   { (exit 1); exit 1; }; }
     16886  fi
     16887 ;;
    1650516888
    1650616889
Note: See TracChangeset for help on using the changeset viewer.