+71 -1

app/xkbevd/ChangeLog

reviewed

··· 1 1 + commit fc79791bd8ec7adb88e206158484b940343c6765 2 2 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 3 3 + Date: Wed Dec 4 13:19:49 2024 -0800 4 4 + 5 5 + xkbevd 1.1.6 6 6 + 7 7 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 8 8 + 9 9 + commit df09a8bd9d4692612647c5054d8113f7b83ce961 10 10 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 11 11 + Date: Mon Nov 11 11:06:39 2024 -0800 12 12 + 13 13 + Use _stricmp() instead of strcasecmp() on Windows 14 14 + 15 15 + v2: Exclude include of <strings.h> as well 16 16 + 17 17 + Fixes: e4bae5f ("Assume target platforms have strcasecmp now") 18 18 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 19 19 + Part-of: <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/merge_requests/7> 20 20 + 21 21 + commit 53fc60d2eb2c6e3847d2e6cb6e3d3f48eaa8e0d8 22 22 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 23 23 + Date: Sun Jul 28 15:44:00 2024 -0700 24 24 + 25 25 + Accept --help & --version as aliases to -help & -version 26 26 + 27 27 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 28 28 + Part-of: <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/merge_requests/6> 29 29 + 30 30 + commit ab1024ef4bd01324d8506d069b465dacc9579165 31 31 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 32 32 + Date: Sun Jul 28 15:23:33 2024 -0700 33 33 + 34 34 + evargs.c: constify pointer arguments that aren't modified 35 35 + 36 36 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 37 37 + Part-of: <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/merge_requests/6> 38 38 + 39 39 + commit 1176594f37734c3f60a0932c1e666edb5179a702 40 40 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 41 41 + Date: Sun Jul 28 15:12:49 2024 -0700 42 42 + 43 43 + evargs.c: Use standard strchr() instead of deprecated index() 44 44 + 45 45 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 46 46 + Part-of: <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/merge_requests/6> 47 47 + 48 48 + commit 7685c5d538067e726723dd99ef8108d303a9ee1a 49 49 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 50 50 + Date: Sun Jul 28 12:58:01 2024 -0700 51 51 + 52 52 + Remove detectableRepeat variable 53 53 + 54 54 + The only uses of it were in the code in the '#ifdef notyet' bits 55 55 + removed a decade ago in commit 01774fb58330733858ff41ceabe2d646d127d4f3. 56 56 + 57 57 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 58 58 + Part-of: <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/merge_requests/6> 59 59 + 60 60 + commit e4bae5f23e2c12d2771b93adc7c686d8f600b3a9 61 61 + Author: Alan Coopersmith <alan.coopersmith@oracle.com> 62 62 + Date: Mon Apr 22 10:26:01 2024 -0700 63 63 + 64 64 + Assume target platforms have strcasecmp now 65 65 + 66 66 + It has been required since Unix98/SUSv2 67 67 + 68 68 + Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> 69 69 + Part-of: <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/merge_requests/5> 70 70 + 1 71 commit ca8e535970c7bec44e02141113e31a42bb0a1c5e 2 72 Author: Alan Coopersmith <alan.coopersmith@oracle.com> 3 73 Date: Sat Nov 12 15:47:00 2022 -0800 ··· 871 941 configure cache, you cache it, and the cached value is probably wrong. 872 942 873 943 commit 6b1df45952ed9088b8f9db18afbd62f1ee84f59d 874 874 - Author: Søren Sandmann Pedersen <sandmann@daimi.au.dk> 944 944 + Author: Søren Sandmann Pedersen <sandmann@daimi.au.dk> 875 945 Date: Wed Jul 6 20:38:28 2005 +0000 876 946 877 947 build system for xkbevd

-3

app/xkbevd/Makefile.in

reviewed

··· 213 213 CCDEPMODE = @CCDEPMODE@ 214 214 CFLAGS = @CFLAGS@ 215 215 CHANGELOG_CMD = @CHANGELOG_CMD@ 216 216 - CPP = @CPP@ 217 216 CPPFLAGS = @CPPFLAGS@ 218 217 CWARNFLAGS = @CWARNFLAGS@ 219 218 CYGPATH_W = @CYGPATH_W@ ··· 224 223 ECHO_C = @ECHO_C@ 225 224 ECHO_N = @ECHO_N@ 226 225 ECHO_T = @ECHO_T@ 227 227 - EGREP = @EGREP@ 228 226 EXEEXT = @EXEEXT@ 229 227 FILE_MAN_DIR = @FILE_MAN_DIR@ 230 228 FILE_MAN_SUFFIX = @FILE_MAN_SUFFIX@ 231 231 - GREP = @GREP@ 232 229 INSTALL = @INSTALL@ 233 230 INSTALL_CMD = @INSTALL_CMD@ 234 231 INSTALL_DATA = @INSTALL_DATA@

+126 -38

app/xkbevd/aclocal.m4

reviewed

··· 13 13 14 14 m4_ifndef([AC_AUTOCONF_VERSION], 15 15 [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl 16 16 - m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],, 17 17 - [m4_warning([this file was generated for autoconf 2.69. 16 16 + m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.71],, 17 17 + [m4_warning([this file was generated for autoconf 2.71. 18 18 You have another version of autoconf. It may work, but is not guaranteed to. 19 19 If you have problems, you may need to regenerate the build system entirely. 20 20 To do so, use the procedure documented by the package, typically 'autoreconf'.])]) 21 21 22 22 - # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- 22 22 + # pkg.m4 - Macros to locate and use pkg-config. -*- Autoconf -*- 23 23 # serial 12 (pkg-config-0.29.2) 24 24 25 25 dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>. ··· 107 107 dnl PKG_CHECK_MODULES(), but does not set variables or print errors. 108 108 dnl 109 109 dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG]) 110 110 - dnl only at the first occurence in configure.ac, so if the first place 110 110 + dnl only at the first occurrence in configure.ac, so if the first place 111 111 dnl it's called might be skipped (such as if it is within an "if", you 112 112 dnl have to call PKG_CHECK_EXISTS manually 113 113 AC_DEFUN([PKG_CHECK_EXISTS], ··· 176 176 AC_MSG_RESULT([no]) 177 177 _PKG_SHORT_ERRORS_SUPPORTED 178 178 if test $_pkg_short_errors_supported = yes; then 179 179 - $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` 179 179 + $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` 180 180 else 181 181 - $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` 181 181 + $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` 182 182 fi 183 183 - # Put the nasty error message in config.log where it belongs 184 184 - echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD 183 183 + # Put the nasty error message in config.log where it belongs 184 184 + echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD 185 185 186 186 - m4_default([$4], [AC_MSG_ERROR( 186 186 + m4_default([$4], [AC_MSG_ERROR( 187 187 [Package requirements ($2) were not met: 188 188 189 189 $$1_PKG_ERRORS ··· 195 195 ]) 196 196 elif test $pkg_failed = untried; then 197 197 AC_MSG_RESULT([no]) 198 198 - m4_default([$4], [AC_MSG_FAILURE( 198 198 + m4_default([$4], [AC_MSG_FAILURE( 199 199 [The pkg-config script could not be found or is too old. Make sure it 200 200 is in your PATH or set the PKG_CONFIG environment variable to the full 201 201 path to pkg-config. ··· 205 205 To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl 206 206 ]) 207 207 else 208 208 - $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS 209 209 - $1[]_LIBS=$pkg_cv_[]$1[]_LIBS 208 208 + $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS 209 209 + $1[]_LIBS=$pkg_cv_[]$1[]_LIBS 210 210 AC_MSG_RESULT([yes]) 211 211 - $3 211 211 + $3 212 212 fi[]dnl 213 213 ])dnl PKG_CHECK_MODULES 214 214 ··· 295 295 AS_VAR_IF([$1], [""], [$5], [$4])dnl 296 296 ])dnl PKG_CHECK_VAR 297 297 298 298 + dnl PKG_WITH_MODULES(VARIABLE-PREFIX, MODULES, 299 299 + dnl [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND], 300 300 + dnl [DESCRIPTION], [DEFAULT]) 301 301 + dnl ------------------------------------------ 302 302 + dnl 303 303 + dnl Prepare a "--with-" configure option using the lowercase 304 304 + dnl [VARIABLE-PREFIX] name, merging the behaviour of AC_ARG_WITH and 305 305 + dnl PKG_CHECK_MODULES in a single macro. 306 306 + AC_DEFUN([PKG_WITH_MODULES], 307 307 + [ 308 308 + m4_pushdef([with_arg], m4_tolower([$1])) 309 309 + 310 310 + m4_pushdef([description], 311 311 + [m4_default([$5], [build with ]with_arg[ support])]) 312 312 + 313 313 + m4_pushdef([def_arg], [m4_default([$6], [auto])]) 314 314 + m4_pushdef([def_action_if_found], [AS_TR_SH([with_]with_arg)=yes]) 315 315 + m4_pushdef([def_action_if_not_found], [AS_TR_SH([with_]with_arg)=no]) 316 316 + 317 317 + m4_case(def_arg, 318 318 + [yes],[m4_pushdef([with_without], [--without-]with_arg)], 319 319 + [m4_pushdef([with_without],[--with-]with_arg)]) 320 320 + 321 321 + AC_ARG_WITH(with_arg, 322 322 + AS_HELP_STRING(with_without, description[ @<:@default=]def_arg[@:>@]),, 323 323 + [AS_TR_SH([with_]with_arg)=def_arg]) 324 324 + 325 325 + AS_CASE([$AS_TR_SH([with_]with_arg)], 326 326 + [yes],[PKG_CHECK_MODULES([$1],[$2],$3,$4)], 327 327 + [auto],[PKG_CHECK_MODULES([$1],[$2], 328 328 + [m4_n([def_action_if_found]) $3], 329 329 + [m4_n([def_action_if_not_found]) $4])]) 330 330 + 331 331 + m4_popdef([with_arg]) 332 332 + m4_popdef([description]) 333 333 + m4_popdef([def_arg]) 334 334 + 335 335 + ])dnl PKG_WITH_MODULES 336 336 + 337 337 + dnl PKG_HAVE_WITH_MODULES(VARIABLE-PREFIX, MODULES, 338 338 + dnl [DESCRIPTION], [DEFAULT]) 339 339 + dnl ----------------------------------------------- 340 340 + dnl 341 341 + dnl Convenience macro to trigger AM_CONDITIONAL after PKG_WITH_MODULES 342 342 + dnl check._[VARIABLE-PREFIX] is exported as make variable. 343 343 + AC_DEFUN([PKG_HAVE_WITH_MODULES], 344 344 + [ 345 345 + PKG_WITH_MODULES([$1],[$2],,,[$3],[$4]) 346 346 + 347 347 + AM_CONDITIONAL([HAVE_][$1], 348 348 + [test "$AS_TR_SH([with_]m4_tolower([$1]))" = "yes"]) 349 349 + ])dnl PKG_HAVE_WITH_MODULES 350 350 + 351 351 + dnl PKG_HAVE_DEFINE_WITH_MODULES(VARIABLE-PREFIX, MODULES, 352 352 + dnl [DESCRIPTION], [DEFAULT]) 353 353 + dnl ------------------------------------------------------ 354 354 + dnl 355 355 + dnl Convenience macro to run AM_CONDITIONAL and AC_DEFINE after 356 356 + dnl PKG_WITH_MODULES check. HAVE_[VARIABLE-PREFIX] is exported as make 357 357 + dnl and preprocessor variable. 358 358 + AC_DEFUN([PKG_HAVE_DEFINE_WITH_MODULES], 359 359 + [ 360 360 + PKG_HAVE_WITH_MODULES([$1],[$2],[$3],[$4]) 361 361 + 362 362 + AS_IF([test "$AS_TR_SH([with_]m4_tolower([$1]))" = "yes"], 363 363 + [AC_DEFINE([HAVE_][$1], 1, [Enable ]m4_tolower([$1])[ support])]) 364 364 + ])dnl PKG_HAVE_DEFINE_WITH_MODULES 365 365 + 298 366 # Copyright (C) 2002-2012 Free Software Foundation, Inc. 299 367 # 300 368 # This file is free software; the Free Software Foundation ··· 1318 1386 1319 1387 dnl xorg-macros.m4. Generated from xorg-macros.m4.in xorgversion.m4 by configure. 1320 1388 dnl 1321 1321 - dnl Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved. 1389 1389 + dnl Copyright (c) 2005, 2023, Oracle and/or its affiliates. 1322 1390 dnl 1323 1391 dnl Permission is hereby granted, free of charge, to any person obtaining a 1324 1392 dnl copy of this software and associated documentation files (the "Software"), ··· 1355 1423 # See the "minimum version" comment for each macro you use to see what 1356 1424 # version you require. 1357 1425 m4_defun([XORG_MACROS_VERSION],[ 1358 1358 - m4_define([vers_have], [1.19.2]) 1426 1426 + m4_define([vers_have], [1.20.1]) 1359 1427 m4_define([maj_have], m4_substr(vers_have, 0, m4_index(vers_have, [.]))) 1360 1428 m4_define([maj_needed], m4_substr([$1], 0, m4_index([$1], [.]))) 1361 1429 m4_if(m4_cmp(maj_have, maj_needed), 0,, ··· 1376 1444 # such as man pages and config files 1377 1445 AC_DEFUN([XORG_PROG_RAWCPP],[ 1378 1446 AC_REQUIRE([AC_PROG_CPP]) 1379 1379 - AC_PATH_PROGS(RAWCPP, [cpp], [${CPP}], 1447 1447 + AC_PATH_TOOL(RAWCPP, [cpp], [${CPP}], 1380 1448 [$PATH:/bin:/usr/bin:/usr/lib:/usr/libexec:/usr/ccs/lib:/usr/ccs/lbin:/lib]) 1381 1449 1382 1450 # Check for flag to avoid builtin definitions - assumes unix is predefined, ··· 1402 1470 1403 1471 AC_MSG_CHECKING([if $RAWCPP requires -traditional]) 1404 1472 AC_LANG_CONFTEST([AC_LANG_SOURCE([[Does cpp preserve "whitespace"?]])]) 1405 1405 - if test `${RAWCPP} < conftest.$ac_ext | grep -c 'preserve \"'` -eq 1 ; then 1473 1473 + if test `${RAWCPP} < conftest.$ac_ext | grep -c 'preserve "'` -eq 1 ; then 1406 1474 AC_MSG_RESULT([no]) 1407 1475 else 1408 1408 - if test `${RAWCPP} -traditional < conftest.$ac_ext | grep -c 'preserve \"'` -eq 1 ; then 1476 1476 + if test `${RAWCPP} -traditional < conftest.$ac_ext | grep -c 'preserve "'` -eq 1 ; then 1409 1477 TRADITIONALCPPFLAGS="-traditional" 1410 1478 RAWCPPFLAGS="${RAWCPPFLAGS} -traditional" 1411 1479 AC_MSG_RESULT([yes]) ··· 1686 1754 # Documentation tools are not always available on all platforms and sometimes 1687 1755 # not at the appropriate level. This macro enables a module to test for the 1688 1756 # presence of the tool and obtain it's path in separate variables. Coupled with 1689 1689 - # the --with-xmlto option, it allows maximum flexibilty in making decisions 1757 1757 + # the --with-xmlto option, it allows maximum flexibility in making decisions 1690 1758 # as whether or not to use the xmlto package. When DEFAULT is not specified, 1691 1759 # --with-xmlto assumes 'auto'. 1692 1760 # ··· 1900 1968 # Documentation tools are not always available on all platforms and sometimes 1901 1969 # not at the appropriate level. This macro enables a module to test for the 1902 1970 # presence of the tool and obtain it's path in separate variables. Coupled with 1903 1903 - # the --with-asciidoc option, it allows maximum flexibilty in making decisions 1971 1971 + # the --with-asciidoc option, it allows maximum flexibility in making decisions 1904 1972 # as whether or not to use the asciidoc package. When DEFAULT is not specified, 1905 1973 # --with-asciidoc assumes 'auto'. 1906 1974 # ··· 1970 2038 # Documentation tools are not always available on all platforms and sometimes 1971 2039 # not at the appropriate level. This macro enables a module to test for the 1972 2040 # presence of the tool and obtain it's path in separate variables. Coupled with 1973 1973 - # the --with-doxygen option, it allows maximum flexibilty in making decisions 2041 2041 + # the --with-doxygen option, it allows maximum flexibility in making decisions 1974 2042 # as whether or not to use the doxygen package. When DEFAULT is not specified, 1975 2043 # --with-doxygen assumes 'auto'. 1976 2044 # ··· 2054 2122 # Documentation tools are not always available on all platforms and sometimes 2055 2123 # not at the appropriate level. This macro enables a module to test for the 2056 2124 # presence of the tool and obtain it's path in separate variables. Coupled with 2057 2057 - # the --with-groff option, it allows maximum flexibilty in making decisions 2125 2125 + # the --with-groff option, it allows maximum flexibility in making decisions 2058 2126 # as whether or not to use the groff package. When DEFAULT is not specified, 2059 2127 # --with-groff assumes 'auto'. 2060 2128 # ··· 2162 2230 # Documentation tools are not always available on all platforms and sometimes 2163 2231 # not at the appropriate level. This macro enables a module to test for the 2164 2232 # presence of the tool and obtain it's path in separate variables. Coupled with 2165 2165 - # the --with-fop option, it allows maximum flexibilty in making decisions 2233 2233 + # the --with-fop option, it allows maximum flexibility in making decisions 2166 2234 # as whether or not to use the fop package. When DEFAULT is not specified, 2167 2235 # --with-fop assumes 'auto'. 2168 2236 # ··· 2256 2324 # Documentation tools are not always available on all platforms and sometimes 2257 2325 # not at the appropriate level. This macro enables a module to test for the 2258 2326 # presence of the tool and obtain it's path in separate variables. Coupled with 2259 2259 - # the --with-ps2pdf option, it allows maximum flexibilty in making decisions 2327 2327 + # the --with-ps2pdf option, it allows maximum flexibility in making decisions 2260 2328 # as whether or not to use the ps2pdf package. When DEFAULT is not specified, 2261 2329 # --with-ps2pdf assumes 'auto'. 2262 2330 # ··· 2311 2379 # not at the appropriate level. This macro enables a builder to skip all 2312 2380 # documentation targets except traditional man pages. 2313 2381 # Combined with the specific tool checking macros XORG_WITH_*, it provides 2314 2314 - # maximum flexibilty in controlling documentation building. 2382 2382 + # maximum flexibility in controlling documentation building. 2315 2383 # Refer to: 2316 2384 # XORG_WITH_XMLTO --with-xmlto 2317 2385 # XORG_WITH_ASCIIDOC --with-asciidoc ··· 2344 2412 # 2345 2413 # This macro enables a builder to skip all developer documentation. 2346 2414 # Combined with the specific tool checking macros XORG_WITH_*, it provides 2347 2347 - # maximum flexibilty in controlling documentation building. 2415 2415 + # maximum flexibility in controlling documentation building. 2348 2416 # Refer to: 2349 2417 # XORG_WITH_XMLTO --with-xmlto 2350 2418 # XORG_WITH_ASCIIDOC --with-asciidoc ··· 2377 2445 # 2378 2446 # This macro enables a builder to skip all functional specification targets. 2379 2447 # Combined with the specific tool checking macros XORG_WITH_*, it provides 2380 2380 - # maximum flexibilty in controlling documentation building. 2448 2448 + # maximum flexibility in controlling documentation building. 2381 2449 # Refer to: 2382 2450 # XORG_WITH_XMLTO --with-xmlto 2383 2451 # XORG_WITH_ASCIIDOC --with-asciidoc ··· 2852 2920 AC_DEFUN([XORG_COMPILER_BRAND], [ 2853 2921 AC_LANG_CASE( 2854 2922 [C], [ 2855 2855 - AC_REQUIRE([AC_PROG_CC_C99]) 2923 2923 + dnl autoconf-2.70 folded AC_PROG_CC_C99 into AC_PROG_CC 2924 2924 + dnl and complains that AC_PROG_CC_C99 is obsolete 2925 2925 + m4_version_prereq([2.70], 2926 2926 + [AC_REQUIRE([AC_PROG_CC])], 2927 2927 + [AC_REQUIRE([AC_PROG_CC_C99])]) 2856 2928 ], 2857 2929 [C++], [ 2858 2930 AC_REQUIRE([AC_PROG_CXX]) ··· 2868 2940 # Minimum version: 1.16.0 2869 2941 # 2870 2942 # Test if the compiler works when passed the given flag as a command line argument. 2871 2871 - # If it succeeds, the flag is appeneded to the given variable. If not, it tries the 2943 2943 + # If it succeeds, the flag is appended to the given variable. If not, it tries the 2872 2944 # next flag in the list until there are no more options. 2873 2945 # 2874 2946 # Note that this does not guarantee that the compiler supports the flag as some ··· 2884 2956 2885 2957 AC_LANG_CASE( 2886 2958 [C], [ 2887 2887 - AC_REQUIRE([AC_PROG_CC_C99]) 2959 2959 + dnl autoconf-2.70 folded AC_PROG_CC_C99 into AC_PROG_CC 2960 2960 + dnl and complains that AC_PROG_CC_C99 is obsolete 2961 2961 + m4_version_prereq([2.70], 2962 2962 + [AC_REQUIRE([AC_PROG_CC])], 2963 2963 + [AC_REQUIRE([AC_PROG_CC_C99])]) 2888 2964 define([PREFIX], [C]) 2889 2965 define([CACHE_PREFIX], [cc]) 2890 2966 define([COMPILER], [$CC]) ··· 3025 3101 # XORG_TESTSET_CFLAG([[BASE_]PREFIX[FLAGS]], [-Wcast-align]) 3026 3102 # XORG_TESTSET_CFLAG([[BASE_]PREFIX[FLAGS]], [-Wcast-qual]) 3027 3103 3028 3028 - # Turn some warnings into errors, so we don't accidently get successful builds 3104 3104 + # Turn some warnings into errors, so we don't accidentally get successful builds 3029 3105 # when there are problems that should be fixed. 3030 3106 3031 3107 if test "x$SELECTIVE_WERROR" = "xyes" ; then ··· 3134 3210 AC_LANG_CASE([C], AC_SUBST([CWARNFLAGS])) 3135 3211 ]) # XORG_STRICT_OPTION 3136 3212 3213 3213 + # XORG_DEFAULT_NOCODE_OPTIONS 3214 3214 + # --------------------------- 3215 3215 + # Minimum version: 1.20.0 3216 3216 + # 3217 3217 + # Defines default options for X.Org modules which don't compile code, 3218 3218 + # such as fonts, bitmaps, cursors, and docs. 3219 3219 + # 3220 3220 + AC_DEFUN([XORG_DEFAULT_NOCODE_OPTIONS], [ 3221 3221 + AC_REQUIRE([AC_PROG_INSTALL]) 3222 3222 + XORG_RELEASE_VERSION 3223 3223 + XORG_CHANGELOG 3224 3224 + XORG_INSTALL 3225 3225 + XORG_MANPAGE_SECTIONS 3226 3226 + m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])], 3227 3227 + [AC_SUBST([AM_DEFAULT_VERBOSITY], [1])]) 3228 3228 + ]) # XORG_DEFAULT_NOCODE_OPTIONS 3229 3229 + 3137 3230 # XORG_DEFAULT_OPTIONS 3138 3231 # -------------------- 3139 3232 # Minimum version: 1.3.0 3140 3233 # 3141 3141 - # Defines default options for X.Org modules. 3234 3234 + # Defines default options for X.Org modules which compile code. 3142 3235 # 3143 3236 AC_DEFUN([XORG_DEFAULT_OPTIONS], [ 3144 3237 AC_REQUIRE([AC_PROG_INSTALL]) 3145 3238 XORG_COMPILER_FLAGS 3146 3239 XORG_CWARNFLAGS 3147 3240 XORG_STRICT_OPTION 3148 3148 - XORG_RELEASE_VERSION 3149 3149 - XORG_CHANGELOG 3150 3150 - XORG_INSTALL 3151 3151 - XORG_MANPAGE_SECTIONS 3152 3152 - m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])], 3153 3153 - [AC_SUBST([AM_DEFAULT_VERBOSITY], [1])]) 3241 3241 + XORG_DEFAULT_NOCODE_OPTIONS 3154 3242 ]) # XORG_DEFAULT_OPTIONS 3155 3243 3156 3244 # XORG_INSTALL()

+7 -4

app/xkbevd/compile

reviewed

··· 1 1 #! /bin/sh 2 2 # Wrapper for compilers which do not understand '-c -o'. 3 3 4 4 - scriptversion=2018-03-07.03; # UTC 4 4 + scriptversion=2024-06-19.01; # UTC 5 5 6 6 - # Copyright (C) 1999-2021 Free Software Foundation, Inc. 6 6 + # Copyright (C) 1999-2024 Free Software Foundation, Inc. 7 7 # Written by Tom Tromey <tromey@cygnus.com>. 8 8 # 9 9 # This program is free software; you can redistribute it and/or modify ··· 143 143 # configure might choose to run compile as 'compile cc -o foo foo.c'. 144 144 eat=1 145 145 case $2 in 146 146 - *.o | *.[oO][bB][jJ]) 146 146 + *.o | *.lo | *.[oO][bB][jJ]) 147 147 func_file_conv "$2" 148 148 set x "$@" -Fo"$file" 149 149 shift ··· 248 248 right script to run: please start by reading the file 'INSTALL'. 249 249 250 250 Report bugs to <bug-automake@gnu.org>. 251 251 + GNU Automake home page: <https://www.gnu.org/software/automake/>. 252 252 + General help using GNU software: <https://www.gnu.org/gethelp/>. 251 253 EOF 252 254 exit $? 253 255 ;; 254 256 -v | --v*) 255 255 - echo "compile $scriptversion" 257 257 + echo "compile (GNU Automake) $scriptversion" 256 258 exit $? 257 259 ;; 258 260 cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \ 261 261 + clang-cl | *[/\\]clang-cl | clang-cl.exe | *[/\\]clang-cl.exe | \ 259 262 icl | *[/\\]icl | icl.exe | *[/\\]icl.exe ) 260 263 func_cl_wrapper "$@" # Doesn't return... 261 264 ;;

+1028 -753

app/xkbevd/config.guess

reviewed

··· 1 1 #! /bin/sh 2 2 # Attempt to guess a canonical system name. 3 3 - # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 4 4 - # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 5 5 - # 2011, 2012 Free Software Foundation, Inc. 3 3 + # Copyright 1992-2024 Free Software Foundation, Inc. 6 4 7 7 - timestamp='2012-09-25' 5 5 + # shellcheck disable=SC2006,SC2268 # see below for rationale 6 6 + 7 7 + timestamp='2024-01-01' 8 8 9 9 # This file is free software; you can redistribute it and/or modify it 10 10 # under the terms of the GNU General Public License as published by 11 11 - # the Free Software Foundation; either version 2 of the License, or 11 11 + # the Free Software Foundation, either version 3 of the License, or 12 12 # (at your option) any later version. 13 13 # 14 14 # This program is distributed in the hope that it will be useful, but ··· 17 17 # General Public License for more details. 18 18 # 19 19 # You should have received a copy of the GNU General Public License 20 20 - # along with this program; if not, see <http://www.gnu.org/licenses/>. 20 20 + # along with this program; if not, see <https://www.gnu.org/licenses/>. 21 21 # 22 22 # As a special exception to the GNU General Public License, if you 23 23 # distribute this file as part of a program that contains a 24 24 # configuration script generated by Autoconf, you may include it under 25 25 - # the same distribution terms that you use for the rest of that program. 26 26 - 27 27 - 28 28 - # Originally written by Per Bothner. Please send patches (context 29 29 - # diff format) to <config-patches@gnu.org> and include a ChangeLog 30 30 - # entry. 25 25 + # the same distribution terms that you use for the rest of that 26 26 + # program. This Exception is an additional permission under section 7 27 27 + # of the GNU General Public License, version 3 ("GPLv3"). 31 28 # 32 32 - # This script attempts to guess a canonical system name similar to 33 33 - # config.sub. If it succeeds, it prints the system name on stdout, and 34 34 - # exits with 0. Otherwise, it exits with 1. 29 29 + # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. 35 30 # 36 31 # You can get the latest version of this script from: 37 37 - # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD 32 32 + # https://git.savannah.gnu.org/cgit/config.git/plain/config.guess 33 33 + # 34 34 + # Please send patches to <config-patches@gnu.org>. 35 35 + 36 36 + 37 37 + # The "shellcheck disable" line above the timestamp inhibits complaints 38 38 + # about features and limitations of the classic Bourne shell that were 39 39 + # superseded or lifted in POSIX. However, this script identifies a wide 40 40 + # variety of pre-POSIX systems that do not have POSIX shells at all, and 41 41 + # even some reasonably current systems (Solaris 10 as case-in-point) still 42 42 + # have a pre-POSIX /bin/sh. 43 43 + 38 44 39 45 me=`echo "$0" | sed -e 's,.*/,,'` 40 46 41 47 usage="\ 42 48 Usage: $0 [OPTION] 43 49 44 44 - Output the configuration name of the system \`$me' is run on. 50 50 + Output the configuration name of the system '$me' is run on. 45 51 46 46 - Operation modes: 52 52 + Options: 47 53 -h, --help print this help, then exit 48 54 -t, --time-stamp print date of last modification, then exit 49 55 -v, --version print version number, then exit ··· 54 60 GNU config.guess ($timestamp) 55 61 56 62 Originally written by Per Bothner. 57 57 - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 58 58 - 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 59 59 - Free Software Foundation, Inc. 63 63 + Copyright 1992-2024 Free Software Foundation, Inc. 60 64 61 65 This is free software; see the source for copying conditions. There is NO 62 66 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." 63 67 64 68 help=" 65 65 - Try \`$me --help' for more information." 69 69 + Try '$me --help' for more information." 66 70 67 71 # Parse command line 68 72 while test $# -gt 0 ; do ··· 90 94 exit 1 91 95 fi 92 96 93 93 - trap 'exit 1' 1 2 15 97 97 + # Just in case it came from the environment. 98 98 + GUESS= 94 99 95 100 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a 96 101 # compiler to aid in system detection is discouraged as it requires 97 102 # temporary files to be created and, as you can see below, it is a 98 103 # headache to deal with in a portable fashion. 99 104 100 100 - # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still 101 101 - # use `HOST_CC' if defined, but it is deprecated. 105 105 + # Historically, 'CC_FOR_BUILD' used to be named 'HOST_CC'. We still 106 106 + # use 'HOST_CC' if defined, but it is deprecated. 102 107 103 108 # Portable tmp directory creation inspired by the Autoconf team. 104 109 105 105 - set_cc_for_build=' 106 106 - trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; 107 107 - trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; 108 108 - : ${TMPDIR=/tmp} ; 109 109 - { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || 110 110 - { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || 111 111 - { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || 112 112 - { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; 113 113 - dummy=$tmp/dummy ; 114 114 - tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; 115 115 - case $CC_FOR_BUILD,$HOST_CC,$CC in 116 116 - ,,) echo "int x;" > $dummy.c ; 117 117 - for c in cc gcc c89 c99 ; do 118 118 - if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then 119 119 - CC_FOR_BUILD="$c"; break ; 120 120 - fi ; 121 121 - done ; 122 122 - if test x"$CC_FOR_BUILD" = x ; then 123 123 - CC_FOR_BUILD=no_compiler_found ; 124 124 - fi 125 125 - ;; 126 126 - ,,*) CC_FOR_BUILD=$CC ;; 127 127 - ,*,*) CC_FOR_BUILD=$HOST_CC ;; 128 128 - esac ; set_cc_for_build= ;' 110 110 + tmp= 111 111 + # shellcheck disable=SC2172 112 112 + trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15 113 113 + 114 114 + set_cc_for_build() { 115 115 + # prevent multiple calls if $tmp is already set 116 116 + test "$tmp" && return 0 117 117 + : "${TMPDIR=/tmp}" 118 118 + # shellcheck disable=SC2039,SC3028 119 119 + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || 120 120 + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } || 121 121 + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } || 122 122 + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } 123 123 + dummy=$tmp/dummy 124 124 + case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in 125 125 + ,,) echo "int x;" > "$dummy.c" 126 126 + for driver in cc gcc c89 c99 ; do 127 127 + if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then 128 128 + CC_FOR_BUILD=$driver 129 129 + break 130 130 + fi 131 131 + done 132 132 + if test x"$CC_FOR_BUILD" = x ; then 133 133 + CC_FOR_BUILD=no_compiler_found 134 134 + fi 135 135 + ;; 136 136 + ,,*) CC_FOR_BUILD=$CC ;; 137 137 + ,*,*) CC_FOR_BUILD=$HOST_CC ;; 138 138 + esac 139 139 + } 129 140 130 141 # This is needed to find uname on a Pyramid OSx when run in the BSD universe. 131 142 # (ghazi@noc.rutgers.edu 1994-08-24) 132 132 - if (test -f /.attbin/uname) >/dev/null 2>&1 ; then 143 143 + if test -f /.attbin/uname ; then 133 144 PATH=$PATH:/.attbin ; export PATH 134 145 fi 135 146 136 147 UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown 137 148 UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown 138 138 - UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown 149 149 + UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown 139 150 UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown 140 151 152 152 + case $UNAME_SYSTEM in 153 153 + Linux|GNU|GNU/*) 154 154 + LIBC=unknown 155 155 + 156 156 + set_cc_for_build 157 157 + cat <<-EOF > "$dummy.c" 158 158 + #if defined(__ANDROID__) 159 159 + LIBC=android 160 160 + #else 161 161 + #include <features.h> 162 162 + #if defined(__UCLIBC__) 163 163 + LIBC=uclibc 164 164 + #elif defined(__dietlibc__) 165 165 + LIBC=dietlibc 166 166 + #elif defined(__GLIBC__) 167 167 + LIBC=gnu 168 168 + #elif defined(__LLVM_LIBC__) 169 169 + LIBC=llvm 170 170 + #else 171 171 + #include <stdarg.h> 172 172 + /* First heuristic to detect musl libc. */ 173 173 + #ifdef __DEFINED_va_list 174 174 + LIBC=musl 175 175 + #endif 176 176 + #endif 177 177 + #endif 178 178 + EOF 179 179 + cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` 180 180 + eval "$cc_set_libc" 181 181 + 182 182 + # Second heuristic to detect musl libc. 183 183 + if [ "$LIBC" = unknown ] && 184 184 + command -v ldd >/dev/null && 185 185 + ldd --version 2>&1 | grep -q ^musl; then 186 186 + LIBC=musl 187 187 + fi 188 188 + 189 189 + # If the system lacks a compiler, then just pick glibc. 190 190 + # We could probably try harder. 191 191 + if [ "$LIBC" = unknown ]; then 192 192 + LIBC=gnu 193 193 + fi 194 194 + ;; 195 195 + esac 196 196 + 141 197 # Note: order is significant - the case branches are not exclusive. 142 198 143 143 - case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in 199 199 + case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in 144 200 *:NetBSD:*:*) 145 201 # NetBSD (nbsd) targets should (where applicable) match one or 146 202 # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, ··· 152 208 # 153 209 # Note: NetBSD doesn't particularly care about the vendor 154 210 # portion of the name. We always set it to "unknown". 155 155 - sysctl="sysctl -n hw.machine_arch" 156 156 - UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ 157 157 - /usr/sbin/$sysctl 2>/dev/null || echo unknown)` 158 158 - case "${UNAME_MACHINE_ARCH}" in 211 211 + UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ 212 212 + /sbin/sysctl -n hw.machine_arch 2>/dev/null || \ 213 213 + /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \ 214 214 + echo unknown)` 215 215 + case $UNAME_MACHINE_ARCH in 216 216 + aarch64eb) machine=aarch64_be-unknown ;; 159 217 armeb) machine=armeb-unknown ;; 160 218 arm*) machine=arm-unknown ;; 161 219 sh3el) machine=shl-unknown ;; 162 220 sh3eb) machine=sh-unknown ;; 163 221 sh5el) machine=sh5le-unknown ;; 164 164 - *) machine=${UNAME_MACHINE_ARCH}-unknown ;; 222 222 + earmv*) 223 223 + arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` 224 224 + endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` 225 225 + machine=${arch}${endian}-unknown 226 226 + ;; 227 227 + *) machine=$UNAME_MACHINE_ARCH-unknown ;; 165 228 esac 166 229 # The Operating System including object format, if it has switched 167 167 - # to ELF recently, or will in the future. 168 168 - case "${UNAME_MACHINE_ARCH}" in 230 230 + # to ELF recently (or will in the future) and ABI. 231 231 + case $UNAME_MACHINE_ARCH in 232 232 + earm*) 233 233 + os=netbsdelf 234 234 + ;; 169 235 arm*|i386|m68k|ns32k|sh3*|sparc|vax) 170 170 - eval $set_cc_for_build 236 236 + set_cc_for_build 171 237 if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ 172 238 | grep -q __ELF__ 173 239 then ··· 182 248 os=netbsd 183 249 ;; 184 250 esac 251 251 + # Determine ABI tags. 252 252 + case $UNAME_MACHINE_ARCH in 253 253 + earm*) 254 254 + expr='s/^earmv[0-9]/-eabi/;s/eb$//' 255 255 + abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` 256 256 + ;; 257 257 + esac 185 258 # The OS release 186 259 # Debian GNU/NetBSD machines have a different userland, and 187 260 # thus, need a distinct triplet. However, they do not need 188 261 # kernel version information, so it can be replaced with a 189 262 # suitable tag, in the style of linux-gnu. 190 190 - case "${UNAME_VERSION}" in 263 263 + case $UNAME_VERSION in 191 264 Debian*) 192 265 release='-gnu' 193 266 ;; 194 267 *) 195 195 - release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` 268 268 + release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2` 196 269 ;; 197 270 esac 198 271 # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: 199 272 # contains redundant information, the shorter form: 200 273 # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. 201 201 - echo "${machine}-${os}${release}" 202 202 - exit ;; 274 274 + GUESS=$machine-${os}${release}${abi-} 275 275 + ;; 203 276 *:Bitrig:*:*) 204 277 UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` 205 205 - echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE} 206 206 - exit ;; 278 278 + GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE 279 279 + ;; 207 280 *:OpenBSD:*:*) 208 281 UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` 209 209 - echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} 210 210 - exit ;; 282 282 + GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE 283 283 + ;; 284 284 + *:SecBSD:*:*) 285 285 + UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'` 286 286 + GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE 287 287 + ;; 288 288 + *:LibertyBSD:*:*) 289 289 + UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` 290 290 + GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE 291 291 + ;; 292 292 + *:MidnightBSD:*:*) 293 293 + GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE 294 294 + ;; 211 295 *:ekkoBSD:*:*) 212 212 - echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} 213 213 - exit ;; 296 296 + GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE 297 297 + ;; 214 298 *:SolidBSD:*:*) 215 215 - echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} 216 216 - exit ;; 299 299 + GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE 300 300 + ;; 301 301 + *:OS108:*:*) 302 302 + GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE 303 303 + ;; 217 304 macppc:MirBSD:*:*) 218 218 - echo powerpc-unknown-mirbsd${UNAME_RELEASE} 219 219 - exit ;; 305 305 + GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE 306 306 + ;; 220 307 *:MirBSD:*:*) 221 221 - echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} 222 222 - exit ;; 308 308 + GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE 309 309 + ;; 310 310 + *:Sortix:*:*) 311 311 + GUESS=$UNAME_MACHINE-unknown-sortix 312 312 + ;; 313 313 + *:Twizzler:*:*) 314 314 + GUESS=$UNAME_MACHINE-unknown-twizzler 315 315 + ;; 316 316 + *:Redox:*:*) 317 317 + GUESS=$UNAME_MACHINE-unknown-redox 318 318 + ;; 319 319 + mips:OSF1:*.*) 320 320 + GUESS=mips-dec-osf1 321 321 + ;; 223 322 alpha:OSF1:*:*) 323 323 + # Reset EXIT trap before exiting to avoid spurious non-zero exit code. 324 324 + trap '' 0 224 325 case $UNAME_RELEASE in 225 326 *4.0) 226 327 UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ··· 234 335 # covers most systems running today. This code pipes the CPU 235 336 # types through head -n 1, so we only detect the type of CPU 0. 236 337 ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` 237 237 - case "$ALPHA_CPU_TYPE" in 338 338 + case $ALPHA_CPU_TYPE in 238 339 "EV4 (21064)") 239 239 - UNAME_MACHINE="alpha" ;; 340 340 + UNAME_MACHINE=alpha ;; 240 341 "EV4.5 (21064)") 241 241 - UNAME_MACHINE="alpha" ;; 342 342 + UNAME_MACHINE=alpha ;; 242 343 "LCA4 (21066/21068)") 243 243 - UNAME_MACHINE="alpha" ;; 344 344 + UNAME_MACHINE=alpha ;; 244 345 "EV5 (21164)") 245 245 - UNAME_MACHINE="alphaev5" ;; 346 346 + UNAME_MACHINE=alphaev5 ;; 246 347 "EV5.6 (21164A)") 247 247 - UNAME_MACHINE="alphaev56" ;; 348 348 + UNAME_MACHINE=alphaev56 ;; 248 349 "EV5.6 (21164PC)") 249 249 - UNAME_MACHINE="alphapca56" ;; 350 350 + UNAME_MACHINE=alphapca56 ;; 250 351 "EV5.7 (21164PC)") 251 251 - UNAME_MACHINE="alphapca57" ;; 352 352 + UNAME_MACHINE=alphapca57 ;; 252 353 "EV6 (21264)") 253 253 - UNAME_MACHINE="alphaev6" ;; 354 354 + UNAME_MACHINE=alphaev6 ;; 254 355 "EV6.7 (21264A)") 255 255 - UNAME_MACHINE="alphaev67" ;; 356 356 + UNAME_MACHINE=alphaev67 ;; 256 357 "EV6.8CB (21264C)") 257 257 - UNAME_MACHINE="alphaev68" ;; 358 358 + UNAME_MACHINE=alphaev68 ;; 258 359 "EV6.8AL (21264B)") 259 259 - UNAME_MACHINE="alphaev68" ;; 360 360 + UNAME_MACHINE=alphaev68 ;; 260 361 "EV6.8CX (21264D)") 261 261 - UNAME_MACHINE="alphaev68" ;; 362 362 + UNAME_MACHINE=alphaev68 ;; 262 363 "EV6.9A (21264/EV69A)") 263 263 - UNAME_MACHINE="alphaev69" ;; 364 364 + UNAME_MACHINE=alphaev69 ;; 264 365 "EV7 (21364)") 265 265 - UNAME_MACHINE="alphaev7" ;; 366 366 + UNAME_MACHINE=alphaev7 ;; 266 367 "EV7.9 (21364A)") 267 267 - UNAME_MACHINE="alphaev79" ;; 368 368 + UNAME_MACHINE=alphaev79 ;; 268 369 esac 269 370 # A Pn.n version is a patched version. 270 371 # A Vn.n version is a released version. 271 372 # A Tn.n version is a released field test version. 272 373 # A Xn.n version is an unreleased experimental baselevel. 273 374 # 1.2 uses "1.2" for uname -r. 274 274 - echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` 275 275 - # Reset EXIT trap before exiting to avoid spurious non-zero exit code. 276 276 - exitcode=$? 277 277 - trap '' 0 278 278 - exit $exitcode ;; 279 279 - Alpha\ *:Windows_NT*:*) 280 280 - # How do we know it's Interix rather than the generic POSIX subsystem? 281 281 - # Should we change UNAME_MACHINE based on the output of uname instead 282 282 - # of the specific Alpha model? 283 283 - echo alpha-pc-interix 284 284 - exit ;; 285 285 - 21064:Windows_NT:50:3) 286 286 - echo alpha-dec-winnt3.5 287 287 - exit ;; 375 375 + OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` 376 376 + GUESS=$UNAME_MACHINE-dec-osf$OSF_REL 377 377 + ;; 288 378 Amiga*:UNIX_System_V:4.0:*) 289 289 - echo m68k-unknown-sysv4 290 290 - exit ;; 379 379 + GUESS=m68k-unknown-sysv4 380 380 + ;; 291 381 *:[Aa]miga[Oo][Ss]:*:*) 292 292 - echo ${UNAME_MACHINE}-unknown-amigaos 293 293 - exit ;; 382 382 + GUESS=$UNAME_MACHINE-unknown-amigaos 383 383 + ;; 294 384 *:[Mm]orph[Oo][Ss]:*:*) 295 295 - echo ${UNAME_MACHINE}-unknown-morphos 296 296 - exit ;; 385 385 + GUESS=$UNAME_MACHINE-unknown-morphos 386 386 + ;; 297 387 *:OS/390:*:*) 298 298 - echo i370-ibm-openedition 299 299 - exit ;; 388 388 + GUESS=i370-ibm-openedition 389 389 + ;; 300 390 *:z/VM:*:*) 301 301 - echo s390-ibm-zvmoe 302 302 - exit ;; 391 391 + GUESS=s390-ibm-zvmoe 392 392 + ;; 303 393 *:OS400:*:*) 304 304 - echo powerpc-ibm-os400 305 305 - exit ;; 394 394 + GUESS=powerpc-ibm-os400 395 395 + ;; 306 396 arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) 307 307 - echo arm-acorn-riscix${UNAME_RELEASE} 308 308 - exit ;; 397 397 + GUESS=arm-acorn-riscix$UNAME_RELEASE 398 398 + ;; 309 399 arm*:riscos:*:*|arm*:RISCOS:*:*) 310 310 - echo arm-unknown-riscos 311 311 - exit ;; 400 400 + GUESS=arm-unknown-riscos 401 401 + ;; 312 402 SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) 313 313 - echo hppa1.1-hitachi-hiuxmpp 314 314 - exit ;; 403 403 + GUESS=hppa1.1-hitachi-hiuxmpp 404 404 + ;; 315 405 Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) 316 406 # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. 317 317 - if test "`(/bin/universe) 2>/dev/null`" = att ; then 318 318 - echo pyramid-pyramid-sysv3 319 319 - else 320 320 - echo pyramid-pyramid-bsd 321 321 - fi 322 322 - exit ;; 407 407 + case `(/bin/universe) 2>/dev/null` in 408 408 + att) GUESS=pyramid-pyramid-sysv3 ;; 409 409 + *) GUESS=pyramid-pyramid-bsd ;; 410 410 + esac 411 411 + ;; 323 412 NILE*:*:*:dcosx) 324 324 - echo pyramid-pyramid-svr4 325 325 - exit ;; 413 413 + GUESS=pyramid-pyramid-svr4 414 414 + ;; 326 415 DRS?6000:unix:4.0:6*) 327 327 - echo sparc-icl-nx6 328 328 - exit ;; 416 416 + GUESS=sparc-icl-nx6 417 417 + ;; 329 418 DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) 330 419 case `/usr/bin/uname -p` in 331 331 - sparc) echo sparc-icl-nx7; exit ;; 332 332 - esac ;; 420 420 + sparc) GUESS=sparc-icl-nx7 ;; 421 421 + esac 422 422 + ;; 333 423 s390x:SunOS:*:*) 334 334 - echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` 335 335 - exit ;; 424 424 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` 425 425 + GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL 426 426 + ;; 336 427 sun4H:SunOS:5.*:*) 337 337 - echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` 338 338 - exit ;; 428 428 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` 429 429 + GUESS=sparc-hal-solaris2$SUN_REL 430 430 + ;; 339 431 sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) 340 340 - echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` 341 341 - exit ;; 432 432 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` 433 433 + GUESS=sparc-sun-solaris2$SUN_REL 434 434 + ;; 342 435 i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) 343 343 - echo i386-pc-auroraux${UNAME_RELEASE} 344 344 - exit ;; 436 436 + GUESS=i386-pc-auroraux$UNAME_RELEASE 437 437 + ;; 345 438 i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) 346 346 - eval $set_cc_for_build 347 347 - SUN_ARCH="i386" 439 439 + set_cc_for_build 440 440 + SUN_ARCH=i386 348 441 # If there is a compiler, see if it is configured for 64-bit objects. 349 442 # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. 350 443 # This test works for both compilers. 351 351 - if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then 444 444 + if test "$CC_FOR_BUILD" != no_compiler_found; then 352 445 if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ 353 353 - (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ 446 446 + (CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \ 354 447 grep IS_64BIT_ARCH >/dev/null 355 448 then 356 356 - SUN_ARCH="x86_64" 449 449 + SUN_ARCH=x86_64 357 450 fi 358 451 fi 359 359 - echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` 360 360 - exit ;; 452 452 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` 453 453 + GUESS=$SUN_ARCH-pc-solaris2$SUN_REL 454 454 + ;; 361 455 sun4*:SunOS:6*:*) 362 456 # According to config.sub, this is the proper way to canonicalize 363 457 # SunOS6. Hard to guess exactly what SunOS6 will be like, but 364 458 # it's likely to be more like Solaris than SunOS4. 365 365 - echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` 366 366 - exit ;; 459 459 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` 460 460 + GUESS=sparc-sun-solaris3$SUN_REL 461 461 + ;; 367 462 sun4*:SunOS:*:*) 368 368 - case "`/usr/bin/arch -k`" in 463 463 + case `/usr/bin/arch -k` in 369 464 Series*|S4*) 370 465 UNAME_RELEASE=`uname -v` 371 466 ;; 372 467 esac 373 373 - # Japanese Language versions have a version number like `4.1.3-JL'. 374 374 - echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` 375 375 - exit ;; 468 468 + # Japanese Language versions have a version number like '4.1.3-JL'. 469 469 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'` 470 470 + GUESS=sparc-sun-sunos$SUN_REL 471 471 + ;; 376 472 sun3*:SunOS:*:*) 377 377 - echo m68k-sun-sunos${UNAME_RELEASE} 378 378 - exit ;; 473 473 + GUESS=m68k-sun-sunos$UNAME_RELEASE 474 474 + ;; 379 475 sun*:*:4.2BSD:*) 380 476 UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` 381 381 - test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 382 382 - case "`/bin/arch`" in 477 477 + test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 478 478 + case `/bin/arch` in 383 479 sun3) 384 384 - echo m68k-sun-sunos${UNAME_RELEASE} 480 480 + GUESS=m68k-sun-sunos$UNAME_RELEASE 385 481 ;; 386 482 sun4) 387 387 - echo sparc-sun-sunos${UNAME_RELEASE} 483 483 + GUESS=sparc-sun-sunos$UNAME_RELEASE 388 484 ;; 389 485 esac 390 390 - exit ;; 486 486 + ;; 391 487 aushp:SunOS:*:*) 392 392 - echo sparc-auspex-sunos${UNAME_RELEASE} 393 393 - exit ;; 488 488 + GUESS=sparc-auspex-sunos$UNAME_RELEASE 489 489 + ;; 394 490 # The situation for MiNT is a little confusing. The machine name 395 491 # can be virtually everything (everything which is not 396 492 # "atarist" or "atariste" at least should have a processor ··· 400 496 # MiNT. But MiNT is downward compatible to TOS, so this should 401 497 # be no problem. 402 498 atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) 403 403 - echo m68k-atari-mint${UNAME_RELEASE} 404 404 - exit ;; 499 499 + GUESS=m68k-atari-mint$UNAME_RELEASE 500 500 + ;; 405 501 atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) 406 406 - echo m68k-atari-mint${UNAME_RELEASE} 407 407 - exit ;; 502 502 + GUESS=m68k-atari-mint$UNAME_RELEASE 503 503 + ;; 408 504 *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) 409 409 - echo m68k-atari-mint${UNAME_RELEASE} 410 410 - exit ;; 505 505 + GUESS=m68k-atari-mint$UNAME_RELEASE 506 506 + ;; 411 507 milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) 412 412 - echo m68k-milan-mint${UNAME_RELEASE} 413 413 - exit ;; 508 508 + GUESS=m68k-milan-mint$UNAME_RELEASE 509 509 + ;; 414 510 hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) 415 415 - echo m68k-hades-mint${UNAME_RELEASE} 416 416 - exit ;; 511 511 + GUESS=m68k-hades-mint$UNAME_RELEASE 512 512 + ;; 417 513 *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) 418 418 - echo m68k-unknown-mint${UNAME_RELEASE} 419 419 - exit ;; 514 514 + GUESS=m68k-unknown-mint$UNAME_RELEASE 515 515 + ;; 420 516 m68k:machten:*:*) 421 421 - echo m68k-apple-machten${UNAME_RELEASE} 422 422 - exit ;; 517 517 + GUESS=m68k-apple-machten$UNAME_RELEASE 518 518 + ;; 423 519 powerpc:machten:*:*) 424 424 - echo powerpc-apple-machten${UNAME_RELEASE} 425 425 - exit ;; 520 520 + GUESS=powerpc-apple-machten$UNAME_RELEASE 521 521 + ;; 426 522 RISC*:Mach:*:*) 427 427 - echo mips-dec-mach_bsd4.3 428 428 - exit ;; 523 523 + GUESS=mips-dec-mach_bsd4.3 524 524 + ;; 429 525 RISC*:ULTRIX:*:*) 430 430 - echo mips-dec-ultrix${UNAME_RELEASE} 431 431 - exit ;; 526 526 + GUESS=mips-dec-ultrix$UNAME_RELEASE 527 527 + ;; 432 528 VAX*:ULTRIX*:*:*) 433 433 - echo vax-dec-ultrix${UNAME_RELEASE} 434 434 - exit ;; 529 529 + GUESS=vax-dec-ultrix$UNAME_RELEASE 530 530 + ;; 435 531 2020:CLIX:*:* | 2430:CLIX:*:*) 436 436 - echo clipper-intergraph-clix${UNAME_RELEASE} 437 437 - exit ;; 532 532 + GUESS=clipper-intergraph-clix$UNAME_RELEASE 533 533 + ;; 438 534 mips:*:*:UMIPS | mips:*:*:RISCos) 439 439 - eval $set_cc_for_build 440 440 - sed 's/^ //' << EOF >$dummy.c 535 535 + set_cc_for_build 536 536 + sed 's/^ //' << EOF > "$dummy.c" 441 537 #ifdef __cplusplus 442 538 #include <stdio.h> /* for printf() prototype */ 443 539 int main (int argc, char *argv[]) { ··· 446 542 #endif 447 543 #if defined (host_mips) && defined (MIPSEB) 448 544 #if defined (SYSTYPE_SYSV) 449 449 - printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); 545 545 + printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0); 450 546 #endif 451 547 #if defined (SYSTYPE_SVR4) 452 452 - printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); 548 548 + printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0); 453 549 #endif 454 550 #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) 455 455 - printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); 551 551 + printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0); 456 552 #endif 457 553 #endif 458 554 exit (-1); 459 555 } 460 556 EOF 461 461 - $CC_FOR_BUILD -o $dummy $dummy.c && 462 462 - dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && 463 463 - SYSTEM_NAME=`$dummy $dummyarg` && 557 557 + $CC_FOR_BUILD -o "$dummy" "$dummy.c" && 558 558 + dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && 559 559 + SYSTEM_NAME=`"$dummy" "$dummyarg"` && 464 560 { echo "$SYSTEM_NAME"; exit; } 465 465 - echo mips-mips-riscos${UNAME_RELEASE} 466 466 - exit ;; 561 561 + GUESS=mips-mips-riscos$UNAME_RELEASE 562 562 + ;; 467 563 Motorola:PowerMAX_OS:*:*) 468 468 - echo powerpc-motorola-powermax 469 469 - exit ;; 564 564 + GUESS=powerpc-motorola-powermax 565 565 + ;; 470 566 Motorola:*:4.3:PL8-*) 471 471 - echo powerpc-harris-powermax 472 472 - exit ;; 567 567 + GUESS=powerpc-harris-powermax 568 568 + ;; 473 569 Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) 474 474 - echo powerpc-harris-powermax 475 475 - exit ;; 570 570 + GUESS=powerpc-harris-powermax 571 571 + ;; 476 572 Night_Hawk:Power_UNIX:*:*) 477 477 - echo powerpc-harris-powerunix 478 478 - exit ;; 573 573 + GUESS=powerpc-harris-powerunix 574 574 + ;; 479 575 m88k:CX/UX:7*:*) 480 480 - echo m88k-harris-cxux7 481 481 - exit ;; 576 576 + GUESS=m88k-harris-cxux7 577 577 + ;; 482 578 m88k:*:4*:R4*) 483 483 - echo m88k-motorola-sysv4 484 484 - exit ;; 579 579 + GUESS=m88k-motorola-sysv4 580 580 + ;; 485 581 m88k:*:3*:R3*) 486 486 - echo m88k-motorola-sysv3 487 487 - exit ;; 582 582 + GUESS=m88k-motorola-sysv3 583 583 + ;; 488 584 AViiON:dgux:*:*) 489 585 # DG/UX returns AViiON for all architectures 490 586 UNAME_PROCESSOR=`/usr/bin/uname -p` 491 491 - if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] 587 587 + if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110 492 588 then 493 493 - if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ 494 494 - [ ${TARGET_BINARY_INTERFACE}x = x ] 589 589 + if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \ 590 590 + test "$TARGET_BINARY_INTERFACE"x = x 495 591 then 496 496 - echo m88k-dg-dgux${UNAME_RELEASE} 592 592 + GUESS=m88k-dg-dgux$UNAME_RELEASE 497 593 else 498 498 - echo m88k-dg-dguxbcs${UNAME_RELEASE} 594 594 + GUESS=m88k-dg-dguxbcs$UNAME_RELEASE 499 595 fi 500 596 else 501 501 - echo i586-dg-dgux${UNAME_RELEASE} 597 597 + GUESS=i586-dg-dgux$UNAME_RELEASE 502 598 fi 503 503 - exit ;; 599 599 + ;; 504 600 M88*:DolphinOS:*:*) # DolphinOS (SVR3) 505 505 - echo m88k-dolphin-sysv3 506 506 - exit ;; 601 601 + GUESS=m88k-dolphin-sysv3 602 602 + ;; 507 603 M88*:*:R3*:*) 508 604 # Delta 88k system running SVR3 509 509 - echo m88k-motorola-sysv3 510 510 - exit ;; 605 605 + GUESS=m88k-motorola-sysv3 606 606 + ;; 511 607 XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) 512 512 - echo m88k-tektronix-sysv3 513 513 - exit ;; 608 608 + GUESS=m88k-tektronix-sysv3 609 609 + ;; 514 610 Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) 515 515 - echo m68k-tektronix-bsd 516 516 - exit ;; 611 611 + GUESS=m68k-tektronix-bsd 612 612 + ;; 517 613 *:IRIX*:*:*) 518 518 - echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` 519 519 - exit ;; 614 614 + IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'` 615 615 + GUESS=mips-sgi-irix$IRIX_REL 616 616 + ;; 520 617 ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. 521 521 - echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id 522 522 - exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' 618 618 + GUESS=romp-ibm-aix # uname -m gives an 8 hex-code CPU id 619 619 + ;; # Note that: echo "'`uname -s`'" gives 'AIX ' 523 620 i*86:AIX:*:*) 524 524 - echo i386-ibm-aix 525 525 - exit ;; 621 621 + GUESS=i386-ibm-aix 622 622 + ;; 526 623 ia64:AIX:*:*) 527 527 - if [ -x /usr/bin/oslevel ] ; then 624 624 + if test -x /usr/bin/oslevel ; then 528 625 IBM_REV=`/usr/bin/oslevel` 529 626 else 530 530 - IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} 627 627 + IBM_REV=$UNAME_VERSION.$UNAME_RELEASE 531 628 fi 532 532 - echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} 533 533 - exit ;; 629 629 + GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV 630 630 + ;; 534 631 *:AIX:2:3) 535 632 if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then 536 536 - eval $set_cc_for_build 537 537 - sed 's/^ //' << EOF >$dummy.c 633 633 + set_cc_for_build 634 634 + sed 's/^ //' << EOF > "$dummy.c" 538 635 #include <sys/systemcfg.h> 539 636 540 637 main() ··· 545 642 exit(0); 546 643 } 547 644 EOF 548 548 - if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` 645 645 + if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` 549 646 then 550 550 - echo "$SYSTEM_NAME" 647 647 + GUESS=$SYSTEM_NAME 551 648 else 552 552 - echo rs6000-ibm-aix3.2.5 649 649 + GUESS=rs6000-ibm-aix3.2.5 553 650 fi 554 651 elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then 555 555 - echo rs6000-ibm-aix3.2.4 652 652 + GUESS=rs6000-ibm-aix3.2.4 556 653 else 557 557 - echo rs6000-ibm-aix3.2 654 654 + GUESS=rs6000-ibm-aix3.2 558 655 fi 559 559 - exit ;; 656 656 + ;; 560 657 *:AIX:*:[4567]) 561 658 IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` 562 562 - if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then 659 659 + if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then 563 660 IBM_ARCH=rs6000 564 661 else 565 662 IBM_ARCH=powerpc 566 663 fi 567 567 - if [ -x /usr/bin/oslevel ] ; then 568 568 - IBM_REV=`/usr/bin/oslevel` 664 664 + if test -x /usr/bin/lslpp ; then 665 665 + IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \ 666 666 + awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` 569 667 else 570 570 - IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} 668 668 + IBM_REV=$UNAME_VERSION.$UNAME_RELEASE 571 669 fi 572 572 - echo ${IBM_ARCH}-ibm-aix${IBM_REV} 573 573 - exit ;; 670 670 + GUESS=$IBM_ARCH-ibm-aix$IBM_REV 671 671 + ;; 574 672 *:AIX:*:*) 575 575 - echo rs6000-ibm-aix 576 576 - exit ;; 577 577 - ibmrt:4.4BSD:*|romp-ibm:BSD:*) 578 578 - echo romp-ibm-bsd4.4 579 579 - exit ;; 673 673 + GUESS=rs6000-ibm-aix 674 674 + ;; 675 675 + ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) 676 676 + GUESS=romp-ibm-bsd4.4 677 677 + ;; 580 678 ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and 581 581 - echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to 582 582 - exit ;; # report: romp-ibm BSD 4.3 679 679 + GUESS=romp-ibm-bsd$UNAME_RELEASE # 4.3 with uname added to 680 680 + ;; # report: romp-ibm BSD 4.3 583 681 *:BOSX:*:*) 584 584 - echo rs6000-bull-bosx 585 585 - exit ;; 682 682 + GUESS=rs6000-bull-bosx 683 683 + ;; 586 684 DPX/2?00:B.O.S.:*:*) 587 587 - echo m68k-bull-sysv3 588 588 - exit ;; 685 685 + GUESS=m68k-bull-sysv3 686 686 + ;; 589 687 9000/[34]??:4.3bsd:1.*:*) 590 590 - echo m68k-hp-bsd 591 591 - exit ;; 688 688 + GUESS=m68k-hp-bsd 689 689 + ;; 592 690 hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) 593 593 - echo m68k-hp-bsd4.4 594 594 - exit ;; 691 691 + GUESS=m68k-hp-bsd4.4 692 692 + ;; 595 693 9000/[34678]??:HP-UX:*:*) 596 596 - HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` 597 597 - case "${UNAME_MACHINE}" in 598 598 - 9000/31? ) HP_ARCH=m68000 ;; 599 599 - 9000/[34]?? ) HP_ARCH=m68k ;; 694 694 + HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` 695 695 + case $UNAME_MACHINE in 696 696 + 9000/31?) HP_ARCH=m68000 ;; 697 697 + 9000/[34]??) HP_ARCH=m68k ;; 600 698 9000/[678][0-9][0-9]) 601 601 - if [ -x /usr/bin/getconf ]; then 699 699 + if test -x /usr/bin/getconf; then 602 700 sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` 603 701 sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` 604 604 - case "${sc_cpu_version}" in 605 605 - 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 606 606 - 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 702 702 + case $sc_cpu_version in 703 703 + 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 704 704 + 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 607 705 532) # CPU_PA_RISC2_0 608 608 - case "${sc_kernel_bits}" in 609 609 - 32) HP_ARCH="hppa2.0n" ;; 610 610 - 64) HP_ARCH="hppa2.0w" ;; 611 611 - '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 706 706 + case $sc_kernel_bits in 707 707 + 32) HP_ARCH=hppa2.0n ;; 708 708 + 64) HP_ARCH=hppa2.0w ;; 709 709 + '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 612 710 esac ;; 613 711 esac 614 712 fi 615 615 - if [ "${HP_ARCH}" = "" ]; then 616 616 - eval $set_cc_for_build 617 617 - sed 's/^ //' << EOF >$dummy.c 713 713 + if test "$HP_ARCH" = ""; then 714 714 + set_cc_for_build 715 715 + sed 's/^ //' << EOF > "$dummy.c" 618 716 619 717 #define _HPUX_SOURCE 620 718 #include <stdlib.h> ··· 647 745 exit (0); 648 746 } 649 747 EOF 650 650 - (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` 748 748 + (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"` 651 749 test -z "$HP_ARCH" && HP_ARCH=hppa 652 750 fi ;; 653 751 esac 654 654 - if [ ${HP_ARCH} = "hppa2.0w" ] 752 752 + if test "$HP_ARCH" = hppa2.0w 655 753 then 656 656 - eval $set_cc_for_build 754 754 + set_cc_for_build 657 755 658 756 # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating 659 757 # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler ··· 664 762 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess 665 763 # => hppa64-hp-hpux11.23 666 764 667 667 - if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | 765 765 + if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | 668 766 grep -q __LP64__ 669 767 then 670 670 - HP_ARCH="hppa2.0w" 768 768 + HP_ARCH=hppa2.0w 671 769 else 672 672 - HP_ARCH="hppa64" 770 770 + HP_ARCH=hppa64 673 771 fi 674 772 fi 675 675 - echo ${HP_ARCH}-hp-hpux${HPUX_REV} 676 676 - exit ;; 773 773 + GUESS=$HP_ARCH-hp-hpux$HPUX_REV 774 774 + ;; 677 775 ia64:HP-UX:*:*) 678 678 - HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` 679 679 - echo ia64-hp-hpux${HPUX_REV} 680 680 - exit ;; 776 776 + HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` 777 777 + GUESS=ia64-hp-hpux$HPUX_REV 778 778 + ;; 681 779 3050*:HI-UX:*:*) 682 682 - eval $set_cc_for_build 683 683 - sed 's/^ //' << EOF >$dummy.c 780 780 + set_cc_for_build 781 781 + sed 's/^ //' << EOF > "$dummy.c" 684 782 #include <unistd.h> 685 783 int 686 784 main () ··· 705 803 exit (0); 706 804 } 707 805 EOF 708 708 - $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && 806 806 + $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && 709 807 { echo "$SYSTEM_NAME"; exit; } 710 710 - echo unknown-hitachi-hiuxwe2 711 711 - exit ;; 712 712 - 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) 713 713 - echo hppa1.1-hp-bsd 714 714 - exit ;; 808 808 + GUESS=unknown-hitachi-hiuxwe2 809 809 + ;; 810 810 + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) 811 811 + GUESS=hppa1.1-hp-bsd 812 812 + ;; 715 813 9000/8??:4.3bsd:*:*) 716 716 - echo hppa1.0-hp-bsd 717 717 - exit ;; 814 814 + GUESS=hppa1.0-hp-bsd 815 815 + ;; 718 816 *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) 719 719 - echo hppa1.0-hp-mpeix 720 720 - exit ;; 721 721 - hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) 722 722 - echo hppa1.1-hp-osf 723 723 - exit ;; 817 817 + GUESS=hppa1.0-hp-mpeix 818 818 + ;; 819 819 + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) 820 820 + GUESS=hppa1.1-hp-osf 821 821 + ;; 724 822 hp8??:OSF1:*:*) 725 725 - echo hppa1.0-hp-osf 726 726 - exit ;; 823 823 + GUESS=hppa1.0-hp-osf 824 824 + ;; 727 825 i*86:OSF1:*:*) 728 728 - if [ -x /usr/sbin/sysversion ] ; then 729 729 - echo ${UNAME_MACHINE}-unknown-osf1mk 826 826 + if test -x /usr/sbin/sysversion ; then 827 827 + GUESS=$UNAME_MACHINE-unknown-osf1mk 730 828 else 731 731 - echo ${UNAME_MACHINE}-unknown-osf1 829 829 + GUESS=$UNAME_MACHINE-unknown-osf1 732 830 fi 733 733 - exit ;; 831 831 + ;; 734 832 parisc*:Lites*:*:*) 735 735 - echo hppa1.1-hp-lites 736 736 - exit ;; 833 833 + GUESS=hppa1.1-hp-lites 834 834 + ;; 737 835 C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) 738 738 - echo c1-convex-bsd 739 739 - exit ;; 836 836 + GUESS=c1-convex-bsd 837 837 + ;; 740 838 C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) 741 839 if getsysinfo -f scalar_acc 742 840 then echo c32-convex-bsd ··· 744 842 fi 745 843 exit ;; 746 844 C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) 747 747 - echo c34-convex-bsd 748 748 - exit ;; 845 845 + GUESS=c34-convex-bsd 846 846 + ;; 749 847 C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) 750 750 - echo c38-convex-bsd 751 751 - exit ;; 848 848 + GUESS=c38-convex-bsd 849 849 + ;; 752 850 C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) 753 753 - echo c4-convex-bsd 754 754 - exit ;; 851 851 + GUESS=c4-convex-bsd 852 852 + ;; 755 853 CRAY*Y-MP:*:*:*) 756 756 - echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' 757 757 - exit ;; 854 854 + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` 855 855 + GUESS=ymp-cray-unicos$CRAY_REL 856 856 + ;; 758 857 CRAY*[A-Z]90:*:*:*) 759 759 - echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ 858 858 + echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ 760 859 | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ 761 860 -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ 762 861 -e 's/\.[^.]*$/.X/' 763 862 exit ;; 764 863 CRAY*TS:*:*:*) 765 765 - echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' 766 766 - exit ;; 864 864 + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` 865 865 + GUESS=t90-cray-unicos$CRAY_REL 866 866 + ;; 767 867 CRAY*T3E:*:*:*) 768 768 - echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' 769 769 - exit ;; 868 868 + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` 869 869 + GUESS=alphaev5-cray-unicosmk$CRAY_REL 870 870 + ;; 770 871 CRAY*SV1:*:*:*) 771 771 - echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' 772 772 - exit ;; 872 872 + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` 873 873 + GUESS=sv1-cray-unicos$CRAY_REL 874 874 + ;; 773 875 *:UNICOS/mp:*:*) 774 774 - echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' 775 775 - exit ;; 876 876 + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` 877 877 + GUESS=craynv-cray-unicosmp$CRAY_REL 878 878 + ;; 776 879 F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) 777 777 - FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` 778 778 - FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` 779 779 - FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` 780 780 - echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" 781 781 - exit ;; 880 880 + FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` 881 881 + FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` 882 882 + FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` 883 883 + GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} 884 884 + ;; 782 885 5000:UNIX_System_V:4.*:*) 783 783 - FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` 784 784 - FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` 785 785 - echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" 786 786 - exit ;; 886 886 + FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` 887 887 + FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` 888 888 + GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} 889 889 + ;; 787 890 i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) 788 788 - echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} 789 789 - exit ;; 891 891 + GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE 892 892 + ;; 790 893 sparc*:BSD/OS:*:*) 791 791 - echo sparc-unknown-bsdi${UNAME_RELEASE} 792 792 - exit ;; 894 894 + GUESS=sparc-unknown-bsdi$UNAME_RELEASE 895 895 + ;; 793 896 *:BSD/OS:*:*) 794 794 - echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} 795 795 - exit ;; 897 897 + GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE 898 898 + ;; 899 899 + arm:FreeBSD:*:*) 900 900 + UNAME_PROCESSOR=`uname -p` 901 901 + set_cc_for_build 902 902 + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ 903 903 + | grep -q __ARM_PCS_VFP 904 904 + then 905 905 + FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` 906 906 + GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi 907 907 + else 908 908 + FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` 909 909 + GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf 910 910 + fi 911 911 + ;; 796 912 *:FreeBSD:*:*) 797 797 - UNAME_PROCESSOR=`/usr/bin/uname -p` 798 798 - case ${UNAME_PROCESSOR} in 913 913 + UNAME_PROCESSOR=`uname -p` 914 914 + case $UNAME_PROCESSOR in 799 915 amd64) 800 800 - echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; 801 801 - *) 802 802 - echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; 916 916 + UNAME_PROCESSOR=x86_64 ;; 917 917 + i386) 918 918 + UNAME_PROCESSOR=i586 ;; 803 919 esac 804 804 - exit ;; 920 920 + FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` 921 921 + GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL 922 922 + ;; 805 923 i*:CYGWIN*:*) 806 806 - echo ${UNAME_MACHINE}-pc-cygwin 807 807 - exit ;; 924 924 + GUESS=$UNAME_MACHINE-pc-cygwin 925 925 + ;; 808 926 *:MINGW64*:*) 809 809 - echo ${UNAME_MACHINE}-pc-mingw64 810 810 - exit ;; 927 927 + GUESS=$UNAME_MACHINE-pc-mingw64 928 928 + ;; 811 929 *:MINGW*:*) 812 812 - echo ${UNAME_MACHINE}-pc-mingw32 813 813 - exit ;; 814 814 - i*:MSYS*:*) 815 815 - echo ${UNAME_MACHINE}-pc-msys 816 816 - exit ;; 817 817 - i*:windows32*:*) 818 818 - # uname -m includes "-pc" on this system. 819 819 - echo ${UNAME_MACHINE}-mingw32 820 820 - exit ;; 930 930 + GUESS=$UNAME_MACHINE-pc-mingw32 931 931 + ;; 932 932 + *:MSYS*:*) 933 933 + GUESS=$UNAME_MACHINE-pc-msys 934 934 + ;; 821 935 i*:PW*:*) 822 822 - echo ${UNAME_MACHINE}-pc-pw32 823 823 - exit ;; 936 936 + GUESS=$UNAME_MACHINE-pc-pw32 937 937 + ;; 938 938 + *:SerenityOS:*:*) 939 939 + GUESS=$UNAME_MACHINE-pc-serenity 940 940 + ;; 824 941 *:Interix*:*) 825 825 - case ${UNAME_MACHINE} in 942 942 + case $UNAME_MACHINE in 826 943 x86) 827 827 - echo i586-pc-interix${UNAME_RELEASE} 828 828 - exit ;; 944 944 + GUESS=i586-pc-interix$UNAME_RELEASE 945 945 + ;; 829 946 authenticamd | genuineintel | EM64T) 830 830 - echo x86_64-unknown-interix${UNAME_RELEASE} 831 831 - exit ;; 947 947 + GUESS=x86_64-unknown-interix$UNAME_RELEASE 948 948 + ;; 832 949 IA64) 833 833 - echo ia64-unknown-interix${UNAME_RELEASE} 834 834 - exit ;; 950 950 + GUESS=ia64-unknown-interix$UNAME_RELEASE 951 951 + ;; 835 952 esac ;; 836 836 - [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) 837 837 - echo i${UNAME_MACHINE}-pc-mks 838 838 - exit ;; 839 839 - 8664:Windows_NT:*) 840 840 - echo x86_64-pc-mks 841 841 - exit ;; 842 842 - i*:Windows_NT*:* | Pentium*:Windows_NT*:*) 843 843 - # How do we know it's Interix rather than the generic POSIX subsystem? 844 844 - # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we 845 845 - # UNAME_MACHINE based on the output of uname instead of i386? 846 846 - echo i586-pc-interix 847 847 - exit ;; 848 953 i*:UWIN*:*) 849 849 - echo ${UNAME_MACHINE}-pc-uwin 850 850 - exit ;; 954 954 + GUESS=$UNAME_MACHINE-pc-uwin 955 955 + ;; 851 956 amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) 852 852 - echo x86_64-unknown-cygwin 853 853 - exit ;; 854 854 - p*:CYGWIN*:*) 855 855 - echo powerpcle-unknown-cygwin 856 856 - exit ;; 957 957 + GUESS=x86_64-pc-cygwin 958 958 + ;; 857 959 prep*:SunOS:5.*:*) 858 858 - echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` 859 859 - exit ;; 960 960 + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` 961 961 + GUESS=powerpcle-unknown-solaris2$SUN_REL 962 962 + ;; 860 963 *:GNU:*:*) 861 964 # the GNU system 862 862 - echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` 863 863 - exit ;; 965 965 + GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'` 966 966 + GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'` 967 967 + GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL 968 968 + ;; 864 969 *:GNU/*:*:*) 865 970 # other systems with GNU libc and userland 866 866 - echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu 867 867 - exit ;; 868 868 - i*86:Minix:*:*) 869 869 - echo ${UNAME_MACHINE}-pc-minix 870 870 - exit ;; 971 971 + GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"` 972 972 + GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` 973 973 + GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC 974 974 + ;; 975 975 + x86_64:[Mm]anagarm:*:*|i?86:[Mm]anagarm:*:*) 976 976 + GUESS="$UNAME_MACHINE-pc-managarm-mlibc" 977 977 + ;; 978 978 + *:[Mm]anagarm:*:*) 979 979 + GUESS="$UNAME_MACHINE-unknown-managarm-mlibc" 980 980 + ;; 981 981 + *:Minix:*:*) 982 982 + GUESS=$UNAME_MACHINE-unknown-minix 983 983 + ;; 871 984 aarch64:Linux:*:*) 872 872 - echo ${UNAME_MACHINE}-unknown-linux-gnu 873 873 - exit ;; 985 985 + set_cc_for_build 986 986 + CPU=$UNAME_MACHINE 987 987 + LIBCABI=$LIBC 988 988 + if test "$CC_FOR_BUILD" != no_compiler_found; then 989 989 + ABI=64 990 990 + sed 's/^ //' << EOF > "$dummy.c" 991 991 + #ifdef __ARM_EABI__ 992 992 + #ifdef __ARM_PCS_VFP 993 993 + ABI=eabihf 994 994 + #else 995 995 + ABI=eabi 996 996 + #endif 997 997 + #endif 998 998 + EOF 999 999 + cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'` 1000 1000 + eval "$cc_set_abi" 1001 1001 + case $ABI in 1002 1002 + eabi | eabihf) CPU=armv8l; LIBCABI=$LIBC$ABI ;; 1003 1003 + esac 1004 1004 + fi 1005 1005 + GUESS=$CPU-unknown-linux-$LIBCABI 1006 1006 + ;; 874 1007 aarch64_be:Linux:*:*) 875 1008 UNAME_MACHINE=aarch64_be 876 876 - echo ${UNAME_MACHINE}-unknown-linux-gnu 877 877 - exit ;; 1009 1009 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1010 1010 + ;; 878 1011 alpha:Linux:*:*) 879 879 - case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in 1012 1012 + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in 880 1013 EV5) UNAME_MACHINE=alphaev5 ;; 881 1014 EV56) UNAME_MACHINE=alphaev56 ;; 882 1015 PCA56) UNAME_MACHINE=alphapca56 ;; ··· 886 1019 EV68*) UNAME_MACHINE=alphaev68 ;; 887 1020 esac 888 1021 objdump --private-headers /bin/sh | grep -q ld.so.1 889 889 - if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi 890 890 - echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} 891 891 - exit ;; 1022 1022 + if test "$?" = 0 ; then LIBC=gnulibc1 ; fi 1023 1023 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1024 1024 + ;; 1025 1025 + arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*) 1026 1026 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1027 1027 + ;; 892 1028 arm*:Linux:*:*) 893 893 - eval $set_cc_for_build 1029 1029 + set_cc_for_build 894 1030 if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ 895 1031 | grep -q __ARM_EABI__ 896 1032 then 897 897 - echo ${UNAME_MACHINE}-unknown-linux-gnu 1033 1033 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 898 1034 else 899 1035 if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ 900 1036 | grep -q __ARM_PCS_VFP 901 1037 then 902 902 - echo ${UNAME_MACHINE}-unknown-linux-gnueabi 1038 1038 + GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi 903 1039 else 904 904 - echo ${UNAME_MACHINE}-unknown-linux-gnueabihf 1040 1040 + GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf 905 1041 fi 906 1042 fi 907 907 - exit ;; 1043 1043 + ;; 908 1044 avr32*:Linux:*:*) 909 909 - echo ${UNAME_MACHINE}-unknown-linux-gnu 910 910 - exit ;; 1045 1045 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1046 1046 + ;; 911 1047 cris:Linux:*:*) 912 912 - echo ${UNAME_MACHINE}-axis-linux-gnu 913 913 - exit ;; 1048 1048 + GUESS=$UNAME_MACHINE-axis-linux-$LIBC 1049 1049 + ;; 914 1050 crisv32:Linux:*:*) 915 915 - echo ${UNAME_MACHINE}-axis-linux-gnu 916 916 - exit ;; 1051 1051 + GUESS=$UNAME_MACHINE-axis-linux-$LIBC 1052 1052 + ;; 1053 1053 + e2k:Linux:*:*) 1054 1054 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1055 1055 + ;; 917 1056 frv:Linux:*:*) 918 918 - echo ${UNAME_MACHINE}-unknown-linux-gnu 919 919 - exit ;; 1057 1057 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1058 1058 + ;; 920 1059 hexagon:Linux:*:*) 921 921 - echo ${UNAME_MACHINE}-unknown-linux-gnu 922 922 - exit ;; 1060 1060 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1061 1061 + ;; 923 1062 i*86:Linux:*:*) 924 924 - LIBC=gnu 925 925 - eval $set_cc_for_build 926 926 - sed 's/^ //' << EOF >$dummy.c 927 927 - #ifdef __dietlibc__ 928 928 - LIBC=dietlibc 929 929 - #endif 930 930 - EOF 931 931 - eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` 932 932 - echo "${UNAME_MACHINE}-pc-linux-${LIBC}" 933 933 - exit ;; 1063 1063 + GUESS=$UNAME_MACHINE-pc-linux-$LIBC 1064 1064 + ;; 934 1065 ia64:Linux:*:*) 935 935 - echo ${UNAME_MACHINE}-unknown-linux-gnu 936 936 - exit ;; 1066 1066 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1067 1067 + ;; 1068 1068 + k1om:Linux:*:*) 1069 1069 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1070 1070 + ;; 1071 1071 + kvx:Linux:*:*) 1072 1072 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1073 1073 + ;; 1074 1074 + kvx:cos:*:*) 1075 1075 + GUESS=$UNAME_MACHINE-unknown-cos 1076 1076 + ;; 1077 1077 + kvx:mbr:*:*) 1078 1078 + GUESS=$UNAME_MACHINE-unknown-mbr 1079 1079 + ;; 1080 1080 + loongarch32:Linux:*:* | loongarch64:Linux:*:*) 1081 1081 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1082 1082 + ;; 937 1083 m32r*:Linux:*:*) 938 938 - echo ${UNAME_MACHINE}-unknown-linux-gnu 939 939 - exit ;; 1084 1084 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1085 1085 + ;; 940 1086 m68*:Linux:*:*) 941 941 - echo ${UNAME_MACHINE}-unknown-linux-gnu 942 942 - exit ;; 1087 1087 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1088 1088 + ;; 943 1089 mips:Linux:*:* | mips64:Linux:*:*) 944 944 - eval $set_cc_for_build 945 945 - sed 's/^ //' << EOF >$dummy.c 1090 1090 + set_cc_for_build 1091 1091 + IS_GLIBC=0 1092 1092 + test x"${LIBC}" = xgnu && IS_GLIBC=1 1093 1093 + sed 's/^ //' << EOF > "$dummy.c" 946 1094 #undef CPU 947 947 - #undef ${UNAME_MACHINE} 948 948 - #undef ${UNAME_MACHINE}el 1095 1095 + #undef mips 1096 1096 + #undef mipsel 1097 1097 + #undef mips64 1098 1098 + #undef mips64el 1099 1099 + #if ${IS_GLIBC} && defined(_ABI64) 1100 1100 + LIBCABI=gnuabi64 1101 1101 + #else 1102 1102 + #if ${IS_GLIBC} && defined(_ABIN32) 1103 1103 + LIBCABI=gnuabin32 1104 1104 + #else 1105 1105 + LIBCABI=${LIBC} 1106 1106 + #endif 1107 1107 + #endif 1108 1108 + 1109 1109 + #if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 1110 1110 + CPU=mipsisa64r6 1111 1111 + #else 1112 1112 + #if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 1113 1113 + CPU=mipsisa32r6 1114 1114 + #else 1115 1115 + #if defined(__mips64) 1116 1116 + CPU=mips64 1117 1117 + #else 1118 1118 + CPU=mips 1119 1119 + #endif 1120 1120 + #endif 1121 1121 + #endif 1122 1122 + 949 1123 #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) 950 950 - CPU=${UNAME_MACHINE}el 1124 1124 + MIPS_ENDIAN=el 951 1125 #else 952 1126 #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) 953 953 - CPU=${UNAME_MACHINE} 1127 1127 + MIPS_ENDIAN= 954 1128 #else 955 955 - CPU= 1129 1129 + MIPS_ENDIAN= 956 1130 #endif 957 1131 #endif 958 1132 EOF 959 959 - eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` 960 960 - test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } 1133 1133 + cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'` 1134 1134 + eval "$cc_set_vars" 1135 1135 + test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; } 1136 1136 + ;; 1137 1137 + mips64el:Linux:*:*) 1138 1138 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1139 1139 + ;; 1140 1140 + openrisc*:Linux:*:*) 1141 1141 + GUESS=or1k-unknown-linux-$LIBC 961 1142 ;; 962 962 - or32:Linux:*:*) 963 963 - echo ${UNAME_MACHINE}-unknown-linux-gnu 964 964 - exit ;; 1143 1143 + or32:Linux:*:* | or1k*:Linux:*:*) 1144 1144 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1145 1145 + ;; 965 1146 padre:Linux:*:*) 966 966 - echo sparc-unknown-linux-gnu 967 967 - exit ;; 1147 1147 + GUESS=sparc-unknown-linux-$LIBC 1148 1148 + ;; 968 1149 parisc64:Linux:*:* | hppa64:Linux:*:*) 969 969 - echo hppa64-unknown-linux-gnu 970 970 - exit ;; 1150 1150 + GUESS=hppa64-unknown-linux-$LIBC 1151 1151 + ;; 971 1152 parisc:Linux:*:* | hppa:Linux:*:*) 972 1153 # Look for CPU level 973 1154 case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in 974 974 - PA7*) echo hppa1.1-unknown-linux-gnu ;; 975 975 - PA8*) echo hppa2.0-unknown-linux-gnu ;; 976 976 - *) echo hppa-unknown-linux-gnu ;; 1155 1155 + PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;; 1156 1156 + PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;; 1157 1157 + *) GUESS=hppa-unknown-linux-$LIBC ;; 977 1158 esac 978 978 - exit ;; 1159 1159 + ;; 979 1160 ppc64:Linux:*:*) 980 980 - echo powerpc64-unknown-linux-gnu 981 981 - exit ;; 1161 1161 + GUESS=powerpc64-unknown-linux-$LIBC 1162 1162 + ;; 982 1163 ppc:Linux:*:*) 983 983 - echo powerpc-unknown-linux-gnu 984 984 - exit ;; 1164 1164 + GUESS=powerpc-unknown-linux-$LIBC 1165 1165 + ;; 1166 1166 + ppc64le:Linux:*:*) 1167 1167 + GUESS=powerpc64le-unknown-linux-$LIBC 1168 1168 + ;; 1169 1169 + ppcle:Linux:*:*) 1170 1170 + GUESS=powerpcle-unknown-linux-$LIBC 1171 1171 + ;; 1172 1172 + riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*) 1173 1173 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1174 1174 + ;; 985 1175 s390:Linux:*:* | s390x:Linux:*:*) 986 986 - echo ${UNAME_MACHINE}-ibm-linux 987 987 - exit ;; 1176 1176 + GUESS=$UNAME_MACHINE-ibm-linux-$LIBC 1177 1177 + ;; 988 1178 sh64*:Linux:*:*) 989 989 - echo ${UNAME_MACHINE}-unknown-linux-gnu 990 990 - exit ;; 1179 1179 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1180 1180 + ;; 991 1181 sh*:Linux:*:*) 992 992 - echo ${UNAME_MACHINE}-unknown-linux-gnu 993 993 - exit ;; 1182 1182 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1183 1183 + ;; 994 1184 sparc:Linux:*:* | sparc64:Linux:*:*) 995 995 - echo ${UNAME_MACHINE}-unknown-linux-gnu 996 996 - exit ;; 1185 1185 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1186 1186 + ;; 997 1187 tile*:Linux:*:*) 998 998 - echo ${UNAME_MACHINE}-unknown-linux-gnu 999 999 - exit ;; 1188 1188 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1189 1189 + ;; 1000 1190 vax:Linux:*:*) 1001 1001 - echo ${UNAME_MACHINE}-dec-linux-gnu 1002 1002 - exit ;; 1191 1191 + GUESS=$UNAME_MACHINE-dec-linux-$LIBC 1192 1192 + ;; 1003 1193 x86_64:Linux:*:*) 1004 1004 - echo ${UNAME_MACHINE}-unknown-linux-gnu 1005 1005 - exit ;; 1194 1194 + set_cc_for_build 1195 1195 + CPU=$UNAME_MACHINE 1196 1196 + LIBCABI=$LIBC 1197 1197 + if test "$CC_FOR_BUILD" != no_compiler_found; then 1198 1198 + ABI=64 1199 1199 + sed 's/^ //' << EOF > "$dummy.c" 1200 1200 + #ifdef __i386__ 1201 1201 + ABI=x86 1202 1202 + #else 1203 1203 + #ifdef __ILP32__ 1204 1204 + ABI=x32 1205 1205 + #endif 1206 1206 + #endif 1207 1207 + EOF 1208 1208 + cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'` 1209 1209 + eval "$cc_set_abi" 1210 1210 + case $ABI in 1211 1211 + x86) CPU=i686 ;; 1212 1212 + x32) LIBCABI=${LIBC}x32 ;; 1213 1213 + esac 1214 1214 + fi 1215 1215 + GUESS=$CPU-pc-linux-$LIBCABI 1216 1216 + ;; 1006 1217 xtensa*:Linux:*:*) 1007 1007 - echo ${UNAME_MACHINE}-unknown-linux-gnu 1008 1008 - exit ;; 1218 1218 + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC 1219 1219 + ;; 1009 1220 i*86:DYNIX/ptx:4*:*) 1010 1221 # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. 1011 1222 # earlier versions are messed up and put the nodename in both 1012 1223 # sysname and nodename. 1013 1013 - echo i386-sequent-sysv4 1014 1014 - exit ;; 1224 1224 + GUESS=i386-sequent-sysv4 1225 1225 + ;; 1015 1226 i*86:UNIX_SV:4.2MP:2.*) 1016 1227 # Unixware is an offshoot of SVR4, but it has its own version 1017 1228 # number series starting with 2... 1018 1229 # I am not positive that other SVR4 systems won't match this, 1019 1230 # I just have to hope. -- rms. 1020 1231 # Use sysv4.2uw... so that sysv4* matches it. 1021 1021 - echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} 1022 1022 - exit ;; 1232 1232 + GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION 1233 1233 + ;; 1023 1234 i*86:OS/2:*:*) 1024 1024 - # If we were able to find `uname', then EMX Unix compatibility 1235 1235 + # If we were able to find 'uname', then EMX Unix compatibility 1025 1236 # is probably installed. 1026 1026 - echo ${UNAME_MACHINE}-pc-os2-emx 1027 1027 - exit ;; 1237 1237 + GUESS=$UNAME_MACHINE-pc-os2-emx 1238 1238 + ;; 1028 1239 i*86:XTS-300:*:STOP) 1029 1029 - echo ${UNAME_MACHINE}-unknown-stop 1030 1030 - exit ;; 1240 1240 + GUESS=$UNAME_MACHINE-unknown-stop 1241 1241 + ;; 1031 1242 i*86:atheos:*:*) 1032 1032 - echo ${UNAME_MACHINE}-unknown-atheos 1033 1033 - exit ;; 1243 1243 + GUESS=$UNAME_MACHINE-unknown-atheos 1244 1244 + ;; 1034 1245 i*86:syllable:*:*) 1035 1035 - echo ${UNAME_MACHINE}-pc-syllable 1036 1036 - exit ;; 1246 1246 + GUESS=$UNAME_MACHINE-pc-syllable 1247 1247 + ;; 1037 1248 i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) 1038 1038 - echo i386-unknown-lynxos${UNAME_RELEASE} 1039 1039 - exit ;; 1249 1249 + GUESS=i386-unknown-lynxos$UNAME_RELEASE 1250 1250 + ;; 1040 1251 i*86:*DOS:*:*) 1041 1041 - echo ${UNAME_MACHINE}-pc-msdosdjgpp 1042 1042 - exit ;; 1043 1043 - i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) 1044 1044 - UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` 1252 1252 + GUESS=$UNAME_MACHINE-pc-msdosdjgpp 1253 1253 + ;; 1254 1254 + i*86:*:4.*:*) 1255 1255 + UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` 1045 1256 if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then 1046 1046 - echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} 1257 1257 + GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL 1047 1258 else 1048 1048 - echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} 1259 1259 + GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL 1049 1260 fi 1050 1050 - exit ;; 1261 1261 + ;; 1051 1262 i*86:*:5:[678]*) 1052 1263 # UnixWare 7.x, OpenUNIX and OpenServer 6. 1053 1264 case `/bin/uname -X | grep "^Machine"` in ··· 1055 1266 *Pentium) UNAME_MACHINE=i586 ;; 1056 1267 *Pent*|*Celeron) UNAME_MACHINE=i686 ;; 1057 1268 esac 1058 1058 - echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} 1059 1059 - exit ;; 1269 1269 + GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} 1270 1270 + ;; 1060 1271 i*86:*:3.2:*) 1061 1272 if test -f /usr/options/cb.name; then 1062 1273 UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name` 1063 1063 - echo ${UNAME_MACHINE}-pc-isc$UNAME_REL 1274 1274 + GUESS=$UNAME_MACHINE-pc-isc$UNAME_REL 1064 1275 elif /bin/uname -X 2>/dev/null >/dev/null ; then 1065 1276 UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` 1066 1277 (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 ··· 1070 1281 && UNAME_MACHINE=i686 1071 1282 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ 1072 1283 && UNAME_MACHINE=i686 1073 1073 - echo ${UNAME_MACHINE}-pc-sco$UNAME_REL 1284 1284 + GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL 1074 1285 else 1075 1075 - echo ${UNAME_MACHINE}-pc-sysv32 1286 1286 + GUESS=$UNAME_MACHINE-pc-sysv32 1076 1287 fi 1077 1077 - exit ;; 1288 1288 + ;; 1078 1289 pc:*:*:*) 1079 1290 # Left here for compatibility: 1080 1291 # uname -m prints for DJGPP always 'pc', but it prints nothing about 1081 1292 # the processor, so we play safe by assuming i586. 1082 1293 # Note: whatever this is, it MUST be the same as what config.sub 1083 1083 - # prints for the "djgpp" host, or else GDB configury will decide that 1294 1294 + # prints for the "djgpp" host, or else GDB configure will decide that 1084 1295 # this is a cross-build. 1085 1085 - echo i586-pc-msdosdjgpp 1086 1086 - exit ;; 1296 1296 + GUESS=i586-pc-msdosdjgpp 1297 1297 + ;; 1087 1298 Intel:Mach:3*:*) 1088 1088 - echo i386-pc-mach3 1089 1089 - exit ;; 1299 1299 + GUESS=i386-pc-mach3 1300 1300 + ;; 1090 1301 paragon:*:*:*) 1091 1091 - echo i860-intel-osf1 1092 1092 - exit ;; 1302 1302 + GUESS=i860-intel-osf1 1303 1303 + ;; 1093 1304 i860:*:4.*:*) # i860-SVR4 1094 1305 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then 1095 1095 - echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 1306 1306 + GUESS=i860-stardent-sysv$UNAME_RELEASE # Stardent Vistra i860-SVR4 1096 1307 else # Add other i860-SVR4 vendors below as they are discovered. 1097 1097 - echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 1308 1308 + GUESS=i860-unknown-sysv$UNAME_RELEASE # Unknown i860-SVR4 1098 1309 fi 1099 1099 - exit ;; 1310 1310 + ;; 1100 1311 mini*:CTIX:SYS*5:*) 1101 1312 # "miniframe" 1102 1102 - echo m68010-convergent-sysv 1103 1103 - exit ;; 1313 1313 + GUESS=m68010-convergent-sysv 1314 1314 + ;; 1104 1315 mc68k:UNIX:SYSTEM5:3.51m) 1105 1105 - echo m68k-convergent-sysv 1106 1106 - exit ;; 1316 1316 + GUESS=m68k-convergent-sysv 1317 1317 + ;; 1107 1318 M680?0:D-NIX:5.3:*) 1108 1108 - echo m68k-diab-dnix 1109 1109 - exit ;; 1319 1319 + GUESS=m68k-diab-dnix 1320 1320 + ;; 1110 1321 M68*:*:R3V[5678]*:*) 1111 1322 test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 1112 1323 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) ··· 1114 1325 test -r /etc/.relid \ 1115 1326 && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` 1116 1327 /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ 1117 1117 - && { echo i486-ncr-sysv4.3${OS_REL}; exit; } 1328 1328 + && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } 1118 1329 /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ 1119 1119 - && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 1330 1330 + && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; 1120 1331 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) 1121 1332 /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ 1122 1333 && { echo i486-ncr-sysv4; exit; } ;; ··· 1125 1336 test -r /etc/.relid \ 1126 1337 && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` 1127 1338 /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ 1128 1128 - && { echo i486-ncr-sysv4.3${OS_REL}; exit; } 1339 1339 + && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } 1129 1340 /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ 1130 1130 - && { echo i586-ncr-sysv4.3${OS_REL}; exit; } 1341 1341 + && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } 1131 1342 /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ 1132 1132 - && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 1343 1343 + && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; 1133 1344 m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) 1134 1134 - echo m68k-unknown-lynxos${UNAME_RELEASE} 1135 1135 - exit ;; 1345 1345 + GUESS=m68k-unknown-lynxos$UNAME_RELEASE 1346 1346 + ;; 1136 1347 mc68030:UNIX_System_V:4.*:*) 1137 1137 - echo m68k-atari-sysv4 1138 1138 - exit ;; 1348 1348 + GUESS=m68k-atari-sysv4 1349 1349 + ;; 1139 1350 TSUNAMI:LynxOS:2.*:*) 1140 1140 - echo sparc-unknown-lynxos${UNAME_RELEASE} 1141 1141 - exit ;; 1351 1351 + GUESS=sparc-unknown-lynxos$UNAME_RELEASE 1352 1352 + ;; 1142 1353 rs6000:LynxOS:2.*:*) 1143 1143 - echo rs6000-unknown-lynxos${UNAME_RELEASE} 1144 1144 - exit ;; 1354 1354 + GUESS=rs6000-unknown-lynxos$UNAME_RELEASE 1355 1355 + ;; 1145 1356 PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) 1146 1146 - echo powerpc-unknown-lynxos${UNAME_RELEASE} 1147 1147 - exit ;; 1357 1357 + GUESS=powerpc-unknown-lynxos$UNAME_RELEASE 1358 1358 + ;; 1148 1359 SM[BE]S:UNIX_SV:*:*) 1149 1149 - echo mips-dde-sysv${UNAME_RELEASE} 1150 1150 - exit ;; 1360 1360 + GUESS=mips-dde-sysv$UNAME_RELEASE 1361 1361 + ;; 1151 1362 RM*:ReliantUNIX-*:*:*) 1152 1152 - echo mips-sni-sysv4 1153 1153 - exit ;; 1363 1363 + GUESS=mips-sni-sysv4 1364 1364 + ;; 1154 1365 RM*:SINIX-*:*:*) 1155 1155 - echo mips-sni-sysv4 1156 1156 - exit ;; 1366 1366 + GUESS=mips-sni-sysv4 1367 1367 + ;; 1157 1368 *:SINIX-*:*:*) 1158 1369 if uname -p 2>/dev/null >/dev/null ; then 1159 1370 UNAME_MACHINE=`(uname -p) 2>/dev/null` 1160 1160 - echo ${UNAME_MACHINE}-sni-sysv4 1371 1371 + GUESS=$UNAME_MACHINE-sni-sysv4 1161 1372 else 1162 1162 - echo ns32k-sni-sysv 1373 1373 + GUESS=ns32k-sni-sysv 1163 1374 fi 1164 1164 - exit ;; 1165 1165 - PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort 1375 1375 + ;; 1376 1376 + PENTIUM:*:4.0*:*) # Unisys 'ClearPath HMP IX 4000' SVR4/MP effort 1166 1377 # says <Richard.M.Bartel@ccMail.Census.GOV> 1167 1167 - echo i586-unisys-sysv4 1168 1168 - exit ;; 1378 1378 + GUESS=i586-unisys-sysv4 1379 1379 + ;; 1169 1380 *:UNIX_System_V:4*:FTX*) 1170 1381 # From Gerald Hewes <hewes@openmarket.com>. 1171 1382 # How about differentiating between stratus architectures? -djm 1172 1172 - echo hppa1.1-stratus-sysv4 1173 1173 - exit ;; 1383 1383 + GUESS=hppa1.1-stratus-sysv4 1384 1384 + ;; 1174 1385 *:*:*:FTX*) 1175 1386 # From seanf@swdc.stratus.com. 1176 1176 - echo i860-stratus-sysv4 1177 1177 - exit ;; 1387 1387 + GUESS=i860-stratus-sysv4 1388 1388 + ;; 1178 1389 i*86:VOS:*:*) 1179 1390 # From Paul.Green@stratus.com. 1180 1180 - echo ${UNAME_MACHINE}-stratus-vos 1181 1181 - exit ;; 1391 1391 + GUESS=$UNAME_MACHINE-stratus-vos 1392 1392 + ;; 1182 1393 *:VOS:*:*) 1183 1394 # From Paul.Green@stratus.com. 1184 1184 - echo hppa1.1-stratus-vos 1185 1185 - exit ;; 1395 1395 + GUESS=hppa1.1-stratus-vos 1396 1396 + ;; 1186 1397 mc68*:A/UX:*:*) 1187 1187 - echo m68k-apple-aux${UNAME_RELEASE} 1188 1188 - exit ;; 1398 1398 + GUESS=m68k-apple-aux$UNAME_RELEASE 1399 1399 + ;; 1189 1400 news*:NEWS-OS:6*:*) 1190 1190 - echo mips-sony-newsos6 1191 1191 - exit ;; 1401 1401 + GUESS=mips-sony-newsos6 1402 1402 + ;; 1192 1403 R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) 1193 1193 - if [ -d /usr/nec ]; then 1194 1194 - echo mips-nec-sysv${UNAME_RELEASE} 1404 1404 + if test -d /usr/nec; then 1405 1405 + GUESS=mips-nec-sysv$UNAME_RELEASE 1195 1406 else 1196 1196 - echo mips-unknown-sysv${UNAME_RELEASE} 1407 1407 + GUESS=mips-unknown-sysv$UNAME_RELEASE 1197 1408 fi 1198 1198 - exit ;; 1409 1409 + ;; 1199 1410 BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. 1200 1200 - echo powerpc-be-beos 1201 1201 - exit ;; 1411 1411 + GUESS=powerpc-be-beos 1412 1412 + ;; 1202 1413 BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. 1203 1203 - echo powerpc-apple-beos 1204 1204 - exit ;; 1414 1414 + GUESS=powerpc-apple-beos 1415 1415 + ;; 1205 1416 BePC:BeOS:*:*) # BeOS running on Intel PC compatible. 1206 1206 - echo i586-pc-beos 1207 1207 - exit ;; 1417 1417 + GUESS=i586-pc-beos 1418 1418 + ;; 1208 1419 BePC:Haiku:*:*) # Haiku running on Intel PC compatible. 1209 1209 - echo i586-pc-haiku 1210 1210 - exit ;; 1211 1211 - x86_64:Haiku:*:*) 1212 1212 - echo x86_64-unknown-haiku 1213 1213 - exit ;; 1420 1420 + GUESS=i586-pc-haiku 1421 1421 + ;; 1422 1422 + ppc:Haiku:*:*) # Haiku running on Apple PowerPC 1423 1423 + GUESS=powerpc-apple-haiku 1424 1424 + ;; 1425 1425 + *:Haiku:*:*) # Haiku modern gcc (not bound by BeOS compat) 1426 1426 + GUESS=$UNAME_MACHINE-unknown-haiku 1427 1427 + ;; 1214 1428 SX-4:SUPER-UX:*:*) 1215 1215 - echo sx4-nec-superux${UNAME_RELEASE} 1216 1216 - exit ;; 1429 1429 + GUESS=sx4-nec-superux$UNAME_RELEASE 1430 1430 + ;; 1217 1431 SX-5:SUPER-UX:*:*) 1218 1218 - echo sx5-nec-superux${UNAME_RELEASE} 1219 1219 - exit ;; 1432 1432 + GUESS=sx5-nec-superux$UNAME_RELEASE 1433 1433 + ;; 1220 1434 SX-6:SUPER-UX:*:*) 1221 1221 - echo sx6-nec-superux${UNAME_RELEASE} 1222 1222 - exit ;; 1435 1435 + GUESS=sx6-nec-superux$UNAME_RELEASE 1436 1436 + ;; 1223 1437 SX-7:SUPER-UX:*:*) 1224 1224 - echo sx7-nec-superux${UNAME_RELEASE} 1225 1225 - exit ;; 1438 1438 + GUESS=sx7-nec-superux$UNAME_RELEASE 1439 1439 + ;; 1226 1440 SX-8:SUPER-UX:*:*) 1227 1227 - echo sx8-nec-superux${UNAME_RELEASE} 1228 1228 - exit ;; 1441 1441 + GUESS=sx8-nec-superux$UNAME_RELEASE 1442 1442 + ;; 1229 1443 SX-8R:SUPER-UX:*:*) 1230 1230 - echo sx8r-nec-superux${UNAME_RELEASE} 1231 1231 - exit ;; 1444 1444 + GUESS=sx8r-nec-superux$UNAME_RELEASE 1445 1445 + ;; 1446 1446 + SX-ACE:SUPER-UX:*:*) 1447 1447 + GUESS=sxace-nec-superux$UNAME_RELEASE 1448 1448 + ;; 1232 1449 Power*:Rhapsody:*:*) 1233 1233 - echo powerpc-apple-rhapsody${UNAME_RELEASE} 1234 1234 - exit ;; 1450 1450 + GUESS=powerpc-apple-rhapsody$UNAME_RELEASE 1451 1451 + ;; 1235 1452 *:Rhapsody:*:*) 1236 1236 - echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} 1237 1237 - exit ;; 1453 1453 + GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE 1454 1454 + ;; 1455 1455 + arm64:Darwin:*:*) 1456 1456 + GUESS=aarch64-apple-darwin$UNAME_RELEASE 1457 1457 + ;; 1238 1458 *:Darwin:*:*) 1239 1239 - UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown 1459 1459 + UNAME_PROCESSOR=`uname -p` 1240 1460 case $UNAME_PROCESSOR in 1241 1241 - i386) 1242 1242 - eval $set_cc_for_build 1243 1243 - if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then 1244 1244 - if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ 1245 1245 - (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ 1246 1246 - grep IS_64BIT_ARCH >/dev/null 1247 1247 - then 1248 1248 - UNAME_PROCESSOR="x86_64" 1249 1249 - fi 1250 1250 - fi ;; 1251 1461 unknown) UNAME_PROCESSOR=powerpc ;; 1252 1462 esac 1253 1253 - echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} 1254 1254 - exit ;; 1463 1463 + if command -v xcode-select > /dev/null 2> /dev/null && \ 1464 1464 + ! xcode-select --print-path > /dev/null 2> /dev/null ; then 1465 1465 + # Avoid executing cc if there is no toolchain installed as 1466 1466 + # cc will be a stub that puts up a graphical alert 1467 1467 + # prompting the user to install developer tools. 1468 1468 + CC_FOR_BUILD=no_compiler_found 1469 1469 + else 1470 1470 + set_cc_for_build 1471 1471 + fi 1472 1472 + if test "$CC_FOR_BUILD" != no_compiler_found; then 1473 1473 + if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ 1474 1474 + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ 1475 1475 + grep IS_64BIT_ARCH >/dev/null 1476 1476 + then 1477 1477 + case $UNAME_PROCESSOR in 1478 1478 + i386) UNAME_PROCESSOR=x86_64 ;; 1479 1479 + powerpc) UNAME_PROCESSOR=powerpc64 ;; 1480 1480 + esac 1481 1481 + fi 1482 1482 + # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc 1483 1483 + if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ 1484 1484 + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ 1485 1485 + grep IS_PPC >/dev/null 1486 1486 + then 1487 1487 + UNAME_PROCESSOR=powerpc 1488 1488 + fi 1489 1489 + elif test "$UNAME_PROCESSOR" = i386 ; then 1490 1490 + # uname -m returns i386 or x86_64 1491 1491 + UNAME_PROCESSOR=$UNAME_MACHINE 1492 1492 + fi 1493 1493 + GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE 1494 1494 + ;; 1255 1495 *:procnto*:*:* | *:QNX:[0123456789]*:*) 1256 1496 UNAME_PROCESSOR=`uname -p` 1257 1257 - if test "$UNAME_PROCESSOR" = "x86"; then 1497 1497 + if test "$UNAME_PROCESSOR" = x86; then 1258 1498 UNAME_PROCESSOR=i386 1259 1499 UNAME_MACHINE=pc 1260 1500 fi 1261 1261 - echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} 1262 1262 - exit ;; 1501 1501 + GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE 1502 1502 + ;; 1263 1503 *:QNX:*:4*) 1264 1264 - echo i386-pc-qnx 1265 1265 - exit ;; 1266 1266 - NEO-?:NONSTOP_KERNEL:*:*) 1267 1267 - echo neo-tandem-nsk${UNAME_RELEASE} 1268 1268 - exit ;; 1504 1504 + GUESS=i386-pc-qnx 1505 1505 + ;; 1506 1506 + NEO-*:NONSTOP_KERNEL:*:*) 1507 1507 + GUESS=neo-tandem-nsk$UNAME_RELEASE 1508 1508 + ;; 1269 1509 NSE-*:NONSTOP_KERNEL:*:*) 1270 1270 - echo nse-tandem-nsk${UNAME_RELEASE} 1271 1271 - exit ;; 1272 1272 - NSR-?:NONSTOP_KERNEL:*:*) 1273 1273 - echo nsr-tandem-nsk${UNAME_RELEASE} 1274 1274 - exit ;; 1510 1510 + GUESS=nse-tandem-nsk$UNAME_RELEASE 1511 1511 + ;; 1512 1512 + NSR-*:NONSTOP_KERNEL:*:*) 1513 1513 + GUESS=nsr-tandem-nsk$UNAME_RELEASE 1514 1514 + ;; 1515 1515 + NSV-*:NONSTOP_KERNEL:*:*) 1516 1516 + GUESS=nsv-tandem-nsk$UNAME_RELEASE 1517 1517 + ;; 1518 1518 + NSX-*:NONSTOP_KERNEL:*:*) 1519 1519 + GUESS=nsx-tandem-nsk$UNAME_RELEASE 1520 1520 + ;; 1275 1521 *:NonStop-UX:*:*) 1276 1276 - echo mips-compaq-nonstopux 1277 1277 - exit ;; 1522 1522 + GUESS=mips-compaq-nonstopux 1523 1523 + ;; 1278 1524 BS2000:POSIX*:*:*) 1279 1279 - echo bs2000-siemens-sysv 1280 1280 - exit ;; 1525 1525 + GUESS=bs2000-siemens-sysv 1526 1526 + ;; 1281 1527 DS/*:UNIX_System_V:*:*) 1282 1282 - echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} 1283 1283 - exit ;; 1528 1528 + GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE 1529 1529 + ;; 1284 1530 *:Plan9:*:*) 1285 1531 # "uname -m" is not consistent, so use $cputype instead. 386 1286 1532 # is converted to i386 for consistency with other x86 1287 1533 # operating systems. 1288 1288 - if test "$cputype" = "386"; then 1534 1534 + if test "${cputype-}" = 386; then 1289 1535 UNAME_MACHINE=i386 1290 1290 - else 1291 1291 - UNAME_MACHINE="$cputype" 1536 1536 + elif test "x${cputype-}" != x; then 1537 1537 + UNAME_MACHINE=$cputype 1292 1538 fi 1293 1293 - echo ${UNAME_MACHINE}-unknown-plan9 1294 1294 - exit ;; 1539 1539 + GUESS=$UNAME_MACHINE-unknown-plan9 1540 1540 + ;; 1295 1541 *:TOPS-10:*:*) 1296 1296 - echo pdp10-unknown-tops10 1297 1297 - exit ;; 1542 1542 + GUESS=pdp10-unknown-tops10 1543 1543 + ;; 1298 1544 *:TENEX:*:*) 1299 1299 - echo pdp10-unknown-tenex 1300 1300 - exit ;; 1545 1545 + GUESS=pdp10-unknown-tenex 1546 1546 + ;; 1301 1547 KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) 1302 1302 - echo pdp10-dec-tops20 1303 1303 - exit ;; 1548 1548 + GUESS=pdp10-dec-tops20 1549 1549 + ;; 1304 1550 XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) 1305 1305 - echo pdp10-xkl-tops20 1306 1306 - exit ;; 1551 1551 + GUESS=pdp10-xkl-tops20 1552 1552 + ;; 1307 1553 *:TOPS-20:*:*) 1308 1308 - echo pdp10-unknown-tops20 1309 1309 - exit ;; 1554 1554 + GUESS=pdp10-unknown-tops20 1555 1555 + ;; 1310 1556 *:ITS:*:*) 1311 1311 - echo pdp10-unknown-its 1312 1312 - exit ;; 1557 1557 + GUESS=pdp10-unknown-its 1558 1558 + ;; 1313 1559 SEI:*:*:SEIUX) 1314 1314 - echo mips-sei-seiux${UNAME_RELEASE} 1315 1315 - exit ;; 1560 1560 + GUESS=mips-sei-seiux$UNAME_RELEASE 1561 1561 + ;; 1316 1562 *:DragonFly:*:*) 1317 1317 - echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` 1318 1318 - exit ;; 1563 1563 + DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` 1564 1564 + GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL 1565 1565 + ;; 1319 1566 *:*VMS:*:*) 1320 1567 UNAME_MACHINE=`(uname -p) 2>/dev/null` 1321 1321 - case "${UNAME_MACHINE}" in 1322 1322 - A*) echo alpha-dec-vms ; exit ;; 1323 1323 - I*) echo ia64-dec-vms ; exit ;; 1324 1324 - V*) echo vax-dec-vms ; exit ;; 1568 1568 + case $UNAME_MACHINE in 1569 1569 + A*) GUESS=alpha-dec-vms ;; 1570 1570 + I*) GUESS=ia64-dec-vms ;; 1571 1571 + V*) GUESS=vax-dec-vms ;; 1325 1572 esac ;; 1326 1573 *:XENIX:*:SysV) 1327 1327 - echo i386-pc-xenix 1328 1328 - exit ;; 1574 1574 + GUESS=i386-pc-xenix 1575 1575 + ;; 1329 1576 i*86:skyos:*:*) 1330 1330 - echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' 1331 1331 - exit ;; 1577 1577 + SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'` 1578 1578 + GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL 1579 1579 + ;; 1332 1580 i*86:rdos:*:*) 1333 1333 - echo ${UNAME_MACHINE}-pc-rdos 1334 1334 - exit ;; 1335 1335 - i*86:AROS:*:*) 1336 1336 - echo ${UNAME_MACHINE}-pc-aros 1337 1337 - exit ;; 1581 1581 + GUESS=$UNAME_MACHINE-pc-rdos 1582 1582 + ;; 1583 1583 + i*86:Fiwix:*:*) 1584 1584 + GUESS=$UNAME_MACHINE-pc-fiwix 1585 1585 + ;; 1586 1586 + *:AROS:*:*) 1587 1587 + GUESS=$UNAME_MACHINE-unknown-aros 1588 1588 + ;; 1338 1589 x86_64:VMkernel:*:*) 1339 1339 - echo ${UNAME_MACHINE}-unknown-esx 1340 1340 - exit ;; 1590 1590 + GUESS=$UNAME_MACHINE-unknown-esx 1591 1591 + ;; 1592 1592 + amd64:Isilon\ OneFS:*:*) 1593 1593 + GUESS=x86_64-unknown-onefs 1594 1594 + ;; 1595 1595 + *:Unleashed:*:*) 1596 1596 + GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE 1597 1597 + ;; 1598 1598 + *:Ironclad:*:*) 1599 1599 + GUESS=$UNAME_MACHINE-unknown-ironclad 1600 1600 + ;; 1341 1601 esac 1342 1602 1343 1343 - eval $set_cc_for_build 1344 1344 - cat >$dummy.c <<EOF 1603 1603 + # Do we have a guess based on uname results? 1604 1604 + if test "x$GUESS" != x; then 1605 1605 + echo "$GUESS" 1606 1606 + exit 1607 1607 + fi 1608 1608 + 1609 1609 + # No uname command or uname output not recognized. 1610 1610 + set_cc_for_build 1611 1611 + cat > "$dummy.c" <<EOF 1345 1612 #ifdef _SEQUENT_ 1346 1346 - # include <sys/types.h> 1347 1347 - # include <sys/utsname.h> 1613 1613 + #include <sys/types.h> 1614 1614 + #include <sys/utsname.h> 1615 1615 + #endif 1616 1616 + #if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) 1617 1617 + #if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) 1618 1618 + #include <signal.h> 1619 1619 + #if defined(_SIZE_T_) || defined(SIGLOST) 1620 1620 + #include <sys/utsname.h> 1621 1621 + #endif 1622 1622 + #endif 1348 1623 #endif 1349 1624 main () 1350 1625 { ··· 1357 1632 #include <sys/param.h> 1358 1633 printf ("m68k-sony-newsos%s\n", 1359 1634 #ifdef NEWSOS4 1360 1360 - "4" 1635 1635 + "4" 1361 1636 #else 1362 1362 - "" 1363 1363 - #endif 1364 1364 - ); exit (0); 1637 1637 + "" 1365 1638 #endif 1639 1639 + ); exit (0); 1366 1640 #endif 1367 1367 - 1368 1368 - #if defined (__arm) && defined (__acorn) && defined (__unix) 1369 1369 - printf ("arm-acorn-riscix\n"); exit (0); 1370 1370 - #endif 1371 1371 - 1372 1372 - #if defined (hp300) && !defined (hpux) 1373 1373 - printf ("m68k-hp-bsd\n"); exit (0); 1374 1641 #endif 1375 1642 1376 1643 #if defined (NeXT) ··· 1412 1679 #endif 1413 1680 1414 1681 #if defined (_SEQUENT_) 1415 1415 - struct utsname un; 1682 1682 + struct utsname un; 1416 1683 1417 1417 - uname(&un); 1418 1418 - 1419 1419 - if (strncmp(un.version, "V2", 2) == 0) { 1420 1420 - printf ("i386-sequent-ptx2\n"); exit (0); 1421 1421 - } 1422 1422 - if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ 1423 1423 - printf ("i386-sequent-ptx1\n"); exit (0); 1424 1424 - } 1425 1425 - printf ("i386-sequent-ptx\n"); exit (0); 1426 1426 - 1684 1684 + uname(&un); 1685 1685 + if (strncmp(un.version, "V2", 2) == 0) { 1686 1686 + printf ("i386-sequent-ptx2\n"); exit (0); 1687 1687 + } 1688 1688 + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ 1689 1689 + printf ("i386-sequent-ptx1\n"); exit (0); 1690 1690 + } 1691 1691 + printf ("i386-sequent-ptx\n"); exit (0); 1427 1692 #endif 1428 1693 1429 1694 #if defined (vax) 1430 1430 - # if !defined (ultrix) 1431 1431 - # include <sys/param.h> 1432 1432 - # if defined (BSD) 1433 1433 - # if BSD == 43 1434 1434 - printf ("vax-dec-bsd4.3\n"); exit (0); 1435 1435 - # else 1436 1436 - # if BSD == 199006 1437 1437 - printf ("vax-dec-bsd4.3reno\n"); exit (0); 1438 1438 - # else 1439 1439 - printf ("vax-dec-bsd\n"); exit (0); 1440 1440 - # endif 1441 1441 - # endif 1442 1442 - # else 1443 1443 - printf ("vax-dec-bsd\n"); exit (0); 1444 1444 - # endif 1445 1445 - # else 1446 1446 - printf ("vax-dec-ultrix\n"); exit (0); 1447 1447 - # endif 1695 1695 + #if !defined (ultrix) 1696 1696 + #include <sys/param.h> 1697 1697 + #if defined (BSD) 1698 1698 + #if BSD == 43 1699 1699 + printf ("vax-dec-bsd4.3\n"); exit (0); 1700 1700 + #else 1701 1701 + #if BSD == 199006 1702 1702 + printf ("vax-dec-bsd4.3reno\n"); exit (0); 1703 1703 + #else 1704 1704 + printf ("vax-dec-bsd\n"); exit (0); 1705 1705 + #endif 1706 1706 + #endif 1707 1707 + #else 1708 1708 + printf ("vax-dec-bsd\n"); exit (0); 1709 1709 + #endif 1710 1710 + #else 1711 1711 + #if defined(_SIZE_T_) || defined(SIGLOST) 1712 1712 + struct utsname un; 1713 1713 + uname (&un); 1714 1714 + printf ("vax-dec-ultrix%s\n", un.release); exit (0); 1715 1715 + #else 1716 1716 + printf ("vax-dec-ultrix\n"); exit (0); 1717 1717 + #endif 1718 1718 + #endif 1719 1719 + #endif 1720 1720 + #if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) 1721 1721 + #if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) 1722 1722 + #if defined(_SIZE_T_) || defined(SIGLOST) 1723 1723 + struct utsname *un; 1724 1724 + uname (&un); 1725 1725 + printf ("mips-dec-ultrix%s\n", un.release); exit (0); 1726 1726 + #else 1727 1727 + printf ("mips-dec-ultrix\n"); exit (0); 1728 1728 + #endif 1729 1729 + #endif 1448 1730 #endif 1449 1731 1450 1732 #if defined (alliant) && defined (i860) ··· 1455 1737 } 1456 1738 EOF 1457 1739 1458 1458 - $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && 1740 1740 + $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` && 1459 1741 { echo "$SYSTEM_NAME"; exit; } 1460 1742 1461 1743 # Apollos put the system type in the environment. 1744 1744 + test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; } 1462 1745 1463 1463 - test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } 1746 1746 + echo "$0: unable to guess system type" >&2 1464 1747 1465 1465 - # Convex versions that predate uname can use getsysinfo(1) 1748 1748 + case $UNAME_MACHINE:$UNAME_SYSTEM in 1749 1749 + mips:Linux | mips64:Linux) 1750 1750 + # If we got here on MIPS GNU/Linux, output extra information. 1751 1751 + cat >&2 <<EOF 1466 1752 1467 1467 - if [ -x /usr/convex/getsysinfo ] 1468 1468 - then 1469 1469 - case `getsysinfo -f cpu_type` in 1470 1470 - c1*) 1471 1471 - echo c1-convex-bsd 1472 1472 - exit ;; 1473 1473 - c2*) 1474 1474 - if getsysinfo -f scalar_acc 1475 1475 - then echo c32-convex-bsd 1476 1476 - else echo c2-convex-bsd 1477 1477 - fi 1478 1478 - exit ;; 1479 1479 - c34*) 1480 1480 - echo c34-convex-bsd 1481 1481 - exit ;; 1482 1482 - c38*) 1483 1483 - echo c38-convex-bsd 1484 1484 - exit ;; 1485 1485 - c4*) 1486 1486 - echo c4-convex-bsd 1487 1487 - exit ;; 1488 1488 - esac 1489 1489 - fi 1753 1753 + NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize 1754 1754 + the system type. Please install a C compiler and try again. 1755 1755 + EOF 1756 1756 + ;; 1757 1757 + esac 1490 1758 1491 1759 cat >&2 <<EOF 1492 1492 - $0: unable to guess system type 1493 1760 1494 1494 - This script, last modified $timestamp, has failed to recognize 1495 1495 - the operating system you are using. It is advised that you 1496 1496 - download the most up to date version of the config scripts from 1761 1761 + This script (version $timestamp), has failed to recognize the 1762 1762 + operating system you are using. If your script is old, overwrite *all* 1763 1763 + copies of config.guess and config.sub with the latest versions from: 1497 1764 1498 1498 - http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD 1765 1765 + https://git.savannah.gnu.org/cgit/config.git/plain/config.guess 1499 1766 and 1500 1500 - http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD 1767 1767 + https://git.savannah.gnu.org/cgit/config.git/plain/config.sub 1768 1768 + EOF 1501 1769 1502 1502 - If the version you run ($0) is already up to date, please 1503 1503 - send the following data and any information you think might be 1504 1504 - pertinent to <config-patches@gnu.org> in order to provide the needed 1505 1505 - information to handle your system. 1770 1770 + our_year=`echo $timestamp | sed 's,-.*,,'` 1771 1771 + thisyear=`date +%Y` 1772 1772 + # shellcheck disable=SC2003 1773 1773 + script_age=`expr "$thisyear" - "$our_year"` 1774 1774 + if test "$script_age" -lt 3 ; then 1775 1775 + cat >&2 <<EOF 1776 1776 + 1777 1777 + If $0 has already been updated, send the following data and any 1778 1778 + information you think might be pertinent to config-patches@gnu.org to 1779 1779 + provide the necessary information to handle your system. 1506 1780 1507 1781 config.guess timestamp = $timestamp 1508 1782 ··· 1521 1795 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` 1522 1796 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` 1523 1797 1524 1524 - UNAME_MACHINE = ${UNAME_MACHINE} 1525 1525 - UNAME_RELEASE = ${UNAME_RELEASE} 1526 1526 - UNAME_SYSTEM = ${UNAME_SYSTEM} 1527 1527 - UNAME_VERSION = ${UNAME_VERSION} 1798 1798 + UNAME_MACHINE = "$UNAME_MACHINE" 1799 1799 + UNAME_RELEASE = "$UNAME_RELEASE" 1800 1800 + UNAME_SYSTEM = "$UNAME_SYSTEM" 1801 1801 + UNAME_VERSION = "$UNAME_VERSION" 1528 1802 EOF 1803 1803 + fi 1529 1804 1530 1805 exit 1 1531 1806 1532 1807 # Local variables: 1533 1533 - # eval: (add-hook 'write-file-hooks 'time-stamp) 1808 1808 + # eval: (add-hook 'before-save-hook 'time-stamp) 1534 1809 # time-stamp-start: "timestamp='" 1535 1810 # time-stamp-format: "%:y-%02m-%02d" 1536 1811 # time-stamp-end: "'"

+6 -7

app/xkbevd/config.h.in

reviewed

··· 3 3 /* Define to 1 if you have the <inttypes.h> header file. */ 4 4 #undef HAVE_INTTYPES_H 5 5 6 6 - /* Define to 1 if you have the <memory.h> header file. */ 7 7 - #undef HAVE_MEMORY_H 8 8 - 9 6 /* Define to 1 if you have the <stdint.h> header file. */ 10 7 #undef HAVE_STDINT_H 11 8 9 9 + /* Define to 1 if you have the <stdio.h> header file. */ 10 10 + #undef HAVE_STDIO_H 11 11 + 12 12 /* Define to 1 if you have the <stdlib.h> header file. */ 13 13 #undef HAVE_STDLIB_H 14 14 - 15 15 - /* Define to 1 if you have the `strcasecmp' function. */ 16 16 - #undef HAVE_STRCASECMP 17 14 18 15 /* Define to 1 if you have the <strings.h> header file. */ 19 16 #undef HAVE_STRINGS_H ··· 60 57 /* Patch version of this package */ 61 58 #undef PACKAGE_VERSION_PATCHLEVEL 62 59 63 63 - /* Define to 1 if you have the ANSI C header files. */ 60 60 + /* Define to 1 if all of the C90 standard headers exist (not just the ones 61 61 + required in a freestanding environment). This macro is provided for 62 62 + backward compatibility; new code need not use it. */ 64 63 #undef STDC_HEADERS 65 64 66 65 /* Version number of package */

+1456 -1278

app/xkbevd/config.sub

reviewed

··· 1 1 #! /bin/sh 2 2 # Configuration validation subroutine script. 3 3 - # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 4 4 - # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 5 5 - # 2011, 2012 Free Software Foundation, Inc. 3 3 + # Copyright 1992-2024 Free Software Foundation, Inc. 6 4 7 7 - timestamp='2012-12-06' 5 5 + # shellcheck disable=SC2006,SC2268 # see below for rationale 8 6 9 9 - # This file is (in principle) common to ALL GNU software. 10 10 - # The presence of a machine in this file suggests that SOME GNU software 11 11 - # can handle that machine. It does not imply ALL GNU software can. 12 12 - # 13 13 - # This file is free software; you can redistribute it and/or modify 14 14 - # it under the terms of the GNU General Public License as published by 15 15 - # the Free Software Foundation; either version 2 of the License, or 7 7 + timestamp='2024-01-01' 8 8 + 9 9 + # This file is free software; you can redistribute it and/or modify it 10 10 + # under the terms of the GNU General Public License as published by 11 11 + # the Free Software Foundation, either version 3 of the License, or 16 12 # (at your option) any later version. 17 13 # 18 18 - # This program is distributed in the hope that it will be useful, 19 19 - # but WITHOUT ANY WARRANTY; without even the implied warranty of 20 20 - # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 21 - # GNU General Public License for more details. 14 14 + # This program is distributed in the hope that it will be useful, but 15 15 + # WITHOUT ANY WARRANTY; without even the implied warranty of 16 16 + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 17 + # General Public License for more details. 22 18 # 23 19 # You should have received a copy of the GNU General Public License 24 24 - # along with this program; if not, see <http://www.gnu.org/licenses/>. 20 20 + # along with this program; if not, see <https://www.gnu.org/licenses/>. 25 21 # 26 22 # As a special exception to the GNU General Public License, if you 27 23 # distribute this file as part of a program that contains a 28 24 # configuration script generated by Autoconf, you may include it under 29 29 - # the same distribution terms that you use for the rest of that program. 25 25 + # the same distribution terms that you use for the rest of that 26 26 + # program. This Exception is an additional permission under section 7 27 27 + # of the GNU General Public License, version 3 ("GPLv3"). 30 28 31 29 32 32 - # Please send patches to <config-patches@gnu.org>. Submit a context 33 33 - # diff and a properly formatted GNU ChangeLog entry. 30 30 + # Please send patches to <config-patches@gnu.org>. 34 31 # 35 32 # Configuration subroutine to validate and canonicalize a configuration type. 36 33 # Supply the specified configuration type as an argument. ··· 38 35 # Otherwise, we print the canonical config type on stdout and succeed. 39 36 40 37 # You can get the latest version of this script from: 41 41 - # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD 38 38 + # https://git.savannah.gnu.org/cgit/config.git/plain/config.sub 42 39 43 40 # This file is supposed to be the same for all GNU packages 44 41 # and recognize all the CPU types, system types and aliases ··· 55 52 # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM 56 53 # It is wrong to echo any other type of specification. 57 54 55 55 + # The "shellcheck disable" line above the timestamp inhibits complaints 56 56 + # about features and limitations of the classic Bourne shell that were 57 57 + # superseded or lifted in POSIX. However, this script identifies a wide 58 58 + # variety of pre-POSIX systems that do not have POSIX shells at all, and 59 59 + # even some reasonably current systems (Solaris 10 as case-in-point) still 60 60 + # have a pre-POSIX /bin/sh. 61 61 + 58 62 me=`echo "$0" | sed -e 's,.*/,,'` 59 63 60 64 usage="\ 61 61 - Usage: $0 [OPTION] CPU-MFR-OPSYS 62 62 - $0 [OPTION] ALIAS 65 65 + Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS 63 66 64 67 Canonicalize a configuration name. 65 68 66 66 - Operation modes: 69 69 + Options: 67 70 -h, --help print this help, then exit 68 71 -t, --time-stamp print date of last modification, then exit 69 72 -v, --version print version number, then exit ··· 73 76 version="\ 74 77 GNU config.sub ($timestamp) 75 78 76 76 - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 77 77 - 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 78 78 - Free Software Foundation, Inc. 79 79 + Copyright 1992-2024 Free Software Foundation, Inc. 79 80 80 81 This is free software; see the source for copying conditions. There is NO 81 82 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." 82 83 83 84 help=" 84 84 - Try \`$me --help' for more information." 85 85 + Try '$me --help' for more information." 85 86 86 87 # Parse command line 87 88 while test $# -gt 0 ; do ··· 97 98 - ) # Use stdin as input. 98 99 break ;; 99 100 -* ) 100 100 - echo "$me: invalid option $1$help" 101 101 + echo "$me: invalid option $1$help" >&2 101 102 exit 1 ;; 102 103 103 104 *local*) 104 105 # First pass through any local machine types. 105 105 - echo $1 106 106 + echo "$1" 106 107 exit ;; 107 108 108 109 * ) ··· 118 119 exit 1;; 119 120 esac 120 121 121 121 - # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). 122 122 - # Here we must recognize all the valid KERNEL-OS combinations. 123 123 - maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` 124 124 - case $maybe_os in 125 125 - nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ 126 126 - linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ 127 127 - knetbsd*-gnu* | netbsd*-gnu* | \ 128 128 - kopensolaris*-gnu* | \ 129 129 - storm-chaos* | os2-emx* | rtmk-nova*) 130 130 - os=-$maybe_os 131 131 - basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` 132 132 - ;; 133 133 - android-linux) 134 134 - os=-linux-android 135 135 - basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown 136 136 - ;; 137 137 - *) 138 138 - basic_machine=`echo $1 | sed 's/-[^-]*$//'` 139 139 - if [ $basic_machine != $1 ] 140 140 - then os=`echo $1 | sed 's/.*-/-/'` 141 141 - else os=; fi 142 142 - ;; 143 143 - esac 122 122 + # Split fields of configuration type 123 123 + # shellcheck disable=SC2162 124 124 + saved_IFS=$IFS 125 125 + IFS="-" read field1 field2 field3 field4 <<EOF 126 126 + $1 127 127 + EOF 128 128 + IFS=$saved_IFS 144 129 145 145 - ### Let's recognize common machines as not being operating systems so 146 146 - ### that things like config.sub decstation-3100 work. We also 147 147 - ### recognize some manufacturers as not being operating systems, so we 148 148 - ### can provide default operating systems below. 149 149 - case $os in 150 150 - -sun*os*) 151 151 - # Prevent following clause from handling this invalid input. 130 130 + # Separate into logical components for further validation 131 131 + case $1 in 132 132 + *-*-*-*-*) 133 133 + echo "Invalid configuration '$1': more than four components" >&2 134 134 + exit 1 152 135 ;; 153 153 - -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ 154 154 - -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ 155 155 - -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ 156 156 - -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ 157 157 - -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ 158 158 - -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ 159 159 - -apple | -axis | -knuth | -cray | -microblaze*) 160 160 - os= 161 161 - basic_machine=$1 136 136 + *-*-*-*) 137 137 + basic_machine=$field1-$field2 138 138 + basic_os=$field3-$field4 162 139 ;; 163 163 - -bluegene*) 164 164 - os=-cnk 165 165 - ;; 166 166 - -sim | -cisco | -oki | -wec | -winbond) 167 167 - os= 168 168 - basic_machine=$1 169 169 - ;; 170 170 - -scout) 171 171 - ;; 172 172 - -wrs) 173 173 - os=-vxworks 174 174 - basic_machine=$1 175 175 - ;; 176 176 - -chorusos*) 177 177 - os=-chorusos 178 178 - basic_machine=$1 179 179 - ;; 180 180 - -chorusrdb) 181 181 - os=-chorusrdb 182 182 - basic_machine=$1 183 183 - ;; 184 184 - -hiux*) 185 185 - os=-hiuxwe2 186 186 - ;; 187 187 - -sco6) 188 188 - os=-sco5v6 189 189 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 190 190 - ;; 191 191 - -sco5) 192 192 - os=-sco3.2v5 193 193 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 194 194 - ;; 195 195 - -sco4) 196 196 - os=-sco3.2v4 197 197 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 198 198 - ;; 199 199 - -sco3.2.[4-9]*) 200 200 - os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` 201 201 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 202 202 - ;; 203 203 - -sco3.2v[4-9]*) 204 204 - # Don't forget version if it is 3.2v4 or newer. 205 205 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 206 206 - ;; 207 207 - -sco5v6*) 208 208 - # Don't forget version if it is 3.2v4 or newer. 209 209 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 210 210 - ;; 211 211 - -sco*) 212 212 - os=-sco3.2v2 213 213 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 140 140 + *-*-*) 141 141 + # Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two 142 142 + # parts 143 143 + maybe_os=$field2-$field3 144 144 + case $maybe_os in 145 145 + nto-qnx* | linux-* | uclinux-uclibc* \ 146 146 + | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \ 147 147 + | netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \ 148 148 + | storm-chaos* | os2-emx* | rtmk-nova* | managarm-* \ 149 149 + | windows-* ) 150 150 + basic_machine=$field1 151 151 + basic_os=$maybe_os 152 152 + ;; 153 153 + android-linux) 154 154 + basic_machine=$field1-unknown 155 155 + basic_os=linux-android 156 156 + ;; 157 157 + *) 158 158 + basic_machine=$field1-$field2 159 159 + basic_os=$field3 160 160 + ;; 161 161 + esac 214 162 ;; 215 215 - -udk*) 216 216 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 163 163 + *-*) 164 164 + # A lone config we happen to match not fitting any pattern 165 165 + case $field1-$field2 in 166 166 + decstation-3100) 167 167 + basic_machine=mips-dec 168 168 + basic_os= 169 169 + ;; 170 170 + *-*) 171 171 + # Second component is usually, but not always the OS 172 172 + case $field2 in 173 173 + # Prevent following clause from handling this valid os 174 174 + sun*os*) 175 175 + basic_machine=$field1 176 176 + basic_os=$field2 177 177 + ;; 178 178 + zephyr*) 179 179 + basic_machine=$field1-unknown 180 180 + basic_os=$field2 181 181 + ;; 182 182 + # Manufacturers 183 183 + dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \ 184 184 + | att* | 7300* | 3300* | delta* | motorola* | sun[234]* \ 185 185 + | unicom* | ibm* | next | hp | isi* | apollo | altos* \ 186 186 + | convergent* | ncr* | news | 32* | 3600* | 3100* \ 187 187 + | hitachi* | c[123]* | convex* | sun | crds | omron* | dg \ 188 188 + | ultra | tti* | harris | dolphin | highlevel | gould \ 189 189 + | cbm | ns | masscomp | apple | axis | knuth | cray \ 190 190 + | microblaze* | sim | cisco \ 191 191 + | oki | wec | wrs | winbond) 192 192 + basic_machine=$field1-$field2 193 193 + basic_os= 194 194 + ;; 195 195 + *) 196 196 + basic_machine=$field1 197 197 + basic_os=$field2 198 198 + ;; 199 199 + esac 200 200 + ;; 201 201 + esac 217 202 ;; 218 218 - -isc) 219 219 - os=-isc2.2 220 220 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 221 221 - ;; 222 222 - -clix*) 223 223 - basic_machine=clipper-intergraph 224 224 - ;; 225 225 - -isc*) 226 226 - basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` 227 227 - ;; 228 228 - -lynx*178) 229 229 - os=-lynxos178 230 230 - ;; 231 231 - -lynx*5) 232 232 - os=-lynxos5 233 233 - ;; 234 234 - -lynx*) 235 235 - os=-lynxos 236 236 - ;; 237 237 - -ptx*) 238 238 - basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` 239 239 - ;; 240 240 - -windowsnt*) 241 241 - os=`echo $os | sed -e 's/windowsnt/winnt/'` 242 242 - ;; 243 243 - -psos*) 244 244 - os=-psos 245 245 - ;; 246 246 - -mint | -mint[0-9]*) 247 247 - basic_machine=m68k-atari 248 248 - os=-mint 203 203 + *) 204 204 + # Convert single-component short-hands not valid as part of 205 205 + # multi-component configurations. 206 206 + case $field1 in 207 207 + 386bsd) 208 208 + basic_machine=i386-pc 209 209 + basic_os=bsd 210 210 + ;; 211 211 + a29khif) 212 212 + basic_machine=a29k-amd 213 213 + basic_os=udi 214 214 + ;; 215 215 + adobe68k) 216 216 + basic_machine=m68010-adobe 217 217 + basic_os=scout 218 218 + ;; 219 219 + alliant) 220 220 + basic_machine=fx80-alliant 221 221 + basic_os= 222 222 + ;; 223 223 + altos | altos3068) 224 224 + basic_machine=m68k-altos 225 225 + basic_os= 226 226 + ;; 227 227 + am29k) 228 228 + basic_machine=a29k-none 229 229 + basic_os=bsd 230 230 + ;; 231 231 + amdahl) 232 232 + basic_machine=580-amdahl 233 233 + basic_os=sysv 234 234 + ;; 235 235 + amiga) 236 236 + basic_machine=m68k-unknown 237 237 + basic_os= 238 238 + ;; 239 239 + amigaos | amigados) 240 240 + basic_machine=m68k-unknown 241 241 + basic_os=amigaos 242 242 + ;; 243 243 + amigaunix | amix) 244 244 + basic_machine=m68k-unknown 245 245 + basic_os=sysv4 246 246 + ;; 247 247 + apollo68) 248 248 + basic_machine=m68k-apollo 249 249 + basic_os=sysv 250 250 + ;; 251 251 + apollo68bsd) 252 252 + basic_machine=m68k-apollo 253 253 + basic_os=bsd 254 254 + ;; 255 255 + aros) 256 256 + basic_machine=i386-pc 257 257 + basic_os=aros 258 258 + ;; 259 259 + aux) 260 260 + basic_machine=m68k-apple 261 261 + basic_os=aux 262 262 + ;; 263 263 + balance) 264 264 + basic_machine=ns32k-sequent 265 265 + basic_os=dynix 266 266 + ;; 267 267 + blackfin) 268 268 + basic_machine=bfin-unknown 269 269 + basic_os=linux 270 270 + ;; 271 271 + cegcc) 272 272 + basic_machine=arm-unknown 273 273 + basic_os=cegcc 274 274 + ;; 275 275 + convex-c1) 276 276 + basic_machine=c1-convex 277 277 + basic_os=bsd 278 278 + ;; 279 279 + convex-c2) 280 280 + basic_machine=c2-convex 281 281 + basic_os=bsd 282 282 + ;; 283 283 + convex-c32) 284 284 + basic_machine=c32-convex 285 285 + basic_os=bsd 286 286 + ;; 287 287 + convex-c34) 288 288 + basic_machine=c34-convex 289 289 + basic_os=bsd 290 290 + ;; 291 291 + convex-c38) 292 292 + basic_machine=c38-convex 293 293 + basic_os=bsd 294 294 + ;; 295 295 + cray) 296 296 + basic_machine=j90-cray 297 297 + basic_os=unicos 298 298 + ;; 299 299 + crds | unos) 300 300 + basic_machine=m68k-crds 301 301 + basic_os= 302 302 + ;; 303 303 + da30) 304 304 + basic_machine=m68k-da30 305 305 + basic_os= 306 306 + ;; 307 307 + decstation | pmax | pmin | dec3100 | decstatn) 308 308 + basic_machine=mips-dec 309 309 + basic_os= 310 310 + ;; 311 311 + delta88) 312 312 + basic_machine=m88k-motorola 313 313 + basic_os=sysv3 314 314 + ;; 315 315 + dicos) 316 316 + basic_machine=i686-pc 317 317 + basic_os=dicos 318 318 + ;; 319 319 + djgpp) 320 320 + basic_machine=i586-pc 321 321 + basic_os=msdosdjgpp 322 322 + ;; 323 323 + ebmon29k) 324 324 + basic_machine=a29k-amd 325 325 + basic_os=ebmon 326 326 + ;; 327 327 + es1800 | OSE68k | ose68k | ose | OSE) 328 328 + basic_machine=m68k-ericsson 329 329 + basic_os=ose 330 330 + ;; 331 331 + gmicro) 332 332 + basic_machine=tron-gmicro 333 333 + basic_os=sysv 334 334 + ;; 335 335 + go32) 336 336 + basic_machine=i386-pc 337 337 + basic_os=go32 338 338 + ;; 339 339 + h8300hms) 340 340 + basic_machine=h8300-hitachi 341 341 + basic_os=hms 342 342 + ;; 343 343 + h8300xray) 344 344 + basic_machine=h8300-hitachi 345 345 + basic_os=xray 346 346 + ;; 347 347 + h8500hms) 348 348 + basic_machine=h8500-hitachi 349 349 + basic_os=hms 350 350 + ;; 351 351 + harris) 352 352 + basic_machine=m88k-harris 353 353 + basic_os=sysv3 354 354 + ;; 355 355 + hp300 | hp300hpux) 356 356 + basic_machine=m68k-hp 357 357 + basic_os=hpux 358 358 + ;; 359 359 + hp300bsd) 360 360 + basic_machine=m68k-hp 361 361 + basic_os=bsd 362 362 + ;; 363 363 + hppaosf) 364 364 + basic_machine=hppa1.1-hp 365 365 + basic_os=osf 366 366 + ;; 367 367 + hppro) 368 368 + basic_machine=hppa1.1-hp 369 369 + basic_os=proelf 370 370 + ;; 371 371 + i386mach) 372 372 + basic_machine=i386-mach 373 373 + basic_os=mach 374 374 + ;; 375 375 + isi68 | isi) 376 376 + basic_machine=m68k-isi 377 377 + basic_os=sysv 378 378 + ;; 379 379 + m68knommu) 380 380 + basic_machine=m68k-unknown 381 381 + basic_os=linux 382 382 + ;; 383 383 + magnum | m3230) 384 384 + basic_machine=mips-mips 385 385 + basic_os=sysv 386 386 + ;; 387 387 + merlin) 388 388 + basic_machine=ns32k-utek 389 389 + basic_os=sysv 390 390 + ;; 391 391 + mingw64) 392 392 + basic_machine=x86_64-pc 393 393 + basic_os=mingw64 394 394 + ;; 395 395 + mingw32) 396 396 + basic_machine=i686-pc 397 397 + basic_os=mingw32 398 398 + ;; 399 399 + mingw32ce) 400 400 + basic_machine=arm-unknown 401 401 + basic_os=mingw32ce 402 402 + ;; 403 403 + monitor) 404 404 + basic_machine=m68k-rom68k 405 405 + basic_os=coff 406 406 + ;; 407 407 + morphos) 408 408 + basic_machine=powerpc-unknown 409 409 + basic_os=morphos 410 410 + ;; 411 411 + moxiebox) 412 412 + basic_machine=moxie-unknown 413 413 + basic_os=moxiebox 414 414 + ;; 415 415 + msdos) 416 416 + basic_machine=i386-pc 417 417 + basic_os=msdos 418 418 + ;; 419 419 + msys) 420 420 + basic_machine=i686-pc 421 421 + basic_os=msys 422 422 + ;; 423 423 + mvs) 424 424 + basic_machine=i370-ibm 425 425 + basic_os=mvs 426 426 + ;; 427 427 + nacl) 428 428 + basic_machine=le32-unknown 429 429 + basic_os=nacl 430 430 + ;; 431 431 + ncr3000) 432 432 + basic_machine=i486-ncr 433 433 + basic_os=sysv4 434 434 + ;; 435 435 + netbsd386) 436 436 + basic_machine=i386-pc 437 437 + basic_os=netbsd 438 438 + ;; 439 439 + netwinder) 440 440 + basic_machine=armv4l-rebel 441 441 + basic_os=linux 442 442 + ;; 443 443 + news | news700 | news800 | news900) 444 444 + basic_machine=m68k-sony 445 445 + basic_os=newsos 446 446 + ;; 447 447 + news1000) 448 448 + basic_machine=m68030-sony 449 449 + basic_os=newsos 450 450 + ;; 451 451 + necv70) 452 452 + basic_machine=v70-nec 453 453 + basic_os=sysv 454 454 + ;; 455 455 + nh3000) 456 456 + basic_machine=m68k-harris 457 457 + basic_os=cxux 458 458 + ;; 459 459 + nh[45]000) 460 460 + basic_machine=m88k-harris 461 461 + basic_os=cxux 462 462 + ;; 463 463 + nindy960) 464 464 + basic_machine=i960-intel 465 465 + basic_os=nindy 466 466 + ;; 467 467 + mon960) 468 468 + basic_machine=i960-intel 469 469 + basic_os=mon960 470 470 + ;; 471 471 + nonstopux) 472 472 + basic_machine=mips-compaq 473 473 + basic_os=nonstopux 474 474 + ;; 475 475 + os400) 476 476 + basic_machine=powerpc-ibm 477 477 + basic_os=os400 478 478 + ;; 479 479 + OSE68000 | ose68000) 480 480 + basic_machine=m68000-ericsson 481 481 + basic_os=ose 482 482 + ;; 483 483 + os68k) 484 484 + basic_machine=m68k-none 485 485 + basic_os=os68k 486 486 + ;; 487 487 + paragon) 488 488 + basic_machine=i860-intel 489 489 + basic_os=osf 490 490 + ;; 491 491 + parisc) 492 492 + basic_machine=hppa-unknown 493 493 + basic_os=linux 494 494 + ;; 495 495 + psp) 496 496 + basic_machine=mipsallegrexel-sony 497 497 + basic_os=psp 498 498 + ;; 499 499 + pw32) 500 500 + basic_machine=i586-unknown 501 501 + basic_os=pw32 502 502 + ;; 503 503 + rdos | rdos64) 504 504 + basic_machine=x86_64-pc 505 505 + basic_os=rdos 506 506 + ;; 507 507 + rdos32) 508 508 + basic_machine=i386-pc 509 509 + basic_os=rdos 510 510 + ;; 511 511 + rom68k) 512 512 + basic_machine=m68k-rom68k 513 513 + basic_os=coff 514 514 + ;; 515 515 + sa29200) 516 516 + basic_machine=a29k-amd 517 517 + basic_os=udi 518 518 + ;; 519 519 + sei) 520 520 + basic_machine=mips-sei 521 521 + basic_os=seiux 522 522 + ;; 523 523 + sequent) 524 524 + basic_machine=i386-sequent 525 525 + basic_os= 526 526 + ;; 527 527 + sps7) 528 528 + basic_machine=m68k-bull 529 529 + basic_os=sysv2 530 530 + ;; 531 531 + st2000) 532 532 + basic_machine=m68k-tandem 533 533 + basic_os= 534 534 + ;; 535 535 + stratus) 536 536 + basic_machine=i860-stratus 537 537 + basic_os=sysv4 538 538 + ;; 539 539 + sun2) 540 540 + basic_machine=m68000-sun 541 541 + basic_os= 542 542 + ;; 543 543 + sun2os3) 544 544 + basic_machine=m68000-sun 545 545 + basic_os=sunos3 546 546 + ;; 547 547 + sun2os4) 548 548 + basic_machine=m68000-sun 549 549 + basic_os=sunos4 550 550 + ;; 551 551 + sun3) 552 552 + basic_machine=m68k-sun 553 553 + basic_os= 554 554 + ;; 555 555 + sun3os3) 556 556 + basic_machine=m68k-sun 557 557 + basic_os=sunos3 558 558 + ;; 559 559 + sun3os4) 560 560 + basic_machine=m68k-sun 561 561 + basic_os=sunos4 562 562 + ;; 563 563 + sun4) 564 564 + basic_machine=sparc-sun 565 565 + basic_os= 566 566 + ;; 567 567 + sun4os3) 568 568 + basic_machine=sparc-sun 569 569 + basic_os=sunos3 570 570 + ;; 571 571 + sun4os4) 572 572 + basic_machine=sparc-sun 573 573 + basic_os=sunos4 574 574 + ;; 575 575 + sun4sol2) 576 576 + basic_machine=sparc-sun 577 577 + basic_os=solaris2 578 578 + ;; 579 579 + sun386 | sun386i | roadrunner) 580 580 + basic_machine=i386-sun 581 581 + basic_os= 582 582 + ;; 583 583 + sv1) 584 584 + basic_machine=sv1-cray 585 585 + basic_os=unicos 586 586 + ;; 587 587 + symmetry) 588 588 + basic_machine=i386-sequent 589 589 + basic_os=dynix 590 590 + ;; 591 591 + t3e) 592 592 + basic_machine=alphaev5-cray 593 593 + basic_os=unicos 594 594 + ;; 595 595 + t90) 596 596 + basic_machine=t90-cray 597 597 + basic_os=unicos 598 598 + ;; 599 599 + toad1) 600 600 + basic_machine=pdp10-xkl 601 601 + basic_os=tops20 602 602 + ;; 603 603 + tpf) 604 604 + basic_machine=s390x-ibm 605 605 + basic_os=tpf 606 606 + ;; 607 607 + udi29k) 608 608 + basic_machine=a29k-amd 609 609 + basic_os=udi 610 610 + ;; 611 611 + ultra3) 612 612 + basic_machine=a29k-nyu 613 613 + basic_os=sym1 614 614 + ;; 615 615 + v810 | necv810) 616 616 + basic_machine=v810-nec 617 617 + basic_os=none 618 618 + ;; 619 619 + vaxv) 620 620 + basic_machine=vax-dec 621 621 + basic_os=sysv 622 622 + ;; 623 623 + vms) 624 624 + basic_machine=vax-dec 625 625 + basic_os=vms 626 626 + ;; 627 627 + vsta) 628 628 + basic_machine=i386-pc 629 629 + basic_os=vsta 630 630 + ;; 631 631 + vxworks960) 632 632 + basic_machine=i960-wrs 633 633 + basic_os=vxworks 634 634 + ;; 635 635 + vxworks68) 636 636 + basic_machine=m68k-wrs 637 637 + basic_os=vxworks 638 638 + ;; 639 639 + vxworks29k) 640 640 + basic_machine=a29k-wrs 641 641 + basic_os=vxworks 642 642 + ;; 643 643 + xbox) 644 644 + basic_machine=i686-pc 645 645 + basic_os=mingw32 646 646 + ;; 647 647 + ymp) 648 648 + basic_machine=ymp-cray 649 649 + basic_os=unicos 650 650 + ;; 651 651 + *) 652 652 + basic_machine=$1 653 653 + basic_os= 654 654 + ;; 655 655 + esac 249 656 ;; 250 657 esac 251 658 252 252 - # Decode aliases for certain CPU-COMPANY combinations. 659 659 + # Decode 1-component or ad-hoc basic machines 253 660 case $basic_machine in 254 254 - # Recognize the basic CPU types without company name. 255 255 - # Some are omitted here because they have special meanings below. 256 256 - 1750a | 580 \ 257 257 - | a29k \ 258 258 - | aarch64 | aarch64_be \ 259 259 - | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ 260 260 - | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ 261 261 - | am33_2.0 \ 262 262 - | arc \ 263 263 - | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ 264 264 - | avr | avr32 \ 265 265 - | be32 | be64 \ 266 266 - | bfin \ 267 267 - | c4x | clipper \ 268 268 - | d10v | d30v | dlx | dsp16xx \ 269 269 - | epiphany \ 270 270 - | fido | fr30 | frv \ 271 271 - | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ 272 272 - | hexagon \ 273 273 - | i370 | i860 | i960 | ia64 \ 274 274 - | ip2k | iq2000 \ 275 275 - | le32 | le64 \ 276 276 - | lm32 \ 277 277 - | m32c | m32r | m32rle | m68000 | m68k | m88k \ 278 278 - | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ 279 279 - | mips | mipsbe | mipseb | mipsel | mipsle \ 280 280 - | mips16 \ 281 281 - | mips64 | mips64el \ 282 282 - | mips64octeon | mips64octeonel \ 283 283 - | mips64orion | mips64orionel \ 284 284 - | mips64r5900 | mips64r5900el \ 285 285 - | mips64vr | mips64vrel \ 286 286 - | mips64vr4100 | mips64vr4100el \ 287 287 - | mips64vr4300 | mips64vr4300el \ 288 288 - | mips64vr5000 | mips64vr5000el \ 289 289 - | mips64vr5900 | mips64vr5900el \ 290 290 - | mipsisa32 | mipsisa32el \ 291 291 - | mipsisa32r2 | mipsisa32r2el \ 292 292 - | mipsisa64 | mipsisa64el \ 293 293 - | mipsisa64r2 | mipsisa64r2el \ 294 294 - | mipsisa64sb1 | mipsisa64sb1el \ 295 295 - | mipsisa64sr71k | mipsisa64sr71kel \ 296 296 - | mipstx39 | mipstx39el \ 297 297 - | mn10200 | mn10300 \ 298 298 - | moxie \ 299 299 - | mt \ 300 300 - | msp430 \ 301 301 - | nds32 | nds32le | nds32be \ 302 302 - | nios | nios2 \ 303 303 - | ns16k | ns32k \ 304 304 - | open8 \ 305 305 - | or32 \ 306 306 - | pdp10 | pdp11 | pj | pjl \ 307 307 - | powerpc | powerpc64 | powerpc64le | powerpcle \ 308 308 - | pyramid \ 309 309 - | rl78 | rx \ 310 310 - | score \ 311 311 - | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ 312 312 - | sh64 | sh64le \ 313 313 - | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ 314 314 - | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ 315 315 - | spu \ 316 316 - | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ 317 317 - | ubicom32 \ 318 318 - | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ 319 319 - | we32k \ 320 320 - | x86 | xc16x | xstormy16 | xtensa \ 321 321 - | z8k | z80) 322 322 - basic_machine=$basic_machine-unknown 661 661 + # Here we handle the default manufacturer of certain CPU types. It is in 662 662 + # some cases the only manufacturer, in others, it is the most popular. 663 663 + w89k) 664 664 + cpu=hppa1.1 665 665 + vendor=winbond 323 666 ;; 324 324 - c54x) 325 325 - basic_machine=tic54x-unknown 667 667 + op50n) 668 668 + cpu=hppa1.1 669 669 + vendor=oki 326 670 ;; 327 327 - c55x) 328 328 - basic_machine=tic55x-unknown 671 671 + op60c) 672 672 + cpu=hppa1.1 673 673 + vendor=oki 329 674 ;; 330 330 - c6x) 331 331 - basic_machine=tic6x-unknown 675 675 + ibm*) 676 676 + cpu=i370 677 677 + vendor=ibm 332 678 ;; 333 333 - m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip) 334 334 - basic_machine=$basic_machine-unknown 335 335 - os=-none 679 679 + orion105) 680 680 + cpu=clipper 681 681 + vendor=highlevel 336 682 ;; 337 337 - m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) 683 683 + mac | mpw | mac-mpw) 684 684 + cpu=m68k 685 685 + vendor=apple 338 686 ;; 339 339 - ms1) 340 340 - basic_machine=mt-unknown 687 687 + pmac | pmac-mpw) 688 688 + cpu=powerpc 689 689 + vendor=apple 341 690 ;; 342 691 343 343 - strongarm | thumb | xscale) 344 344 - basic_machine=arm-unknown 345 345 - ;; 346 346 - xgate) 347 347 - basic_machine=$basic_machine-unknown 348 348 - os=-none 349 349 - ;; 350 350 - xscaleeb) 351 351 - basic_machine=armeb-unknown 352 352 - ;; 353 353 - 354 354 - xscaleel) 355 355 - basic_machine=armel-unknown 356 356 - ;; 357 357 - 358 358 - # We use `pc' rather than `unknown' 359 359 - # because (1) that's what they normally are, and 360 360 - # (2) the word "unknown" tends to confuse beginning users. 361 361 - i*86 | x86_64) 362 362 - basic_machine=$basic_machine-pc 363 363 - ;; 364 364 - # Object if more than one company name word. 365 365 - *-*-*) 366 366 - echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 367 367 - exit 1 368 368 - ;; 369 369 - # Recognize the basic CPU types with company name. 370 370 - 580-* \ 371 371 - | a29k-* \ 372 372 - | aarch64-* | aarch64_be-* \ 373 373 - | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ 374 374 - | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ 375 375 - | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ 376 376 - | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ 377 377 - | avr-* | avr32-* \ 378 378 - | be32-* | be64-* \ 379 379 - | bfin-* | bs2000-* \ 380 380 - | c[123]* | c30-* | [cjt]90-* | c4x-* \ 381 381 - | clipper-* | craynv-* | cydra-* \ 382 382 - | d10v-* | d30v-* | dlx-* \ 383 383 - | elxsi-* \ 384 384 - | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ 385 385 - | h8300-* | h8500-* \ 386 386 - | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ 387 387 - | hexagon-* \ 388 388 - | i*86-* | i860-* | i960-* | ia64-* \ 389 389 - | ip2k-* | iq2000-* \ 390 390 - | le32-* | le64-* \ 391 391 - | lm32-* \ 392 392 - | m32c-* | m32r-* | m32rle-* \ 393 393 - | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ 394 394 - | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ 395 395 - | microblaze-* | microblazeel-* \ 396 396 - | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ 397 397 - | mips16-* \ 398 398 - | mips64-* | mips64el-* \ 399 399 - | mips64octeon-* | mips64octeonel-* \ 400 400 - | mips64orion-* | mips64orionel-* \ 401 401 - | mips64r5900-* | mips64r5900el-* \ 402 402 - | mips64vr-* | mips64vrel-* \ 403 403 - | mips64vr4100-* | mips64vr4100el-* \ 404 404 - | mips64vr4300-* | mips64vr4300el-* \ 405 405 - | mips64vr5000-* | mips64vr5000el-* \ 406 406 - | mips64vr5900-* | mips64vr5900el-* \ 407 407 - | mipsisa32-* | mipsisa32el-* \ 408 408 - | mipsisa32r2-* | mipsisa32r2el-* \ 409 409 - | mipsisa64-* | mipsisa64el-* \ 410 410 - | mipsisa64r2-* | mipsisa64r2el-* \ 411 411 - | mipsisa64sb1-* | mipsisa64sb1el-* \ 412 412 - | mipsisa64sr71k-* | mipsisa64sr71kel-* \ 413 413 - | mipstx39-* | mipstx39el-* \ 414 414 - | mmix-* \ 415 415 - | mt-* \ 416 416 - | msp430-* \ 417 417 - | nds32-* | nds32le-* | nds32be-* \ 418 418 - | nios-* | nios2-* \ 419 419 - | none-* | np1-* | ns16k-* | ns32k-* \ 420 420 - | open8-* \ 421 421 - | orion-* \ 422 422 - | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ 423 423 - | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ 424 424 - | pyramid-* \ 425 425 - | rl78-* | romp-* | rs6000-* | rx-* \ 426 426 - | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ 427 427 - | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ 428 428 - | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ 429 429 - | sparclite-* \ 430 430 - | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ 431 431 - | tahoe-* \ 432 432 - | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ 433 433 - | tile*-* \ 434 434 - | tron-* \ 435 435 - | ubicom32-* \ 436 436 - | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ 437 437 - | vax-* \ 438 438 - | we32k-* \ 439 439 - | x86-* | x86_64-* | xc16x-* | xps100-* \ 440 440 - | xstormy16-* | xtensa*-* \ 441 441 - | ymp-* \ 442 442 - | z8k-* | z80-*) 443 443 - ;; 444 444 - # Recognize the basic CPU types without company name, with glob match. 445 445 - xtensa*) 446 446 - basic_machine=$basic_machine-unknown 447 447 - ;; 448 692 # Recognize the various machine names and aliases which stand 449 693 # for a CPU type and a company and sometimes even an OS. 450 450 - 386bsd) 451 451 - basic_machine=i386-unknown 452 452 - os=-bsd 453 453 - ;; 454 694 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) 455 455 - basic_machine=m68000-att 695 695 + cpu=m68000 696 696 + vendor=att 456 697 ;; 457 698 3b*) 458 458 - basic_machine=we32k-att 459 459 - ;; 460 460 - a29khif) 461 461 - basic_machine=a29k-amd 462 462 - os=-udi 463 463 - ;; 464 464 - abacus) 465 465 - basic_machine=abacus-unknown 466 466 - ;; 467 467 - adobe68k) 468 468 - basic_machine=m68010-adobe 469 469 - os=-scout 470 470 - ;; 471 471 - alliant | fx80) 472 472 - basic_machine=fx80-alliant 473 473 - ;; 474 474 - altos | altos3068) 475 475 - basic_machine=m68k-altos 476 476 - ;; 477 477 - am29k) 478 478 - basic_machine=a29k-none 479 479 - os=-bsd 480 480 - ;; 481 481 - amd64) 482 482 - basic_machine=x86_64-pc 483 483 - ;; 484 484 - amd64-*) 485 485 - basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` 486 486 - ;; 487 487 - amdahl) 488 488 - basic_machine=580-amdahl 489 489 - os=-sysv 490 490 - ;; 491 491 - amiga | amiga-*) 492 492 - basic_machine=m68k-unknown 493 493 - ;; 494 494 - amigaos | amigados) 495 495 - basic_machine=m68k-unknown 496 496 - os=-amigaos 497 497 - ;; 498 498 - amigaunix | amix) 499 499 - basic_machine=m68k-unknown 500 500 - os=-sysv4 501 501 - ;; 502 502 - apollo68) 503 503 - basic_machine=m68k-apollo 504 504 - os=-sysv 505 505 - ;; 506 506 - apollo68bsd) 507 507 - basic_machine=m68k-apollo 508 508 - os=-bsd 509 509 - ;; 510 510 - aros) 511 511 - basic_machine=i386-pc 512 512 - os=-aros 513 513 - ;; 514 514 - aux) 515 515 - basic_machine=m68k-apple 516 516 - os=-aux 517 517 - ;; 518 518 - balance) 519 519 - basic_machine=ns32k-sequent 520 520 - os=-dynix 521 521 - ;; 522 522 - blackfin) 523 523 - basic_machine=bfin-unknown 524 524 - os=-linux 525 525 - ;; 526 526 - blackfin-*) 527 527 - basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` 528 528 - os=-linux 699 699 + cpu=we32k 700 700 + vendor=att 529 701 ;; 530 702 bluegene*) 531 531 - basic_machine=powerpc-ibm 532 532 - os=-cnk 533 533 - ;; 534 534 - c54x-*) 535 535 - basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` 536 536 - ;; 537 537 - c55x-*) 538 538 - basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` 539 539 - ;; 540 540 - c6x-*) 541 541 - basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` 542 542 - ;; 543 543 - c90) 544 544 - basic_machine=c90-cray 545 545 - os=-unicos 546 546 - ;; 547 547 - cegcc) 548 548 - basic_machine=arm-unknown 549 549 - os=-cegcc 550 550 - ;; 551 551 - convex-c1) 552 552 - basic_machine=c1-convex 553 553 - os=-bsd 554 554 - ;; 555 555 - convex-c2) 556 556 - basic_machine=c2-convex 557 557 - os=-bsd 558 558 - ;; 559 559 - convex-c32) 560 560 - basic_machine=c32-convex 561 561 - os=-bsd 562 562 - ;; 563 563 - convex-c34) 564 564 - basic_machine=c34-convex 565 565 - os=-bsd 566 566 - ;; 567 567 - convex-c38) 568 568 - basic_machine=c38-convex 569 569 - os=-bsd 570 570 - ;; 571 571 - cray | j90) 572 572 - basic_machine=j90-cray 573 573 - os=-unicos 574 574 - ;; 575 575 - craynv) 576 576 - basic_machine=craynv-cray 577 577 - os=-unicosmp 578 578 - ;; 579 579 - cr16 | cr16-*) 580 580 - basic_machine=cr16-unknown 581 581 - os=-elf 582 582 - ;; 583 583 - crds | unos) 584 584 - basic_machine=m68k-crds 585 585 - ;; 586 586 - crisv32 | crisv32-* | etraxfs*) 587 587 - basic_machine=crisv32-axis 588 588 - ;; 589 589 - cris | cris-* | etrax*) 590 590 - basic_machine=cris-axis 591 591 - ;; 592 592 - crx) 593 593 - basic_machine=crx-unknown 594 594 - os=-elf 595 595 - ;; 596 596 - da30 | da30-*) 597 597 - basic_machine=m68k-da30 598 598 - ;; 599 599 - decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) 600 600 - basic_machine=mips-dec 703 703 + cpu=powerpc 704 704 + vendor=ibm 705 705 + basic_os=cnk 601 706 ;; 602 707 decsystem10* | dec10*) 603 603 - basic_machine=pdp10-dec 604 604 - os=-tops10 708 708 + cpu=pdp10 709 709 + vendor=dec 710 710 + basic_os=tops10 605 711 ;; 606 712 decsystem20* | dec20*) 607 607 - basic_machine=pdp10-dec 608 608 - os=-tops20 713 713 + cpu=pdp10 714 714 + vendor=dec 715 715 + basic_os=tops20 609 716 ;; 610 717 delta | 3300 | motorola-3300 | motorola-delta \ 611 718 | 3300-motorola | delta-motorola) 612 612 - basic_machine=m68k-motorola 719 719 + cpu=m68k 720 720 + vendor=motorola 613 721 ;; 614 614 - delta88) 615 615 - basic_machine=m88k-motorola 616 616 - os=-sysv3 722 722 + dpx2*) 723 723 + cpu=m68k 724 724 + vendor=bull 725 725 + basic_os=sysv3 617 726 ;; 618 618 - dicos) 619 619 - basic_machine=i686-pc 620 620 - os=-dicos 621 621 - ;; 622 622 - djgpp) 623 623 - basic_machine=i586-pc 624 624 - os=-msdosdjgpp 625 625 - ;; 626 626 - dpx20 | dpx20-*) 627 627 - basic_machine=rs6000-bull 628 628 - os=-bosx 629 629 - ;; 630 630 - dpx2* | dpx2*-bull) 631 631 - basic_machine=m68k-bull 632 632 - os=-sysv3 633 633 - ;; 634 634 - ebmon29k) 635 635 - basic_machine=a29k-amd 636 636 - os=-ebmon 727 727 + encore | umax | mmax) 728 728 + cpu=ns32k 729 729 + vendor=encore 637 730 ;; 638 731 elxsi) 639 639 - basic_machine=elxsi-elxsi 640 640 - os=-bsd 641 641 - ;; 642 642 - encore | umax | mmax) 643 643 - basic_machine=ns32k-encore 644 644 - ;; 645 645 - es1800 | OSE68k | ose68k | ose | OSE) 646 646 - basic_machine=m68k-ericsson 647 647 - os=-ose 732 732 + cpu=elxsi 733 733 + vendor=elxsi 734 734 + basic_os=${basic_os:-bsd} 648 735 ;; 649 736 fx2800) 650 650 - basic_machine=i860-alliant 737 737 + cpu=i860 738 738 + vendor=alliant 651 739 ;; 652 740 genix) 653 653 - basic_machine=ns32k-ns 654 654 - ;; 655 655 - gmicro) 656 656 - basic_machine=tron-gmicro 657 657 - os=-sysv 658 658 - ;; 659 659 - go32) 660 660 - basic_machine=i386-pc 661 661 - os=-go32 741 741 + cpu=ns32k 742 742 + vendor=ns 662 743 ;; 663 744 h3050r* | hiux*) 664 664 - basic_machine=hppa1.1-hitachi 665 665 - os=-hiuxwe2 666 666 - ;; 667 667 - h8300hms) 668 668 - basic_machine=h8300-hitachi 669 669 - os=-hms 670 670 - ;; 671 671 - h8300xray) 672 672 - basic_machine=h8300-hitachi 673 673 - os=-xray 674 674 - ;; 675 675 - h8500hms) 676 676 - basic_machine=h8500-hitachi 677 677 - os=-hms 678 678 - ;; 679 679 - harris) 680 680 - basic_machine=m88k-harris 681 681 - os=-sysv3 682 682 - ;; 683 683 - hp300-*) 684 684 - basic_machine=m68k-hp 685 685 - ;; 686 686 - hp300bsd) 687 687 - basic_machine=m68k-hp 688 688 - os=-bsd 689 689 - ;; 690 690 - hp300hpux) 691 691 - basic_machine=m68k-hp 692 692 - os=-hpux 745 745 + cpu=hppa1.1 746 746 + vendor=hitachi 747 747 + basic_os=hiuxwe2 693 748 ;; 694 749 hp3k9[0-9][0-9] | hp9[0-9][0-9]) 695 695 - basic_machine=hppa1.0-hp 750 750 + cpu=hppa1.0 751 751 + vendor=hp 696 752 ;; 697 753 hp9k2[0-9][0-9] | hp9k31[0-9]) 698 698 - basic_machine=m68000-hp 754 754 + cpu=m68000 755 755 + vendor=hp 699 756 ;; 700 757 hp9k3[2-9][0-9]) 701 701 - basic_machine=m68k-hp 758 758 + cpu=m68k 759 759 + vendor=hp 702 760 ;; 703 761 hp9k6[0-9][0-9] | hp6[0-9][0-9]) 704 704 - basic_machine=hppa1.0-hp 762 762 + cpu=hppa1.0 763 763 + vendor=hp 705 764 ;; 706 765 hp9k7[0-79][0-9] | hp7[0-79][0-9]) 707 707 - basic_machine=hppa1.1-hp 766 766 + cpu=hppa1.1 767 767 + vendor=hp 708 768 ;; 709 769 hp9k78[0-9] | hp78[0-9]) 710 770 # FIXME: really hppa2.0-hp 711 711 - basic_machine=hppa1.1-hp 771 771 + cpu=hppa1.1 772 772 + vendor=hp 712 773 ;; 713 774 hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) 714 775 # FIXME: really hppa2.0-hp 715 715 - basic_machine=hppa1.1-hp 776 776 + cpu=hppa1.1 777 777 + vendor=hp 716 778 ;; 717 779 hp9k8[0-9][13679] | hp8[0-9][13679]) 718 718 - basic_machine=hppa1.1-hp 780 780 + cpu=hppa1.1 781 781 + vendor=hp 719 782 ;; 720 783 hp9k8[0-9][0-9] | hp8[0-9][0-9]) 721 721 - basic_machine=hppa1.0-hp 722 722 - ;; 723 723 - hppa-next) 724 724 - os=-nextstep3 725 725 - ;; 726 726 - hppaosf) 727 727 - basic_machine=hppa1.1-hp 728 728 - os=-osf 729 729 - ;; 730 730 - hppro) 731 731 - basic_machine=hppa1.1-hp 732 732 - os=-proelf 733 733 - ;; 734 734 - i370-ibm* | ibm*) 735 735 - basic_machine=i370-ibm 784 784 + cpu=hppa1.0 785 785 + vendor=hp 736 786 ;; 737 787 i*86v32) 738 738 - basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` 739 739 - os=-sysv32 788 788 + cpu=`echo "$1" | sed -e 's/86.*/86/'` 789 789 + vendor=pc 790 790 + basic_os=sysv32 740 791 ;; 741 792 i*86v4*) 742 742 - basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` 743 743 - os=-sysv4 793 793 + cpu=`echo "$1" | sed -e 's/86.*/86/'` 794 794 + vendor=pc 795 795 + basic_os=sysv4 744 796 ;; 745 797 i*86v) 746 746 - basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` 747 747 - os=-sysv 798 798 + cpu=`echo "$1" | sed -e 's/86.*/86/'` 799 799 + vendor=pc 800 800 + basic_os=sysv 748 801 ;; 749 802 i*86sol2) 750 750 - basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` 751 751 - os=-solaris2 803 803 + cpu=`echo "$1" | sed -e 's/86.*/86/'` 804 804 + vendor=pc 805 805 + basic_os=solaris2 752 806 ;; 753 753 - i386mach) 754 754 - basic_machine=i386-mach 755 755 - os=-mach 756 756 - ;; 757 757 - i386-vsta | vsta) 758 758 - basic_machine=i386-unknown 759 759 - os=-vsta 807 807 + j90 | j90-cray) 808 808 + cpu=j90 809 809 + vendor=cray 810 810 + basic_os=${basic_os:-unicos} 760 811 ;; 761 812 iris | iris4d) 762 762 - basic_machine=mips-sgi 763 763 - case $os in 764 764 - -irix*) 813 813 + cpu=mips 814 814 + vendor=sgi 815 815 + case $basic_os in 816 816 + irix*) 765 817 ;; 766 818 *) 767 767 - os=-irix4 819 819 + basic_os=irix4 768 820 ;; 769 821 esac 770 822 ;; 771 771 - isi68 | isi) 772 772 - basic_machine=m68k-isi 773 773 - os=-sysv 774 774 - ;; 775 775 - m68knommu) 776 776 - basic_machine=m68k-unknown 777 777 - os=-linux 778 778 - ;; 779 779 - m68knommu-*) 780 780 - basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` 781 781 - os=-linux 782 782 - ;; 783 783 - m88k-omron*) 784 784 - basic_machine=m88k-omron 785 785 - ;; 786 786 - magnum | m3230) 787 787 - basic_machine=mips-mips 788 788 - os=-sysv 789 789 - ;; 790 790 - merlin) 791 791 - basic_machine=ns32k-utek 792 792 - os=-sysv 793 793 - ;; 794 794 - microblaze*) 795 795 - basic_machine=microblaze-xilinx 796 796 - ;; 797 797 - mingw64) 798 798 - basic_machine=x86_64-pc 799 799 - os=-mingw64 800 800 - ;; 801 801 - mingw32) 802 802 - basic_machine=i386-pc 803 803 - os=-mingw32 804 804 - ;; 805 805 - mingw32ce) 806 806 - basic_machine=arm-unknown 807 807 - os=-mingw32ce 808 808 - ;; 809 823 miniframe) 810 810 - basic_machine=m68000-convergent 824 824 + cpu=m68000 825 825 + vendor=convergent 811 826 ;; 812 812 - *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) 813 813 - basic_machine=m68k-atari 814 814 - os=-mint 815 815 - ;; 816 816 - mips3*-*) 817 817 - basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` 818 818 - ;; 819 819 - mips3*) 820 820 - basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown 821 821 - ;; 822 822 - monitor) 823 823 - basic_machine=m68k-rom68k 824 824 - os=-coff 825 825 - ;; 826 826 - morphos) 827 827 - basic_machine=powerpc-unknown 828 828 - os=-morphos 829 829 - ;; 830 830 - msdos) 831 831 - basic_machine=i386-pc 832 832 - os=-msdos 833 833 - ;; 834 834 - ms1-*) 835 835 - basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` 836 836 - ;; 837 837 - msys) 838 838 - basic_machine=i386-pc 839 839 - os=-msys 840 840 - ;; 841 841 - mvs) 842 842 - basic_machine=i370-ibm 843 843 - os=-mvs 844 844 - ;; 845 845 - nacl) 846 846 - basic_machine=le32-unknown 847 847 - os=-nacl 848 848 - ;; 849 849 - ncr3000) 850 850 - basic_machine=i486-ncr 851 851 - os=-sysv4 852 852 - ;; 853 853 - netbsd386) 854 854 - basic_machine=i386-unknown 855 855 - os=-netbsd 856 856 - ;; 857 857 - netwinder) 858 858 - basic_machine=armv4l-rebel 859 859 - os=-linux 860 860 - ;; 861 861 - news | news700 | news800 | news900) 862 862 - basic_machine=m68k-sony 863 863 - os=-newsos 864 864 - ;; 865 865 - news1000) 866 866 - basic_machine=m68030-sony 867 867 - os=-newsos 827 827 + *mint | mint[0-9]* | *MiNT | *MiNT[0-9]*) 828 828 + cpu=m68k 829 829 + vendor=atari 830 830 + basic_os=mint 868 831 ;; 869 832 news-3600 | risc-news) 870 870 - basic_machine=mips-sony 871 871 - os=-newsos 872 872 - ;; 873 873 - necv70) 874 874 - basic_machine=v70-nec 875 875 - os=-sysv 833 833 + cpu=mips 834 834 + vendor=sony 835 835 + basic_os=newsos 876 836 ;; 877 877 - next | m*-next ) 878 878 - basic_machine=m68k-next 879 879 - case $os in 880 880 - -nextstep* ) 837 837 + next | m*-next) 838 838 + cpu=m68k 839 839 + vendor=next 840 840 + case $basic_os in 841 841 + openstep*) 842 842 + ;; 843 843 + nextstep*) 881 844 ;; 882 882 - -ns2*) 883 883 - os=-nextstep2 845 845 + ns2*) 846 846 + basic_os=nextstep2 884 847 ;; 885 848 *) 886 886 - os=-nextstep3 849 849 + basic_os=nextstep3 887 850 ;; 888 851 esac 889 852 ;; 890 890 - nh3000) 891 891 - basic_machine=m68k-harris 892 892 - os=-cxux 893 893 - ;; 894 894 - nh[45]000) 895 895 - basic_machine=m88k-harris 896 896 - os=-cxux 897 897 - ;; 898 898 - nindy960) 899 899 - basic_machine=i960-intel 900 900 - os=-nindy 901 901 - ;; 902 902 - mon960) 903 903 - basic_machine=i960-intel 904 904 - os=-mon960 905 905 - ;; 906 906 - nonstopux) 907 907 - basic_machine=mips-compaq 908 908 - os=-nonstopux 909 909 - ;; 910 853 np1) 911 911 - basic_machine=np1-gould 912 912 - ;; 913 913 - neo-tandem) 914 914 - basic_machine=neo-tandem 915 915 - ;; 916 916 - nse-tandem) 917 917 - basic_machine=nse-tandem 918 918 - ;; 919 919 - nsr-tandem) 920 920 - basic_machine=nsr-tandem 854 854 + cpu=np1 855 855 + vendor=gould 921 856 ;; 922 857 op50n-* | op60c-*) 923 923 - basic_machine=hppa1.1-oki 924 924 - os=-proelf 925 925 - ;; 926 926 - openrisc | openrisc-*) 927 927 - basic_machine=or32-unknown 928 928 - ;; 929 929 - os400) 930 930 - basic_machine=powerpc-ibm 931 931 - os=-os400 932 932 - ;; 933 933 - OSE68000 | ose68000) 934 934 - basic_machine=m68000-ericsson 935 935 - os=-ose 936 936 - ;; 937 937 - os68k) 938 938 - basic_machine=m68k-none 939 939 - os=-os68k 858 858 + cpu=hppa1.1 859 859 + vendor=oki 860 860 + basic_os=proelf 940 861 ;; 941 862 pa-hitachi) 942 942 - basic_machine=hppa1.1-hitachi 943 943 - os=-hiuxwe2 944 944 - ;; 945 945 - paragon) 946 946 - basic_machine=i860-intel 947 947 - os=-osf 948 948 - ;; 949 949 - parisc) 950 950 - basic_machine=hppa-unknown 951 951 - os=-linux 952 952 - ;; 953 953 - parisc-*) 954 954 - basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` 955 955 - os=-linux 863 863 + cpu=hppa1.1 864 864 + vendor=hitachi 865 865 + basic_os=hiuxwe2 956 866 ;; 957 867 pbd) 958 958 - basic_machine=sparc-tti 868 868 + cpu=sparc 869 869 + vendor=tti 959 870 ;; 960 871 pbb) 961 961 - basic_machine=m68k-tti 962 962 - ;; 963 963 - pc532 | pc532-*) 964 964 - basic_machine=ns32k-pc532 965 965 - ;; 966 966 - pc98) 967 967 - basic_machine=i386-pc 968 968 - ;; 969 969 - pc98-*) 970 970 - basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` 872 872 + cpu=m68k 873 873 + vendor=tti 971 874 ;; 972 972 - pentium | p5 | k5 | k6 | nexgen | viac3) 973 973 - basic_machine=i586-pc 974 974 - ;; 975 975 - pentiumpro | p6 | 6x86 | athlon | athlon_*) 976 976 - basic_machine=i686-pc 977 977 - ;; 978 978 - pentiumii | pentium2 | pentiumiii | pentium3) 979 979 - basic_machine=i686-pc 980 980 - ;; 981 981 - pentium4) 982 982 - basic_machine=i786-pc 983 983 - ;; 984 984 - pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) 985 985 - basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` 986 986 - ;; 987 987 - pentiumpro-* | p6-* | 6x86-* | athlon-*) 988 988 - basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` 989 989 - ;; 990 990 - pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) 991 991 - basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` 992 992 - ;; 993 993 - pentium4-*) 994 994 - basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` 875 875 + pc532) 876 876 + cpu=ns32k 877 877 + vendor=pc532 995 878 ;; 996 879 pn) 997 997 - basic_machine=pn-gould 880 880 + cpu=pn 881 881 + vendor=gould 998 882 ;; 999 999 - power) basic_machine=power-ibm 1000 1000 - ;; 1001 1001 - ppc | ppcbe) basic_machine=powerpc-unknown 1002 1002 - ;; 1003 1003 - ppc-* | ppcbe-*) 1004 1004 - basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` 1005 1005 - ;; 1006 1006 - ppcle | powerpclittle | ppc-le | powerpc-little) 1007 1007 - basic_machine=powerpcle-unknown 1008 1008 - ;; 1009 1009 - ppcle-* | powerpclittle-*) 1010 1010 - basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` 1011 1011 - ;; 1012 1012 - ppc64) basic_machine=powerpc64-unknown 1013 1013 - ;; 1014 1014 - ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` 1015 1015 - ;; 1016 1016 - ppc64le | powerpc64little | ppc64-le | powerpc64-little) 1017 1017 - basic_machine=powerpc64le-unknown 1018 1018 - ;; 1019 1019 - ppc64le-* | powerpc64little-*) 1020 1020 - basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` 883 883 + power) 884 884 + cpu=power 885 885 + vendor=ibm 1021 886 ;; 1022 887 ps2) 1023 1023 - basic_machine=i386-ibm 1024 1024 - ;; 1025 1025 - pw32) 1026 1026 - basic_machine=i586-unknown 1027 1027 - os=-pw32 1028 1028 - ;; 1029 1029 - rdos | rdos64) 1030 1030 - basic_machine=x86_64-pc 1031 1031 - os=-rdos 1032 1032 - ;; 1033 1033 - rdos32) 1034 1034 - basic_machine=i386-pc 1035 1035 - os=-rdos 1036 1036 - ;; 1037 1037 - rom68k) 1038 1038 - basic_machine=m68k-rom68k 1039 1039 - os=-coff 888 888 + cpu=i386 889 889 + vendor=ibm 1040 890 ;; 1041 891 rm[46]00) 1042 1042 - basic_machine=mips-siemens 892 892 + cpu=mips 893 893 + vendor=siemens 1043 894 ;; 1044 895 rtpc | rtpc-*) 1045 1045 - basic_machine=romp-ibm 896 896 + cpu=romp 897 897 + vendor=ibm 1046 898 ;; 1047 1047 - s390 | s390-*) 1048 1048 - basic_machine=s390-ibm 899 899 + sde) 900 900 + cpu=mipsisa32 901 901 + vendor=sde 902 902 + basic_os=${basic_os:-elf} 1049 903 ;; 1050 1050 - s390x | s390x-*) 1051 1051 - basic_machine=s390x-ibm 904 904 + simso-wrs) 905 905 + cpu=sparclite 906 906 + vendor=wrs 907 907 + basic_os=vxworks 1052 908 ;; 1053 1053 - sa29200) 1054 1054 - basic_machine=a29k-amd 1055 1055 - os=-udi 909 909 + tower | tower-32) 910 910 + cpu=m68k 911 911 + vendor=ncr 1056 912 ;; 1057 1057 - sb1) 1058 1058 - basic_machine=mipsisa64sb1-unknown 913 913 + vpp*|vx|vx-*) 914 914 + cpu=f301 915 915 + vendor=fujitsu 1059 916 ;; 1060 1060 - sb1el) 1061 1061 - basic_machine=mipsisa64sb1el-unknown 917 917 + w65) 918 918 + cpu=w65 919 919 + vendor=wdc 1062 920 ;; 1063 1063 - sde) 1064 1064 - basic_machine=mipsisa32-sde 1065 1065 - os=-elf 921 921 + w89k-*) 922 922 + cpu=hppa1.1 923 923 + vendor=winbond 924 924 + basic_os=proelf 1066 925 ;; 1067 1067 - sei) 1068 1068 - basic_machine=mips-sei 1069 1069 - os=-seiux 926 926 + none) 927 927 + cpu=none 928 928 + vendor=none 1070 929 ;; 1071 1071 - sequent) 1072 1072 - basic_machine=i386-sequent 930 930 + leon|leon[3-9]) 931 931 + cpu=sparc 932 932 + vendor=$basic_machine 1073 933 ;; 1074 1074 - sh) 1075 1075 - basic_machine=sh-hitachi 1076 1076 - os=-hms 934 934 + leon-*|leon[3-9]-*) 935 935 + cpu=sparc 936 936 + vendor=`echo "$basic_machine" | sed 's/-.*//'` 1077 937 ;; 1078 1078 - sh5el) 1079 1079 - basic_machine=sh5le-unknown 938 938 + 939 939 + *-*) 940 940 + # shellcheck disable=SC2162 941 941 + saved_IFS=$IFS 942 942 + IFS="-" read cpu vendor <<EOF 943 943 + $basic_machine 944 944 + EOF 945 945 + IFS=$saved_IFS 1080 946 ;; 1081 1081 - sh64) 1082 1082 - basic_machine=sh64-unknown 947 947 + # We use 'pc' rather than 'unknown' 948 948 + # because (1) that's what they normally are, and 949 949 + # (2) the word "unknown" tends to confuse beginning users. 950 950 + i*86 | x86_64) 951 951 + cpu=$basic_machine 952 952 + vendor=pc 1083 953 ;; 1084 1084 - sparclite-wrs | simso-wrs) 1085 1085 - basic_machine=sparclite-wrs 1086 1086 - os=-vxworks 954 954 + # These rules are duplicated from below for sake of the special case above; 955 955 + # i.e. things that normalized to x86 arches should also default to "pc" 956 956 + pc98) 957 957 + cpu=i386 958 958 + vendor=pc 1087 959 ;; 1088 1088 - sps7) 1089 1089 - basic_machine=m68k-bull 1090 1090 - os=-sysv2 960 960 + x64 | amd64) 961 961 + cpu=x86_64 962 962 + vendor=pc 1091 963 ;; 1092 1092 - spur) 1093 1093 - basic_machine=spur-unknown 964 964 + # Recognize the basic CPU types without company name. 965 965 + *) 966 966 + cpu=$basic_machine 967 967 + vendor=unknown 1094 968 ;; 1095 1095 - st2000) 1096 1096 - basic_machine=m68k-tandem 969 969 + esac 970 970 + 971 971 + unset -v basic_machine 972 972 + 973 973 + # Decode basic machines in the full and proper CPU-Company form. 974 974 + case $cpu-$vendor in 975 975 + # Here we handle the default manufacturer of certain CPU types in canonical form. It is in 976 976 + # some cases the only manufacturer, in others, it is the most popular. 977 977 + craynv-unknown) 978 978 + vendor=cray 979 979 + basic_os=${basic_os:-unicosmp} 1097 980 ;; 1098 1098 - stratus) 1099 1099 - basic_machine=i860-stratus 1100 1100 - os=-sysv4 981 981 + c90-unknown | c90-cray) 982 982 + vendor=cray 983 983 + basic_os=${Basic_os:-unicos} 1101 984 ;; 1102 1102 - strongarm-* | thumb-*) 1103 1103 - basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` 985 985 + fx80-unknown) 986 986 + vendor=alliant 1104 987 ;; 1105 1105 - sun2) 1106 1106 - basic_machine=m68000-sun 988 988 + romp-unknown) 989 989 + vendor=ibm 1107 990 ;; 1108 1108 - sun2os3) 1109 1109 - basic_machine=m68000-sun 1110 1110 - os=-sunos3 991 991 + mmix-unknown) 992 992 + vendor=knuth 1111 993 ;; 1112 1112 - sun2os4) 1113 1113 - basic_machine=m68000-sun 1114 1114 - os=-sunos4 994 994 + microblaze-unknown | microblazeel-unknown) 995 995 + vendor=xilinx 1115 996 ;; 1116 1116 - sun3os3) 1117 1117 - basic_machine=m68k-sun 1118 1118 - os=-sunos3 997 997 + rs6000-unknown) 998 998 + vendor=ibm 1119 999 ;; 1120 1120 - sun3os4) 1121 1121 - basic_machine=m68k-sun 1122 1122 - os=-sunos4 1123 1123 - ;; 1124 1124 - sun4os3) 1125 1125 - basic_machine=sparc-sun 1126 1126 - os=-sunos3 1127 1127 - ;; 1128 1128 - sun4os4) 1129 1129 - basic_machine=sparc-sun 1130 1130 - os=-sunos4 1000 1000 + vax-unknown) 1001 1001 + vendor=dec 1131 1002 ;; 1132 1132 - sun4sol2) 1133 1133 - basic_machine=sparc-sun 1134 1134 - os=-solaris2 1003 1003 + pdp11-unknown) 1004 1004 + vendor=dec 1135 1005 ;; 1136 1136 - sun3 | sun3-*) 1137 1137 - basic_machine=m68k-sun 1006 1006 + we32k-unknown) 1007 1007 + vendor=att 1138 1008 ;; 1139 1139 - sun4) 1140 1140 - basic_machine=sparc-sun 1009 1009 + cydra-unknown) 1010 1010 + vendor=cydrome 1141 1011 ;; 1142 1142 - sun386 | sun386i | roadrunner) 1143 1143 - basic_machine=i386-sun 1012 1012 + i370-ibm*) 1013 1013 + vendor=ibm 1144 1014 ;; 1145 1145 - sv1) 1146 1146 - basic_machine=sv1-cray 1147 1147 - os=-unicos 1015 1015 + orion-unknown) 1016 1016 + vendor=highlevel 1148 1017 ;; 1149 1149 - symmetry) 1150 1150 - basic_machine=i386-sequent 1151 1151 - os=-dynix 1018 1018 + xps-unknown | xps100-unknown) 1019 1019 + cpu=xps100 1020 1020 + vendor=honeywell 1152 1021 ;; 1153 1153 - t3e) 1154 1154 - basic_machine=alphaev5-cray 1155 1155 - os=-unicos 1022 1022 + 1023 1023 + # Here we normalize CPU types with a missing or matching vendor 1024 1024 + armh-unknown | armh-alt) 1025 1025 + cpu=armv7l 1026 1026 + vendor=alt 1027 1027 + basic_os=${basic_os:-linux-gnueabihf} 1156 1028 ;; 1157 1157 - t90) 1158 1158 - basic_machine=t90-cray 1159 1159 - os=-unicos 1029 1029 + dpx20-unknown | dpx20-bull) 1030 1030 + cpu=rs6000 1031 1031 + vendor=bull 1032 1032 + basic_os=${basic_os:-bosx} 1160 1033 ;; 1161 1161 - tile*) 1162 1162 - basic_machine=$basic_machine-unknown 1163 1163 - os=-linux-gnu 1034 1034 + 1035 1035 + # Here we normalize CPU types irrespective of the vendor 1036 1036 + amd64-*) 1037 1037 + cpu=x86_64 1164 1038 ;; 1165 1165 - tx39) 1166 1166 - basic_machine=mipstx39-unknown 1039 1039 + blackfin-*) 1040 1040 + cpu=bfin 1041 1041 + basic_os=linux 1167 1042 ;; 1168 1168 - tx39el) 1169 1169 - basic_machine=mipstx39el-unknown 1043 1043 + c54x-*) 1044 1044 + cpu=tic54x 1170 1045 ;; 1171 1171 - toad1) 1172 1172 - basic_machine=pdp10-xkl 1173 1173 - os=-tops20 1046 1046 + c55x-*) 1047 1047 + cpu=tic55x 1174 1048 ;; 1175 1175 - tower | tower-32) 1176 1176 - basic_machine=m68k-ncr 1049 1049 + c6x-*) 1050 1050 + cpu=tic6x 1177 1051 ;; 1178 1178 - tpf) 1179 1179 - basic_machine=s390x-ibm 1180 1180 - os=-tpf 1052 1052 + e500v[12]-*) 1053 1053 + cpu=powerpc 1054 1054 + basic_os=${basic_os}"spe" 1181 1055 ;; 1182 1182 - udi29k) 1183 1183 - basic_machine=a29k-amd 1184 1184 - os=-udi 1056 1056 + mips3*-*) 1057 1057 + cpu=mips64 1185 1058 ;; 1186 1186 - ultra3) 1187 1187 - basic_machine=a29k-nyu 1188 1188 - os=-sym1 1059 1059 + ms1-*) 1060 1060 + cpu=mt 1189 1061 ;; 1190 1190 - v810 | necv810) 1191 1191 - basic_machine=v810-nec 1192 1192 - os=-none 1062 1062 + m68knommu-*) 1063 1063 + cpu=m68k 1064 1064 + basic_os=linux 1193 1065 ;; 1194 1194 - vaxv) 1195 1195 - basic_machine=vax-dec 1196 1196 - os=-sysv 1066 1066 + m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*) 1067 1067 + cpu=s12z 1197 1068 ;; 1198 1198 - vms) 1199 1199 - basic_machine=vax-dec 1200 1200 - os=-vms 1069 1069 + openrisc-*) 1070 1070 + cpu=or32 1201 1071 ;; 1202 1202 - vpp*|vx|vx-*) 1203 1203 - basic_machine=f301-fujitsu 1072 1072 + parisc-*) 1073 1073 + cpu=hppa 1074 1074 + basic_os=linux 1204 1075 ;; 1205 1205 - vxworks960) 1206 1206 - basic_machine=i960-wrs 1207 1207 - os=-vxworks 1076 1076 + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) 1077 1077 + cpu=i586 1208 1078 ;; 1209 1209 - vxworks68) 1210 1210 - basic_machine=m68k-wrs 1211 1211 - os=-vxworks 1079 1079 + pentiumpro-* | p6-* | 6x86-* | athlon-* | athlon_*-*) 1080 1080 + cpu=i686 1212 1081 ;; 1213 1213 - vxworks29k) 1214 1214 - basic_machine=a29k-wrs 1215 1215 - os=-vxworks 1082 1082 + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) 1083 1083 + cpu=i686 1216 1084 ;; 1217 1217 - w65*) 1218 1218 - basic_machine=w65-wdc 1219 1219 - os=-none 1085 1085 + pentium4-*) 1086 1086 + cpu=i786 1220 1087 ;; 1221 1221 - w89k-*) 1222 1222 - basic_machine=hppa1.1-winbond 1223 1223 - os=-proelf 1088 1088 + pc98-*) 1089 1089 + cpu=i386 1224 1090 ;; 1225 1225 - xbox) 1226 1226 - basic_machine=i686-pc 1227 1227 - os=-mingw32 1091 1091 + ppc-* | ppcbe-*) 1092 1092 + cpu=powerpc 1228 1093 ;; 1229 1229 - xps | xps100) 1230 1230 - basic_machine=xps100-honeywell 1094 1094 + ppcle-* | powerpclittle-*) 1095 1095 + cpu=powerpcle 1231 1096 ;; 1232 1232 - xscale-* | xscalee[bl]-*) 1233 1233 - basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` 1097 1097 + ppc64-*) 1098 1098 + cpu=powerpc64 1234 1099 ;; 1235 1235 - ymp) 1236 1236 - basic_machine=ymp-cray 1237 1237 - os=-unicos 1100 1100 + ppc64le-* | powerpc64little-*) 1101 1101 + cpu=powerpc64le 1238 1102 ;; 1239 1239 - z8k-*-coff) 1240 1240 - basic_machine=z8k-unknown 1241 1241 - os=-sim 1103 1103 + sb1-*) 1104 1104 + cpu=mipsisa64sb1 1242 1105 ;; 1243 1243 - z80-*-coff) 1244 1244 - basic_machine=z80-unknown 1245 1245 - os=-sim 1106 1106 + sb1el-*) 1107 1107 + cpu=mipsisa64sb1el 1246 1108 ;; 1247 1247 - none) 1248 1248 - basic_machine=none-none 1249 1249 - os=-none 1109 1109 + sh5e[lb]-*) 1110 1110 + cpu=`echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/'` 1250 1111 ;; 1251 1251 - 1252 1252 - # Here we handle the default manufacturer of certain CPU types. It is in 1253 1253 - # some cases the only manufacturer, in others, it is the most popular. 1254 1254 - w89k) 1255 1255 - basic_machine=hppa1.1-winbond 1112 1112 + spur-*) 1113 1113 + cpu=spur 1256 1114 ;; 1257 1257 - op50n) 1258 1258 - basic_machine=hppa1.1-oki 1115 1115 + strongarm-* | thumb-*) 1116 1116 + cpu=arm 1259 1117 ;; 1260 1260 - op60c) 1261 1261 - basic_machine=hppa1.1-oki 1118 1118 + tx39-*) 1119 1119 + cpu=mipstx39 1262 1120 ;; 1263 1263 - romp) 1264 1264 - basic_machine=romp-ibm 1121 1121 + tx39el-*) 1122 1122 + cpu=mipstx39el 1265 1123 ;; 1266 1266 - mmix) 1267 1267 - basic_machine=mmix-knuth 1124 1124 + x64-*) 1125 1125 + cpu=x86_64 1268 1126 ;; 1269 1269 - rs6000) 1270 1270 - basic_machine=rs6000-ibm 1127 1127 + xscale-* | xscalee[bl]-*) 1128 1128 + cpu=`echo "$cpu" | sed 's/^xscale/arm/'` 1271 1129 ;; 1272 1272 - vax) 1273 1273 - basic_machine=vax-dec 1130 1130 + arm64-* | aarch64le-*) 1131 1131 + cpu=aarch64 1274 1132 ;; 1275 1275 - pdp10) 1276 1276 - # there are many clones, so DEC is not a safe bet 1277 1277 - basic_machine=pdp10-unknown 1133 1133 + 1134 1134 + # Recognize the canonical CPU Types that limit and/or modify the 1135 1135 + # company names they are paired with. 1136 1136 + cr16-*) 1137 1137 + basic_os=${basic_os:-elf} 1278 1138 ;; 1279 1279 - pdp11) 1280 1280 - basic_machine=pdp11-dec 1139 1139 + crisv32-* | etraxfs*-*) 1140 1140 + cpu=crisv32 1141 1141 + vendor=axis 1281 1142 ;; 1282 1282 - we32k) 1283 1283 - basic_machine=we32k-att 1143 1143 + cris-* | etrax*-*) 1144 1144 + cpu=cris 1145 1145 + vendor=axis 1284 1146 ;; 1285 1285 - sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) 1286 1286 - basic_machine=sh-unknown 1147 1147 + crx-*) 1148 1148 + basic_os=${basic_os:-elf} 1287 1149 ;; 1288 1288 - sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) 1289 1289 - basic_machine=sparc-sun 1150 1150 + neo-tandem) 1151 1151 + cpu=neo 1152 1152 + vendor=tandem 1290 1153 ;; 1291 1291 - cydra) 1292 1292 - basic_machine=cydra-cydrome 1154 1154 + nse-tandem) 1155 1155 + cpu=nse 1156 1156 + vendor=tandem 1293 1157 ;; 1294 1294 - orion) 1295 1295 - basic_machine=orion-highlevel 1158 1158 + nsr-tandem) 1159 1159 + cpu=nsr 1160 1160 + vendor=tandem 1296 1161 ;; 1297 1297 - orion105) 1298 1298 - basic_machine=clipper-highlevel 1162 1162 + nsv-tandem) 1163 1163 + cpu=nsv 1164 1164 + vendor=tandem 1299 1165 ;; 1300 1300 - mac | mpw | mac-mpw) 1301 1301 - basic_machine=m68k-apple 1166 1166 + nsx-tandem) 1167 1167 + cpu=nsx 1168 1168 + vendor=tandem 1302 1169 ;; 1303 1303 - pmac | pmac-mpw) 1304 1304 - basic_machine=powerpc-apple 1170 1170 + mipsallegrexel-sony) 1171 1171 + cpu=mipsallegrexel 1172 1172 + vendor=sony 1305 1173 ;; 1306 1306 - *-unknown) 1307 1307 - # Make sure to match an already-canonicalized machine name. 1174 1174 + tile*-*) 1175 1175 + basic_os=${basic_os:-linux-gnu} 1308 1176 ;; 1177 1177 + 1309 1178 *) 1310 1310 - echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 1311 1311 - exit 1 1179 1179 + # Recognize the canonical CPU types that are allowed with any 1180 1180 + # company name. 1181 1181 + case $cpu in 1182 1182 + 1750a | 580 \ 1183 1183 + | a29k \ 1184 1184 + | aarch64 | aarch64_be | aarch64c | arm64ec \ 1185 1185 + | abacus \ 1186 1186 + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] \ 1187 1187 + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] \ 1188 1188 + | alphapca5[67] | alpha64pca5[67] \ 1189 1189 + | am33_2.0 \ 1190 1190 + | amdgcn \ 1191 1191 + | arc | arceb | arc32 | arc64 \ 1192 1192 + | arm | arm[lb]e | arme[lb] | armv* \ 1193 1193 + | avr | avr32 \ 1194 1194 + | asmjs \ 1195 1195 + | ba \ 1196 1196 + | be32 | be64 \ 1197 1197 + | bfin | bpf | bs2000 \ 1198 1198 + | c[123]* | c30 | [cjt]90 | c4x \ 1199 1199 + | c8051 | clipper | craynv | csky | cydra \ 1200 1200 + | d10v | d30v | dlx | dsp16xx \ 1201 1201 + | e2k | elxsi | epiphany \ 1202 1202 + | f30[01] | f700 | fido | fr30 | frv | ft32 | fx80 \ 1203 1203 + | javascript \ 1204 1204 + | h8300 | h8500 \ 1205 1205 + | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ 1206 1206 + | hexagon \ 1207 1207 + | i370 | i*86 | i860 | i960 | ia16 | ia64 \ 1208 1208 + | ip2k | iq2000 \ 1209 1209 + | k1om \ 1210 1210 + | kvx \ 1211 1211 + | le32 | le64 \ 1212 1212 + | lm32 \ 1213 1213 + | loongarch32 | loongarch64 \ 1214 1214 + | m32c | m32r | m32rle \ 1215 1215 + | m5200 | m68000 | m680[012346]0 | m68360 | m683?2 | m68k \ 1216 1216 + | m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x \ 1217 1217 + | m88110 | m88k | maxq | mb | mcore | mep | metag \ 1218 1218 + | microblaze | microblazeel \ 1219 1219 + | mips* \ 1220 1220 + | mmix \ 1221 1221 + | mn10200 | mn10300 \ 1222 1222 + | moxie \ 1223 1223 + | mt \ 1224 1224 + | msp430 \ 1225 1225 + | nanomips* \ 1226 1226 + | nds32 | nds32le | nds32be \ 1227 1227 + | nfp \ 1228 1228 + | nios | nios2 | nios2eb | nios2el \ 1229 1229 + | none | np1 | ns16k | ns32k | nvptx \ 1230 1230 + | open8 \ 1231 1231 + | or1k* \ 1232 1232 + | or32 \ 1233 1233 + | orion \ 1234 1234 + | picochip \ 1235 1235 + | pdp10 | pdp11 | pj | pjl | pn | power \ 1236 1236 + | powerpc | powerpc64 | powerpc64le | powerpcle | powerpcspe \ 1237 1237 + | pru \ 1238 1238 + | pyramid \ 1239 1239 + | riscv | riscv32 | riscv32be | riscv64 | riscv64be \ 1240 1240 + | rl78 | romp | rs6000 | rx \ 1241 1241 + | s390 | s390x \ 1242 1242 + | score \ 1243 1243 + | sh | shl \ 1244 1244 + | sh[1234] | sh[24]a | sh[24]ae[lb] | sh[23]e | she[lb] | sh[lb]e \ 1245 1245 + | sh[1234]e[lb] | sh[12345][lb]e | sh[23]ele | sh64 | sh64le \ 1246 1246 + | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet \ 1247 1247 + | sparclite \ 1248 1248 + | sparcv8 | sparcv9 | sparcv9b | sparcv9v | sv1 | sx* \ 1249 1249 + | spu \ 1250 1250 + | tahoe \ 1251 1251 + | thumbv7* \ 1252 1252 + | tic30 | tic4x | tic54x | tic55x | tic6x | tic80 \ 1253 1253 + | tron \ 1254 1254 + | ubicom32 \ 1255 1255 + | v70 | v850 | v850e | v850e1 | v850es | v850e2 | v850e2v3 \ 1256 1256 + | vax \ 1257 1257 + | vc4 \ 1258 1258 + | visium \ 1259 1259 + | w65 \ 1260 1260 + | wasm32 | wasm64 \ 1261 1261 + | we32k \ 1262 1262 + | x86 | x86_64 | xc16x | xgate | xps100 \ 1263 1263 + | xstormy16 | xtensa* \ 1264 1264 + | ymp \ 1265 1265 + | z8k | z80) 1266 1266 + ;; 1267 1267 + 1268 1268 + *) 1269 1269 + echo "Invalid configuration '$1': machine '$cpu-$vendor' not recognized" 1>&2 1270 1270 + exit 1 1271 1271 + ;; 1272 1272 + esac 1312 1273 ;; 1313 1274 esac 1314 1275 1315 1276 # Here we canonicalize certain aliases for manufacturers. 1316 1316 - case $basic_machine in 1317 1317 - *-digital*) 1318 1318 - basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` 1277 1277 + case $vendor in 1278 1278 + digital*) 1279 1279 + vendor=dec 1319 1280 ;; 1320 1320 - *-commodore*) 1321 1321 - basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` 1281 1281 + commodore*) 1282 1282 + vendor=cbm 1322 1283 ;; 1323 1284 *) 1324 1285 ;; ··· 1326 1287 1327 1288 # Decode manufacturer-specific aliases for certain operating systems. 1328 1289 1329 1329 - if [ x"$os" != x"" ] 1290 1290 + if test x"$basic_os" != x 1330 1291 then 1331 1331 - case $os in 1332 1332 - # First match some system type aliases 1333 1333 - # that might get confused with valid system types. 1334 1334 - # -solaris* is a basic system type, with this one exception. 1335 1335 - -auroraux) 1336 1336 - os=-auroraux 1292 1292 + 1293 1293 + # First recognize some ad-hoc cases, or perhaps split kernel-os, or else just 1294 1294 + # set os. 1295 1295 + obj= 1296 1296 + case $basic_os in 1297 1297 + gnu/linux*) 1298 1298 + kernel=linux 1299 1299 + os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'` 1337 1300 ;; 1338 1338 - -solaris1 | -solaris1.*) 1339 1339 - os=`echo $os | sed -e 's|solaris1|sunos4|'` 1301 1301 + os2-emx) 1302 1302 + kernel=os2 1303 1303 + os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'` 1340 1304 ;; 1341 1341 - -solaris) 1342 1342 - os=-solaris2 1305 1305 + nto-qnx*) 1306 1306 + kernel=nto 1307 1307 + os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'` 1343 1308 ;; 1344 1344 - -svr4*) 1345 1345 - os=-sysv4 1309 1309 + *-*) 1310 1310 + # shellcheck disable=SC2162 1311 1311 + saved_IFS=$IFS 1312 1312 + IFS="-" read kernel os <<EOF 1313 1313 + $basic_os 1314 1314 + EOF 1315 1315 + IFS=$saved_IFS 1346 1316 ;; 1347 1347 - -unixware*) 1348 1348 - os=-sysv4.2uw 1317 1317 + # Default OS when just kernel was specified 1318 1318 + nto*) 1319 1319 + kernel=nto 1320 1320 + os=`echo "$basic_os" | sed -e 's|nto|qnx|'` 1349 1321 ;; 1350 1350 - -gnu/linux*) 1351 1351 - os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` 1322 1322 + linux*) 1323 1323 + kernel=linux 1324 1324 + os=`echo "$basic_os" | sed -e 's|linux|gnu|'` 1352 1325 ;; 1353 1353 - # First accept the basic system types. 1354 1354 - # The portable systems comes first. 1355 1355 - # Each alternative MUST END IN A *, to match a version number. 1356 1356 - # -sysv* is not here because it comes later, after sysvr4. 1357 1357 - -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ 1358 1358 - | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ 1359 1359 - | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ 1360 1360 - | -sym* | -kopensolaris* \ 1361 1361 - | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ 1362 1362 - | -aos* | -aros* \ 1363 1363 - | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ 1364 1364 - | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ 1365 1365 - | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ 1366 1366 - | -bitrig* | -openbsd* | -solidbsd* \ 1367 1367 - | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ 1368 1368 - | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ 1369 1369 - | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ 1370 1370 - | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ 1371 1371 - | -chorusos* | -chorusrdb* | -cegcc* \ 1372 1372 - | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ 1373 1373 - | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ 1374 1374 - | -linux-newlib* | -linux-musl* | -linux-uclibc* \ 1375 1375 - | -uxpv* | -beos* | -mpeix* | -udk* \ 1376 1376 - | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ 1377 1377 - | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ 1378 1378 - | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ 1379 1379 - | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ 1380 1380 - | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ 1381 1381 - | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ 1382 1382 - | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) 1383 1383 - # Remember, each alternative MUST END IN *, to match a version number. 1326 1326 + managarm*) 1327 1327 + kernel=managarm 1328 1328 + os=`echo "$basic_os" | sed -e 's|managarm|mlibc|'` 1384 1329 ;; 1385 1385 - -qnx*) 1386 1386 - case $basic_machine in 1387 1387 - x86-* | i*86-*) 1388 1388 - ;; 1389 1389 - *) 1390 1390 - os=-nto$os 1391 1391 - ;; 1392 1392 - esac 1330 1330 + *) 1331 1331 + kernel= 1332 1332 + os=$basic_os 1393 1333 ;; 1394 1394 - -nto-qnx*) 1334 1334 + esac 1335 1335 + 1336 1336 + # Now, normalize the OS (knowing we just have one component, it's not a kernel, 1337 1337 + # etc.) 1338 1338 + case $os in 1339 1339 + # First match some system type aliases that might get confused 1340 1340 + # with valid system types. 1341 1341 + # solaris* is a basic system type, with this one exception. 1342 1342 + auroraux) 1343 1343 + os=auroraux 1395 1344 ;; 1396 1396 - -nto*) 1397 1397 - os=`echo $os | sed -e 's|nto|nto-qnx|'` 1345 1345 + bluegene*) 1346 1346 + os=cnk 1398 1347 ;; 1399 1399 - -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ 1400 1400 - | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ 1401 1401 - | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) 1348 1348 + solaris1 | solaris1.*) 1349 1349 + os=`echo "$os" | sed -e 's|solaris1|sunos4|'` 1402 1350 ;; 1403 1403 - -mac*) 1404 1404 - os=`echo $os | sed -e 's|mac|macos|'` 1351 1351 + solaris) 1352 1352 + os=solaris2 1405 1353 ;; 1406 1406 - -linux-dietlibc) 1407 1407 - os=-linux-dietlibc 1354 1354 + unixware*) 1355 1355 + os=sysv4.2uw 1408 1356 ;; 1409 1409 - -linux*) 1410 1410 - os=`echo $os | sed -e 's|linux|linux-gnu|'` 1357 1357 + # es1800 is here to avoid being matched by es* (a different OS) 1358 1358 + es1800*) 1359 1359 + os=ose 1411 1360 ;; 1412 1412 - -sunos5*) 1413 1413 - os=`echo $os | sed -e 's|sunos5|solaris2|'` 1361 1361 + # Some version numbers need modification 1362 1362 + chorusos*) 1363 1363 + os=chorusos 1414 1364 ;; 1415 1415 - -sunos6*) 1416 1416 - os=`echo $os | sed -e 's|sunos6|solaris3|'` 1365 1365 + isc) 1366 1366 + os=isc2.2 1417 1367 ;; 1418 1418 - -opened*) 1419 1419 - os=-openedition 1368 1368 + sco6) 1369 1369 + os=sco5v6 1420 1370 ;; 1421 1421 - -os400*) 1422 1422 - os=-os400 1371 1371 + sco5) 1372 1372 + os=sco3.2v5 1423 1373 ;; 1424 1424 - -wince*) 1425 1425 - os=-wince 1374 1374 + sco4) 1375 1375 + os=sco3.2v4 1426 1376 ;; 1427 1427 - -osfrose*) 1428 1428 - os=-osfrose 1377 1377 + sco3.2.[4-9]*) 1378 1378 + os=`echo "$os" | sed -e 's/sco3.2./sco3.2v/'` 1429 1379 ;; 1430 1430 - -osf*) 1431 1431 - os=-osf 1380 1380 + sco*v* | scout) 1381 1381 + # Don't match below 1432 1382 ;; 1433 1433 - -utek*) 1434 1434 - os=-bsd 1383 1383 + sco*) 1384 1384 + os=sco3.2v2 1435 1385 ;; 1436 1436 - -dynix*) 1437 1437 - os=-bsd 1386 1386 + psos*) 1387 1387 + os=psos 1438 1388 ;; 1439 1439 - -acis*) 1440 1440 - os=-aos 1389 1389 + qnx*) 1390 1390 + os=qnx 1441 1391 ;; 1442 1442 - -atheos*) 1443 1443 - os=-atheos 1392 1392 + hiux*) 1393 1393 + os=hiuxwe2 1444 1394 ;; 1445 1445 - -syllable*) 1446 1446 - os=-syllable 1395 1395 + lynx*178) 1396 1396 + os=lynxos178 1447 1397 ;; 1448 1448 - -386bsd) 1449 1449 - os=-bsd 1398 1398 + lynx*5) 1399 1399 + os=lynxos5 1450 1400 ;; 1451 1451 - -ctix* | -uts*) 1452 1452 - os=-sysv 1401 1401 + lynxos*) 1402 1402 + # don't get caught up in next wildcard 1453 1403 ;; 1454 1454 - -nova*) 1455 1455 - os=-rtmk-nova 1404 1404 + lynx*) 1405 1405 + os=lynxos 1456 1406 ;; 1457 1457 - -ns2 ) 1458 1458 - os=-nextstep2 1407 1407 + mac[0-9]*) 1408 1408 + os=`echo "$os" | sed -e 's|mac|macos|'` 1459 1409 ;; 1460 1460 - -nsk*) 1461 1461 - os=-nsk 1410 1410 + opened*) 1411 1411 + os=openedition 1462 1412 ;; 1463 1463 - # Preserve the version number of sinix5. 1464 1464 - -sinix5.*) 1465 1465 - os=`echo $os | sed -e 's|sinix|sysv|'` 1413 1413 + os400*) 1414 1414 + os=os400 1466 1415 ;; 1467 1467 - -sinix*) 1468 1468 - os=-sysv4 1416 1416 + sunos5*) 1417 1417 + os=`echo "$os" | sed -e 's|sunos5|solaris2|'` 1469 1418 ;; 1470 1470 - -tpf*) 1471 1471 - os=-tpf 1419 1419 + sunos6*) 1420 1420 + os=`echo "$os" | sed -e 's|sunos6|solaris3|'` 1472 1421 ;; 1473 1473 - -triton*) 1474 1474 - os=-sysv3 1422 1422 + wince*) 1423 1423 + os=wince 1475 1424 ;; 1476 1476 - -oss*) 1477 1477 - os=-sysv3 1425 1425 + utek*) 1426 1426 + os=bsd 1478 1427 ;; 1479 1479 - -svr4) 1480 1480 - os=-sysv4 1428 1428 + dynix*) 1429 1429 + os=bsd 1481 1430 ;; 1482 1482 - -svr3) 1483 1483 - os=-sysv3 1431 1431 + acis*) 1432 1432 + os=aos 1433 1433 + ;; 1434 1434 + atheos*) 1435 1435 + os=atheos 1436 1436 + ;; 1437 1437 + syllable*) 1438 1438 + os=syllable 1439 1439 + ;; 1440 1440 + 386bsd) 1441 1441 + os=bsd 1442 1442 + ;; 1443 1443 + ctix* | uts*) 1444 1444 + os=sysv 1445 1445 + ;; 1446 1446 + nova*) 1447 1447 + os=rtmk-nova 1448 1448 + ;; 1449 1449 + ns2) 1450 1450 + os=nextstep2 1451 1451 + ;; 1452 1452 + # Preserve the version number of sinix5. 1453 1453 + sinix5.*) 1454 1454 + os=`echo "$os" | sed -e 's|sinix|sysv|'` 1484 1455 ;; 1485 1485 - -sysvr4) 1486 1486 - os=-sysv4 1456 1456 + sinix*) 1457 1457 + os=sysv4 1487 1458 ;; 1488 1488 - # This must come after -sysvr4. 1489 1489 - -sysv*) 1459 1459 + tpf*) 1460 1460 + os=tpf 1490 1461 ;; 1491 1491 - -ose*) 1492 1492 - os=-ose 1462 1462 + triton*) 1463 1463 + os=sysv3 1493 1464 ;; 1494 1494 - -es1800*) 1495 1495 - os=-ose 1465 1465 + oss*) 1466 1466 + os=sysv3 1496 1467 ;; 1497 1497 - -xenix) 1498 1498 - os=-xenix 1468 1468 + svr4*) 1469 1469 + os=sysv4 1499 1470 ;; 1500 1500 - -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) 1501 1501 - os=-mint 1471 1471 + svr3) 1472 1472 + os=sysv3 1502 1473 ;; 1503 1503 - -aros*) 1504 1504 - os=-aros 1474 1474 + sysvr4) 1475 1475 + os=sysv4 1505 1476 ;; 1506 1506 - -kaos*) 1507 1507 - os=-kaos 1477 1477 + ose*) 1478 1478 + os=ose 1508 1479 ;; 1509 1509 - -zvmoe) 1510 1510 - os=-zvmoe 1480 1480 + *mint | mint[0-9]* | *MiNT | MiNT[0-9]*) 1481 1481 + os=mint 1511 1482 ;; 1512 1512 - -dicos*) 1513 1513 - os=-dicos 1483 1483 + dicos*) 1484 1484 + os=dicos 1514 1485 ;; 1515 1515 - -nacl*) 1486 1486 + pikeos*) 1487 1487 + # Until real need of OS specific support for 1488 1488 + # particular features comes up, bare metal 1489 1489 + # configurations are quite functional. 1490 1490 + case $cpu in 1491 1491 + arm*) 1492 1492 + os=eabi 1493 1493 + ;; 1494 1494 + *) 1495 1495 + os= 1496 1496 + obj=elf 1497 1497 + ;; 1498 1498 + esac 1516 1499 ;; 1517 1517 - -none) 1500 1500 + aout* | coff* | elf* | pe*) 1501 1501 + # These are machine code file formats, not OSes 1502 1502 + obj=$os 1503 1503 + os= 1518 1504 ;; 1519 1505 *) 1520 1520 - # Get rid of the `-' at the beginning of $os. 1521 1521 - os=`echo $os | sed 's/[^-]*-//'` 1522 1522 - echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 1523 1523 - exit 1 1506 1506 + # No normalization, but not necessarily accepted, that comes below. 1524 1507 ;; 1525 1508 esac 1509 1509 + 1526 1510 else 1527 1511 1528 1512 # Here we handle the default operating systems that come with various machines. ··· 1535 1519 # will signal an error saying that MANUFACTURER isn't an operating 1536 1520 # system, and we'll never get to this point. 1537 1521 1538 1538 - case $basic_machine in 1522 1522 + kernel= 1523 1523 + obj= 1524 1524 + case $cpu-$vendor in 1539 1525 score-*) 1540 1540 - os=-elf 1526 1526 + os= 1527 1527 + obj=elf 1541 1528 ;; 1542 1529 spu-*) 1543 1543 - os=-elf 1530 1530 + os= 1531 1531 + obj=elf 1544 1532 ;; 1545 1533 *-acorn) 1546 1546 - os=-riscix1.2 1534 1534 + os=riscix1.2 1547 1535 ;; 1548 1536 arm*-rebel) 1549 1549 - os=-linux 1537 1537 + kernel=linux 1538 1538 + os=gnu 1550 1539 ;; 1551 1540 arm*-semi) 1552 1552 - os=-aout 1541 1541 + os= 1542 1542 + obj=aout 1553 1543 ;; 1554 1544 c4x-* | tic4x-*) 1555 1555 - os=-coff 1545 1545 + os= 1546 1546 + obj=coff 1547 1547 + ;; 1548 1548 + c8051-*) 1549 1549 + os= 1550 1550 + obj=elf 1551 1551 + ;; 1552 1552 + clipper-intergraph) 1553 1553 + os=clix 1556 1554 ;; 1557 1555 hexagon-*) 1558 1558 - os=-elf 1556 1556 + os= 1557 1557 + obj=elf 1559 1558 ;; 1560 1559 tic54x-*) 1561 1561 - os=-coff 1560 1560 + os= 1561 1561 + obj=coff 1562 1562 ;; 1563 1563 tic55x-*) 1564 1564 - os=-coff 1564 1564 + os= 1565 1565 + obj=coff 1565 1566 ;; 1566 1567 tic6x-*) 1567 1567 - os=-coff 1568 1568 + os= 1569 1569 + obj=coff 1568 1570 ;; 1569 1571 # This must come before the *-dec entry. 1570 1572 pdp10-*) 1571 1571 - os=-tops20 1573 1573 + os=tops20 1572 1574 ;; 1573 1575 pdp11-*) 1574 1574 - os=-none 1576 1576 + os=none 1575 1577 ;; 1576 1578 *-dec | vax-*) 1577 1577 - os=-ultrix4.2 1579 1579 + os=ultrix4.2 1578 1580 ;; 1579 1581 m68*-apollo) 1580 1580 - os=-domain 1582 1582 + os=domain 1581 1583 ;; 1582 1584 i386-sun) 1583 1583 - os=-sunos4.0.2 1585 1585 + os=sunos4.0.2 1584 1586 ;; 1585 1587 m68000-sun) 1586 1586 - os=-sunos3 1588 1588 + os=sunos3 1587 1589 ;; 1588 1590 m68*-cisco) 1589 1589 - os=-aout 1591 1591 + os= 1592 1592 + obj=aout 1590 1593 ;; 1591 1594 mep-*) 1592 1592 - os=-elf 1595 1595 + os= 1596 1596 + obj=elf 1593 1597 ;; 1594 1598 mips*-cisco) 1595 1595 - os=-elf 1599 1599 + os= 1600 1600 + obj=elf 1596 1601 ;; 1597 1597 - mips*-*) 1598 1598 - os=-elf 1602 1602 + mips*-*|nanomips*-*) 1603 1603 + os= 1604 1604 + obj=elf 1599 1605 ;; 1600 1606 or32-*) 1601 1601 - os=-coff 1607 1607 + os= 1608 1608 + obj=coff 1602 1609 ;; 1603 1610 *-tti) # must be before sparc entry or we get the wrong os. 1604 1604 - os=-sysv3 1611 1611 + os=sysv3 1605 1612 ;; 1606 1613 sparc-* | *-sun) 1607 1607 - os=-sunos4.1.1 1614 1614 + os=sunos4.1.1 1608 1615 ;; 1609 1609 - *-be) 1610 1610 - os=-beos 1616 1616 + pru-*) 1617 1617 + os= 1618 1618 + obj=elf 1611 1619 ;; 1612 1612 - *-haiku) 1613 1613 - os=-haiku 1620 1620 + *-be) 1621 1621 + os=beos 1614 1622 ;; 1615 1623 *-ibm) 1616 1616 - os=-aix 1624 1624 + os=aix 1617 1625 ;; 1618 1626 *-knuth) 1619 1619 - os=-mmixware 1627 1627 + os=mmixware 1620 1628 ;; 1621 1629 *-wec) 1622 1622 - os=-proelf 1630 1630 + os=proelf 1623 1631 ;; 1624 1632 *-winbond) 1625 1625 - os=-proelf 1633 1633 + os=proelf 1626 1634 ;; 1627 1635 *-oki) 1628 1628 - os=-proelf 1636 1636 + os=proelf 1629 1637 ;; 1630 1638 *-hp) 1631 1631 - os=-hpux 1639 1639 + os=hpux 1632 1640 ;; 1633 1641 *-hitachi) 1634 1634 - os=-hiux 1642 1642 + os=hiux 1635 1643 ;; 1636 1644 i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) 1637 1637 - os=-sysv 1645 1645 + os=sysv 1638 1646 ;; 1639 1647 *-cbm) 1640 1640 - os=-amigaos 1648 1648 + os=amigaos 1641 1649 ;; 1642 1650 *-dg) 1643 1643 - os=-dgux 1651 1651 + os=dgux 1644 1652 ;; 1645 1653 *-dolphin) 1646 1646 - os=-sysv3 1654 1654 + os=sysv3 1647 1655 ;; 1648 1656 m68k-ccur) 1649 1649 - os=-rtu 1657 1657 + os=rtu 1650 1658 ;; 1651 1659 m88k-omron*) 1652 1652 - os=-luna 1660 1660 + os=luna 1653 1661 ;; 1654 1654 - *-next ) 1655 1655 - os=-nextstep 1662 1662 + *-next) 1663 1663 + os=nextstep 1656 1664 ;; 1657 1665 *-sequent) 1658 1658 - os=-ptx 1666 1666 + os=ptx 1659 1667 ;; 1660 1668 *-crds) 1661 1661 - os=-unos 1669 1669 + os=unos 1662 1670 ;; 1663 1671 *-ns) 1664 1664 - os=-genix 1672 1672 + os=genix 1665 1673 ;; 1666 1674 i370-*) 1667 1667 - os=-mvs 1668 1668 - ;; 1669 1669 - *-next) 1670 1670 - os=-nextstep3 1675 1675 + os=mvs 1671 1676 ;; 1672 1677 *-gould) 1673 1673 - os=-sysv 1678 1678 + os=sysv 1674 1679 ;; 1675 1680 *-highlevel) 1676 1676 - os=-bsd 1681 1681 + os=bsd 1677 1682 ;; 1678 1683 *-encore) 1679 1679 - os=-bsd 1684 1684 + os=bsd 1680 1685 ;; 1681 1686 *-sgi) 1682 1682 - os=-irix 1687 1687 + os=irix 1683 1688 ;; 1684 1689 *-siemens) 1685 1685 - os=-sysv4 1690 1690 + os=sysv4 1686 1691 ;; 1687 1692 *-masscomp) 1688 1688 - os=-rtu 1693 1693 + os=rtu 1689 1694 ;; 1690 1695 f30[01]-fujitsu | f700-fujitsu) 1691 1691 - os=-uxpv 1696 1696 + os=uxpv 1692 1697 ;; 1693 1698 *-rom68k) 1694 1694 - os=-coff 1699 1699 + os= 1700 1700 + obj=coff 1695 1701 ;; 1696 1702 *-*bug) 1697 1697 - os=-coff 1703 1703 + os= 1704 1704 + obj=coff 1698 1705 ;; 1699 1706 *-apple) 1700 1700 - os=-macos 1707 1707 + os=macos 1701 1708 ;; 1702 1709 *-atari*) 1703 1703 - os=-mint 1710 1710 + os=mint 1711 1711 + ;; 1712 1712 + *-wrs) 1713 1713 + os=vxworks 1704 1714 ;; 1705 1715 *) 1706 1706 - os=-none 1716 1716 + os=none 1707 1717 ;; 1708 1718 esac 1719 1719 + 1709 1720 fi 1710 1721 1722 1722 + # Now, validate our (potentially fixed-up) individual pieces (OS, OBJ). 1723 1723 + 1724 1724 + case $os in 1725 1725 + # Sometimes we do "kernel-libc", so those need to count as OSes. 1726 1726 + llvm* | musl* | newlib* | relibc* | uclibc*) 1727 1727 + ;; 1728 1728 + # Likewise for "kernel-abi" 1729 1729 + eabi* | gnueabi*) 1730 1730 + ;; 1731 1731 + # VxWorks passes extra cpu info in the 4th filed. 1732 1732 + simlinux | simwindows | spe) 1733 1733 + ;; 1734 1734 + # See `case $cpu-$os` validation below 1735 1735 + ghcjs) 1736 1736 + ;; 1737 1737 + # Now accept the basic system types. 1738 1738 + # The portable systems comes first. 1739 1739 + # Each alternative MUST end in a * to match a version number. 1740 1740 + gnu* | android* | bsd* | mach* | minix* | genix* | ultrix* | irix* \ 1741 1741 + | *vms* | esix* | aix* | cnk* | sunos | sunos[34]* \ 1742 1742 + | hpux* | unos* | osf* | luna* | dgux* | auroraux* | solaris* \ 1743 1743 + | sym* | plan9* | psp* | sim* | xray* | os68k* | v88r* \ 1744 1744 + | hiux* | abug | nacl* | netware* | windows* \ 1745 1745 + | os9* | macos* | osx* | ios* | tvos* | watchos* \ 1746 1746 + | mpw* | magic* | mmixware* | mon960* | lnews* \ 1747 1747 + | amigaos* | amigados* | msdos* | newsos* | unicos* | aof* \ 1748 1748 + | aos* | aros* | cloudabi* | sortix* | twizzler* \ 1749 1749 + | nindy* | vxsim* | vxworks* | ebmon* | hms* | mvs* \ 1750 1750 + | clix* | riscos* | uniplus* | iris* | isc* | rtu* | xenix* \ 1751 1751 + | mirbsd* | netbsd* | dicos* | openedition* | ose* \ 1752 1752 + | bitrig* | openbsd* | secbsd* | solidbsd* | libertybsd* | os108* \ 1753 1753 + | ekkobsd* | freebsd* | riscix* | lynxos* | os400* \ 1754 1754 + | bosx* | nextstep* | cxux* | oabi* \ 1755 1755 + | ptx* | ecoff* | winnt* | domain* | vsta* \ 1756 1756 + | udi* | lites* | ieee* | go32* | aux* | hcos* \ 1757 1757 + | chorusrdb* | cegcc* | glidix* | serenity* \ 1758 1758 + | cygwin* | msys* | moss* | proelf* | rtems* \ 1759 1759 + | midipix* | mingw32* | mingw64* | mint* \ 1760 1760 + | uxpv* | beos* | mpeix* | udk* | moxiebox* \ 1761 1761 + | interix* | uwin* | mks* | rhapsody* | darwin* \ 1762 1762 + | openstep* | oskit* | conix* | pw32* | nonstopux* \ 1763 1763 + | storm-chaos* | tops10* | tenex* | tops20* | its* \ 1764 1764 + | os2* | vos* | palmos* | uclinux* | nucleus* | morphos* \ 1765 1765 + | scout* | superux* | sysv* | rtmk* | tpf* | windiss* \ 1766 1766 + | powermax* | dnix* | nx6 | nx7 | sei* | dragonfly* \ 1767 1767 + | skyos* | haiku* | rdos* | toppers* | drops* | es* \ 1768 1768 + | onefs* | tirtos* | phoenix* | fuchsia* | redox* | bme* \ 1769 1769 + | midnightbsd* | amdhsa* | unleashed* | emscripten* | wasi* \ 1770 1770 + | nsk* | powerunix* | genode* | zvmoe* | qnx* | emx* | zephyr* \ 1771 1771 + | fiwix* | mlibc* | cos* | mbr* | ironclad* ) 1772 1772 + ;; 1773 1773 + # This one is extra strict with allowed versions 1774 1774 + sco3.2v2 | sco3.2v[4-9]* | sco5v6*) 1775 1775 + # Don't forget version if it is 3.2v4 or newer. 1776 1776 + ;; 1777 1777 + # This refers to builds using the UEFI calling convention 1778 1778 + # (which depends on the architecture) and PE file format. 1779 1779 + # Note that this is both a different calling convention and 1780 1780 + # different file format than that of GNU-EFI 1781 1781 + # (x86_64-w64-mingw32). 1782 1782 + uefi) 1783 1783 + ;; 1784 1784 + none) 1785 1785 + ;; 1786 1786 + kernel* | msvc* ) 1787 1787 + # Restricted further below 1788 1788 + ;; 1789 1789 + '') 1790 1790 + if test x"$obj" = x 1791 1791 + then 1792 1792 + echo "Invalid configuration '$1': Blank OS only allowed with explicit machine code file format" 1>&2 1793 1793 + fi 1794 1794 + ;; 1795 1795 + *) 1796 1796 + echo "Invalid configuration '$1': OS '$os' not recognized" 1>&2 1797 1797 + exit 1 1798 1798 + ;; 1799 1799 + esac 1800 1800 + 1801 1801 + case $obj in 1802 1802 + aout* | coff* | elf* | pe*) 1803 1803 + ;; 1804 1804 + '') 1805 1805 + # empty is fine 1806 1806 + ;; 1807 1807 + *) 1808 1808 + echo "Invalid configuration '$1': Machine code format '$obj' not recognized" 1>&2 1809 1809 + exit 1 1810 1810 + ;; 1811 1811 + esac 1812 1812 + 1813 1813 + # Here we handle the constraint that a (synthetic) cpu and os are 1814 1814 + # valid only in combination with each other and nowhere else. 1815 1815 + case $cpu-$os in 1816 1816 + # The "javascript-unknown-ghcjs" triple is used by GHC; we 1817 1817 + # accept it here in order to tolerate that, but reject any 1818 1818 + # variations. 1819 1819 + javascript-ghcjs) 1820 1820 + ;; 1821 1821 + javascript-* | *-ghcjs) 1822 1822 + echo "Invalid configuration '$1': cpu '$cpu' is not valid with os '$os$obj'" 1>&2 1823 1823 + exit 1 1824 1824 + ;; 1825 1825 + esac 1826 1826 + 1827 1827 + # As a final step for OS-related things, validate the OS-kernel combination 1828 1828 + # (given a valid OS), if there is a kernel. 1829 1829 + case $kernel-$os-$obj in 1830 1830 + linux-gnu*- | linux-android*- | linux-dietlibc*- | linux-llvm*- \ 1831 1831 + | linux-mlibc*- | linux-musl*- | linux-newlib*- \ 1832 1832 + | linux-relibc*- | linux-uclibc*- ) 1833 1833 + ;; 1834 1834 + uclinux-uclibc*- ) 1835 1835 + ;; 1836 1836 + managarm-mlibc*- | managarm-kernel*- ) 1837 1837 + ;; 1838 1838 + windows*-msvc*-) 1839 1839 + ;; 1840 1840 + -dietlibc*- | -llvm*- | -mlibc*- | -musl*- | -newlib*- | -relibc*- \ 1841 1841 + | -uclibc*- ) 1842 1842 + # These are just libc implementations, not actual OSes, and thus 1843 1843 + # require a kernel. 1844 1844 + echo "Invalid configuration '$1': libc '$os' needs explicit kernel." 1>&2 1845 1845 + exit 1 1846 1846 + ;; 1847 1847 + -kernel*- ) 1848 1848 + echo "Invalid configuration '$1': '$os' needs explicit kernel." 1>&2 1849 1849 + exit 1 1850 1850 + ;; 1851 1851 + *-kernel*- ) 1852 1852 + echo "Invalid configuration '$1': '$kernel' does not support '$os'." 1>&2 1853 1853 + exit 1 1854 1854 + ;; 1855 1855 + *-msvc*- ) 1856 1856 + echo "Invalid configuration '$1': '$os' needs 'windows'." 1>&2 1857 1857 + exit 1 1858 1858 + ;; 1859 1859 + kfreebsd*-gnu*- | kopensolaris*-gnu*-) 1860 1860 + ;; 1861 1861 + vxworks-simlinux- | vxworks-simwindows- | vxworks-spe-) 1862 1862 + ;; 1863 1863 + nto-qnx*-) 1864 1864 + ;; 1865 1865 + os2-emx-) 1866 1866 + ;; 1867 1867 + *-eabi*- | *-gnueabi*-) 1868 1868 + ;; 1869 1869 + none--*) 1870 1870 + # None (no kernel, i.e. freestanding / bare metal), 1871 1871 + # can be paired with an machine code file format 1872 1872 + ;; 1873 1873 + -*-) 1874 1874 + # Blank kernel with real OS is always fine. 1875 1875 + ;; 1876 1876 + --*) 1877 1877 + # Blank kernel and OS with real machine code file format is always fine. 1878 1878 + ;; 1879 1879 + *-*-*) 1880 1880 + echo "Invalid configuration '$1': Kernel '$kernel' not known to work with OS '$os'." 1>&2 1881 1881 + exit 1 1882 1882 + ;; 1883 1883 + esac 1884 1884 + 1711 1885 # Here we handle the case where we know the os, and the CPU type, but not the 1712 1886 # manufacturer. We pick the logical manufacturer. 1713 1713 - vendor=unknown 1714 1714 - case $basic_machine in 1715 1715 - *-unknown) 1716 1716 - case $os in 1717 1717 - -riscix*) 1887 1887 + case $vendor in 1888 1888 + unknown) 1889 1889 + case $cpu-$os in 1890 1890 + *-riscix*) 1718 1891 vendor=acorn 1719 1892 ;; 1720 1720 - -sunos*) 1893 1893 + *-sunos*) 1721 1894 vendor=sun 1722 1895 ;; 1723 1723 - -cnk*|-aix*) 1896 1896 + *-cnk* | *-aix*) 1724 1897 vendor=ibm 1725 1898 ;; 1726 1726 - -beos*) 1899 1899 + *-beos*) 1727 1900 vendor=be 1728 1901 ;; 1729 1729 - -hpux*) 1902 1902 + *-hpux*) 1730 1903 vendor=hp 1731 1904 ;; 1732 1732 - -mpeix*) 1905 1905 + *-mpeix*) 1733 1906 vendor=hp 1734 1907 ;; 1735 1735 - -hiux*) 1908 1908 + *-hiux*) 1736 1909 vendor=hitachi 1737 1910 ;; 1738 1738 - -unos*) 1911 1911 + *-unos*) 1739 1912 vendor=crds 1740 1913 ;; 1741 1741 - -dgux*) 1914 1914 + *-dgux*) 1742 1915 vendor=dg 1743 1916 ;; 1744 1744 - -luna*) 1917 1917 + *-luna*) 1745 1918 vendor=omron 1746 1919 ;; 1747 1747 - -genix*) 1920 1920 + *-genix*) 1748 1921 vendor=ns 1749 1922 ;; 1750 1750 - -mvs* | -opened*) 1923 1923 + *-clix*) 1924 1924 + vendor=intergraph 1925 1925 + ;; 1926 1926 + *-mvs* | *-opened*) 1751 1927 vendor=ibm 1752 1928 ;; 1753 1753 - -os400*) 1929 1929 + *-os400*) 1754 1930 vendor=ibm 1755 1931 ;; 1756 1756 - -ptx*) 1932 1932 + s390-* | s390x-*) 1933 1933 + vendor=ibm 1934 1934 + ;; 1935 1935 + *-ptx*) 1757 1936 vendor=sequent 1758 1937 ;; 1759 1759 - -tpf*) 1938 1938 + *-tpf*) 1760 1939 vendor=ibm 1761 1940 ;; 1762 1762 - -vxsim* | -vxworks* | -windiss*) 1941 1941 + *-vxsim* | *-vxworks* | *-windiss*) 1763 1942 vendor=wrs 1764 1943 ;; 1765 1765 - -aux*) 1944 1944 + *-aux*) 1766 1945 vendor=apple 1767 1946 ;; 1768 1768 - -hms*) 1947 1947 + *-hms*) 1769 1948 vendor=hitachi 1770 1949 ;; 1771 1771 - -mpw* | -macos*) 1950 1950 + *-mpw* | *-macos*) 1772 1951 vendor=apple 1773 1952 ;; 1774 1774 - -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) 1953 1953 + *-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*) 1775 1954 vendor=atari 1776 1955 ;; 1777 1777 - -vos*) 1956 1956 + *-vos*) 1778 1957 vendor=stratus 1779 1958 ;; 1780 1959 esac 1781 1781 - basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` 1782 1960 ;; 1783 1961 esac 1784 1962 1785 1785 - echo $basic_machine$os 1963 1963 + echo "$cpu-$vendor${kernel:+-$kernel}${os:+-$os}${obj:+-$obj}" 1786 1964 exit 1787 1965 1788 1966 # Local variables: 1789 1789 - # eval: (add-hook 'write-file-hooks 'time-stamp) 1967 1967 + # eval: (add-hook 'before-save-hook 'time-stamp) 1790 1968 # time-stamp-start: "timestamp='" 1791 1969 # time-stamp-format: "%:y-%02m-%02d" 1792 1970 # time-stamp-end: "'"

+3451 -3098

app/xkbevd/configure

reviewed

··· 1 1 #! /bin/sh 2 2 # Guess values for system-dependent variables and create Makefiles. 3 3 - # Generated by GNU Autoconf 2.69 for xkbevd 1.1.5. 3 3 + # Generated by GNU Autoconf 2.71 for xkbevd 1.1.6. 4 4 # 5 5 # Report bugs to <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/issues>. 6 6 # 7 7 # 8 8 - # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. 8 8 + # Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation, 9 9 + # Inc. 9 10 # 10 11 # 11 12 # This configure script is free software; the Free Software Foundation ··· 16 17 17 18 # Be more Bourne compatible 18 19 DUALCASE=1; export DUALCASE # for MKS sh 19 19 - if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : 20 20 + as_nop=: 21 21 + if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 22 22 + then : 20 23 emulate sh 21 24 NULLCMD=: 22 25 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which 23 26 # is contrary to our usage. Disable this feature. 24 27 alias -g '${1+"$@"}'='"$@"' 25 28 setopt NO_GLOB_SUBST 26 26 - else 29 29 + else $as_nop 27 30 case `(set -o) 2>/dev/null` in #( 28 31 *posix*) : 29 32 set -o posix ;; #( ··· 33 36 fi 34 37 35 38 39 39 + 40 40 + # Reset variables that may have inherited troublesome values from 41 41 + # the environment. 42 42 + 43 43 + # IFS needs to be set, to space, tab, and newline, in precisely that order. 44 44 + # (If _AS_PATH_WALK were called with IFS unset, it would have the 45 45 + # side effect of setting IFS to empty, thus disabling word splitting.) 46 46 + # Quoting is to prevent editors from complaining about space-tab. 36 47 as_nl=' 37 48 ' 38 49 export as_nl 39 39 - # Printing a long string crashes Solaris 7 /usr/bin/printf. 40 40 - as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' 41 41 - as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo 42 42 - as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo 43 43 - # Prefer a ksh shell builtin over an external printf program on Solaris, 44 44 - # but without wasting forks for bash or zsh. 45 45 - if test -z "$BASH_VERSION$ZSH_VERSION" \ 46 46 - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then 47 47 - as_echo='print -r --' 48 48 - as_echo_n='print -rn --' 49 49 - elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then 50 50 - as_echo='printf %s\n' 51 51 - as_echo_n='printf %s' 52 52 - else 53 53 - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then 54 54 - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' 55 55 - as_echo_n='/usr/ucb/echo -n' 56 56 - else 57 57 - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' 58 58 - as_echo_n_body='eval 59 59 - arg=$1; 60 60 - case $arg in #( 61 61 - *"$as_nl"*) 62 62 - expr "X$arg" : "X\\(.*\\)$as_nl"; 63 63 - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; 64 64 - esac; 65 65 - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" 66 66 - ' 67 67 - export as_echo_n_body 68 68 - as_echo_n='sh -c $as_echo_n_body as_echo' 69 69 - fi 70 70 - export as_echo_body 71 71 - as_echo='sh -c $as_echo_body as_echo' 72 72 - fi 50 50 + IFS=" "" $as_nl" 51 51 + 52 52 + PS1='$ ' 53 53 + PS2='> ' 54 54 + PS4='+ ' 55 55 + 56 56 + # Ensure predictable behavior from utilities with locale-dependent output. 57 57 + LC_ALL=C 58 58 + export LC_ALL 59 59 + LANGUAGE=C 60 60 + export LANGUAGE 61 61 + 62 62 + # We cannot yet rely on "unset" to work, but we need these variables 63 63 + # to be unset--not just set to an empty or harmless value--now, to 64 64 + # avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct 65 65 + # also avoids known problems related to "unset" and subshell syntax 66 66 + # in other old shells (e.g. bash 2.01 and pdksh 5.2.14). 67 67 + for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH 68 68 + do eval test \${$as_var+y} \ 69 69 + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : 70 70 + done 71 71 + 72 72 + # Ensure that fds 0, 1, and 2 are open. 73 73 + if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi 74 74 + if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi 75 75 + if (exec 3>&2) ; then :; else exec 2>/dev/null; fi 73 76 74 77 # The user is always right. 75 75 - if test "${PATH_SEPARATOR+set}" != set; then 78 78 + if ${PATH_SEPARATOR+false} :; then 76 79 PATH_SEPARATOR=: 77 80 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { 78 81 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || ··· 81 84 fi 82 85 83 86 84 84 - # IFS 85 85 - # We need space, tab and new line, in precisely that order. Quoting is 86 86 - # there to prevent editors from complaining about space-tab. 87 87 - # (If _AS_PATH_WALK were called with IFS unset, it would disable word 88 88 - # splitting by setting IFS to empty value.) 89 89 - IFS=" "" $as_nl" 90 90 - 91 87 # Find who we are. Look in the path if we contain no directory separator. 92 88 as_myself= 93 89 case $0 in #(( ··· 96 92 for as_dir in $PATH 97 93 do 98 94 IFS=$as_save_IFS 99 99 - test -z "$as_dir" && as_dir=. 100 100 - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break 95 95 + case $as_dir in #((( 96 96 + '') as_dir=./ ;; 97 97 + */) ;; 98 98 + *) as_dir=$as_dir/ ;; 99 99 + esac 100 100 + test -r "$as_dir$0" && as_myself=$as_dir$0 && break 101 101 done 102 102 IFS=$as_save_IFS 103 103 ··· 109 109 as_myself=$0 110 110 fi 111 111 if test ! -f "$as_myself"; then 112 112 - $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 112 112 + printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 113 113 exit 1 114 114 fi 115 115 116 116 - # Unset variables that we do not need and which cause bugs (e.g. in 117 117 - # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" 118 118 - # suppresses any "Segmentation fault" message there. '((' could 119 119 - # trigger a bug in pdksh 5.2.14. 120 120 - for as_var in BASH_ENV ENV MAIL MAILPATH 121 121 - do eval test x\${$as_var+set} = xset \ 122 122 - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : 123 123 - done 124 124 - PS1='$ ' 125 125 - PS2='> ' 126 126 - PS4='+ ' 127 127 - 128 128 - # NLS nuisances. 129 129 - LC_ALL=C 130 130 - export LC_ALL 131 131 - LANGUAGE=C 132 132 - export LANGUAGE 133 133 - 134 134 - # CDPATH. 135 135 - (unset CDPATH) >/dev/null 2>&1 && unset CDPATH 136 116 137 117 # Use a proper internal environment variable to ensure we don't fall 138 118 # into an infinite loop, continuously re-executing ourselves. ··· 154 134 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} 155 135 # Admittedly, this is quite paranoid, since all the known shells bail 156 136 # out after a failed `exec'. 157 157 - $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 158 158 - as_fn_exit 255 137 137 + printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 138 138 + exit 255 159 139 fi 160 140 # We don't want this to propagate to other subprocesses. 161 141 { _as_can_reexec=; unset _as_can_reexec;} 162 142 if test "x$CONFIG_SHELL" = x; then 163 163 - as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : 143 143 + as_bourne_compatible="as_nop=: 144 144 + if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 145 145 + then : 164 146 emulate sh 165 147 NULLCMD=: 166 148 # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which 167 149 # is contrary to our usage. Disable this feature. 168 150 alias -g '\${1+\"\$@\"}'='\"\$@\"' 169 151 setopt NO_GLOB_SUBST 170 170 - else 152 152 + else \$as_nop 171 153 case \`(set -o) 2>/dev/null\` in #( 172 154 *posix*) : 173 155 set -o posix ;; #( ··· 187 169 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } 188 170 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } 189 171 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } 190 190 - if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : 172 172 + if ( set x; as_fn_ret_success y && test x = \"\$1\" ) 173 173 + then : 191 174 192 192 - else 175 175 + else \$as_nop 193 176 exitcode=1; echo positional parameters were not saved. 194 177 fi 195 178 test x\$exitcode = x0 || exit 1 179 179 + blah=\$(echo \$(echo blah)) 180 180 + test x\"\$blah\" = xblah || exit 1 196 181 test -x / || exit 1" 197 182 as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO 198 183 as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO 199 184 eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && 200 185 test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 201 186 test \$(( 1 + 1 )) = 2 || exit 1" 202 202 - if (eval "$as_required") 2>/dev/null; then : 187 187 + if (eval "$as_required") 2>/dev/null 188 188 + then : 203 189 as_have_required=yes 204 204 - else 190 190 + else $as_nop 205 191 as_have_required=no 206 192 fi 207 207 - if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : 193 193 + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null 194 194 + then : 208 195 209 209 - else 196 196 + else $as_nop 210 197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 211 198 as_found=false 212 199 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH 213 200 do 214 201 IFS=$as_save_IFS 215 215 - test -z "$as_dir" && as_dir=. 202 202 + case $as_dir in #((( 203 203 + '') as_dir=./ ;; 204 204 + */) ;; 205 205 + *) as_dir=$as_dir/ ;; 206 206 + esac 216 207 as_found=: 217 208 case $as_dir in #( 218 209 /*) 219 210 for as_base in sh bash ksh sh5; do 220 211 # Try only shells that exist, to save several forks. 221 221 - as_shell=$as_dir/$as_base 212 212 + as_shell=$as_dir$as_base 222 213 if { test -f "$as_shell" || test -f "$as_shell.exe"; } && 223 223 - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : 214 214 + as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null 215 215 + then : 224 216 CONFIG_SHELL=$as_shell as_have_required=yes 225 225 - if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : 217 217 + if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null 218 218 + then : 226 219 break 2 227 220 fi 228 221 fi ··· 230 223 esac 231 224 as_found=false 232 225 done 233 233 - $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && 234 234 - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : 235 235 - CONFIG_SHELL=$SHELL as_have_required=yes 236 236 - fi; } 237 226 IFS=$as_save_IFS 227 227 + if $as_found 228 228 + then : 238 229 230 230 + else $as_nop 231 231 + if { test -f "$SHELL" || test -f "$SHELL.exe"; } && 232 232 + as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null 233 233 + then : 234 234 + CONFIG_SHELL=$SHELL as_have_required=yes 235 235 + fi 236 236 + fi 239 237 240 240 - if test "x$CONFIG_SHELL" != x; then : 238 238 + 239 239 + if test "x$CONFIG_SHELL" != x 240 240 + then : 241 241 export CONFIG_SHELL 242 242 # We cannot yet assume a decent shell, so we have to provide a 243 243 # neutralization value for shells without unset; and this also ··· 255 255 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} 256 256 # Admittedly, this is quite paranoid, since all the known shells bail 257 257 # out after a failed `exec'. 258 258 - $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 258 258 + printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 259 259 exit 255 260 260 fi 261 261 262 262 - if test x$as_have_required = xno; then : 263 263 - $as_echo "$0: This script requires a shell more modern than all" 264 264 - $as_echo "$0: the shells that I found on your system." 265 265 - if test x${ZSH_VERSION+set} = xset ; then 266 266 - $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" 267 267 - $as_echo "$0: be upgraded to zsh 4.3.4 or later." 262 262 + if test x$as_have_required = xno 263 263 + then : 264 264 + printf "%s\n" "$0: This script requires a shell more modern than all" 265 265 + printf "%s\n" "$0: the shells that I found on your system." 266 266 + if test ${ZSH_VERSION+y} ; then 267 267 + printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should" 268 268 + printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later." 268 269 else 269 269 - $as_echo "$0: Please tell bug-autoconf@gnu.org and 270 270 + printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and 270 271 $0: https://gitlab.freedesktop.org/xorg/app/xkbevd/-/issues 271 272 $0: about your system, including any error possibly output 272 273 $0: before this message. Then install a modern shell, or ··· 295 296 } 296 297 as_unset=as_fn_unset 297 298 299 299 + 298 300 # as_fn_set_status STATUS 299 301 # ----------------------- 300 302 # Set $? to STATUS, without forking. ··· 312 314 as_fn_set_status $1 313 315 exit $1 314 316 } # as_fn_exit 317 317 + # as_fn_nop 318 318 + # --------- 319 319 + # Do nothing but, unlike ":", preserve the value of $?. 320 320 + as_fn_nop () 321 321 + { 322 322 + return $? 323 323 + } 324 324 + as_nop=as_fn_nop 315 325 316 326 # as_fn_mkdir_p 317 327 # ------------- ··· 326 336 as_dirs= 327 337 while :; do 328 338 case $as_dir in #( 329 329 - *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( 339 339 + *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( 330 340 *) as_qdir=$as_dir;; 331 341 esac 332 342 as_dirs="'$as_qdir' $as_dirs" ··· 335 345 X"$as_dir" : 'X\(//\)[^/]' \| \ 336 346 X"$as_dir" : 'X\(//\)$' \| \ 337 347 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || 338 338 - $as_echo X"$as_dir" | 348 348 + printf "%s\n" X"$as_dir" | 339 349 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 340 350 s//\1/ 341 351 q ··· 374 384 # advantage of any shell optimizations that allow amortized linear growth over 375 385 # repeated appends, instead of the typical quadratic growth present in naive 376 386 # implementations. 377 377 - if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : 387 387 + if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null 388 388 + then : 378 389 eval 'as_fn_append () 379 390 { 380 391 eval $1+=\$2 381 392 }' 382 382 - else 393 393 + else $as_nop 383 394 as_fn_append () 384 395 { 385 396 eval $1=\$$1\$2 ··· 391 402 # Perform arithmetic evaluation on the ARGs, and store the result in the 392 403 # global $as_val. Take advantage of shells that can avoid forks. The arguments 393 404 # must be portable across $(()) and expr. 394 394 - if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : 405 405 + if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null 406 406 + then : 395 407 eval 'as_fn_arith () 396 408 { 397 409 as_val=$(( $* )) 398 410 }' 399 399 - else 411 411 + else $as_nop 400 412 as_fn_arith () 401 413 { 402 414 as_val=`expr "$@" || test $? -eq 1` 403 415 } 404 416 fi # as_fn_arith 405 417 418 418 + # as_fn_nop 419 419 + # --------- 420 420 + # Do nothing but, unlike ":", preserve the value of $?. 421 421 + as_fn_nop () 422 422 + { 423 423 + return $? 424 424 + } 425 425 + as_nop=as_fn_nop 406 426 407 427 # as_fn_error STATUS ERROR [LINENO LOG_FD] 408 428 # ---------------------------------------- ··· 414 434 as_status=$1; test $as_status -eq 0 && as_status=1 415 435 if test "$4"; then 416 436 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 417 417 - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 437 437 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 418 438 fi 419 419 - $as_echo "$as_me: error: $2" >&2 439 439 + printf "%s\n" "$as_me: error: $2" >&2 420 440 as_fn_exit $as_status 421 441 } # as_fn_error 422 442 ··· 443 463 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ 444 464 X"$0" : 'X\(//\)$' \| \ 445 465 X"$0" : 'X\(/\)' \| . 2>/dev/null || 446 446 - $as_echo X/"$0" | 466 466 + printf "%s\n" X/"$0" | 447 467 sed '/^.*\/\([^/][^/]*\)\/*$/{ 448 468 s//\1/ 449 469 q ··· 487 507 s/-\n.*// 488 508 ' >$as_me.lineno && 489 509 chmod +x "$as_me.lineno" || 490 490 - { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } 510 510 + { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } 491 511 492 512 # If we had to re-execute with $CONFIG_SHELL, we're ensured to have 493 513 # already done that, so ensure we don't try to do so again and fall ··· 501 521 exit 502 522 } 503 523 524 524 + 525 525 + # Determine whether it's possible to make 'echo' print without a newline. 526 526 + # These variables are no longer used directly by Autoconf, but are AC_SUBSTed 527 527 + # for compatibility with existing Makefiles. 504 528 ECHO_C= ECHO_N= ECHO_T= 505 529 case `echo -n x` in #((((( 506 530 -n*) ··· 513 537 *) 514 538 ECHO_N='-n';; 515 539 esac 540 540 + 541 541 + # For backward compatibility with old third-party macros, we provide 542 542 + # the shell variables $as_echo and $as_echo_n. New code should use 543 543 + # AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. 544 544 + as_echo='printf %s\n' 545 545 + as_echo_n='printf %s' 546 546 + 516 547 517 548 rm -f conf$$ conf$$.exe conf$$.file 518 549 if test -d conf$$.dir; then ··· 581 612 # Identity of this package. 582 613 PACKAGE_NAME='xkbevd' 583 614 PACKAGE_TARNAME='xkbevd' 584 584 - PACKAGE_VERSION='1.1.5' 585 585 - PACKAGE_STRING='xkbevd 1.1.5' 615 615 + PACKAGE_VERSION='1.1.6' 616 616 + PACKAGE_STRING='xkbevd 1.1.6' 586 617 PACKAGE_BUGREPORT='https://gitlab.freedesktop.org/xorg/app/xkbevd/-/issues' 587 618 PACKAGE_URL='' 588 619 589 620 ac_unique_file="Makefile.am" 590 621 # Factoring default headers for most tests. 591 622 ac_includes_default="\ 592 592 - #include <stdio.h> 593 593 - #ifdef HAVE_SYS_TYPES_H 594 594 - # include <sys/types.h> 623 623 + #include <stddef.h> 624 624 + #ifdef HAVE_STDIO_H 625 625 + # include <stdio.h> 595 626 #endif 596 596 - #ifdef HAVE_SYS_STAT_H 597 597 - # include <sys/stat.h> 598 598 - #endif 599 599 - #ifdef STDC_HEADERS 627 627 + #ifdef HAVE_STDLIB_H 600 628 # include <stdlib.h> 601 601 - # include <stddef.h> 602 602 - #else 603 603 - # ifdef HAVE_STDLIB_H 604 604 - # include <stdlib.h> 605 605 - # endif 606 629 #endif 607 630 #ifdef HAVE_STRING_H 608 608 - # if !defined STDC_HEADERS && defined HAVE_MEMORY_H 609 609 - # include <memory.h> 610 610 - # endif 611 631 # include <string.h> 612 632 #endif 613 613 - #ifdef HAVE_STRINGS_H 614 614 - # include <strings.h> 615 615 - #endif 616 633 #ifdef HAVE_INTTYPES_H 617 634 # include <inttypes.h> 618 635 #endif 619 636 #ifdef HAVE_STDINT_H 620 637 # include <stdint.h> 621 638 #endif 639 639 + #ifdef HAVE_STRINGS_H 640 640 + # include <strings.h> 641 641 + #endif 642 642 + #ifdef HAVE_SYS_TYPES_H 643 643 + # include <sys/types.h> 644 644 + #endif 645 645 + #ifdef HAVE_SYS_STAT_H 646 646 + # include <sys/stat.h> 647 647 + #endif 622 648 #ifdef HAVE_UNISTD_H 623 649 # include <unistd.h> 624 650 #endif" 625 651 652 652 + ac_header_c_list= 626 653 ac_subst_vars='am__EXEEXT_FALSE 627 654 am__EXEEXT_TRUE 628 655 LTLIBOBJS ··· 667 694 STRICT_CFLAGS 668 695 CWARNFLAGS 669 696 BASE_CFLAGS 670 670 - EGREP 671 671 - GREP 672 672 - CPP 673 697 am__fastdepCC_FALSE 674 698 am__fastdepCC_TRUE 675 699 CCDEPMODE ··· 769 793 LDFLAGS 770 794 LIBS 771 795 CPPFLAGS 772 772 - CPP 773 796 PKG_CONFIG 774 797 PKG_CONFIG_PATH 775 798 PKG_CONFIG_LIBDIR ··· 845 868 *) ac_optarg=yes ;; 846 869 esac 847 870 848 848 - # Accept the important Cygnus configure options, so we can diagnose typos. 849 849 - 850 871 case $ac_dashdash$ac_option in 851 872 --) 852 873 ac_dashdash=yes ;; ··· 887 908 ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` 888 909 # Reject names that are not valid shell variable names. 889 910 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && 890 890 - as_fn_error $? "invalid feature name: $ac_useropt" 911 911 + as_fn_error $? "invalid feature name: \`$ac_useropt'" 891 912 ac_useropt_orig=$ac_useropt 892 892 - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` 913 913 + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` 893 914 case $ac_user_opts in 894 915 *" 895 916 "enable_$ac_useropt" ··· 913 934 ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` 914 935 # Reject names that are not valid shell variable names. 915 936 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && 916 916 - as_fn_error $? "invalid feature name: $ac_useropt" 937 937 + as_fn_error $? "invalid feature name: \`$ac_useropt'" 917 938 ac_useropt_orig=$ac_useropt 918 918 - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` 939 939 + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` 919 940 case $ac_user_opts in 920 941 *" 921 942 "enable_$ac_useropt" ··· 1126 1147 ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` 1127 1148 # Reject names that are not valid shell variable names. 1128 1149 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && 1129 1129 - as_fn_error $? "invalid package name: $ac_useropt" 1150 1150 + as_fn_error $? "invalid package name: \`$ac_useropt'" 1130 1151 ac_useropt_orig=$ac_useropt 1131 1131 - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` 1152 1152 + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` 1132 1153 case $ac_user_opts in 1133 1154 *" 1134 1155 "with_$ac_useropt" ··· 1142 1163 ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` 1143 1164 # Reject names that are not valid shell variable names. 1144 1165 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && 1145 1145 - as_fn_error $? "invalid package name: $ac_useropt" 1166 1166 + as_fn_error $? "invalid package name: \`$ac_useropt'" 1146 1167 ac_useropt_orig=$ac_useropt 1147 1147 - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` 1168 1168 + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` 1148 1169 case $ac_user_opts in 1149 1170 *" 1150 1171 "with_$ac_useropt" ··· 1188 1209 1189 1210 *) 1190 1211 # FIXME: should be removed in autoconf 3.0. 1191 1191 - $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 1212 1212 + printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2 1192 1213 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && 1193 1193 - $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 1214 1214 + printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2 1194 1215 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" 1195 1216 ;; 1196 1217 ··· 1206 1227 case $enable_option_checking in 1207 1228 no) ;; 1208 1229 fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; 1209 1209 - *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; 1230 1230 + *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; 1210 1231 esac 1211 1232 fi 1212 1233 ··· 1270 1291 X"$as_myself" : 'X\(//\)[^/]' \| \ 1271 1292 X"$as_myself" : 'X\(//\)$' \| \ 1272 1293 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || 1273 1273 - $as_echo X"$as_myself" | 1294 1294 + printf "%s\n" X"$as_myself" | 1274 1295 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 1275 1296 s//\1/ 1276 1297 q ··· 1327 1348 # Omit some internal or obsolete options to make the list less imposing. 1328 1349 # This message is too long to be a string in the A/UX 3.1 sh. 1329 1350 cat <<_ACEOF 1330 1330 - \`configure' configures xkbevd 1.1.5 to adapt to many kinds of systems. 1351 1351 + \`configure' configures xkbevd 1.1.6 to adapt to many kinds of systems. 1331 1352 1332 1353 Usage: $0 [OPTION]... [VAR=VALUE]... 1333 1354 ··· 1398 1419 1399 1420 if test -n "$ac_init_help"; then 1400 1421 case $ac_init_help in 1401 1401 - short | recursive ) echo "Configuration of xkbevd 1.1.5:";; 1422 1422 + short | recursive ) echo "Configuration of xkbevd 1.1.6:";; 1402 1423 esac 1403 1424 cat <<\_ACEOF 1404 1425 ··· 1430 1451 LIBS libraries to pass to the linker, e.g. -l<library> 1431 1452 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if 1432 1453 you have headers in a nonstandard directory <include dir> 1433 1433 - CPP C preprocessor 1434 1454 PKG_CONFIG path to pkg-config utility 1435 1455 PKG_CONFIG_PATH 1436 1456 directories to add to pkg-config's search path ··· 1465 1485 case "$ac_dir" in 1466 1486 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; 1467 1487 *) 1468 1468 - ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` 1488 1488 + ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` 1469 1489 # A ".." for each directory in $ac_dir_suffix. 1470 1470 - ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` 1490 1490 + ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` 1471 1491 case $ac_top_builddir_sub in 1472 1492 "") ac_top_builddir_sub=. ac_top_build_prefix= ;; 1473 1493 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; ··· 1495 1515 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix 1496 1516 1497 1517 cd "$ac_dir" || { ac_status=$?; continue; } 1498 1498 - # Check for guested configure. 1518 1518 + # Check for configure.gnu first; this name is used for a wrapper for 1519 1519 + # Metaconfig's "Configure" on case-insensitive file systems. 1499 1520 if test -f "$ac_srcdir/configure.gnu"; then 1500 1521 echo && 1501 1522 $SHELL "$ac_srcdir/configure.gnu" --help=recursive ··· 1503 1524 echo && 1504 1525 $SHELL "$ac_srcdir/configure" --help=recursive 1505 1526 else 1506 1506 - $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 1527 1527 + printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2 1507 1528 fi || ac_status=$? 1508 1529 cd "$ac_pwd" || { ac_status=$?; break; } 1509 1530 done ··· 1512 1533 test -n "$ac_init_help" && exit $ac_status 1513 1534 if $ac_init_version; then 1514 1535 cat <<\_ACEOF 1515 1515 - xkbevd configure 1.1.5 1516 1516 - generated by GNU Autoconf 2.69 1536 1536 + xkbevd configure 1.1.6 1537 1537 + generated by GNU Autoconf 2.71 1517 1538 1518 1518 - Copyright (C) 2012 Free Software Foundation, Inc. 1539 1539 + Copyright (C) 2021 Free Software Foundation, Inc. 1519 1540 This configure script is free software; the Free Software Foundation 1520 1541 gives unlimited permission to copy, distribute and modify it. 1521 1542 _ACEOF ··· 1532 1553 ac_fn_c_try_compile () 1533 1554 { 1534 1555 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1535 1535 - rm -f conftest.$ac_objext 1556 1556 + rm -f conftest.$ac_objext conftest.beam 1536 1557 if { { ac_try="$ac_compile" 1537 1558 case "(($ac_try" in 1538 1559 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 1539 1560 *) ac_try_echo=$ac_try;; 1540 1561 esac 1541 1562 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 1542 1542 - $as_echo "$ac_try_echo"; } >&5 1563 1563 + printf "%s\n" "$ac_try_echo"; } >&5 1543 1564 (eval "$ac_compile") 2>conftest.err 1544 1565 ac_status=$? 1545 1566 if test -s conftest.err; then ··· 1547 1568 cat conftest.er1 >&5 1548 1569 mv -f conftest.er1 conftest.err 1549 1570 fi 1550 1550 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1571 1571 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1551 1572 test $ac_status = 0; } && { 1552 1573 test -z "$ac_c_werror_flag" || 1553 1574 test ! -s conftest.err 1554 1554 - } && test -s conftest.$ac_objext; then : 1575 1575 + } && test -s conftest.$ac_objext 1576 1576 + then : 1555 1577 ac_retval=0 1556 1556 - else 1557 1557 - $as_echo "$as_me: failed program was:" >&5 1578 1578 + else $as_nop 1579 1579 + printf "%s\n" "$as_me: failed program was:" >&5 1558 1580 sed 's/^/| /' conftest.$ac_ext >&5 1559 1581 1560 1582 ac_retval=1 ··· 1564 1586 1565 1587 } # ac_fn_c_try_compile 1566 1588 1567 1567 - # ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES 1568 1568 - # --------------------------------------------- 1589 1589 + # ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR 1590 1590 + # ------------------------------------------------------------------ 1569 1591 # Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR 1570 1570 - # accordingly. 1571 1571 - ac_fn_c_check_decl () 1592 1592 + # accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR. 1593 1593 + ac_fn_check_decl () 1572 1594 { 1573 1595 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1574 1596 as_decl_name=`echo $2|sed 's/ *(.*//'` 1597 1597 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 1598 1598 + printf %s "checking whether $as_decl_name is declared... " >&6; } 1599 1599 + if eval test \${$3+y} 1600 1600 + then : 1601 1601 + printf %s "(cached) " >&6 1602 1602 + else $as_nop 1575 1603 as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` 1576 1576 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 1577 1577 - $as_echo_n "checking whether $as_decl_name is declared... " >&6; } 1578 1578 - if eval \${$3+:} false; then : 1579 1579 - $as_echo_n "(cached) " >&6 1580 1580 - else 1604 1604 + eval ac_save_FLAGS=\$$6 1605 1605 + as_fn_append $6 " $5" 1581 1606 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1582 1607 /* end confdefs.h. */ 1583 1608 $4 1584 1609 int 1585 1585 - main () 1610 1610 + main (void) 1586 1611 { 1587 1612 #ifndef $as_decl_name 1588 1613 #ifdef __cplusplus ··· 1596 1621 return 0; 1597 1622 } 1598 1623 _ACEOF 1599 1599 - if ac_fn_c_try_compile "$LINENO"; then : 1624 1624 + if ac_fn_c_try_compile "$LINENO" 1625 1625 + then : 1600 1626 eval "$3=yes" 1601 1601 - else 1627 1627 + else $as_nop 1602 1628 eval "$3=no" 1603 1629 fi 1604 1604 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1630 1630 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 1631 1631 + eval $6=\$ac_save_FLAGS 1632 1632 + 1605 1633 fi 1606 1634 eval ac_res=\$$3 1607 1607 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 1608 1608 - $as_echo "$ac_res" >&6; } 1635 1635 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 1636 1636 + printf "%s\n" "$ac_res" >&6; } 1609 1637 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno 1610 1638 1611 1611 - } # ac_fn_c_check_decl 1612 1612 - 1613 1613 - # ac_fn_c_try_cpp LINENO 1614 1614 - # ---------------------- 1615 1615 - # Try to preprocess conftest.$ac_ext, and return whether this succeeded. 1616 1616 - ac_fn_c_try_cpp () 1617 1617 - { 1618 1618 - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1619 1619 - if { { ac_try="$ac_cpp conftest.$ac_ext" 1620 1620 - case "(($ac_try" in 1621 1621 - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 1622 1622 - *) ac_try_echo=$ac_try;; 1623 1623 - esac 1624 1624 - eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 1625 1625 - $as_echo "$ac_try_echo"; } >&5 1626 1626 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err 1627 1627 - ac_status=$? 1628 1628 - if test -s conftest.err; then 1629 1629 - grep -v '^ *+' conftest.err >conftest.er1 1630 1630 - cat conftest.er1 >&5 1631 1631 - mv -f conftest.er1 conftest.err 1632 1632 - fi 1633 1633 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1634 1634 - test $ac_status = 0; } > conftest.i && { 1635 1635 - test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || 1636 1636 - test ! -s conftest.err 1637 1637 - }; then : 1638 1638 - ac_retval=0 1639 1639 - else 1640 1640 - $as_echo "$as_me: failed program was:" >&5 1641 1641 - sed 's/^/| /' conftest.$ac_ext >&5 1642 1642 - 1643 1643 - ac_retval=1 1644 1644 - fi 1645 1645 - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno 1646 1646 - as_fn_set_status $ac_retval 1647 1647 - 1648 1648 - } # ac_fn_c_try_cpp 1649 1649 - 1650 1650 - # ac_fn_c_try_run LINENO 1651 1651 - # ---------------------- 1652 1652 - # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes 1653 1653 - # that executables *can* be run. 1654 1654 - ac_fn_c_try_run () 1655 1655 - { 1656 1656 - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1657 1657 - if { { ac_try="$ac_link" 1658 1658 - case "(($ac_try" in 1659 1659 - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 1660 1660 - *) ac_try_echo=$ac_try;; 1661 1661 - esac 1662 1662 - eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 1663 1663 - $as_echo "$ac_try_echo"; } >&5 1664 1664 - (eval "$ac_link") 2>&5 1665 1665 - ac_status=$? 1666 1666 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1667 1667 - test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' 1668 1668 - { { case "(($ac_try" in 1669 1669 - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 1670 1670 - *) ac_try_echo=$ac_try;; 1671 1671 - esac 1672 1672 - eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 1673 1673 - $as_echo "$ac_try_echo"; } >&5 1674 1674 - (eval "$ac_try") 2>&5 1675 1675 - ac_status=$? 1676 1676 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1677 1677 - test $ac_status = 0; }; }; then : 1678 1678 - ac_retval=0 1679 1679 - else 1680 1680 - $as_echo "$as_me: program exited with status $ac_status" >&5 1681 1681 - $as_echo "$as_me: failed program was:" >&5 1682 1682 - sed 's/^/| /' conftest.$ac_ext >&5 1683 1683 - 1684 1684 - ac_retval=$ac_status 1685 1685 - fi 1686 1686 - rm -rf conftest.dSYM conftest_ipa8_conftest.oo 1687 1687 - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno 1688 1688 - as_fn_set_status $ac_retval 1689 1689 - 1690 1690 - } # ac_fn_c_try_run 1639 1639 + } # ac_fn_check_decl 1691 1640 1692 1641 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES 1693 1642 # ------------------------------------------------------- ··· 1696 1645 ac_fn_c_check_header_compile () 1697 1646 { 1698 1647 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1699 1699 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 1700 1700 - $as_echo_n "checking for $2... " >&6; } 1701 1701 - if eval \${$3+:} false; then : 1702 1702 - $as_echo_n "(cached) " >&6 1703 1703 - else 1648 1648 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 1649 1649 + printf %s "checking for $2... " >&6; } 1650 1650 + if eval test \${$3+y} 1651 1651 + then : 1652 1652 + printf %s "(cached) " >&6 1653 1653 + else $as_nop 1704 1654 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1705 1655 /* end confdefs.h. */ 1706 1656 $4 1707 1657 #include <$2> 1708 1658 _ACEOF 1709 1709 - if ac_fn_c_try_compile "$LINENO"; then : 1659 1659 + if ac_fn_c_try_compile "$LINENO" 1660 1660 + then : 1710 1661 eval "$3=yes" 1711 1711 - else 1662 1662 + else $as_nop 1712 1663 eval "$3=no" 1713 1664 fi 1714 1714 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1665 1665 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 1715 1666 fi 1716 1667 eval ac_res=\$$3 1717 1717 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 1718 1718 - $as_echo "$ac_res" >&6; } 1668 1668 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 1669 1669 + printf "%s\n" "$ac_res" >&6; } 1719 1670 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno 1720 1671 1721 1672 } # ac_fn_c_check_header_compile ··· 1726 1677 ac_fn_c_try_link () 1727 1678 { 1728 1679 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1729 1729 - rm -f conftest.$ac_objext conftest$ac_exeext 1680 1680 + rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext 1730 1681 if { { ac_try="$ac_link" 1731 1682 case "(($ac_try" in 1732 1683 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 1733 1684 *) ac_try_echo=$ac_try;; 1734 1685 esac 1735 1686 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 1736 1736 - $as_echo "$ac_try_echo"; } >&5 1687 1687 + printf "%s\n" "$ac_try_echo"; } >&5 1737 1688 (eval "$ac_link") 2>conftest.err 1738 1689 ac_status=$? 1739 1690 if test -s conftest.err; then ··· 1741 1692 cat conftest.er1 >&5 1742 1693 mv -f conftest.er1 conftest.err 1743 1694 fi 1744 1744 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1695 1695 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 1745 1696 test $ac_status = 0; } && { 1746 1697 test -z "$ac_c_werror_flag" || 1747 1698 test ! -s conftest.err 1748 1699 } && test -s conftest$ac_exeext && { 1749 1700 test "$cross_compiling" = yes || 1750 1701 test -x conftest$ac_exeext 1751 1751 - }; then : 1702 1702 + } 1703 1703 + then : 1752 1704 ac_retval=0 1753 1753 - else 1754 1754 - $as_echo "$as_me: failed program was:" >&5 1705 1705 + else $as_nop 1706 1706 + printf "%s\n" "$as_me: failed program was:" >&5 1755 1707 sed 's/^/| /' conftest.$ac_ext >&5 1756 1708 1757 1709 ac_retval=1 ··· 1765 1717 as_fn_set_status $ac_retval 1766 1718 1767 1719 } # ac_fn_c_try_link 1720 1720 + ac_configure_args_raw= 1721 1721 + for ac_arg 1722 1722 + do 1723 1723 + case $ac_arg in 1724 1724 + *\'*) 1725 1725 + ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; 1726 1726 + esac 1727 1727 + as_fn_append ac_configure_args_raw " '$ac_arg'" 1728 1728 + done 1768 1729 1769 1769 - # ac_fn_c_check_func LINENO FUNC VAR 1770 1770 - # ---------------------------------- 1771 1771 - # Tests whether FUNC exists, setting the cache variable VAR accordingly 1772 1772 - ac_fn_c_check_func () 1773 1773 - { 1774 1774 - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 1775 1775 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 1776 1776 - $as_echo_n "checking for $2... " >&6; } 1777 1777 - if eval \${$3+:} false; then : 1778 1778 - $as_echo_n "(cached) " >&6 1779 1779 - else 1780 1780 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1781 1781 - /* end confdefs.h. */ 1782 1782 - /* Define $2 to an innocuous variant, in case <limits.h> declares $2. 1783 1783 - For example, HP-UX 11i <limits.h> declares gettimeofday. */ 1784 1784 - #define $2 innocuous_$2 1730 1730 + case $ac_configure_args_raw in 1731 1731 + *$as_nl*) 1732 1732 + ac_safe_unquote= ;; 1733 1733 + *) 1734 1734 + ac_unsafe_z='|&;<>()$`\\"*?[ '' ' # This string ends in space, tab. 1735 1735 + ac_unsafe_a="$ac_unsafe_z#~" 1736 1736 + ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g" 1737 1737 + ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; 1738 1738 + esac 1785 1739 1786 1786 - /* System header to define __stub macros and hopefully few prototypes, 1787 1787 - which can conflict with char $2 (); below. 1788 1788 - Prefer <limits.h> to <assert.h> if __STDC__ is defined, since 1789 1789 - <limits.h> exists even on freestanding compilers. */ 1790 1790 - 1791 1791 - #ifdef __STDC__ 1792 1792 - # include <limits.h> 1793 1793 - #else 1794 1794 - # include <assert.h> 1795 1795 - #endif 1796 1796 - 1797 1797 - #undef $2 1798 1798 - 1799 1799 - /* Override any GCC internal prototype to avoid an error. 1800 1800 - Use char because int might match the return type of a GCC 1801 1801 - builtin and then its argument prototype would still apply. */ 1802 1802 - #ifdef __cplusplus 1803 1803 - extern "C" 1804 1804 - #endif 1805 1805 - char $2 (); 1806 1806 - /* The GNU C library defines this for functions which it implements 1807 1807 - to always fail with ENOSYS. Some functions are actually named 1808 1808 - something starting with __ and the normal name is an alias. */ 1809 1809 - #if defined __stub_$2 || defined __stub___$2 1810 1810 - choke me 1811 1811 - #endif 1812 1812 - 1813 1813 - int 1814 1814 - main () 1815 1815 - { 1816 1816 - return $2 (); 1817 1817 - ; 1818 1818 - return 0; 1819 1819 - } 1820 1820 - _ACEOF 1821 1821 - if ac_fn_c_try_link "$LINENO"; then : 1822 1822 - eval "$3=yes" 1823 1823 - else 1824 1824 - eval "$3=no" 1825 1825 - fi 1826 1826 - rm -f core conftest.err conftest.$ac_objext \ 1827 1827 - conftest$ac_exeext conftest.$ac_ext 1828 1828 - fi 1829 1829 - eval ac_res=\$$3 1830 1830 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 1831 1831 - $as_echo "$ac_res" >&6; } 1832 1832 - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno 1833 1833 - 1834 1834 - } # ac_fn_c_check_func 1835 1740 cat >config.log <<_ACEOF 1836 1741 This file contains any messages produced by compilers while 1837 1742 running configure, to aid debugging if configure makes a mistake. 1838 1743 1839 1839 - It was created by xkbevd $as_me 1.1.5, which was 1840 1840 - generated by GNU Autoconf 2.69. Invocation command line was 1744 1744 + It was created by xkbevd $as_me 1.1.6, which was 1745 1745 + generated by GNU Autoconf 2.71. Invocation command line was 1841 1746 1842 1842 - $ $0 $@ 1747 1747 + $ $0$ac_configure_args_raw 1843 1748 1844 1749 _ACEOF 1845 1750 exec 5>>config.log ··· 1872 1777 for as_dir in $PATH 1873 1778 do 1874 1779 IFS=$as_save_IFS 1875 1875 - test -z "$as_dir" && as_dir=. 1876 1876 - $as_echo "PATH: $as_dir" 1780 1780 + case $as_dir in #((( 1781 1781 + '') as_dir=./ ;; 1782 1782 + */) ;; 1783 1783 + *) as_dir=$as_dir/ ;; 1784 1784 + esac 1785 1785 + printf "%s\n" "PATH: $as_dir" 1877 1786 done 1878 1787 IFS=$as_save_IFS 1879 1788 ··· 1908 1817 | -silent | --silent | --silen | --sile | --sil) 1909 1818 continue ;; 1910 1819 *\'*) 1911 1911 - ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; 1820 1820 + ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; 1912 1821 esac 1913 1822 case $ac_pass in 1914 1823 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; ··· 1943 1852 # WARNING: Use '\'' to represent an apostrophe within the trap. 1944 1853 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. 1945 1854 trap 'exit_status=$? 1855 1855 + # Sanitize IFS. 1856 1856 + IFS=" "" $as_nl" 1946 1857 # Save into config.log some information that might help in debugging. 1947 1858 { 1948 1859 echo 1949 1860 1950 1950 - $as_echo "## ---------------- ## 1861 1861 + printf "%s\n" "## ---------------- ## 1951 1862 ## Cache variables. ## 1952 1863 ## ---------------- ##" 1953 1864 echo ··· 1958 1869 case $ac_val in #( 1959 1870 *${as_nl}*) 1960 1871 case $ac_var in #( 1961 1961 - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 1962 1962 - $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; 1872 1872 + *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 1873 1873 + printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; 1963 1874 esac 1964 1875 case $ac_var in #( 1965 1876 _ | IFS | as_nl) ;; #( ··· 1983 1894 ) 1984 1895 echo 1985 1896 1986 1986 - $as_echo "## ----------------- ## 1897 1897 + printf "%s\n" "## ----------------- ## 1987 1898 ## Output variables. ## 1988 1899 ## ----------------- ##" 1989 1900 echo ··· 1991 1902 do 1992 1903 eval ac_val=\$$ac_var 1993 1904 case $ac_val in 1994 1994 - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; 1905 1905 + *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; 1995 1906 esac 1996 1996 - $as_echo "$ac_var='\''$ac_val'\''" 1907 1907 + printf "%s\n" "$ac_var='\''$ac_val'\''" 1997 1908 done | sort 1998 1909 echo 1999 1910 2000 1911 if test -n "$ac_subst_files"; then 2001 2001 - $as_echo "## ------------------- ## 1912 1912 + printf "%s\n" "## ------------------- ## 2002 1913 ## File substitutions. ## 2003 1914 ## ------------------- ##" 2004 1915 echo ··· 2006 1917 do 2007 1918 eval ac_val=\$$ac_var 2008 1919 case $ac_val in 2009 2009 - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; 1920 1920 + *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; 2010 1921 esac 2011 2011 - $as_echo "$ac_var='\''$ac_val'\''" 1922 1922 + printf "%s\n" "$ac_var='\''$ac_val'\''" 2012 1923 done | sort 2013 1924 echo 2014 1925 fi 2015 1926 2016 1927 if test -s confdefs.h; then 2017 2017 - $as_echo "## ----------- ## 1928 1928 + printf "%s\n" "## ----------- ## 2018 1929 ## confdefs.h. ## 2019 1930 ## ----------- ##" 2020 1931 echo ··· 2022 1933 echo 2023 1934 fi 2024 1935 test "$ac_signal" != 0 && 2025 2025 - $as_echo "$as_me: caught signal $ac_signal" 2026 2026 - $as_echo "$as_me: exit $exit_status" 1936 1936 + printf "%s\n" "$as_me: caught signal $ac_signal" 1937 1937 + printf "%s\n" "$as_me: exit $exit_status" 2027 1938 } >&5 2028 1939 rm -f core *.core core.conftest.* && 2029 1940 rm -f -r conftest* confdefs* conf$$* $ac_clean_files && ··· 2037 1948 # confdefs.h avoids OS command line length limits that DEFS can exceed. 2038 1949 rm -f -r conftest* confdefs.h 2039 1950 2040 2040 - $as_echo "/* confdefs.h */" > confdefs.h 1951 1951 + printf "%s\n" "/* confdefs.h */" > confdefs.h 2041 1952 2042 1953 # Predefined preprocessor variables. 2043 1954 2044 2044 - cat >>confdefs.h <<_ACEOF 2045 2045 - #define PACKAGE_NAME "$PACKAGE_NAME" 2046 2046 - _ACEOF 1955 1955 + printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h 2047 1956 2048 2048 - cat >>confdefs.h <<_ACEOF 2049 2049 - #define PACKAGE_TARNAME "$PACKAGE_TARNAME" 2050 2050 - _ACEOF 1957 1957 + printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h 2051 1958 2052 2052 - cat >>confdefs.h <<_ACEOF 2053 2053 - #define PACKAGE_VERSION "$PACKAGE_VERSION" 2054 2054 - _ACEOF 1959 1959 + printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h 2055 1960 2056 2056 - cat >>confdefs.h <<_ACEOF 2057 2057 - #define PACKAGE_STRING "$PACKAGE_STRING" 2058 2058 - _ACEOF 1961 1961 + printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h 2059 1962 2060 2060 - cat >>confdefs.h <<_ACEOF 2061 2061 - #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" 2062 2062 - _ACEOF 1963 1963 + printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h 2063 1964 2064 2064 - cat >>confdefs.h <<_ACEOF 2065 2065 - #define PACKAGE_URL "$PACKAGE_URL" 2066 2066 - _ACEOF 1965 1965 + printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h 2067 1966 2068 1967 2069 1968 # Let the site file select an alternate cache file if it wants to. 2070 1969 # Prefer an explicitly selected file to automatically selected ones. 2071 2071 - ac_site_file1=NONE 2072 2072 - ac_site_file2=NONE 2073 1970 if test -n "$CONFIG_SITE"; then 2074 2074 - # We do not want a PATH search for config.site. 2075 2075 - case $CONFIG_SITE in #(( 2076 2076 - -*) ac_site_file1=./$CONFIG_SITE;; 2077 2077 - */*) ac_site_file1=$CONFIG_SITE;; 2078 2078 - *) ac_site_file1=./$CONFIG_SITE;; 2079 2079 - esac 1971 1971 + ac_site_files="$CONFIG_SITE" 2080 1972 elif test "x$prefix" != xNONE; then 2081 2081 - ac_site_file1=$prefix/share/config.site 2082 2082 - ac_site_file2=$prefix/etc/config.site 1973 1973 + ac_site_files="$prefix/share/config.site $prefix/etc/config.site" 2083 1974 else 2084 2084 - ac_site_file1=$ac_default_prefix/share/config.site 2085 2085 - ac_site_file2=$ac_default_prefix/etc/config.site 1975 1975 + ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" 2086 1976 fi 2087 2087 - for ac_site_file in "$ac_site_file1" "$ac_site_file2" 1977 1977 + 1978 1978 + for ac_site_file in $ac_site_files 2088 1979 do 2089 2089 - test "x$ac_site_file" = xNONE && continue 2090 2090 - if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then 2091 2091 - { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 2092 2092 - $as_echo "$as_me: loading site script $ac_site_file" >&6;} 1980 1980 + case $ac_site_file in #( 1981 1981 + */*) : 1982 1982 + ;; #( 1983 1983 + *) : 1984 1984 + ac_site_file=./$ac_site_file ;; 1985 1985 + esac 1986 1986 + if test -f "$ac_site_file" && test -r "$ac_site_file"; then 1987 1987 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 1988 1988 + printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;} 2093 1989 sed 's/^/| /' "$ac_site_file" >&5 2094 1990 . "$ac_site_file" \ 2095 2095 - || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 2096 2096 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 1991 1991 + || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 1992 1992 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 2097 1993 as_fn_error $? "failed to load site script $ac_site_file 2098 1994 See \`config.log' for more details" "$LINENO" 5; } 2099 1995 fi ··· 2103 1999 # Some versions of bash will fail to source /dev/null (special files 2104 2000 # actually), so we avoid doing that. DJGPP emulates it as a regular file. 2105 2001 if test /dev/null != "$cache_file" && test -f "$cache_file"; then 2106 2106 - { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 2107 2107 - $as_echo "$as_me: loading cache $cache_file" >&6;} 2002 2002 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 2003 2003 + printf "%s\n" "$as_me: loading cache $cache_file" >&6;} 2108 2004 case $cache_file in 2109 2005 [\\/]* | ?:[\\/]* ) . "$cache_file";; 2110 2006 *) . "./$cache_file";; 2111 2007 esac 2112 2008 fi 2113 2009 else 2114 2114 - { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 2115 2115 - $as_echo "$as_me: creating cache $cache_file" >&6;} 2010 2010 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 2011 2011 + printf "%s\n" "$as_me: creating cache $cache_file" >&6;} 2116 2012 >$cache_file 2117 2013 fi 2118 2014 2015 2015 + # Test code for whether the C compiler supports C89 (global declarations) 2016 2016 + ac_c_conftest_c89_globals=' 2017 2017 + /* Does the compiler advertise C89 conformance? 2018 2018 + Do not test the value of __STDC__, because some compilers set it to 0 2019 2019 + while being otherwise adequately conformant. */ 2020 2020 + #if !defined __STDC__ 2021 2021 + # error "Compiler does not advertise C89 conformance" 2022 2022 + #endif 2023 2023 + 2024 2024 + #include <stddef.h> 2025 2025 + #include <stdarg.h> 2026 2026 + struct stat; 2027 2027 + /* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */ 2028 2028 + struct buf { int x; }; 2029 2029 + struct buf * (*rcsopen) (struct buf *, struct stat *, int); 2030 2030 + static char *e (p, i) 2031 2031 + char **p; 2032 2032 + int i; 2033 2033 + { 2034 2034 + return p[i]; 2035 2035 + } 2036 2036 + static char *f (char * (*g) (char **, int), char **p, ...) 2037 2037 + { 2038 2038 + char *s; 2039 2039 + va_list v; 2040 2040 + va_start (v,p); 2041 2041 + s = g (p, va_arg (v,int)); 2042 2042 + va_end (v); 2043 2043 + return s; 2044 2044 + } 2045 2045 + 2046 2046 + /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has 2047 2047 + function prototypes and stuff, but not \xHH hex character constants. 2048 2048 + These do not provoke an error unfortunately, instead are silently treated 2049 2049 + as an "x". The following induces an error, until -std is added to get 2050 2050 + proper ANSI mode. Curiously \x00 != x always comes out true, for an 2051 2051 + array size at least. It is necessary to write \x00 == 0 to get something 2052 2052 + that is true only with -std. */ 2053 2053 + int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1]; 2054 2054 + 2055 2055 + /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters 2056 2056 + inside strings and character constants. */ 2057 2057 + #define FOO(x) '\''x'\'' 2058 2058 + int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1]; 2059 2059 + 2060 2060 + int test (int i, double x); 2061 2061 + struct s1 {int (*f) (int a);}; 2062 2062 + struct s2 {int (*f) (double a);}; 2063 2063 + int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int), 2064 2064 + int, int);' 2065 2065 + 2066 2066 + # Test code for whether the C compiler supports C89 (body of main). 2067 2067 + ac_c_conftest_c89_main=' 2068 2068 + ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]); 2069 2069 + ' 2070 2070 + 2071 2071 + # Test code for whether the C compiler supports C99 (global declarations) 2072 2072 + ac_c_conftest_c99_globals=' 2073 2073 + // Does the compiler advertise C99 conformance? 2074 2074 + #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L 2075 2075 + # error "Compiler does not advertise C99 conformance" 2076 2076 + #endif 2077 2077 + 2078 2078 + #include <stdbool.h> 2079 2079 + extern int puts (const char *); 2080 2080 + extern int printf (const char *, ...); 2081 2081 + extern int dprintf (int, const char *, ...); 2082 2082 + extern void *malloc (size_t); 2083 2083 + 2084 2084 + // Check varargs macros. These examples are taken from C99 6.10.3.5. 2085 2085 + // dprintf is used instead of fprintf to avoid needing to declare 2086 2086 + // FILE and stderr. 2087 2087 + #define debug(...) dprintf (2, __VA_ARGS__) 2088 2088 + #define showlist(...) puts (#__VA_ARGS__) 2089 2089 + #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) 2090 2090 + static void 2091 2091 + test_varargs_macros (void) 2092 2092 + { 2093 2093 + int x = 1234; 2094 2094 + int y = 5678; 2095 2095 + debug ("Flag"); 2096 2096 + debug ("X = %d\n", x); 2097 2097 + showlist (The first, second, and third items.); 2098 2098 + report (x>y, "x is %d but y is %d", x, y); 2099 2099 + } 2100 2100 + 2101 2101 + // Check long long types. 2102 2102 + #define BIG64 18446744073709551615ull 2103 2103 + #define BIG32 4294967295ul 2104 2104 + #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) 2105 2105 + #if !BIG_OK 2106 2106 + #error "your preprocessor is broken" 2107 2107 + #endif 2108 2108 + #if BIG_OK 2109 2109 + #else 2110 2110 + #error "your preprocessor is broken" 2111 2111 + #endif 2112 2112 + static long long int bignum = -9223372036854775807LL; 2113 2113 + static unsigned long long int ubignum = BIG64; 2114 2114 + 2115 2115 + struct incomplete_array 2116 2116 + { 2117 2117 + int datasize; 2118 2118 + double data[]; 2119 2119 + }; 2120 2120 + 2121 2121 + struct named_init { 2122 2122 + int number; 2123 2123 + const wchar_t *name; 2124 2124 + double average; 2125 2125 + }; 2126 2126 + 2127 2127 + typedef const char *ccp; 2128 2128 + 2129 2129 + static inline int 2130 2130 + test_restrict (ccp restrict text) 2131 2131 + { 2132 2132 + // See if C++-style comments work. 2133 2133 + // Iterate through items via the restricted pointer. 2134 2134 + // Also check for declarations in for loops. 2135 2135 + for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i) 2136 2136 + continue; 2137 2137 + return 0; 2138 2138 + } 2139 2139 + 2140 2140 + // Check varargs and va_copy. 2141 2141 + static bool 2142 2142 + test_varargs (const char *format, ...) 2143 2143 + { 2144 2144 + va_list args; 2145 2145 + va_start (args, format); 2146 2146 + va_list args_copy; 2147 2147 + va_copy (args_copy, args); 2148 2148 + 2149 2149 + const char *str = ""; 2150 2150 + int number = 0; 2151 2151 + float fnumber = 0; 2152 2152 + 2153 2153 + while (*format) 2154 2154 + { 2155 2155 + switch (*format++) 2156 2156 + { 2157 2157 + case '\''s'\'': // string 2158 2158 + str = va_arg (args_copy, const char *); 2159 2159 + break; 2160 2160 + case '\''d'\'': // int 2161 2161 + number = va_arg (args_copy, int); 2162 2162 + break; 2163 2163 + case '\''f'\'': // float 2164 2164 + fnumber = va_arg (args_copy, double); 2165 2165 + break; 2166 2166 + default: 2167 2167 + break; 2168 2168 + } 2169 2169 + } 2170 2170 + va_end (args_copy); 2171 2171 + va_end (args); 2172 2172 + 2173 2173 + return *str && number && fnumber; 2174 2174 + } 2175 2175 + ' 2176 2176 + 2177 2177 + # Test code for whether the C compiler supports C99 (body of main). 2178 2178 + ac_c_conftest_c99_main=' 2179 2179 + // Check bool. 2180 2180 + _Bool success = false; 2181 2181 + success |= (argc != 0); 2182 2182 + 2183 2183 + // Check restrict. 2184 2184 + if (test_restrict ("String literal") == 0) 2185 2185 + success = true; 2186 2186 + char *restrict newvar = "Another string"; 2187 2187 + 2188 2188 + // Check varargs. 2189 2189 + success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234); 2190 2190 + test_varargs_macros (); 2191 2191 + 2192 2192 + // Check flexible array members. 2193 2193 + struct incomplete_array *ia = 2194 2194 + malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); 2195 2195 + ia->datasize = 10; 2196 2196 + for (int i = 0; i < ia->datasize; ++i) 2197 2197 + ia->data[i] = i * 1.234; 2198 2198 + 2199 2199 + // Check named initializers. 2200 2200 + struct named_init ni = { 2201 2201 + .number = 34, 2202 2202 + .name = L"Test wide string", 2203 2203 + .average = 543.34343, 2204 2204 + }; 2205 2205 + 2206 2206 + ni.number = 58; 2207 2207 + 2208 2208 + int dynamic_array[ni.number]; 2209 2209 + dynamic_array[0] = argv[0][0]; 2210 2210 + dynamic_array[ni.number - 1] = 543; 2211 2211 + 2212 2212 + // work around unused variable warnings 2213 2213 + ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' 2214 2214 + || dynamic_array[ni.number - 1] != 543); 2215 2215 + ' 2216 2216 + 2217 2217 + # Test code for whether the C compiler supports C11 (global declarations) 2218 2218 + ac_c_conftest_c11_globals=' 2219 2219 + // Does the compiler advertise C11 conformance? 2220 2220 + #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L 2221 2221 + # error "Compiler does not advertise C11 conformance" 2222 2222 + #endif 2223 2223 + 2224 2224 + // Check _Alignas. 2225 2225 + char _Alignas (double) aligned_as_double; 2226 2226 + char _Alignas (0) no_special_alignment; 2227 2227 + extern char aligned_as_int; 2228 2228 + char _Alignas (0) _Alignas (int) aligned_as_int; 2229 2229 + 2230 2230 + // Check _Alignof. 2231 2231 + enum 2232 2232 + { 2233 2233 + int_alignment = _Alignof (int), 2234 2234 + int_array_alignment = _Alignof (int[100]), 2235 2235 + char_alignment = _Alignof (char) 2236 2236 + }; 2237 2237 + _Static_assert (0 < -_Alignof (int), "_Alignof is signed"); 2238 2238 + 2239 2239 + // Check _Noreturn. 2240 2240 + int _Noreturn does_not_return (void) { for (;;) continue; } 2241 2241 + 2242 2242 + // Check _Static_assert. 2243 2243 + struct test_static_assert 2244 2244 + { 2245 2245 + int x; 2246 2246 + _Static_assert (sizeof (int) <= sizeof (long int), 2247 2247 + "_Static_assert does not work in struct"); 2248 2248 + long int y; 2249 2249 + }; 2250 2250 + 2251 2251 + // Check UTF-8 literals. 2252 2252 + #define u8 syntax error! 2253 2253 + char const utf8_literal[] = u8"happens to be ASCII" "another string"; 2254 2254 + 2255 2255 + // Check duplicate typedefs. 2256 2256 + typedef long *long_ptr; 2257 2257 + typedef long int *long_ptr; 2258 2258 + typedef long_ptr long_ptr; 2259 2259 + 2260 2260 + // Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. 2261 2261 + struct anonymous 2262 2262 + { 2263 2263 + union { 2264 2264 + struct { int i; int j; }; 2265 2265 + struct { int k; long int l; } w; 2266 2266 + }; 2267 2267 + int m; 2268 2268 + } v1; 2269 2269 + ' 2270 2270 + 2271 2271 + # Test code for whether the C compiler supports C11 (body of main). 2272 2272 + ac_c_conftest_c11_main=' 2273 2273 + _Static_assert ((offsetof (struct anonymous, i) 2274 2274 + == offsetof (struct anonymous, w.k)), 2275 2275 + "Anonymous union alignment botch"); 2276 2276 + v1.i = 2; 2277 2277 + v1.w.k = 5; 2278 2278 + ok |= v1.i != 5; 2279 2279 + ' 2280 2280 + 2281 2281 + # Test code for whether the C compiler supports C11 (complete). 2282 2282 + ac_c_conftest_c11_program="${ac_c_conftest_c89_globals} 2283 2283 + ${ac_c_conftest_c99_globals} 2284 2284 + ${ac_c_conftest_c11_globals} 2285 2285 + 2286 2286 + int 2287 2287 + main (int argc, char **argv) 2288 2288 + { 2289 2289 + int ok = 0; 2290 2290 + ${ac_c_conftest_c89_main} 2291 2291 + ${ac_c_conftest_c99_main} 2292 2292 + ${ac_c_conftest_c11_main} 2293 2293 + return ok; 2294 2294 + } 2295 2295 + " 2296 2296 + 2297 2297 + # Test code for whether the C compiler supports C99 (complete). 2298 2298 + ac_c_conftest_c99_program="${ac_c_conftest_c89_globals} 2299 2299 + ${ac_c_conftest_c99_globals} 2300 2300 + 2301 2301 + int 2302 2302 + main (int argc, char **argv) 2303 2303 + { 2304 2304 + int ok = 0; 2305 2305 + ${ac_c_conftest_c89_main} 2306 2306 + ${ac_c_conftest_c99_main} 2307 2307 + return ok; 2308 2308 + } 2309 2309 + " 2310 2310 + 2311 2311 + # Test code for whether the C compiler supports C89 (complete). 2312 2312 + ac_c_conftest_c89_program="${ac_c_conftest_c89_globals} 2313 2313 + 2314 2314 + int 2315 2315 + main (int argc, char **argv) 2316 2316 + { 2317 2317 + int ok = 0; 2318 2318 + ${ac_c_conftest_c89_main} 2319 2319 + return ok; 2320 2320 + } 2321 2321 + " 2322 2322 + 2323 2323 + as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H" 2324 2324 + as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H" 2325 2325 + as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H" 2326 2326 + as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H" 2327 2327 + as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H" 2328 2328 + as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H" 2329 2329 + as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H" 2330 2330 + as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H" 2331 2331 + as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H" 2332 2332 + 2333 2333 + # Auxiliary files required by this configure script. 2334 2334 + ac_aux_files="config.guess config.sub missing install-sh" 2335 2335 + 2336 2336 + # Locations in which to look for auxiliary files. 2337 2337 + ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.." 2338 2338 + 2339 2339 + # Search for a directory containing all of the required auxiliary files, 2340 2340 + # $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates. 2341 2341 + # If we don't find one directory that contains all the files we need, 2342 2342 + # we report the set of missing files from the *first* directory in 2343 2343 + # $ac_aux_dir_candidates and give up. 2344 2344 + ac_missing_aux_files="" 2345 2345 + ac_first_candidate=: 2346 2346 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 2347 2347 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 2348 2348 + as_found=false 2349 2349 + for as_dir in $ac_aux_dir_candidates 2350 2350 + do 2351 2351 + IFS=$as_save_IFS 2352 2352 + case $as_dir in #((( 2353 2353 + '') as_dir=./ ;; 2354 2354 + */) ;; 2355 2355 + *) as_dir=$as_dir/ ;; 2356 2356 + esac 2357 2357 + as_found=: 2358 2358 + 2359 2359 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 2360 2360 + ac_aux_dir_found=yes 2361 2361 + ac_install_sh= 2362 2362 + for ac_aux in $ac_aux_files 2363 2363 + do 2364 2364 + # As a special case, if "install-sh" is required, that requirement 2365 2365 + # can be satisfied by any of "install-sh", "install.sh", or "shtool", 2366 2366 + # and $ac_install_sh is set appropriately for whichever one is found. 2367 2367 + if test x"$ac_aux" = x"install-sh" 2368 2368 + then 2369 2369 + if test -f "${as_dir}install-sh"; then 2370 2370 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 2371 2371 + ac_install_sh="${as_dir}install-sh -c" 2372 2372 + elif test -f "${as_dir}install.sh"; then 2373 2373 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 2374 2374 + ac_install_sh="${as_dir}install.sh -c" 2375 2375 + elif test -f "${as_dir}shtool"; then 2376 2376 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 2377 2377 + ac_install_sh="${as_dir}shtool install -c" 2378 2378 + else 2379 2379 + ac_aux_dir_found=no 2380 2380 + if $ac_first_candidate; then 2381 2381 + ac_missing_aux_files="${ac_missing_aux_files} install-sh" 2382 2382 + else 2383 2383 + break 2384 2384 + fi 2385 2385 + fi 2386 2386 + else 2387 2387 + if test -f "${as_dir}${ac_aux}"; then 2388 2388 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 2389 2389 + else 2390 2390 + ac_aux_dir_found=no 2391 2391 + if $ac_first_candidate; then 2392 2392 + ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}" 2393 2393 + else 2394 2394 + break 2395 2395 + fi 2396 2396 + fi 2397 2397 + fi 2398 2398 + done 2399 2399 + if test "$ac_aux_dir_found" = yes; then 2400 2400 + ac_aux_dir="$as_dir" 2401 2401 + break 2402 2402 + fi 2403 2403 + ac_first_candidate=false 2404 2404 + 2405 2405 + as_found=false 2406 2406 + done 2407 2407 + IFS=$as_save_IFS 2408 2408 + if $as_found 2409 2409 + then : 2410 2410 + 2411 2411 + else $as_nop 2412 2412 + as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 2413 2413 + fi 2414 2414 + 2415 2415 + 2416 2416 + # These three variables are undocumented and unsupported, 2417 2417 + # and are intended to be withdrawn in a future Autoconf release. 2418 2418 + # They can cause serious problems if a builder's source tree is in a directory 2419 2419 + # whose full name contains unusual characters. 2420 2420 + if test -f "${ac_aux_dir}config.guess"; then 2421 2421 + ac_config_guess="$SHELL ${ac_aux_dir}config.guess" 2422 2422 + fi 2423 2423 + if test -f "${ac_aux_dir}config.sub"; then 2424 2424 + ac_config_sub="$SHELL ${ac_aux_dir}config.sub" 2425 2425 + fi 2426 2426 + if test -f "$ac_aux_dir/configure"; then 2427 2427 + ac_configure="$SHELL ${ac_aux_dir}configure" 2428 2428 + fi 2429 2429 + 2119 2430 # Check that the precious variables saved in the cache have kept the same 2120 2431 # value. 2121 2432 ac_cache_corrupted=false ··· 2126 2437 eval ac_new_val=\$ac_env_${ac_var}_value 2127 2438 case $ac_old_set,$ac_new_set in 2128 2439 set,) 2129 2129 - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 2130 2130 - $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} 2440 2440 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 2441 2441 + printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} 2131 2442 ac_cache_corrupted=: ;; 2132 2443 ,set) 2133 2133 - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 2134 2134 - $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} 2444 2444 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 2445 2445 + printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} 2135 2446 ac_cache_corrupted=: ;; 2136 2447 ,);; 2137 2448 *) ··· 2140 2451 ac_old_val_w=`echo x $ac_old_val` 2141 2452 ac_new_val_w=`echo x $ac_new_val` 2142 2453 if test "$ac_old_val_w" != "$ac_new_val_w"; then 2143 2143 - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 2144 2144 - $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} 2454 2454 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 2455 2455 + printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} 2145 2456 ac_cache_corrupted=: 2146 2457 else 2147 2147 - { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 2148 2148 - $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} 2458 2458 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 2459 2459 + printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} 2149 2460 eval $ac_var=\$ac_old_val 2150 2461 fi 2151 2151 - { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 2152 2152 - $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} 2153 2153 - { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 2154 2154 - $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} 2462 2462 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 2463 2463 + printf "%s\n" "$as_me: former value: \`$ac_old_val'" >&2;} 2464 2464 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 2465 2465 + printf "%s\n" "$as_me: current value: \`$ac_new_val'" >&2;} 2155 2466 fi;; 2156 2467 esac 2157 2468 # Pass precious variables to config.status. 2158 2469 if test "$ac_new_set" = set; then 2159 2470 case $ac_new_val in 2160 2160 - *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; 2471 2471 + *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; 2161 2472 *) ac_arg=$ac_var=$ac_new_val ;; 2162 2473 esac 2163 2474 case " $ac_configure_args " in ··· 2167 2478 fi 2168 2479 done 2169 2480 if $ac_cache_corrupted; then 2170 2170 - { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 2171 2171 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 2172 2172 - { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 2173 2173 - $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} 2174 2174 - as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 2481 2481 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 2482 2482 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 2483 2483 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 2484 2484 + printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;} 2485 2485 + as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file' 2486 2486 + and start over" "$LINENO" 5 2175 2487 fi 2176 2488 ## -------------------- ## 2177 2489 ## Main body of script. ## ··· 2191 2503 # Initialize Automake 2192 2504 am__api_version='1.12' 2193 2505 2194 2194 - ac_aux_dir= 2195 2195 - for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do 2196 2196 - if test -f "$ac_dir/install-sh"; then 2197 2197 - ac_aux_dir=$ac_dir 2198 2198 - ac_install_sh="$ac_aux_dir/install-sh -c" 2199 2199 - break 2200 2200 - elif test -f "$ac_dir/install.sh"; then 2201 2201 - ac_aux_dir=$ac_dir 2202 2202 - ac_install_sh="$ac_aux_dir/install.sh -c" 2203 2203 - break 2204 2204 - elif test -f "$ac_dir/shtool"; then 2205 2205 - ac_aux_dir=$ac_dir 2206 2206 - ac_install_sh="$ac_aux_dir/shtool install -c" 2207 2207 - break 2208 2208 - fi 2209 2209 - done 2210 2210 - if test -z "$ac_aux_dir"; then 2211 2211 - as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 2212 2212 - fi 2213 2506 2214 2214 - # These three variables are undocumented and unsupported, 2215 2215 - # and are intended to be withdrawn in a future Autoconf release. 2216 2216 - # They can cause serious problems if a builder's source tree is in a directory 2217 2217 - # whose full name contains unusual characters. 2218 2218 - ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. 2219 2219 - ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. 2220 2220 - ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. 2221 2507 2222 2222 - 2223 2223 - # Find a good install program. We prefer a C program (faster), 2508 2508 + # Find a good install program. We prefer a C program (faster), 2224 2509 # so one script is as good as another. But avoid the broken or 2225 2510 # incompatible versions: 2226 2511 # SysV /etc/install, /usr/sbin/install ··· 2234 2519 # OS/2's system install, which has a completely different semantic 2235 2520 # ./install, which can be erroneously created by make from ./install.sh. 2236 2521 # Reject install programs that cannot install multiple files. 2237 2237 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 2238 2238 - $as_echo_n "checking for a BSD-compatible install... " >&6; } 2522 2522 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 2523 2523 + printf %s "checking for a BSD-compatible install... " >&6; } 2239 2524 if test -z "$INSTALL"; then 2240 2240 - if ${ac_cv_path_install+:} false; then : 2241 2241 - $as_echo_n "(cached) " >&6 2242 2242 - else 2525 2525 + if test ${ac_cv_path_install+y} 2526 2526 + then : 2527 2527 + printf %s "(cached) " >&6 2528 2528 + else $as_nop 2243 2529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 2244 2530 for as_dir in $PATH 2245 2531 do 2246 2532 IFS=$as_save_IFS 2247 2247 - test -z "$as_dir" && as_dir=. 2248 2248 - # Account for people who put trailing slashes in PATH elements. 2249 2249 - case $as_dir/ in #(( 2250 2250 - ./ | .// | /[cC]/* | \ 2533 2533 + case $as_dir in #((( 2534 2534 + '') as_dir=./ ;; 2535 2535 + */) ;; 2536 2536 + *) as_dir=$as_dir/ ;; 2537 2537 + esac 2538 2538 + # Account for fact that we put trailing slashes in our PATH walk. 2539 2539 + case $as_dir in #(( 2540 2540 + ./ | /[cC]/* | \ 2251 2541 /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ 2252 2542 ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ 2253 2543 /usr/ucb/* ) ;; ··· 2257 2547 # by default. 2258 2548 for ac_prog in ginstall scoinst install; do 2259 2549 for ac_exec_ext in '' $ac_executable_extensions; do 2260 2260 - if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then 2550 2550 + if as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext"; then 2261 2551 if test $ac_prog = install && 2262 2262 - grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then 2552 2552 + grep dspmsg "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then 2263 2553 # AIX install. It has an incompatible calling convention. 2264 2554 : 2265 2555 elif test $ac_prog = install && 2266 2266 - grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then 2556 2556 + grep pwplus "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then 2267 2557 # program-specific install script used by HP pwplus--don't use. 2268 2558 : 2269 2559 else ··· 2271 2561 echo one > conftest.one 2272 2562 echo two > conftest.two 2273 2563 mkdir conftest.dir 2274 2274 - if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && 2564 2564 + if "$as_dir$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir/" && 2275 2565 test -s conftest.one && test -s conftest.two && 2276 2566 test -s conftest.dir/conftest.one && 2277 2567 test -s conftest.dir/conftest.two 2278 2568 then 2279 2279 - ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" 2569 2569 + ac_cv_path_install="$as_dir$ac_prog$ac_exec_ext -c" 2280 2570 break 3 2281 2571 fi 2282 2572 fi ··· 2292 2582 rm -rf conftest.one conftest.two conftest.dir 2293 2583 2294 2584 fi 2295 2295 - if test "${ac_cv_path_install+set}" = set; then 2585 2585 + if test ${ac_cv_path_install+y}; then 2296 2586 INSTALL=$ac_cv_path_install 2297 2587 else 2298 2588 # As a last resort, use the slow shell script. Don't cache a ··· 2302 2592 INSTALL=$ac_install_sh 2303 2593 fi 2304 2594 fi 2305 2305 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 2306 2306 - $as_echo "$INSTALL" >&6; } 2595 2595 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 2596 2596 + printf "%s\n" "$INSTALL" >&6; } 2307 2597 2308 2598 # Use test -z because SunOS4 sh mishandles braces in ${var-val}. 2309 2599 # It thinks the first close brace ends the variable substitution. ··· 2313 2603 2314 2604 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' 2315 2605 2316 2316 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 2317 2317 - $as_echo_n "checking whether build environment is sane... " >&6; } 2606 2606 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 2607 2607 + printf %s "checking whether build environment is sane... " >&6; } 2318 2608 # Reject unsafe characters in $srcdir or the absolute working directory 2319 2609 # name. Accept space and tab only in the latter. 2320 2610 am_lf=' ··· 2368 2658 as_fn_error $? "newly created file is older than distributed files! 2369 2659 Check your system clock" "$LINENO" 5 2370 2660 fi 2371 2371 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 2372 2372 - $as_echo "yes" >&6; } 2661 2661 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 2662 2662 + printf "%s\n" "yes" >&6; } 2373 2663 # If we didn't sleep, we still need to ensure time stamps of config.status and 2374 2664 # generated files are strictly newer. 2375 2665 am_sleep_pid= ··· 2388 2678 # Double any \ or $. 2389 2679 # By default was `s,x,x', remove it if useless. 2390 2680 ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' 2391 2391 - program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` 2681 2681 + program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"` 2392 2682 2393 2683 # expand $ac_aux_dir to an absolute path 2394 2684 am_aux_dir=`cd $ac_aux_dir && pwd` 2395 2685 2396 2396 - if test x"${MISSING+set}" != xset; then 2686 2686 + 2687 2687 + if test x"${MISSING+set}" != xset; then 2397 2688 case $am_aux_dir in 2398 2689 *\ * | *\ *) 2399 2690 MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; ··· 2406 2697 am_missing_run="$MISSING --run " 2407 2698 else 2408 2699 am_missing_run= 2409 2409 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 2410 2410 - $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;} 2700 2700 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 2701 2701 + printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;} 2411 2702 fi 2412 2703 2413 2704 if test x"${install_sh}" != xset; then ··· 2427 2718 if test -n "$ac_tool_prefix"; then 2428 2719 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. 2429 2720 set dummy ${ac_tool_prefix}strip; ac_word=$2 2430 2430 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2431 2431 - $as_echo_n "checking for $ac_word... " >&6; } 2432 2432 - if ${ac_cv_prog_STRIP+:} false; then : 2433 2433 - $as_echo_n "(cached) " >&6 2434 2434 - else 2721 2721 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2722 2722 + printf %s "checking for $ac_word... " >&6; } 2723 2723 + if test ${ac_cv_prog_STRIP+y} 2724 2724 + then : 2725 2725 + printf %s "(cached) " >&6 2726 2726 + else $as_nop 2435 2727 if test -n "$STRIP"; then 2436 2728 ac_cv_prog_STRIP="$STRIP" # Let the user override the test. 2437 2729 else ··· 2439 2731 for as_dir in $PATH 2440 2732 do 2441 2733 IFS=$as_save_IFS 2442 2442 - test -z "$as_dir" && as_dir=. 2734 2734 + case $as_dir in #((( 2735 2735 + '') as_dir=./ ;; 2736 2736 + */) ;; 2737 2737 + *) as_dir=$as_dir/ ;; 2738 2738 + esac 2443 2739 for ac_exec_ext in '' $ac_executable_extensions; do 2444 2444 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 2740 2740 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 2445 2741 ac_cv_prog_STRIP="${ac_tool_prefix}strip" 2446 2446 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 2742 2742 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2447 2743 break 2 2448 2744 fi 2449 2745 done ··· 2454 2750 fi 2455 2751 STRIP=$ac_cv_prog_STRIP 2456 2752 if test -n "$STRIP"; then 2457 2457 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 2458 2458 - $as_echo "$STRIP" >&6; } 2753 2753 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 2754 2754 + printf "%s\n" "$STRIP" >&6; } 2459 2755 else 2460 2460 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2461 2461 - $as_echo "no" >&6; } 2756 2756 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 2757 2757 + printf "%s\n" "no" >&6; } 2462 2758 fi 2463 2759 2464 2760 ··· 2467 2763 ac_ct_STRIP=$STRIP 2468 2764 # Extract the first word of "strip", so it can be a program name with args. 2469 2765 set dummy strip; ac_word=$2 2470 2470 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2471 2471 - $as_echo_n "checking for $ac_word... " >&6; } 2472 2472 - if ${ac_cv_prog_ac_ct_STRIP+:} false; then : 2473 2473 - $as_echo_n "(cached) " >&6 2474 2474 - else 2766 2766 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2767 2767 + printf %s "checking for $ac_word... " >&6; } 2768 2768 + if test ${ac_cv_prog_ac_ct_STRIP+y} 2769 2769 + then : 2770 2770 + printf %s "(cached) " >&6 2771 2771 + else $as_nop 2475 2772 if test -n "$ac_ct_STRIP"; then 2476 2773 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. 2477 2774 else ··· 2479 2776 for as_dir in $PATH 2480 2777 do 2481 2778 IFS=$as_save_IFS 2482 2482 - test -z "$as_dir" && as_dir=. 2779 2779 + case $as_dir in #((( 2780 2780 + '') as_dir=./ ;; 2781 2781 + */) ;; 2782 2782 + *) as_dir=$as_dir/ ;; 2783 2783 + esac 2483 2784 for ac_exec_ext in '' $ac_executable_extensions; do 2484 2484 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 2785 2785 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 2485 2786 ac_cv_prog_ac_ct_STRIP="strip" 2486 2486 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 2787 2787 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2487 2788 break 2 2488 2789 fi 2489 2790 done ··· 2494 2795 fi 2495 2796 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP 2496 2797 if test -n "$ac_ct_STRIP"; then 2497 2497 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 2498 2498 - $as_echo "$ac_ct_STRIP" >&6; } 2798 2798 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 2799 2799 + printf "%s\n" "$ac_ct_STRIP" >&6; } 2499 2800 else 2500 2500 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2501 2501 - $as_echo "no" >&6; } 2801 2801 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 2802 2802 + printf "%s\n" "no" >&6; } 2502 2803 fi 2503 2804 2504 2805 if test "x$ac_ct_STRIP" = x; then ··· 2506 2807 else 2507 2808 case $cross_compiling:$ac_tool_warned in 2508 2809 yes:) 2509 2509 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 2510 2510 - $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 2810 2810 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 2811 2811 + printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 2511 2812 ac_tool_warned=yes ;; 2512 2813 esac 2513 2814 STRIP=$ac_ct_STRIP ··· 2519 2820 fi 2520 2821 INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" 2521 2822 2522 2522 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 2523 2523 - $as_echo_n "checking for a thread-safe mkdir -p... " >&6; } 2823 2823 + 2824 2824 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5 2825 2825 + printf %s "checking for a race-free mkdir -p... " >&6; } 2524 2826 if test -z "$MKDIR_P"; then 2525 2525 - if ${ac_cv_path_mkdir+:} false; then : 2526 2526 - $as_echo_n "(cached) " >&6 2527 2527 - else 2827 2827 + if test ${ac_cv_path_mkdir+y} 2828 2828 + then : 2829 2829 + printf %s "(cached) " >&6 2830 2830 + else $as_nop 2528 2831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 2529 2832 for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin 2530 2833 do 2531 2834 IFS=$as_save_IFS 2532 2532 - test -z "$as_dir" && as_dir=. 2835 2835 + case $as_dir in #((( 2836 2836 + '') as_dir=./ ;; 2837 2837 + */) ;; 2838 2838 + *) as_dir=$as_dir/ ;; 2839 2839 + esac 2533 2840 for ac_prog in mkdir gmkdir; do 2534 2841 for ac_exec_ext in '' $ac_executable_extensions; do 2535 2535 - as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue 2536 2536 - case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( 2537 2537 - 'mkdir (GNU coreutils) '* | \ 2538 2538 - 'mkdir (coreutils) '* | \ 2842 2842 + as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue 2843 2843 + case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #( 2844 2844 + 'mkdir ('*'coreutils) '* | \ 2845 2845 + 'BusyBox '* | \ 2539 2846 'mkdir (fileutils) '4.1*) 2540 2540 - ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext 2847 2847 + ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext 2541 2848 break 3;; 2542 2849 esac 2543 2850 done ··· 2548 2855 fi 2549 2856 2550 2857 test -d ./--version && rmdir ./--version 2551 2551 - if test "${ac_cv_path_mkdir+set}" = set; then 2858 2858 + if test ${ac_cv_path_mkdir+y}; then 2552 2859 MKDIR_P="$ac_cv_path_mkdir -p" 2553 2860 else 2554 2861 # As a last resort, use the slow shell script. Don't cache a ··· 2558 2865 MKDIR_P="$ac_install_sh -d" 2559 2866 fi 2560 2867 fi 2561 2561 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 2562 2562 - $as_echo "$MKDIR_P" >&6; } 2868 2868 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 2869 2869 + printf "%s\n" "$MKDIR_P" >&6; } 2563 2870 2564 2871 for ac_prog in gawk mawk nawk awk 2565 2872 do 2566 2873 # Extract the first word of "$ac_prog", so it can be a program name with args. 2567 2874 set dummy $ac_prog; ac_word=$2 2568 2568 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2569 2569 - $as_echo_n "checking for $ac_word... " >&6; } 2570 2570 - if ${ac_cv_prog_AWK+:} false; then : 2571 2571 - $as_echo_n "(cached) " >&6 2572 2572 - else 2875 2875 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2876 2876 + printf %s "checking for $ac_word... " >&6; } 2877 2877 + if test ${ac_cv_prog_AWK+y} 2878 2878 + then : 2879 2879 + printf %s "(cached) " >&6 2880 2880 + else $as_nop 2573 2881 if test -n "$AWK"; then 2574 2882 ac_cv_prog_AWK="$AWK" # Let the user override the test. 2575 2883 else ··· 2577 2885 for as_dir in $PATH 2578 2886 do 2579 2887 IFS=$as_save_IFS 2580 2580 - test -z "$as_dir" && as_dir=. 2888 2888 + case $as_dir in #((( 2889 2889 + '') as_dir=./ ;; 2890 2890 + */) ;; 2891 2891 + *) as_dir=$as_dir/ ;; 2892 2892 + esac 2581 2893 for ac_exec_ext in '' $ac_executable_extensions; do 2582 2582 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 2894 2894 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 2583 2895 ac_cv_prog_AWK="$ac_prog" 2584 2584 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 2896 2896 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2585 2897 break 2 2586 2898 fi 2587 2899 done ··· 2592 2904 fi 2593 2905 AWK=$ac_cv_prog_AWK 2594 2906 if test -n "$AWK"; then 2595 2595 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 2596 2596 - $as_echo "$AWK" >&6; } 2907 2907 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 2908 2908 + printf "%s\n" "$AWK" >&6; } 2597 2909 else 2598 2598 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2599 2599 - $as_echo "no" >&6; } 2910 2910 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 2911 2911 + printf "%s\n" "no" >&6; } 2600 2912 fi 2601 2913 2602 2914 2603 2915 test -n "$AWK" && break 2604 2916 done 2605 2917 2606 2606 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 2607 2607 - $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } 2918 2918 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 2919 2919 + printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } 2608 2920 set x ${MAKE-make} 2609 2609 - ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` 2610 2610 - if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : 2611 2611 - $as_echo_n "(cached) " >&6 2612 2612 - else 2921 2921 + ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` 2922 2922 + if eval test \${ac_cv_prog_make_${ac_make}_set+y} 2923 2923 + then : 2924 2924 + printf %s "(cached) " >&6 2925 2925 + else $as_nop 2613 2926 cat >conftest.make <<\_ACEOF 2614 2927 SHELL = /bin/sh 2615 2928 all: ··· 2625 2938 rm -f conftest.make 2626 2939 fi 2627 2940 if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then 2628 2628 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 2629 2629 - $as_echo "yes" >&6; } 2941 2941 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 2942 2942 + printf "%s\n" "yes" >&6; } 2630 2943 SET_MAKE= 2631 2944 else 2632 2632 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2633 2633 - $as_echo "no" >&6; } 2945 2945 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 2946 2946 + printf "%s\n" "no" >&6; } 2634 2947 SET_MAKE="MAKE=${MAKE-make}" 2635 2948 fi 2636 2949 ··· 2665 2978 2666 2979 # Define the identity of the package. 2667 2980 PACKAGE='xkbevd' 2668 2668 - VERSION='1.1.5' 2981 2981 + VERSION='1.1.6' 2669 2982 2670 2983 2671 2671 - cat >>confdefs.h <<_ACEOF 2672 2672 - #define PACKAGE "$PACKAGE" 2673 2673 - _ACEOF 2984 2984 + printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h 2674 2985 2675 2986 2676 2676 - cat >>confdefs.h <<_ACEOF 2677 2677 - #define VERSION "$VERSION" 2678 2678 - _ACEOF 2987 2987 + printf "%s\n" "#define VERSION \"$VERSION\"" >>confdefs.h 2679 2988 2680 2989 # Some tools Automake needs. 2681 2990 ··· 2724 3033 2725 3034 2726 3035 2727 2727 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5 2728 2728 - $as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; } 3036 3036 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5 3037 3037 + printf %s "checking whether to enable maintainer-specific portions of Makefiles... " >&6; } 2729 3038 # Check whether --enable-maintainer-mode was given. 2730 2730 - if test "${enable_maintainer_mode+set}" = set; then : 3039 3039 + if test ${enable_maintainer_mode+y} 3040 3040 + then : 2731 3041 enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval 2732 2732 - else 3042 3042 + else $as_nop 2733 3043 USE_MAINTAINER_MODE=no 2734 3044 fi 2735 3045 2736 2736 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5 2737 2737 - $as_echo "$USE_MAINTAINER_MODE" >&6; } 3046 3046 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5 3047 3047 + printf "%s\n" "$USE_MAINTAINER_MODE" >&6; } 2738 3048 if test $USE_MAINTAINER_MODE = yes; then 2739 3049 MAINTAINER_MODE_TRUE= 2740 3050 MAINTAINER_MODE_FALSE='#' ··· 2744 3054 fi 2745 3055 2746 3056 MAINT=$MAINTAINER_MODE_TRUE 3057 3057 + 3058 3058 + 3059 3059 + 3060 3060 + 3061 3061 + 3062 3062 + 3063 3063 + 3064 3064 + 3065 3065 + 2747 3066 2748 3067 2749 3068 ··· 2759 3078 .PHONY: am__doit 2760 3079 END 2761 3080 # If we don't find an include directive, just comment out the code. 2762 2762 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 2763 2763 - $as_echo_n "checking for style of include used by $am_make... " >&6; } 3081 3081 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 3082 3082 + printf %s "checking for style of include used by $am_make... " >&6; } 2764 3083 am__include="#" 2765 3084 am__quote= 2766 3085 _am_result=none ··· 2787 3106 fi 2788 3107 2789 3108 2790 2790 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 2791 2791 - $as_echo "$_am_result" >&6; } 3109 3109 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 3110 3110 + printf "%s\n" "$_am_result" >&6; } 2792 3111 rm -f confinc confmf 2793 3112 2794 3113 # Check whether --enable-dependency-tracking was given. 2795 2795 - if test "${enable_dependency_tracking+set}" = set; then : 3114 3114 + if test ${enable_dependency_tracking+y} 3115 3115 + then : 2796 3116 enableval=$enable_dependency_tracking; 2797 3117 fi 2798 3118 ··· 2818 3138 if test -n "$ac_tool_prefix"; then 2819 3139 # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. 2820 3140 set dummy ${ac_tool_prefix}gcc; ac_word=$2 2821 2821 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2822 2822 - $as_echo_n "checking for $ac_word... " >&6; } 2823 2823 - if ${ac_cv_prog_CC+:} false; then : 2824 2824 - $as_echo_n "(cached) " >&6 2825 2825 - else 3141 3141 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3142 3142 + printf %s "checking for $ac_word... " >&6; } 3143 3143 + if test ${ac_cv_prog_CC+y} 3144 3144 + then : 3145 3145 + printf %s "(cached) " >&6 3146 3146 + else $as_nop 2826 3147 if test -n "$CC"; then 2827 3148 ac_cv_prog_CC="$CC" # Let the user override the test. 2828 3149 else ··· 2830 3151 for as_dir in $PATH 2831 3152 do 2832 3153 IFS=$as_save_IFS 2833 2833 - test -z "$as_dir" && as_dir=. 3154 3154 + case $as_dir in #((( 3155 3155 + '') as_dir=./ ;; 3156 3156 + */) ;; 3157 3157 + *) as_dir=$as_dir/ ;; 3158 3158 + esac 2834 3159 for ac_exec_ext in '' $ac_executable_extensions; do 2835 2835 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 3160 3160 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 2836 3161 ac_cv_prog_CC="${ac_tool_prefix}gcc" 2837 2837 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 3162 3162 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2838 3163 break 2 2839 3164 fi 2840 3165 done ··· 2845 3170 fi 2846 3171 CC=$ac_cv_prog_CC 2847 3172 if test -n "$CC"; then 2848 2848 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 2849 2849 - $as_echo "$CC" >&6; } 3173 3173 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 3174 3174 + printf "%s\n" "$CC" >&6; } 2850 3175 else 2851 2851 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2852 2852 - $as_echo "no" >&6; } 3176 3176 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3177 3177 + printf "%s\n" "no" >&6; } 2853 3178 fi 2854 3179 2855 3180 ··· 2858 3183 ac_ct_CC=$CC 2859 3184 # Extract the first word of "gcc", so it can be a program name with args. 2860 3185 set dummy gcc; ac_word=$2 2861 2861 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2862 2862 - $as_echo_n "checking for $ac_word... " >&6; } 2863 2863 - if ${ac_cv_prog_ac_ct_CC+:} false; then : 2864 2864 - $as_echo_n "(cached) " >&6 2865 2865 - else 3186 3186 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3187 3187 + printf %s "checking for $ac_word... " >&6; } 3188 3188 + if test ${ac_cv_prog_ac_ct_CC+y} 3189 3189 + then : 3190 3190 + printf %s "(cached) " >&6 3191 3191 + else $as_nop 2866 3192 if test -n "$ac_ct_CC"; then 2867 3193 ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. 2868 3194 else ··· 2870 3196 for as_dir in $PATH 2871 3197 do 2872 3198 IFS=$as_save_IFS 2873 2873 - test -z "$as_dir" && as_dir=. 3199 3199 + case $as_dir in #((( 3200 3200 + '') as_dir=./ ;; 3201 3201 + */) ;; 3202 3202 + *) as_dir=$as_dir/ ;; 3203 3203 + esac 2874 3204 for ac_exec_ext in '' $ac_executable_extensions; do 2875 2875 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 3205 3205 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 2876 3206 ac_cv_prog_ac_ct_CC="gcc" 2877 2877 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 3207 3207 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2878 3208 break 2 2879 3209 fi 2880 3210 done ··· 2885 3215 fi 2886 3216 ac_ct_CC=$ac_cv_prog_ac_ct_CC 2887 3217 if test -n "$ac_ct_CC"; then 2888 2888 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 2889 2889 - $as_echo "$ac_ct_CC" >&6; } 3218 3218 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 3219 3219 + printf "%s\n" "$ac_ct_CC" >&6; } 2890 3220 else 2891 2891 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2892 2892 - $as_echo "no" >&6; } 3221 3221 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3222 3222 + printf "%s\n" "no" >&6; } 2893 3223 fi 2894 3224 2895 3225 if test "x$ac_ct_CC" = x; then ··· 2897 3227 else 2898 3228 case $cross_compiling:$ac_tool_warned in 2899 3229 yes:) 2900 2900 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 2901 2901 - $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 3230 3230 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 3231 3231 + printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 2902 3232 ac_tool_warned=yes ;; 2903 3233 esac 2904 3234 CC=$ac_ct_CC ··· 2911 3241 if test -n "$ac_tool_prefix"; then 2912 3242 # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. 2913 3243 set dummy ${ac_tool_prefix}cc; ac_word=$2 2914 2914 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2915 2915 - $as_echo_n "checking for $ac_word... " >&6; } 2916 2916 - if ${ac_cv_prog_CC+:} false; then : 2917 2917 - $as_echo_n "(cached) " >&6 2918 2918 - else 3244 3244 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3245 3245 + printf %s "checking for $ac_word... " >&6; } 3246 3246 + if test ${ac_cv_prog_CC+y} 3247 3247 + then : 3248 3248 + printf %s "(cached) " >&6 3249 3249 + else $as_nop 2919 3250 if test -n "$CC"; then 2920 3251 ac_cv_prog_CC="$CC" # Let the user override the test. 2921 3252 else ··· 2923 3254 for as_dir in $PATH 2924 3255 do 2925 3256 IFS=$as_save_IFS 2926 2926 - test -z "$as_dir" && as_dir=. 3257 3257 + case $as_dir in #((( 3258 3258 + '') as_dir=./ ;; 3259 3259 + */) ;; 3260 3260 + *) as_dir=$as_dir/ ;; 3261 3261 + esac 2927 3262 for ac_exec_ext in '' $ac_executable_extensions; do 2928 2928 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 3263 3263 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 2929 3264 ac_cv_prog_CC="${ac_tool_prefix}cc" 2930 2930 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 3265 3265 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2931 3266 break 2 2932 3267 fi 2933 3268 done ··· 2938 3273 fi 2939 3274 CC=$ac_cv_prog_CC 2940 3275 if test -n "$CC"; then 2941 2941 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 2942 2942 - $as_echo "$CC" >&6; } 3276 3276 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 3277 3277 + printf "%s\n" "$CC" >&6; } 2943 3278 else 2944 2944 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 2945 2945 - $as_echo "no" >&6; } 3279 3279 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3280 3280 + printf "%s\n" "no" >&6; } 2946 3281 fi 2947 3282 2948 3283 ··· 2951 3286 if test -z "$CC"; then 2952 3287 # Extract the first word of "cc", so it can be a program name with args. 2953 3288 set dummy cc; ac_word=$2 2954 2954 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 2955 2955 - $as_echo_n "checking for $ac_word... " >&6; } 2956 2956 - if ${ac_cv_prog_CC+:} false; then : 2957 2957 - $as_echo_n "(cached) " >&6 2958 2958 - else 3289 3289 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3290 3290 + printf %s "checking for $ac_word... " >&6; } 3291 3291 + if test ${ac_cv_prog_CC+y} 3292 3292 + then : 3293 3293 + printf %s "(cached) " >&6 3294 3294 + else $as_nop 2959 3295 if test -n "$CC"; then 2960 3296 ac_cv_prog_CC="$CC" # Let the user override the test. 2961 3297 else ··· 2964 3300 for as_dir in $PATH 2965 3301 do 2966 3302 IFS=$as_save_IFS 2967 2967 - test -z "$as_dir" && as_dir=. 3303 3303 + case $as_dir in #((( 3304 3304 + '') as_dir=./ ;; 3305 3305 + */) ;; 3306 3306 + *) as_dir=$as_dir/ ;; 3307 3307 + esac 2968 3308 for ac_exec_ext in '' $ac_executable_extensions; do 2969 2969 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 2970 2970 - if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then 3309 3309 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 3310 3310 + if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then 2971 3311 ac_prog_rejected=yes 2972 3312 continue 2973 3313 fi 2974 3314 ac_cv_prog_CC="cc" 2975 2975 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 3315 3315 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 2976 3316 break 2 2977 3317 fi 2978 3318 done ··· 2988 3328 # However, it has the same basename, so the bogon will be chosen 2989 3329 # first if we set CC to just the basename; use the full file name. 2990 3330 shift 2991 2991 - ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" 3331 3331 + ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@" 2992 3332 fi 2993 3333 fi 2994 3334 fi 2995 3335 fi 2996 3336 CC=$ac_cv_prog_CC 2997 3337 if test -n "$CC"; then 2998 2998 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 2999 2999 - $as_echo "$CC" >&6; } 3338 3338 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 3339 3339 + printf "%s\n" "$CC" >&6; } 3000 3340 else 3001 3001 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 3002 3002 - $as_echo "no" >&6; } 3341 3341 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3342 3342 + printf "%s\n" "no" >&6; } 3003 3343 fi 3004 3344 3005 3345 ··· 3010 3350 do 3011 3351 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. 3012 3352 set dummy $ac_tool_prefix$ac_prog; ac_word=$2 3013 3013 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3014 3014 - $as_echo_n "checking for $ac_word... " >&6; } 3015 3015 - if ${ac_cv_prog_CC+:} false; then : 3016 3016 - $as_echo_n "(cached) " >&6 3017 3017 - else 3353 3353 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3354 3354 + printf %s "checking for $ac_word... " >&6; } 3355 3355 + if test ${ac_cv_prog_CC+y} 3356 3356 + then : 3357 3357 + printf %s "(cached) " >&6 3358 3358 + else $as_nop 3018 3359 if test -n "$CC"; then 3019 3360 ac_cv_prog_CC="$CC" # Let the user override the test. 3020 3361 else ··· 3022 3363 for as_dir in $PATH 3023 3364 do 3024 3365 IFS=$as_save_IFS 3025 3025 - test -z "$as_dir" && as_dir=. 3366 3366 + case $as_dir in #((( 3367 3367 + '') as_dir=./ ;; 3368 3368 + */) ;; 3369 3369 + *) as_dir=$as_dir/ ;; 3370 3370 + esac 3026 3371 for ac_exec_ext in '' $ac_executable_extensions; do 3027 3027 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 3372 3372 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 3028 3373 ac_cv_prog_CC="$ac_tool_prefix$ac_prog" 3029 3029 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 3374 3374 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 3030 3375 break 2 3031 3376 fi 3032 3377 done ··· 3037 3382 fi 3038 3383 CC=$ac_cv_prog_CC 3039 3384 if test -n "$CC"; then 3040 3040 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 3041 3041 - $as_echo "$CC" >&6; } 3385 3385 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 3386 3386 + printf "%s\n" "$CC" >&6; } 3042 3387 else 3043 3043 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 3044 3044 - $as_echo "no" >&6; } 3388 3388 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3389 3389 + printf "%s\n" "no" >&6; } 3045 3390 fi 3046 3391 3047 3392 ··· 3054 3399 do 3055 3400 # Extract the first word of "$ac_prog", so it can be a program name with args. 3056 3401 set dummy $ac_prog; ac_word=$2 3057 3057 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3058 3058 - $as_echo_n "checking for $ac_word... " >&6; } 3059 3059 - if ${ac_cv_prog_ac_ct_CC+:} false; then : 3060 3060 - $as_echo_n "(cached) " >&6 3061 3061 - else 3402 3402 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3403 3403 + printf %s "checking for $ac_word... " >&6; } 3404 3404 + if test ${ac_cv_prog_ac_ct_CC+y} 3405 3405 + then : 3406 3406 + printf %s "(cached) " >&6 3407 3407 + else $as_nop 3062 3408 if test -n "$ac_ct_CC"; then 3063 3409 ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. 3064 3410 else ··· 3066 3412 for as_dir in $PATH 3067 3413 do 3068 3414 IFS=$as_save_IFS 3069 3069 - test -z "$as_dir" && as_dir=. 3415 3415 + case $as_dir in #((( 3416 3416 + '') as_dir=./ ;; 3417 3417 + */) ;; 3418 3418 + *) as_dir=$as_dir/ ;; 3419 3419 + esac 3070 3420 for ac_exec_ext in '' $ac_executable_extensions; do 3071 3071 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 3421 3421 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 3072 3422 ac_cv_prog_ac_ct_CC="$ac_prog" 3073 3073 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 3423 3423 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 3074 3424 break 2 3075 3425 fi 3076 3426 done ··· 3081 3431 fi 3082 3432 ac_ct_CC=$ac_cv_prog_ac_ct_CC 3083 3433 if test -n "$ac_ct_CC"; then 3084 3084 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 3085 3085 - $as_echo "$ac_ct_CC" >&6; } 3434 3434 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 3435 3435 + printf "%s\n" "$ac_ct_CC" >&6; } 3086 3436 else 3087 3087 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 3088 3088 - $as_echo "no" >&6; } 3437 3437 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3438 3438 + printf "%s\n" "no" >&6; } 3089 3439 fi 3090 3440 3091 3441 ··· 3097 3447 else 3098 3448 case $cross_compiling:$ac_tool_warned in 3099 3449 yes:) 3100 3100 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 3101 3101 - $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 3450 3450 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 3451 3451 + printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 3452 3452 + ac_tool_warned=yes ;; 3453 3453 + esac 3454 3454 + CC=$ac_ct_CC 3455 3455 + fi 3456 3456 + fi 3457 3457 + 3458 3458 + fi 3459 3459 + if test -z "$CC"; then 3460 3460 + if test -n "$ac_tool_prefix"; then 3461 3461 + # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args. 3462 3462 + set dummy ${ac_tool_prefix}clang; ac_word=$2 3463 3463 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3464 3464 + printf %s "checking for $ac_word... " >&6; } 3465 3465 + if test ${ac_cv_prog_CC+y} 3466 3466 + then : 3467 3467 + printf %s "(cached) " >&6 3468 3468 + else $as_nop 3469 3469 + if test -n "$CC"; then 3470 3470 + ac_cv_prog_CC="$CC" # Let the user override the test. 3471 3471 + else 3472 3472 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 3473 3473 + for as_dir in $PATH 3474 3474 + do 3475 3475 + IFS=$as_save_IFS 3476 3476 + case $as_dir in #((( 3477 3477 + '') as_dir=./ ;; 3478 3478 + */) ;; 3479 3479 + *) as_dir=$as_dir/ ;; 3480 3480 + esac 3481 3481 + for ac_exec_ext in '' $ac_executable_extensions; do 3482 3482 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 3483 3483 + ac_cv_prog_CC="${ac_tool_prefix}clang" 3484 3484 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 3485 3485 + break 2 3486 3486 + fi 3487 3487 + done 3488 3488 + done 3489 3489 + IFS=$as_save_IFS 3490 3490 + 3491 3491 + fi 3492 3492 + fi 3493 3493 + CC=$ac_cv_prog_CC 3494 3494 + if test -n "$CC"; then 3495 3495 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 3496 3496 + printf "%s\n" "$CC" >&6; } 3497 3497 + else 3498 3498 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3499 3499 + printf "%s\n" "no" >&6; } 3500 3500 + fi 3501 3501 + 3502 3502 + 3503 3503 + fi 3504 3504 + if test -z "$ac_cv_prog_CC"; then 3505 3505 + ac_ct_CC=$CC 3506 3506 + # Extract the first word of "clang", so it can be a program name with args. 3507 3507 + set dummy clang; ac_word=$2 3508 3508 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 3509 3509 + printf %s "checking for $ac_word... " >&6; } 3510 3510 + if test ${ac_cv_prog_ac_ct_CC+y} 3511 3511 + then : 3512 3512 + printf %s "(cached) " >&6 3513 3513 + else $as_nop 3514 3514 + if test -n "$ac_ct_CC"; then 3515 3515 + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. 3516 3516 + else 3517 3517 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 3518 3518 + for as_dir in $PATH 3519 3519 + do 3520 3520 + IFS=$as_save_IFS 3521 3521 + case $as_dir in #((( 3522 3522 + '') as_dir=./ ;; 3523 3523 + */) ;; 3524 3524 + *) as_dir=$as_dir/ ;; 3525 3525 + esac 3526 3526 + for ac_exec_ext in '' $ac_executable_extensions; do 3527 3527 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 3528 3528 + ac_cv_prog_ac_ct_CC="clang" 3529 3529 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 3530 3530 + break 2 3531 3531 + fi 3532 3532 + done 3533 3533 + done 3534 3534 + IFS=$as_save_IFS 3535 3535 + 3536 3536 + fi 3537 3537 + fi 3538 3538 + ac_ct_CC=$ac_cv_prog_ac_ct_CC 3539 3539 + if test -n "$ac_ct_CC"; then 3540 3540 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 3541 3541 + printf "%s\n" "$ac_ct_CC" >&6; } 3542 3542 + else 3543 3543 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3544 3544 + printf "%s\n" "no" >&6; } 3545 3545 + fi 3546 3546 + 3547 3547 + if test "x$ac_ct_CC" = x; then 3548 3548 + CC="" 3549 3549 + else 3550 3550 + case $cross_compiling:$ac_tool_warned in 3551 3551 + yes:) 3552 3552 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 3553 3553 + printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 3102 3554 ac_tool_warned=yes ;; 3103 3555 esac 3104 3556 CC=$ac_ct_CC 3105 3557 fi 3558 3558 + else 3559 3559 + CC="$ac_cv_prog_CC" 3106 3560 fi 3107 3561 3108 3562 fi 3109 3563 3110 3564 3111 3111 - test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3112 3112 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 3565 3565 + test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3566 3566 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 3113 3567 as_fn_error $? "no acceptable C compiler found in \$PATH 3114 3568 See \`config.log' for more details" "$LINENO" 5; } 3115 3569 3116 3570 # Provide some information about the compiler. 3117 3117 - $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 3571 3571 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 3118 3572 set X $ac_compile 3119 3573 ac_compiler=$2 3120 3120 - for ac_option in --version -v -V -qversion; do 3574 3574 + for ac_option in --version -v -V -qversion -version; do 3121 3575 { { ac_try="$ac_compiler $ac_option >&5" 3122 3576 case "(($ac_try" in 3123 3577 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 3124 3578 *) ac_try_echo=$ac_try;; 3125 3579 esac 3126 3580 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 3127 3127 - $as_echo "$ac_try_echo"; } >&5 3581 3581 + printf "%s\n" "$ac_try_echo"; } >&5 3128 3582 (eval "$ac_compiler $ac_option >&5") 2>conftest.err 3129 3583 ac_status=$? 3130 3584 if test -s conftest.err; then ··· 3134 3588 cat conftest.er1 >&5 3135 3589 fi 3136 3590 rm -f conftest.er1 conftest.err 3137 3137 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3591 3591 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3138 3592 test $ac_status = 0; } 3139 3593 done 3140 3594 ··· 3142 3596 /* end confdefs.h. */ 3143 3597 3144 3598 int 3145 3145 - main () 3599 3599 + main (void) 3146 3600 { 3147 3601 3148 3602 ; ··· 3154 3608 # Try to create an executable without -o first, disregard a.out. 3155 3609 # It will help us diagnose broken compilers, and finding out an intuition 3156 3610 # of exeext. 3157 3157 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 3158 3158 - $as_echo_n "checking whether the C compiler works... " >&6; } 3159 3159 - ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` 3611 3611 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 3612 3612 + printf %s "checking whether the C compiler works... " >&6; } 3613 3613 + ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'` 3160 3614 3161 3615 # The possible output files: 3162 3616 ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ··· 3177 3631 *) ac_try_echo=$ac_try;; 3178 3632 esac 3179 3633 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 3180 3180 - $as_echo "$ac_try_echo"; } >&5 3634 3634 + printf "%s\n" "$ac_try_echo"; } >&5 3181 3635 (eval "$ac_link_default") 2>&5 3182 3636 ac_status=$? 3183 3183 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3184 3184 - test $ac_status = 0; }; then : 3637 3637 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3638 3638 + test $ac_status = 0; } 3639 3639 + then : 3185 3640 # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. 3186 3641 # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' 3187 3642 # in a Makefile. We should not override ac_cv_exeext if it was cached, ··· 3198 3653 # certainly right. 3199 3654 break;; 3200 3655 *.* ) 3201 3201 - if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; 3656 3656 + if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no; 3202 3657 then :; else 3203 3658 ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` 3204 3659 fi ··· 3214 3669 done 3215 3670 test "$ac_cv_exeext" = no && ac_cv_exeext= 3216 3671 3217 3217 - else 3672 3672 + else $as_nop 3218 3673 ac_file='' 3219 3674 fi 3220 3220 - if test -z "$ac_file"; then : 3221 3221 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 3222 3222 - $as_echo "no" >&6; } 3223 3223 - $as_echo "$as_me: failed program was:" >&5 3675 3675 + if test -z "$ac_file" 3676 3676 + then : 3677 3677 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 3678 3678 + printf "%s\n" "no" >&6; } 3679 3679 + printf "%s\n" "$as_me: failed program was:" >&5 3224 3680 sed 's/^/| /' conftest.$ac_ext >&5 3225 3681 3226 3226 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3227 3227 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 3682 3682 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3683 3683 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 3228 3684 as_fn_error 77 "C compiler cannot create executables 3229 3685 See \`config.log' for more details" "$LINENO" 5; } 3230 3230 - else 3231 3231 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 3232 3232 - $as_echo "yes" >&6; } 3686 3686 + else $as_nop 3687 3687 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 3688 3688 + printf "%s\n" "yes" >&6; } 3233 3689 fi 3234 3234 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 3235 3235 - $as_echo_n "checking for C compiler default output file name... " >&6; } 3236 3236 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 3237 3237 - $as_echo "$ac_file" >&6; } 3690 3690 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 3691 3691 + printf %s "checking for C compiler default output file name... " >&6; } 3692 3692 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 3693 3693 + printf "%s\n" "$ac_file" >&6; } 3238 3694 ac_exeext=$ac_cv_exeext 3239 3695 3240 3696 rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out 3241 3697 ac_clean_files=$ac_clean_files_save 3242 3242 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 3243 3243 - $as_echo_n "checking for suffix of executables... " >&6; } 3698 3698 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 3699 3699 + printf %s "checking for suffix of executables... " >&6; } 3244 3700 if { { ac_try="$ac_link" 3245 3701 case "(($ac_try" in 3246 3702 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; 3247 3703 *) ac_try_echo=$ac_try;; 3248 3704 esac 3249 3705 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 3250 3250 - $as_echo "$ac_try_echo"; } >&5 3706 3706 + printf "%s\n" "$ac_try_echo"; } >&5 3251 3707 (eval "$ac_link") 2>&5 3252 3708 ac_status=$? 3253 3253 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3254 3254 - test $ac_status = 0; }; then : 3709 3709 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3710 3710 + test $ac_status = 0; } 3711 3711 + then : 3255 3712 # If both `conftest.exe' and `conftest' are `present' (well, observable) 3256 3713 # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will 3257 3714 # work properly (i.e., refer to `conftest.exe'), while it won't with ··· 3265 3722 * ) break;; 3266 3723 esac 3267 3724 done 3268 3268 - else 3269 3269 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3270 3270 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 3725 3725 + else $as_nop 3726 3726 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3727 3727 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 3271 3728 as_fn_error $? "cannot compute suffix of executables: cannot compile and link 3272 3729 See \`config.log' for more details" "$LINENO" 5; } 3273 3730 fi 3274 3731 rm -f conftest conftest$ac_cv_exeext 3275 3275 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 3276 3276 - $as_echo "$ac_cv_exeext" >&6; } 3732 3732 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 3733 3733 + printf "%s\n" "$ac_cv_exeext" >&6; } 3277 3734 3278 3735 rm -f conftest.$ac_ext 3279 3736 EXEEXT=$ac_cv_exeext ··· 3282 3739 /* end confdefs.h. */ 3283 3740 #include <stdio.h> 3284 3741 int 3285 3285 - main () 3742 3742 + main (void) 3286 3743 { 3287 3744 FILE *f = fopen ("conftest.out", "w"); 3288 3745 return ferror (f) || fclose (f) != 0; ··· 3294 3751 ac_clean_files="$ac_clean_files conftest.out" 3295 3752 # Check that the compiler produces executables we can run. If not, either 3296 3753 # the compiler is broken, or we cross compile. 3297 3297 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 3298 3298 - $as_echo_n "checking whether we are cross compiling... " >&6; } 3754 3754 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 3755 3755 + printf %s "checking whether we are cross compiling... " >&6; } 3299 3756 if test "$cross_compiling" != yes; then 3300 3757 { { ac_try="$ac_link" 3301 3758 case "(($ac_try" in ··· 3303 3760 *) ac_try_echo=$ac_try;; 3304 3761 esac 3305 3762 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 3306 3306 - $as_echo "$ac_try_echo"; } >&5 3763 3763 + printf "%s\n" "$ac_try_echo"; } >&5 3307 3764 (eval "$ac_link") 2>&5 3308 3765 ac_status=$? 3309 3309 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3766 3766 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3310 3767 test $ac_status = 0; } 3311 3768 if { ac_try='./conftest$ac_cv_exeext' 3312 3769 { { case "(($ac_try" in ··· 3314 3771 *) ac_try_echo=$ac_try;; 3315 3772 esac 3316 3773 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 3317 3317 - $as_echo "$ac_try_echo"; } >&5 3774 3774 + printf "%s\n" "$ac_try_echo"; } >&5 3318 3775 (eval "$ac_try") 2>&5 3319 3776 ac_status=$? 3320 3320 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3777 3777 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3321 3778 test $ac_status = 0; }; }; then 3322 3779 cross_compiling=no 3323 3780 else 3324 3781 if test "$cross_compiling" = maybe; then 3325 3782 cross_compiling=yes 3326 3783 else 3327 3327 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3328 3328 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 3329 3329 - as_fn_error $? "cannot run C compiled programs. 3784 3784 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3785 3785 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 3786 3786 + as_fn_error 77 "cannot run C compiled programs. 3330 3787 If you meant to cross compile, use \`--host'. 3331 3788 See \`config.log' for more details" "$LINENO" 5; } 3332 3789 fi 3333 3790 fi 3334 3791 fi 3335 3335 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 3336 3336 - $as_echo "$cross_compiling" >&6; } 3792 3792 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 3793 3793 + printf "%s\n" "$cross_compiling" >&6; } 3337 3794 3338 3795 rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out 3339 3796 ac_clean_files=$ac_clean_files_save 3340 3340 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 3341 3341 - $as_echo_n "checking for suffix of object files... " >&6; } 3342 3342 - if ${ac_cv_objext+:} false; then : 3343 3343 - $as_echo_n "(cached) " >&6 3344 3344 - else 3797 3797 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 3798 3798 + printf %s "checking for suffix of object files... " >&6; } 3799 3799 + if test ${ac_cv_objext+y} 3800 3800 + then : 3801 3801 + printf %s "(cached) " >&6 3802 3802 + else $as_nop 3345 3803 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3346 3804 /* end confdefs.h. */ 3347 3805 3348 3806 int 3349 3349 - main () 3807 3807 + main (void) 3350 3808 { 3351 3809 3352 3810 ; ··· 3360 3818 *) ac_try_echo=$ac_try;; 3361 3819 esac 3362 3820 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" 3363 3363 - $as_echo "$ac_try_echo"; } >&5 3821 3821 + printf "%s\n" "$ac_try_echo"; } >&5 3364 3822 (eval "$ac_compile") 2>&5 3365 3823 ac_status=$? 3366 3366 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3367 3367 - test $ac_status = 0; }; then : 3824 3824 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 3825 3825 + test $ac_status = 0; } 3826 3826 + then : 3368 3827 for ac_file in conftest.o conftest.obj conftest.*; do 3369 3828 test -f "$ac_file" || continue; 3370 3829 case $ac_file in ··· 3373 3832 break;; 3374 3833 esac 3375 3834 done 3376 3376 - else 3377 3377 - $as_echo "$as_me: failed program was:" >&5 3835 3835 + else $as_nop 3836 3836 + printf "%s\n" "$as_me: failed program was:" >&5 3378 3837 sed 's/^/| /' conftest.$ac_ext >&5 3379 3838 3380 3380 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3381 3381 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 3839 3839 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 3840 3840 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 3382 3841 as_fn_error $? "cannot compute suffix of object files: cannot compile 3383 3842 See \`config.log' for more details" "$LINENO" 5; } 3384 3843 fi 3385 3844 rm -f conftest.$ac_cv_objext conftest.$ac_ext 3386 3845 fi 3387 3387 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 3388 3388 - $as_echo "$ac_cv_objext" >&6; } 3846 3846 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 3847 3847 + printf "%s\n" "$ac_cv_objext" >&6; } 3389 3848 OBJEXT=$ac_cv_objext 3390 3849 ac_objext=$OBJEXT 3391 3391 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 3392 3392 - $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } 3393 3393 - if ${ac_cv_c_compiler_gnu+:} false; then : 3394 3394 - $as_echo_n "(cached) " >&6 3395 3395 - else 3850 3850 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 3851 3851 + printf %s "checking whether the compiler supports GNU C... " >&6; } 3852 3852 + if test ${ac_cv_c_compiler_gnu+y} 3853 3853 + then : 3854 3854 + printf %s "(cached) " >&6 3855 3855 + else $as_nop 3396 3856 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3397 3857 /* end confdefs.h. */ 3398 3858 3399 3859 int 3400 3400 - main () 3860 3860 + main (void) 3401 3861 { 3402 3862 #ifndef __GNUC__ 3403 3863 choke me ··· 3407 3867 return 0; 3408 3868 } 3409 3869 _ACEOF 3410 3410 - if ac_fn_c_try_compile "$LINENO"; then : 3870 3870 + if ac_fn_c_try_compile "$LINENO" 3871 3871 + then : 3411 3872 ac_compiler_gnu=yes 3412 3412 - else 3873 3873 + else $as_nop 3413 3874 ac_compiler_gnu=no 3414 3875 fi 3415 3415 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3876 3876 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 3416 3877 ac_cv_c_compiler_gnu=$ac_compiler_gnu 3417 3878 3418 3879 fi 3419 3419 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 3420 3420 - $as_echo "$ac_cv_c_compiler_gnu" >&6; } 3880 3880 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 3881 3881 + printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } 3882 3882 + ac_compiler_gnu=$ac_cv_c_compiler_gnu 3883 3883 + 3421 3884 if test $ac_compiler_gnu = yes; then 3422 3885 GCC=yes 3423 3886 else 3424 3887 GCC= 3425 3888 fi 3426 3426 - ac_test_CFLAGS=${CFLAGS+set} 3889 3889 + ac_test_CFLAGS=${CFLAGS+y} 3427 3890 ac_save_CFLAGS=$CFLAGS 3428 3428 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 3429 3429 - $as_echo_n "checking whether $CC accepts -g... " >&6; } 3430 3430 - if ${ac_cv_prog_cc_g+:} false; then : 3431 3431 - $as_echo_n "(cached) " >&6 3432 3432 - else 3891 3891 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 3892 3892 + printf %s "checking whether $CC accepts -g... " >&6; } 3893 3893 + if test ${ac_cv_prog_cc_g+y} 3894 3894 + then : 3895 3895 + printf %s "(cached) " >&6 3896 3896 + else $as_nop 3433 3897 ac_save_c_werror_flag=$ac_c_werror_flag 3434 3898 ac_c_werror_flag=yes 3435 3899 ac_cv_prog_cc_g=no ··· 3438 3902 /* end confdefs.h. */ 3439 3903 3440 3904 int 3441 3441 - main () 3905 3905 + main (void) 3442 3906 { 3443 3907 3444 3908 ; 3445 3909 return 0; 3446 3910 } 3447 3911 _ACEOF 3448 3448 - if ac_fn_c_try_compile "$LINENO"; then : 3912 3912 + if ac_fn_c_try_compile "$LINENO" 3913 3913 + then : 3449 3914 ac_cv_prog_cc_g=yes 3450 3450 - else 3915 3915 + else $as_nop 3451 3916 CFLAGS="" 3452 3917 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3453 3918 /* end confdefs.h. */ 3454 3919 3455 3920 int 3456 3456 - main () 3921 3921 + main (void) 3457 3922 { 3458 3923 3459 3924 ; 3460 3925 return 0; 3461 3926 } 3462 3927 _ACEOF 3463 3463 - if ac_fn_c_try_compile "$LINENO"; then : 3928 3928 + if ac_fn_c_try_compile "$LINENO" 3929 3929 + then : 3464 3930 3465 3465 - else 3931 3931 + else $as_nop 3466 3932 ac_c_werror_flag=$ac_save_c_werror_flag 3467 3933 CFLAGS="-g" 3468 3934 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3469 3935 /* end confdefs.h. */ 3470 3936 3471 3937 int 3472 3472 - main () 3938 3938 + main (void) 3473 3939 { 3474 3940 3475 3941 ; 3476 3942 return 0; 3477 3943 } 3478 3944 _ACEOF 3479 3479 - if ac_fn_c_try_compile "$LINENO"; then : 3945 3945 + if ac_fn_c_try_compile "$LINENO" 3946 3946 + then : 3480 3947 ac_cv_prog_cc_g=yes 3481 3948 fi 3482 3482 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3949 3949 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 3483 3950 fi 3484 3484 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3951 3951 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 3485 3952 fi 3486 3486 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3953 3953 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 3487 3954 ac_c_werror_flag=$ac_save_c_werror_flag 3488 3955 fi 3489 3489 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 3490 3490 - $as_echo "$ac_cv_prog_cc_g" >&6; } 3491 3491 - if test "$ac_test_CFLAGS" = set; then 3956 3956 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 3957 3957 + printf "%s\n" "$ac_cv_prog_cc_g" >&6; } 3958 3958 + if test $ac_test_CFLAGS; then 3492 3959 CFLAGS=$ac_save_CFLAGS 3493 3960 elif test $ac_cv_prog_cc_g = yes; then 3494 3961 if test "$GCC" = yes; then ··· 3503 3970 CFLAGS= 3504 3971 fi 3505 3972 fi 3506 3506 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 3507 3507 - $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } 3508 3508 - if ${ac_cv_prog_cc_c89+:} false; then : 3509 3509 - $as_echo_n "(cached) " >&6 3510 3510 - else 3511 3511 - ac_cv_prog_cc_c89=no 3973 3973 + ac_prog_cc_stdc=no 3974 3974 + if test x$ac_prog_cc_stdc = xno 3975 3975 + then : 3976 3976 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 3977 3977 + printf %s "checking for $CC option to enable C11 features... " >&6; } 3978 3978 + if test ${ac_cv_prog_cc_c11+y} 3979 3979 + then : 3980 3980 + printf %s "(cached) " >&6 3981 3981 + else $as_nop 3982 3982 + ac_cv_prog_cc_c11=no 3512 3983 ac_save_CC=$CC 3513 3984 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3514 3985 /* end confdefs.h. */ 3515 3515 - #include <stdarg.h> 3516 3516 - #include <stdio.h> 3517 3517 - struct stat; 3518 3518 - /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ 3519 3519 - struct buf { int x; }; 3520 3520 - FILE * (*rcsopen) (struct buf *, struct stat *, int); 3521 3521 - static char *e (p, i) 3522 3522 - char **p; 3523 3523 - int i; 3524 3524 - { 3525 3525 - return p[i]; 3526 3526 - } 3527 3527 - static char *f (char * (*g) (char **, int), char **p, ...) 3528 3528 - { 3529 3529 - char *s; 3530 3530 - va_list v; 3531 3531 - va_start (v,p); 3532 3532 - s = g (p, va_arg (v,int)); 3533 3533 - va_end (v); 3534 3534 - return s; 3535 3535 - } 3986 3986 + $ac_c_conftest_c11_program 3987 3987 + _ACEOF 3988 3988 + for ac_arg in '' -std=gnu11 3989 3989 + do 3990 3990 + CC="$ac_save_CC $ac_arg" 3991 3991 + if ac_fn_c_try_compile "$LINENO" 3992 3992 + then : 3993 3993 + ac_cv_prog_cc_c11=$ac_arg 3994 3994 + fi 3995 3995 + rm -f core conftest.err conftest.$ac_objext conftest.beam 3996 3996 + test "x$ac_cv_prog_cc_c11" != "xno" && break 3997 3997 + done 3998 3998 + rm -f conftest.$ac_ext 3999 3999 + CC=$ac_save_CC 4000 4000 + fi 3536 4001 3537 3537 - /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has 3538 3538 - function prototypes and stuff, but not '\xHH' hex character constants. 3539 3539 - These don't provoke an error unfortunately, instead are silently treated 3540 3540 - as 'x'. The following induces an error, until -std is added to get 3541 3541 - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an 3542 3542 - array size at least. It's necessary to write '\x00'==0 to get something 3543 3543 - that's true only with -std. */ 3544 3544 - int osf4_cc_array ['\x00' == 0 ? 1 : -1]; 4002 4002 + if test "x$ac_cv_prog_cc_c11" = xno 4003 4003 + then : 4004 4004 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 4005 4005 + printf "%s\n" "unsupported" >&6; } 4006 4006 + else $as_nop 4007 4007 + if test "x$ac_cv_prog_cc_c11" = x 4008 4008 + then : 4009 4009 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 4010 4010 + printf "%s\n" "none needed" >&6; } 4011 4011 + else $as_nop 4012 4012 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 4013 4013 + printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } 4014 4014 + CC="$CC $ac_cv_prog_cc_c11" 4015 4015 + fi 4016 4016 + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 4017 4017 + ac_prog_cc_stdc=c11 4018 4018 + fi 4019 4019 + fi 4020 4020 + if test x$ac_prog_cc_stdc = xno 4021 4021 + then : 4022 4022 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 4023 4023 + printf %s "checking for $CC option to enable C99 features... " >&6; } 4024 4024 + if test ${ac_cv_prog_cc_c99+y} 4025 4025 + then : 4026 4026 + printf %s "(cached) " >&6 4027 4027 + else $as_nop 4028 4028 + ac_cv_prog_cc_c99=no 4029 4029 + ac_save_CC=$CC 4030 4030 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4031 4031 + /* end confdefs.h. */ 4032 4032 + $ac_c_conftest_c99_program 4033 4033 + _ACEOF 4034 4034 + for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99= 4035 4035 + do 4036 4036 + CC="$ac_save_CC $ac_arg" 4037 4037 + if ac_fn_c_try_compile "$LINENO" 4038 4038 + then : 4039 4039 + ac_cv_prog_cc_c99=$ac_arg 4040 4040 + fi 4041 4041 + rm -f core conftest.err conftest.$ac_objext conftest.beam 4042 4042 + test "x$ac_cv_prog_cc_c99" != "xno" && break 4043 4043 + done 4044 4044 + rm -f conftest.$ac_ext 4045 4045 + CC=$ac_save_CC 4046 4046 + fi 3545 4047 3546 3546 - /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters 3547 3547 - inside strings and character constants. */ 3548 3548 - #define FOO(x) 'x' 3549 3549 - int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; 3550 3550 - 3551 3551 - int test (int i, double x); 3552 3552 - struct s1 {int (*f) (int a);}; 3553 3553 - struct s2 {int (*f) (double a);}; 3554 3554 - int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); 3555 3555 - int argc; 3556 3556 - char **argv; 3557 3557 - int 3558 3558 - main () 3559 3559 - { 3560 3560 - return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; 3561 3561 - ; 3562 3562 - return 0; 3563 3563 - } 4048 4048 + if test "x$ac_cv_prog_cc_c99" = xno 4049 4049 + then : 4050 4050 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 4051 4051 + printf "%s\n" "unsupported" >&6; } 4052 4052 + else $as_nop 4053 4053 + if test "x$ac_cv_prog_cc_c99" = x 4054 4054 + then : 4055 4055 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 4056 4056 + printf "%s\n" "none needed" >&6; } 4057 4057 + else $as_nop 4058 4058 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 4059 4059 + printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } 4060 4060 + CC="$CC $ac_cv_prog_cc_c99" 4061 4061 + fi 4062 4062 + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 4063 4063 + ac_prog_cc_stdc=c99 4064 4064 + fi 4065 4065 + fi 4066 4066 + if test x$ac_prog_cc_stdc = xno 4067 4067 + then : 4068 4068 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 4069 4069 + printf %s "checking for $CC option to enable C89 features... " >&6; } 4070 4070 + if test ${ac_cv_prog_cc_c89+y} 4071 4071 + then : 4072 4072 + printf %s "(cached) " >&6 4073 4073 + else $as_nop 4074 4074 + ac_cv_prog_cc_c89=no 4075 4075 + ac_save_CC=$CC 4076 4076 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4077 4077 + /* end confdefs.h. */ 4078 4078 + $ac_c_conftest_c89_program 3564 4079 _ACEOF 3565 3565 - for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ 3566 3566 - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" 4080 4080 + for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" 3567 4081 do 3568 4082 CC="$ac_save_CC $ac_arg" 3569 3569 - if ac_fn_c_try_compile "$LINENO"; then : 4083 4083 + if ac_fn_c_try_compile "$LINENO" 4084 4084 + then : 3570 4085 ac_cv_prog_cc_c89=$ac_arg 3571 4086 fi 3572 3572 - rm -f core conftest.err conftest.$ac_objext 4087 4087 + rm -f core conftest.err conftest.$ac_objext conftest.beam 3573 4088 test "x$ac_cv_prog_cc_c89" != "xno" && break 3574 4089 done 3575 4090 rm -f conftest.$ac_ext 3576 4091 CC=$ac_save_CC 3577 3577 - 3578 4092 fi 3579 3579 - # AC_CACHE_VAL 3580 3580 - case "x$ac_cv_prog_cc_c89" in 3581 3581 - x) 3582 3582 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 3583 3583 - $as_echo "none needed" >&6; } ;; 3584 3584 - xno) 3585 3585 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 3586 3586 - $as_echo "unsupported" >&6; } ;; 3587 3587 - *) 3588 3588 - CC="$CC $ac_cv_prog_cc_c89" 3589 3589 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 3590 3590 - $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; 3591 3591 - esac 3592 3592 - if test "x$ac_cv_prog_cc_c89" != xno; then : 3593 4093 4094 4094 + if test "x$ac_cv_prog_cc_c89" = xno 4095 4095 + then : 4096 4096 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 4097 4097 + printf "%s\n" "unsupported" >&6; } 4098 4098 + else $as_nop 4099 4099 + if test "x$ac_cv_prog_cc_c89" = x 4100 4100 + then : 4101 4101 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 4102 4102 + printf "%s\n" "none needed" >&6; } 4103 4103 + else $as_nop 4104 4104 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 4105 4105 + printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } 4106 4106 + CC="$CC $ac_cv_prog_cc_c89" 4107 4107 + fi 4108 4108 + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 4109 4109 + ac_prog_cc_stdc=c89 4110 4110 + fi 3594 4111 fi 3595 4112 3596 4113 ac_ext=c ··· 3601 4118 3602 4119 depcc="$CC" am_compiler_list= 3603 4120 3604 3604 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 3605 3605 - $as_echo_n "checking dependency style of $depcc... " >&6; } 3606 3606 - if ${am_cv_CC_dependencies_compiler_type+:} false; then : 3607 3607 - $as_echo_n "(cached) " >&6 3608 3608 - else 4121 4121 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 4122 4122 + printf %s "checking dependency style of $depcc... " >&6; } 4123 4123 + if test ${am_cv_CC_dependencies_compiler_type+y} 4124 4124 + then : 4125 4125 + printf %s "(cached) " >&6 4126 4126 + else $as_nop 3609 4127 if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then 3610 4128 # We make a subdir and do the tests there. Otherwise we can end up 3611 4129 # making bogus files that we don't know about and never remove. For ··· 3712 4230 fi 3713 4231 3714 4232 fi 3715 3715 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 3716 3716 - $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } 4233 4233 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 4234 4234 + printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; } 3717 4235 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type 3718 4236 3719 4237 if ··· 3727 4245 fi 3728 4246 3729 4247 3730 3730 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5 3731 3731 - $as_echo_n "checking for $CC option to accept ISO C99... " >&6; } 3732 3732 - if ${ac_cv_prog_cc_c99+:} false; then : 3733 3733 - $as_echo_n "(cached) " >&6 3734 3734 - else 3735 3735 - ac_cv_prog_cc_c99=no 3736 3736 - ac_save_CC=$CC 3737 3737 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4248 4248 + 4249 4249 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5 4250 4250 + printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; } 4251 4251 + if test ${ac_cv_c_undeclared_builtin_options+y} 4252 4252 + then : 4253 4253 + printf %s "(cached) " >&6 4254 4254 + else $as_nop 4255 4255 + ac_save_CFLAGS=$CFLAGS 4256 4256 + ac_cv_c_undeclared_builtin_options='cannot detect' 4257 4257 + for ac_arg in '' -fno-builtin; do 4258 4258 + CFLAGS="$ac_save_CFLAGS $ac_arg" 4259 4259 + # This test program should *not* compile successfully. 4260 4260 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3738 4261 /* end confdefs.h. */ 3739 3739 - #include <stdarg.h> 3740 3740 - #include <stdbool.h> 3741 3741 - #include <stdlib.h> 3742 3742 - #include <wchar.h> 3743 3743 - #include <stdio.h> 3744 4262 3745 3745 - // Check varargs macros. These examples are taken from C99 6.10.3.5. 3746 3746 - #define debug(...) fprintf (stderr, __VA_ARGS__) 3747 3747 - #define showlist(...) puts (#__VA_ARGS__) 3748 3748 - #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) 3749 3749 - static void 3750 3750 - test_varargs_macros (void) 4263 4263 + int 4264 4264 + main (void) 3751 4265 { 3752 3752 - int x = 1234; 3753 3753 - int y = 5678; 3754 3754 - debug ("Flag"); 3755 3755 - debug ("X = %d\n", x); 3756 3756 - showlist (The first, second, and third items.); 3757 3757 - report (x>y, "x is %d but y is %d", x, y); 3758 3758 - } 3759 3759 - 3760 3760 - // Check long long types. 3761 3761 - #define BIG64 18446744073709551615ull 3762 3762 - #define BIG32 4294967295ul 3763 3763 - #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) 3764 3764 - #if !BIG_OK 3765 3765 - your preprocessor is broken; 3766 3766 - #endif 3767 3767 - #if BIG_OK 3768 3768 - #else 3769 3769 - your preprocessor is broken; 3770 3770 - #endif 3771 3771 - static long long int bignum = -9223372036854775807LL; 3772 3772 - static unsigned long long int ubignum = BIG64; 3773 3773 - 3774 3774 - struct incomplete_array 3775 3775 - { 3776 3776 - int datasize; 3777 3777 - double data[]; 3778 3778 - }; 3779 3779 - 3780 3780 - struct named_init { 3781 3781 - int number; 3782 3782 - const wchar_t *name; 3783 3783 - double average; 3784 3784 - }; 3785 3785 - 3786 3786 - typedef const char *ccp; 3787 3787 - 3788 3788 - static inline int 3789 3789 - test_restrict (ccp restrict text) 3790 3790 - { 3791 3791 - // See if C++-style comments work. 3792 3792 - // Iterate through items via the restricted pointer. 3793 3793 - // Also check for declarations in for loops. 3794 3794 - for (unsigned int i = 0; *(text+i) != '\0'; ++i) 3795 3795 - continue; 4266 4266 + (void) strchr; 4267 4267 + ; 3796 4268 return 0; 3797 4269 } 3798 3798 - 3799 3799 - // Check varargs and va_copy. 3800 3800 - static void 3801 3801 - test_varargs (const char *format, ...) 3802 3802 - { 3803 3803 - va_list args; 3804 3804 - va_start (args, format); 3805 3805 - va_list args_copy; 3806 3806 - va_copy (args_copy, args); 4270 4270 + _ACEOF 4271 4271 + if ac_fn_c_try_compile "$LINENO" 4272 4272 + then : 3807 4273 3808 3808 - const char *str; 3809 3809 - int number; 3810 3810 - float fnumber; 3811 3811 - 3812 3812 - while (*format) 3813 3813 - { 3814 3814 - switch (*format++) 3815 3815 - { 3816 3816 - case 's': // string 3817 3817 - str = va_arg (args_copy, const char *); 3818 3818 - break; 3819 3819 - case 'd': // int 3820 3820 - number = va_arg (args_copy, int); 3821 3821 - break; 3822 3822 - case 'f': // float 3823 3823 - fnumber = va_arg (args_copy, double); 3824 3824 - break; 3825 3825 - default: 3826 3826 - break; 3827 3827 - } 3828 3828 - } 3829 3829 - va_end (args_copy); 3830 3830 - va_end (args); 3831 3831 - } 4274 4274 + else $as_nop 4275 4275 + # This test program should compile successfully. 4276 4276 + # No library function is consistently available on 4277 4277 + # freestanding implementations, so test against a dummy 4278 4278 + # declaration. Include always-available headers on the 4279 4279 + # off chance that they somehow elicit warnings. 4280 4280 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4281 4281 + /* end confdefs.h. */ 4282 4282 + #include <float.h> 4283 4283 + #include <limits.h> 4284 4284 + #include <stdarg.h> 4285 4285 + #include <stddef.h> 4286 4286 + extern void ac_decl (int, char *); 3832 4287 3833 4288 int 3834 3834 - main () 4289 4289 + main (void) 3835 4290 { 3836 3836 - 3837 3837 - // Check bool. 3838 3838 - _Bool success = false; 3839 3839 - 3840 3840 - // Check restrict. 3841 3841 - if (test_restrict ("String literal") == 0) 3842 3842 - success = true; 3843 3843 - char *restrict newvar = "Another string"; 3844 3844 - 3845 3845 - // Check varargs. 3846 3846 - test_varargs ("s, d' f .", "string", 65, 34.234); 3847 3847 - test_varargs_macros (); 3848 3848 - 3849 3849 - // Check flexible array members. 3850 3850 - struct incomplete_array *ia = 3851 3851 - malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); 3852 3852 - ia->datasize = 10; 3853 3853 - for (int i = 0; i < ia->datasize; ++i) 3854 3854 - ia->data[i] = i * 1.234; 3855 3855 - 3856 3856 - // Check named initializers. 3857 3857 - struct named_init ni = { 3858 3858 - .number = 34, 3859 3859 - .name = L"Test wide string", 3860 3860 - .average = 543.34343, 3861 3861 - }; 3862 3862 - 3863 3863 - ni.number = 58; 3864 3864 - 3865 3865 - int dynamic_array[ni.number]; 3866 3866 - dynamic_array[ni.number - 1] = 543; 3867 3867 - 3868 3868 - // work around unused variable warnings 3869 3869 - return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' 3870 3870 - || dynamic_array[ni.number - 1] != 543); 4291 4291 + (void) ac_decl (0, (char *) 0); 4292 4292 + (void) ac_decl; 3871 4293 3872 4294 ; 3873 4295 return 0; 3874 4296 } 3875 4297 _ACEOF 3876 3876 - for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99 3877 3877 - do 3878 3878 - CC="$ac_save_CC $ac_arg" 3879 3879 - if ac_fn_c_try_compile "$LINENO"; then : 3880 3880 - ac_cv_prog_cc_c99=$ac_arg 3881 3881 - fi 3882 3882 - rm -f core conftest.err conftest.$ac_objext 3883 3883 - test "x$ac_cv_prog_cc_c99" != "xno" && break 3884 3884 - done 3885 3885 - rm -f conftest.$ac_ext 3886 3886 - CC=$ac_save_CC 3887 3887 - 3888 3888 - fi 3889 3889 - # AC_CACHE_VAL 3890 3890 - case "x$ac_cv_prog_cc_c99" in 3891 3891 - x) 3892 3892 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 3893 3893 - $as_echo "none needed" >&6; } ;; 3894 3894 - xno) 3895 3895 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 3896 3896 - $as_echo "unsupported" >&6; } ;; 3897 3897 - *) 3898 3898 - CC="$CC $ac_cv_prog_cc_c99" 3899 3899 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 3900 3900 - $as_echo "$ac_cv_prog_cc_c99" >&6; } ;; 3901 3901 - esac 3902 3902 - if test "x$ac_cv_prog_cc_c99" != xno; then : 3903 3903 - 3904 3904 - fi 3905 3905 - 3906 3906 - 3907 3907 - 3908 3908 - ac_ext=c 3909 3909 - ac_cpp='$CPP $CPPFLAGS' 3910 3910 - ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3911 3911 - ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3912 3912 - ac_compiler_gnu=$ac_cv_c_compiler_gnu 3913 3913 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 3914 3914 - $as_echo_n "checking how to run the C preprocessor... " >&6; } 3915 3915 - # On Suns, sometimes $CPP names a directory. 3916 3916 - if test -n "$CPP" && test -d "$CPP"; then 3917 3917 - CPP= 3918 3918 - fi 3919 3919 - if test -z "$CPP"; then 3920 3920 - if ${ac_cv_prog_CPP+:} false; then : 3921 3921 - $as_echo_n "(cached) " >&6 3922 3922 - else 3923 3923 - # Double quotes because CPP needs to be expanded 3924 3924 - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" 3925 3925 - do 3926 3926 - ac_preproc_ok=false 3927 3927 - for ac_c_preproc_warn_flag in '' yes 3928 3928 - do 3929 3929 - # Use a header file that comes with gcc, so configuring glibc 3930 3930 - # with a fresh cross-compiler works. 3931 3931 - # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since 3932 3932 - # <limits.h> exists even on freestanding compilers. 3933 3933 - # On the NeXT, cc -E runs the code through the compiler's parser, 3934 3934 - # not just through cpp. "Syntax error" is here to catch this case. 3935 3935 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3936 3936 - /* end confdefs.h. */ 3937 3937 - #ifdef __STDC__ 3938 3938 - # include <limits.h> 3939 3939 - #else 3940 3940 - # include <assert.h> 3941 3941 - #endif 3942 3942 - Syntax error 3943 3943 - _ACEOF 3944 3944 - if ac_fn_c_try_cpp "$LINENO"; then : 3945 3945 - 3946 3946 - else 3947 3947 - # Broken: fails on valid input. 3948 3948 - continue 4298 4298 + if ac_fn_c_try_compile "$LINENO" 4299 4299 + then : 4300 4300 + if test x"$ac_arg" = x 4301 4301 + then : 4302 4302 + ac_cv_c_undeclared_builtin_options='none needed' 4303 4303 + else $as_nop 4304 4304 + ac_cv_c_undeclared_builtin_options=$ac_arg 3949 4305 fi 3950 3950 - rm -f conftest.err conftest.i conftest.$ac_ext 3951 3951 - 3952 3952 - # OK, works on sane cases. Now check whether nonexistent headers 3953 3953 - # can be detected and how. 3954 3954 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3955 3955 - /* end confdefs.h. */ 3956 3956 - #include <ac_nonexistent.h> 3957 3957 - _ACEOF 3958 3958 - if ac_fn_c_try_cpp "$LINENO"; then : 3959 3959 - # Broken: success on invalid input. 3960 3960 - continue 3961 3961 - else 3962 3962 - # Passes both tests. 3963 3963 - ac_preproc_ok=: 3964 3964 - break 4306 4306 + break 3965 4307 fi 3966 3966 - rm -f conftest.err conftest.i conftest.$ac_ext 3967 3967 - 3968 3968 - done 3969 3969 - # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. 3970 3970 - rm -f conftest.i conftest.err conftest.$ac_ext 3971 3971 - if $ac_preproc_ok; then : 3972 3972 - break 4308 4308 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 3973 4309 fi 3974 3974 - 4310 4310 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 3975 4311 done 3976 3976 - ac_cv_prog_CPP=$CPP 3977 3977 - 3978 3978 - fi 3979 3979 - CPP=$ac_cv_prog_CPP 3980 3980 - else 3981 3981 - ac_cv_prog_CPP=$CPP 3982 3982 - fi 3983 3983 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 3984 3984 - $as_echo "$CPP" >&6; } 3985 3985 - ac_preproc_ok=false 3986 3986 - for ac_c_preproc_warn_flag in '' yes 3987 3987 - do 3988 3988 - # Use a header file that comes with gcc, so configuring glibc 3989 3989 - # with a fresh cross-compiler works. 3990 3990 - # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since 3991 3991 - # <limits.h> exists even on freestanding compilers. 3992 3992 - # On the NeXT, cc -E runs the code through the compiler's parser, 3993 3993 - # not just through cpp. "Syntax error" is here to catch this case. 3994 3994 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3995 3995 - /* end confdefs.h. */ 3996 3996 - #ifdef __STDC__ 3997 3997 - # include <limits.h> 3998 3998 - #else 3999 3999 - # include <assert.h> 4000 4000 - #endif 4001 4001 - Syntax error 4002 4002 - _ACEOF 4003 4003 - if ac_fn_c_try_cpp "$LINENO"; then : 4312 4312 + CFLAGS=$ac_save_CFLAGS 4004 4313 4005 4005 - else 4006 4006 - # Broken: fails on valid input. 4007 4007 - continue 4008 4314 fi 4009 4009 - rm -f conftest.err conftest.i conftest.$ac_ext 4010 4010 - 4011 4011 - # OK, works on sane cases. Now check whether nonexistent headers 4012 4012 - # can be detected and how. 4013 4013 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4014 4014 - /* end confdefs.h. */ 4015 4015 - #include <ac_nonexistent.h> 4016 4016 - _ACEOF 4017 4017 - if ac_fn_c_try_cpp "$LINENO"; then : 4018 4018 - # Broken: success on invalid input. 4019 4019 - continue 4020 4020 - else 4021 4021 - # Passes both tests. 4022 4022 - ac_preproc_ok=: 4023 4023 - break 4024 4024 - fi 4025 4025 - rm -f conftest.err conftest.i conftest.$ac_ext 4026 4026 - 4027 4027 - done 4028 4028 - # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. 4029 4029 - rm -f conftest.i conftest.err conftest.$ac_ext 4030 4030 - if $ac_preproc_ok; then : 4031 4031 - 4032 4032 - else 4033 4033 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 4034 4034 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 4035 4035 - as_fn_error $? "C preprocessor \"$CPP\" fails sanity check 4036 4036 - See \`config.log' for more details" "$LINENO" 5; } 4037 4037 - fi 4038 4038 - 4039 4039 - ac_ext=c 4040 4040 - ac_cpp='$CPP $CPPFLAGS' 4041 4041 - ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4042 4042 - ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4043 4043 - ac_compiler_gnu=$ac_cv_c_compiler_gnu 4044 4044 - 4045 4045 - 4046 4046 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 4047 4047 - $as_echo_n "checking for grep that handles long lines and -e... " >&6; } 4048 4048 - if ${ac_cv_path_GREP+:} false; then : 4049 4049 - $as_echo_n "(cached) " >&6 4050 4050 - else 4051 4051 - if test -z "$GREP"; then 4052 4052 - ac_path_GREP_found=false 4053 4053 - # Loop through the user's path and test for each of PROGNAME-LIST 4054 4054 - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 4055 4055 - for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin 4056 4056 - do 4057 4057 - IFS=$as_save_IFS 4058 4058 - test -z "$as_dir" && as_dir=. 4059 4059 - for ac_prog in grep ggrep; do 4060 4060 - for ac_exec_ext in '' $ac_executable_extensions; do 4061 4061 - ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" 4062 4062 - as_fn_executable_p "$ac_path_GREP" || continue 4063 4063 - # Check for GNU ac_path_GREP and select it if it is found. 4064 4064 - # Check for GNU $ac_path_GREP 4065 4065 - case `"$ac_path_GREP" --version 2>&1` in 4066 4066 - *GNU*) 4067 4067 - ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; 4068 4068 - *) 4069 4069 - ac_count=0 4070 4070 - $as_echo_n 0123456789 >"conftest.in" 4071 4071 - while : 4072 4072 - do 4073 4073 - cat "conftest.in" "conftest.in" >"conftest.tmp" 4074 4074 - mv "conftest.tmp" "conftest.in" 4075 4075 - cp "conftest.in" "conftest.nl" 4076 4076 - $as_echo 'GREP' >> "conftest.nl" 4077 4077 - "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break 4078 4078 - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break 4079 4079 - as_fn_arith $ac_count + 1 && ac_count=$as_val 4080 4080 - if test $ac_count -gt ${ac_path_GREP_max-0}; then 4081 4081 - # Best one so far, save it but keep looking for a better one 4082 4082 - ac_cv_path_GREP="$ac_path_GREP" 4083 4083 - ac_path_GREP_max=$ac_count 4084 4084 - fi 4085 4085 - # 10*(2^10) chars as input seems more than enough 4086 4086 - test $ac_count -gt 10 && break 4087 4087 - done 4088 4088 - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; 4315 4315 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5 4316 4316 + printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; } 4317 4317 + case $ac_cv_c_undeclared_builtin_options in #( 4318 4318 + 'cannot detect') : 4319 4319 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 4320 4320 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 4321 4321 + as_fn_error $? "cannot make $CC report undeclared builtins 4322 4322 + See \`config.log' for more details" "$LINENO" 5; } ;; #( 4323 4323 + 'none needed') : 4324 4324 + ac_c_undeclared_builtin_options='' ;; #( 4325 4325 + *) : 4326 4326 + ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;; 4089 4327 esac 4090 4328 4091 4091 - $ac_path_GREP_found && break 3 4092 4092 - done 4093 4093 - done 4094 4094 - done 4095 4095 - IFS=$as_save_IFS 4096 4096 - if test -z "$ac_cv_path_GREP"; then 4097 4097 - as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 4098 4098 - fi 4099 4099 - else 4100 4100 - ac_cv_path_GREP=$GREP 4101 4101 - fi 4102 4102 - 4103 4103 - fi 4104 4104 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 4105 4105 - $as_echo "$ac_cv_path_GREP" >&6; } 4106 4106 - GREP="$ac_cv_path_GREP" 4107 4107 - 4108 4108 - 4109 4109 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 4110 4110 - $as_echo_n "checking for egrep... " >&6; } 4111 4111 - if ${ac_cv_path_EGREP+:} false; then : 4112 4112 - $as_echo_n "(cached) " >&6 4113 4113 - else 4114 4114 - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 4115 4115 - then ac_cv_path_EGREP="$GREP -E" 4116 4116 - else 4117 4117 - if test -z "$EGREP"; then 4118 4118 - ac_path_EGREP_found=false 4119 4119 - # Loop through the user's path and test for each of PROGNAME-LIST 4120 4120 - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 4121 4121 - for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin 4329 4329 + ac_header= ac_cache= 4330 4330 + for ac_item in $ac_header_c_list 4122 4331 do 4123 4123 - IFS=$as_save_IFS 4124 4124 - test -z "$as_dir" && as_dir=. 4125 4125 - for ac_prog in egrep; do 4126 4126 - for ac_exec_ext in '' $ac_executable_extensions; do 4127 4127 - ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" 4128 4128 - as_fn_executable_p "$ac_path_EGREP" || continue 4129 4129 - # Check for GNU ac_path_EGREP and select it if it is found. 4130 4130 - # Check for GNU $ac_path_EGREP 4131 4131 - case `"$ac_path_EGREP" --version 2>&1` in 4132 4132 - *GNU*) 4133 4133 - ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; 4134 4134 - *) 4135 4135 - ac_count=0 4136 4136 - $as_echo_n 0123456789 >"conftest.in" 4137 4137 - while : 4138 4138 - do 4139 4139 - cat "conftest.in" "conftest.in" >"conftest.tmp" 4140 4140 - mv "conftest.tmp" "conftest.in" 4141 4141 - cp "conftest.in" "conftest.nl" 4142 4142 - $as_echo 'EGREP' >> "conftest.nl" 4143 4143 - "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break 4144 4144 - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break 4145 4145 - as_fn_arith $ac_count + 1 && ac_count=$as_val 4146 4146 - if test $ac_count -gt ${ac_path_EGREP_max-0}; then 4147 4147 - # Best one so far, save it but keep looking for a better one 4148 4148 - ac_cv_path_EGREP="$ac_path_EGREP" 4149 4149 - ac_path_EGREP_max=$ac_count 4332 4332 + if test $ac_cache; then 4333 4333 + ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default" 4334 4334 + if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then 4335 4335 + printf "%s\n" "#define $ac_item 1" >> confdefs.h 4150 4336 fi 4151 4151 - # 10*(2^10) chars as input seems more than enough 4152 4152 - test $ac_count -gt 10 && break 4153 4153 - done 4154 4154 - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; 4155 4155 - esac 4156 4156 - 4157 4157 - $ac_path_EGREP_found && break 3 4158 4158 - done 4159 4159 - done 4160 4160 - done 4161 4161 - IFS=$as_save_IFS 4162 4162 - if test -z "$ac_cv_path_EGREP"; then 4163 4163 - as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 4337 4337 + ac_header= ac_cache= 4338 4338 + elif test $ac_header; then 4339 4339 + ac_cache=$ac_item 4340 4340 + else 4341 4341 + ac_header=$ac_item 4164 4342 fi 4165 4165 - else 4166 4166 - ac_cv_path_EGREP=$EGREP 4167 4167 - fi 4343 4343 + done 4168 4344 4169 4169 - fi 4170 4170 - fi 4171 4171 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 4172 4172 - $as_echo "$ac_cv_path_EGREP" >&6; } 4173 4173 - EGREP="$ac_cv_path_EGREP" 4174 4345 4175 4346 4176 4176 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 4177 4177 - $as_echo_n "checking for ANSI C header files... " >&6; } 4178 4178 - if ${ac_cv_header_stdc+:} false; then : 4179 4179 - $as_echo_n "(cached) " >&6 4180 4180 - else 4181 4181 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4182 4182 - /* end confdefs.h. */ 4183 4183 - #include <stdlib.h> 4184 4184 - #include <stdarg.h> 4185 4185 - #include <string.h> 4186 4186 - #include <float.h> 4187 4347 4188 4188 - int 4189 4189 - main () 4190 4190 - { 4191 4348 4192 4192 - ; 4193 4193 - return 0; 4194 4194 - } 4195 4195 - _ACEOF 4196 4196 - if ac_fn_c_try_compile "$LINENO"; then : 4197 4197 - ac_cv_header_stdc=yes 4198 4198 - else 4199 4199 - ac_cv_header_stdc=no 4200 4200 - fi 4201 4201 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4202 4349 4203 4203 - if test $ac_cv_header_stdc = yes; then 4204 4204 - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. 4205 4205 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4206 4206 - /* end confdefs.h. */ 4207 4207 - #include <string.h> 4208 4350 4209 4209 - _ACEOF 4210 4210 - if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 4211 4211 - $EGREP "memchr" >/dev/null 2>&1; then : 4212 4351 4213 4213 - else 4214 4214 - ac_cv_header_stdc=no 4215 4215 - fi 4216 4216 - rm -f conftest* 4352 4352 + if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes 4353 4353 + then : 4217 4354 4218 4218 - fi 4355 4355 + printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h 4219 4356 4220 4220 - if test $ac_cv_header_stdc = yes; then 4221 4221 - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. 4222 4222 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4223 4223 - /* end confdefs.h. */ 4224 4224 - #include <stdlib.h> 4225 4225 - 4226 4226 - _ACEOF 4227 4227 - if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 4228 4228 - $EGREP "free" >/dev/null 2>&1; then : 4229 4229 - 4230 4230 - else 4231 4231 - ac_cv_header_stdc=no 4232 4357 fi 4233 4233 - rm -f conftest* 4234 4358 4235 4235 - fi 4236 4359 4237 4237 - if test $ac_cv_header_stdc = yes; then 4238 4238 - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. 4239 4239 - if test "$cross_compiling" = yes; then : 4240 4240 - : 4241 4241 - else 4242 4242 - cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4243 4243 - /* end confdefs.h. */ 4244 4244 - #include <ctype.h> 4245 4245 - #include <stdlib.h> 4246 4246 - #if ((' ' & 0x0FF) == 0x020) 4247 4247 - # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') 4248 4248 - # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) 4249 4249 - #else 4250 4250 - # define ISLOWER(c) \ 4251 4251 - (('a' <= (c) && (c) <= 'i') \ 4252 4252 - || ('j' <= (c) && (c) <= 'r') \ 4253 4253 - || ('s' <= (c) && (c) <= 'z')) 4254 4254 - # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) 4255 4255 - #endif 4256 4360 4257 4257 - #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) 4258 4258 - int 4259 4259 - main () 4260 4260 - { 4261 4261 - int i; 4262 4262 - for (i = 0; i < 256; i++) 4263 4263 - if (XOR (islower (i), ISLOWER (i)) 4264 4264 - || toupper (i) != TOUPPER (i)) 4265 4265 - return 2; 4266 4266 - return 0; 4267 4267 - } 4268 4268 - _ACEOF 4269 4269 - if ac_fn_c_try_run "$LINENO"; then : 4270 4361 4271 4271 - else 4272 4272 - ac_cv_header_stdc=no 4273 4273 - fi 4274 4274 - rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ 4275 4275 - conftest.$ac_objext conftest.beam conftest.$ac_ext 4276 4276 - fi 4277 4277 - 4278 4278 - fi 4279 4279 - fi 4280 4280 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 4281 4281 - $as_echo "$ac_cv_header_stdc" >&6; } 4282 4282 - if test $ac_cv_header_stdc = yes; then 4283 4283 - 4284 4284 - $as_echo "#define STDC_HEADERS 1" >>confdefs.h 4285 4285 - 4286 4286 - fi 4287 4287 - 4288 4288 - # On IRIX 5.3, sys/types and inttypes.h are conflicting. 4289 4289 - for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ 4290 4290 - inttypes.h stdint.h unistd.h 4291 4291 - do : 4292 4292 - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` 4293 4293 - ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default 4294 4294 - " 4295 4295 - if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : 4296 4296 - cat >>confdefs.h <<_ACEOF 4297 4297 - #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 4298 4298 - _ACEOF 4299 4299 - 4300 4300 - fi 4301 4301 - 4302 4302 - done 4303 4303 - 4304 4304 - 4305 4305 - 4306 4306 - 4307 4307 - 4308 4308 - 4309 4309 - ac_fn_c_check_decl "$LINENO" "__clang__" "ac_cv_have_decl___clang__" "$ac_includes_default" 4310 4310 - if test "x$ac_cv_have_decl___clang__" = xyes; then : 4362 4362 + ac_fn_check_decl "$LINENO" "__clang__" "ac_cv_have_decl___clang__" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" 4363 4363 + if test "x$ac_cv_have_decl___clang__" = xyes 4364 4364 + then : 4311 4365 CLANGCC="yes" 4312 4312 - else 4366 4366 + else $as_nop 4313 4367 CLANGCC="no" 4314 4368 fi 4315 4315 - 4316 4316 - ac_fn_c_check_decl "$LINENO" "__INTEL_COMPILER" "ac_cv_have_decl___INTEL_COMPILER" "$ac_includes_default" 4317 4317 - if test "x$ac_cv_have_decl___INTEL_COMPILER" = xyes; then : 4369 4369 + ac_fn_check_decl "$LINENO" "__INTEL_COMPILER" "ac_cv_have_decl___INTEL_COMPILER" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" 4370 4370 + if test "x$ac_cv_have_decl___INTEL_COMPILER" = xyes 4371 4371 + then : 4318 4372 INTELCC="yes" 4319 4319 - else 4373 4373 + else $as_nop 4320 4374 INTELCC="no" 4321 4375 fi 4322 4322 - 4323 4323 - ac_fn_c_check_decl "$LINENO" "__SUNPRO_C" "ac_cv_have_decl___SUNPRO_C" "$ac_includes_default" 4324 4324 - if test "x$ac_cv_have_decl___SUNPRO_C" = xyes; then : 4376 4376 + ac_fn_check_decl "$LINENO" "__SUNPRO_C" "ac_cv_have_decl___SUNPRO_C" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" 4377 4377 + if test "x$ac_cv_have_decl___SUNPRO_C" = xyes 4378 4378 + then : 4325 4379 SUNCC="yes" 4326 4326 - else 4380 4380 + else $as_nop 4327 4381 SUNCC="no" 4328 4382 fi 4329 4329 - 4330 4383 4331 4384 4332 4385 ··· 4339 4392 if test -n "$ac_tool_prefix"; then 4340 4393 # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. 4341 4394 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 4342 4342 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 4343 4343 - $as_echo_n "checking for $ac_word... " >&6; } 4344 4344 - if ${ac_cv_path_PKG_CONFIG+:} false; then : 4345 4345 - $as_echo_n "(cached) " >&6 4346 4346 - else 4395 4395 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 4396 4396 + printf %s "checking for $ac_word... " >&6; } 4397 4397 + if test ${ac_cv_path_PKG_CONFIG+y} 4398 4398 + then : 4399 4399 + printf %s "(cached) " >&6 4400 4400 + else $as_nop 4347 4401 case $PKG_CONFIG in 4348 4402 [\\/]* | ?:[\\/]*) 4349 4403 ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ··· 4353 4407 for as_dir in $PATH 4354 4408 do 4355 4409 IFS=$as_save_IFS 4356 4356 - test -z "$as_dir" && as_dir=. 4410 4410 + case $as_dir in #((( 4411 4411 + '') as_dir=./ ;; 4412 4412 + */) ;; 4413 4413 + *) as_dir=$as_dir/ ;; 4414 4414 + esac 4357 4415 for ac_exec_ext in '' $ac_executable_extensions; do 4358 4358 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 4359 4359 - ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" 4360 4360 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 4416 4416 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 4417 4417 + ac_cv_path_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext" 4418 4418 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 4361 4419 break 2 4362 4420 fi 4363 4421 done ··· 4369 4427 fi 4370 4428 PKG_CONFIG=$ac_cv_path_PKG_CONFIG 4371 4429 if test -n "$PKG_CONFIG"; then 4372 4372 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 4373 4373 - $as_echo "$PKG_CONFIG" >&6; } 4430 4430 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 4431 4431 + printf "%s\n" "$PKG_CONFIG" >&6; } 4374 4432 else 4375 4375 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 4376 4376 - $as_echo "no" >&6; } 4433 4433 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 4434 4434 + printf "%s\n" "no" >&6; } 4377 4435 fi 4378 4436 4379 4437 ··· 4382 4440 ac_pt_PKG_CONFIG=$PKG_CONFIG 4383 4441 # Extract the first word of "pkg-config", so it can be a program name with args. 4384 4442 set dummy pkg-config; ac_word=$2 4385 4385 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 4386 4386 - $as_echo_n "checking for $ac_word... " >&6; } 4387 4387 - if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then : 4388 4388 - $as_echo_n "(cached) " >&6 4389 4389 - else 4443 4443 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 4444 4444 + printf %s "checking for $ac_word... " >&6; } 4445 4445 + if test ${ac_cv_path_ac_pt_PKG_CONFIG+y} 4446 4446 + then : 4447 4447 + printf %s "(cached) " >&6 4448 4448 + else $as_nop 4390 4449 case $ac_pt_PKG_CONFIG in 4391 4450 [\\/]* | ?:[\\/]*) 4392 4451 ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. ··· 4396 4455 for as_dir in $PATH 4397 4456 do 4398 4457 IFS=$as_save_IFS 4399 4399 - test -z "$as_dir" && as_dir=. 4458 4458 + case $as_dir in #((( 4459 4459 + '') as_dir=./ ;; 4460 4460 + */) ;; 4461 4461 + *) as_dir=$as_dir/ ;; 4462 4462 + esac 4400 4463 for ac_exec_ext in '' $ac_executable_extensions; do 4401 4401 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 4402 4402 - ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" 4403 4403 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 4464 4464 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 4465 4465 + ac_cv_path_ac_pt_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext" 4466 4466 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 4404 4467 break 2 4405 4468 fi 4406 4469 done ··· 4412 4475 fi 4413 4476 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG 4414 4477 if test -n "$ac_pt_PKG_CONFIG"; then 4415 4415 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 4416 4416 - $as_echo "$ac_pt_PKG_CONFIG" >&6; } 4478 4478 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 4479 4479 + printf "%s\n" "$ac_pt_PKG_CONFIG" >&6; } 4417 4480 else 4418 4418 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 4419 4419 - $as_echo "no" >&6; } 4481 4481 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 4482 4482 + printf "%s\n" "no" >&6; } 4420 4483 fi 4421 4484 4422 4485 if test "x$ac_pt_PKG_CONFIG" = x; then ··· 4424 4487 else 4425 4488 case $cross_compiling:$ac_tool_warned in 4426 4489 yes:) 4427 4427 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 4428 4428 - $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 4490 4490 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 4491 4491 + printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} 4429 4492 ac_tool_warned=yes ;; 4430 4493 esac 4431 4494 PKG_CONFIG=$ac_pt_PKG_CONFIG ··· 4437 4500 fi 4438 4501 if test -n "$PKG_CONFIG"; then 4439 4502 _pkg_min_version=0.9.0 4440 4440 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 4441 4441 - $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } 4503 4503 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 4504 4504 + printf %s "checking pkg-config is at least version $_pkg_min_version... " >&6; } 4442 4505 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then 4443 4443 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 4444 4444 - $as_echo "yes" >&6; } 4506 4506 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 4507 4507 + printf "%s\n" "yes" >&6; } 4445 4508 else 4446 4446 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 4447 4447 - $as_echo "no" >&6; } 4509 4509 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 4510 4510 + printf "%s\n" "no" >&6; } 4448 4511 PKG_CONFIG="" 4449 4512 fi 4450 4513 fi 4451 4451 - # Make sure we can run config.sub. 4452 4452 - $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || 4453 4453 - as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 4514 4514 + 4515 4515 + 4516 4516 + # Make sure we can run config.sub. 4517 4517 + $SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 || 4518 4518 + as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5 4454 4519 4455 4455 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 4456 4456 - $as_echo_n "checking build system type... " >&6; } 4457 4457 - if ${ac_cv_build+:} false; then : 4458 4458 - $as_echo_n "(cached) " >&6 4459 4459 - else 4520 4520 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 4521 4521 + printf %s "checking build system type... " >&6; } 4522 4522 + if test ${ac_cv_build+y} 4523 4523 + then : 4524 4524 + printf %s "(cached) " >&6 4525 4525 + else $as_nop 4460 4526 ac_build_alias=$build_alias 4461 4527 test "x$ac_build_alias" = x && 4462 4462 - ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` 4528 4528 + ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"` 4463 4529 test "x$ac_build_alias" = x && 4464 4530 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 4465 4465 - ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || 4466 4466 - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 4531 4531 + ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || 4532 4532 + as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5 4467 4533 4468 4534 fi 4469 4469 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 4470 4470 - $as_echo "$ac_cv_build" >&6; } 4535 4535 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 4536 4536 + printf "%s\n" "$ac_cv_build" >&6; } 4471 4537 case $ac_cv_build in 4472 4538 *-*-*) ;; 4473 4539 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; ··· 4486 4552 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac 4487 4553 4488 4554 4489 4489 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 4490 4490 - $as_echo_n "checking host system type... " >&6; } 4491 4491 - if ${ac_cv_host+:} false; then : 4492 4492 - $as_echo_n "(cached) " >&6 4493 4493 - else 4555 4555 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 4556 4556 + printf %s "checking host system type... " >&6; } 4557 4557 + if test ${ac_cv_host+y} 4558 4558 + then : 4559 4559 + printf %s "(cached) " >&6 4560 4560 + else $as_nop 4494 4561 if test "x$host_alias" = x; then 4495 4562 ac_cv_host=$ac_cv_build 4496 4563 else 4497 4497 - ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || 4498 4498 - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 4564 4564 + ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` || 4565 4565 + as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5 4499 4566 fi 4500 4567 4501 4568 fi 4502 4502 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 4503 4503 - $as_echo "$ac_cv_host" >&6; } 4569 4569 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 4570 4570 + printf "%s\n" "$ac_cv_host" >&6; } 4504 4571 case $ac_cv_host in 4505 4572 *-*-*) ;; 4506 4573 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; ··· 4519 4586 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac 4520 4587 4521 4588 4522 4522 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 4523 4523 - $as_echo_n "checking for a sed that does not truncate output... " >&6; } 4524 4524 - if ${ac_cv_path_SED+:} false; then : 4525 4525 - $as_echo_n "(cached) " >&6 4526 4526 - else 4589 4589 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 4590 4590 + printf %s "checking for a sed that does not truncate output... " >&6; } 4591 4591 + if test ${ac_cv_path_SED+y} 4592 4592 + then : 4593 4593 + printf %s "(cached) " >&6 4594 4594 + else $as_nop 4527 4595 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ 4528 4596 for ac_i in 1 2 3 4 5 6 7; do 4529 4597 ac_script="$ac_script$as_nl$ac_script" ··· 4537 4605 for as_dir in $PATH 4538 4606 do 4539 4607 IFS=$as_save_IFS 4540 4540 - test -z "$as_dir" && as_dir=. 4541 4541 - for ac_prog in sed gsed; do 4608 4608 + case $as_dir in #((( 4609 4609 + '') as_dir=./ ;; 4610 4610 + */) ;; 4611 4611 + *) as_dir=$as_dir/ ;; 4612 4612 + esac 4613 4613 + for ac_prog in sed gsed 4614 4614 + do 4542 4615 for ac_exec_ext in '' $ac_executable_extensions; do 4543 4543 - ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" 4616 4616 + ac_path_SED="$as_dir$ac_prog$ac_exec_ext" 4544 4617 as_fn_executable_p "$ac_path_SED" || continue 4545 4618 # Check for GNU ac_path_SED and select it if it is found. 4546 4619 # Check for GNU $ac_path_SED ··· 4549 4622 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; 4550 4623 *) 4551 4624 ac_count=0 4552 4552 - $as_echo_n 0123456789 >"conftest.in" 4625 4625 + printf %s 0123456789 >"conftest.in" 4553 4626 while : 4554 4627 do 4555 4628 cat "conftest.in" "conftest.in" >"conftest.tmp" 4556 4629 mv "conftest.tmp" "conftest.in" 4557 4630 cp "conftest.in" "conftest.nl" 4558 4558 - $as_echo '' >> "conftest.nl" 4631 4631 + printf "%s\n" '' >> "conftest.nl" 4559 4632 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break 4560 4633 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break 4561 4634 as_fn_arith $ac_count + 1 && ac_count=$as_val ··· 4583 4656 fi 4584 4657 4585 4658 fi 4586 4586 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 4587 4587 - $as_echo "$ac_cv_path_SED" >&6; } 4659 4659 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 4660 4660 + printf "%s\n" "$ac_cv_path_SED" >&6; } 4588 4661 SED="$ac_cv_path_SED" 4589 4662 rm -f conftest.sed 4590 4663 ··· 4594 4667 4595 4668 4596 4669 # Check whether --enable-selective-werror was given. 4597 4597 - if test "${enable_selective_werror+set}" = set; then : 4670 4670 + if test ${enable_selective_werror+y} 4671 4671 + then : 4598 4672 enableval=$enable_selective_werror; SELECTIVE_WERROR=$enableval 4599 4599 - else 4673 4673 + else $as_nop 4600 4674 SELECTIVE_WERROR=yes 4601 4675 fi 4602 4676 ··· 4629 4703 4630 4704 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 4631 4705 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4632 4632 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4633 4633 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4634 4634 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 4635 4635 - $as_echo_n "(cached) " >&6 4636 4636 - else 4706 4706 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4707 4707 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4708 4708 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 4709 4709 + then : 4710 4710 + printf %s "(cached) " >&6 4711 4711 + else $as_nop 4637 4712 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4638 4713 /* end confdefs.h. */ 4639 4714 int i; 4640 4715 _ACEOF 4641 4641 - if ac_fn_c_try_compile "$LINENO"; then : 4716 4716 + if ac_fn_c_try_compile "$LINENO" 4717 4717 + then : 4642 4718 xorg_cv_cc_flag_unknown_warning_option=yes 4643 4643 - else 4719 4719 + else $as_nop 4644 4720 xorg_cv_cc_flag_unknown_warning_option=no 4645 4721 fi 4646 4646 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4722 4722 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 4647 4723 fi 4648 4648 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 4649 4649 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 4724 4724 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 4725 4725 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 4650 4726 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 4651 4727 CFLAGS="$xorg_testset_save_CFLAGS" 4652 4728 fi ··· 4656 4732 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4657 4733 fi 4658 4734 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 4659 4659 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 4660 4660 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 4661 4661 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 4662 4662 - $as_echo_n "(cached) " >&6 4663 4663 - else 4735 4735 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 4736 4736 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 4737 4737 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 4738 4738 + then : 4739 4739 + printf %s "(cached) " >&6 4740 4740 + else $as_nop 4664 4741 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4665 4742 /* end confdefs.h. */ 4666 4743 int i; 4667 4744 _ACEOF 4668 4668 - if ac_fn_c_try_compile "$LINENO"; then : 4745 4745 + if ac_fn_c_try_compile "$LINENO" 4746 4746 + then : 4669 4747 xorg_cv_cc_flag_unused_command_line_argument=yes 4670 4670 - else 4748 4748 + else $as_nop 4671 4749 xorg_cv_cc_flag_unused_command_line_argument=no 4672 4750 fi 4673 4673 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4751 4751 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 4674 4752 fi 4675 4675 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 4676 4676 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 4753 4753 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 4754 4754 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 4677 4755 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 4678 4756 CFLAGS="$xorg_testset_save_CFLAGS" 4679 4757 fi ··· 4691 4769 4692 4770 CFLAGS="$CFLAGS -Wall" 4693 4771 4694 4694 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wall" >&5 4695 4695 - $as_echo_n "checking if $CC supports -Wall... " >&6; } 4772 4772 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wall" >&5 4773 4773 + printf %s "checking if $CC supports -Wall... " >&6; } 4696 4774 cacheid=xorg_cv_cc_flag__Wall 4697 4697 - if eval \${$cacheid+:} false; then : 4698 4698 - $as_echo_n "(cached) " >&6 4699 4699 - else 4775 4775 + if eval test \${$cacheid+y} 4776 4776 + then : 4777 4777 + printf %s "(cached) " >&6 4778 4778 + else $as_nop 4700 4779 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4701 4780 /* end confdefs.h. */ 4702 4781 int i; 4703 4782 int 4704 4704 - main () 4783 4783 + main (void) 4705 4784 { 4706 4785 4707 4786 ; 4708 4787 return 0; 4709 4788 } 4710 4789 _ACEOF 4711 4711 - if ac_fn_c_try_link "$LINENO"; then : 4790 4790 + if ac_fn_c_try_link "$LINENO" 4791 4791 + then : 4712 4792 eval $cacheid=yes 4713 4713 - else 4793 4793 + else $as_nop 4714 4794 eval $cacheid=no 4715 4795 fi 4716 4716 - rm -f core conftest.err conftest.$ac_objext \ 4796 4796 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 4717 4797 conftest$ac_exeext conftest.$ac_ext 4718 4798 fi 4719 4799 ··· 4721 4801 CFLAGS="$xorg_testset_save_CFLAGS" 4722 4802 4723 4803 eval supported=\$$cacheid 4724 4724 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 4725 4725 - $as_echo "$supported" >&6; } 4804 4804 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 4805 4805 + printf "%s\n" "$supported" >&6; } 4726 4806 if test "$supported" = "yes" ; then 4727 4807 BASE_CFLAGS="$BASE_CFLAGS -Wall" 4728 4808 found="yes" ··· 4747 4827 4748 4828 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 4749 4829 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4750 4750 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4751 4751 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4752 4752 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 4753 4753 - $as_echo_n "(cached) " >&6 4754 4754 - else 4830 4830 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4831 4831 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4832 4832 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 4833 4833 + then : 4834 4834 + printf %s "(cached) " >&6 4835 4835 + else $as_nop 4755 4836 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4756 4837 /* end confdefs.h. */ 4757 4838 int i; 4758 4839 _ACEOF 4759 4759 - if ac_fn_c_try_compile "$LINENO"; then : 4840 4840 + if ac_fn_c_try_compile "$LINENO" 4841 4841 + then : 4760 4842 xorg_cv_cc_flag_unknown_warning_option=yes 4761 4761 - else 4843 4843 + else $as_nop 4762 4844 xorg_cv_cc_flag_unknown_warning_option=no 4763 4845 fi 4764 4764 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4846 4846 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 4765 4847 fi 4766 4766 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 4767 4767 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 4848 4848 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 4849 4849 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 4768 4850 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 4769 4851 CFLAGS="$xorg_testset_save_CFLAGS" 4770 4852 fi ··· 4774 4856 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4775 4857 fi 4776 4858 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 4777 4777 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 4778 4778 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 4779 4779 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 4780 4780 - $as_echo_n "(cached) " >&6 4781 4781 - else 4859 4859 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 4860 4860 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 4861 4861 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 4862 4862 + then : 4863 4863 + printf %s "(cached) " >&6 4864 4864 + else $as_nop 4782 4865 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4783 4866 /* end confdefs.h. */ 4784 4867 int i; 4785 4868 _ACEOF 4786 4786 - if ac_fn_c_try_compile "$LINENO"; then : 4869 4869 + if ac_fn_c_try_compile "$LINENO" 4870 4870 + then : 4787 4871 xorg_cv_cc_flag_unused_command_line_argument=yes 4788 4788 - else 4872 4872 + else $as_nop 4789 4873 xorg_cv_cc_flag_unused_command_line_argument=no 4790 4874 fi 4791 4791 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4875 4875 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 4792 4876 fi 4793 4793 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 4794 4794 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 4877 4877 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 4878 4878 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 4795 4879 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 4796 4880 CFLAGS="$xorg_testset_save_CFLAGS" 4797 4881 fi ··· 4809 4893 4810 4894 CFLAGS="$CFLAGS -Wpointer-arith" 4811 4895 4812 4812 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wpointer-arith" >&5 4813 4813 - $as_echo_n "checking if $CC supports -Wpointer-arith... " >&6; } 4896 4896 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wpointer-arith" >&5 4897 4897 + printf %s "checking if $CC supports -Wpointer-arith... " >&6; } 4814 4898 cacheid=xorg_cv_cc_flag__Wpointer_arith 4815 4815 - if eval \${$cacheid+:} false; then : 4816 4816 - $as_echo_n "(cached) " >&6 4817 4817 - else 4899 4899 + if eval test \${$cacheid+y} 4900 4900 + then : 4901 4901 + printf %s "(cached) " >&6 4902 4902 + else $as_nop 4818 4903 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4819 4904 /* end confdefs.h. */ 4820 4905 int i; 4821 4906 int 4822 4822 - main () 4907 4907 + main (void) 4823 4908 { 4824 4909 4825 4910 ; 4826 4911 return 0; 4827 4912 } 4828 4913 _ACEOF 4829 4829 - if ac_fn_c_try_link "$LINENO"; then : 4914 4914 + if ac_fn_c_try_link "$LINENO" 4915 4915 + then : 4830 4916 eval $cacheid=yes 4831 4831 - else 4917 4917 + else $as_nop 4832 4918 eval $cacheid=no 4833 4919 fi 4834 4834 - rm -f core conftest.err conftest.$ac_objext \ 4920 4920 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 4835 4921 conftest$ac_exeext conftest.$ac_ext 4836 4922 fi 4837 4923 ··· 4839 4925 CFLAGS="$xorg_testset_save_CFLAGS" 4840 4926 4841 4927 eval supported=\$$cacheid 4842 4842 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 4843 4843 - $as_echo "$supported" >&6; } 4928 4928 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 4929 4929 + printf "%s\n" "$supported" >&6; } 4844 4930 if test "$supported" = "yes" ; then 4845 4931 BASE_CFLAGS="$BASE_CFLAGS -Wpointer-arith" 4846 4932 found="yes" ··· 4865 4951 4866 4952 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 4867 4953 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4868 4868 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4869 4869 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4870 4870 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 4871 4871 - $as_echo_n "(cached) " >&6 4872 4872 - else 4954 4954 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4955 4955 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4956 4956 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 4957 4957 + then : 4958 4958 + printf %s "(cached) " >&6 4959 4959 + else $as_nop 4873 4960 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4874 4961 /* end confdefs.h. */ 4875 4962 int i; 4876 4963 _ACEOF 4877 4877 - if ac_fn_c_try_compile "$LINENO"; then : 4964 4964 + if ac_fn_c_try_compile "$LINENO" 4965 4965 + then : 4878 4966 xorg_cv_cc_flag_unknown_warning_option=yes 4879 4879 - else 4967 4967 + else $as_nop 4880 4968 xorg_cv_cc_flag_unknown_warning_option=no 4881 4969 fi 4882 4882 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4970 4970 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 4883 4971 fi 4884 4884 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 4885 4885 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 4972 4972 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 4973 4973 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 4886 4974 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 4887 4975 CFLAGS="$xorg_testset_save_CFLAGS" 4888 4976 fi ··· 4892 4980 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4893 4981 fi 4894 4982 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 4895 4895 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 4896 4896 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 4897 4897 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 4898 4898 - $as_echo_n "(cached) " >&6 4899 4899 - else 4983 4983 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 4984 4984 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 4985 4985 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 4986 4986 + then : 4987 4987 + printf %s "(cached) " >&6 4988 4988 + else $as_nop 4900 4989 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4901 4990 /* end confdefs.h. */ 4902 4991 int i; 4903 4992 _ACEOF 4904 4904 - if ac_fn_c_try_compile "$LINENO"; then : 4993 4993 + if ac_fn_c_try_compile "$LINENO" 4994 4994 + then : 4905 4995 xorg_cv_cc_flag_unused_command_line_argument=yes 4906 4906 - else 4996 4996 + else $as_nop 4907 4997 xorg_cv_cc_flag_unused_command_line_argument=no 4908 4998 fi 4909 4909 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4999 4999 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 4910 5000 fi 4911 4911 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 4912 4912 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5001 5001 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5002 5002 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 4913 5003 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 4914 5004 CFLAGS="$xorg_testset_save_CFLAGS" 4915 5005 fi ··· 4927 5017 4928 5018 CFLAGS="$CFLAGS -Wmissing-declarations" 4929 5019 4930 4930 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-declarations" >&5 4931 4931 - $as_echo_n "checking if $CC supports -Wmissing-declarations... " >&6; } 5020 5020 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-declarations" >&5 5021 5021 + printf %s "checking if $CC supports -Wmissing-declarations... " >&6; } 4932 5022 cacheid=xorg_cv_cc_flag__Wmissing_declarations 4933 4933 - if eval \${$cacheid+:} false; then : 4934 4934 - $as_echo_n "(cached) " >&6 4935 4935 - else 5023 5023 + if eval test \${$cacheid+y} 5024 5024 + then : 5025 5025 + printf %s "(cached) " >&6 5026 5026 + else $as_nop 4936 5027 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4937 5028 /* end confdefs.h. */ 4938 5029 int i; 4939 5030 int 4940 4940 - main () 5031 5031 + main (void) 4941 5032 { 4942 5033 4943 5034 ; 4944 5035 return 0; 4945 5036 } 4946 5037 _ACEOF 4947 4947 - if ac_fn_c_try_link "$LINENO"; then : 5038 5038 + if ac_fn_c_try_link "$LINENO" 5039 5039 + then : 4948 5040 eval $cacheid=yes 4949 4949 - else 5041 5041 + else $as_nop 4950 5042 eval $cacheid=no 4951 5043 fi 4952 4952 - rm -f core conftest.err conftest.$ac_objext \ 5044 5044 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 4953 5045 conftest$ac_exeext conftest.$ac_ext 4954 5046 fi 4955 5047 ··· 4957 5049 CFLAGS="$xorg_testset_save_CFLAGS" 4958 5050 4959 5051 eval supported=\$$cacheid 4960 4960 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 4961 4961 - $as_echo "$supported" >&6; } 5052 5052 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5053 5053 + printf "%s\n" "$supported" >&6; } 4962 5054 if test "$supported" = "yes" ; then 4963 5055 BASE_CFLAGS="$BASE_CFLAGS -Wmissing-declarations" 4964 5056 found="yes" ··· 4983 5075 4984 5076 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 4985 5077 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 4986 4986 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 4987 4987 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 4988 4988 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 4989 4989 - $as_echo_n "(cached) " >&6 4990 4990 - else 5078 5078 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5079 5079 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5080 5080 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5081 5081 + then : 5082 5082 + printf %s "(cached) " >&6 5083 5083 + else $as_nop 4991 5084 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4992 5085 /* end confdefs.h. */ 4993 5086 int i; 4994 5087 _ACEOF 4995 4995 - if ac_fn_c_try_compile "$LINENO"; then : 5088 5088 + if ac_fn_c_try_compile "$LINENO" 5089 5089 + then : 4996 5090 xorg_cv_cc_flag_unknown_warning_option=yes 4997 4997 - else 5091 5091 + else $as_nop 4998 5092 xorg_cv_cc_flag_unknown_warning_option=no 4999 5093 fi 5000 5000 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5094 5094 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5001 5095 fi 5002 5002 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5003 5003 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5096 5096 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5097 5097 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5004 5098 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5005 5099 CFLAGS="$xorg_testset_save_CFLAGS" 5006 5100 fi ··· 5010 5104 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5011 5105 fi 5012 5106 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5013 5013 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5014 5014 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5015 5015 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5016 5016 - $as_echo_n "(cached) " >&6 5017 5017 - else 5107 5107 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5108 5108 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5109 5109 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5110 5110 + then : 5111 5111 + printf %s "(cached) " >&6 5112 5112 + else $as_nop 5018 5113 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5019 5114 /* end confdefs.h. */ 5020 5115 int i; 5021 5116 _ACEOF 5022 5022 - if ac_fn_c_try_compile "$LINENO"; then : 5117 5117 + if ac_fn_c_try_compile "$LINENO" 5118 5118 + then : 5023 5119 xorg_cv_cc_flag_unused_command_line_argument=yes 5024 5024 - else 5120 5120 + else $as_nop 5025 5121 xorg_cv_cc_flag_unused_command_line_argument=no 5026 5122 fi 5027 5027 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5123 5123 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5028 5124 fi 5029 5029 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5030 5030 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5125 5125 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5126 5126 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5031 5127 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5032 5128 CFLAGS="$xorg_testset_save_CFLAGS" 5033 5129 fi ··· 5045 5141 5046 5142 CFLAGS="$CFLAGS -Wformat=2" 5047 5143 5048 5048 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wformat=2" >&5 5049 5049 - $as_echo_n "checking if $CC supports -Wformat=2... " >&6; } 5144 5144 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wformat=2" >&5 5145 5145 + printf %s "checking if $CC supports -Wformat=2... " >&6; } 5050 5146 cacheid=xorg_cv_cc_flag__Wformat_2 5051 5051 - if eval \${$cacheid+:} false; then : 5052 5052 - $as_echo_n "(cached) " >&6 5053 5053 - else 5147 5147 + if eval test \${$cacheid+y} 5148 5148 + then : 5149 5149 + printf %s "(cached) " >&6 5150 5150 + else $as_nop 5054 5151 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5055 5152 /* end confdefs.h. */ 5056 5153 int i; 5057 5154 int 5058 5058 - main () 5155 5155 + main (void) 5059 5156 { 5060 5157 5061 5158 ; 5062 5159 return 0; 5063 5160 } 5064 5161 _ACEOF 5065 5065 - if ac_fn_c_try_link "$LINENO"; then : 5162 5162 + if ac_fn_c_try_link "$LINENO" 5163 5163 + then : 5066 5164 eval $cacheid=yes 5067 5067 - else 5165 5165 + else $as_nop 5068 5166 eval $cacheid=no 5069 5167 fi 5070 5070 - rm -f core conftest.err conftest.$ac_objext \ 5168 5168 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5071 5169 conftest$ac_exeext conftest.$ac_ext 5072 5170 fi 5073 5171 ··· 5075 5173 CFLAGS="$xorg_testset_save_CFLAGS" 5076 5174 5077 5175 eval supported=\$$cacheid 5078 5078 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5079 5079 - $as_echo "$supported" >&6; } 5176 5176 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5177 5177 + printf "%s\n" "$supported" >&6; } 5080 5178 if test "$supported" = "yes" ; then 5081 5179 BASE_CFLAGS="$BASE_CFLAGS -Wformat=2" 5082 5180 found="yes" ··· 5094 5192 5095 5193 CFLAGS="$CFLAGS -Wformat" 5096 5194 5097 5097 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wformat" >&5 5098 5098 - $as_echo_n "checking if $CC supports -Wformat... " >&6; } 5195 5195 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wformat" >&5 5196 5196 + printf %s "checking if $CC supports -Wformat... " >&6; } 5099 5197 cacheid=xorg_cv_cc_flag__Wformat 5100 5100 - if eval \${$cacheid+:} false; then : 5101 5101 - $as_echo_n "(cached) " >&6 5102 5102 - else 5198 5198 + if eval test \${$cacheid+y} 5199 5199 + then : 5200 5200 + printf %s "(cached) " >&6 5201 5201 + else $as_nop 5103 5202 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5104 5203 /* end confdefs.h. */ 5105 5204 int i; 5106 5205 int 5107 5107 - main () 5206 5206 + main (void) 5108 5207 { 5109 5208 5110 5209 ; 5111 5210 return 0; 5112 5211 } 5113 5212 _ACEOF 5114 5114 - if ac_fn_c_try_link "$LINENO"; then : 5213 5213 + if ac_fn_c_try_link "$LINENO" 5214 5214 + then : 5115 5215 eval $cacheid=yes 5116 5116 - else 5216 5216 + else $as_nop 5117 5217 eval $cacheid=no 5118 5218 fi 5119 5119 - rm -f core conftest.err conftest.$ac_objext \ 5219 5219 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5120 5220 conftest$ac_exeext conftest.$ac_ext 5121 5221 fi 5122 5222 ··· 5124 5224 CFLAGS="$xorg_testset_save_CFLAGS" 5125 5225 5126 5226 eval supported=\$$cacheid 5127 5127 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5128 5128 - $as_echo "$supported" >&6; } 5227 5227 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5228 5228 + printf "%s\n" "$supported" >&6; } 5129 5229 if test "$supported" = "yes" ; then 5130 5230 BASE_CFLAGS="$BASE_CFLAGS -Wformat" 5131 5231 found="yes" ··· 5152 5252 5153 5253 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5154 5254 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5155 5155 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5156 5156 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5157 5157 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5158 5158 - $as_echo_n "(cached) " >&6 5159 5159 - else 5255 5255 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5256 5256 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5257 5257 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5258 5258 + then : 5259 5259 + printf %s "(cached) " >&6 5260 5260 + else $as_nop 5160 5261 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5161 5262 /* end confdefs.h. */ 5162 5263 int i; 5163 5264 _ACEOF 5164 5164 - if ac_fn_c_try_compile "$LINENO"; then : 5265 5265 + if ac_fn_c_try_compile "$LINENO" 5266 5266 + then : 5165 5267 xorg_cv_cc_flag_unknown_warning_option=yes 5166 5166 - else 5268 5268 + else $as_nop 5167 5269 xorg_cv_cc_flag_unknown_warning_option=no 5168 5270 fi 5169 5169 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5271 5271 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5170 5272 fi 5171 5171 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5172 5172 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5273 5273 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5274 5274 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5173 5275 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5174 5276 CFLAGS="$xorg_testset_save_CFLAGS" 5175 5277 fi ··· 5179 5281 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5180 5282 fi 5181 5283 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5182 5182 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5183 5183 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5184 5184 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5185 5185 - $as_echo_n "(cached) " >&6 5186 5186 - else 5284 5284 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5285 5285 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5286 5286 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5287 5287 + then : 5288 5288 + printf %s "(cached) " >&6 5289 5289 + else $as_nop 5187 5290 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5188 5291 /* end confdefs.h. */ 5189 5292 int i; 5190 5293 _ACEOF 5191 5191 - if ac_fn_c_try_compile "$LINENO"; then : 5294 5294 + if ac_fn_c_try_compile "$LINENO" 5295 5295 + then : 5192 5296 xorg_cv_cc_flag_unused_command_line_argument=yes 5193 5193 - else 5297 5297 + else $as_nop 5194 5298 xorg_cv_cc_flag_unused_command_line_argument=no 5195 5299 fi 5196 5196 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5300 5300 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5197 5301 fi 5198 5198 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5199 5199 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5302 5302 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5303 5303 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5200 5304 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5201 5305 CFLAGS="$xorg_testset_save_CFLAGS" 5202 5306 fi ··· 5214 5318 5215 5319 CFLAGS="$CFLAGS -Wstrict-prototypes" 5216 5320 5217 5217 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wstrict-prototypes" >&5 5218 5218 - $as_echo_n "checking if $CC supports -Wstrict-prototypes... " >&6; } 5321 5321 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wstrict-prototypes" >&5 5322 5322 + printf %s "checking if $CC supports -Wstrict-prototypes... " >&6; } 5219 5323 cacheid=xorg_cv_cc_flag__Wstrict_prototypes 5220 5220 - if eval \${$cacheid+:} false; then : 5221 5221 - $as_echo_n "(cached) " >&6 5222 5222 - else 5324 5324 + if eval test \${$cacheid+y} 5325 5325 + then : 5326 5326 + printf %s "(cached) " >&6 5327 5327 + else $as_nop 5223 5328 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5224 5329 /* end confdefs.h. */ 5225 5330 int i; 5226 5331 int 5227 5227 - main () 5332 5332 + main (void) 5228 5333 { 5229 5334 5230 5335 ; 5231 5336 return 0; 5232 5337 } 5233 5338 _ACEOF 5234 5234 - if ac_fn_c_try_link "$LINENO"; then : 5339 5339 + if ac_fn_c_try_link "$LINENO" 5340 5340 + then : 5235 5341 eval $cacheid=yes 5236 5236 - else 5342 5342 + else $as_nop 5237 5343 eval $cacheid=no 5238 5344 fi 5239 5239 - rm -f core conftest.err conftest.$ac_objext \ 5345 5345 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5240 5346 conftest$ac_exeext conftest.$ac_ext 5241 5347 fi 5242 5348 ··· 5244 5350 CFLAGS="$xorg_testset_save_CFLAGS" 5245 5351 5246 5352 eval supported=\$$cacheid 5247 5247 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5248 5248 - $as_echo "$supported" >&6; } 5353 5353 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5354 5354 + printf "%s\n" "$supported" >&6; } 5249 5355 if test "$supported" = "yes" ; then 5250 5356 BASE_CFLAGS="$BASE_CFLAGS -Wstrict-prototypes" 5251 5357 found="yes" ··· 5270 5376 5271 5377 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5272 5378 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5273 5273 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5274 5274 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5275 5275 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5276 5276 - $as_echo_n "(cached) " >&6 5277 5277 - else 5379 5379 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5380 5380 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5381 5381 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5382 5382 + then : 5383 5383 + printf %s "(cached) " >&6 5384 5384 + else $as_nop 5278 5385 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5279 5386 /* end confdefs.h. */ 5280 5387 int i; 5281 5388 _ACEOF 5282 5282 - if ac_fn_c_try_compile "$LINENO"; then : 5389 5389 + if ac_fn_c_try_compile "$LINENO" 5390 5390 + then : 5283 5391 xorg_cv_cc_flag_unknown_warning_option=yes 5284 5284 - else 5392 5392 + else $as_nop 5285 5393 xorg_cv_cc_flag_unknown_warning_option=no 5286 5394 fi 5287 5287 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5395 5395 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5288 5396 fi 5289 5289 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5290 5290 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5397 5397 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5398 5398 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5291 5399 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5292 5400 CFLAGS="$xorg_testset_save_CFLAGS" 5293 5401 fi ··· 5297 5405 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5298 5406 fi 5299 5407 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5300 5300 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5301 5301 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5302 5302 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5303 5303 - $as_echo_n "(cached) " >&6 5304 5304 - else 5408 5408 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5409 5409 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5410 5410 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5411 5411 + then : 5412 5412 + printf %s "(cached) " >&6 5413 5413 + else $as_nop 5305 5414 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5306 5415 /* end confdefs.h. */ 5307 5416 int i; 5308 5417 _ACEOF 5309 5309 - if ac_fn_c_try_compile "$LINENO"; then : 5418 5418 + if ac_fn_c_try_compile "$LINENO" 5419 5419 + then : 5310 5420 xorg_cv_cc_flag_unused_command_line_argument=yes 5311 5311 - else 5421 5421 + else $as_nop 5312 5422 xorg_cv_cc_flag_unused_command_line_argument=no 5313 5423 fi 5314 5314 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5424 5424 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5315 5425 fi 5316 5316 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5317 5317 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5426 5426 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5427 5427 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5318 5428 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5319 5429 CFLAGS="$xorg_testset_save_CFLAGS" 5320 5430 fi ··· 5332 5442 5333 5443 CFLAGS="$CFLAGS -Wmissing-prototypes" 5334 5444 5335 5335 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-prototypes" >&5 5336 5336 - $as_echo_n "checking if $CC supports -Wmissing-prototypes... " >&6; } 5445 5445 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-prototypes" >&5 5446 5446 + printf %s "checking if $CC supports -Wmissing-prototypes... " >&6; } 5337 5447 cacheid=xorg_cv_cc_flag__Wmissing_prototypes 5338 5338 - if eval \${$cacheid+:} false; then : 5339 5339 - $as_echo_n "(cached) " >&6 5340 5340 - else 5448 5448 + if eval test \${$cacheid+y} 5449 5449 + then : 5450 5450 + printf %s "(cached) " >&6 5451 5451 + else $as_nop 5341 5452 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5342 5453 /* end confdefs.h. */ 5343 5454 int i; 5344 5455 int 5345 5345 - main () 5456 5456 + main (void) 5346 5457 { 5347 5458 5348 5459 ; 5349 5460 return 0; 5350 5461 } 5351 5462 _ACEOF 5352 5352 - if ac_fn_c_try_link "$LINENO"; then : 5463 5463 + if ac_fn_c_try_link "$LINENO" 5464 5464 + then : 5353 5465 eval $cacheid=yes 5354 5354 - else 5466 5466 + else $as_nop 5355 5467 eval $cacheid=no 5356 5468 fi 5357 5357 - rm -f core conftest.err conftest.$ac_objext \ 5469 5469 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5358 5470 conftest$ac_exeext conftest.$ac_ext 5359 5471 fi 5360 5472 ··· 5362 5474 CFLAGS="$xorg_testset_save_CFLAGS" 5363 5475 5364 5476 eval supported=\$$cacheid 5365 5365 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5366 5366 - $as_echo "$supported" >&6; } 5477 5477 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5478 5478 + printf "%s\n" "$supported" >&6; } 5367 5479 if test "$supported" = "yes" ; then 5368 5480 BASE_CFLAGS="$BASE_CFLAGS -Wmissing-prototypes" 5369 5481 found="yes" ··· 5388 5500 5389 5501 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5390 5502 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5391 5391 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5392 5392 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5393 5393 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5394 5394 - $as_echo_n "(cached) " >&6 5395 5395 - else 5503 5503 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5504 5504 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5505 5505 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5506 5506 + then : 5507 5507 + printf %s "(cached) " >&6 5508 5508 + else $as_nop 5396 5509 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5397 5510 /* end confdefs.h. */ 5398 5511 int i; 5399 5512 _ACEOF 5400 5400 - if ac_fn_c_try_compile "$LINENO"; then : 5513 5513 + if ac_fn_c_try_compile "$LINENO" 5514 5514 + then : 5401 5515 xorg_cv_cc_flag_unknown_warning_option=yes 5402 5402 - else 5516 5516 + else $as_nop 5403 5517 xorg_cv_cc_flag_unknown_warning_option=no 5404 5518 fi 5405 5405 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5519 5519 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5406 5520 fi 5407 5407 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5408 5408 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5521 5521 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5522 5522 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5409 5523 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5410 5524 CFLAGS="$xorg_testset_save_CFLAGS" 5411 5525 fi ··· 5415 5529 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5416 5530 fi 5417 5531 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5418 5418 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5419 5419 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5420 5420 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5421 5421 - $as_echo_n "(cached) " >&6 5422 5422 - else 5532 5532 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5533 5533 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5534 5534 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5535 5535 + then : 5536 5536 + printf %s "(cached) " >&6 5537 5537 + else $as_nop 5423 5538 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5424 5539 /* end confdefs.h. */ 5425 5540 int i; 5426 5541 _ACEOF 5427 5427 - if ac_fn_c_try_compile "$LINENO"; then : 5542 5542 + if ac_fn_c_try_compile "$LINENO" 5543 5543 + then : 5428 5544 xorg_cv_cc_flag_unused_command_line_argument=yes 5429 5429 - else 5545 5545 + else $as_nop 5430 5546 xorg_cv_cc_flag_unused_command_line_argument=no 5431 5547 fi 5432 5432 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5548 5548 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5433 5549 fi 5434 5434 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5435 5435 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5550 5550 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5551 5551 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5436 5552 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5437 5553 CFLAGS="$xorg_testset_save_CFLAGS" 5438 5554 fi ··· 5450 5566 5451 5567 CFLAGS="$CFLAGS -Wnested-externs" 5452 5568 5453 5453 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wnested-externs" >&5 5454 5454 - $as_echo_n "checking if $CC supports -Wnested-externs... " >&6; } 5569 5569 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wnested-externs" >&5 5570 5570 + printf %s "checking if $CC supports -Wnested-externs... " >&6; } 5455 5571 cacheid=xorg_cv_cc_flag__Wnested_externs 5456 5456 - if eval \${$cacheid+:} false; then : 5457 5457 - $as_echo_n "(cached) " >&6 5458 5458 - else 5572 5572 + if eval test \${$cacheid+y} 5573 5573 + then : 5574 5574 + printf %s "(cached) " >&6 5575 5575 + else $as_nop 5459 5576 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5460 5577 /* end confdefs.h. */ 5461 5578 int i; 5462 5579 int 5463 5463 - main () 5580 5580 + main (void) 5464 5581 { 5465 5582 5466 5583 ; 5467 5584 return 0; 5468 5585 } 5469 5586 _ACEOF 5470 5470 - if ac_fn_c_try_link "$LINENO"; then : 5587 5587 + if ac_fn_c_try_link "$LINENO" 5588 5588 + then : 5471 5589 eval $cacheid=yes 5472 5472 - else 5590 5590 + else $as_nop 5473 5591 eval $cacheid=no 5474 5592 fi 5475 5475 - rm -f core conftest.err conftest.$ac_objext \ 5593 5593 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5476 5594 conftest$ac_exeext conftest.$ac_ext 5477 5595 fi 5478 5596 ··· 5480 5598 CFLAGS="$xorg_testset_save_CFLAGS" 5481 5599 5482 5600 eval supported=\$$cacheid 5483 5483 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5484 5484 - $as_echo "$supported" >&6; } 5601 5601 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5602 5602 + printf "%s\n" "$supported" >&6; } 5485 5603 if test "$supported" = "yes" ; then 5486 5604 BASE_CFLAGS="$BASE_CFLAGS -Wnested-externs" 5487 5605 found="yes" ··· 5506 5624 5507 5625 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5508 5626 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5509 5509 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5510 5510 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5511 5511 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5512 5512 - $as_echo_n "(cached) " >&6 5513 5513 - else 5627 5627 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5628 5628 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5629 5629 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5630 5630 + then : 5631 5631 + printf %s "(cached) " >&6 5632 5632 + else $as_nop 5514 5633 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5515 5634 /* end confdefs.h. */ 5516 5635 int i; 5517 5636 _ACEOF 5518 5518 - if ac_fn_c_try_compile "$LINENO"; then : 5637 5637 + if ac_fn_c_try_compile "$LINENO" 5638 5638 + then : 5519 5639 xorg_cv_cc_flag_unknown_warning_option=yes 5520 5520 - else 5640 5640 + else $as_nop 5521 5641 xorg_cv_cc_flag_unknown_warning_option=no 5522 5642 fi 5523 5523 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5643 5643 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5524 5644 fi 5525 5525 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5526 5526 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5645 5645 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5646 5646 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5527 5647 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5528 5648 CFLAGS="$xorg_testset_save_CFLAGS" 5529 5649 fi ··· 5533 5653 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5534 5654 fi 5535 5655 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5536 5536 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5537 5537 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5538 5538 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5539 5539 - $as_echo_n "(cached) " >&6 5540 5540 - else 5656 5656 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5657 5657 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5658 5658 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5659 5659 + then : 5660 5660 + printf %s "(cached) " >&6 5661 5661 + else $as_nop 5541 5662 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5542 5663 /* end confdefs.h. */ 5543 5664 int i; 5544 5665 _ACEOF 5545 5545 - if ac_fn_c_try_compile "$LINENO"; then : 5666 5666 + if ac_fn_c_try_compile "$LINENO" 5667 5667 + then : 5546 5668 xorg_cv_cc_flag_unused_command_line_argument=yes 5547 5547 - else 5669 5669 + else $as_nop 5548 5670 xorg_cv_cc_flag_unused_command_line_argument=no 5549 5671 fi 5550 5550 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5672 5672 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5551 5673 fi 5552 5552 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5553 5553 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5674 5674 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5675 5675 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5554 5676 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5555 5677 CFLAGS="$xorg_testset_save_CFLAGS" 5556 5678 fi ··· 5568 5690 5569 5691 CFLAGS="$CFLAGS -Wbad-function-cast" 5570 5692 5571 5571 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wbad-function-cast" >&5 5572 5572 - $as_echo_n "checking if $CC supports -Wbad-function-cast... " >&6; } 5693 5693 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wbad-function-cast" >&5 5694 5694 + printf %s "checking if $CC supports -Wbad-function-cast... " >&6; } 5573 5695 cacheid=xorg_cv_cc_flag__Wbad_function_cast 5574 5574 - if eval \${$cacheid+:} false; then : 5575 5575 - $as_echo_n "(cached) " >&6 5576 5576 - else 5696 5696 + if eval test \${$cacheid+y} 5697 5697 + then : 5698 5698 + printf %s "(cached) " >&6 5699 5699 + else $as_nop 5577 5700 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5578 5701 /* end confdefs.h. */ 5579 5702 int i; 5580 5703 int 5581 5581 - main () 5704 5704 + main (void) 5582 5705 { 5583 5706 5584 5707 ; 5585 5708 return 0; 5586 5709 } 5587 5710 _ACEOF 5588 5588 - if ac_fn_c_try_link "$LINENO"; then : 5711 5711 + if ac_fn_c_try_link "$LINENO" 5712 5712 + then : 5589 5713 eval $cacheid=yes 5590 5590 - else 5714 5714 + else $as_nop 5591 5715 eval $cacheid=no 5592 5716 fi 5593 5593 - rm -f core conftest.err conftest.$ac_objext \ 5717 5717 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5594 5718 conftest$ac_exeext conftest.$ac_ext 5595 5719 fi 5596 5720 ··· 5598 5722 CFLAGS="$xorg_testset_save_CFLAGS" 5599 5723 5600 5724 eval supported=\$$cacheid 5601 5601 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5602 5602 - $as_echo "$supported" >&6; } 5725 5725 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5726 5726 + printf "%s\n" "$supported" >&6; } 5603 5727 if test "$supported" = "yes" ; then 5604 5728 BASE_CFLAGS="$BASE_CFLAGS -Wbad-function-cast" 5605 5729 found="yes" ··· 5624 5748 5625 5749 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5626 5750 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5627 5627 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5628 5628 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5629 5629 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5630 5630 - $as_echo_n "(cached) " >&6 5631 5631 - else 5751 5751 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5752 5752 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5753 5753 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5754 5754 + then : 5755 5755 + printf %s "(cached) " >&6 5756 5756 + else $as_nop 5632 5757 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5633 5758 /* end confdefs.h. */ 5634 5759 int i; 5635 5760 _ACEOF 5636 5636 - if ac_fn_c_try_compile "$LINENO"; then : 5761 5761 + if ac_fn_c_try_compile "$LINENO" 5762 5762 + then : 5637 5763 xorg_cv_cc_flag_unknown_warning_option=yes 5638 5638 - else 5764 5764 + else $as_nop 5639 5765 xorg_cv_cc_flag_unknown_warning_option=no 5640 5766 fi 5641 5641 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5767 5767 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5642 5768 fi 5643 5643 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5644 5644 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5769 5769 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5770 5770 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5645 5771 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5646 5772 CFLAGS="$xorg_testset_save_CFLAGS" 5647 5773 fi ··· 5651 5777 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5652 5778 fi 5653 5779 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5654 5654 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5655 5655 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5656 5656 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5657 5657 - $as_echo_n "(cached) " >&6 5658 5658 - else 5780 5780 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5781 5781 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5782 5782 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5783 5783 + then : 5784 5784 + printf %s "(cached) " >&6 5785 5785 + else $as_nop 5659 5786 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5660 5787 /* end confdefs.h. */ 5661 5788 int i; 5662 5789 _ACEOF 5663 5663 - if ac_fn_c_try_compile "$LINENO"; then : 5790 5790 + if ac_fn_c_try_compile "$LINENO" 5791 5791 + then : 5664 5792 xorg_cv_cc_flag_unused_command_line_argument=yes 5665 5665 - else 5793 5793 + else $as_nop 5666 5794 xorg_cv_cc_flag_unused_command_line_argument=no 5667 5795 fi 5668 5668 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5796 5796 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5669 5797 fi 5670 5670 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5671 5671 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5798 5798 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5799 5799 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5672 5800 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5673 5801 CFLAGS="$xorg_testset_save_CFLAGS" 5674 5802 fi ··· 5686 5814 5687 5815 CFLAGS="$CFLAGS -Wold-style-definition" 5688 5816 5689 5689 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wold-style-definition" >&5 5690 5690 - $as_echo_n "checking if $CC supports -Wold-style-definition... " >&6; } 5817 5817 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wold-style-definition" >&5 5818 5818 + printf %s "checking if $CC supports -Wold-style-definition... " >&6; } 5691 5819 cacheid=xorg_cv_cc_flag__Wold_style_definition 5692 5692 - if eval \${$cacheid+:} false; then : 5693 5693 - $as_echo_n "(cached) " >&6 5694 5694 - else 5820 5820 + if eval test \${$cacheid+y} 5821 5821 + then : 5822 5822 + printf %s "(cached) " >&6 5823 5823 + else $as_nop 5695 5824 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5696 5825 /* end confdefs.h. */ 5697 5826 int i; 5698 5827 int 5699 5699 - main () 5828 5828 + main (void) 5700 5829 { 5701 5830 5702 5831 ; 5703 5832 return 0; 5704 5833 } 5705 5834 _ACEOF 5706 5706 - if ac_fn_c_try_link "$LINENO"; then : 5835 5835 + if ac_fn_c_try_link "$LINENO" 5836 5836 + then : 5707 5837 eval $cacheid=yes 5708 5708 - else 5838 5838 + else $as_nop 5709 5839 eval $cacheid=no 5710 5840 fi 5711 5711 - rm -f core conftest.err conftest.$ac_objext \ 5841 5841 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5712 5842 conftest$ac_exeext conftest.$ac_ext 5713 5843 fi 5714 5844 ··· 5716 5846 CFLAGS="$xorg_testset_save_CFLAGS" 5717 5847 5718 5848 eval supported=\$$cacheid 5719 5719 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5720 5720 - $as_echo "$supported" >&6; } 5849 5849 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5850 5850 + printf "%s\n" "$supported" >&6; } 5721 5851 if test "$supported" = "yes" ; then 5722 5852 BASE_CFLAGS="$BASE_CFLAGS -Wold-style-definition" 5723 5853 found="yes" ··· 5735 5865 5736 5866 CFLAGS="$CFLAGS -fd" 5737 5867 5738 5738 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -fd" >&5 5739 5739 - $as_echo_n "checking if $CC supports -fd... " >&6; } 5868 5868 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -fd" >&5 5869 5869 + printf %s "checking if $CC supports -fd... " >&6; } 5740 5870 cacheid=xorg_cv_cc_flag__fd 5741 5741 - if eval \${$cacheid+:} false; then : 5742 5742 - $as_echo_n "(cached) " >&6 5743 5743 - else 5871 5871 + if eval test \${$cacheid+y} 5872 5872 + then : 5873 5873 + printf %s "(cached) " >&6 5874 5874 + else $as_nop 5744 5875 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5745 5876 /* end confdefs.h. */ 5746 5877 int i; 5747 5878 int 5748 5748 - main () 5879 5879 + main (void) 5749 5880 { 5750 5881 5751 5882 ; 5752 5883 return 0; 5753 5884 } 5754 5885 _ACEOF 5755 5755 - if ac_fn_c_try_link "$LINENO"; then : 5886 5886 + if ac_fn_c_try_link "$LINENO" 5887 5887 + then : 5756 5888 eval $cacheid=yes 5757 5757 - else 5889 5889 + else $as_nop 5758 5890 eval $cacheid=no 5759 5891 fi 5760 5760 - rm -f core conftest.err conftest.$ac_objext \ 5892 5892 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5761 5893 conftest$ac_exeext conftest.$ac_ext 5762 5894 fi 5763 5895 ··· 5765 5897 CFLAGS="$xorg_testset_save_CFLAGS" 5766 5898 5767 5899 eval supported=\$$cacheid 5768 5768 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5769 5769 - $as_echo "$supported" >&6; } 5900 5900 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5901 5901 + printf "%s\n" "$supported" >&6; } 5770 5902 if test "$supported" = "yes" ; then 5771 5903 BASE_CFLAGS="$BASE_CFLAGS -fd" 5772 5904 found="yes" ··· 5791 5923 5792 5924 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5793 5925 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5794 5794 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5795 5795 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5796 5796 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5797 5797 - $as_echo_n "(cached) " >&6 5798 5798 - else 5926 5926 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5927 5927 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5928 5928 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 5929 5929 + then : 5930 5930 + printf %s "(cached) " >&6 5931 5931 + else $as_nop 5799 5932 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5800 5933 /* end confdefs.h. */ 5801 5934 int i; 5802 5935 _ACEOF 5803 5803 - if ac_fn_c_try_compile "$LINENO"; then : 5936 5936 + if ac_fn_c_try_compile "$LINENO" 5937 5937 + then : 5804 5938 xorg_cv_cc_flag_unknown_warning_option=yes 5805 5805 - else 5939 5939 + else $as_nop 5806 5940 xorg_cv_cc_flag_unknown_warning_option=no 5807 5941 fi 5808 5808 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5942 5942 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5809 5943 fi 5810 5810 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5811 5811 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5944 5944 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5945 5945 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5812 5946 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5813 5947 CFLAGS="$xorg_testset_save_CFLAGS" 5814 5948 fi ··· 5818 5952 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5819 5953 fi 5820 5954 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5821 5821 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5822 5822 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5823 5823 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5824 5824 - $as_echo_n "(cached) " >&6 5825 5825 - else 5955 5955 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5956 5956 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5957 5957 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 5958 5958 + then : 5959 5959 + printf %s "(cached) " >&6 5960 5960 + else $as_nop 5826 5961 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5827 5962 /* end confdefs.h. */ 5828 5963 int i; 5829 5964 _ACEOF 5830 5830 - if ac_fn_c_try_compile "$LINENO"; then : 5965 5965 + if ac_fn_c_try_compile "$LINENO" 5966 5966 + then : 5831 5967 xorg_cv_cc_flag_unused_command_line_argument=yes 5832 5832 - else 5968 5968 + else $as_nop 5833 5969 xorg_cv_cc_flag_unused_command_line_argument=no 5834 5970 fi 5835 5835 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5971 5971 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5836 5972 fi 5837 5837 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5838 5838 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5973 5973 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5974 5974 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5839 5975 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5840 5976 CFLAGS="$xorg_testset_save_CFLAGS" 5841 5977 fi ··· 5853 5989 5854 5990 CFLAGS="$CFLAGS -Wdeclaration-after-statement" 5855 5991 5856 5856 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wdeclaration-after-statement" >&5 5857 5857 - $as_echo_n "checking if $CC supports -Wdeclaration-after-statement... " >&6; } 5992 5992 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wdeclaration-after-statement" >&5 5993 5993 + printf %s "checking if $CC supports -Wdeclaration-after-statement... " >&6; } 5858 5994 cacheid=xorg_cv_cc_flag__Wdeclaration_after_statement 5859 5859 - if eval \${$cacheid+:} false; then : 5860 5860 - $as_echo_n "(cached) " >&6 5861 5861 - else 5995 5995 + if eval test \${$cacheid+y} 5996 5996 + then : 5997 5997 + printf %s "(cached) " >&6 5998 5998 + else $as_nop 5862 5999 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5863 6000 /* end confdefs.h. */ 5864 6001 int i; 5865 6002 int 5866 5866 - main () 6003 6003 + main (void) 5867 6004 { 5868 6005 5869 6006 ; 5870 6007 return 0; 5871 6008 } 5872 6009 _ACEOF 5873 5873 - if ac_fn_c_try_link "$LINENO"; then : 6010 6010 + if ac_fn_c_try_link "$LINENO" 6011 6011 + then : 5874 6012 eval $cacheid=yes 5875 5875 - else 6013 6013 + else $as_nop 5876 6014 eval $cacheid=no 5877 6015 fi 5878 5878 - rm -f core conftest.err conftest.$ac_objext \ 6016 6016 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 5879 6017 conftest$ac_exeext conftest.$ac_ext 5880 6018 fi 5881 6019 ··· 5883 6021 CFLAGS="$xorg_testset_save_CFLAGS" 5884 6022 5885 6023 eval supported=\$$cacheid 5886 5886 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 5887 5887 - $as_echo "$supported" >&6; } 6024 6024 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6025 6025 + printf "%s\n" "$supported" >&6; } 5888 6026 if test "$supported" = "yes" ; then 5889 6027 BASE_CFLAGS="$BASE_CFLAGS -Wdeclaration-after-statement" 5890 6028 found="yes" ··· 5913 6051 5914 6052 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 5915 6053 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5916 5916 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 5917 5917 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 5918 5918 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 5919 5919 - $as_echo_n "(cached) " >&6 5920 5920 - else 6054 6054 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6055 6055 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6056 6056 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6057 6057 + then : 6058 6058 + printf %s "(cached) " >&6 6059 6059 + else $as_nop 5921 6060 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5922 6061 /* end confdefs.h. */ 5923 6062 int i; 5924 6063 _ACEOF 5925 5925 - if ac_fn_c_try_compile "$LINENO"; then : 6064 6064 + if ac_fn_c_try_compile "$LINENO" 6065 6065 + then : 5926 6066 xorg_cv_cc_flag_unknown_warning_option=yes 5927 5927 - else 6067 6067 + else $as_nop 5928 6068 xorg_cv_cc_flag_unknown_warning_option=no 5929 6069 fi 5930 5930 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6070 6070 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5931 6071 fi 5932 5932 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 5933 5933 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6072 6072 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6073 6073 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 5934 6074 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 5935 6075 CFLAGS="$xorg_testset_save_CFLAGS" 5936 6076 fi ··· 5940 6080 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 5941 6081 fi 5942 6082 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 5943 5943 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 5944 5944 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 5945 5945 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 5946 5946 - $as_echo_n "(cached) " >&6 5947 5947 - else 6083 6083 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6084 6084 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6085 6085 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6086 6086 + then : 6087 6087 + printf %s "(cached) " >&6 6088 6088 + else $as_nop 5948 6089 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5949 6090 /* end confdefs.h. */ 5950 6091 int i; 5951 6092 _ACEOF 5952 5952 - if ac_fn_c_try_compile "$LINENO"; then : 6093 6093 + if ac_fn_c_try_compile "$LINENO" 6094 6094 + then : 5953 6095 xorg_cv_cc_flag_unused_command_line_argument=yes 5954 5954 - else 6096 6096 + else $as_nop 5955 6097 xorg_cv_cc_flag_unused_command_line_argument=no 5956 6098 fi 5957 5957 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6099 6099 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 5958 6100 fi 5959 5959 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 5960 5960 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6101 6101 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6102 6102 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 5961 6103 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 5962 6104 CFLAGS="$xorg_testset_save_CFLAGS" 5963 6105 fi ··· 5975 6117 5976 6118 CFLAGS="$CFLAGS -Wunused" 5977 6119 5978 5978 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wunused" >&5 5979 5979 - $as_echo_n "checking if $CC supports -Wunused... " >&6; } 6120 6120 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wunused" >&5 6121 6121 + printf %s "checking if $CC supports -Wunused... " >&6; } 5980 6122 cacheid=xorg_cv_cc_flag__Wunused 5981 5981 - if eval \${$cacheid+:} false; then : 5982 5982 - $as_echo_n "(cached) " >&6 5983 5983 - else 6123 6123 + if eval test \${$cacheid+y} 6124 6124 + then : 6125 6125 + printf %s "(cached) " >&6 6126 6126 + else $as_nop 5984 6127 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5985 6128 /* end confdefs.h. */ 5986 6129 int i; 5987 6130 int 5988 5988 - main () 6131 6131 + main (void) 5989 6132 { 5990 6133 5991 6134 ; 5992 6135 return 0; 5993 6136 } 5994 6137 _ACEOF 5995 5995 - if ac_fn_c_try_link "$LINENO"; then : 6138 6138 + if ac_fn_c_try_link "$LINENO" 6139 6139 + then : 5996 6140 eval $cacheid=yes 5997 5997 - else 6141 6141 + else $as_nop 5998 6142 eval $cacheid=no 5999 6143 fi 6000 6000 - rm -f core conftest.err conftest.$ac_objext \ 6144 6144 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6001 6145 conftest$ac_exeext conftest.$ac_ext 6002 6146 fi 6003 6147 ··· 6005 6149 CFLAGS="$xorg_testset_save_CFLAGS" 6006 6150 6007 6151 eval supported=\$$cacheid 6008 6008 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6009 6009 - $as_echo "$supported" >&6; } 6152 6152 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6153 6153 + printf "%s\n" "$supported" >&6; } 6010 6154 if test "$supported" = "yes" ; then 6011 6155 BASE_CFLAGS="$BASE_CFLAGS -Wunused" 6012 6156 found="yes" ··· 6031 6175 6032 6176 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6033 6177 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6034 6034 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6035 6035 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6036 6036 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6037 6037 - $as_echo_n "(cached) " >&6 6038 6038 - else 6178 6178 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6179 6179 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6180 6180 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6181 6181 + then : 6182 6182 + printf %s "(cached) " >&6 6183 6183 + else $as_nop 6039 6184 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6040 6185 /* end confdefs.h. */ 6041 6186 int i; 6042 6187 _ACEOF 6043 6043 - if ac_fn_c_try_compile "$LINENO"; then : 6188 6188 + if ac_fn_c_try_compile "$LINENO" 6189 6189 + then : 6044 6190 xorg_cv_cc_flag_unknown_warning_option=yes 6045 6045 - else 6191 6191 + else $as_nop 6046 6192 xorg_cv_cc_flag_unknown_warning_option=no 6047 6193 fi 6048 6048 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6194 6194 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6049 6195 fi 6050 6050 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6051 6051 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6196 6196 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6197 6197 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6052 6198 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6053 6199 CFLAGS="$xorg_testset_save_CFLAGS" 6054 6200 fi ··· 6058 6204 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6059 6205 fi 6060 6206 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6061 6061 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6062 6062 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6063 6063 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6064 6064 - $as_echo_n "(cached) " >&6 6065 6065 - else 6207 6207 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6208 6208 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6209 6209 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6210 6210 + then : 6211 6211 + printf %s "(cached) " >&6 6212 6212 + else $as_nop 6066 6213 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6067 6214 /* end confdefs.h. */ 6068 6215 int i; 6069 6216 _ACEOF 6070 6070 - if ac_fn_c_try_compile "$LINENO"; then : 6217 6217 + if ac_fn_c_try_compile "$LINENO" 6218 6218 + then : 6071 6219 xorg_cv_cc_flag_unused_command_line_argument=yes 6072 6072 - else 6220 6220 + else $as_nop 6073 6221 xorg_cv_cc_flag_unused_command_line_argument=no 6074 6222 fi 6075 6075 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6223 6223 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6076 6224 fi 6077 6077 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6078 6078 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6225 6225 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6226 6226 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6079 6227 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6080 6228 CFLAGS="$xorg_testset_save_CFLAGS" 6081 6229 fi ··· 6093 6241 6094 6242 CFLAGS="$CFLAGS -Wuninitialized" 6095 6243 6096 6096 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wuninitialized" >&5 6097 6097 - $as_echo_n "checking if $CC supports -Wuninitialized... " >&6; } 6244 6244 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wuninitialized" >&5 6245 6245 + printf %s "checking if $CC supports -Wuninitialized... " >&6; } 6098 6246 cacheid=xorg_cv_cc_flag__Wuninitialized 6099 6099 - if eval \${$cacheid+:} false; then : 6100 6100 - $as_echo_n "(cached) " >&6 6101 6101 - else 6247 6247 + if eval test \${$cacheid+y} 6248 6248 + then : 6249 6249 + printf %s "(cached) " >&6 6250 6250 + else $as_nop 6102 6251 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6103 6252 /* end confdefs.h. */ 6104 6253 int i; 6105 6254 int 6106 6106 - main () 6255 6255 + main (void) 6107 6256 { 6108 6257 6109 6258 ; 6110 6259 return 0; 6111 6260 } 6112 6261 _ACEOF 6113 6113 - if ac_fn_c_try_link "$LINENO"; then : 6262 6262 + if ac_fn_c_try_link "$LINENO" 6263 6263 + then : 6114 6264 eval $cacheid=yes 6115 6115 - else 6265 6265 + else $as_nop 6116 6266 eval $cacheid=no 6117 6267 fi 6118 6118 - rm -f core conftest.err conftest.$ac_objext \ 6268 6268 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6119 6269 conftest$ac_exeext conftest.$ac_ext 6120 6270 fi 6121 6271 ··· 6123 6273 CFLAGS="$xorg_testset_save_CFLAGS" 6124 6274 6125 6275 eval supported=\$$cacheid 6126 6126 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6127 6127 - $as_echo "$supported" >&6; } 6276 6276 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6277 6277 + printf "%s\n" "$supported" >&6; } 6128 6278 if test "$supported" = "yes" ; then 6129 6279 BASE_CFLAGS="$BASE_CFLAGS -Wuninitialized" 6130 6280 found="yes" ··· 6149 6299 6150 6300 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6151 6301 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6152 6152 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6153 6153 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6154 6154 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6155 6155 - $as_echo_n "(cached) " >&6 6156 6156 - else 6302 6302 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6303 6303 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6304 6304 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6305 6305 + then : 6306 6306 + printf %s "(cached) " >&6 6307 6307 + else $as_nop 6157 6308 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6158 6309 /* end confdefs.h. */ 6159 6310 int i; 6160 6311 _ACEOF 6161 6161 - if ac_fn_c_try_compile "$LINENO"; then : 6312 6312 + if ac_fn_c_try_compile "$LINENO" 6313 6313 + then : 6162 6314 xorg_cv_cc_flag_unknown_warning_option=yes 6163 6163 - else 6315 6315 + else $as_nop 6164 6316 xorg_cv_cc_flag_unknown_warning_option=no 6165 6317 fi 6166 6166 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6318 6318 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6167 6319 fi 6168 6168 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6169 6169 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6320 6320 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6321 6321 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6170 6322 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6171 6323 CFLAGS="$xorg_testset_save_CFLAGS" 6172 6324 fi ··· 6176 6328 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6177 6329 fi 6178 6330 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6179 6179 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6180 6180 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6181 6181 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6182 6182 - $as_echo_n "(cached) " >&6 6183 6183 - else 6331 6331 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6332 6332 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6333 6333 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6334 6334 + then : 6335 6335 + printf %s "(cached) " >&6 6336 6336 + else $as_nop 6184 6337 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6185 6338 /* end confdefs.h. */ 6186 6339 int i; 6187 6340 _ACEOF 6188 6188 - if ac_fn_c_try_compile "$LINENO"; then : 6341 6341 + if ac_fn_c_try_compile "$LINENO" 6342 6342 + then : 6189 6343 xorg_cv_cc_flag_unused_command_line_argument=yes 6190 6190 - else 6344 6344 + else $as_nop 6191 6345 xorg_cv_cc_flag_unused_command_line_argument=no 6192 6346 fi 6193 6193 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6347 6347 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6194 6348 fi 6195 6195 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6196 6196 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6349 6349 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6350 6350 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6197 6351 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6198 6352 CFLAGS="$xorg_testset_save_CFLAGS" 6199 6353 fi ··· 6211 6365 6212 6366 CFLAGS="$CFLAGS -Wshadow" 6213 6367 6214 6214 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wshadow" >&5 6215 6215 - $as_echo_n "checking if $CC supports -Wshadow... " >&6; } 6368 6368 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wshadow" >&5 6369 6369 + printf %s "checking if $CC supports -Wshadow... " >&6; } 6216 6370 cacheid=xorg_cv_cc_flag__Wshadow 6217 6217 - if eval \${$cacheid+:} false; then : 6218 6218 - $as_echo_n "(cached) " >&6 6219 6219 - else 6371 6371 + if eval test \${$cacheid+y} 6372 6372 + then : 6373 6373 + printf %s "(cached) " >&6 6374 6374 + else $as_nop 6220 6375 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6221 6376 /* end confdefs.h. */ 6222 6377 int i; 6223 6378 int 6224 6224 - main () 6379 6379 + main (void) 6225 6380 { 6226 6381 6227 6382 ; 6228 6383 return 0; 6229 6384 } 6230 6385 _ACEOF 6231 6231 - if ac_fn_c_try_link "$LINENO"; then : 6386 6386 + if ac_fn_c_try_link "$LINENO" 6387 6387 + then : 6232 6388 eval $cacheid=yes 6233 6233 - else 6389 6389 + else $as_nop 6234 6390 eval $cacheid=no 6235 6391 fi 6236 6236 - rm -f core conftest.err conftest.$ac_objext \ 6392 6392 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6237 6393 conftest$ac_exeext conftest.$ac_ext 6238 6394 fi 6239 6395 ··· 6241 6397 CFLAGS="$xorg_testset_save_CFLAGS" 6242 6398 6243 6399 eval supported=\$$cacheid 6244 6244 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6245 6245 - $as_echo "$supported" >&6; } 6400 6400 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6401 6401 + printf "%s\n" "$supported" >&6; } 6246 6402 if test "$supported" = "yes" ; then 6247 6403 BASE_CFLAGS="$BASE_CFLAGS -Wshadow" 6248 6404 found="yes" ··· 6267 6423 6268 6424 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6269 6425 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6270 6270 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6271 6271 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6272 6272 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6273 6273 - $as_echo_n "(cached) " >&6 6274 6274 - else 6426 6426 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6427 6427 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6428 6428 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6429 6429 + then : 6430 6430 + printf %s "(cached) " >&6 6431 6431 + else $as_nop 6275 6432 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6276 6433 /* end confdefs.h. */ 6277 6434 int i; 6278 6435 _ACEOF 6279 6279 - if ac_fn_c_try_compile "$LINENO"; then : 6436 6436 + if ac_fn_c_try_compile "$LINENO" 6437 6437 + then : 6280 6438 xorg_cv_cc_flag_unknown_warning_option=yes 6281 6281 - else 6439 6439 + else $as_nop 6282 6440 xorg_cv_cc_flag_unknown_warning_option=no 6283 6441 fi 6284 6284 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6442 6442 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6285 6443 fi 6286 6286 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6287 6287 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6444 6444 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6445 6445 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6288 6446 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6289 6447 CFLAGS="$xorg_testset_save_CFLAGS" 6290 6448 fi ··· 6294 6452 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6295 6453 fi 6296 6454 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6297 6297 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6298 6298 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6299 6299 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6300 6300 - $as_echo_n "(cached) " >&6 6301 6301 - else 6455 6455 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6456 6456 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6457 6457 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6458 6458 + then : 6459 6459 + printf %s "(cached) " >&6 6460 6460 + else $as_nop 6302 6461 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6303 6462 /* end confdefs.h. */ 6304 6463 int i; 6305 6464 _ACEOF 6306 6306 - if ac_fn_c_try_compile "$LINENO"; then : 6465 6465 + if ac_fn_c_try_compile "$LINENO" 6466 6466 + then : 6307 6467 xorg_cv_cc_flag_unused_command_line_argument=yes 6308 6308 - else 6468 6468 + else $as_nop 6309 6469 xorg_cv_cc_flag_unused_command_line_argument=no 6310 6470 fi 6311 6311 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6471 6471 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6312 6472 fi 6313 6313 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6314 6314 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6473 6473 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6474 6474 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6315 6475 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6316 6476 CFLAGS="$xorg_testset_save_CFLAGS" 6317 6477 fi ··· 6329 6489 6330 6490 CFLAGS="$CFLAGS -Wmissing-noreturn" 6331 6491 6332 6332 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-noreturn" >&5 6333 6333 - $as_echo_n "checking if $CC supports -Wmissing-noreturn... " >&6; } 6492 6492 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-noreturn" >&5 6493 6493 + printf %s "checking if $CC supports -Wmissing-noreturn... " >&6; } 6334 6494 cacheid=xorg_cv_cc_flag__Wmissing_noreturn 6335 6335 - if eval \${$cacheid+:} false; then : 6336 6336 - $as_echo_n "(cached) " >&6 6337 6337 - else 6495 6495 + if eval test \${$cacheid+y} 6496 6496 + then : 6497 6497 + printf %s "(cached) " >&6 6498 6498 + else $as_nop 6338 6499 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6339 6500 /* end confdefs.h. */ 6340 6501 int i; 6341 6502 int 6342 6342 - main () 6503 6503 + main (void) 6343 6504 { 6344 6505 6345 6506 ; 6346 6507 return 0; 6347 6508 } 6348 6509 _ACEOF 6349 6349 - if ac_fn_c_try_link "$LINENO"; then : 6510 6510 + if ac_fn_c_try_link "$LINENO" 6511 6511 + then : 6350 6512 eval $cacheid=yes 6351 6351 - else 6513 6513 + else $as_nop 6352 6514 eval $cacheid=no 6353 6515 fi 6354 6354 - rm -f core conftest.err conftest.$ac_objext \ 6516 6516 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6355 6517 conftest$ac_exeext conftest.$ac_ext 6356 6518 fi 6357 6519 ··· 6359 6521 CFLAGS="$xorg_testset_save_CFLAGS" 6360 6522 6361 6523 eval supported=\$$cacheid 6362 6362 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6363 6363 - $as_echo "$supported" >&6; } 6524 6524 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6525 6525 + printf "%s\n" "$supported" >&6; } 6364 6526 if test "$supported" = "yes" ; then 6365 6527 BASE_CFLAGS="$BASE_CFLAGS -Wmissing-noreturn" 6366 6528 found="yes" ··· 6385 6547 6386 6548 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6387 6549 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6388 6388 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6389 6389 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6390 6390 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6391 6391 - $as_echo_n "(cached) " >&6 6392 6392 - else 6550 6550 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6551 6551 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6552 6552 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6553 6553 + then : 6554 6554 + printf %s "(cached) " >&6 6555 6555 + else $as_nop 6393 6556 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6394 6557 /* end confdefs.h. */ 6395 6558 int i; 6396 6559 _ACEOF 6397 6397 - if ac_fn_c_try_compile "$LINENO"; then : 6560 6560 + if ac_fn_c_try_compile "$LINENO" 6561 6561 + then : 6398 6562 xorg_cv_cc_flag_unknown_warning_option=yes 6399 6399 - else 6563 6563 + else $as_nop 6400 6564 xorg_cv_cc_flag_unknown_warning_option=no 6401 6565 fi 6402 6402 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6566 6566 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6403 6567 fi 6404 6404 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6405 6405 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6568 6568 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6569 6569 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6406 6570 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6407 6571 CFLAGS="$xorg_testset_save_CFLAGS" 6408 6572 fi ··· 6412 6576 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6413 6577 fi 6414 6578 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6415 6415 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6416 6416 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6417 6417 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6418 6418 - $as_echo_n "(cached) " >&6 6419 6419 - else 6579 6579 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6580 6580 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6581 6581 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6582 6582 + then : 6583 6583 + printf %s "(cached) " >&6 6584 6584 + else $as_nop 6420 6585 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6421 6586 /* end confdefs.h. */ 6422 6587 int i; 6423 6588 _ACEOF 6424 6424 - if ac_fn_c_try_compile "$LINENO"; then : 6589 6589 + if ac_fn_c_try_compile "$LINENO" 6590 6590 + then : 6425 6591 xorg_cv_cc_flag_unused_command_line_argument=yes 6426 6426 - else 6592 6592 + else $as_nop 6427 6593 xorg_cv_cc_flag_unused_command_line_argument=no 6428 6594 fi 6429 6429 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6595 6595 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6430 6596 fi 6431 6431 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6432 6432 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6597 6597 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6598 6598 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6433 6599 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6434 6600 CFLAGS="$xorg_testset_save_CFLAGS" 6435 6601 fi ··· 6447 6613 6448 6614 CFLAGS="$CFLAGS -Wmissing-format-attribute" 6449 6615 6450 6450 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-format-attribute" >&5 6451 6451 - $as_echo_n "checking if $CC supports -Wmissing-format-attribute... " >&6; } 6616 6616 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-format-attribute" >&5 6617 6617 + printf %s "checking if $CC supports -Wmissing-format-attribute... " >&6; } 6452 6618 cacheid=xorg_cv_cc_flag__Wmissing_format_attribute 6453 6453 - if eval \${$cacheid+:} false; then : 6454 6454 - $as_echo_n "(cached) " >&6 6455 6455 - else 6619 6619 + if eval test \${$cacheid+y} 6620 6620 + then : 6621 6621 + printf %s "(cached) " >&6 6622 6622 + else $as_nop 6456 6623 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6457 6624 /* end confdefs.h. */ 6458 6625 int i; 6459 6626 int 6460 6460 - main () 6627 6627 + main (void) 6461 6628 { 6462 6629 6463 6630 ; 6464 6631 return 0; 6465 6632 } 6466 6633 _ACEOF 6467 6467 - if ac_fn_c_try_link "$LINENO"; then : 6634 6634 + if ac_fn_c_try_link "$LINENO" 6635 6635 + then : 6468 6636 eval $cacheid=yes 6469 6469 - else 6637 6637 + else $as_nop 6470 6638 eval $cacheid=no 6471 6639 fi 6472 6472 - rm -f core conftest.err conftest.$ac_objext \ 6640 6640 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6473 6641 conftest$ac_exeext conftest.$ac_ext 6474 6642 fi 6475 6643 ··· 6477 6645 CFLAGS="$xorg_testset_save_CFLAGS" 6478 6646 6479 6647 eval supported=\$$cacheid 6480 6480 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6481 6481 - $as_echo "$supported" >&6; } 6648 6648 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6649 6649 + printf "%s\n" "$supported" >&6; } 6482 6650 if test "$supported" = "yes" ; then 6483 6651 BASE_CFLAGS="$BASE_CFLAGS -Wmissing-format-attribute" 6484 6652 found="yes" ··· 6504 6672 6505 6673 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6506 6674 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6507 6507 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6508 6508 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6509 6509 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6510 6510 - $as_echo_n "(cached) " >&6 6511 6511 - else 6675 6675 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6676 6676 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6677 6677 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6678 6678 + then : 6679 6679 + printf %s "(cached) " >&6 6680 6680 + else $as_nop 6512 6681 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6513 6682 /* end confdefs.h. */ 6514 6683 int i; 6515 6684 _ACEOF 6516 6516 - if ac_fn_c_try_compile "$LINENO"; then : 6685 6685 + if ac_fn_c_try_compile "$LINENO" 6686 6686 + then : 6517 6687 xorg_cv_cc_flag_unknown_warning_option=yes 6518 6518 - else 6688 6688 + else $as_nop 6519 6689 xorg_cv_cc_flag_unknown_warning_option=no 6520 6690 fi 6521 6521 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6691 6691 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6522 6692 fi 6523 6523 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6524 6524 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6693 6693 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6694 6694 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6525 6695 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6526 6696 CFLAGS="$xorg_testset_save_CFLAGS" 6527 6697 fi ··· 6531 6701 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6532 6702 fi 6533 6703 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6534 6534 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6535 6535 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6536 6536 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6537 6537 - $as_echo_n "(cached) " >&6 6538 6538 - else 6704 6704 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6705 6705 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6706 6706 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6707 6707 + then : 6708 6708 + printf %s "(cached) " >&6 6709 6709 + else $as_nop 6539 6710 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6540 6711 /* end confdefs.h. */ 6541 6712 int i; 6542 6713 _ACEOF 6543 6543 - if ac_fn_c_try_compile "$LINENO"; then : 6714 6714 + if ac_fn_c_try_compile "$LINENO" 6715 6715 + then : 6544 6716 xorg_cv_cc_flag_unused_command_line_argument=yes 6545 6545 - else 6717 6717 + else $as_nop 6546 6718 xorg_cv_cc_flag_unused_command_line_argument=no 6547 6719 fi 6548 6548 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6720 6720 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6549 6721 fi 6550 6550 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6551 6551 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6722 6722 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6723 6723 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6552 6724 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6553 6725 CFLAGS="$xorg_testset_save_CFLAGS" 6554 6726 fi ··· 6566 6738 6567 6739 CFLAGS="$CFLAGS -Wlogical-op" 6568 6740 6569 6569 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wlogical-op" >&5 6570 6570 - $as_echo_n "checking if $CC supports -Wlogical-op... " >&6; } 6741 6741 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wlogical-op" >&5 6742 6742 + printf %s "checking if $CC supports -Wlogical-op... " >&6; } 6571 6743 cacheid=xorg_cv_cc_flag__Wlogical_op 6572 6572 - if eval \${$cacheid+:} false; then : 6573 6573 - $as_echo_n "(cached) " >&6 6574 6574 - else 6744 6744 + if eval test \${$cacheid+y} 6745 6745 + then : 6746 6746 + printf %s "(cached) " >&6 6747 6747 + else $as_nop 6575 6748 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6576 6749 /* end confdefs.h. */ 6577 6750 int i; 6578 6751 int 6579 6579 - main () 6752 6752 + main (void) 6580 6753 { 6581 6754 6582 6755 ; 6583 6756 return 0; 6584 6757 } 6585 6758 _ACEOF 6586 6586 - if ac_fn_c_try_link "$LINENO"; then : 6759 6759 + if ac_fn_c_try_link "$LINENO" 6760 6760 + then : 6587 6761 eval $cacheid=yes 6588 6588 - else 6762 6762 + else $as_nop 6589 6763 eval $cacheid=no 6590 6764 fi 6591 6591 - rm -f core conftest.err conftest.$ac_objext \ 6765 6765 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6592 6766 conftest$ac_exeext conftest.$ac_ext 6593 6767 fi 6594 6768 ··· 6596 6770 CFLAGS="$xorg_testset_save_CFLAGS" 6597 6771 6598 6772 eval supported=\$$cacheid 6599 6599 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6600 6600 - $as_echo "$supported" >&6; } 6773 6773 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6774 6774 + printf "%s\n" "$supported" >&6; } 6601 6775 if test "$supported" = "yes" ; then 6602 6776 BASE_CFLAGS="$BASE_CFLAGS -Wlogical-op" 6603 6777 found="yes" ··· 6613 6787 # XORG_TESTSET_CFLAG([[BASE_]PREFIX[FLAGS]], [-Wcast-align]) 6614 6788 # XORG_TESTSET_CFLAG([[BASE_]PREFIX[FLAGS]], [-Wcast-qual]) 6615 6789 6616 6616 - # Turn some warnings into errors, so we don't accidently get successful builds 6790 6790 + # Turn some warnings into errors, so we don't accidentally get successful builds 6617 6791 # when there are problems that should be fixed. 6618 6792 6619 6793 if test "x$SELECTIVE_WERROR" = "xyes" ; then ··· 6634 6808 6635 6809 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6636 6810 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6637 6637 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6638 6638 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6639 6639 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6640 6640 - $as_echo_n "(cached) " >&6 6641 6641 - else 6811 6811 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6812 6812 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6813 6813 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6814 6814 + then : 6815 6815 + printf %s "(cached) " >&6 6816 6816 + else $as_nop 6642 6817 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6643 6818 /* end confdefs.h. */ 6644 6819 int i; 6645 6820 _ACEOF 6646 6646 - if ac_fn_c_try_compile "$LINENO"; then : 6821 6821 + if ac_fn_c_try_compile "$LINENO" 6822 6822 + then : 6647 6823 xorg_cv_cc_flag_unknown_warning_option=yes 6648 6648 - else 6824 6824 + else $as_nop 6649 6825 xorg_cv_cc_flag_unknown_warning_option=no 6650 6826 fi 6651 6651 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6827 6827 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6652 6828 fi 6653 6653 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6654 6654 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6829 6829 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6830 6830 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6655 6831 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6656 6832 CFLAGS="$xorg_testset_save_CFLAGS" 6657 6833 fi ··· 6661 6837 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6662 6838 fi 6663 6839 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6664 6664 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6665 6665 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6666 6666 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6667 6667 - $as_echo_n "(cached) " >&6 6668 6668 - else 6840 6840 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6841 6841 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6842 6842 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 6843 6843 + then : 6844 6844 + printf %s "(cached) " >&6 6845 6845 + else $as_nop 6669 6846 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6670 6847 /* end confdefs.h. */ 6671 6848 int i; 6672 6849 _ACEOF 6673 6673 - if ac_fn_c_try_compile "$LINENO"; then : 6850 6850 + if ac_fn_c_try_compile "$LINENO" 6851 6851 + then : 6674 6852 xorg_cv_cc_flag_unused_command_line_argument=yes 6675 6675 - else 6853 6853 + else $as_nop 6676 6854 xorg_cv_cc_flag_unused_command_line_argument=no 6677 6855 fi 6678 6678 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6856 6856 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6679 6857 fi 6680 6680 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6681 6681 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6858 6858 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6859 6859 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6682 6860 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6683 6861 CFLAGS="$xorg_testset_save_CFLAGS" 6684 6862 fi ··· 6696 6874 6697 6875 CFLAGS="$CFLAGS -Werror=implicit" 6698 6876 6699 6699 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=implicit" >&5 6700 6700 - $as_echo_n "checking if $CC supports -Werror=implicit... " >&6; } 6877 6877 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=implicit" >&5 6878 6878 + printf %s "checking if $CC supports -Werror=implicit... " >&6; } 6701 6879 cacheid=xorg_cv_cc_flag__Werror_implicit 6702 6702 - if eval \${$cacheid+:} false; then : 6703 6703 - $as_echo_n "(cached) " >&6 6704 6704 - else 6880 6880 + if eval test \${$cacheid+y} 6881 6881 + then : 6882 6882 + printf %s "(cached) " >&6 6883 6883 + else $as_nop 6705 6884 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6706 6885 /* end confdefs.h. */ 6707 6886 int i; 6708 6887 int 6709 6709 - main () 6888 6888 + main (void) 6710 6889 { 6711 6890 6712 6891 ; 6713 6892 return 0; 6714 6893 } 6715 6894 _ACEOF 6716 6716 - if ac_fn_c_try_link "$LINENO"; then : 6895 6895 + if ac_fn_c_try_link "$LINENO" 6896 6896 + then : 6717 6897 eval $cacheid=yes 6718 6718 - else 6898 6898 + else $as_nop 6719 6899 eval $cacheid=no 6720 6900 fi 6721 6721 - rm -f core conftest.err conftest.$ac_objext \ 6901 6901 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6722 6902 conftest$ac_exeext conftest.$ac_ext 6723 6903 fi 6724 6904 ··· 6726 6906 CFLAGS="$xorg_testset_save_CFLAGS" 6727 6907 6728 6908 eval supported=\$$cacheid 6729 6729 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6730 6730 - $as_echo "$supported" >&6; } 6909 6909 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6910 6910 + printf "%s\n" "$supported" >&6; } 6731 6911 if test "$supported" = "yes" ; then 6732 6912 BASE_CFLAGS="$BASE_CFLAGS -Werror=implicit" 6733 6913 found="yes" ··· 6745 6925 6746 6926 CFLAGS="$CFLAGS -errwarn=E_NO_EXPLICIT_TYPE_GIVEN -errwarn=E_NO_IMPLICIT_DECL_ALLOWED" 6747 6927 6748 6748 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn=E_NO_EXPLICIT_TYPE_GIVEN -errwarn=E_NO_IMPLICIT_DECL_ALLOWED" >&5 6749 6749 - $as_echo_n "checking if $CC supports -errwarn=E_NO_EXPLICIT_TYPE_GIVEN -errwarn=E_NO_IMPLICIT_DECL_ALLOWED... " >&6; } 6928 6928 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn=E_NO_EXPLICIT_TYPE_GIVEN -errwarn=E_NO_IMPLICIT_DECL_ALLOWED" >&5 6929 6929 + printf %s "checking if $CC supports -errwarn=E_NO_EXPLICIT_TYPE_GIVEN -errwarn=E_NO_IMPLICIT_DECL_ALLOWED... " >&6; } 6750 6930 cacheid=xorg_cv_cc_flag__errwarn_E_NO_EXPLICIT_TYPE_GIVEN__errwarn_E_NO_IMPLICIT_DECL_ALLOWED 6751 6751 - if eval \${$cacheid+:} false; then : 6752 6752 - $as_echo_n "(cached) " >&6 6753 6753 - else 6931 6931 + if eval test \${$cacheid+y} 6932 6932 + then : 6933 6933 + printf %s "(cached) " >&6 6934 6934 + else $as_nop 6754 6935 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6755 6936 /* end confdefs.h. */ 6756 6937 int i; 6757 6938 int 6758 6758 - main () 6939 6939 + main (void) 6759 6940 { 6760 6941 6761 6942 ; 6762 6943 return 0; 6763 6944 } 6764 6945 _ACEOF 6765 6765 - if ac_fn_c_try_link "$LINENO"; then : 6946 6946 + if ac_fn_c_try_link "$LINENO" 6947 6947 + then : 6766 6948 eval $cacheid=yes 6767 6767 - else 6949 6949 + else $as_nop 6768 6950 eval $cacheid=no 6769 6951 fi 6770 6770 - rm -f core conftest.err conftest.$ac_objext \ 6952 6952 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6771 6953 conftest$ac_exeext conftest.$ac_ext 6772 6954 fi 6773 6955 ··· 6775 6957 CFLAGS="$xorg_testset_save_CFLAGS" 6776 6958 6777 6959 eval supported=\$$cacheid 6778 6778 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6779 6779 - $as_echo "$supported" >&6; } 6960 6960 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6961 6961 + printf "%s\n" "$supported" >&6; } 6780 6962 if test "$supported" = "yes" ; then 6781 6963 BASE_CFLAGS="$BASE_CFLAGS -errwarn=E_NO_EXPLICIT_TYPE_GIVEN -errwarn=E_NO_IMPLICIT_DECL_ALLOWED" 6782 6964 found="yes" ··· 6801 6983 6802 6984 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6803 6985 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6804 6804 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6805 6805 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6806 6806 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6807 6807 - $as_echo_n "(cached) " >&6 6808 6808 - else 6986 6986 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6987 6987 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6988 6988 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 6989 6989 + then : 6990 6990 + printf %s "(cached) " >&6 6991 6991 + else $as_nop 6809 6992 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6810 6993 /* end confdefs.h. */ 6811 6994 int i; 6812 6995 _ACEOF 6813 6813 - if ac_fn_c_try_compile "$LINENO"; then : 6996 6996 + if ac_fn_c_try_compile "$LINENO" 6997 6997 + then : 6814 6998 xorg_cv_cc_flag_unknown_warning_option=yes 6815 6815 - else 6999 6999 + else $as_nop 6816 7000 xorg_cv_cc_flag_unknown_warning_option=no 6817 7001 fi 6818 6818 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7002 7002 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6819 7003 fi 6820 6820 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6821 6821 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7004 7004 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7005 7005 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6822 7006 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6823 7007 CFLAGS="$xorg_testset_save_CFLAGS" 6824 7008 fi ··· 6828 7012 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6829 7013 fi 6830 7014 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6831 6831 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6832 6832 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6833 6833 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6834 6834 - $as_echo_n "(cached) " >&6 6835 6835 - else 7015 7015 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7016 7016 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7017 7017 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7018 7018 + then : 7019 7019 + printf %s "(cached) " >&6 7020 7020 + else $as_nop 6836 7021 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6837 7022 /* end confdefs.h. */ 6838 7023 int i; 6839 7024 _ACEOF 6840 6840 - if ac_fn_c_try_compile "$LINENO"; then : 7025 7025 + if ac_fn_c_try_compile "$LINENO" 7026 7026 + then : 6841 7027 xorg_cv_cc_flag_unused_command_line_argument=yes 6842 6842 - else 7028 7028 + else $as_nop 6843 7029 xorg_cv_cc_flag_unused_command_line_argument=no 6844 7030 fi 6845 6845 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7031 7031 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6846 7032 fi 6847 6847 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6848 6848 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7033 7033 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7034 7034 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6849 7035 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6850 7036 CFLAGS="$xorg_testset_save_CFLAGS" 6851 7037 fi ··· 6863 7049 6864 7050 CFLAGS="$CFLAGS -Werror=nonnull" 6865 7051 6866 6866 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=nonnull" >&5 6867 6867 - $as_echo_n "checking if $CC supports -Werror=nonnull... " >&6; } 7052 7052 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=nonnull" >&5 7053 7053 + printf %s "checking if $CC supports -Werror=nonnull... " >&6; } 6868 7054 cacheid=xorg_cv_cc_flag__Werror_nonnull 6869 6869 - if eval \${$cacheid+:} false; then : 6870 6870 - $as_echo_n "(cached) " >&6 6871 6871 - else 7055 7055 + if eval test \${$cacheid+y} 7056 7056 + then : 7057 7057 + printf %s "(cached) " >&6 7058 7058 + else $as_nop 6872 7059 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6873 7060 /* end confdefs.h. */ 6874 7061 int i; 6875 7062 int 6876 6876 - main () 7063 7063 + main (void) 6877 7064 { 6878 7065 6879 7066 ; 6880 7067 return 0; 6881 7068 } 6882 7069 _ACEOF 6883 6883 - if ac_fn_c_try_link "$LINENO"; then : 7070 7070 + if ac_fn_c_try_link "$LINENO" 7071 7071 + then : 6884 7072 eval $cacheid=yes 6885 6885 - else 7073 7073 + else $as_nop 6886 7074 eval $cacheid=no 6887 7075 fi 6888 6888 - rm -f core conftest.err conftest.$ac_objext \ 7076 7076 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 6889 7077 conftest$ac_exeext conftest.$ac_ext 6890 7078 fi 6891 7079 ··· 6893 7081 CFLAGS="$xorg_testset_save_CFLAGS" 6894 7082 6895 7083 eval supported=\$$cacheid 6896 6896 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 6897 6897 - $as_echo "$supported" >&6; } 7084 7084 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7085 7085 + printf "%s\n" "$supported" >&6; } 6898 7086 if test "$supported" = "yes" ; then 6899 7087 BASE_CFLAGS="$BASE_CFLAGS -Werror=nonnull" 6900 7088 found="yes" ··· 6919 7107 6920 7108 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 6921 7109 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6922 6922 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 6923 6923 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 6924 6924 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 6925 6925 - $as_echo_n "(cached) " >&6 6926 6926 - else 7110 7110 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7111 7111 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7112 7112 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7113 7113 + then : 7114 7114 + printf %s "(cached) " >&6 7115 7115 + else $as_nop 6927 7116 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6928 7117 /* end confdefs.h. */ 6929 7118 int i; 6930 7119 _ACEOF 6931 6931 - if ac_fn_c_try_compile "$LINENO"; then : 7120 7120 + if ac_fn_c_try_compile "$LINENO" 7121 7121 + then : 6932 7122 xorg_cv_cc_flag_unknown_warning_option=yes 6933 6933 - else 7123 7123 + else $as_nop 6934 7124 xorg_cv_cc_flag_unknown_warning_option=no 6935 7125 fi 6936 6936 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7126 7126 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6937 7127 fi 6938 6938 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 6939 6939 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7128 7128 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7129 7129 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 6940 7130 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 6941 7131 CFLAGS="$xorg_testset_save_CFLAGS" 6942 7132 fi ··· 6946 7136 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 6947 7137 fi 6948 7138 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 6949 6949 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 6950 6950 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 6951 6951 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 6952 6952 - $as_echo_n "(cached) " >&6 6953 6953 - else 7139 7139 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7140 7140 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7141 7141 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7142 7142 + then : 7143 7143 + printf %s "(cached) " >&6 7144 7144 + else $as_nop 6954 7145 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6955 7146 /* end confdefs.h. */ 6956 7147 int i; 6957 7148 _ACEOF 6958 6958 - if ac_fn_c_try_compile "$LINENO"; then : 7149 7149 + if ac_fn_c_try_compile "$LINENO" 7150 7150 + then : 6959 7151 xorg_cv_cc_flag_unused_command_line_argument=yes 6960 6960 - else 7152 7152 + else $as_nop 6961 7153 xorg_cv_cc_flag_unused_command_line_argument=no 6962 7154 fi 6963 6963 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7155 7155 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 6964 7156 fi 6965 6965 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 6966 6966 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7157 7157 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7158 7158 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 6967 7159 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 6968 7160 CFLAGS="$xorg_testset_save_CFLAGS" 6969 7161 fi ··· 6981 7173 6982 7174 CFLAGS="$CFLAGS -Werror=init-self" 6983 7175 6984 6984 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=init-self" >&5 6985 6985 - $as_echo_n "checking if $CC supports -Werror=init-self... " >&6; } 7176 7176 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=init-self" >&5 7177 7177 + printf %s "checking if $CC supports -Werror=init-self... " >&6; } 6986 7178 cacheid=xorg_cv_cc_flag__Werror_init_self 6987 6987 - if eval \${$cacheid+:} false; then : 6988 6988 - $as_echo_n "(cached) " >&6 6989 6989 - else 7179 7179 + if eval test \${$cacheid+y} 7180 7180 + then : 7181 7181 + printf %s "(cached) " >&6 7182 7182 + else $as_nop 6990 7183 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6991 7184 /* end confdefs.h. */ 6992 7185 int i; 6993 7186 int 6994 6994 - main () 7187 7187 + main (void) 6995 7188 { 6996 7189 6997 7190 ; 6998 7191 return 0; 6999 7192 } 7000 7193 _ACEOF 7001 7001 - if ac_fn_c_try_link "$LINENO"; then : 7194 7194 + if ac_fn_c_try_link "$LINENO" 7195 7195 + then : 7002 7196 eval $cacheid=yes 7003 7003 - else 7197 7197 + else $as_nop 7004 7198 eval $cacheid=no 7005 7199 fi 7006 7006 - rm -f core conftest.err conftest.$ac_objext \ 7200 7200 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7007 7201 conftest$ac_exeext conftest.$ac_ext 7008 7202 fi 7009 7203 ··· 7011 7205 CFLAGS="$xorg_testset_save_CFLAGS" 7012 7206 7013 7207 eval supported=\$$cacheid 7014 7014 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7015 7015 - $as_echo "$supported" >&6; } 7208 7208 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7209 7209 + printf "%s\n" "$supported" >&6; } 7016 7210 if test "$supported" = "yes" ; then 7017 7211 BASE_CFLAGS="$BASE_CFLAGS -Werror=init-self" 7018 7212 found="yes" ··· 7037 7231 7038 7232 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7039 7233 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7040 7040 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7041 7041 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7042 7042 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7043 7043 - $as_echo_n "(cached) " >&6 7044 7044 - else 7234 7234 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7235 7235 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7236 7236 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7237 7237 + then : 7238 7238 + printf %s "(cached) " >&6 7239 7239 + else $as_nop 7045 7240 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7046 7241 /* end confdefs.h. */ 7047 7242 int i; 7048 7243 _ACEOF 7049 7049 - if ac_fn_c_try_compile "$LINENO"; then : 7244 7244 + if ac_fn_c_try_compile "$LINENO" 7245 7245 + then : 7050 7246 xorg_cv_cc_flag_unknown_warning_option=yes 7051 7051 - else 7247 7247 + else $as_nop 7052 7248 xorg_cv_cc_flag_unknown_warning_option=no 7053 7249 fi 7054 7054 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7250 7250 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7055 7251 fi 7056 7056 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7057 7057 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7252 7252 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7253 7253 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7058 7254 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7059 7255 CFLAGS="$xorg_testset_save_CFLAGS" 7060 7256 fi ··· 7064 7260 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7065 7261 fi 7066 7262 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7067 7067 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7068 7068 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7069 7069 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7070 7070 - $as_echo_n "(cached) " >&6 7071 7071 - else 7263 7263 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7264 7264 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7265 7265 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7266 7266 + then : 7267 7267 + printf %s "(cached) " >&6 7268 7268 + else $as_nop 7072 7269 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7073 7270 /* end confdefs.h. */ 7074 7271 int i; 7075 7272 _ACEOF 7076 7076 - if ac_fn_c_try_compile "$LINENO"; then : 7273 7273 + if ac_fn_c_try_compile "$LINENO" 7274 7274 + then : 7077 7275 xorg_cv_cc_flag_unused_command_line_argument=yes 7078 7078 - else 7276 7276 + else $as_nop 7079 7277 xorg_cv_cc_flag_unused_command_line_argument=no 7080 7278 fi 7081 7081 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7279 7279 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7082 7280 fi 7083 7083 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7084 7084 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7281 7281 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7282 7282 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7085 7283 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7086 7284 CFLAGS="$xorg_testset_save_CFLAGS" 7087 7285 fi ··· 7099 7297 7100 7298 CFLAGS="$CFLAGS -Werror=main" 7101 7299 7102 7102 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=main" >&5 7103 7103 - $as_echo_n "checking if $CC supports -Werror=main... " >&6; } 7300 7300 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=main" >&5 7301 7301 + printf %s "checking if $CC supports -Werror=main... " >&6; } 7104 7302 cacheid=xorg_cv_cc_flag__Werror_main 7105 7105 - if eval \${$cacheid+:} false; then : 7106 7106 - $as_echo_n "(cached) " >&6 7107 7107 - else 7303 7303 + if eval test \${$cacheid+y} 7304 7304 + then : 7305 7305 + printf %s "(cached) " >&6 7306 7306 + else $as_nop 7108 7307 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7109 7308 /* end confdefs.h. */ 7110 7309 int i; 7111 7310 int 7112 7112 - main () 7311 7311 + main (void) 7113 7312 { 7114 7313 7115 7314 ; 7116 7315 return 0; 7117 7316 } 7118 7317 _ACEOF 7119 7119 - if ac_fn_c_try_link "$LINENO"; then : 7318 7318 + if ac_fn_c_try_link "$LINENO" 7319 7319 + then : 7120 7320 eval $cacheid=yes 7121 7121 - else 7321 7321 + else $as_nop 7122 7322 eval $cacheid=no 7123 7323 fi 7124 7124 - rm -f core conftest.err conftest.$ac_objext \ 7324 7324 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7125 7325 conftest$ac_exeext conftest.$ac_ext 7126 7326 fi 7127 7327 ··· 7129 7329 CFLAGS="$xorg_testset_save_CFLAGS" 7130 7330 7131 7331 eval supported=\$$cacheid 7132 7132 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7133 7133 - $as_echo "$supported" >&6; } 7332 7332 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7333 7333 + printf "%s\n" "$supported" >&6; } 7134 7334 if test "$supported" = "yes" ; then 7135 7335 BASE_CFLAGS="$BASE_CFLAGS -Werror=main" 7136 7336 found="yes" ··· 7155 7355 7156 7356 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7157 7357 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7158 7158 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7159 7159 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7160 7160 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7161 7161 - $as_echo_n "(cached) " >&6 7162 7162 - else 7358 7358 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7359 7359 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7360 7360 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7361 7361 + then : 7362 7362 + printf %s "(cached) " >&6 7363 7363 + else $as_nop 7163 7364 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7164 7365 /* end confdefs.h. */ 7165 7366 int i; 7166 7367 _ACEOF 7167 7167 - if ac_fn_c_try_compile "$LINENO"; then : 7368 7368 + if ac_fn_c_try_compile "$LINENO" 7369 7369 + then : 7168 7370 xorg_cv_cc_flag_unknown_warning_option=yes 7169 7169 - else 7371 7371 + else $as_nop 7170 7372 xorg_cv_cc_flag_unknown_warning_option=no 7171 7373 fi 7172 7172 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7374 7374 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7173 7375 fi 7174 7174 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7175 7175 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7376 7376 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7377 7377 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7176 7378 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7177 7379 CFLAGS="$xorg_testset_save_CFLAGS" 7178 7380 fi ··· 7182 7384 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7183 7385 fi 7184 7386 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7185 7185 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7186 7186 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7187 7187 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7188 7188 - $as_echo_n "(cached) " >&6 7189 7189 - else 7387 7387 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7388 7388 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7389 7389 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7390 7390 + then : 7391 7391 + printf %s "(cached) " >&6 7392 7392 + else $as_nop 7190 7393 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7191 7394 /* end confdefs.h. */ 7192 7395 int i; 7193 7396 _ACEOF 7194 7194 - if ac_fn_c_try_compile "$LINENO"; then : 7397 7397 + if ac_fn_c_try_compile "$LINENO" 7398 7398 + then : 7195 7399 xorg_cv_cc_flag_unused_command_line_argument=yes 7196 7196 - else 7400 7400 + else $as_nop 7197 7401 xorg_cv_cc_flag_unused_command_line_argument=no 7198 7402 fi 7199 7199 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7403 7403 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7200 7404 fi 7201 7201 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7202 7202 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7405 7405 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7406 7406 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7203 7407 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7204 7408 CFLAGS="$xorg_testset_save_CFLAGS" 7205 7409 fi ··· 7217 7421 7218 7422 CFLAGS="$CFLAGS -Werror=missing-braces" 7219 7423 7220 7220 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=missing-braces" >&5 7221 7221 - $as_echo_n "checking if $CC supports -Werror=missing-braces... " >&6; } 7424 7424 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=missing-braces" >&5 7425 7425 + printf %s "checking if $CC supports -Werror=missing-braces... " >&6; } 7222 7426 cacheid=xorg_cv_cc_flag__Werror_missing_braces 7223 7223 - if eval \${$cacheid+:} false; then : 7224 7224 - $as_echo_n "(cached) " >&6 7225 7225 - else 7427 7427 + if eval test \${$cacheid+y} 7428 7428 + then : 7429 7429 + printf %s "(cached) " >&6 7430 7430 + else $as_nop 7226 7431 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7227 7432 /* end confdefs.h. */ 7228 7433 int i; 7229 7434 int 7230 7230 - main () 7435 7435 + main (void) 7231 7436 { 7232 7437 7233 7438 ; 7234 7439 return 0; 7235 7440 } 7236 7441 _ACEOF 7237 7237 - if ac_fn_c_try_link "$LINENO"; then : 7442 7442 + if ac_fn_c_try_link "$LINENO" 7443 7443 + then : 7238 7444 eval $cacheid=yes 7239 7239 - else 7445 7445 + else $as_nop 7240 7446 eval $cacheid=no 7241 7447 fi 7242 7242 - rm -f core conftest.err conftest.$ac_objext \ 7448 7448 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7243 7449 conftest$ac_exeext conftest.$ac_ext 7244 7450 fi 7245 7451 ··· 7247 7453 CFLAGS="$xorg_testset_save_CFLAGS" 7248 7454 7249 7455 eval supported=\$$cacheid 7250 7250 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7251 7251 - $as_echo "$supported" >&6; } 7456 7456 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7457 7457 + printf "%s\n" "$supported" >&6; } 7252 7458 if test "$supported" = "yes" ; then 7253 7459 BASE_CFLAGS="$BASE_CFLAGS -Werror=missing-braces" 7254 7460 found="yes" ··· 7273 7479 7274 7480 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7275 7481 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7276 7276 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7277 7277 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7278 7278 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7279 7279 - $as_echo_n "(cached) " >&6 7280 7280 - else 7482 7482 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7483 7483 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7484 7484 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7485 7485 + then : 7486 7486 + printf %s "(cached) " >&6 7487 7487 + else $as_nop 7281 7488 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7282 7489 /* end confdefs.h. */ 7283 7490 int i; 7284 7491 _ACEOF 7285 7285 - if ac_fn_c_try_compile "$LINENO"; then : 7492 7492 + if ac_fn_c_try_compile "$LINENO" 7493 7493 + then : 7286 7494 xorg_cv_cc_flag_unknown_warning_option=yes 7287 7287 - else 7495 7495 + else $as_nop 7288 7496 xorg_cv_cc_flag_unknown_warning_option=no 7289 7497 fi 7290 7290 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7498 7498 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7291 7499 fi 7292 7292 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7293 7293 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7500 7500 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7501 7501 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7294 7502 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7295 7503 CFLAGS="$xorg_testset_save_CFLAGS" 7296 7504 fi ··· 7300 7508 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7301 7509 fi 7302 7510 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7303 7303 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7304 7304 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7305 7305 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7306 7306 - $as_echo_n "(cached) " >&6 7307 7307 - else 7511 7511 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7512 7512 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7513 7513 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7514 7514 + then : 7515 7515 + printf %s "(cached) " >&6 7516 7516 + else $as_nop 7308 7517 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7309 7518 /* end confdefs.h. */ 7310 7519 int i; 7311 7520 _ACEOF 7312 7312 - if ac_fn_c_try_compile "$LINENO"; then : 7521 7521 + if ac_fn_c_try_compile "$LINENO" 7522 7522 + then : 7313 7523 xorg_cv_cc_flag_unused_command_line_argument=yes 7314 7314 - else 7524 7524 + else $as_nop 7315 7525 xorg_cv_cc_flag_unused_command_line_argument=no 7316 7526 fi 7317 7317 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7527 7527 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7318 7528 fi 7319 7319 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7320 7320 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7529 7529 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7530 7530 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7321 7531 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7322 7532 CFLAGS="$xorg_testset_save_CFLAGS" 7323 7533 fi ··· 7335 7545 7336 7546 CFLAGS="$CFLAGS -Werror=sequence-point" 7337 7547 7338 7338 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=sequence-point" >&5 7339 7339 - $as_echo_n "checking if $CC supports -Werror=sequence-point... " >&6; } 7548 7548 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=sequence-point" >&5 7549 7549 + printf %s "checking if $CC supports -Werror=sequence-point... " >&6; } 7340 7550 cacheid=xorg_cv_cc_flag__Werror_sequence_point 7341 7341 - if eval \${$cacheid+:} false; then : 7342 7342 - $as_echo_n "(cached) " >&6 7343 7343 - else 7551 7551 + if eval test \${$cacheid+y} 7552 7552 + then : 7553 7553 + printf %s "(cached) " >&6 7554 7554 + else $as_nop 7344 7555 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7345 7556 /* end confdefs.h. */ 7346 7557 int i; 7347 7558 int 7348 7348 - main () 7559 7559 + main (void) 7349 7560 { 7350 7561 7351 7562 ; 7352 7563 return 0; 7353 7564 } 7354 7565 _ACEOF 7355 7355 - if ac_fn_c_try_link "$LINENO"; then : 7566 7566 + if ac_fn_c_try_link "$LINENO" 7567 7567 + then : 7356 7568 eval $cacheid=yes 7357 7357 - else 7569 7569 + else $as_nop 7358 7570 eval $cacheid=no 7359 7571 fi 7360 7360 - rm -f core conftest.err conftest.$ac_objext \ 7572 7572 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7361 7573 conftest$ac_exeext conftest.$ac_ext 7362 7574 fi 7363 7575 ··· 7365 7577 CFLAGS="$xorg_testset_save_CFLAGS" 7366 7578 7367 7579 eval supported=\$$cacheid 7368 7368 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7369 7369 - $as_echo "$supported" >&6; } 7580 7580 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7581 7581 + printf "%s\n" "$supported" >&6; } 7370 7582 if test "$supported" = "yes" ; then 7371 7583 BASE_CFLAGS="$BASE_CFLAGS -Werror=sequence-point" 7372 7584 found="yes" ··· 7391 7603 7392 7604 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7393 7605 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7394 7394 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7395 7395 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7396 7396 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7397 7397 - $as_echo_n "(cached) " >&6 7398 7398 - else 7606 7606 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7607 7607 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7608 7608 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7609 7609 + then : 7610 7610 + printf %s "(cached) " >&6 7611 7611 + else $as_nop 7399 7612 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7400 7613 /* end confdefs.h. */ 7401 7614 int i; 7402 7615 _ACEOF 7403 7403 - if ac_fn_c_try_compile "$LINENO"; then : 7616 7616 + if ac_fn_c_try_compile "$LINENO" 7617 7617 + then : 7404 7618 xorg_cv_cc_flag_unknown_warning_option=yes 7405 7405 - else 7619 7619 + else $as_nop 7406 7620 xorg_cv_cc_flag_unknown_warning_option=no 7407 7621 fi 7408 7408 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7622 7622 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7409 7623 fi 7410 7410 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7411 7411 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7624 7624 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7625 7625 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7412 7626 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7413 7627 CFLAGS="$xorg_testset_save_CFLAGS" 7414 7628 fi ··· 7418 7632 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7419 7633 fi 7420 7634 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7421 7421 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7422 7422 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7423 7423 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7424 7424 - $as_echo_n "(cached) " >&6 7425 7425 - else 7635 7635 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7636 7636 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7637 7637 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7638 7638 + then : 7639 7639 + printf %s "(cached) " >&6 7640 7640 + else $as_nop 7426 7641 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7427 7642 /* end confdefs.h. */ 7428 7643 int i; 7429 7644 _ACEOF 7430 7430 - if ac_fn_c_try_compile "$LINENO"; then : 7645 7645 + if ac_fn_c_try_compile "$LINENO" 7646 7646 + then : 7431 7647 xorg_cv_cc_flag_unused_command_line_argument=yes 7432 7432 - else 7648 7648 + else $as_nop 7433 7649 xorg_cv_cc_flag_unused_command_line_argument=no 7434 7650 fi 7435 7435 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7651 7651 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7436 7652 fi 7437 7437 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7438 7438 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7653 7653 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7654 7654 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7439 7655 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7440 7656 CFLAGS="$xorg_testset_save_CFLAGS" 7441 7657 fi ··· 7453 7669 7454 7670 CFLAGS="$CFLAGS -Werror=return-type" 7455 7671 7456 7456 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=return-type" >&5 7457 7457 - $as_echo_n "checking if $CC supports -Werror=return-type... " >&6; } 7672 7672 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=return-type" >&5 7673 7673 + printf %s "checking if $CC supports -Werror=return-type... " >&6; } 7458 7674 cacheid=xorg_cv_cc_flag__Werror_return_type 7459 7459 - if eval \${$cacheid+:} false; then : 7460 7460 - $as_echo_n "(cached) " >&6 7461 7461 - else 7675 7675 + if eval test \${$cacheid+y} 7676 7676 + then : 7677 7677 + printf %s "(cached) " >&6 7678 7678 + else $as_nop 7462 7679 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7463 7680 /* end confdefs.h. */ 7464 7681 int i; 7465 7682 int 7466 7466 - main () 7683 7683 + main (void) 7467 7684 { 7468 7685 7469 7686 ; 7470 7687 return 0; 7471 7688 } 7472 7689 _ACEOF 7473 7473 - if ac_fn_c_try_link "$LINENO"; then : 7690 7690 + if ac_fn_c_try_link "$LINENO" 7691 7691 + then : 7474 7692 eval $cacheid=yes 7475 7475 - else 7693 7693 + else $as_nop 7476 7694 eval $cacheid=no 7477 7695 fi 7478 7478 - rm -f core conftest.err conftest.$ac_objext \ 7696 7696 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7479 7697 conftest$ac_exeext conftest.$ac_ext 7480 7698 fi 7481 7699 ··· 7483 7701 CFLAGS="$xorg_testset_save_CFLAGS" 7484 7702 7485 7703 eval supported=\$$cacheid 7486 7486 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7487 7487 - $as_echo "$supported" >&6; } 7704 7704 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7705 7705 + printf "%s\n" "$supported" >&6; } 7488 7706 if test "$supported" = "yes" ; then 7489 7707 BASE_CFLAGS="$BASE_CFLAGS -Werror=return-type" 7490 7708 found="yes" ··· 7502 7720 7503 7721 CFLAGS="$CFLAGS -errwarn=E_FUNC_HAS_NO_RETURN_STMT" 7504 7722 7505 7505 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn=E_FUNC_HAS_NO_RETURN_STMT" >&5 7506 7506 - $as_echo_n "checking if $CC supports -errwarn=E_FUNC_HAS_NO_RETURN_STMT... " >&6; } 7723 7723 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn=E_FUNC_HAS_NO_RETURN_STMT" >&5 7724 7724 + printf %s "checking if $CC supports -errwarn=E_FUNC_HAS_NO_RETURN_STMT... " >&6; } 7507 7725 cacheid=xorg_cv_cc_flag__errwarn_E_FUNC_HAS_NO_RETURN_STMT 7508 7508 - if eval \${$cacheid+:} false; then : 7509 7509 - $as_echo_n "(cached) " >&6 7510 7510 - else 7726 7726 + if eval test \${$cacheid+y} 7727 7727 + then : 7728 7728 + printf %s "(cached) " >&6 7729 7729 + else $as_nop 7511 7730 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7512 7731 /* end confdefs.h. */ 7513 7732 int i; 7514 7733 int 7515 7515 - main () 7734 7734 + main (void) 7516 7735 { 7517 7736 7518 7737 ; 7519 7738 return 0; 7520 7739 } 7521 7740 _ACEOF 7522 7522 - if ac_fn_c_try_link "$LINENO"; then : 7741 7741 + if ac_fn_c_try_link "$LINENO" 7742 7742 + then : 7523 7743 eval $cacheid=yes 7524 7524 - else 7744 7744 + else $as_nop 7525 7745 eval $cacheid=no 7526 7746 fi 7527 7527 - rm -f core conftest.err conftest.$ac_objext \ 7747 7747 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7528 7748 conftest$ac_exeext conftest.$ac_ext 7529 7749 fi 7530 7750 ··· 7532 7752 CFLAGS="$xorg_testset_save_CFLAGS" 7533 7753 7534 7754 eval supported=\$$cacheid 7535 7535 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7536 7536 - $as_echo "$supported" >&6; } 7755 7755 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7756 7756 + printf "%s\n" "$supported" >&6; } 7537 7757 if test "$supported" = "yes" ; then 7538 7758 BASE_CFLAGS="$BASE_CFLAGS -errwarn=E_FUNC_HAS_NO_RETURN_STMT" 7539 7759 found="yes" ··· 7558 7778 7559 7779 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7560 7780 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7561 7561 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7562 7562 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7563 7563 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7564 7564 - $as_echo_n "(cached) " >&6 7565 7565 - else 7781 7781 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7782 7782 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7783 7783 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7784 7784 + then : 7785 7785 + printf %s "(cached) " >&6 7786 7786 + else $as_nop 7566 7787 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7567 7788 /* end confdefs.h. */ 7568 7789 int i; 7569 7790 _ACEOF 7570 7570 - if ac_fn_c_try_compile "$LINENO"; then : 7791 7791 + if ac_fn_c_try_compile "$LINENO" 7792 7792 + then : 7571 7793 xorg_cv_cc_flag_unknown_warning_option=yes 7572 7572 - else 7794 7794 + else $as_nop 7573 7795 xorg_cv_cc_flag_unknown_warning_option=no 7574 7796 fi 7575 7575 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7797 7797 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7576 7798 fi 7577 7577 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7578 7578 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7799 7799 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7800 7800 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7579 7801 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7580 7802 CFLAGS="$xorg_testset_save_CFLAGS" 7581 7803 fi ··· 7585 7807 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7586 7808 fi 7587 7809 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7588 7588 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7589 7589 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7590 7590 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7591 7591 - $as_echo_n "(cached) " >&6 7592 7592 - else 7810 7810 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7811 7811 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7812 7812 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7813 7813 + then : 7814 7814 + printf %s "(cached) " >&6 7815 7815 + else $as_nop 7593 7816 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7594 7817 /* end confdefs.h. */ 7595 7818 int i; 7596 7819 _ACEOF 7597 7597 - if ac_fn_c_try_compile "$LINENO"; then : 7820 7820 + if ac_fn_c_try_compile "$LINENO" 7821 7821 + then : 7598 7822 xorg_cv_cc_flag_unused_command_line_argument=yes 7599 7599 - else 7823 7823 + else $as_nop 7600 7824 xorg_cv_cc_flag_unused_command_line_argument=no 7601 7825 fi 7602 7602 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7826 7826 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7603 7827 fi 7604 7604 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7605 7605 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7828 7828 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7829 7829 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7606 7830 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7607 7831 CFLAGS="$xorg_testset_save_CFLAGS" 7608 7832 fi ··· 7620 7844 7621 7845 CFLAGS="$CFLAGS -Werror=trigraphs" 7622 7846 7623 7623 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=trigraphs" >&5 7624 7624 - $as_echo_n "checking if $CC supports -Werror=trigraphs... " >&6; } 7847 7847 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=trigraphs" >&5 7848 7848 + printf %s "checking if $CC supports -Werror=trigraphs... " >&6; } 7625 7849 cacheid=xorg_cv_cc_flag__Werror_trigraphs 7626 7626 - if eval \${$cacheid+:} false; then : 7627 7627 - $as_echo_n "(cached) " >&6 7628 7628 - else 7850 7850 + if eval test \${$cacheid+y} 7851 7851 + then : 7852 7852 + printf %s "(cached) " >&6 7853 7853 + else $as_nop 7629 7854 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7630 7855 /* end confdefs.h. */ 7631 7856 int i; 7632 7857 int 7633 7633 - main () 7858 7858 + main (void) 7634 7859 { 7635 7860 7636 7861 ; 7637 7862 return 0; 7638 7863 } 7639 7864 _ACEOF 7640 7640 - if ac_fn_c_try_link "$LINENO"; then : 7865 7865 + if ac_fn_c_try_link "$LINENO" 7866 7866 + then : 7641 7867 eval $cacheid=yes 7642 7642 - else 7868 7868 + else $as_nop 7643 7869 eval $cacheid=no 7644 7870 fi 7645 7645 - rm -f core conftest.err conftest.$ac_objext \ 7871 7871 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7646 7872 conftest$ac_exeext conftest.$ac_ext 7647 7873 fi 7648 7874 ··· 7650 7876 CFLAGS="$xorg_testset_save_CFLAGS" 7651 7877 7652 7878 eval supported=\$$cacheid 7653 7653 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7654 7654 - $as_echo "$supported" >&6; } 7879 7879 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7880 7880 + printf "%s\n" "$supported" >&6; } 7655 7881 if test "$supported" = "yes" ; then 7656 7882 BASE_CFLAGS="$BASE_CFLAGS -Werror=trigraphs" 7657 7883 found="yes" ··· 7676 7902 7677 7903 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7678 7904 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7679 7679 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7680 7680 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7681 7681 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7682 7682 - $as_echo_n "(cached) " >&6 7683 7683 - else 7905 7905 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7906 7906 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7907 7907 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 7908 7908 + then : 7909 7909 + printf %s "(cached) " >&6 7910 7910 + else $as_nop 7684 7911 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7685 7912 /* end confdefs.h. */ 7686 7913 int i; 7687 7914 _ACEOF 7688 7688 - if ac_fn_c_try_compile "$LINENO"; then : 7915 7915 + if ac_fn_c_try_compile "$LINENO" 7916 7916 + then : 7689 7917 xorg_cv_cc_flag_unknown_warning_option=yes 7690 7690 - else 7918 7918 + else $as_nop 7691 7919 xorg_cv_cc_flag_unknown_warning_option=no 7692 7920 fi 7693 7693 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7921 7921 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7694 7922 fi 7695 7695 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7696 7696 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7923 7923 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7924 7924 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7697 7925 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7698 7926 CFLAGS="$xorg_testset_save_CFLAGS" 7699 7927 fi ··· 7703 7931 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7704 7932 fi 7705 7933 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7706 7706 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7707 7707 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7708 7708 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7709 7709 - $as_echo_n "(cached) " >&6 7710 7710 - else 7934 7934 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7935 7935 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7936 7936 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 7937 7937 + then : 7938 7938 + printf %s "(cached) " >&6 7939 7939 + else $as_nop 7711 7940 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7712 7941 /* end confdefs.h. */ 7713 7942 int i; 7714 7943 _ACEOF 7715 7715 - if ac_fn_c_try_compile "$LINENO"; then : 7944 7944 + if ac_fn_c_try_compile "$LINENO" 7945 7945 + then : 7716 7946 xorg_cv_cc_flag_unused_command_line_argument=yes 7717 7717 - else 7947 7947 + else $as_nop 7718 7948 xorg_cv_cc_flag_unused_command_line_argument=no 7719 7949 fi 7720 7720 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 7950 7950 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7721 7951 fi 7722 7722 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7723 7723 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7952 7952 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7953 7953 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7724 7954 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7725 7955 CFLAGS="$xorg_testset_save_CFLAGS" 7726 7956 fi ··· 7738 7968 7739 7969 CFLAGS="$CFLAGS -Werror=array-bounds" 7740 7970 7741 7741 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=array-bounds" >&5 7742 7742 - $as_echo_n "checking if $CC supports -Werror=array-bounds... " >&6; } 7971 7971 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=array-bounds" >&5 7972 7972 + printf %s "checking if $CC supports -Werror=array-bounds... " >&6; } 7743 7973 cacheid=xorg_cv_cc_flag__Werror_array_bounds 7744 7744 - if eval \${$cacheid+:} false; then : 7745 7745 - $as_echo_n "(cached) " >&6 7746 7746 - else 7974 7974 + if eval test \${$cacheid+y} 7975 7975 + then : 7976 7976 + printf %s "(cached) " >&6 7977 7977 + else $as_nop 7747 7978 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7748 7979 /* end confdefs.h. */ 7749 7980 int i; 7750 7981 int 7751 7751 - main () 7982 7982 + main (void) 7752 7983 { 7753 7984 7754 7985 ; 7755 7986 return 0; 7756 7987 } 7757 7988 _ACEOF 7758 7758 - if ac_fn_c_try_link "$LINENO"; then : 7989 7989 + if ac_fn_c_try_link "$LINENO" 7990 7990 + then : 7759 7991 eval $cacheid=yes 7760 7760 - else 7992 7992 + else $as_nop 7761 7993 eval $cacheid=no 7762 7994 fi 7763 7763 - rm -f core conftest.err conftest.$ac_objext \ 7995 7995 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7764 7996 conftest$ac_exeext conftest.$ac_ext 7765 7997 fi 7766 7998 ··· 7768 8000 CFLAGS="$xorg_testset_save_CFLAGS" 7769 8001 7770 8002 eval supported=\$$cacheid 7771 7771 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7772 7772 - $as_echo "$supported" >&6; } 8003 8003 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8004 8004 + printf "%s\n" "$supported" >&6; } 7773 8005 if test "$supported" = "yes" ; then 7774 8006 BASE_CFLAGS="$BASE_CFLAGS -Werror=array-bounds" 7775 8007 found="yes" ··· 7794 8026 7795 8027 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7796 8028 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7797 7797 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7798 7798 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7799 7799 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7800 7800 - $as_echo_n "(cached) " >&6 7801 7801 - else 8029 8029 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8030 8030 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8031 8031 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8032 8032 + then : 8033 8033 + printf %s "(cached) " >&6 8034 8034 + else $as_nop 7802 8035 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7803 8036 /* end confdefs.h. */ 7804 8037 int i; 7805 8038 _ACEOF 7806 7806 - if ac_fn_c_try_compile "$LINENO"; then : 8039 8039 + if ac_fn_c_try_compile "$LINENO" 8040 8040 + then : 7807 8041 xorg_cv_cc_flag_unknown_warning_option=yes 7808 7808 - else 8042 8042 + else $as_nop 7809 8043 xorg_cv_cc_flag_unknown_warning_option=no 7810 8044 fi 7811 7811 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8045 8045 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7812 8046 fi 7813 7813 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7814 7814 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8047 8047 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8048 8048 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7815 8049 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7816 8050 CFLAGS="$xorg_testset_save_CFLAGS" 7817 8051 fi ··· 7821 8055 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7822 8056 fi 7823 8057 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7824 7824 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7825 7825 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7826 7826 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7827 7827 - $as_echo_n "(cached) " >&6 7828 7828 - else 8058 8058 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8059 8059 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8060 8060 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8061 8061 + then : 8062 8062 + printf %s "(cached) " >&6 8063 8063 + else $as_nop 7829 8064 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7830 8065 /* end confdefs.h. */ 7831 8066 int i; 7832 8067 _ACEOF 7833 7833 - if ac_fn_c_try_compile "$LINENO"; then : 8068 8068 + if ac_fn_c_try_compile "$LINENO" 8069 8069 + then : 7834 8070 xorg_cv_cc_flag_unused_command_line_argument=yes 7835 7835 - else 8071 8071 + else $as_nop 7836 8072 xorg_cv_cc_flag_unused_command_line_argument=no 7837 8073 fi 7838 7838 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8074 8074 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7839 8075 fi 7840 7840 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7841 7841 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8076 8076 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8077 8077 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7842 8078 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7843 8079 CFLAGS="$xorg_testset_save_CFLAGS" 7844 8080 fi ··· 7856 8092 7857 8093 CFLAGS="$CFLAGS -Werror=write-strings" 7858 8094 7859 7859 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=write-strings" >&5 7860 7860 - $as_echo_n "checking if $CC supports -Werror=write-strings... " >&6; } 8095 8095 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=write-strings" >&5 8096 8096 + printf %s "checking if $CC supports -Werror=write-strings... " >&6; } 7861 8097 cacheid=xorg_cv_cc_flag__Werror_write_strings 7862 7862 - if eval \${$cacheid+:} false; then : 7863 7863 - $as_echo_n "(cached) " >&6 7864 7864 - else 8098 8098 + if eval test \${$cacheid+y} 8099 8099 + then : 8100 8100 + printf %s "(cached) " >&6 8101 8101 + else $as_nop 7865 8102 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7866 8103 /* end confdefs.h. */ 7867 8104 int i; 7868 8105 int 7869 7869 - main () 8106 8106 + main (void) 7870 8107 { 7871 8108 7872 8109 ; 7873 8110 return 0; 7874 8111 } 7875 8112 _ACEOF 7876 7876 - if ac_fn_c_try_link "$LINENO"; then : 8113 8113 + if ac_fn_c_try_link "$LINENO" 8114 8114 + then : 7877 8115 eval $cacheid=yes 7878 7878 - else 8116 8116 + else $as_nop 7879 8117 eval $cacheid=no 7880 8118 fi 7881 7881 - rm -f core conftest.err conftest.$ac_objext \ 8119 8119 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 7882 8120 conftest$ac_exeext conftest.$ac_ext 7883 8121 fi 7884 8122 ··· 7886 8124 CFLAGS="$xorg_testset_save_CFLAGS" 7887 8125 7888 8126 eval supported=\$$cacheid 7889 7889 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 7890 7890 - $as_echo "$supported" >&6; } 8127 8127 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8128 8128 + printf "%s\n" "$supported" >&6; } 7891 8129 if test "$supported" = "yes" ; then 7892 8130 BASE_CFLAGS="$BASE_CFLAGS -Werror=write-strings" 7893 8131 found="yes" ··· 7912 8150 7913 8151 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 7914 8152 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7915 7915 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 7916 7916 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 7917 7917 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 7918 7918 - $as_echo_n "(cached) " >&6 7919 7919 - else 8153 8153 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8154 8154 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8155 8155 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8156 8156 + then : 8157 8157 + printf %s "(cached) " >&6 8158 8158 + else $as_nop 7920 8159 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7921 8160 /* end confdefs.h. */ 7922 8161 int i; 7923 8162 _ACEOF 7924 7924 - if ac_fn_c_try_compile "$LINENO"; then : 8163 8163 + if ac_fn_c_try_compile "$LINENO" 8164 8164 + then : 7925 8165 xorg_cv_cc_flag_unknown_warning_option=yes 7926 7926 - else 8166 8166 + else $as_nop 7927 8167 xorg_cv_cc_flag_unknown_warning_option=no 7928 8168 fi 7929 7929 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8169 8169 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7930 8170 fi 7931 7931 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 7932 7932 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8171 8171 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8172 8172 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 7933 8173 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 7934 8174 CFLAGS="$xorg_testset_save_CFLAGS" 7935 8175 fi ··· 7939 8179 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 7940 8180 fi 7941 8181 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 7942 7942 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 7943 7943 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 7944 7944 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 7945 7945 - $as_echo_n "(cached) " >&6 7946 7946 - else 8182 8182 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8183 8183 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8184 8184 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8185 8185 + then : 8186 8186 + printf %s "(cached) " >&6 8187 8187 + else $as_nop 7947 8188 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7948 8189 /* end confdefs.h. */ 7949 8190 int i; 7950 8191 _ACEOF 7951 7951 - if ac_fn_c_try_compile "$LINENO"; then : 8192 8192 + if ac_fn_c_try_compile "$LINENO" 8193 8193 + then : 7952 8194 xorg_cv_cc_flag_unused_command_line_argument=yes 7953 7953 - else 8195 8195 + else $as_nop 7954 8196 xorg_cv_cc_flag_unused_command_line_argument=no 7955 8197 fi 7956 7956 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8198 8198 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 7957 8199 fi 7958 7958 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 7959 7959 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8200 8200 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8201 8201 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 7960 8202 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 7961 8203 CFLAGS="$xorg_testset_save_CFLAGS" 7962 8204 fi ··· 7974 8216 7975 8217 CFLAGS="$CFLAGS -Werror=address" 7976 8218 7977 7977 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=address" >&5 7978 7978 - $as_echo_n "checking if $CC supports -Werror=address... " >&6; } 8219 8219 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=address" >&5 8220 8220 + printf %s "checking if $CC supports -Werror=address... " >&6; } 7979 8221 cacheid=xorg_cv_cc_flag__Werror_address 7980 7980 - if eval \${$cacheid+:} false; then : 7981 7981 - $as_echo_n "(cached) " >&6 7982 7982 - else 8222 8222 + if eval test \${$cacheid+y} 8223 8223 + then : 8224 8224 + printf %s "(cached) " >&6 8225 8225 + else $as_nop 7983 8226 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 7984 8227 /* end confdefs.h. */ 7985 8228 int i; 7986 8229 int 7987 7987 - main () 8230 8230 + main (void) 7988 8231 { 7989 8232 7990 8233 ; 7991 8234 return 0; 7992 8235 } 7993 8236 _ACEOF 7994 7994 - if ac_fn_c_try_link "$LINENO"; then : 8237 8237 + if ac_fn_c_try_link "$LINENO" 8238 8238 + then : 7995 8239 eval $cacheid=yes 7996 7996 - else 8240 8240 + else $as_nop 7997 8241 eval $cacheid=no 7998 8242 fi 7999 7999 - rm -f core conftest.err conftest.$ac_objext \ 8243 8243 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8000 8244 conftest$ac_exeext conftest.$ac_ext 8001 8245 fi 8002 8246 ··· 8004 8248 CFLAGS="$xorg_testset_save_CFLAGS" 8005 8249 8006 8250 eval supported=\$$cacheid 8007 8007 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8008 8008 - $as_echo "$supported" >&6; } 8251 8251 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8252 8252 + printf "%s\n" "$supported" >&6; } 8009 8253 if test "$supported" = "yes" ; then 8010 8254 BASE_CFLAGS="$BASE_CFLAGS -Werror=address" 8011 8255 found="yes" ··· 8030 8274 8031 8275 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8032 8276 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8033 8033 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8034 8034 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8035 8035 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8036 8036 - $as_echo_n "(cached) " >&6 8037 8037 - else 8277 8277 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8278 8278 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8279 8279 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8280 8280 + then : 8281 8281 + printf %s "(cached) " >&6 8282 8282 + else $as_nop 8038 8283 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8039 8284 /* end confdefs.h. */ 8040 8285 int i; 8041 8286 _ACEOF 8042 8042 - if ac_fn_c_try_compile "$LINENO"; then : 8287 8287 + if ac_fn_c_try_compile "$LINENO" 8288 8288 + then : 8043 8289 xorg_cv_cc_flag_unknown_warning_option=yes 8044 8044 - else 8290 8290 + else $as_nop 8045 8291 xorg_cv_cc_flag_unknown_warning_option=no 8046 8292 fi 8047 8047 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8293 8293 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8048 8294 fi 8049 8049 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8050 8050 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8295 8295 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8296 8296 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8051 8297 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8052 8298 CFLAGS="$xorg_testset_save_CFLAGS" 8053 8299 fi ··· 8057 8303 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8058 8304 fi 8059 8305 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8060 8060 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8061 8061 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8062 8062 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8063 8063 - $as_echo_n "(cached) " >&6 8064 8064 - else 8306 8306 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8307 8307 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8308 8308 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8309 8309 + then : 8310 8310 + printf %s "(cached) " >&6 8311 8311 + else $as_nop 8065 8312 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8066 8313 /* end confdefs.h. */ 8067 8314 int i; 8068 8315 _ACEOF 8069 8069 - if ac_fn_c_try_compile "$LINENO"; then : 8316 8316 + if ac_fn_c_try_compile "$LINENO" 8317 8317 + then : 8070 8318 xorg_cv_cc_flag_unused_command_line_argument=yes 8071 8071 - else 8319 8319 + else $as_nop 8072 8320 xorg_cv_cc_flag_unused_command_line_argument=no 8073 8321 fi 8074 8074 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8322 8322 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8075 8323 fi 8076 8076 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8077 8077 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8324 8324 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8325 8325 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8078 8326 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8079 8327 CFLAGS="$xorg_testset_save_CFLAGS" 8080 8328 fi ··· 8092 8340 8093 8341 CFLAGS="$CFLAGS -Werror=int-to-pointer-cast" 8094 8342 8095 8095 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=int-to-pointer-cast" >&5 8096 8096 - $as_echo_n "checking if $CC supports -Werror=int-to-pointer-cast... " >&6; } 8343 8343 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=int-to-pointer-cast" >&5 8344 8344 + printf %s "checking if $CC supports -Werror=int-to-pointer-cast... " >&6; } 8097 8345 cacheid=xorg_cv_cc_flag__Werror_int_to_pointer_cast 8098 8098 - if eval \${$cacheid+:} false; then : 8099 8099 - $as_echo_n "(cached) " >&6 8100 8100 - else 8346 8346 + if eval test \${$cacheid+y} 8347 8347 + then : 8348 8348 + printf %s "(cached) " >&6 8349 8349 + else $as_nop 8101 8350 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8102 8351 /* end confdefs.h. */ 8103 8352 int i; 8104 8353 int 8105 8105 - main () 8354 8354 + main (void) 8106 8355 { 8107 8356 8108 8357 ; 8109 8358 return 0; 8110 8359 } 8111 8360 _ACEOF 8112 8112 - if ac_fn_c_try_link "$LINENO"; then : 8361 8361 + if ac_fn_c_try_link "$LINENO" 8362 8362 + then : 8113 8363 eval $cacheid=yes 8114 8114 - else 8364 8364 + else $as_nop 8115 8365 eval $cacheid=no 8116 8366 fi 8117 8117 - rm -f core conftest.err conftest.$ac_objext \ 8367 8367 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8118 8368 conftest$ac_exeext conftest.$ac_ext 8119 8369 fi 8120 8370 ··· 8122 8372 CFLAGS="$xorg_testset_save_CFLAGS" 8123 8373 8124 8374 eval supported=\$$cacheid 8125 8125 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8126 8126 - $as_echo "$supported" >&6; } 8375 8375 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8376 8376 + printf "%s\n" "$supported" >&6; } 8127 8377 if test "$supported" = "yes" ; then 8128 8378 BASE_CFLAGS="$BASE_CFLAGS -Werror=int-to-pointer-cast" 8129 8379 found="yes" ··· 8141 8391 8142 8392 CFLAGS="$CFLAGS -errwarn=E_BAD_PTR_INT_COMBINATION" 8143 8393 8144 8144 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn=E_BAD_PTR_INT_COMBINATION" >&5 8145 8145 - $as_echo_n "checking if $CC supports -errwarn=E_BAD_PTR_INT_COMBINATION... " >&6; } 8394 8394 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn=E_BAD_PTR_INT_COMBINATION" >&5 8395 8395 + printf %s "checking if $CC supports -errwarn=E_BAD_PTR_INT_COMBINATION... " >&6; } 8146 8396 cacheid=xorg_cv_cc_flag__errwarn_E_BAD_PTR_INT_COMBINATION 8147 8147 - if eval \${$cacheid+:} false; then : 8148 8148 - $as_echo_n "(cached) " >&6 8149 8149 - else 8397 8397 + if eval test \${$cacheid+y} 8398 8398 + then : 8399 8399 + printf %s "(cached) " >&6 8400 8400 + else $as_nop 8150 8401 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8151 8402 /* end confdefs.h. */ 8152 8403 int i; 8153 8404 int 8154 8154 - main () 8405 8405 + main (void) 8155 8406 { 8156 8407 8157 8408 ; 8158 8409 return 0; 8159 8410 } 8160 8411 _ACEOF 8161 8161 - if ac_fn_c_try_link "$LINENO"; then : 8412 8412 + if ac_fn_c_try_link "$LINENO" 8413 8413 + then : 8162 8414 eval $cacheid=yes 8163 8163 - else 8415 8415 + else $as_nop 8164 8416 eval $cacheid=no 8165 8417 fi 8166 8166 - rm -f core conftest.err conftest.$ac_objext \ 8418 8418 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8167 8419 conftest$ac_exeext conftest.$ac_ext 8168 8420 fi 8169 8421 ··· 8171 8423 CFLAGS="$xorg_testset_save_CFLAGS" 8172 8424 8173 8425 eval supported=\$$cacheid 8174 8174 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8175 8175 - $as_echo "$supported" >&6; } 8426 8426 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8427 8427 + printf "%s\n" "$supported" >&6; } 8176 8428 if test "$supported" = "yes" ; then 8177 8429 BASE_CFLAGS="$BASE_CFLAGS -errwarn=E_BAD_PTR_INT_COMBINATION" 8178 8430 found="yes" ··· 8197 8449 8198 8450 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8199 8451 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8200 8200 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8201 8201 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8202 8202 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8203 8203 - $as_echo_n "(cached) " >&6 8204 8204 - else 8452 8452 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8453 8453 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8454 8454 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8455 8455 + then : 8456 8456 + printf %s "(cached) " >&6 8457 8457 + else $as_nop 8205 8458 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8206 8459 /* end confdefs.h. */ 8207 8460 int i; 8208 8461 _ACEOF 8209 8209 - if ac_fn_c_try_compile "$LINENO"; then : 8462 8462 + if ac_fn_c_try_compile "$LINENO" 8463 8463 + then : 8210 8464 xorg_cv_cc_flag_unknown_warning_option=yes 8211 8211 - else 8465 8465 + else $as_nop 8212 8466 xorg_cv_cc_flag_unknown_warning_option=no 8213 8467 fi 8214 8214 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8468 8468 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8215 8469 fi 8216 8216 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8217 8217 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8470 8470 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8471 8471 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8218 8472 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8219 8473 CFLAGS="$xorg_testset_save_CFLAGS" 8220 8474 fi ··· 8224 8478 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8225 8479 fi 8226 8480 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8227 8227 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8228 8228 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8229 8229 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8230 8230 - $as_echo_n "(cached) " >&6 8231 8231 - else 8481 8481 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8482 8482 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8483 8483 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8484 8484 + then : 8485 8485 + printf %s "(cached) " >&6 8486 8486 + else $as_nop 8232 8487 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8233 8488 /* end confdefs.h. */ 8234 8489 int i; 8235 8490 _ACEOF 8236 8236 - if ac_fn_c_try_compile "$LINENO"; then : 8491 8491 + if ac_fn_c_try_compile "$LINENO" 8492 8492 + then : 8237 8493 xorg_cv_cc_flag_unused_command_line_argument=yes 8238 8238 - else 8494 8494 + else $as_nop 8239 8495 xorg_cv_cc_flag_unused_command_line_argument=no 8240 8496 fi 8241 8241 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8497 8497 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8242 8498 fi 8243 8243 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8244 8244 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8499 8499 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8500 8500 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8245 8501 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8246 8502 CFLAGS="$xorg_testset_save_CFLAGS" 8247 8503 fi ··· 8259 8515 8260 8516 CFLAGS="$CFLAGS -Werror=pointer-to-int-cast" 8261 8517 8262 8262 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=pointer-to-int-cast" >&5 8263 8263 - $as_echo_n "checking if $CC supports -Werror=pointer-to-int-cast... " >&6; } 8518 8518 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=pointer-to-int-cast" >&5 8519 8519 + printf %s "checking if $CC supports -Werror=pointer-to-int-cast... " >&6; } 8264 8520 cacheid=xorg_cv_cc_flag__Werror_pointer_to_int_cast 8265 8265 - if eval \${$cacheid+:} false; then : 8266 8266 - $as_echo_n "(cached) " >&6 8267 8267 - else 8521 8521 + if eval test \${$cacheid+y} 8522 8522 + then : 8523 8523 + printf %s "(cached) " >&6 8524 8524 + else $as_nop 8268 8525 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8269 8526 /* end confdefs.h. */ 8270 8527 int i; 8271 8528 int 8272 8272 - main () 8529 8529 + main (void) 8273 8530 { 8274 8531 8275 8532 ; 8276 8533 return 0; 8277 8534 } 8278 8535 _ACEOF 8279 8279 - if ac_fn_c_try_link "$LINENO"; then : 8536 8536 + if ac_fn_c_try_link "$LINENO" 8537 8537 + then : 8280 8538 eval $cacheid=yes 8281 8281 - else 8539 8539 + else $as_nop 8282 8540 eval $cacheid=no 8283 8541 fi 8284 8284 - rm -f core conftest.err conftest.$ac_objext \ 8542 8542 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8285 8543 conftest$ac_exeext conftest.$ac_ext 8286 8544 fi 8287 8545 ··· 8289 8547 CFLAGS="$xorg_testset_save_CFLAGS" 8290 8548 8291 8549 eval supported=\$$cacheid 8292 8292 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8293 8293 - $as_echo "$supported" >&6; } 8550 8550 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8551 8551 + printf "%s\n" "$supported" >&6; } 8294 8552 if test "$supported" = "yes" ; then 8295 8553 BASE_CFLAGS="$BASE_CFLAGS -Werror=pointer-to-int-cast" 8296 8554 found="yes" ··· 8299 8557 8300 8558 # Also -errwarn=E_BAD_PTR_INT_COMBINATION 8301 8559 else 8302 8302 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You have chosen not to turn some select compiler warnings into errors. This should not be necessary. Please report why you needed to do so in a bug report at $PACKAGE_BUGREPORT" >&5 8303 8303 - $as_echo "$as_me: WARNING: You have chosen not to turn some select compiler warnings into errors. This should not be necessary. Please report why you needed to do so in a bug report at $PACKAGE_BUGREPORT" >&2;} 8560 8560 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: You have chosen not to turn some select compiler warnings into errors. This should not be necessary. Please report why you needed to do so in a bug report at $PACKAGE_BUGREPORT" >&5 8561 8561 + printf "%s\n" "$as_me: WARNING: You have chosen not to turn some select compiler warnings into errors. This should not be necessary. Please report why you needed to do so in a bug report at $PACKAGE_BUGREPORT" >&2;} 8304 8562 8305 8563 8306 8564 ··· 8318 8576 8319 8577 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8320 8578 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8321 8321 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8322 8322 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8323 8323 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8324 8324 - $as_echo_n "(cached) " >&6 8325 8325 - else 8579 8579 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8580 8580 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8581 8581 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8582 8582 + then : 8583 8583 + printf %s "(cached) " >&6 8584 8584 + else $as_nop 8326 8585 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8327 8586 /* end confdefs.h. */ 8328 8587 int i; 8329 8588 _ACEOF 8330 8330 - if ac_fn_c_try_compile "$LINENO"; then : 8589 8589 + if ac_fn_c_try_compile "$LINENO" 8590 8590 + then : 8331 8591 xorg_cv_cc_flag_unknown_warning_option=yes 8332 8332 - else 8592 8592 + else $as_nop 8333 8593 xorg_cv_cc_flag_unknown_warning_option=no 8334 8594 fi 8335 8335 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8595 8595 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8336 8596 fi 8337 8337 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8338 8338 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8597 8597 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8598 8598 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8339 8599 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8340 8600 CFLAGS="$xorg_testset_save_CFLAGS" 8341 8601 fi ··· 8345 8605 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8346 8606 fi 8347 8607 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8348 8348 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8349 8349 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8350 8350 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8351 8351 - $as_echo_n "(cached) " >&6 8352 8352 - else 8608 8608 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8609 8609 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8610 8610 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8611 8611 + then : 8612 8612 + printf %s "(cached) " >&6 8613 8613 + else $as_nop 8353 8614 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8354 8615 /* end confdefs.h. */ 8355 8616 int i; 8356 8617 _ACEOF 8357 8357 - if ac_fn_c_try_compile "$LINENO"; then : 8618 8618 + if ac_fn_c_try_compile "$LINENO" 8619 8619 + then : 8358 8620 xorg_cv_cc_flag_unused_command_line_argument=yes 8359 8359 - else 8621 8621 + else $as_nop 8360 8622 xorg_cv_cc_flag_unused_command_line_argument=no 8361 8623 fi 8362 8362 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8624 8624 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8363 8625 fi 8364 8364 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8365 8365 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8626 8626 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8627 8627 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8366 8628 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8367 8629 CFLAGS="$xorg_testset_save_CFLAGS" 8368 8630 fi ··· 8380 8642 8381 8643 CFLAGS="$CFLAGS -Wimplicit" 8382 8644 8383 8383 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wimplicit" >&5 8384 8384 - $as_echo_n "checking if $CC supports -Wimplicit... " >&6; } 8645 8645 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wimplicit" >&5 8646 8646 + printf %s "checking if $CC supports -Wimplicit... " >&6; } 8385 8647 cacheid=xorg_cv_cc_flag__Wimplicit 8386 8386 - if eval \${$cacheid+:} false; then : 8387 8387 - $as_echo_n "(cached) " >&6 8388 8388 - else 8648 8648 + if eval test \${$cacheid+y} 8649 8649 + then : 8650 8650 + printf %s "(cached) " >&6 8651 8651 + else $as_nop 8389 8652 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8390 8653 /* end confdefs.h. */ 8391 8654 int i; 8392 8655 int 8393 8393 - main () 8656 8656 + main (void) 8394 8657 { 8395 8658 8396 8659 ; 8397 8660 return 0; 8398 8661 } 8399 8662 _ACEOF 8400 8400 - if ac_fn_c_try_link "$LINENO"; then : 8663 8663 + if ac_fn_c_try_link "$LINENO" 8664 8664 + then : 8401 8665 eval $cacheid=yes 8402 8402 - else 8666 8666 + else $as_nop 8403 8667 eval $cacheid=no 8404 8668 fi 8405 8405 - rm -f core conftest.err conftest.$ac_objext \ 8669 8669 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8406 8670 conftest$ac_exeext conftest.$ac_ext 8407 8671 fi 8408 8672 ··· 8410 8674 CFLAGS="$xorg_testset_save_CFLAGS" 8411 8675 8412 8676 eval supported=\$$cacheid 8413 8413 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8414 8414 - $as_echo "$supported" >&6; } 8677 8677 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8678 8678 + printf "%s\n" "$supported" >&6; } 8415 8679 if test "$supported" = "yes" ; then 8416 8680 BASE_CFLAGS="$BASE_CFLAGS -Wimplicit" 8417 8681 found="yes" ··· 8436 8700 8437 8701 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8438 8702 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8439 8439 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8440 8440 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8441 8441 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8442 8442 - $as_echo_n "(cached) " >&6 8443 8443 - else 8703 8703 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8704 8704 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8705 8705 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8706 8706 + then : 8707 8707 + printf %s "(cached) " >&6 8708 8708 + else $as_nop 8444 8709 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8445 8710 /* end confdefs.h. */ 8446 8711 int i; 8447 8712 _ACEOF 8448 8448 - if ac_fn_c_try_compile "$LINENO"; then : 8713 8713 + if ac_fn_c_try_compile "$LINENO" 8714 8714 + then : 8449 8715 xorg_cv_cc_flag_unknown_warning_option=yes 8450 8450 - else 8716 8716 + else $as_nop 8451 8717 xorg_cv_cc_flag_unknown_warning_option=no 8452 8718 fi 8453 8453 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8719 8719 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8454 8720 fi 8455 8455 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8456 8456 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8721 8721 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8722 8722 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8457 8723 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8458 8724 CFLAGS="$xorg_testset_save_CFLAGS" 8459 8725 fi ··· 8463 8729 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8464 8730 fi 8465 8731 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8466 8466 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8467 8467 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8468 8468 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8469 8469 - $as_echo_n "(cached) " >&6 8470 8470 - else 8732 8732 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8733 8733 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8734 8734 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8735 8735 + then : 8736 8736 + printf %s "(cached) " >&6 8737 8737 + else $as_nop 8471 8738 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8472 8739 /* end confdefs.h. */ 8473 8740 int i; 8474 8741 _ACEOF 8475 8475 - if ac_fn_c_try_compile "$LINENO"; then : 8742 8742 + if ac_fn_c_try_compile "$LINENO" 8743 8743 + then : 8476 8744 xorg_cv_cc_flag_unused_command_line_argument=yes 8477 8477 - else 8745 8745 + else $as_nop 8478 8746 xorg_cv_cc_flag_unused_command_line_argument=no 8479 8747 fi 8480 8480 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8748 8748 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8481 8749 fi 8482 8482 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8483 8483 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8750 8750 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8751 8751 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8484 8752 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8485 8753 CFLAGS="$xorg_testset_save_CFLAGS" 8486 8754 fi ··· 8498 8766 8499 8767 CFLAGS="$CFLAGS -Wnonnull" 8500 8768 8501 8501 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wnonnull" >&5 8502 8502 - $as_echo_n "checking if $CC supports -Wnonnull... " >&6; } 8769 8769 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wnonnull" >&5 8770 8770 + printf %s "checking if $CC supports -Wnonnull... " >&6; } 8503 8771 cacheid=xorg_cv_cc_flag__Wnonnull 8504 8504 - if eval \${$cacheid+:} false; then : 8505 8505 - $as_echo_n "(cached) " >&6 8506 8506 - else 8772 8772 + if eval test \${$cacheid+y} 8773 8773 + then : 8774 8774 + printf %s "(cached) " >&6 8775 8775 + else $as_nop 8507 8776 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8508 8777 /* end confdefs.h. */ 8509 8778 int i; 8510 8779 int 8511 8511 - main () 8780 8780 + main (void) 8512 8781 { 8513 8782 8514 8783 ; 8515 8784 return 0; 8516 8785 } 8517 8786 _ACEOF 8518 8518 - if ac_fn_c_try_link "$LINENO"; then : 8787 8787 + if ac_fn_c_try_link "$LINENO" 8788 8788 + then : 8519 8789 eval $cacheid=yes 8520 8520 - else 8790 8790 + else $as_nop 8521 8791 eval $cacheid=no 8522 8792 fi 8523 8523 - rm -f core conftest.err conftest.$ac_objext \ 8793 8793 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8524 8794 conftest$ac_exeext conftest.$ac_ext 8525 8795 fi 8526 8796 ··· 8528 8798 CFLAGS="$xorg_testset_save_CFLAGS" 8529 8799 8530 8800 eval supported=\$$cacheid 8531 8531 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8532 8532 - $as_echo "$supported" >&6; } 8801 8801 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8802 8802 + printf "%s\n" "$supported" >&6; } 8533 8803 if test "$supported" = "yes" ; then 8534 8804 BASE_CFLAGS="$BASE_CFLAGS -Wnonnull" 8535 8805 found="yes" ··· 8554 8824 8555 8825 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8556 8826 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8557 8557 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8558 8558 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8559 8559 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8560 8560 - $as_echo_n "(cached) " >&6 8561 8561 - else 8827 8827 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8828 8828 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8829 8829 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8830 8830 + then : 8831 8831 + printf %s "(cached) " >&6 8832 8832 + else $as_nop 8562 8833 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8563 8834 /* end confdefs.h. */ 8564 8835 int i; 8565 8836 _ACEOF 8566 8566 - if ac_fn_c_try_compile "$LINENO"; then : 8837 8837 + if ac_fn_c_try_compile "$LINENO" 8838 8838 + then : 8567 8839 xorg_cv_cc_flag_unknown_warning_option=yes 8568 8568 - else 8840 8840 + else $as_nop 8569 8841 xorg_cv_cc_flag_unknown_warning_option=no 8570 8842 fi 8571 8571 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8843 8843 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8572 8844 fi 8573 8573 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8574 8574 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8845 8845 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8846 8846 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8575 8847 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8576 8848 CFLAGS="$xorg_testset_save_CFLAGS" 8577 8849 fi ··· 8581 8853 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8582 8854 fi 8583 8855 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8584 8584 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8585 8585 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8586 8586 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8587 8587 - $as_echo_n "(cached) " >&6 8588 8588 - else 8856 8856 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8857 8857 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8858 8858 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8859 8859 + then : 8860 8860 + printf %s "(cached) " >&6 8861 8861 + else $as_nop 8589 8862 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8590 8863 /* end confdefs.h. */ 8591 8864 int i; 8592 8865 _ACEOF 8593 8593 - if ac_fn_c_try_compile "$LINENO"; then : 8866 8866 + if ac_fn_c_try_compile "$LINENO" 8867 8867 + then : 8594 8868 xorg_cv_cc_flag_unused_command_line_argument=yes 8595 8595 - else 8869 8869 + else $as_nop 8596 8870 xorg_cv_cc_flag_unused_command_line_argument=no 8597 8871 fi 8598 8598 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8872 8872 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8599 8873 fi 8600 8600 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8601 8601 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8874 8874 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8875 8875 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8602 8876 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8603 8877 CFLAGS="$xorg_testset_save_CFLAGS" 8604 8878 fi ··· 8616 8890 8617 8891 CFLAGS="$CFLAGS -Winit-self" 8618 8892 8619 8619 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Winit-self" >&5 8620 8620 - $as_echo_n "checking if $CC supports -Winit-self... " >&6; } 8893 8893 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Winit-self" >&5 8894 8894 + printf %s "checking if $CC supports -Winit-self... " >&6; } 8621 8895 cacheid=xorg_cv_cc_flag__Winit_self 8622 8622 - if eval \${$cacheid+:} false; then : 8623 8623 - $as_echo_n "(cached) " >&6 8624 8624 - else 8896 8896 + if eval test \${$cacheid+y} 8897 8897 + then : 8898 8898 + printf %s "(cached) " >&6 8899 8899 + else $as_nop 8625 8900 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8626 8901 /* end confdefs.h. */ 8627 8902 int i; 8628 8903 int 8629 8629 - main () 8904 8904 + main (void) 8630 8905 { 8631 8906 8632 8907 ; 8633 8908 return 0; 8634 8909 } 8635 8910 _ACEOF 8636 8636 - if ac_fn_c_try_link "$LINENO"; then : 8911 8911 + if ac_fn_c_try_link "$LINENO" 8912 8912 + then : 8637 8913 eval $cacheid=yes 8638 8638 - else 8914 8914 + else $as_nop 8639 8915 eval $cacheid=no 8640 8916 fi 8641 8641 - rm -f core conftest.err conftest.$ac_objext \ 8917 8917 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8642 8918 conftest$ac_exeext conftest.$ac_ext 8643 8919 fi 8644 8920 ··· 8646 8922 CFLAGS="$xorg_testset_save_CFLAGS" 8647 8923 8648 8924 eval supported=\$$cacheid 8649 8649 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8650 8650 - $as_echo "$supported" >&6; } 8925 8925 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8926 8926 + printf "%s\n" "$supported" >&6; } 8651 8927 if test "$supported" = "yes" ; then 8652 8928 BASE_CFLAGS="$BASE_CFLAGS -Winit-self" 8653 8929 found="yes" ··· 8672 8948 8673 8949 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8674 8950 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8675 8675 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8676 8676 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8677 8677 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8678 8678 - $as_echo_n "(cached) " >&6 8679 8679 - else 8951 8951 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8952 8952 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8953 8953 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 8954 8954 + then : 8955 8955 + printf %s "(cached) " >&6 8956 8956 + else $as_nop 8680 8957 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8681 8958 /* end confdefs.h. */ 8682 8959 int i; 8683 8960 _ACEOF 8684 8684 - if ac_fn_c_try_compile "$LINENO"; then : 8961 8961 + if ac_fn_c_try_compile "$LINENO" 8962 8962 + then : 8685 8963 xorg_cv_cc_flag_unknown_warning_option=yes 8686 8686 - else 8964 8964 + else $as_nop 8687 8965 xorg_cv_cc_flag_unknown_warning_option=no 8688 8966 fi 8689 8689 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8967 8967 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8690 8968 fi 8691 8691 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8692 8692 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8969 8969 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8970 8970 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8693 8971 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8694 8972 CFLAGS="$xorg_testset_save_CFLAGS" 8695 8973 fi ··· 8699 8977 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8700 8978 fi 8701 8979 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8702 8702 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8703 8703 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8704 8704 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8705 8705 - $as_echo_n "(cached) " >&6 8706 8706 - else 8980 8980 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8981 8981 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8982 8982 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 8983 8983 + then : 8984 8984 + printf %s "(cached) " >&6 8985 8985 + else $as_nop 8707 8986 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8708 8987 /* end confdefs.h. */ 8709 8988 int i; 8710 8989 _ACEOF 8711 8711 - if ac_fn_c_try_compile "$LINENO"; then : 8990 8990 + if ac_fn_c_try_compile "$LINENO" 8991 8991 + then : 8712 8992 xorg_cv_cc_flag_unused_command_line_argument=yes 8713 8713 - else 8993 8993 + else $as_nop 8714 8994 xorg_cv_cc_flag_unused_command_line_argument=no 8715 8995 fi 8716 8716 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 8996 8996 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8717 8997 fi 8718 8718 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8719 8719 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8998 8998 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8999 8999 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8720 9000 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8721 9001 CFLAGS="$xorg_testset_save_CFLAGS" 8722 9002 fi ··· 8734 9014 8735 9015 CFLAGS="$CFLAGS -Wmain" 8736 9016 8737 8737 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmain" >&5 8738 8738 - $as_echo_n "checking if $CC supports -Wmain... " >&6; } 9017 9017 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmain" >&5 9018 9018 + printf %s "checking if $CC supports -Wmain... " >&6; } 8739 9019 cacheid=xorg_cv_cc_flag__Wmain 8740 8740 - if eval \${$cacheid+:} false; then : 8741 8741 - $as_echo_n "(cached) " >&6 8742 8742 - else 9020 9020 + if eval test \${$cacheid+y} 9021 9021 + then : 9022 9022 + printf %s "(cached) " >&6 9023 9023 + else $as_nop 8743 9024 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8744 9025 /* end confdefs.h. */ 8745 9026 int i; 8746 9027 int 8747 8747 - main () 9028 9028 + main (void) 8748 9029 { 8749 9030 8750 9031 ; 8751 9032 return 0; 8752 9033 } 8753 9034 _ACEOF 8754 8754 - if ac_fn_c_try_link "$LINENO"; then : 9035 9035 + if ac_fn_c_try_link "$LINENO" 9036 9036 + then : 8755 9037 eval $cacheid=yes 8756 8756 - else 9038 9038 + else $as_nop 8757 9039 eval $cacheid=no 8758 9040 fi 8759 8759 - rm -f core conftest.err conftest.$ac_objext \ 9041 9041 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8760 9042 conftest$ac_exeext conftest.$ac_ext 8761 9043 fi 8762 9044 ··· 8764 9046 CFLAGS="$xorg_testset_save_CFLAGS" 8765 9047 8766 9048 eval supported=\$$cacheid 8767 8767 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8768 8768 - $as_echo "$supported" >&6; } 9049 9049 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9050 9050 + printf "%s\n" "$supported" >&6; } 8769 9051 if test "$supported" = "yes" ; then 8770 9052 BASE_CFLAGS="$BASE_CFLAGS -Wmain" 8771 9053 found="yes" ··· 8790 9072 8791 9073 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8792 9074 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8793 8793 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8794 8794 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8795 8795 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8796 8796 - $as_echo_n "(cached) " >&6 8797 8797 - else 9075 9075 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9076 9076 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9077 9077 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9078 9078 + then : 9079 9079 + printf %s "(cached) " >&6 9080 9080 + else $as_nop 8798 9081 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8799 9082 /* end confdefs.h. */ 8800 9083 int i; 8801 9084 _ACEOF 8802 8802 - if ac_fn_c_try_compile "$LINENO"; then : 9085 9085 + if ac_fn_c_try_compile "$LINENO" 9086 9086 + then : 8803 9087 xorg_cv_cc_flag_unknown_warning_option=yes 8804 8804 - else 9088 9088 + else $as_nop 8805 9089 xorg_cv_cc_flag_unknown_warning_option=no 8806 9090 fi 8807 8807 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9091 9091 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8808 9092 fi 8809 8809 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8810 8810 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9093 9093 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9094 9094 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8811 9095 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8812 9096 CFLAGS="$xorg_testset_save_CFLAGS" 8813 9097 fi ··· 8817 9101 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8818 9102 fi 8819 9103 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8820 8820 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8821 8821 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8822 8822 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8823 8823 - $as_echo_n "(cached) " >&6 8824 8824 - else 9104 9104 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9105 9105 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9106 9106 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9107 9107 + then : 9108 9108 + printf %s "(cached) " >&6 9109 9109 + else $as_nop 8825 9110 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8826 9111 /* end confdefs.h. */ 8827 9112 int i; 8828 9113 _ACEOF 8829 8829 - if ac_fn_c_try_compile "$LINENO"; then : 9114 9114 + if ac_fn_c_try_compile "$LINENO" 9115 9115 + then : 8830 9116 xorg_cv_cc_flag_unused_command_line_argument=yes 8831 8831 - else 9117 9117 + else $as_nop 8832 9118 xorg_cv_cc_flag_unused_command_line_argument=no 8833 9119 fi 8834 8834 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9120 9120 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8835 9121 fi 8836 8836 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8837 8837 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9122 9122 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9123 9123 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8838 9124 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8839 9125 CFLAGS="$xorg_testset_save_CFLAGS" 8840 9126 fi ··· 8852 9138 8853 9139 CFLAGS="$CFLAGS -Wmissing-braces" 8854 9140 8855 8855 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-braces" >&5 8856 8856 - $as_echo_n "checking if $CC supports -Wmissing-braces... " >&6; } 9141 9141 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wmissing-braces" >&5 9142 9142 + printf %s "checking if $CC supports -Wmissing-braces... " >&6; } 8857 9143 cacheid=xorg_cv_cc_flag__Wmissing_braces 8858 8858 - if eval \${$cacheid+:} false; then : 8859 8859 - $as_echo_n "(cached) " >&6 8860 8860 - else 9144 9144 + if eval test \${$cacheid+y} 9145 9145 + then : 9146 9146 + printf %s "(cached) " >&6 9147 9147 + else $as_nop 8861 9148 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8862 9149 /* end confdefs.h. */ 8863 9150 int i; 8864 9151 int 8865 8865 - main () 9152 9152 + main (void) 8866 9153 { 8867 9154 8868 9155 ; 8869 9156 return 0; 8870 9157 } 8871 9158 _ACEOF 8872 8872 - if ac_fn_c_try_link "$LINENO"; then : 9159 9159 + if ac_fn_c_try_link "$LINENO" 9160 9160 + then : 8873 9161 eval $cacheid=yes 8874 8874 - else 9162 9162 + else $as_nop 8875 9163 eval $cacheid=no 8876 9164 fi 8877 8877 - rm -f core conftest.err conftest.$ac_objext \ 9165 9165 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8878 9166 conftest$ac_exeext conftest.$ac_ext 8879 9167 fi 8880 9168 ··· 8882 9170 CFLAGS="$xorg_testset_save_CFLAGS" 8883 9171 8884 9172 eval supported=\$$cacheid 8885 8885 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 8886 8886 - $as_echo "$supported" >&6; } 9173 9173 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9174 9174 + printf "%s\n" "$supported" >&6; } 8887 9175 if test "$supported" = "yes" ; then 8888 9176 BASE_CFLAGS="$BASE_CFLAGS -Wmissing-braces" 8889 9177 found="yes" ··· 8908 9196 8909 9197 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 8910 9198 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8911 8911 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 8912 8912 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 8913 8913 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 8914 8914 - $as_echo_n "(cached) " >&6 8915 8915 - else 9199 9199 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9200 9200 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9201 9201 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9202 9202 + then : 9203 9203 + printf %s "(cached) " >&6 9204 9204 + else $as_nop 8916 9205 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8917 9206 /* end confdefs.h. */ 8918 9207 int i; 8919 9208 _ACEOF 8920 8920 - if ac_fn_c_try_compile "$LINENO"; then : 9209 9209 + if ac_fn_c_try_compile "$LINENO" 9210 9210 + then : 8921 9211 xorg_cv_cc_flag_unknown_warning_option=yes 8922 8922 - else 9212 9212 + else $as_nop 8923 9213 xorg_cv_cc_flag_unknown_warning_option=no 8924 9214 fi 8925 8925 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9215 9215 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8926 9216 fi 8927 8927 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 8928 8928 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9217 9217 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9218 9218 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 8929 9219 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 8930 9220 CFLAGS="$xorg_testset_save_CFLAGS" 8931 9221 fi ··· 8935 9225 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 8936 9226 fi 8937 9227 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 8938 8938 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 8939 8939 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 8940 8940 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 8941 8941 - $as_echo_n "(cached) " >&6 8942 8942 - else 9228 9228 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9229 9229 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9230 9230 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9231 9231 + then : 9232 9232 + printf %s "(cached) " >&6 9233 9233 + else $as_nop 8943 9234 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8944 9235 /* end confdefs.h. */ 8945 9236 int i; 8946 9237 _ACEOF 8947 8947 - if ac_fn_c_try_compile "$LINENO"; then : 9238 9238 + if ac_fn_c_try_compile "$LINENO" 9239 9239 + then : 8948 9240 xorg_cv_cc_flag_unused_command_line_argument=yes 8949 8949 - else 9241 9241 + else $as_nop 8950 9242 xorg_cv_cc_flag_unused_command_line_argument=no 8951 9243 fi 8952 8952 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9244 9244 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 8953 9245 fi 8954 8954 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 8955 8955 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9246 9246 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9247 9247 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 8956 9248 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 8957 9249 CFLAGS="$xorg_testset_save_CFLAGS" 8958 9250 fi ··· 8970 9262 8971 9263 CFLAGS="$CFLAGS -Wsequence-point" 8972 9264 8973 8973 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wsequence-point" >&5 8974 8974 - $as_echo_n "checking if $CC supports -Wsequence-point... " >&6; } 9265 9265 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wsequence-point" >&5 9266 9266 + printf %s "checking if $CC supports -Wsequence-point... " >&6; } 8975 9267 cacheid=xorg_cv_cc_flag__Wsequence_point 8976 8976 - if eval \${$cacheid+:} false; then : 8977 8977 - $as_echo_n "(cached) " >&6 8978 8978 - else 9268 9268 + if eval test \${$cacheid+y} 9269 9269 + then : 9270 9270 + printf %s "(cached) " >&6 9271 9271 + else $as_nop 8979 9272 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 8980 9273 /* end confdefs.h. */ 8981 9274 int i; 8982 9275 int 8983 8983 - main () 9276 9276 + main (void) 8984 9277 { 8985 9278 8986 9279 ; 8987 9280 return 0; 8988 9281 } 8989 9282 _ACEOF 8990 8990 - if ac_fn_c_try_link "$LINENO"; then : 9283 9283 + if ac_fn_c_try_link "$LINENO" 9284 9284 + then : 8991 9285 eval $cacheid=yes 8992 8992 - else 9286 9286 + else $as_nop 8993 9287 eval $cacheid=no 8994 9288 fi 8995 8995 - rm -f core conftest.err conftest.$ac_objext \ 9289 9289 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 8996 9290 conftest$ac_exeext conftest.$ac_ext 8997 9291 fi 8998 9292 ··· 9000 9294 CFLAGS="$xorg_testset_save_CFLAGS" 9001 9295 9002 9296 eval supported=\$$cacheid 9003 9003 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9004 9004 - $as_echo "$supported" >&6; } 9297 9297 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9298 9298 + printf "%s\n" "$supported" >&6; } 9005 9299 if test "$supported" = "yes" ; then 9006 9300 BASE_CFLAGS="$BASE_CFLAGS -Wsequence-point" 9007 9301 found="yes" ··· 9026 9320 9027 9321 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9028 9322 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9029 9029 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9030 9030 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9031 9031 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9032 9032 - $as_echo_n "(cached) " >&6 9033 9033 - else 9323 9323 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9324 9324 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9325 9325 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9326 9326 + then : 9327 9327 + printf %s "(cached) " >&6 9328 9328 + else $as_nop 9034 9329 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9035 9330 /* end confdefs.h. */ 9036 9331 int i; 9037 9332 _ACEOF 9038 9038 - if ac_fn_c_try_compile "$LINENO"; then : 9333 9333 + if ac_fn_c_try_compile "$LINENO" 9334 9334 + then : 9039 9335 xorg_cv_cc_flag_unknown_warning_option=yes 9040 9040 - else 9336 9336 + else $as_nop 9041 9337 xorg_cv_cc_flag_unknown_warning_option=no 9042 9338 fi 9043 9043 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9339 9339 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9044 9340 fi 9045 9045 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9046 9046 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9341 9341 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9342 9342 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9047 9343 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9048 9344 CFLAGS="$xorg_testset_save_CFLAGS" 9049 9345 fi ··· 9053 9349 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9054 9350 fi 9055 9351 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9056 9056 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9057 9057 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9058 9058 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9059 9059 - $as_echo_n "(cached) " >&6 9060 9060 - else 9352 9352 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9353 9353 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9354 9354 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9355 9355 + then : 9356 9356 + printf %s "(cached) " >&6 9357 9357 + else $as_nop 9061 9358 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9062 9359 /* end confdefs.h. */ 9063 9360 int i; 9064 9361 _ACEOF 9065 9065 - if ac_fn_c_try_compile "$LINENO"; then : 9362 9362 + if ac_fn_c_try_compile "$LINENO" 9363 9363 + then : 9066 9364 xorg_cv_cc_flag_unused_command_line_argument=yes 9067 9067 - else 9365 9365 + else $as_nop 9068 9366 xorg_cv_cc_flag_unused_command_line_argument=no 9069 9367 fi 9070 9070 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9368 9368 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9071 9369 fi 9072 9072 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9073 9073 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9370 9370 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9371 9371 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9074 9372 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9075 9373 CFLAGS="$xorg_testset_save_CFLAGS" 9076 9374 fi ··· 9088 9386 9089 9387 CFLAGS="$CFLAGS -Wreturn-type" 9090 9388 9091 9091 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wreturn-type" >&5 9092 9092 - $as_echo_n "checking if $CC supports -Wreturn-type... " >&6; } 9389 9389 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wreturn-type" >&5 9390 9390 + printf %s "checking if $CC supports -Wreturn-type... " >&6; } 9093 9391 cacheid=xorg_cv_cc_flag__Wreturn_type 9094 9094 - if eval \${$cacheid+:} false; then : 9095 9095 - $as_echo_n "(cached) " >&6 9096 9096 - else 9392 9392 + if eval test \${$cacheid+y} 9393 9393 + then : 9394 9394 + printf %s "(cached) " >&6 9395 9395 + else $as_nop 9097 9396 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9098 9397 /* end confdefs.h. */ 9099 9398 int i; 9100 9399 int 9101 9101 - main () 9400 9400 + main (void) 9102 9401 { 9103 9402 9104 9403 ; 9105 9404 return 0; 9106 9405 } 9107 9406 _ACEOF 9108 9108 - if ac_fn_c_try_link "$LINENO"; then : 9407 9407 + if ac_fn_c_try_link "$LINENO" 9408 9408 + then : 9109 9409 eval $cacheid=yes 9110 9110 - else 9410 9410 + else $as_nop 9111 9411 eval $cacheid=no 9112 9412 fi 9113 9113 - rm -f core conftest.err conftest.$ac_objext \ 9413 9413 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9114 9414 conftest$ac_exeext conftest.$ac_ext 9115 9415 fi 9116 9416 ··· 9118 9418 CFLAGS="$xorg_testset_save_CFLAGS" 9119 9419 9120 9420 eval supported=\$$cacheid 9121 9121 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9122 9122 - $as_echo "$supported" >&6; } 9421 9421 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9422 9422 + printf "%s\n" "$supported" >&6; } 9123 9423 if test "$supported" = "yes" ; then 9124 9424 BASE_CFLAGS="$BASE_CFLAGS -Wreturn-type" 9125 9425 found="yes" ··· 9144 9444 9145 9445 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9146 9446 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9147 9147 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9148 9148 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9149 9149 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9150 9150 - $as_echo_n "(cached) " >&6 9151 9151 - else 9447 9447 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9448 9448 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9449 9449 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9450 9450 + then : 9451 9451 + printf %s "(cached) " >&6 9452 9452 + else $as_nop 9152 9453 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9153 9454 /* end confdefs.h. */ 9154 9455 int i; 9155 9456 _ACEOF 9156 9156 - if ac_fn_c_try_compile "$LINENO"; then : 9457 9457 + if ac_fn_c_try_compile "$LINENO" 9458 9458 + then : 9157 9459 xorg_cv_cc_flag_unknown_warning_option=yes 9158 9158 - else 9460 9460 + else $as_nop 9159 9461 xorg_cv_cc_flag_unknown_warning_option=no 9160 9462 fi 9161 9161 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9463 9463 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9162 9464 fi 9163 9163 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9164 9164 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9465 9465 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9466 9466 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9165 9467 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9166 9468 CFLAGS="$xorg_testset_save_CFLAGS" 9167 9469 fi ··· 9171 9473 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9172 9474 fi 9173 9475 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9174 9174 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9175 9175 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9176 9176 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9177 9177 - $as_echo_n "(cached) " >&6 9178 9178 - else 9476 9476 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9477 9477 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9478 9478 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9479 9479 + then : 9480 9480 + printf %s "(cached) " >&6 9481 9481 + else $as_nop 9179 9482 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9180 9483 /* end confdefs.h. */ 9181 9484 int i; 9182 9485 _ACEOF 9183 9183 - if ac_fn_c_try_compile "$LINENO"; then : 9486 9486 + if ac_fn_c_try_compile "$LINENO" 9487 9487 + then : 9184 9488 xorg_cv_cc_flag_unused_command_line_argument=yes 9185 9185 - else 9489 9489 + else $as_nop 9186 9490 xorg_cv_cc_flag_unused_command_line_argument=no 9187 9491 fi 9188 9188 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9492 9492 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9189 9493 fi 9190 9190 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9191 9191 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9494 9494 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9495 9495 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9192 9496 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9193 9497 CFLAGS="$xorg_testset_save_CFLAGS" 9194 9498 fi ··· 9206 9510 9207 9511 CFLAGS="$CFLAGS -Wtrigraphs" 9208 9512 9209 9209 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wtrigraphs" >&5 9210 9210 - $as_echo_n "checking if $CC supports -Wtrigraphs... " >&6; } 9513 9513 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wtrigraphs" >&5 9514 9514 + printf %s "checking if $CC supports -Wtrigraphs... " >&6; } 9211 9515 cacheid=xorg_cv_cc_flag__Wtrigraphs 9212 9212 - if eval \${$cacheid+:} false; then : 9213 9213 - $as_echo_n "(cached) " >&6 9214 9214 - else 9516 9516 + if eval test \${$cacheid+y} 9517 9517 + then : 9518 9518 + printf %s "(cached) " >&6 9519 9519 + else $as_nop 9215 9520 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9216 9521 /* end confdefs.h. */ 9217 9522 int i; 9218 9523 int 9219 9219 - main () 9524 9524 + main (void) 9220 9525 { 9221 9526 9222 9527 ; 9223 9528 return 0; 9224 9529 } 9225 9530 _ACEOF 9226 9226 - if ac_fn_c_try_link "$LINENO"; then : 9531 9531 + if ac_fn_c_try_link "$LINENO" 9532 9532 + then : 9227 9533 eval $cacheid=yes 9228 9228 - else 9534 9534 + else $as_nop 9229 9535 eval $cacheid=no 9230 9536 fi 9231 9231 - rm -f core conftest.err conftest.$ac_objext \ 9537 9537 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9232 9538 conftest$ac_exeext conftest.$ac_ext 9233 9539 fi 9234 9540 ··· 9236 9542 CFLAGS="$xorg_testset_save_CFLAGS" 9237 9543 9238 9544 eval supported=\$$cacheid 9239 9239 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9240 9240 - $as_echo "$supported" >&6; } 9545 9545 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9546 9546 + printf "%s\n" "$supported" >&6; } 9241 9547 if test "$supported" = "yes" ; then 9242 9548 BASE_CFLAGS="$BASE_CFLAGS -Wtrigraphs" 9243 9549 found="yes" ··· 9262 9568 9263 9569 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9264 9570 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9265 9265 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9266 9266 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9267 9267 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9268 9268 - $as_echo_n "(cached) " >&6 9269 9269 - else 9571 9571 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9572 9572 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9573 9573 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9574 9574 + then : 9575 9575 + printf %s "(cached) " >&6 9576 9576 + else $as_nop 9270 9577 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9271 9578 /* end confdefs.h. */ 9272 9579 int i; 9273 9580 _ACEOF 9274 9274 - if ac_fn_c_try_compile "$LINENO"; then : 9581 9581 + if ac_fn_c_try_compile "$LINENO" 9582 9582 + then : 9275 9583 xorg_cv_cc_flag_unknown_warning_option=yes 9276 9276 - else 9584 9584 + else $as_nop 9277 9585 xorg_cv_cc_flag_unknown_warning_option=no 9278 9586 fi 9279 9279 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9587 9587 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9280 9588 fi 9281 9281 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9282 9282 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9589 9589 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9590 9590 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9283 9591 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9284 9592 CFLAGS="$xorg_testset_save_CFLAGS" 9285 9593 fi ··· 9289 9597 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9290 9598 fi 9291 9599 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9292 9292 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9293 9293 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9294 9294 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9295 9295 - $as_echo_n "(cached) " >&6 9296 9296 - else 9600 9600 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9601 9601 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9602 9602 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9603 9603 + then : 9604 9604 + printf %s "(cached) " >&6 9605 9605 + else $as_nop 9297 9606 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9298 9607 /* end confdefs.h. */ 9299 9608 int i; 9300 9609 _ACEOF 9301 9301 - if ac_fn_c_try_compile "$LINENO"; then : 9610 9610 + if ac_fn_c_try_compile "$LINENO" 9611 9611 + then : 9302 9612 xorg_cv_cc_flag_unused_command_line_argument=yes 9303 9303 - else 9613 9613 + else $as_nop 9304 9614 xorg_cv_cc_flag_unused_command_line_argument=no 9305 9615 fi 9306 9306 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9616 9616 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9307 9617 fi 9308 9308 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9309 9309 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9618 9618 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9619 9619 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9310 9620 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9311 9621 CFLAGS="$xorg_testset_save_CFLAGS" 9312 9622 fi ··· 9324 9634 9325 9635 CFLAGS="$CFLAGS -Warray-bounds" 9326 9636 9327 9327 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Warray-bounds" >&5 9328 9328 - $as_echo_n "checking if $CC supports -Warray-bounds... " >&6; } 9637 9637 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Warray-bounds" >&5 9638 9638 + printf %s "checking if $CC supports -Warray-bounds... " >&6; } 9329 9639 cacheid=xorg_cv_cc_flag__Warray_bounds 9330 9330 - if eval \${$cacheid+:} false; then : 9331 9331 - $as_echo_n "(cached) " >&6 9332 9332 - else 9640 9640 + if eval test \${$cacheid+y} 9641 9641 + then : 9642 9642 + printf %s "(cached) " >&6 9643 9643 + else $as_nop 9333 9644 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9334 9645 /* end confdefs.h. */ 9335 9646 int i; 9336 9647 int 9337 9337 - main () 9648 9648 + main (void) 9338 9649 { 9339 9650 9340 9651 ; 9341 9652 return 0; 9342 9653 } 9343 9654 _ACEOF 9344 9344 - if ac_fn_c_try_link "$LINENO"; then : 9655 9655 + if ac_fn_c_try_link "$LINENO" 9656 9656 + then : 9345 9657 eval $cacheid=yes 9346 9346 - else 9658 9658 + else $as_nop 9347 9659 eval $cacheid=no 9348 9660 fi 9349 9349 - rm -f core conftest.err conftest.$ac_objext \ 9661 9661 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9350 9662 conftest$ac_exeext conftest.$ac_ext 9351 9663 fi 9352 9664 ··· 9354 9666 CFLAGS="$xorg_testset_save_CFLAGS" 9355 9667 9356 9668 eval supported=\$$cacheid 9357 9357 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9358 9358 - $as_echo "$supported" >&6; } 9669 9669 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9670 9670 + printf "%s\n" "$supported" >&6; } 9359 9671 if test "$supported" = "yes" ; then 9360 9672 BASE_CFLAGS="$BASE_CFLAGS -Warray-bounds" 9361 9673 found="yes" ··· 9380 9692 9381 9693 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9382 9694 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9383 9383 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9384 9384 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9385 9385 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9386 9386 - $as_echo_n "(cached) " >&6 9387 9387 - else 9695 9695 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9696 9696 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9697 9697 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9698 9698 + then : 9699 9699 + printf %s "(cached) " >&6 9700 9700 + else $as_nop 9388 9701 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9389 9702 /* end confdefs.h. */ 9390 9703 int i; 9391 9704 _ACEOF 9392 9392 - if ac_fn_c_try_compile "$LINENO"; then : 9705 9705 + if ac_fn_c_try_compile "$LINENO" 9706 9706 + then : 9393 9707 xorg_cv_cc_flag_unknown_warning_option=yes 9394 9394 - else 9708 9708 + else $as_nop 9395 9709 xorg_cv_cc_flag_unknown_warning_option=no 9396 9710 fi 9397 9397 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9711 9711 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9398 9712 fi 9399 9399 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9400 9400 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9713 9713 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9714 9714 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9401 9715 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9402 9716 CFLAGS="$xorg_testset_save_CFLAGS" 9403 9717 fi ··· 9407 9721 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9408 9722 fi 9409 9723 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9410 9410 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9411 9411 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9412 9412 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9413 9413 - $as_echo_n "(cached) " >&6 9414 9414 - else 9724 9724 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9725 9725 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9726 9726 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9727 9727 + then : 9728 9728 + printf %s "(cached) " >&6 9729 9729 + else $as_nop 9415 9730 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9416 9731 /* end confdefs.h. */ 9417 9732 int i; 9418 9733 _ACEOF 9419 9419 - if ac_fn_c_try_compile "$LINENO"; then : 9734 9734 + if ac_fn_c_try_compile "$LINENO" 9735 9735 + then : 9420 9736 xorg_cv_cc_flag_unused_command_line_argument=yes 9421 9421 - else 9737 9737 + else $as_nop 9422 9738 xorg_cv_cc_flag_unused_command_line_argument=no 9423 9739 fi 9424 9424 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9740 9740 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9425 9741 fi 9426 9426 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9427 9427 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9742 9742 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9743 9743 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9428 9744 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9429 9745 CFLAGS="$xorg_testset_save_CFLAGS" 9430 9746 fi ··· 9442 9758 9443 9759 CFLAGS="$CFLAGS -Wwrite-strings" 9444 9760 9445 9445 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wwrite-strings" >&5 9446 9446 - $as_echo_n "checking if $CC supports -Wwrite-strings... " >&6; } 9761 9761 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wwrite-strings" >&5 9762 9762 + printf %s "checking if $CC supports -Wwrite-strings... " >&6; } 9447 9763 cacheid=xorg_cv_cc_flag__Wwrite_strings 9448 9448 - if eval \${$cacheid+:} false; then : 9449 9449 - $as_echo_n "(cached) " >&6 9450 9450 - else 9764 9764 + if eval test \${$cacheid+y} 9765 9765 + then : 9766 9766 + printf %s "(cached) " >&6 9767 9767 + else $as_nop 9451 9768 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9452 9769 /* end confdefs.h. */ 9453 9770 int i; 9454 9771 int 9455 9455 - main () 9772 9772 + main (void) 9456 9773 { 9457 9774 9458 9775 ; 9459 9776 return 0; 9460 9777 } 9461 9778 _ACEOF 9462 9462 - if ac_fn_c_try_link "$LINENO"; then : 9779 9779 + if ac_fn_c_try_link "$LINENO" 9780 9780 + then : 9463 9781 eval $cacheid=yes 9464 9464 - else 9782 9782 + else $as_nop 9465 9783 eval $cacheid=no 9466 9784 fi 9467 9467 - rm -f core conftest.err conftest.$ac_objext \ 9785 9785 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9468 9786 conftest$ac_exeext conftest.$ac_ext 9469 9787 fi 9470 9788 ··· 9472 9790 CFLAGS="$xorg_testset_save_CFLAGS" 9473 9791 9474 9792 eval supported=\$$cacheid 9475 9475 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9476 9476 - $as_echo "$supported" >&6; } 9793 9793 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9794 9794 + printf "%s\n" "$supported" >&6; } 9477 9795 if test "$supported" = "yes" ; then 9478 9796 BASE_CFLAGS="$BASE_CFLAGS -Wwrite-strings" 9479 9797 found="yes" ··· 9498 9816 9499 9817 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9500 9818 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9501 9501 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9502 9502 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9503 9503 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9504 9504 - $as_echo_n "(cached) " >&6 9505 9505 - else 9819 9819 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9820 9820 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9821 9821 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9822 9822 + then : 9823 9823 + printf %s "(cached) " >&6 9824 9824 + else $as_nop 9506 9825 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9507 9826 /* end confdefs.h. */ 9508 9827 int i; 9509 9828 _ACEOF 9510 9510 - if ac_fn_c_try_compile "$LINENO"; then : 9829 9829 + if ac_fn_c_try_compile "$LINENO" 9830 9830 + then : 9511 9831 xorg_cv_cc_flag_unknown_warning_option=yes 9512 9512 - else 9832 9832 + else $as_nop 9513 9833 xorg_cv_cc_flag_unknown_warning_option=no 9514 9834 fi 9515 9515 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9835 9835 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9516 9836 fi 9517 9517 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9518 9518 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9837 9837 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9838 9838 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9519 9839 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9520 9840 CFLAGS="$xorg_testset_save_CFLAGS" 9521 9841 fi ··· 9525 9845 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9526 9846 fi 9527 9847 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9528 9528 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9529 9529 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9530 9530 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9531 9531 - $as_echo_n "(cached) " >&6 9532 9532 - else 9848 9848 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9849 9849 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9850 9850 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9851 9851 + then : 9852 9852 + printf %s "(cached) " >&6 9853 9853 + else $as_nop 9533 9854 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9534 9855 /* end confdefs.h. */ 9535 9856 int i; 9536 9857 _ACEOF 9537 9537 - if ac_fn_c_try_compile "$LINENO"; then : 9858 9858 + if ac_fn_c_try_compile "$LINENO" 9859 9859 + then : 9538 9860 xorg_cv_cc_flag_unused_command_line_argument=yes 9539 9539 - else 9861 9861 + else $as_nop 9540 9862 xorg_cv_cc_flag_unused_command_line_argument=no 9541 9863 fi 9542 9542 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9864 9864 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9543 9865 fi 9544 9544 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9545 9545 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9866 9866 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9867 9867 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9546 9868 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9547 9869 CFLAGS="$xorg_testset_save_CFLAGS" 9548 9870 fi ··· 9560 9882 9561 9883 CFLAGS="$CFLAGS -Waddress" 9562 9884 9563 9563 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Waddress" >&5 9564 9564 - $as_echo_n "checking if $CC supports -Waddress... " >&6; } 9885 9885 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Waddress" >&5 9886 9886 + printf %s "checking if $CC supports -Waddress... " >&6; } 9565 9887 cacheid=xorg_cv_cc_flag__Waddress 9566 9566 - if eval \${$cacheid+:} false; then : 9567 9567 - $as_echo_n "(cached) " >&6 9568 9568 - else 9888 9888 + if eval test \${$cacheid+y} 9889 9889 + then : 9890 9890 + printf %s "(cached) " >&6 9891 9891 + else $as_nop 9569 9892 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9570 9893 /* end confdefs.h. */ 9571 9894 int i; 9572 9895 int 9573 9573 - main () 9896 9896 + main (void) 9574 9897 { 9575 9898 9576 9899 ; 9577 9900 return 0; 9578 9901 } 9579 9902 _ACEOF 9580 9580 - if ac_fn_c_try_link "$LINENO"; then : 9903 9903 + if ac_fn_c_try_link "$LINENO" 9904 9904 + then : 9581 9905 eval $cacheid=yes 9582 9582 - else 9906 9906 + else $as_nop 9583 9907 eval $cacheid=no 9584 9908 fi 9585 9585 - rm -f core conftest.err conftest.$ac_objext \ 9909 9909 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9586 9910 conftest$ac_exeext conftest.$ac_ext 9587 9911 fi 9588 9912 ··· 9590 9914 CFLAGS="$xorg_testset_save_CFLAGS" 9591 9915 9592 9916 eval supported=\$$cacheid 9593 9593 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9594 9594 - $as_echo "$supported" >&6; } 9917 9917 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9918 9918 + printf "%s\n" "$supported" >&6; } 9595 9919 if test "$supported" = "yes" ; then 9596 9920 BASE_CFLAGS="$BASE_CFLAGS -Waddress" 9597 9921 found="yes" ··· 9616 9940 9617 9941 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9618 9942 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9619 9619 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9620 9620 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9621 9621 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9622 9622 - $as_echo_n "(cached) " >&6 9623 9623 - else 9943 9943 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9944 9944 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9945 9945 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 9946 9946 + then : 9947 9947 + printf %s "(cached) " >&6 9948 9948 + else $as_nop 9624 9949 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9625 9950 /* end confdefs.h. */ 9626 9951 int i; 9627 9952 _ACEOF 9628 9628 - if ac_fn_c_try_compile "$LINENO"; then : 9953 9953 + if ac_fn_c_try_compile "$LINENO" 9954 9954 + then : 9629 9955 xorg_cv_cc_flag_unknown_warning_option=yes 9630 9630 - else 9956 9956 + else $as_nop 9631 9957 xorg_cv_cc_flag_unknown_warning_option=no 9632 9958 fi 9633 9633 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9959 9959 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9634 9960 fi 9635 9635 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9636 9636 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9961 9961 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9962 9962 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9637 9963 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9638 9964 CFLAGS="$xorg_testset_save_CFLAGS" 9639 9965 fi ··· 9643 9969 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9644 9970 fi 9645 9971 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9646 9646 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9647 9647 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9648 9648 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9649 9649 - $as_echo_n "(cached) " >&6 9650 9650 - else 9972 9972 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9973 9973 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9974 9974 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 9975 9975 + then : 9976 9976 + printf %s "(cached) " >&6 9977 9977 + else $as_nop 9651 9978 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9652 9979 /* end confdefs.h. */ 9653 9980 int i; 9654 9981 _ACEOF 9655 9655 - if ac_fn_c_try_compile "$LINENO"; then : 9982 9982 + if ac_fn_c_try_compile "$LINENO" 9983 9983 + then : 9656 9984 xorg_cv_cc_flag_unused_command_line_argument=yes 9657 9657 - else 9985 9985 + else $as_nop 9658 9986 xorg_cv_cc_flag_unused_command_line_argument=no 9659 9987 fi 9660 9660 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 9988 9988 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9661 9989 fi 9662 9662 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9663 9663 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9990 9990 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9991 9991 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9664 9992 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9665 9993 CFLAGS="$xorg_testset_save_CFLAGS" 9666 9994 fi ··· 9678 10006 9679 10007 CFLAGS="$CFLAGS -Wint-to-pointer-cast" 9680 10008 9681 9681 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wint-to-pointer-cast" >&5 9682 9682 - $as_echo_n "checking if $CC supports -Wint-to-pointer-cast... " >&6; } 10009 10009 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wint-to-pointer-cast" >&5 10010 10010 + printf %s "checking if $CC supports -Wint-to-pointer-cast... " >&6; } 9683 10011 cacheid=xorg_cv_cc_flag__Wint_to_pointer_cast 9684 9684 - if eval \${$cacheid+:} false; then : 9685 9685 - $as_echo_n "(cached) " >&6 9686 9686 - else 10012 10012 + if eval test \${$cacheid+y} 10013 10013 + then : 10014 10014 + printf %s "(cached) " >&6 10015 10015 + else $as_nop 9687 10016 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9688 10017 /* end confdefs.h. */ 9689 10018 int i; 9690 10019 int 9691 9691 - main () 10020 10020 + main (void) 9692 10021 { 9693 10022 9694 10023 ; 9695 10024 return 0; 9696 10025 } 9697 10026 _ACEOF 9698 9698 - if ac_fn_c_try_link "$LINENO"; then : 10027 10027 + if ac_fn_c_try_link "$LINENO" 10028 10028 + then : 9699 10029 eval $cacheid=yes 9700 9700 - else 10030 10030 + else $as_nop 9701 10031 eval $cacheid=no 9702 10032 fi 9703 9703 - rm -f core conftest.err conftest.$ac_objext \ 10033 10033 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9704 10034 conftest$ac_exeext conftest.$ac_ext 9705 10035 fi 9706 10036 ··· 9708 10038 CFLAGS="$xorg_testset_save_CFLAGS" 9709 10039 9710 10040 eval supported=\$$cacheid 9711 9711 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9712 9712 - $as_echo "$supported" >&6; } 10041 10041 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10042 10042 + printf "%s\n" "$supported" >&6; } 9713 10043 if test "$supported" = "yes" ; then 9714 10044 BASE_CFLAGS="$BASE_CFLAGS -Wint-to-pointer-cast" 9715 10045 found="yes" ··· 9734 10064 9735 10065 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9736 10066 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9737 9737 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9738 9738 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9739 9739 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9740 9740 - $as_echo_n "(cached) " >&6 9741 9741 - else 10067 10067 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 10068 10068 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 10069 10069 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 10070 10070 + then : 10071 10071 + printf %s "(cached) " >&6 10072 10072 + else $as_nop 9742 10073 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9743 10074 /* end confdefs.h. */ 9744 10075 int i; 9745 10076 _ACEOF 9746 9746 - if ac_fn_c_try_compile "$LINENO"; then : 10077 10077 + if ac_fn_c_try_compile "$LINENO" 10078 10078 + then : 9747 10079 xorg_cv_cc_flag_unknown_warning_option=yes 9748 9748 - else 10080 10080 + else $as_nop 9749 10081 xorg_cv_cc_flag_unknown_warning_option=no 9750 10082 fi 9751 9751 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10083 10083 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9752 10084 fi 9753 9753 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9754 9754 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 10085 10085 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 10086 10086 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9755 10087 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9756 10088 CFLAGS="$xorg_testset_save_CFLAGS" 9757 10089 fi ··· 9761 10093 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9762 10094 fi 9763 10095 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9764 9764 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9765 9765 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9766 9766 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9767 9767 - $as_echo_n "(cached) " >&6 9768 9768 - else 10096 10096 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 10097 10097 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 10098 10098 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 10099 10099 + then : 10100 10100 + printf %s "(cached) " >&6 10101 10101 + else $as_nop 9769 10102 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9770 10103 /* end confdefs.h. */ 9771 10104 int i; 9772 10105 _ACEOF 9773 9773 - if ac_fn_c_try_compile "$LINENO"; then : 10106 10106 + if ac_fn_c_try_compile "$LINENO" 10107 10107 + then : 9774 10108 xorg_cv_cc_flag_unused_command_line_argument=yes 9775 9775 - else 10109 10109 + else $as_nop 9776 10110 xorg_cv_cc_flag_unused_command_line_argument=no 9777 10111 fi 9778 9778 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10112 10112 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9779 10113 fi 9780 9780 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9781 9781 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 10114 10114 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 10115 10115 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9782 10116 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9783 10117 CFLAGS="$xorg_testset_save_CFLAGS" 9784 10118 fi ··· 9796 10130 9797 10131 CFLAGS="$CFLAGS -Wpointer-to-int-cast" 9798 10132 9799 9799 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wpointer-to-int-cast" >&5 9800 9800 - $as_echo_n "checking if $CC supports -Wpointer-to-int-cast... " >&6; } 10133 10133 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Wpointer-to-int-cast" >&5 10134 10134 + printf %s "checking if $CC supports -Wpointer-to-int-cast... " >&6; } 9801 10135 cacheid=xorg_cv_cc_flag__Wpointer_to_int_cast 9802 9802 - if eval \${$cacheid+:} false; then : 9803 9803 - $as_echo_n "(cached) " >&6 9804 9804 - else 10136 10136 + if eval test \${$cacheid+y} 10137 10137 + then : 10138 10138 + printf %s "(cached) " >&6 10139 10139 + else $as_nop 9805 10140 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9806 10141 /* end confdefs.h. */ 9807 10142 int i; 9808 10143 int 9809 9809 - main () 10144 10144 + main (void) 9810 10145 { 9811 10146 9812 10147 ; 9813 10148 return 0; 9814 10149 } 9815 10150 _ACEOF 9816 9816 - if ac_fn_c_try_link "$LINENO"; then : 10151 10151 + if ac_fn_c_try_link "$LINENO" 10152 10152 + then : 9817 10153 eval $cacheid=yes 9818 9818 - else 10154 10154 + else $as_nop 9819 10155 eval $cacheid=no 9820 10156 fi 9821 9821 - rm -f core conftest.err conftest.$ac_objext \ 10157 10157 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9822 10158 conftest$ac_exeext conftest.$ac_ext 9823 10159 fi 9824 10160 ··· 9826 10162 CFLAGS="$xorg_testset_save_CFLAGS" 9827 10163 9828 10164 eval supported=\$$cacheid 9829 9829 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9830 9830 - $as_echo "$supported" >&6; } 10165 10165 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10166 10166 + printf "%s\n" "$supported" >&6; } 9831 10167 if test "$supported" = "yes" ; then 9832 10168 BASE_CFLAGS="$BASE_CFLAGS -Wpointer-to-int-cast" 9833 10169 found="yes" ··· 9856 10192 9857 10193 9858 10194 # Check whether --enable-strict-compilation was given. 9859 9859 - if test "${enable_strict_compilation+set}" = set; then : 10195 10195 + if test ${enable_strict_compilation+y} 10196 10196 + then : 9860 10197 enableval=$enable_strict_compilation; STRICT_COMPILE=$enableval 9861 9861 - else 10198 10198 + else $as_nop 9862 10199 STRICT_COMPILE=no 9863 10200 fi 9864 10201 ··· 9885 10222 9886 10223 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 9887 10224 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9888 9888 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 9889 9889 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 9890 9890 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 9891 9891 - $as_echo_n "(cached) " >&6 9892 9892 - else 10225 10225 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 10226 10226 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 10227 10227 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 10228 10228 + then : 10229 10229 + printf %s "(cached) " >&6 10230 10230 + else $as_nop 9893 10231 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9894 10232 /* end confdefs.h. */ 9895 10233 int i; 9896 10234 _ACEOF 9897 9897 - if ac_fn_c_try_compile "$LINENO"; then : 10235 10235 + if ac_fn_c_try_compile "$LINENO" 10236 10236 + then : 9898 10237 xorg_cv_cc_flag_unknown_warning_option=yes 9899 9899 - else 10238 10238 + else $as_nop 9900 10239 xorg_cv_cc_flag_unknown_warning_option=no 9901 10240 fi 9902 9902 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10241 10241 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9903 10242 fi 9904 9904 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 9905 9905 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 10243 10243 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 10244 10244 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 9906 10245 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 9907 10246 CFLAGS="$xorg_testset_save_CFLAGS" 9908 10247 fi ··· 9912 10251 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 9913 10252 fi 9914 10253 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 9915 9915 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 9916 9916 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 9917 9917 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 9918 9918 - $as_echo_n "(cached) " >&6 9919 9919 - else 10254 10254 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 10255 10255 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 10256 10256 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 10257 10257 + then : 10258 10258 + printf %s "(cached) " >&6 10259 10259 + else $as_nop 9920 10260 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9921 10261 /* end confdefs.h. */ 9922 10262 int i; 9923 10263 _ACEOF 9924 9924 - if ac_fn_c_try_compile "$LINENO"; then : 10264 10264 + if ac_fn_c_try_compile "$LINENO" 10265 10265 + then : 9925 10266 xorg_cv_cc_flag_unused_command_line_argument=yes 9926 9926 - else 10267 10267 + else $as_nop 9927 10268 xorg_cv_cc_flag_unused_command_line_argument=no 9928 10269 fi 9929 9929 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10270 10270 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 9930 10271 fi 9931 9931 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 9932 9932 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 10272 10272 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 10273 10273 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 9933 10274 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 9934 10275 CFLAGS="$xorg_testset_save_CFLAGS" 9935 10276 fi ··· 9947 10288 9948 10289 CFLAGS="$CFLAGS -pedantic" 9949 10290 9950 9950 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -pedantic" >&5 9951 9951 - $as_echo_n "checking if $CC supports -pedantic... " >&6; } 10291 10291 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -pedantic" >&5 10292 10292 + printf %s "checking if $CC supports -pedantic... " >&6; } 9952 10293 cacheid=xorg_cv_cc_flag__pedantic 9953 9953 - if eval \${$cacheid+:} false; then : 9954 9954 - $as_echo_n "(cached) " >&6 9955 9955 - else 10294 10294 + if eval test \${$cacheid+y} 10295 10295 + then : 10296 10296 + printf %s "(cached) " >&6 10297 10297 + else $as_nop 9956 10298 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 9957 10299 /* end confdefs.h. */ 9958 10300 int i; 9959 10301 int 9960 9960 - main () 10302 10302 + main (void) 9961 10303 { 9962 10304 9963 10305 ; 9964 10306 return 0; 9965 10307 } 9966 10308 _ACEOF 9967 9967 - if ac_fn_c_try_link "$LINENO"; then : 10309 10309 + if ac_fn_c_try_link "$LINENO" 10310 10310 + then : 9968 10311 eval $cacheid=yes 9969 9969 - else 10312 10312 + else $as_nop 9970 10313 eval $cacheid=no 9971 10314 fi 9972 9972 - rm -f core conftest.err conftest.$ac_objext \ 10315 10315 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 9973 10316 conftest$ac_exeext conftest.$ac_ext 9974 10317 fi 9975 10318 ··· 9977 10320 CFLAGS="$xorg_testset_save_CFLAGS" 9978 10321 9979 10322 eval supported=\$$cacheid 9980 9980 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 9981 9981 - $as_echo "$supported" >&6; } 10323 10323 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10324 10324 + printf "%s\n" "$supported" >&6; } 9982 10325 if test "$supported" = "yes" ; then 9983 10326 STRICT_CFLAGS="$STRICT_CFLAGS -pedantic" 9984 10327 found="yes" ··· 10003 10346 10004 10347 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 10005 10348 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 10006 10006 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 10007 10007 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 10008 10008 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 10009 10009 - $as_echo_n "(cached) " >&6 10010 10010 - else 10349 10349 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 10350 10350 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 10351 10351 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 10352 10352 + then : 10353 10353 + printf %s "(cached) " >&6 10354 10354 + else $as_nop 10011 10355 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10012 10356 /* end confdefs.h. */ 10013 10357 int i; 10014 10358 _ACEOF 10015 10015 - if ac_fn_c_try_compile "$LINENO"; then : 10359 10359 + if ac_fn_c_try_compile "$LINENO" 10360 10360 + then : 10016 10361 xorg_cv_cc_flag_unknown_warning_option=yes 10017 10017 - else 10362 10362 + else $as_nop 10018 10363 xorg_cv_cc_flag_unknown_warning_option=no 10019 10364 fi 10020 10020 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10365 10365 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 10021 10366 fi 10022 10022 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 10023 10023 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 10367 10367 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 10368 10368 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 10024 10369 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 10025 10370 CFLAGS="$xorg_testset_save_CFLAGS" 10026 10371 fi ··· 10030 10375 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 10031 10376 fi 10032 10377 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 10033 10033 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 10034 10034 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 10035 10035 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 10036 10036 - $as_echo_n "(cached) " >&6 10037 10037 - else 10378 10378 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 10379 10379 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 10380 10380 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 10381 10381 + then : 10382 10382 + printf %s "(cached) " >&6 10383 10383 + else $as_nop 10038 10384 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10039 10385 /* end confdefs.h. */ 10040 10386 int i; 10041 10387 _ACEOF 10042 10042 - if ac_fn_c_try_compile "$LINENO"; then : 10388 10388 + if ac_fn_c_try_compile "$LINENO" 10389 10389 + then : 10043 10390 xorg_cv_cc_flag_unused_command_line_argument=yes 10044 10044 - else 10391 10391 + else $as_nop 10045 10392 xorg_cv_cc_flag_unused_command_line_argument=no 10046 10393 fi 10047 10047 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10394 10394 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 10048 10395 fi 10049 10049 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 10050 10050 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 10396 10396 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 10397 10397 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 10051 10398 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 10052 10399 CFLAGS="$xorg_testset_save_CFLAGS" 10053 10400 fi ··· 10065 10412 10066 10413 CFLAGS="$CFLAGS -Werror" 10067 10414 10068 10068 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror" >&5 10069 10069 - $as_echo_n "checking if $CC supports -Werror... " >&6; } 10415 10415 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror" >&5 10416 10416 + printf %s "checking if $CC supports -Werror... " >&6; } 10070 10417 cacheid=xorg_cv_cc_flag__Werror 10071 10071 - if eval \${$cacheid+:} false; then : 10072 10072 - $as_echo_n "(cached) " >&6 10073 10073 - else 10418 10418 + if eval test \${$cacheid+y} 10419 10419 + then : 10420 10420 + printf %s "(cached) " >&6 10421 10421 + else $as_nop 10074 10422 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10075 10423 /* end confdefs.h. */ 10076 10424 int i; 10077 10425 int 10078 10078 - main () 10426 10426 + main (void) 10079 10427 { 10080 10428 10081 10429 ; 10082 10430 return 0; 10083 10431 } 10084 10432 _ACEOF 10085 10085 - if ac_fn_c_try_link "$LINENO"; then : 10433 10433 + if ac_fn_c_try_link "$LINENO" 10434 10434 + then : 10086 10435 eval $cacheid=yes 10087 10087 - else 10436 10436 + else $as_nop 10088 10437 eval $cacheid=no 10089 10438 fi 10090 10090 - rm -f core conftest.err conftest.$ac_objext \ 10439 10439 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 10091 10440 conftest$ac_exeext conftest.$ac_ext 10092 10441 fi 10093 10442 ··· 10095 10444 CFLAGS="$xorg_testset_save_CFLAGS" 10096 10445 10097 10446 eval supported=\$$cacheid 10098 10098 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10099 10099 - $as_echo "$supported" >&6; } 10447 10447 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10448 10448 + printf "%s\n" "$supported" >&6; } 10100 10449 if test "$supported" = "yes" ; then 10101 10450 STRICT_CFLAGS="$STRICT_CFLAGS -Werror" 10102 10451 found="yes" ··· 10114 10463 10115 10464 CFLAGS="$CFLAGS -errwarn" 10116 10465 10117 10117 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn" >&5 10118 10118 - $as_echo_n "checking if $CC supports -errwarn... " >&6; } 10466 10466 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -errwarn" >&5 10467 10467 + printf %s "checking if $CC supports -errwarn... " >&6; } 10119 10468 cacheid=xorg_cv_cc_flag__errwarn 10120 10120 - if eval \${$cacheid+:} false; then : 10121 10121 - $as_echo_n "(cached) " >&6 10122 10122 - else 10469 10469 + if eval test \${$cacheid+y} 10470 10470 + then : 10471 10471 + printf %s "(cached) " >&6 10472 10472 + else $as_nop 10123 10473 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10124 10474 /* end confdefs.h. */ 10125 10475 int i; 10126 10476 int 10127 10127 - main () 10477 10477 + main (void) 10128 10478 { 10129 10479 10130 10480 ; 10131 10481 return 0; 10132 10482 } 10133 10483 _ACEOF 10134 10134 - if ac_fn_c_try_link "$LINENO"; then : 10484 10484 + if ac_fn_c_try_link "$LINENO" 10485 10485 + then : 10135 10486 eval $cacheid=yes 10136 10136 - else 10487 10487 + else $as_nop 10137 10488 eval $cacheid=no 10138 10489 fi 10139 10139 - rm -f core conftest.err conftest.$ac_objext \ 10490 10490 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 10140 10491 conftest$ac_exeext conftest.$ac_ext 10141 10492 fi 10142 10493 ··· 10144 10495 CFLAGS="$xorg_testset_save_CFLAGS" 10145 10496 10146 10497 eval supported=\$$cacheid 10147 10147 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10148 10148 - $as_echo "$supported" >&6; } 10498 10498 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10499 10499 + printf "%s\n" "$supported" >&6; } 10149 10500 if test "$supported" = "yes" ; then 10150 10501 STRICT_CFLAGS="$STRICT_CFLAGS -errwarn" 10151 10502 found="yes" ··· 10173 10524 10174 10525 if test "x$xorg_testset_cc_unknown_warning_option" = "x" ; then 10175 10526 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 10176 10176 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 10177 10177 - $as_echo_n "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 10178 10178 - if ${xorg_cv_cc_flag_unknown_warning_option+:} false; then : 10179 10179 - $as_echo_n "(cached) " >&6 10180 10180 - else 10527 10527 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unknown-warning-option" >&5 10528 10528 + printf %s "checking if $CC supports -Werror=unknown-warning-option... " >&6; } 10529 10529 + if test ${xorg_cv_cc_flag_unknown_warning_option+y} 10530 10530 + then : 10531 10531 + printf %s "(cached) " >&6 10532 10532 + else $as_nop 10181 10533 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10182 10534 /* end confdefs.h. */ 10183 10535 int i; 10184 10536 _ACEOF 10185 10185 - if ac_fn_c_try_compile "$LINENO"; then : 10537 10537 + if ac_fn_c_try_compile "$LINENO" 10538 10538 + then : 10186 10539 xorg_cv_cc_flag_unknown_warning_option=yes 10187 10187 - else 10540 10540 + else $as_nop 10188 10541 xorg_cv_cc_flag_unknown_warning_option=no 10189 10542 fi 10190 10190 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10543 10543 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 10191 10544 fi 10192 10192 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 10193 10193 - $as_echo "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 10545 10545 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unknown_warning_option" >&5 10546 10546 + printf "%s\n" "$xorg_cv_cc_flag_unknown_warning_option" >&6; } 10194 10547 xorg_testset_cc_unknown_warning_option=$xorg_cv_cc_flag_unknown_warning_option 10195 10548 CFLAGS="$xorg_testset_save_CFLAGS" 10196 10549 fi ··· 10200 10553 CFLAGS="$CFLAGS -Werror=unknown-warning-option" 10201 10554 fi 10202 10555 CFLAGS="$CFLAGS -Werror=unused-command-line-argument" 10203 10203 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 10204 10204 - $as_echo_n "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 10205 10205 - if ${xorg_cv_cc_flag_unused_command_line_argument+:} false; then : 10206 10206 - $as_echo_n "(cached) " >&6 10207 10207 - else 10556 10556 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=unused-command-line-argument" >&5 10557 10557 + printf %s "checking if $CC supports -Werror=unused-command-line-argument... " >&6; } 10558 10558 + if test ${xorg_cv_cc_flag_unused_command_line_argument+y} 10559 10559 + then : 10560 10560 + printf %s "(cached) " >&6 10561 10561 + else $as_nop 10208 10562 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10209 10563 /* end confdefs.h. */ 10210 10564 int i; 10211 10565 _ACEOF 10212 10212 - if ac_fn_c_try_compile "$LINENO"; then : 10566 10566 + if ac_fn_c_try_compile "$LINENO" 10567 10567 + then : 10213 10568 xorg_cv_cc_flag_unused_command_line_argument=yes 10214 10214 - else 10569 10569 + else $as_nop 10215 10570 xorg_cv_cc_flag_unused_command_line_argument=no 10216 10571 fi 10217 10217 - rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 10572 10572 + rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext 10218 10573 fi 10219 10219 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 10220 10220 - $as_echo "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 10574 10574 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xorg_cv_cc_flag_unused_command_line_argument" >&5 10575 10575 + printf "%s\n" "$xorg_cv_cc_flag_unused_command_line_argument" >&6; } 10221 10576 xorg_testset_cc_unused_command_line_argument=$xorg_cv_cc_flag_unused_command_line_argument 10222 10577 CFLAGS="$xorg_testset_save_CFLAGS" 10223 10578 fi ··· 10235 10590 10236 10591 CFLAGS="$CFLAGS -Werror=attributes" 10237 10592 10238 10238 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=attributes" >&5 10239 10239 - $as_echo_n "checking if $CC supports -Werror=attributes... " >&6; } 10593 10593 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC supports -Werror=attributes" >&5 10594 10594 + printf %s "checking if $CC supports -Werror=attributes... " >&6; } 10240 10595 cacheid=xorg_cv_cc_flag__Werror_attributes 10241 10241 - if eval \${$cacheid+:} false; then : 10242 10242 - $as_echo_n "(cached) " >&6 10243 10243 - else 10596 10596 + if eval test \${$cacheid+y} 10597 10597 + then : 10598 10598 + printf %s "(cached) " >&6 10599 10599 + else $as_nop 10244 10600 cat confdefs.h - <<_ACEOF >conftest.$ac_ext 10245 10601 /* end confdefs.h. */ 10246 10602 int i; 10247 10603 int 10248 10248 - main () 10604 10604 + main (void) 10249 10605 { 10250 10606 10251 10607 ; 10252 10608 return 0; 10253 10609 } 10254 10610 _ACEOF 10255 10255 - if ac_fn_c_try_link "$LINENO"; then : 10611 10611 + if ac_fn_c_try_link "$LINENO" 10612 10612 + then : 10256 10613 eval $cacheid=yes 10257 10257 - else 10614 10614 + else $as_nop 10258 10615 eval $cacheid=no 10259 10616 fi 10260 10260 - rm -f core conftest.err conftest.$ac_objext \ 10617 10617 + rm -f core conftest.err conftest.$ac_objext conftest.beam \ 10261 10618 conftest$ac_exeext conftest.$ac_ext 10262 10619 fi 10263 10620 ··· 10265 10622 CFLAGS="$xorg_testset_save_CFLAGS" 10266 10623 10267 10624 eval supported=\$$cacheid 10268 10268 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10269 10269 - $as_echo "$supported" >&6; } 10625 10625 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supported" >&5 10626 10626 + printf "%s\n" "$supported" >&6; } 10270 10627 if test "$supported" = "yes" ; then 10271 10628 STRICT_CFLAGS="$STRICT_CFLAGS -Werror=attributes" 10272 10629 found="yes" ··· 10285 10642 10286 10643 10287 10644 10645 10645 + 10646 10646 + 10288 10647 cat >>confdefs.h <<_ACEOF 10289 10648 #define PACKAGE_VERSION_MAJOR `echo $PACKAGE_VERSION | cut -d . -f 1` 10290 10649 _ACEOF ··· 10294 10653 PVM="0" 10295 10654 fi 10296 10655 10297 10297 - cat >>confdefs.h <<_ACEOF 10298 10298 - #define PACKAGE_VERSION_MINOR $PVM 10299 10299 - _ACEOF 10656 10656 + printf "%s\n" "#define PACKAGE_VERSION_MINOR $PVM" >>confdefs.h 10300 10657 10301 10658 PVP=`echo $PACKAGE_VERSION | cut -d . -f 3 | cut -d - -f 1` 10302 10659 if test "x$PVP" = "x"; then 10303 10660 PVP="0" 10304 10661 fi 10305 10662 10306 10306 - cat >>confdefs.h <<_ACEOF 10307 10307 - #define PACKAGE_VERSION_PATCHLEVEL $PVP 10308 10308 - _ACEOF 10663 10663 + printf "%s\n" "#define PACKAGE_VERSION_PATCHLEVEL $PVP" >>confdefs.h 10309 10664 10310 10665 10311 10666 ··· 10335 10690 # Solaris 2.0 - 11.3 use SysV man page section numbers, so we 10336 10691 # check for a man page file found in later versions that use 10337 10692 # traditional section numbers instead 10338 10338 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/man/man7/attributes.7" >&5 10339 10339 - $as_echo_n "checking for /usr/share/man/man7/attributes.7... " >&6; } 10340 10340 - if ${ac_cv_file__usr_share_man_man7_attributes_7+:} false; then : 10341 10341 - $as_echo_n "(cached) " >&6 10342 10342 - else 10693 10693 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for /usr/share/man/man7/attributes.7" >&5 10694 10694 + printf %s "checking for /usr/share/man/man7/attributes.7... " >&6; } 10695 10695 + if test ${ac_cv_file__usr_share_man_man7_attributes_7+y} 10696 10696 + then : 10697 10697 + printf %s "(cached) " >&6 10698 10698 + else $as_nop 10343 10699 test "$cross_compiling" = yes && 10344 10700 as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5 10345 10701 if test -r "/usr/share/man/man7/attributes.7"; then ··· 10348 10704 ac_cv_file__usr_share_man_man7_attributes_7=no 10349 10705 fi 10350 10706 fi 10351 10351 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_man_man7_attributes_7" >&5 10352 10352 - $as_echo "$ac_cv_file__usr_share_man_man7_attributes_7" >&6; } 10353 10353 - if test "x$ac_cv_file__usr_share_man_man7_attributes_7" = xyes; then : 10707 10707 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_man_man7_attributes_7" >&5 10708 10708 + printf "%s\n" "$ac_cv_file__usr_share_man_man7_attributes_7" >&6; } 10709 10709 + if test "x$ac_cv_file__usr_share_man_man7_attributes_7" = xyes 10710 10710 + then : 10354 10711 SYSV_MAN_SECTIONS=false 10355 10355 - else 10712 10712 + else $as_nop 10356 10713 SYSV_MAN_SECTIONS=true 10357 10714 fi 10358 10715 ··· 10447 10804 10448 10805 10449 10806 # Check whether --enable-silent-rules was given. 10450 10450 - if test "${enable_silent_rules+set}" = set; then : 10807 10807 + if test ${enable_silent_rules+y} 10808 10808 + then : 10451 10809 enableval=$enable_silent_rules; 10452 10810 fi 10453 10811 ··· 10457 10815 *) AM_DEFAULT_VERBOSITY=0;; 10458 10816 esac 10459 10817 am_make=${MAKE-make} 10460 10460 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 10461 10461 - $as_echo_n "checking whether $am_make supports nested variables... " >&6; } 10462 10462 - if ${am_cv_make_support_nested_variables+:} false; then : 10463 10463 - $as_echo_n "(cached) " >&6 10464 10464 - else 10465 10465 - if $as_echo 'TRUE=$(BAR$(V)) 10818 10818 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 10819 10819 + printf %s "checking whether $am_make supports nested variables... " >&6; } 10820 10820 + if test ${am_cv_make_support_nested_variables+y} 10821 10821 + then : 10822 10822 + printf %s "(cached) " >&6 10823 10823 + else $as_nop 10824 10824 + if printf "%s\n" 'TRUE=$(BAR$(V)) 10466 10825 BAR0=false 10467 10826 BAR1=true 10468 10827 V=1 ··· 10474 10833 am_cv_make_support_nested_variables=no 10475 10834 fi 10476 10835 fi 10477 10477 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 10478 10478 - $as_echo "$am_cv_make_support_nested_variables" >&6; } 10836 10836 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 10837 10837 + printf "%s\n" "$am_cv_make_support_nested_variables" >&6; } 10479 10838 if test $am_cv_make_support_nested_variables = yes; then 10480 10839 AM_V='$(V)' 10481 10840 AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' ··· 10487 10846 10488 10847 10489 10848 10849 10849 + 10490 10850 for ac_prog in 'bison -y' byacc 10491 10851 do 10492 10852 # Extract the first word of "$ac_prog", so it can be a program name with args. 10493 10853 set dummy $ac_prog; ac_word=$2 10494 10494 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 10495 10495 - $as_echo_n "checking for $ac_word... " >&6; } 10496 10496 - if ${ac_cv_prog_YACC+:} false; then : 10497 10497 - $as_echo_n "(cached) " >&6 10498 10498 - else 10854 10854 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 10855 10855 + printf %s "checking for $ac_word... " >&6; } 10856 10856 + if test ${ac_cv_prog_YACC+y} 10857 10857 + then : 10858 10858 + printf %s "(cached) " >&6 10859 10859 + else $as_nop 10499 10860 if test -n "$YACC"; then 10500 10861 ac_cv_prog_YACC="$YACC" # Let the user override the test. 10501 10862 else ··· 10503 10864 for as_dir in $PATH 10504 10865 do 10505 10866 IFS=$as_save_IFS 10506 10506 - test -z "$as_dir" && as_dir=. 10867 10867 + case $as_dir in #((( 10868 10868 + '') as_dir=./ ;; 10869 10869 + */) ;; 10870 10870 + *) as_dir=$as_dir/ ;; 10871 10871 + esac 10507 10872 for ac_exec_ext in '' $ac_executable_extensions; do 10508 10508 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 10873 10873 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 10509 10874 ac_cv_prog_YACC="$ac_prog" 10510 10510 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 10875 10875 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 10511 10876 break 2 10512 10877 fi 10513 10878 done ··· 10518 10883 fi 10519 10884 YACC=$ac_cv_prog_YACC 10520 10885 if test -n "$YACC"; then 10521 10521 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5 10522 10522 - $as_echo "$YACC" >&6; } 10886 10886 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5 10887 10887 + printf "%s\n" "$YACC" >&6; } 10523 10888 else 10524 10524 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 10525 10525 - $as_echo "no" >&6; } 10889 10889 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 10890 10890 + printf "%s\n" "no" >&6; } 10526 10891 fi 10527 10892 10528 10893 ··· 10532 10897 10533 10898 # Extract the first word of "$YACC", so it can be a program name with args. 10534 10899 set dummy $YACC; ac_word=$2 10535 10535 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 10536 10536 - $as_echo_n "checking for $ac_word... " >&6; } 10537 10537 - if ${ac_cv_path_YACC_INST+:} false; then : 10538 10538 - $as_echo_n "(cached) " >&6 10539 10539 - else 10900 10900 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 10901 10901 + printf %s "checking for $ac_word... " >&6; } 10902 10902 + if test ${ac_cv_path_YACC_INST+y} 10903 10903 + then : 10904 10904 + printf %s "(cached) " >&6 10905 10905 + else $as_nop 10540 10906 case $YACC_INST in 10541 10907 [\\/]* | ?:[\\/]*) 10542 10908 ac_cv_path_YACC_INST="$YACC_INST" # Let the user override the test with a path. ··· 10546 10912 for as_dir in $PATH 10547 10913 do 10548 10914 IFS=$as_save_IFS 10549 10549 - test -z "$as_dir" && as_dir=. 10915 10915 + case $as_dir in #((( 10916 10916 + '') as_dir=./ ;; 10917 10917 + */) ;; 10918 10918 + *) as_dir=$as_dir/ ;; 10919 10919 + esac 10550 10920 for ac_exec_ext in '' $ac_executable_extensions; do 10551 10551 - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then 10552 10552 - ac_cv_path_YACC_INST="$as_dir/$ac_word$ac_exec_ext" 10553 10553 - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 10921 10921 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then 10922 10922 + ac_cv_path_YACC_INST="$as_dir$ac_word$ac_exec_ext" 10923 10923 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 10554 10924 break 2 10555 10925 fi 10556 10926 done ··· 10562 10932 fi 10563 10933 YACC_INST=$ac_cv_path_YACC_INST 10564 10934 if test -n "$YACC_INST"; then 10565 10565 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC_INST" >&5 10566 10566 - $as_echo "$YACC_INST" >&6; } 10935 10935 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $YACC_INST" >&5 10936 10936 + printf "%s\n" "$YACC_INST" >&6; } 10567 10937 else 10568 10568 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 10569 10569 - $as_echo "no" >&6; } 10938 10938 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 10939 10939 + printf "%s\n" "no" >&6; } 10570 10940 fi 10571 10941 10572 10942 ··· 10576 10946 fi 10577 10947 fi 10578 10948 10579 10579 - for ac_func in strcasecmp 10580 10580 - do : 10581 10581 - ac_fn_c_check_func "$LINENO" "strcasecmp" "ac_cv_func_strcasecmp" 10582 10582 - if test "x$ac_cv_func_strcasecmp" = xyes; then : 10583 10583 - cat >>confdefs.h <<_ACEOF 10584 10584 - #define HAVE_STRCASECMP 1 10585 10585 - _ACEOF 10586 10586 - 10587 10587 - fi 10588 10588 - done 10589 10589 - 10590 10590 - 10591 10949 # Checks for pkg-config packages 10592 10950 10593 10951 pkg_failed=no 10594 10594 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for xkbfile x11" >&5 10595 10595 - $as_echo_n "checking for xkbfile x11... " >&6; } 10952 10952 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for xkbfile x11" >&5 10953 10953 + printf %s "checking for xkbfile x11... " >&6; } 10596 10954 10597 10955 if test -n "$XKBEVD_CFLAGS"; then 10598 10956 pkg_cv_XKBEVD_CFLAGS="$XKBEVD_CFLAGS" 10599 10957 elif test -n "$PKG_CONFIG"; then 10600 10958 if test -n "$PKG_CONFIG" && \ 10601 10601 - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xkbfile x11\""; } >&5 10959 10959 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xkbfile x11\""; } >&5 10602 10960 ($PKG_CONFIG --exists --print-errors "xkbfile x11") 2>&5 10603 10961 ac_status=$? 10604 10604 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 10962 10962 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 10605 10963 test $ac_status = 0; }; then 10606 10964 pkg_cv_XKBEVD_CFLAGS=`$PKG_CONFIG --cflags "xkbfile x11" 2>/dev/null` 10607 10965 test "x$?" != "x0" && pkg_failed=yes ··· 10615 10973 pkg_cv_XKBEVD_LIBS="$XKBEVD_LIBS" 10616 10974 elif test -n "$PKG_CONFIG"; then 10617 10975 if test -n "$PKG_CONFIG" && \ 10618 10618 - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xkbfile x11\""; } >&5 10976 10976 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xkbfile x11\""; } >&5 10619 10977 ($PKG_CONFIG --exists --print-errors "xkbfile x11") 2>&5 10620 10978 ac_status=$? 10621 10621 - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 10979 10979 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 10622 10980 test $ac_status = 0; }; then 10623 10981 pkg_cv_XKBEVD_LIBS=`$PKG_CONFIG --libs "xkbfile x11" 2>/dev/null` 10624 10982 test "x$?" != "x0" && pkg_failed=yes ··· 10632 10990 10633 10991 10634 10992 if test $pkg_failed = yes; then 10635 10635 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 10636 10636 - $as_echo "no" >&6; } 10993 10993 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 10994 10994 + printf "%s\n" "no" >&6; } 10637 10995 10638 10996 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then 10639 10997 _pkg_short_errors_supported=yes ··· 10641 10999 _pkg_short_errors_supported=no 10642 11000 fi 10643 11001 if test $_pkg_short_errors_supported = yes; then 10644 10644 - XKBEVD_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "xkbfile x11" 2>&1` 11002 11002 + XKBEVD_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "xkbfile x11" 2>&1` 10645 11003 else 10646 10646 - XKBEVD_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "xkbfile x11" 2>&1` 11004 11004 + XKBEVD_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "xkbfile x11" 2>&1` 10647 11005 fi 10648 10648 - # Put the nasty error message in config.log where it belongs 10649 10649 - echo "$XKBEVD_PKG_ERRORS" >&5 11006 11006 + # Put the nasty error message in config.log where it belongs 11007 11007 + echo "$XKBEVD_PKG_ERRORS" >&5 10650 11008 10651 10651 - as_fn_error $? "Package requirements (xkbfile x11) were not met: 11009 11009 + as_fn_error $? "Package requirements (xkbfile x11) were not met: 10652 11010 10653 11011 $XKBEVD_PKG_ERRORS 10654 11012 ··· 10659 11017 and XKBEVD_LIBS to avoid the need to call pkg-config. 10660 11018 See the pkg-config man page for more details." "$LINENO" 5 10661 11019 elif test $pkg_failed = untried; then 10662 10662 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 10663 10663 - $as_echo "no" >&6; } 10664 10664 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 10665 10665 - $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 11020 11020 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 11021 11021 + printf "%s\n" "no" >&6; } 11022 11022 + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 11023 11023 + printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} 10666 11024 as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it 10667 11025 is in your PATH or set the PKG_CONFIG environment variable to the full 10668 11026 path to pkg-config. ··· 10674 11032 To get pkg-config, see <http://pkg-config.freedesktop.org/>. 10675 11033 See \`config.log' for more details" "$LINENO" 5; } 10676 11034 else 10677 10677 - XKBEVD_CFLAGS=$pkg_cv_XKBEVD_CFLAGS 10678 10678 - XKBEVD_LIBS=$pkg_cv_XKBEVD_LIBS 10679 10679 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 10680 10680 - $as_echo "yes" >&6; } 11035 11035 + XKBEVD_CFLAGS=$pkg_cv_XKBEVD_CFLAGS 11036 11036 + XKBEVD_LIBS=$pkg_cv_XKBEVD_LIBS 11037 11037 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 11038 11038 + printf "%s\n" "yes" >&6; } 10681 11039 10682 11040 fi 10683 11041 ··· 10710 11068 case $ac_val in #( 10711 11069 *${as_nl}*) 10712 11070 case $ac_var in #( 10713 10713 - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 10714 10714 - $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; 11071 11071 + *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 11072 11072 + printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; 10715 11073 esac 10716 11074 case $ac_var in #( 10717 11075 _ | IFS | as_nl) ;; #( ··· 10741 11099 /^ac_cv_env_/b end 10742 11100 t clear 10743 11101 :clear 10744 10744 - s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ 11102 11102 + s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/ 10745 11103 t end 10746 11104 s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ 10747 11105 :end' >>confcache 10748 11106 if diff "$cache_file" confcache >/dev/null 2>&1; then :; else 10749 11107 if test -w "$cache_file"; then 10750 11108 if test "x$cache_file" != "x/dev/null"; then 10751 10751 - { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 10752 10752 - $as_echo "$as_me: updating cache $cache_file" >&6;} 11109 11109 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 11110 11110 + printf "%s\n" "$as_me: updating cache $cache_file" >&6;} 10753 11111 if test ! -f "$cache_file" || test -h "$cache_file"; then 10754 11112 cat confcache >"$cache_file" 10755 11113 else ··· 10763 11121 fi 10764 11122 fi 10765 11123 else 10766 10766 - { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 10767 10767 - $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} 11124 11124 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 11125 11125 + printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;} 10768 11126 fi 10769 11127 fi 10770 11128 rm -f confcache ··· 10781 11139 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue 10782 11140 # 1. Remove the extension, and $U if already installed. 10783 11141 ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' 10784 10784 - ac_i=`$as_echo "$ac_i" | sed "$ac_script"` 11142 11142 + ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"` 10785 11143 # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR 10786 11144 # will be set to the directory where LIBOBJS objects are built. 10787 11145 as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" ··· 10792 11150 LTLIBOBJS=$ac_ltlibobjs 10793 11151 10794 11152 10795 10795 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 10796 10796 - $as_echo_n "checking that generated files are newer than configure... " >&6; } 11153 11153 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 11154 11154 + printf %s "checking that generated files are newer than configure... " >&6; } 10797 11155 if test -n "$am_sleep_pid"; then 10798 11156 # Hide warnings about reused PIDs. 10799 11157 wait $am_sleep_pid 2>/dev/null 10800 11158 fi 10801 10801 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5 10802 10802 - $as_echo "done" >&6; } 11159 11159 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5 11160 11160 + printf "%s\n" "done" >&6; } 10803 11161 if test -n "$EXEEXT"; then 10804 11162 am__EXEEXT_TRUE= 10805 11163 am__EXEEXT_FALSE='#' ··· 10825 11183 ac_write_fail=0 10826 11184 ac_clean_files_save=$ac_clean_files 10827 11185 ac_clean_files="$ac_clean_files $CONFIG_STATUS" 10828 10828 - { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 10829 10829 - $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} 11186 11186 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 11187 11187 + printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;} 10830 11188 as_write_fail=0 10831 11189 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 10832 11190 #! $SHELL ··· 10849 11207 10850 11208 # Be more Bourne compatible 10851 11209 DUALCASE=1; export DUALCASE # for MKS sh 10852 10852 - if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : 11210 11210 + as_nop=: 11211 11211 + if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 11212 11212 + then : 10853 11213 emulate sh 10854 11214 NULLCMD=: 10855 11215 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which 10856 11216 # is contrary to our usage. Disable this feature. 10857 11217 alias -g '${1+"$@"}'='"$@"' 10858 11218 setopt NO_GLOB_SUBST 10859 10859 - else 11219 11219 + else $as_nop 10860 11220 case `(set -o) 2>/dev/null` in #( 10861 11221 *posix*) : 10862 11222 set -o posix ;; #( ··· 10866 11226 fi 10867 11227 10868 11228 11229 11229 + 11230 11230 + # Reset variables that may have inherited troublesome values from 11231 11231 + # the environment. 11232 11232 + 11233 11233 + # IFS needs to be set, to space, tab, and newline, in precisely that order. 11234 11234 + # (If _AS_PATH_WALK were called with IFS unset, it would have the 11235 11235 + # side effect of setting IFS to empty, thus disabling word splitting.) 11236 11236 + # Quoting is to prevent editors from complaining about space-tab. 10869 11237 as_nl=' 10870 11238 ' 10871 11239 export as_nl 10872 10872 - # Printing a long string crashes Solaris 7 /usr/bin/printf. 10873 10873 - as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' 10874 10874 - as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo 10875 10875 - as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo 10876 10876 - # Prefer a ksh shell builtin over an external printf program on Solaris, 10877 10877 - # but without wasting forks for bash or zsh. 10878 10878 - if test -z "$BASH_VERSION$ZSH_VERSION" \ 10879 10879 - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then 10880 10880 - as_echo='print -r --' 10881 10881 - as_echo_n='print -rn --' 10882 10882 - elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then 10883 10883 - as_echo='printf %s\n' 10884 10884 - as_echo_n='printf %s' 10885 10885 - else 10886 10886 - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then 10887 10887 - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' 10888 10888 - as_echo_n='/usr/ucb/echo -n' 10889 10889 - else 10890 10890 - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' 10891 10891 - as_echo_n_body='eval 10892 10892 - arg=$1; 10893 10893 - case $arg in #( 10894 10894 - *"$as_nl"*) 10895 10895 - expr "X$arg" : "X\\(.*\\)$as_nl"; 10896 10896 - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; 10897 10897 - esac; 10898 10898 - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" 10899 10899 - ' 10900 10900 - export as_echo_n_body 10901 10901 - as_echo_n='sh -c $as_echo_n_body as_echo' 10902 10902 - fi 10903 10903 - export as_echo_body 10904 10904 - as_echo='sh -c $as_echo_body as_echo' 10905 10905 - fi 11240 11240 + IFS=" "" $as_nl" 11241 11241 + 11242 11242 + PS1='$ ' 11243 11243 + PS2='> ' 11244 11244 + PS4='+ ' 11245 11245 + 11246 11246 + # Ensure predictable behavior from utilities with locale-dependent output. 11247 11247 + LC_ALL=C 11248 11248 + export LC_ALL 11249 11249 + LANGUAGE=C 11250 11250 + export LANGUAGE 11251 11251 + 11252 11252 + # We cannot yet rely on "unset" to work, but we need these variables 11253 11253 + # to be unset--not just set to an empty or harmless value--now, to 11254 11254 + # avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct 11255 11255 + # also avoids known problems related to "unset" and subshell syntax 11256 11256 + # in other old shells (e.g. bash 2.01 and pdksh 5.2.14). 11257 11257 + for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH 11258 11258 + do eval test \${$as_var+y} \ 11259 11259 + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : 11260 11260 + done 11261 11261 + 11262 11262 + # Ensure that fds 0, 1, and 2 are open. 11263 11263 + if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi 11264 11264 + if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi 11265 11265 + if (exec 3>&2) ; then :; else exec 2>/dev/null; fi 10906 11266 10907 11267 # The user is always right. 10908 10908 - if test "${PATH_SEPARATOR+set}" != set; then 11268 11268 + if ${PATH_SEPARATOR+false} :; then 10909 11269 PATH_SEPARATOR=: 10910 11270 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { 10911 11271 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || ··· 10914 11274 fi 10915 11275 10916 11276 10917 10917 - # IFS 10918 10918 - # We need space, tab and new line, in precisely that order. Quoting is 10919 10919 - # there to prevent editors from complaining about space-tab. 10920 10920 - # (If _AS_PATH_WALK were called with IFS unset, it would disable word 10921 10921 - # splitting by setting IFS to empty value.) 10922 10922 - IFS=" "" $as_nl" 10923 10923 - 10924 11277 # Find who we are. Look in the path if we contain no directory separator. 10925 11278 as_myself= 10926 11279 case $0 in #(( ··· 10929 11282 for as_dir in $PATH 10930 11283 do 10931 11284 IFS=$as_save_IFS 10932 10932 - test -z "$as_dir" && as_dir=. 10933 10933 - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break 11285 11285 + case $as_dir in #((( 11286 11286 + '') as_dir=./ ;; 11287 11287 + */) ;; 11288 11288 + *) as_dir=$as_dir/ ;; 11289 11289 + esac 11290 11290 + test -r "$as_dir$0" && as_myself=$as_dir$0 && break 10934 11291 done 10935 11292 IFS=$as_save_IFS 10936 11293 ··· 10942 11299 as_myself=$0 10943 11300 fi 10944 11301 if test ! -f "$as_myself"; then 10945 10945 - $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 11302 11302 + printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 10946 11303 exit 1 10947 11304 fi 10948 11305 10949 10949 - # Unset variables that we do not need and which cause bugs (e.g. in 10950 10950 - # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" 10951 10951 - # suppresses any "Segmentation fault" message there. '((' could 10952 10952 - # trigger a bug in pdksh 5.2.14. 10953 10953 - for as_var in BASH_ENV ENV MAIL MAILPATH 10954 10954 - do eval test x\${$as_var+set} = xset \ 10955 10955 - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : 10956 10956 - done 10957 10957 - PS1='$ ' 10958 10958 - PS2='> ' 10959 10959 - PS4='+ ' 10960 10960 - 10961 10961 - # NLS nuisances. 10962 10962 - LC_ALL=C 10963 10963 - export LC_ALL 10964 10964 - LANGUAGE=C 10965 10965 - export LANGUAGE 10966 10966 - 10967 10967 - # CDPATH. 10968 10968 - (unset CDPATH) >/dev/null 2>&1 && unset CDPATH 10969 11306 10970 11307 10971 11308 # as_fn_error STATUS ERROR [LINENO LOG_FD] ··· 10978 11315 as_status=$1; test $as_status -eq 0 && as_status=1 10979 11316 if test "$4"; then 10980 11317 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 10981 10981 - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 11318 11318 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 10982 11319 fi 10983 10983 - $as_echo "$as_me: error: $2" >&2 11320 11320 + printf "%s\n" "$as_me: error: $2" >&2 10984 11321 as_fn_exit $as_status 10985 11322 } # as_fn_error 10986 11323 10987 11324 11325 11325 + 10988 11326 # as_fn_set_status STATUS 10989 11327 # ----------------------- 10990 11328 # Set $? to STATUS, without forking. ··· 11011 11349 { eval $1=; unset $1;} 11012 11350 } 11013 11351 as_unset=as_fn_unset 11352 11352 + 11014 11353 # as_fn_append VAR VALUE 11015 11354 # ---------------------- 11016 11355 # Append the text in VALUE to the end of the definition contained in VAR. Take 11017 11356 # advantage of any shell optimizations that allow amortized linear growth over 11018 11357 # repeated appends, instead of the typical quadratic growth present in naive 11019 11358 # implementations. 11020 11020 - if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : 11359 11359 + if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null 11360 11360 + then : 11021 11361 eval 'as_fn_append () 11022 11362 { 11023 11363 eval $1+=\$2 11024 11364 }' 11025 11025 - else 11365 11365 + else $as_nop 11026 11366 as_fn_append () 11027 11367 { 11028 11368 eval $1=\$$1\$2 ··· 11034 11374 # Perform arithmetic evaluation on the ARGs, and store the result in the 11035 11375 # global $as_val. Take advantage of shells that can avoid forks. The arguments 11036 11376 # must be portable across $(()) and expr. 11037 11037 - if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : 11377 11377 + if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null 11378 11378 + then : 11038 11379 eval 'as_fn_arith () 11039 11380 { 11040 11381 as_val=$(( $* )) 11041 11382 }' 11042 11042 - else 11383 11383 + else $as_nop 11043 11384 as_fn_arith () 11044 11385 { 11045 11386 as_val=`expr "$@" || test $? -eq 1` ··· 11070 11411 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ 11071 11412 X"$0" : 'X\(//\)$' \| \ 11072 11413 X"$0" : 'X\(/\)' \| . 2>/dev/null || 11073 11073 - $as_echo X/"$0" | 11414 11414 + printf "%s\n" X/"$0" | 11074 11415 sed '/^.*\/\([^/][^/]*\)\/*$/{ 11075 11416 s//\1/ 11076 11417 q ··· 11092 11433 as_cr_digits='0123456789' 11093 11434 as_cr_alnum=$as_cr_Letters$as_cr_digits 11094 11435 11436 11436 + 11437 11437 + # Determine whether it's possible to make 'echo' print without a newline. 11438 11438 + # These variables are no longer used directly by Autoconf, but are AC_SUBSTed 11439 11439 + # for compatibility with existing Makefiles. 11095 11440 ECHO_C= ECHO_N= ECHO_T= 11096 11441 case `echo -n x` in #((((( 11097 11442 -n*) ··· 11105 11450 ECHO_N='-n';; 11106 11451 esac 11107 11452 11453 11453 + # For backward compatibility with old third-party macros, we provide 11454 11454 + # the shell variables $as_echo and $as_echo_n. New code should use 11455 11455 + # AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. 11456 11456 + as_echo='printf %s\n' 11457 11457 + as_echo_n='printf %s' 11458 11458 + 11108 11459 rm -f conf$$ conf$$.exe conf$$.file 11109 11460 if test -d conf$$.dir; then 11110 11461 rm -f conf$$.dir/conf$$.file ··· 11146 11497 as_dirs= 11147 11498 while :; do 11148 11499 case $as_dir in #( 11149 11149 - *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( 11500 11500 + *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( 11150 11501 *) as_qdir=$as_dir;; 11151 11502 esac 11152 11503 as_dirs="'$as_qdir' $as_dirs" ··· 11155 11506 X"$as_dir" : 'X\(//\)[^/]' \| \ 11156 11507 X"$as_dir" : 'X\(//\)$' \| \ 11157 11508 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || 11158 11158 - $as_echo X"$as_dir" | 11509 11509 + printf "%s\n" X"$as_dir" | 11159 11510 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 11160 11511 s//\1/ 11161 11512 q ··· 11217 11568 # report actual input values of CONFIG_FILES etc. instead of their 11218 11569 # values after options handling. 11219 11570 ac_log=" 11220 11220 - This file was extended by xkbevd $as_me 1.1.5, which was 11221 11221 - generated by GNU Autoconf 2.69. Invocation command line was 11571 11571 + This file was extended by xkbevd $as_me 1.1.6, which was 11572 11572 + generated by GNU Autoconf 2.71. Invocation command line was 11222 11573 11223 11574 CONFIG_FILES = $CONFIG_FILES 11224 11575 CONFIG_HEADERS = $CONFIG_HEADERS ··· 11280 11631 Report bugs to <https://gitlab.freedesktop.org/xorg/app/xkbevd/-/issues>." 11281 11632 11282 11633 _ACEOF 11634 11634 + ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"` 11635 11635 + ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` 11283 11636 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 11284 11284 - ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" 11637 11637 + ac_cs_config='$ac_cs_config_escaped' 11285 11638 ac_cs_version="\\ 11286 11286 - xkbevd config.status 1.1.5 11287 11287 - configured by $0, generated by GNU Autoconf 2.69, 11639 11639 + xkbevd config.status 1.1.6 11640 11640 + configured by $0, generated by GNU Autoconf 2.71, 11288 11641 with options \\"\$ac_cs_config\\" 11289 11642 11290 11290 - Copyright (C) 2012 Free Software Foundation, Inc. 11643 11643 + Copyright (C) 2021 Free Software Foundation, Inc. 11291 11644 This config.status script is free software; the Free Software Foundation 11292 11645 gives unlimited permission to copy, distribute and modify it." 11293 11646 ··· 11327 11680 -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) 11328 11681 ac_cs_recheck=: ;; 11329 11682 --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) 11330 11330 - $as_echo "$ac_cs_version"; exit ;; 11683 11683 + printf "%s\n" "$ac_cs_version"; exit ;; 11331 11684 --config | --confi | --conf | --con | --co | --c ) 11332 11332 - $as_echo "$ac_cs_config"; exit ;; 11685 11685 + printf "%s\n" "$ac_cs_config"; exit ;; 11333 11686 --debug | --debu | --deb | --de | --d | -d ) 11334 11687 debug=: ;; 11335 11688 --file | --fil | --fi | --f ) 11336 11689 $ac_shift 11337 11690 case $ac_optarg in 11338 11338 - *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; 11691 11691 + *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; 11339 11692 '') as_fn_error $? "missing file argument" ;; 11340 11693 esac 11341 11694 as_fn_append CONFIG_FILES " '$ac_optarg'" ··· 11343 11696 --header | --heade | --head | --hea ) 11344 11697 $ac_shift 11345 11698 case $ac_optarg in 11346 11346 - *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; 11699 11699 + *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; 11347 11700 esac 11348 11701 as_fn_append CONFIG_HEADERS " '$ac_optarg'" 11349 11702 ac_need_defaults=false;; ··· 11352 11705 as_fn_error $? "ambiguous option: \`$1' 11353 11706 Try \`$0 --help' for more information.";; 11354 11707 --help | --hel | -h ) 11355 11355 - $as_echo "$ac_cs_usage"; exit ;; 11708 11708 + printf "%s\n" "$ac_cs_usage"; exit ;; 11356 11709 -q | -quiet | --quiet | --quie | --qui | --qu | --q \ 11357 11710 | -silent | --silent | --silen | --sile | --sil | --si | --s) 11358 11711 ac_cs_silent=: ;; ··· 11380 11733 if \$ac_cs_recheck; then 11381 11734 set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion 11382 11735 shift 11383 11383 - \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 11736 11736 + \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 11384 11737 CONFIG_SHELL='$SHELL' 11385 11738 export CONFIG_SHELL 11386 11739 exec "\$@" ··· 11394 11747 sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX 11395 11748 ## Running $as_me. ## 11396 11749 _ASBOX 11397 11397 - $as_echo "$ac_log" 11750 11750 + printf "%s\n" "$ac_log" 11398 11751 } >&5 11399 11752 11400 11753 _ACEOF ··· 11427 11780 # We use the long form for the default assignment because of an extremely 11428 11781 # bizarre bug on SunOS 4.1.3. 11429 11782 if $ac_need_defaults; then 11430 11430 - test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files 11431 11431 - test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers 11432 11432 - test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands 11783 11783 + test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files 11784 11784 + test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers 11785 11785 + test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands 11433 11786 fi 11434 11787 11435 11788 # Have a temporary directory for convenience. Make it in the build tree ··· 11765 12118 esac || 11766 12119 as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; 11767 12120 esac 11768 11768 - case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac 12121 12121 + case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac 11769 12122 as_fn_append ac_file_inputs " '$ac_f'" 11770 12123 done 11771 12124 ··· 11773 12126 # use $as_me), people would be surprised to read: 11774 12127 # /* config.h. Generated by config.status. */ 11775 12128 configure_input='Generated from '` 11776 11776 - $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' 12129 12129 + printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' 11777 12130 `' by configure.' 11778 12131 if test x"$ac_file" != x-; then 11779 12132 configure_input="$ac_file. $configure_input" 11780 11780 - { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 11781 11781 - $as_echo "$as_me: creating $ac_file" >&6;} 12133 12133 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 12134 12134 + printf "%s\n" "$as_me: creating $ac_file" >&6;} 11782 12135 fi 11783 12136 # Neutralize special characters interpreted by sed in replacement strings. 11784 12137 case $configure_input in #( 11785 12138 *\&* | *\|* | *\\* ) 11786 11786 - ac_sed_conf_input=`$as_echo "$configure_input" | 12139 12139 + ac_sed_conf_input=`printf "%s\n" "$configure_input" | 11787 12140 sed 's/[\\\\&|]/\\\\&/g'`;; #( 11788 12141 *) ac_sed_conf_input=$configure_input;; 11789 12142 esac ··· 11800 12153 X"$ac_file" : 'X\(//\)[^/]' \| \ 11801 12154 X"$ac_file" : 'X\(//\)$' \| \ 11802 12155 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || 11803 11803 - $as_echo X"$ac_file" | 12156 12156 + printf "%s\n" X"$ac_file" | 11804 12157 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 11805 12158 s//\1/ 11806 12159 q ··· 11824 12177 case "$ac_dir" in 11825 12178 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; 11826 12179 *) 11827 11827 - ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` 12180 12180 + ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` 11828 12181 # A ".." for each directory in $ac_dir_suffix. 11829 11829 - ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` 12182 12182 + ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` 11830 12183 case $ac_top_builddir_sub in 11831 12184 "") ac_top_builddir_sub=. ac_top_build_prefix= ;; 11832 12185 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; ··· 11888 12241 case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in 11889 12242 *datarootdir*) ac_datarootdir_seen=yes;; 11890 12243 *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) 11891 11891 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 11892 11892 - $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} 12244 12244 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 12245 12245 + printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} 11893 12246 _ACEOF 11894 12247 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 11895 12248 ac_datarootdir_hack=' ··· 11933 12286 { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && 11934 12287 { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ 11935 12288 "$ac_tmp/out"`; test -z "$ac_out"; } && 11936 11936 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' 12289 12289 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' 11937 12290 which seems to be undefined. Please make sure it is defined" >&5 11938 11938 - $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' 12291 12291 + printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' 11939 12292 which seems to be undefined. Please make sure it is defined" >&2;} 11940 12293 11941 12294 rm -f "$ac_tmp/stdin" ··· 11951 12304 # 11952 12305 if test x"$ac_file" != x-; then 11953 12306 { 11954 11954 - $as_echo "/* $configure_input */" \ 12307 12307 + printf "%s\n" "/* $configure_input */" >&1 \ 11955 12308 && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" 11956 12309 } >"$ac_tmp/config.h" \ 11957 12310 || as_fn_error $? "could not create $ac_file" "$LINENO" 5 11958 12311 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then 11959 11959 - { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 11960 11960 - $as_echo "$as_me: $ac_file is unchanged" >&6;} 12312 12312 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 12313 12313 + printf "%s\n" "$as_me: $ac_file is unchanged" >&6;} 11961 12314 else 11962 12315 rm -f "$ac_file" 11963 12316 mv "$ac_tmp/config.h" "$ac_file" \ 11964 12317 || as_fn_error $? "could not create $ac_file" "$LINENO" 5 11965 12318 fi 11966 12319 else 11967 11967 - $as_echo "/* $configure_input */" \ 12320 12320 + printf "%s\n" "/* $configure_input */" >&1 \ 11968 12321 && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ 11969 12322 || as_fn_error $? "could not create -" "$LINENO" 5 11970 12323 fi ··· 11984 12337 X"$_am_arg" : 'X\(//\)[^/]' \| \ 11985 12338 X"$_am_arg" : 'X\(//\)$' \| \ 11986 12339 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || 11987 11987 - $as_echo X"$_am_arg" | 12340 12340 + printf "%s\n" X"$_am_arg" | 11988 12341 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 11989 12342 s//\1/ 11990 12343 q ··· 12004 12357 s/.*/./; q'`/stamp-h$_am_stamp_count 12005 12358 ;; 12006 12359 12007 12007 - :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 12008 12008 - $as_echo "$as_me: executing $ac_file commands" >&6;} 12360 12360 + :C) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 12361 12361 + printf "%s\n" "$as_me: executing $ac_file commands" >&6;} 12009 12362 ;; 12010 12363 esac 12011 12364 ··· 12037 12390 X"$mf" : 'X\(//\)[^/]' \| \ 12038 12391 X"$mf" : 'X\(//\)$' \| \ 12039 12392 X"$mf" : 'X\(/\)' \| . 2>/dev/null || 12040 12040 - $as_echo X"$mf" | 12393 12393 + printf "%s\n" X"$mf" | 12041 12394 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 12042 12395 s//\1/ 12043 12396 q ··· 12079 12432 X"$file" : 'X\(//\)[^/]' \| \ 12080 12433 X"$file" : 'X\(//\)$' \| \ 12081 12434 X"$file" : 'X\(/\)' \| . 2>/dev/null || 12082 12082 - $as_echo X"$file" | 12435 12435 + printf "%s\n" X"$file" | 12083 12436 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 12084 12437 s//\1/ 12085 12438 q ··· 12138 12491 $ac_cs_success || as_fn_exit 1 12139 12492 fi 12140 12493 if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then 12141 12141 - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 12142 12142 - $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} 12494 12494 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 12495 12495 + printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} 12143 12496 fi 12144 12497

+1 -3

app/xkbevd/configure.ac

reviewed

··· 22 22 23 23 # Initialize Autoconf 24 24 AC_PREREQ([2.60]) 25 25 - AC_INIT([xkbevd], [1.1.5], 25 25 + AC_INIT([xkbevd], [1.1.6], 26 26 [https://gitlab.freedesktop.org/xorg/app/xkbevd/-/issues], [xkbevd]) 27 27 AC_CONFIG_SRCDIR([Makefile.am]) 28 28 AC_CONFIG_HEADERS([config.h]) ··· 43 43 AC_MSG_ERROR([yacc not found - unable to compile cfgparse.y]) 44 44 fi 45 45 fi 46 46 - 47 47 - AC_CHECK_FUNCS([strcasecmp]) 48 46 49 47 # Checks for pkg-config packages 50 48 PKG_CHECK_MODULES(XKBEVD, xkbfile x11)

+12 -10

app/xkbevd/evargs.c

reviewed

··· 29 29 /***====================================================================***/ 30 30 31 31 static char * 32 32 - AppendBellNotifyArg(char *sink, char *arg, XkbEvent *ev) 32 32 + AppendBellNotifyArg(char *sink, const char *arg, const XkbEvent *ev) 33 33 { 34 34 if (uStringEqual(arg, "device") || uStringEqual(arg, "D")) 35 35 sprintf(sink, "%d", ev->bell.device); ··· 51 51 } 52 52 53 53 static char * 54 54 - AppendAccessXNotifyArg(char *sink, char *arg, XkbEvent *ev) 54 54 + AppendAccessXNotifyArg(char *sink, const char *arg, const XkbEvent *ev) 55 55 { 56 56 if (uStringEqual(arg, "device") || uStringEqual(arg, "D")) 57 57 sprintf(sink, "%d", ev->accessx.device); ··· 70 70 } 71 71 72 72 static char * 73 73 - AppendActionMessageArg(char *sink, char *arg, XkbEvent *ev) 73 73 + AppendActionMessageArg(char *sink, const char *arg, const XkbEvent *ev) 74 74 { 75 75 if (uStringEqual(arg, "device") || uStringEqual(arg, "D")) 76 76 sprintf(sink, "%d", ev->message.device); ··· 88 88 } 89 89 90 90 static char * 91 91 - AppendEventArg(char *sink, char *arg, XkbEvent *ev) 91 91 + AppendEventArg(char *sink, const char *arg, const XkbEvent *ev) 92 92 { 93 93 switch (ev->any.xkb_type) { 94 94 case XkbBellNotify: ··· 108 108 } 109 109 110 110 static void 111 111 - CopyEventArg(char **sink_inout, char **source_inout, XkbEvent *ev) 111 111 + CopyEventArg(char **sink_inout, const char **source_inout, const XkbEvent *ev) 112 112 { 113 113 char buf[1024]; 114 114 - char *source, *sink; 114 114 + const char *source; 115 115 + char *sink; 115 116 char *arg; 116 117 117 118 arg = buf; ··· 150 151 return; 151 152 } 152 153 153 153 - char * 154 154 - SubstituteEventArgs(char *cmd, XkbEvent *ev) 154 154 + const char * 155 155 + SubstituteEventArgs(const char *cmd, const XkbEvent *ev) 155 156 { 156 157 static char buf[1024]; 157 157 - char *source, *sink; 158 158 + const char *source; 159 159 + char *sink; 158 160 159 159 - if (index(cmd, '$') == NULL) 161 161 + if (strchr(cmd, '$') == NULL) 160 162 return cmd; 161 163 buf[0] = '\0'; 162 164 sink = buf;

+214 -200

app/xkbevd/install-sh

reviewed

··· 1 1 #!/bin/sh 2 2 # install - install a program, script, or datafile 3 3 4 4 - scriptversion=2011-11-20.07; # UTC 4 4 + scriptversion=2020-11-14.01; # UTC 5 5 6 6 # This originates from X11R5 (mit/util/scripts/install.sh), which was 7 7 # later released in X11R6 (xc/config/util/install.sh) with the ··· 41 41 # This script is compatible with the BSD install script, but was written 42 42 # from scratch. 43 43 44 44 + tab=' ' 44 45 nl=' 45 46 ' 46 46 - IFS=" "" $nl" 47 47 + IFS=" $tab$nl" 47 48 48 48 - # set DOITPROG to echo to test this script 49 49 + # Set DOITPROG to "echo" to test this script. 49 50 50 50 - # Don't use :- since 4.3BSD and earlier shells don't like it. 51 51 doit=${DOITPROG-} 52 52 - if test -z "$doit"; then 53 53 - doit_exec=exec 54 54 - else 55 55 - doit_exec=$doit 56 56 - fi 52 52 + doit_exec=${doit:-exec} 57 53 58 54 # Put in absolute file names if you don't have them in your path; 59 55 # or use environment vars. ··· 68 64 rmprog=${RMPROG-rm} 69 65 stripprog=${STRIPPROG-strip} 70 66 71 71 - posix_glob='?' 72 72 - initialize_posix_glob=' 73 73 - test "$posix_glob" != "?" || { 74 74 - if (set -f) 2>/dev/null; then 75 75 - posix_glob= 76 76 - else 77 77 - posix_glob=: 78 78 - fi 79 79 - } 80 80 - ' 81 81 - 82 67 posix_mkdir= 83 68 84 69 # Desired mode of installed file. 85 70 mode=0755 86 71 72 72 + # Create dirs (including intermediate dirs) using mode 755. 73 73 + # This is like GNU 'install' as of coreutils 8.32 (2020). 74 74 + mkdir_umask=22 75 75 + 76 76 + backupsuffix= 87 77 chgrpcmd= 88 78 chmodcmd=$chmodprog 89 79 chowncmd= ··· 97 87 dst_arg= 98 88 99 89 copy_on_change=false 100 100 - no_target_directory= 90 90 + is_target_a_directory=possibly 101 91 102 92 usage="\ 103 93 Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE ··· 114 104 --version display version info and exit. 115 105 116 106 -c (ignored) 117 117 - -C install only if different (preserve the last data modification time) 107 107 + -C install only if different (preserve data modification time) 118 108 -d create directories instead of installing files. 119 109 -g GROUP $chgrpprog installed files to GROUP. 120 110 -m MODE $chmodprog installed files to MODE. 121 111 -o USER $chownprog installed files to USER. 112 112 + -p pass -p to $cpprog. 122 113 -s $stripprog installed files. 114 114 + -S SUFFIX attempt to back up existing files, with suffix SUFFIX. 123 115 -t DIRECTORY install into DIRECTORY. 124 116 -T report an error if DSTFILE is a directory. 125 117 126 118 Environment variables override the default commands: 127 119 CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG 128 120 RMPROG STRIPPROG 121 121 + 122 122 + By default, rm is invoked with -f; when overridden with RMPROG, 123 123 + it's up to you to specify -f if you want it. 124 124 + 125 125 + If -S is not specified, no backups are attempted. 126 126 + 127 127 + Email bug reports to bug-automake@gnu.org. 128 128 + Automake home page: https://www.gnu.org/software/automake/ 129 129 " 130 130 131 131 while test $# -ne 0; do ··· 137 137 -d) dir_arg=true;; 138 138 139 139 -g) chgrpcmd="$chgrpprog $2" 140 140 - shift;; 140 140 + shift;; 141 141 142 142 --help) echo "$usage"; exit $?;; 143 143 144 144 -m) mode=$2 145 145 - case $mode in 146 146 - *' '* | *' '* | *' 147 147 - '* | *'*'* | *'?'* | *'['*) 148 148 - echo "$0: invalid mode: $mode" >&2 149 149 - exit 1;; 150 150 - esac 151 151 - shift;; 145 145 + case $mode in 146 146 + *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) 147 147 + echo "$0: invalid mode: $mode" >&2 148 148 + exit 1;; 149 149 + esac 150 150 + shift;; 152 151 153 152 -o) chowncmd="$chownprog $2" 154 154 - shift;; 153 153 + shift;; 154 154 + 155 155 + -p) cpprog="$cpprog -p";; 155 156 156 157 -s) stripcmd=$stripprog;; 157 158 158 158 - -t) dst_arg=$2 159 159 - # Protect names problematic for 'test' and other utilities. 160 160 - case $dst_arg in 161 161 - -* | [=\(\)!]) dst_arg=./$dst_arg;; 162 162 - esac 163 163 - shift;; 159 159 + -S) backupsuffix="$2" 160 160 + shift;; 164 161 165 165 - -T) no_target_directory=true;; 162 162 + -t) 163 163 + is_target_a_directory=always 164 164 + dst_arg=$2 165 165 + # Protect names problematic for 'test' and other utilities. 166 166 + case $dst_arg in 167 167 + -* | [=\(\)!]) dst_arg=./$dst_arg;; 168 168 + esac 169 169 + shift;; 170 170 + 171 171 + -T) is_target_a_directory=never;; 166 172 167 173 --version) echo "$0 $scriptversion"; exit $?;; 168 174 169 169 - --) shift 170 170 - break;; 175 175 + --) shift 176 176 + break;; 171 177 172 172 - -*) echo "$0: invalid option: $1" >&2 173 173 - exit 1;; 178 178 + -*) echo "$0: invalid option: $1" >&2 179 179 + exit 1;; 174 180 175 181 *) break;; 176 182 esac 177 183 shift 178 184 done 185 185 + 186 186 + # We allow the use of options -d and -T together, by making -d 187 187 + # take the precedence; this is for compatibility with GNU install. 188 188 + 189 189 + if test -n "$dir_arg"; then 190 190 + if test -n "$dst_arg"; then 191 191 + echo "$0: target directory not allowed when installing a directory." >&2 192 192 + exit 1 193 193 + fi 194 194 + fi 179 195 180 196 if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then 181 197 # When -d is used, all remaining arguments are directories to create. ··· 208 224 fi 209 225 210 226 if test -z "$dir_arg"; then 227 227 + if test $# -gt 1 || test "$is_target_a_directory" = always; then 228 228 + if test ! -d "$dst_arg"; then 229 229 + echo "$0: $dst_arg: Is not a directory." >&2 230 230 + exit 1 231 231 + fi 232 232 + fi 233 233 + fi 234 234 + 235 235 + if test -z "$dir_arg"; then 211 236 do_exit='(exit $ret); exit $ret' 212 237 trap "ret=129; $do_exit" 1 213 238 trap "ret=130; $do_exit" 2 ··· 223 248 224 249 *[0-7]) 225 250 if test -z "$stripcmd"; then 226 226 - u_plus_rw= 251 251 + u_plus_rw= 227 252 else 228 228 - u_plus_rw='% 200' 253 253 + u_plus_rw='% 200' 229 254 fi 230 255 cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; 231 256 *) 232 257 if test -z "$stripcmd"; then 233 233 - u_plus_rw= 258 258 + u_plus_rw= 234 259 else 235 235 - u_plus_rw=,u+rw 260 260 + u_plus_rw=,u+rw 236 261 fi 237 262 cp_umask=$mode$u_plus_rw;; 238 263 esac ··· 250 275 dstdir=$dst 251 276 test -d "$dstdir" 252 277 dstdir_status=$? 278 278 + # Don't chown directories that already exist. 279 279 + if test $dstdir_status = 0; then 280 280 + chowncmd="" 281 281 + fi 253 282 else 254 283 255 284 # Waiting for this to be detected by the "$cpprog $src $dsttmp" command ··· 266 295 fi 267 296 dst=$dst_arg 268 297 269 269 - # If destination is a directory, append the input filename; won't work 270 270 - # if double slashes aren't ignored. 298 298 + # If destination is a directory, append the input filename. 271 299 if test -d "$dst"; then 272 272 - if test -n "$no_target_directory"; then 273 273 - echo "$0: $dst_arg: Is a directory" >&2 274 274 - exit 1 300 300 + if test "$is_target_a_directory" = never; then 301 301 + echo "$0: $dst_arg: Is a directory" >&2 302 302 + exit 1 275 303 fi 276 304 dstdir=$dst 277 277 - dst=$dstdir/`basename "$src"` 305 305 + dstbase=`basename "$src"` 306 306 + case $dst in 307 307 + */) dst=$dst$dstbase;; 308 308 + *) dst=$dst/$dstbase;; 309 309 + esac 278 310 dstdir_status=0 279 311 else 280 280 - # Prefer dirname, but fall back on a substitute if dirname fails. 281 281 - dstdir=` 282 282 - (dirname "$dst") 2>/dev/null || 283 283 - expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ 284 284 - X"$dst" : 'X\(//\)[^/]' \| \ 285 285 - X"$dst" : 'X\(//\)$' \| \ 286 286 - X"$dst" : 'X\(/\)' \| . 2>/dev/null || 287 287 - echo X"$dst" | 288 288 - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 289 289 - s//\1/ 290 290 - q 291 291 - } 292 292 - /^X\(\/\/\)[^/].*/{ 293 293 - s//\1/ 294 294 - q 295 295 - } 296 296 - /^X\(\/\/\)$/{ 297 297 - s//\1/ 298 298 - q 299 299 - } 300 300 - /^X\(\/\).*/{ 301 301 - s//\1/ 302 302 - q 303 303 - } 304 304 - s/.*/./; q' 305 305 - ` 306 306 - 312 312 + dstdir=`dirname "$dst"` 307 313 test -d "$dstdir" 308 314 dstdir_status=$? 309 315 fi 310 316 fi 317 317 + 318 318 + case $dstdir in 319 319 + */) dstdirslash=$dstdir;; 320 320 + *) dstdirslash=$dstdir/;; 321 321 + esac 311 322 312 323 obsolete_mkdir_used=false 313 324 314 325 if test $dstdir_status != 0; then 315 326 case $posix_mkdir in 316 327 '') 317 317 - # Create intermediate dirs using mode 755 as modified by the umask. 318 318 - # This is like FreeBSD 'install' as of 1997-10-28. 319 319 - umask=`umask` 320 320 - case $stripcmd.$umask in 321 321 - # Optimize common cases. 322 322 - *[2367][2367]) mkdir_umask=$umask;; 323 323 - .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; 328 328 + # With -d, create the new directory with the user-specified mode. 329 329 + # Otherwise, rely on $mkdir_umask. 330 330 + if test -n "$dir_arg"; then 331 331 + mkdir_mode=-m$mode 332 332 + else 333 333 + mkdir_mode= 334 334 + fi 335 335 + 336 336 + posix_mkdir=false 337 337 + # The $RANDOM variable is not portable (e.g., dash). Use it 338 338 + # here however when possible just to lower collision chance. 339 339 + tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ 324 340 325 325 - *[0-7]) 326 326 - mkdir_umask=`expr $umask + 22 \ 327 327 - - $umask % 100 % 40 + $umask % 20 \ 328 328 - - $umask % 10 % 4 + $umask % 2 329 329 - `;; 330 330 - *) mkdir_umask=$umask,go-w;; 331 331 - esac 341 341 + trap ' 342 342 + ret=$? 343 343 + rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null 344 344 + exit $ret 345 345 + ' 0 332 346 333 333 - # With -d, create the new directory with the user-specified mode. 334 334 - # Otherwise, rely on $mkdir_umask. 335 335 - if test -n "$dir_arg"; then 336 336 - mkdir_mode=-m$mode 347 347 + # Because "mkdir -p" follows existing symlinks and we likely work 348 348 + # directly in world-writeable /tmp, make sure that the '$tmpdir' 349 349 + # directory is successfully created first before we actually test 350 350 + # 'mkdir -p'. 351 351 + if (umask $mkdir_umask && 352 352 + $mkdirprog $mkdir_mode "$tmpdir" && 353 353 + exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1 354 354 + then 355 355 + if test -z "$dir_arg" || { 356 356 + # Check for POSIX incompatibilities with -m. 357 357 + # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or 358 358 + # other-writable bit of parent directory when it shouldn't. 359 359 + # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. 360 360 + test_tmpdir="$tmpdir/a" 361 361 + ls_ld_tmpdir=`ls -ld "$test_tmpdir"` 362 362 + case $ls_ld_tmpdir in 363 363 + d????-?r-*) different_mode=700;; 364 364 + d????-?--*) different_mode=755;; 365 365 + *) false;; 366 366 + esac && 367 367 + $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { 368 368 + ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` 369 369 + test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" 370 370 + } 371 371 + } 372 372 + then posix_mkdir=: 373 373 + fi 374 374 + rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 337 375 else 338 338 - mkdir_mode= 376 376 + # Remove any dirs left behind by ancient mkdir implementations. 377 377 + rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null 339 378 fi 340 340 - 341 341 - posix_mkdir=false 342 342 - case $umask in 343 343 - *[123567][0-7][0-7]) 344 344 - # POSIX mkdir -p sets u+wx bits regardless of umask, which 345 345 - # is incompatible with FreeBSD 'install' when (umask & 300) != 0. 346 346 - ;; 347 347 - *) 348 348 - tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ 349 349 - trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 350 350 - 351 351 - if (umask $mkdir_umask && 352 352 - exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 353 353 - then 354 354 - if test -z "$dir_arg" || { 355 355 - # Check for POSIX incompatibilities with -m. 356 356 - # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or 357 357 - # other-writable bit of parent directory when it shouldn't. 358 358 - # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. 359 359 - ls_ld_tmpdir=`ls -ld "$tmpdir"` 360 360 - case $ls_ld_tmpdir in 361 361 - d????-?r-*) different_mode=700;; 362 362 - d????-?--*) different_mode=755;; 363 363 - *) false;; 364 364 - esac && 365 365 - $mkdirprog -m$different_mode -p -- "$tmpdir" && { 366 366 - ls_ld_tmpdir_1=`ls -ld "$tmpdir"` 367 367 - test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" 368 368 - } 369 369 - } 370 370 - then posix_mkdir=: 371 371 - fi 372 372 - rmdir "$tmpdir/d" "$tmpdir" 373 373 - else 374 374 - # Remove any dirs left behind by ancient mkdir implementations. 375 375 - rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null 376 376 - fi 377 377 - trap '' 0;; 378 378 - esac;; 379 379 + trap '' 0;; 379 380 esac 380 381 381 382 if 382 383 $posix_mkdir && ( 383 383 - umask $mkdir_umask && 384 384 - $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" 384 384 + umask $mkdir_umask && 385 385 + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" 385 386 ) 386 387 then : 387 388 else 388 389 389 389 - # The umask is ridiculous, or mkdir does not conform to POSIX, 390 390 + # mkdir does not conform to POSIX, 390 391 # or it failed possibly due to a race condition. Create the 391 392 # directory the slow way, step by step, checking for races as we go. 392 393 393 394 case $dstdir in 394 394 - /*) prefix='/';; 395 395 - [-=\(\)!]*) prefix='./';; 396 396 - *) prefix='';; 395 395 + /*) prefix='/';; 396 396 + [-=\(\)!]*) prefix='./';; 397 397 + *) prefix='';; 397 398 esac 398 398 - 399 399 - eval "$initialize_posix_glob" 400 399 401 400 oIFS=$IFS 402 401 IFS=/ 403 403 - $posix_glob set -f 402 402 + set -f 404 403 set fnord $dstdir 405 404 shift 406 406 - $posix_glob set +f 405 405 + set +f 407 406 IFS=$oIFS 408 407 409 408 prefixes= 410 409 411 410 for d 412 411 do 413 413 - test X"$d" = X && continue 412 412 + test X"$d" = X && continue 414 413 415 415 - prefix=$prefix$d 416 416 - if test -d "$prefix"; then 417 417 - prefixes= 418 418 - else 419 419 - if $posix_mkdir; then 420 420 - (umask=$mkdir_umask && 421 421 - $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break 422 422 - # Don't fail if two instances are running concurrently. 423 423 - test -d "$prefix" || exit 1 424 424 - else 425 425 - case $prefix in 426 426 - *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; 427 427 - *) qprefix=$prefix;; 428 428 - esac 429 429 - prefixes="$prefixes '$qprefix'" 430 430 - fi 431 431 - fi 432 432 - prefix=$prefix/ 414 414 + prefix=$prefix$d 415 415 + if test -d "$prefix"; then 416 416 + prefixes= 417 417 + else 418 418 + if $posix_mkdir; then 419 419 + (umask $mkdir_umask && 420 420 + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break 421 421 + # Don't fail if two instances are running concurrently. 422 422 + test -d "$prefix" || exit 1 423 423 + else 424 424 + case $prefix in 425 425 + *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; 426 426 + *) qprefix=$prefix;; 427 427 + esac 428 428 + prefixes="$prefixes '$qprefix'" 429 429 + fi 430 430 + fi 431 431 + prefix=$prefix/ 433 432 done 434 433 435 434 if test -n "$prefixes"; then 436 436 - # Don't fail if two instances are running concurrently. 437 437 - (umask $mkdir_umask && 438 438 - eval "\$doit_exec \$mkdirprog $prefixes") || 439 439 - test -d "$dstdir" || exit 1 440 440 - obsolete_mkdir_used=true 435 435 + # Don't fail if two instances are running concurrently. 436 436 + (umask $mkdir_umask && 437 437 + eval "\$doit_exec \$mkdirprog $prefixes") || 438 438 + test -d "$dstdir" || exit 1 439 439 + obsolete_mkdir_used=true 441 440 fi 442 441 fi 443 442 fi ··· 450 449 else 451 450 452 451 # Make a couple of temp file names in the proper directory. 453 453 - dsttmp=$dstdir/_inst.$$_ 454 454 - rmtmp=$dstdir/_rm.$$_ 452 452 + dsttmp=${dstdirslash}_inst.$$_ 453 453 + rmtmp=${dstdirslash}_rm.$$_ 455 454 456 455 # Trap to clean up those temp files at exit. 457 456 trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 458 457 459 458 # Copy the file name to the temp name. 460 460 - (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && 459 459 + (umask $cp_umask && 460 460 + { test -z "$stripcmd" || { 461 461 + # Create $dsttmp read-write so that cp doesn't create it read-only, 462 462 + # which would cause strip to fail. 463 463 + if test -z "$doit"; then 464 464 + : >"$dsttmp" # No need to fork-exec 'touch'. 465 465 + else 466 466 + $doit touch "$dsttmp" 467 467 + fi 468 468 + } 469 469 + } && 470 470 + $doit_exec $cpprog "$src" "$dsttmp") && 461 471 462 472 # and set any options; do chmod last to preserve setuid bits. 463 473 # ··· 472 482 473 483 # If -C, don't bother to copy if it wouldn't change the file. 474 484 if $copy_on_change && 475 475 - old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && 476 476 - new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && 477 477 - 478 478 - eval "$initialize_posix_glob" && 479 479 - $posix_glob set -f && 485 485 + old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && 486 486 + new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && 487 487 + set -f && 480 488 set X $old && old=:$2:$4:$5:$6 && 481 489 set X $new && new=:$2:$4:$5:$6 && 482 482 - $posix_glob set +f && 483 483 - 490 490 + set +f && 484 491 test "$old" = "$new" && 485 492 $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 486 493 then 487 494 rm -f "$dsttmp" 488 495 else 496 496 + # If $backupsuffix is set, and the file being installed 497 497 + # already exists, attempt a backup. Don't worry if it fails, 498 498 + # e.g., if mv doesn't support -f. 499 499 + if test -n "$backupsuffix" && test -f "$dst"; then 500 500 + $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null 501 501 + fi 502 502 + 489 503 # Rename the file to the real destination. 490 504 $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || 491 505 ··· 493 507 # to itself, or perhaps because mv is so ancient that it does not 494 508 # support -f. 495 509 { 496 496 - # Now remove or move aside any old file at destination location. 497 497 - # We try this two ways since rm can't unlink itself on some 498 498 - # systems and the destination file might be busy for other 499 499 - # reasons. In this case, the final cleanup might fail but the new 500 500 - # file should still install successfully. 501 501 - { 502 502 - test ! -f "$dst" || 503 503 - $doit $rmcmd -f "$dst" 2>/dev/null || 504 504 - { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && 505 505 - { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } 506 506 - } || 507 507 - { echo "$0: cannot unlink or rename $dst" >&2 508 508 - (exit 1); exit 1 509 509 - } 510 510 - } && 510 510 + # Now remove or move aside any old file at destination location. 511 511 + # We try this two ways since rm can't unlink itself on some 512 512 + # systems and the destination file might be busy for other 513 513 + # reasons. In this case, the final cleanup might fail but the new 514 514 + # file should still install successfully. 515 515 + { 516 516 + test ! -f "$dst" || 517 517 + $doit $rmcmd "$dst" 2>/dev/null || 518 518 + { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && 519 519 + { $doit $rmcmd "$rmtmp" 2>/dev/null; :; } 520 520 + } || 521 521 + { echo "$0: cannot unlink or rename $dst" >&2 522 522 + (exit 1); exit 1 523 523 + } 524 524 + } && 511 525 512 512 - # Now rename the file to the real destination. 513 513 - $doit $mvcmd "$dsttmp" "$dst" 526 526 + # Now rename the file to the real destination. 527 527 + $doit $mvcmd "$dsttmp" "$dst" 514 528 } 515 529 fi || exit 1 516 530 ··· 519 533 done 520 534 521 535 # Local variables: 522 522 - # eval: (add-hook 'write-file-hooks 'time-stamp) 536 536 + # eval: (add-hook 'before-save-hook 'time-stamp) 523 537 # time-stamp-start: "scriptversion=" 524 538 # time-stamp-format: "%:y-%02m-%02d.%02H" 525 525 - # time-stamp-time-zone: "UTC" 539 539 + # time-stamp-time-zone: "UTC0" 526 540 # time-stamp-end: "; # UTC" 527 541 # End:

-3

app/xkbevd/man/Makefile.in

reviewed

··· 125 125 CCDEPMODE = @CCDEPMODE@ 126 126 CFLAGS = @CFLAGS@ 127 127 CHANGELOG_CMD = @CHANGELOG_CMD@ 128 128 - CPP = @CPP@ 129 128 CPPFLAGS = @CPPFLAGS@ 130 129 CWARNFLAGS = @CWARNFLAGS@ 131 130 CYGPATH_W = @CYGPATH_W@ ··· 136 135 ECHO_C = @ECHO_C@ 137 136 ECHO_N = @ECHO_N@ 138 137 ECHO_T = @ECHO_T@ 139 139 - EGREP = @EGREP@ 140 138 EXEEXT = @EXEEXT@ 141 139 FILE_MAN_DIR = @FILE_MAN_DIR@ 142 140 FILE_MAN_SUFFIX = @FILE_MAN_SUFFIX@ 143 143 - GREP = @GREP@ 144 141 INSTALL = @INSTALL@ 145 142 INSTALL_CMD = @INSTALL_CMD@ 146 143 INSTALL_DATA = @INSTALL_DATA@

-29

app/xkbevd/utils.c

reviewed

··· 125 125 126 126 /***====================================================================***/ 127 127 128 128 - #ifndef HAVE_STRCASECMP 129 129 - int 130 130 - uStrCaseCmp(const char *str1, const char *str2) 131 131 - { 132 132 - char buf1[512], buf2[512]; 133 133 - 134 134 - char c, *s; 135 135 - 136 136 - register int n; 137 137 - 138 138 - for (n = 0, s = buf1; (c = *str1++); n++) { 139 139 - if (isupper(c)) 140 140 - c = tolower(c); 141 141 - if (n > 510) 142 142 - break; 143 143 - *s++ = c; 144 144 - } 145 145 - *s = '\0'; 146 146 - for (n = 0, s = buf2; (c = *str2++); n++) { 147 147 - if (isupper(c)) 148 148 - c = tolower(c); 149 149 - if (n > 510) 150 150 - break; 151 151 - *s++ = c; 152 152 - } 153 153 - *s = '\0'; 154 154 - return (strcmp(buf1, buf2)); 155 155 - } 156 156 - #endif

+7 -4

app/xkbevd/utils.h

reviewed

··· 39 39 #include <X11/Xfuncs.h> 40 40 #include <stdarg.h> 41 41 #include <stddef.h> 42 42 + #if !defined(_MSC_VER) 43 43 + #include <strings.h> 44 44 + #endif 42 45 43 46 _XFUNCPROTOBEGIN 44 47 ··· 87 90 88 91 /***====================================================================***/ 89 92 93 93 + #if defined(_MSC_VER) 94 94 + #define strcasecmp _stricmp 95 95 + #endif 96 96 + 90 97 #define NullString ((char *)NULL) 91 98 92 99 #define uStringText(s) ((s)==NullString?"<NullString>":(s)) ··· 94 101 #define uStringPrefix(p,s) (strncmp(p,s,strlen(p))==0) 95 102 #define uStringCompare(s1,s2) (strcmp(s1,s2)) 96 103 #define uStrCaseEqual(s1,s2) (uStrCaseCmp(s1,s2)==0) 97 97 - #ifdef HAVE_STRCASECMP 98 104 #define uStrCaseCmp(s1,s2) (strcasecmp(s1,s2)) 99 99 - #else 100 100 - extern int uStrCaseCmp(const char *s1, const char *s2); 101 101 - #endif 102 105 #define uStringDup(s1) (strdup(s1)) 103 106 104 107 /***====================================================================***/

+6 -4

app/xkbevd/xkbevd.c

reviewed

··· 57 57 static const char *cfgFileName = NULL; 58 58 int xkbOpcode = 0; 59 59 int xkbEventCode = 0; 60 60 - Bool detectableRepeat = False; 61 60 62 61 static CfgEntryPtr config = NULL; 63 62 static unsigned long eventMask = 0; ··· 192 191 else if (strcmp(argv[i], "-v") == 0) { 193 192 verbose++; 194 193 } 195 195 - else if (strcmp(argv[i], "-version") == 0) { 194 194 + else if ((strcmp(argv[i], "-version") == 0) || 195 195 + (strcmp(argv[i], "--version") == 0)) { 196 196 puts(PACKAGE_STRING); 197 197 exit(0); 198 198 } 199 199 else if ((strcmp(argv[i], "-?") == 0) || 200 200 - (strcmp(argv[i], "-help") == 0)) { 200 200 + (strcmp(argv[i], "-help") == 0) || 201 201 + (strcmp(argv[i], "--help") == 0)) { 201 202 Usage(argc, argv); 202 203 exit(0); 203 204 } ··· 403 404 ProcessMatchingConfig(XkbEvent * ev) 404 405 { 405 406 CfgEntryPtr cfg; 406 406 - char buf[1024], *cmd; 407 407 + char buf[1024]; 408 408 + const char *cmd; 407 409 int ok; 408 410 409 411 cfg = FindMatchingConfig(ev);

+3 -4

app/xkbevd/xkbevd.h

reviewed

··· 47 47 extern Display * dpy; 48 48 extern int xkbOpcode; 49 49 extern int xkbEventCode; 50 50 - extern Bool detectableRepeat; 51 50 52 51 extern XkbDescPtr xkb; 53 52 ··· 83 82 CfgEntryPtr /* cfgs */ 84 83 ); 85 84 86 86 - extern char *SubstituteEventArgs( 87 87 - char * /* cmd */, 88 88 - XkbEvent * /* ev */ 85 85 + extern const char *SubstituteEventArgs( 86 86 + const char * /* cmd */, 87 87 + const XkbEvent * /* ev */ 89 88 ); 90 89 91 90 extern void PrintXkbEvent(