Back to index...

	/*
	* 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>;"
	}
	};
	}
	}

Back to index...