From 89066f10f5dbb9e6192cd2ae29ec0f6815ce1d60 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Fri, 7 Sep 2001 00:15:47 +0000 Subject: [PATCH] RuleBasedCollator.java (clone): Rewrote. * java/text/RuleBasedCollator.java (clone): Rewrote. (RuleBasedCollator(RuleBasedCollator)): Removed. * java/text/MessageFormat.java: Re-merged from Classpath. * java/text/DecimalFormat.java: Re-merged from Classpath. From-SVN: r45458 --- libjava/ChangeLog | 7 + libjava/java/text/DecimalFormat.java | 18 +- libjava/java/text/MessageFormat.java | 898 ++++++++++++----------- libjava/java/text/RuleBasedCollator.java | 18 +- 4 files changed, 497 insertions(+), 444 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 469a8ec8a21..d15be6ab39c 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,10 @@ +2001-09-06 Tom Tromey + + * java/text/RuleBasedCollator.java (clone): Rewrote. + (RuleBasedCollator(RuleBasedCollator)): Removed. + * java/text/MessageFormat.java: Re-merged from Classpath. + * java/text/DecimalFormat.java: Re-merged from Classpath. + 2001-09-06 Anthony Green * include/jvm.h: Declare _Jv_RegisterResource. diff --git a/libjava/java/text/DecimalFormat.java b/libjava/java/text/DecimalFormat.java index f6b7223ed04..edf340027ed 100644 --- a/libjava/java/text/DecimalFormat.java +++ b/libjava/java/text/DecimalFormat.java @@ -350,21 +350,9 @@ public class DecimalFormat extends NumberFormat public Object clone () { - return new DecimalFormat (this); - } - - private DecimalFormat (DecimalFormat dup) - { - decimalSeparatorAlwaysShown = dup.decimalSeparatorAlwaysShown; - groupingSize = dup.groupingSize; - minExponentDigits = dup.minExponentDigits; - multiplier = dup.multiplier; - negativePrefix = dup.negativePrefix; - negativeSuffix = dup.negativeSuffix; - positivePrefix = dup.positivePrefix; - positiveSuffix = dup.positiveSuffix; - symbols = (DecimalFormatSymbols) dup.symbols.clone(); - useExponentialNotation = dup.useExponentialNotation; + DecimalFormat c = (DecimalFormat) super.clone (); + c.symbols = (DecimalFormatSymbols) symbols.clone (); + return c; } public DecimalFormat () diff --git a/libjava/java/text/MessageFormat.java b/libjava/java/text/MessageFormat.java index aaf49075e19..4470f6136cc 100644 --- a/libjava/java/text/MessageFormat.java +++ b/libjava/java/text/MessageFormat.java @@ -33,6 +33,7 @@ import java.util.Vector; /** * @author Tom Tromey + * @author Jorge Aliss * @date March 3, 1999 */ /* Written using "Java Class Libraries", 2nd edition, plus online @@ -40,7 +41,6 @@ import java.util.Vector; * Status: Believed complete and correct to 1.2, except serialization. * and parsing. */ - final class MessageFormatElement { // Argument number. @@ -64,70 +64,70 @@ final class MessageFormatElement // Recompute the locale-based formatter. void setLocale (Locale loc) - { - if (type == null) - ; - else if (type.equals("number")) - { - formatClass = java.lang.Number.class; - - if (style == null) - format = NumberFormat.getInstance(loc); - else if (style.equals("currency")) - format = NumberFormat.getCurrencyInstance(loc); - else if (style.equals("percent")) - format = NumberFormat.getPercentInstance(loc); - else if (style.equals("integer")) - { - NumberFormat nf = NumberFormat.getNumberInstance(loc); - nf.setMaximumFractionDigits(0); - nf.setGroupingUsed(false); - format = nf; - } - else - { - format = NumberFormat.getNumberInstance(loc); - DecimalFormat df = (DecimalFormat) format; - df.applyPattern(style); - } - } - else if (type.equals("time") || type.equals("date")) - { - formatClass = java.util.Date.class; - - int val = DateFormat.DEFAULT; - if (style == null) - ; - else if (style.equals("short")) - val = DateFormat.SHORT; - else if (style.equals("medium")) - val = DateFormat.MEDIUM; - else if (style.equals("long")) - val = DateFormat.LONG; - else if (style.equals("full")) - val = DateFormat.FULL; - - if (type.equals("time")) - format = DateFormat.getTimeInstance(val, loc); - else - format = DateFormat.getDateInstance(val, loc); - - if (style != null && val == DateFormat.DEFAULT) - { - SimpleDateFormat sdf = (SimpleDateFormat) format; - sdf.applyPattern(style); - } - } - else if (type.equals("choice")) - { - formatClass = java.lang.Number.class; - - if (style == null) - throw new - IllegalArgumentException ("style required for choice format"); - format = new ChoiceFormat (style); - } - } + { + if (type == null) + ; + else if (type.equals("number")) + { + formatClass = java.lang.Number.class; + + if (style == null) + format = NumberFormat.getInstance(loc); + else if (style.equals("currency")) + format = NumberFormat.getCurrencyInstance(loc); + else if (style.equals("percent")) + format = NumberFormat.getPercentInstance(loc); + else if (style.equals("integer")) + { + NumberFormat nf = NumberFormat.getNumberInstance(loc); + nf.setMaximumFractionDigits(0); + nf.setGroupingUsed(false); + format = nf; + } + else + { + format = NumberFormat.getNumberInstance(loc); + DecimalFormat df = (DecimalFormat) format; + df.applyPattern(style); + } + } + else if (type.equals("time") || type.equals("date")) + { + formatClass = java.util.Date.class; + + int val = DateFormat.DEFAULT; + if (style == null) + ; + else if (style.equals("short")) + val = DateFormat.SHORT; + else if (style.equals("medium")) + val = DateFormat.MEDIUM; + else if (style.equals("long")) + val = DateFormat.LONG; + else if (style.equals("full")) + val = DateFormat.FULL; + + if (type.equals("time")) + format = DateFormat.getTimeInstance(val, loc); + else + format = DateFormat.getDateInstance(val, loc); + + if (style != null && val == DateFormat.DEFAULT) + { + SimpleDateFormat sdf = (SimpleDateFormat) format; + sdf.applyPattern(style); + } + } + else if (type.equals("choice")) + { + formatClass = java.lang.Number.class; + + if (style == null) + throw new + IllegalArgumentException ("style required for choice format"); + format = new ChoiceFormat (style); + } + } } public class MessageFormat extends Format @@ -137,403 +137,469 @@ public class MessageFormat extends Format // string. Throws IllegalArgumentException on error. private static final int scanString (String pat, int index, StringBuffer buffer) - { - int max = pat.length(); - buffer.setLength(0); - for (; index < max; ++index) - { - char c = pat.charAt(index); - if (c == '\'' && index + 2 < max && pat.charAt(index + 2) == '\'') - { - buffer.append(pat.charAt(index + 1)); - index += 2; - } - else if (c == '\'' && index + 1 < max - && pat.charAt(index + 1) == '\'') - { - buffer.append(c); - ++index; - } - else if (c == '{') - break; - else if (c == '}') - throw new IllegalArgumentException (); - else + { + int max = pat.length(); + buffer.setLength(0); + for (; index < max; ++index) + { + char c = pat.charAt(index); + if (c == '\'' && index + 2 < max && pat.charAt(index + 2) == '\'') + { + buffer.append(pat.charAt(index + 1)); + index += 2; + } + else if (c == '\'' && index + 1 < max + && pat.charAt(index + 1) == '\'') + { buffer.append(c); - } - return index; - } + ++index; + } + else if (c == '{') + break; + else if (c == '}') + throw new IllegalArgumentException (); + else + buffer.append(c); + } + return index; + } // This helper retrieves a single part of a format element. Returns // the index of the terminating character. private static final int scanFormatElement (String pat, int index, StringBuffer buffer, char term) - { - int max = pat.length(); - buffer.setLength(0); - int brace_depth = 1; - - for (; index < max; ++index) - { - char c = pat.charAt(index); - if (c == '\'' && index + 2 < max && pat.charAt(index + 2) == '\'') - { - buffer.append(c); - buffer.append(pat.charAt(index + 1)); - buffer.append(c); - index += 2; - } - else if (c == '\'' && index + 1 < max - && pat.charAt(index + 1) == '\'') - { - buffer.append(c); - ++index; - } - else if (c == '{') - { - buffer.append(c); - ++brace_depth; - } - else if (c == '}') - { - if (--brace_depth == 0) - break; - buffer.append(c); - } - // Check for TERM after braces, because TERM might be `}'. - else if (c == term) - break; - else + { + int max = pat.length(); + buffer.setLength(0); + int brace_depth = 1; + + for (; index < max; ++index) + { + char c = pat.charAt(index); + if (c == '\'' && index + 2 < max && pat.charAt(index + 2) == '\'') + { + buffer.append(c); + buffer.append(pat.charAt(index + 1)); + buffer.append(c); + index += 2; + } + else if (c == '\'' && index + 1 < max + && pat.charAt(index + 1) == '\'') + { buffer.append(c); - } - return index; - } + ++index; + } + else if (c == '{') + { + buffer.append(c); + ++brace_depth; + } + else if (c == '}') + { + if (--brace_depth == 0) + break; + buffer.append(c); + } + // Check for TERM after braces, because TERM might be `}'. + else if (c == term) + break; + else + buffer.append(c); + } + return index; + } // This is used to parse a format element and whatever non-format // text might trail it. private static final int scanFormat (String pat, int index, StringBuffer buffer, Vector elts, Locale locale) - { - MessageFormatElement mfe = new MessageFormatElement (); - elts.addElement(mfe); - - int max = pat.length(); - - // Skip the opening `{'. - ++index; - - // Fetch the argument number. - index = scanFormatElement (pat, index, buffer, ','); - try - { - mfe.argNumber = Integer.parseInt(buffer.toString()); - } - catch (NumberFormatException nfx) - { - throw new IllegalArgumentException (); - } - - // Extract the element format. - if (index < max && pat.charAt(index) == ',') - { - index = scanFormatElement (pat, index + 1, buffer, ','); - mfe.type = buffer.toString(); - - // Extract the style. - if (index < max && pat.charAt(index) == ',') - { - index = scanFormatElement (pat, index + 1, buffer, '}'); - mfe.style = buffer.toString (); - } - } - - // Advance past the last terminator. - if (index >= max || pat.charAt(index) != '}') + { + MessageFormatElement mfe = new MessageFormatElement (); + elts.addElement(mfe); + + int max = pat.length(); + + // Skip the opening `{'. + ++index; + + // Fetch the argument number. + index = scanFormatElement (pat, index, buffer, ','); + try + { + mfe.argNumber = Integer.parseInt(buffer.toString()); + } + catch (NumberFormatException nfx) + { throw new IllegalArgumentException (); - ++index; - - // Now fetch trailing string. - index = scanString (pat, index, buffer); - mfe.trailer = buffer.toString (); - - mfe.setLocale(locale); - - return index; - } - + } + + // Extract the element format. + if (index < max && pat.charAt(index) == ',') + { + index = scanFormatElement (pat, index + 1, buffer, ','); + mfe.type = buffer.toString(); + + // Extract the style. + if (index < max && pat.charAt(index) == ',') + { + index = scanFormatElement (pat, index + 1, buffer, '}'); + mfe.style = buffer.toString (); + } + } + + // Advance past the last terminator. + if (index >= max || pat.charAt(index) != '}') + throw new IllegalArgumentException (); + ++index; + + // Now fetch trailing string. + index = scanString (pat, index, buffer); + mfe.trailer = buffer.toString (); + + mfe.setLocale(locale); + + return index; + } + + /** + * Applies the specified pattern to this MessageFormat. + * + * @param aPattern The Pattern + */ public void applyPattern (String newPattern) - { - pattern = newPattern; + { + pattern = newPattern; - StringBuffer tempBuffer = new StringBuffer (); + StringBuffer tempBuffer = new StringBuffer (); - int index = scanString (newPattern, 0, tempBuffer); - leader = tempBuffer.toString(); + int index = scanString (newPattern, 0, tempBuffer); + leader = tempBuffer.toString(); - Vector elts = new Vector (); - while (index < newPattern.length()) - index = scanFormat (newPattern, index, tempBuffer, elts, locale); + Vector elts = new Vector (); + while (index < newPattern.length()) + index = scanFormat (newPattern, index, tempBuffer, elts, locale); - elements = new MessageFormatElement[elts.size()]; - elts.copyInto(elements); - } + elements = new MessageFormatElement[elts.size()]; + elts.copyInto(elements); + } + /** + * Overrides Format.clone() + */ public Object clone () - { - MessageFormat c = new MessageFormat (); - c.setLocale(locale); - c.applyPattern(pattern); - return (Object) c; - } - + { + MessageFormat c = (MessageFormat) super.clone (); + c.elements = (MessageFormatElement[]) elements.clone (); + return c; + } + + /** + * Overrides Format.equals(Object obj) + */ public boolean equals (Object obj) - { - if (! (obj instanceof MessageFormat)) - return false; - MessageFormat mf = (MessageFormat) obj; - return (pattern.equals(mf.pattern) - && locale.equals(mf.locale)); - } - + { + if (! (obj instanceof MessageFormat)) + return false; + MessageFormat mf = (MessageFormat) obj; + return (pattern.equals(mf.pattern) + && locale.equals(mf.locale)); + } + + /** + * A convinience method to format patterns. + * + * @param aPattern The pattern used when formatting. + * @param arguments The array containing the objects to be formatted. + */ public static String format (String pattern, Object arguments[]) - { - MessageFormat mf = new MessageFormat (pattern); - StringBuffer sb = new StringBuffer (); - FieldPosition fp = new FieldPosition (NumberFormat.INTEGER_FIELD); - return mf.format(arguments, sb, fp).toString(); - } - + { + MessageFormat mf = new MessageFormat (pattern); + StringBuffer sb = new StringBuffer (); + FieldPosition fp = new FieldPosition (NumberFormat.INTEGER_FIELD); + return mf.format(arguments, sb, fp).toString(); + } + + /** + * Returns the pattern with the formatted objects. + * + * @param source The array containing the objects to be formatted. + * @param result The StringBuffer where the text is appened. + * @param fp A FieldPosition object (it is ignored). + */ public final StringBuffer format (Object arguments[], StringBuffer appendBuf, FieldPosition ignore) - { - appendBuf.append(leader); - - for (int i = 0; i < elements.length; ++i) - { - if (elements[i].argNumber >= arguments.length) - throw new IllegalArgumentException (); - Object thisArg = arguments[elements[i].argNumber]; - - Format formatter = null; - if (elements[i].setFormat != null) - formatter = elements[i].setFormat; - else if (elements[i].format != null) - { - if (elements[i].formatClass != null - && ! elements[i].formatClass.isInstance(thisArg)) - throw new IllegalArgumentException (); - formatter = elements[i].format; - } - else if (thisArg instanceof Number) - formatter = NumberFormat.getInstance(locale); - else if (thisArg instanceof Date) - formatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale); - else - appendBuf.append(thisArg); - - if (formatter != null) - { - // Special-case ChoiceFormat. - if (formatter instanceof ChoiceFormat) - { - StringBuffer buf = new StringBuffer (); - // FIXME: don't actually know what is correct here. - // Can a sub-format refer to any argument, or just - // the single argument passed to it? Must test - // against JDK. - formatter.format(thisArg, buf, ignore); - MessageFormat mf = new MessageFormat (); - mf.setLocale(locale); - mf.applyPattern(buf.toString()); - formatter = mf; - } - formatter.format(thisArg, appendBuf, ignore); - } - - appendBuf.append(elements[i].trailer); - } - - return appendBuf; - } + { + appendBuf.append(leader); + for (int i = 0; i < elements.length; ++i) + { + if (elements[i].argNumber >= arguments.length) + throw new IllegalArgumentException (); + Object thisArg = arguments[elements[i].argNumber]; + + Format formatter = null; + if (elements[i].setFormat != null) + formatter = elements[i].setFormat; + else if (elements[i].format != null) + { + if (elements[i].formatClass != null + && ! elements[i].formatClass.isInstance(thisArg)) + throw new IllegalArgumentException (); + formatter = elements[i].format; + } + else if (thisArg instanceof Number) + formatter = NumberFormat.getInstance(locale); + else if (thisArg instanceof Date) + formatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale); + else + appendBuf.append(thisArg); + + if (formatter != null) + { + // Special-case ChoiceFormat. + if (formatter instanceof ChoiceFormat) + { + StringBuffer buf = new StringBuffer (); + // FIXME: don't actually know what is correct here. + // Can a sub-format refer to any argument, or just + // the single argument passed to it? Must test + // against JDK. + formatter.format(thisArg, buf, ignore); + MessageFormat mf = new MessageFormat (); + mf.setLocale(locale); + mf.applyPattern(buf.toString()); + formatter = mf; + } + formatter.format(thisArg, appendBuf, ignore); + } + + appendBuf.append(elements[i].trailer); + } + + return appendBuf; + } + + /** + * Returns the pattern with the formatted objects. + * + * @param source The object to be formatted. + * @param result The StringBuffer where the text is appened. + * @param fp A FieldPosition object (it is ignored). + */ public final StringBuffer format (Object singleArg, StringBuffer appendBuf, FieldPosition ignore) - { - Object[] args; - - if (singleArg instanceof Object[]) - { - // This isn't specified in any manual, but it follows the - // JDK implementation. - args = (Object[]) singleArg; - } - else - { - args = new Object[1]; - args[0] = singleArg; - } - return format (args, appendBuf, ignore); - } - + { + Object[] args; + + if (singleArg instanceof Object[]) + { + // This isn't specified in any manual, but it follows the + // JDK implementation. + args = (Object[]) singleArg; + } + else + { + args = new Object[1]; + args[0] = singleArg; + } + return format (args, appendBuf, ignore); + } + + /** + * Returns an array with the Formats for + * the arguments. + */ public Format[] getFormats () - { - Format[] f = new Format[elements.length]; - for (int i = elements.length - 1; i >= 0; --i) - f[i] = elements[i].setFormat; - return f; - } - + { + Format[] f = new Format[elements.length]; + for (int i = elements.length - 1; i >= 0; --i) + f[i] = elements[i].setFormat; + return f; + } + + /** + * Returns the locale. + */ public Locale getLocale () - { - return locale; - } + { + return locale; + } + /** + * Overrides Format.hashCode() + */ public int hashCode () - { - // FIXME: not a very good hash. - return pattern.hashCode() + locale.hashCode(); - } + { + // FIXME: not a very good hash. + return pattern.hashCode() + locale.hashCode(); + } private MessageFormat () - { - } - + { + } + + /** + * Creates a new MessageFormat object with + * the specified pattern + * + * @param aPattern The Pattern + */ public MessageFormat (String pattern) - { - locale = Locale.getDefault(); - applyPattern (pattern); - } + { + locale = Locale.getDefault(); + applyPattern (pattern); + } public Object[] parse (String sourceStr, ParsePosition pos) - { - // Check initial text. - int index = pos.getIndex(); - if (! sourceStr.startsWith(leader, index)) - { - pos.setErrorIndex(index); - return null; - } - index += leader.length(); - - Vector results = new Vector (elements.length, 1); - // Now check each format. - for (int i = 0; i < elements.length; ++i) - { - Format formatter = null; - if (elements[i].setFormat != null) - formatter = elements[i].setFormat; - else if (elements[i].format != null) - formatter = elements[i].format; - - Object value = null; - if (formatter instanceof ChoiceFormat) - { - // We must special-case a ChoiceFormat because it might - // have recursive formatting. - ChoiceFormat cf = (ChoiceFormat) formatter; - String[] formats = (String[]) cf.getFormats(); - double[] limits = (double[]) cf.getLimits(); - MessageFormat subfmt = new MessageFormat (); - subfmt.setLocale(locale); - ParsePosition subpos = new ParsePosition (index); - - int j; - for (j = 0; value == null && j < limits.length; ++j) - { - subfmt.applyPattern(formats[j]); - subpos.setIndex(index); - value = subfmt.parse(sourceStr, subpos); - } - if (value != null) - { - index = subpos.getIndex(); - value = new Double (limits[j]); - } - } - else if (formatter != null) - { - pos.setIndex(index); - value = formatter.parseObject(sourceStr, pos); - if (value != null) - index = pos.getIndex(); - } - else - { - // We have a String format. This can lose in a number - // of ways, but we give it a shot. - int next_index = sourceStr.indexOf(elements[i].trailer, index); - if (next_index == -1) - { - pos.setErrorIndex(index); - return null; - } - value = sourceStr.substring(index, next_index); - index = next_index; - } - - if (value == null - || ! sourceStr.startsWith(elements[i].trailer, index)) - { - pos.setErrorIndex(index); - return null; - } - - if (elements[i].argNumber >= results.size()) - results.setSize(elements[i].argNumber + 1); - results.setElementAt(value, elements[i].argNumber); - - index += elements[i].trailer.length(); - } - - Object[] r = new Object[results.size()]; - results.copyInto(r); - return r; - } + { + // Check initial text. + int index = pos.getIndex(); + if (! sourceStr.startsWith(leader, index)) + { + pos.setErrorIndex(index); + return null; + } + index += leader.length(); + + Vector results = new Vector (elements.length, 1); + // Now check each format. + for (int i = 0; i < elements.length; ++i) + { + Format formatter = null; + if (elements[i].setFormat != null) + formatter = elements[i].setFormat; + else if (elements[i].format != null) + formatter = elements[i].format; + + Object value = null; + if (formatter instanceof ChoiceFormat) + { + // We must special-case a ChoiceFormat because it might + // have recursive formatting. + ChoiceFormat cf = (ChoiceFormat) formatter; + String[] formats = (String[]) cf.getFormats(); + double[] limits = (double[]) cf.getLimits(); + MessageFormat subfmt = new MessageFormat (); + subfmt.setLocale(locale); + ParsePosition subpos = new ParsePosition (index); + + int j; + for (j = 0; value == null && j < limits.length; ++j) + { + subfmt.applyPattern(formats[j]); + subpos.setIndex(index); + value = subfmt.parse(sourceStr, subpos); + } + if (value != null) + { + index = subpos.getIndex(); + value = new Double (limits[j]); + } + } + else if (formatter != null) + { + pos.setIndex(index); + value = formatter.parseObject(sourceStr, pos); + if (value != null) + index = pos.getIndex(); + } + else + { + // We have a String format. This can lose in a number + // of ways, but we give it a shot. + int next_index = sourceStr.indexOf(elements[i].trailer, index); + if (next_index == -1) + { + pos.setErrorIndex(index); + return null; + } + value = sourceStr.substring(index, next_index); + index = next_index; + } + + if (value == null + || ! sourceStr.startsWith(elements[i].trailer, index)) + { + pos.setErrorIndex(index); + return null; + } + + if (elements[i].argNumber >= results.size()) + results.setSize(elements[i].argNumber + 1); + results.setElementAt(value, elements[i].argNumber); + + index += elements[i].trailer.length(); + } + + Object[] r = new Object[results.size()]; + results.copyInto(r); + return r; + } public Object[] parse (String sourceStr) throws ParseException - { - ParsePosition pp = new ParsePosition (0); - Object[] r = parse (sourceStr, pp); - if (r == null) - throw new ParseException ("couldn't parse string", pp.getErrorIndex()); - return r; - } + { + ParsePosition pp = new ParsePosition (0); + Object[] r = parse (sourceStr, pp); + if (r == null) + throw new ParseException ("couldn't parse string", pp.getErrorIndex()); + return r; + } public Object parseObject (String sourceStr, ParsePosition pos) - { - return parse (sourceStr, pos); - } - + { + return parse (sourceStr, pos); + } + + /** + * Sets the format for the argument at an specified + * index. + * + * @param index The index. + * @format The Format object. + */ public void setFormat (int variableNum, Format newFormat) - { - elements[variableNum].setFormat = newFormat; - } - + { + elements[variableNum].setFormat = newFormat; + } + + /** + * Sets the formats for the arguments. + * + * @param formats An array of Format objects. + */ public void setFormats (Format[] newFormats) - { - if (newFormats.length < elements.length) - throw new IllegalArgumentException (); - int len = Math.min(newFormats.length, elements.length); - for (int i = 0; i < len; ++i) - elements[i].setFormat = newFormats[i]; - } - + { + if (newFormats.length < elements.length) + throw new IllegalArgumentException (); + int len = Math.min(newFormats.length, elements.length); + for (int i = 0; i < len; ++i) + elements[i].setFormat = newFormats[i]; + } + + /** + * Sets the locale. + * + * @param locale A Locale + */ public void setLocale (Locale loc) - { - locale = loc; - if (elements != null) - { - for (int i = 0; i < elements.length; ++i) - elements[i].setLocale(loc); - } - } - + { + locale = loc; + if (elements != null) + { + for (int i = 0; i < elements.length; ++i) + elements[i].setLocale(loc); + } + } + + /** + * Returns the pattern. + */ public String toPattern () - { - return pattern; - } + { + return pattern; + } // The pattern string. private String pattern; diff --git a/libjava/java/text/RuleBasedCollator.java b/libjava/java/text/RuleBasedCollator.java index dde09572923..e8662a827a6 100644 --- a/libjava/java/text/RuleBasedCollator.java +++ b/libjava/java/text/RuleBasedCollator.java @@ -1,6 +1,6 @@ // RuleBasedCollator.java - Concrete class for locale-based string compare. -/* Copyright (C) 1999, 2000 Free Software Foundation +/* Copyright (C) 1999, 2000, 2001 Free Software Foundation This file is part of libgcj. @@ -39,7 +39,10 @@ public class RuleBasedCollator extends Collator { public Object clone () { - return new RuleBasedCollator (this); + RuleBasedCollator c = (RuleBasedCollator) super.clone (); + c.map = (Hashtable) map.clone (); + c.prefixes = (Hashtable) map.clone (); + return c; } // A helper for CollationElementIterator.next(). @@ -352,17 +355,6 @@ public class RuleBasedCollator extends Collator } } - // This is a helper for clone. - private RuleBasedCollator (RuleBasedCollator other) - { - frenchAccents = other.frenchAccents; - rules = other.rules; - decmp = other.decmp; - strength = other.strength; - map = other.map; - prefixes = other.prefixes; - } - // True if we are using French-style accent ordering. private boolean frenchAccents; -- 2.30.2