...

icu46/source/data/brkitr/line.txt

 # Copyright (c) 2002-2010  International Business Machines Corporation and
 # others. All Rights Reserved.
 #
 #  file:  line.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.
+#
+#         CHROME: Hebrew tailoring was incorporatd as well as some 
+#         other minor changes (CL, OP, ID).
 
 #
 #  Character Classes defined by TR 14.
 #
 
 !!chain;
 !!LBCMNoChain;
 
 
 !!lookAheadHardBreak;
@@ skipping 26 matching lines @@
 #
 #           !!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:];
+$AL = [[:LineBreak =  Alphabetic:] - [[:Hebrew:] & [:Letter:]] - [\u23B4\u23B5]];
+$HL = [[:Hebrew:] & [:Letter:]];
+$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:];
+$CL = [[:LineBreak =  Close_Punctuation:] [\uFE51\uFE10\u23B5]];
 $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:];
+$ID = [[:LineBreak =  Ideographic:] - [\uFE51]];
 $IN = [:LineBreak =  Inseperable:];
-$IS = [:LineBreak =  Infix_Numeric:];
+$IS = [[:LineBreak =  Infix_Numeric:] - [\uFE10]];
 $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:];
+$OP = [[:LineBreak =  Open_Punctuation:] \u23B4];
 $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];
+$ALPlus = [$AL $HL $AI $SA $SG $XX];
 
 #
 #  Combining Marks.   X $CM*  behaves as if it were X.  Rule LB6.
 #
 $ALcm = $ALPlus $CM*;
+$HLcm = $HL $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*;
@@ skipping 13 matching lines @@
 
 ## -------------------------------------------------
 
 !!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+;
@@ skipping 22 matching lines @@
 $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 $HY $NS $IN $NU $ALPlus];
+$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};
 
@@ skipping 41 matching lines @@
 # 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 $HY]] $CM* $GLcm;
+[[$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
@@ skipping 52 matching lines @@
 
 # LB 20
 #        <break>  $CB
 #        $CB   <break>
 
 $LB20NonBreaks = [$LB18NonBreaks - $CB];
 
 # LB 21        x   (BA | HY | NS)
 #           BB x
 #
-$LB20NonBreaks $CM* ($BAcm | $HYcm | $NScm); 
+$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;
@@ skipping 35 matching lines @@
 $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);
 
+# (LB 31) Add new rule to prevent the break we do not want, this is the behavior change
+$HLcm ($HY | $HH) $ALcm;
 
 #
 #  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;
@@ skipping 68 matching lines @@
 # 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 $HY]];
+$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;
@@ skipping 49 matching lines @@
 
 $CM* $CAN_CM  $CM* $QU;                               #   QU x .
      $CANT_CM $CM* $QU;
      
 #
 #  LB 20  Break before and after CB.
 #         nothing needed here.
 #
 
 # LB 21
-$CM* ($BA | $HY | $NS) $CM* [$LB20NonBreaks-$CM];     #  . x (BA | HY | NS)
+$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;
@@ skipping 27 matching lines @@
 $CM* $ALPlus $CM* $ALPlus;
 
 
 # LB 29
 $CM* $ALPlus $CM* $IS;
 
 # LB 30
 $CM* $OP $CM* ($ALPlus | $NU);
 $CM* ($ALPlus | $NU) $CM* $CP;
 
+# (LB 31) Add new rule to prevent the break we do not want, this is the behavior change
+$CM* $ALPlus ($HY | $HH) $CM* $HL;
 
 ## -------------------------------------------------
 
 !!safe_reverse;
 
 # LB 9
 $CM+ [^$CM $BK $CR $LF $NL $ZW $SP];
 $CM+ $SP / .;
 
 # LB 14
@@ skipping 24 matching lines @@
 #   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;