[svn-r26622] Description:

    Bring r26546 from autotools_rework branch to trunk:

    Convert AC_TRY_RUN to AC_RUN_IFELSE, for the LDOUBLE_TO_LONG_SPECIAL and
LONG_TO_LDOUBLE_SPECIAL checks.

Tested on:
    Linux/32 2.6.18 (jam) w/serial & parallel
    (Daily tested on branch for 2+ days)

2 files changed, 240 insertions, 214 deletions

diff --git a/configure b/configure
index 9e01508..c67612d 100755
--- a/configure
+++ b/configure
@@ -28125,59 +28125,72 @@ else
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-        int main(void)
-        {
-            long double         ld = 20041683600089727.779961L;
-            long                ll;
-            unsigned long       ull;
-            unsigned char       s[16];
-            unsigned char       s2[8];
-            int                 ret = 1;
-
-            if(sizeof(long double) == 16 && sizeof(long) == 8) {
-                /*make sure the long double type has 16 bytes in size and
-                 * 11 bits of exponent.  If it is,
-                 *the bit sequence should be like below.  It's not
-                 *a decent way to check but this info isn't available. */
-                memcpy(s, &ld, 16);
-                if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
-                    s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
-                    s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
-
-                    /* Assign the hexadecimal value of long double type. */
-                    s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
-                    s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
-                    s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
-                    s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
-
-                    memcpy(&ld, s, 16);
-
-                    ll = (long)ld;
-                    memcpy(s2, &ll, 8);
-
-                    /* The library's algorithm converts it to 0x 00 47 33 ce 17 af 22 82
-                     * and gets wrong value 20041683600089730 on the IBM Power6 Linux.
-                     * But the IBM Power6 Linux converts it to 0x00 47 33 ce 17 af 22 7f
-                     * and gets the correct value 20041683600089727.  It uses some special
-                     * algorithm.  We're going to define the macro and skip the test until
-                     * we can figure out how they do it. */
-                    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
-                       s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
-                        ret = 0;
+                #include <string.h>
 
-                    ull = (unsigned long)ld;
-                    memcpy(s2, &ull, 8);
+#ifdef FC_DUMMY_MAIN
+#ifndef FC_DUMMY_MAIN_EQ_F77
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int FC_DUMMY_MAIN() { return 1; }
+#endif
+#endif
+int
+main ()
+{
 
-                    /* The unsigned long is the same as signed long. */
-                    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
-                       s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
-                        ret = 0;
+                long double         ld = 20041683600089727.779961L;
+                long                ll;
+                unsigned long       ull;
+                unsigned char       s[16];
+                unsigned char       s2[8];
+                int                 ret = 1;
+
+                if(sizeof(long double) == 16 && sizeof(long) == 8) {
+                    /*make sure the long double type has 16 bytes in size and
+                     * 11 bits of exponent.  If it is,
+                     *the bit sequence should be like below.  It's not
+                     *a decent way to check but this info isn't available. */
+                    memcpy(s, &ld, 16);
+                    if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
+                        s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
+                        s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
+
+                        /* Assign the hexadecimal value of long double type. */
+                        s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
+                        s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
+                        s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
+                        s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
+
+                        memcpy(&ld, s, 16);
+
+                        ll = (long)ld;
+                        memcpy(s2, &ll, 8);
+
+                        /* The library's algorithm converts it to 0x 00 47 33 ce 17 af 22 82
+                         * and gets wrong value 20041683600089730 on the IBM Power6 Linux.
+                         * But the IBM Power6 Linux converts it to 0x00 47 33 ce 17 af 22 7f
+                         * and gets the correct value 20041683600089727.  It uses some special
+                         * algorithm.  We're going to define the macro and skip the test until
+                         * we can figure out how they do it. */
+                        if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+                           s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+                            ret = 0;
+
+                        ull = (unsigned long)ld;
+                        memcpy(s2, &ull, 8);
+
+                        /* The unsigned long is the same as signed long. */
+                        if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+                           s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+                            ret = 0;
+                    }
                 }
-            }
+                exit(ret);
 
-    done:
-            exit(ret);
-        }
+  ;
+  return 0;
+}
 
 _ACEOF
 if ac_fn_c_try_run "$LINENO"; then :
