1. /*

  2.  * @(#)LineBreakData.java	1.17 00/01/19

  3.  *

  4.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. /*

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

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

  14.  *

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

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

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

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

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

  20.  *

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

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

  23.  *

  24.  */

  25. 

  26. package java.text;

  27. 

  28. /**

  29.  * The LineBreakData contains data used by SimpleTextBoundary

  30.  * to determine line breaks.

  31.  * @see #BreakIterator

  32.  */

  33. final class LineBreakData extends TextBoundaryData

  34. {

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

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

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

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

  39.     // the static members defined here.

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

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

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

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

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

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

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

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

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

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

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

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

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

  53.     // is 1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  78.     

  79.     private static final byte BREAK                 = 0;

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

  81.     private static final byte blank                 = 1;

  82.     //spaces, tabs, nulls.

  83.     private static final byte cr                    = 2;

  84.     //carriage return

  85.     private static final byte nonBlank              = 3;

  86.     //everything not included elsewhere

  87.     private static final byte op                    = 4;

  88.     //hyphens....

  89.     private static final byte jwrd                  = 5;

  90.     //hiragana, katakana, and kanji

  91.     private static final byte preJwrd               = 6;

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

  93.     private static final byte postJwrd              = 7;

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

  95.     private static final byte digit                 = 8;

  96.     //digits

  97.     private static final byte numPunct              = 9;

  98.     //punctuation that can appear within a number

  99.     private static final byte currency              = 10;

  100.     //currency symbols that can precede a number

  101.     private static final byte quote                 = 11;

  102.     // the ASCII quotation mark

  103.     private static final byte nsm                   = 12;

  104.     // non-spacing marks

  105.     private static final byte nbsp                  = 13;

  106.     // non-breaking characters

  107.     private static final byte EOS                   = 14;

  108.     private static final int COL_COUNT = 15;

  109. 

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

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

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

  113. 

  114.     public LineBreakData() {

  115.         super(kLineForward, kLineBackward, kLineMap);

  116.     }

  117. 

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

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

  120.     // breaking a line are.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  136.     //    (state 2)

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

  138.     private static final byte kLineForwardData[] =

  139.     {

  140.         // brk         bl             cr             nBl

  141.         // op          kan            prJ            poJ

  142.         // dgt         np             curr           quote

  143.         // nsm         nbsp           EOS

  144.         // 00 - dummy state

  145.         STOP,          STOP,          STOP,          STOP,

  146.         STOP,          STOP,          STOP,          STOP,

  147.         STOP,          STOP,          STOP,          STOP,

  148.         STOP,          STOP,          STOP,

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

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

  151.         // to other states.

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

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

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

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

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

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

  158.         // and CRs and LFs)

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

  160.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  161.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

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

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

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

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

  166.         // between any two Kanji characters)

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

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

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

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

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

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

  173.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  174.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  175.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  176.         SI_STOP,       SI_STOP,       SI_STOP,

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

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

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

  180.         // (including more Kanji)

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

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

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

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

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

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

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

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

  189.         // break position).

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

  191.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

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

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

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

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

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

  197.         // terminator (except another CR).

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

  199.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  200.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  201.         SI_STOP,       SI_STOP,       SI_STOP,

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

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

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

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

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

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

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

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

  210.         // digits.

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

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

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

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

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

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

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

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

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

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

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

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

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

  224.         STOP,          STOP,          STOP,          STOP,

  225.         STOP,          STOP,          STOP,          STOP,

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

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

  228.     };

  229. 

  230.     private static final WordBreakTable kLineForward

  231.         = new WordBreakTable(COL_COUNT, kLineForwardData);

  232. 

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

  234.     // It implements the following rules:

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

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

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

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

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

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

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

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

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

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

  245.     private static final byte kLineBackwardData[] =

  246.     {

  247.         // brk         bl             cr             nBl

  248.         // op          kan            prJ            poJ

  249.         // dgt         np             curr           quote

  250.         // nsm         nbsp           EOS

  251.         /*00*/

  252.         STOP,          STOP,          STOP,          STOP,

  253.         STOP,          STOP,          STOP,          STOP,

  254.         STOP,          STOP,          STOP,          STOP,

  255.         STOP,          STOP,          STOP,

  256.         /*01*/

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

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

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

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

  261.         /*02*/

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

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

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

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

  266.         /*03*/

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

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

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

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

  271.         /*04*/

  272.         STOP,          STOP,          STOP,          STOP,

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

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

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

  276.     };

  277. 

  278.     private static final WordBreakTable kLineBackward

  279.         = new WordBreakTable(COL_COUNT, kLineBackwardData);

  280. 

  281.     private static final int kRawMapping[] =

  282.     {

  283.         nonBlank, //UNASSIGNED             = 0,

  284.         nonBlank, //UPPERCASE_LETTER       = 1,

  285.         nonBlank, //LOWERCASE_LETTER       = 2,

  286.         nonBlank, //TITLECASE_LETTER       = 3,

  287.         nonBlank, //MODIFIER_LETTER        = 4,

  288.         nonBlank, //OTHER_LETTER           = 5,

  289.         nsm,      //NON_SPACING_MARK       = 6,

  290.         nsm,      //ENCLOSING_MARK         = 7,

  291.         nonBlank, //COMBINING_SPACING_MARK = 8,

  292.         digit, //DECIMAL_DIGIT_NUMBER      = 9,

  293.         nonBlank, //LETTER_NUMBER          = 10,

  294.         digit, //OTHER_NUMBER              = 11,

  295.         blank, //SPACE_SEPARATOR           = 12,

  296.         blank, //LINE_SEPARATOR            = 13,

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

  298.         blank, //CONTROL                   = 15,

  299.         nonBlank, //PRIVATE_USE            = 16,

  300.         nonBlank, //FORMAT                 = 17

  301.         nonBlank, //????                   = 18,

  302.         nonBlank, //SURROGATE              = 19,

  303.         op, //DASH_PUNCTUATION             = 20,

  304.         preJwrd, //START_PUNCTUATION       = 21,

  305.         postJwrd, //END_PUNCTUATION        = 22,

  306.         nonBlank, //CONNECTOR_PUNCTUATION  = 23,

  307.         nonBlank, //OTHER_PUNCTUATION      = 24,

  308.         nonBlank, //MATH_SYMBOL            = 25,

  309.         preJwrd, //CURRENCY_SYMBOL         = 26,

  310.         nonBlank, //MODIFIER_SYMBOL        = 27,

  311.         nonBlank  //OTHER_SYMBOL           = 28;

  312.     };

  313. 

  314.     private static SpecialMapping kExceptionChar[] =

  315.     {

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

  317.         //      required by the UnicodeClassMapping class.

  318.         new SpecialMapping(ASCII_END_OF_TEXT, BREAK),

  319.         new SpecialMapping(ASCII_HORIZONTAL_TABULATION,

  320.                            ASCII_FORM_FEED, BREAK),

  321.         new SpecialMapping(ASCII_CARRIAGE_RETURN, cr),

  322.         new SpecialMapping(ASCII_EXCLAMATION_MARK, postJwrd),

  323.         new SpecialMapping(ASCII_QUOTATION_MARK, quote),

  324.         new SpecialMapping(ASCII_DOLLAR_SIGN, preJwrd),

  325.         new SpecialMapping(ASCII_PERCENT, postJwrd),

  326.         new SpecialMapping(ASCII_COMMA, numPunct),

  327.         new SpecialMapping(ASCII_FULL_STOP, numPunct),

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

  329.         new SpecialMapping(ASCII_QUESTION_MARK, postJwrd),

  330.         new SpecialMapping(ASCII_NONBREAKING_SPACE, nbsp),

  331.         new SpecialMapping(ASCII_CENT_SIGN, postJwrd),

  332.         new SpecialMapping(LATIN1_SOFTHYPHEN, op),

  333.         new SpecialMapping(LATIN1_DEGREE_SIGN, postJwrd),

  334.         new SpecialMapping(ARABIC_PERCENT_SIGN, postJwrd),

  335.         new SpecialMapping(FIGURE_SPACE, nbsp),

  336.         new SpecialMapping(NONBREAKING_HYPHEN, nbsp),

  337.         new SpecialMapping(PUNCTUATION_LINE_SEPARATOR,

  338.                            PUNCTUATION_PARAGRAPH_SEPARATOR, BREAK),

  339.         new SpecialMapping(PER_MILLE_SIGN, postJwrd),

  340.         new SpecialMapping(PER_TEN_THOUSAND_SIGN, postJwrd),

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

  342.         new SpecialMapping(DEGREE_CELSIUS, postJwrd),

  343.         new SpecialMapping(DEGREE_FAHRENHEIT, postJwrd),

  344.         new SpecialMapping(PUNCTUATION_IDEOGRAPHIC_COMMA,

  345.                            PUNCTUATION_IDEOGRAPHIC_FULL_STOP, postJwrd),

  346.         new SpecialMapping(IDEOGRAPHIC_ITERATION_MARK, postJwrd),

  347.         new SpecialMapping(HIRAGANA_LETTER_SMALL_A, postJwrd),

  348.         new SpecialMapping(HIRAGANA_LETTER_A, jwrd),

  349.         new SpecialMapping(HIRAGANA_LETTER_SMALL_I, postJwrd),

  350.         new SpecialMapping(HIRAGANA_LETTER_I, jwrd),

  351.         new SpecialMapping(HIRAGANA_LETTER_SMALL_U, postJwrd),

  352.         new SpecialMapping(HIRAGANA_LETTER_U, jwrd),

  353.         new SpecialMapping(HIRAGANA_LETTER_SMALL_E, postJwrd),

  354.         new SpecialMapping(HIRAGANA_LETTER_E, jwrd),

  355.         new SpecialMapping(HIRAGANA_LETTER_SMALL_O, postJwrd),

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

  357.         new SpecialMapping(HIRAGANA_LETTER_SMALL_TU, postJwrd),

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

  359.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YA, postJwrd),

  360.         new SpecialMapping(HIRAGANA_LETTER_YA, jwrd),

  361.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YU, postJwrd),

  362.         new SpecialMapping(HIRAGANA_LETTER_YU, jwrd),

  363.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YO, postJwrd),

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

  365.         new SpecialMapping(HIRAGANA_LETTER_SMALL_WA, postJwrd),

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

  367.         new SpecialMapping(COMBINING_KATAKANA_HIRAGANA_VOICED_SOUND_MARK,

  368.                            HIRAGANA_SEMIVOICED_SOUND_MARK, postJwrd),

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

  370.         new SpecialMapping(KATAKANA_LETTER_SMALL_A, postJwrd),

  371.         new SpecialMapping(KATAKANA_LETTER_A, jwrd),

  372.         new SpecialMapping(KATAKANA_LETTER_SMALL_I, postJwrd),

  373.         new SpecialMapping(KATAKANA_LETTER_I, jwrd),

  374.         new SpecialMapping(KATAKANA_LETTER_SMALL_U, postJwrd),

  375.         new SpecialMapping(KATAKANA_LETTER_U, jwrd),

  376.         new SpecialMapping(KATAKANA_LETTER_SMALL_E, postJwrd),

  377.         new SpecialMapping(KATAKANA_LETTER_E, jwrd),

  378.         new SpecialMapping(KATAKANA_LETTER_SMALL_O, postJwrd),

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

  380.         new SpecialMapping(KATAKANA_LETTER_SMALL_TU, postJwrd),

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

  382.         new SpecialMapping(KATAKANA_LETTER_SMALL_YA, postJwrd),

  383.         new SpecialMapping(KATAKANA_LETTER_YA, jwrd),

  384.         new SpecialMapping(KATAKANA_LETTER_SMALL_YU, postJwrd),

  385.         new SpecialMapping(KATAKANA_LETTER_YU, jwrd),

  386.         new SpecialMapping(KATAKANA_LETTER_SMALL_YO, postJwrd),

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

  388.         new SpecialMapping(KATAKANA_LETTER_SMALL_WA, postJwrd),

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

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

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

  392.         new SpecialMapping(KATAKANA_HIRAGANA_PROLONGED_SOUND_MARK, postJwrd),

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

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

  395.         new SpecialMapping(CJK_COMPATIBILITY_F900,

  396.                            CJK_COMPATIBILITY_FA2D, jwrd),

  397.         new SpecialMapping(UNICODE_ZERO_WIDTH_NON_BREAKING_SPACE, nbsp),

  398.         new SpecialMapping(FULLWIDTH_EXCLAMATION_MARK, postJwrd),

  399.         new SpecialMapping(FULLWIDTH_COMMA, postJwrd),

  400.         new SpecialMapping(FULLWIDTH_FULL_STOP, postJwrd),

  401.         new SpecialMapping(FULLWIDTH_QUESTION_MARK, postJwrd),

  402.         new SpecialMapping(END_OF_STRING, EOS)

  403.     };

  404. 

  405.     private static final boolean LineExceptionFlags[] = {

  406.         false,          // kNonCharacter            = 0,

  407.         false,          // kUppercaseLetter         = 1,

  408.         false,          // kLowercaseLetter         = 2,

  409.         false,          // kTitlecaseLetter         = 3,

  410.         true,           // kModifierLetter          = 4,

  411.         true,           // kOtherLetter             = 5,

  412.         true,           // kNonSpacingMark          = 6,

  413.         false,          // kEnclosingMark           = 7,

  414.         false,          // kCombiningSpacingMark    = 8,

  415.         false,          // kDecimalNumber           = 9,

  416.         false,          // kLetterNumber            = 10,

  417.         false,          // kOtherNumber             = 11,

  418.         true,           // kSpaceSeparator          = 12,

  419.         true,           // kLineSeparator           = 13,

  420.         true,           // kParagraphSeparator      = 14,

  421.         true,           // kControlCharacter        = 15,

  422.         true,           // kFormatCharacter         = 16,

  423.         false,          // UNDEFINED                = 17,

  424.         false,          // kPrivateUseCharacter     = 18,

  425.         false,          // kSurrogate               = 19,

  426.         true,           // kDashPunctuation         = 20,

  427.         false,          // kOpenPunctuation         = 21,

  428.         false,          // kClosePunctuation        = 22,

  429.         false,          // kConnectorPunctuation    = 23,

  430.         true,           // kOtherPunctuation        = 24,

  431.         false,          // kMathSymbol              = 25,

  432.         true,           // kCurrencySymbol          = 26,

  433.         false,          // kModifierSymbol          = 27,

  434.         true            // kOtherSymbol             = 28

  435.     };

  436. 

  437.     private static final int kLineAsciiValues[] = {

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

  439.             blank,  blank,  blank,  BREAK,  blank,  blank,  blank,  blank,

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

  441.             blank,  BREAK,  BREAK,  BREAK,  BREAK,  cr,     blank,  blank,

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

  443.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  445.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  447.             blank,  postJwrd, quote, nonBlank, currency, postJwrd, nonBlank, nonBlank,

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

  449.             preJwrd, postJwrd, nonBlank, nonBlank, numPunct, op, numPunct, nonBlank,

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

  451.             digit,    digit,    digit,    digit,    digit,    digit,    digit,    digit,

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

  453.             digit,    digit,    postJwrd, postJwrd, nonBlank, nonBlank, nonBlank, postJwrd,

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

  455.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  457.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  459.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  461.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, postJwrd, nonBlank, nonBlank,

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

  463.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  465.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  467.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  469.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, postJwrd, nonBlank, blank,

  470.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  471.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  472.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  473.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  474.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  475.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  476.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  477.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  479.             nbsp,  nonBlank, postJwrd, currency, currency, currency, nonBlank, nonBlank,

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

  481.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, op, nonBlank, nonBlank,

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

  483.             postJwrd, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  485.             nonBlank, nonBlank, nonBlank, postJwrd, digit,    digit,    digit,    nonBlank,

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

  487.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  489.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  491.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  493.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  495.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  497.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  499.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  501.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank

  502.     };

  503. 

  504.     private static final UnicodeClassMapping kLineMap

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

  506.         kLineAsciiValues);

  507. }