source: icXML/icXML-devel/configure.ac

Last change on this file was 3581, checked in by nmedfort, 6 years ago

changed AC_COMPILE to AC_RUN to test SSE/AVX/AVX2 support.

File size: 19.8 KB
Line 
1#                                               -*- Autoconf -*-
2# Process this file with autoconf to produce a configure script.
3#
4
5#
6# Licensed to the Apache Software Foundation (ASF) under one or more
7# contributor license agreements.  See the NOTICE file distributed with
8# this work for additional information regarding copyright ownership.
9# The ASF licenses this file to You under the Apache License, Version 2.0
10# (the "License"); you may not use this file except in compliance with
11# the License.  You may obtain a copy of the License at
12#
13#      http://www.apache.org/licenses/LICENSE-2.0
14#
15# Unless required by applicable law or agreed to in writing, software
16# distributed under the License is distributed on an "AS IS" BASIS,
17# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18# See the License for the specific language governing permissions and
19# limitations under the License.
20#
21
22#
23# $Id: configure.ac 935350 2010-04-18 15:02:36Z borisk $
24#
25
26AC_PREREQ(2.60)
27AC_INIT([xerces-c],[3.1.1])
28AC_CONFIG_SRCDIR([src/Makefile.am])
29AC_CONFIG_LIBOBJ_DIR([src])
30AC_CONFIG_AUX_DIR([config])
31AC_CONFIG_MACRO_DIR([m4])
32AC_CONFIG_HEADERS([config.h src/xercesc/util/Xerces_autoconf_config.hpp])
33AC_CONFIG_FILES([Makefile \
34                 src/Makefile \
35                 src/xercesc/util/MsgLoaders/MsgCatalog/Makefile \
36                 tests/Makefile \
37                 samples/Makefile \
38                 xerces-c.pc])
39
40# Check the target system
41AC_CANONICAL_HOST
42
43# Initialize automake
44AM_INIT_AUTOMAKE([foreign subdir-objects dist-bzip2 tar-ustar])
45AM_MAINTAINER_MODE
46
47# Check if rpath is disabled
48AC_MSG_CHECKING(whether to use rpath)
49AC_ARG_ENABLE(rpath,
50        [AC_HELP_STRING([--disable-rpath],
51                        [Patches libtool to not use rpath in the libraries produced.])],
52        [xerces_cv_rpath="$enable_rpath"], [xerces_cv_rpath="yes"])
53AC_MSG_RESULT($xerces_cv_rpath)
54
55# Checks for programs.
56AC_PROG_CXX
57# Use the C++ compiler for the compile tests
58AC_LANG(C++)
59# used by "make check"
60AC_PROG_SED
61#it would be nice to also check for PERL...
62#AC_PROG_PERL
63
64#skip detection of Fortran
65m4_undefine([AC_PROG_F77])
66m4_defun([AC_PROG_F77],[])
67
68AC_PROG_LN_S
69AC_LIBTOOL_WIN32_DLL
70AC_PROG_LIBTOOL
71AM_PROG_CC_C_O
72
73AS_IF([test x$AR = xfalse],
74        AC_MSG_ERROR([Cannot find a valid 'ar' tool]))
75
76# Patch libtool to not use rpath if requested.
77#
78AC_CONFIG_COMMANDS([libtool-rpath-patch],
79[if test "$libtool_patch_use_rpath" = "no"; then
80   echo config.status: patching libtool to not use rpath
81   sed < libtool > libtool-2 's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_NO_RPATH__ "/'
82   mv libtool-2 libtool
83   chmod 755 libtool
84fi],
85[libtool_patch_use_rpath=$xerces_cv_rpath])
86
87# Export information on whether we are building static/shared libraries.
88# enable_shared and enable_static are defined by AC_PROG_LIBTOOL.
89#
90AC_SUBST([BUILD_SHARED], [$enable_shared])
91AC_SUBST([BUILD_STATIC], [$enable_static])
92
93# Checks for header files.
94AC_HEADER_STDC
95AC_HEADER_TIME
96AC_CHECK_HEADERS([arpa/inet.h fcntl.h float.h inttypes.h langinfo.h limits.h locale.h \
97                  memory.h netdb.h netinet/in.h nl_types.h stddef.h stdint.h stdlib.h \
98                  string.h strings.h \
99                  sys/param.h sys/socket.h sys/time.h sys/timeb.h \
100                  unistd.h wchar.h wctype.h \
101                  CoreServices/CoreServices.h \
102                  endian.h machine/endian.h arpa/nameser_compat.h \
103                 ])
104
105# Checks for typedefs, structures, and compiler characteristics.
106AC_HEADER_STDBOOL
107AC_C_CONST
108AC_C_INLINE
109AC_C_VOLATILE
110
111AC_CHECK_SIZEOF(wchar_t)
112AC_CHECK_TYPE(size_t)
113AC_CHECK_TYPE(ssize_t)
114
115AC_TYPE_OFF_T
116AC_TYPE_SIZE_T
117
118XERCES_INT_TYPES
119
120AC_CXX_HAVE_BOOL
121AC_CXX_HAVE_NAMESPACES
122AC_CXX_HAVE_STD_NAMESPACE
123AC_CXX_HAVE_STD_LIBS
124AC_CXX_HAVE_LSTRING
125
126ACX_PTHREAD
127
128# Checks for library functions.
129#AC_FUNC_ERROR_AT_LINE
130#AC_FUNC_MALLOC
131#AC_FUNC_MEMCMP
132#AC_FUNC_STRCOLL
133#AC_FUNC_STRTOD
134AC_CHECK_FUNCS([getcwd pathconf realpath \
135                getaddrinfo gethostbyaddr gethostbyname socket \
136                clock_gettime ftime gettimeofday \
137                memmove memset nl_langinfo setlocale localeconv \
138                strcasecmp strncasecmp stricmp strnicmp strchr strdup \
139                strrchr strstr strtol strtoul \
140                towupper towlower mblen \
141        wcsupr wcslwr wcsnicmp wcsicmp \
142                ])
143
144# The check for mbrlen, wcsrtombs and mbsrtowcs gives a false
145# positive on HP-UX, so we use a different snippet to set the
146# corresponding macro
147AC_MSG_CHECKING([for mbrlen])
148AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <wchar.h>]],
149                                     [[mbstate_t st; mbrlen( "t", 5, &st );]])],
150                    [
151                      AC_MSG_RESULT([yes])
152                      AC_DEFINE_UNQUOTED([HAVE_MBRLEN], 1, [Define to 1 if you have the `mbrlen' function.])
153                    ],
154                    [
155                      AC_MSG_RESULT([no])
156                      AC_DEFINE_UNQUOTED([HAVE_MBRLEN], 0, [Define to 1 if you have the `mbrlen' function.])
157                    ]
158                 )
159AC_MSG_CHECKING([for wcsrtombs])
160AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <wchar.h>]],
161                                     [[mbstate_t st; char buffer[2]; const wchar_t* src=0; wcsrtombs(buffer, &src, 2, &st);]])],
162                    [
163                      AC_MSG_RESULT([yes])
164                      AC_DEFINE_UNQUOTED([HAVE_WCSRTOMBS], 1, [Define to 1 if you have the `wcsrtombs' function.])
165                    ],
166                    [
167                      AC_MSG_RESULT([no])
168                      AC_DEFINE_UNQUOTED([HAVE_WCSRTOMBS], 0, [Define to 1 if you have the `wcsrtombs' function.])
169                    ]
170                 )
171AC_MSG_CHECKING([for mbsrtowcs])
172AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <wchar.h>]],
173                                     [[mbstate_t st; wchar_t buffer[2]; const char* src=0; mbsrtowcs(buffer, &src, 2, &st);]])],
174                    [
175                      AC_MSG_RESULT([yes])
176                      AC_DEFINE_UNQUOTED([HAVE_MBSRTOWCS], 1, [Define to 1 if you have the `mbsrtowcs' function.])
177                    ],
178                    [
179                      AC_MSG_RESULT([no])
180                      AC_DEFINE_UNQUOTED([HAVE_MBSRTOWCS], 0, [Define to 1 if you have the `mbsrtowcs' function.])
181                    ]
182                 )
183
184AC_MSG_CHECKING([if iconv uses const pointers])
185AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <iconv.h>]],
186                                     [[
187                                       const char *fromPtr=0;
188                                       size_t     fromLen=0;
189                                       char       *toPtr=0;
190                                       size_t     toLen=0;
191                                       iconv_t    cv=0;
192                                       iconv(cv, &fromPtr, &fromLen, &toPtr, &toLen);
193                                      ]])],
194                    [
195                      AC_MSG_RESULT([yes])
196                      AC_DEFINE_UNQUOTED([ICONV_USES_CONST_POINTER], 1, [Define to 1 if you have to use const char* with iconv, to 0 if you must use char*.])
197                    ],
198                    [
199                      AC_MSG_RESULT([no])
200                      AC_DEFINE_UNQUOTED([ICONV_USES_CONST_POINTER], 0, [Define to 1 if you have to use const char* with iconv, to 0 if you must use char*.])
201                    ]
202                 )
203
204AC_SUBST([SHREXT], [$shrext_cmds])
205
206#
207# Orchestrate the replacement of missing functions
208#
209AC_REPLACE_FUNCS([stricmp strnicmp towlower towupper])
210
211abs_top_srcdir=`cd $srcdir; pwd`
212AC_SUBST(abs_top_srcdir)
213abs_top_builddir=`pwd`
214AC_SUBST(abs_top_builddir)
215
216######################################################
217# Look for availability of available packages
218######################################################
219
220XERCES_PRETTY_MAKE
221XERCES_PATH_DELIMITERS
222
223XERCES_MUTEXMGR_SELECTION
224XERCES_NETACCESSOR_SELECTION
225XERCES_TRANSCODER_SELECTION
226XERCES_MSGLOADER_SELECTION
227XERCES_FILEMGR_SELECTION
228
229# Allow the user to specify the pkgconfig directory.
230#
231AC_ARG_WITH(pkgconfigdir,
232        AC_HELP_STRING([--with-pkgconfigdir=DIR],[Specify location of pkgconfig dir (default is libdir/pkgconfig)]),
233        [pkgconfigdir=${withval}],
234        [pkgconfigdir='${libdir}/pkgconfig'])
235
236AC_SUBST([pkgconfigdir])
237
238# Allow the user to disable the SSE2 support
239#
240AC_ARG_ENABLE(sse2,
241    AC_HELP_STRING([--disable-sse2],[disable SSE2 optimizations]),
242    [have_sse2=${enableval}],
243    [have_sse2=yes])
244
245######################################################
246# Define some namespace-protected macros for use in the
247# publicly visible Xerces_autoconf_config.h file.
248######################################################
249
250AC_DEFINE([XERCES_AUTOCONF], 1, [Define to true if autoconf is used in this configuration])
251
252AS_IF([test x$ac_cv_header_sys_types_h = xyes],
253        AC_DEFINE([XERCES_HAVE_SYS_TYPES_H], 1, [Define to 1 if we have sys/types.h]))
254AS_IF([test x$ac_cv_header_inttypes_h = xyes],
255        AC_DEFINE([XERCES_HAVE_INTTYPES_H],    1, [Define to 1 if we have inttypes.h]))
256
257case $host in
258*-*-msdos* | *-*-mingw32* | *-*-cygwin* | *-*-windows* )
259        platform_export="__declspec(dllexport)"
260        platform_import="__declspec(dllimport)"
261        ;;
262* )
263        platform_export=""
264        platform_import=""
265        ;;
266esac
267
268AC_DEFINE_UNQUOTED([XERCES_PLATFORM_EXPORT], [$platform_export], [Define as the platform's export attribute])
269AC_DEFINE_UNQUOTED([XERCES_PLATFORM_IMPORT], [$platform_import], [Define as the platform's import attribute])
270
271AS_IF([test ! $ac_cv_cxx_have_bool],
272        AC_DEFINE([XERCES_NO_NATIVE_BOOL], 1, [Define if there is no native bool support in this environment]))
273
274AS_IF([test $ac_cv_cxx_have_lstring],
275        AC_DEFINE([XERCES_LSTRSUPPORT], 1, [Define if there is support for L"widestring"]))
276
277# check if the Windows API is defined as using wchar_t or unsigned short; if it's wchar_t, we need to map XMLCh to be wchar_t
278# (this is safe because on Windows wchar_t is used to store UTF-16 codepoints, while it is not true on Unix)
279AC_MSG_CHECKING([whether the Windows SDK is available and using wchar_t as wide string])
280AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <windows.h>
281                                        wchar_t file[] = L"dummy.file";]],
282                                     [[DeleteFileW(file);]])],
283                    [
284                      xerces_cv_type_xmlch=wchar_t
285                      AC_MSG_RESULT([yes])
286                      AC_DEFINE_UNQUOTED([XERCES_INCLUDE_WCHAR_H], 1, [Define to have Xerces_autoconf_config.hpp include wchar.h])
287                    ],
288                    [
289                      xerces_cv_type_xmlch=$xerces_cv_type_u16bit_int
290                      AC_MSG_RESULT([no])
291                    ]
292                 )
293
294AC_DEFINE_UNQUOTED([XERCES_XMLCH_T], [$xerces_cv_type_xmlch], [Define to the 16 bit type used to represent Xerces UTF-16 characters])
295
296AC_MSG_CHECKING([whether the compiler chokes on a placement operator delete])
297AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <stdlib.h>
298
299                                        class XMemory
300                                        {
301                                        public :
302                                            void* operator new(size_t s) { return 0; }
303                                            void* operator new(size_t s, void* ptr) { return 0; }
304                                            void operator delete(void* p) {}
305                                            void operator delete(void* p, void* ptr) {}
306                                        };]],
307                                     [[ ]])],
308                    [
309                      AC_MSG_RESULT([no])
310                    ],
311                    [
312                      AC_MSG_RESULT([yes])
313                      AC_DEFINE_UNQUOTED([XERCES_NO_MATCHING_DELETE_OPERATOR], 1, [Define to have XMemory.hpp avoid declaring a matching operator delete for the placement operator new])
314                    ]
315                 )
316
317save_CXXFLAGS="$CXXFLAGS"
318CXXFLAGS="$CXXFLAGS -std=gnu++0x"
319AC_MSG_CHECKING([whether $CXX supports ISO C++ 2011 standard])
320AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[]], [[]])],
321                    [AC_MSG_RESULT([yes])],
322                    [AC_MSG_ERROR([C++0x support required])]
323                                 )
324
325if test "$have_sse2" = "yes"; then
326
327    save_CXXFLAGS="$CXXFLAGS"
328    no_sse_CXXFLAGS="$CXXFLAGS"
329    CXXFLAGS="$CXXFLAGS -msse2"
330        AC_MSG_CHECKING([whether we need to add -msse2])
331        AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <emmintrin.h>]], [[__m128i one;]])],
332                                                [msse2_ok=yes],
333                                                [msse2_ok=no]
334                                         )
335    AC_MSG_RESULT($msse2_ok)
336    if test x"$msse2_ok" = xno; then
337        CXXFLAGS="$save_CXXFLAGS"
338    fi
339# Sun CC option test. Currently disabled since it doesn't work. Also note
340# that Sun CC will accept -msse2 (i.e., it won't fail) but will keep issuing
341# warnings. So if enabled this test needs to be moved before -msse2 and if
342# it passes, then -msse2 should be skipped.
343#
344#    save_CXXFLAGS="$CXXFLAGS"
345#    CXXFLAGS="$CXXFLAGS -xarch=sse2"
346#      AC_MSG_CHECKING([whether we need to add -xarch=sse2])
347#      AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <emmintrin.h>]], [[__m128i one;]])],
348#                                               [xarchsse2_ok=yes],
349#                                               [xarchsse2_ok=no]
350#                                        )
351#    AC_MSG_RESULT($xarchsse2_ok)
352#    if test x"$xarchsse2_ok" = xno; then
353#        CXXFLAGS="$save_CXXFLAGS"
354#    fi
355
356    AC_MSG_CHECKING([for intrin.h usability])
357    AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <intrin.h>]],
358                                         [[]])],
359                        [
360                          AC_MSG_RESULT([yes])
361                          AC_DEFINE_UNQUOTED([XERCES_HAVE_INTRIN_H], 1, [Define to 1 if you have intrin.h])
362                        ],
363                        [
364                          AC_MSG_RESULT([no])
365                        ]
366                     )
367    AC_MSG_CHECKING([for emmintrin.h usability])
368    AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <emmintrin.h>]],
369                                         [[]])],
370                        [
371                          AC_MSG_RESULT([yes])
372                          AC_DEFINE_UNQUOTED([XERCES_HAVE_EMMINTRIN_H], 1, [Define to 1 if you have emmintrin.h])
373                        ],
374                        [
375                          AC_MSG_RESULT([no])
376                        ]
377                     )
378    AC_MSG_CHECKING([for cpuid.h usability])
379    AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <cpuid.h>]],
380                                         [[]])],
381                        [
382                          AC_MSG_RESULT([yes])
383                          AC_DEFINE_UNQUOTED([HAVE_CPUID_H], 1, [Define to 1 if you have cpuid.h])
384                        ],
385                        [
386                          AC_MSG_RESULT([no])
387                        ]
388                     )
389
390        AC_MSG_CHECKING([whether the compiler has the CPUID intrinsic])
391        AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <intrin.h>]],
392                                                                                 [[int CPUInfo[4];
393                                                                                   __cpuid(CPUInfo, 1);
394                                                                                 ]])],
395                                                [
396                                                  AC_MSG_RESULT([yes])
397                                                  AC_DEFINE_UNQUOTED([XERCES_HAVE_CPUID_INTRINSIC], 1, [Define to have SSE2 instruction support detected at runtime using __cpuid])
398                                                ],
399                                                [
400                                                  AC_MSG_RESULT([no])
401                                                ]
402                                         )
403
404        AC_MSG_CHECKING([whether the compiler has the _get_cpuid intrinsic])
405        AC_COMPILE_IFELSE(  [AC_LANG_PROGRAM([[#include <cpuid.h>]],
406                                                                                 [[unsigned int eax, ebx, ecx, edx;
407                                           __get_cpuid (1, &eax, &ebx, &ecx, &edx);
408                                                                                 ]])],
409                                                [
410                                                  AC_MSG_RESULT([yes])
411                                                  AC_DEFINE_UNQUOTED([XERCES_HAVE_GETCPUID], 1, [Define to have SSE2 instruction support detected at runtime using __get_cpuid])
412                                                ],
413                                                [
414                                                  AC_MSG_RESULT([no])
415                                                ]
416                                         )
417
418        AC_MSG_CHECKING([whether the compiler has the SSE2 intrinsic])
419        AC_RUN_IFELSE(  [AC_LANG_PROGRAM([[#include <emmintrin.h>]],
420                                                                                 [[__m128i* one=(__m128i*)_mm_malloc(4, 16);
421                                                                                   __m128i* two=(__m128i*)_mm_malloc(4, 16);
422                                                                                   __m128i xmm1 = _mm_load_si128(one);
423                                                                                   __m128i xmm2 = _mm_load_si128(two);
424                                                                                   __m128i xmm3 = _mm_or_si128(xmm1, xmm2);
425                                                                                   _mm_store_si128(one, xmm3);
426                                                                                   _mm_free(one);
427                                                                                   _mm_free(two);
428                                                                                 ]])],
429                                                [
430                                                  AC_MSG_RESULT([yes])
431                                                  sse2_usable=yes
432                                                  AC_DEFINE_UNQUOTED([XERCES_HAVE_SSE2_INTRINSIC], 1, [Define to have SSE2 instruction used at runtime])
433                          save_CXXFLAGS="$CXXFLAGS"
434                                                ],
435                                                [
436                                                  AC_MSG_RESULT([no])
437                                                  sse2_usable=no
438                                                ],
439                                                [
440                                                  sse2_usable=yes
441                                                  AC_DEFINE_UNQUOTED([XERCES_HAVE_SSE2_INTRINSIC], 1, [Define to have SSE2 instruction used at runtime])
442                          save_CXXFLAGS="$CXXFLAGS"
443                                                ]
444                                         )
445   
446    CXXFLAGS="$no_sse_CXXFLAGS -mavx -DUSE_SSE4_2"
447
448        AC_MSG_CHECKING([whether the compiler supports non-destructive SSE form])
449        AC_RUN_IFELSE(  [AC_LANG_PROGRAM([[#include <immintrin.h>]],
450                                                                                 [[    __m256* one=(__m256*)_mm_malloc(4, 32);
451                                               __m256* two=(__m256*)_mm_malloc(4, 32);
452                                               __m256 xmm1 = _mm256_load_ps((float*)one);
453                                               __m256 xmm2 = _mm256_load_ps((float*)two);
454                                               __m256 xmm3 = _mm256_or_ps(xmm1, xmm2);
455                                               _mm256_store_ps((float*)one, xmm3);
456                                               _mm_free(one);
457                                               _mm_free(two);
458                                                                                 ]])],
459                                                [
460                                                  AC_MSG_RESULT([yes])
461                          save_CXXFLAGS="$CXXFLAGS"                                               
462                                                ],
463                                                [
464                                                  AC_MSG_RESULT([no])
465                          CXXFLAGS="$save_CXXFLAGS"
466                                                ],
467                                                [
468                                                  AC_MSG_RESULT([unknown])
469                          CXXFLAGS="$save_CXXFLAGS"
470                                                ]
471                                         )
472
473    CXXFLAGS="$no_sse_CXXFLAGS -mavx2 -mbmi2 -fabi-version=6 -DUSE_AVX2"
474
475        AC_MSG_CHECKING([whether the compiler supports AVX2 intrinsics])
476        AC_RUN_IFELSE(  [AC_LANG_PROGRAM([[#include <immintrin.h>]],
477                                                                                 [[    __m256i* one=(__m256i*)_mm_malloc(4, 32);
478                                               __m256i* two=(__m256i*)_mm_malloc(4, 32);
479                                               __m256i xmm1 = _mm256_load_si256(one);
480                                               __m256i xmm2 = _mm256_load_si256(two);
481                                               __m256i xmm3 = _mm256_or_si256(xmm1, xmm2);
482                                               _mm256_store_si256(one, xmm3);
483                                               _mm_free(one);
484                                               _mm_free(two);
485                                                                                 ]])],
486                                                [
487                                                  AC_MSG_RESULT([yes])                                           
488                                                ],
489                                                [
490                                                  AC_MSG_RESULT([no])
491                          CXXFLAGS="$save_CXXFLAGS"
492                                                ],
493                                                [
494                                                  AC_MSG_RESULT([unknown])
495                          CXXFLAGS="$save_CXXFLAGS"
496                                                ]
497                                         )
498fi
499
500# Raise a compile error if SSE2 is not usable.
501#
502if test "$sse2_usable" = "no"; then
503    AC_MSG_ERROR([SSE2 support required])
504fi
505
506AS_IF([test x$ac_cv_type_size_t = xyes],
507        AC_DEFINE([XERCES_SIZE_T], [size_t], [Define as the appropriate size_t type]),
508        AC_DEFINE([XERCES_SIZE_T], [long], [Define as the appropriate size_t type]))
509
510AS_IF([test x$ac_cv_type_ssize_t = xyes],
511        AC_DEFINE([XERCES_SSIZE_T], [ssize_t], [Define as the appropriate ssize_t type]),
512        AC_DEFINE([XERCES_SSIZE_T], [unsigned long], [Define as the appropriate ssize_t type]))
513
514AS_IF([test x$ac_cv_cxx_have_namespaces = xyes],
515        AC_DEFINE([XERCES_HAS_CPP_NAMESPACE], 1, [Define if namespaces is supported by the compiler]))
516
517AS_IF([test x$ac_cv_cxx_have_std_namespace = xyes],
518        AC_DEFINE([XERCES_STD_NAMESPACE], 1, [Define if the std namespace is supported]))
519
520AS_IF([test x$ac_cv_cxx_have_std_libs = xyes],
521        AC_DEFINE([XERCES_NEW_IOSTREAMS], 1, [Define if the isstream library can be included as <iostream>]))
522
523
524AC_OUTPUT
525
526AC_MSG_NOTICE
527AC_MSG_NOTICE([Report:])
528AC_MSG_NOTICE([  File Manager: $filemgr])
529AC_MSG_NOTICE([  Mutex Manager: $mutexmgr])
530AC_MSG_NOTICE([  Transcoder: $transcoder])
531AC_MSG_NOTICE([  NetAccessor: $netaccessor])
532AC_MSG_NOTICE([  Message Loader: $msgloader])
Note: See TracBrowser for help on using the repository browser.