@@ -28230,61 +28243,75 @@ else
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-        int main(void)
-        {
-            long double         ld;
-            long                ll;
-            unsigned long       ull;
-            unsigned char       s[16];
-            int                 flag=0, ret=1;
+                #include <string.h>
 
-            /*Determine if long double has 16 byte in size, 11 bit exponent, and
-             *the bias is 0x3ff */
-            if(sizeof(long double) == 16) {
-                ld = 1.0L;
-                memcpy(s, &ld, 16);
-                if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00)
-                    flag = 1;
-            }
+#ifdef FC_DUMMY_MAIN
+#ifndef FC_DUMMY_MAIN_EQ_F77
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int FC_DUMMY_MAIN() { return 1; }
+#endif
+#endif
+int
+main ()
+{
 
-            if(flag==1 && sizeof(long)==8) {
-                ll = 0x003fffffffffffffL;
-                ld = (long double)ll;
-                memcpy(s, &ld, 16);
-                /* The library converts the value to 0x434fffffffffffff8000000000000000.
-                 * In decimal it is 18014398509481982.000000, one value short of the original.
-                 * The IBM Power6 Linux converts it to 0x4350000000000000bff0000000000000.
-                 * The value is correct in decimal. It uses some special
-                 * algorithm.  We're going to define the macro and skip the test until
-                 * we can figure out how they do it. */
-                if(s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
-                    s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
-                    s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
-                    ret = 0;
-            }
-            if(flag==1 && sizeof(unsigned long)==8) {
-                ull = 0xffffffffffffffffUL;
-                ld = (long double)ull;
-                memcpy(s, &ld, 16);
-                /* Use a different value from signed long to test. The problem is the same
-                 * for both long and unsigned long. The value is 18446744073709551615.
-                 * The library converts the value to 0x43effffffffffffffe000000000000000.
-                 * In decimal it's 18446744073709548544.000000, very different from the original.
-                 * The IBM Power6 Linux converts it to 0x43f0000000000000bff0000000000000.
-                 * The value is correct in decimal. It uses some special
-                 * algorithm.  We're going to define the macro and skip the test until
-                 * we can figure out how they do it. */
-                if(s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
-                    s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
-                    s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
-                    ret = 0;
-            }
-    done:
-            exit(ret);
-        }
+                long double         ld;
+                long                ll;
+                unsigned long       ull;
+                unsigned char       s[16];
+                int                 flag=0, ret=1;
+
+                /*Determine if long double has 16 byte in size, 11 bit exponent, and
+                 *the bias is 0x3ff */
+                if(sizeof(long double) == 16) {
+                    ld = 1.0L;
+                    memcpy(s, &ld, 16);
+                    if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+                        s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00)
+                        flag = 1;
+                }
+
+                if(flag==1 && sizeof(long)==8) {
+                    ll = 0x003fffffffffffffL;
+                    ld = (long double)ll;
+                    memcpy(s, &ld, 16);
+                    /* The library converts the value to 0x434fffffffffffff8000000000000000.
+                     * In decimal it is 18014398509481982.000000, one value short of the original.
+                     * The IBM Power6 Linux converts it to 0x4350000000000000bff0000000000000.
+                     * The value is correct in decimal. It uses some special
+                     * algorithm.  We're going to define the macro and skip the test until
+                     * we can figure out how they do it. */
+                    if(s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
+                        s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+                        s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+                        s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+                        ret = 0;
+                }
+                if(flag==1 && sizeof(unsigned long)==8) {
+                    ull = 0xffffffffffffffffUL;
+                    ld = (long double)ull;
+                    memcpy(s, &ld, 16);
+                    /* Use a different value from signed long to test. The problem is the same
+                     * for both long and unsigned long. The value is 18446744073709551615.
+                     * The library converts the value to 0x43effffffffffffffe000000000000000.
+                     * In decimal it's 18446744073709548544.000000, very different from the original.
+                     * The IBM Power6 Linux converts it to 0x43f0000000000000bff0000000000000.
+                     * The value is correct in decimal. It uses some special
+                     * algorithm.  We're going to define the macro and skip the test until
+                     * we can figure out how they do it. */
+                    if(s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+                        s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+                        s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+                        s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+                        ret = 0;
+                }
+                exit(ret);
+
+  ;
+  return 0;
+}
 
 _ACEOF
 if ac_fn_c_try_run "$LINENO"; then :
diff --git a/configure.ac b/configure.ac
index 2b821a5..e285d5e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2555,61 +2555,60 @@ if test ${ac_cv_sizeof_long_double} = 0; then
    hdf5_cv_ldouble_to_long_special=${hdf5_cv_ldouble_to_long_special=no}
 else
    AC_CACHE_VAL([hdf5_cv_ldouble_to_long_special],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double         ld = 20041683600089727.779961L;
-            long                ll;
-            unsigned long       ull;
-            unsigned char       s[16];
-            unsigned char       s2[8];
-            int                 ret = 1;
-            
-            if(sizeof(long double) == 16 && sizeof(long) == 8) {
-                /*make sure the long double type has 16 bytes in size and 
-                 * 11 bits of exponent.  If it is,
-                 *the bit sequence should be like below.  It's not 
-                 *a decent way to check but this info isn't available. */   
-                memcpy(s, &ld, 16);
-                if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
-                    s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
-                    s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
-
-                    /* Assign the hexadecimal value of long double type. */
-                    s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
-                    s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
-                    s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
-                    s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
-
-                    memcpy(&ld, s, 16);
-
-                    ll = (long)ld;
-                    memcpy(s2, &ll, 8);
-
-                    /* The library's algorithm converts it to 0x 00 47 33 ce 17 af 22 82
-                     * and gets wrong value 20041683600089730 on the IBM Power6 Linux.
-                     * But the IBM Power6 Linux converts it to 0x00 47 33 ce 17 af 22 7f
-                     * and gets the correct value 20041683600089727.  It uses some special
-                     * algorithm.  We're going to define the macro and skip the test until
-                     * we can figure out how they do it. */
-                    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
-                       s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
-                        ret = 0;
-
-                    ull = (unsigned long)ld;
-                    memcpy(s2, &ull, 8);
-
-                    /* The unsigned long is the same as signed long. */
-                    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
-                       s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
-                        ret = 0;
-                }    
-            }   
-            
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_ldouble_to_long_special=yes], [hdf5_cv_ldouble_to_long_special=no],)])
+        [AC_RUN_IFELSE(
+            [AC_LANG_PROGRAM([
+                #include <string.h>
+            ],[[
+                long double         ld = 20041683600089727.779961L;
+                long                ll;
+                unsigned long       ull;
+                unsigned char       s[16];
+                unsigned char       s2[8];
+                int                 ret = 1;
+                
+                if(sizeof(long double) == 16 && sizeof(long) == 8) {
+                    /*make sure the long double type has 16 bytes in size and 
+                     * 11 bits of exponent.  If it is,
+                     *the bit sequence should be like below.  It's not 
+                     *a decent way to check but this info isn't available. */   
+                    memcpy(s, &ld, 16);
+                    if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
+                        s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
+                        s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
+
+                        /* Assign the hexadecimal value of long double type. */
+                        s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
+                        s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
+                        s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
+                        s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
+
+                        memcpy(&ld, s, 16);
+
+                        ll = (long)ld;
+                        memcpy(s2, &ll, 8);
+
+                        /* The library's algorithm converts it to 0x 00 47 33 ce 17 af 22 82
+                         * and gets wrong value 20041683600089730 on the IBM Power6 Linux.
+                         * But the IBM Power6 Linux converts it to 0x00 47 33 ce 17 af 22 7f
+                         * and gets the correct value 20041683600089727.  It uses some special
+                         * algorithm.  We're going to define the macro and skip the test until
+                         * we can figure out how they do it. */
+                        if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+                           s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+                            ret = 0;
+
+                        ull = (unsigned long)ld;
+                        memcpy(s2, &ull, 8);
+
+                        /* The unsigned long is the same as signed long. */
+                        if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+                           s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+                            ret = 0;
+                    }    
+                }   
+                exit(ret);
+        ]])]
+    , [hdf5_cv_ldouble_to_long_special=yes], [hdf5_cv_ldouble_to_long_special=no],)])
 fi
 
 if test ${hdf5_cv_ldouble_to_long_special} = "yes"; then
