1. /*

  2.  * @(#)WordBreakData.java	1.14 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. /*

  9.  * @(#)WordBreakData.java	1.14 01/11/29

  10.  *

  11.  * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved

  12.  * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved

  13.  *

  14.  * Portions copyright (c) 1996-1998 Sun Microsystems, Inc.

  15.  * All Rights Reserved.

  16.  *

  17.  * The original version of this source code and documentation

  18.  * is copyrighted and owned by Taligent, Inc., a wholly-owned

  19.  * subsidiary of IBM. These materials are provided under terms

  20.  * of a License Agreement between Taligent and Sun. This technology

  21.  * is protected by multiple US and International patents.

  22.  *

  23.  * This notice and attribution to Taligent may not be removed.

  24.  * Taligent is a registered trademark of Taligent, Inc.

  25.  *

  26.  * Permission to use, copy, modify, and distribute this software

  27.  * and its documentation for NON-COMMERCIAL purposes and without

  28.  * fee is hereby granted provided that this copyright notice

  29.  * appears in all copies. Please refer to the file "copyright.html"

  30.  * for further important copyright and licensing information.

  31.  *

  32.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF

  33.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

  34.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

  35.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR

  36.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR

  37.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.

  38.  *

  39.  */

  40. 

  41. package java.text;

  42. 

  43. /**

  44.  * The WordBreakData contains data used by SimpleTextBoundary

  45.  * to determine word breaks.

  46.  * @see #BreakIterator

  47.  */

  48. final class WordBreakData extends TextBoundaryData

  49. {

  50.     private static final byte BREAK = 0;

  51.     private static final byte letter = 1;

  52.     private static final byte number = 2;

  53.     private static final byte midLetter = 3;

  54.     private static final byte midLetNum = 4;

  55.     private static final byte preNum = 5;

  56.     private static final byte postNum = 6;

  57.     private static final byte midNum = 7;

  58.     private static final byte preMidNum = 8;

  59.     private static final byte blank = 9;

  60.     private static final byte lf = 10;

  61.     private static final byte kata = 11;

  62.     private static final byte hira = 12;

  63.     private static final byte kanji = 13;

  64.     private static final byte diacrit = 14;

  65.     private static final byte cr = 15;

  66.     private static final byte nsm = 16;

  67.     private static final byte EOS = 17;

  68.     private static final int COL_COUNT = 18;

  69. 

  70.     private static final byte SI = (byte)0x80;

  71.     private static final byte STOP = (byte) 0;

  72.     private static final byte SI_STOP = (byte)SI + STOP;

  73. 

  74.     public WordBreakData() {

  75.         super(kWordForward, kWordBackward, kWordMap);

  76.     }

  77. 

  78.     private static final byte kWordForwardData[] =

  79.     {

  80.         // brk         let            num            mLe            mLN

  81.         // prN         poN            mNu            pMN            blk

  82.         // lf          kat            hir            kan            dia

  83.         // cr          nsm            EOS

  84. 

  85.         // 0

  86.         STOP,          STOP,          STOP,          STOP,          STOP,

  87.         STOP,          STOP,          STOP,          STOP,          STOP,

  88.         STOP,          STOP,          STOP,          STOP,          STOP,

  89.         STOP,          STOP,          STOP,

  90. 

  91.         // 1

  92.         (byte)(SI+14), (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+14), (byte)(SI+14),

  93.         (byte)(SI+5),  (byte)(SI+14), (byte)(SI+14), (byte)(SI+5),  (byte)(SI+6),

  94.         (byte)(SI+4),  (byte)(SI+10), (byte)(SI+11), (byte)(SI+12), (byte)(SI+9),

  95.         (byte)(SI+13), (byte)(1),     SI_STOP,

  96. 

  97.         // 2

  98.         SI_STOP,       (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+7),  (byte)(SI+7),

  99.         SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+7),  SI_STOP,

  100.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  101.         SI_STOP,       (byte)(2),     SI_STOP,

  102. 

  103.         // 3

  104.         SI_STOP,       (byte)(SI+2),  (byte)(SI+3),  SI_STOP,       (byte)(SI+8),

  105.         SI_STOP,       (byte)(SI+14), (byte)(SI+8),  (byte)(SI+8),  SI_STOP,

  106.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  107.         SI_STOP,       (byte)(3),     SI_STOP,

  108. 

  109.         // 4

  110.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  111.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  112.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  113.         SI_STOP,       SI_STOP,       SI_STOP,

  114. 

  115.         // 5

  116.         SI_STOP,       SI_STOP,       (byte)(SI+3),  SI_STOP,       SI_STOP,

  117.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  118.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  119.         SI_STOP,       (byte)(5),     SI_STOP,

  120. 

  121.         // 6

  122.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  123.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+6),

  124.         (byte)(SI+4),  SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  125.         (byte)(SI+13), (byte)(6),     SI_STOP,

  126. 

  127.         // 7

  128.         STOP,          (byte)(SI+2),  STOP,          STOP,          STOP,

  129.         STOP,          STOP,          STOP,          STOP,          STOP,

  130.         STOP,          STOP,          STOP,          STOP,          STOP,

  131.         STOP,          (byte)(7),     STOP,

  132. 

  133.         // 8

  134.         STOP,          STOP,          (byte)(SI+3),  STOP,          STOP,

  135.         STOP,          STOP,          STOP,          STOP,          STOP,

  136.         STOP,          STOP,          STOP,          STOP,          STOP,

  137.         STOP,          (byte)(8),     STOP,

  138. 

  139.         // 9

  140.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  141.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  142.         SI_STOP,       (byte)(SI+10), (byte)(SI+11), SI_STOP,       (byte)(SI+9),

  143.         SI_STOP,       (byte)(9),     SI_STOP,

  144. 

  145.         // 10

  146.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  147.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  148.         SI_STOP,       (byte)(SI+10), SI_STOP,       SI_STOP,       (byte)(SI+10),

  149.         SI_STOP,       (byte)(10),    SI_STOP,

  150. 

  151.         // 11

  152.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  153.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  154.         SI_STOP,       SI_STOP,       (byte)(SI+11), SI_STOP,       (byte)(SI+11),

  155.         SI_STOP,       (byte)(11),    SI_STOP,

  156. 

  157.         // 12

  158.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  159.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  160.         SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+12), SI_STOP,

  161.         SI_STOP,       (byte)(12),    SI_STOP,

  162. 

  163.         // 13

  164.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  165.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  166.         (byte)(SI+4),  SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  167.         SI_STOP,       SI_STOP,       SI_STOP,

  168. 

  169.         // 14

  170.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  171.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  172.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  173.         SI_STOP,       (byte)(14),    SI_STOP

  174.     };

  175.     private static final WordBreakTable kWordForward =

  176.     new WordBreakTable(COL_COUNT, kWordForwardData);

  177.     private static final byte kWordBackwardData[] =

  178.     {

  179.         // brk         let            num            mLe            mLN

  180.         // prN         poN            mNu            pMN            blk

  181.         // lf          kat            hir            kan            dia

  182.         // cr          nsm            EOS

  183. 

  184.         // 0

  185.         STOP,          STOP,          STOP,          STOP,          STOP,

  186.         STOP,          STOP,          STOP,          STOP,          STOP,

  187.         STOP,          STOP,          STOP,          STOP,          STOP,

  188.         STOP,          STOP,          STOP,

  189. 

  190.         // 1

  191.         (byte)(SI+6),  (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+4),  (byte)(SI+5),

  192.         (byte)(SI+6),  (byte)(SI+7),  (byte)(SI+7),  (byte)(SI+5),  (byte)(SI+8),

  193.         (byte)(SI+8),  (byte)(SI+9),  (byte)(SI+10), (byte)(SI+12), (byte)(SI+11),

  194.         (byte)(SI+8),  (byte)(1),     STOP,

  195. 

  196.         // 2

  197.         STOP,          (byte)(SI+2), (byte)(SI+3),   (byte)(4),     (byte)(4),

  198.         STOP,          STOP,          STOP,          (byte)(4),     STOP,

  199.         STOP,          STOP,          STOP,          STOP,          STOP,

  200.         STOP,          (byte)(2),     STOP,

  201. 

  202.         // 3

  203.         STOP,          (byte)(SI+2),  (byte)(SI+3),  STOP,          (byte)(7),

  204.         SI_STOP,       STOP,          (byte)(7),     (byte)(SI+7),  STOP,

  205.         STOP,          STOP,          STOP,          STOP,          STOP,

  206.         STOP,          (byte)(3),     STOP,

  207. 

  208.         // 4

  209.         STOP,          (byte)(SI+2),  STOP,          STOP,          STOP,

  210.         STOP,          STOP,          STOP,          STOP,          STOP,

  211.         STOP,          STOP,          STOP,          STOP,          STOP,

  212.         STOP,          (byte)(4),     STOP,

  213. 

  214.         // 5

  215.         STOP,          (byte)(SI+2), (byte)(SI+3), STOP,          STOP,

  216.         STOP,          STOP,          STOP,          STOP,          STOP,

  217.         STOP,          STOP,          STOP,          STOP,          STOP,

  218.         STOP,          (byte)(5),     STOP,

  219. 

  220.         // 6

  221.         STOP,          STOP,          STOP,          STOP,          STOP,

  222.         STOP,          STOP,          STOP,          STOP,          STOP,

  223.         STOP,          STOP,          STOP,          STOP,          STOP,

  224.         STOP,          (byte)(6),     STOP,

  225. 

  226.         // 7

  227.         STOP,          STOP,          (byte)(SI+3),  STOP,          STOP,

  228.         STOP,          STOP,          STOP,          STOP,          STOP,

  229.         STOP,          STOP,          STOP,          STOP,          STOP,

  230.         STOP,          (byte)(7),     STOP,

  231. 

  232.         // 8

  233.         STOP,          STOP,          STOP,          STOP,          STOP,

  234.         STOP,          STOP,          STOP,          STOP,          (byte)(SI+8),

  235.         (byte)(SI+8),  STOP,          STOP,          STOP,          STOP,

  236.         (byte)(SI+8),  (byte)(8),     STOP,

  237. 

  238.         // 9

  239.         STOP,          STOP,          STOP,          STOP,          STOP,

  240.         STOP,          STOP,          STOP,          STOP,          STOP,

  241.         STOP,          (byte)(SI+9),  STOP,          STOP,          (byte)(9),

  242.         STOP,          (byte)(9),     STOP,

  243. 

  244.         // 10

  245.         STOP,          STOP,          STOP,          STOP,          STOP,

  246.         STOP,          STOP,          STOP,          STOP,          STOP,

  247.         STOP,          STOP,          (byte)(SI+10),STOP,          (byte)(10),

  248.         STOP,          (byte)(10),    STOP,

  249. 

  250.         // 11

  251.         STOP,          STOP,          STOP,          STOP,          STOP,

  252.         STOP,          STOP,          STOP,          STOP,          STOP,

  253.         STOP,          (byte)(SI+9), (byte)(SI+10),  STOP,          (byte)(SI+11),

  254.         STOP,          (byte)(11),    STOP,

  255. 

  256.         // 12

  257.         STOP,          STOP,          STOP,          STOP,          STOP,

  258.         STOP,          STOP,          STOP,          STOP,          STOP,

  259.         STOP,          STOP,          STOP,          (byte)(SI+12), STOP,

  260.         STOP,          (byte)(12),    STOP

  261.     };

  262.     private static final WordBreakTable kWordBackward =

  263.     new WordBreakTable(COL_COUNT, kWordBackwardData);

  264.     private static final int kRawMapping[] =

  265.     {

  266.         BREAK,     // UNASSIGNED             = 0,

  267.         letter,    // UPPERCASE_LETTER       = 1,

  268.         letter,    // LOWERCASE_LETTER       = 2,

  269.         letter,    // TITLECASE_LETTER       = 3,

  270.         letter,    // MODIFIER_LETTER        = 4,

  271.         letter,    // OTHER_LETTER           = 5,

  272.         nsm,       // NON_SPACING_MARK       = 6,

  273.         nsm,       // ENCLOSING_MARK         = 7,

  274.         BREAK,     // COMBINING_SPACING_MARK = 8,

  275.         number,    // DECIMAL_DIGIT_NUMBER   = 9,

  276.         letter,    // LETTER_NUMBER          = 10,

  277.         number,    // OTHER_NUMBER           = 11,

  278.         blank,     // SPACE_SEPARATOR        = 12,

  279.         BREAK,     // LINE_SEPARATOR         = 13,

  280.         BREAK,     // PARAGRAPH_SEPARATOR    = 14,

  281.         BREAK,     // CONTROL                = 15,

  282.         BREAK,     // FORMAT                 = 16

  283.         BREAK,     // ????                   = 17,

  284.         BREAK,     // PRIVATE_USE            = 18,

  285.         BREAK,     // SURROGATE              = 19,

  286.         midLetter, // DASH_PUNCTUATION       = 20,

  287.         BREAK,     // START_PUNCTUATION      = 21,

  288.         BREAK,     // END_PUNCTUATION        = 22,

  289.         BREAK,     // CONNECTOR_PUNCTUATION  = 23,

  290.         BREAK,     // OTHER_PUNCTUATION      = 24,

  291.         BREAK,     // MATH_SYMBOL            = 25,

  292.         preNum,    // CURRENCY_SYMBOL        = 26,

  293.         BREAK,     // MODIFIER_SYMBOL        = 27,

  294.         BREAK      // OTHER_SYMBOL           = 28

  295.     };

  296.     private static final SpecialMapping kExceptionChar[] =

  297.     {

  298.         //note: the ranges in this table must be sorted in ascending order

  299.         //as required by the UnicodeClassMapping class.

  300.         new SpecialMapping(ASCII_HORIZONTAL_TABULATION, blank),

  301.         new SpecialMapping(ASCII_LINEFEED, lf),

  302.         new SpecialMapping(ASCII_FORM_FEED, lf),

  303.         new SpecialMapping(ASCII_CARRIAGE_RETURN, cr),

  304.         new SpecialMapping(ASCII_QUOTATION_MARK, midLetNum),

  305.         new SpecialMapping(ASCII_NUMBER_SIGN, preNum),

  306.         new SpecialMapping(ASCII_PERCENT, postNum),

  307.         new SpecialMapping(ASCII_AMPERSAND, postNum),

  308.         new SpecialMapping(ASCII_APOSTROPHE, midLetNum),

  309.         new SpecialMapping(ASCII_COMMA, midNum),

  310.         new SpecialMapping(ASCII_FULL_STOP, preMidNum),

  311.         new SpecialMapping(ASCII_CENT_SIGN, postNum),

  312.         new SpecialMapping(LATIN1_SOFTHYPHEN, midLetter),

  313.         new SpecialMapping(ARABIC_PERCENT_SIGN, postNum),

  314.         new SpecialMapping(ARABIC_DECIMAL_SEPARATOR, midNum),

  315.         new SpecialMapping(PUNCTUATION_HYPHENATION_POINT, midLetter),

  316.         new SpecialMapping(PUNCTUATION_LINE_SEPARATOR,

  317.                            PUNCTUATION_PARAGRAPH_SEPARATOR, lf),

  318.         new SpecialMapping(PER_MILLE_SIGN, postNum),

  319.         new SpecialMapping(PER_TEN_THOUSAND_SIGN, postNum),

  320.         new SpecialMapping(IDEOGRAPHIC_ITERATION_MARK, kanji),

  321.         new SpecialMapping(HIRAGANA_LETTER_SMALL_A, HIRAGANA_LETTER_VU, hira),

  322.         new SpecialMapping(COMBINING_KATAKANA_HIRAGANA_VOICED_SOUND_MARK,

  323.                            HIRAGANA_SEMIVOICED_SOUND_MARK, diacrit),

  324.         new SpecialMapping(KATAKANA_LETTER_SMALL_A,

  325.                            KATAKANA_LETTER_SMALL_KE, kata),

  326.         new SpecialMapping(UNICODE_LOW_BOUND_HAN,

  327.                            UNICODE_HIGH_BOUND_HAN, kanji),

  328.         new SpecialMapping(HANGUL_SYL_LOW, HANGUL_SYL_HIGH, letter),

  329.         new SpecialMapping(CJK_COMPATIBILITY_F900,

  330.                            CJK_COMPATIBILITY_FA2D, kanji),

  331.         new SpecialMapping(END_OF_STRING, EOS)

  332.     };

  333. 

  334.     private static final boolean WordExceptionFlags[] = {

  335.         false,          // kNonCharacter            = 0,

  336.         false,          // kUppercaseLetter         = 1,

  337.         false,          // kLowercaseLetter         = 2,

  338.         false,          // kTitlecaseLetter         = 3,

  339.         true,           // kModifierLetter          = 4,

  340.         true,           // kOtherLetter             = 5,

  341.         true,           // kNonSpacingMark          = 6,

  342.         false,          // kEnclosingMark           = 7,

  343.         false,          // kCombiningSpacingMark    = 8,

  344.         false,          // kDecimalNumber           = 9,

  345.         false,          // kLetterNumber            = 10,

  346.         false,          // kOtherNumber             = 11,

  347.         false,          // kSpaceSeparator          = 12,

  348.         true,           // kLineSeparator           = 13,

  349.         true,           // kParagraphSeparator      = 14,

  350.         true,           // kControlCharacter        = 15,

  351.         false,          // kFormatCharacter         = 16,

  352.         false,          // UNDEFINED                = 17,

  353.         false,          // kPrivateUseCharacter     = 18,

  354.         false,          // kSurrogate               = 19,

  355.         true,           // kDashPunctuation         = 20,

  356.         false,          // kOpenPunctuation         = 21,

  357.         false,          // kClosePunctuation        = 22,

  358.         false,          // kConnectorPunctuation    = 23,

  359.         true,           // kOtherPunctuation        = 24,

  360.         false,          // kMathSymbol              = 25,

  361.         true,           // kCurrencySymbol          = 26,

  362.         false,          // kModifierSymbol          = 27,

  363.         false           // kOtherSymbol             = 28

  364.     };

  365. 

  366.     private static final int kWordAsciiValues[] = {

  367.         //  null    soh     stx     etx     eot     enq     ask     bell

  368.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  369.         //  bs      ht      lf      vt      ff      cr      so      si

  370.             BREAK,  blank,  lf,     BREAK,  lf,     cr,     BREAK,  BREAK,

  371.         //  dle     dc1     dc2     dc3     dc4     nak     syn     etb

  372.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  373.         //  can     em      sub     esc     fs      gs      rs      us

  374.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  375.         //  sp      !       "          #       $       %        &        '

  376.             blank,  BREAK,  midLetNum, preNum, preNum, postNum, postNum, midLetNum,

  377.         //  (       )       *       +       ,       -          .          /

  378.             BREAK,  BREAK,  BREAK,  BREAK,  midNum, midLetter, preMidNum, BREAK,

  379.         //  0       1       2       3       4       5       6       7

  380.             number, number, number, number, number, number, number, number,

  381.         //  8       9       :       ;       <       =       >       ?

  382.             number, number, BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  383.         //  @       A       B       C       D       E       F       G

  384.             BREAK,  letter, letter, letter, letter, letter, letter, letter,

  385.         //  H       I       J       K       L       M       N       O

  386.             letter, letter, letter, letter, letter, letter, letter, letter,

  387.         //  P       Q       R       S       T       U       V       W

  388.             letter, letter, letter, letter, letter, letter, letter, letter,

  389.         //  X       Y       Z       [       \       ]       ^       _

  390.             letter, letter, letter, BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  391.         //  `       a       b       c       d       e       f       g

  392.             BREAK,  letter, letter, letter, letter, letter, letter, letter,

  393.         //  h       i       j       k       l       m       n       o

  394.             letter, letter, letter, letter, letter, letter, letter, letter,

  395.         //  p       q       r       s       t       u       v       w

  396.             letter, letter, letter, letter, letter, letter, letter, letter,

  397.         //  x       y       z       {       |       }       ~       del

  398.             letter, letter, letter, BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  399.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  400.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  401.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  402.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  403.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  404.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  405.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  406.             BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,  BREAK,

  407.         //  nbsp      inv-!     cents     pounds    currency  yen       broken-bar  section

  408.             blank,  BREAK,  postNum, preNum, preNum, preNum, BREAK,  BREAK,

  409.         //  umlaut    copyright super-a   gui-left  not       soft-hyph registered  macron

  410.             BREAK,  BREAK,  letter, BREAK,  BREAK,  midLetter, BREAK, BREAK,

  411.         //  degree    +/-       super-2   super-3   acute     micro     paragraph  bullet

  412.             BREAK,  BREAK,  number, number, BREAK,  letter, BREAK,  BREAK,

  413.         //  cedilla   super-1   super-o   gui-right 1/4       1/2       3/4      inv-?

  414.             BREAK,  letter, BREAK,  BREAK,  number, number, number, BREAK,

  415.         //  A-grave   A-acute   A-hat     A-tilde   A-umlaut A-ring    AE        C-cedilla

  416.             letter, letter, letter, letter, letter, letter, letter, letter,

  417.         //  E-grave   E-acute   E-hat     E-umlaut  I-grave   I-acute   I-hat    I-umlaut

  418.             letter, letter, letter, letter, letter, letter, letter, letter,

  419.         //  Edh       N-tilde   O-grave   O-acute   O-hat     O-tilde   O-umlaut times

  420.             letter, letter, letter, letter, letter, letter, letter, BREAK,

  421.         //  O-slash   U-grave   U-acute   U-hat     U-umlaut  Y-acute   Thorn    ess-zed

  422.             letter, letter, letter, letter, letter, letter, letter, letter,

  423.         //  a-grave   a-acute   a-hat     a-tilde   a-umlaut  a-ring    ae       c-cedilla

  424.             letter, letter, letter, letter, letter, letter, letter, letter,

  425.         //  e-grave   e-acute   e-hat     e-umlaut  i-grave   i-acute   i-hat    i-umlaut

  426.             letter, letter, letter, letter, letter, letter, letter, letter,

  427.         //  edh       n-tilde   o-grave   o-acute   o-hat     o-tilde   o-umlaut  over

  428.             letter, letter, letter, letter, letter, letter, letter, BREAK,

  429.         //  o-slash   u-grave   u-acute   u-hat     u-umlaut  y-acute   thorn    y-umlaut

  430.             letter, letter, letter, letter, letter, letter, letter, letter

  431.     };

  432. 

  433.     private static final UnicodeClassMapping kWordMap

  434.         = new UnicodeClassMapping(kRawMapping, kExceptionChar, WordExceptionFlags,

  435.         kWordAsciiValues);

  436. }

  437.