gcc/libjava/classpath/java/text/DecimalFormat.java

/* DecimalFormat.java -- Formats and parses numbers
   Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005  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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package java.text;

import gnu.java.text.AttributedFormatBuffer;
import gnu.java.text.FormatBuffer;
import gnu.java.text.FormatCharacterIterator;
import gnu.java.text.StringFormatBuffer;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Currency;
import java.util.HashMap;
import java.util.Locale;

/**
 * @author Tom Tromey (tromey@cygnus.com)
 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 * @date March 4, 1999
 */
/* Written using "Java Class Libraries", 2nd edition, plus online
 * API docs for JDK 1.2 from http://www.javasoft.com.
 * Status:  Believed complete and correct to 1.2.
 * Note however that the docs are very unclear about how format parsing
 * should work.  No doubt there are problems here.
 */
public class DecimalFormat extends NumberFormat
{
  // This is a helper for applyPatternWithSymbols.  It reads a prefix
  // or a suffix.  It can cause some side-effects.
  private int scanFix (String pattern, int index, FormatBuffer buf,
                       String patChars, DecimalFormatSymbols syms,
                       boolean is_suffix)
    {
    int len = pattern.length();
    boolean quoteStarted = false;
    buf.clear();
    
    boolean multiplierSet = false;
    while (index < len)
      {
	char c = pattern.charAt(index);

	if (quoteStarted)
	  {
	    if (c == '\'')
	      quoteStarted = false;
	    else
	      buf.append(c);
	    index++;
	    continue;
	  }

	if (c == '\'' && index + 1 < len
	    && pattern.charAt(index + 1) == '\'')
	  {
	    buf.append(c);
	    index++;
	  }
	else if (c == '\'')
	  {
	    quoteStarted = true;
	  }
	else if (c == '\u00a4')
	  {
			/* Currency interpreted later */
			buf.append(c);
		}
	else if (c == syms.getPercent())
	  {
	    if (multiplierSet)
	      throw new IllegalArgumentException ("multiplier already set " +
						  "- index: " + index);
	    multiplierSet = true;
	    multiplier = 100;
	    buf.append(c, NumberFormat.Field.PERCENT);
	  }
	else if (c == syms.getPerMill())
	  {
	    if (multiplierSet)
	      throw new IllegalArgumentException ("multiplier already set " +
						  "- index: " + index);
	    multiplierSet = true;
	    multiplier = 1000;
	    buf.append(c, NumberFormat.Field.PERMILLE);
	  }
	else if (patChars.indexOf(c) != -1)
	  {
	    // This is a pattern character.
	    break;
	  }
	else
		{
			buf.append(c);
		}
	index++;
      }

    if (quoteStarted)
      throw new IllegalArgumentException ("pattern is lacking a closing quote");

    return index;
  }

  // A helper which reads a number format.
  private int scanFormat (String pattern, int index, String patChars,
                          DecimalFormatSymbols syms, boolean is_positive)
  {
    int max = pattern.length();

    int countSinceGroup = 0;
    int zeroCount = 0;
    boolean saw_group = false;

    //
    // Scan integer part.
    //
    while (index < max)
      {
	char c = pattern.charAt(index);

	if (c == syms.getDigit())
	  {
	    if (zeroCount > 0)
	      throw new IllegalArgumentException ("digit mark following " +
						  "zero - index: " + index);
	    ++countSinceGroup;
	  }
	else if (c == syms.getZeroDigit())
	  {
	    ++zeroCount;
	    ++countSinceGroup;
	  }
	else if (c == syms.getGroupingSeparator())
	  {
	    countSinceGroup = 0;
	    saw_group = true;
	  }
	else
	  break;

	++index;
      }

    // We can only side-effect when parsing the positive format.
    if (is_positive)
      {
	groupingUsed = saw_group;
	groupingSize = (byte) countSinceGroup;
	// Checking "zeroCount > 0" avoids 0 being formatted into "" with "#".
	if (zeroCount > 0)
	  minimumIntegerDigits = zeroCount;
      }

    // Early termination.
    if (index == max || pattern.charAt(index) == syms.getGroupingSeparator())
      {
	if (is_positive)
	  decimalSeparatorAlwaysShown = false;
	return index;
      }

    if (pattern.charAt(index) == syms.getDecimalSeparator())
      {
	++index;

	//
	// Scan fractional part.
	//
	int hashCount = 0;
	zeroCount = 0;
	while (index < max)
	  {
	    char c = pattern.charAt(index);
	    if (c == syms.getZeroDigit())
	      {
		if (hashCount > 0)
		  throw new IllegalArgumentException ("zero mark " +
						      "following digit - index: " + index);
		++zeroCount;
	      }
	    else if (c == syms.getDigit())
	      {
		++hashCount;
	      }
	    else if (c != syms.getExponential()
		     && c != syms.getPatternSeparator()
		     && c != syms.getPercent()
		     && c != syms.getPerMill()
		     && patChars.indexOf(c) != -1)
	      throw new IllegalArgumentException ("unexpected special " +
						  "character - index: " + index);
	    else
	      break;

	    ++index;
	  }

	if (is_positive)
	  {
	    maximumFractionDigits = hashCount + zeroCount;
	    minimumFractionDigits = zeroCount;
	  }

	if (index == max)
	  return index;
      }

    if (pattern.charAt(index) == syms.getExponential())
      {
	//
	// Scan exponential format.
	//
	zeroCount = 0;
	++index;
	while (index < max)
	  {
	    char c = pattern.charAt(index);
	    if (c == syms.getZeroDigit())
	      ++zeroCount;
	    else if (c == syms.getDigit())
	      {
		if (zeroCount > 0)
		  throw new
		    IllegalArgumentException ("digit mark following zero " +
					      "in exponent - index: " +
					      index);
	      }
	    else if (patChars.indexOf(c) != -1)
	      throw new IllegalArgumentException ("unexpected special " +
						  "character - index: " +
						  index);
	    else
	      break;

	    ++index;
	  }

	if (is_positive)
	  {
	    useExponentialNotation = true;
	    minExponentDigits = (byte) zeroCount;
	  }

	maximumIntegerDigits = groupingSize;
	groupingSize = 0;
	if (maximumIntegerDigits > minimumIntegerDigits && maximumIntegerDigits > 0)
	  {
	    minimumIntegerDigits = 1;
	    exponentRound = maximumIntegerDigits;
	  }
	else
	  exponentRound = 1;
      }

    return index;
  }

  // This helper function creates a string consisting of all the
  // characters which can appear in a pattern and must be quoted.
  private String patternChars (DecimalFormatSymbols syms)
  {
    StringBuffer buf = new StringBuffer ();
    buf.append(syms.getDecimalSeparator());
    buf.append(syms.getDigit());
    buf.append(syms.getExponential());
    buf.append(syms.getGroupingSeparator());
    // Adding this one causes pattern application to fail.
    // Of course, omitting is causes toPattern to fail.
    // ... but we already have bugs there.  FIXME.
    // buf.append(syms.getMinusSign());
    buf.append(syms.getPatternSeparator());
    buf.append(syms.getPercent());
    buf.append(syms.getPerMill());
    buf.append(syms.getZeroDigit());
    buf.append('\u00a4');
    return buf.toString();
  }

  private void applyPatternWithSymbols(String pattern, DecimalFormatSymbols syms)
  {
    // Initialize to the state the parser expects.
    negativePrefix = "";
    negativeSuffix = "";
    positivePrefix = "";
    positiveSuffix = "";
    decimalSeparatorAlwaysShown = false;
    groupingSize = 0;
    minExponentDigits = 0;
    multiplier = 1;
    useExponentialNotation = false;
    groupingUsed = false;
    maximumFractionDigits = 0;
    maximumIntegerDigits = MAXIMUM_INTEGER_DIGITS;
    minimumFractionDigits = 0;
    minimumIntegerDigits = 1;

    AttributedFormatBuffer buf = new AttributedFormatBuffer ();
    String patChars = patternChars (syms);

    int max = pattern.length();
    int index = scanFix (pattern, 0, buf, patChars, syms, false);
    buf.sync();
    positivePrefix = buf.getBuffer().toString();
    positivePrefixRanges = buf.getRanges();
    positivePrefixAttrs = buf.getAttributes();

    index = scanFormat (pattern, index, patChars, syms, true);

    index = scanFix (pattern, index, buf, patChars, syms, true);
    buf.sync();
    positiveSuffix = buf.getBuffer().toString();
    positiveSuffixRanges = buf.getRanges();
    positiveSuffixAttrs = buf.getAttributes();

    if (index == pattern.length())
      {
	// No negative info.
	negativePrefix = null;
	negativeSuffix = null;
      }
    else
      {
	if (pattern.charAt(index) != syms.getPatternSeparator())
	  throw new IllegalArgumentException ("separator character " +
					      "expected - index: " + index);

	index = scanFix (pattern, index + 1, buf, patChars, syms, false);
	buf.sync();
	negativePrefix = buf.getBuffer().toString();
	negativePrefixRanges = buf.getRanges();
	negativePrefixAttrs = buf.getAttributes();

	// We parse the negative format for errors but we don't let
	// it side-effect this object.
	index = scanFormat (pattern, index, patChars, syms, false);

	index = scanFix (pattern, index, buf, patChars, syms, true);
	buf.sync();
	negativeSuffix = buf.getBuffer().toString();
	negativeSuffixRanges = buf.getRanges();
	negativeSuffixAttrs = buf.getAttributes();

	if (index != pattern.length())
	  throw new IllegalArgumentException ("end of pattern expected " +
					      "- index: " + index);
      }
  }

  public void applyLocalizedPattern (String pattern)
  {
    // JCL p. 638 claims this throws a ParseException but p. 629
    // contradicts this.  Empirical tests with patterns of "0,###.0"
    // and "#.#.#" corroborate the p. 629 statement that an
    // IllegalArgumentException is thrown.
    applyPatternWithSymbols (pattern, symbols);
  }

  public void applyPattern (String pattern)
  {
    // JCL p. 638 claims this throws a ParseException but p. 629
    // contradicts this.  Empirical tests with patterns of "0,###.0"
    // and "#.#.#" corroborate the p. 629 statement that an
    // IllegalArgumentException is thrown.
    applyPatternWithSymbols (pattern, nonLocalizedSymbols);
  }

  public Object clone ()
  {
    DecimalFormat c = (DecimalFormat) super.clone ();
    c.symbols = (DecimalFormatSymbols) symbols.clone ();
    return c;
  }

  /**
   * Constructs a <code>DecimalFormat</code> which uses the default
   * pattern and symbols.
   */
  public DecimalFormat ()
  {
    this ("#,##0.###");
  }

  /**
   * Constructs a <code>DecimalFormat</code> which uses the given
   * pattern and the default symbols for formatting and parsing.
   *
   * @param pattern the non-localized pattern to use.
   * @throws NullPointerException if any argument is null.
   * @throws IllegalArgumentException if the pattern is invalid.
   */
  public DecimalFormat (String pattern)
  {
    this (pattern, new DecimalFormatSymbols ());
  }

  /**
   * Constructs a <code>DecimalFormat</code> using the given pattern
   * and formatting symbols.  This construction method is used to give
   * complete control over the formatting process.  
   *
   * @param pattern the non-localized pattern to use.
   * @param symbols the set of symbols used for parsing and formatting.
   * @throws NullPointerException if any argument is null.
   * @throws IllegalArgumentException if the pattern is invalid.
   */
  public DecimalFormat(String pattern, DecimalFormatSymbols symbols)
  {
    this.symbols = (DecimalFormatSymbols) symbols.clone();
    applyPattern(pattern);
  }

  private boolean equals(String s1, String s2)
  {
    if (s1 == null || s2 == null)
      return s1 == s2;
    return s1.equals(s2);
  }

  /**
   * Tests this instance for equality with an arbitrary object.  This method
   * returns <code>true</code> if:
   * <ul>
   * <li><code>obj</code> is not <code>null</code>;</li>
   * <li><code>obj</code> is an instance of <code>DecimalFormat</code>;</li>
   * <li>this instance and <code>obj</code> have the same attributes;</li>
   * </ul>
   * 
   * @param obj  the object (<code>null</code> permitted).
   * 
   * @return A boolean.
   */
  public boolean equals(Object obj)
  {
    if (! (obj instanceof DecimalFormat))
      return false;
    DecimalFormat dup = (DecimalFormat) obj;
    return (decimalSeparatorAlwaysShown == dup.decimalSeparatorAlwaysShown 
           && groupingUsed == dup.groupingUsed 
           && groupingSize == dup.groupingSize 
           && multiplier == dup.multiplier
           && useExponentialNotation == dup.useExponentialNotation
           && minExponentDigits == dup.minExponentDigits
           && minimumIntegerDigits == dup.minimumIntegerDigits
           && maximumIntegerDigits == dup.maximumIntegerDigits
           && minimumFractionDigits == dup.minimumFractionDigits
           && maximumFractionDigits == dup.maximumFractionDigits
           && equals(negativePrefix, dup.negativePrefix)
           && equals(negativeSuffix, dup.negativeSuffix)
           && equals(positivePrefix, dup.positivePrefix)
           && equals(positiveSuffix, dup.positiveSuffix)
           && symbols.equals(dup.symbols));
  }

  private void formatInternal (double number, FormatBuffer dest,
			       FieldPosition fieldPos)
  {
    // A very special case.
    if (Double.isNaN(number))
      {
	dest.append(symbols.getNaN());
	if (fieldPos != null && 
	    (fieldPos.getField() == INTEGER_FIELD ||
	     fieldPos.getFieldAttribute() == NumberFormat.Field.INTEGER))
	  {
	    int index = dest.length();
	    fieldPos.setBeginIndex(index - symbols.getNaN().length());
	    fieldPos.setEndIndex(index);
	  }
	return;
      }
		
    boolean is_neg = number < 0;
    if (is_neg)
      {
	if (negativePrefix != null)
	  {
	    dest.append(substituteCurrency(negativePrefix, number),
			negativePrefixRanges, negativePrefixAttrs);
	  }
	else
	  {
	    dest.append(symbols.getMinusSign(), NumberFormat.Field.SIGN);
	    dest.append(substituteCurrency(positivePrefix, number),
			positivePrefixRanges, positivePrefixAttrs);
	  }
	number = - number;
      }
    else
      {
	dest.append(substituteCurrency(positivePrefix, number),
		    positivePrefixRanges, positivePrefixAttrs);
      }
    int integerBeginIndex = dest.length();
    int integerEndIndex = 0;
    int zeroStart = symbols.getZeroDigit() - '0';
		
    if (Double.isInfinite (number))
      {
	dest.append(symbols.getInfinity());
	integerEndIndex = dest.length();
      }
    else
      {
	number *= multiplier;
	
	// Compute exponent.
	long exponent = 0;
	double baseNumber;
	if (useExponentialNotation && number > 0)
	  {
	    exponent = (long) Math.floor (Math.log10(number));
	    exponent = exponent - (exponent % exponentRound);
	    if (minimumIntegerDigits > 0)
	      exponent -= minimumIntegerDigits - 1;
	    baseNumber = (number / Math.pow(10.0, exponent));
	  }
	else
	  baseNumber = number;

	// Round to the correct number of digits.
	baseNumber += 5 * Math.pow(10.0, - maximumFractionDigits - 1);

	int index = dest.length();
	//double intPart = Math.floor(baseNumber);
	String intPart = Long.toString((long)Math.floor(baseNumber));
	int count, groupPosition = intPart.length();

	dest.setDefaultAttribute(NumberFormat.Field.INTEGER);

	for (count = 0; count < minimumIntegerDigits-intPart.length(); count++)
	  dest.append(symbols.getZeroDigit());

	for (count = 0;
	     count < maximumIntegerDigits && count < intPart.length();
	     count++)
	  {
	    int dig = intPart.charAt(count);

	    // Append group separator if required.
	    if (groupingUsed && count > 0 && groupingSize != 0 && groupPosition % groupingSize == 0)
	      {
		dest.append(symbols.getGroupingSeparator(), NumberFormat.Field.GROUPING_SEPARATOR);
		dest.setDefaultAttribute(NumberFormat.Field.INTEGER);
	      }
	    dest.append((char) (zeroStart + dig));

	    groupPosition--;
	  }
	dest.setDefaultAttribute(null);

	integerEndIndex = dest.length();
	   
	int decimal_index = integerEndIndex;
	int consecutive_zeros = 0;
	int total_digits = 0;

	int localMaximumFractionDigits = maximumFractionDigits;

	if (useExponentialNotation)
	  localMaximumFractionDigits += minimumIntegerDigits - count;

	// Strip integer part from NUMBER.
	double fracPart = baseNumber - Math.floor(baseNumber);
	
	if ( ((fracPart != 0 || minimumFractionDigits > 0) && localMaximumFractionDigits > 0)
	     || decimalSeparatorAlwaysShown)
	  {
	    dest.append (symbols.getDecimalSeparator(), NumberFormat.Field.DECIMAL_SEPARATOR);
	  }

	int fraction_begin = dest.length();
	dest.setDefaultAttribute(NumberFormat.Field.FRACTION);
	for (count = 0;
	     count < localMaximumFractionDigits
	       && (fracPart != 0 || count < minimumFractionDigits);
	     ++count)
	  {
	    ++total_digits;
	    fracPart *= 10;
	    long dig = (long) fracPart;
	    if (dig == 0)
	      ++consecutive_zeros;
	    else
	      consecutive_zeros = 0;
	    dest.append((char) (symbols.getZeroDigit() + dig));

	    // Strip integer part from FRACPART.
	    fracPart = fracPart - Math.floor (fracPart);
	  }

	// Strip extraneous trailing `0's.  We can't always detect
	// these in the loop.
	int extra_zeros = Math.min (consecutive_zeros,
				    total_digits - minimumFractionDigits);
	if (extra_zeros > 0)
	  {
	    dest.cutTail(extra_zeros);
	    total_digits -= extra_zeros;
	    if (total_digits == 0 && !decimalSeparatorAlwaysShown)
	      dest.cutTail(1);
	  }

	if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
	  {
	    fieldPos.setBeginIndex(fraction_begin);
	    fieldPos.setEndIndex(dest.length());
	  }

	// Finally, print the exponent.
	if (useExponentialNotation)
	  {
	    dest.append(symbols.getExponential(), NumberFormat.Field.EXPONENT_SYMBOL);	    
	    if (exponent < 0)
	      {
		dest.append (symbols.getMinusSign (), NumberFormat.Field.EXPONENT_SIGN);
		exponent = - exponent;
	      }
	    index = dest.length();
	    dest.setDefaultAttribute(NumberFormat.Field.EXPONENT);
	    String exponentString = Long.toString ((long) exponent);

	    for (count = 0; count < minExponentDigits-exponentString.length();
		 count++)
	      dest.append((char) symbols.getZeroDigit());

	    for (count = 0;
		 count < exponentString.length();
		 ++count)
	      {
		int dig = exponentString.charAt(count);
		dest.append((char) (zeroStart + dig));
	      }
	  }
      }

    if (fieldPos != null && 
	(fieldPos.getField() == INTEGER_FIELD ||
	 fieldPos.getFieldAttribute() == NumberFormat.Field.INTEGER))
      {
	fieldPos.setBeginIndex(integerBeginIndex);
	fieldPos.setEndIndex(integerEndIndex);
      }
		
    if (is_neg && negativeSuffix != null)
      {
	dest.append(substituteCurrency(negativeSuffix, number),
		    negativeSuffixRanges, negativeSuffixAttrs);
      }
    else
      {
	dest.append(substituteCurrency(positiveSuffix, number),
		    positiveSuffixRanges, positiveSuffixAttrs);
      }
  }

  public StringBuffer format (double number, StringBuffer dest,
			      FieldPosition fieldPos)
  {
    formatInternal (number, new StringFormatBuffer(dest), fieldPos);
    return dest;
  }

  public AttributedCharacterIterator formatToCharacterIterator (Object value)
  {
    AttributedFormatBuffer sbuf = new AttributedFormatBuffer();

    if (value instanceof Number)
      formatInternal(((Number) value).doubleValue(), sbuf, null);
    else
      throw new IllegalArgumentException 
	("Cannot format given Object as a Number");
    
    sbuf.sync();
    return new FormatCharacterIterator(sbuf.getBuffer().toString(), 
				       sbuf.getRanges(), 
				       sbuf.getAttributes());
  }

  public StringBuffer format (long number, StringBuffer dest,
			      FieldPosition fieldPos)
  {
    // If using exponential notation, we just format as a double.
    if (useExponentialNotation)
       return format ((double) number, dest, fieldPos);

    boolean is_neg = number < 0;
    if (is_neg)
      {
	if (negativePrefix != null)
	  dest.append(substituteCurrency(negativePrefix, number));
	else
	  {
	    dest.append(symbols.getMinusSign());
	    dest.append(substituteCurrency(positivePrefix, number));
	  }
	number = - number;
      }
    else
      dest.append(substituteCurrency(positivePrefix, number));

    int integerBeginIndex = dest.length();
    int index = dest.length();
    int count = 0;

    /* Handle percentages, etc. */
    number *= multiplier;
    while (count < maximumIntegerDigits
	   && (number > 0 || count < minimumIntegerDigits))
      {
	long dig = number % 10;
	number /= 10;
	// NUMBER and DIG will be less than 0 if the original number
	// was the most negative long.
	if (dig < 0)
	  {
	    dig = - dig;
	    number = - number;
	  }

	// Append group separator if required.
	if (groupingUsed && count > 0 && groupingSize != 0 && count % groupingSize == 0)
	  dest.insert(index, symbols.getGroupingSeparator());

	dest.insert(index, (char) (symbols.getZeroDigit() + dig));

	++count;
      }

    if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
      {
	fieldPos.setBeginIndex(integerBeginIndex);
	fieldPos.setEndIndex(dest.length());
      }

    if (decimalSeparatorAlwaysShown || minimumFractionDigits > 0)
      {
	dest.append(symbols.getDecimalSeparator());
	if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
	  {
	    fieldPos.setBeginIndex(dest.length());
	    fieldPos.setEndIndex(dest.length() + minimumFractionDigits);
	  }
      }

    for (count = 0; count < minimumFractionDigits; ++count)
      dest.append(symbols.getZeroDigit());

    dest.append((is_neg && negativeSuffix != null)
		? substituteCurrency(negativeSuffix, number)
		: substituteCurrency(positiveSuffix, number));
    return dest;
  }

  /**
   * Returns the currency corresponding to the currency symbol stored
   * in the instance of <code>DecimalFormatSymbols</code> used by this
   * <code>DecimalFormat</code>.
   *
   * @return A new instance of <code>Currency</code> if
   * the currency code matches a known one, null otherwise.
   */
  public Currency getCurrency()
  {
    return symbols.getCurrency();
  }

  /**
   * Returns a copy of the symbols used by this instance.
   * 
   * @return A copy of the symbols.
   */
  public DecimalFormatSymbols getDecimalFormatSymbols()
  {
    return (DecimalFormatSymbols) symbols.clone();
  }

  public int getGroupingSize ()
  {
    return groupingSize;
  }

  public int getMultiplier ()
  {
    return multiplier;
  }

  public String getNegativePrefix ()
  {
    return negativePrefix;
  }

  public String getNegativeSuffix ()
  {
    return negativeSuffix;
  }

  public String getPositivePrefix ()
  {
    return positivePrefix;
  }

  public String getPositiveSuffix ()
  {
    return positiveSuffix;
  }

  /**
   * Returns a hash code for this object.
   *
   * @return A hash code.
   */
  public int hashCode()
  {
    return toPattern().hashCode();
  }

  public boolean isDecimalSeparatorAlwaysShown ()
  {
    return decimalSeparatorAlwaysShown;
  }

  public Number parse (String str, ParsePosition pos)
  {
    /*
     * Our strategy is simple: copy the text into separate buffers: one for the int part,
     * one for the fraction part and for the exponential part.
     * We translate or omit locale-specific information.  
     * If exponential is sufficiently big we merge the fraction and int part and
     * remove the '.' and then we use Long to convert the number. In the other
     * case, we use Double to convert the full number.
     */

    boolean is_neg = false;
    int index = pos.getIndex();
    StringBuffer int_buf = new StringBuffer ();
        
    // We have to check both prefixes, because one might be empty.  We
    // want to pick the longest prefix that matches.
    boolean got_pos = str.startsWith(positivePrefix, index);
    String np = (negativePrefix != null
		 ? negativePrefix
		 : positivePrefix + symbols.getMinusSign());
    boolean got_neg = str.startsWith(np, index);

    if (got_pos && got_neg)
      {
	// By checking this way, we preserve ambiguity in the case
	// where the negative format differs only in suffix.  We
	// check this again later.
	if (np.length() > positivePrefix.length())
	  {
	    is_neg = true;
	    index += np.length();
	  }
	else
	  index += positivePrefix.length();
      }
    else if (got_neg)
      {
	is_neg = true;
	index += np.length();
      }
    else if (got_pos)
      index += positivePrefix.length();
    else
      {
	pos.setErrorIndex (index);
	return null;
      }

    // FIXME: handle Inf and NaN.

    // FIXME: do we have to respect minimum digits?
    // What about multiplier?

    StringBuffer buf = int_buf;
    StringBuffer frac_buf = null;
    StringBuffer exp_buf = null;
    int start_index = index;
    int max = str.length();
    int exp_index = -1;
    int last = index + maximumIntegerDigits; 

    if (maximumFractionDigits > 0)
      last += maximumFractionDigits + 1;
    
    if (useExponentialNotation)
      last += minExponentDigits + 1;

    if (last > 0 && max > last)
      max = last;

    char zero = symbols.getZeroDigit();
    int last_group = -1;
    boolean int_part = true;
    boolean exp_part = false;
    for (; index < max; ++index)
      {
	char c = str.charAt(index);

	// FIXME: what about grouping size?
	if (groupingUsed && c == symbols.getGroupingSeparator())
	  {
	    if (last_group != -1 
		&& groupingSize != 0  
		&& (index - last_group) % groupingSize != 0)
	      {
		pos.setErrorIndex(index);
		return null;
	      }
	    last_group = index+1;
	  }
	else if (c >= zero && c <= zero + 9)
	  {
	    buf.append((char) (c - zero + '0'));
	  }
	else if (parseIntegerOnly)
	  break;
	else if (c == symbols.getDecimalSeparator())
	  {
	    if (last_group != -1 
		&& groupingSize != 0 
		&& (index - last_group) % groupingSize != 0)
	      {
		pos.setErrorIndex(index);
		return null;
	      }
	    buf = frac_buf = new StringBuffer();
	    frac_buf.append('.');
	    int_part = false;
	  }
	else if (c == symbols.getExponential())
	  {
	    buf = exp_buf = new StringBuffer();
	    int_part = false;
	    exp_part = true;
	    exp_index = index+1;
	  }
	else if (exp_part
		 && (c == '+' || c == '-' || c == symbols.getMinusSign()))
	  {
	    // For exponential notation.
	    buf.append(c);
	  }
	else
	  break;
      }

    if (index == start_index)
      {
	// Didn't see any digits.
	pos.setErrorIndex(index);
	return null;
      }

    // Check the suffix.  We must do this before converting the
    // buffer to a number to handle the case of a number which is
    // the most negative Long.
    boolean got_pos_suf = str.startsWith(positiveSuffix, index);
    String ns = (negativePrefix == null ? positiveSuffix : negativeSuffix);
    boolean got_neg_suf = str.startsWith(ns, index);
    if (is_neg)
      {
	if (! got_neg_suf)
	  {
	    pos.setErrorIndex(index);
	    return null;
	  }
      }
    else if (got_pos && got_neg && got_neg_suf)
      {
	is_neg = true;
      }
    else if (got_pos != got_pos_suf && got_neg != got_neg_suf)
      {
	pos.setErrorIndex(index);
	return null;
      }
    else if (! got_pos_suf)
      {
       pos.setErrorIndex(index);
       return null;
      }

    String suffix = is_neg ? ns : positiveSuffix;
    long parsedMultiplier = 1;
    boolean use_long;

    if (is_neg)
      int_buf.insert(0, '-');

    // Now handle the exponential part if there is one.
    if (exp_buf != null)
      {
	int exponent_value;

	try
	  {
	    exponent_value = Integer.parseInt(exp_buf.toString());
	  }
	catch (NumberFormatException x1)
	  {
	    pos.setErrorIndex(exp_index);
	    return null;
	  }

	if (frac_buf == null)
	  {
	    // We only have to add some zeros to the int part.
	    // Build a multiplier.
	    for (int i = 0; i < exponent_value; i++)
	      int_buf.append('0');
	    
	    use_long = true;
	  }
	else
	  {
	    boolean long_sufficient;

	    if (exponent_value < frac_buf.length()-1)
	      {
		int lastNonNull = -1;
		/* We have to check the fraction buffer: it may only be full of '0'
		 * or be sufficiently filled with it to convert the number into Long.
		 */
		for (int i = 1; i < frac_buf.length(); i++)
		  if (frac_buf.charAt(i) != '0')
		    lastNonNull = i;

		long_sufficient = (lastNonNull < 0 || lastNonNull <= exponent_value);
	      }
	    else
	      long_sufficient = true;
	    
	    if (long_sufficient)
	      {
		for (int i = 1; i < frac_buf.length() && i < exponent_value; i++)
		  int_buf.append(frac_buf.charAt(i));
		for (int i = frac_buf.length()-1; i < exponent_value; i++)
		  int_buf.append('0');
		use_long = true;
	      }
	    else
	      {
		/*
		 * A long type is not sufficient, we build the full buffer to
		 * be parsed by Double.
		 */
		int_buf.append(frac_buf);
		int_buf.append('E');
		int_buf.append(exp_buf);
		use_long = false;
	      }
	  }
      }
    else
      {
	if (frac_buf != null)
	  {
	    /* Check whether the fraction buffer contains only '0' */
	    int i;
	    for (i = 1; i < frac_buf.length(); i++)
	      if (frac_buf.charAt(i) != '0')
		break;
	   
	    if (i != frac_buf.length())
	      {
		use_long = false;
		int_buf.append(frac_buf);
	      }
	    else
	      use_long = true;
	  }
	else
	  use_long = true;
      }

    String t = int_buf.toString();
    Number result = null;
    if (use_long)
      {
	try
	  {
	    result = new Long (t);
	  }
	catch (NumberFormatException x1)
	  {
	  }
      }
    else
      {
	try
	  {
	    result = new Double (t);
	  }
	catch (NumberFormatException x2)
	  {
	  }
      }
    if (result == null)
      {
	pos.setErrorIndex(index);
	return null;
      }

    pos.setIndex(index + suffix.length());

    return result;
  }

  /**
   * Sets the <code>Currency</code> on the
   * <code>DecimalFormatSymbols</code> used, which also sets the
   * currency symbols on those symbols.
   */
  public void setCurrency(Currency currency)
  {
    symbols.setCurrency(currency);
  }

  /**
   * Sets the symbols used by this instance.  This method makes a copy of 
   * the supplied symbols.
   * 
   * @param newSymbols  the symbols (<code>null</code> not permitted).
   */
  public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols)
  {
    symbols = (DecimalFormatSymbols) newSymbols.clone();
  }

  public void setDecimalSeparatorAlwaysShown (boolean newValue)
  {
    decimalSeparatorAlwaysShown = newValue;
  }

  public void setGroupingSize (int groupSize)
  {
    groupingSize = (byte) groupSize;
  }

  public void setMaximumFractionDigits (int newValue)
  {
    super.setMaximumFractionDigits(Math.min(newValue, 340));
  }

  public void setMaximumIntegerDigits (int newValue)
  {
    super.setMaximumIntegerDigits(Math.min(newValue, 309));
  }

  public void setMinimumFractionDigits (int newValue)
  {
    super.setMinimumFractionDigits(Math.min(newValue, 340));
  }

  public void setMinimumIntegerDigits (int newValue)
  {
    super.setMinimumIntegerDigits(Math.min(newValue, 309));
  }

  public void setMultiplier (int newValue)
  {
    multiplier = newValue;
  }

  public void setNegativePrefix (String newValue)
  {
    negativePrefix = newValue;
  }

  public void setNegativeSuffix (String newValue)
  {
    negativeSuffix = newValue;
  }

  public void setPositivePrefix (String newValue)
  {
    positivePrefix = newValue;
  }

  public void setPositiveSuffix (String newValue)
  {
    positiveSuffix = newValue;
  }

  private void quoteFix(StringBuffer buf, String text, String patChars)
  {
    int len = text.length();
    for (int index = 0; index < len; ++index)
      {
	char c = text.charAt(index);
	if (patChars.indexOf(c) != -1)
	  {
	    buf.append('\'');
	    buf.append(c);
	    buf.append('\'');
	  }
	else
	  buf.append(c);
      }
  }

  private String computePattern(DecimalFormatSymbols syms)
  {
    StringBuffer mainPattern = new StringBuffer ();
    // We have to at least emit a zero for the minimum number of
    // digits.  Past that we need hash marks up to the grouping
    // separator (and one beyond).
    int total_digits = Math.max(minimumIntegerDigits,
				groupingUsed ? groupingSize + 1: groupingSize);
    for (int i = 0; i < total_digits - minimumIntegerDigits; ++i)
      mainPattern.append(syms.getDigit());
    for (int i = total_digits - minimumIntegerDigits; i < total_digits; ++i)
      mainPattern.append(syms.getZeroDigit());
    // Inserting the gropuing operator afterwards is easier.
    if (groupingUsed)
      mainPattern.insert(mainPattern.length() - groupingSize,
			 syms.getGroupingSeparator());
    // See if we need decimal info.
    if (minimumFractionDigits > 0 || maximumFractionDigits > 0
	|| decimalSeparatorAlwaysShown)
      mainPattern.append(syms.getDecimalSeparator());
    for (int i = 0; i < minimumFractionDigits; ++i)
      mainPattern.append(syms.getZeroDigit());
    for (int i = minimumFractionDigits; i < maximumFractionDigits; ++i)
      mainPattern.append(syms.getDigit());
    if (useExponentialNotation)
      {
	mainPattern.append(syms.getExponential());
	for (int i = 0; i < minExponentDigits; ++i)
	  mainPattern.append(syms.getZeroDigit());
	if (minExponentDigits == 0)
	  mainPattern.append(syms.getDigit());
      }

    String main = mainPattern.toString();
    String patChars = patternChars (syms);
    mainPattern.setLength(0);

    quoteFix (mainPattern, positivePrefix, patChars);
    mainPattern.append(main);
    quoteFix (mainPattern, positiveSuffix, patChars);

    if (negativePrefix != null)
      {
	quoteFix (mainPattern, negativePrefix, patChars);
	mainPattern.append(main);
	quoteFix (mainPattern, negativeSuffix, patChars);
      }

    return mainPattern.toString();
  }

  public String toLocalizedPattern ()
  {
    return computePattern (symbols);
  }

  public String toPattern ()
  {
    return computePattern (nonLocalizedSymbols);
  }

  private static final int MAXIMUM_INTEGER_DIGITS = 309; 

  // These names are fixed by the serialization spec.
  private boolean decimalSeparatorAlwaysShown;
  private byte groupingSize;
  private byte minExponentDigits;
  private int exponentRound;
  private int multiplier;
  private String negativePrefix;
  private String negativeSuffix;
  private String positivePrefix;
  private String positiveSuffix;
  private int[] negativePrefixRanges, positivePrefixRanges;
  private HashMap[] negativePrefixAttrs, positivePrefixAttrs;
  private int[] negativeSuffixRanges, positiveSuffixRanges;
  private HashMap[] negativeSuffixAttrs, positiveSuffixAttrs;
  private int serialVersionOnStream = 1;
  private DecimalFormatSymbols symbols;
  private boolean useExponentialNotation;
  private static final long serialVersionUID = 864413376551465018L;

  private void readObject(ObjectInputStream stream)
    throws IOException, ClassNotFoundException
  {
    stream.defaultReadObject();
    if (serialVersionOnStream < 1)
      {
        useExponentialNotation = false;
	serialVersionOnStream = 1;
      }
  }

  // The locale-independent pattern symbols happen to be the same as
  // the US symbols.
  private static final DecimalFormatSymbols nonLocalizedSymbols
    = new DecimalFormatSymbols (Locale.US);

  /**
   * <p>
   * Substitutes the currency symbol into the given string,
   * based on the value used.  Currency symbols can either
   * be a simple series of characters (e.g. '$'), which are
   * simply used as is, or they can be of a more complex
   * form:
   * </p>
   * <p>
   * (lower bound)|(mid value)|(upper bound)
   * </p>
   * <p>
   * where each bound has the syntax '(value)(# or <)(symbol)',
   * to indicate the bounding value and the symbol used.
   * </p>
   * <p>
   * The currency symbol replaces the currency specifier, '\u00a4',
   * an unlocalised character, which thus is used as such in all formats.
   * If this symbol occurs twice, the international currency code is used
   * instead.
   * </p>
   *
   * @param string The string containing the currency specifier, '\u00a4'.
   * @param number the number being formatted.
   * @return a string formatted for the correct currency.
   */
  private String substituteCurrency(String string, double number)
  {
    int index;
    int length;
    char currentChar;
    StringBuffer buf;
    
    index = 0;
    length = string.length();
    buf = new StringBuffer();
    
    while (index < length)
      {
	currentChar = string.charAt(index);
	if (string.charAt(index) == '\u00a4')
	  {
	    if ((index + 1) < length && string.charAt(index + 1) == '\u00a4')
	      {
		buf.append(symbols.getInternationalCurrencySymbol());
		index += 2;
	      }
	    else
	      {
		String symbol;
		
		symbol = symbols.getCurrencySymbol();
		if (symbol.startsWith("="))
		  {
		    String[] bounds;
		    int[] boundValues;
		    String[] boundSymbols;
		    
		    bounds = symbol.substring(1).split("\\|");
		    boundValues = new int[3];
		    boundSymbols = new String[3];
		    for (int a = 0; a < 3; ++a)
		      {
			String[] bound;
			
			bound = bounds[a].split("[#<]");
			boundValues[a] = Integer.parseInt(bound[0]);
			boundSymbols[a] = bound[1];
		      }
		    if (number <= boundValues[0])
		      {
			buf.append(boundSymbols[0]);
		      }
		    else if (number >= boundValues[2])
		      {
			buf.append(boundSymbols[2]);
		      }
		    else 
		      {
			buf.append(boundSymbols[1]);
		      }
		    ++index;
		  }
		else
		  {
		    buf.append(symbol);
		    ++index;
		  }
	      }
	  }
	else
	  {
	    buf.append(string.charAt(index));
	    ++index;
	  }
      }
    return buf.toString();
  }
  
}