[PATCH 1/6] build: beware of Clang++ not supporting POSIXLY_CORRECT

[Akim Demaille]

* m4/c-working.m4 (BISON_LANG_COMPILER_POSIXLY_CORRECT): New.
(BISON_C_COMPILER_POSIXLY_CORRECT): Use it.
For consistency with C++, also define BISON_C_WORKS.
* m4/cxx.m4 (BISON_CXX_COMPILER_POSIXLY_CORRECT): New.
* configure.ac: Use it.
* tests/atlocal.in: Get its result.
Propagate properly CXX values when used to compile C.
When POSIXLY_CORRECT, adjust BISON_C_WORKS and BISON_CXX_WORKS.
* tests/local.at (AT_COMPILE): Use BISON_C_WORKS.
---
 configure.ac     |  3 ++-
 m4/c-working.m4  | 42 +++++++++++++++++++++++++-----------------
 m4/cxx.m4        |  9 +++++++++
 tests/atlocal.in | 34 +++++++++++++++++++++++-----------
 tests/local.at   |  4 +---
 5 files changed, 60 insertions(+), 32 deletions(-)

diff --git a/configure.ac b/configure.ac
index d14cb29..e6403f4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -135,8 +135,9 @@ if test "$enable_gcc_warnings" = yes; then
 fi
 
 BISON_TEST_FOR_WORKING_C_COMPILER
-BISON_TEST_FOR_WORKING_CXX_COMPILER
 BISON_C_COMPILER_POSIXLY_CORRECT
+BISON_TEST_FOR_WORKING_CXX_COMPILER
+BISON_CXX_COMPILER_POSIXLY_CORRECT
 
 AC_ARG_ENABLE([yacc],
   [AC_HELP_STRING([--disable-yacc],
diff --git a/m4/c-working.m4 b/m4/c-working.m4
index 0db60f7..de1a4c5 100644
--- a/m4/c-working.m4
+++ b/m4/c-working.m4
@@ -24,6 +24,7 @@ AC_DEFUN([BISON_TEST_FOR_WORKING_C_COMPILER], [
         int test_array[CHAR_BIT];]])],
     [],
     [AC_MSG_FAILURE([cannot compile a simple C program])])
+   AC_SUBST([BISON_C_WORKS], [:])
 ])
 
 # BISON_CHECK_WITH_POSIXLY_CORRECT(CODE)
@@ -47,25 +48,32 @@ case $gl_had_POSIXLY_CORRECT in
 esac
 ])
 
+# BISON_LANG_COMPILER_POSIXLY_CORRECT
+# -----------------------------------
+# Whether the compiler for the current language supports -g in
+# POSIXLY_CORRECT mode.  clang-2.9 on OS X does not, because
+# "clang-mp-2.9 -o test -g test.c" launches "/usr/bin/dsymutil test -o
+# test.dSYM" which fails with "error: unable to open executable '-o'".
+#
+# Sets <LANG>_COMPILER_POSIXLY_CORRECT to true/false.
+AC_DEFUN([BISON_LANG_COMPILER_POSIXLY_CORRECT],
+[AC_CACHE_CHECK([whether $_AC_CC supports POSIXLY_CORRECT=1],
+                [bison_cv_[]_AC_LANG_ABBREV[]_supports_posixly_correct],
+[BISON_CHECK_WITH_POSIXLY_CORRECT(
+[AC_LINK_IFELSE([AC_LANG_PROGRAM],
+                [bison_cv_[]_AC_LANG_ABBREV[]_supports_posixly_correct=yes],
+                [bison_cv_[]_AC_LANG_ABBREV[]_supports_posixly_correct=no])])])
+case $bison_cv_[]_AC_LANG_ABBREV[]_supports_posixly_correct in
+  yes) AC_SUBST(_AC_LANG_PREFIX[_COMPILER_POSIXLY_CORRECT], [true]) ;;
+  no)  AC_SUBST(_AC_LANG_PREFIX[_COMPILER_POSIXLY_CORRECT], [false]);;
+esac
+])
+
 # BISON_C_COMPILER_POSIXLY_CORRECT
 # --------------------------------
-# Whether the compiler supports -g in POSIXLY_CORRECT mode.  clang-2.9
-# on OS X does not, because "clang-mp-2.9 -o test -g test.c" launches
-# "/usr/bin/dsymutil test -o test.dSYM" which fails with "error:
-# unable to open executable '-o'".
-#
-# Sets C_COMPILER_POSIXLY_CORRECT to true/false.
+# Whether the C compiler supports -g in POSIXLY_CORRECT mode.
 AC_DEFUN([BISON_C_COMPILER_POSIXLY_CORRECT],
-[AC_CACHE_CHECK([whether $CC supports POSIXLY_CORRECT=1],
-                [bison_cv_cc_supports_posixly_correct],
-[BISON_CHECK_WITH_POSIXLY_CORRECT(
 [AC_LANG_PUSH([C])
-AC_LINK_IFELSE([AC_LANG_PROGRAM],
-                [bison_cv_cc_supports_posixly_correct=yes],
-                [bison_cv_cc_supports_posixly_correct=no])
-AC_LANG_POP([C])])])
-case $bison_cv_cc_supports_posixly_correct in
-  yes) AC_SUBST([C_COMPILER_POSIXLY_CORRECT], [true]) ;;
-  no)  AC_SUBST([C_COMPILER_POSIXLY_CORRECT], [false]);;
-esac
+BISON_LANG_COMPILER_POSIXLY_CORRECT
+AC_LANG_POP([C])
 ])
