1. /*

  2.  * @(#)LineBreakData.java	1.20 03/01/23

  3.  *

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

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

  6.  */

  7. 

  8. /*

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

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

  11.  *

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

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

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

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

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

  17.  *

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

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

  20.  *

  21.  */

  22. 

  23. package java.text;

  24. 

  25. /**

  26.  * The LineBreakData contains data used by SimpleTextBoundary

  27.  * to determine line breaks.

  28.  * @see #BreakIterator

  29.  */

  30. final class LineBreakData extends TextBoundaryData

  31. {

  32.     // THEORY OF OPERATION:  This class contains all the tables necessary to do

  33.     // character-break iteration.  This class descends from TextBoundaryData, which

  34.     // is abstract.  This class doesn't define any non-static members; it inherits the

  35.     // non-static members from TextBoundaryData and fills them in with pointers to

  36.     // the static members defined here.

  37.     //   There are two main parts to a TextBoundaryData object: the state-transition

  38.     // tables and the character-mapping tables.  The forward state table defines the

  39.     // transitions for a deterministic finite state machine that locates character

  40.     // boundaries.  The rows are the states and the columns are character categories.

  41.     // The cell values consist of two parts: The first is the row number of the next

  42.     // state to transition to, or a "stop" value (0).  (Because 0 is the stop value

  43.     // rather than a valid state number, row 0 of the array isn't ever looked at; we

  44.     // fill it with STOP values by convention.)  The second part is a flag indicating

  45.     // whether the iterator should update its break position on this transition.  When

  46.     // the flag is set, the sign bit of the value is turned on (SI is used to represent

  47.     // the flag bit being turned on-- we do it this way rather than just using negative

  48.     // numbers because we still need to see the SI flag when the value of the transition

  49.     // is STOP.  SI_STOP is used to denote this.)  The starting state in all state tables

  50.     // is 1.

  51.     //   The backward state table works the same way as the forward state table, but is

  52.     // usually simplified.  The iterator uses the backward state table only to find a

  53.     // "safe place" to start iterating forward.  It then seeks forward from the "safe

  54.     // place" to the actual break position using the forward table.  A "safe place" is

  55.     // a spot in the text that is guaranteed to be a break position.

  56.     //   The character-category mapping tables are split into several pieces, one for

  57.     // each stage of the category-mapping process: 1) kRawMapping maps generic Unicode

  58.     // character categories to the character categories used by this break iterator.

  59.     // The index of the array is the Unicode category number as returned by

  60.     // Character.getType().  2) The kExceptionFlags table is a table of Boolean values

  61.     // indicating whether all the characters in the Unicode category have the

  62.     // raw-mapping value.  The rows correspond to the rows of the raw-mapping table.  If

  63.     // an entry is true, then we find the right category using...  3) The kExceptionChar

  64.     // table.  This table is a sorted list of SpecialMapping objects.  Each entry defines

  65.     // a range of contiguous characters that share the same category and the category

  66.     // number.  This list is binary-searched to find an entry corresponding to the 

  67.     // charactre being mapped.  Only characters whose breaking category is different from

  68.     // the raw-mapping value (the breaking category for their Unicode category) are

  69.     // listed in this table.  4) The kAsciiValues table is a fast-path table for characters

  70.     // in the Latin1 range.  This table maps straight from a character value to a

  71.     // category number, bypassing all the other tables.  The programmer must take care

  72.     // that all of the different category-mapping tables are consistent.

  73.     //   In the current implementation, all of these tables are created and maintained

  74.     // by hand, not using a tool.

  75.     

  76.     private static final byte BREAK                 = 0;

  77.     //always breaks (must be present as first item)

  78.     private static final byte blank                 = 1;

  79.     //spaces, tabs, nulls.

  80.     private static final byte cr                    = 2;

  81.     //carriage return

  82.     private static final byte nonBlank              = 3;

  83.     //everything not included elsewhere

  84.     private static final byte op                    = 4;

  85.     //hyphens....

  86.     private static final byte jwrd                  = 5;

  87.     //hiragana, katakana, and kanji

  88.     private static final byte preJwrd               = 6;

  89.     //characters that bind to the beginning of a Japanese word

  90.     private static final byte postJwrd              = 7;

  91.     //characters that bind to the end of a Japanese word

  92.     private static final byte digit                 = 8;

  93.     //digits

  94.     private static final byte numPunct              = 9;

  95.     //punctuation that can appear within a number

  96.     private static final byte currency              = 10;

  97.     //currency symbols that can precede a number

  98.     private static final byte quote                 = 11;

  99.     // the ASCII quotation mark

  100.     private static final byte nsm                   = 12;

  101.     // non-spacing marks

  102.     private static final byte nbsp                  = 13;

  103.     // non-breaking characters

  104.     private static final byte EOS                   = 14;

  105.     private static final int COL_COUNT = 15;

  106. 

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

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

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

  110. 

  111.     public LineBreakData() {

  112.         super(kLineForward, kLineBackward, kLineMap);

  113.     }

  114. 

  115.     // This table locates legal line-break positions.  i.e., a process that word-wraps a line of

  116.     // text can use this version of the BreakIterator to tell it where the legal places for

  117.     // breaking a line are.

  118.     // The rules implemented here are as follows:

  119.     // 1) There is always a legal break position after a line or paragraph separator, but

  120.     //    one can occur before only when the preceding character is also a line or paragraph

  121.     //    separator.  (The CR-LF sequence is also kept together.)  (states 4 and 7)

  122.     // 2) There is never a break before a non-spacing mark, unless it's preceded by a line

  123.     //    or paragraph separator.  (the nsm column)

  124.     // 3) There is never a break on either side of a non-breaking space (or other non-breaking

  125.     //    chartacters).  (the nbsp column, and state 1)

  126.     // 4) There is always a break before and after Kanji and Kana characters, except for certain

  127.     //    punctuation that must be kept with the following character and certain punctuation

  128.     //    and diacritic marks that must be kept with the preceding character.  (states 5 and 8)

  129.     // 5) There is always a legal break position following a dash, except when it is followed

  130.     //    by a digit, a line/paragraph separator, or whitespace. (state 6)

  131.     // 6) There is never a break before a whitespace character.  There is a break after a

  132.     //    whitespace character, except when it's followed by a line/paragraph separator.

  133.     //    (state 2)

  134.     // 7) Breaks don't occur anywhere else.  (state 1)

  135.     private static final byte kLineForwardData[] =

  136.     {

  137.         // brk         bl             cr             nBl

  138.         // op          kan            prJ            poJ

  139.         // dgt         np             curr           quote

  140.         // nsm         nbsp           EOS

  141.         // 00 - dummy state

  142.         STOP,          STOP,          STOP,          STOP,

  143.         STOP,          STOP,          STOP,          STOP,

  144.         STOP,          STOP,          STOP,          STOP,

  145.         STOP,          STOP,          STOP,

  146.         // 01 - main dispatch state.  This state eats pre-Kanji punctuation,

  147.         // non-breaking spaces, and non-spacing diacritics without transitioning

  148.         // to other states.

  149.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  (byte)(SI+3),

  150.         (byte)(SI+6),  (byte)(SI+5),  (byte)(SI+1),  (byte)(SI+8),

  151.         (byte)(SI+9),  (byte)(SI+8),  (byte)(SI+1),  (byte)(SI+3),

  152.         (byte)(SI+1),  (byte)(SI+1),  SI_STOP,

  153.         // 02 - This state eats whitespce and stops on almost anything else

  154.         // (the exceptions are non-breaking spaces, which go back to 1,

  155.         // and CRs and LFs)

  156.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  SI_STOP,

  157.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  158.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  159.         (byte)(SI+2),  (byte)(SI+1),  SI_STOP,

  160.         // 03 - This state eats non-whitespace characters that aren't

  161.         // otherwise accounted for.  The only difference between

  162.         // this and state 1 is that it stops on Kanji (you can break

  163.         // between any two Kanji characters)

  164.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  (byte)(SI+3),

  165.         (byte)(SI+6),  SI_STOP,       (byte)(SI+1),  (byte)(SI+8),

  166.         (byte)(SI+9),  (byte)(SI+8),  (byte)(SI+1),  (byte)(SI+3),

  167.         (byte)(SI+3),  (byte)(SI+1),  SI_STOP,

  168.         // 04 - this is the state you go to when you see a hard line-

  169.         // breaking character.  It eats that character and stops.

  170.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  171.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  172.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  173.         SI_STOP,       SI_STOP,       SI_STOP,

  174.         // 05 - this is the state that handles Kanji.  It handles

  175.         // post-Kanji punctuation, whitespace, non-breaking spaces,

  176.         // and line terminators, but stops on everything else

  177.         // (including more Kanji)

  178.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  SI_STOP,

  179.         SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+8),

  180.         SI_STOP,       (byte)(SI+8),  SI_STOP,       SI_STOP,

  181.         (byte)(SI+5),  (byte)(SI+1),  SI_STOP,

  182.         // 06 - This state handles dashes.  It'll continue on

  183.         // whitespace, more dashes, line terminators, and digits

  184.         // (the dash is a minus sign), but stops on everything else

  185.         // (unless there's an nbsp, a dash is always a legal

  186.         // break position).

  187.         (byte)(SI+4),  SI_STOP,       (byte)(SI+7),  SI_STOP,

  188.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  189.         (byte)(SI+9),  SI_STOP,       (byte)(SI+11), SI_STOP,

  190.         (byte)(SI+6),  (byte)(SI+1),  SI_STOP,

  191.         // 07 - This state handles CRs.  A CR is a line terminator

  192.         // when it appears alone, and considered "half" a line

  193.         // terminator when it occurs right before any other line

  194.         // terminator (except another CR).

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

  196.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  197.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  198.         SI_STOP,       SI_STOP,       SI_STOP,

  199.         // 08 - This state eats post-Kanji punctuation, and passes

  200.         // whitespace, non-breaking characters, dashes, line terminators,

  201.         // etc.  It stops on almost everything else.

  202.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  SI_STOP,

  203.         SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+8),

  204.         SI_STOP,       (byte)(SI+8),  SI_STOP,       (byte)(SI+3),

  205.         (byte)(SI+8),  (byte)(SI+1),  SI_STOP,

  206.         // 09 - This state is the main "number" state.  It eats

  207.         // digits.

  208.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  (byte)(SI+3),

  209.         (byte)(SI+6),  SI_STOP,       SI_STOP,       (byte)(SI+8),

  210.         (byte)(SI+9),  (byte)(SI+10), (byte)(SI+10), (byte)(SI+3),

  211.         (byte)(SI+9),  (byte)(SI+1),  SI_STOP,

  212.         // 10 - This state is the secondary "number" state.  It

  213.         // easts punctuation that can occur inside a number.

  214.         (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+7),  SI_STOP,

  215.         SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+8),

  216.         (byte)(SI+9),  (byte)(SI+8),  SI_STOP,       SI_STOP,

  217.         (byte)(SI+10), (byte)(SI+1),  SI_STOP,

  218.         // 11 - This state is here to allow a dash to go before a

  219.         // currency symbol and still be treated as a minus sign

  220.         // (if the character after the currency symbol is a digit).

  221.         STOP,          STOP,          STOP,          STOP,

  222.         STOP,          STOP,          STOP,          STOP,

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

  224.         (byte)(11),    (byte)(SI+1),  STOP

  225.     };

  226. 

  227.     private static final WordBreakTable kLineForward

  228.         = new WordBreakTable(COL_COUNT, kLineForwardData);

  229. 

  230.     // This table locates unambiguous break positions when iterating backward.

  231.     // It implements the following rules:

  232.     // 1) For most characters, there is a break before them if they're preceded

  233.     //    by whitespace, Kanji, or a line/paragraph separator. (CR-LF is kept together)

  234.     // 2) There is a break before a Kanji character, except when it's preceded by

  235.     //    a Kanji-prefix character.  (state 4)

  236.     // 3) There is NOT a break before a Kanji-suffix character, except when preceded

  237.     //    by whitespace, a line/paragraph separator, or a dash. (state 3)

  238.     // 4) There is never a break on either side of a non-break character.  (the nbsp column)

  239.     // 5) There is never a break before a non-spacing mark (the nsm column)

  240.     // [In this set of rules, "break" means "unambiguous break position".  There may sometimes

  241.     // be actual breaks in positions this table always skips.]

  242.     private static final byte kLineBackwardData[] =

  243.     {

  244.         // brk         bl             cr             nBl

  245.         // op          kan            prJ            poJ

  246.         // dgt         np             curr           quote

  247.         // nsm         nbsp           EOS

  248.         /*00*/

  249.         STOP,          STOP,          STOP,          STOP,

  250.         STOP,          STOP,          STOP,          STOP,

  251.         STOP,          STOP,          STOP,          STOP,

  252.         STOP,          STOP,          STOP,

  253.         /*01*/

  254.         (byte)(SI+1),  (byte)(SI+1),  (byte)(SI+1),  (byte)(SI+2),

  255.         (byte)(SI+2),  (byte)(SI+4),  (byte)(SI+2),  (byte)(SI+3),

  256.         (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+2),  (byte)(SI+2),

  257.         (byte)(SI+1),  (byte)(SI+2),  STOP,

  258.         /*02*/

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

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

  261.         (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+2),  (byte)(SI+2),

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

  263.         /*03*/

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

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

  266.         (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+2),  (byte)(SI+2),

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

  268.         /*04*/

  269.         STOP,          STOP,          STOP,          STOP,

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

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

  272.         (byte)(SI+4),  (byte)(SI+4),  STOP

  273.     };

  274. 

  275.     private static final WordBreakTable kLineBackward

  276.         = new WordBreakTable(COL_COUNT, kLineBackwardData);

  277. 

  278.     private static final int kRawMapping[] =

  279.     {

  280.         nonBlank, //UNASSIGNED             = 0,

  281.         nonBlank, //UPPERCASE_LETTER       = 1,

  282.         nonBlank, //LOWERCASE_LETTER       = 2,

  283.         nonBlank, //TITLECASE_LETTER       = 3,

  284.         nonBlank, //MODIFIER_LETTER        = 4,

  285.         nonBlank, //OTHER_LETTER           = 5,

  286.         nsm,      //NON_SPACING_MARK       = 6,

  287.         nsm,      //ENCLOSING_MARK         = 7,

  288.         nonBlank, //COMBINING_SPACING_MARK = 8,

  289.         digit, //DECIMAL_DIGIT_NUMBER      = 9,

  290.         nonBlank, //LETTER_NUMBER          = 10,

  291.         digit, //OTHER_NUMBER              = 11,

  292.         blank, //SPACE_SEPARATOR           = 12,

  293.         blank, //LINE_SEPARATOR            = 13,

  294.         blank, //PARAGRAPH_SEPARATOR       = 14,     ???????????

  295.         blank, //CONTROL                   = 15,

  296.         nonBlank, //PRIVATE_USE            = 16,

  297.         nonBlank, //FORMAT                 = 17

  298.         nonBlank, //????                   = 18,

  299.         nonBlank, //SURROGATE              = 19,

  300.         op, //DASH_PUNCTUATION             = 20,

  301.         preJwrd, //START_PUNCTUATION       = 21,

  302.         postJwrd, //END_PUNCTUATION        = 22,

  303.         nonBlank, //CONNECTOR_PUNCTUATION  = 23,

  304.         nonBlank, //OTHER_PUNCTUATION      = 24,

  305.         nonBlank, //MATH_SYMBOL            = 25,

  306.         preJwrd, //CURRENCY_SYMBOL         = 26,

  307.         nonBlank, //MODIFIER_SYMBOL        = 27,

  308.         nonBlank, //OTHER_SYMBOL           = 28,

  309.         preJwrd, //INITIAL_QUOTE_PUNCTUATION = 29,

  310.         postJwrd, //FINAL_QUOTE_PUNCTUATION = 30,

  311.     };

  312. 

  313.     private static SpecialMapping kExceptionChar[] =

  314.     {

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

  316.         //      required by the UnicodeClassMapping class.

  317.         new SpecialMapping(ASCII_END_OF_TEXT, BREAK),

  318.         new SpecialMapping(ASCII_HORIZONTAL_TABULATION,

  319.                            ASCII_FORM_FEED, BREAK),

  320.         new SpecialMapping(ASCII_CARRIAGE_RETURN, cr),

  321.         new SpecialMapping(ASCII_EXCLAMATION_MARK, postJwrd),

  322.         new SpecialMapping(ASCII_QUOTATION_MARK, quote),

  323.         new SpecialMapping(ASCII_DOLLAR_SIGN, preJwrd),

  324.         new SpecialMapping(ASCII_PERCENT, postJwrd),

  325.         new SpecialMapping(ASCII_COMMA, numPunct),

  326.         new SpecialMapping(ASCII_FULL_STOP, numPunct),

  327.         new SpecialMapping(ASCII_COLON, ASCII_SEMICOLON, postJwrd),

  328.         new SpecialMapping(ASCII_QUESTION_MARK, postJwrd),

  329.         new SpecialMapping(ASCII_NONBREAKING_SPACE, nbsp),

  330.         new SpecialMapping(ASCII_CENT_SIGN, postJwrd),

  331.         new SpecialMapping(LATIN1_SOFTHYPHEN, op),

  332.         new SpecialMapping(LATIN1_DEGREE_SIGN, postJwrd),

  333.         new SpecialMapping(ARABIC_PERCENT_SIGN, postJwrd),

  334.         new SpecialMapping(FIGURE_SPACE, nbsp),

  335.         new SpecialMapping(NONBREAKING_HYPHEN, nbsp),

  336.         new SpecialMapping(PUNCTUATION_LINE_SEPARATOR,

  337.                            PUNCTUATION_PARAGRAPH_SEPARATOR, BREAK),

  338.         new SpecialMapping(PER_MILLE_SIGN, postJwrd),

  339.         new SpecialMapping(PER_TEN_THOUSAND_SIGN, postJwrd),

  340.         new SpecialMapping(PRIME, TRIPLE_PRIME, postJwrd),

  341.         new SpecialMapping(DEGREE_CELSIUS, postJwrd),

  342.         new SpecialMapping(DEGREE_FAHRENHEIT, postJwrd),

  343.         new SpecialMapping(PUNCTUATION_IDEOGRAPHIC_COMMA,

  344.                            PUNCTUATION_IDEOGRAPHIC_FULL_STOP, postJwrd),

  345.         new SpecialMapping(IDEOGRAPHIC_ITERATION_MARK, postJwrd),

  346.         new SpecialMapping(HIRAGANA_LETTER_SMALL_A, postJwrd),

  347.         new SpecialMapping(HIRAGANA_LETTER_A, jwrd),

  348.         new SpecialMapping(HIRAGANA_LETTER_SMALL_I, postJwrd),

  349.         new SpecialMapping(HIRAGANA_LETTER_I, jwrd),

  350.         new SpecialMapping(HIRAGANA_LETTER_SMALL_U, postJwrd),

  351.         new SpecialMapping(HIRAGANA_LETTER_U, jwrd),

  352.         new SpecialMapping(HIRAGANA_LETTER_SMALL_E, postJwrd),

  353.         new SpecialMapping(HIRAGANA_LETTER_E, jwrd),

  354.         new SpecialMapping(HIRAGANA_LETTER_SMALL_O, postJwrd),

  355.         new SpecialMapping(HIRAGANA_LETTER_O, HIRAGANA_LETTER_DI, jwrd),

  356.         new SpecialMapping(HIRAGANA_LETTER_SMALL_TU, postJwrd),

  357.         new SpecialMapping(HIRAGANA_LETTER_TU, HIRAGANA_LETTER_MO, jwrd),

  358.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YA, postJwrd),

  359.         new SpecialMapping(HIRAGANA_LETTER_YA, jwrd),

  360.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YU, postJwrd),

  361.         new SpecialMapping(HIRAGANA_LETTER_YU, jwrd),

  362.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YO, postJwrd),

  363.         new SpecialMapping(HIRAGANA_LETTER_YO, HIRAGANA_LETTER_RO, jwrd),

  364.         new SpecialMapping(HIRAGANA_LETTER_SMALL_WA, postJwrd),

  365.         new SpecialMapping(HIRAGANA_LETTER_WA, HIRAGANA_LETTER_VU, jwrd),

  366.         new SpecialMapping(COMBINING_KATAKANA_HIRAGANA_VOICED_SOUND_MARK,

  367.                            HIRAGANA_SEMIVOICED_SOUND_MARK, postJwrd),

  368.         new SpecialMapping(HIRAGANA_ITERATION_MARK, HIRAGANA_VOICED_ITERATION_MARK, postJwrd),

  369.         new SpecialMapping(KATAKANA_LETTER_SMALL_A, postJwrd),

  370.         new SpecialMapping(KATAKANA_LETTER_A, jwrd),

  371.         new SpecialMapping(KATAKANA_LETTER_SMALL_I, postJwrd),

  372.         new SpecialMapping(KATAKANA_LETTER_I, jwrd),

  373.         new SpecialMapping(KATAKANA_LETTER_SMALL_U, postJwrd),

  374.         new SpecialMapping(KATAKANA_LETTER_U, jwrd),

  375.         new SpecialMapping(KATAKANA_LETTER_SMALL_E, postJwrd),

  376.         new SpecialMapping(KATAKANA_LETTER_E, jwrd),

  377.         new SpecialMapping(KATAKANA_LETTER_SMALL_O, postJwrd),

  378.         new SpecialMapping(KATAKANA_LETTER_O, KATAKANA_LETTER_DI, jwrd),

  379.         new SpecialMapping(KATAKANA_LETTER_SMALL_TU, postJwrd),

  380.         new SpecialMapping(KATAKANA_LETTER_TU, KATAKANA_LETTER_MO, jwrd),

  381.         new SpecialMapping(KATAKANA_LETTER_SMALL_YA, postJwrd),

  382.         new SpecialMapping(KATAKANA_LETTER_YA, jwrd),

  383.         new SpecialMapping(KATAKANA_LETTER_SMALL_YU, postJwrd),

  384.         new SpecialMapping(KATAKANA_LETTER_YU, jwrd),

  385.         new SpecialMapping(KATAKANA_LETTER_SMALL_YO, postJwrd),

  386.         new SpecialMapping(KATAKANA_LETTER_YO, KATAKANA_LETTER_RO, jwrd),

  387.         new SpecialMapping(KATAKANA_LETTER_SMALL_WA, postJwrd),

  388.         new SpecialMapping(KATAKANA_LETTER_WA, KATAKANA_LETTER_VU, jwrd),

  389.         new SpecialMapping(KATAKANA_LETTER_SMALL_KA, KATAKANA_LETTER_SMALL_KE, postJwrd),

  390.         new SpecialMapping(KATAKANA_LETTER_VA, KATAKANA_LETTER_VO, jwrd),

  391.         new SpecialMapping(KATAKANA_HIRAGANA_PROLONGED_SOUND_MARK, postJwrd),

  392.         new SpecialMapping(KATAKANA_ITERATION_MARK, KATAKANA_VOICED_ITERATION_MARK, postJwrd),

  393.         new SpecialMapping(UNICODE_LOW_BOUND_HAN,UNICODE_HIGH_BOUND_HAN,jwrd),

  394.         new SpecialMapping(CJK_COMPATIBILITY_F900,

  395.                            CJK_COMPATIBILITY_FA2D, jwrd),

  396.         new SpecialMapping(UNICODE_ZERO_WIDTH_NON_BREAKING_SPACE, nbsp),

  397.         new SpecialMapping(FULLWIDTH_EXCLAMATION_MARK, postJwrd),

  398.         new SpecialMapping(FULLWIDTH_COMMA, postJwrd),

  399.         new SpecialMapping(FULLWIDTH_FULL_STOP, postJwrd),

  400.         new SpecialMapping(FULLWIDTH_QUESTION_MARK, postJwrd),

  401.         new SpecialMapping(END_OF_STRING, EOS)

  402.     };

  403. 

  404.     private static final boolean LineExceptionFlags[] = {

  405.         false,          // kNonCharacter            = 0,

  406.         false,          // kUppercaseLetter         = 1,

  407.         false,          // kLowercaseLetter         = 2,

  408.         false,          // kTitlecaseLetter         = 3,

  409.         true,           // kModifierLetter          = 4,

  410.         true,           // kOtherLetter             = 5,

  411.         true,           // kNonSpacingMark          = 6,

  412.         false,          // kEnclosingMark           = 7,

  413.         false,          // kCombiningSpacingMark    = 8,

  414.         false,          // kDecimalNumber           = 9,

  415.         false,          // kLetterNumber            = 10,

  416.         false,          // kOtherNumber             = 11,

  417.         true,           // kSpaceSeparator          = 12,

  418.         true,           // kLineSeparator           = 13,

  419.         true,           // kParagraphSeparator      = 14,

  420.         true,           // kControlCharacter        = 15,

  421.         true,           // kFormatCharacter         = 16,

  422.         false,          // UNDEFINED                = 17,

  423.         false,          // kPrivateUseCharacter     = 18,

  424.         false,          // kSurrogate               = 19,

  425.         true,           // kDashPunctuation         = 20,

  426.         false,          // kOpenPunctuation         = 21,

  427.         false,          // kClosePunctuation        = 22,

  428.         false,          // kConnectorPunctuation    = 23,

  429.         true,           // kOtherPunctuation        = 24,

  430.         false,          // kMathSymbol              = 25,

  431.         true,           // kCurrencySymbol          = 26,

  432.         false,          // kModifierSymbol          = 27,

  433.         true,           // kOtherSymbol             = 28,

  434.         false,          // kInitialQuotePunctuation = 29,

  435.         false,          // kFinalQuotePunctuation   = 30,

  436.     };

  437. 

  438.     private static final int kLineAsciiValues[] = {

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

  440.             blank,  blank,  blank,  BREAK,  blank,  blank,  blank,  blank,

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

  442.             blank,  BREAK,  BREAK,  BREAK,  BREAK,  cr,     blank,  blank,

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

  444.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  446.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  448.             blank,  postJwrd, quote, nonBlank, currency, postJwrd, nonBlank, nonBlank,

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

  450.             preJwrd, postJwrd, nonBlank, nonBlank, numPunct, op, numPunct, nonBlank,

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

  452.             digit,    digit,    digit,    digit,    digit,    digit,    digit,    digit,

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

  454.             digit,    digit,    postJwrd, postJwrd, nonBlank, nonBlank, nonBlank, postJwrd,

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

  456.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  458.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  460.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  462.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, postJwrd, nonBlank, nonBlank,

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

  464.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  466.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  468.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  470.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, postJwrd, nonBlank, blank,

  471.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  472.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  473.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  474.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  475.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  476.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  477.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  478.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  480.             nbsp,  nonBlank, postJwrd, currency, currency, currency, nonBlank, nonBlank,

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

  482.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, op, nonBlank, nonBlank,

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

  484.             postJwrd, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  486.             nonBlank, nonBlank, nonBlank, postJwrd, digit,    digit,    digit,    nonBlank,

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

  488.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  490.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  492.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  494.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  496.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  498.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  500.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  502.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank

  503.     };

  504. 

  505.     private static final UnicodeClassMapping kLineMap

  506.         = new UnicodeClassMapping(kRawMapping, kExceptionChar, LineExceptionFlags,

  507.         kLineAsciiValues);

  508. }