开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
configure
资源名称：tor-0.2.1.20.tar.gz　[点击查看]
上传用户：awang829
上传日期：2019-07-14
资源大小：2356k
文件大小：565k
源码类别：

网络

开发平台：

Unix_Linux

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