summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAndras Timar <andras.timar@collabora.com>2017-04-24 10:55:47 +0200
committerAndras Timar <andras.timar@collabora.com>2017-04-24 11:01:41 +0200
commitb799279088353b38117171ea212c73af6ccae648 (patch)
tree3c68275c6b5a2dc9224a8832cb3da8ad9758a1ec
parentaa89161fc713a365bbec2936331f4f342d6eb58d (diff)
Revert back to ICU 54, because MSP cannot be generated on Windows
Change-Id: Ie0c857c9c8fd7091e115245c75d7490d46033426
-rw-r--r--bridges/Module_bridges.mk2
-rw-r--r--configure.ac38
-rw-r--r--distro-configs/LibreOfficeEmscripten.conf54
-rw-r--r--download.lst2
-rw-r--r--external/icu/ExternalProject_icu.mk10
-rw-r--r--external/icu/UnpackedTarball_icu.mk10
-rw-r--r--external/icu/clang-cl.patch.026
-rw-r--r--external/icu/icu-ubsan.patch.011
-rw-r--r--external/icu/icu.changeset_36724.patch.139
-rw-r--r--external/icu/icu.changeset_36727.patch.155
-rw-r--r--external/icu/icu.changeset_36801.patch.11222
-rw-r--r--external/icu/icu4c-changeset-39671.patch.1189
-rw-r--r--external/icu/icu4c-emscripten.patch.1116
-rw-r--r--external/icu/icu4c-icu11451.patch.111
-rw-r--r--external/icu/khmerbreakengine.patch1110
-rw-r--r--external/icu/khmerdict.dictbin263537 -> 0 bytes
-rw-r--r--i18npool/qa/cppunit/test_breakiterator.cxx20
-rw-r--r--i18npool/source/breakiterator/breakiterator_unicode.cxx4
-rw-r--r--include/osl/endian.h10
-rw-r--r--include/sal/alloca.h2
-rw-r--r--include/sal/config.h10
-rw-r--r--sal/osl/unx/socket.cxx2
-rw-r--r--sal/osl/unx/system.hxx5
-rw-r--r--solenv/gbuild/platform/EMSCRIPTEN_INTEL_emcc.mk18
-rw-r--r--vcl/Library_vcl.mk6
25 files changed, 1369 insertions, 1603 deletions
diff --git a/bridges/Module_bridges.mk b/bridges/Module_bridges.mk
index a876f0b01deb..534efda6936b 100644
--- a/bridges/Module_bridges.mk
+++ b/bridges/Module_bridges.mk
@@ -24,7 +24,6 @@ $(eval $(call gb_Module_add_targets,bridges,\
) \
))
-ifneq ($(OS), EMSCRIPTEN)
ifeq (,$(filter build,$(gb_Module_SKIPTARGETS)))
ifeq ($(strip $(bridges_SELECTED_BRIDGE)),)
$(call gb_Output_error,no bridge selected for build: bailing out)
@@ -32,6 +31,5 @@ else ifneq ($(words $(bridges_SELECTED_BRIDGE)),1)
$(call gb_Output_error,multiple bridges selected for build: $(bridges_SELECTED_BRIDGE))
endif
endif
-endif
# vim: set noet sw=4 ts=4:
diff --git a/configure.ac b/configure.ac
index ba2dd3408828..9714815911d0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -792,27 +792,6 @@ linux-android*)
BUILD_TYPE="$BUILD_TYPE FONTCONFIG FREETYPE"
;;
-emscripten*)
- build_gstreamer_1_0=no
- build_gstreamer_0_10=no
- enable_lotuswordpro=no
- enable_mpl_subset=yes
- enable_coinmp=yes
- enable_lpsolve=no
- enable_report_builder=no
- with_theme="tango"
- test_cups=no
- test_dbus=no
- test_fontconfig=no
- test_freetype=no
- test_gtk=no
- test_tde=no
- test_kde4=no
- test_randr=no
- test_xrender=no
- _os=Emscripten
- ;;
-
*)
AC_MSG_ERROR([$host_os operating system is not suitable to build LibreOffice for!])
;;
@@ -4318,17 +4297,6 @@ linux-android*)
esac
;;
-emscripten*)
- COM=emcc
- USING_X11=
- OS=EMSCRIPTEN
- RTL_OS=Emscripten
- P_SEP=:
- CPUNAME=INTEL
- RTL_ARCH=x86
- PLATFORMID=linux_x86
- ;;
-
mingw*)
COM=GCC
GUIBASE=not-used
@@ -5394,7 +5362,7 @@ else
fi
dnl check for GNU C++ compiler version
-if test "$GXX" = "yes" -a $CXX != "emcc"; then
+if test "$GXX" = "yes"; then
AC_MSG_CHECKING([the GNU C++ compiler version])
_gpp_version=`$CXX -dumpversion`
@@ -8935,7 +8903,7 @@ SYSTEM_GENBRK=
SYSTEM_GENCCODE=
SYSTEM_GENCMN=
-ICU_MAJOR=57
+ICU_MAJOR=54
ICU_MINOR=1
ICU_RECLASSIFIED_CLOSE_PARENTHESIS="TRUE"
ICU_RECLASSIFIED_PREPEND_SET_EMPTY="TRUE"
@@ -10015,7 +9983,7 @@ fi
AC_SUBST(ENABLE_KDE4)
ENABLE_HEADLESS=""
-if test "x$with_x" = "xno" -o $CXX = "emcc"; then
+if test "x$with_x" = "xno"; then
ENABLE_HEADLESS="TRUE"
SCPDEFS="$SCPDEFS -DLIBO_HEADLESS"
R="headless"
diff --git a/distro-configs/LibreOfficeEmscripten.conf b/distro-configs/LibreOfficeEmscripten.conf
deleted file mode 100644
index 2678b929d7cc..000000000000
--- a/distro-configs/LibreOfficeEmscripten.conf
+++ /dev/null
@@ -1,54 +0,0 @@
-# Need to specify --host and --build to enable cross-compilation mode
-# See https://www.gnu.org/software/autoconf/manual/autoconf-2.69/html_node/Hosts-and-Cross_002dCompilation.html
---host=asmjs-local-emscripten
---build=x86_64-unknown-linux-gnu
-
-# Disable unnecessary stuff
---disable-cairo-canvas
---disable-cups
---disable-gconf
---disable-dconf
---disable-gio
---disable-dbus
---disable-sdremote-bluetooth
---disable-gstreamer-0-10
---disable-gstreamer-1-0
---disable-liblangtag
---disable-lockdown
---disable-odk
---disable-postgresql-sdbc
---disable-firebird-sdbc
---disable-python
---disable-randr
---disable-randr-link
---disable-pdfimport
---disable-systray
---disable-gltf
---disable-collada
---disable-export
---disable-report-builder
---disable-lpsolve
---disable-coinmp
---disable-scripting
---disable-graphite
---disable-orcus
---without-fonts
---without-java
---without-junit
---without-helppack-integration
---without-system-dicts
---with-theme=no
---with-system-zlib=no
-
-# This helps spotting build errors
---with-parallelism=no
-
-# Emscripten doesn't support dynamic loading
---disable-dynamic-loading
-
-# Not sure whether we need this
-#--disable-ccache
-
-# Specify Emscripten compiler
-CC=emcc
-CXX=emcc
diff --git a/download.lst b/download.lst
index c993c7e81f6e..7afba25c9bbf 100644
--- a/download.lst
+++ b/download.lst
@@ -58,7 +58,7 @@ export HARFBUZZ_TARBALL := harfbuzz-0.9.40.tar.bz2
export HSQLDB_TARBALL := 17410483b5b5f267aa18b7e00b65e6e0-hsqldb_1_8_0.zip
export HUNSPELL_TARBALL := 4967da60b23413604c9e563beacc63b4-hunspell-1.3.3.tar.gz
export HYPHEN_TARBALL := 5ade6ae2a99bc1e9e57031ca88d36dad-hyphen-2.8.8.tar.gz
-export ICU_TARBALL := 976734806026a4ef8bdd17937c8898b9-icu4c-57_1-src.tgz
+export ICU_TARBALL := e844caed8f2ca24c088505b0d6271bc0-icu4c-54_1-src.tgz
export JFREEREPORT_FLOW_ENGINE_TARBALL := ba2930200c9f019c2d93a8c88c651a0f-flow-engine-0.9.4.zip
export JFREEREPORT_FLUTE_TARBALL := d8bd5eed178db6e2b18eeed243f85aa8-flute-1.1.6.zip
export JFREEREPORT_LIBBASE_TARBALL := eeb2c7ddf0d302fba4bfc6e97eac9624-libbase-1.1.6.zip
diff --git a/external/icu/ExternalProject_icu.mk b/external/icu/ExternalProject_icu.mk
index 0442997d869a..d302a7c0949e 100644
--- a/external/icu/ExternalProject_icu.mk
+++ b/external/icu/ExternalProject_icu.mk
@@ -22,7 +22,7 @@ ifeq ($(COM),MSC)
$(call gb_ExternalProject_get_state_target,icu,build) :
$(call gb_ExternalProject_run,build,\
export LIB="$(ILIB)" \
- && CFLAGS="-FS -arch:SSE $(SOLARINC) $(gb_DEBUG_CFLAGS)" CPPFLAGS="$(SOLARINC)" CXXFLAGS="-FS -arch:SSE $(SOLARINC) $(gb_DEBUG_CFLAGS)" \
+ && CFLAGS="-arch:SSE $(SOLARINC) $(gb_DEBUG_CFLAGS)" CPPFLAGS="$(SOLARINC)" CXXFLAGS="-arch:SSE $(SOLARINC) $(gb_DEBUG_CFLAGS)" \
INSTALL=`cygpath -m /usr/bin/install` \
./runConfigureICU \
$(if $(MSVC_USE_DEBUG_RUNTIME),--enable-debug --disable-release) \
@@ -55,14 +55,14 @@ icu_CFLAGS:=" \
$(if $(debug),$(gb_DEBUG_CFLAGS),$(gb_COMPILEROPTFLAGS)) \
$(if $(ENABLE_LTO),$(gb_LTOFLAGS)) \
$(if $(filter GCC,$(COM)),-fno-strict-aliasing) \
- $(if $(filter $(true),$(gb_SYMBOL)),$(gb_DEBUGINFO_FLAGS)) \
+ $(if $(filter $(true),$(gb_SYMBOL)),-g) \
$(if $(filter ANDROID,$(OS)),-fvisibility=hidden -fno-omit-frame-pointer)"
-icu_CXXFLAGS:="$(CXXFLAGS) $(CXXFLAGS_CXX11) \
+icu_CXXFLAGS:="$(CXXFLAGS_CXX11) \
$(if $(filter IOS,$(OS)),-DUCONFIG_NO_FILE_IO) \
$(if $(debug),$(gb_DEBUG_CFLAGS),$(gb_COMPILEROPTFLAGS)) \
$(if $(ENABLE_LTO),$(gb_LTOFLAGS)) \
$(if $(filter GCC,$(COM)),-fno-strict-aliasing) \
- $(if $(filter $(true),$(gb_SYMBOL)),$(gb_DEBUGINFO_FLAGS)) \
+ $(if $(filter $(true),$(gb_SYMBOL)),-g) \
$(if $(filter ANDROID,$(OS)),-fvisibility=hidden -fno-omit-frame-pointer)"
icu_LDFLAGS:=" \
$(if $(ENABLE_LTO),$(gb_LTOFLAGS)) \
@@ -80,7 +80,7 @@ $(call gb_ExternalProject_get_state_target,icu,build) :
--disable-layout --disable-samples \
$(if $(CROSS_COMPILING),--disable-tools --disable-extras) \
$(if $(filter IOS ANDROID,$(OS)),--disable-dyload) \
- $(if $(filter ANDROID EMSCRIPTEN,$(OS)),--disable-strict ac_cv_c_bigendian=no) \
+ $(if $(filter ANDROID,$(OS)),--disable-strict ac_cv_c_bigendian=no) \
$(if $(filter SOLARIS AIX,$(OS)),--disable-64bit-libs) \
$(if $(filter TRUE,$(DISABLE_DYNLOADING)),\
--enable-static --disable-shared,\
diff --git a/external/icu/UnpackedTarball_icu.mk b/external/icu/UnpackedTarball_icu.mk
index 86369ef8e43b..09342893fc8c 100644
--- a/external/icu/UnpackedTarball_icu.mk
+++ b/external/icu/UnpackedTarball_icu.mk
@@ -23,14 +23,12 @@ $(eval $(call gb_UnpackedTarball_add_patches,icu,\
external/icu/icu-ubsan.patch.0 \
external/icu/icu4c-icu11100.patch.1 \
external/icu/icu4c-scriptrun.patch \
+ external/icu/icu4c-icu11451.patch.1 \
external/icu/rtti.patch.0 \
- external/icu/clang-cl.patch.0 \
+ external/icu/icu.changeset_36724.patch.1 \
+ external/icu/icu.changeset_36727.patch.1 \
+ external/icu/icu.changeset_36801.patch.1 \
$(if $(filter-out ANDROID,$(OS)),external/icu/icu4c-icudata-stdlibs.diff) \
- $(if $(filter EMSCRIPTEN,$(OS)),external/icu/icu4c-emscripten.patch.1) \
- external/icu/khmerbreakengine.patch \
- external/icu/icu4c-changeset-39671.patch.1 \
))
-$(eval $(call gb_UnpackedTarball_add_file,icu,source/data/brkitr/khmerdict.dict,external/icu/khmerdict.dict))
-
# vim: set noet sw=4 ts=4:
diff --git a/external/icu/clang-cl.patch.0 b/external/icu/clang-cl.patch.0
deleted file mode 100644
index 4df5d0f56c83..000000000000
--- a/external/icu/clang-cl.patch.0
+++ /dev/null
@@ -1,26 +0,0 @@
---- source/config/mh-cygwin-msvc
-+++ source/config/mh-cygwin-msvc
-@@ -51,8 +51,8 @@
- LDFLAGS+=-nologo
-
- # Commands to compile
--COMPILE.c= $(CC) $(CPPFLAGS) $(DEFS) $(CFLAGS) -c
-+COMPILE.c= true && $(CC) $(CPPFLAGS) $(DEFS) $(CFLAGS) -c
--COMPILE.cc= $(CXX) $(CPPFLAGS) $(DEFS) $(CXXFLAGS) -c
-+COMPILE.cc= true && $(CXX) $(CPPFLAGS) $(DEFS) $(CXXFLAGS) -c
-
- # Commands to link
- LINK.c= LINK.EXE -subsystem:console $(LDFLAGS)
---- source/runConfigureICU
-+++ source/runConfigureICU
-@@ -259,8 +259,8 @@
- Cygwin/MSVC)
- THE_OS="Windows with Cygwin"
- THE_COMP="Microsoft Visual C++"
-- CC=cl; export CC
-- CXX=cl; export CXX
-+ CC=${CC-cl}; export CC
-+ CXX=${CXX-cl}; export CXX
- RELEASE_CFLAGS='-Gy -MD'
- RELEASE_CXXFLAGS='-Gy -MD'
- DEBUG_CFLAGS='-Zi -MDd'
diff --git a/external/icu/icu-ubsan.patch.0 b/external/icu/icu-ubsan.patch.0
index 6d1d3bcf5014..25efb5fec728 100644
--- a/external/icu/icu-ubsan.patch.0
+++ b/external/icu/icu-ubsan.patch.0
@@ -162,3 +162,14 @@
}
virtual UBool operator == (const CacheKeyBase &other) const {
// reflexive
+--- source/common/uresbund.cpp
++++ source/common/uresbund.cpp
+@@ -53,7 +53,7 @@
+ UHashTok namekey, pathkey;
+ namekey.pointer = b->fName;
+ pathkey.pointer = b->fPath;
+- return uhash_hashChars(namekey)+37*uhash_hashChars(pathkey);
++ return uhash_hashChars(namekey)+37U*uhash_hashChars(pathkey);
+ }
+
+ /* INTERNAL: compares two entries */
diff --git a/external/icu/icu.changeset_36724.patch.1 b/external/icu/icu.changeset_36724.patch.1
new file mode 100644
index 000000000000..82e0f21394b5
--- /dev/null
+++ b/external/icu/icu.changeset_36724.patch.1
@@ -0,0 +1,39 @@
+Index: icu/source/i18n/regexcmp.cpp
+===================================================================
+--- icu/source/i18n/regexcmp.cpp (revision 36723)
++++ icu/source/i18n/regexcmp.cpp (revision 36724)
+@@ -2136,4 +2136,8 @@
+ int32_t minML = minMatchLength(fMatchOpenParen, patEnd);
+ int32_t maxML = maxMatchLength(fMatchOpenParen, patEnd);
++ if (URX_TYPE(maxML) != 0) {
++ error(U_REGEX_LOOK_BEHIND_LIMIT);
++ break;
++ }
+ if (maxML == INT32_MAX) {
+ error(U_REGEX_LOOK_BEHIND_LIMIT);
+@@ -2169,4 +2173,8 @@
+ int32_t minML = minMatchLength(fMatchOpenParen, patEnd);
+ int32_t maxML = maxMatchLength(fMatchOpenParen, patEnd);
++ if (URX_TYPE(maxML) != 0) {
++ error(U_REGEX_LOOK_BEHIND_LIMIT);
++ break;
++ }
+ if (maxML == INT32_MAX) {
+ error(U_REGEX_LOOK_BEHIND_LIMIT);
+Index: icu/source/test/testdata/regextst.txt
+===================================================================
+--- icu/source/test/testdata/regextst.txt (revision 36723)
++++ icu/source/test/testdata/regextst.txt (revision 36724)
+@@ -1201,4 +1201,12 @@
+ "A|B|\U00012345" "hello <0>\U00012345</0>"
+ "A|B|\U00010000" "hello \ud800"
++
++# Bug 11370
++# Max match length computation of look-behind expression gives result that is too big to fit in the
++# in the 24 bit operand portion of the compiled code. Expressions should fail to compile
++# (Look-behind match length must be bounded. This case is treated as unbounded, an error.)
++
++"(?<!(0123456789a){10000000})x" E "no match"
++"(?<!\\ubeaf(\\ubeaf{11000}){11000})" E "no match"
+
+ # Random debugging, Temporary
diff --git a/external/icu/icu.changeset_36727.patch.1 b/external/icu/icu.changeset_36727.patch.1
new file mode 100644
index 000000000000..1b8e01edb98a
--- /dev/null
+++ b/external/icu/icu.changeset_36727.patch.1
@@ -0,0 +1,55 @@
+Index: icu/source/i18n/regexcmp.cpp
+===================================================================
+--- icu/source/i18n/regexcmp.cpp (revision 36726)
++++ icu/source/i18n/regexcmp.cpp (revision 36727)
+@@ -2340,5 +2340,13 @@
+ if (fIntervalUpper == 0) {
+ // Pathological case. Attempt no matches, as if the block doesn't exist.
++ // Discard the generated code for the block.
++ // If the block included parens, discard the info pertaining to them as well.
+ fRXPat->fCompiledPat->setSize(topOfBlock);
++ if (fMatchOpenParen >= topOfBlock) {
++ fMatchOpenParen = -1;
++ }
++ if (fMatchCloseParen >= topOfBlock) {
++ fMatchCloseParen = -1;
++ }
+ return TRUE;
+ }
+Index: icu/source/i18n/regexcmp.h
+===================================================================
+--- icu/source/i18n/regexcmp.h (revision 36726)
++++ icu/source/i18n/regexcmp.h (revision 36727)
+@@ -188,5 +188,7 @@
+ // of the slot reserved for a state save
+ // at the start of the most recently processed
+- // parenthesized block.
++ // parenthesized block. Updated when processing
++ // a close to the location for the corresponding open.
++
+ int32_t fMatchCloseParen; // The position in the pattern of the first
+ // location after the most recently processed
+Index: icu/source/test/testdata/regextst.txt
+===================================================================
+--- icu/source/test/testdata/regextst.txt (revision 36726)
++++ icu/source/test/testdata/regextst.txt (revision 36727)
+@@ -1202,4 +1202,13 @@
+ "A|B|\U00010000" "hello \ud800"
+
++# Bug 11369
++# Incorrect optimization of patterns with a zero length quantifier {0}
++
++"(.|b)(|b){0}\$(?#xxx){3}(?>\D*)" "AAAAABBBBBCCCCCDDDDEEEEE"
++"(|b)ab(c)" "<0><1></1>ab<2>c</2></0>"
++"(|b){0}a{3}(D*)" "<0>aaa<2></2></0>"
++"(|b){0,1}a{3}(D*)" "<0><1></1>aaa<2></2></0>"
++"((|b){0})a{3}(D*)" "<0><1></1>aaa<3></3></0>"
++
+ # Bug 11370
+ # Max match length computation of look-behind expression gives result that is too big to fit in the
+@@ -1209,4 +1218,5 @@
+ "(?<!(0123456789a){10000000})x" E "no match"
+ "(?<!\\ubeaf(\\ubeaf{11000}){11000})" E "no match"
++
+
+ # Random debugging, Temporary
diff --git a/external/icu/icu.changeset_36801.patch.1 b/external/icu/icu.changeset_36801.patch.1
new file mode 100644
index 000000000000..4a926d9126ed
--- /dev/null
+++ b/external/icu/icu.changeset_36801.patch.1
@@ -0,0 +1,1222 @@
+diff -ru icu/source/common/unicode/utypes.h icu/source/common/unicode/utypes.h
+--- icu/source/common/unicode/utypes.h 2014-10-03 18:11:02.000000000 +0200
++++ icu/source/common/unicode/utypes.h 2015-04-10 15:28:06.149993491 +0200
+@@ -647,6 +647,7 @@
+ U_REGEX_STACK_OVERFLOW, /**< Regular expression backtrack stack overflow. */
+ U_REGEX_TIME_OUT, /**< Maximum allowed match time exceeded */
+ U_REGEX_STOPPED_BY_CALLER, /**< Matching operation aborted by user callback fn. */
++ U_REGEX_PATTERN_TOO_BIG, /**< Pattern exceeds limits on size or complexity. @draft ICU 55 */
+ U_REGEX_ERROR_LIMIT, /**< This must always be the last value to indicate the limit for regexp errors */
+
+ /*
+diff -ru icu/source/common/utypes.c icu/source/common/utypes.c
+--- icu/source/common/utypes.c 2014-10-03 18:11:14.000000000 +0200
++++ icu/source/common/utypes.c 2015-04-10 15:28:06.149993491 +0200
+@@ -1,7 +1,7 @@
+ /*
+ ******************************************************************************
+ *
+-* Copyright (C) 1997-2011, International Business Machines
++* Copyright (C) 1997-2014, International Business Machines
+ * Corporation and others. All Rights Reserved.
+ *
+ ******************************************************************************
+@@ -165,7 +165,8 @@
+ "U_REGEX_INVALID_RANGE",
+ "U_REGEX_STACK_OVERFLOW",
+ "U_REGEX_TIME_OUT",
+- "U_REGEX_STOPPED_BY_CALLER"
++ "U_REGEX_STOPPED_BY_CALLER",
++ "U_REGEX_PATTERN_TOO_BIG"
+ };
+
+ static const char * const
+diff -ru icu/source/i18n/regexcmp.cpp icu/source/i18n/regexcmp.cpp
+--- icu/source/i18n/regexcmp.cpp 2015-04-10 15:27:31.369772849 +0200
++++ icu/source/i18n/regexcmp.cpp 2015-04-10 15:28:06.152993511 +0200
+@@ -301,7 +301,7 @@
+ // present in the saved state: the input string position (int64_t) and
+ // the position in the compiled pattern.
+ //
+- fRXPat->fFrameSize+=RESTACKFRAME_HDRCOUNT;
++ allocateStackData(RESTACKFRAME_HDRCOUNT);
+
+ //
+ // Optimization pass 1: NOPs, back-references, and case-folding
+@@ -367,9 +367,9 @@
+ // the start of an ( grouping.
+ //4 NOP Resreved, will be replaced by a save if there are
+ // OR | operators at the top level
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_STATE_SAVE, 2), *fStatus);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_JMP, 3), *fStatus);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_FAIL, 0), *fStatus);
++ appendOp(URX_STATE_SAVE, 2);
++ appendOp(URX_JMP, 3);
++ appendOp(URX_FAIL, 0);
+
+ // Standard open nonCapture paren action emits the two NOPs and
+ // sets up the paren stack frame.
+@@ -392,7 +392,7 @@
+ }
+
+ // add the END operation to the compiled pattern.
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_END, 0), *fStatus);
++ appendOp(URX_END, 0);
+
+ // Terminate the pattern compilation state machine.
+ returnVal = FALSE;
+@@ -414,14 +414,13 @@
+ int32_t savePosition = fParenStack.popi();
+ int32_t op = (int32_t)fRXPat->fCompiledPat->elementAti(savePosition);
+ U_ASSERT(URX_TYPE(op) == URX_NOP); // original contents of reserved location
+- op = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+1);
++ op = buildOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+1);
+ fRXPat->fCompiledPat->setElementAt(op, savePosition);
+
+ // Append an JMP operation into the compiled pattern. The operand for
+ // the JMP will eventually be the location following the ')' for the
+ // group. This will be patched in later, when the ')' is encountered.
+- op = URX_BUILD(URX_JMP, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_JMP, 0);
+
+ // Push the position of the newly added JMP op onto the parentheses stack.
+ // This registers if for fixup when this block's close paren is encountered.
+@@ -430,7 +429,7 @@
+ // Append a NOP to the compiled pattern. This is the slot reserved
+ // for a SAVE in the event that there is yet another '|' following
+ // this one.
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
++ appendOp(URX_NOP, 0);
+ fParenStack.push(fRXPat->fCompiledPat->size()-1, *fStatus);
+ }
+ break;
+@@ -456,12 +455,10 @@
+ // END_CAPTURE is encountered.
+ {
+ fixLiterals();
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
+- int32_t varsLoc = fRXPat->fFrameSize; // Reserve three slots in match stack frame.
+- fRXPat->fFrameSize += 3;
+- int32_t cop = URX_BUILD(URX_START_CAPTURE, varsLoc);
+- fRXPat->fCompiledPat->addElement(cop, *fStatus);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
++ appendOp(URX_NOP, 0);
++ int32_t varsLoc = allocateStackData(3); // Reserve three slots in match stack frame.
++ appendOp(URX_START_CAPTURE, varsLoc);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the two NOPs. Depending on what follows in the pattern, the
+@@ -486,8 +483,8 @@
+ // is an '|' alternation within the parens.
+ {
+ fixLiterals();
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
++ appendOp(URX_NOP, 0);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the two NOPs.
+@@ -509,12 +506,10 @@
+ // is an '|' alternation within the parens.
+ {
+ fixLiterals();
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
+- int32_t varLoc = fRXPat->fDataSize; // Reserve a data location for saving the
+- fRXPat->fDataSize += 1; // state stack ptr.
+- int32_t stoOp = URX_BUILD(URX_STO_SP, varLoc);
+- fRXPat->fCompiledPat->addElement(stoOp, *fStatus);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
++ appendOp(URX_NOP, 0);
++ int32_t varLoc = allocateData(1); // Reserve a data location for saving the state stack ptr.
++ appendOp(URX_STO_SP, varLoc);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the two NOPs. Depending on what follows in the pattern, the
+@@ -557,26 +552,14 @@
+ // Two data slots are reserved, for saving the stack ptr and the input position.
+ {
+ fixLiterals();
+- int32_t dataLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize += 2;
+- int32_t op = URX_BUILD(URX_LA_START, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+ 2);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_JMP, fRXPat->fCompiledPat->size()+ 3);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_LA_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_BACKTRACK, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_NOP, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ int32_t dataLoc = allocateData(2);
++ appendOp(URX_LA_START, dataLoc);
++ appendOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+ 2);
++ appendOp(URX_JMP, fRXPat->fCompiledPat->size()+ 3);
++ appendOp(URX_LA_END, dataLoc);
++ appendOp(URX_BACKTRACK, 0);
++ appendOp(URX_NOP, 0);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the NOPs.
+@@ -601,16 +584,10 @@
+ // an alternate (transparent) region.
+ {
+ fixLiterals();
+- int32_t dataLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize += 2;
+- int32_t op = URX_BUILD(URX_LA_START, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_STATE_SAVE, 0); // dest address will be patched later.
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+-
+- op = URX_BUILD(URX_NOP, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ int32_t dataLoc = allocateData(2);
++ appendOp(URX_LA_START, dataLoc);
++ appendOp(URX_STATE_SAVE, 0); // dest address will be patched later.
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the StateSave and NOP.
+@@ -648,23 +625,19 @@
+ fixLiterals();
+
+ // Allocate data space
+- int32_t dataLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize += 4;
++ int32_t dataLoc = allocateData(4);
+
+ // Emit URX_LB_START
+- int32_t op = URX_BUILD(URX_LB_START, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LB_START, dataLoc);
+
+ // Emit URX_LB_CONT
+- op = URX_BUILD(URX_LB_CONT, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- fRXPat->fCompiledPat->addElement(0, *fStatus); // MinMatchLength. To be filled later.
+- fRXPat->fCompiledPat->addElement(0, *fStatus); // MaxMatchLength. To be filled later.
+-
+- // Emit the NOP
+- op = URX_BUILD(URX_NOP, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LB_CONT, dataLoc);
++ appendOp(URX_RESERVED_OP, 0); // MinMatchLength. To be filled later.
++ appendOp(URX_RESERVED_OP, 0); // MaxMatchLength. To be filled later.
++
++ // Emit the NOPs
++ appendOp(URX_NOP, 0);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the URX_LB_CONT and the NOP.
+@@ -704,24 +677,20 @@
+ fixLiterals();
+
+ // Allocate data space
+- int32_t dataLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize += 4;
++ int32_t dataLoc = allocateData(4);
+
+ // Emit URX_LB_START
+- int32_t op = URX_BUILD(URX_LB_START, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LB_START, dataLoc);
+
+ // Emit URX_LBN_CONT
+- op = URX_BUILD(URX_LBN_CONT, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- fRXPat->fCompiledPat->addElement(0, *fStatus); // MinMatchLength. To be filled later.
+- fRXPat->fCompiledPat->addElement(0, *fStatus); // MaxMatchLength. To be filled later.
+- fRXPat->fCompiledPat->addElement(0, *fStatus); // Continue Loc. To be filled later.
+-
+- // Emit the NOP
+- op = URX_BUILD(URX_NOP, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LBN_CONT, dataLoc);
++ appendOp(URX_RESERVED_OP, 0); // MinMatchLength. To be filled later.
++ appendOp(URX_RESERVED_OP, 0); // MaxMatchLength. To be filled later.
++ appendOp(URX_RESERVED_OP, 0); // Continue Loc. To be filled later.
++
++ // Emit the NOPs
++ appendOp(URX_NOP, 0);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the URX_LB_CONT and the NOP.
+@@ -791,12 +760,9 @@
+
+ if (URX_TYPE(repeatedOp) == URX_SETREF) {
+ // Emit optimized code for [char set]+
+- int32_t loopOpI = URX_BUILD(URX_LOOP_SR_I, URX_VAL(repeatedOp));
+- fRXPat->fCompiledPat->addElement(loopOpI, *fStatus);
+- frameLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
+- int32_t loopOpC = URX_BUILD(URX_LOOP_C, frameLoc);
+- fRXPat->fCompiledPat->addElement(loopOpC, *fStatus);
++ appendOp(URX_LOOP_SR_I, URX_VAL(repeatedOp));
++ frameLoc = allocateStackData(1);
++ appendOp(URX_LOOP_C, frameLoc);
+ break;
+ }
+
+@@ -804,7 +770,7 @@
+ URX_TYPE(repeatedOp) == URX_DOTANY_ALL ||
+ URX_TYPE(repeatedOp) == URX_DOTANY_UNIX) {
+ // Emit Optimized code for .+ operations.
+- int32_t loopOpI = URX_BUILD(URX_LOOP_DOT_I, 0);
++ int32_t loopOpI = buildOp(URX_LOOP_DOT_I, 0);
+ if (URX_TYPE(repeatedOp) == URX_DOTANY_ALL) {
+ // URX_LOOP_DOT_I operand is a flag indicating ". matches any" mode.
+ loopOpI |= 1;
+@@ -812,11 +778,9 @@
+ if (fModeFlags & UREGEX_UNIX_LINES) {
+ loopOpI |= 2;
+ }
+- fRXPat->fCompiledPat->addElement(loopOpI, *fStatus);
+- frameLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
+- int32_t loopOpC = URX_BUILD(URX_LOOP_C, frameLoc);
+- fRXPat->fCompiledPat->addElement(loopOpC, *fStatus);
++ appendOp(loopOpI);
++ frameLoc = allocateStackData(1);
++ appendOp(URX_LOOP_C, frameLoc);
+ break;
+ }
+
+@@ -830,18 +794,15 @@
+ // Zero length match is possible.
+ // Emit the code sequence that can handle it.
+ insertOp(topLoc);
+- frameLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
++ frameLoc = allocateStackData(1);
+
+- int32_t op = URX_BUILD(URX_STO_INP_LOC, frameLoc);
++ int32_t op = buildOp(URX_STO_INP_LOC, frameLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc);
+
+- op = URX_BUILD(URX_JMP_SAV_X, topLoc+1);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_JMP_SAV_X, topLoc+1);
+ } else {
+ // Simpler code when the repeated body must match something non-empty
+- int32_t jmpOp = URX_BUILD(URX_JMP_SAV, topLoc);
+- fRXPat->fCompiledPat->addElement(jmpOp, *fStatus);
++ appendOp(URX_JMP_SAV, topLoc);
+ }
+ }
+ break;
+@@ -853,8 +814,7 @@
+ // 3. ...
+ {
+ int32_t topLoc = blockTopLoc(FALSE);
+- int32_t saveStateOp = URX_BUILD(URX_STATE_SAVE, topLoc);
+- fRXPat->fCompiledPat->addElement(saveStateOp, *fStatus);
++ appendOp(URX_STATE_SAVE, topLoc);
+ }
+ break;
+
+@@ -868,7 +828,7 @@
+ // Insert the state save into the compiled pattern, and we're done.
+ {
+ int32_t saveStateLoc = blockTopLoc(TRUE);
+- int32_t saveStateOp = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size());
++ int32_t saveStateOp = buildOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size());
+ fRXPat->fCompiledPat->setElementAt(saveStateOp, saveStateLoc);
+ }
+ break;
+@@ -887,14 +847,12 @@
+ int32_t jmp1_loc = blockTopLoc(TRUE);
+ int32_t jmp2_loc = fRXPat->fCompiledPat->size();
+
+- int32_t jmp1_op = URX_BUILD(URX_JMP, jmp2_loc+1);
++ int32_t jmp1_op = buildOp(URX_JMP, jmp2_loc+1);
+ fRXPat->fCompiledPat->setElementAt(jmp1_op, jmp1_loc);
+
+- int32_t jmp2_op = URX_BUILD(URX_JMP, jmp2_loc+2);
+- fRXPat->fCompiledPat->addElement(jmp2_op, *fStatus);
++ appendOp(URX_JMP, jmp2_loc+2);
+
+- int32_t save_op = URX_BUILD(URX_STATE_SAVE, jmp1_loc+1);
+- fRXPat->fCompiledPat->addElement(save_op, *fStatus);
++ appendOp(URX_STATE_SAVE, jmp1_loc+1);
+ }
+ break;
+
+@@ -934,12 +892,10 @@
+
+ if (URX_TYPE(repeatedOp) == URX_SETREF) {
+ // Emit optimized code for a [char set]*
+- int32_t loopOpI = URX_BUILD(URX_LOOP_SR_I, URX_VAL(repeatedOp));
++ int32_t loopOpI = buildOp(URX_LOOP_SR_I, URX_VAL(repeatedOp));
+ fRXPat->fCompiledPat->setElementAt(loopOpI, topLoc);
+- dataLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
+- int32_t loopOpC = URX_BUILD(URX_LOOP_C, dataLoc);
+- fRXPat->fCompiledPat->addElement(loopOpC, *fStatus);
++ dataLoc = allocateStackData(1);
++ appendOp(URX_LOOP_C, dataLoc);
+ break;
+ }
+
+@@ -947,7 +903,7 @@
+ URX_TYPE(repeatedOp) == URX_DOTANY_ALL ||
+ URX_TYPE(repeatedOp) == URX_DOTANY_UNIX) {
+ // Emit Optimized code for .* operations.
+- int32_t loopOpI = URX_BUILD(URX_LOOP_DOT_I, 0);
++ int32_t loopOpI = buildOp(URX_LOOP_DOT_I, 0);
+ if (URX_TYPE(repeatedOp) == URX_DOTANY_ALL) {
+ // URX_LOOP_DOT_I operand is a flag indicating . matches any mode.
+ loopOpI |= 1;
+@@ -956,10 +912,8 @@
+ loopOpI |= 2;
+ }
+ fRXPat->fCompiledPat->setElementAt(loopOpI, topLoc);
+- dataLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
+- int32_t loopOpC = URX_BUILD(URX_LOOP_C, dataLoc);
+- fRXPat->fCompiledPat->addElement(loopOpC, *fStatus);
++ dataLoc = allocateStackData(1);
++ appendOp(URX_LOOP_C, dataLoc);
+ break;
+ }
+ }
+@@ -968,30 +922,29 @@
+ // The optimizations did not apply.
+
+ int32_t saveStateLoc = blockTopLoc(TRUE);
+- int32_t jmpOp = URX_BUILD(URX_JMP_SAV, saveStateLoc+1);
++ int32_t jmpOp = buildOp(URX_JMP_SAV, saveStateLoc+1);
+
+ // Check for minimum match length of zero, which requires
+ // extra loop-breaking code.
+ if (minMatchLength(saveStateLoc, fRXPat->fCompiledPat->size()-1) == 0) {
+ insertOp(saveStateLoc);
+- dataLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
++ dataLoc = allocateStackData(1);
+
+- int32_t op = URX_BUILD(URX_STO_INP_LOC, dataLoc);
++ int32_t op = buildOp(URX_STO_INP_LOC, dataLoc);
+ fRXPat->fCompiledPat->setElementAt(op, saveStateLoc+1);
+- jmpOp = URX_BUILD(URX_JMP_SAV_X, saveStateLoc+2);
++ jmpOp = buildOp(URX_JMP_SAV_X, saveStateLoc+2);
+ }
+
+ // Locate the position in the compiled pattern where the match will continue
+ // after completing the *. (4 or 5 in the comment above)
+ int32_t continueLoc = fRXPat->fCompiledPat->size()+1;
+
+- // Put together the save state op store it into the compiled code.
+- int32_t saveStateOp = URX_BUILD(URX_STATE_SAVE, continueLoc);
++ // Put together the save state op and store it into the compiled code.
++ int32_t saveStateOp = buildOp(URX_STATE_SAVE, continueLoc);
+ fRXPat->fCompiledPat->setElementAt(saveStateOp, saveStateLoc);
+
+ // Append the URX_JMP_SAV or URX_JMPX operation to the compiled pattern.
+- fRXPat->fCompiledPat->addElement(jmpOp, *fStatus);
++ appendOp(jmpOp);
+ }
+ break;
+
+@@ -1005,10 +958,9 @@
+ {
+ int32_t jmpLoc = blockTopLoc(TRUE); // loc 1.
+ int32_t saveLoc = fRXPat->fCompiledPat->size(); // loc 3.
+- int32_t jmpOp = URX_BUILD(URX_JMP, saveLoc);
+- int32_t stateSaveOp = URX_BUILD(URX_STATE_SAVE, jmpLoc+1);
++ int32_t jmpOp = buildOp(URX_JMP, saveLoc);
+ fRXPat->fCompiledPat->setElementAt(jmpOp, jmpLoc);
+- fRXPat->fCompiledPat->addElement(stateSaveOp, *fStatus);
++ appendOp(URX_STATE_SAVE, jmpLoc+1);
+ }
+ break;
+
+@@ -1077,9 +1029,9 @@
+
+ // First the STO_SP before the start of the loop
+ insertOp(topLoc);
+- int32_t varLoc = fRXPat->fDataSize; // Reserve a data location for saving the
+- fRXPat->fDataSize += 1; // state stack ptr.
+- int32_t op = URX_BUILD(URX_STO_SP, varLoc);
++
++ int32_t varLoc = allocateData(1); // Reserve a data location for saving the
++ int32_t op = buildOp(URX_STO_SP, varLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc);
+
+ int32_t loopOp = (int32_t)fRXPat->fCompiledPat->popi();
+@@ -1088,8 +1040,7 @@
+ fRXPat->fCompiledPat->push(loopOp, *fStatus);
+
+ // Then the LD_SP after the end of the loop
+- op = URX_BUILD(URX_LD_SP, varLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LD_SP, varLoc);
+ }
+
+ break;
+@@ -1125,55 +1076,49 @@
+ // scanned a ".", match any single character.
+ {
+ fixLiterals(FALSE);
+- int32_t op;
+ if (fModeFlags & UREGEX_DOTALL) {
+- op = URX_BUILD(URX_DOTANY_ALL, 0);
++ appendOp(URX_DOTANY_ALL, 0);
+ } else if (fModeFlags & UREGEX_UNIX_LINES) {
+- op = URX_BUILD(URX_DOTANY_UNIX, 0);
++ appendOp(URX_DOTANY_UNIX, 0);
+ } else {
+- op = URX_BUILD(URX_DOTANY, 0);
++ appendOp(URX_DOTANY, 0);
+ }
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+ }
+ break;
+
+ case doCaret:
+ {
+ fixLiterals(FALSE);
+- int32_t op = 0;
+ if ( (fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) {
+- op = URX_CARET;
++ appendOp(URX_CARET, 0);
+ } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) {
+- op = URX_CARET_M;
++ appendOp(URX_CARET_M, 0);
+ } else if ((fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) {
+- op = URX_CARET; // Only testing true start of input.
++ appendOp(URX_CARET, 0); // Only testing true start of input.
+ } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) {
+- op = URX_CARET_M_UNIX;
++ appendOp(URX_CARET_M_UNIX, 0);
+ }
+- fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus);
+ }
+ break;
+
+ case doDollar:
+ {
+ fixLiterals(FALSE);
+- int32_t op = 0;
+ if ( (fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) {
+- op = URX_DOLLAR;
++ appendOp(URX_DOLLAR, 0);
+ } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) {
+- op = URX_DOLLAR_M;
++ appendOp(URX_DOLLAR_M, 0);
+ } else if ((fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) {
+- op = URX_DOLLAR_D;
++ appendOp(URX_DOLLAR_D, 0);
+ } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) {
+- op = URX_DOLLAR_MD;
++ appendOp(URX_DOLLAR_MD, 0);
+ }
+- fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus);
+ }
+ break;
+
+ case doBackslashA:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_CARET, 0), *fStatus);
++ appendOp(URX_CARET, 0);
+ break;
+
+ case doBackslashB:
+@@ -1185,7 +1130,7 @@
+ #endif
+ fixLiterals(FALSE);
+ int32_t op = (fModeFlags & UREGEX_UWORD)? URX_BACKSLASH_BU : URX_BACKSLASH_B;
+- fRXPat->fCompiledPat->addElement(URX_BUILD(op, 1), *fStatus);
++ appendOp(op, 1);
+ }
+ break;
+
+@@ -1198,63 +1143,59 @@
+ #endif
+ fixLiterals(FALSE);
+ int32_t op = (fModeFlags & UREGEX_UWORD)? URX_BACKSLASH_BU : URX_BACKSLASH_B;
+- fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus);
++ appendOp(op, 0);
+ }
+ break;
+
+ case doBackslashD:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_D, 1), *fStatus);
++ appendOp(URX_BACKSLASH_D, 1);
+ break;
+
+ case doBackslashd:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_D, 0), *fStatus);
++ appendOp(URX_BACKSLASH_D, 0);
+ break;
+
+ case doBackslashG:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_G, 0), *fStatus);
++ appendOp(URX_BACKSLASH_G, 0);
+ break;
+
+ case doBackslashS:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(
+- URX_BUILD(URX_STAT_SETREF_N, URX_ISSPACE_SET), *fStatus);
++ appendOp(URX_STAT_SETREF_N, URX_ISSPACE_SET);
+ break;
+
+ case doBackslashs:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(
+- URX_BUILD(URX_STATIC_SETREF, URX_ISSPACE_SET), *fStatus);
++ appendOp(URX_STATIC_SETREF, URX_ISSPACE_SET);
+ break;
+
+ case doBackslashW:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(
+- URX_BUILD(URX_STAT_SETREF_N, URX_ISWORD_SET), *fStatus);
++ appendOp(URX_STAT_SETREF_N, URX_ISWORD_SET);
+ break;
+
+ case doBackslashw:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(
+- URX_BUILD(URX_STATIC_SETREF, URX_ISWORD_SET), *fStatus);
++ appendOp(URX_STATIC_SETREF, URX_ISWORD_SET);
+ break;
+
+ case doBackslashX:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_X, 0), *fStatus);
++ appendOp(URX_BACKSLASH_X, 0);
+ break;
+
+
+ case doBackslashZ:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_DOLLAR, 0), *fStatus);
++ appendOp(URX_DOLLAR, 0);
+ break;
+
+ case doBackslashz:
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_Z, 0), *fStatus);
++ appendOp(URX_BACKSLASH_Z, 0);
+ break;
+
+ case doEscapeError:
+@@ -1314,13 +1255,11 @@
+ U_ASSERT(groupNum > 0); // Shouldn't happen. '\0' begins an octal escape sequence,
+ // and shouldn't enter this code path at all.
+ fixLiterals(FALSE);
+- int32_t op;
+ if (fModeFlags & UREGEX_CASE_INSENSITIVE) {
+- op = URX_BUILD(URX_BACKREF_I, groupNum);
++ appendOp(URX_BACKREF_I, groupNum);
+ } else {
+- op = URX_BUILD(URX_BACKREF, groupNum);
++ appendOp(URX_BACKREF, groupNum);
+ }
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+ }
+ break;
+
+@@ -1341,22 +1280,18 @@
+ {
+ // Emit the STO_SP
+ int32_t topLoc = blockTopLoc(TRUE);
+- int32_t stoLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize++; // Reserve the data location for storing save stack ptr.
+- int32_t op = URX_BUILD(URX_STO_SP, stoLoc);
++ int32_t stoLoc = allocateData(1); // Reserve the data location for storing save stack ptr.
++ int32_t op = buildOp(URX_STO_SP, stoLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc);
+
+ // Emit the STATE_SAVE
+- op = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+2);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+2);
+
+ // Emit the JMP
+- op = URX_BUILD(URX_JMP, topLoc+1);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_JMP, topLoc+1);
+
+ // Emit the LD_SP
+- op = URX_BUILD(URX_LD_SP, stoLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LD_SP, stoLoc);
+ }
+ break;
+
+@@ -1376,23 +1311,20 @@
+ insertOp(topLoc);
+
+ // emit STO_SP loc
+- int32_t stoLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize++; // Reserve the data location for storing save stack ptr.
+- int32_t op = URX_BUILD(URX_STO_SP, stoLoc);
++ int32_t stoLoc = allocateData(1); // Reserve the data location for storing save stack ptr.
++ int32_t op = buildOp(URX_STO_SP, stoLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc);
+
+ // Emit the SAVE_STATE 5
+ int32_t L7 = fRXPat->fCompiledPat->size()+1;
+- op = URX_BUILD(URX_STATE_SAVE, L7);
++ op = buildOp(URX_STATE_SAVE, L7);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc+1);
+
+ // Append the JMP operation.
+- op = URX_BUILD(URX_JMP, topLoc+1);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_JMP, topLoc+1);
+
+ // Emit the LD_SP loc
+- op = URX_BUILD(URX_LD_SP, stoLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LD_SP, stoLoc);
+ }
+ break;
+
+@@ -1411,19 +1343,17 @@
+ insertOp(topLoc);
+
+ // Emit the STO_SP
+- int32_t stoLoc = fRXPat->fDataSize;
+- fRXPat->fDataSize++; // Reserve the data location for storing save stack ptr.
+- int32_t op = URX_BUILD(URX_STO_SP, stoLoc);
++ int32_t stoLoc = allocateData(1); // Reserve the data location for storing save stack ptr.
++ int32_t op = buildOp(URX_STO_SP, stoLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc);
+
+ // Emit the SAVE_STATE
+ int32_t continueLoc = fRXPat->fCompiledPat->size()+1;
+- op = URX_BUILD(URX_STATE_SAVE, continueLoc);
++ op = buildOp(URX_STATE_SAVE, continueLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topLoc+1);
+
+ // Emit the LD_SP
+- op = URX_BUILD(URX_LD_SP, stoLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LD_SP, stoLoc);
+ }
+ break;
+
+@@ -1480,8 +1410,8 @@
+ // is an '|' alternation within the parens.
+ {
+ fixLiterals(FALSE);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus);
++ appendOp(URX_NOP, 0);
++ appendOp(URX_NOP, 0);
+
+ // On the Parentheses stack, start a new frame and add the postions
+ // of the two NOPs (a normal non-capturing () frame, except for the
+@@ -1818,7 +1748,6 @@
+ //
+ //------------------------------------------------------------------------------
+ void RegexCompile::fixLiterals(UBool split) {
+- int32_t op = 0; // An op from/for the compiled pattern.
+
+ // If no literal characters have been scanned but not yet had code generated
+ // for them, nothing needs to be done.
+@@ -1857,23 +1786,23 @@
+ // Single character, emit a URX_ONECHAR op to match it.
+ if ((fModeFlags & UREGEX_CASE_INSENSITIVE) &&
+ u_hasBinaryProperty(lastCodePoint, UCHAR_CASE_SENSITIVE)) {
+- op = URX_BUILD(URX_ONECHAR_I, lastCodePoint);
++ appendOp(URX_ONECHAR_I, lastCodePoint);
+ } else {
+- op = URX_BUILD(URX_ONECHAR, lastCodePoint);
++ appendOp(URX_ONECHAR, lastCodePoint);
+ }
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+ } else {
+ // Two or more chars, emit a URX_STRING to match them.
++ if (fLiteralChars.length() > 0x00ffffff || fRXPat->fLiteralText.length() > 0x00ffffff) {
++ error(U_REGEX_PATTERN_TOO_BIG);
++ }
+ if (fModeFlags & UREGEX_CASE_INSENSITIVE) {
+- op = URX_BUILD(URX_STRING_I, fRXPat->fLiteralText.length());
++ appendOp(URX_STRING_I, fRXPat->fLiteralText.length());
+ } else {
+ // TODO here: add optimization to split case sensitive strings of length two
+ // into two single char ops, for efficiency.
+- op = URX_BUILD(URX_STRING, fRXPat->fLiteralText.length());
++ appendOp(URX_STRING, fRXPat->fLiteralText.length());
+ }
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- op = URX_BUILD(URX_STRING_LEN, fLiteralChars.length());
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_STRING_LEN, fLiteralChars.length());
+
+ // Add this string into the accumulated strings of the compiled pattern.
+ fRXPat->fLiteralText.append(fLiteralChars);
+@@ -1883,8 +1812,58 @@
+ }
+
+
++int32_t RegexCompile::buildOp(int32_t type, int32_t val) {
++ if (U_FAILURE(*fStatus)) {
++ return 0;
++ }
++ if (type < 0 || type > 255) {
++ U_ASSERT(FALSE);
++ error(U_REGEX_INTERNAL_ERROR);
++ type = URX_RESERVED_OP;
++ }
++ if (val > 0x00ffffff) {
++ U_ASSERT(FALSE);
++ error(U_REGEX_INTERNAL_ERROR);
++ val = 0;
++ }
++ if (val < 0) {
++ if (!(type == URX_RESERVED_OP_N || type == URX_RESERVED_OP)) {
++ U_ASSERT(FALSE);
++ error(U_REGEX_INTERNAL_ERROR);
++ return -1;
++ }
++ if (URX_TYPE(val) != 0xff) {
++ U_ASSERT(FALSE);
++ error(U_REGEX_INTERNAL_ERROR);
++ return -1;
++ }
++ type = URX_RESERVED_OP_N;
++ }
++ return (type << 24) | val;
++}
++
+
++//------------------------------------------------------------------------------
++//
++// appendOp() Append a new instruction onto the compiled pattern
++// Includes error checking, limiting the size of the
++// pattern to lengths that can be represented in the
++// 24 bit operand field of an instruction.
++//
++//------------------------------------------------------------------------------
++void RegexCompile::appendOp(int32_t op) {
++ if (U_FAILURE(*fStatus)) {
++ return;
++ }
++ fRXPat->fCompiledPat->addElement(op, *fStatus);
++ if ((fRXPat->fCompiledPat->size() > 0x00fffff0) && U_SUCCESS(*fStatus)) {
++ error(U_REGEX_PATTERN_TOO_BIG);
++ }
++}
+
++void RegexCompile::appendOp(int32_t type, int32_t val) {
++ appendOp(buildOp(type, val));
++}
+
+
+ //------------------------------------------------------------------------------
+@@ -1900,7 +1879,7 @@
+ UVector64 *code = fRXPat->fCompiledPat;
+ U_ASSERT(where>0 && where < code->size());
+
+- int32_t nop = URX_BUILD(URX_NOP, 0);
++ int32_t nop = buildOp(URX_NOP, 0);
+ code->insertElementAt(nop, where, *fStatus);
+
+ // Walk through the pattern, looking for any ops with targets that
+@@ -1921,7 +1900,7 @@
+ // Target location for this opcode is after the insertion point and
+ // needs to be incremented to adjust for the insertion.
+ opValue++;
+- op = URX_BUILD(opType, opValue);
++ op = buildOp(opType, opValue);
+ code->setElementAt(op, loc);
+ }
+ }
+@@ -1946,6 +1925,58 @@
+ }
+
+
++//------------------------------------------------------------------------------
++//
++// allocateData() Allocate storage in the matcher's static data area.
++// Return the index for the newly allocated data.
++// The storage won't actually exist until we are running a match
++// operation, but the storage indexes are inserted into various
++// opcodes while compiling the pattern.
++//
++//------------------------------------------------------------------------------
++int32_t RegexCompile::allocateData(int32_t size) {
++ if (U_FAILURE(*fStatus)) {
++ return 0;
++ }
++ if (size <= 0 || size > 0x100 || fRXPat->fDataSize < 0) {
++ error(U_REGEX_INTERNAL_ERROR);
++ return 0;
++ }
++ int32_t dataIndex = fRXPat->fDataSize;
++ fRXPat->fDataSize += size;
++ if (fRXPat->fDataSize >= 0x00fffff0) {
++ error(U_REGEX_INTERNAL_ERROR);
++ }
++ return dataIndex;
++}
++
++
++//------------------------------------------------------------------------------
++//
++// allocateStackData() Allocate space in the back-tracking stack frame.
++// Return the index for the newly allocated data.
++// The frame indexes are inserted into various
++// opcodes while compiling the pattern, meaning that frame
++// size must be restricted to the size that will fit
++// as an operand (24 bits).
++//
++//------------------------------------------------------------------------------
++int32_t RegexCompile::allocateStackData(int32_t size) {
++ if (U_FAILURE(*fStatus)) {
++ return 0;
++ }
++ if (size <= 0 || size > 0x100 || fRXPat->fFrameSize < 0) {
++ error(U_REGEX_INTERNAL_ERROR);
++ return 0;
++ }
++ int32_t dataIndex = fRXPat->fFrameSize;
++ fRXPat->fFrameSize += size;
++ if (fRXPat->fFrameSize >= 0x00fffff0) {
++ error(U_REGEX_PATTERN_TOO_BIG);
++ }
++ return dataIndex;
++}
++
+
+ //------------------------------------------------------------------------------
+ //
+@@ -1988,7 +2019,7 @@
+ theLoc--;
+ }
+ if (reserveLoc) {
+- int32_t nop = URX_BUILD(URX_NOP, 0);
++ int32_t nop = buildOp(URX_NOP, 0);
+ fRXPat->fCompiledPat->insertElementAt(nop, theLoc, *fStatus);
+ }
+ }
+@@ -2063,8 +2094,7 @@
+ U_ASSERT(URX_TYPE(captureOp) == URX_START_CAPTURE);
+
+ int32_t frameVarLocation = URX_VAL(captureOp);
+- int32_t endCaptureOp = URX_BUILD(URX_END_CAPTURE, frameVarLocation);
+- fRXPat->fCompiledPat->addElement(endCaptureOp, *fStatus);
++ appendOp(URX_END_CAPTURE, frameVarLocation);
+ }
+ break;
+ case atomic:
+@@ -2075,8 +2105,7 @@
+ int32_t stoOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen+1);
+ U_ASSERT(URX_TYPE(stoOp) == URX_STO_SP);
+ int32_t stoLoc = URX_VAL(stoOp);
+- int32_t ldOp = URX_BUILD(URX_LD_SP, stoLoc);
+- fRXPat->fCompiledPat->addElement(ldOp, *fStatus);
++ appendOp(URX_LD_SP, stoLoc);
+ }
+ break;
+
+@@ -2085,8 +2114,7 @@
+ int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-5);
+ U_ASSERT(URX_TYPE(startOp) == URX_LA_START);
+ int32_t dataLoc = URX_VAL(startOp);
+- int32_t op = URX_BUILD(URX_LA_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LA_END, dataLoc);
+ }
+ break;
+
+@@ -2096,19 +2124,16 @@
+ int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-1);
+ U_ASSERT(URX_TYPE(startOp) == URX_LA_START);
+ int32_t dataLoc = URX_VAL(startOp);
+- int32_t op = URX_BUILD(URX_LA_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- op = URX_BUILD(URX_BACKTRACK, 0);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- op = URX_BUILD(URX_LA_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LA_END, dataLoc);
++ appendOp(URX_BACKTRACK, 0);
++ appendOp(URX_LA_END, dataLoc);
+
+ // Patch the URX_SAVE near the top of the block.
+ // The destination of the SAVE is the final LA_END that was just added.
+ int32_t saveOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen);
+ U_ASSERT(URX_TYPE(saveOp) == URX_STATE_SAVE);
+ int32_t dest = fRXPat->fCompiledPat->size()-1;
+- saveOp = URX_BUILD(URX_STATE_SAVE, dest);
++ saveOp = buildOp(URX_STATE_SAVE, dest);
+ fRXPat->fCompiledPat->setElementAt(saveOp, fMatchOpenParen);
+ }
+ break;
+@@ -2121,10 +2146,8 @@
+ int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-4);
+ U_ASSERT(URX_TYPE(startOp) == URX_LB_START);
+ int32_t dataLoc = URX_VAL(startOp);
+- int32_t op = URX_BUILD(URX_LB_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
+- op = URX_BUILD(URX_LA_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LB_END, dataLoc);
++ appendOp(URX_LA_END, dataLoc);
+
+ // Determine the min and max bounds for the length of the
+ // string that the pattern can match.
+@@ -2160,8 +2183,7 @@
+ int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-5);
+ U_ASSERT(URX_TYPE(startOp) == URX_LB_START);
+ int32_t dataLoc = URX_VAL(startOp);
+- int32_t op = URX_BUILD(URX_LBN_END, dataLoc);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(URX_LBN_END, dataLoc);
+
+ // Determine the min and max bounds for the length of the
+ // string that the pattern can match.
+@@ -2186,7 +2208,7 @@
+
+ // Insert the pattern location to continue at after a successful match
+ // as the last operand of the URX_LBN_CONT
+- op = URX_BUILD(URX_RELOC_OPRND, fRXPat->fCompiledPat->size());
++ int32_t op = buildOp(URX_RELOC_OPRND, fRXPat->fCompiledPat->size());
+ fRXPat->fCompiledPat->setElementAt(op, fMatchOpenParen-1);
+ }
+ break;
+@@ -2227,7 +2249,7 @@
+ case 0:
+ {
+ // Set of no elements. Always fails to match.
+- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKTRACK, 0), *fStatus);
++ appendOp(URX_BACKTRACK, 0);
+ delete theSet;
+ }
+ break;
+@@ -2248,8 +2270,7 @@
+ // Put it into the compiled pattern as a set.
+ int32_t setNumber = fRXPat->fSets->size();
+ fRXPat->fSets->addElement(theSet, *fStatus);
+- int32_t setOp = URX_BUILD(URX_SETREF, setNumber);
+- fRXPat->fCompiledPat->addElement(setOp, *fStatus);
++ appendOp(URX_SETREF, setNumber);
+ }
+ }
+ }
+@@ -2288,13 +2309,10 @@
+ // counterLoc --> Loop counter
+ // +1 --> Input index (for breaking non-progressing loops)
+ // (Only present if unbounded upper limit on loop)
+- int32_t counterLoc = fRXPat->fFrameSize;
+- fRXPat->fFrameSize++;
+- if (fIntervalUpper < 0) {
+- fRXPat->fFrameSize++;
+- }
++ int32_t dataSize = fIntervalUpper < 0 ? 2 : 1;
++ int32_t counterLoc = allocateStackData(dataSize);
+
+- int32_t op = URX_BUILD(InitOp, counterLoc);
++ int32_t op = buildOp(InitOp, counterLoc);
+ fRXPat->fCompiledPat->setElementAt(op, topOfBlock);
+
+ // The second operand of CTR_INIT is the location following the end of the loop.
+@@ -2302,7 +2320,7 @@
+ // compilation of something later on causes the code to grow and the target
+ // position to move.
+ int32_t loopEnd = fRXPat->fCompiledPat->size();
+- op = URX_BUILD(URX_RELOC_OPRND, loopEnd);
++ op = buildOp(URX_RELOC_OPRND, loopEnd);
+ fRXPat->fCompiledPat->setElementAt(op, topOfBlock+1);
+
+ // Followed by the min and max counts.
+@@ -2311,8 +2329,7 @@
+
+ // Apend the CTR_LOOP op. The operand is the location of the CTR_INIT op.
+ // Goes at end of the block being looped over, so just append to the code so far.
+- op = URX_BUILD(LoopOp, topOfBlock);
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(LoopOp, topOfBlock);
+
+ if ((fIntervalLow & 0xff000000) != 0 ||
+ (fIntervalUpper > 0 && (fIntervalUpper & 0xff000000) != 0)) {
+@@ -2365,7 +2382,7 @@
+ //
+ int32_t endOfSequenceLoc = fRXPat->fCompiledPat->size()-1
+ + fIntervalUpper + (fIntervalUpper-fIntervalLow);
+- int32_t saveOp = URX_BUILD(URX_STATE_SAVE, endOfSequenceLoc);
++ int32_t saveOp = buildOp(URX_STATE_SAVE, endOfSequenceLoc);
+ if (fIntervalLow == 0) {
+ insertOp(topOfBlock);
+ fRXPat->fCompiledPat->setElementAt(saveOp, topOfBlock);
+@@ -2378,13 +2395,10 @@
+ // it was put there when it was originally encountered.
+ int32_t i;
+ for (i=1; i<fIntervalUpper; i++ ) {
+- if (i == fIntervalLow) {
+- fRXPat->fCompiledPat->addElement(saveOp, *fStatus);
+- }
+- if (i > fIntervalLow) {
+- fRXPat->fCompiledPat->addElement(saveOp, *fStatus);
++ if (i >= fIntervalLow) {
++ appendOp(saveOp);
+ }
+- fRXPat->fCompiledPat->addElement(op, *fStatus);
++ appendOp(op);
+ }
+ return TRUE;
+ }
+@@ -3603,7 +3617,7 @@
+ int32_t operandAddress = URX_VAL(op);
+ U_ASSERT(operandAddress>=0 && operandAddress<deltas.size());
+ int32_t fixedOperandAddress = operandAddress - deltas.elementAti(operandAddress);
+- op = URX_BUILD(opType, fixedOperandAddress);
++ op = buildOp(opType, fixedOperandAddress);
+ fRXPat->fCompiledPat->setElementAt(op, dst);
+ dst++;
+ break;
+@@ -3618,7 +3632,7 @@
+ break;
+ }
+ where = fRXPat->fGroupMap->elementAti(where-1);
+- op = URX_BUILD(opType, where);
++ op = buildOp(opType, where);
+ fRXPat->fCompiledPat->setElementAt(op, dst);
+ dst++;
+
+@@ -3970,7 +3984,7 @@
+ //------------------------------------------------------------------------------
+ //
+ // scanNamedChar
+- // Get a UChar32 from a \N{UNICODE CHARACTER NAME} in the pattern.
++// Get a UChar32 from a \N{UNICODE CHARACTER NAME} in the pattern.
+ //
+ // The scan position will be at the 'N'. On return
+ // the scan position should be just after the '}'
+diff -ru icu/source/i18n/regexcmp.h icu/source/i18n/regexcmp.h
+--- icu/source/i18n/regexcmp.h 2015-04-10 15:27:31.370772856 +0200
++++ icu/source/i18n/regexcmp.h 2015-04-10 15:28:06.152993511 +0200
+@@ -104,6 +104,13 @@
+ void fixLiterals(UBool split=FALSE); // Generate code for pending literal characters.
+ void insertOp(int32_t where); // Open up a slot for a new op in the
+ // generated code at the specified location.
++ void appendOp(int32_t op); // Append a new op to the compiled pattern.
++ void appendOp(int32_t type, int32_t val); // Build & append a new op to the compiled pattern.
++ int32_t buildOp(int32_t type, int32_t val); // Construct a new pcode instruction.
++ int32_t allocateData(int32_t size); // Allocate space in the matcher data area.
++ // Return index of the newly allocated data.
++ int32_t allocateStackData(int32_t size); // Allocate space in the match back-track stack frame.
++ // Return offset index in the frame.
+ int32_t minMatchLength(int32_t start,
+ int32_t end);
+ int32_t maxMatchLength(int32_t start,
+diff -ru icu/source/i18n/regeximp.h icu/source/i18n/regeximp.h
+--- icu/source/i18n/regeximp.h 2014-10-03 18:10:44.000000000 +0200
++++ icu/source/i18n/regeximp.h 2015-04-10 15:28:06.153993517 +0200
+@@ -1,5 +1,5 @@
+ //
+-// Copyright (C) 2002-2013 International Business Machines Corporation
++// Copyright (C) 2002-2014 International Business Machines Corporation
+ // and others. All rights reserved.
+ //
+ // file: regeximp.h
+@@ -241,7 +241,6 @@
+ //
+ // Convenience macros for assembling and disassembling a compiled operation.
+ //
+-#define URX_BUILD(type, val) (int32_t)((type << 24) | (val))
+ #define URX_TYPE(x) ((uint32_t)(x) >> 24)
+ #define URX_VAL(x) ((x) & 0xffffff)
+
+diff -ru icu/source/test/intltest/regextst.cpp icu/source/test/intltest/regextst.cpp
+--- icu/source/test/intltest/regextst.cpp 2014-10-03 18:09:44.000000000 +0200
++++ icu/source/test/intltest/regextst.cpp 2015-04-10 15:28:06.154993523 +0200
+@@ -144,6 +144,9 @@
+ case 24: name = "TestBug11049";
+ if (exec) TestBug11049();
+ break;
++ case 25: name = "TestBug11371";
++ if (exec) TestBug11371();
++ break;
+ default: name = "";
+ break; //needed to end loop
+ }
+@@ -5367,6 +5370,49 @@
+ }
+
+
++void RegexTest::TestBug11371() {
++ if (quick) {
++ logln("Skipping test. Runs in exhuastive mode only.");
++ return;
++ }
++ UErrorCode status = U_ZERO_ERROR;
++ UnicodeString patternString;
++
++ for (int i=0; i<8000000; i++) {
++ patternString.append(UnicodeString("()"));
++ }
++ LocalPointer<RegexPattern> compiledPat(RegexPattern::compile(patternString, 0, status));
++ if (status != U_REGEX_PATTERN_TOO_BIG) {
++ errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
++ __FILE__, __LINE__, u_errorName(status));
++ }
++
++ status = U_ZERO_ERROR;
++ patternString = "(";
++ for (int i=0; i<20000000; i++) {
++ patternString.append(UnicodeString("A++"));
++ }
++ patternString.append(UnicodeString("){0}B++"));
++ LocalPointer<RegexPattern> compiledPat2(RegexPattern::compile(patternString, 0, status));
++ if (status != U_REGEX_PATTERN_TOO_BIG) {
++ errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
++ __FILE__, __LINE__, u_errorName(status));
++ }
++
++ // Pattern with too much string data, such that string indexes overflow operand data field size
++ // in compiled instruction.
++ status = U_ZERO_ERROR;
++ patternString = "";
++ while (patternString.length() < 0x00ffffff) {
++ patternString.append(UnicodeString("stuff and things dont you know, these are a few of my favorite strings\n"));
++ }
++ patternString.append(UnicodeString("X? trailing string"));
++ LocalPointer<RegexPattern> compiledPat3(RegexPattern::compile(patternString, 0, status));
++ if (status != U_REGEX_PATTERN_TOO_BIG) {
++ errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
++ __FILE__, __LINE__, u_errorName(status));
++ }
++}
+
+ #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
+
+diff -ru icu/source/test/intltest/regextst.h icu/source/test/intltest/regextst.h
+--- icu/source/test/intltest/regextst.h 2014-10-03 18:09:40.000000000 +0200
++++ icu/source/test/intltest/regextst.h 2015-04-10 15:28:06.154993523 +0200
+@@ -50,6 +50,7 @@
+ virtual void Bug10459();
+ virtual void TestCaseInsensitiveStarters();
+ virtual void TestBug11049();
++ virtual void TestBug11371();
+
+ // The following functions are internal to the regexp tests.
+ virtual void assertUText(const char *expected, UText *actual, const char *file, int line);
diff --git a/external/icu/icu4c-changeset-39671.patch.1 b/external/icu/icu4c-changeset-39671.patch.1
deleted file mode 100644
index b8ac1385364e..000000000000
--- a/external/icu/icu4c-changeset-39671.patch.1
+++ /dev/null
@@ -1,189 +0,0 @@
-diff -ur icu.org/source/common/utext.cpp icu/source/common/utext.cpp
---- icu.org/source/common/utext.cpp 2016-06-15 20:58:17.000000000 +0200
-+++ icu/source/common/utext.cpp 2017-04-21 16:38:15.993398034 +0200
-@@ -847,9 +847,15 @@
- //------------------------------------------------------------------------------
-
- // Chunk size.
--// Must be less than 85, because of byte mapping from UChar indexes to native indexes.
--// Worst case is three native bytes to one UChar. (Supplemenaries are 4 native bytes
--// to two UChars.)
-+// Must be less than 42 (256/6), because of byte mapping from UChar indexes to native indexes.
-+// Worst case there are six UTF-8 bytes per UChar.
-+// obsolete 6 byte form fd + 5 trails maps to fffd
-+// obsolete 5 byte form fc + 4 trails maps to fffd
-+// non-shortest 4 byte forms maps to fffd
-+// normal supplementaries map to a pair of utf-16, two utf8 bytes per utf-16 unit
-+// mapToUChars array size must allow for the worst case, 6.
-+// This could be brought down to 4, by treating fd and fc as pure illegal,
-+// rather than obsolete lead bytes. But that is not compatible with the utf-8 access macros.
- //
- enum { UTF8_TEXT_CHUNK_SIZE=32 };
-
-@@ -867,6 +873,15 @@
- // pair. Doing this is simpler than checking for the edge case.
- //
-
-+// erAck: older MSVC used on libreoffice-5-3 and 5-2 bails out with
-+// error C2070: 'unknown': illegal sizeof operand
-+// for sizeof(UTF8Buf::mapToUChars)
-+// so have an ugly workaround:
-+// First define a macro of the original size expression, so a follow-up patch
-+// on the original code would fail..
-+#define UGLY_MAPTOUCHARS_SIZE (UTF8_TEXT_CHUNK_SIZE*6+6)
-+#define UGLY_SIZEOF_MAPTOUCHARS (sizeof(uint8_t)*(UGLY_MAPTOUCHARS_SIZE))
-+
- struct UTF8Buf {
- int32_t bufNativeStart; // Native index of first char in UChar buf
- int32_t bufNativeLimit; // Native index following last char in buf.
-@@ -889,7 +904,7 @@
- // Requires two extra slots,
- // one for a supplementary starting in the last normal position,
- // and one for an entry for the buffer limit position.
-- uint8_t mapToUChars[UTF8_TEXT_CHUNK_SIZE*3+6]; // Map native offset from bufNativeStart to
-+ uint8_t mapToUChars[UGLY_MAPTOUCHARS_SIZE]; // Map native offset from bufNativeStart to
- // correspoding offset in filled part of buf.
- int32_t align;
- };
-@@ -1032,6 +1047,7 @@
- // Requested index is in this buffer.
- u8b = (UTF8Buf *)ut->p; // the current buffer
- mapIndex = ix - u8b->toUCharsMapStart;
-+ U_ASSERT(mapIndex < (int32_t)UGLY_SIZEOF_MAPTOUCHARS);
- ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
- return TRUE;
-
-@@ -1298,6 +1314,10 @@
- // Can only do this if the incoming index is somewhere in the interior of the string.
- // If index is at the end, there is no character there to look at.
- if (ix != ut->b) {
-+ // Note: this function will only move the index back if it is on a trail byte
-+ // and there is a preceding lead byte and the sequence from the lead
-+ // through this trail could be part of a valid UTF-8 sequence
-+ // Otherwise the index remains unchanged.
- U8_SET_CP_START(s8, 0, ix);
- }
-
-@@ -1311,7 +1331,10 @@
- UChar *buf = u8b->buf;
- uint8_t *mapToNative = u8b->mapToNative;
- uint8_t *mapToUChars = u8b->mapToUChars;
-- int32_t toUCharsMapStart = ix - (UTF8_TEXT_CHUNK_SIZE*3 + 1);
-+ int32_t toUCharsMapStart = ix - UGLY_SIZEOF_MAPTOUCHARS + 1;
-+ // Note that toUCharsMapStart can be negative. Happens when the remaining
-+ // text from current position to the beginning is less than the buffer size.
-+ // + 1 because mapToUChars must have a slot at the end for the bufNativeLimit entry.
- int32_t destIx = UTF8_TEXT_CHUNK_SIZE+2; // Start in the overflow region
- // at end of buffer to leave room
- // for a surrogate pair at the
-@@ -1338,6 +1361,7 @@
- if (c<0x80) {
- // Special case ASCII range for speed.
- buf[destIx] = (UChar)c;
-+ U_ASSERT(toUCharsMapStart <= srcIx);
- mapToUChars[srcIx - toUCharsMapStart] = (uint8_t)destIx;
- mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart);
- } else {
-@@ -1367,6 +1391,7 @@
- do {
- mapToUChars[sIx-- - toUCharsMapStart] = (uint8_t)destIx;
- } while (sIx >= srcIx);
-+ U_ASSERT(toUCharsMapStart <= (srcIx+1));
-
- // Set native indexing limit to be the current position.
- // We are processing a non-ascii, non-native-indexing char now;
-@@ -1541,6 +1566,7 @@
- U_ASSERT(index>=ut->chunkNativeStart+ut->nativeIndexingLimit);
- U_ASSERT(index<=ut->chunkNativeLimit);
- int32_t mapIndex = index - u8b->toUCharsMapStart;
-+ U_ASSERT(mapIndex < (int32_t)UGLY_SIZEOF_MAPTOUCHARS);
- int32_t offset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
- U_ASSERT(offset>=0 && offset<=ut->chunkLength);
- return offset;
-diff -ur icu.org/source/test/intltest/utxttest.cpp icu/source/test/intltest/utxttest.cpp
---- icu.org/source/test/intltest/utxttest.cpp 2016-06-15 20:58:17.000000000 +0200
-+++ icu/source/test/intltest/utxttest.cpp 2017-04-21 16:14:57.383814739 +0200
-@@ -67,6 +67,8 @@
- if (exec) Ticket10983(); break;
- case 7: name = "Ticket12130";
- if (exec) Ticket12130(); break;
-+ case 8: name = "Ticket12888";
-+ if (exec) Ticket12888(); break;
- default: name = ""; break;
- }
- }
-@@ -1583,3 +1585,63 @@
- }
- utext_close(&ut);
- }
-+
-+// Ticket 12888: bad handling of illegal utf-8 containing many instances of the archaic, now illegal,
-+// six byte utf-8 forms. Original implementation had an assumption that
-+// there would be at most three utf-8 bytes per UTF-16 code unit.
-+// The five and six byte sequences map to a single replacement character.
-+
-+void UTextTest::Ticket12888() {
-+ const char *badString =
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80"
-+ "\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80\xfd\x80\x80\x80\x80\x80";
-+
-+ UErrorCode status = U_ZERO_ERROR;
-+ LocalUTextPointer ut(utext_openUTF8(NULL, badString, -1, &status));
-+ TEST_SUCCESS(status);
-+ for (;;) {
-+ UChar32 c = utext_next32(ut.getAlias());
-+ if (c == U_SENTINEL) {
-+ break;
-+ }
-+ }
-+ int32_t endIdx = utext_getNativeIndex(ut.getAlias());
-+ if (endIdx != (int32_t)strlen(badString)) {
-+ errln("%s:%d expected=%d, actual=%d", __FILE__, __LINE__, strlen(badString), endIdx);
-+ return;
-+ }
-+
-+ for (int32_t prevIndex = endIdx; prevIndex>0;) {
-+ UChar32 c = utext_previous32(ut.getAlias());
-+ int32_t currentIndex = utext_getNativeIndex(ut.getAlias());
-+ if (c != 0xfffd) {
-+ errln("%s:%d (expected, actual, index) = (%d, %d, %d)\n",
-+ __FILE__, __LINE__, 0xfffd, c, currentIndex);
-+ break;
-+ }
-+ if (currentIndex != prevIndex - 6) {
-+ errln("%s:%d: wrong index. Expected, actual = %d, %d",
-+ __FILE__, __LINE__, prevIndex - 6, currentIndex);
-+ break;
-+ }
-+ prevIndex = currentIndex;
-+ }
-+}
-diff -ur icu.org/source/test/intltest/utxttest.h icu/source/test/intltest/utxttest.h
---- icu.org/source/test/intltest/utxttest.h 2016-06-15 20:58:17.000000000 +0200
-+++ icu/source/test/intltest/utxttest.h 2017-04-21 16:14:57.383814739 +0200
-@@ -38,6 +38,7 @@
- void Ticket10562();
- void Ticket10983();
- void Ticket12130();
-+ void Ticket12888();
-
- private:
- struct m { // Map between native indices & code points.
diff --git a/external/icu/icu4c-emscripten.patch.1 b/external/icu/icu4c-emscripten.patch.1
deleted file mode 100644
index 3ce6d527b5cd..000000000000
--- a/external/icu/icu4c-emscripten.patch.1
+++ /dev/null
@@ -1,116 +0,0 @@
---- icu.org/source/config/mh-unknown 2015-10-06 11:35:03.212459286 +0200
-+++ icu/source/config/mh-unknown 2015-10-06 12:01:00.497972406 +0200
-@@ -1,27 +1,90 @@
- ## -*-makefile-*-
--## Copyright (c) 2003, International Business Machines Corporation and
-+## Emscripten-specific setup
-+## Copyright (c) 1999-2013, International Business Machines Corporation and
- ## others. All Rights Reserved.
--##
-
--# Note, this is not a real mh- file. You got here because configure
--# (specifically, aclocal.m4) could not determine a suitable mh- file.
--#
--# Perhaps your platform wasn't detected- try changing aclocal.m4 and
--# re-running autoconf.
--#
--# If your platform is truly new/different:
--# As a start, try copying mh-linux (which is fairly generic) over this
--# file, and re-run config.status.
--
--%.$(STATIC_O) %.o %.$(STATIC_O) %.o ../data/%.o %.d %.d %.$(SO).$(SO_TARGET_VERSION_MAJOR) %.$(SO):
-- @echo
-- @echo
-- @echo "*** ERROR - configure could not detect your platform"
-- @echo "*** see the readme.html"
-- @echo "*** or, try copying icu/source/config/mh-linux to mh-unknown"
-- @echo "*** and editing it."
-- @echo
-- @echo
-- exit 1
-+## Commands to generate dependency files
-+GEN_DEPS.c= $(CC) -E -MM $(DEFS) $(CPPFLAGS)
-+GEN_DEPS.cc= $(CXX) -E -MM $(DEFS) $(CPPFLAGS) $(CXXFLAGS)
-
-+## Flags for position independent code
-+SHAREDLIBCFLAGS = -fPIC
-+SHAREDLIBCXXFLAGS = -fPIC
-+SHAREDLIBCPPFLAGS = -DPIC
-
-+## Additional flags when building libraries and with threads
-+THREADSCPPFLAGS = -D_REENTRANT
-+LIBCPPFLAGS =
-+
-+## Compiler switch to embed a runtime search path
-+LD_RPATH= -Wl,-zorigin,-rpath,'$$'ORIGIN
-+LD_RPATH_PRE = -Wl,-rpath,
-+
-+## Force RPATH=$ORIGIN to locate own dependencies w/o need for LD_LIBRARY_PATH:
-+ENABLE_RPATH=YES
-+RPATHLDFLAGS=${LD_RPATH_PRE}'$$ORIGIN'
-+
-+## These are the library specific LDFLAGS
-+#LDFLAGSICUDT=-nodefaultlibs -nostdlib
-+# Debian change: linking icudata as data only causes too many problems.
-+LDFLAGSICUDT=
-+
-+## Compiler switch to embed a library name
-+# The initial tab in the next line is to prevent icu-config from reading it.
-+ LD_SONAME = -Wl,-soname -Wl,$(notdir $(MIDDLE_SO_TARGET))
-+#SH# # We can't depend on MIDDLE_SO_TARGET being set.
-+#SH# LD_SONAME=
-+
-+## Shared library options
-+LD_SOOPTIONS= -Wl,-Bsymbolic-functions
-+
-+## Shared object suffix
-+SO = so
-+## Non-shared intermediate object suffix
-+STATIC_O = ao
-+
-+## Compilation rules
-+%.$(STATIC_O): $(srcdir)/%.c
-+ $(call SILENT_COMPILE,$(strip $(COMPILE.c) $(STATICCPPFLAGS) $(STATICCFLAGS)) -o $@ $<)
-+%.o: $(srcdir)/%.c
-+ $(call SILENT_COMPILE,$(strip $(COMPILE.c) $(DYNAMICCPPFLAGS) $(DYNAMICCFLAGS)) -o $@ $<)
-+
-+%.$(STATIC_O): $(srcdir)/%.cpp
-+ $(call SILENT_COMPILE,$(strip $(COMPILE.cc) $(STATICCPPFLAGS) $(STATICCXXFLAGS)) -o $@ $<)
-+%.o: $(srcdir)/%.cpp
-+ $(call SILENT_COMPILE,$(strip $(COMPILE.cc) $(DYNAMICCPPFLAGS) $(DYNAMICCXXFLAGS)) -o $@ $<)
-+
-+
-+## Dependency rules
-+%.d: $(srcdir)/%.c
-+ $(call ICU_MSG,(deps)) $<
-+ @$(SHELL) -ec '$(GEN_DEPS.c) $< \
-+ | sed '\''s%\($*\)\.o[ :]*%\1.o $@ : %g'\'' > $@; \
-+ [ -s $@ ] || rm -f $@'
-+
-+%.d: $(srcdir)/%.cpp
-+ $(call ICU_MSG,(deps)) $<
-+ @$(SHELL) -ec '$(GEN_DEPS.cc) $< \
-+ | sed '\''s%\($*\)\.o[ :]*%\1.o $@ : %g'\'' > $@; \
-+ [ -s $@ ] || rm -f $@'
-+
-+## Versioned libraries rules
-+
-+%.$(SO).$(SO_TARGET_VERSION_MAJOR): %.$(SO).$(SO_TARGET_VERSION)
-+ $(RM) $@ && ln -s ${<F} $@
-+%.$(SO): %.$(SO).$(SO_TARGET_VERSION_MAJOR)
-+ $(RM) $@ && ln -s ${*F}.$(SO).$(SO_TARGET_VERSION) $@
-+
-+## Bind internal references
-+
-+# LDflags that pkgdata will use
-+BIR_LDFLAGS= -Wl,-Bsymbolic
-+
-+# Dependencies [i.e. map files] for the final library
-+BIR_DEPS=
-+
-+## Remove shared library 's'
-+STATIC_PREFIX_WHEN_USED =
-+STATIC_PREFIX =
-+
-+## End Linux-specific setup
-
diff --git a/external/icu/icu4c-icu11451.patch.1 b/external/icu/icu4c-icu11451.patch.1
new file mode 100644
index 000000000000..b15185a4dbb0
--- /dev/null
+++ b/external/icu/icu4c-icu11451.patch.1
@@ -0,0 +1,11 @@
+--- icu/source/common/ubidi.c.orig 2014-12-19 10:23:38.103928414 +0000
++++ icu/source/common/ubidi.c 2014-12-19 10:26:58.370071527 +0000
+@@ -2146,7 +2146,7 @@
+ /* The isolates[] entries contain enough information to
+ resume the bidi algorithm in the same state as it was
+ when it was interrupted by an isolate sequence. */
+- if(dirProps[start]==PDI) {
++ if(dirProps[start]==PDI && pBiDi->isolateCount >= 0) {
+ levState.startON=pBiDi->isolates[pBiDi->isolateCount].startON;
+ start1=pBiDi->isolates[pBiDi->isolateCount].start1;
+ stateImp=pBiDi->isolates[pBiDi->isolateCount].stateImp;
diff --git a/external/icu/khmerbreakengine.patch b/external/icu/khmerbreakengine.patch
deleted file mode 100644
index 8f81f315da3e..000000000000
--- a/external/icu/khmerbreakengine.patch
+++ /dev/null
@@ -1,1110 +0,0 @@
-diff --git a/source/common/dictbe.cpp b/source/common/dictbe.cpp
-index f1c874d..3ad1b3f 100644
---- misc/icu/source/common/dictbe.cpp
-+++ build/icu/source/common/dictbe.cpp
-@@ -27,8 +27,17 @@ U_NAMESPACE_BEGIN
- ******************************************************************
- */
-
--DictionaryBreakEngine::DictionaryBreakEngine(uint32_t breakTypes) {
-+DictionaryBreakEngine::DictionaryBreakEngine(uint32_t breakTypes) :
-+ clusterLimit(3)
-+{
-+ UErrorCode status = U_ZERO_ERROR;
- fTypes = breakTypes;
-+ fViramaSet.applyPattern(UNICODE_STRING_SIMPLE("[[:ccc=VR:]]"), status);
-+
-+ // note Skip Sets contain fIgnoreSet characters too.
-+ fSkipStartSet.applyPattern(UNICODE_STRING_SIMPLE("[[:lb=OP:][:lb=QU:]\\u200C\\u200D\\u2060]"), status);
-+ fSkipEndSet.applyPattern(UNICODE_STRING_SIMPLE("[[:lb=CP:][:lb=QU:][:lb=EX:][:lb=CL:]\\u200C\\u200D\\u2060]"), status);
-+ fNBeforeSet.applyPattern(UNICODE_STRING_SIMPLE("[[:lb=CR:][:lb=LF:][:lb=NL:][:lb=SP:][:lb=ZW:][:lb=IS:][:lb=BA:][:lb=NS:]]"), status);
- }
-
- DictionaryBreakEngine::~DictionaryBreakEngine() {
-@@ -90,7 +99,7 @@ DictionaryBreakEngine::findBreaks( UText *text,
- result = divideUpDictionaryRange(text, rangeStart, rangeEnd, foundBreaks);
- utext_setNativeIndex(text, current);
- }
--
-+
- return result;
- }
-
-@@ -101,6 +110,169 @@ DictionaryBreakEngine::setCharacters( const UnicodeSet &set ) {
- fSet.compact();
- }
-
-+bool
-+DictionaryBreakEngine::scanBeforeStart(UText *text, int32_t& start, bool &doBreak) const {
-+ UErrorCode status = U_ZERO_ERROR;
-+ UText* ut = utext_clone(NULL, text, false, true, &status);
-+ utext_setNativeIndex(ut, start);
-+ UChar32 c = utext_current32(ut);
-+ bool res = false;
-+ doBreak = true;
-+ while (start >= 0) {
-+ if (!fSkipStartSet.contains(c)) {
-+ res = (c == ZWSP);
-+ break;
-+ }
-+ --start;
-+ c = utext_previous32(ut);
-+ doBreak = false;
-+ }
-+ utext_close(ut);
-+ return res;
-+}
-+
-+bool
-+DictionaryBreakEngine::scanAfterEnd(UText *text, int32_t textEnd, int32_t& end, bool &doBreak) const {
-+ UErrorCode status = U_ZERO_ERROR;
-+ UText* ut = utext_clone(NULL, text, false, true, &status);
-+ utext_setNativeIndex(ut, end);
-+ UChar32 c = utext_current32(ut);
-+ bool res = false;
-+ doBreak = !fNBeforeSet.contains(c);
-+ while (end < textEnd) {
-+ if (!fSkipEndSet.contains(c)) {
-+ res = (c == ZWSP);
-+ break;
-+ }
-+ ++end;
-+ c = utext_next32(ut);
-+ doBreak = false;
-+ }
-+ utext_close(ut);
-+ return res;
-+}
-+
-+void
-+DictionaryBreakEngine::scanBackClusters(UText *text, int32_t textStart, int32_t& start) const {
-+ UChar32 c = 0;
-+ start = utext_getNativeIndex(text);
-+ while (start > textStart) {
-+ c = utext_previous32(text);
-+ --start;
-+ if (!fSkipEndSet.contains(c))
-+ break;
-+ }
-+ for (int i = 0; i < clusterLimit; ++i) { // scan backwards clusterLimit clusters
-+ while (start > textStart) {
-+ while (fIgnoreSet.contains(c))
-+ c = utext_previous32(text);
-+ if (!fMarkSet.contains(c)) {
-+ if (fBaseSet.contains(c)) {
-+ c = utext_previous32(text);
-+ if (!fViramaSet.contains(c)) { // Virama (e.g. coeng) preceding base. Treat sequence as a mark
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ break;
-+ } else {
-+ --start;
-+ }
-+ } else {
-+ break;
-+ }
-+ }
-+ c = utext_previous32(text);
-+ --start;
-+ }
-+ if (!fBaseSet.contains(c) || start < textStart) { // not a cluster start so finish
-+ break;
-+ }
-+ c = utext_previous32(text);
-+ --start; // go round again
-+ } // ignore hitting previous inhibitor since scanning for it should have found us!
-+ ++start; // counteract --before
-+}
-+
-+void
-+DictionaryBreakEngine::scanFwdClusters(UText *text, int32_t textEnd, int32_t& end) const {
-+ UChar32 c = utext_current32(text);
-+ end = utext_getNativeIndex(text);
-+ while (end < textEnd) {
-+ if (!fSkipStartSet.contains(c))
-+ break;
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ ++end;
-+ }
-+ for (int i = 0; i < clusterLimit; ++i) { // scan forwards clusterLimit clusters
-+ while (fIgnoreSet.contains(c)) {
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ }
-+ if (fBaseSet.contains(c)) {
-+ while (end < textEnd) {
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ ++end;
-+ if (!fMarkSet.contains(c))
-+ break;
-+ else if (fViramaSet.contains(c)) { // handle coeng + base as mark
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ ++end;
-+ if (!fBaseSet.contains(c))
-+ break;
-+ }
-+ }
-+ } else {
-+ --end; // bad char so break after char before it
-+ break;
-+ }
-+ }
-+}
-+
-+bool
-+DictionaryBreakEngine::scanWJ(UText *text, int32_t &start, int32_t end, int32_t &before, int32_t &after) const {
-+ UErrorCode status = U_ZERO_ERROR;
-+ UText* ut = utext_clone(NULL, text, false, true, &status);
-+ int32_t nat = start;
-+ utext_setNativeIndex(ut, nat);
-+ bool foundFirst = true;
-+ int32_t curr = start;
-+ while (nat < end) {
-+ UChar32 c = utext_current32(ut);
-+ if (c == ZWSP || c == WJ) {
-+ curr = nat + 1;
-+ if (foundFirst) // only scan backwards for first inhibitor
-+ scanBackClusters(ut, start, before);
-+ foundFirst = false; // don't scan backwards if we go around again. Also marks found something
-+
-+ utext_next32(ut);
-+ scanFwdClusters(ut, end, after);
-+ nat = after + 1;
-+
-+ if (c == ZWSP || c == WJ) { // did we hit another one?
-+ continue;
-+ } else {
-+ break;
-+ }
-+ }
-+
-+ ++nat; // keep hunting
-+ utext_next32(ut);
-+ }
-+
-+ utext_close(ut);
-+
-+ if (nat >= end && foundFirst) {
-+ start = before = after = nat;
-+ return false; // failed to find anything
-+ }
-+ else {
-+ start = curr;
-+ }
-+ return true; // yup hit one
-+}
-+
- /*
- ******************************************************************
- * PossibleWord
-@@ -128,35 +302,35 @@ private:
- public:
- PossibleWord() : count(0), prefix(0), offset(-1), mark(0), current(0) {};
- ~PossibleWord() {};
--
-+
- // Fill the list of candidates if needed, select the longest, and return the number found
-- int32_t candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd );
--
-+ int32_t candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd, UnicodeSet const *ignoreSet = NULL, int32_t minLength = 0 );
-+
- // Select the currently marked candidate, point after it in the text, and invalidate self
- int32_t acceptMarked( UText *text );
--
-+
- // Back up from the current candidate to the next shorter one; return TRUE if that exists
- // and point the text after it
- UBool backUp( UText *text );
--
-+
- // Return the longest prefix this candidate location shares with a dictionary word
- // Return value is in code points.
- int32_t longestPrefix() { return prefix; };
--
-+
- // Mark the current candidate as the one we like
- void markCurrent() { mark = current; };
--
-+
- // Get length in code points of the marked word.
- int32_t markedCPLength() { return cpLengths[mark]; };
- };
-
-
--int32_t PossibleWord::candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd ) {
-+int32_t PossibleWord::candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd, UnicodeSet const *ignoreSet, int32_t minLength) {
- // TODO: If getIndex is too slow, use offset < 0 and add discardAll()
- int32_t start = (int32_t)utext_getNativeIndex(text);
- if (start != offset) {
- offset = start;
-- count = dict->matches(text, rangeEnd-start, UPRV_LENGTHOF(cuLengths), cuLengths, cpLengths, NULL, &prefix);
-+ count = dict->matches(text, rangeEnd-start, UPRV_LENGTHOF(cuLengths), cuLengths, cpLengths, NULL, &prefix, ignoreSet, minLength);
- // Dictionary leaves text after longest prefix, not longest word. Back up.
- if (count <= 0) {
- utext_setNativeIndex(text, start);
-@@ -828,51 +1002,28 @@ foundBest:
- * KhmerBreakEngine
- */
-
--// How many words in a row are "good enough"?
--static const int32_t KHMER_LOOKAHEAD = 3;
--
--// Will not combine a non-word with a preceding dictionary word longer than this
--static const int32_t KHMER_ROOT_COMBINE_THRESHOLD = 3;
--
--// Will not combine a non-word that shares at least this much prefix with a
--// dictionary word, with a preceding word
--static const int32_t KHMER_PREFIX_COMBINE_THRESHOLD = 3;
--
--// Minimum word size
--static const int32_t KHMER_MIN_WORD = 2;
--
--// Minimum number of characters for two words
--static const int32_t KHMER_MIN_WORD_SPAN = KHMER_MIN_WORD * 2;
--
- KhmerBreakEngine::KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status)
- : DictionaryBreakEngine((1 << UBRK_WORD) | (1 << UBRK_LINE)),
- fDictionary(adoptDictionary)
- {
-- fKhmerWordSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]&[:LineBreak=SA:]]"), status);
-+
-+ clusterLimit = 3;
-+
-+ fKhmerWordSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]\\u2060\\u200C\\u200D]"), status);
- if (U_SUCCESS(status)) {
- setCharacters(fKhmerWordSet);
- }
- fMarkSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]&[:LineBreak=SA:]&[:M:]]"), status);
-- fMarkSet.add(0x0020);
-- fEndWordSet = fKhmerWordSet;
-- fBeginWordSet.add(0x1780, 0x17B3);
-- //fBeginWordSet.add(0x17A3, 0x17A4); // deprecated vowels
-- //fEndWordSet.remove(0x17A5, 0x17A9); // Khmer independent vowels that can't end a word
-- //fEndWordSet.remove(0x17B2); // Khmer independent vowel that can't end a word
-- fEndWordSet.remove(0x17D2); // KHMER SIGN COENG that combines some following characters
-- //fEndWordSet.remove(0x17B6, 0x17C5); // Remove dependent vowels
--// fEndWordSet.remove(0x0E31); // MAI HAN-AKAT
--// fEndWordSet.remove(0x0E40, 0x0E44); // SARA E through SARA AI MAIMALAI
--// fBeginWordSet.add(0x0E01, 0x0E2E); // KO KAI through HO NOKHUK
--// fBeginWordSet.add(0x0E40, 0x0E44); // SARA E through SARA AI MAIMALAI
--// fSuffixSet.add(THAI_PAIYANNOI);
--// fSuffixSet.add(THAI_MAIYAMOK);
-+ fIgnoreSet.add(0x2060); // WJ
-+ fIgnoreSet.add(0x200C, 0x200D); // ZWJ, ZWNJ
-+ fBaseSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]&[:lb=SA:]&[:^M:]]"), status);
-+ fPuncSet.applyPattern(UNICODE_STRING_SIMPLE("[\\u17D4\\u17D5\\u17D6\\u17D7\\u17D9:]"), status);
-
- // Compact for caching.
- fMarkSet.compact();
-- fEndWordSet.compact();
-- fBeginWordSet.compact();
--// fSuffixSet.compact();
-+ fIgnoreSet.compact();
-+ fBaseSet.compact();
-+ fPuncSet.compact();
- }
-
- KhmerBreakEngine::~KhmerBreakEngine() {
-@@ -884,180 +1036,204 @@ KhmerBreakEngine::divideUpDictionaryRange( UText *text,
- int32_t rangeStart,
- int32_t rangeEnd,
- UStack &foundBreaks ) const {
-- if ((rangeEnd - rangeStart) < KHMER_MIN_WORD_SPAN) {
-- return 0; // Not enough characters for two words
-+ uint32_t wordsFound = foundBreaks.size();
-+ UErrorCode status = U_ZERO_ERROR;
-+ int32_t before = 0;
-+ int32_t after = 0;
-+ int32_t finalBefore = 0;
-+ int32_t initAfter = 0;
-+ int32_t scanStart = rangeStart;
-+ int32_t scanEnd = rangeEnd;
-+
-+ bool startZwsp = false;
-+ bool breakStart = false;
-+ bool breakEnd = false;
-+
-+ if (rangeStart > 0) {
-+ --scanStart;
-+ startZwsp = scanBeforeStart(text, scanStart, breakStart);
-+ }
-+ utext_setNativeIndex(text, rangeStart);
-+ scanFwdClusters(text, rangeEnd, initAfter);
-+ bool endZwsp = scanAfterEnd(text, utext_nativeLength(text), scanEnd, breakEnd);
-+ utext_setNativeIndex(text, rangeEnd - 1);
-+ scanBackClusters(text, rangeStart, finalBefore);
-+ if (finalBefore < initAfter) { // the whole run is tented so no breaks
-+ if (breakStart || fTypes < UBRK_LINE)
-+ foundBreaks.push(rangeStart, status);
-+ if (breakEnd || fTypes < UBRK_LINE)
-+ foundBreaks.push(rangeEnd, status);
-+ return foundBreaks.size() - wordsFound;
- }
-
-- uint32_t wordsFound = 0;
-- int32_t cpWordLength = 0;
-- int32_t cuWordLength = 0;
-- int32_t current;
-- UErrorCode status = U_ZERO_ERROR;
-- PossibleWord words[KHMER_LOOKAHEAD];
-+ scanStart = rangeStart;
-+ scanWJ(text, scanStart, rangeEnd, before, after);
-+ if (startZwsp || initAfter >= before) {
-+ after = initAfter;
-+ before = 0;
-+ }
-+ if (!endZwsp && after > finalBefore && after < rangeEnd)
-+ endZwsp = true;
-+ if (endZwsp && before > finalBefore)
-+ before = finalBefore;
-
- utext_setNativeIndex(text, rangeStart);
-+ int32_t numCodePts = rangeEnd - rangeStart;
-+ // bestSnlp[i] is the snlp of the best segmentation of the first i
-+ // code points in the range to be matched.
-+ UVector32 bestSnlp(numCodePts + 1, status);
-+ bestSnlp.addElement(0, status);
-+ for(int32_t i = 1; i <= numCodePts; i++) {
-+ bestSnlp.addElement(kuint32max, status);
-+ }
-
-- while (U_SUCCESS(status) && (current = (int32_t)utext_getNativeIndex(text)) < rangeEnd) {
-- cuWordLength = 0;
-- cpWordLength = 0;
-+ // prev[i] is the index of the last code point in the previous word in
-+ // the best segmentation of the first i characters. Note negative implies
-+ // that the code point is part of an unknown word.
-+ UVector32 prev(numCodePts + 1, status);
-+ for(int32_t i = 0; i <= numCodePts; i++) {
-+ prev.addElement(kuint32max, status);
-+ }
-
-- // Look for candidate words at the current position
-- int32_t candidates = words[wordsFound%KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd);
-+ const int32_t maxWordSize = 20;
-+ UVector32 values(maxWordSize, status);
-+ values.setSize(maxWordSize);
-+ UVector32 lengths(maxWordSize, status);
-+ lengths.setSize(maxWordSize);
-
-- // If we found exactly one, use that
-- if (candidates == 1) {
-- cuWordLength = words[wordsFound % KHMER_LOOKAHEAD].acceptMarked(text);
-- cpWordLength = words[wordsFound % KHMER_LOOKAHEAD].markedCPLength();
-- wordsFound += 1;
-- }
-+ // Dynamic programming to find the best segmentation.
-
-- // If there was more than one, see which one can take us forward the most words
-- else if (candidates > 1) {
-- // If we're already at the end of the range, we're done
-- if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) {
-- goto foundBest;
-- }
-- do {
-- int32_t wordsMatched = 1;
-- if (words[(wordsFound + 1) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) > 0) {
-- if (wordsMatched < 2) {
-- // Followed by another dictionary word; mark first word as a good candidate
-- words[wordsFound % KHMER_LOOKAHEAD].markCurrent();
-- wordsMatched = 2;
-- }
-+ // In outer loop, i is the code point index,
-+ // ix is the corresponding string (code unit) index.
-+ // They differ when the string contains supplementary characters.
-+ int32_t ix = rangeStart;
-+ for (int32_t i = 0; i < numCodePts; ++i, utext_setNativeIndex(text, ++ix)) {
-+ if ((uint32_t)bestSnlp.elementAti(i) == kuint32max) {
-+ continue;
-+ }
-
-- // If we're already at the end of the range, we're done
-- if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) {
-- goto foundBest;
-- }
-+ int32_t count;
-+ count = fDictionary->matches(text, numCodePts - i, maxWordSize,
-+ NULL, lengths.getBuffer(), values.getBuffer(), NULL, &fIgnoreSet, 2);
-+ // Note: lengths is filled with code point lengths
-+ // The NULL parameter is the ignored code unit lengths.
-
-- // See if any of the possible second words is followed by a third word
-- do {
-- // If we find a third word, stop right away
-- if (words[(wordsFound + 2) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd)) {
-- words[wordsFound % KHMER_LOOKAHEAD].markCurrent();
-- goto foundBest;
-- }
-- }
-- while (words[(wordsFound + 1) % KHMER_LOOKAHEAD].backUp(text));
-- }
-+ for (int32_t j = 0; j < count; j++) {
-+ int32_t ln = lengths.elementAti(j);
-+ if (ln + i >= numCodePts)
-+ continue;
-+ utext_setNativeIndex(text, ln+ix);
-+ int32_t c = utext_current32(text);
-+ if (fMarkSet.contains(c) || c == 0x17D2) { // Coeng
-+ lengths.removeElementAt(j);
-+ values.removeElementAt(j);
-+ --j;
-+ --count;
- }
-- while (words[wordsFound % KHMER_LOOKAHEAD].backUp(text));
--foundBest:
-- cuWordLength = words[wordsFound % KHMER_LOOKAHEAD].acceptMarked(text);
-- cpWordLength = words[wordsFound % KHMER_LOOKAHEAD].markedCPLength();
-- wordsFound += 1;
- }
--
-- // We come here after having either found a word or not. We look ahead to the
-- // next word. If it's not a dictionary word, we will combine it with the word we
-- // just found (if there is one), but only if the preceding word does not exceed
-- // the threshold.
-- // The text iterator should now be positioned at the end of the word we found.
-- if ((int32_t)utext_getNativeIndex(text) < rangeEnd && cpWordLength < KHMER_ROOT_COMBINE_THRESHOLD) {
-- // if it is a dictionary word, do nothing. If it isn't, then if there is
-- // no preceding word, or the non-word shares less than the minimum threshold
-- // of characters with a dictionary word, then scan to resynchronize
-- if (words[wordsFound % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) <= 0
-- && (cuWordLength == 0
-- || words[wordsFound % KHMER_LOOKAHEAD].longestPrefix() < KHMER_PREFIX_COMBINE_THRESHOLD)) {
-- // Look for a plausible word boundary
-- int32_t remaining = rangeEnd - (current+cuWordLength);
-- UChar32 pc;
-- UChar32 uc;
-- int32_t chars = 0;
-- for (;;) {
-- int32_t pcIndex = (int32_t)utext_getNativeIndex(text);
-- pc = utext_next32(text);
-- int32_t pcSize = (int32_t)utext_getNativeIndex(text) - pcIndex;
-- chars += pcSize;
-- remaining -= pcSize;
-- if (remaining <= 0) {
-+ if (count == 0) {
-+ utext_setNativeIndex(text, ix);
-+ int32_t c = utext_current32(text);
-+ if (fPuncSet.contains(c) || fIgnoreSet.contains(c) || c == ZWSP) {
-+ values.setElementAt(0, count);
-+ lengths.setElementAt(1, count++);
-+ } else if (fBaseSet.contains(c)) {
-+ int32_t currix = utext_getNativeIndex(text);
-+ do {
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ if (utext_getNativeIndex(text) >= rangeEnd)
- break;
-- }
-- uc = utext_current32(text);
-- if (fEndWordSet.contains(pc) && fBeginWordSet.contains(uc)) {
-- // Maybe. See if it's in the dictionary.
-- int32_t candidates = words[(wordsFound + 1) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd);
-- utext_setNativeIndex(text, current+cuWordLength+chars);
-- if (candidates > 0) {
-+ if (c == 0x17D2) { // Coeng
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ if (!fBaseSet.contains(c) || utext_getNativeIndex(text) >= rangeEnd) {
- break;
-+ } else {
-+ utext_next32(text);
-+ c = utext_current32(text);
-+ if (utext_getNativeIndex(text) >= rangeEnd)
-+ break;
- }
- }
-- }
--
-- // Bump the word count if there wasn't already one
-- if (cuWordLength <= 0) {
-- wordsFound += 1;
-- }
-+ } while (fMarkSet.contains(c) || fIgnoreSet.contains(c));
-+ values.setElementAt(BADSNLP, count);
-+ lengths.setElementAt(utext_getNativeIndex(text) - currix, count++);
-+ } else {
-+ values.setElementAt(BADSNLP, count);
-+ lengths.setElementAt(1, count++);
-+ }
-+ }
-
-- // Update the length with the passed-over characters
-- cuWordLength += chars;
-+ for (int32_t j = 0; j < count; j++) {
-+ uint32_t v = values.elementAti(j);
-+ int32_t newSnlp = bestSnlp.elementAti(i) + v;
-+ int32_t ln = lengths.elementAti(j);
-+ utext_setNativeIndex(text, ln+ix);
-+ int32_t c = utext_current32(text);
-+ while ((fPuncSet.contains(c) || fIgnoreSet.contains(c)) && ln + i < numCodePts) {
-+ ++ln;
-+ utext_next32(text);
-+ c = utext_current32(text);
- }
-- else {
-- // Back up to where we were for next iteration
-- utext_setNativeIndex(text, current+cuWordLength);
-+ int32_t ln_j_i = ln + i; // yes really i!
-+ if (newSnlp < bestSnlp.elementAti(ln_j_i)) {
-+ if (v == BADSNLP) {
-+ int32_t p = prev.elementAti(i);
-+ if (p < 0)
-+ prev.setElementAt(p, ln_j_i);
-+ else
-+ prev.setElementAt(-i, ln_j_i);
-+ }
-+ else
-+ prev.setElementAt(i, ln_j_i);
-+ bestSnlp.setElementAt(newSnlp, ln_j_i);
- }
- }
-+ }
-+ // Start pushing the optimal offset index into t_boundary (t for tentative).
-+ // prev[numCodePts] is guaranteed to be meaningful.
-+ // We'll first push in the reverse order, i.e.,
-+ // t_boundary[0] = numCodePts, and afterwards do a swap.
-+ UVector32 t_boundary(numCodePts+1, status);
-
-- // Never stop before a combining mark.
-- int32_t currPos;
-- while ((currPos = (int32_t)utext_getNativeIndex(text)) < rangeEnd && fMarkSet.contains(utext_current32(text))) {
-- utext_next32(text);
-- cuWordLength += (int32_t)utext_getNativeIndex(text) - currPos;
-+ int32_t numBreaks = 0;
-+ // No segmentation found, set boundary to end of range
-+ while (numCodePts >= 0 && (uint32_t)bestSnlp.elementAti(numCodePts) == kuint32max) {
-+ --numCodePts;
-+ }
-+ if (numCodePts < 0) {
-+ t_boundary.addElement(numCodePts, status);
-+ numBreaks++;
-+ } else {
-+ for (int32_t i = numCodePts; (uint32_t)i != kuint32max; i = prev.elementAti(i)) {
-+ if (i < 0) i = -i;
-+ t_boundary.addElement(i, status);
-+ numBreaks++;
- }
-+ U_ASSERT(prev.elementAti(t_boundary.elementAti(numBreaks - 1)) == 0);
-+ }
-
-- // Look ahead for possible suffixes if a dictionary word does not follow.
-- // We do this in code rather than using a rule so that the heuristic
-- // resynch continues to function. For example, one of the suffix characters
-- // could be a typo in the middle of a word.
--// if ((int32_t)utext_getNativeIndex(text) < rangeEnd && wordLength > 0) {
--// if (words[wordsFound%KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) <= 0
--// && fSuffixSet.contains(uc = utext_current32(text))) {
--// if (uc == KHMER_PAIYANNOI) {
--// if (!fSuffixSet.contains(utext_previous32(text))) {
--// // Skip over previous end and PAIYANNOI
--// utext_next32(text);
--// utext_next32(text);
--// wordLength += 1; // Add PAIYANNOI to word
--// uc = utext_current32(text); // Fetch next character
--// }
--// else {
--// // Restore prior position
--// utext_next32(text);
--// }
--// }
--// if (uc == KHMER_MAIYAMOK) {
--// if (utext_previous32(text) != KHMER_MAIYAMOK) {
--// // Skip over previous end and MAIYAMOK
--// utext_next32(text);
--// utext_next32(text);
--// wordLength += 1; // Add MAIYAMOK to word
--// }
--// else {
--// // Restore prior position
--// utext_next32(text);
--// }
--// }
--// }
--// else {
--// utext_setNativeIndex(text, current+wordLength);
--// }
--// }
--
-- // Did we find a word on this iteration? If so, push it on the break stack
-- if (cuWordLength > 0) {
-- foundBreaks.push((current+cuWordLength), status);
-+ // Now that we're done, convert positions in t_boundary[] (indices in
-+ // the normalized input string) back to indices in the original input UText
-+ // while reversing t_boundary and pushing values to foundBreaks.
-+ for (int32_t i = numBreaks-1; i >= 0; i--) {
-+ int32_t cpPos = t_boundary.elementAti(i);
-+ if (cpPos == 0 && !breakStart && fTypes >= UBRK_LINE) continue;
-+ int32_t utextPos = cpPos + rangeStart;
-+ while (utextPos > after && scanWJ(text, utextPos, scanEnd, before, after));
-+ if (utextPos < before) {
-+ // Boundaries are added to foundBreaks output in ascending order.
-+ U_ASSERT(foundBreaks.size() == 0 ||foundBreaks.peeki() < utextPos);
-+ foundBreaks.push(utextPos, status);
- }
- }
--
-+
- // Don't return a break for the end of the dictionary range if there is one there.
-- if (foundBreaks.peeki() >= rangeEnd) {
-+ if (!breakEnd && fTypes >= UBRK_LINE && foundBreaks.peeki() >= rangeEnd) {
- (void) foundBreaks.popi();
-- wordsFound -= 1;
- }
--
-- return wordsFound;
-+ return foundBreaks.size() - wordsFound;
- }
-
- #if !UCONFIG_NO_NORMALIZATION
-diff --git a/source/common/dictbe.h b/source/common/dictbe.h
-index d3488cd..26caa75 100644
---- misc/icu/source/common/dictbe.h
-+++ build/icu/source/common/dictbe.h
-@@ -32,6 +32,15 @@ class Normalizer2;
- */
- class DictionaryBreakEngine : public LanguageBreakEngine {
- private:
-+
-+ /**
-+ * <p>Default constructor.</p>
-+ *
-+ */
-+ DictionaryBreakEngine();
-+
-+ protected:
-+
- /**
- * The set of characters handled by this engine
- * @internal
-@@ -46,11 +55,63 @@ class DictionaryBreakEngine : public LanguageBreakEngine {
-
- uint32_t fTypes;
-
-+ const int32_t WJ = 0x2060;
-+ const int32_t ZWSP = 0x200B;
-+
- /**
-- * <p>Default constructor.</p>
-- *
-+ * A Unicode set of all viramas
-+ * @internal
- */
-- DictionaryBreakEngine();
-+ UnicodeSet fViramaSet;
-+
-+ /**
-+ * A Unicode set of all base characters
-+ * @internal
-+ */
-+ UnicodeSet fBaseSet;
-+
-+ /**
-+ * A Unicode set of all marks
-+ * @internal
-+ */
-+ UnicodeSet fMarkSet;
-+
-+ /**
-+ * A Unicode set of all characters ignored ignored in dictionary matching
-+ * @internal
-+ */
-+ UnicodeSet fIgnoreSet;
-+
-+ /**
-+ * A Unicode set of all characters ignored ignored in dictionary matching
-+ * @internal
-+ */
-+ UnicodeSet fSkipStartSet;
-+
-+ /**
-+ * A Unicode set of all characters ignored ignored in dictionary matching
-+ * @internal
-+ */
-+ UnicodeSet fSkipEndSet;
-+
-+ /**
-+ * A Unicode set of all characters that should not be broken before
-+ * @internal
-+ */
-+ UnicodeSet fNBeforeSet;
-+
-+ /**
-+ * The number of clusters within which breaks are inhibited
-+ * @internal
-+ */
-+ int32_t clusterLimit;
-+
-+ bool scanWJ(UText *text, int32_t &start, int32_t end, int32_t &before, int32_t &after) const;
-+
-+ bool scanBeforeStart(UText *text, int32_t& start, bool &doBreak) const;
-+ bool scanAfterEnd(UText *text, int32_t rangeEnd, int32_t& end, bool &doBreak) const;
-+ void scanBackClusters(UText *text, int32_t textStart, int32_t& start) const;
-+ void scanFwdClusters(UText *text, int32_t textEnd, int32_t& end) const;
-
- public:
-
-@@ -81,7 +142,7 @@ class DictionaryBreakEngine : public LanguageBreakEngine {
- * <p>Find any breaks within a run in the supplied text.</p>
- *
- * @param text A UText representing the text. The iterator is left at
-- * the end of the run of characters which the engine is capable of handling
-+ * the end of the run of characters which the engine is capable of handling
- * that starts from the first (or last) character in the range.
- * @param startPos The start of the run within the supplied text.
- * @param endPos The end of the run within the supplied text.
-@@ -243,118 +304,120 @@ class LaoBreakEngine : public DictionaryBreakEngine {
-
- };
-
--/*******************************************************************
-- * BurmeseBreakEngine
-- */
--
--/**
-- * <p>BurmeseBreakEngine is a kind of DictionaryBreakEngine that uses a
-- * DictionaryMatcher and heuristics to determine Burmese-specific breaks.</p>
-- *
-- * <p>After it is constructed a BurmeseBreakEngine may be shared between
-- * threads without synchronization.</p>
-- */
--class BurmeseBreakEngine : public DictionaryBreakEngine {
-- private:
-- /**
-- * The set of characters handled by this engine
-- * @internal
-- */
--
-- UnicodeSet fBurmeseWordSet;
-- UnicodeSet fEndWordSet;
-- UnicodeSet fBeginWordSet;
-- UnicodeSet fMarkSet;
-- DictionaryMatcher *fDictionary;
--
-- public:
--
-- /**
-- * <p>Default constructor.</p>
-- *
-- * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the
-- * engine is deleted.
-- */
-- BurmeseBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status);
--
-- /**
-- * <p>Virtual destructor.</p>
-- */
-- virtual ~BurmeseBreakEngine();
--
-- protected:
-- /**
-- * <p>Divide up a range of known dictionary characters.</p>
-- *
-- * @param text A UText representing the text
-- * @param rangeStart The start of the range of dictionary characters
-- * @param rangeEnd The end of the range of dictionary characters
-- * @param foundBreaks Output of C array of int32_t break positions, or 0
-- * @return The number of breaks found
-- */
-- virtual int32_t divideUpDictionaryRange( UText *text,
-- int32_t rangeStart,
-- int32_t rangeEnd,
-- UStack &foundBreaks ) const;
--
--};
--
--/*******************************************************************
-- * KhmerBreakEngine
-- */
--
--/**
-- * <p>KhmerBreakEngine is a kind of DictionaryBreakEngine that uses a
-- * DictionaryMatcher and heuristics to determine Khmer-specific breaks.</p>
-- *
-- * <p>After it is constructed a KhmerBreakEngine may be shared between
-- * threads without synchronization.</p>
-- */
--class KhmerBreakEngine : public DictionaryBreakEngine {
-- private:
-- /**
-- * The set of characters handled by this engine
-- * @internal
-- */
--
-- UnicodeSet fKhmerWordSet;
-- UnicodeSet fEndWordSet;
-- UnicodeSet fBeginWordSet;
-- UnicodeSet fMarkSet;
-- DictionaryMatcher *fDictionary;
--
-- public:
--
-- /**
-- * <p>Default constructor.</p>
-- *
-- * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the
-- * engine is deleted.
-- */
-- KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status);
--
-- /**
-- * <p>Virtual destructor.</p>
-- */
-- virtual ~KhmerBreakEngine();
--
-- protected:
-- /**
-- * <p>Divide up a range of known dictionary characters.</p>
-- *
-- * @param text A UText representing the text
-- * @param rangeStart The start of the range of dictionary characters
-- * @param rangeEnd The end of the range of dictionary characters
-- * @param foundBreaks Output of C array of int32_t break positions, or 0
-- * @return The number of breaks found
-- */
-- virtual int32_t divideUpDictionaryRange( UText *text,
-- int32_t rangeStart,
-- int32_t rangeEnd,
-- UStack &foundBreaks ) const;
--
--};
--
-+/*******************************************************************
-+ * BurmeseBreakEngine
-+ */
-+
-+/**
-+ * <p>BurmeseBreakEngine is a kind of DictionaryBreakEngine that uses a
-+ * DictionaryMatcher and heuristics to determine Burmese-specific breaks.</p>
-+ *
-+ * <p>After it is constructed a BurmeseBreakEngine may be shared between
-+ * threads without synchronization.</p>
-+ */
-+class BurmeseBreakEngine : public DictionaryBreakEngine {
-+ private:
-+ /**
-+ * The set of characters handled by this engine
-+ * @internal
-+ */
-+
-+ UnicodeSet fBurmeseWordSet;
-+ UnicodeSet fEndWordSet;
-+ UnicodeSet fBeginWordSet;
-+ UnicodeSet fMarkSet;
-+ DictionaryMatcher *fDictionary;
-+
-+ public:
-+
-+ /**
-+ * <p>Default constructor.</p>
-+ *
-+ * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the
-+ * engine is deleted.
-+ */
-+ BurmeseBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status);
-+
-+ /**
-+ * <p>Virtual destructor.</p>
-+ */
-+ virtual ~BurmeseBreakEngine();
-+
-+ protected:
-+ /**
-+ * <p>Divide up a range of known dictionary characters.</p>
-+ *
-+ * @param text A UText representing the text
-+ * @param rangeStart The start of the range of dictionary characters
-+ * @param rangeEnd The end of the range of dictionary characters
-+ * @param foundBreaks Output of C array of int32_t break positions, or 0
-+ * @return The number of breaks found
-+ */
-+ virtual int32_t divideUpDictionaryRange( UText *text,
-+ int32_t rangeStart,
-+ int32_t rangeEnd,
-+ UStack &foundBreaks ) const;
-+
-+};
-+
-+/*******************************************************************
-+ * KhmerBreakEngine
-+ */
-+
-+/**
-+ * <p>KhmerBreakEngine is a kind of DictionaryBreakEngine that uses a
-+ * DictionaryMatcher and heuristics to determine Khmer-specific breaks.</p>
-+ *
-+ * <p>After it is constructed a KhmerBreakEngine may be shared between
-+ * threads without synchronization.</p>
-+ */
-+class KhmerBreakEngine : public DictionaryBreakEngine {
-+ private:
-+ /**
-+ * The set of characters handled by this engine
-+ * @internal
-+ */
-+
-+ UnicodeSet fKhmerWordSet;
-+ UnicodeSet fBeginWordSet;
-+ UnicodeSet fPuncSet;
-+ DictionaryMatcher *fDictionary;
-+
-+ const uint32_t BADSNLP = 256 * 20;
-+ const uint32_t kuint32max = 0x7FFFFFFF;
-+
-+ public:
-+
-+ /**
-+ * <p>Default constructor.</p>
-+ *
-+ * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the
-+ * engine is deleted.
-+ */
-+ KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status);
-+
-+ /**
-+ * <p>Virtual destructor.</p>
-+ */
-+ virtual ~KhmerBreakEngine();
-+
-+ protected:
-+ /**
-+ * <p>Divide up a range of known dictionary characters.</p>
-+ *
-+ * @param text A UText representing the text
-+ * @param rangeStart The start of the range of dictionary characters
-+ * @param rangeEnd The end of the range of dictionary characters
-+ * @param foundBreaks Output of C array of int32_t break positions, or 0
-+ * @return The number of breaks found
-+ */
-+ virtual int32_t divideUpDictionaryRange( UText *text,
-+ int32_t rangeStart,
-+ int32_t rangeEnd,
-+ UStack &foundBreaks ) const;
-+
-+};
-+
- #if !UCONFIG_NO_NORMALIZATION
-
- /*******************************************************************
-diff --git a/source/common/dictionarydata.cpp b/source/common/dictionarydata.cpp
-index cb594c6..82f2e77 100644
---- misc/icu/source/common/dictionarydata.cpp
-+++ build/icu/source/common/dictionarydata.cpp
-@@ -42,7 +42,7 @@ int32_t UCharsDictionaryMatcher::getType() const {
-
- int32_t UCharsDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t limit,
- int32_t *lengths, int32_t *cpLengths, int32_t *values,
-- int32_t *prefix) const {
-+ int32_t *prefix, UnicodeSet const* ignoreSet, int32_t minLength) const {
-
- UCharsTrie uct(characters);
- int32_t startingTextIndex = (int32_t)utext_getNativeIndex(text);
-@@ -53,7 +53,13 @@ int32_t UCharsDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t
- UStringTrieResult result = (codePointsMatched == 0) ? uct.first(c) : uct.next(c);
- int32_t lengthMatched = (int32_t)utext_getNativeIndex(text) - startingTextIndex;
- codePointsMatched += 1;
-+ if (ignoreSet != NULL && ignoreSet->contains(c)) {
-+ continue;
-+ }
- if (USTRINGTRIE_HAS_VALUE(result)) {
-+ if (codePointsMatched < minLength) {
-+ continue;
-+ }
- if (wordCount < limit) {
- if (values != NULL) {
- values[wordCount] = uct.getValue();
-@@ -110,7 +116,7 @@ int32_t BytesDictionaryMatcher::getType() const {
-
- int32_t BytesDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t limit,
- int32_t *lengths, int32_t *cpLengths, int32_t *values,
-- int32_t *prefix) const {
-+ int32_t *prefix, UnicodeSet const* ignoreSet, int32_t minLength) const {
- BytesTrie bt(characters);
- int32_t startingTextIndex = (int32_t)utext_getNativeIndex(text);
- int32_t wordCount = 0;
-@@ -120,7 +126,13 @@ int32_t BytesDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t
- UStringTrieResult result = (codePointsMatched == 0) ? bt.first(transform(c)) : bt.next(transform(c));
- int32_t lengthMatched = (int32_t)utext_getNativeIndex(text) - startingTextIndex;
- codePointsMatched += 1;
-+ if (ignoreSet != NULL && ignoreSet->contains(c)) {
-+ continue;
-+ }
- if (USTRINGTRIE_HAS_VALUE(result)) {
-+ if (codePointsMatched < minLength) {
-+ continue;
-+ }
- if (wordCount < limit) {
- if (values != NULL) {
- values[wordCount] = bt.getValue();
-diff --git a/source/common/dictionarydata.h b/source/common/dictionarydata.h
-index 0216ab0..ee9e571 100644
---- misc/icu/source/common/dictionarydata.h
-+++ build/icu/source/common/dictionarydata.h
-@@ -19,6 +19,7 @@
- #include "unicode/utext.h"
- #include "unicode/udata.h"
- #include "udataswp.h"
-+#include "unicode/uniset.h"
- #include "unicode/uobject.h"
- #include "unicode/ustringtrie.h"
-
-@@ -90,7 +91,7 @@ public:
- */
- virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit,
- int32_t *lengths, int32_t *cpLengths, int32_t *values,
-- int32_t *prefix) const = 0;
-+ int32_t *prefix, UnicodeSet const* ignoreSet = NULL, int32_t minLength = 0) const = 0;
-
- /** @return DictionaryData::TRIE_TYPE_XYZ */
- virtual int32_t getType() const = 0;
-@@ -105,7 +106,7 @@ public:
- virtual ~UCharsDictionaryMatcher();
- virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit,
- int32_t *lengths, int32_t *cpLengths, int32_t *values,
-- int32_t *prefix) const;
-+ int32_t *prefix, UnicodeSet const* ignoreSet = NULL, int32_t minLength = 0) const;
- virtual int32_t getType() const;
- private:
- const UChar *characters;
-@@ -123,7 +124,7 @@ public:
- virtual ~BytesDictionaryMatcher();
- virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit,
- int32_t *lengths, int32_t *cpLengths, int32_t *values,
-- int32_t *prefix) const;
-+ int32_t *prefix, UnicodeSet const* ignoreSet = NULL, int32_t minLength = 0) const;
- virtual int32_t getType() const;
- private:
- UChar32 transform(UChar32 c) const;
-diff --git a/source/data/Makefile.in b/source/data/Makefile.in
-index 816c82d..c637d70 100644
---- misc/icu/source/data/Makefile.in
-+++ build/icu/source/data/Makefile.in
-@@ -181,7 +181,7 @@ endif
- endif
- endif
-
--packagedata: icupkg.inc $(PKGDATA_LIST) build-local
-+packagedata: icupkg.inc $(PKGDATA_LIST) build-local $(MAINBUILDDIR)/khmerdict.stamp
- ifneq ($(ENABLE_STATIC),)
- ifeq ($(PKGDATA_MODE),dll)
- $(PKGDATA_INVOKE) $(PKGDATA) -e $(ICUDATA_ENTRY_POINT) -T $(OUTTMPDIR) -p $(ICUDATA_NAME) $(PKGDATA_LIBSTATICNAME) -m static $(PKGDATA_VERSIONING) $(PKGDATA_LIST)
-@@ -564,8 +564,14 @@ $(BRKBLDDIR)/burmesedict.dict: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(DAT_FILES)
- $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1000 -c -i $(BUILDDIR) $(DICTSRCDIR)/burmesedict.txt $(BRKBLDDIR)/burmesedict.dict
-
- # TODO: figure out why combining characters are here?
--$(BRKBLDDIR)/khmerdict.dict: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(DAT_FILES)
-- $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1780 -c -i $(BUILDDIR) $(DICTSRCDIR)/khmerdict.txt $(BRKBLDDIR)/khmerdict.dict
-+#$(BRKBLDDIR)/khmerdict.dict: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(DAT_FILES)
-+# $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1780 -c -i $(BUILDDIR) $(DICTSRCDIR)/khmerdict.txt $(BRKBLDDIR)/khmerdict.dict
-+
-+#$(MAINBUILDDIR)/khmerdict.stamp: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(BRKSRCDIR)/khmerdict.txt build-local
-+# $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1780 -c -i $(BUILDDIR) $(DICTSRCDIR)/khmerdict.txt $(BRKBLDDIR)/khmerdict.dict
-+$(MAINBUILDDIR)/khmerdict.stamp: $(BRKSRCDIR)/khmerdict.dict build-local
-+ cp $< $(BRKBLDDIR)
-+ echo "timestamp" > $@
-
- #################################################### CFU
- # CFU FILES
-
diff --git a/external/icu/khmerdict.dict b/external/icu/khmerdict.dict
deleted file mode 100644
index 52605b65469d..000000000000
--- a/external/icu/khmerdict.dict
+++ /dev/null
Binary files differ
diff --git a/i18npool/qa/cppunit/test_breakiterator.cxx b/i18npool/qa/cppunit/test_breakiterator.cxx
index 567fec5d8580..be4dd6d13935 100644
--- a/i18npool/qa/cppunit/test_breakiterator.cxx
+++ b/i18npool/qa/cppunit/test_breakiterator.cxx
@@ -39,28 +39,29 @@ public:
void testWeak();
void testAsian();
void testThai();
-#if (U_ICU_VERSION_MAJOR_NUM > 51)
void testLao();
#ifdef TODO
void testNorthernThai();
- void testKhmer();
-#endif
#endif
+ void testKhmer();
void testJapanese();
void testChinese();
CPPUNIT_TEST_SUITE(TestBreakIterator);
CPPUNIT_TEST(testLineBreaking);
- CPPUNIT_TEST(testWordBoundaries);
CPPUNIT_TEST(testGraphemeIteration);
CPPUNIT_TEST(testWeak);
CPPUNIT_TEST(testAsian);
CPPUNIT_TEST(testThai);
-#if (U_ICU_VERSION_MAJOR_NUM > 51)
- CPPUNIT_TEST(testLao);
#ifdef TODO
- CPPUNIT_TEST(testKhmer);
CPPUNIT_TEST(testNorthernThai);
#endif
+
+ CPPUNIT_TEST(testWordBoundaries);
+#if (U_ICU_VERSION_MAJOR_NUM > 4)
+ CPPUNIT_TEST(testKhmer);
+#endif
+#if (U_ICU_VERSION_MAJOR_NUM > 51)
+ CPPUNIT_TEST(testLao);
#endif
CPPUNIT_TEST(testJapanese);
CPPUNIT_TEST(testChinese);
@@ -883,13 +884,12 @@ void TestBreakIterator::testNorthernThai()
CPPUNIT_ASSERT_MESSAGE("Should skip full word",
aBounds.startPos == 0 && aBounds.endPos == aTest.getLength());
}
+#endif
+#if (U_ICU_VERSION_MAJOR_NUM > 4)
// Not sure if any version earlier than 49 did have Khmer word boundary
// dictionaries, 4.6 does not.
-// As of icu 54, word boundary detection for Khmer is still considered
-// insufficient, so icu khmer stuff is disabled
-
//A test to ensure that our khmer word boundary detection is useful
//https://bugs.libreoffice.org/show_bug.cgi?id=52020
void TestBreakIterator::testKhmer()
diff --git a/i18npool/source/breakiterator/breakiterator_unicode.cxx b/i18npool/source/breakiterator/breakiterator_unicode.cxx
index 36786308c65f..126114c2c195 100644
--- a/i18npool/source/breakiterator/breakiterator_unicode.cxx
+++ b/i18npool/source/breakiterator/breakiterator_unicode.cxx
@@ -123,8 +123,8 @@ void SAL_CALL BreakIterator_Unicode::loadICUBreakIterator(const com::sun::star::
rbi = new OOoRuleBasedBreakIterator(udata_open("OpenOffice", "brk",
OUStringToOString(breakRules[breakType], RTL_TEXTENCODING_ASCII_US).getStr(), &status), status);
}
- //use icu's breakiterator for Thai, Tibetan and Dzongkha
- else if (rLocale.Language != "th" && rLocale.Language != "lo" && rLocale.Language != "bo" && rLocale.Language != "dz")
+ //use icu's breakiterator for Thai, Khmer, Tibetan and Dzongkha
+ else if (rLocale.Language != "th" && rLocale.Language != "lo" && rLocale.Language != "km" && rLocale.Language != "bo" && rLocale.Language != "dz")
{
status = U_ZERO_ERROR;
OStringBuffer aUDName(64);
diff --git a/include/osl/endian.h b/include/osl/endian.h
index 34efcd9367cb..0819deebba41 100644
--- a/include/osl/endian.h
+++ b/include/osl/endian.h
@@ -68,13 +68,6 @@ extern "C" {
# endif
#endif
-#ifdef EMSCRIPTEN
-# include <endian.h>
-# ifndef _LITTLE_ENDIAN
-# define _LITTLE_ENDIAN
-# endif
-#endif
-
#ifdef NETBSD
# include <machine/endian.h>
# if BYTE_ORDER == LITTLE_ENDIAN
@@ -139,8 +132,7 @@ extern "C" {
!defined(AIX) && !defined(OPENBSD) && \
!defined(SOLARIS) && !defined(MACOSX) && !defined(FREEBSD) && \
!defined(DRAGONFLY) && \
- !defined(IOS) && !defined(ANDROID) && \
- !defined(EMSCRIPTEN)
+ !defined(IOS) && !defined(ANDROID)
# error "Target platform not specified !"
#endif
diff --git a/include/sal/alloca.h b/include/sal/alloca.h
index ad4f512f7ff0..dfa808967a91 100644
--- a/include/sal/alloca.h
+++ b/include/sal/alloca.h
@@ -20,7 +20,7 @@
#ifndef INCLUDED_SAL_ALLOCA_H
#define INCLUDED_SAL_ALLOCA_H
-#if defined (SOLARIS) || defined (LINUX) || defined(AIX) || defined(ANDROID) || defined(EMSCRIPTEN)
+#if defined (SOLARIS) || defined (LINUX) || defined(AIX) || defined(ANDROID)
#ifndef INCLUDED_ALLOCA_H
#include <alloca.h>
diff --git a/include/sal/config.h b/include/sal/config.h
index c86b12ffd9f9..e891a6b09424 100644
--- a/include/sal/config.h
+++ b/include/sal/config.h
@@ -63,16 +63,6 @@
#define SAL_CONFIGFILE( name ) name "rc"
#endif
-#ifdef EMSCRIPTEN
-#define SAL_UNX
-#define SAL_DLLEXTENSION ".bc"
-#define SAL_DLLPREFIX "lib"
-#define SAL_PATHSEPARATOR ':'
-#define SAL_PATHDELIMITER '/'
-#define SAL_NEWLINE_STRING "\n"
-#define SAL_CONFIGFILE( name ) name "rc"
-#endif
-
#ifdef MACOSX
#define SAL_UNX
#define SAL_DLLEXTENSION ".dylib"
diff --git a/sal/osl/unx/socket.cxx b/sal/osl/unx/socket.cxx
index 7de16d6e0d1f..6aba809bce4f 100644
--- a/sal/osl/unx/socket.cxx
+++ b/sal/osl/unx/socket.cxx
@@ -728,7 +728,7 @@ static struct hostent* _osl_gethostbyname_r (
const char *name, struct hostent *result,
char *buffer, int buflen, int *h_errnop)
{
-#if defined(LINUX) || defined(ANDROID) || defined(FREEBSD) || defined(DRAGONFLY) || defined(EMSCRIPTEN)
+#if defined(LINUX) || defined(ANDROID) || defined(FREEBSD) || defined(DRAGONFLY)
struct hostent *__result; /* will be the same as result */
int __error;
__error = gethostbyname_r (name, result, buffer, buflen,
diff --git a/sal/osl/unx/system.hxx b/sal/osl/unx/system.hxx
index cca52ddf12bc..75c3d9d90d36 100644
--- a/sal/osl/unx/system.hxx
+++ b/sal/osl/unx/system.hxx
@@ -92,7 +92,7 @@
#endif
-#if defined(ANDROID) || defined(EMSCRIPTEN)
+#ifdef ANDROID
# include <pthread.h>
# include <sys/file.h>
# include <sys/ioctl.h>
@@ -280,8 +280,7 @@ int macxp_resolveAlias(char *path, int buflen);
!defined(AIX) && \
!defined(SOLARIS) && !defined(MACOSX) && \
!defined(OPENBSD) && !defined(DRAGONFLY) && \
- !defined(IOS) && !defined(ANDROID) && \
- !defined(EMSCRIPTEN)
+ !defined(IOS) && !defined(ANDROID)
# error "Target platform not specified!"
#endif
diff --git a/solenv/gbuild/platform/EMSCRIPTEN_INTEL_emcc.mk b/solenv/gbuild/platform/EMSCRIPTEN_INTEL_emcc.mk
deleted file mode 100644
index 7619db753db3..000000000000
--- a/solenv/gbuild/platform/EMSCRIPTEN_INTEL_emcc.mk
+++ /dev/null
@@ -1,18 +0,0 @@
-# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
-#
-# This file is part of the LibreOffice project.
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-#
-
-ifeq ($(DISABLE_DYNLOADING),TRUE)
-gb_UnoApiHeadersTarget_select_variant = $(if $(filter udkapi,$(1)),comprehensive,$(2))
-else
-gb_UnoApiHeadersTarget_select_variant = $(2)
-endif
-
-include $(GBUILDDIR)/platform/unxgcc.mk
-
-# vim: set noet sw=4 ts=4:
diff --git a/vcl/Library_vcl.mk b/vcl/Library_vcl.mk
index 05d390085bc8..c6b33e64272d 100644
--- a/vcl/Library_vcl.mk
+++ b/vcl/Library_vcl.mk
@@ -616,13 +616,9 @@ $(eval $(call gb_Library_use_libraries,vcl,\
))
$(eval $(call gb_Library_use_externals,vcl,\
+ fontconfig \
freetype \
))
-ifneq ($(OS),EMSCRIPTEN)
- $(eval $(call gb_Library_use_externals,vcl,\
- fontconfig \
- ))
-endif
endif
ifeq ($(OS),ANDROID)