1. /*

  2.  * @(#)LineBreakData.java	1.13 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.  * @(#)LineBreakData.java	1.13 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 LineBreakData contains data used by SimpleTextBoundary

  45.  * to determine line breaks.

  46.  * @see #BreakIterator

  47.  */

  48. final class LineBreakData extends TextBoundaryData

  49. {

  50.     private static final byte BREAK                 = 0;

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

  52.     private static final byte blank                 = 1;

  53.     //spaces, tabs, nulls.

  54.     private static final byte cr                    = 2;

  55.     //carriage return

  56.     private static final byte nonBlank              = 3;

  57.     //everything not included elsewhere

  58.     private static final byte op                    = 4;

  59.     //hyphens....

  60.     private static final byte jwrd                  = 5;

  61.     //hiragana, katakana, and kanji

  62.     private static final byte preJwrd               = 6;

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

  64.     private static final byte postJwrd              = 7;

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

  66.     private static final byte digit                 = 8;

  67.     //digits

  68.     private static final byte numPunct              = 9;

  69.     //punctuation that can appear within a number

  70.     private static final byte currency              = 10;

  71.     //currency symbols that can precede a number

  72.     private static final byte nsm                   = 11;

  73.     // non-spacing marks

  74.     private static final byte nbsp                  = 12;

  75.     // non-breaking characters

  76.     private static final byte EOS                   = 13;

  77.     private static final int COL_COUNT = 14;

  78. 

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

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

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

  82. 

  83.     public LineBreakData() {

  84.         super(kLineForward, kLineBackward, kLineMap);

  85.     }

  86. 

  87.     private static final byte kLineForwardData[] =

  88.     {

  89.         // brk         bl             cr             nBl

  90.         // op          kan            prJ            poJ

  91.         // dgt         np             curr           nsm

  92.         // nbsp        EOS

  93.         /*00*/

  94.         STOP,          STOP,          STOP,          STOP,

  95.         STOP,          STOP,          STOP,          STOP,

  96.         STOP,          STOP,          STOP,          STOP,

  97.         STOP,          STOP,

  98.         /*01*/

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

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

  101.         (byte)(SI+9),  (byte)(SI+8),  (byte)(SI+1),  (byte)(SI+1),

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

  103.         /*02*/

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

  105.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  106.         SI_STOP,       SI_STOP,       SI_STOP,       (byte)(SI+2),

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

  108.         /*03*/

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

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

  111.         (byte)(SI+9),  (byte)(SI+8),  SI_STOP,       (byte)(SI+3),

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

  113.         /*04*/

  114.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  115.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  116.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  117.         SI_STOP,       SI_STOP,

  118.         /*05*/

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

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

  121.         SI_STOP,       (byte)(SI+8),  SI_STOP,       (byte)(SI+5),

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

  123.         /*06*/

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

  125.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  126.         (byte)(SI+9),  SI_STOP,       (byte)(SI+11), (byte)(SI+6),

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

  128.         /*07*/

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

  130.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  131.         SI_STOP,       SI_STOP,       SI_STOP,       SI_STOP,

  132.         SI_STOP,       SI_STOP,

  133.         /*08*/

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

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

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

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

  138.         /*09*/

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

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

  141.         (byte)(SI+9),  (byte)(SI+10), (byte)(SI+10), (byte)(SI+9),

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

  143.         /*10*/

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

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

  146.         (byte)(SI+9),  (byte)(SI+8),  SI_STOP,       (byte)(SI+10),

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

  148.         /*11*/

  149.         STOP,          STOP,          STOP,          STOP,

  150.         STOP,          STOP,          STOP,          STOP,

  151.         (byte)(SI+9),  STOP,          STOP,          (byte)(11),

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

  153.     };

  154. 

  155.     private static final WordBreakTable kLineForward

  156.         = new WordBreakTable(COL_COUNT, kLineForwardData);

  157. 

  158.     private static final byte kLineBackwardData[] =

  159.     {

  160.         // brk         bl             cr             nBl

  161.         // op          kan            prJ            poJ

  162.         // dgt         np             curr           nsm

  163.         // nbsp        EOS

  164.         /*00*/

  165.         STOP,          STOP,          STOP,          STOP,

  166.         STOP,          STOP,          STOP,          STOP,

  167.         STOP,          STOP,          STOP,          STOP,

  168.         STOP,          STOP,

  169.         /*01*/

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

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

  172.         (byte)(SI+2),  (byte)(SI+3),  (byte)(SI+2),  (byte)(SI+1),

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

  174.         /*02*/

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

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

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

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

  179.         /*03*/

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

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

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

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

  184.         /*04*/

  185.         STOP,          STOP,          STOP,          STOP,

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

  187.         STOP,          STOP,          (byte)(SI+2),  (byte)(SI+4),

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

  189.     };

  190. 

  191.     private static final WordBreakTable kLineBackward

  192.         = new WordBreakTable(COL_COUNT, kLineBackwardData);

  193. 

  194.     private static final int kRawMapping[] =

  195.     {

  196.         nonBlank, //UNASSIGNED             = 0,

  197.         nonBlank, //UPPERCASE_LETTER       = 1,

  198.         nonBlank, //LOWERCASE_LETTER       = 2,

  199.         nonBlank, //TITLECASE_LETTER       = 3,

  200.         nonBlank, //MODIFIER_LETTER        = 4,

  201.         nonBlank, //OTHER_LETTER           = 5,

  202.         nsm,      //NON_SPACING_MARK       = 6,

  203.         nsm,      //ENCLOSING_MARK         = 7,

  204.         nonBlank, //COMBINING_SPACING_MARK = 8,

  205.         digit, //DECIMAL_DIGIT_NUMBER      = 9,

  206.         nonBlank, //LETTER_NUMBER          = 10,

  207.         digit, //OTHER_NUMBER              = 11,

  208.         blank, //SPACE_SEPARATOR           = 12,

  209.         blank, //LINE_SEPARATOR            = 13,

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

  211.         blank, //CONTROL                   = 15,

  212.         nonBlank, //PRIVATE_USE            = 16,

  213.         nonBlank, //FORMAT                 = 17

  214.         nonBlank, //????                   = 18,

  215.         nonBlank, //SURROGATE              = 19,

  216.         op, //DASH_PUNCTUATION             = 20,

  217.         preJwrd, //START_PUNCTUATION       = 21,

  218.         postJwrd, //END_PUNCTUATION        = 22,

  219.         nonBlank, //CONNECTOR_PUNCTUATION  = 23,

  220.         nonBlank, //OTHER_PUNCTUATION      = 24,

  221.         nonBlank, //MATH_SYMBOL            = 25,

  222.         preJwrd, //CURRENCY_SYMBOL         = 26,

  223.         nonBlank, //MODIFIER_SYMBOL        = 27,

  224.         nonBlank  //OTHER_SYMBOL           = 28;

  225.     };

  226. 

  227.     private static SpecialMapping kExceptionChar[] =

  228.     {

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

  230.         //      required by the UnicodeClassMapping class.

  231.         new SpecialMapping(ASCII_END_OF_TEXT, BREAK),

  232.         new SpecialMapping(ASCII_HORIZONTAL_TABULATION,

  233.                            ASCII_FORM_FEED, BREAK),

  234.         new SpecialMapping(ASCII_CARRIAGE_RETURN, cr),

  235.         new SpecialMapping(ASCII_EXCLAMATION_MARK, postJwrd),

  236.         new SpecialMapping(ASCII_DOLLAR_SIGN, preJwrd),

  237.         new SpecialMapping(ASCII_PERCENT, postJwrd),

  238.         new SpecialMapping(ASCII_COMMA, numPunct),

  239.         new SpecialMapping(ASCII_FULL_STOP, numPunct),

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

  241.         new SpecialMapping(ASCII_QUESTION_MARK, postJwrd),

  242.         new SpecialMapping(ASCII_NONBREAKING_SPACE, nbsp),

  243.         new SpecialMapping(ASCII_CENT_SIGN, postJwrd),

  244.         new SpecialMapping(LATIN1_SOFTHYPHEN, op),

  245.         new SpecialMapping(LATIN1_DEGREE_SIGN, postJwrd),

  246.         new SpecialMapping(ARABIC_PERCENT_SIGN, postJwrd),

  247.         new SpecialMapping(FIGURE_SPACE, nbsp),

  248.         new SpecialMapping(NONBREAKING_HYPHEN, nbsp),

  249.         new SpecialMapping(PUNCTUATION_LINE_SEPARATOR,

  250.                            PUNCTUATION_PARAGRAPH_SEPARATOR, BREAK),

  251.         new SpecialMapping(PER_MILLE_SIGN, postJwrd),

  252.         new SpecialMapping(PER_TEN_THOUSAND_SIGN, postJwrd),

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

  254.         new SpecialMapping(DEGREE_CELSIUS, postJwrd),

  255.         new SpecialMapping(DEGREE_FAHRENHEIT, postJwrd),

  256.         new SpecialMapping(PUNCTUATION_IDEOGRAPHIC_COMMA,

  257.                            PUNCTUATION_IDEOGRAPHIC_FULL_STOP, postJwrd),

  258.         new SpecialMapping(IDEOGRAPHIC_ITERATION_MARK, postJwrd),

  259.         new SpecialMapping(HIRAGANA_LETTER_SMALL_A, postJwrd),

  260.         new SpecialMapping(HIRAGANA_LETTER_A, jwrd),

  261.         new SpecialMapping(HIRAGANA_LETTER_SMALL_I, postJwrd),

  262.         new SpecialMapping(HIRAGANA_LETTER_I, jwrd),

  263.         new SpecialMapping(HIRAGANA_LETTER_SMALL_U, postJwrd),

  264.         new SpecialMapping(HIRAGANA_LETTER_U, jwrd),

  265.         new SpecialMapping(HIRAGANA_LETTER_SMALL_E, postJwrd),

  266.         new SpecialMapping(HIRAGANA_LETTER_E, jwrd),

  267.         new SpecialMapping(HIRAGANA_LETTER_SMALL_O, postJwrd),

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

  269.         new SpecialMapping(HIRAGANA_LETTER_SMALL_TU, postJwrd),

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

  271.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YA, postJwrd),

  272.         new SpecialMapping(HIRAGANA_LETTER_YA, jwrd),

  273.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YU, postJwrd),

  274.         new SpecialMapping(HIRAGANA_LETTER_YU, jwrd),

  275.         new SpecialMapping(HIRAGANA_LETTER_SMALL_YO, postJwrd),

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

  277.         new SpecialMapping(HIRAGANA_LETTER_SMALL_WA, postJwrd),

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

  279.         new SpecialMapping(COMBINING_KATAKANA_HIRAGANA_VOICED_SOUND_MARK,

  280.                            HIRAGANA_SEMIVOICED_SOUND_MARK, postJwrd),

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

  282.         new SpecialMapping(KATAKANA_LETTER_SMALL_A, postJwrd),

  283.         new SpecialMapping(KATAKANA_LETTER_A, jwrd),

  284.         new SpecialMapping(KATAKANA_LETTER_SMALL_I, postJwrd),

  285.         new SpecialMapping(KATAKANA_LETTER_I, jwrd),

  286.         new SpecialMapping(KATAKANA_LETTER_SMALL_U, postJwrd),

  287.         new SpecialMapping(KATAKANA_LETTER_U, jwrd),

  288.         new SpecialMapping(KATAKANA_LETTER_SMALL_E, postJwrd),

  289.         new SpecialMapping(KATAKANA_LETTER_E, jwrd),

  290.         new SpecialMapping(KATAKANA_LETTER_SMALL_O, postJwrd),

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

  292.         new SpecialMapping(KATAKANA_LETTER_SMALL_TU, postJwrd),

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

  294.         new SpecialMapping(KATAKANA_LETTER_SMALL_YA, postJwrd),

  295.         new SpecialMapping(KATAKANA_LETTER_YA, jwrd),

  296.         new SpecialMapping(KATAKANA_LETTER_SMALL_YU, postJwrd),

  297.         new SpecialMapping(KATAKANA_LETTER_YU, jwrd),

  298.         new SpecialMapping(KATAKANA_LETTER_SMALL_YO, postJwrd),

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

  300.         new SpecialMapping(KATAKANA_LETTER_SMALL_WA, postJwrd),

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

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

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

  304.         new SpecialMapping(KATAKANA_HIRAGANA_PROLONGED_SOUND_MARK, postJwrd),

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

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

  307.         new SpecialMapping(CJK_COMPATIBILITY_F900,

  308.                            CJK_COMPATIBILITY_FA2D, jwrd),

  309.         new SpecialMapping(UNICODE_ZERO_WIDTH_NON_BREAKING_SPACE, nbsp),

  310.         new SpecialMapping(FULLWIDTH_EXCLAMATION_MARK, postJwrd),

  311.         new SpecialMapping(FULLWIDTH_FULL_STOP, postJwrd),

  312.         new SpecialMapping(FULLWIDTH_QUESTION_MARK, postJwrd),

  313.         new SpecialMapping(END_OF_STRING, EOS)

  314.     };

  315. 

  316.     private static final boolean LineExceptionFlags[] = {

  317.         false,          // kNonCharacter            = 0,

  318.         false,          // kUppercaseLetter         = 1,

  319.         false,          // kLowercaseLetter         = 2,

  320.         false,          // kTitlecaseLetter         = 3,

  321.         true,           // kModifierLetter          = 4,

  322.         true,           // kOtherLetter             = 5,

  323.         true,           // kNonSpacingMark          = 6,

  324.         false,          // kEnclosingMark           = 7,

  325.         false,          // kCombiningSpacingMark    = 8,

  326.         false,          // kDecimalNumber           = 9,

  327.         false,          // kLetterNumber            = 10,

  328.         false,          // kOtherNumber             = 11,

  329.         true,           // kSpaceSeparator          = 12,

  330.         true,           // kLineSeparator           = 13,

  331.         true,           // kParagraphSeparator      = 14,

  332.         true,           // kControlCharacter        = 15,

  333.         true,           // kFormatCharacter         = 16,

  334.         false,          // UNDEFINED                = 17,

  335.         false,          // kPrivateUseCharacter     = 18,

  336.         false,          // kSurrogate               = 19,

  337.         true,           // kDashPunctuation         = 20,

  338.         false,          // kOpenPunctuation         = 21,

  339.         false,          // kClosePunctuation        = 22,

  340.         false,          // kConnectorPunctuation    = 23,

  341.         true,           // kOtherPunctuation        = 24,

  342.         false,          // kMathSymbol              = 25,

  343.         true,           // kCurrencySymbol          = 26,

  344.         false,          // kModifierSymbol          = 27,

  345.         true            // kOtherSymbol             = 28

  346.     };

  347. 

  348.     private static final int kLineAsciiValues[] = {

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

  350.             blank,  blank,  blank,  BREAK,  blank,  blank,  blank,  blank,

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

  352.             blank,  BREAK,  BREAK,  BREAK,  BREAK,  cr,     blank,  blank,

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

  354.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  356.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  358.             blank,  postJwrd, nonBlank, nonBlank, currency, postJwrd, nonBlank, nonBlank,

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

  360.             preJwrd, postJwrd, nonBlank, nonBlank, numPunct, op, numPunct, nonBlank,

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

  362.             digit,    digit,    digit,    digit,    digit,    digit,    digit,    digit,

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

  364.             digit,    digit,    postJwrd, postJwrd, nonBlank, nonBlank, nonBlank, postJwrd,

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

  366.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  368.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  370.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  372.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, postJwrd, nonBlank, nonBlank,

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

  374.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  376.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  378.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  380.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, postJwrd, nonBlank, blank,

  381.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  382.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  383.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  384.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  385.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  386.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

  387.         //  ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl    ctrl

  388.             blank,  blank,  blank,  blank,  blank,  blank,  blank,  blank,

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

  390.             nbsp,  nonBlank, postJwrd, currency, currency, currency, nonBlank, nonBlank,

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

  392.             nonBlank, nonBlank, nonBlank, preJwrd, nonBlank, op, nonBlank, nonBlank,

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

  394.             postJwrd, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  396.             nonBlank, nonBlank, nonBlank, postJwrd, digit,    digit,    digit,    nonBlank,

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

  398.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  400.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  402.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  404.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  406.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  408.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  410.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank,

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

  412.             nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank, nonBlank

  413.     };

  414. 

  415.     private static final UnicodeClassMapping kLineMap

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

  417.         kLineAsciiValues);

  418. }