From b52138122f4e3a04a2500b9a5c8ec980799c0ce4 Mon Sep 17 00:00:00 2001 From: Peter Edberg Date: Mon, 25 Oct 2010 22:37:20 +0000 Subject: [PATCH] ICU-8046 CLDR 1.9 integration pass 3 (CLDR r5147, still minus 14 transliterators) X-SVN-Rev: 28906 --- .gitattributes | 3 + icu4c/source/data/brkitr/brkfiles.mk | 4 +- icu4c/source/data/brkitr/fi.txt | 14 + icu4c/source/data/brkitr/line_fi.txt | 653 ++++++++++++++++++++++++++ icu4c/source/data/curr/my.txt | 2 +- icu4c/source/data/lang/my.txt | 2 +- icu4c/source/data/locales/my.txt | 9 +- icu4c/source/data/region/my.txt | 2 +- icu4c/source/data/xml/brkitr/fi.xml | 25 + icu4c/source/data/zone/my.txt | 2 +- icu4c/source/test/cintltst/cbiapts.c | 97 +++- icu4c/source/test/cintltst/cldrtest.c | 2 +- 12 files changed, 801 insertions(+), 14 deletions(-) create mode 100644 icu4c/source/data/brkitr/fi.txt create mode 100644 icu4c/source/data/brkitr/line_fi.txt create mode 100644 icu4c/source/data/xml/brkitr/fi.xml diff --git a/.gitattributes b/.gitattributes index c3747b17db0..c512406be73 100644 --- a/.gitattributes +++ b/.gitattributes @@ -53,7 +53,9 @@ icu4c/source/allinone/icucheck.bat -text icu4c/source/common/common.vcxproj -text icu4c/source/common/common.vcxproj.filters -text icu4c/source/config/mh-haiku -text +icu4c/source/data/brkitr/fi.txt -text icu4c/source/data/brkitr/he.txt -text +icu4c/source/data/brkitr/line_fi.txt -text icu4c/source/data/brkitr/line_he.txt -text icu4c/source/data/coll/my.txt -text icu4c/source/data/coll/my_MM.txt -text @@ -98,6 +100,7 @@ icu4c/source/data/translit/ro_FONIPA_ja.txt -text icu4c/source/data/translit/ro_ja.txt -text icu4c/source/data/translit/sk_FONIPA_ja.txt -text icu4c/source/data/translit/sk_ja.txt -text +icu4c/source/data/xml/brkitr/fi.xml -text icu4c/source/data/xml/brkitr/he.xml -text icu4c/source/data/xml/collation/en_US.xml -text icu4c/source/data/xml/collation/en_US_POSIX.xml -text diff --git a/icu4c/source/data/brkitr/brkfiles.mk b/icu4c/source/data/brkitr/brkfiles.mk index c446b7d5249..324f6d3b22f 100644 --- a/icu4c/source/data/brkitr/brkfiles.mk +++ b/icu4c/source/data/brkitr/brkfiles.mk @@ -38,10 +38,10 @@ BRK_CTD_SOURCE = thaidict.txt # List of break iterator files (brk). -BRK_SOURCE = sent_el.txt word_POSIX.txt line_he.txt word_ja.txt char.txt word.txt line.txt sent.txt title.txt char_th.txt +BRK_SOURCE = sent_el.txt word_POSIX.txt line_fi.txt line_he.txt word_ja.txt char.txt word.txt line.txt sent.txt title.txt char_th.txt # Ordinary resources BRK_RES_SOURCE = el.txt en.txt en_US.txt en_US_POSIX.txt\ - he.txt ja.txt th.txt + fi.txt he.txt ja.txt th.txt diff --git a/icu4c/source/data/brkitr/fi.txt b/icu4c/source/data/brkitr/fi.txt new file mode 100644 index 00000000000..bf22c89be6e --- /dev/null +++ b/icu4c/source/data/brkitr/fi.txt @@ -0,0 +1,14 @@ +// *************************************************************************** +// * +// * Copyright (C) 2010 International Business Machines +// * Corporation and others. All Rights Reserved. +// * Tool: com.ibm.icu.dev.tool.cldr.LDML2ICUConverter.java +// * Source File:/xml/brkitr/fi.xml +// * +// *************************************************************************** +fi{ + Version{"2.2.89.3"} + boundaries{ + sentence:process(dependency){"line_fi.brk"} + } +} diff --git a/icu4c/source/data/brkitr/line_fi.txt b/icu4c/source/data/brkitr/line_fi.txt new file mode 100644 index 00000000000..5686da65d86 --- /dev/null +++ b/icu4c/source/data/brkitr/line_fi.txt @@ -0,0 +1,653 @@ +# Copyright (c) 2002-2010 International Business Machines Corporation and +# others. All Rights Reserved. +# +# file: line_fi.txt +# +# Line Breaking Rules +# Implement default line breaking as defined by +# Unicode Standard Annex #14 Revision 24 for Unicode 6.0 +# http://www.unicode.org/reports/tr14/ +# +# TODO: Rule LB 8 remains as it was in Unicode 5.2 +# This is only because of a limitation of ICU break engine implementation, +# not because the older behavior is desirable. + +# +# Character Classes defined by TR 14. +# + +!!chain; +!!LBCMNoChain; + + +!!lookAheadHardBreak; +# +# !!lookAheadHardBreak Described here because it is (as yet) undocumented elsewhere +# and only used for the line break rules. +# +# It is used in the implementation of rule LB 10 +# which says to treat any combining mark that is not attached to a base +# character as if it were of class AL (alphabetic). +# +# The problem occurs in the reverse rules. +# +# Consider a sequence like, with correct breaks as shown +# LF ID CM AL AL +# ^ ^ ^ +# Then consider the sequence without the initial ID (ideographic) +# LF CM AL AL +# ^ ^ +# Our CM, which in the first example was attached to the ideograph, +# is now unattached, becomes an alpha, and joins in with the other +# alphas. +# +# When iterating forwards, these sequences do not present any problems +# When iterating backwards, we need to look ahead when encountering +# a CM to see whether it attaches to something further on or not. +# (Look-ahead in a reverse rule is looking towards the start) +# +# If the CM is unattached, we need to force a break. +# +# !!lookAheadHardBreak forces the run time state machine to +# stop immediately when a look ahead rule ( '/' operator) matches, +# and set the match position to that of the look-ahead operator, +# no matter what other rules may be in play at the time. +# +# See rule LB 19 for an example. +# + +$AI = [:LineBreak = Ambiguous:]; +$AL = [:LineBreak = Alphabetic:]; +$BA = [[:LineBreak = Break_After:] - [\u2010]]; +$HH = [\u2010]; +$BB = [:LineBreak = Break_Before:]; +$BK = [:LineBreak = Mandatory_Break:]; +$B2 = [:LineBreak = Break_Both:]; +$CB = [:LineBreak = Contingent_Break:]; +$CL = [:LineBreak = Close_Punctuation:]; +$CM = [:LineBreak = Combining_Mark:]; +$CP = [:LineBreak = Close_Parenthesis:]; +$CR = [:LineBreak = Carriage_Return:]; +$EX = [:LineBreak = Exclamation:]; +$GL = [:LineBreak = Glue:]; +$HY = [:LineBreak = Hyphen:]; +$H2 = [:LineBreak = H2:]; +$H3 = [:LineBreak = H3:]; +$ID = [:LineBreak = Ideographic:]; +$IN = [:LineBreak = Inseperable:]; +$IS = [:LineBreak = Infix_Numeric:]; +$JL = [:LineBreak = JL:]; +$JV = [:LineBreak = JV:]; +$JT = [:LineBreak = JT:]; +$LF = [:LineBreak = Line_Feed:]; +$NL = [:LineBreak = Next_Line:]; +$NS = [:LineBreak = Nonstarter:]; +$NU = [:LineBreak = Numeric:]; +$OP = [:LineBreak = Open_Punctuation:]; +$PO = [:LineBreak = Postfix_Numeric:]; +$PR = [:LineBreak = Prefix_Numeric:]; +$QU = [:LineBreak = Quotation:]; +$SA = [:LineBreak = Complex_Context:]; +$SG = [:LineBreak = Surrogate:]; +$SP = [:LineBreak = Space:]; +$SY = [:LineBreak = Break_Symbols:]; +$WJ = [:LineBreak = Word_Joiner:]; +$XX = [:LineBreak = Unknown:]; +$ZW = [:LineBreak = ZWSpace:]; + +# Dictionary character set, for triggering language-based break engines. Currently +# limited to LineBreak=Complex_Context. Note that this set only works in Unicode +# 5.0 or later as the definition of Complex_Context was corrected to include all +# characters requiring dictionary break. + +$dictionary = [:LineBreak = Complex_Context:]; + +# +# Rule LB1. By default, treat AI (characters with ambiguous east Asian width), +# SA (South East Asian: Thai, Lao, Khmer) +# SG (Unpaired Surrogates) +# XX (Unknown, unassigned) +# as $AL (Alphabetic) +# +$ALPlus = [$AL $AI $SA $SG $XX]; + +# +# Combining Marks. X $CM* behaves as if it were X. Rule LB6. +# +$ALcm = $ALPlus $CM*; +$BAcm = $BA $CM*; +$HHcm = $HH $CM*; +$BBcm = $BB $CM*; +$B2cm = $B2 $CM*; +$CLcm = $CL $CM*; +$CPcm = $CP $CM*; +$EXcm = $EX $CM*; +$GLcm = $GL $CM*; +$HYcm = $HY $CM*; +$H2cm = $H2 $CM*; +$H3cm = $H3 $CM*; +$IDcm = $ID $CM*; +$INcm = $IN $CM*; +$IScm = $IS $CM*; +$JLcm = $JL $CM*; +$JVcm = $JV $CM*; +$JTcm = $JT $CM*; +$NScm = $NS $CM*; +$NUcm = $NU $CM*; +$OPcm = $OP $CM*; +$POcm = $PO $CM*; +$PRcm = $PR $CM*; +$QUcm = $QU $CM*; +$SYcm = $SY $CM*; +$WJcm = $WJ $CM*; + +## ------------------------------------------------- + +!!forward; + +# +# Each class of character can stand by itself as an unbroken token, with trailing combining stuff +# +$ALPlus $CM+; +$BA $CM+; +$HH $CM+; +$BB $CM+; +$B2 $CM+; +$CL $CM+; +$CP $CM+; +$EX $CM+; +$GL $CM+; +$HY $CM+; +$H2 $CM+; +$H3 $CM+; +$ID $CM+; +$IN $CM+; +$IS $CM+; +$JL $CM+; +$JV $CM+; +$JT $CM+; +$NS $CM+; +$NU $CM+; +$OP $CM+; +$PO $CM+; +$PR $CM+; +$QU $CM+; +$SY $CM+; +$WJ $CM+; + +# +# CAN_CM is the set of characters that may combine with CM combining chars. +# Note that Linebreak UAX 14's concept of a combining char and the rules +# for what they can combine with are _very_ different from the rest of Unicode. +# +# Note that $CM itself is left out of this set. If CM is needed as a base +# it must be listed separately in the rule. +# +$CAN_CM = [^$SP $BK $CR $LF $NL $ZW $CM]; # Bases that can take CMs +$CANT_CM = [ $SP $BK $CR $LF $NL $ZW $CM]; # Bases that can't take CMs + +# +# AL_FOLLOW set of chars that can unconditionally follow an AL +# Needed in rules where stand-alone $CM s are treated as AL. +# Chaining is disabled with CM because it causes other failures, +# so for this one case we need to manually list out longer sequences. +# +$AL_FOLLOW_NOCM = [$BK $CR $LF $NL $ZW $SP]; +$AL_FOLLOW_CM = [$CL $CP $EX $IS $SY $WJ $GL $OP $QU $BA $HH $HY $NS $IN $NU $ALPlus]; +$AL_FOLLOW = [$AL_FOLLOW_NOCM $AL_FOLLOW_CM]; + + +# +# Rule LB 4, 5 Mandatory (Hard) breaks. +# +$LB4Breaks = [$BK $CR $LF $NL]; +$LB4NonBreaks = [^$BK $CR $LF $NL]; +$CR $LF {100}; + +# +# LB 6 Do not break before hard line breaks. +# +$LB4NonBreaks? $LB4Breaks {100}; # LB 5 do not break before hard breaks. +$CAN_CM $CM* $LB4Breaks {100}; +$CM+ $LB4Breaks {100}; + +# LB 7 x SP +# x ZW +$LB4NonBreaks [$SP $ZW]; +$CAN_CM $CM* [$SP $ZW]; +$CM+ [$SP $ZW]; + +# +# LB 8 Break after zero width space +# TODO: ZW SP* +# An engine change is required to write the reverse rule for this. +# For now, leave the Unicode 5.2 rule, ZW +# +$LB8Breaks = [$LB4Breaks $ZW]; +$LB8NonBreaks = [[$LB4NonBreaks] - [$ZW]]; + + +# LB 9 Combining marks. X $CM needs to behave like X, where X is not $SP, $BK $CR $LF $NL +# $CM not covered by the above needs to behave like $AL +# See definition of $CAN_CM. + +$CAN_CM $CM+; # Stick together any combining sequences that don't match other rules. +$CM+; + +# +# LB 11 Do not break before or after WORD JOINER & related characters. +# +$CAN_CM $CM* $WJcm; +$LB8NonBreaks $WJcm; +$CM+ $WJcm; + +$WJcm $CANT_CM; +$WJcm $CAN_CM $CM*; + +# +# LB 12 Do not break after NBSP and related characters. +# GL x +# +$GLcm $CAN_CM $CM*; +$GLcm $CANT_CM; + +# +# LB 12a Do not break before NBSP and related characters ... +# [^SP BA HY] x GL +# +[[$LB8NonBreaks] - [$SP $BA $HH $HY]] $CM* $GLcm; +$CM+ GLcm; + + + +# +# LB 13 Don't break before ']' or '!' or ';' or '/', even after spaces. +# +$LB8NonBreaks $CL; +$CAN_CM $CM* $CL; +$CM+ $CL; # by rule 10, stand-alone CM behaves as AL + +$LB8NonBreaks $CP; +$CAN_CM $CM* $CP; +$CM+ $CP; # by rule 10, stand-alone CM behaves as AL + +$LB8NonBreaks $EX; +$CAN_CM $CM* $EX; +$CM+ $EX; # by rule 10, stand-alone CM behaves as AL + +$LB8NonBreaks $IS; +$CAN_CM $CM* $IS; +$CM+ $IS; # by rule 10, stand-alone CM behaves as AL + +$LB8NonBreaks $SY; +$CAN_CM $CM* $SY; +$CM+ $SY; # by rule 10, stand-alone CM behaves as AL + + +# +# LB 14 Do not break after OP, even after spaces +# +$OPcm $SP* $CAN_CM $CM*; +$OPcm $SP* $CANT_CM; + +$OPcm $SP+ $CM+ $AL_FOLLOW?; # by rule 10, stand-alone CM behaves as AL + +# LB 15 +$QUcm $SP* $OPcm; + +# LB 16 +($CLcm | $CPcm) $SP* $NScm; + +# LB 17 +$B2cm $SP* $B2cm; + +# +# LB 18 Break after spaces. +# +$LB18NonBreaks = [$LB8NonBreaks - [$SP]]; +$LB18Breaks = [$LB8Breaks $SP]; + + +# LB 19 +# x QU +$LB18NonBreaks $CM* $QUcm; +$CM+ $QUcm; + +# QU x +$QUcm .?; +$QUcm $LB18NonBreaks $CM*; # Don't let a combining mark go onto $CR, $BK, etc. + # TODO: I don't think this rule is needed. + + +# LB 20 +# $CB +# $CB + +$LB20NonBreaks = [$LB18NonBreaks - $CB]; + +# LB 20.09 added rule for Finnish tailoring +$SP / ($HY | $HH) $AL; + +# LB 21 x (BA | HY | NS) +# BB x +# +$LB20NonBreaks $CM* ($BAcm | $HHcm | $HYcm | $NScm); + +$BBcm [^$CB]; # $BB x +$BBcm $LB20NonBreaks $CM*; + +# LB 22 +$ALcm $INcm; +$CM+ $INcm; # by rule 10, any otherwise unattached CM behaves as AL +$IDcm $INcm; +$INcm $INcm; +$NUcm $INcm; + + +# $LB 23 +$IDcm $POcm; +$ALcm $NUcm; # includes $LB19 +$CM+ $NUcm; # Rule 10, any otherwise unattached CM behaves as AL +$NUcm $ALcm; + +# +# LB 24 +# +$PRcm $IDcm; +$PRcm $ALcm; +$POcm $ALcm; + +# +# LB 25 Numbers. +# +($PRcm | $POcm)? ($OPcm | $HYcm)? $NUcm ($NUcm | $SYcm | $IScm)* ($CLcm | $CPcm)? ($PRcm | $POcm)?; + +# LB 26 Do not break a Korean syllable +# +$JLcm ($JLcm | $JVcm | $H2cm | $H3cm); +($JVcm | $H2cm) ($JVcm | $JTcm); +($JTcm | $H3cm) $JTcm; + +# LB 27 Treat korean Syllable Block the same as ID (don't break it) +($JLcm | $JVcm | $JTcm | $H2cm | $H3cm) $INcm; +($JLcm | $JVcm | $JTcm | $H2cm | $H3cm) $POcm; +$PRcm ($JLcm | $JVcm | $JTcm | $H2cm | $H3cm); + + +# LB 28 Do not break between alphabetics +# +$ALcm $ALcm; +$CM+ $ALcm; # The $CM+ is from rule 10, an unattached CM is treated as AL + +# LB 29 +$IScm $ALcm; + +# LB 30 +($ALcm | $NUcm) $OPcm; +$CM+ $OPcm; # The $CM+ is from rule 10, an unattached CM is treated as AL. +$CPcm ($ALcm | $NUcm); + + +# +# Reverse Rules. +# +## ------------------------------------------------- + +!!reverse; + +$CM+ $ALPlus; +$CM+ $BA; +$CM+ $HH; +$CM+ $BB; +$CM+ $B2; +$CM+ $CL; +$CM+ $CP; +$CM+ $EX; +$CM+ $GL; +$CM+ $HY; +$CM+ $H2; +$CM+ $H3; +$CM+ $ID; +$CM+ $IN; +$CM+ $IS; +$CM+ $JL; +$CM+ $JV; +$CM+ $JT; +$CM+ $NS; +$CM+ $NU; +$CM+ $OP; +$CM+ $PO; +$CM+ $PR; +$CM+ $QU; +$CM+ $SY; +$CM+ $WJ; +$CM+; + + +# +# Sequences of the form (shown forwards) +# [CANT_CM] [CM] [whatever] +# The CM needs to behave as an AL +# +$AL_FOLLOW $CM+ / ( + [$BK $CR $LF $NL $ZW {eof}] | + $SP+ $CM+ $SP | + $SP+ $CM* ([^$OP $CM $SP] | [$AL {eof}])); # if LB 14 will match, need to surpress this break. + # LB14 says OP SP* x . + # becomes OP SP* x AL + # becomes OP SP* x CM+ AL_FOLLOW + # + # Further note: the $AL in [$AL {eof}] is only to work around + # a rule compiler bug which complains about + # empty sets otherwise. + +# +# Sequences of the form (shown forwards) +# [CANT_CM] [CM] [PR] +# The CM needs to behave as an AL +# This rule is concerned about getting the second of the two in place. +# + +[$PR ] / $CM+ [$BK $CR $LF $NL $ZW $SP {eof}]; + + + +# LB 4, 5, 5 + +$LB4Breaks [$LB4NonBreaks-$CM]; +$LB4Breaks $CM+ $CAN_CM; +$LF $CR; + + +# LB 7 x SP +# x ZW +[$SP $ZW] [$LB4NonBreaks-$CM]; +[$SP $ZW] $CM+ $CAN_CM; + +# LB 8 ZW SP* +# TODO: to implement this, we need more than one look-ahead hard break in play at a time. +# Requires an engine enhancement. +# / $SP* $ZW + +# LB 9,10 Combining marks. +# X $CM needs to behave like X, where X is not $SP or controls. +# $CM not covered by the above needs to behave like $AL +# Stick together any combining sequences that don't match other rules. +$CM+ $CAN_CM; + + +# LB 11 +$CM* $WJ $CM* $CAN_CM; +$CM* $WJ [$LB8NonBreaks-$CM]; + + $CANT_CM $CM* $WJ; +$CM* $CAN_CM $CM* $WJ; + +# LB 12a +# [^SP BA HY] x GL +# +$CM* $GL $CM* [$LB8NonBreaks-[$CM $SP $BA $HH $HY]]; + +# LB 12 +# GL x +# +$CANT_CM $CM* $GL; +$CM* $CAN_CM $CM* $GL; + + +# LB 13 +$CL $CM+ $CAN_CM; +$CP $CM+ $CAN_CM; +$EX $CM+ $CAN_CM; +$IS $CM+ $CAN_CM; +$SY $CM+ $CAN_CM; + +$CL [$LB8NonBreaks-$CM]; +$CP [$LB8NonBreaks-$CM]; +$EX [$LB8NonBreaks-$CM]; +$IS [$LB8NonBreaks-$CM]; +$SY [$LB8NonBreaks-$CM]; + +# Rule 13 & 14 taken together for an edge case. +# Match this, shown forward +# OP SP+ ($CM+ behaving as $AL) (CL | CP | EX | IS | IY) +# This really wants to chain at the $CM+ (which is acting as an $AL) +# except for $CM chaining being disabled. +[$CL $CP $EX $IS $SY] $CM+ $SP+ $CM* $OP; + +# LB 14 OP SP* x +# +$CM* $CAN_CM $SP* $CM* $OP; + $CANT_CM $SP* $CM* $OP; +$AL_FOLLOW? $CM+ $SP $SP* $CM* $OP; # by LB 10, behaves like $AL_FOLLOW? $AL $SP* $CM* $OP + + $AL_FOLLOW_NOCM $CM+ $SP+ $CM* $OP; +$CM* $AL_FOLLOW_CM $CM+ $SP+ $CM* $OP; +$SY $CM $SP+ $OP; # TODO: Experiment. Remove. + + + +# LB 15 +$CM* $OP $SP* $CM* $QU; + +# LB 16 +$CM* $NS $SP* $CM* ($CL | $CP); + +# LB 17 +$CM* $B2 $SP* $CM* $B2; + +# LB 18 break after spaces +# Nothing explicit needed here. + + +# +# LB 19 +# +$CM* $QU $CM* $CAN_CM; # . x QU +$CM* $QU $LB18NonBreaks; + + +$CM* $CAN_CM $CM* $QU; # QU x . + $CANT_CM $CM* $QU; + +# +# LB 20 Break before and after CB. +# nothing needed here. +# + +# LB 20.09 added rule for Finnish tailoring +$AL ($HY | $HH) / $SP; + +# LB 21 +$CM* ($BA | $HH | $HY | $NS) $CM* [$LB20NonBreaks-$CM]; # . x (BA | HY | NS) + +$CM* [$LB20NonBreaks-$CM] $CM* $BB; # BB x . +[^$CB] $CM* $BB; # + + + +# LB 22 +$CM* $IN $CM* $ALPlus; +$CM* $IN $CM* $ID; +$CM* $IN $CM* $IN; +$CM* $IN $CM* $NU; + +# LB 23 +$CM* $PO $CM* $ID; +$CM* $NU $CM* $ALPlus; +$CM* $ALPlus $CM* $NU; + +# LB 24 +$CM* $ID $CM* $PR; +$CM* $ALPlus $CM* $PR; +$CM* $ALPlus $CM* $PO; + + +# LB 25 +($CM* ($PR | $PO))? ($CM* ($CL | $CP))? ($CM* ($NU | $IS | $SY))* $CM* $NU ($CM* ($OP | $HY))? ($CM* ($PR | $PO))?; + +# LB 26 +$CM* ($H3 | $H2 | $JV | $JL) $CM* $JL; +$CM* ($JT | $JV) $CM* ($H2 | $JV); +$CM* $JT $CM* ($H3 | $JT); + +# LB 27 +$CM* $IN $CM* ($H3 | $H2 | $JT | $JV | $JL); +$CM* $PO $CM* ($H3 | $H2 | $JT | $JV | $JL); +$CM* ($H3 | $H2 | $JT | $JV | $JL) $CM* $PR; + +# LB 28 +$CM* $ALPlus $CM* $ALPlus; + + +# LB 29 +$CM* $ALPlus $CM* $IS; + +# LB 30 +$CM* $OP $CM* ($ALPlus | $NU); +$CM* ($ALPlus | $NU) $CM* $CP; + + +## ------------------------------------------------- + +!!safe_reverse; + +# LB 9 +$CM+ [^$CM $BK $CR $LF $NL $ZW $SP]; +$CM+ $SP / .; + +# LB 14 +$SP+ $CM* $OP; + +# LB 15 +$SP+ $CM* $QU; + +# LB 16 +$SP+ $CM* ($CL | $CP); + +# LB 17 +$SP+ $CM* $B2; + +# LB 25 +($CM* ($IS | $SY))+ $CM* $NU; +($CL | $CP) $CM* ($NU | $IS | $SY); + +# For dictionary-based break +$dictionary $dictionary; + +## ------------------------------------------------- + +!!safe_forward; + +# Skip forward over all character classes that are involved in +# rules containing patterns with possibly more than one char +# of context. +# +# It might be slightly more efficient to have specific rules +# instead of one generic one, but only if we could +# turn off rule chaining. We don't want to move more +# than necessary. +# +[$CM $OP $QU $CL $CP $B2 $PR $HY $SP $dictionary]+ [^$CM $OP $QU $CL $CP $B2 $PR $HY $dictionary]; +$dictionary $dictionary; + diff --git a/icu4c/source/data/curr/my.txt b/icu4c/source/data/curr/my.txt index 10330ccb631..ce2a1262117 100644 --- a/icu4c/source/data/curr/my.txt +++ b/icu4c/source/data/curr/my.txt @@ -328,5 +328,5 @@ my{ "ဇင်ဘာဘွေ ဒေါ်လာ", } } - Version{"2.0.51.24"} + Version{"2.0.51.46"} } diff --git a/icu4c/source/data/lang/my.txt b/icu4c/source/data/lang/my.txt index f930fea41f1..c5bfbde537c 100644 --- a/icu4c/source/data/lang/my.txt +++ b/icu4c/source/data/lang/my.txt @@ -223,7 +223,7 @@ my{ REVISED{"ပြန်လည်စီစစ်ထားသော ရေးထုံး"} SCOTLAND{"စကော့ စံ အင်္ဂလိပ်"} } - Version{"2.0.51.24"} + Version{"2.0.51.46"} codePatterns{ language{"ဘာသာစကား - {0}"} script{"စာ - {0}"} diff --git a/icu4c/source/data/locales/my.txt b/icu4c/source/data/locales/my.txt index 4ba546e0615..eb63c7a6f42 100644 --- a/icu4c/source/data/locales/my.txt +++ b/icu4c/source/data/locales/my.txt @@ -10,13 +10,10 @@ * ICU source: /xml/main/my.xml */ my{ - AuxExemplarCharacters{ - "[\u1022 \u1028 \u1037 \u1039 \u103A \u1050-\u1062 \u1065-\u1068 \u106E-" - "\u1086 \u108E \u109C-\u109D]" - } + AuxExemplarCharacters{"[\u1022 \u1028 \u1050-\u1059]"} ExemplarCharacters{ "[က ခ ဂ ဃ င စ ဆ ဇ ဈ ဉ ည ဋ ဌ ဍ ဎ ဏ တ ထ ဒ ဓ န ပ ဖ ဗ ဘ မ ယ ရ လ ဝ သ ဟ ဠ အ ဣ ဤ ဥ ဦ" - " ဧ ဩ ဪ \u102B-\u1032 \u1036 \u1038 \u103B-\u103E]" + " ဧ ဩ ဪ ဿ \u102B-\u1032 \u1036-\u103E]" } ExemplarCharactersCurrency{"[a b c d e f g h i j k l m n o p q r s t u v w x y z]"} ExemplarCharactersIndex{"[က ခ ဂ ဃ င စ ဆ ဇ ဈ ဉ ည ဋ ဌ ဍ ဎ ဏ တ ထ ဒ ဓ န ပ ဖ ဗ ဘ မ ယ ရ လ ဝ သ ဟ ဠ အ]"} @@ -44,7 +41,7 @@ my{ } } } - Version{"2.0.51.24"} + Version{"2.0.51.46"} calendar{ gregorian{ AmPmMarkers{ diff --git a/icu4c/source/data/region/my.txt b/icu4c/source/data/region/my.txt index d4d12b2e159..5ffdcd90cac 100644 --- a/icu4c/source/data/region/my.txt +++ b/icu4c/source/data/region/my.txt @@ -221,5 +221,5 @@ my{ ZW{"ဇင်ဘာဘွေ"} ZZ{"မသိ သို့မဟုတ် မရှိ သော နေရာ"} } - Version{"2.0.51.24"} + Version{"2.0.51.46"} } diff --git a/icu4c/source/data/xml/brkitr/fi.xml b/icu4c/source/data/xml/brkitr/fi.xml new file mode 100644 index 00000000000..9eaa82b3cec --- /dev/null +++ b/icu4c/source/data/xml/brkitr/fi.xml @@ -0,0 +1,25 @@ + + + + %icu; +] +> + + + + + + + + + + + + + + + diff --git a/icu4c/source/data/zone/my.txt b/icu4c/source/data/zone/my.txt index 9ef95adc97a..b68fcd565ac 100644 --- a/icu4c/source/data/zone/my.txt +++ b/icu4c/source/data/zone/my.txt @@ -10,7 +10,7 @@ * ICU source: /xml/main/my.xml */ my{ - Version{"2.0.51.24"} + Version{"2.0.51.46"} zoneStrings{ "America:Anchorage"{ ec{"အန်ကာရေ့ဂျ်"} diff --git a/icu4c/source/test/cintltst/cbiapts.c b/icu4c/source/test/cintltst/cbiapts.c index 12cbbb4b8c4..9d53eb1b7e1 100644 --- a/icu4c/source/test/cintltst/cbiapts.c +++ b/icu4c/source/test/cintltst/cbiapts.c @@ -1,6 +1,6 @@ /******************************************************************** * COPYRIGHT: - * Copyright (c) 1997-2009, International Business Machines Corporation and + * Copyright (c) 1997-2010, International Business Machines Corporation and * others. All Rights Reserved. ********************************************************************/ /******************************************************************************** @@ -43,6 +43,7 @@ static void TestBreakIteratorRules(void); static void TestBreakIteratorRuleError(void); static void TestBreakIteratorStatusVec(void); static void TestBreakIteratorUText(void); +static void TestBreakIteratorTailoring(void); void addBrkIterAPITest(TestNode** root); @@ -56,6 +57,7 @@ void addBrkIterAPITest(TestNode** root) addTest(root, &TestBreakIteratorRules, "tstxtbd/cbiapts/TestBreakIteratorRules"); addTest(root, &TestBreakIteratorRuleError, "tstxtbd/cbiapts/TestBreakIteratorRuleError"); addTest(root, &TestBreakIteratorStatusVec, "tstxtbd/cbiapts/TestBreakIteratorStatusVec"); + addTest(root, &TestBreakIteratorTailoring, "tstxtbd/cbiapts/TestBreakIteratorTailoring"); } #define CLONETEST_ITERATOR_COUNT 2 @@ -705,6 +707,99 @@ static void TestBreakIteratorUText(void) { utext_close(ut); } +/* + * static void TestBreakIteratorTailoring(void); + * + * Test break iterator tailorings from CLDR data. + */ +/* Hebrew line break tailoring, for cldrbug 3028 */ +static const UChar heTest[] = { 0x0020, 0x002D, 0x0031, 0x0032, 0x0020, + 0x0061, 0x002D, 0x006B, 0x0020, + 0x0061, 0x0300, 0x2010, 0x006B, 0x0020, + 0x05DE, 0x05D4, 0x002D, 0x0069, 0x0020, + 0x05D1, 0x05BC, 0x2010, 0x0047, 0x0020, 0 }; +static const int32_t heTestOffs_enFwd[] = { 1, 5, 7, 9, 12, 14, 17, 19, 22, 24 }; +static const int32_t heTestOffs_heFwd[] = { 1, 5, 7, 9, 12, 14, 19, 24 }; +static const int32_t heTestOffs_enRev[] = { 22, 19, 17, 14, 12, 9, 7, 5, 1, 0 }; +static const int32_t heTestOffs_heRev[] = { 19, 14, 12, 9, 7, 5, 1, 0 }; + +/* Finnish line break tailoring, for cldrbug 3029 */ +static const UChar fiTest[] = { 0x0020, 0x002D, 0x0031, 0x0032, 0x0020, + 0x0061, 0x002D, 0x006B, 0x0020, + 0x0061, 0x0300, 0x2010, 0x006B, 0x0020, + 0x0061, 0x0020, 0x002D, 0x006B, 0x0020, + 0x0061, 0x0300, 0x0020, 0x2010, 0x006B, 0x0020, 0 }; +static const int32_t fiTestOffs_enFwd[] = { 1, 5, 7, 9, 12, 14, 16, 17, 19, 22, 23, 25 }; +static const int32_t fiTestOffs_fiFwd[] = { 1, 5, 7, 9, 12, 14, 16, 19, 22, 25 }; +static const int32_t fiTestOffs_enRev[] = { 23, 22, 19, 17, 16, 14, 12, 9, 7, 5, 1, 0 }; +static const int32_t fiTestOffs_fiRev[] = { 22, 19, 16, 14, 12, 9, 7, 5, 1, 0 }; + +typedef struct { + const char * locale; + UBreakIteratorType type; + const UChar * test; + const int32_t * offsFwd; + const int32_t * offsRev; + int32_t numOffsets; +} RBBITailoringTest; + +static const RBBITailoringTest tailoringTests[] = { + { "en", UBRK_LINE, heTest, heTestOffs_enFwd, heTestOffs_enRev, sizeof(heTestOffs_enFwd)/ sizeof(heTestOffs_enFwd[0]) }, +/* { "he", UBRK_LINE, heTest, heTestOffs_heFwd, heTestOffs_heRev, sizeof(heTestOffs_heFwd)/ sizeof(heTestOffs_heFwd[0]) }, not working yet */ + { "en", UBRK_LINE, fiTest, fiTestOffs_enFwd, fiTestOffs_enRev, sizeof(fiTestOffs_enFwd)/ sizeof(fiTestOffs_enFwd[0]) }, +/* { "fi", UBRK_LINE, fiTest, fiTestOffs_fiFwd, fiTestOffs_fiRev, sizeof(fiTestOffs_fiFwd)/ sizeof(fiTestOffs_fiFwd[0]) }, not working yet */ + { NULL, 0, NULL, NULL, NULL, 0 }, +}; + +static void TestBreakIteratorTailoring(void) { + const RBBITailoringTest * testPtr; + for (testPtr = tailoringTests; testPtr->locale != NULL; ++testPtr) { + UErrorCode status = U_ZERO_ERROR; + UBreakIterator* ubrkiter = ubrk_open(testPtr->type, testPtr->locale, testPtr->test, -1, &status); + if ( U_SUCCESS(status) ) { + int32_t offset, offsindx; + UBool foundError; + + foundError = FALSE; + for (offsindx = 0; (offset = ubrk_next(ubrkiter)) != UBRK_DONE; ++offsindx) { + if (!foundError && offsindx >= testPtr->numOffsets) { + log_err("FAIL: locale %s, break type %d, ubrk_next expected UBRK_DONE, got %d\n", + testPtr->locale, testPtr->type, offset); + foundError = TRUE; + } else if (!foundError && offset != testPtr->offsFwd[offsindx]) { + log_err("FAIL: locale %s, break type %d, ubrk_next expected %d, got %d\n", + testPtr->locale, testPtr->type, testPtr->offsFwd[offsindx], offset); + foundError = TRUE; + } + } + if (!foundError && offsindx < testPtr->numOffsets) { + log_err("FAIL: locale %s, break type %d, ubrk_next expected %d, got UBRK_DONE\n", + testPtr->locale, testPtr->type, testPtr->offsFwd[offsindx]); + } + + foundError = FALSE; + for (offsindx = 0; (offset = ubrk_previous(ubrkiter)) != UBRK_DONE; ++offsindx) { + if (!foundError && offsindx >= testPtr->numOffsets) { + log_err("FAIL: locale %s, break type %d, ubrk_previous expected UBRK_DONE, got %d\n", + testPtr->locale, testPtr->type, offset); + foundError = TRUE; + } else if (!foundError && offset != testPtr->offsRev[offsindx]) { + log_err("FAIL: locale %s, break type %d, ubrk_previous expected %d, got %d\n", + testPtr->locale, testPtr->type, testPtr->offsRev[offsindx], offset); + foundError = TRUE; + } + } + if (!foundError && offsindx < testPtr->numOffsets) { + log_err("FAIL: locale %s, break type %d, ubrk_previous expected %d, got UBRK_DONE\n", + testPtr->locale, testPtr->type, testPtr->offsRev[offsindx]); + } + + ubrk_close(ubrkiter); + } else { + log_err("FAIL: locale %s, break type %d, ubrk_open status %d\n", testPtr->locale, testPtr->type, status); + } + } +} #endif /* #if !UCONFIG_NO_BREAK_ITERATION */ diff --git a/icu4c/source/test/cintltst/cldrtest.c b/icu4c/source/test/cintltst/cldrtest.c index b17c481354f..faf16eeb88a 100644 --- a/icu4c/source/test/cintltst/cldrtest.c +++ b/icu4c/source/test/cintltst/cldrtest.c @@ -985,7 +985,7 @@ static void VerifyTranslation(void) { else if (getTestOption(QUICK_OPTION) && exemplarLen > 2048) { log_verbose("skipping test for %s\n", currLoc); } - else if (uprv_strncmp(currLoc,"bem",3) == 0 || uprv_strncmp(currLoc,"my",2) == 0) { /* TODO: restore test for my* when cldrbug 3062 is fixed) */ + else if (uprv_strncmp(currLoc,"bem",3) == 0) { log_verbose("skipping test for %s, some month and country names known to use aux exemplars\n", currLoc); } else {