DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (dcc6d7a0dc00)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
dnl This Source Code Form is subject to the terms of the Mozilla Public
dnl License, v. 2.0. If a copy of the MPL was not distributed with this
dnl file, You can obtain one at http://mozilla.org/MPL/2.0/.

dnl Set the MOZ_ICU_VERSION variable to denote the current version of the
dnl ICU library, and also the MOZ_SHARED_ICU which would be true if we are
dnl linking against a shared library of ICU, either one that we build from
dnl our copy of ICU or the system provided library.

AC_DEFUN([MOZ_CONFIG_ICU], [

ICU_LIB_NAMES=
MOZ_NATIVE_ICU=
MOZ_ARG_WITH_BOOL(system-icu,
[  --with-system-icu
                          Use system ICU (located with pkgconfig)],
    MOZ_NATIVE_ICU=1)

if test -n "$MOZ_NATIVE_ICU"; then
    PKG_CHECK_MODULES(MOZ_ICU, icu-i18n >= 50.1)
    MOZ_SHARED_ICU=1
else
    MOZ_ICU_INCLUDES="/intl/icu/source/common /intl/icu/source/i18n"
fi

AC_SUBST_LIST(MOZ_ICU_INCLUDES)
AC_SUBST(MOZ_NATIVE_ICU)

MOZ_ARG_WITH_STRING(intl-api,
[  --with-intl-api, --with-intl-api=build, --without-intl-api
    Determine the status of the ECMAScript Internationalization API.  The first
    (or lack of any of these) builds and exposes the API.  The second builds it
    but doesn't use ICU or expose the API to script.  The third doesn't build
    ICU at all.],
    _INTL_API=$withval)

ENABLE_INTL_API=
EXPOSE_INTL_API=
case "$_INTL_API" in
no)
    ;;
build)
    ENABLE_INTL_API=1
    ;;
yes)
    ENABLE_INTL_API=1
    EXPOSE_INTL_API=1
    ;;
*)
    AC_MSG_ERROR([Invalid value passed to --with-intl-api: $_INTL_API])
    ;;
esac

if test -n "$ENABLE_INTL_API"; then
    USE_ICU=1
fi

if test -n "$EXPOSE_INTL_API"; then
    AC_DEFINE(EXPOSE_INTL_API)
fi

if test -n "$ENABLE_INTL_API"; then
    AC_DEFINE(ENABLE_INTL_API)
fi

dnl Settings for the implementation of the ECMAScript Internationalization API
if test -n "$USE_ICU"; then
    icudir="$_topsrcdir/intl/icu/source"
    if test ! -d "$icudir"; then
        icudir="$_topsrcdir/../../intl/icu/source"
        if test ! -d "$icudir"; then
            AC_MSG_ERROR([Cannot find the ICU directory])
        fi
    fi

    version=`sed -n 's/^[[[:space:]]]*#[[:space:]]*define[[:space:]][[:space:]]*U_ICU_VERSION_MAJOR_NUM[[:space:]][[:space:]]*\([0-9][0-9]*\)[[:space:]]*$/\1/p' "$icudir/common/unicode/uvernum.h"`
    if test x"$version" = x; then
       AC_MSG_ERROR([cannot determine icu version number from uvernum.h header file $lineno])
    fi
    MOZ_ICU_VERSION="$version"

    if test "$OS_TARGET" = WINNT; then
        MOZ_SHARED_ICU=1
    fi

    if test -z "${JS_STANDALONE}" -a -n "${JS_SHARED_LIBRARY}${MOZ_NATIVE_ICU}"; then
        MOZ_SHARED_ICU=1
    fi

    AC_SUBST(MOZ_ICU_VERSION)
    AC_SUBST(MOZ_SHARED_ICU)

    if test -z "$MOZ_NATIVE_ICU"; then
        case "$OS_TARGET" in
            WINNT)
                ICU_LIB_NAMES="icuin icuuc icudt"
                MOZ_ICU_DBG_SUFFIX=
                if test -n "$MOZ_DEBUG" -a -z "$MOZ_NO_DEBUG_RTL"; then
                    MOZ_ICU_DBG_SUFFIX=d
                fi
                ;;
            Darwin|Linux|DragonFly|FreeBSD|NetBSD|OpenBSD|GNU/kFreeBSD|SunOS|Android)
                ICU_LIB_NAMES="icui18n icuuc icudata"
                ;;
            *)
                AC_MSG_ERROR([ECMAScript Internationalization API is not yet supported on this platform])
        esac
    fi
fi

AC_SUBST(MOZ_ICU_DBG_SUFFIX)
AC_SUBST(ENABLE_INTL_API)
AC_SUBST(USE_ICU)
AC_SUBST_LIST(ICU_LIB_NAMES)

if test -n "$USE_ICU" -a -z "$MOZ_NATIVE_ICU"; then
    dnl We build ICU as a static library for non-shared js builds and as a shared library for shared js builds.
    if test -z "$MOZ_SHARED_ICU"; then
        AC_DEFINE(U_STATIC_IMPLEMENTATION)
    fi
    dnl Source files that use ICU should have control over which parts of the ICU
    dnl namespace they want to use.
    AC_DEFINE(U_USING_ICU_NAMESPACE,0)
