yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SimpleDateFormat.java: Re-merged with Classpath.

Browse Source 
* java/text/SimpleDateFormat.java: Re-merged with Classpath.
	* gnu/gcj/text/LocaleData.java, gnu/gcj/text/LocaleData_en.java,
	gnu/gcj/text/LocaleData_en_US.java: Removed.
	* java/text/DateFormatSymbols.java (clone): Use Classpath
	implementation.
	(equals): Simplified.
	(DateFormatSymbols): Look in gnu.java.locale for information.
	(DateFormatSymbols(DateFormatSymbols)): Removed.
	(safeGetResource): Removed.
	(DateFormatSymbols): Throws MissingResourceException.
	(ampmsDefault, erasDefault, localPatternCharsDefault,
	monthsDefault, shortMonthsDefault, shortWeekdaysDefault,
	weekdaysDefault, zoneStringsDefault): Removed.
	* java/text/Collator.java (getAvailableLocales): Use modified
	Classpath implementation.
	(getInstance): Look in gnu.java.locale for information.
	(clone): Rewrote.
	* java/text/MessageFormat.java: Reindented.
	(clone): Rewrote.
	* java/text/FieldPosition.java: Merged with Classpath.
	* java/text/ParsePosition.java: Merged with Classpath.
	* java/text/Format.java: Merged with Classpath.
	* java/text/StringCharacterIterator.java
	(StringCharacterIterator(StringCharacterIterator,int,int)): New
	constructor from Classpath.
	* java/text/Annotation.java,
	java/text/AttributedCharacterIterator.java,
	java/text/AttributedString.java,
	java/text/AttributedStringIterator.java: New from Classpath.
	* java/text/CharacterIterator.java: Copied from Classpath.
	* java/text/ChoiceFormat.java: Reindented.
	(clone): Removed.
	* gnu/java/text/BaseBreakIterator.java,
	gnu/java/text/CharacterBreakIterator.java,
	gnu/java/text/LineBreakIterator.java,
	gnu/java/text/LocaleData_en.java,
	gnu/java/text/LocaleData_en_US.java,
	gnu/java/text/SentenceBreakIterator.java,
	gnu/java/text/WordBreakIterator.java: Renamed from gnu/gcj/text/*.
	* gnu/gcj/text/BaseBreakIterator.java (last): Advance past final
	character.
	* java/text/BreakIterator.java (getAvailableLocales): Use
	Classpath implementation.
	(getInstance): Look in gnu.java.locale for information.
	(getCharacterInstance, getLineInstance, getSentenceInstance,
	getWordInstance): Look in gnu.java.text for implementations.
	* java/text/DecimalFormatSymbols.java: Reindented
	(clone): Use Classpath implementation.
	(DecimalFormatSymbols(DecimalFormatSymbols)): Removed.
	(DecimalFormatSymbols(Locale)): Look in gnu.java.locale for
	information.
	* java/text/DateFormat.java: Merged with Classpath.
	(getAvailableLocales): Use Classpath implementation.
	(format(Object,StringBuffer,FieldPosition)): Minor cleanup.
	(computeInstance): Look in gnu.java.locale for information.
	* java/text/NumberFormat.java: Reindented.
	(computeInstance): Look in gnu.java.locale for information.
	(getAvailableLocales): Use implementation from Classpath.
	(setMaximumIntegerDigits): Likewise.
	(setMinimumIntegerDigits): Likewise.
	(setMaximumFractionDigits): Likewise.
	(clone): Removed.
	* java/text/DecimalFormat.java: Reindented.
	* gnu/java/locale/LocaleInformation_en.java: Copied from Classpath.
	* gnu/java/locale/LocaleInformation_en_US.java: Copied from Classpath.
	* Makefile.in: Rebuilt.
	* Makefile.am (ordinary_java_source_files): Added all new files.
	(ordinary_java_source_files): Renamed or removed gnu/gcj/text/*.
	* java/security/spec/AlgorithmParameterSpec.java,
	java/security/spec/KeySpec.java: Re-merged with Classpath.

From-SVN: r45390
This commit is contained in:
Tom Tromey
2001-09-05 00:00:55 +00:00
committed by Tom Tromey
parent 45932d27fb
commit a1f4e5ed0a
35 changed files with 5666 additions and 2403 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/gnu/java/locale/LocaleInformation_de.java
+2 -2
View File
@@ -1,5 +1,5 @@
/* LocaleInformation_de.java -- German locale data
Copyright (C) 1999 Free Software Foundation, Inc.
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -47,7 +47,7 @@ public class LocaleInformation_de extends ListResourceBundle
* proper format.
*/
private static final String collation_rules =
"-<0,1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<j,K" +
"<0<1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<k,K" +
"<l,L<m,M<n,N<o,O<p,P<q,Q<r,R<s,S<t,T<u,U<v,V<w,W<x,X<y,Y,z<Z" +
"&ae,\u00e4&Ae,\u00c4&oe,\u00f6&Oe,\u00d6&ue,\u00fc&Ue,\u00dc&ss,\u00df";
libjava/gnu/java/locale/LocaleInformation_en.java
+101 -279
View File
@@ -1,5 +1,5 @@
/* LocaleInformation_en.java -- US English locale data
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -32,301 +32,123 @@ import java.util.Calendar;
import java.util.Date;
/**
* This class contains locale data for the US English locale
*/
* This class contains locale data for English.
*/
public class LocaleInformation_en extends ListResourceBundle
{
/*
* This area is used for defining object values
*/
/*
* This area is used for defining object values
*/
/**
* This is the set of collation rules used by java.text.RuleBasedCollator
* to sort strings properly. See the documentation of that class for the
* proper format.
*/
private static final String collation_rules =
"-<0,1<2<3<4<5<6<7<8<9A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<j,K" +
/**
* This is the set of collation rules used by java.text.RuleBasedCollator
* to sort strings properly. See the documentation of that class for the
* proper format.
*/
// FIXME: this is nowhere near complete.
// In particular we must mark accents as ignorable,
// and probably other things as well.
private static final String collation_rules =
"<0<1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<k,K" +
"<l,L<m,M<n,N<o,O<p,P<q,Q<r,R<s,S<t,T<u,U<v,V<w,W<x,X<y,Y,z<Z";
/*
* For the followings lists, strings that are subsets of other break strigns
* must be listed first. For example, if "\r" and "\r\n" are sequences,
* the "\r" must be first or it will never be used.
*/
/**
* This is the list of months, fully spelled out
*/
private static final String[] months =
{
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December", null
};
/**
* This is the list of word separator characters used by
* java.text.BreakIterator
*/
private static final String[] word_breaks = { " ", "\t", "\r\n", "\n" };
/**
* This is the list of abbreviated month names
*/
private static final String[] shortMonths =
{
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec", null
};
/**
* This is the list of sentence break sequences used by
* java.text.BreakIterator
*/
private static final String[] sentence_breaks = { ". " };
/**
* This is the list of weekdays, fully spelled out
*/
private static final String[] weekdays =
{
null, "Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
/**
* This is the list of potential line break locations.
*/
private static final String[] line_breaks = { "\t", "-", "\r\n",
"\n", ". ", ". ", ".", "? ", "? ", "?", "! ", "! ", "!", ", ", " " };
/**
* This is the list of abbreviated weekdays
*/
private static final String[] shortWeekdays =
{
null, "Sun", "Mon", "Tue", "Wed",
"Thu", "Fri", "Sat"
};
/**
* This is the list of months, fully spelled out
*/
private static final String[] months = { "January", "February", "March",
"April", "May", "June", "July", "August", "September", "October",
"November", "December", null };
/**
* This is the list of AM/PM strings
*/
private static final String[] ampms = { "AM", "PM" };
/**
* This is the list of abbreviated month names
*/
private static final String[] shortMonths = { "Jan", "Feb", "Mar", "Apr", "May",
"Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", null };
/**
* This is the list of era identifiers
*/
private static final String[] eras = { "BC", "AD" };
/**
* This is the list of weekdays, fully spelled out
*/
private static final String[] weekdays = { null, "Sunday", "Monday", "Tuesday",
"Wednesday", "Thursday", "Friday", "Saturday" };
/*************************************************************************/
/**
* This is the list of abbreviated weekdays
*/
private static final String[] shortWeekdays = { null, "Sun", "Mon", "Tue", "Wed",
"Thu", "Fri", "Sat" };
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
/**
* This is the list of AM/PM strings
*/
private static final String[] ampms = { "AM", "PM" };
private static final Object[][] contents =
{
// For RuleBasedCollator
{ "collation_rules", collation_rules },
/**
* This is the list of era identifiers
*/
private static final String[] eras = { "BC", "AD" };
// For SimpleDateFormat/DateFormatSymbols
{ "months", months },
{ "shortMonths", shortMonths },
{ "weekdays", weekdays },
{ "shortWeekdays", shortWeekdays },
{ "ampms", ampms },
{ "eras", eras },
{ "localPatternChars", "GyMdkHmsSEDFwWahKz" },
/**
* This is the list of timezone strings. The JDK appears to include a
* city name as the sixth element.
*/
private static final String[][] zoneStrings =
{
{ "EST6EDT", "Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT",
"New York" },
{ "EST6", "Eastern Standard Time", "EST", "Eastern Standard Time", "EST",
"Indianapolis" },
{ "CST6CDT", "Central Standard Time", "CST", "Central Daylight Time", "CDT",
"Chicago" },
{ "MST6MDT", "Mountain Standard Time", "MST", "Mountain Daylight Time",
"MDT", "Denver" },
{ "MST6", "Mountain Standard Time", "MST", "Mountain Standard Time", "MST",
"Phoenix" },
{ "PST6PDT", "Pacific Standard Time", "PDT", "Pacific Daylight Time", "PDT",
"San Francisco" },
{ "AST6ADT", "Alaska Standard Time", "AST", "Alaska Daylight Time", "ADT",
"Anchorage" },
{ "HST6HDT", "Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT",
"Honolulu" },
// European time zones. The city names are a little bit random.
{ "WET", "Western European Time", "WET", "Western European Savings Time", "WEST", "London" },
{ "CET", "Central European Time", "CET", "Central European Savings Time", "CEST", "Berlin" },
{ "EET", "Eastern European Time", "EET", "Eastern European Savings Time", "EEST", "Istanbul" },
};
// For DecimalFormat/DecimalFormatSymbols
{ "decimalSeparator", "." },
{ "digit", "#" },
{ "exponential", "E" },
{ "groupingSeparator", "," },
{ "infinity", "\u221e" },
{ "NaN", "\ufffd" },
{ "minusSign", "-" },
{ "monetarySeparator", "." },
{ "patternSeparator", ";" },
{ "percent", "%" },
{ "perMill", "\u2030" },
{ "zeroDigit", "0" },
/**
* This is the list of pattern characters for formatting dates
*/
private static final String localPatternChars = "GyMdkHmsSEDFwWahKz"; // Not a mistake!
// For NumberFormat.
{ "numberFormat", "#,##0.###" },
{ "percentFormat", "#,##0%" },
};
/**
* This is the DateFormat.SHORT date format
*/
private static final String shortDateFormat = "M/d/yy";
/*************************************************************************/
/**
* This is the DateFormat.MEDIUM format
*/
private static final String mediumDateFormat = "dd-MMM-yy";
/**
* This is the DateFormat.LONG format
*/
private static final String longDateFormat = "MMMM d, yyyy";
/**
* This is the DateFormat.FULL format
*/
private static final String fullDateFormat = "EEEE, MMMM d, yyyy";
/**
* This is the DateFormat.DEFAULT format
*/
private static final String defaultDateFormat = "dd-MMM-yy";
/**
* This is the DateFormat.SHORT format
*/
private static final String shortTimeFormat = "h:mm a";
/**
* This is the DateFormat.MEDIUM format
*/
private static final String mediumTimeFormat = "h:mm:ss a";
/**
* This is the DateFormat.LONG format
*/
private static final String longTimeFormat = "h:mm:ss a z";
/**
* This is the DateFormat.FULL format
*/
private static final String fullTimeFormat = "h:mm:ss 'o''clock' a z";
/**
* This is the DateFormat.DEFAULT format
*/
private static final String defaultTimeFormat = "h:mm:ss a";
/**
* This is the currency symbol
*/
private static final String currencySymbol = "$";
/**
* This is the international currency symbol.
*/
private static final String intlCurrencySymbol = "US$";
/**
* This is the decimal point.
*/
private static final String decimalSeparator = ".";
/**
* This is the exponential symbol
*/
private static final String exponential = "E";
/**
* This is the char used for digits in format strings
*/
private static final String digit = "#";
/**
* This is the grouping separator symbols
*/
private static final String groupingSeparator = ",";
/**
* This is the symbols for infinity
*/
private static final String infinity = "\u221e";
/**
* This is the symbol for the not a number value
*/
private static final String NaN = "\ufffd";
/**
* This is the minus sign symbol.
*/
private static final String minusSign = "-";
/**
* This is the decimal separator in monetary values.
*/
private static final String monetarySeparator = ".";
/**
* This is the separator between positive and negative subpatterns.
*/
private static final String patternSeparator = ";";
/**
* This is the percent sign
*/
private static final String percent = "%";
/**
* This is the per mille sign
*/
private static final String perMill = "\u2030";
/**
* This is the character for zero.
*/
private static final String zeroDigit = "0";
/*************************************************************************/
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
private static final Object[][] contents =
{
// For RuleBasedCollator
{ "collation_rules", collation_rules },
// For BreakIterator
{ "word_breaks", word_breaks },
{ "sentence_breaks", sentence_breaks },
{ "line_breaks", line_breaks },
// For SimpleDateFormat/DateFormatSymbols
{ "months", months },
{ "shortMonths", shortMonths },
{ "weekdays", weekdays },
{ "shortWeekdays", shortWeekdays },
{ "ampms", ampms },
{ "eras", eras },
{ "zoneStrings", zoneStrings },
{ "localPatternChars", localPatternChars },
{ "shortDateFormat", shortDateFormat },
{ "mediumDateFormat", mediumDateFormat },
{ "longDateFormat", longDateFormat },
{ "fullDateFormat", fullDateFormat },
{ "defaultDateFormat", defaultDateFormat },
{ "shortTimeFormat", shortTimeFormat },
{ "mediumTimeFormat", mediumTimeFormat },
{ "longTimeFormat", longTimeFormat },
{ "fullTimeFormat", fullTimeFormat },
{ "defaultTimeFormat", defaultTimeFormat },
// For DecimalFormat/DecimalFormatSymbols
{ "currencySymbol", currencySymbol },
{ "intlCurrencySymbol", intlCurrencySymbol },
{ "decimalSeparator", decimalSeparator },
{ "digit", digit },
{ "exponential", exponential },
{ "groupingSeparator", groupingSeparator },
{ "infinity", infinity },
{ "NaN", NaN },
{ "minusSign", minusSign },
{ "monetarySeparator", monetarySeparator },
{ "patternSeparator", patternSeparator },
{ "percent", percent },
{ "perMill", perMill },
{ "zeroDigit", zeroDigit },
};
/*************************************************************************/
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][]
getContents()
{
return(contents);
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][] getContents ()
{
return contents;
}
}
} // class LocaleInformation_en
libjava/gnu/java/locale/LocaleInformation_en_US.java
+112
View File
@@ -0,0 +1,112 @@
/* LocaleInformation_en.java -- US English locale data
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.locale;
import java.util.ListResourceBundle;
import java.util.Calendar;
import java.util.Date;
/**
* This class contains locale data for English in the US.
*/
public class LocaleInformation_en_US extends ListResourceBundle
{
// These are for DateFormatSymbols.
private static final String[][] zoneStrings =
{
{ "GMT", "Greenwich Mean Time", "GMT",
/**/ "Greenwich Mean Time", "GMT", "GMT" },
{ "PST", "Pacific Standard Time", "PST",
/**/ "Pacific Daylight Time", "PDT", "San Francisco" },
{ "MST", "Mountain Standard Time", "MST",
/**/ "Mountain Daylight Time", "MDT", "Denver" },
{ "PNT", "Mountain Standard Time", "MST",
/**/ "Mountain Standard Time", "MST", "Phoenix" },
{ "CST", "Central Standard Time", "CST",
/**/ "Central Daylight Time", "CDT", "Chicago" },
{ "EST", "Eastern Standard Time", "EST",
/**/ "Eastern Daylight Time", "EDT", "Boston" },
{ "IET", "Eastern Standard Time", "EST",
/**/ "Eastern Standard Time", "EST", "Indianapolis" },
{ "PRT", "Atlantic Standard Time", "AST",
/**/ "Atlantic Daylight Time", "ADT", "Halifax" },
{ "CNT", "Newfoundland Standard Time", "NST",
/**/ "Newfoundland Daylight Time", "NDT", "St. Johns" },
{ "ECT", "Central European Standard Time", "CET",
/**/ "Central European Daylight Time", "CEST", "Paris" },
{ "CTT", "China Standard Time", "CST",
/**/ "China Standard Time", "CST", "Shanghai" },
{ "JST", "Japan Standard Time", "JST",
/**/ "Japan Standard Time", "JST", "Tokyo" },
{ "HST", "Hawaii Standard Time", "HST",
/**/ "Hawaii Standard Time", "HST", "Honolulu" },
{ "AST", "Alaska Standard Time", "AKST",
/**/ "Alaska Daylight Time", "AKDT", "Anchorage" }
};
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
private static final Object[][] contents =
{
// For SimpleDateFormat/DateFormatSymbols
{ "zoneStrings", zoneStrings },
{ "shortDateFormat", "M/d/yy" }, // Java's Y2K bug.
{ "mediumDateFormat", "d-MMM-yy" },
{ "longDateFormat", "MMMM d, yyyy" },
{ "defaultDateFormat", "d-MMMM-yy" },
{ "fullDateFormat", "EEEE MMMM d, yyyy G" },
{ "shortTimeFormat", "h:mm a" },
{ "mediumTimeFormat", "h:mm:ss a" },
{ "longTimeFormat", "h:mm:ss a z" },
{ "fullTimeFormat", "h:mm:ss;S 'o''clock' a z" },
{ "defaultTimeFormat", "h:mm:ss a" },
// For DecimalFormat/DecimalFormatSymbols
{ "currencySymbol", "$" },
{ "intlCurrencySymbol", "US$" },
// For NumberFormat.
{ "currencyFormat", "$#,##0.00;($#,##0.00)" }
};
/*************************************************************************/
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][] getContents ()
{
return contents;
}
}
libjava/gnu/java/locale/LocaleInformation_nl.java
+2 -36
View File
@@ -1,5 +1,5 @@
/* LocaleInformation_nl.java -- Dutch locale data
Copyright (C) 1999 Free Software Foundation, Inc.
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -50,39 +50,9 @@ public class LocaleInformation_nl extends ListResourceBundle
* This is the same rule as used in the English locale.
*/
private static final String collation_rules =
"-<0,1<2<3<4<5<6<7<8<9A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<j,K" +
"<0<1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<k,K" +
"<l,L<m,M<n,N<o,O<p,P<q,Q<r,R<s,S<t,T<u,U<v,V<w,W<x,X<y,Y,z<Z";
/*
* For the followings lists, strings that are subsets of other break strings
* must be listed first. For example, if "\r" and "\r\n" are sequences,
* the "\r" must be first or it will never be used.
*/
/**
* This is the list of word separator characters used by
* java.text.BreakIterator
* <p>
* This is the same list as used in the English local
*/
private static final String[] word_breaks = { " ", "\t", "\r\n", "\n" };
/**
* This is the list of sentence break sequences used by
* java.text.BreakIterator
* <p>
* This is the same list as used in the English local
*/
private static final String[] sentence_breaks = { ". " };
/**
* This is the list of potential line break locations.
* <p>
* This is the same list as used in the English local
*/
private static final String[] line_breaks = { "\t", "-", "\r\n",
"\n", ". ", ". ", ".", "? ", "? ", "?", "! ", "! ", "!", ", ", " " };
/**
* This is the list of months, fully spelled out
*/
@@ -281,10 +251,6 @@ private static final Object[][] contents =
{
// For RuleBasedCollator
{ "collation_rules", collation_rules },
// For BreakIterator
{ "word_breaks", word_breaks },
{ "sentence_breaks", sentence_breaks },
{ "line_breaks", line_breaks },
// For SimpleDateFormat/DateFormatSymbols
{ "months", months },
{ "shortMonths", shortMonths },
libjava/gnu/java/text/BaseBreakIterator.java
+101
View File
@@ -0,0 +1,101 @@
/* BaseBreakIterator.java -- Base class for default BreakIterators
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 22, 1999
*/
public abstract class BaseBreakIterator extends BreakIterator
{
public int current ()
{
return iter.getIndex();
}
public int first ()
{
iter.first();
return iter.getBeginIndex();
}
public int following (int pos)
{
int save = iter.getIndex();
iter.setIndex(pos);
int r = next ();
iter.setIndex(save);
return r;
}
public CharacterIterator getText ()
{
return iter;
}
public int last ()
{
iter.last();
// Go past the last character.
iter.next();
return iter.getEndIndex();
}
public int next (int n)
{
int r = iter.getIndex ();
if (n > 0)
{
while (n > 0 && r != DONE)
{
r = next ();
--n;
}
}
else if (n < 0)
{
while (n < 0 && r != DONE)
{
r = previous ();
++n;
}
}
return r;
}
public void setText (CharacterIterator newText)
{
iter = newText;
}
protected CharacterIterator iter;
}
libjava/gnu/java/text/CharacterBreakIterator.java
+205
View File
@@ -0,0 +1,205 @@
/* CharacterBreakIterator.java - Default character BreakIterator.
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 19, 1999
* Written using The Unicode Standard, Version 2.0.
*/
public class CharacterBreakIterator extends BaseBreakIterator
{
// Hangul Jamo constants from Unicode book.
private static final int LBase = 0x1100;
private static final int VBase = 0x1161;
private static final int TBase = 0x11a7;
private static final int LCount = 19;
private static final int VCount = 21;
private static final int TCount = 28;
// Information about surrogates.
private static final int highSurrogateStart = 0xD800;
private static final int highSurrogateEnd = 0xDBFF;
private static final int lowSurrogateStart = 0xDC00;
private static final int lowSurrogateEnd = 0xDFFF;
public Object clone ()
{
return new CharacterBreakIterator (this);
}
public CharacterBreakIterator ()
{
iter = null; // FIXME?
}
private CharacterBreakIterator (CharacterBreakIterator other)
{
iter = (CharacterIterator) other.iter.clone();
}
// Some methods to tell us different properties of characters.
private final boolean isL (char c)
{
return c >= LBase && c <= LBase + LCount;
}
private final boolean isV (char c)
{
return c >= VBase && c <= VBase + VCount;
}
private final boolean isT (char c)
{
return c >= TBase && c <= TBase + TCount;
}
private final boolean isLVT (char c)
{
return isL (c) || isV (c) || isT (c);
}
private final boolean isHighSurrogate (char c)
{
return c >= highSurrogateStart && c <= highSurrogateEnd;
}
private final boolean isLowSurrogate (char c)
{
return c >= lowSurrogateStart && c <= lowSurrogateEnd;
}
public int next ()
{
int end = iter.getEndIndex();
if (iter.getIndex() == end)
return DONE;
char c;
for (char prev = CharacterIterator.DONE; iter.getIndex() < end; prev = c)
{
c = iter.next();
if (c == CharacterIterator.DONE)
break;
int type = Character.getType(c);
// Break after paragraph separators.
if (type == Character.PARAGRAPH_SEPARATOR)
break;
// Now we need some lookahead.
char ahead = iter.next();
iter.previous();
if (ahead == CharacterIterator.DONE)
break;
int aheadType = Character.getType(ahead);
if (aheadType != Character.NON_SPACING_MARK
&& ! isLowSurrogate (ahead)
&& ! isLVT (ahead))
break;
if (! isLVT (c) && isLVT (ahead))
break;
if (isL (c) && ! isLVT (ahead)
&& aheadType != Character.NON_SPACING_MARK)
break;
if (isV (c) && ! isV (ahead) && !isT (ahead)
&& aheadType != Character.NON_SPACING_MARK)
break;
if (isT (c) && ! isT (ahead)
&& aheadType != Character.NON_SPACING_MARK)
break;
if (! isHighSurrogate (c) && isLowSurrogate (ahead))
break;
if (isHighSurrogate (c) && ! isLowSurrogate (ahead))
break;
if (! isHighSurrogate (prev) && isLowSurrogate (c))
break;
}
return iter.getIndex();
}
public int previous ()
{
if (iter.getIndex() == iter.getBeginIndex())
return DONE;
int start = iter.getBeginIndex();
while (iter.getIndex() >= iter.getBeginIndex())
{
char c = iter.previous();
if (c == CharacterIterator.DONE)
break;
int type = Character.getType(c);
if (type != Character.NON_SPACING_MARK
&& ! isLowSurrogate (c)
&& ! isLVT (c))
break;
// Now we need some lookahead.
char ahead = iter.previous();
if (ahead == CharacterIterator.DONE)
{
iter.next();
break;
}
char ahead2 = iter.previous();
iter.next();
iter.next();
if (ahead2 == CharacterIterator.DONE)
break;
int aheadType = Character.getType(ahead);
if (aheadType == Character.PARAGRAPH_SEPARATOR)
break;
if (isLVT (c) && ! isLVT (ahead))
break;
if (! isLVT (c) && type != Character.NON_SPACING_MARK
&& isL (ahead))
break;
if (! isV (c) && ! isT (c) && type != Character.NON_SPACING_MARK
&& isV (ahead))
break;
if (! isT (c) && type != Character.NON_SPACING_MARK
&& isT (ahead))
break;
if (isLowSurrogate (c) && ! isHighSurrogate (ahead))
break;
if (! isLowSurrogate (c) && isHighSurrogate (ahead))
break;
if (isLowSurrogate (ahead) && ! isHighSurrogate (ahead2))
break;
}
return iter.getIndex();
}
}
libjava/gnu/java/text/LineBreakIterator.java
+185
View File
@@ -0,0 +1,185 @@
/* LineBreakIterator.java - Default word BreakIterator.
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 22, 1999
* Written using The Unicode Standard, Version 2.0.
*/
public class LineBreakIterator extends BaseBreakIterator
{
public Object clone ()
{
return new LineBreakIterator (this);
}
public LineBreakIterator ()
{
iter = null;
}
private LineBreakIterator (LineBreakIterator other)
{
iter = (CharacterIterator) other.iter.clone();
}
// Some methods to tell us different properties of characters.
private final boolean isNb (char c)
{
return (c == 0x00a0 // NO-BREAK SPACE
|| c == 0x2011 // NON-BREAKING HYPHEN
|| c == 0xfeff); // ZERO WITH NO-BREAK SPACE
}
private final boolean isClose (int type)
{
return (type == Character.END_PUNCTUATION
// Unicode book says "comma, period, ...", which I take to
// mean "Po" class.
|| type == Character.OTHER_PUNCTUATION);
}
private final boolean isIdeo (char c)
{
return (c >= 0x3040 && c <= 0x309f // Hiragana
|| c >= 0x30a0 && c <= 0x30ff // Katakana
|| c >= 0x4e00 && c <= 0x9fff // Han
|| c >= 0x3100 && c <= 0x312f); // Bopomofo
}
public int next ()
{
int end = iter.getEndIndex();
if (iter.getIndex() == end)
return DONE;
while (iter.getIndex() < end)
{
char c = iter.current();
int type = Character.getType(c);
char n = iter.next();
if (n == CharacterIterator.DONE
|| type == Character.PARAGRAPH_SEPARATOR
|| type == Character.LINE_SEPARATOR)
break;
// Handle two cases where we must scan for non-spacing marks.
int start = iter.getIndex();
if (type == Character.SPACE_SEPARATOR
|| type == Character.START_PUNCTUATION
|| isIdeo (c))
{
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.NON_SPACING_MARK)
n = iter.next();
if (n == CharacterIterator.DONE)
break;
if (type == Character.SPACE_SEPARATOR)
{
int nt = Character.getType(n);
if (nt != Character.NON_SPACING_MARK
&& nt != Character.SPACE_SEPARATOR
&& ! isNb (n))
break;
}
else if (type == Character.START_PUNCTUATION)
{
if (isIdeo (n))
{
// Open punctuation followed by non spacing marks
// and then ideograph does not have a break in
// it. So skip all this.
start = iter.getIndex();
}
}
else
{
// Ideograph preceded this character.
if (isClose (Character.getType(n)))
break;
}
}
iter.setIndex(start);
}
return iter.getIndex();
}
public int previous ()
{
int start = iter.getBeginIndex();
if (iter.getIndex() == start)
return DONE;
while (iter.getIndex() >= start)
{
char c = iter.previous();
if (c == CharacterIterator.DONE)
break;
int type = Character.getType(c);
char n = iter.previous();
if (n == CharacterIterator.DONE)
break;
iter.next();
int nt = Character.getType(n);
// Break after paragraph separators.
if (nt == Character.PARAGRAPH_SEPARATOR
|| nt == Character.LINE_SEPARATOR)
break;
// Skip non-spacing marks.
int init = iter.getIndex();
while (n != CharacterIterator.DONE && nt == Character.NON_SPACING_MARK)
{
n = iter.previous();
nt = Character.getType(n);
}
if (nt == Character.SPACE_SEPARATOR
&& type != Character.SPACE_SEPARATOR
&& type != Character.NON_SPACING_MARK
&& ! isNb (c))
break;
if (! isClose (type) && isIdeo (n))
break;
if (isIdeo (c) && nt != Character.START_PUNCTUATION)
break;
iter.setIndex(init);
}
return iter.getIndex();
}
}
libjava/gnu/java/text/SentenceBreakIterator.java
+243
View File
@@ -0,0 +1,243 @@
/* SentenceBreakIterator.java - Default sentence BreakIterator.
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 23, 1999
* Written using The Unicode Standard, Version 2.0.
*/
public class SentenceBreakIterator extends BaseBreakIterator
{
public Object clone ()
{
return new SentenceBreakIterator (this);
}
public SentenceBreakIterator ()
{
iter = null;
}
private SentenceBreakIterator (SentenceBreakIterator other)
{
iter = (CharacterIterator) other.iter.clone();
}
public int next ()
{
int end = iter.getEndIndex();
if (iter.getIndex() == end)
return DONE;
while (iter.getIndex() < end)
{
char c = iter.current();
if (c == CharacterIterator.DONE)
break;
int type = Character.getType(c);
char n = iter.next();
if (n == CharacterIterator.DONE)
break;
// Always break after paragraph separator.
if (type == Character.PARAGRAPH_SEPARATOR)
break;
if (c == '!' || c == '?')
{
// Skip close punctuation.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.END_PUNCTUATION)
n = iter.next();
// Skip spaces.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.SPACE_SEPARATOR)
n = iter.next();
// Skip optional paragraph separator.
if (n != CharacterIterator.DONE
&& Character.getType(n) == Character.PARAGRAPH_SEPARATOR)
n = iter.next();
// There's always a break somewhere after `!' or `?'.
break;
}
if (c == '.')
{
int save = iter.getIndex();
// Skip close punctuation.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.END_PUNCTUATION)
n = iter.next();
// Skip spaces. We keep count because we need at least
// one for this period to represent a terminator.
int spcount = 0;
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.SPACE_SEPARATOR)
{
n = iter.next();
++spcount;
}
if (spcount > 0)
{
int save2 = iter.getIndex();
// Skip over open puncutation.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.START_PUNCTUATION)
n = iter.next();
// Next character must not be lower case.
if (n == CharacterIterator.DONE
|| ! Character.isLowerCase(n))
{
iter.setIndex(save2);
break;
}
}
iter.setIndex(save);
}
}
return iter.getIndex();
}
private final int previous_internal ()
{
int start = iter.getBeginIndex();
if (iter.getIndex() == start)
return DONE;
while (iter.getIndex() >= start)
{
char c = iter.previous();
if (c == CharacterIterator.DONE)
break;
char n = iter.previous();
if (n == CharacterIterator.DONE)
break;
iter.next();
int nt = Character.getType(n);
if (! Character.isLowerCase(c)
&& (nt == Character.START_PUNCTUATION
|| nt == Character.SPACE_SEPARATOR))
{
int save = iter.getIndex();
int save_nt = nt;
char save_n = n;
// Skip open punctuation.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.START_PUNCTUATION)
n = iter.previous();
if (n == CharacterIterator.DONE)
break;
if (Character.getType(n) == Character.SPACE_SEPARATOR)
{
// Must have at least once space after the `.'.
int save2 = iter.getIndex();
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.SPACE_SEPARATOR)
n = iter.previous();
// Skip close punctuation.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.END_PUNCTUATION)
n = iter.previous();
if (n == CharacterIterator.DONE || n == '.')
{
// Communicate location of actual end.
period = iter.getIndex();
iter.setIndex(save2);
break;
}
}
iter.setIndex(save);
nt = save_nt;
n = save_n;
}
if (nt == Character.PARAGRAPH_SEPARATOR)
{
// Communicate location of actual end.
period = iter.getIndex();
break;
}
else if (nt == Character.SPACE_SEPARATOR
|| nt == Character.END_PUNCTUATION)
{
int save = iter.getIndex();
// Skip spaces.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.SPACE_SEPARATOR)
n = iter.previous();
// Skip close punctuation.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.END_PUNCTUATION)
n = iter.previous();
int here = iter.getIndex();
iter.setIndex(save);
if (n == CharacterIterator.DONE || n == '!' || n == '?')
{
// Communicate location of actual end.
period = here;
break;
}
}
else if (n == '!' || n == '?')
{
// Communicate location of actual end.
period = iter.getIndex();
break;
}
}
return iter.getIndex();
}
public int previous ()
{
// We want to skip over the first sentence end to the second one.
// However, at the end of the string we want the first end.
int here = iter.getIndex();
period = here;
int first = previous_internal ();
if (here == iter.getEndIndex() || first == DONE)
return first;
iter.setIndex(period);
return previous_internal ();
}
// This is used for communication between previous and
// previous_internal.
private int period;
}
libjava/gnu/java/text/WordBreakIterator.java
+241
View File
@@ -0,0 +1,241 @@
/* WordBreakIterator.java - Default word BreakIterator.
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 22, 1999
* Written using The Unicode Standard, Version 2.0.
*/
public class WordBreakIterator extends BaseBreakIterator
{
public Object clone ()
{
return new WordBreakIterator (this);
}
public WordBreakIterator ()
{
iter = null;
}
private WordBreakIterator (WordBreakIterator other)
{
iter = (CharacterIterator) other.iter.clone();
}
// Some methods to tell us different properties of characters.
private final boolean isHira (char c)
{
return c >= 0x3040 && c <= 0x309f;
}
private final boolean isKata (char c)
{
return c >= 0x30a0 && c <= 0x30ff;
}
private final boolean isHan (char c)
{
return c >= 0x4e00 && c <= 0x9fff;
}
public int next ()
{
int end = iter.getEndIndex();
if (iter.getIndex() == end)
return DONE;
while (iter.getIndex() < end)
{
char c = iter.current();
if (c == CharacterIterator.DONE)
break;
int type = Character.getType(c);
char n = iter.next();
if (n == CharacterIterator.DONE)
break;
// Break after paragraph separators.
if (type == Character.PARAGRAPH_SEPARATOR
|| type == Character.LINE_SEPARATOR)
break;
// Break between letters and non-letters.
// FIXME: we treat apostrophe as part of a word. This
// is an English-ism.
boolean is_letter = Character.isLetter(c);
if (c != '\'' && ! is_letter && type != Character.NON_SPACING_MARK
&& Character.isLetter(n))
break;
// Always break after certain symbols, such as punctuation.
// This heuristic is derived from hints in the JCL book and is
// not part of Unicode. It seems to be right, however.
// FIXME: we treat apostrophe as part of a word. This
// is an English-ism.
if (c != '\''
&& (type == Character.DASH_PUNCTUATION
|| type == Character.START_PUNCTUATION
|| type == Character.END_PUNCTUATION
|| type == Character.CONNECTOR_PUNCTUATION
|| type == Character.OTHER_PUNCTUATION
|| type == Character.MATH_SYMBOL
|| type == Character.CURRENCY_SYMBOL
|| type == Character.MODIFIER_SYMBOL
|| type == Character.OTHER_SYMBOL
|| type == Character.FORMAT
|| type == Character.CONTROL))
break;
boolean is_hira = isHira (c);
boolean is_kata = isKata (c);
boolean is_han = isHan (c);
// Special case Japanese.
if (! is_hira && ! is_kata && ! is_han
&& type != Character.NON_SPACING_MARK
&& (isHira (n) || isKata (n) || isHan (n)))
break;
if (is_hira || is_kata || is_han || is_letter)
{
// Now we need to do some lookahead. We might need to do
// quite a bit of lookahead, so we save our position and
// restore it later.
int save = iter.getIndex();
// Skip string of non spacing marks.
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.NON_SPACING_MARK)
n = iter.next();
if (n == CharacterIterator.DONE)
break;
if ((is_hira && ! isHira (n))
|| (is_kata && ! isHira (n) && ! isKata (n))
|| (is_han && ! isHira (n) && ! isHan (n))
// FIXME: we treat apostrophe as part of a word. This
// is an English-ism.
|| (is_letter && ! Character.isLetter(n) && n != '\''))
break;
iter.setIndex(save);
}
}
return iter.getIndex();
}
public int previous ()
{
int start = iter.getBeginIndex();
if (iter.getIndex() == start)
return DONE;
while (iter.getIndex() >= start)
{
char c = iter.previous();
if (c == CharacterIterator.DONE)
break;
boolean is_hira = isHira (c);
boolean is_kata = isKata (c);
boolean is_han = isHan (c);
boolean is_letter = Character.isLetter(c);
char n = iter.previous();
if (n == CharacterIterator.DONE)
break;
iter.next();
int type = Character.getType(n);
// Break after paragraph separators.
if (type == Character.PARAGRAPH_SEPARATOR
|| type == Character.LINE_SEPARATOR)
break;
// Break between letters and non-letters.
// FIXME: we treat apostrophe as part of a word. This
// is an English-ism.
if (n != '\'' && ! Character.isLetter(n)
&& type != Character.NON_SPACING_MARK
&& is_letter)
break;
// Always break after certain symbols, such as punctuation.
// This heuristic is derived from hints in the JCL book and is
// not part of Unicode. It seems to be right, however.
// FIXME: we treat apostrophe as part of a word. This
// is an English-ism.
if (n != '\''
&& (type == Character.DASH_PUNCTUATION
|| type == Character.START_PUNCTUATION
|| type == Character.END_PUNCTUATION
|| type == Character.CONNECTOR_PUNCTUATION
|| type == Character.OTHER_PUNCTUATION
|| type == Character.MATH_SYMBOL
|| type == Character.CURRENCY_SYMBOL
|| type == Character.MODIFIER_SYMBOL
|| type == Character.OTHER_SYMBOL
|| type == Character.FORMAT
|| type == Character.CONTROL))
break;
// Special case Japanese.
if ((is_hira || is_kata || is_han)
&& ! isHira (n) && ! isKata (n) && ! isHan (n)
&& type != Character.NON_SPACING_MARK)
break;
// We might have to skip over non spacing marks to see what's
// on the other side.
if (! is_hira || (! is_letter && c != '\''))
{
int save = iter.getIndex();
while (n != CharacterIterator.DONE
&& Character.getType(n) == Character.NON_SPACING_MARK)
n = iter.previous();
iter.setIndex(save);
// This is a strange case: a bunch of non-spacing marks at
// the beginning. We treat the current location as a word
// break.
if (n == CharacterIterator.DONE)
break;
if ((isHira (n) && ! is_hira)
|| (isKata (n) && ! is_hira && ! is_kata)
|| (isHan (n) && ! is_hira && ! is_han)
// FIXME: we treat apostrophe as part of a word. This
// is an English-ism.
|| (! is_letter && c != '\'' && Character.isLetter(n)))
break;
}
}
return iter.getIndex();
}
}