@@ -2634,63 +2633,63 @@ if test ${ac_cv_sizeof_long_double} = 0; then
    hdf5_cv_long_to_ldouble_special=${hdf5_cv_long_to_ldouble_special=no}
 else
    AC_CACHE_VAL([hdf5_cv_long_to_ldouble_special],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double         ld;
-            long                ll;
-            unsigned long       ull;
-            unsigned char       s[16];
-            int                 flag=0, ret=1;
-        
-            /*Determine if long double has 16 byte in size, 11 bit exponent, and
-             *the bias is 0x3ff */ 
-            if(sizeof(long double) == 16) { 
-                ld = 1.0L;
-                memcpy(s, &ld, 16);
-                if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00) 
-                    flag = 1; 
-            }
-             
-            if(flag==1 && sizeof(long)==8) {
-                ll = 0x003fffffffffffffL;
-                ld = (long double)ll;
-                memcpy(s, &ld, 16);
-                /* The library converts the value to 0x434fffffffffffff8000000000000000.
-                 * In decimal it is 18014398509481982.000000, one value short of the original.
-                 * The IBM Power6 Linux converts it to 0x4350000000000000bff0000000000000.
-                 * The value is correct in decimal. It uses some special
-                 * algorithm.  We're going to define the macro and skip the test until
-                 * we can figure out how they do it. */
-                if(s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
-                    s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
-                    s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
-                    ret = 0;
-            }        
-            if(flag==1 && sizeof(unsigned long)==8) {
-                ull = 0xffffffffffffffffUL;
-                ld = (long double)ull;
-                memcpy(s, &ld, 16);
-                /* Use a different value from signed long to test. The problem is the same
-                 * for both long and unsigned long. The value is 18446744073709551615.
-                 * The library converts the value to 0x43effffffffffffffe000000000000000.
-                 * In decimal it's 18446744073709548544.000000, very different from the original.
-                 * The IBM Power6 Linux converts it to 0x43f0000000000000bff0000000000000.
-                 * The value is correct in decimal. It uses some special
-                 * algorithm.  We're going to define the macro and skip the test until
-                 * we can figure out how they do it. */
-                if(s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
-                    s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
-                    s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
-                    ret = 0;
-            }        
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_long_to_ldouble_special=yes], [hdf5_cv_long_to_ldouble_special=no],)])
+        [AC_RUN_IFELSE(
+            [AC_LANG_PROGRAM([
+                #include <string.h>
+            ],[[
+                long double         ld;
+                long                ll;
+                unsigned long       ull;
+                unsigned char       s[16];
+                int                 flag=0, ret=1;
+            
+                /*Determine if long double has 16 byte in size, 11 bit exponent, and
+                 *the bias is 0x3ff */ 
+                if(sizeof(long double) == 16) { 
+                    ld = 1.0L;
+                    memcpy(s, &ld, 16);
+                    if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+                        s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00) 
+                        flag = 1; 
+                }
+                 
+                if(flag==1 && sizeof(long)==8) {
+                    ll = 0x003fffffffffffffL;
+                    ld = (long double)ll;
+                    memcpy(s, &ld, 16);
+                    /* The library converts the value to 0x434fffffffffffff8000000000000000.
+                     * In decimal it is 18014398509481982.000000, one value short of the original.
+                     * The IBM Power6 Linux converts it to 0x4350000000000000bff0000000000000.
+                     * The value is correct in decimal. It uses some special
+                     * algorithm.  We're going to define the macro and skip the test until
+                     * we can figure out how they do it. */
+                    if(s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
+                        s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+                        s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+                        s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+                        ret = 0;
+                }        
+                if(flag==1 && sizeof(unsigned long)==8) {
+                    ull = 0xffffffffffffffffUL;
+                    ld = (long double)ull;
+                    memcpy(s, &ld, 16);
+                    /* Use a different value from signed long to test. The problem is the same
+                     * for both long and unsigned long. The value is 18446744073709551615.
+                     * The library converts the value to 0x43effffffffffffffe000000000000000.
+                     * In decimal it's 18446744073709548544.000000, very different from the original.
+                     * The IBM Power6 Linux converts it to 0x43f0000000000000bff0000000000000.
+                     * The value is correct in decimal. It uses some special
+                     * algorithm.  We're going to define the macro and skip the test until
+                     * we can figure out how they do it. */
+                    if(s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+                        s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+                        s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+                        s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+                        ret = 0;
+                }        
+                exit(ret);
+        ]])]
+    , [hdf5_cv_long_to_ldouble_special=yes], [hdf5_cv_long_to_ldouble_special=no],)])
 fi
 
 if test ${hdf5_cv_long_to_ldouble_special} = "yes"; then