configure
上传用户:awang829
上传日期:2019-07-14
资源大小:2356k
文件大小:565k
源码类别:

网络

开发平台:

Unix_Linux

  1.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2.   (exit $ac_status); }; }; then
  3.   ac_cv_sizeof_uintptr_t=`cat conftest.val`
  4. else
  5.   echo "$as_me: program exited with status $ac_status" >&5
  6. echo "$as_me: failed program was:" >&5
  7. sed 's/^/| /' conftest.$ac_ext >&5
  8. ( exit $ac_status )
  9. if test "$ac_cv_type_uintptr_t" = yes; then
  10.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (uintptr_t)
  11. See `config.log' for more details." >&5
  12. echo "$as_me: error: cannot compute sizeof (uintptr_t)
  13. See `config.log' for more details." >&2;}
  14.    { (exit 77); exit 77; }; }
  15.    else
  16.      ac_cv_sizeof_uintptr_t=0
  17.    fi
  18. fi
  19. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  20. fi
  21. rm -f conftest.val
  22. fi
  23. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_uintptr_t" >&5
  24. echo "${ECHO_T}$ac_cv_sizeof_uintptr_t" >&6; }
  25. cat >>confdefs.h <<_ACEOF
  26. #define SIZEOF_UINTPTR_T $ac_cv_sizeof_uintptr_t
  27. _ACEOF
  28. { echo "$as_me:$LINENO: checking for char" >&5
  29. echo $ECHO_N "checking for char... $ECHO_C" >&6; }
  30. if test "${ac_cv_type_char+set}" = set; then
  31.   echo $ECHO_N "(cached) $ECHO_C" >&6
  32. else
  33.   cat >conftest.$ac_ext <<_ACEOF
  34. /* confdefs.h.  */
  35. _ACEOF
  36. cat confdefs.h >>conftest.$ac_ext
  37. cat >>conftest.$ac_ext <<_ACEOF
  38. /* end confdefs.h.  */
  39. $ac_includes_default
  40. typedef char ac__type_new_;
  41. int
  42. main ()
  43. {
  44. if ((ac__type_new_ *) 0)
  45.   return 0;
  46. if (sizeof (ac__type_new_))
  47.   return 0;
  48.   ;
  49.   return 0;
  50. }
  51. _ACEOF
  52. rm -f conftest.$ac_objext
  53. if { (ac_try="$ac_compile"
  54. case "(($ac_try" in
  55.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  56.   *) ac_try_echo=$ac_try;;
  57. esac
  58. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  59.   (eval "$ac_compile") 2>conftest.er1
  60.   ac_status=$?
  61.   grep -v '^ *+' conftest.er1 >conftest.err
  62.   rm -f conftest.er1
  63.   cat conftest.err >&5
  64.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  65.   (exit $ac_status); } && {
  66.  test -z "$ac_c_werror_flag" ||
  67.  test ! -s conftest.err
  68.        } && test -s conftest.$ac_objext; then
  69.   ac_cv_type_char=yes
  70. else
  71.   echo "$as_me: failed program was:" >&5
  72. sed 's/^/| /' conftest.$ac_ext >&5
  73. ac_cv_type_char=no
  74. fi
  75. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  76. fi
  77. { echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
  78. echo "${ECHO_T}$ac_cv_type_char" >&6; }
  79. # The cast to long int works around a bug in the HP C Compiler
  80. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  81. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  82. # This bug is HP SR number 8606223364.
  83. { echo "$as_me:$LINENO: checking size of char" >&5
  84. echo $ECHO_N "checking size of char... $ECHO_C" >&6; }
  85. if test "${ac_cv_sizeof_char+set}" = set; then
  86.   echo $ECHO_N "(cached) $ECHO_C" >&6
  87. else
  88.   if test "$cross_compiling" = yes; then
  89.   # Depending upon the size, compute the lo and hi bounds.
  90. cat >conftest.$ac_ext <<_ACEOF
  91. /* confdefs.h.  */
  92. _ACEOF
  93. cat confdefs.h >>conftest.$ac_ext
  94. cat >>conftest.$ac_ext <<_ACEOF
  95. /* end confdefs.h.  */
  96. $ac_includes_default
  97.    typedef char ac__type_sizeof_;
  98. int
  99. main ()
  100. {
  101. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  102. test_array [0] = 0
  103.   ;
  104.   return 0;
  105. }
  106. _ACEOF
  107. rm -f conftest.$ac_objext
  108. if { (ac_try="$ac_compile"
  109. case "(($ac_try" in
  110.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  111.   *) ac_try_echo=$ac_try;;
  112. esac
  113. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  114.   (eval "$ac_compile") 2>conftest.er1
  115.   ac_status=$?
  116.   grep -v '^ *+' conftest.er1 >conftest.err
  117.   rm -f conftest.er1
  118.   cat conftest.err >&5
  119.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  120.   (exit $ac_status); } && {
  121.  test -z "$ac_c_werror_flag" ||
  122.  test ! -s conftest.err
  123.        } && test -s conftest.$ac_objext; then
  124.   ac_lo=0 ac_mid=0
  125.   while :; do
  126.     cat >conftest.$ac_ext <<_ACEOF
  127. /* confdefs.h.  */
  128. _ACEOF
  129. cat confdefs.h >>conftest.$ac_ext
  130. cat >>conftest.$ac_ext <<_ACEOF
  131. /* end confdefs.h.  */
  132. $ac_includes_default
  133.    typedef char ac__type_sizeof_;
  134. int
  135. main ()
  136. {
  137. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  138. test_array [0] = 0
  139.   ;
  140.   return 0;
  141. }
  142. _ACEOF
  143. rm -f conftest.$ac_objext
  144. if { (ac_try="$ac_compile"
  145. case "(($ac_try" in
  146.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  147.   *) ac_try_echo=$ac_try;;
  148. esac
  149. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  150.   (eval "$ac_compile") 2>conftest.er1
  151.   ac_status=$?
  152.   grep -v '^ *+' conftest.er1 >conftest.err
  153.   rm -f conftest.er1
  154.   cat conftest.err >&5
  155.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  156.   (exit $ac_status); } && {
  157.  test -z "$ac_c_werror_flag" ||
  158.  test ! -s conftest.err
  159.        } && test -s conftest.$ac_objext; then
  160.   ac_hi=$ac_mid; break
  161. else
  162.   echo "$as_me: failed program was:" >&5
  163. sed 's/^/| /' conftest.$ac_ext >&5
  164. ac_lo=`expr $ac_mid + 1`
  165. if test $ac_lo -le $ac_mid; then
  166.   ac_lo= ac_hi=
  167.   break
  168. fi
  169. ac_mid=`expr 2 '*' $ac_mid + 1`
  170. fi
  171. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  172.   done
  173. else
  174.   echo "$as_me: failed program was:" >&5
  175. sed 's/^/| /' conftest.$ac_ext >&5
  176. cat >conftest.$ac_ext <<_ACEOF
  177. /* confdefs.h.  */
  178. _ACEOF
  179. cat confdefs.h >>conftest.$ac_ext
  180. cat >>conftest.$ac_ext <<_ACEOF
  181. /* end confdefs.h.  */
  182. $ac_includes_default
  183.    typedef char ac__type_sizeof_;
  184. int
  185. main ()
  186. {
  187. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  188. test_array [0] = 0
  189.   ;
  190.   return 0;
  191. }
  192. _ACEOF
  193. rm -f conftest.$ac_objext
  194. if { (ac_try="$ac_compile"
  195. case "(($ac_try" in
  196.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  197.   *) ac_try_echo=$ac_try;;
  198. esac
  199. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  200.   (eval "$ac_compile") 2>conftest.er1
  201.   ac_status=$?
  202.   grep -v '^ *+' conftest.er1 >conftest.err
  203.   rm -f conftest.er1
  204.   cat conftest.err >&5
  205.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  206.   (exit $ac_status); } && {
  207.  test -z "$ac_c_werror_flag" ||
  208.  test ! -s conftest.err
  209.        } && test -s conftest.$ac_objext; then
  210.   ac_hi=-1 ac_mid=-1
  211.   while :; do
  212.     cat >conftest.$ac_ext <<_ACEOF
  213. /* confdefs.h.  */
  214. _ACEOF
  215. cat confdefs.h >>conftest.$ac_ext
  216. cat >>conftest.$ac_ext <<_ACEOF
  217. /* end confdefs.h.  */
  218. $ac_includes_default
  219.    typedef char ac__type_sizeof_;
  220. int
  221. main ()
  222. {
  223. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  224. test_array [0] = 0
  225.   ;
  226.   return 0;
  227. }
  228. _ACEOF
  229. rm -f conftest.$ac_objext
  230. if { (ac_try="$ac_compile"
  231. case "(($ac_try" in
  232.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  233.   *) ac_try_echo=$ac_try;;
  234. esac
  235. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  236.   (eval "$ac_compile") 2>conftest.er1
  237.   ac_status=$?
  238.   grep -v '^ *+' conftest.er1 >conftest.err
  239.   rm -f conftest.er1
  240.   cat conftest.err >&5
  241.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  242.   (exit $ac_status); } && {
  243.  test -z "$ac_c_werror_flag" ||
  244.  test ! -s conftest.err
  245.        } && test -s conftest.$ac_objext; then
  246.   ac_lo=$ac_mid; break
  247. else
  248.   echo "$as_me: failed program was:" >&5
  249. sed 's/^/| /' conftest.$ac_ext >&5
  250. ac_hi=`expr '(' $ac_mid ')' - 1`
  251. if test $ac_mid -le $ac_hi; then
  252.   ac_lo= ac_hi=
  253.   break
  254. fi
  255. ac_mid=`expr 2 '*' $ac_mid`
  256. fi
  257. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  258.   done
  259. else
  260.   echo "$as_me: failed program was:" >&5
  261. sed 's/^/| /' conftest.$ac_ext >&5
  262. ac_lo= ac_hi=
  263. fi
  264. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  265. fi
  266. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  267. # Binary search between lo and hi bounds.
  268. while test "x$ac_lo" != "x$ac_hi"; do
  269.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  270.   cat >conftest.$ac_ext <<_ACEOF
  271. /* confdefs.h.  */
  272. _ACEOF
  273. cat confdefs.h >>conftest.$ac_ext
  274. cat >>conftest.$ac_ext <<_ACEOF
  275. /* end confdefs.h.  */
  276. $ac_includes_default
  277.    typedef char ac__type_sizeof_;
  278. int
  279. main ()
  280. {
  281. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  282. test_array [0] = 0
  283.   ;
  284.   return 0;
  285. }
  286. _ACEOF
  287. rm -f conftest.$ac_objext
  288. if { (ac_try="$ac_compile"
  289. case "(($ac_try" in
  290.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  291.   *) ac_try_echo=$ac_try;;
  292. esac
  293. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  294.   (eval "$ac_compile") 2>conftest.er1
  295.   ac_status=$?
  296.   grep -v '^ *+' conftest.er1 >conftest.err
  297.   rm -f conftest.er1
  298.   cat conftest.err >&5
  299.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  300.   (exit $ac_status); } && {
  301.  test -z "$ac_c_werror_flag" ||
  302.  test ! -s conftest.err
  303.        } && test -s conftest.$ac_objext; then
  304.   ac_hi=$ac_mid
  305. else
  306.   echo "$as_me: failed program was:" >&5
  307. sed 's/^/| /' conftest.$ac_ext >&5
  308. ac_lo=`expr '(' $ac_mid ')' + 1`
  309. fi
  310. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  311. done
  312. case $ac_lo in
  313. ?*) ac_cv_sizeof_char=$ac_lo;;
  314. '') if test "$ac_cv_type_char" = yes; then
  315.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (char)
  316. See `config.log' for more details." >&5
  317. echo "$as_me: error: cannot compute sizeof (char)
  318. See `config.log' for more details." >&2;}
  319.    { (exit 77); exit 77; }; }
  320.    else
  321.      ac_cv_sizeof_char=0
  322.    fi ;;
  323. esac
  324. else
  325.   cat >conftest.$ac_ext <<_ACEOF
  326. /* confdefs.h.  */
  327. _ACEOF
  328. cat confdefs.h >>conftest.$ac_ext
  329. cat >>conftest.$ac_ext <<_ACEOF
  330. /* end confdefs.h.  */
  331. $ac_includes_default
  332.    typedef char ac__type_sizeof_;
  333. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  334. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  335. #include <stdio.h>
  336. #include <stdlib.h>
  337. int
  338. main ()
  339. {
  340.   FILE *f = fopen ("conftest.val", "w");
  341.   if (! f)
  342.     return 1;
  343.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  344.     {
  345.       long int i = longval ();
  346.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  347. return 1;
  348.       fprintf (f, "%ldn", i);
  349.     }
  350.   else
  351.     {
  352.       unsigned long int i = ulongval ();
  353.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  354. return 1;
  355.       fprintf (f, "%lun", i);
  356.     }
  357.   return ferror (f) || fclose (f) != 0;
  358.   ;
  359.   return 0;
  360. }
  361. _ACEOF
  362. rm -f conftest$ac_exeext
  363. if { (ac_try="$ac_link"
  364. case "(($ac_try" in
  365.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  366.   *) ac_try_echo=$ac_try;;
  367. esac
  368. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  369.   (eval "$ac_link") 2>&5
  370.   ac_status=$?
  371.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  372.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  373.   { (case "(($ac_try" in
  374.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  375.   *) ac_try_echo=$ac_try;;
  376. esac
  377. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  378.   (eval "$ac_try") 2>&5
  379.   ac_status=$?
  380.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  381.   (exit $ac_status); }; }; then
  382.   ac_cv_sizeof_char=`cat conftest.val`
  383. else
  384.   echo "$as_me: program exited with status $ac_status" >&5
  385. echo "$as_me: failed program was:" >&5
  386. sed 's/^/| /' conftest.$ac_ext >&5
  387. ( exit $ac_status )
  388. if test "$ac_cv_type_char" = yes; then
  389.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (char)
  390. See `config.log' for more details." >&5
  391. echo "$as_me: error: cannot compute sizeof (char)
  392. See `config.log' for more details." >&2;}
  393.    { (exit 77); exit 77; }; }
  394.    else
  395.      ac_cv_sizeof_char=0
  396.    fi
  397. fi
  398. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  399. fi
  400. rm -f conftest.val
  401. fi
  402. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
  403. echo "${ECHO_T}$ac_cv_sizeof_char" >&6; }
  404. cat >>confdefs.h <<_ACEOF
  405. #define SIZEOF_CHAR $ac_cv_sizeof_char
  406. _ACEOF
  407. { echo "$as_me:$LINENO: checking for short" >&5
  408. echo $ECHO_N "checking for short... $ECHO_C" >&6; }
  409. if test "${ac_cv_type_short+set}" = set; then
  410.   echo $ECHO_N "(cached) $ECHO_C" >&6
  411. else
  412.   cat >conftest.$ac_ext <<_ACEOF
  413. /* confdefs.h.  */
  414. _ACEOF
  415. cat confdefs.h >>conftest.$ac_ext
  416. cat >>conftest.$ac_ext <<_ACEOF
  417. /* end confdefs.h.  */
  418. $ac_includes_default
  419. typedef short ac__type_new_;
  420. int
  421. main ()
  422. {
  423. if ((ac__type_new_ *) 0)
  424.   return 0;
  425. if (sizeof (ac__type_new_))
  426.   return 0;
  427.   ;
  428.   return 0;
  429. }
  430. _ACEOF
  431. rm -f conftest.$ac_objext
  432. if { (ac_try="$ac_compile"
  433. case "(($ac_try" in
  434.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  435.   *) ac_try_echo=$ac_try;;
  436. esac
  437. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  438.   (eval "$ac_compile") 2>conftest.er1
  439.   ac_status=$?
  440.   grep -v '^ *+' conftest.er1 >conftest.err
  441.   rm -f conftest.er1
  442.   cat conftest.err >&5
  443.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  444.   (exit $ac_status); } && {
  445.  test -z "$ac_c_werror_flag" ||
  446.  test ! -s conftest.err
  447.        } && test -s conftest.$ac_objext; then
  448.   ac_cv_type_short=yes
  449. else
  450.   echo "$as_me: failed program was:" >&5
  451. sed 's/^/| /' conftest.$ac_ext >&5
  452. ac_cv_type_short=no
  453. fi
  454. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  455. fi
  456. { echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
  457. echo "${ECHO_T}$ac_cv_type_short" >&6; }
  458. # The cast to long int works around a bug in the HP C Compiler
  459. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  460. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  461. # This bug is HP SR number 8606223364.
  462. { echo "$as_me:$LINENO: checking size of short" >&5
  463. echo $ECHO_N "checking size of short... $ECHO_C" >&6; }
  464. if test "${ac_cv_sizeof_short+set}" = set; then
  465.   echo $ECHO_N "(cached) $ECHO_C" >&6
  466. else
  467.   if test "$cross_compiling" = yes; then
  468.   # Depending upon the size, compute the lo and hi bounds.
  469. cat >conftest.$ac_ext <<_ACEOF
  470. /* confdefs.h.  */
  471. _ACEOF
  472. cat confdefs.h >>conftest.$ac_ext
  473. cat >>conftest.$ac_ext <<_ACEOF
  474. /* end confdefs.h.  */
  475. $ac_includes_default
  476.    typedef short ac__type_sizeof_;
  477. int
  478. main ()
  479. {
  480. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  481. test_array [0] = 0
  482.   ;
  483.   return 0;
  484. }
  485. _ACEOF
  486. rm -f conftest.$ac_objext
  487. if { (ac_try="$ac_compile"
  488. case "(($ac_try" in
  489.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  490.   *) ac_try_echo=$ac_try;;
  491. esac
  492. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  493.   (eval "$ac_compile") 2>conftest.er1
  494.   ac_status=$?
  495.   grep -v '^ *+' conftest.er1 >conftest.err
  496.   rm -f conftest.er1
  497.   cat conftest.err >&5
  498.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  499.   (exit $ac_status); } && {
  500.  test -z "$ac_c_werror_flag" ||
  501.  test ! -s conftest.err
  502.        } && test -s conftest.$ac_objext; then
  503.   ac_lo=0 ac_mid=0
  504.   while :; do
  505.     cat >conftest.$ac_ext <<_ACEOF
  506. /* confdefs.h.  */
  507. _ACEOF
  508. cat confdefs.h >>conftest.$ac_ext
  509. cat >>conftest.$ac_ext <<_ACEOF
  510. /* end confdefs.h.  */
  511. $ac_includes_default
  512.    typedef short ac__type_sizeof_;
  513. int
  514. main ()
  515. {
  516. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  517. test_array [0] = 0
  518.   ;
  519.   return 0;
  520. }
  521. _ACEOF
  522. rm -f conftest.$ac_objext
  523. if { (ac_try="$ac_compile"
  524. case "(($ac_try" in
  525.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  526.   *) ac_try_echo=$ac_try;;
  527. esac
  528. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  529.   (eval "$ac_compile") 2>conftest.er1
  530.   ac_status=$?
  531.   grep -v '^ *+' conftest.er1 >conftest.err
  532.   rm -f conftest.er1
  533.   cat conftest.err >&5
  534.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  535.   (exit $ac_status); } && {
  536.  test -z "$ac_c_werror_flag" ||
  537.  test ! -s conftest.err
  538.        } && test -s conftest.$ac_objext; then
  539.   ac_hi=$ac_mid; break
  540. else
  541.   echo "$as_me: failed program was:" >&5
  542. sed 's/^/| /' conftest.$ac_ext >&5
  543. ac_lo=`expr $ac_mid + 1`
  544. if test $ac_lo -le $ac_mid; then
  545.   ac_lo= ac_hi=
  546.   break
  547. fi
  548. ac_mid=`expr 2 '*' $ac_mid + 1`
  549. fi
  550. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  551.   done
  552. else
  553.   echo "$as_me: failed program was:" >&5
  554. sed 's/^/| /' conftest.$ac_ext >&5
  555. cat >conftest.$ac_ext <<_ACEOF
  556. /* confdefs.h.  */
  557. _ACEOF
  558. cat confdefs.h >>conftest.$ac_ext
  559. cat >>conftest.$ac_ext <<_ACEOF
  560. /* end confdefs.h.  */
  561. $ac_includes_default
  562.    typedef short ac__type_sizeof_;
  563. int
  564. main ()
  565. {
  566. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  567. test_array [0] = 0
  568.   ;
  569.   return 0;
  570. }
  571. _ACEOF
  572. rm -f conftest.$ac_objext
  573. if { (ac_try="$ac_compile"
  574. case "(($ac_try" in
  575.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  576.   *) ac_try_echo=$ac_try;;
  577. esac
  578. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  579.   (eval "$ac_compile") 2>conftest.er1
  580.   ac_status=$?
  581.   grep -v '^ *+' conftest.er1 >conftest.err
  582.   rm -f conftest.er1
  583.   cat conftest.err >&5
  584.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  585.   (exit $ac_status); } && {
  586.  test -z "$ac_c_werror_flag" ||
  587.  test ! -s conftest.err
  588.        } && test -s conftest.$ac_objext; then
  589.   ac_hi=-1 ac_mid=-1
  590.   while :; do
  591.     cat >conftest.$ac_ext <<_ACEOF
  592. /* confdefs.h.  */
  593. _ACEOF
  594. cat confdefs.h >>conftest.$ac_ext
  595. cat >>conftest.$ac_ext <<_ACEOF
  596. /* end confdefs.h.  */
  597. $ac_includes_default
  598.    typedef short ac__type_sizeof_;
  599. int
  600. main ()
  601. {
  602. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  603. test_array [0] = 0
  604.   ;
  605.   return 0;
  606. }
  607. _ACEOF
  608. rm -f conftest.$ac_objext
  609. if { (ac_try="$ac_compile"
  610. case "(($ac_try" in
  611.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  612.   *) ac_try_echo=$ac_try;;
  613. esac
  614. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  615.   (eval "$ac_compile") 2>conftest.er1
  616.   ac_status=$?
  617.   grep -v '^ *+' conftest.er1 >conftest.err
  618.   rm -f conftest.er1
  619.   cat conftest.err >&5
  620.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  621.   (exit $ac_status); } && {
  622.  test -z "$ac_c_werror_flag" ||
  623.  test ! -s conftest.err
  624.        } && test -s conftest.$ac_objext; then
  625.   ac_lo=$ac_mid; break
  626. else
  627.   echo "$as_me: failed program was:" >&5
  628. sed 's/^/| /' conftest.$ac_ext >&5
  629. ac_hi=`expr '(' $ac_mid ')' - 1`
  630. if test $ac_mid -le $ac_hi; then
  631.   ac_lo= ac_hi=
  632.   break
  633. fi
  634. ac_mid=`expr 2 '*' $ac_mid`
  635. fi
  636. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  637.   done
  638. else
  639.   echo "$as_me: failed program was:" >&5
  640. sed 's/^/| /' conftest.$ac_ext >&5
  641. ac_lo= ac_hi=
  642. fi
  643. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  644. fi
  645. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  646. # Binary search between lo and hi bounds.
  647. while test "x$ac_lo" != "x$ac_hi"; do
  648.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  649.   cat >conftest.$ac_ext <<_ACEOF
  650. /* confdefs.h.  */
  651. _ACEOF
  652. cat confdefs.h >>conftest.$ac_ext
  653. cat >>conftest.$ac_ext <<_ACEOF
  654. /* end confdefs.h.  */
  655. $ac_includes_default
  656.    typedef short ac__type_sizeof_;
  657. int
  658. main ()
  659. {
  660. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  661. test_array [0] = 0
  662.   ;
  663.   return 0;
  664. }
  665. _ACEOF
  666. rm -f conftest.$ac_objext
  667. if { (ac_try="$ac_compile"
  668. case "(($ac_try" in
  669.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  670.   *) ac_try_echo=$ac_try;;
  671. esac
  672. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  673.   (eval "$ac_compile") 2>conftest.er1
  674.   ac_status=$?
  675.   grep -v '^ *+' conftest.er1 >conftest.err
  676.   rm -f conftest.er1
  677.   cat conftest.err >&5
  678.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  679.   (exit $ac_status); } && {
  680.  test -z "$ac_c_werror_flag" ||
  681.  test ! -s conftest.err
  682.        } && test -s conftest.$ac_objext; then
  683.   ac_hi=$ac_mid
  684. else
  685.   echo "$as_me: failed program was:" >&5
  686. sed 's/^/| /' conftest.$ac_ext >&5
  687. ac_lo=`expr '(' $ac_mid ')' + 1`
  688. fi
  689. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  690. done
  691. case $ac_lo in
  692. ?*) ac_cv_sizeof_short=$ac_lo;;
  693. '') if test "$ac_cv_type_short" = yes; then
  694.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (short)
  695. See `config.log' for more details." >&5
  696. echo "$as_me: error: cannot compute sizeof (short)
  697. See `config.log' for more details." >&2;}
  698.    { (exit 77); exit 77; }; }
  699.    else
  700.      ac_cv_sizeof_short=0
  701.    fi ;;
  702. esac
  703. else
  704.   cat >conftest.$ac_ext <<_ACEOF
  705. /* confdefs.h.  */
  706. _ACEOF
  707. cat confdefs.h >>conftest.$ac_ext
  708. cat >>conftest.$ac_ext <<_ACEOF
  709. /* end confdefs.h.  */
  710. $ac_includes_default
  711.    typedef short ac__type_sizeof_;
  712. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  713. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  714. #include <stdio.h>
  715. #include <stdlib.h>
  716. int
  717. main ()
  718. {
  719.   FILE *f = fopen ("conftest.val", "w");
  720.   if (! f)
  721.     return 1;
  722.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  723.     {
  724.       long int i = longval ();
  725.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  726. return 1;
  727.       fprintf (f, "%ldn", i);
  728.     }
  729.   else
  730.     {
  731.       unsigned long int i = ulongval ();
  732.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  733. return 1;
  734.       fprintf (f, "%lun", i);
  735.     }
  736.   return ferror (f) || fclose (f) != 0;
  737.   ;
  738.   return 0;
  739. }
  740. _ACEOF
  741. rm -f conftest$ac_exeext
  742. if { (ac_try="$ac_link"
  743. case "(($ac_try" in
  744.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  745.   *) ac_try_echo=$ac_try;;
  746. esac
  747. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  748.   (eval "$ac_link") 2>&5
  749.   ac_status=$?
  750.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  751.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  752.   { (case "(($ac_try" in
  753.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  754.   *) ac_try_echo=$ac_try;;
  755. esac
  756. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  757.   (eval "$ac_try") 2>&5
  758.   ac_status=$?
  759.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  760.   (exit $ac_status); }; }; then
  761.   ac_cv_sizeof_short=`cat conftest.val`
  762. else
  763.   echo "$as_me: program exited with status $ac_status" >&5
  764. echo "$as_me: failed program was:" >&5
  765. sed 's/^/| /' conftest.$ac_ext >&5
  766. ( exit $ac_status )
  767. if test "$ac_cv_type_short" = yes; then
  768.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (short)
  769. See `config.log' for more details." >&5
  770. echo "$as_me: error: cannot compute sizeof (short)
  771. See `config.log' for more details." >&2;}
  772.    { (exit 77); exit 77; }; }
  773.    else
  774.      ac_cv_sizeof_short=0
  775.    fi
  776. fi
  777. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  778. fi
  779. rm -f conftest.val
  780. fi
  781. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
  782. echo "${ECHO_T}$ac_cv_sizeof_short" >&6; }
  783. cat >>confdefs.h <<_ACEOF
  784. #define SIZEOF_SHORT $ac_cv_sizeof_short
  785. _ACEOF
  786. { echo "$as_me:$LINENO: checking for int" >&5
  787. echo $ECHO_N "checking for int... $ECHO_C" >&6; }
  788. if test "${ac_cv_type_int+set}" = set; then
  789.   echo $ECHO_N "(cached) $ECHO_C" >&6
  790. else
  791.   cat >conftest.$ac_ext <<_ACEOF
  792. /* confdefs.h.  */
  793. _ACEOF
  794. cat confdefs.h >>conftest.$ac_ext
  795. cat >>conftest.$ac_ext <<_ACEOF
  796. /* end confdefs.h.  */
  797. $ac_includes_default
  798. typedef int ac__type_new_;
  799. int
  800. main ()
  801. {
  802. if ((ac__type_new_ *) 0)
  803.   return 0;
  804. if (sizeof (ac__type_new_))
  805.   return 0;
  806.   ;
  807.   return 0;
  808. }
  809. _ACEOF
  810. rm -f conftest.$ac_objext
  811. if { (ac_try="$ac_compile"
  812. case "(($ac_try" in
  813.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  814.   *) ac_try_echo=$ac_try;;
  815. esac
  816. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  817.   (eval "$ac_compile") 2>conftest.er1
  818.   ac_status=$?
  819.   grep -v '^ *+' conftest.er1 >conftest.err
  820.   rm -f conftest.er1
  821.   cat conftest.err >&5
  822.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  823.   (exit $ac_status); } && {
  824.  test -z "$ac_c_werror_flag" ||
  825.  test ! -s conftest.err
  826.        } && test -s conftest.$ac_objext; then
  827.   ac_cv_type_int=yes
  828. else
  829.   echo "$as_me: failed program was:" >&5
  830. sed 's/^/| /' conftest.$ac_ext >&5
  831. ac_cv_type_int=no
  832. fi
  833. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  834. fi
  835. { echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
  836. echo "${ECHO_T}$ac_cv_type_int" >&6; }
  837. # The cast to long int works around a bug in the HP C Compiler
  838. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  839. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  840. # This bug is HP SR number 8606223364.
  841. { echo "$as_me:$LINENO: checking size of int" >&5
  842. echo $ECHO_N "checking size of int... $ECHO_C" >&6; }
  843. if test "${ac_cv_sizeof_int+set}" = set; then
  844.   echo $ECHO_N "(cached) $ECHO_C" >&6
  845. else
  846.   if test "$cross_compiling" = yes; then
  847.   # Depending upon the size, compute the lo and hi bounds.
  848. cat >conftest.$ac_ext <<_ACEOF
  849. /* confdefs.h.  */
  850. _ACEOF
  851. cat confdefs.h >>conftest.$ac_ext
  852. cat >>conftest.$ac_ext <<_ACEOF
  853. /* end confdefs.h.  */
  854. $ac_includes_default
  855.    typedef int ac__type_sizeof_;
  856. int
  857. main ()
  858. {
  859. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  860. test_array [0] = 0
  861.   ;
  862.   return 0;
  863. }
  864. _ACEOF
  865. rm -f conftest.$ac_objext
  866. if { (ac_try="$ac_compile"
  867. case "(($ac_try" in
  868.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  869.   *) ac_try_echo=$ac_try;;
  870. esac
  871. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  872.   (eval "$ac_compile") 2>conftest.er1
  873.   ac_status=$?
  874.   grep -v '^ *+' conftest.er1 >conftest.err
  875.   rm -f conftest.er1
  876.   cat conftest.err >&5
  877.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  878.   (exit $ac_status); } && {
  879.  test -z "$ac_c_werror_flag" ||
  880.  test ! -s conftest.err
  881.        } && test -s conftest.$ac_objext; then
  882.   ac_lo=0 ac_mid=0
  883.   while :; do
  884.     cat >conftest.$ac_ext <<_ACEOF
  885. /* confdefs.h.  */
  886. _ACEOF
  887. cat confdefs.h >>conftest.$ac_ext
  888. cat >>conftest.$ac_ext <<_ACEOF
  889. /* end confdefs.h.  */
  890. $ac_includes_default
  891.    typedef int ac__type_sizeof_;
  892. int
  893. main ()
  894. {
  895. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  896. test_array [0] = 0
  897.   ;
  898.   return 0;
  899. }
  900. _ACEOF
  901. rm -f conftest.$ac_objext
  902. if { (ac_try="$ac_compile"
  903. case "(($ac_try" in
  904.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  905.   *) ac_try_echo=$ac_try;;
  906. esac
  907. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  908.   (eval "$ac_compile") 2>conftest.er1
  909.   ac_status=$?
  910.   grep -v '^ *+' conftest.er1 >conftest.err
  911.   rm -f conftest.er1
  912.   cat conftest.err >&5
  913.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  914.   (exit $ac_status); } && {
  915.  test -z "$ac_c_werror_flag" ||
  916.  test ! -s conftest.err
  917.        } && test -s conftest.$ac_objext; then
  918.   ac_hi=$ac_mid; break
  919. else
  920.   echo "$as_me: failed program was:" >&5
  921. sed 's/^/| /' conftest.$ac_ext >&5
  922. ac_lo=`expr $ac_mid + 1`
  923. if test $ac_lo -le $ac_mid; then
  924.   ac_lo= ac_hi=
  925.   break
  926. fi
  927. ac_mid=`expr 2 '*' $ac_mid + 1`
  928. fi
  929. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  930.   done
  931. else
  932.   echo "$as_me: failed program was:" >&5
  933. sed 's/^/| /' conftest.$ac_ext >&5
  934. cat >conftest.$ac_ext <<_ACEOF
  935. /* confdefs.h.  */
  936. _ACEOF
  937. cat confdefs.h >>conftest.$ac_ext
  938. cat >>conftest.$ac_ext <<_ACEOF
  939. /* end confdefs.h.  */
  940. $ac_includes_default
  941.    typedef int ac__type_sizeof_;
  942. int
  943. main ()
  944. {
  945. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  946. test_array [0] = 0
  947.   ;
  948.   return 0;
  949. }
  950. _ACEOF
  951. rm -f conftest.$ac_objext
  952. if { (ac_try="$ac_compile"
  953. case "(($ac_try" in
  954.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  955.   *) ac_try_echo=$ac_try;;
  956. esac
  957. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  958.   (eval "$ac_compile") 2>conftest.er1
  959.   ac_status=$?
  960.   grep -v '^ *+' conftest.er1 >conftest.err
  961.   rm -f conftest.er1
  962.   cat conftest.err >&5
  963.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  964.   (exit $ac_status); } && {
  965.  test -z "$ac_c_werror_flag" ||
  966.  test ! -s conftest.err
  967.        } && test -s conftest.$ac_objext; then
  968.   ac_hi=-1 ac_mid=-1
  969.   while :; do
  970.     cat >conftest.$ac_ext <<_ACEOF
  971. /* confdefs.h.  */
  972. _ACEOF
  973. cat confdefs.h >>conftest.$ac_ext
  974. cat >>conftest.$ac_ext <<_ACEOF
  975. /* end confdefs.h.  */
  976. $ac_includes_default
  977.    typedef int ac__type_sizeof_;
  978. int
  979. main ()
  980. {
  981. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  982. test_array [0] = 0
  983.   ;
  984.   return 0;
  985. }
  986. _ACEOF
  987. rm -f conftest.$ac_objext
  988. if { (ac_try="$ac_compile"
  989. case "(($ac_try" in
  990.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  991.   *) ac_try_echo=$ac_try;;
  992. esac
  993. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  994.   (eval "$ac_compile") 2>conftest.er1
  995.   ac_status=$?
  996.   grep -v '^ *+' conftest.er1 >conftest.err
  997.   rm -f conftest.er1
  998.   cat conftest.err >&5
  999.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1000.   (exit $ac_status); } && {
  1001.  test -z "$ac_c_werror_flag" ||
  1002.  test ! -s conftest.err
  1003.        } && test -s conftest.$ac_objext; then
  1004.   ac_lo=$ac_mid; break
  1005. else
  1006.   echo "$as_me: failed program was:" >&5
  1007. sed 's/^/| /' conftest.$ac_ext >&5
  1008. ac_hi=`expr '(' $ac_mid ')' - 1`
  1009. if test $ac_mid -le $ac_hi; then
  1010.   ac_lo= ac_hi=
  1011.   break
  1012. fi
  1013. ac_mid=`expr 2 '*' $ac_mid`
  1014. fi
  1015. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1016.   done
  1017. else
  1018.   echo "$as_me: failed program was:" >&5
  1019. sed 's/^/| /' conftest.$ac_ext >&5
  1020. ac_lo= ac_hi=
  1021. fi
  1022. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1023. fi
  1024. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1025. # Binary search between lo and hi bounds.
  1026. while test "x$ac_lo" != "x$ac_hi"; do
  1027.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  1028.   cat >conftest.$ac_ext <<_ACEOF
  1029. /* confdefs.h.  */
  1030. _ACEOF
  1031. cat confdefs.h >>conftest.$ac_ext
  1032. cat >>conftest.$ac_ext <<_ACEOF
  1033. /* end confdefs.h.  */
  1034. $ac_includes_default
  1035.    typedef int ac__type_sizeof_;
  1036. int
  1037. main ()
  1038. {
  1039. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  1040. test_array [0] = 0
  1041.   ;
  1042.   return 0;
  1043. }
  1044. _ACEOF
  1045. rm -f conftest.$ac_objext
  1046. if { (ac_try="$ac_compile"
  1047. case "(($ac_try" in
  1048.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1049.   *) ac_try_echo=$ac_try;;
  1050. esac
  1051. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1052.   (eval "$ac_compile") 2>conftest.er1
  1053.   ac_status=$?
  1054.   grep -v '^ *+' conftest.er1 >conftest.err
  1055.   rm -f conftest.er1
  1056.   cat conftest.err >&5
  1057.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1058.   (exit $ac_status); } && {
  1059.  test -z "$ac_c_werror_flag" ||
  1060.  test ! -s conftest.err
  1061.        } && test -s conftest.$ac_objext; then
  1062.   ac_hi=$ac_mid
  1063. else
  1064.   echo "$as_me: failed program was:" >&5
  1065. sed 's/^/| /' conftest.$ac_ext >&5
  1066. ac_lo=`expr '(' $ac_mid ')' + 1`
  1067. fi
  1068. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1069. done
  1070. case $ac_lo in
  1071. ?*) ac_cv_sizeof_int=$ac_lo;;
  1072. '') if test "$ac_cv_type_int" = yes; then
  1073.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (int)
  1074. See `config.log' for more details." >&5
  1075. echo "$as_me: error: cannot compute sizeof (int)
  1076. See `config.log' for more details." >&2;}
  1077.    { (exit 77); exit 77; }; }
  1078.    else
  1079.      ac_cv_sizeof_int=0
  1080.    fi ;;
  1081. esac
  1082. else
  1083.   cat >conftest.$ac_ext <<_ACEOF
  1084. /* confdefs.h.  */
  1085. _ACEOF
  1086. cat confdefs.h >>conftest.$ac_ext
  1087. cat >>conftest.$ac_ext <<_ACEOF
  1088. /* end confdefs.h.  */
  1089. $ac_includes_default
  1090.    typedef int ac__type_sizeof_;
  1091. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  1092. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  1093. #include <stdio.h>
  1094. #include <stdlib.h>
  1095. int
  1096. main ()
  1097. {
  1098.   FILE *f = fopen ("conftest.val", "w");
  1099.   if (! f)
  1100.     return 1;
  1101.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  1102.     {
  1103.       long int i = longval ();
  1104.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  1105. return 1;
  1106.       fprintf (f, "%ldn", i);
  1107.     }
  1108.   else
  1109.     {
  1110.       unsigned long int i = ulongval ();
  1111.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  1112. return 1;
  1113.       fprintf (f, "%lun", i);
  1114.     }
  1115.   return ferror (f) || fclose (f) != 0;
  1116.   ;
  1117.   return 0;
  1118. }
  1119. _ACEOF
  1120. rm -f conftest$ac_exeext
  1121. if { (ac_try="$ac_link"
  1122. case "(($ac_try" in
  1123.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1124.   *) ac_try_echo=$ac_try;;
  1125. esac
  1126. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1127.   (eval "$ac_link") 2>&5
  1128.   ac_status=$?
  1129.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1130.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  1131.   { (case "(($ac_try" in
  1132.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1133.   *) ac_try_echo=$ac_try;;
  1134. esac
  1135. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1136.   (eval "$ac_try") 2>&5
  1137.   ac_status=$?
  1138.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1139.   (exit $ac_status); }; }; then
  1140.   ac_cv_sizeof_int=`cat conftest.val`
  1141. else
  1142.   echo "$as_me: program exited with status $ac_status" >&5
  1143. echo "$as_me: failed program was:" >&5
  1144. sed 's/^/| /' conftest.$ac_ext >&5
  1145. ( exit $ac_status )
  1146. if test "$ac_cv_type_int" = yes; then
  1147.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (int)
  1148. See `config.log' for more details." >&5
  1149. echo "$as_me: error: cannot compute sizeof (int)
  1150. See `config.log' for more details." >&2;}
  1151.    { (exit 77); exit 77; }; }
  1152.    else
  1153.      ac_cv_sizeof_int=0
  1154.    fi
  1155. fi
  1156. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  1157. fi
  1158. rm -f conftest.val
  1159. fi
  1160. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
  1161. echo "${ECHO_T}$ac_cv_sizeof_int" >&6; }
  1162. cat >>confdefs.h <<_ACEOF
  1163. #define SIZEOF_INT $ac_cv_sizeof_int
  1164. _ACEOF
  1165. { echo "$as_me:$LINENO: checking for long" >&5
  1166. echo $ECHO_N "checking for long... $ECHO_C" >&6; }
  1167. if test "${ac_cv_type_long+set}" = set; then
  1168.   echo $ECHO_N "(cached) $ECHO_C" >&6
  1169. else
  1170.   cat >conftest.$ac_ext <<_ACEOF
  1171. /* confdefs.h.  */
  1172. _ACEOF
  1173. cat confdefs.h >>conftest.$ac_ext
  1174. cat >>conftest.$ac_ext <<_ACEOF
  1175. /* end confdefs.h.  */
  1176. $ac_includes_default
  1177. typedef long ac__type_new_;
  1178. int
  1179. main ()
  1180. {
  1181. if ((ac__type_new_ *) 0)
  1182.   return 0;
  1183. if (sizeof (ac__type_new_))
  1184.   return 0;
  1185.   ;
  1186.   return 0;
  1187. }
  1188. _ACEOF
  1189. rm -f conftest.$ac_objext
  1190. if { (ac_try="$ac_compile"
  1191. case "(($ac_try" in
  1192.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1193.   *) ac_try_echo=$ac_try;;
  1194. esac
  1195. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1196.   (eval "$ac_compile") 2>conftest.er1
  1197.   ac_status=$?
  1198.   grep -v '^ *+' conftest.er1 >conftest.err
  1199.   rm -f conftest.er1
  1200.   cat conftest.err >&5
  1201.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1202.   (exit $ac_status); } && {
  1203.  test -z "$ac_c_werror_flag" ||
  1204.  test ! -s conftest.err
  1205.        } && test -s conftest.$ac_objext; then
  1206.   ac_cv_type_long=yes
  1207. else
  1208.   echo "$as_me: failed program was:" >&5
  1209. sed 's/^/| /' conftest.$ac_ext >&5
  1210. ac_cv_type_long=no
  1211. fi
  1212. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1213. fi
  1214. { echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
  1215. echo "${ECHO_T}$ac_cv_type_long" >&6; }
  1216. # The cast to long int works around a bug in the HP C Compiler
  1217. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  1218. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  1219. # This bug is HP SR number 8606223364.
  1220. { echo "$as_me:$LINENO: checking size of long" >&5
  1221. echo $ECHO_N "checking size of long... $ECHO_C" >&6; }
  1222. if test "${ac_cv_sizeof_long+set}" = set; then
  1223.   echo $ECHO_N "(cached) $ECHO_C" >&6
  1224. else
  1225.   if test "$cross_compiling" = yes; then
  1226.   # Depending upon the size, compute the lo and hi bounds.
  1227. cat >conftest.$ac_ext <<_ACEOF
  1228. /* confdefs.h.  */
  1229. _ACEOF
  1230. cat confdefs.h >>conftest.$ac_ext
  1231. cat >>conftest.$ac_ext <<_ACEOF
  1232. /* end confdefs.h.  */
  1233. $ac_includes_default
  1234.    typedef long ac__type_sizeof_;
  1235. int
  1236. main ()
  1237. {
  1238. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  1239. test_array [0] = 0
  1240.   ;
  1241.   return 0;
  1242. }
  1243. _ACEOF
  1244. rm -f conftest.$ac_objext
  1245. if { (ac_try="$ac_compile"
  1246. case "(($ac_try" in
  1247.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1248.   *) ac_try_echo=$ac_try;;
  1249. esac
  1250. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1251.   (eval "$ac_compile") 2>conftest.er1
  1252.   ac_status=$?
  1253.   grep -v '^ *+' conftest.er1 >conftest.err
  1254.   rm -f conftest.er1
  1255.   cat conftest.err >&5
  1256.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1257.   (exit $ac_status); } && {
  1258.  test -z "$ac_c_werror_flag" ||
  1259.  test ! -s conftest.err
  1260.        } && test -s conftest.$ac_objext; then
  1261.   ac_lo=0 ac_mid=0
  1262.   while :; do
  1263.     cat >conftest.$ac_ext <<_ACEOF
  1264. /* confdefs.h.  */
  1265. _ACEOF
  1266. cat confdefs.h >>conftest.$ac_ext
  1267. cat >>conftest.$ac_ext <<_ACEOF
  1268. /* end confdefs.h.  */
  1269. $ac_includes_default
  1270.    typedef long ac__type_sizeof_;
  1271. int
  1272. main ()
  1273. {
  1274. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  1275. test_array [0] = 0
  1276.   ;
  1277.   return 0;
  1278. }
  1279. _ACEOF
  1280. rm -f conftest.$ac_objext
  1281. if { (ac_try="$ac_compile"
  1282. case "(($ac_try" in
  1283.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1284.   *) ac_try_echo=$ac_try;;
  1285. esac
  1286. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1287.   (eval "$ac_compile") 2>conftest.er1
  1288.   ac_status=$?
  1289.   grep -v '^ *+' conftest.er1 >conftest.err
  1290.   rm -f conftest.er1
  1291.   cat conftest.err >&5
  1292.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1293.   (exit $ac_status); } && {
  1294.  test -z "$ac_c_werror_flag" ||
  1295.  test ! -s conftest.err
  1296.        } && test -s conftest.$ac_objext; then
  1297.   ac_hi=$ac_mid; break
  1298. else
  1299.   echo "$as_me: failed program was:" >&5
  1300. sed 's/^/| /' conftest.$ac_ext >&5
  1301. ac_lo=`expr $ac_mid + 1`
  1302. if test $ac_lo -le $ac_mid; then
  1303.   ac_lo= ac_hi=
  1304.   break
  1305. fi
  1306. ac_mid=`expr 2 '*' $ac_mid + 1`
  1307. fi
  1308. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1309.   done
  1310. else
  1311.   echo "$as_me: failed program was:" >&5
  1312. sed 's/^/| /' conftest.$ac_ext >&5
  1313. cat >conftest.$ac_ext <<_ACEOF
  1314. /* confdefs.h.  */
  1315. _ACEOF
  1316. cat confdefs.h >>conftest.$ac_ext
  1317. cat >>conftest.$ac_ext <<_ACEOF
  1318. /* end confdefs.h.  */
  1319. $ac_includes_default
  1320.    typedef long ac__type_sizeof_;
  1321. int
  1322. main ()
  1323. {
  1324. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  1325. test_array [0] = 0
  1326.   ;
  1327.   return 0;
  1328. }
  1329. _ACEOF
  1330. rm -f conftest.$ac_objext
  1331. if { (ac_try="$ac_compile"
  1332. case "(($ac_try" in
  1333.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1334.   *) ac_try_echo=$ac_try;;
  1335. esac
  1336. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1337.   (eval "$ac_compile") 2>conftest.er1
  1338.   ac_status=$?
  1339.   grep -v '^ *+' conftest.er1 >conftest.err
  1340.   rm -f conftest.er1
  1341.   cat conftest.err >&5
  1342.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1343.   (exit $ac_status); } && {
  1344.  test -z "$ac_c_werror_flag" ||
  1345.  test ! -s conftest.err
  1346.        } && test -s conftest.$ac_objext; then
  1347.   ac_hi=-1 ac_mid=-1
  1348.   while :; do
  1349.     cat >conftest.$ac_ext <<_ACEOF
  1350. /* confdefs.h.  */
  1351. _ACEOF
  1352. cat confdefs.h >>conftest.$ac_ext
  1353. cat >>conftest.$ac_ext <<_ACEOF
  1354. /* end confdefs.h.  */
  1355. $ac_includes_default
  1356.    typedef long ac__type_sizeof_;
  1357. int
  1358. main ()
  1359. {
  1360. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  1361. test_array [0] = 0
  1362.   ;
  1363.   return 0;
  1364. }
  1365. _ACEOF
  1366. rm -f conftest.$ac_objext
  1367. if { (ac_try="$ac_compile"
  1368. case "(($ac_try" in
  1369.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1370.   *) ac_try_echo=$ac_try;;
  1371. esac
  1372. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1373.   (eval "$ac_compile") 2>conftest.er1
  1374.   ac_status=$?
  1375.   grep -v '^ *+' conftest.er1 >conftest.err
  1376.   rm -f conftest.er1
  1377.   cat conftest.err >&5
  1378.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1379.   (exit $ac_status); } && {
  1380.  test -z "$ac_c_werror_flag" ||
  1381.  test ! -s conftest.err
  1382.        } && test -s conftest.$ac_objext; then
  1383.   ac_lo=$ac_mid; break
  1384. else
  1385.   echo "$as_me: failed program was:" >&5
  1386. sed 's/^/| /' conftest.$ac_ext >&5
  1387. ac_hi=`expr '(' $ac_mid ')' - 1`
  1388. if test $ac_mid -le $ac_hi; then
  1389.   ac_lo= ac_hi=
  1390.   break
  1391. fi
  1392. ac_mid=`expr 2 '*' $ac_mid`
  1393. fi
  1394. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1395.   done
  1396. else
  1397.   echo "$as_me: failed program was:" >&5
  1398. sed 's/^/| /' conftest.$ac_ext >&5
  1399. ac_lo= ac_hi=
  1400. fi
  1401. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1402. fi
  1403. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1404. # Binary search between lo and hi bounds.
  1405. while test "x$ac_lo" != "x$ac_hi"; do
  1406.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  1407.   cat >conftest.$ac_ext <<_ACEOF
  1408. /* confdefs.h.  */
  1409. _ACEOF
  1410. cat confdefs.h >>conftest.$ac_ext
  1411. cat >>conftest.$ac_ext <<_ACEOF
  1412. /* end confdefs.h.  */
  1413. $ac_includes_default
  1414.    typedef long ac__type_sizeof_;
  1415. int
  1416. main ()
  1417. {
  1418. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  1419. test_array [0] = 0
  1420.   ;
  1421.   return 0;
  1422. }
  1423. _ACEOF
  1424. rm -f conftest.$ac_objext
  1425. if { (ac_try="$ac_compile"
  1426. case "(($ac_try" in
  1427.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1428.   *) ac_try_echo=$ac_try;;
  1429. esac
  1430. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1431.   (eval "$ac_compile") 2>conftest.er1
  1432.   ac_status=$?
  1433.   grep -v '^ *+' conftest.er1 >conftest.err
  1434.   rm -f conftest.er1
  1435.   cat conftest.err >&5
  1436.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1437.   (exit $ac_status); } && {
  1438.  test -z "$ac_c_werror_flag" ||
  1439.  test ! -s conftest.err
  1440.        } && test -s conftest.$ac_objext; then
  1441.   ac_hi=$ac_mid
  1442. else
  1443.   echo "$as_me: failed program was:" >&5
  1444. sed 's/^/| /' conftest.$ac_ext >&5
  1445. ac_lo=`expr '(' $ac_mid ')' + 1`
  1446. fi
  1447. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1448. done
  1449. case $ac_lo in
  1450. ?*) ac_cv_sizeof_long=$ac_lo;;
  1451. '') if test "$ac_cv_type_long" = yes; then
  1452.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
  1453. See `config.log' for more details." >&5
  1454. echo "$as_me: error: cannot compute sizeof (long)
  1455. See `config.log' for more details." >&2;}
  1456.    { (exit 77); exit 77; }; }
  1457.    else
  1458.      ac_cv_sizeof_long=0
  1459.    fi ;;
  1460. esac
  1461. else
  1462.   cat >conftest.$ac_ext <<_ACEOF
  1463. /* confdefs.h.  */
  1464. _ACEOF
  1465. cat confdefs.h >>conftest.$ac_ext
  1466. cat >>conftest.$ac_ext <<_ACEOF
  1467. /* end confdefs.h.  */
  1468. $ac_includes_default
  1469.    typedef long ac__type_sizeof_;
  1470. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  1471. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  1472. #include <stdio.h>
  1473. #include <stdlib.h>
  1474. int
  1475. main ()
  1476. {
  1477.   FILE *f = fopen ("conftest.val", "w");
  1478.   if (! f)
  1479.     return 1;
  1480.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  1481.     {
  1482.       long int i = longval ();
  1483.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  1484. return 1;
  1485.       fprintf (f, "%ldn", i);
  1486.     }
  1487.   else
  1488.     {
  1489.       unsigned long int i = ulongval ();
  1490.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  1491. return 1;
  1492.       fprintf (f, "%lun", i);
  1493.     }
  1494.   return ferror (f) || fclose (f) != 0;
  1495.   ;
  1496.   return 0;
  1497. }
  1498. _ACEOF
  1499. rm -f conftest$ac_exeext
  1500. if { (ac_try="$ac_link"
  1501. case "(($ac_try" in
  1502.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1503.   *) ac_try_echo=$ac_try;;
  1504. esac
  1505. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1506.   (eval "$ac_link") 2>&5
  1507.   ac_status=$?
  1508.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1509.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  1510.   { (case "(($ac_try" in
  1511.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1512.   *) ac_try_echo=$ac_try;;
  1513. esac
  1514. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1515.   (eval "$ac_try") 2>&5
  1516.   ac_status=$?
  1517.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1518.   (exit $ac_status); }; }; then
  1519.   ac_cv_sizeof_long=`cat conftest.val`
  1520. else
  1521.   echo "$as_me: program exited with status $ac_status" >&5
  1522. echo "$as_me: failed program was:" >&5
  1523. sed 's/^/| /' conftest.$ac_ext >&5
  1524. ( exit $ac_status )
  1525. if test "$ac_cv_type_long" = yes; then
  1526.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
  1527. See `config.log' for more details." >&5
  1528. echo "$as_me: error: cannot compute sizeof (long)
  1529. See `config.log' for more details." >&2;}
  1530.    { (exit 77); exit 77; }; }
  1531.    else
  1532.      ac_cv_sizeof_long=0
  1533.    fi
  1534. fi
  1535. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  1536. fi
  1537. rm -f conftest.val
  1538. fi
  1539. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
  1540. echo "${ECHO_T}$ac_cv_sizeof_long" >&6; }
  1541. cat >>confdefs.h <<_ACEOF
  1542. #define SIZEOF_LONG $ac_cv_sizeof_long
  1543. _ACEOF
  1544. { echo "$as_me:$LINENO: checking for long long" >&5
  1545. echo $ECHO_N "checking for long long... $ECHO_C" >&6; }
  1546. if test "${ac_cv_type_long_long+set}" = set; then
  1547.   echo $ECHO_N "(cached) $ECHO_C" >&6
  1548. else
  1549.   cat >conftest.$ac_ext <<_ACEOF
  1550. /* confdefs.h.  */
  1551. _ACEOF
  1552. cat confdefs.h >>conftest.$ac_ext
  1553. cat >>conftest.$ac_ext <<_ACEOF
  1554. /* end confdefs.h.  */
  1555. $ac_includes_default
  1556. typedef long long ac__type_new_;
  1557. int
  1558. main ()
  1559. {
  1560. if ((ac__type_new_ *) 0)
  1561.   return 0;
  1562. if (sizeof (ac__type_new_))
  1563.   return 0;
  1564.   ;
  1565.   return 0;
  1566. }
  1567. _ACEOF
  1568. rm -f conftest.$ac_objext
  1569. if { (ac_try="$ac_compile"
  1570. case "(($ac_try" in
  1571.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1572.   *) ac_try_echo=$ac_try;;
  1573. esac
  1574. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1575.   (eval "$ac_compile") 2>conftest.er1
  1576.   ac_status=$?
  1577.   grep -v '^ *+' conftest.er1 >conftest.err
  1578.   rm -f conftest.er1
  1579.   cat conftest.err >&5
  1580.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1581.   (exit $ac_status); } && {
  1582.  test -z "$ac_c_werror_flag" ||
  1583.  test ! -s conftest.err
  1584.        } && test -s conftest.$ac_objext; then
  1585.   ac_cv_type_long_long=yes
  1586. else
  1587.   echo "$as_me: failed program was:" >&5
  1588. sed 's/^/| /' conftest.$ac_ext >&5
  1589. ac_cv_type_long_long=no
  1590. fi
  1591. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1592. fi
  1593. { echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5
  1594. echo "${ECHO_T}$ac_cv_type_long_long" >&6; }
  1595. # The cast to long int works around a bug in the HP C Compiler
  1596. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  1597. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  1598. # This bug is HP SR number 8606223364.
  1599. { echo "$as_me:$LINENO: checking size of long long" >&5
  1600. echo $ECHO_N "checking size of long long... $ECHO_C" >&6; }
  1601. if test "${ac_cv_sizeof_long_long+set}" = set; then
  1602.   echo $ECHO_N "(cached) $ECHO_C" >&6
  1603. else
  1604.   if test "$cross_compiling" = yes; then
  1605.   # Depending upon the size, compute the lo and hi bounds.
  1606. cat >conftest.$ac_ext <<_ACEOF
  1607. /* confdefs.h.  */
  1608. _ACEOF
  1609. cat confdefs.h >>conftest.$ac_ext
  1610. cat >>conftest.$ac_ext <<_ACEOF
  1611. /* end confdefs.h.  */
  1612. $ac_includes_default
  1613.    typedef long long ac__type_sizeof_;
  1614. int
  1615. main ()
  1616. {
  1617. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  1618. test_array [0] = 0
  1619.   ;
  1620.   return 0;
  1621. }
  1622. _ACEOF
  1623. rm -f conftest.$ac_objext
  1624. if { (ac_try="$ac_compile"
  1625. case "(($ac_try" in
  1626.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1627.   *) ac_try_echo=$ac_try;;
  1628. esac
  1629. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1630.   (eval "$ac_compile") 2>conftest.er1
  1631.   ac_status=$?
  1632.   grep -v '^ *+' conftest.er1 >conftest.err
  1633.   rm -f conftest.er1
  1634.   cat conftest.err >&5
  1635.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1636.   (exit $ac_status); } && {
  1637.  test -z "$ac_c_werror_flag" ||
  1638.  test ! -s conftest.err
  1639.        } && test -s conftest.$ac_objext; then
  1640.   ac_lo=0 ac_mid=0
  1641.   while :; do
  1642.     cat >conftest.$ac_ext <<_ACEOF
  1643. /* confdefs.h.  */
  1644. _ACEOF
  1645. cat confdefs.h >>conftest.$ac_ext
  1646. cat >>conftest.$ac_ext <<_ACEOF
  1647. /* end confdefs.h.  */
  1648. $ac_includes_default
  1649.    typedef long long ac__type_sizeof_;
  1650. int
  1651. main ()
  1652. {
  1653. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  1654. test_array [0] = 0
  1655.   ;
  1656.   return 0;
  1657. }
  1658. _ACEOF
  1659. rm -f conftest.$ac_objext
  1660. if { (ac_try="$ac_compile"
  1661. case "(($ac_try" in
  1662.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1663.   *) ac_try_echo=$ac_try;;
  1664. esac
  1665. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1666.   (eval "$ac_compile") 2>conftest.er1
  1667.   ac_status=$?
  1668.   grep -v '^ *+' conftest.er1 >conftest.err
  1669.   rm -f conftest.er1
  1670.   cat conftest.err >&5
  1671.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1672.   (exit $ac_status); } && {
  1673.  test -z "$ac_c_werror_flag" ||
  1674.  test ! -s conftest.err
  1675.        } && test -s conftest.$ac_objext; then
  1676.   ac_hi=$ac_mid; break
  1677. else
  1678.   echo "$as_me: failed program was:" >&5
  1679. sed 's/^/| /' conftest.$ac_ext >&5
  1680. ac_lo=`expr $ac_mid + 1`
  1681. if test $ac_lo -le $ac_mid; then
  1682.   ac_lo= ac_hi=
  1683.   break
  1684. fi
  1685. ac_mid=`expr 2 '*' $ac_mid + 1`
  1686. fi
  1687. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1688.   done
  1689. else
  1690.   echo "$as_me: failed program was:" >&5
  1691. sed 's/^/| /' conftest.$ac_ext >&5
  1692. cat >conftest.$ac_ext <<_ACEOF
  1693. /* confdefs.h.  */
  1694. _ACEOF
  1695. cat confdefs.h >>conftest.$ac_ext
  1696. cat >>conftest.$ac_ext <<_ACEOF
  1697. /* end confdefs.h.  */
  1698. $ac_includes_default
  1699.    typedef long long ac__type_sizeof_;
  1700. int
  1701. main ()
  1702. {
  1703. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  1704. test_array [0] = 0
  1705.   ;
  1706.   return 0;
  1707. }
  1708. _ACEOF
  1709. rm -f conftest.$ac_objext
  1710. if { (ac_try="$ac_compile"
  1711. case "(($ac_try" in
  1712.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1713.   *) ac_try_echo=$ac_try;;
  1714. esac
  1715. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1716.   (eval "$ac_compile") 2>conftest.er1
  1717.   ac_status=$?
  1718.   grep -v '^ *+' conftest.er1 >conftest.err
  1719.   rm -f conftest.er1
  1720.   cat conftest.err >&5
  1721.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1722.   (exit $ac_status); } && {
  1723.  test -z "$ac_c_werror_flag" ||
  1724.  test ! -s conftest.err
  1725.        } && test -s conftest.$ac_objext; then
  1726.   ac_hi=-1 ac_mid=-1
  1727.   while :; do
  1728.     cat >conftest.$ac_ext <<_ACEOF
  1729. /* confdefs.h.  */
  1730. _ACEOF
  1731. cat confdefs.h >>conftest.$ac_ext
  1732. cat >>conftest.$ac_ext <<_ACEOF
  1733. /* end confdefs.h.  */
  1734. $ac_includes_default
  1735.    typedef long long ac__type_sizeof_;
  1736. int
  1737. main ()
  1738. {
  1739. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  1740. test_array [0] = 0
  1741.   ;
  1742.   return 0;
  1743. }
  1744. _ACEOF
  1745. rm -f conftest.$ac_objext
  1746. if { (ac_try="$ac_compile"
  1747. case "(($ac_try" in
  1748.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1749.   *) ac_try_echo=$ac_try;;
  1750. esac
  1751. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1752.   (eval "$ac_compile") 2>conftest.er1
  1753.   ac_status=$?
  1754.   grep -v '^ *+' conftest.er1 >conftest.err
  1755.   rm -f conftest.er1
  1756.   cat conftest.err >&5
  1757.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1758.   (exit $ac_status); } && {
  1759.  test -z "$ac_c_werror_flag" ||
  1760.  test ! -s conftest.err
  1761.        } && test -s conftest.$ac_objext; then
  1762.   ac_lo=$ac_mid; break
  1763. else
  1764.   echo "$as_me: failed program was:" >&5
  1765. sed 's/^/| /' conftest.$ac_ext >&5
  1766. ac_hi=`expr '(' $ac_mid ')' - 1`
  1767. if test $ac_mid -le $ac_hi; then
  1768.   ac_lo= ac_hi=
  1769.   break
  1770. fi
  1771. ac_mid=`expr 2 '*' $ac_mid`
  1772. fi
  1773. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1774.   done
  1775. else
  1776.   echo "$as_me: failed program was:" >&5
  1777. sed 's/^/| /' conftest.$ac_ext >&5
  1778. ac_lo= ac_hi=
  1779. fi
  1780. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1781. fi
  1782. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1783. # Binary search between lo and hi bounds.
  1784. while test "x$ac_lo" != "x$ac_hi"; do
  1785.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  1786.   cat >conftest.$ac_ext <<_ACEOF
  1787. /* confdefs.h.  */
  1788. _ACEOF
  1789. cat confdefs.h >>conftest.$ac_ext
  1790. cat >>conftest.$ac_ext <<_ACEOF
  1791. /* end confdefs.h.  */
  1792. $ac_includes_default
  1793.    typedef long long ac__type_sizeof_;
  1794. int
  1795. main ()
  1796. {
  1797. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  1798. test_array [0] = 0
  1799.   ;
  1800.   return 0;
  1801. }
  1802. _ACEOF
  1803. rm -f conftest.$ac_objext
  1804. if { (ac_try="$ac_compile"
  1805. case "(($ac_try" in
  1806.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1807.   *) ac_try_echo=$ac_try;;
  1808. esac
  1809. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1810.   (eval "$ac_compile") 2>conftest.er1
  1811.   ac_status=$?
  1812.   grep -v '^ *+' conftest.er1 >conftest.err
  1813.   rm -f conftest.er1
  1814.   cat conftest.err >&5
  1815.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1816.   (exit $ac_status); } && {
  1817.  test -z "$ac_c_werror_flag" ||
  1818.  test ! -s conftest.err
  1819.        } && test -s conftest.$ac_objext; then
  1820.   ac_hi=$ac_mid
  1821. else
  1822.   echo "$as_me: failed program was:" >&5
  1823. sed 's/^/| /' conftest.$ac_ext >&5
  1824. ac_lo=`expr '(' $ac_mid ')' + 1`
  1825. fi
  1826. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1827. done
  1828. case $ac_lo in
  1829. ?*) ac_cv_sizeof_long_long=$ac_lo;;
  1830. '') if test "$ac_cv_type_long_long" = yes; then
  1831.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
  1832. See `config.log' for more details." >&5
  1833. echo "$as_me: error: cannot compute sizeof (long long)
  1834. See `config.log' for more details." >&2;}
  1835.    { (exit 77); exit 77; }; }
  1836.    else
  1837.      ac_cv_sizeof_long_long=0
  1838.    fi ;;
  1839. esac
  1840. else
  1841.   cat >conftest.$ac_ext <<_ACEOF
  1842. /* confdefs.h.  */
  1843. _ACEOF
  1844. cat confdefs.h >>conftest.$ac_ext
  1845. cat >>conftest.$ac_ext <<_ACEOF
  1846. /* end confdefs.h.  */
  1847. $ac_includes_default
  1848.    typedef long long ac__type_sizeof_;
  1849. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  1850. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  1851. #include <stdio.h>
  1852. #include <stdlib.h>
  1853. int
  1854. main ()
  1855. {
  1856.   FILE *f = fopen ("conftest.val", "w");
  1857.   if (! f)
  1858.     return 1;
  1859.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  1860.     {
  1861.       long int i = longval ();
  1862.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  1863. return 1;
  1864.       fprintf (f, "%ldn", i);
  1865.     }
  1866.   else
  1867.     {
  1868.       unsigned long int i = ulongval ();
  1869.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  1870. return 1;
  1871.       fprintf (f, "%lun", i);
  1872.     }
  1873.   return ferror (f) || fclose (f) != 0;
  1874.   ;
  1875.   return 0;
  1876. }
  1877. _ACEOF
  1878. rm -f conftest$ac_exeext
  1879. if { (ac_try="$ac_link"
  1880. case "(($ac_try" in
  1881.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1882.   *) ac_try_echo=$ac_try;;
  1883. esac
  1884. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1885.   (eval "$ac_link") 2>&5
  1886.   ac_status=$?
  1887.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1888.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  1889.   { (case "(($ac_try" in
  1890.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1891.   *) ac_try_echo=$ac_try;;
  1892. esac
  1893. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1894.   (eval "$ac_try") 2>&5
  1895.   ac_status=$?
  1896.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1897.   (exit $ac_status); }; }; then
  1898.   ac_cv_sizeof_long_long=`cat conftest.val`
  1899. else
  1900.   echo "$as_me: program exited with status $ac_status" >&5
  1901. echo "$as_me: failed program was:" >&5
  1902. sed 's/^/| /' conftest.$ac_ext >&5
  1903. ( exit $ac_status )
  1904. if test "$ac_cv_type_long_long" = yes; then
  1905.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
  1906. See `config.log' for more details." >&5
  1907. echo "$as_me: error: cannot compute sizeof (long long)
  1908. See `config.log' for more details." >&2;}
  1909.    { (exit 77); exit 77; }; }
  1910.    else
  1911.      ac_cv_sizeof_long_long=0
  1912.    fi
  1913. fi
  1914. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  1915. fi
  1916. rm -f conftest.val
  1917. fi
  1918. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5
  1919. echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6; }
  1920. cat >>confdefs.h <<_ACEOF
  1921. #define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long
  1922. _ACEOF
  1923. { echo "$as_me:$LINENO: checking for __int64" >&5
  1924. echo $ECHO_N "checking for __int64... $ECHO_C" >&6; }
  1925. if test "${ac_cv_type___int64+set}" = set; then
  1926.   echo $ECHO_N "(cached) $ECHO_C" >&6
  1927. else
  1928.   cat >conftest.$ac_ext <<_ACEOF
  1929. /* confdefs.h.  */
  1930. _ACEOF
  1931. cat confdefs.h >>conftest.$ac_ext
  1932. cat >>conftest.$ac_ext <<_ACEOF
  1933. /* end confdefs.h.  */
  1934. $ac_includes_default
  1935. typedef __int64 ac__type_new_;
  1936. int
  1937. main ()
  1938. {
  1939. if ((ac__type_new_ *) 0)
  1940.   return 0;
  1941. if (sizeof (ac__type_new_))
  1942.   return 0;
  1943.   ;
  1944.   return 0;
  1945. }
  1946. _ACEOF
  1947. rm -f conftest.$ac_objext
  1948. if { (ac_try="$ac_compile"
  1949. case "(($ac_try" in
  1950.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1951.   *) ac_try_echo=$ac_try;;
  1952. esac
  1953. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  1954.   (eval "$ac_compile") 2>conftest.er1
  1955.   ac_status=$?
  1956.   grep -v '^ *+' conftest.er1 >conftest.err
  1957.   rm -f conftest.er1
  1958.   cat conftest.err >&5
  1959.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  1960.   (exit $ac_status); } && {
  1961.  test -z "$ac_c_werror_flag" ||
  1962.  test ! -s conftest.err
  1963.        } && test -s conftest.$ac_objext; then
  1964.   ac_cv_type___int64=yes
  1965. else
  1966.   echo "$as_me: failed program was:" >&5
  1967. sed 's/^/| /' conftest.$ac_ext >&5
  1968. ac_cv_type___int64=no
  1969. fi
  1970. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1971. fi
  1972. { echo "$as_me:$LINENO: result: $ac_cv_type___int64" >&5
  1973. echo "${ECHO_T}$ac_cv_type___int64" >&6; }
  1974. # The cast to long int works around a bug in the HP C Compiler
  1975. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  1976. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  1977. # This bug is HP SR number 8606223364.
  1978. { echo "$as_me:$LINENO: checking size of __int64" >&5
  1979. echo $ECHO_N "checking size of __int64... $ECHO_C" >&6; }
  1980. if test "${ac_cv_sizeof___int64+set}" = set; then
  1981.   echo $ECHO_N "(cached) $ECHO_C" >&6
  1982. else
  1983.   if test "$cross_compiling" = yes; then
  1984.   # Depending upon the size, compute the lo and hi bounds.
  1985. cat >conftest.$ac_ext <<_ACEOF
  1986. /* confdefs.h.  */
  1987. _ACEOF
  1988. cat confdefs.h >>conftest.$ac_ext
  1989. cat >>conftest.$ac_ext <<_ACEOF
  1990. /* end confdefs.h.  */
  1991. $ac_includes_default
  1992.    typedef __int64 ac__type_sizeof_;
  1993. int
  1994. main ()
  1995. {
  1996. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  1997. test_array [0] = 0
  1998.   ;
  1999.   return 0;
  2000. }
  2001. _ACEOF
  2002. rm -f conftest.$ac_objext
  2003. if { (ac_try="$ac_compile"
  2004. case "(($ac_try" in
  2005.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2006.   *) ac_try_echo=$ac_try;;
  2007. esac
  2008. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2009.   (eval "$ac_compile") 2>conftest.er1
  2010.   ac_status=$?
  2011.   grep -v '^ *+' conftest.er1 >conftest.err
  2012.   rm -f conftest.er1
  2013.   cat conftest.err >&5
  2014.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2015.   (exit $ac_status); } && {
  2016.  test -z "$ac_c_werror_flag" ||
  2017.  test ! -s conftest.err
  2018.        } && test -s conftest.$ac_objext; then
  2019.   ac_lo=0 ac_mid=0
  2020.   while :; do
  2021.     cat >conftest.$ac_ext <<_ACEOF
  2022. /* confdefs.h.  */
  2023. _ACEOF
  2024. cat confdefs.h >>conftest.$ac_ext
  2025. cat >>conftest.$ac_ext <<_ACEOF
  2026. /* end confdefs.h.  */
  2027. $ac_includes_default
  2028.    typedef __int64 ac__type_sizeof_;
  2029. int
  2030. main ()
  2031. {
  2032. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  2033. test_array [0] = 0
  2034.   ;
  2035.   return 0;
  2036. }
  2037. _ACEOF
  2038. rm -f conftest.$ac_objext
  2039. if { (ac_try="$ac_compile"
  2040. case "(($ac_try" in
  2041.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2042.   *) ac_try_echo=$ac_try;;
  2043. esac
  2044. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2045.   (eval "$ac_compile") 2>conftest.er1
  2046.   ac_status=$?
  2047.   grep -v '^ *+' conftest.er1 >conftest.err
  2048.   rm -f conftest.er1
  2049.   cat conftest.err >&5
  2050.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2051.   (exit $ac_status); } && {
  2052.  test -z "$ac_c_werror_flag" ||
  2053.  test ! -s conftest.err
  2054.        } && test -s conftest.$ac_objext; then
  2055.   ac_hi=$ac_mid; break
  2056. else
  2057.   echo "$as_me: failed program was:" >&5
  2058. sed 's/^/| /' conftest.$ac_ext >&5
  2059. ac_lo=`expr $ac_mid + 1`
  2060. if test $ac_lo -le $ac_mid; then
  2061.   ac_lo= ac_hi=
  2062.   break
  2063. fi
  2064. ac_mid=`expr 2 '*' $ac_mid + 1`
  2065. fi
  2066. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2067.   done
  2068. else
  2069.   echo "$as_me: failed program was:" >&5
  2070. sed 's/^/| /' conftest.$ac_ext >&5
  2071. cat >conftest.$ac_ext <<_ACEOF
  2072. /* confdefs.h.  */
  2073. _ACEOF
  2074. cat confdefs.h >>conftest.$ac_ext
  2075. cat >>conftest.$ac_ext <<_ACEOF
  2076. /* end confdefs.h.  */
  2077. $ac_includes_default
  2078.    typedef __int64 ac__type_sizeof_;
  2079. int
  2080. main ()
  2081. {
  2082. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  2083. test_array [0] = 0
  2084.   ;
  2085.   return 0;
  2086. }
  2087. _ACEOF
  2088. rm -f conftest.$ac_objext
  2089. if { (ac_try="$ac_compile"
  2090. case "(($ac_try" in
  2091.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2092.   *) ac_try_echo=$ac_try;;
  2093. esac
  2094. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2095.   (eval "$ac_compile") 2>conftest.er1
  2096.   ac_status=$?
  2097.   grep -v '^ *+' conftest.er1 >conftest.err
  2098.   rm -f conftest.er1
  2099.   cat conftest.err >&5
  2100.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2101.   (exit $ac_status); } && {
  2102.  test -z "$ac_c_werror_flag" ||
  2103.  test ! -s conftest.err
  2104.        } && test -s conftest.$ac_objext; then
  2105.   ac_hi=-1 ac_mid=-1
  2106.   while :; do
  2107.     cat >conftest.$ac_ext <<_ACEOF
  2108. /* confdefs.h.  */
  2109. _ACEOF
  2110. cat confdefs.h >>conftest.$ac_ext
  2111. cat >>conftest.$ac_ext <<_ACEOF
  2112. /* end confdefs.h.  */
  2113. $ac_includes_default
  2114.    typedef __int64 ac__type_sizeof_;
  2115. int
  2116. main ()
  2117. {
  2118. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  2119. test_array [0] = 0
  2120.   ;
  2121.   return 0;
  2122. }
  2123. _ACEOF
  2124. rm -f conftest.$ac_objext
  2125. if { (ac_try="$ac_compile"
  2126. case "(($ac_try" in
  2127.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2128.   *) ac_try_echo=$ac_try;;
  2129. esac
  2130. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2131.   (eval "$ac_compile") 2>conftest.er1
  2132.   ac_status=$?
  2133.   grep -v '^ *+' conftest.er1 >conftest.err
  2134.   rm -f conftest.er1
  2135.   cat conftest.err >&5
  2136.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2137.   (exit $ac_status); } && {
  2138.  test -z "$ac_c_werror_flag" ||
  2139.  test ! -s conftest.err
  2140.        } && test -s conftest.$ac_objext; then
  2141.   ac_lo=$ac_mid; break
  2142. else
  2143.   echo "$as_me: failed program was:" >&5
  2144. sed 's/^/| /' conftest.$ac_ext >&5
  2145. ac_hi=`expr '(' $ac_mid ')' - 1`
  2146. if test $ac_mid -le $ac_hi; then
  2147.   ac_lo= ac_hi=
  2148.   break
  2149. fi
  2150. ac_mid=`expr 2 '*' $ac_mid`
  2151. fi
  2152. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2153.   done
  2154. else
  2155.   echo "$as_me: failed program was:" >&5
  2156. sed 's/^/| /' conftest.$ac_ext >&5
  2157. ac_lo= ac_hi=
  2158. fi
  2159. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2160. fi
  2161. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2162. # Binary search between lo and hi bounds.
  2163. while test "x$ac_lo" != "x$ac_hi"; do
  2164.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  2165.   cat >conftest.$ac_ext <<_ACEOF
  2166. /* confdefs.h.  */
  2167. _ACEOF
  2168. cat confdefs.h >>conftest.$ac_ext
  2169. cat >>conftest.$ac_ext <<_ACEOF
  2170. /* end confdefs.h.  */
  2171. $ac_includes_default
  2172.    typedef __int64 ac__type_sizeof_;
  2173. int
  2174. main ()
  2175. {
  2176. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  2177. test_array [0] = 0
  2178.   ;
  2179.   return 0;
  2180. }
  2181. _ACEOF
  2182. rm -f conftest.$ac_objext
  2183. if { (ac_try="$ac_compile"
  2184. case "(($ac_try" in
  2185.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2186.   *) ac_try_echo=$ac_try;;
  2187. esac
  2188. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2189.   (eval "$ac_compile") 2>conftest.er1
  2190.   ac_status=$?
  2191.   grep -v '^ *+' conftest.er1 >conftest.err
  2192.   rm -f conftest.er1
  2193.   cat conftest.err >&5
  2194.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2195.   (exit $ac_status); } && {
  2196.  test -z "$ac_c_werror_flag" ||
  2197.  test ! -s conftest.err
  2198.        } && test -s conftest.$ac_objext; then
  2199.   ac_hi=$ac_mid
  2200. else
  2201.   echo "$as_me: failed program was:" >&5
  2202. sed 's/^/| /' conftest.$ac_ext >&5
  2203. ac_lo=`expr '(' $ac_mid ')' + 1`
  2204. fi
  2205. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2206. done
  2207. case $ac_lo in
  2208. ?*) ac_cv_sizeof___int64=$ac_lo;;
  2209. '') if test "$ac_cv_type___int64" = yes; then
  2210.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (__int64)
  2211. See `config.log' for more details." >&5
  2212. echo "$as_me: error: cannot compute sizeof (__int64)
  2213. See `config.log' for more details." >&2;}
  2214.    { (exit 77); exit 77; }; }
  2215.    else
  2216.      ac_cv_sizeof___int64=0
  2217.    fi ;;
  2218. esac
  2219. else
  2220.   cat >conftest.$ac_ext <<_ACEOF
  2221. /* confdefs.h.  */
  2222. _ACEOF
  2223. cat confdefs.h >>conftest.$ac_ext
  2224. cat >>conftest.$ac_ext <<_ACEOF
  2225. /* end confdefs.h.  */
  2226. $ac_includes_default
  2227.    typedef __int64 ac__type_sizeof_;
  2228. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  2229. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  2230. #include <stdio.h>
  2231. #include <stdlib.h>
  2232. int
  2233. main ()
  2234. {
  2235.   FILE *f = fopen ("conftest.val", "w");
  2236.   if (! f)
  2237.     return 1;
  2238.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  2239.     {
  2240.       long int i = longval ();
  2241.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  2242. return 1;
  2243.       fprintf (f, "%ldn", i);
  2244.     }
  2245.   else
  2246.     {
  2247.       unsigned long int i = ulongval ();
  2248.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  2249. return 1;
  2250.       fprintf (f, "%lun", i);
  2251.     }
  2252.   return ferror (f) || fclose (f) != 0;
  2253.   ;
  2254.   return 0;
  2255. }
  2256. _ACEOF
  2257. rm -f conftest$ac_exeext
  2258. if { (ac_try="$ac_link"
  2259. case "(($ac_try" in
  2260.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2261.   *) ac_try_echo=$ac_try;;
  2262. esac
  2263. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2264.   (eval "$ac_link") 2>&5
  2265.   ac_status=$?
  2266.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2267.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  2268.   { (case "(($ac_try" in
  2269.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2270.   *) ac_try_echo=$ac_try;;
  2271. esac
  2272. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2273.   (eval "$ac_try") 2>&5
  2274.   ac_status=$?
  2275.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2276.   (exit $ac_status); }; }; then
  2277.   ac_cv_sizeof___int64=`cat conftest.val`
  2278. else
  2279.   echo "$as_me: program exited with status $ac_status" >&5
  2280. echo "$as_me: failed program was:" >&5
  2281. sed 's/^/| /' conftest.$ac_ext >&5
  2282. ( exit $ac_status )
  2283. if test "$ac_cv_type___int64" = yes; then
  2284.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (__int64)
  2285. See `config.log' for more details." >&5
  2286. echo "$as_me: error: cannot compute sizeof (__int64)
  2287. See `config.log' for more details." >&2;}
  2288.    { (exit 77); exit 77; }; }
  2289.    else
  2290.      ac_cv_sizeof___int64=0
  2291.    fi
  2292. fi
  2293. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  2294. fi
  2295. rm -f conftest.val
  2296. fi
  2297. { echo "$as_me:$LINENO: result: $ac_cv_sizeof___int64" >&5
  2298. echo "${ECHO_T}$ac_cv_sizeof___int64" >&6; }
  2299. cat >>confdefs.h <<_ACEOF
  2300. #define SIZEOF___INT64 $ac_cv_sizeof___int64
  2301. _ACEOF
  2302. { echo "$as_me:$LINENO: checking for void *" >&5
  2303. echo $ECHO_N "checking for void *... $ECHO_C" >&6; }
  2304. if test "${ac_cv_type_void_p+set}" = set; then
  2305.   echo $ECHO_N "(cached) $ECHO_C" >&6
  2306. else
  2307.   cat >conftest.$ac_ext <<_ACEOF
  2308. /* confdefs.h.  */
  2309. _ACEOF
  2310. cat confdefs.h >>conftest.$ac_ext
  2311. cat >>conftest.$ac_ext <<_ACEOF
  2312. /* end confdefs.h.  */
  2313. $ac_includes_default
  2314. typedef void * ac__type_new_;
  2315. int
  2316. main ()
  2317. {
  2318. if ((ac__type_new_ *) 0)
  2319.   return 0;
  2320. if (sizeof (ac__type_new_))
  2321.   return 0;
  2322.   ;
  2323.   return 0;
  2324. }
  2325. _ACEOF
  2326. rm -f conftest.$ac_objext
  2327. if { (ac_try="$ac_compile"
  2328. case "(($ac_try" in
  2329.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2330.   *) ac_try_echo=$ac_try;;
  2331. esac
  2332. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2333.   (eval "$ac_compile") 2>conftest.er1
  2334.   ac_status=$?
  2335.   grep -v '^ *+' conftest.er1 >conftest.err
  2336.   rm -f conftest.er1
  2337.   cat conftest.err >&5
  2338.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2339.   (exit $ac_status); } && {
  2340.  test -z "$ac_c_werror_flag" ||
  2341.  test ! -s conftest.err
  2342.        } && test -s conftest.$ac_objext; then
  2343.   ac_cv_type_void_p=yes
  2344. else
  2345.   echo "$as_me: failed program was:" >&5
  2346. sed 's/^/| /' conftest.$ac_ext >&5
  2347. ac_cv_type_void_p=no
  2348. fi
  2349. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2350. fi
  2351. { echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
  2352. echo "${ECHO_T}$ac_cv_type_void_p" >&6; }
  2353. # The cast to long int works around a bug in the HP C Compiler
  2354. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  2355. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  2356. # This bug is HP SR number 8606223364.
  2357. { echo "$as_me:$LINENO: checking size of void *" >&5
  2358. echo $ECHO_N "checking size of void *... $ECHO_C" >&6; }
  2359. if test "${ac_cv_sizeof_void_p+set}" = set; then
  2360.   echo $ECHO_N "(cached) $ECHO_C" >&6
  2361. else
  2362.   if test "$cross_compiling" = yes; then
  2363.   # Depending upon the size, compute the lo and hi bounds.
  2364. cat >conftest.$ac_ext <<_ACEOF
  2365. /* confdefs.h.  */
  2366. _ACEOF
  2367. cat confdefs.h >>conftest.$ac_ext
  2368. cat >>conftest.$ac_ext <<_ACEOF
  2369. /* end confdefs.h.  */
  2370. $ac_includes_default
  2371.    typedef void * ac__type_sizeof_;
  2372. int
  2373. main ()
  2374. {
  2375. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  2376. test_array [0] = 0
  2377.   ;
  2378.   return 0;
  2379. }
  2380. _ACEOF
  2381. rm -f conftest.$ac_objext
  2382. if { (ac_try="$ac_compile"
  2383. case "(($ac_try" in
  2384.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2385.   *) ac_try_echo=$ac_try;;
  2386. esac
  2387. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2388.   (eval "$ac_compile") 2>conftest.er1
  2389.   ac_status=$?
  2390.   grep -v '^ *+' conftest.er1 >conftest.err
  2391.   rm -f conftest.er1
  2392.   cat conftest.err >&5
  2393.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2394.   (exit $ac_status); } && {
  2395.  test -z "$ac_c_werror_flag" ||
  2396.  test ! -s conftest.err
  2397.        } && test -s conftest.$ac_objext; then
  2398.   ac_lo=0 ac_mid=0
  2399.   while :; do
  2400.     cat >conftest.$ac_ext <<_ACEOF
  2401. /* confdefs.h.  */
  2402. _ACEOF
  2403. cat confdefs.h >>conftest.$ac_ext
  2404. cat >>conftest.$ac_ext <<_ACEOF
  2405. /* end confdefs.h.  */
  2406. $ac_includes_default
  2407.    typedef void * ac__type_sizeof_;
  2408. int
  2409. main ()
  2410. {
  2411. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  2412. test_array [0] = 0
  2413.   ;
  2414.   return 0;
  2415. }
  2416. _ACEOF
  2417. rm -f conftest.$ac_objext
  2418. if { (ac_try="$ac_compile"
  2419. case "(($ac_try" in
  2420.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2421.   *) ac_try_echo=$ac_try;;
  2422. esac
  2423. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2424.   (eval "$ac_compile") 2>conftest.er1
  2425.   ac_status=$?
  2426.   grep -v '^ *+' conftest.er1 >conftest.err
  2427.   rm -f conftest.er1
  2428.   cat conftest.err >&5
  2429.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2430.   (exit $ac_status); } && {
  2431.  test -z "$ac_c_werror_flag" ||
  2432.  test ! -s conftest.err
  2433.        } && test -s conftest.$ac_objext; then
  2434.   ac_hi=$ac_mid; break
  2435. else
  2436.   echo "$as_me: failed program was:" >&5
  2437. sed 's/^/| /' conftest.$ac_ext >&5
  2438. ac_lo=`expr $ac_mid + 1`
  2439. if test $ac_lo -le $ac_mid; then
  2440.   ac_lo= ac_hi=
  2441.   break
  2442. fi
  2443. ac_mid=`expr 2 '*' $ac_mid + 1`
  2444. fi
  2445. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2446.   done
  2447. else
  2448.   echo "$as_me: failed program was:" >&5
  2449. sed 's/^/| /' conftest.$ac_ext >&5
  2450. cat >conftest.$ac_ext <<_ACEOF
  2451. /* confdefs.h.  */
  2452. _ACEOF
  2453. cat confdefs.h >>conftest.$ac_ext
  2454. cat >>conftest.$ac_ext <<_ACEOF
  2455. /* end confdefs.h.  */
  2456. $ac_includes_default
  2457.    typedef void * ac__type_sizeof_;
  2458. int
  2459. main ()
  2460. {
  2461. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  2462. test_array [0] = 0
  2463.   ;
  2464.   return 0;
  2465. }
  2466. _ACEOF
  2467. rm -f conftest.$ac_objext
  2468. if { (ac_try="$ac_compile"
  2469. case "(($ac_try" in
  2470.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2471.   *) ac_try_echo=$ac_try;;
  2472. esac
  2473. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2474.   (eval "$ac_compile") 2>conftest.er1
  2475.   ac_status=$?
  2476.   grep -v '^ *+' conftest.er1 >conftest.err
  2477.   rm -f conftest.er1
  2478.   cat conftest.err >&5
  2479.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2480.   (exit $ac_status); } && {
  2481.  test -z "$ac_c_werror_flag" ||
  2482.  test ! -s conftest.err
  2483.        } && test -s conftest.$ac_objext; then
  2484.   ac_hi=-1 ac_mid=-1
  2485.   while :; do
  2486.     cat >conftest.$ac_ext <<_ACEOF
  2487. /* confdefs.h.  */
  2488. _ACEOF
  2489. cat confdefs.h >>conftest.$ac_ext
  2490. cat >>conftest.$ac_ext <<_ACEOF
  2491. /* end confdefs.h.  */
  2492. $ac_includes_default
  2493.    typedef void * ac__type_sizeof_;
  2494. int
  2495. main ()
  2496. {
  2497. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  2498. test_array [0] = 0
  2499.   ;
  2500.   return 0;
  2501. }
  2502. _ACEOF
  2503. rm -f conftest.$ac_objext
  2504. if { (ac_try="$ac_compile"
  2505. case "(($ac_try" in
  2506.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2507.   *) ac_try_echo=$ac_try;;
  2508. esac
  2509. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2510.   (eval "$ac_compile") 2>conftest.er1
  2511.   ac_status=$?
  2512.   grep -v '^ *+' conftest.er1 >conftest.err
  2513.   rm -f conftest.er1
  2514.   cat conftest.err >&5
  2515.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2516.   (exit $ac_status); } && {
  2517.  test -z "$ac_c_werror_flag" ||
  2518.  test ! -s conftest.err
  2519.        } && test -s conftest.$ac_objext; then
  2520.   ac_lo=$ac_mid; break
  2521. else
  2522.   echo "$as_me: failed program was:" >&5
  2523. sed 's/^/| /' conftest.$ac_ext >&5
  2524. ac_hi=`expr '(' $ac_mid ')' - 1`
  2525. if test $ac_mid -le $ac_hi; then
  2526.   ac_lo= ac_hi=
  2527.   break
  2528. fi
  2529. ac_mid=`expr 2 '*' $ac_mid`
  2530. fi
  2531. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2532.   done
  2533. else
  2534.   echo "$as_me: failed program was:" >&5
  2535. sed 's/^/| /' conftest.$ac_ext >&5
  2536. ac_lo= ac_hi=
  2537. fi
  2538. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2539. fi
  2540. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2541. # Binary search between lo and hi bounds.
  2542. while test "x$ac_lo" != "x$ac_hi"; do
  2543.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  2544.   cat >conftest.$ac_ext <<_ACEOF
  2545. /* confdefs.h.  */
  2546. _ACEOF
  2547. cat confdefs.h >>conftest.$ac_ext
  2548. cat >>conftest.$ac_ext <<_ACEOF
  2549. /* end confdefs.h.  */
  2550. $ac_includes_default
  2551.    typedef void * ac__type_sizeof_;
  2552. int
  2553. main ()
  2554. {
  2555. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  2556. test_array [0] = 0
  2557.   ;
  2558.   return 0;
  2559. }
  2560. _ACEOF
  2561. rm -f conftest.$ac_objext
  2562. if { (ac_try="$ac_compile"
  2563. case "(($ac_try" in
  2564.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2565.   *) ac_try_echo=$ac_try;;
  2566. esac
  2567. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2568.   (eval "$ac_compile") 2>conftest.er1
  2569.   ac_status=$?
  2570.   grep -v '^ *+' conftest.er1 >conftest.err
  2571.   rm -f conftest.er1
  2572.   cat conftest.err >&5
  2573.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2574.   (exit $ac_status); } && {
  2575.  test -z "$ac_c_werror_flag" ||
  2576.  test ! -s conftest.err
  2577.        } && test -s conftest.$ac_objext; then
  2578.   ac_hi=$ac_mid
  2579. else
  2580.   echo "$as_me: failed program was:" >&5
  2581. sed 's/^/| /' conftest.$ac_ext >&5
  2582. ac_lo=`expr '(' $ac_mid ')' + 1`
  2583. fi
  2584. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2585. done
  2586. case $ac_lo in
  2587. ?*) ac_cv_sizeof_void_p=$ac_lo;;
  2588. '') if test "$ac_cv_type_void_p" = yes; then
  2589.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *)
  2590. See `config.log' for more details." >&5
  2591. echo "$as_me: error: cannot compute sizeof (void *)
  2592. See `config.log' for more details." >&2;}
  2593.    { (exit 77); exit 77; }; }
  2594.    else
  2595.      ac_cv_sizeof_void_p=0
  2596.    fi ;;
  2597. esac
  2598. else
  2599.   cat >conftest.$ac_ext <<_ACEOF
  2600. /* confdefs.h.  */
  2601. _ACEOF
  2602. cat confdefs.h >>conftest.$ac_ext
  2603. cat >>conftest.$ac_ext <<_ACEOF
  2604. /* end confdefs.h.  */
  2605. $ac_includes_default
  2606.    typedef void * ac__type_sizeof_;
  2607. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  2608. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  2609. #include <stdio.h>
  2610. #include <stdlib.h>
  2611. int
  2612. main ()
  2613. {
  2614.   FILE *f = fopen ("conftest.val", "w");
  2615.   if (! f)
  2616.     return 1;
  2617.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  2618.     {
  2619.       long int i = longval ();
  2620.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  2621. return 1;
  2622.       fprintf (f, "%ldn", i);
  2623.     }
  2624.   else
  2625.     {
  2626.       unsigned long int i = ulongval ();
  2627.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  2628. return 1;
  2629.       fprintf (f, "%lun", i);
  2630.     }
  2631.   return ferror (f) || fclose (f) != 0;
  2632.   ;
  2633.   return 0;
  2634. }
  2635. _ACEOF
  2636. rm -f conftest$ac_exeext
  2637. if { (ac_try="$ac_link"
  2638. case "(($ac_try" in
  2639.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2640.   *) ac_try_echo=$ac_try;;
  2641. esac
  2642. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2643.   (eval "$ac_link") 2>&5
  2644.   ac_status=$?
  2645.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2646.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  2647.   { (case "(($ac_try" in
  2648.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2649.   *) ac_try_echo=$ac_try;;
  2650. esac
  2651. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2652.   (eval "$ac_try") 2>&5
  2653.   ac_status=$?
  2654.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2655.   (exit $ac_status); }; }; then
  2656.   ac_cv_sizeof_void_p=`cat conftest.val`
  2657. else
  2658.   echo "$as_me: program exited with status $ac_status" >&5
  2659. echo "$as_me: failed program was:" >&5
  2660. sed 's/^/| /' conftest.$ac_ext >&5
  2661. ( exit $ac_status )
  2662. if test "$ac_cv_type_void_p" = yes; then
  2663.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *)
  2664. See `config.log' for more details." >&5
  2665. echo "$as_me: error: cannot compute sizeof (void *)
  2666. See `config.log' for more details." >&2;}
  2667.    { (exit 77); exit 77; }; }
  2668.    else
  2669.      ac_cv_sizeof_void_p=0
  2670.    fi
  2671. fi
  2672. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  2673. fi
  2674. rm -f conftest.val
  2675. fi
  2676. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
  2677. echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6; }
  2678. cat >>confdefs.h <<_ACEOF
  2679. #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
  2680. _ACEOF
  2681. { echo "$as_me:$LINENO: checking for time_t" >&5
  2682. echo $ECHO_N "checking for time_t... $ECHO_C" >&6; }
  2683. if test "${ac_cv_type_time_t+set}" = set; then
  2684.   echo $ECHO_N "(cached) $ECHO_C" >&6
  2685. else
  2686.   cat >conftest.$ac_ext <<_ACEOF
  2687. /* confdefs.h.  */
  2688. _ACEOF
  2689. cat confdefs.h >>conftest.$ac_ext
  2690. cat >>conftest.$ac_ext <<_ACEOF
  2691. /* end confdefs.h.  */
  2692. $ac_includes_default
  2693. typedef time_t ac__type_new_;
  2694. int
  2695. main ()
  2696. {
  2697. if ((ac__type_new_ *) 0)
  2698.   return 0;
  2699. if (sizeof (ac__type_new_))
  2700.   return 0;
  2701.   ;
  2702.   return 0;
  2703. }
  2704. _ACEOF
  2705. rm -f conftest.$ac_objext
  2706. if { (ac_try="$ac_compile"
  2707. case "(($ac_try" in
  2708.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2709.   *) ac_try_echo=$ac_try;;
  2710. esac
  2711. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2712.   (eval "$ac_compile") 2>conftest.er1
  2713.   ac_status=$?
  2714.   grep -v '^ *+' conftest.er1 >conftest.err
  2715.   rm -f conftest.er1
  2716.   cat conftest.err >&5
  2717.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2718.   (exit $ac_status); } && {
  2719.  test -z "$ac_c_werror_flag" ||
  2720.  test ! -s conftest.err
  2721.        } && test -s conftest.$ac_objext; then
  2722.   ac_cv_type_time_t=yes
  2723. else
  2724.   echo "$as_me: failed program was:" >&5
  2725. sed 's/^/| /' conftest.$ac_ext >&5
  2726. ac_cv_type_time_t=no
  2727. fi
  2728. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2729. fi
  2730. { echo "$as_me:$LINENO: result: $ac_cv_type_time_t" >&5
  2731. echo "${ECHO_T}$ac_cv_type_time_t" >&6; }
  2732. # The cast to long int works around a bug in the HP C Compiler
  2733. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  2734. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  2735. # This bug is HP SR number 8606223364.
  2736. { echo "$as_me:$LINENO: checking size of time_t" >&5
  2737. echo $ECHO_N "checking size of time_t... $ECHO_C" >&6; }
  2738. if test "${ac_cv_sizeof_time_t+set}" = set; then
  2739.   echo $ECHO_N "(cached) $ECHO_C" >&6
  2740. else
  2741.   if test "$cross_compiling" = yes; then
  2742.   # Depending upon the size, compute the lo and hi bounds.
  2743. cat >conftest.$ac_ext <<_ACEOF
  2744. /* confdefs.h.  */
  2745. _ACEOF
  2746. cat confdefs.h >>conftest.$ac_ext
  2747. cat >>conftest.$ac_ext <<_ACEOF
  2748. /* end confdefs.h.  */
  2749. $ac_includes_default
  2750.    typedef time_t ac__type_sizeof_;
  2751. int
  2752. main ()
  2753. {
  2754. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  2755. test_array [0] = 0
  2756.   ;
  2757.   return 0;
  2758. }
  2759. _ACEOF
  2760. rm -f conftest.$ac_objext
  2761. if { (ac_try="$ac_compile"
  2762. case "(($ac_try" in
  2763.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2764.   *) ac_try_echo=$ac_try;;
  2765. esac
  2766. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2767.   (eval "$ac_compile") 2>conftest.er1
  2768.   ac_status=$?
  2769.   grep -v '^ *+' conftest.er1 >conftest.err
  2770.   rm -f conftest.er1
  2771.   cat conftest.err >&5
  2772.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2773.   (exit $ac_status); } && {
  2774.  test -z "$ac_c_werror_flag" ||
  2775.  test ! -s conftest.err
  2776.        } && test -s conftest.$ac_objext; then
  2777.   ac_lo=0 ac_mid=0
  2778.   while :; do
  2779.     cat >conftest.$ac_ext <<_ACEOF
  2780. /* confdefs.h.  */
  2781. _ACEOF
  2782. cat confdefs.h >>conftest.$ac_ext
  2783. cat >>conftest.$ac_ext <<_ACEOF
  2784. /* end confdefs.h.  */
  2785. $ac_includes_default
  2786.    typedef time_t ac__type_sizeof_;
  2787. int
  2788. main ()
  2789. {
  2790. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  2791. test_array [0] = 0
  2792.   ;
  2793.   return 0;
  2794. }
  2795. _ACEOF
  2796. rm -f conftest.$ac_objext
  2797. if { (ac_try="$ac_compile"
  2798. case "(($ac_try" in
  2799.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2800.   *) ac_try_echo=$ac_try;;
  2801. esac
  2802. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2803.   (eval "$ac_compile") 2>conftest.er1
  2804.   ac_status=$?
  2805.   grep -v '^ *+' conftest.er1 >conftest.err
  2806.   rm -f conftest.er1
  2807.   cat conftest.err >&5
  2808.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2809.   (exit $ac_status); } && {
  2810.  test -z "$ac_c_werror_flag" ||
  2811.  test ! -s conftest.err
  2812.        } && test -s conftest.$ac_objext; then
  2813.   ac_hi=$ac_mid; break
  2814. else
  2815.   echo "$as_me: failed program was:" >&5
  2816. sed 's/^/| /' conftest.$ac_ext >&5
  2817. ac_lo=`expr $ac_mid + 1`
  2818. if test $ac_lo -le $ac_mid; then
  2819.   ac_lo= ac_hi=
  2820.   break
  2821. fi
  2822. ac_mid=`expr 2 '*' $ac_mid + 1`
  2823. fi
  2824. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2825.   done
  2826. else
  2827.   echo "$as_me: failed program was:" >&5
  2828. sed 's/^/| /' conftest.$ac_ext >&5
  2829. cat >conftest.$ac_ext <<_ACEOF
  2830. /* confdefs.h.  */
  2831. _ACEOF
  2832. cat confdefs.h >>conftest.$ac_ext
  2833. cat >>conftest.$ac_ext <<_ACEOF
  2834. /* end confdefs.h.  */
  2835. $ac_includes_default
  2836.    typedef time_t ac__type_sizeof_;
  2837. int
  2838. main ()
  2839. {
  2840. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  2841. test_array [0] = 0
  2842.   ;
  2843.   return 0;
  2844. }
  2845. _ACEOF
  2846. rm -f conftest.$ac_objext
  2847. if { (ac_try="$ac_compile"
  2848. case "(($ac_try" in
  2849.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2850.   *) ac_try_echo=$ac_try;;
  2851. esac
  2852. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2853.   (eval "$ac_compile") 2>conftest.er1
  2854.   ac_status=$?
  2855.   grep -v '^ *+' conftest.er1 >conftest.err
  2856.   rm -f conftest.er1
  2857.   cat conftest.err >&5
  2858.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2859.   (exit $ac_status); } && {
  2860.  test -z "$ac_c_werror_flag" ||
  2861.  test ! -s conftest.err
  2862.        } && test -s conftest.$ac_objext; then
  2863.   ac_hi=-1 ac_mid=-1
  2864.   while :; do
  2865.     cat >conftest.$ac_ext <<_ACEOF
  2866. /* confdefs.h.  */
  2867. _ACEOF
  2868. cat confdefs.h >>conftest.$ac_ext
  2869. cat >>conftest.$ac_ext <<_ACEOF
  2870. /* end confdefs.h.  */
  2871. $ac_includes_default
  2872.    typedef time_t ac__type_sizeof_;
  2873. int
  2874. main ()
  2875. {
  2876. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  2877. test_array [0] = 0
  2878.   ;
  2879.   return 0;
  2880. }
  2881. _ACEOF
  2882. rm -f conftest.$ac_objext
  2883. if { (ac_try="$ac_compile"
  2884. case "(($ac_try" in
  2885.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2886.   *) ac_try_echo=$ac_try;;
  2887. esac
  2888. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2889.   (eval "$ac_compile") 2>conftest.er1
  2890.   ac_status=$?
  2891.   grep -v '^ *+' conftest.er1 >conftest.err
  2892.   rm -f conftest.er1
  2893.   cat conftest.err >&5
  2894.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2895.   (exit $ac_status); } && {
  2896.  test -z "$ac_c_werror_flag" ||
  2897.  test ! -s conftest.err
  2898.        } && test -s conftest.$ac_objext; then
  2899.   ac_lo=$ac_mid; break
  2900. else
  2901.   echo "$as_me: failed program was:" >&5
  2902. sed 's/^/| /' conftest.$ac_ext >&5
  2903. ac_hi=`expr '(' $ac_mid ')' - 1`
  2904. if test $ac_mid -le $ac_hi; then
  2905.   ac_lo= ac_hi=
  2906.   break
  2907. fi
  2908. ac_mid=`expr 2 '*' $ac_mid`
  2909. fi
  2910. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2911.   done
  2912. else
  2913.   echo "$as_me: failed program was:" >&5
  2914. sed 's/^/| /' conftest.$ac_ext >&5
  2915. ac_lo= ac_hi=
  2916. fi
  2917. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2918. fi
  2919. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2920. # Binary search between lo and hi bounds.
  2921. while test "x$ac_lo" != "x$ac_hi"; do
  2922.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  2923.   cat >conftest.$ac_ext <<_ACEOF
  2924. /* confdefs.h.  */
  2925. _ACEOF
  2926. cat confdefs.h >>conftest.$ac_ext
  2927. cat >>conftest.$ac_ext <<_ACEOF
  2928. /* end confdefs.h.  */
  2929. $ac_includes_default
  2930.    typedef time_t ac__type_sizeof_;
  2931. int
  2932. main ()
  2933. {
  2934. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  2935. test_array [0] = 0
  2936.   ;
  2937.   return 0;
  2938. }
  2939. _ACEOF
  2940. rm -f conftest.$ac_objext
  2941. if { (ac_try="$ac_compile"
  2942. case "(($ac_try" in
  2943.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  2944.   *) ac_try_echo=$ac_try;;
  2945. esac
  2946. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  2947.   (eval "$ac_compile") 2>conftest.er1
  2948.   ac_status=$?
  2949.   grep -v '^ *+' conftest.er1 >conftest.err
  2950.   rm -f conftest.er1
  2951.   cat conftest.err >&5
  2952.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  2953.   (exit $ac_status); } && {
  2954.  test -z "$ac_c_werror_flag" ||
  2955.  test ! -s conftest.err
  2956.        } && test -s conftest.$ac_objext; then
  2957.   ac_hi=$ac_mid
  2958. else
  2959.   echo "$as_me: failed program was:" >&5
  2960. sed 's/^/| /' conftest.$ac_ext >&5
  2961. ac_lo=`expr '(' $ac_mid ')' + 1`
  2962. fi
  2963. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2964. done
  2965. case $ac_lo in
  2966. ?*) ac_cv_sizeof_time_t=$ac_lo;;
  2967. '') if test "$ac_cv_type_time_t" = yes; then
  2968.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (time_t)
  2969. See `config.log' for more details." >&5
  2970. echo "$as_me: error: cannot compute sizeof (time_t)
  2971. See `config.log' for more details." >&2;}
  2972.    { (exit 77); exit 77; }; }
  2973.    else
  2974.      ac_cv_sizeof_time_t=0
  2975.    fi ;;
  2976. esac
  2977. else
  2978.   cat >conftest.$ac_ext <<_ACEOF
  2979. /* confdefs.h.  */
  2980. _ACEOF
  2981. cat confdefs.h >>conftest.$ac_ext
  2982. cat >>conftest.$ac_ext <<_ACEOF
  2983. /* end confdefs.h.  */
  2984. $ac_includes_default
  2985.    typedef time_t ac__type_sizeof_;
  2986. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  2987. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  2988. #include <stdio.h>
  2989. #include <stdlib.h>
  2990. int
  2991. main ()
  2992. {
  2993.   FILE *f = fopen ("conftest.val", "w");
  2994.   if (! f)
  2995.     return 1;
  2996.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  2997.     {
  2998.       long int i = longval ();
  2999.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  3000. return 1;
  3001.       fprintf (f, "%ldn", i);
  3002.     }
  3003.   else
  3004.     {
  3005.       unsigned long int i = ulongval ();
  3006.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  3007. return 1;
  3008.       fprintf (f, "%lun", i);
  3009.     }
  3010.   return ferror (f) || fclose (f) != 0;
  3011.   ;
  3012.   return 0;
  3013. }
  3014. _ACEOF
  3015. rm -f conftest$ac_exeext
  3016. if { (ac_try="$ac_link"
  3017. case "(($ac_try" in
  3018.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3019.   *) ac_try_echo=$ac_try;;
  3020. esac
  3021. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3022.   (eval "$ac_link") 2>&5
  3023.   ac_status=$?
  3024.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3025.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  3026.   { (case "(($ac_try" in
  3027.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3028.   *) ac_try_echo=$ac_try;;
  3029. esac
  3030. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3031.   (eval "$ac_try") 2>&5
  3032.   ac_status=$?
  3033.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3034.   (exit $ac_status); }; }; then
  3035.   ac_cv_sizeof_time_t=`cat conftest.val`
  3036. else
  3037.   echo "$as_me: program exited with status $ac_status" >&5
  3038. echo "$as_me: failed program was:" >&5
  3039. sed 's/^/| /' conftest.$ac_ext >&5
  3040. ( exit $ac_status )
  3041. if test "$ac_cv_type_time_t" = yes; then
  3042.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (time_t)
  3043. See `config.log' for more details." >&5
  3044. echo "$as_me: error: cannot compute sizeof (time_t)
  3045. See `config.log' for more details." >&2;}
  3046.    { (exit 77); exit 77; }; }
  3047.    else
  3048.      ac_cv_sizeof_time_t=0
  3049.    fi
  3050. fi
  3051. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  3052. fi
  3053. rm -f conftest.val
  3054. fi
  3055. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_time_t" >&5
  3056. echo "${ECHO_T}$ac_cv_sizeof_time_t" >&6; }
  3057. cat >>confdefs.h <<_ACEOF
  3058. #define SIZEOF_TIME_T $ac_cv_sizeof_time_t
  3059. _ACEOF
  3060. { echo "$as_me:$LINENO: checking for size_t" >&5
  3061. echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
  3062. if test "${ac_cv_type_size_t+set}" = set; then
  3063.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3064. else
  3065.   cat >conftest.$ac_ext <<_ACEOF
  3066. /* confdefs.h.  */
  3067. _ACEOF
  3068. cat confdefs.h >>conftest.$ac_ext
  3069. cat >>conftest.$ac_ext <<_ACEOF
  3070. /* end confdefs.h.  */
  3071. $ac_includes_default
  3072. typedef size_t ac__type_new_;
  3073. int
  3074. main ()
  3075. {
  3076. if ((ac__type_new_ *) 0)
  3077.   return 0;
  3078. if (sizeof (ac__type_new_))
  3079.   return 0;
  3080.   ;
  3081.   return 0;
  3082. }
  3083. _ACEOF
  3084. rm -f conftest.$ac_objext
  3085. if { (ac_try="$ac_compile"
  3086. case "(($ac_try" in
  3087.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3088.   *) ac_try_echo=$ac_try;;
  3089. esac
  3090. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3091.   (eval "$ac_compile") 2>conftest.er1
  3092.   ac_status=$?
  3093.   grep -v '^ *+' conftest.er1 >conftest.err
  3094.   rm -f conftest.er1
  3095.   cat conftest.err >&5
  3096.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3097.   (exit $ac_status); } && {
  3098.  test -z "$ac_c_werror_flag" ||
  3099.  test ! -s conftest.err
  3100.        } && test -s conftest.$ac_objext; then
  3101.   ac_cv_type_size_t=yes
  3102. else
  3103.   echo "$as_me: failed program was:" >&5
  3104. sed 's/^/| /' conftest.$ac_ext >&5
  3105. ac_cv_type_size_t=no
  3106. fi
  3107. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3108. fi
  3109. { echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
  3110. echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
  3111. # The cast to long int works around a bug in the HP C Compiler
  3112. # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
  3113. # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
  3114. # This bug is HP SR number 8606223364.
  3115. { echo "$as_me:$LINENO: checking size of size_t" >&5
  3116. echo $ECHO_N "checking size of size_t... $ECHO_C" >&6; }
  3117. if test "${ac_cv_sizeof_size_t+set}" = set; then
  3118.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3119. else
  3120.   if test "$cross_compiling" = yes; then
  3121.   # Depending upon the size, compute the lo and hi bounds.
  3122. cat >conftest.$ac_ext <<_ACEOF
  3123. /* confdefs.h.  */
  3124. _ACEOF
  3125. cat confdefs.h >>conftest.$ac_ext
  3126. cat >>conftest.$ac_ext <<_ACEOF
  3127. /* end confdefs.h.  */
  3128. $ac_includes_default
  3129.    typedef size_t ac__type_sizeof_;
  3130. int
  3131. main ()
  3132. {
  3133. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
  3134. test_array [0] = 0
  3135.   ;
  3136.   return 0;
  3137. }
  3138. _ACEOF
  3139. rm -f conftest.$ac_objext
  3140. if { (ac_try="$ac_compile"
  3141. case "(($ac_try" in
  3142.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3143.   *) ac_try_echo=$ac_try;;
  3144. esac
  3145. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3146.   (eval "$ac_compile") 2>conftest.er1
  3147.   ac_status=$?
  3148.   grep -v '^ *+' conftest.er1 >conftest.err
  3149.   rm -f conftest.er1
  3150.   cat conftest.err >&5
  3151.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3152.   (exit $ac_status); } && {
  3153.  test -z "$ac_c_werror_flag" ||
  3154.  test ! -s conftest.err
  3155.        } && test -s conftest.$ac_objext; then
  3156.   ac_lo=0 ac_mid=0
  3157.   while :; do
  3158.     cat >conftest.$ac_ext <<_ACEOF
  3159. /* confdefs.h.  */
  3160. _ACEOF
  3161. cat confdefs.h >>conftest.$ac_ext
  3162. cat >>conftest.$ac_ext <<_ACEOF
  3163. /* end confdefs.h.  */
  3164. $ac_includes_default
  3165.    typedef size_t ac__type_sizeof_;
  3166. int
  3167. main ()
  3168. {
  3169. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  3170. test_array [0] = 0
  3171.   ;
  3172.   return 0;
  3173. }
  3174. _ACEOF
  3175. rm -f conftest.$ac_objext
  3176. if { (ac_try="$ac_compile"
  3177. case "(($ac_try" in
  3178.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3179.   *) ac_try_echo=$ac_try;;
  3180. esac
  3181. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3182.   (eval "$ac_compile") 2>conftest.er1
  3183.   ac_status=$?
  3184.   grep -v '^ *+' conftest.er1 >conftest.err
  3185.   rm -f conftest.er1
  3186.   cat conftest.err >&5
  3187.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3188.   (exit $ac_status); } && {
  3189.  test -z "$ac_c_werror_flag" ||
  3190.  test ! -s conftest.err
  3191.        } && test -s conftest.$ac_objext; then
  3192.   ac_hi=$ac_mid; break
  3193. else
  3194.   echo "$as_me: failed program was:" >&5
  3195. sed 's/^/| /' conftest.$ac_ext >&5
  3196. ac_lo=`expr $ac_mid + 1`
  3197. if test $ac_lo -le $ac_mid; then
  3198.   ac_lo= ac_hi=
  3199.   break
  3200. fi
  3201. ac_mid=`expr 2 '*' $ac_mid + 1`
  3202. fi
  3203. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3204.   done
  3205. else
  3206.   echo "$as_me: failed program was:" >&5
  3207. sed 's/^/| /' conftest.$ac_ext >&5
  3208. cat >conftest.$ac_ext <<_ACEOF
  3209. /* confdefs.h.  */
  3210. _ACEOF
  3211. cat confdefs.h >>conftest.$ac_ext
  3212. cat >>conftest.$ac_ext <<_ACEOF
  3213. /* end confdefs.h.  */
  3214. $ac_includes_default
  3215.    typedef size_t ac__type_sizeof_;
  3216. int
  3217. main ()
  3218. {
  3219. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
  3220. test_array [0] = 0
  3221.   ;
  3222.   return 0;
  3223. }
  3224. _ACEOF
  3225. rm -f conftest.$ac_objext
  3226. if { (ac_try="$ac_compile"
  3227. case "(($ac_try" in
  3228.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3229.   *) ac_try_echo=$ac_try;;
  3230. esac
  3231. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3232.   (eval "$ac_compile") 2>conftest.er1
  3233.   ac_status=$?
  3234.   grep -v '^ *+' conftest.er1 >conftest.err
  3235.   rm -f conftest.er1
  3236.   cat conftest.err >&5
  3237.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3238.   (exit $ac_status); } && {
  3239.  test -z "$ac_c_werror_flag" ||
  3240.  test ! -s conftest.err
  3241.        } && test -s conftest.$ac_objext; then
  3242.   ac_hi=-1 ac_mid=-1
  3243.   while :; do
  3244.     cat >conftest.$ac_ext <<_ACEOF
  3245. /* confdefs.h.  */
  3246. _ACEOF
  3247. cat confdefs.h >>conftest.$ac_ext
  3248. cat >>conftest.$ac_ext <<_ACEOF
  3249. /* end confdefs.h.  */
  3250. $ac_includes_default
  3251.    typedef size_t ac__type_sizeof_;
  3252. int
  3253. main ()
  3254. {
  3255. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
  3256. test_array [0] = 0
  3257.   ;
  3258.   return 0;
  3259. }
  3260. _ACEOF
  3261. rm -f conftest.$ac_objext
  3262. if { (ac_try="$ac_compile"
  3263. case "(($ac_try" in
  3264.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3265.   *) ac_try_echo=$ac_try;;
  3266. esac
  3267. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3268.   (eval "$ac_compile") 2>conftest.er1
  3269.   ac_status=$?
  3270.   grep -v '^ *+' conftest.er1 >conftest.err
  3271.   rm -f conftest.er1
  3272.   cat conftest.err >&5
  3273.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3274.   (exit $ac_status); } && {
  3275.  test -z "$ac_c_werror_flag" ||
  3276.  test ! -s conftest.err
  3277.        } && test -s conftest.$ac_objext; then
  3278.   ac_lo=$ac_mid; break
  3279. else
  3280.   echo "$as_me: failed program was:" >&5
  3281. sed 's/^/| /' conftest.$ac_ext >&5
  3282. ac_hi=`expr '(' $ac_mid ')' - 1`
  3283. if test $ac_mid -le $ac_hi; then
  3284.   ac_lo= ac_hi=
  3285.   break
  3286. fi
  3287. ac_mid=`expr 2 '*' $ac_mid`
  3288. fi
  3289. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3290.   done
  3291. else
  3292.   echo "$as_me: failed program was:" >&5
  3293. sed 's/^/| /' conftest.$ac_ext >&5
  3294. ac_lo= ac_hi=
  3295. fi
  3296. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3297. fi
  3298. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3299. # Binary search between lo and hi bounds.
  3300. while test "x$ac_lo" != "x$ac_hi"; do
  3301.   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
  3302.   cat >conftest.$ac_ext <<_ACEOF
  3303. /* confdefs.h.  */
  3304. _ACEOF
  3305. cat confdefs.h >>conftest.$ac_ext
  3306. cat >>conftest.$ac_ext <<_ACEOF
  3307. /* end confdefs.h.  */
  3308. $ac_includes_default
  3309.    typedef size_t ac__type_sizeof_;
  3310. int
  3311. main ()
  3312. {
  3313. static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
  3314. test_array [0] = 0
  3315.   ;
  3316.   return 0;
  3317. }
  3318. _ACEOF
  3319. rm -f conftest.$ac_objext
  3320. if { (ac_try="$ac_compile"
  3321. case "(($ac_try" in
  3322.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3323.   *) ac_try_echo=$ac_try;;
  3324. esac
  3325. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3326.   (eval "$ac_compile") 2>conftest.er1
  3327.   ac_status=$?
  3328.   grep -v '^ *+' conftest.er1 >conftest.err
  3329.   rm -f conftest.er1
  3330.   cat conftest.err >&5
  3331.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3332.   (exit $ac_status); } && {
  3333.  test -z "$ac_c_werror_flag" ||
  3334.  test ! -s conftest.err
  3335.        } && test -s conftest.$ac_objext; then
  3336.   ac_hi=$ac_mid
  3337. else
  3338.   echo "$as_me: failed program was:" >&5
  3339. sed 's/^/| /' conftest.$ac_ext >&5
  3340. ac_lo=`expr '(' $ac_mid ')' + 1`
  3341. fi
  3342. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3343. done
  3344. case $ac_lo in
  3345. ?*) ac_cv_sizeof_size_t=$ac_lo;;
  3346. '') if test "$ac_cv_type_size_t" = yes; then
  3347.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (size_t)
  3348. See `config.log' for more details." >&5
  3349. echo "$as_me: error: cannot compute sizeof (size_t)
  3350. See `config.log' for more details." >&2;}
  3351.    { (exit 77); exit 77; }; }
  3352.    else
  3353.      ac_cv_sizeof_size_t=0
  3354.    fi ;;
  3355. esac
  3356. else
  3357.   cat >conftest.$ac_ext <<_ACEOF
  3358. /* confdefs.h.  */
  3359. _ACEOF
  3360. cat confdefs.h >>conftest.$ac_ext
  3361. cat >>conftest.$ac_ext <<_ACEOF
  3362. /* end confdefs.h.  */
  3363. $ac_includes_default
  3364.    typedef size_t ac__type_sizeof_;
  3365. static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
  3366. static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
  3367. #include <stdio.h>
  3368. #include <stdlib.h>
  3369. int
  3370. main ()
  3371. {
  3372.   FILE *f = fopen ("conftest.val", "w");
  3373.   if (! f)
  3374.     return 1;
  3375.   if (((long int) (sizeof (ac__type_sizeof_))) < 0)
  3376.     {
  3377.       long int i = longval ();
  3378.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  3379. return 1;
  3380.       fprintf (f, "%ldn", i);
  3381.     }
  3382.   else
  3383.     {
  3384.       unsigned long int i = ulongval ();
  3385.       if (i != ((long int) (sizeof (ac__type_sizeof_))))
  3386. return 1;
  3387.       fprintf (f, "%lun", i);
  3388.     }
  3389.   return ferror (f) || fclose (f) != 0;
  3390.   ;
  3391.   return 0;
  3392. }
  3393. _ACEOF
  3394. rm -f conftest$ac_exeext
  3395. if { (ac_try="$ac_link"
  3396. case "(($ac_try" in
  3397.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3398.   *) ac_try_echo=$ac_try;;
  3399. esac
  3400. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3401.   (eval "$ac_link") 2>&5
  3402.   ac_status=$?
  3403.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3404.   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
  3405.   { (case "(($ac_try" in
  3406.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3407.   *) ac_try_echo=$ac_try;;
  3408. esac
  3409. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3410.   (eval "$ac_try") 2>&5
  3411.   ac_status=$?
  3412.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3413.   (exit $ac_status); }; }; then
  3414.   ac_cv_sizeof_size_t=`cat conftest.val`
  3415. else
  3416.   echo "$as_me: program exited with status $ac_status" >&5
  3417. echo "$as_me: failed program was:" >&5
  3418. sed 's/^/| /' conftest.$ac_ext >&5
  3419. ( exit $ac_status )
  3420. if test "$ac_cv_type_size_t" = yes; then
  3421.      { { echo "$as_me:$LINENO: error: cannot compute sizeof (size_t)
  3422. See `config.log' for more details." >&5
  3423. echo "$as_me: error: cannot compute sizeof (size_t)
  3424. See `config.log' for more details." >&2;}
  3425.    { (exit 77); exit 77; }; }
  3426.    else
  3427.      ac_cv_sizeof_size_t=0
  3428.    fi
  3429. fi
  3430. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
  3431. fi
  3432. rm -f conftest.val
  3433. fi
  3434. { echo "$as_me:$LINENO: result: $ac_cv_sizeof_size_t" >&5
  3435. echo "${ECHO_T}$ac_cv_sizeof_size_t" >&6; }
  3436. cat >>confdefs.h <<_ACEOF
  3437. #define SIZEOF_SIZE_T $ac_cv_sizeof_size_t
  3438. _ACEOF
  3439. { echo "$as_me:$LINENO: checking for uint" >&5
  3440. echo $ECHO_N "checking for uint... $ECHO_C" >&6; }
  3441. if test "${ac_cv_type_uint+set}" = set; then
  3442.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3443. else
  3444.   cat >conftest.$ac_ext <<_ACEOF
  3445. /* confdefs.h.  */
  3446. _ACEOF
  3447. cat confdefs.h >>conftest.$ac_ext
  3448. cat >>conftest.$ac_ext <<_ACEOF
  3449. /* end confdefs.h.  */
  3450. $ac_includes_default
  3451. typedef uint ac__type_new_;
  3452. int
  3453. main ()
  3454. {
  3455. if ((ac__type_new_ *) 0)
  3456.   return 0;
  3457. if (sizeof (ac__type_new_))
  3458.   return 0;
  3459.   ;
  3460.   return 0;
  3461. }
  3462. _ACEOF
  3463. rm -f conftest.$ac_objext
  3464. if { (ac_try="$ac_compile"
  3465. case "(($ac_try" in
  3466.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3467.   *) ac_try_echo=$ac_try;;
  3468. esac
  3469. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3470.   (eval "$ac_compile") 2>conftest.er1
  3471.   ac_status=$?
  3472.   grep -v '^ *+' conftest.er1 >conftest.err
  3473.   rm -f conftest.er1
  3474.   cat conftest.err >&5
  3475.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3476.   (exit $ac_status); } && {
  3477.  test -z "$ac_c_werror_flag" ||
  3478.  test ! -s conftest.err
  3479.        } && test -s conftest.$ac_objext; then
  3480.   ac_cv_type_uint=yes
  3481. else
  3482.   echo "$as_me: failed program was:" >&5
  3483. sed 's/^/| /' conftest.$ac_ext >&5
  3484. ac_cv_type_uint=no
  3485. fi
  3486. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3487. fi
  3488. { echo "$as_me:$LINENO: result: $ac_cv_type_uint" >&5
  3489. echo "${ECHO_T}$ac_cv_type_uint" >&6; }
  3490. if test $ac_cv_type_uint = yes; then
  3491. cat >>confdefs.h <<_ACEOF
  3492. #define HAVE_UINT 1
  3493. _ACEOF
  3494. fi
  3495. { echo "$as_me:$LINENO: checking for u_char" >&5
  3496. echo $ECHO_N "checking for u_char... $ECHO_C" >&6; }
  3497. if test "${ac_cv_type_u_char+set}" = set; then
  3498.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3499. else
  3500.   cat >conftest.$ac_ext <<_ACEOF
  3501. /* confdefs.h.  */
  3502. _ACEOF
  3503. cat confdefs.h >>conftest.$ac_ext
  3504. cat >>conftest.$ac_ext <<_ACEOF
  3505. /* end confdefs.h.  */
  3506. $ac_includes_default
  3507. typedef u_char ac__type_new_;
  3508. int
  3509. main ()
  3510. {
  3511. if ((ac__type_new_ *) 0)
  3512.   return 0;
  3513. if (sizeof (ac__type_new_))
  3514.   return 0;
  3515.   ;
  3516.   return 0;
  3517. }
  3518. _ACEOF
  3519. rm -f conftest.$ac_objext
  3520. if { (ac_try="$ac_compile"
  3521. case "(($ac_try" in
  3522.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3523.   *) ac_try_echo=$ac_try;;
  3524. esac
  3525. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3526.   (eval "$ac_compile") 2>conftest.er1
  3527.   ac_status=$?
  3528.   grep -v '^ *+' conftest.er1 >conftest.err
  3529.   rm -f conftest.er1
  3530.   cat conftest.err >&5
  3531.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3532.   (exit $ac_status); } && {
  3533.  test -z "$ac_c_werror_flag" ||
  3534.  test ! -s conftest.err
  3535.        } && test -s conftest.$ac_objext; then
  3536.   ac_cv_type_u_char=yes
  3537. else
  3538.   echo "$as_me: failed program was:" >&5
  3539. sed 's/^/| /' conftest.$ac_ext >&5
  3540. ac_cv_type_u_char=no
  3541. fi
  3542. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3543. fi
  3544. { echo "$as_me:$LINENO: result: $ac_cv_type_u_char" >&5
  3545. echo "${ECHO_T}$ac_cv_type_u_char" >&6; }
  3546. if test $ac_cv_type_u_char = yes; then
  3547. cat >>confdefs.h <<_ACEOF
  3548. #define HAVE_U_CHAR 1
  3549. _ACEOF
  3550. fi
  3551. { echo "$as_me:$LINENO: checking for ssize_t" >&5
  3552. echo $ECHO_N "checking for ssize_t... $ECHO_C" >&6; }
  3553. if test "${ac_cv_type_ssize_t+set}" = set; then
  3554.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3555. else
  3556.   cat >conftest.$ac_ext <<_ACEOF
  3557. /* confdefs.h.  */
  3558. _ACEOF
  3559. cat confdefs.h >>conftest.$ac_ext
  3560. cat >>conftest.$ac_ext <<_ACEOF
  3561. /* end confdefs.h.  */
  3562. $ac_includes_default
  3563. typedef ssize_t ac__type_new_;
  3564. int
  3565. main ()
  3566. {
  3567. if ((ac__type_new_ *) 0)
  3568.   return 0;
  3569. if (sizeof (ac__type_new_))
  3570.   return 0;
  3571.   ;
  3572.   return 0;
  3573. }
  3574. _ACEOF
  3575. rm -f conftest.$ac_objext
  3576. if { (ac_try="$ac_compile"
  3577. case "(($ac_try" in
  3578.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3579.   *) ac_try_echo=$ac_try;;
  3580. esac
  3581. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3582.   (eval "$ac_compile") 2>conftest.er1
  3583.   ac_status=$?
  3584.   grep -v '^ *+' conftest.er1 >conftest.err
  3585.   rm -f conftest.er1
  3586.   cat conftest.err >&5
  3587.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3588.   (exit $ac_status); } && {
  3589.  test -z "$ac_c_werror_flag" ||
  3590.  test ! -s conftest.err
  3591.        } && test -s conftest.$ac_objext; then
  3592.   ac_cv_type_ssize_t=yes
  3593. else
  3594.   echo "$as_me: failed program was:" >&5
  3595. sed 's/^/| /' conftest.$ac_ext >&5
  3596. ac_cv_type_ssize_t=no
  3597. fi
  3598. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3599. fi
  3600. { echo "$as_me:$LINENO: result: $ac_cv_type_ssize_t" >&5
  3601. echo "${ECHO_T}$ac_cv_type_ssize_t" >&6; }
  3602. if test $ac_cv_type_ssize_t = yes; then
  3603. cat >>confdefs.h <<_ACEOF
  3604. #define HAVE_SSIZE_T 1
  3605. _ACEOF
  3606. fi
  3607. { echo "$as_me:$LINENO: checking for struct in6_addr" >&5
  3608. echo $ECHO_N "checking for struct in6_addr... $ECHO_C" >&6; }
  3609. if test "${ac_cv_type_struct_in6_addr+set}" = set; then
  3610.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3611. else
  3612.   cat >conftest.$ac_ext <<_ACEOF
  3613. /* confdefs.h.  */
  3614. _ACEOF
  3615. cat confdefs.h >>conftest.$ac_ext
  3616. cat >>conftest.$ac_ext <<_ACEOF
  3617. /* end confdefs.h.  */
  3618. #ifdef HAVE_SYS_TYPES_H
  3619. #include <sys/types.h>
  3620. #endif
  3621. #ifdef HAVE_NETINET_IN_H
  3622. #include <netinet/in.h>
  3623. #endif
  3624. #ifdef HAVE_NETINET_IN6_H
  3625. #include <netinet/in6.h>
  3626. #endif
  3627. #ifdef HAVE_SYS_SOCKET_H
  3628. #include <sys/socket.h>
  3629. #endif
  3630. #ifdef MS_WINDOWS
  3631. #define WIN32_WINNT 0x400
  3632. #define _WIN32_WINNT 0x400
  3633. #define WIN32_LEAN_AND_MEAN
  3634. #if defined(_MSC_VER) && (_MSC_VER < 1300)
  3635. #include <winsock.h>
  3636. #else
  3637. #include <winsock2.h>
  3638. #include <ws2tcpip.h>
  3639. #endif
  3640. #endif
  3641. typedef struct in6_addr ac__type_new_;
  3642. int
  3643. main ()
  3644. {
  3645. if ((ac__type_new_ *) 0)
  3646.   return 0;
  3647. if (sizeof (ac__type_new_))
  3648.   return 0;
  3649.   ;
  3650.   return 0;
  3651. }
  3652. _ACEOF
  3653. rm -f conftest.$ac_objext
  3654. if { (ac_try="$ac_compile"
  3655. case "(($ac_try" in
  3656.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3657.   *) ac_try_echo=$ac_try;;
  3658. esac
  3659. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3660.   (eval "$ac_compile") 2>conftest.er1
  3661.   ac_status=$?
  3662.   grep -v '^ *+' conftest.er1 >conftest.err
  3663.   rm -f conftest.er1
  3664.   cat conftest.err >&5
  3665.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3666.   (exit $ac_status); } && {
  3667.  test -z "$ac_c_werror_flag" ||
  3668.  test ! -s conftest.err
  3669.        } && test -s conftest.$ac_objext; then
  3670.   ac_cv_type_struct_in6_addr=yes
  3671. else
  3672.   echo "$as_me: failed program was:" >&5
  3673. sed 's/^/| /' conftest.$ac_ext >&5
  3674. ac_cv_type_struct_in6_addr=no
  3675. fi
  3676. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3677. fi
  3678. { echo "$as_me:$LINENO: result: $ac_cv_type_struct_in6_addr" >&5
  3679. echo "${ECHO_T}$ac_cv_type_struct_in6_addr" >&6; }
  3680. if test $ac_cv_type_struct_in6_addr = yes; then
  3681. cat >>confdefs.h <<_ACEOF
  3682. #define HAVE_STRUCT_IN6_ADDR 1
  3683. _ACEOF
  3684. fi
  3685. { echo "$as_me:$LINENO: checking for struct sockaddr_in6" >&5
  3686. echo $ECHO_N "checking for struct sockaddr_in6... $ECHO_C" >&6; }
  3687. if test "${ac_cv_type_struct_sockaddr_in6+set}" = set; then
  3688.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3689. else
  3690.   cat >conftest.$ac_ext <<_ACEOF
  3691. /* confdefs.h.  */
  3692. _ACEOF
  3693. cat confdefs.h >>conftest.$ac_ext
  3694. cat >>conftest.$ac_ext <<_ACEOF
  3695. /* end confdefs.h.  */
  3696. #ifdef HAVE_SYS_TYPES_H
  3697. #include <sys/types.h>
  3698. #endif
  3699. #ifdef HAVE_NETINET_IN_H
  3700. #include <netinet/in.h>
  3701. #endif
  3702. #ifdef HAVE_NETINET_IN6_H
  3703. #include <netinet/in6.h>
  3704. #endif
  3705. #ifdef HAVE_SYS_SOCKET_H
  3706. #include <sys/socket.h>
  3707. #endif
  3708. #ifdef MS_WINDOWS
  3709. #define WIN32_WINNT 0x400
  3710. #define _WIN32_WINNT 0x400
  3711. #define WIN32_LEAN_AND_MEAN
  3712. #if defined(_MSC_VER) && (_MSC_VER < 1300)
  3713. #include <winsock.h>
  3714. #else
  3715. #include <winsock2.h>
  3716. #include <ws2tcpip.h>
  3717. #endif
  3718. #endif
  3719. typedef struct sockaddr_in6 ac__type_new_;
  3720. int
  3721. main ()
  3722. {
  3723. if ((ac__type_new_ *) 0)
  3724.   return 0;
  3725. if (sizeof (ac__type_new_))
  3726.   return 0;
  3727.   ;
  3728.   return 0;
  3729. }
  3730. _ACEOF
  3731. rm -f conftest.$ac_objext
  3732. if { (ac_try="$ac_compile"
  3733. case "(($ac_try" in
  3734.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3735.   *) ac_try_echo=$ac_try;;
  3736. esac
  3737. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3738.   (eval "$ac_compile") 2>conftest.er1
  3739.   ac_status=$?
  3740.   grep -v '^ *+' conftest.er1 >conftest.err
  3741.   rm -f conftest.er1
  3742.   cat conftest.err >&5
  3743.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3744.   (exit $ac_status); } && {
  3745.  test -z "$ac_c_werror_flag" ||
  3746.  test ! -s conftest.err
  3747.        } && test -s conftest.$ac_objext; then
  3748.   ac_cv_type_struct_sockaddr_in6=yes
  3749. else
  3750.   echo "$as_me: failed program was:" >&5
  3751. sed 's/^/| /' conftest.$ac_ext >&5
  3752. ac_cv_type_struct_sockaddr_in6=no
  3753. fi
  3754. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3755. fi
  3756. { echo "$as_me:$LINENO: result: $ac_cv_type_struct_sockaddr_in6" >&5
  3757. echo "${ECHO_T}$ac_cv_type_struct_sockaddr_in6" >&6; }
  3758. if test $ac_cv_type_struct_sockaddr_in6 = yes; then
  3759. cat >>confdefs.h <<_ACEOF
  3760. #define HAVE_STRUCT_SOCKADDR_IN6 1
  3761. _ACEOF
  3762. fi
  3763. { echo "$as_me:$LINENO: checking for sa_family_t" >&5
  3764. echo $ECHO_N "checking for sa_family_t... $ECHO_C" >&6; }
  3765. if test "${ac_cv_type_sa_family_t+set}" = set; then
  3766.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3767. else
  3768.   cat >conftest.$ac_ext <<_ACEOF
  3769. /* confdefs.h.  */
  3770. _ACEOF
  3771. cat confdefs.h >>conftest.$ac_ext
  3772. cat >>conftest.$ac_ext <<_ACEOF
  3773. /* end confdefs.h.  */
  3774. #ifdef HAVE_SYS_TYPES_H
  3775. #include <sys/types.h>
  3776. #endif
  3777. #ifdef HAVE_NETINET_IN_H
  3778. #include <netinet/in.h>
  3779. #endif
  3780. #ifdef HAVE_NETINET_IN6_H
  3781. #include <netinet/in6.h>
  3782. #endif
  3783. #ifdef HAVE_SYS_SOCKET_H
  3784. #include <sys/socket.h>
  3785. #endif
  3786. #ifdef MS_WINDOWS
  3787. #define WIN32_WINNT 0x400
  3788. #define _WIN32_WINNT 0x400
  3789. #define WIN32_LEAN_AND_MEAN
  3790. #if defined(_MSC_VER) && (_MSC_VER < 1300)
  3791. #include <winsock.h>
  3792. #else
  3793. #include <winsock2.h>
  3794. #include <ws2tcpip.h>
  3795. #endif
  3796. #endif
  3797. typedef sa_family_t ac__type_new_;
  3798. int
  3799. main ()
  3800. {
  3801. if ((ac__type_new_ *) 0)
  3802.   return 0;
  3803. if (sizeof (ac__type_new_))
  3804.   return 0;
  3805.   ;
  3806.   return 0;
  3807. }
  3808. _ACEOF
  3809. rm -f conftest.$ac_objext
  3810. if { (ac_try="$ac_compile"
  3811. case "(($ac_try" in
  3812.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3813.   *) ac_try_echo=$ac_try;;
  3814. esac
  3815. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3816.   (eval "$ac_compile") 2>conftest.er1
  3817.   ac_status=$?
  3818.   grep -v '^ *+' conftest.er1 >conftest.err
  3819.   rm -f conftest.er1
  3820.   cat conftest.err >&5
  3821.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3822.   (exit $ac_status); } && {
  3823.  test -z "$ac_c_werror_flag" ||
  3824.  test ! -s conftest.err
  3825.        } && test -s conftest.$ac_objext; then
  3826.   ac_cv_type_sa_family_t=yes
  3827. else
  3828.   echo "$as_me: failed program was:" >&5
  3829. sed 's/^/| /' conftest.$ac_ext >&5
  3830. ac_cv_type_sa_family_t=no
  3831. fi
  3832. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3833. fi
  3834. { echo "$as_me:$LINENO: result: $ac_cv_type_sa_family_t" >&5
  3835. echo "${ECHO_T}$ac_cv_type_sa_family_t" >&6; }
  3836. if test $ac_cv_type_sa_family_t = yes; then
  3837. cat >>confdefs.h <<_ACEOF
  3838. #define HAVE_SA_FAMILY_T 1
  3839. _ACEOF
  3840. fi
  3841. { echo "$as_me:$LINENO: checking for struct in6_addr.s6_addr32" >&5
  3842. echo $ECHO_N "checking for struct in6_addr.s6_addr32... $ECHO_C" >&6; }
  3843. if test "${ac_cv_member_struct_in6_addr_s6_addr32+set}" = set; then
  3844.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3845. else
  3846.   cat >conftest.$ac_ext <<_ACEOF
  3847. /* confdefs.h.  */
  3848. _ACEOF
  3849. cat confdefs.h >>conftest.$ac_ext
  3850. cat >>conftest.$ac_ext <<_ACEOF
  3851. /* end confdefs.h.  */
  3852. #ifdef HAVE_SYS_TYPES_H
  3853. #include <sys/types.h>
  3854. #endif
  3855. #ifdef HAVE_NETINET_IN_H
  3856. #include <netinet/in.h>
  3857. #endif
  3858. #ifdef HAVE_NETINET_IN6_H
  3859. #include <netinet/in6.h>
  3860. #endif
  3861. #ifdef HAVE_SYS_SOCKET_H
  3862. #include <sys/socket.h>
  3863. #endif
  3864. #ifdef MS_WINDOWS
  3865. #define WIN32_WINNT 0x400
  3866. #define _WIN32_WINNT 0x400
  3867. #define WIN32_LEAN_AND_MEAN
  3868. #if defined(_MSC_VER) && (_MSC_VER < 1300)
  3869. #include <winsock.h>
  3870. #else
  3871. #include <winsock2.h>
  3872. #include <ws2tcpip.h>
  3873. #endif
  3874. #endif
  3875. int
  3876. main ()
  3877. {
  3878. static struct in6_addr ac_aggr;
  3879. if (ac_aggr.s6_addr32)
  3880. return 0;
  3881.   ;
  3882.   return 0;
  3883. }
  3884. _ACEOF
  3885. rm -f conftest.$ac_objext
  3886. if { (ac_try="$ac_compile"
  3887. case "(($ac_try" in
  3888.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3889.   *) ac_try_echo=$ac_try;;
  3890. esac
  3891. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3892.   (eval "$ac_compile") 2>conftest.er1
  3893.   ac_status=$?
  3894.   grep -v '^ *+' conftest.er1 >conftest.err
  3895.   rm -f conftest.er1
  3896.   cat conftest.err >&5
  3897.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3898.   (exit $ac_status); } && {
  3899.  test -z "$ac_c_werror_flag" ||
  3900.  test ! -s conftest.err
  3901.        } && test -s conftest.$ac_objext; then
  3902.   ac_cv_member_struct_in6_addr_s6_addr32=yes
  3903. else
  3904.   echo "$as_me: failed program was:" >&5
  3905. sed 's/^/| /' conftest.$ac_ext >&5
  3906. cat >conftest.$ac_ext <<_ACEOF
  3907. /* confdefs.h.  */
  3908. _ACEOF
  3909. cat confdefs.h >>conftest.$ac_ext
  3910. cat >>conftest.$ac_ext <<_ACEOF
  3911. /* end confdefs.h.  */
  3912. #ifdef HAVE_SYS_TYPES_H
  3913. #include <sys/types.h>
  3914. #endif
  3915. #ifdef HAVE_NETINET_IN_H
  3916. #include <netinet/in.h>
  3917. #endif
  3918. #ifdef HAVE_NETINET_IN6_H
  3919. #include <netinet/in6.h>
  3920. #endif
  3921. #ifdef HAVE_SYS_SOCKET_H
  3922. #include <sys/socket.h>
  3923. #endif
  3924. #ifdef MS_WINDOWS
  3925. #define WIN32_WINNT 0x400
  3926. #define _WIN32_WINNT 0x400
  3927. #define WIN32_LEAN_AND_MEAN
  3928. #if defined(_MSC_VER) && (_MSC_VER < 1300)
  3929. #include <winsock.h>
  3930. #else
  3931. #include <winsock2.h>
  3932. #include <ws2tcpip.h>
  3933. #endif
  3934. #endif
  3935. int
  3936. main ()
  3937. {
  3938. static struct in6_addr ac_aggr;
  3939. if (sizeof ac_aggr.s6_addr32)
  3940. return 0;
  3941.   ;
  3942.   return 0;
  3943. }
  3944. _ACEOF
  3945. rm -f conftest.$ac_objext
  3946. if { (ac_try="$ac_compile"
  3947. case "(($ac_try" in
  3948.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  3949.   *) ac_try_echo=$ac_try;;
  3950. esac
  3951. eval "echo "$as_me:$LINENO: $ac_try_echo"") >&5
  3952.   (eval "$ac_compile") 2>conftest.er1
  3953.   ac_status=$?
  3954.   grep -v '^ *+' conftest.er1 >conftest.err
  3955.   rm -f conftest.er1
  3956.   cat conftest.err >&5
  3957.   echo "$as_me:$LINENO: $? = $ac_status" >&5
  3958.   (exit $ac_status); } && {
  3959.  test -z "$ac_c_werror_flag" ||
  3960.  test ! -s conftest.err
  3961.        } && test -s conftest.$ac_objext; then
  3962.   ac_cv_member_struct_in6_addr_s6_addr32=yes
  3963. else
  3964.   echo "$as_me: failed program was:" >&5
  3965. sed 's/^/| /' conftest.$ac_ext >&5
  3966. ac_cv_member_struct_in6_addr_s6_addr32=no
  3967. fi
  3968. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3969. fi
  3970. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3971. fi
  3972. { echo "$as_me:$LINENO: result: $ac_cv_member_struct_in6_addr_s6_addr32" >&5
  3973. echo "${ECHO_T}$ac_cv_member_struct_in6_addr_s6_addr32" >&6; }
  3974. if test $ac_cv_member_struct_in6_addr_s6_addr32 = yes; then
  3975. cat >>confdefs.h <<_ACEOF
  3976. #define HAVE_STRUCT_IN6_ADDR_S6_ADDR32 1
  3977. _ACEOF
  3978. fi
  3979. { echo "$as_me:$LINENO: checking for struct in6_addr.s6_addr16" >&5
  3980. echo $ECHO_N "checking for struct in6_addr.s6_addr16... $ECHO_C" >&6; }
  3981. if test "${ac_cv_member_struct_in6_addr_s6_addr16+set}" = set; then
  3982.   echo $ECHO_N "(cached) $ECHO_C" >&6
  3983. else