/* * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* */ /* * Licensed Materials - Property of IBM * * (C) Copyright IBM Corp. 1999 All Rights Reserved. * (C) IBM Corp. 1997-1998.  All Rights Reserved. * * The program is provided "as is" without any warranty express or * implied, including the warranty of non-infringement and the implied * warranties of merchantibility and fitness for a particular purpose. * IBM will not be liable for any damages suffered by you as a result * of using the Program. In no event will IBM be liable for any * special, indirect or consequential damages or lost profits even if * IBM has been advised of the possibility of their occurrence. IBM * will not be liable for any third party claims against you. */ package sun.text.resources; import java.util.ListResourceBundle; /** * Default break-iterator rules.  These rules are more or less general for * all locales, although there are probably a few we're missing.  The * behavior currently mimics the behavior of BreakIterator in JDK 1.2. * There are known deficiencies in this behavior, including the fact that * the logic for handling CJK characters works for Japanese but not for * Chinese, and that we don't currently have an appropriate locale for * Thai.  The resources will eventually be updated to fix these problems. */  /* Modified for Hindi 3/1/99. */ /* * Since JDK 1.5.0, this file no longer goes to runtime and is used at J2SE * build phase in order to create [Character|Word|Line|Sentence]BreakIteratorData * files which are used on runtime instead. */ public class BreakIteratorRules extends ListResourceBundle {    protected final Object[][] getContents() {        return new Object[][] {            // rules describing how to break between logical characters            { "CharacterBreakRules",               // ignore non-spacing marks and enclosing marks (since we never              // put a break before ignore characters, this keeps combining              // accents with the base characters they modify)              "<enclosing>=[:Mn::Me:];"               // other category definitions              + "<choseong>=[\u1100-\u115f];"              + "<jungseong>=[\u1160-\u11a7];"              + "<jongseong>=[\u11a8-\u11ff];"              + "<surr-hi>=[\ud800-\udbff];"              + "<surr-lo>=[\udc00-\udfff];"               // break after every character, except as follows:              + ".;"               // keep base and combining characters togethers              + "<base>=[^<enclosing>^[:Cc::Cf::Zl::Zp:]];"              + "<base><enclosing><enclosing>*;"               // keep CRLF sequences together              + "\r\n;"               // keep surrogate pairs together              + "<surr-hi><surr-lo>;"               // keep Hangul syllables spelled out using conjoining jamo together              + "<choseong>*<jungseong>*<jongseong>*;"               // various additions for Hindi support              + "<nukta>=[\u093c];"              + "<danda>=[\u0964\u0965];"              + "<virama>=[\u094d];"              + "<devVowelSign>=[\u093e-\u094c\u0962\u0963];"              + "<devConsonant>=[\u0915-\u0939];"              + "<devNuktaConsonant>=[\u0958-\u095f];"              + "<devCharEnd>=[\u0902\u0903\u0951-\u0954];"              + "<devCAMN>=(<devConsonant>{<nukta>});"              + "<devConsonant1>=(<devNuktaConsonant>|<devCAMN>);"              + "<zwj>=[\u200d];"              + "<devConjunct>=({<devConsonant1><virama>{<zwj>}}<devConsonant1>);"              + "<devConjunct>{<devVowelSign>}{<devCharEnd>};"              + "<danda><nukta>;"            },             // default rules for finding word boundaries            { "WordBreakRules",              // ignore non-spacing marks, enclosing marks, and format characters,              // all of which should not influence the algorithm              //"<ignore>=[:Mn::Me::Cf:];"              "<ignore>=[:Cf:];"               + "<enclosing>=[:Mn::Me:];"               // Hindi phrase separator, kanji, katakana, hiragana, CJK diacriticals,              // other letters, and digits              + "<danda>=[\u0964\u0965];"              + "<kanji>=[\u3005\u4e00-\u9fa5\uf900-\ufa2d];"              + "<kata>=[\u30a1-\u30fa\u30fd\u30fe];"              + "<hira>=[\u3041-\u3094\u309d\u309e];"              + "<cjk-diacrit>=[\u3099-\u309c\u30fb\u30fc];"              + "<letter-base>=[:L::Mc:^[<kanji><kata><hira><cjk-diacrit>]];"              + "<let>=(<letter-base><enclosing>*);"              + "<digit-base>=[:N:];"              + "<dgt>=(<digit-base><enclosing>*);"               // punctuation that can occur in the middle of a word: currently              // dashes, apostrophes, quotation marks, and periods              + "<mid-word>=[:Pd::Pc:\u00ad\u2027\\\"\\\'\\.];"               // punctuation that can occur in the middle of a number: currently              // apostrophes, qoutation marks, periods, commas, and the Arabic              // decimal point              + "<mid-num>=[\\\"\\\'\\,\u066b\\.];"               // punctuation that can occur at the beginning of a number: currently              // the period, the number sign, and all currency symbols except the cents sign              + "<pre-num>=[:Sc:\\#\\.^\u00a2];"               // punctuation that can occur at the end of a number: currently              // the percent, per-thousand, per-ten-thousand, and Arabic percent              // signs, the cents sign, and the ampersand              + "<post-num>=[\\%\\&\u00a2\u066a\u2030\u2031];"               // line separators: currently LF, FF, PS, and LS              + "<ls>=[\n\u000c\u2028\u2029];"               // whitespace: all space separators and the tab character              + "<ws-base>=[:Zs:\t];"              + "<ws>=(<ws-base><enclosing>*);"               // a word is a sequence of letters that may contain internal              // punctuation, as long as it begins and ends with a letter and              // never contains two punctuation marks in a row              + "<word>=((<let><let>*(<mid-word><let><let>*)*){<danda>});"               // a number is a sequence of digits that may contain internal              // punctuation, as long as it begins and ends with a digit and              // never contains two punctuation marks in a row.              + "<number>=(<dgt><dgt>*(<mid-num><dgt><dgt>*)*);"               // break after every character, with the following exceptions              // (this will cause punctuation marks that aren't considered              // part of words or numbers to be treated as words unto themselves)              + ".;"               // keep together any sequence of contiguous words and numbers              // (including just one of either), plus an optional trailing              // number-suffix character              + "{<word>}(<number><word>)*{<number>{<post-num>}};"               // keep together and sequence of contiguous words and numbers              // that starts with a number-prefix character and a number,              // and may end with a number-suffix character              + "<pre-num>(<number><word>)*{<number>{<post-num>}};"               // keep together runs of whitespace (optionally with a single trailing              // line separator or CRLF sequence)              + "<ws>*{\r}{<ls>};"               // keep together runs of Katakana and CJK diacritical marks              + "[<kata><cjk-diacrit>]*;"               // keep together runs of Hiragana and CJK diacritical marks              + "[<hira><cjk-diacrit>]*;"               // keep together runs of Kanji              + "<kanji>*;"               // keep together anything else and an enclosing mark              + "<base>=[^<enclosing>^[:Cc::Cf::Zl::Zp:]];"              + "<base><enclosing><enclosing>*;"            },             // default rules for determining legal line-breaking positions            { "LineBreakRules",              // characters that always cause a break: ETX, tab, LF, FF, LS, and PS              "<break>=[\u0003\t\n\f\u2028\u2029];"               // ignore format characters and control characters EXCEPT for breaking chars              + "<ignore>=[:Cf:[:Cc:^[<break>\r]]];"               // enclosing marks              + "<enclosing>=[:Mn::Me:];"               // Hindi phrase separators              + "<danda>=[\u0964\u0965];"               // characters that always prevent a break: the non-breaking space              // and similar characters              + "<glue>=[\u00a0\u0f0c\u2007\u2011\u202f\ufeff];"               // whitespace: space separators and control characters, except for              // CR and the other characters mentioned above              + "<space>=[:Zs::Cc:^[<glue><break>\r]];"               // dashes: dash punctuation and the discretionary hyphen, except for              // non-breaking hyphens              + "<dash>=[:Pd:\u00ad^<glue>];"               // characters that stick to a word if they precede it: currency symbols              // (except the cents sign) and starting punctuation              + "<pre-word>=[:Sc::Ps::Pi:^[\u00a2]\\\"\\\'];"               // characters that stick to a word if they follow it: ending punctuation,              // other punctuation that usually occurs at the end of a sentence,              // small Kana characters, some CJK diacritics, etc.              + "<post-word>=[\\\":Pe::Pf:\\!\\%\\.\\,\\:\\;\\?\u00a2\u00b0\u066a\u2030-\u2034\u2103"              + "\u2105\u2109\u3001\u3002\u3005\u3041\u3043\u3045\u3047\u3049\u3063"              + "\u3083\u3085\u3087\u308e\u3099-\u309e\u30a1\u30a3\u30a5\u30a7\u30a9"              + "\u30c3\u30e3\u30e5\u30e7\u30ee\u30f5\u30f6\u30fc-\u30fe\uff01\uff05"              + "\uff0c\uff0e\uff1a\uff1b\uff1f];"               // Kanji: actually includes Kanji,Kana and Hangul syllables,              // except for small Kana and CJK diacritics              + "<kanji>=[\u4e00-\u9fa5\uac00-\ud7a3\uf900-\ufa2d\ufa30-\ufa6a\u3041-\u3094\u30a1-\u30fa^[<post-word><ignore>]];"               // digits              + "<digit>=[:Nd::No:];"               // punctuation that can occur in the middle of a number: periods and commas              + "<mid-num>=[\\.\\,];"               // everything not mentioned above              + "<char>=[^[<break><space><dash><kanji><glue><ignore><pre-word><post-word><mid-num>\r<danda>]];"               // a "number" is a run of prefix characters and dashes, followed by one or              // more digits with isolated number-punctuation characters interspersed              + "<number>=([<pre-word><dash>]*<digit><digit>*(<mid-num><digit><digit>*)*);"               // the basic core of a word can be either a "number" as defined above, a single              // "Kanji" character, or a run of any number of not-explicitly-mentioned              // characters (this includes Latin letters)              + "<word-core>=(<char>*|<kanji>|<number>);"               // a word may end with an optional suffix that be either a run of one or              // more dashes or a run of word-suffix characters              + "<word-suffix>=((<dash><dash>*|<post-word>*));"               // a word, thus, is an optional run of word-prefix characters, followed by              // a word core and a word suffix (the syntax of <word-core> and <word-suffix>              // actually allows either of them to match the empty string, putting a break              // between things like ")(" or "aaa(aaa"              + "<word>=(<pre-word>*<word-core><word-suffix>);"               + "<hack1>=[\\(];"              + "<hack2>=[\\)];"              + "<hack3>=[\\$\\'];"               // finally, the rule that does the work: Keep together any run of words that              // are joined by runs of one of more non-spacing mark.  Also keep a trailing              // line-break character or CRLF combination with the word.  (line separators              // "win" over nbsp's)              + "<word>(((<space>*<glue><glue>*{<space>})|<hack3>)<word>)*<space>*{<enclosing>*}{<hack1><hack2><post-word>*}{<enclosing>*}{\r}{<break>};"              + "\r<break>;"            },             // default rules for finding sentence boundaries            { "SentenceBreakRules",              // ignore non-spacing marks, enclosing marks, and format characters              "<ignore>=[:Mn::Me::Cf:];"               // letters              + "<letter>=[:L:];"               // lowercase letters              + "<lc>=[:Ll:];"               // uppercase letters              + "<uc>=[:Lu:];"               // NOT lowercase letters              + "<notlc>=[<letter>^<lc>];"               // whitespace (line separators are treated as whitespace)              + "<space>=[\t\r\f\n\u2028:Zs:];"               // punctuation which may occur at the beginning of a sentence: "starting              // punctuation" and quotation marks              + "<start-punctuation>=[:Ps::Pi:\\\"\\\'];"               // punctuation with may occur at the end of a sentence: "ending punctuation"              // and quotation marks              + "<end>=[:Pe::Pf:\\\"\\\'];"               // digits              + "<digit>=[:N:];"               // characters that unambiguously signal the end of a sentence              + "<term>=[\\!\\?\u3002\uff01\uff1f];"               // periods, which MAY signal the end of a sentence              + "<period>=[\\.\uff0e];"               // characters that may occur at the beginning of a sentence: basically anything              // not mentioned above (letters and digits are specifically excluded)              + "<sent-start>=[^[:L:<space><start-punctuation><end><digit><term><period>\u2029<ignore>]];"               // Hindi phrase separator              + "<danda>=[\u0964\u0965];"               // always break sentences after paragraph separators              + ".*?{\u2029};"               // always break after a danda, if it's followed by whitespace              + ".*?<danda><space>*;"               // if you see a period, skip over additional periods and ending punctuation              // and if the next character is a paragraph separator, break after the              // paragraph separator              //+ ".*?<period>[<period><end>]*<space>*\u2029;"              //+ ".*?[<period><end>]*<space>*\u2029;"               // if you see a period, skip over additional periods and ending punctuation,              // followed by optional whitespace, followed by optional starting punctuation,              // and if the next character is something that can start a sentence              // (basically, a capital letter), then put the sentence break between the              // whitespace and the opening punctuation              + ".*?<period>[<period><end>]*<space><space>*/<notlc>;"              + ".*?<period>[<period><end>]*<space>*/[<start-punctuation><sent-start>][<start-punctuation><sent-start>]*<letter>;"               // if you see a sentence-terminating character, skip over any additional              // terminators, periods, or ending punctuation, followed by any whitespace,              // followed by a SINGLE optional paragraph separator, and put the break there              + ".*?<term>[<term><period><end>]*<space>*{\u2029};"               // The following rules are here to aid in backwards iteration.  The automatically              // generated backwards state table will rewind to the beginning of the              // paragraph all the time (or all the way to the beginning of the document              // if the document doesn't use the Unicode PS character) because the only              // unambiguous character pairs are those involving paragraph separators.              // These specify a few more unambiguous breaking situations.               // if you see a sentence-starting character, followed by starting punctuation              // (remember, we're iterating backwards), followed by an optional run of              // whitespace, followed by an optional run of ending punctuation, followed              // by a period, this is a safe place to turn around              + "!<sent-start><start-punctuation>*<space>*<end>*<period>;"               // if you see a letter or a digit, followed by an optional run of              // starting punctuation, followed by an optional run of whitespace,              // followed by an optional run of ending punctuation, followed by              // a sentence terminator, this is a safe place to turn around              + "![<sent-start><lc><digit>]<start-punctuation>*<space>*<end>*<term>;"            }        };    }}