fi


])

AC_DEFUN([MOZ_SUBCONFIGURE_ICU], [

if test -z "$BUILDING_JS" -o -n "$JS_STANDALONE"; then

    if test -n "$USE_ICU" -a -z "$MOZ_NATIVE_ICU"; then
        # Set ICU compile options
        ICU_CPPFLAGS=""
        # don't use icu namespace automatically in client code
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DU_USING_ICU_NAMESPACE=0"
        # don't include obsolete header files
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DU_NO_DEFAULT_INCLUDE_UTF_HEADERS=1"
        # remove chunks of the library that we don't need (yet)
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DUCONFIG_NO_LEGACY_CONVERSION"
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DUCONFIG_NO_TRANSLITERATION"
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DUCONFIG_NO_REGULAR_EXPRESSIONS"
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DUCONFIG_NO_BREAK_ITERATION"
        # we don't need to pass data to and from legacy char* APIs
        ICU_CPPFLAGS="$ICU_CPPFLAGS -DU_CHARSET_IS_UTF8"
        # make sure to not accidentally pick up system-icu headers
        ICU_CPPFLAGS="$ICU_CPPFLAGS -I$icudir/common -I$icudir/i18n"

        ICU_CROSS_BUILD_OPT=""

        if test "$CROSS_COMPILE"; then
            # Remove _DEPEND_CFLAGS from HOST_FLAGS to avoid configure error
            HOST_ICU_CFLAGS="$HOST_CFLAGS"
            HOST_ICU_CXXFLAGS="$HOST_CXXFLAGS"

            HOST_ICU_CFLAGS=`echo $HOST_ICU_CFLAGS | sed "s|$_DEPEND_CFLAGS||g"`
            HOST_ICU_CXXFLAGS=`echo $HOST_ICU_CFXXLAGS | sed "s|$_DEPEND_CFLAGS||g"`

            # ICU requires RTTI
            if test "$GNU_CC"; then
                HOST_ICU_CXXFLAGS=`echo $HOST_ICU_CXXFLAGS | sed 's|-fno-rtti|-frtti|g'`
            elif test "$_MSC_VER"; then
                HOST_ICU_CXXFLAGS=`echo $HOST_ICU_CXXFLAGS | sed 's|-GR-|-GR|g'`
            fi

            HOST_ICU_BUILD_OPTS=""
            if test -n "$MOZ_DEBUG"; then
                HOST_ICU_BUILD_OPTS="$HOST_ICU_BUILD_OPTS --enable-debug"
            fi

            abs_srcdir=`(cd $srcdir; pwd)`
            mkdir -p $_objdir/intl/icu/host
            (export AR="$HOST_AR"
             export RANLIB="$HOST_RANLIB"
             export CC="$HOST_CC"
             export CXX="$HOST_CXX"
             export CPP="$HOST_CPP"
             export LD="$HOST_LD"
             export CFLAGS="$HOST_ICU_CFLAGS $HOST_OPTIMIZE_FLAGS"
             export CPPFLAGS="$ICU_CPPFLAGS"
             export CXXFLAGS="$HOST_ICU_CXXFLAGS $HOST_OPTIMIZE_FLAGS"
             export LDFLAGS="$HOST_LDFLAGS"
             ac_configure_args="$HOST_ICU_BUILD_OPTS"
             ac_configure_args="$ac_configure_args --enable-static --disable-shared --enable-extras=no --enable-icuio=no --enable-layout=no --enable-tests=no --enable-samples=no"
             AC_OUTPUT_SUBDIRS_NOW(intl/icu/source:intl/icu/host)
            ) || exit 1
            # generate config/icucross.mk
            $GMAKE -C $_objdir/intl/icu/host/ config/icucross.mk

            # --with-cross-build requires absolute path
            ICU_HOST_PATH=`cd $_objdir/intl/icu/host && pwd`
            ICU_CROSS_BUILD_OPT="--with-cross-build=$ICU_HOST_PATH --disable-tools"
            ICU_TARGET_OPT="--build=$build --host=$target"
        else
            # CROSS_COMPILE isn't set build and target are i386 and x86-64.
            # So we must set target for --build and --host.
            ICU_TARGET_OPT="--build=$target --host=$target"
        fi

        if test -z "$MOZ_SHARED_ICU"; then
            # To reduce library size, use static linking
            ICU_LINK_OPTS="--enable-static --disable-shared"
        else
            ICU_LINK_OPTS="--disable-static --enable-shared"
        fi
        # Force the ICU static libraries to be position independent code
        ICU_CFLAGS="$DSO_PIC_CFLAGS $CFLAGS"
        ICU_CXXFLAGS="$DSO_PIC_CFLAGS $CXXFLAGS"

        ICU_BUILD_OPTS=""
        if test -n "$MOZ_DEBUG" -o "MOZ_DEBUG_SYMBOLS"; then
            ICU_CFLAGS="$ICU_CFLAGS $MOZ_DEBUG_FLAGS"
            ICU_CXXFLAGS="$ICU_CXXFLAGS $MOZ_DEBUG_FLAGS"
            if test -n "$CROSS_COMPILE" -a "$OS_TARGET" = "Darwin" \
                    -a "$HOST_OS_ARCH" != "Darwin"
            then
                # Bug 951758: Cross-OSX builds with non-Darwin hosts have issues
                # with -g and friends (like -gdwarf and -gfull) because they try
                # to run dsymutil
                changequote(,)
                ICU_CFLAGS=`echo $ICU_CFLAGS | sed 's|-g[^ \t]*||g'`
                ICU_CXXFLAGS=`echo $ICU_CXXFLAGS | sed 's|-g[^ \t]*||g'`
                changequote([,])
            fi

            ICU_LDFLAGS="$MOZ_DEBUG_LDFLAGS"
            if test -z "$MOZ_DEBUG"; then
                # To generate debug symbols, it requires MOZ_DEBUG_FLAGS.
                # But, not debug build.
                ICU_CFLAGS="$ICU_CFLAGS -UDEBUG -DNDEBUG"
                ICU_CXXFLAGS="$ICU_CXXFLAGS -UDEBUG -DNDEBUG"
            elif test -z "$MOZ_NO_DEBUG_RTL"; then
                ICU_BUILD_OPTS="$ICU_BUILD_OPTS --enable-debug"
            fi
        fi
        if test -z "$MOZ_OPTIMIZE"; then
            ICU_BUILD_OPTS="$ICU_BUILD_OPTS --disable-release"
        else
            ICU_CFLAGS="$ICU_CFLAGS $MOZ_OPTIMIZE_FLAGS"
            ICU_CXXFLAGS="$ICU_CXXFLAGS $MOZ_OPTIMIZE_FLAGS"
        fi

        if test "$am_cv_langinfo_codeset" = "no"; then
            # ex. Android
            ICU_CPPFLAGS="$ICU_CPPFLAGS -DU_HAVE_NL_LANGINFO_CODESET=0"
        fi

        # ICU requires RTTI
        if test "$GNU_CC"; then
            ICU_CXXFLAGS=`echo $ICU_CXXFLAGS | sed 's|-fno-rtti|-frtti|g'`
        else
            if test "$_MSC_VER"; then
                ICU_CXXFLAGS=`echo $ICU_CXXFLAGS | sed 's|-GR-|-GR|g'`
            fi

            # Add RTL flags for MSVCRT.DLL
            if test -n "$MOZ_DEBUG" -a -z "$MOZ_NO_DEBUG_RTL"; then
                ICU_CFLAGS="$ICU_CFLAGS -MDd"
                ICU_CXXFLAGS="$ICU_CXXFLAGS -MDd"
            else
                ICU_CFLAGS="$ICU_CFLAGS -MD"
                ICU_CXXFLAGS="$ICU_CXXFLAGS -MD"
            fi

            # add disable optimize flag for workaround for bug 899948
            if test -z "$MOZ_OPTIMIZE"; then
                ICU_CFLAGS="$ICU_CFLAGS -Od"
                ICU_CXXFLAGS="$ICU_CXXFLAGS -Od"
            fi
        fi

        if test -n "$gonkdir"; then
            ICU_CXXFLAGS="-I$gonkdir/abi/cpp/include $ICU_CXXFLAGS"
        elif test "$OS_TARGET" = Android -a "$MOZ_ANDROID_CXX_STL" = mozstlport; then
            ICU_CXXFLAGS="-I$_topsrcdir/build/gabi++/include $ICU_CXXFLAGS"
        fi

        if test -z "$MOZ_SHARED_ICU"; then
          ICU_CXXFLAGS="$ICU_CXXFLAGS -DU_STATIC_IMPLEMENTATION"
          ICU_CFLAGS="$ICU_CFLAGS -DU_STATIC_IMPLEMENTATION"
          if test "$GNU_CC"; then
            ICU_CFLAGS="$ICU_CFLAGS -fvisibility=hidden"
            ICU_CXXFLAGS="$ICU_CXXFLAGS -fvisibility=hidden"
          fi
        fi

        (export AR="$AR"
         export RANLIB="$RANLIB"
         export CC="$CC"
         export CXX="$CXX"
         export LD="$LD"
         export ARFLAGS="$ARFLAGS"
         export CPPFLAGS="$ICU_CPPFLAGS $CPPFLAGS"
         export CFLAGS="$ICU_CFLAGS"
         export CXXFLAGS="$ICU_CXXFLAGS"
         export LDFLAGS="$ICU_LDFLAGS $LDFLAGS"
         ac_configure_args="$ICU_BUILD_OPTS $ICU_CROSS_BUILD_OPT $ICU_LINK_OPTS $ICU_TARGET_OPT"
         ac_configure_args="$ac_configure_args --disable-extras --disable-icuio --disable-layout --disable-tests --disable-samples --disable-strict"
         AC_OUTPUT_SUBDIRS(intl/icu/source:intl/icu/target)
        ) || exit 1
    fi

fi

])