diff --git a/m4/cxx.m4 b/m4/cxx.m4
index 7d5cc78..5e266c9 100644
--- a/m4/cxx.m4
+++ b/m4/cxx.m4
@@ -58,3 +58,12 @@ AC_DEFUN([BISON_TEST_FOR_WORKING_CXX_COMPILER],
  AC_SUBST([BISON_CXX_WORKS])
  AM_CONDITIONAL(BISON_CXX_WORKS, test $bison_cv_cxx_works = yes)
 ])
+
+# BISON_CXX_COMPILER_POSIXLY_CORRECT
+# ----------------------------------
+# Whether the C++ compiler supports -g in POSIXLY_CORRECT mode.
+AC_DEFUN([BISON_CXX_COMPILER_POSIXLY_CORRECT],
+[AC_LANG_PUSH([C++])
+BISON_LANG_COMPILER_POSIXLY_CORRECT
+AC_LANG_POP([C++])
+])
diff --git a/tests/atlocal.in b/tests/atlocal.in
index 5e3cb72..f817f94 100644
--- a/tests/atlocal.in
+++ b/tests/atlocal.in
@@ -19,6 +19,15 @@
 # We need `config.h'.
 CPPFLAGS="-I$abs_top_builddir/lib @CPPFLAGS@"
 
+# Don't just check if $POSIXLY_CORRECT is set, as Bash, when launched
+# as /bin/sh, sets the shell variable POSIXLY_CORRECT to y, but not
+# the environment variable.
+if env | grep '^POSIXLY_CORRECT=' >/dev/null; then
+  POSIXLY_CORRECT_IS_EXPORTED=true
+else
+  POSIXLY_CORRECT_IS_EXPORTED=false
+fi
+
 ## ------------------- ##
 ## C/C++ Compilation.  ##
 ## ------------------- ##
@@ -38,15 +47,28 @@ NO_WERROR_CXXFLAGS='@CXXFLAGS@ @WARN_CXXFLAGS@ 
@WARN_CXXFLAGS_TEST@'
   CFLAGS="$NO_WERROR_CFLAGS   @WERROR_CFLAGS@"
 CXXFLAGS="$NO_WERROR_CXXFLAGS @WERROR_CXXFLAGS@"
 
-# If 'exit 77'; skip all C++ tests; otherwise ':'.
+# If 'exit 77'; skip all C/C++ tests; otherwise ':'.
+BISON_C_WORKS='@BISON_C_WORKS@'
 BISON_CXX_WORKS='@BISON_CXX_WORKS@'
 
+# Whether the compiler supports POSIXLY_CORRECT defined.
+: ${C_COMPILER_POSIXLY_CORRECT='@C_COMPILER_POSIXLY_CORRECT@'}
+: ${CXX_COMPILER_POSIXLY_CORRECT='@CXX_COMPILER_POSIXLY_CORRECT@'}
+
+if $POSIXLY_CORRECT_IS_EXPORTED; then
+  $C_COMPILER_POSIXLY_CORRECT ||
+    BISON_C_WORKS="as_fn_error 77 POSIXLY_CORRECT"
+  $CXX_COMPILER_POSIXLY_CORRECT ||
+    BISON_CXX_WORKS="as_fn_error 77 POSIXLY_CORRECT"
+fi
+
 # Handle --compile-c-with-cxx here, once CXX and CXXFLAGS are known.
 if "$at_arg_compile_c_with_cxx"; then
   CC_IS_CXX=1
   CC=$CXX
   NO_WERROR_CFLAGS=$NO_WERROR_CXXFLAGS
   CFLAGS=$CXXFLAGS
+  BISON_C_WORKS=$BISON_CXX_WORKS
 else
   CC_IS_CXX=0
 fi
@@ -79,13 +101,3 @@ LIBS="$abs_top_builddir/lib/libbison.a @LIBS@ @INTLLIBS@"
 : ${XSLTPROC='@XSLTPROC@'}
 
 : ${PERL='@PERL@'}
-
-# Don't just check if $POSIXLY_CORRECT is set, as Bash, when launched
-# as /bin/sh, sets the shell variable POSIXLY_CORRECT to y, but not
-# the environment variable.
-: ${C_COMPILER_POSIXLY_CORRECT='@C_COMPILER_POSIXLY_CORRECT@'}
-if env | grep '^POSIXLY_CORRECT=' >/dev/null; then
-  POSIXLY_CORRECT_IS_EXPORTED=true
-else
-  POSIXLY_CORRECT_IS_EXPORTED=false
-fi
diff --git a/tests/local.at b/tests/local.at
index 48afab8..68a7eca 100644
--- a/tests/local.at
+++ b/tests/local.at
@@ -600,9 +600,7 @@ m4_define([AT_QUELL_VALGRIND],
 # otherwise pass "-c"; this is a hack.  The default SOURCES is OUTPUT
 # with trailing .o removed, and ".c" appended.
 m4_define([AT_COMPILE],
-[AT_CHECK([case $POSIXLY_CORRECT_IS_EXPORTED:$C_COMPILER_POSIXLY_CORRECT in
-  true:false) echo 'cannot compile properly with POSIXLY_CORRECT' && exit 77;;
-esac])
+[AT_CHECK([$BISON_C_WORKS], 0, ignore, ignore)
 AT_CHECK(m4_join([ ],
                   [$CC $CFLAGS $CPPFLAGS],
                   [m4_bmatch([$1], [[.]], [-c], [$LDFLAGS])],
-- 
1.8.0.1