The Tor Browser / file comparison

comparison: intl/icu/source/configure.ac

intl/icu/source/configure.ac

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:5c0412586e8a
1 # -*-autoconf-*-
2 AC_COPYRIGHT([ Copyright (c) 1999-2013, International Business Machines Corporation and others. All Rights Reserved. ])
3 # configure.in for ICU
4 # Stephen F. Booth, heavily modified by Yves and others
5
6 # Check for autoconf version
7 AC_PREREQ(2.68)
8
9 # Process this file with autoconf to produce a configure script
10 AC_INIT([ICU])
11
12 #TODO: IcuBug:8502
13 #AC_INIT([ICU],
14 # m4_esyscmd_s([sed -n 's/^[ ]*#[ ]*define[ ]*U_ICU_VERSION[ ]*"\([^"]*\)".*/\1/p' "./common/unicode/uvernum.h]"),
15 # [http://icu-project.org/bugs],
16 # [International Components for Unicode],
17 # [http://icu-project.org])
18
19 AC_CONFIG_SRCDIR([common/unicode/utypes.h])
20
21 PACKAGE="icu"
22 AC_SUBST(PACKAGE)
23
24 # Use custom echo test for newline option
25 # Current autoconf (2.65) gives incorrect echo newline option
26 # for icu-config
27 # This may be removed later - mow (June 17, 2010)
28 ICU_ECHO_C= ICU_ECHO_N= ICU_ECHO_T=
29 case `/bin/sh -c "echo -n x"` in
30 -n*)
31 case `/bin/sh -c "echo 'x\c'"` in
32 *c*) ICU_ECHO_T=' ';; # ECHO_T is single tab character.
33 *) ICU_ECHO_C='\c';;
34 esac;;
35 *)
36 ICU_ECHO_N='-n';;
37 esac
38 AC_SUBST(ICU_ECHO_N)
39 AC_SUBST(ICU_ECHO_C)
40 AC_SUBST(ICU_ECHO_T)
41
42 AC_MSG_CHECKING(for ICU version numbers)
43
44 # Get the ICU version from uversion.h or other headers
45 geticuversion() {
46 [sed -n 's/^[ ]*#[ ]*define[ ]*U_ICU_VERSION[ ]*"\([^"]*\)".*/\1/p' "$@"]
47 }
48 getuversion() {
49 [sed -n 's/^[ ]*#[ ]*define[ ]*U_UNICODE_VERSION[ ]*"\([^"]*\)".*/\1/p' "$@"]
50 }
51 VERSION=`geticuversion $srcdir/common/unicode/uvernum.h`
52 if test x"$VERSION" = x; then
53 as_fn_error $? "Cannot determine ICU version number from uvernum.h header file" "$LINENO" 5
54 fi
55
56 #TODO: IcuBug:8502
57 #if test "$VERSION" != "$PACKAGE_VERSION"; then
58 # AC_MSG_ERROR([configure was generated for $PACKAGE_VERSION but uvernum.h has $VERSION - please rerun autoconf])
59 #fi
60
61 UNICODE_VERSION=`getuversion $srcdir/common/unicode/uchar.h`
62 if test x"$UNICODE_VERSION" = x; then
63 AC_MSG_ERROR([Cannot determine Unicode version number from uchar.h header file])
64 fi
65 # Compute a reasonable library version from the release version. This is
66 # very bad, but that's wanted... We want to make sure that the LIB_VERSION
67 # has at least a dot in it, so we'll add a .0 if needed.
68 #[LIB_VERSION=`echo $VERSION | sed -e 's/\.//' -e 's/^\([^.]*\)$/\1.0/'`]
69 LIB_VERSION=$VERSION
70 LIB_VERSION_MAJOR=`echo $LIB_VERSION | sed 's/\..*//'`
71 AC_SUBST(VERSION)
72 AC_SUBST(LIB_VERSION)
73 AC_SUBST(LIB_VERSION_MAJOR)
74 AC_MSG_RESULT([release $VERSION, library $LIB_VERSION, unicode version $UNICODE_VERSION])
75
76 AC_SUBST(UNICODE_VERSION)
77
78 # Determine the host system
79 AC_CANONICAL_HOST
80
81 AC_SUBST(CPPFLAGS)
82
83 # This variable is needed on z/OS because the C++ compiler only recognizes .C
84 _CXX_CXXSUFFIX=cpp
85 export _CXX_CXXSUFFIX
86
87 # Accumulate #defines
88
89 # CONFIG_CPPFLAGS: These are defines that are set for ICU Build time only.
90 # They are only needed for building ICU itself. Example: platform stuff
91 CONFIG_CPPFLAGS=""
92 # UCONFIG_CPPFLAGS: These are defines which are set for ICU build time,
93 # and also a notice is output that they need to be set
94 # for end-users of ICU also. uconfig.h.prepend is generated
95 # with, for example, "#define U_DISABLE_RENAMING 1"
96 # Example: ICU configuration stuff
97 UCONFIG_CPPFLAGS=""
98 # UCONFIG_CFLAGS: contains a copy of anything that needs to be set by end users
99 # such as -std
100 UCONFIG_CFLAGS=""
101
102 # Check whether to build debug libraries
103 AC_MSG_CHECKING([whether to build debug libraries])
104 enabled=no
105 ENABLE_DEBUG=0
106 AC_ARG_ENABLE(debug,
107 [ --enable-debug build debug libraries and enable the U_DEBUG define [default=no]],
108 [ case "${enableval}" in
109 yes|"") enabled=yes; ENABLE_DEBUG=1; CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_DEBUG=1" ;;
110 *) ;;
111 esac],
112 )
113 AC_MSG_RESULT($enabled)
114 AC_SUBST(ENABLE_DEBUG)
115
116 # Check whether to build release libraries
117 AC_MSG_CHECKING([whether to build release libraries])
118 enabled=yes
119 ENABLE_RELEASE=1
120 AC_ARG_ENABLE(release,
121 [ --enable-release build release libraries [default=yes]],
122 [ case "${enableval}" in
123 no) enabled=no; ENABLE_RELEASE=0 ;;
124 *) ;;
125 esac],
126 )
127 AC_MSG_RESULT($enabled)
128 AC_SUBST(ENABLE_RELEASE)
129
130 # Don't use the default C/CXXFLags
131 : ${CFLAGS=""}
132 : ${CXXFLAGS=""}
133
134 # Checks for compilers
135 AC_PROG_CC([clang gcc cc c99 c89 xlc_r xlc cl.exe icc])
136 # Make sure that we try clang++ first, which provides C++11 support.
137 # The g++ compiler is less likely to support C++11.
138 AC_PROG_CXX([clang++ g++ c++ gpp xlC_r xlC aCC CC cxx cc++ cl.exe icc FCC KCC RCC])
139
140 # Ensure that if CXXFLAGS/CFLAGS were not set when calling configure, set it correctly based on (enable/disable) debug or release option
141 # The release mode use is the default one for autoconf
142 if test "$GCC" = yes; then
143 if test "$CFLAGS" = ""; then
144 if test "$ENABLE_DEBUG" = 1; then
145 CFLAGS=-g
146 fi
147 if test "$ENABLE_RELEASE" = 1; then
148 CFLAGS="$CFLAGS -O2"
149 fi
150 fi
151 if test "$CXXFLAGS" = ""; then
152 if test "$ENABLE_DEBUG" = 1; then
153 CXXFLAGS=-g
154 fi
155 if test "$ENABLE_RELEASE" = 1; then
156 CXXFLAGS="$CXXFLAGS -O2"
157 fi
158 fi
159 fi
160
161 AC_PROG_CPP
162
163 AC_PROG_INSTALL
164
165 AC_SUBST(cross_compiling)
166
167 dnl use the pld hack to get ac_fn_cxx_try_link defined globally and not local
168 AC_LANG_PUSH([C++])
169 AC_LINK_IFELSE([AC_LANG_PROGRAM()])
170 AC_LANG_POP([C++])
171
172 # make sure install is relative to srcdir - if a script
173 if test "$srcdir" = "."; then
174 # If srcdir isn't just ., then (srcdir) is already prepended.
175 if test "${ac_install_sh}" = "${INSTALL}"; then
176 INSTALL="\\\$(top_srcdir)/${ac_install_sh}"
177 fi
178 fi
179
180 #AC_CHECK_PROG(AUTOCONF, autoconf, autoconf, true)
181 #AC_CHECK_PROG(STRIP, strip, strip, true)
182
183 # Check for the platform make
184 AC_PATH_PROGS(U_MAKE, gmake gnumake, make)
185 AC_SUBST(U_MAKE)
186
187
188 AC_ARG_WITH(cross-build,
189 [ --with-cross-build=dir specify an absolute path to the build directory of an ICU built for the current platform [default=no cross dir]],
190 [cross_buildroot="${withval}"],
191 [cross_buildroot=""])
192
193 if test "X$cross_buildroot" = "X"; then
194 if test "$cross_compiling" = "yes"; then
195 AC_MSG_ERROR([Error! Cross compiling but no --with-cross-build option specified - please supply the path to an executable ICU's build root])
196 dnl '
197 fi
198 else
199 if test -f "${cross_buildroot}/config/icucross.mk"; then
200 AC_MSG_RESULT([Using cross buildroot: $cross_buildroot])
201 else
202 if test -d "${cross_buildroot}"; then
203 AC_MSG_ERROR([${cross_buildroot}/config/icucross.mk not found. Please build ICU in ${cross_buildroot} first.])
204 else
205 AC_MSG_ERROR([No such directory ${cross_buildroot} supplied as the argument to --with-cross-build. Use an absolute path.])
206 fi
207 fi
208 fi
209 AC_SUBST(cross_buildroot)
210
211 # Check for doxygen to generate documentation
212 AC_PATH_PROG(DOXYGEN,doxygen,,$PATH:/usr/local/bin:/usr/bin)
213
214 # Check that the linker is usable
215 ICU_PROG_LINK
216
217 # Determine the executable suffix
218 # We don't use AC_EXEEXT because some compilers output separate debugging
219 # files, which confuses the AC_EXEEXT macro.
220 AC_MSG_CHECKING(checking for executable suffix)
221 case "${host}" in
222 *-*-cygwin*|*-*-mingw*) EXEEXT=.exe ;;
223 *) EXEEXT="" ;;
224 esac
225 ac_exeext=$EXEEXT
226 AC_MSG_RESULT($EXEEXT)
227 AC_SUBST(EXEEXT)
228
229 # Determine how strict we want to be when compiling
230 AC_CHECK_STRICT_COMPILE
231
232 # Check if we can build and use 64-bit libraries
233 AC_CHECK_64BIT_LIBS
234 AC_SUBST(ARFLAGS)
235 AC_SUBST(COMPILE_LINK_ENVVAR)
236
237 # Determine the Makefile fragment
238 ICU_CHECK_MH_FRAG
239
240 # Checks for libraries and other host specific stuff
241 # On HP/UX, don't link to -lm from a shared lib because it isn't
242 # PIC (at least on 10.2)
243 case "${host}" in
244 *-*-hpux*) AC_CHECK_LIB(m, floor, LIB_M="-lm") ;;
245
246 *) AC_CHECK_LIB(m, floor)
247 LIB_M="" ;;
248 esac
249 AC_SUBST(LIB_M)
250
251 # Check whether to build shared libraries
252 AC_MSG_CHECKING([whether to build shared libraries])
253 enabled=no
254 AC_ARG_ENABLE(shared,
255 [ --enable-shared build shared libraries [default=yes]],
256 [ case "${enableval}" in
257 yes|"") enabled=yes; ENABLE_SHARED=YES ;;
258 no);;
259 *) ;;
260 esac],
261 [enabled=yes; ENABLE_SHARED=YES]
262 )
263 AC_MSG_RESULT($enabled)
264 AC_SUBST(ENABLE_SHARED)
265
266 # Check whether to build static libraries
267 AC_MSG_CHECKING([whether to build static libraries])
268 enabled=no
269 AC_ARG_ENABLE(static,
270 [ --enable-static build static libraries [default=no]],
271 [ case "${enableval}" in
272 yes|"") enabled=yes; ENABLE_STATIC=YES ;;
273 no) ;;
274 *) ;;
275 esac],
276 )
277 AC_MSG_RESULT($enabled)
278 AC_SUBST(ENABLE_STATIC)
279
280 # When building release static library, there might be some optimization flags we can use
281 if test "$ENABLE_STATIC" = "YES"; then
282 if test "$ENABLE_SHARED" != "YES"; then
283 if test "$ENABLE_RELEASE" = 1; then
284 AC_MSG_CHECKING([whether we can use static library optimization option])
285 CHECK_STATIC_OPT_FLAG=no
286
287 OLD_CPPFLAGS="${CPPFLAGS}"
288 OLD_LDFLAGS="${LDFLAGS}"
289
290 case "${host}" in
291 *-linux*|i*86-*-*bsd*|i*86-pc-gnu)
292 if test "$GCC" = yes; then
293 CPPFLAGS="${CPPFLAGS} -ffunction-sections -fdata-sections"
294 LDFLAGS="${LDFLAGS} -Wl,--gc-sections"
295 fi
296 ;;
297 *)
298 ;;
299 esac
300
301 AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [CHECK_STATIC_OPT_FLAG=yes], [CHECK_STATIC_OPT_FLAG=no])
302 AC_MSG_RESULT($CHECK_STATIC_OPT_FLAG)
303 if test "$CHECK_STATIC_OPT_FLAG" = no; then
304 CPPFLAGS="${OLD_CPPFLAGS}"
305 LDFLAGS="${OLD_LDFLAGS}"
306 fi
307 fi
308 fi
309 fi
310
311
312 # Check whether to enable auto cleanup of libraries
313 AC_MSG_CHECKING([whether to enable auto cleanup of libraries])
314 enabled=no
315 UCLN_NO_AUTO_CLEANUP=1
316 AC_ARG_ENABLE(auto-cleanup,
317 [ --enable-auto-cleanup enable auto cleanup of libraries [default=no]],
318 [ case "${enableval}" in
319 yes) enabled=yes;
320 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DUCLN_NO_AUTO_CLEANUP=0";
321 UCLN_NO_AUTO_CLEANUP=0
322 ;;
323 *) ;;
324 esac],
325 )
326 AC_MSG_RESULT($enabled)
327 AC_SUBST(UCLN_NO_AUTO_CLEANUP)
328
329 # MSVC floating-point option
330 MSVC_RELEASE_FLAG=""
331 if test $enabled = yes
332 then
333 if test $icu_cv_host_frag = mh-cygwin-msvc -o $icu_cv_host_frag = mh-msys-msvc
334 then
335 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
336 #if defined _MSC_VER && _MSC_VER >= 1400
337 #else
338 Microsoft Visual C++ < 2005
339 #endif
340 ]], [[]])],[MSVC_RELEASE_FLAG="/fp:precise"],[MSVC_RELEASE_FLAG="/Op"])
341
342 CFLAGS="${CFLAGS} ${MSVC_RELEASE_FLAG}"
343 CXXFLAGS="${CXXFLAGS} ${MSVC_RELEASE_FLAG}"
344 fi
345 fi
346
347 # Check whether to enabled draft APIs
348 AC_MSG_CHECKING([whether to enable draft APIs])
349 enabled=yes
350 U_DEFAULT_SHOW_DRAFT=1
351 AC_ARG_ENABLE(draft,
352 [ --enable-draft enable draft APIs (and internal APIs) [default=yes]],
353 [ case "${enableval}" in
354 no) enabled=no; U_DEFAULT_SHOW_DRAFT=0;
355 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_DEFAULT_SHOW_DRAFT=0"
356 ;;
357 *) ;;
358 esac],
359 )
360 AC_MSG_RESULT($enabled)
361 # Make sure that we can use draft API in ICU.
362 if test "$U_DEFAULT_SHOW_DRAFT" = 0; then
363 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_SHOW_DRAFT_API"
364 fi
365 AC_SUBST(U_DEFAULT_SHOW_DRAFT)
366
367 AC_PROG_RANLIB
368
369 # look for 'ar' the proper way
370 AC_CHECK_TOOL(AR, ar, false)
371
372 AC_MSG_CHECKING([whether to enable renaming of symbols])
373 enabled=yes
374 U_DISABLE_RENAMING=0
375 AC_ARG_ENABLE(renaming,
376 [ --enable-renaming add a version suffix to symbols [default=yes]],
377 [ case "${enableval}" in
378 yes|"") enabled=yes ;;
379 no) enabled=no; U_DISABLE_RENAMING=1;
380 UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_DISABLE_RENAMING=1"
381 ;;
382 *) ;;
383 esac],
384 )
385 AC_MSG_RESULT($enabled)
386 AC_SUBST(U_DISABLE_RENAMING)
387
388 AC_MSG_CHECKING([whether to enable function and data tracing])
389 enabled=no
390 U_ENABLE_TRACING=0
391 AC_ARG_ENABLE(tracing,
392 [ --enable-tracing enable function and data tracing [default=no]],
393 [ case "${enableval}" in
394 yes|"") enabled=yes;
395 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_ENABLE_TRACING=1";
396 U_ENABLE_TRACING=1 ;;
397 no) enabled=no; U_ENABLE_TRACING=0 ;;
398 *) ;;
399 esac],
400 )
401 AC_MSG_RESULT($enabled)
402 AC_SUBST(U_ENABLE_TRACING)
403
404 # check if elf.h is present.
405 AC_CHECK_HEADERS([elf.h])
406 if test "x$ac_cv_header_elf_h" = "xyes"; then
407 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_HAVE_ELF_H=1";
408 fi
409
410 U_ENABLE_DYLOAD=1
411 enable=yes
412 AC_MSG_CHECKING([whether to enable dynamic loading of plugins])
413 AC_ARG_ENABLE(dyload,
414 [ --disable-dyload disable dynamic loading [default=no]],
415 [ case "${enableval}" in
416 yes|"")
417 U_ENABLE_DYLOAD=1
418 enable=yes
419 ;;
420 no)
421 U_ENABLE_DYLOAD=0;
422 enable=no;
423 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DU_ENABLE_DYLOAD=0";
424 ;;
425 *) ;;
426 esac],
427 )
428 AC_MSG_RESULT($enable)
429 AC_SUBST(U_ENABLE_DYLOAD)
430
431 if test "$enable" = "yes"; then
432 AC_CHECK_HEADERS([dlfcn.h])
433 #AC_MSG_RESULT($enabled)
434 AC_SEARCH_LIBS([dlopen], [dl])
435 AC_CHECK_FUNCS([dlopen])
436
437 if test "x$ac_cv_func_dlopen" != xyes; then
438 CONFIG_CPPFLAGS="$CONFIG_CPPFLAGS -DHAVE_DLOPEN=0"
439 fi
440 fi
441
442 # Check for miscellanous functions.
443 # So, use for putil / tools only.
444 # Note that this will generate HAVE_GETTIMEOFDAY, not U_HAVE_GETTIMEOFDAY
445 AC_CHECK_FUNCS([gettimeofday])
446
447
448 # Check whether to use the evil rpath or not
449 AC_ARG_ENABLE(rpath,
450 [ --enable-rpath use rpath when linking [default is only if necessary]],
451 [ case "${enableval}" in
452 yes|"") ENABLE_RPATH=YES ;;
453 no) ;;
454 *) ;;
455 esac],
456 [ENABLE_RPATH=NO]
457 )
458 AC_SUBST(ENABLE_RPATH)
459
460
461
462 AC_LANG_PUSH([C++])
463 AC_MSG_CHECKING([[if we have a C++ compiler]])
464 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx_okay=yes],[cxx_okay=no])
465 if test $cxx_okay = yes
466 then
467 AC_MSG_RESULT([[Good]])
468 else
469 AC_MSG_RESULT([[no]])
470 AC_MSG_ERROR([[C++ compiler $CXX does not work or no compiler found]])
471 fi
472
473 if [[ "$GXX" = yes ]]; then
474 # if CXXFLAGS does not have a "-std=" setting, set it now to -std=c++0x,
475 # and check that the compiler still works.
476 if ! echo "$CXXFLAGS" | grep '\-std=' >/dev/null 2>&1; then
477 OLD_CXXFLAGS="${CXXFLAGS}"
478 CXXFLAGS="$CXXFLAGS --std=c++0x"
479 AC_MSG_CHECKING([[if we have a C++11 compiler]])
480 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[cxx11_okay=yes],[cxx11_okay=no])
481 AC_MSG_RESULT($cxx11_okay)
482 if [[ $cxx11_okay = yes ]]; then
483 AC_MSG_NOTICE([Adding CXXFLAGS option --std=c++0x])
484 UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} --std=c++0x"
485 else
486 CXXFLAGS="$OLD_CXXFLAGS"
487 fi
488 fi
489 fi
490
491 AC_MSG_CHECKING([[if #include <string> works]])
492 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <string>]], [[]])], [ac_cv_header_stdstring=yes], [ac_cv_header_stdstring=no])
493 AC_MSG_RESULT($ac_cv_header_stdstring)
494 if test $ac_cv_header_stdstring = yes
495 then
496 U_HAVE_STD_STRING=1
497 else
498 U_HAVE_STD_STRING=0
499 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_STD_STRING=0"
500 fi
501 AC_SUBST(U_HAVE_STD_STRING)
502
503
504 AC_MSG_CHECKING([[if #include <atomic> works]])
505 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <atomic>]], [[]])], [ac_cv_header_atomic=yes], [ac_cv_header_atomic=no])
506 AC_MSG_RESULT($ac_cv_header_atomic)
507 if test $ac_cv_header_atomic = yes
508 then
509 U_HAVE_ATOMIC=1
510 else
511 U_HAVE_ATOMIC=0
512 fi
513 # Make this available via CPPFLAGS
514 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_ATOMIC=${U_HAVE_ATOMIC}"
515 AC_SUBST(U_HAVE_ATOMIC)
516
517 AC_LANG_POP([C++])
518
519 # Always build ICU with multi-threading support.
520 threads=true
521 ICU_USE_THREADS=1
522 OLD_LIBS=${LIBS}
523
524 if test $threads = true; then
525 # For Compaq Tru64 (OSF1), we must look for pthread_attr_init
526 # and must do this before seaching for pthread_mutex_destroy, or
527 # we will pick up libpthreads.so not libpthread.so
528 # If this fails, then we must test for HPUX specials, before
529 # moving on to a more generic test
530
531 AC_CHECK_LIB(pthread, pthread_attr_init)
532 if test $ac_cv_lib_pthread_pthread_attr_init = yes; then
533 ICU_USE_THREADS=1
534 else
535 # Locate the right library for POSIX threads. We look for the
536 # symbols in the libraries first, because on Solaris libc provides
537 # pthread_create but libpthread has the real code :(
538 # AIX uses libpthreads instead of libpthread, and HP/UX uses libpthread
539 # FreeBSD users may need libpthread if they do not have libc_r.
540
541 AC_SEARCH_LIBS_FIRST(pthread_mutex_destroy, pthread pthreads c_r )
542
543 if test "$ac_cv_search_pthread_mutex_destroy" != no; then
544 ICU_USE_THREADS=1
545 else
546 # For HP 11
547 AC_CHECK_LIB(pthread, pthread_mutex_init)
548 if test $ac_cv_lib_pthread_pthread_mutex_init = yes; then
549 ICU_USE_THREADS=1
550 fi
551 fi
552
553 AC_CHECK_FUNC(pthread_mutex_lock)
554
555 if test $ac_cv_func_pthread_mutex_lock = yes; then
556 ICU_USE_THREADS=1
557 fi
558 fi
559 # Check to see if we are using CygWin with MSVC
560 case "${host}" in
561 *-pc-cygwin*|*-pc-mingw*)
562 # For gcc, the thread options are set by mh-mingw/mh-cygwin
563 # For msvc, the thread options are set by runConfigureICU
564 ICU_USE_THREADS=1
565 ;;
566 *-*-hpux*)
567 # Add -mt because it does several nice things on newer compilers.
568 case "${icu_cv_host_frag}" in
569 mh-hpux-acc)
570 OLD_CXXFLAGS="${CXXFLAGS}"
571 CXXFLAGS="${CXXFLAGS} -mt"
572 if test x"`${CXX} ${CXXFLAGS} 2>&1`" != x""; then
573 CXXFLAGS="${OLD_CXXFLAGS}"
574 else
575 UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -mt"
576 fi
577 ;;
578 esac
579 ;;
580 *-*-solaris*)
581 case "${icu_cv_host_frag}" in
582 mh-solaris)
583 LIBS="${LIBS} -mt"
584 ;;
585 esac
586 ;;
587 esac
588 fi
589
590 AC_ARG_ENABLE(weak-threads,
591 [ --enable-weak-threads weakly reference the threading library [default=no]],
592 [case "${enableval}" in
593 yes)
594 LIB_THREAD="${LIBS%${OLD_LIBS}}"
595 LIBS=${OLD_LIBS}
596 ;;
597 no) ;;
598 *) AC_MSG_ERROR(bad value ${enableval} for --enable-weak-threads) ;;
599 esac])
600 AC_SUBST(LIB_THREAD)
601
602 # Check for mmap()
603
604 # The AC_FUNC_MMAP macro doesn't work properly. It seems to be too specific.
605 # Do this check instead.
606 HAVE_MMAP=0
607 AC_MSG_CHECKING([for mmap])
608 AC_CACHE_VAL(ac_cv_func_mmap_ok,
609 [AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <unistd.h>
610 #include <sys/mman.h>
611 #include <sys/stat.h>
612 #include <fcntl.h>], [mmap((void *)0, 0, PROT_READ, 0, 0, 0);])],[ac_cv_func_mmap_ok=yes],[ac_cv_func_mmap_ok=no])] )
613 AC_MSG_RESULT($ac_cv_func_mmap_ok)
614 if test $ac_cv_func_mmap_ok = yes
615 then
616 HAVE_MMAP=1
617 else
618 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_MMAP=0"
619 fi
620 AC_SUBST(HAVE_MMAP)
621
622 AC_MSG_CHECKING([for genccode assembly])
623
624 # Check to see if genccode can generate simple assembly.
625 GENCCODE_ASSEMBLY=
626 case "${host}" in
627 *-linux*|*-kfreebsd*-gnu*|i*86-*-*bsd*|i*86-pc-gnu)
628 if test "$GCC" = yes; then
629 # We're using gcc, and the simple -a gcc command line works for genccode
630 GENCCODE_ASSEMBLY="-a gcc"
631 fi ;;
632 i*86-*-solaris*)
633 if test "$GCC" = yes; then
634 # When using gcc, look if we're also using GNU as.
635 # When using GNU as, the simple -a gcc command line works for genccode.
636 asv=`"${CC}" -print-prog-name=as 2>/dev/null`
637 asv=`"${asv}" --version 2>/dev/null`
638 case "X${asv}" in
639 X*GNU*) GENCCODE_ASSEMBLY="-a gcc" ;;
640 X*) GENCCODE_ASSEMBLY="-a sun-x86" ;;
641 esac
642 unset asv
643 else
644 GENCCODE_ASSEMBLY="-a sun-x86"
645 fi ;;
646 sparc-*-solaris*)
647 GENCCODE_ASSEMBLY="-a sun"
648 ;;
649 ia64-*-hpux*)
650 GENCCODE_ASSEMBLY="-a aCC-ia64"
651 ;;
652 esac
653 AC_SUBST(GENCCODE_ASSEMBLY)
654
655 AC_MSG_RESULT($GENCCODE_ASSEMBLY)
656
657 # Checks for header files
658 AC_CHECK_HEADERS(inttypes.h)
659 if test $ac_cv_header_inttypes_h = no; then
660 U_HAVE_INTTYPES_H=0
661 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INTTYPES_H=0"
662 else
663 U_HAVE_INTTYPES_H=1
664 fi
665 if test "$CC" = ccc; then
666 AC_MSG_RESULT("C compiler set to CCC ${CC}" )
667 case "${host}" in
668 alpha*-*-*) U_HAVE_INTTYPES_H=0;
669 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INTTYPES_H=0"
670 esac
671 fi
672
673 AC_SUBST(U_HAVE_INTTYPES_H)
674
675 AC_CHECK_HEADERS(dirent.h)
676 if test $ac_cv_header_dirent_h = no; then
677 U_HAVE_DIRENT_H=0
678 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_DIRENT_H=0"
679 else
680 U_HAVE_DIRENT_H=1
681 fi
682
683 AC_SUBST(U_HAVE_DIRENT_H)
684
685 # Check for endianness
686 AC_C_BIGENDIAN()
687 if test $ac_cv_c_bigendian = no; then
688 U_IS_BIG_ENDIAN=0
689 U_ENDIAN_CHAR="l"
690 else
691 U_IS_BIG_ENDIAN=1
692 U_ENDIAN_CHAR="b"
693 fi
694 AC_SUBST(U_IS_BIG_ENDIAN)
695
696 # Do various POSIX related checks
697 U_HAVE_NL_LANGINFO_CODESET=0
698 U_NL_LANGINFO_CODESET=-1
699 AC_CHECK_FUNC(nl_langinfo,[U_HAVE_NL_LANGINFO=1],[U_HAVE_NL_LANGINFO=0])
700 dnl AC_SUBST(U_HAVE_NL_LANGINFO)
701 if test $U_HAVE_NL_LANGINFO -eq 1; then
702 AC_CACHE_CHECK([for nl_langinfo's argument to obtain the codeset],
703 ac_cv_nl_langinfo_codeset,
704 [ac_cv_nl_langinfo_codeset="unknown"
705 for a in CODESET _NL_CTYPE_CODESET_NAME; do
706 AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <langinfo.h>]], [[nl_langinfo($a);]])],[ac_cv_nl_langinfo_codeset="$a"; break],[])]
707 done)
708 if test x$ac_cv_nl_langinfo_codeset != xunknown
709 then
710 U_HAVE_NL_LANGINFO_CODESET=1
711 U_NL_LANGINFO_CODESET=$ac_cv_nl_langinfo_codeset
712 if test "x${ac_cv_nl_langinfo_codeset}" != "xCODESET"
713 then
714 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DNL_LANGINFO_CODESET=${ac_cv_nl_langinfo_codeset}"
715 fi
716 else
717 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_NL_LANGINFO_CODESET=0"
718 fi
719 fi
720 AC_SUBST(U_HAVE_NL_LANGINFO_CODESET)
721 AC_SUBST(U_NL_LANGINFO_CODESET)
722
723 # Namespace support checks
724 AC_LANG(C++)
725 AC_MSG_CHECKING([for namespace support])
726 AC_CACHE_VAL(ac_cv_namespace_ok,
727 [AC_LINK_IFELSE([AC_LANG_PROGRAM([namespace x_version {void f(){}}
728 namespace x = x_version;
729 using namespace x_version;
730 ], [f();])],[ac_cv_namespace_ok=yes],[ac_cv_namespace_ok=no])] )
731 AC_MSG_RESULT($ac_cv_namespace_ok)
732 if test $ac_cv_namespace_ok = no
733 then
734 AC_MSG_ERROR(Namespace support is required to build ICU.)
735 fi
736
737 AC_MSG_CHECKING([for properly overriding new and delete])
738 U_OVERRIDE_CXX_ALLOCATION=0
739 U_HAVE_PLACEMENT_NEW=0
740 AC_CACHE_VAL(ac_cv_override_cxx_allocation_ok,
741 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
742 class UMemory {
743 public:
744 void *operator new(size_t size) {return malloc(size);}
745 void *operator new[](size_t size) {return malloc(size);}
746 void operator delete(void *p) {free(p);}
747 void operator delete[](void *p) {free(p);}
748 };
749 ]], [])],[ac_cv_override_cxx_allocation_ok=yes],[ac_cv_override_cxx_allocation_ok=no])] )
750 AC_MSG_RESULT($ac_cv_override_cxx_allocation_ok)
751 if test $ac_cv_override_cxx_allocation_ok = yes
752 then
753 U_OVERRIDE_CXX_ALLOCATION=1
754 AC_MSG_CHECKING([for placement new and delete])
755 AC_CACHE_VAL(ac_cv_override_placement_new_ok,
756 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
757 class UMemory {
758 public:
759 void *operator new(size_t size) {return malloc(size);}
760 void *operator new[](size_t size) {return malloc(size);}
761 void operator delete(void *p) {free(p);}
762 void operator delete[](void *p) {free(p);}
763 void * operator new(size_t, void *ptr) { return ptr; }
764 void operator delete(void *, void *) {}
765 };
766 ]], [])],[ac_cv_override_placement_new_ok=yes],[ac_cv_override_placement_new_ok=no])] )
767 AC_MSG_RESULT($ac_cv_override_placement_new_ok)
768 if test $ac_cv_override_placement_new_ok = yes
769 then
770 U_HAVE_PLACEMENT_NEW=1
771 else
772 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_PLACEMENT_NEW=0"
773 fi
774 else
775 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_OVERRIDE_CXX_ALLOCATION=0"
776 fi
777 AC_SUBST(U_OVERRIDE_CXX_ALLOCATION)
778 AC_SUBST(U_HAVE_PLACEMENT_NEW)
779
780 AC_LANG(C)
781 AC_CHECK_FUNC(popen)
782 if test x$ac_cv_func_popen = xyes
783 then
784 U_HAVE_POPEN=1
785 else
786 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_POPEN=0"
787 U_HAVE_POPEN=0
788 fi
789 AC_SUBST(U_HAVE_POPEN)
790
791 AC_CHECK_FUNC(tzset)
792 U_HAVE_TZSET=0
793 if test x$ac_cv_func_tzset = xyes
794 then
795 U_TZSET=tzset
796 U_HAVE_TZSET=1
797 else
798 AC_CHECK_FUNC(_tzset)
799 if test x$ac_cv_func__tzset = xyes
800 then
801 U_TZSET=_tzset
802 U_HAVE_TZSET=1
803 else
804 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TZSET=0"
805 fi
806 fi
807 AC_SUBST(U_HAVE_TZSET)
808 AC_SUBST(U_TZSET)
809
810 U_HAVE_TZNAME=0
811 AC_CACHE_CHECK(for tzname,ac_cv_var_tzname,
812 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#ifndef __USE_POSIX
813 #define __USE_POSIX
814 #endif
815 #include <stdlib.h>
816 #include <time.h>
817 #ifndef tzname /* For SGI. */
818 extern char *tzname[]; /* RS6000 and others reject char **tzname. */
819 #endif]], [atoi(*tzname);])],[ac_cv_var_tzname=yes],[ac_cv_var_tzname=no])])
820 if test $ac_cv_var_tzname = yes; then
821 U_TZNAME=tzname
822 U_HAVE_TZNAME=1
823 else
824 AC_CACHE_CHECK(for _tzname,ac_cv_var__tzname,
825 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
826 #include <time.h>
827 extern char *_tzname[];]], [atoi(*_tzname);])],[ac_cv_var__tzname=yes],[ac_cv_var__tzname=no])])
828 if test $ac_cv_var__tzname = yes; then
829 U_TZNAME=_tzname
830 U_HAVE_TZNAME=1
831 else
832 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TZNAME=0"
833 fi
834 fi
835 AC_SUBST(U_HAVE_TZNAME)
836 AC_SUBST(U_TZNAME)
837
838 AC_CACHE_CHECK(for timezone,ac_cv_var_timezone,
839 [AC_LINK_IFELSE([AC_LANG_PROGRAM([#ifndef __USE_POSIX
840 #define __USE_POSIX
841 #endif
842 #ifndef __USE_XOPEN
843 #define __USE_XOPEN
844 #endif
845 #include <time.h>
846 ], [[timezone = 1;]])],[ac_cv_var_timezone=yes],[ac_cv_var_timezone=no])])
847 U_HAVE_TIMEZONE=0
848 if test $ac_cv_var_timezone = yes; then
849 U_TIMEZONE=timezone
850 U_HAVE_TIMEZONE=1
851 else
852 AC_CACHE_CHECK(for __timezone,ac_cv_var___timezone,
853 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[__timezone = 1;]])],[ac_cv_var___timezone=yes],[ac_cv_var___timezone=no])])
854 if test $ac_cv_var___timezone = yes; then
855 U_TIMEZONE=__timezone
856 U_HAVE_TIMEZONE=1
857 else
858 AC_CACHE_CHECK(for _timezone,ac_cv_var__timezone,
859 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[_timezone = 1;]])],[ac_cv_var__timezone=yes],[ac_cv_var__timezone=no])])
860 if test $ac_cv_var__timezone = yes; then
861 U_TIMEZONE=_timezone
862 U_HAVE_TIMEZONE=1
863 else
864 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_TIMEZONE=0"
865 fi
866 fi
867 fi
868 AC_SUBST(U_HAVE_TIMEZONE)
869 AC_SUBST(U_TIMEZONE)
870
871 # Checks for typedefs
872 AC_CHECK_TYPE(int8_t,signed char)
873 AC_CHECK_TYPE(uint8_t,unsigned char)
874 AC_CHECK_TYPE(int16_t,signed short)
875 AC_CHECK_TYPE(uint16_t,unsigned short)
876 AC_CHECK_TYPE(int32_t,signed long)
877 AC_CHECK_TYPE(uint32_t,unsigned long)
878 AC_CHECK_TYPE(int64_t,signed long long)
879 AC_CHECK_TYPE(uint64_t,unsigned long long)
880
881 if test $ac_cv_type_int8_t = no; then
882 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT8_T=0"
883 fi
884
885 if test $ac_cv_type_uint8_t = no; then
886 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT8_T=0"
887 fi
888
889 if test $ac_cv_type_int16_t = no; then
890 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT16_T=0"
891 fi
892
893 if test $ac_cv_type_uint16_t = no; then
894 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT16_T=0"
895 fi
896
897 if test $ac_cv_type_int32_t = no; then
898 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT32_T=0"
899 fi
900
901 if test $ac_cv_type_uint32_t = no; then
902 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT32_T=0"
903 fi
904
905 if test $ac_cv_type_int64_t = no; then
906 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_INT64_T=0"
907 fi
908
909 if test $ac_cv_type_uint64_t = no; then
910 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_UINT64_T=0"
911 fi
912
913 # Do various wchar_t related checks
914 AC_CHECK_HEADER(wchar.h)
915 if test "$ac_cv_header_wchar_h" = no
916 then
917 U_HAVE_WCHAR_H=0
918 U_HAVE_WCSCPY=0
919 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_WCHAR_H=0 -DU_HAVE_WCSCPY=0"
920 else
921 AC_DEFINE([HAVE_WCHAR_H], [1], [wchar.h was found.])
922 U_HAVE_WCHAR_H=1
923 # Some broken systems have wchar.h but not some of its functions...
924 AC_SEARCH_LIBS(wcscpy, wcs w)
925 if test "$ac_cv_search_wcscpy" != no; then
926 U_HAVE_WCSCPY=1
927 else
928 U_HAVE_WCSCPY=0
929 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_HAVE_WCSCPY=0"
930 fi
931 fi
932 AC_SUBST(U_HAVE_WCHAR_H)
933 AC_SUBST(U_HAVE_WCSCPY)
934
935 AC_CHECK_SIZEOF([wchar_t], 0, [
936 #if STDC_HEADERS
937 #include <stddef.h>
938 #endif
939 #include <stdlib.h>
940 #if HAVE_WCHAR_H
941 #include <string.h>
942 #include <wchar.h>
943 #endif])
944 U_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t
945 # We do this check to verify that everything is okay.
946 if test $U_SIZEOF_WCHAR_T = 0; then
947 if test $U_HAVE_WCHAR_H=1; then
948 AC_MSG_ERROR(There is wchar.h but the size of wchar_t is 0)
949 fi
950 fi
951
952 AC_MSG_CHECKING([for UTF-16 string literal support])
953 U_CHECK_UTF16_STRING=1
954 CHECK_UTF16_STRING_RESULT="unknown"
955
956 case "${host}" in
957 *-*-aix*|powerpc64-*-linux*)
958 if test "$GCC" = no; then
959 OLD_CFLAGS="${CFLAGS}"
960 OLD_CXXFLAGS="${CXXFLAGS}"
961 CFLAGS="${CFLAGS} -qutf"
962 CXXFLAGS="${CXXFLAGS} -qutf"
963 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = u"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
964 if test "$U_CHECK_UTF16_STRING" = 0; then
965 CFLAGS="${OLD_CFLAGS}"
966 CXXFLAGS="${OLD_CXXFLAGS}"
967 else
968 UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -qutf"
969 CHECK_UTF16_STRING_RESULT="-qutf"
970 fi
971 fi
972 ;;
973 *-*-solaris*)
974 if test "$GCC" = no; then
975 OLD_CFLAGS="${CFLAGS}"
976 OLD_CXXFLAGS="${CXXFLAGS}"
977 CFLAGS="${CFLAGS} -xustr=ascii_utf16_ushort"
978 CXXFLAGS="${CXXFLAGS} -xustr=ascii_utf16_ushort"
979 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[const unsigned short hello[] = U"hello";]], [[]])],[U_CHECK_UTF16_STRING=1],[U_CHECK_UTF16_STRING=0])
980 if test "$U_CHECK_UTF16_STRING" = 0; then
981 CFLAGS="${OLD_CFLAGS}"
982 CXXFLAGS="${OLD_CXXFLAGS}"
983 else
984 CHECK_UTF16_STRING_RESULT="-xustr=ascii_utf16_ushort"
985 UCONFIG_CXXFLAGS="${UCONFIG_CXXFLAGS} -xustr=ascii_utf16_ushort"
986 UCONFIG_CFLAGS="${UCONFIG_CFLAGS} -xustr=ascii_utf16_ushort"
987 # Since we can't detect the availability of this UTF-16 syntax at compile time,
988 # we depend on configure telling us that we can use it.
989 # Since we can't ensure ICU users use -xustr=ascii_utf16_ushort,
990 # we only use this macro within ICU.
991 # If an ICU user uses icu-config, this feature will be enabled.
992 CONFIG_CPPFLAGS="${CONFIG_CPPFLAGS} -DU_CHECK_UTF16_STRING=1"
993 U_CHECK_UTF16_STRING=0
994 fi
995 fi
996 ;;
997 *-*-hpux*)
998 if test "$GCC" = no; then
999 # The option will be detected at compile time without additional compiler options.
1000 CHECK_UTF16_STRING_RESULT="available"
1001 fi
1002 ;;
1003 *-*-cygwin)
1004 # wchar_t can be used
1005 CHECK_UTF16_STRING_RESULT="available"
1006 ;;
1007 *)
1008 ;;
1009 esac
1010
1011 # GCC >= 4.4 supports UTF16 string literals. The CFLAGS and CXXFLAGS may change in the future.
1012 if test "$CHECK_UTF16_STRING_RESULT" = "unknown"; then
1013 if test "$GCC" = yes; then
1014 OLD_CFLAGS="${CFLAGS}"
1015 CFLAGS="${CFLAGS} -std=gnu99"
1016 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1017 static const char16_t test[] = u"This is a UTF16 literal string.";
1018 ]], [[]])],[CC_UTF16_STRING=1],[CC_UTF16_STRING=0])
1019 if test "$CC_UTF16_STRING" = 1; then
1020 UCONFIG_CFLAGS="${UCONFIG_CFLAGS} -std=gnu99"
1021 CHECK_UTF16_STRING_RESULT="C only";
1022 else
1023 CFLAGS="${OLD_CFLAGS}"
1024 fi
1025 fi
1026 if test "$GXX" = yes; then
1027 # -Wno-return-type-c-linkage is desired so that stable ICU API is not warned about.
1028 AC_LANG_PUSH([C++])
1029 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1030 static const char16_t test[] = u"This is a UTF16 literal string.";
1031 ]], [[]])],[CXX_UTF16_STRING=1],[CXX_UTF16_STRING=0])
1032 AC_LANG_POP([C++])
1033 if test "$CXX_UTF16_STRING" = 1; then
1034 if test "$CC_UTF16_STRING" = 1; then
1035 CHECK_UTF16_STRING_RESULT="available";
1036 else
1037 CHECK_UTF16_STRING_RESULT="C++ only";
1038 fi
1039 fi
1040 fi
1041 fi
1042 AC_MSG_RESULT($CHECK_UTF16_STRING_RESULT)
1043
1044 # Enable/disable extras
1045 AC_ARG_ENABLE(extras,
1046 [ --enable-extras build ICU extras [default=yes]],
1047 [case "${enableval}" in
1048 yes) extras=true ;;
1049 no) extras=false ;;
1050 *) AC_MSG_ERROR(bad value ${enableval} for --enable-extras) ;;
1051 esac],
1052 extras=true)
1053 ICU_CONDITIONAL(EXTRAS, test "$extras" = true)
1054 AC_ARG_ENABLE(icuio,
1055 [ --enable-icuio build ICU's icuio library [default=yes]],
1056 [case "${enableval}" in
1057 yes) icuio=true ;;
1058 no) icuio=false ;;
1059 *) AC_MSG_ERROR(bad value ${enableval} for --enable-icuio) ;;
1060 esac],
1061 icuio=true)
1062 ICU_CONDITIONAL(ICUIO, test "$icuio" = true)
1063
1064 # Enable/disable layout
1065 AC_ARG_ENABLE(layout,
1066 [ --enable-layout build ICU's layout library [default=yes]],
1067 [case "${enableval}" in
1068 yes) layout=true ;;
1069 no) layout=false ;;
1070 *) AC_MSG_ERROR(bad value ${enableval} for --enable-layout) ;;
1071 esac],
1072 layout=true)
1073 ICU_CONDITIONAL(LAYOUT, test "$layout" = true)
1074
1075 # Enable/disable tools
1076 AC_ARG_ENABLE(tools,
1077 [ --enable-tools build ICU's tools [default=yes]],
1078 [case "${enableval}" in
1079 yes) tools=true ;;
1080 no) tools=false ;;
1081 *) AC_MSG_ERROR(bad value ${enableval} for --enable-tools) ;;
1082 esac],
1083 tools=true)
1084 ICU_CONDITIONAL(TOOLS, test "$tools" = true)
1085
1086 AC_ARG_WITH(data-packaging,
1087 [ --with-data-packaging=type specify how to package ICU data (files, archive, library, static, auto) [default=auto]],
1088 [case "${withval}" in
1089 files|archive|library) datapackaging=$withval ;;
1090 auto) datapackaging=$withval ;;
1091 common) datapackaging=archive ;;
1092 dll) datapackaging=library ;;
1093 static) datapackaging=static ;;
1094 *) AC_MSG_ERROR(bad value ${withval} for --with-data-packaging) ;;
1095 esac],
1096 [datapackaging=])
1097
1098 # Note: 'thesysconfdir' is an evaluated version, for Man pages, so also for thedatadir, thelibdir, etc..
1099 # thesysconfdir=`eval echo $sysconfdir`
1100 dnl# AC_SUBST(thesysconfdir)
1101 dnl# thelibdir=`test "x$exec_prefix" = xNONE && exec_prefix="$prefix"; eval echo $libdir`
1102 dnl# AC_SUBST(thelibdir)
1103 thedatadir=`eval echo $datadir`
1104 dnl# AC_SUBST(thedatadir)
1105 # Always put raw data files in share/icu/{version}, etc. Never use lib/icu/{version} for data files.. Actual shared libraries will go in {libdir}.
1106 pkgicudatadir=$datadir
1107 thepkgicudatadir=$thedatadir
1108 AC_SUBST(pkgicudatadir)
1109 AC_SUBST(thepkgicudatadir)
1110
1111 dnl# Shouldn't need the AC_SUBST
1112
1113 if test x"$datapackaging" = x -o x"$datapackaging" = xauto; then
1114 # default to library
1115 datapackaging=library
1116 if test "$ENABLE_STATIC" = "YES"; then
1117 if test "$ENABLE_SHARED" != "YES"; then
1118 datapackaging=static
1119 fi
1120 fi
1121 fi
1122
1123 datapackaging_dir=`eval echo $thedatadir`"/icu/${VERSION}"
1124
1125 datapackaging_msg="(No explaination for mode $datapackaging.)"
1126
1127 datapackaging_msg_path="ICU will look in $datapackaging_dir which is the installation location. Call u_setDataDirectory() or use the ICU_DATA environment variable to override."
1128 datapackaging_msg_set="ICU will use the linked data library. If linked with the stub library located in stubdata/, the application can use udata_setCommonData() or set a data path to override."
1129 datapackaging_howfound="(unknown)"
1130
1131 case "$datapackaging" in
1132 files)
1133 DATA_PACKAGING_MODE=files
1134 datapackaging_msg="ICU data will be stored in individual files."
1135 datapackaging_howfound="$datapackaging_msg_path"
1136 ;;
1137 archive)
1138 DATA_PACKAGING_MODE=common
1139 datapackaging_msg="ICU data will be stored in a single .dat file."
1140 datapackaging_howfound="$datapackaging_msg_path"
1141 ;;
1142 library)
1143 DATA_PACKAGING_MODE=dll
1144 datapackaging_msg="ICU data will be linked with ICU."
1145 if test "$ENABLE_STATIC" = "YES"; then
1146 datapackaging_msg="$datapackaging_msg A static data library will be built. "
1147 fi
1148 if test "$ENABLE_SHARED" = "YES"; then
1149 datapackaging_msg="$datapackaging_msg A shared data library will be built. "
1150 fi
1151 datapackaging_howfound="$datapackaging_msg_set"
1152 ;;
1153 static)
1154 DATA_PACKAGING_MODE=static
1155 datapackaging_msg="ICU data will be stored in a static library."
1156 datapackaging_howfound="$datapackaging_msg_set"
1157 ;;
1158 esac
1159 AC_SUBST(DATA_PACKAGING_MODE)
1160
1161 # Sets a library suffix
1162 AC_MSG_CHECKING([for a library suffix to use])
1163 AC_ARG_WITH(library-suffix,
1164 [ --with-library-suffix=suffix tag a suffix to the library names [default=]],
1165 [ICULIBSUFFIX="${withval}"],
1166 [ICULIBSUFFIX=])
1167 msg=$ICULIBSUFFIX
1168 if test "$msg" = ""; then
1169 msg=none
1170 fi
1171 AC_MSG_RESULT($msg)
1172 AC_SUBST(ICULIBSUFFIX)
1173 if test "$ICULIBSUFFIX" != ""
1174 then
1175 U_HAVE_LIB_SUFFIX=1
1176 ICULIBSUFFIXCNAME=`echo _$ICULIBSUFFIX | sed 's/[^A-Za-z0-9_]/_/g'`
1177 UCONFIG_CPPFLAGS="${UCONFIG_CPPFLAGS} -DU_HAVE_LIB_SUFFIX=1 -DU_LIB_SUFFIX_C_NAME=${ICULIBSUFFIXCNAME} "
1178 else
1179 U_HAVE_LIB_SUFFIX=0
1180 fi
1181 AC_SUBST(U_HAVE_LIB_SUFFIX)
1182 AC_SUBST(ICULIBSUFFIXCNAME)
1183
1184 # Enable/disable tests
1185 AC_ARG_ENABLE(tests,
1186 [ --enable-tests build ICU tests [default=yes]],
1187 [case "${enableval}" in
1188 yes) tests=true ;;
1189 no) tests=false ;;
1190 *) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
1191 esac],
1192 tests=true)
1193 ICU_CONDITIONAL(TESTS, test "$tests" = true)
1194
1195 # Enable/disable samples
1196 AC_ARG_ENABLE(samples,
1197 [ --enable-samples build ICU samples [default=yes]
1198
1199 Additionally, the variable FORCE_LIBS may be set before calling configure.
1200 If set, it will REPLACE any automatic list of libraries.],
1201 [case "${enableval}" in
1202 yes) samples=true ;;
1203 no) samples=false ;;
1204 *) AC_MSG_ERROR(bad value ${enableval} for --enable-samples) ;;
1205 esac],
1206 samples=true)
1207 ICU_CONDITIONAL(SAMPLES, test "$samples" = true)
1208
1209 ICUDATA_CHAR=$U_ENDIAN_CHAR
1210
1211 # Platform-specific Makefile setup
1212 # set ICUDATA_CHAR to 'e' for any EBCDIC (which should be big endian) platform.
1213 case "${host}" in
1214 *-*-solaris*) platform=U_SOLARIS ;;
1215 *-*-linux*|*-*-gnu|*-*-k*bsd*-gnu|*-*-kopensolaris*-gnu) platform=U_LINUX ;;
1216 *-*-*bsd*|*-*-dragonfly*) platform=U_BSD ;;
1217 *-*-aix*) platform=U_AIX ;;
1218 *-*-hpux*) platform=U_HPUX ;;
1219 *-apple-darwin*|*-apple-rhapsody*) platform=U_DARWIN ;;
1220 *-*-cygwin*) platform=U_CYGWIN ;;
1221 *-*-mingw*) platform=U_MINGW ;;
1222 *-*ibm-openedition*|*-*-os390*) platform=OS390
1223 if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
1224 ICUDATA_CHAR="e"
1225 fi ;;
1226 *-*-os400*) platform=OS400
1227 if test "${ICU_ENABLE_ASCII_STRINGS}" != "1"; then
1228 ICUDATA_CHAR="e"
1229 fi ;;
1230 *-*-nto*) platform=U_QNX ;;
1231 *-dec-osf*) platform=U_OSF ;;
1232 *-*-beos) platform=U_BEOS ;;
1233 *-*-irix*) platform=U_IRIX ;;
1234 *-ncr-*) platform=U_MPRAS ;;
1235 *) platform=U_UNKNOWN_PLATFORM ;;
1236 esac
1237 AC_SUBST(ICUDATA_CHAR)
1238 AC_SUBST(platform)
1239 platform_make_fragment_name="$icu_cv_host_frag"
1240 platform_make_fragment='$(top_srcdir)/config/'"$platform_make_fragment_name"
1241 AC_SUBST(platform_make_fragment_name)
1242 AC_SUBST(platform_make_fragment)
1243
1244 if test "${FORCE_LIBS}" != ""; then
1245 echo " *** Overriding automatically chosen [LIBS=$LIBS], using instead [FORCE_LIBS=${FORCE_LIBS}]" 1>&6
1246 LIBS=${FORCE_LIBS}
1247 fi
1248
1249 # Now that we're done using CPPFLAGS etc. for tests, we can change it
1250 # for build.
1251
1252 if test "${CC}" == "clang"; then
1253 CLANGCFLAGS="-Qunused-arguments -Wno-parentheses-equality"
1254 else
1255 CLANGCFLAGS=""
1256 fi
1257
1258 if test "${CXX}" == "clang++"; then
1259 CLANGCXXFLAGS="-Qunused-arguments -Wno-parentheses-equality"
1260 else
1261 CLANGCXXFLAGS=""
1262 fi
1263
1264 CPPFLAGS="$CPPFLAGS \$(THREADSCPPFLAGS)"
1265 CFLAGS="$CFLAGS \$(THREADSCFLAGS) $CLANGCFLAGS"
1266 CXXFLAGS="$CXXFLAGS \$(THREADSCXXFLAGS) $CLANGCXXFLAGS"
1267
1268 AC_SUBST(LIBCFLAGS)
1269 AC_SUBST(LIBCXXFLAGS)
1270
1271 # append all config cppflags
1272 CPPFLAGS="$CPPFLAGS $CONFIG_CPPFLAGS $UCONFIG_CPPFLAGS"
1273
1274 echo "CPPFLAGS=$CPPFLAGS"
1275 echo "CFLAGS=$CFLAGS"
1276 echo "CXXFLAGS=$CXXFLAGS"
1277
1278
1279 # output the Makefiles
1280 AC_CONFIG_FILES([icudefs.mk \
1281 Makefile \
1282 data/pkgdataMakefile \
1283 config/Makefile.inc \
1284 config/icu.pc \
1285 config/pkgdataMakefile \
1286 data/Makefile \
1287 stubdata/Makefile \
1288 common/Makefile \
1289 i18n/Makefile \
1290 layout/Makefile \
1291 layoutex/Makefile \
1292 io/Makefile \
1293 extra/Makefile \
1294 extra/uconv/Makefile \
1295 extra/uconv/pkgdataMakefile \
1296 extra/scrptrun/Makefile \
1297 tools/Makefile \
1298 tools/ctestfw/Makefile \
1299 tools/toolutil/Makefile \
1300 tools/makeconv/Makefile \
1301 tools/genrb/Makefile \
1302 tools/genccode/Makefile \
1303 tools/gencmn/Makefile \
1304 tools/gencnval/Makefile \
1305 tools/gendict/Makefile \
1306 tools/gentest/Makefile \
1307 tools/gennorm2/Makefile \
1308 tools/genbrk/Makefile \
1309 tools/gensprep/Makefile \
1310 tools/icuinfo/Makefile \
1311 tools/icupkg/Makefile \
1312 tools/icuswap/Makefile \
1313 tools/pkgdata/Makefile \
1314 tools/tzcode/Makefile \
1315 tools/gencfu/Makefile \
1316 test/Makefile \
1317 test/compat/Makefile \
1318 test/testdata/Makefile \
1319 test/testdata/pkgdataMakefile \
1320 test/hdrtst/Makefile \
1321 test/intltest/Makefile \
1322 test/cintltst/Makefile \
1323 test/iotest/Makefile \
1324 test/letest/Makefile \
1325 test/perf/Makefile \
1326 test/perf/collationperf/Makefile \
1327 test/perf/collperf/Makefile \
1328 test/perf/dicttrieperf/Makefile \
1329 test/perf/ubrkperf/Makefile \
1330 test/perf/charperf/Makefile \
1331 test/perf/convperf/Makefile \
1332 test/perf/normperf/Makefile \
1333 test/perf/DateFmtPerf/Makefile \
1334 test/perf/howExpensiveIs/Makefile \
1335 test/perf/strsrchperf/Makefile \
1336 test/perf/unisetperf/Makefile \
1337 test/perf/usetperf/Makefile \
1338 test/perf/ustrperf/Makefile \
1339 test/perf/utfperf/Makefile \
1340 test/perf/utrie2perf/Makefile \
1341 test/perf/leperf/Makefile \
1342 samples/Makefile samples/date/Makefile \
1343 samples/cal/Makefile samples/layout/Makefile])
1344 AC_OUTPUT
1345
1346 echo
1347 echo "ICU for C/C++ $VERSION is ready to be built."
1348 echo "=== Important Notes: ==="
1349
1350 echo "Data Packaging: $datapackaging"
1351 echo " This means: $datapackaging_msg"
1352 echo " To locate data: $datapackaging_howfound"
1353
1354 if test -n "`$U_MAKE -v 2>&1 | grep '^GNU Make'`"; then
1355 echo "Building ICU: Use a GNU make such as $U_MAKE to build ICU."
1356 else
1357 echo "** WARNING: $U_MAKE may not be GNU make."
1358 echo "This may cause ICU to fail to build. Please make sure that GNU make"
1359 echo "is in your PATH so that the configure script can detect its location."
1360 fi
1361 if test "x$AR" = "xfalse"; then
1362 echo "*** WARNING: Archiver ar not found. Set AR= or fix PATH. Some builds (such as static) may fail."
1363 fi
1364
1365 AC_MSG_CHECKING([the version of "$U_MAKE"])
1366 if "$U_MAKE" -f "$srcdir/config/gmakever.mk" PLATFORM="$platform"; then
1367 AC_MSG_RESULT([ok])
1368 else
1369 AC_MSG_RESULT([too old or test failed - try upgrading GNU Make])
1370 fi
1371
1372 AC_SUBST(UCONFIG_CPPFLAGS)
1373 if test -n "$UCONFIG_CPPFLAGS"; then
1374 HDRFILE="uconfig.h.prepend"
1375 echo "*** WARNING: You must set the following flags before code compiled against this ICU will function properly:"
1376 echo
1377 echo " ${UCONFIG_CPPFLAGS}"
1378 echo
1379 echo 'The recommended way to do this is to prepend the following lines to source/common/unicode/uconfig.h or #include them near the top of that file.'
1380 echo "Creating the file ${HDRFILE}"
1381 echo
1382 echo '--------------- ' "${HDRFILE}"
1383 echo > "${HDRFILE}"
1384 echo '/* ICU customizations: put these lines at the top of uconfig.h */' >> "${HDRFILE}"
1385 echo >> "${HDRFILE}"
1386 for flag in ${UCONFIG_CPPFLAGS};
1387 do
1388 echo " /* $flag */" >> "${HDRFILE}"
1389 case "${flag}" in
1390 -D*=*)
1391 [ \echo "${flag}" | sed -n 's%-D\([^=]*\)=%#define \1 %p' >> "${HDRFILE}" ]
1392 \echo >> "${HDRFILE}"
1393 ;;
1394 -D*)
1395 [ \echo "${flag}" | sed -n 's%-D\([^=]*\)%#define \1 %p' >> "${HDRFILE}" ]
1396 \echo >> "${HDRFILE}"
1397 ;;
1398 *)
1399 \echo "/* Not sure how to handle this argument: ${flag} */" >> "${HDRFILE}"
1400 \echo >> "${HDRFILE}"
1401 ;;
1402 esac
1403 done
1404 cat "${HDRFILE}"
1405 \echo "/* End of ${HDRFILE} ------------ */" >> "${HDRFILE}"
1406 echo >> "${HDRFILE}"
1407 echo '--------------- end ' "${HDRFILE}"
1408 fi
1409
1410 AC_SUBST(UCONFIG_CFLAGS)
1411 if test -n "$UCONFIG_CFLAGS"; then
1412 echo "C apps may want to build with CFLAGS = ${UCONFIG_CFLAGS}"
1413 fi
1414 AC_SUBST(UCONFIG_CXXFLAGS)
1415 if test -n "$UCONFIG_CXXFLAGS"; then
1416 echo "C++ apps may want to build with CXXFLAGS = ${UCONFIG_CXXFLAGS}"
1417 fi
1418
1419 if test "$tools" = false;
1420 then
1421 echo "## Note: you have disabled ICU's tools. This ICU cannot build its own data or tests."
1422 echo "## Expect build failures in the 'data', 'test', and other directories."
1423 fi
1424
1425 $as_unset _CXX_CXXSUFFIX

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial