gcc/libjava/java/text/MessageFormat.java

// MessageFormat.java - Localized message formatting.

/* Copyright (C) 1999  Cygnus Solutions

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

package java.text;

import java.util.Date;
import java.util.Locale;
import java.util.Vector;

/**
 * @author Tom Tromey <tromey@cygnus.com>
 * @date March 3, 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, except serialization.
 *          and parsing.
 */

final class MessageFormatElement
{
  // Argument number.
  int argNumber;
  // Formatter to be used.  This is the format set by setFormat.
  Format setFormat;
  // Formatter to be used based on the type.
  Format format;

  // Argument will be checked to make sure it is an instance of this
  // class.
  Class formatClass;

  // Formatter type.
  String type;
  // Formatter style.
  String style;

  // Text to follow this element.
  String trailer;

  // FIXME: shouldn't need this.
  Class forName (String name)
    {
      try
	{
	  return Class.forName (name);
	}
      catch (ClassNotFoundException x)
	{
	}
      return null;
    }

  // Recompute the locale-based formatter.
  void setLocale (Locale loc)
    {
      if (type == null)
	;
      else if (type.equals("number"))
	{
	  // FIXME: named class literal.
	  // formatClass = Number.class;
	  formatClass = forName ("java.lang.Number");

	  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;
	      try
		{
		  df.applyPattern(style);
		}
	      catch (ParseException x)
		{
		  throw new IllegalArgumentException (x.getMessage());
		}
	    }
	}
      else if (type.equals("time") || type.equals("date"))
	{
	  // FIXME: named class literal.
	  // formatClass = Date.class;
	  formatClass = forName ("java.util.Date");

	  int val = DateFormat.DEFAULT;
	  if (style == null)
	    ;
	  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"))
	{
	  // FIXME: named class literal.
	  // formatClass = Number.class;
	  formatClass = forName ("java.lang.Number");

	  if (style == null)
	    throw new
	      IllegalArgumentException ("style required for choice format");
	  format = new ChoiceFormat (style);
	}
    }
}

public class MessageFormat extends Format
{
  // Helper that returns the text up to the next format opener.  The
  // text is put into BUFFER.  Returns index of character after end of
  // 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
	    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
	    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) != '}')
	throw new IllegalArgumentException ();
      ++index;

      // Now fetch trailing string.
      index = scanString (pat, index, buffer);
      mfe.trailer = buffer.toString ();

      mfe.setLocale(locale);

      return index;
    }

  public void applyPattern (String newPattern)
    {
      pattern = newPattern;

      StringBuffer tempBuffer = new StringBuffer ();

      int index = scanString (newPattern, 0, tempBuffer);
      leader = tempBuffer.toString();

      Vector elts = new Vector ();
      while (index < newPattern.length())
	index = scanFormat (newPattern, index, tempBuffer, elts, locale);

      elements = new MessageFormatElement[elts.size()];
      elts.copyInto(elements);
    }

  public Object clone ()
    {
      MessageFormat c = new MessageFormat ();
      c.setLocale(locale);
      c.applyPattern(pattern);
      return (Object) c;
    }

  public boolean equals (Object obj)
    {
      if (! (obj instanceof MessageFormat))
	return false;
      MessageFormat mf = (MessageFormat) obj;
      return (pattern.equals(mf.pattern)
	      && locale.equals(mf.locale));
    }

  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();
    }

  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;
    }

  public final StringBuffer format (Object singleArg, StringBuffer appendBuf,
				    FieldPosition ignore)
    {
      Object[] args = new Object[1];
      args[0] = singleArg;
      return format (args, appendBuf, ignore);
    }

  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;
    }

  public Locale getLocale ()
    {
      return locale;
    }

  public int hashCode ()
    {
      // FIXME: not a very good hash.
      return pattern.hashCode() + locale.hashCode();
    }

  private MessageFormat ()
    {
    }

  public MessageFormat (String pattern)
    {
      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;
    }

  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;
    }

  public Object parseObject (String sourceStr, ParsePosition pos)
    {
      return parse (sourceStr, pos);
    }

  public void setFormat (int variableNum, Format newFormat)
    {
      elements[variableNum].setFormat = newFormat;
    }

  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];
    }

  public void setLocale (Locale loc)
    {
      locale = loc;
      if (elements != null)
	{
	  for (int i = 0; i < elements.length; ++i)
	    elements[i].setLocale(loc);
	}
    }

  public String toPattern ()
    {
      return pattern;
    }

  // The pattern string.
  private String pattern;
  // The locale.
  private Locale locale;
  // Variables.
  private MessageFormatElement[] elements;
  // Leader text.
  private String leader;
}