/*
DRM, distributed resource machine supporting special distributed applications
Copyright (C) 2002 The European Commission DREAM Project IST-1999-12679

This file is part of DRM.

DRM 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 of the License, or
(at your option) any later version.

DRM 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 DRM; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

contact: http://www.dr-ea-m.org, http://www.sourceforge.net/projects/dr-ea-m
*/


package drm.util; // we put this in this package for convinience,
		    // but no other changes are made

//
// (c) 2000 Sun Microsystems, Inc.
// ALL RIGHTS RESERVED
// 
// License Grant-
// 
// 
// Permission to use, copy, modify, and distribute this Software and its 
// documentation for NON-COMMERCIAL or COMMERCIAL purposes and without fee is 
// hereby granted.  
// 
// This Software is provided "AS IS".  All express warranties, including any 
// implied warranty of merchantability, satisfactory quality, fitness for a 
// particular purpose, or non-infringement, are disclaimed, except to the extent 
// that such disclaimers are held to be legally invalid.
// 
// You acknowledge that Software is not designed, licensed or intended for use in 
// the design, construction, operation or maintenance of any nuclear facility 
// ("High Risk Activities").  Sun disclaims any express or implied warranty of 
// fitness for such uses.  
//
// Please refer to the file http://www.sun.com/policies/trademarks/ for further 
// important trademark information and to 
// http://java.sun.com/nav/business/index.html for further important licensing 
// information for the Java Technology.
//


import java.util.Enumeration;
import java.util.Vector;
import java.util.Locale;
import java.text.DecimalFormatSymbols;

/**
 * PrintfFormat allows the formatting of an array of
 * objects embedded within a string.  Primitive types
 * must be passed using wrapper types.  The formatting
 * is controlled by a control string.
 *<p>
 * A control string is a Java string that contains a
 * control specification.  The control specification
 * starts at the first percent sign (%) in the string,
 * provided that this percent sign
 *<ol>
 *<li>is not escaped protected by a matching % or is
 * not an escape % character,
 *<li>is not at the end of the format string, and
 *<li>precedes a sequence of characters that parses as
 * a valid control specification.
 *</ol>
 *</p><p>
 * A control specification usually takes the form:
 *<pre> % ['-+ #0]* [0..9]* { . [0..9]* }+
 *                { [hlL] }+ [idfgGoxXeEcs]
 *</pre>
 * There are variants of this basic form that are
 * discussed below.</p>
 *<p>
 * The format is composed of zero or more directives
 * defined as follows:
 *<ul>
 *<li>ordinary characters, which are simply copied to
 * the output stream;
 *<li>escape sequences, which represent non-graphic
 * characters; and
 *<li>conversion specifications,  each of which
 * results in the fetching of zero or more arguments.
 *</ul></p>
 *<p>
 * The results are undefined if there are insufficient
 * arguments for the format.  Usually an unchecked
 * exception will be thrown.  If the format is
 * exhausted while arguments remain, the excess
 * arguments are evaluated but are otherwise ignored.
 * In format strings containing the % form of
 * conversion specifications, each argument in the
 * argument list is used exactly once.</p>
 * <p>
 * Conversions can be applied to the <code>n</code>th
 * argument after the format in the argument list,
 * rather than to the next unused argument.  In this
 * case, the conversion characer % is replaced by the
 * sequence %<code>n</code>$, where <code>n</code> is
 * a decimal integer giving the position of the
 * argument in the argument list.</p>
 * <p>
 * In format strings containing the %<code>n</code>$
 * form of conversion specifications, each argument
 * in the argument list is used exactly once.</p>
 *
 *<h4>Escape Sequences</h4>
 *<p>
 * The following table lists escape sequences and
 * associated actions on display devices capable of
 * the action.
 *<table>
 *<tr><th align=left>Sequence</th>
 *    <th align=left>Name</th>
 *    <th align=left>Description</th></tr>
 *<tr><td>\\</td><td>backlash</td><td>None.
 *</td></tr>
 *<tr><td>\a</td><td>alert</td><td>Attempts to alert
 *          the user through audible or visible
 *          notification.
 *</td></tr>
 *<tr><td>\b</td><td>backspace</td><td>Moves the
 *          printing position to one column before
 *          the current position, unless the
 *          current position is the start of a line.
 *</td></tr>
 *<tr><td>\f</td><td>form-feed</td><td>Moves the
 *          printing position to the initial 
 *          printing position of the next logical
 *          page.
 *</td></tr>
 *<tr><td>\n</td><td>newline</td><td>Moves the
 *          printing position to the start of the
 *          next line.
 *</td></tr>
 *<tr><td>\r</td><td>carriage-return</td><td>Moves
 *          the printing position to the start of
 *          the current line.
 *</td></tr>
 *<tr><td>\t</td><td>tab</td><td>Moves the printing
 *          position to the next implementation-
 *          defined horizontal tab position.
 *</td></tr>
 *<tr><td>\v</td><td>vertical-tab</td><td>Moves the
 *          printing position to the start of the
 *          next implementation-defined vertical
 *          tab position.
 *</td></tr>
 *</table></p>
 *<h4>Conversion Specifications</h4>
 *<p>
 * Each conversion specification is introduced by
 * the percent sign character (%).  After the character
 * %, the following appear in sequence:</p>
 *<p>
 * Zero or more flags (in any order), which modify the
 * meaning of the conversion specification.</p>
 *<p>
 * An optional minimum field width.  If the converted
 * value has fewer characters than the field width, it
 * will be padded with spaces by default on the left;
 * t will be padded on the right, if the left-
 * adjustment flag (-), described below, is given to
 * the field width.  The field width takes the form
 * of a decimal integer.  If the conversion character
 * is s, the field width is the the minimum number of
 * characters to be printed.</p>
 *<p>
 * An optional precision that gives the minumum number
 * of digits to appear for the d, i, o, x or X
 * conversions (the field is padded with leading
 * zeros); the number of digits to appear after the
 * radix character for the e, E, and f conversions,
 * the maximum number of significant digits for the g
 * and G conversions; or the maximum number of
 * characters to be written from a string is s and S
 * conversions.  The precision takes the form of an
 * optional decimal digit string, where a null digit
 * string is treated as 0.  If a precision appears
 * with a c conversion character the precision is
 * ignored.
 * </p>
 *<p>
 * An optional h specifies that a following d, i, o,
 * x, or X conversion character applies to a type 
 * short argument (the argument will be promoted
 * according to the integral promotions and its value
 * converted to type short before printing).</p>
 *<p>
 * An optional l (ell) specifies that a following
 * d, i, o, x, or X conversion character applies to a
 * type long argument.</p>
 *<p>
 * A field width or precision may be indicated by an
 * asterisk (*) instead of a digit string.  In this
 * case, an integer argument supplised the field width
 * precision.  The argument that is actually converted
 * is not fetched until the conversion letter is seen,
 * so the the arguments specifying field width or
 * precision must appear before the argument (if any)
 * to be converted.  If the precision argument is
 * negative, it will be changed to zero.  A negative
 * field width argument is taken as a - flag, followed
 * by a positive field width.</p>
 * <p>
 * In format strings containing the %<code>n</code>$
 * form of a conversion specification, a field width
 * or precision may be indicated by the sequence
 * *<code>m</code>$, where m is a decimal integer
 * giving the position in the argument list (after the
 * format argument) of an integer argument containing
 * the field width or precision.</p>
 * <p>
 * The format can contain either numbered argument
 * specifications (that is, %<code>n</code>$ and
 * *<code>m</code>$), or unnumbered argument
 * specifications (that is % and *), but normally not
 * both.  The only exception to this is that %% can
 * be mixed with the %<code>n</code>$ form.  The
 * results of mixing numbered and unnumbered argument
 * specifications in a format string are undefined.</p>
 *
 *<h4>Flag Characters</h4>
 *<p>
 * The flags and their meanings are:</p>
 *<dl>
 * <dt>'<dd> integer portion of the result of a
 *      decimal conversion (%i, %d, %f, %g, or %G) will
 *      be formatted with thousands' grouping
 *      characters.  For other conversions the flag
 *      is ignored.  The non-monetary grouping
 *      character is used.
 * <dt>-<dd> result of the conversion is left-justified
 *      within the field.  (It will be right-justified
 *      if this flag is not specified).</td></tr>
 * <dt>+<dd> result of a signed conversion always
 *      begins with a sign (+ or -).  (It will begin
 *      with a sign only when a negative value is
 *      converted if this flag is not specified.)
 * <dt>&lt;space&gt;<dd> If the first character of a
 *      signed conversion is not a sign, a space
 *      character will be placed before the result.
 *      This means that if the space character and +
 *      flags both appear, the space flag will be
 *      ignored.
 * <dt>#<dd> value is to be converted to an alternative
 *      form.  For c, d, i, and s conversions, the flag
 *      has no effect.  For o conversion, it increases
 *      the precision to force the first digit of the
 *      result to be a zero.  For x or X conversion, a
 *      non-zero result has 0x or 0X prefixed to it,
 *      respectively.  For e, E, f, g, and G
 *      conversions, the result always contains a radix
 *      character, even if no digits follow the radix
 *      character (normally, a decimal point appears in
 *      the result of these conversions only if a digit
 *      follows it).  For g and G conversions, trailing
 *      zeros will not be removed from the result as
 *      they normally are.
 * <dt>0<dd> d, i, o, x, X, e, E, f, g, and G
 *      conversions, leading zeros (following any
 *      indication of sign or base) are used to pad to
 *      the field width;  no space padding is
 *      performed.  If the 0 and - flags both appear,
 *      the 0 flag is ignored.  For d, i, o, x, and X
 *      conversions, if a precision is specified, the
 *      0 flag will be ignored. For c conversions,
 *      the flag is ignored.
 *</dl>
 *
 *<h4>Conversion Characters</h4>
 *<p>
 * Each conversion character results in fetching zero
 * or more arguments.  The results are undefined if
 * there are insufficient arguments for the format.
 * Usually, an unchecked exception will be thrown.
 * If the format is exhausted while arguments remain,
 * the excess arguments are ignored.</p>
 *
 *<p>
 * The conversion characters and their meanings are:
 *</p>
 *<dl>
 * <dt>d,i<dd>The int argument is converted to a
 *        signed decimal in the style [-]dddd.  The
 *        precision specifies the minimum number of
 *        digits to appear;  if the value being
 *        converted can be represented in fewer
 *        digits, it will be expanded with leading
 *        zeros.  The default precision is 1.  The
 *        result of converting 0 with an explicit
 *        precision of 0 is no characters.
 * <dt>o<dd> The int argument is converted to unsigned
 *        octal format in the style ddddd.  The
 *        precision specifies the minimum number of
 *        digits to appear;  if the value being
 *        converted can be represented in fewer
 *        digits, it will be expanded with leading
 *        zeros.  The default precision is 1.  The
 *        result of converting 0 with an explicit
 *        precision of 0 is no characters.
 * <dt>x<dd> The int argument is converted to unsigned
 *        hexadecimal format in the style dddd;  the
 *        letters abcdef are used.  The precision
 *        specifies the minimum numberof digits to
 *        appear; if the value being converted can be
 *        represented in fewer digits, it will be
 *        expanded with leading zeros.  The default
 *        precision is 1.  The result of converting 0
 *        with an explicit precision of 0 is no
 *        characters.
 * <dt>X<dd> Behaves the same as the x conversion
 *        character except that letters ABCDEF are
 *        used instead of abcdef.
 * <dt>f<dd> The floating point number argument is
 *        written in decimal notation in the style
 *        [-]ddd.ddd, where the number of digits after
 *        the radix character (shown here as a decimal
 *        point) is equal to the precision
 *        specification.  A Locale is used to determine
 *        the radix character to use in this format.
 *        If the precision is omitted from the
 *        argument, six digits are written after the
 *        radix character;  if the precision is
 *        explicitly 0 and the # flag is not specified,
 *        no radix character appears.  If a radix
 *        character appears, at least 1 digit appears
 *        before it.  The value is rounded to the
 *        appropriate number of digits.
 * <dt>e,E<dd>The floating point number argument is
 *        written in the style [-]d.ddde{+-}dd
 *        (the symbols {+-} indicate either a plus or
 *        minus sign), where there is one digit before
 *        the radix character (shown here as a decimal
 *        point) and the number of digits after it is
 *        equal to the precision.  A Locale is used to
 *        determine the radix character to use in this
 *        format.  When the precision is missing, six
 *        digits are written after the radix character;
 *        if the precision is 0 and the # flag is not
 *        specified, no radix character appears.  The
 *        E conversion will produce a number with E
 *        instead of e introducing the exponent.  The
 *        exponent always contains at least two digits.
 *        However, if the value to be written requires
 *        an exponent greater than two digits,
 *        additional exponent digits are written as
 *        necessary.  The value is rounded to the
 *        appropriate number of digits.
 * <dt>g,G<dd>The floating point number argument is
 *        written in style f or e (or in sytle E in the
 *        case of a G conversion character), with the
 *        precision specifying the number of
 *        significant digits.  If the precision is
 *        zero, it is taken as one.  The style used
 *        depends on the value converted:  style e
 *        (or E) will be used only if the exponent
 *        resulting from the conversion is less than
 *        -4 or greater than or equal to the precision.
 *        Trailing zeros are removed from the result.
 *        A radix character appears only if it is
 *        followed by a digit.
 * <dt>c,C<dd>The integer argument is converted to a
 *        char and the result is written.
 *
 * <dt>s,S<dd>The argument is taken to be a string and
 *        bytes from the string are written until the
 *        end of the string or the number of bytes 
 *        indicated by the precision specification of
 *        the argument is reached.  If the precision
 *        is omitted from the argument, it is taken to
 *        be infinite, so all characters up to the end
 *        of the string are written.
 * <dt>%<dd>Write a % character;  no argument is
 *        converted.
 *</dl>
 *<p>
 * If a conversion specification does not match one of
 * the above forms, an IllegalArgumentException is
 * thrown and the instance of PrintfFormat is not
 * created.</p>
 *<p>
 * If a floating point value is the internal
 * representation for infinity, the output is
 * [+]Infinity, where Infinity is either Infinity or
 * Inf, depending on the desired output string length.
 * Printing of the sign follows the rules described
 * above.</p>
 *<p>
 * If a floating point value is the internal
 * representation for "not-a-number," the output is
 * [+]NaN.  Printing of the sign follows the rules
 * described above.</p>
 *<p>
 * In no case does a non-existent or small field width
 * cause truncation of a field;  if the result of a
 * conversion is wider than the field width, the field
 * is simply expanded to contain the conversion result.
 *</p>
 *<p>
 * The behavior is like printf.  One exception is that
 * the minimum number of exponent digits is 3 instead
 * of 2 for e and E formats when the optional L is used
 * before the e, E, g, or G conversion character.  The
 * optional L does not imply conversion to a long long
 * double. </p>
 * <p>
 * The biggest divergence from the C printf
 * specification is in the use of 16 bit characters.
 * This allows the handling of characters beyond the
 * small ASCII character set and allows the utility to
 * interoperate correctly with the rest of the Java
 * runtime environment.</p>
 *<p>
 * Omissions from the C printf specification are
 * numerous.  All the known omissions are present
 * because Java never uses bytes to represent
 * characters and does not have pointers:</p>
 *<ul>
 * <li>%c is the same as %C.
 * <li>%s is the same as %S.
 * <li>u, p, and n conversion characters. 
 * <li>%ws format.
 * <li>h modifier applied to an n conversion character.
 * <li>l (ell) modifier applied to the c, n, or s
 * conversion characters.
 * <li>ll (ell ell) modifier to d, i, o, u, x, or X
 * conversion characters.
 * <li>ll (ell ell) modifier to an n conversion
 * character.
 * <li>c, C, d,i,o,u,x, and X conversion characters
 * apply to Byte, Character, Short, Integer, Long
 * types.
 * <li>f, e, E, g, and G conversion characters apply
 * to Float and Double types.
 * <li>s and S conversion characters apply to String
 * types.
 * <li>All other reference types can be formatted
 * using the s or S conversion characters only.
 *</ul>
 * <p>
 * Most of this specification is quoted from the Unix
 * man page for the sprintf utility.</p>
 *
 * @author Allan Jacobs
 * @version 1
 * Release 1: Initial release.
 * Release 2: Asterisk field widths and precisions    
 *            %n$ and *m$
 *            Bug fixes
 *              g format fix (2 digits in e form corrupt)
 *              rounding in f format implemented
 *              round up when digit not printed is 5
 *              formatting of -0.0f
 *              round up/down when last digits are 50000...
 */
public class PrintfFormat {
  /**
   * Constructs an array of control specifications
   * possibly preceded, separated, or followed by
   * ordinary strings.  Control strings begin with
   * unpaired percent signs.  A pair of successive
   * percent signs designates a single percent sign in
   * the format.
   * @param fmtArg  Control string.
   * @exception IllegalArgumentException if the control
   * string is null, zero length, or otherwise
   * malformed.
   */
  public PrintfFormat(String fmtArg)
      throws IllegalArgumentException {
    this(Locale.getDefault(),fmtArg);
  }
  /**
   * Constructs an array of control specifications
   * possibly preceded, separated, or followed by
   * ordinary strings.  Control strings begin with
   * unpaired percent signs.  A pair of successive
   * percent signs designates a single percent sign in
   * the format.
   * @param fmtArg  Control string.
   * @exception IllegalArgumentException if the control
   * string is null, zero length, or otherwise
   * malformed.
   */
  public PrintfFormat(Locale locale,String fmtArg)
      throws IllegalArgumentException {
    dfs = new DecimalFormatSymbols(locale);
    int ePos=0;
    ConversionSpecification sFmt=null;
    String unCS = this.nonControl(fmtArg,0);
    if (unCS!=null) {
      sFmt = new ConversionSpecification();
      sFmt.setLiteral(unCS);
      vFmt.addElement(sFmt);
    }
    while(cPos!=-1 && cPos<fmtArg.length()) {
      for (ePos=cPos+1; ePos<fmtArg.length();
                    ePos++) {
        char c=0;
        c = fmtArg.charAt(ePos);
        if (c == 'i') break;
        if (c == 'd') break;
        if (c == 'f') break;
        if (c == 'g') break;
        if (c == 'G') break;
        if (c == 'o') break;
        if (c == 'x') break;
        if (c == 'X') break;
        if (c == 'e') break;
        if (c == 'E') break;
        if (c == 'c') break;
        if (c == 's') break;
        if (c == '%') break;
      }
      ePos=Math.min(ePos+1,fmtArg.length());
      sFmt = new ConversionSpecification(
        fmtArg.substring(cPos,ePos));
      vFmt.addElement(sFmt);
      unCS = this.nonControl(fmtArg,ePos);
      if (unCS!=null) {
        sFmt = new ConversionSpecification();
        sFmt.setLiteral(unCS);
        vFmt.addElement(sFmt);
      }
    }
  }
  /**
   * Return a substring starting at
   * <code>start</code> and ending at either the end
   * of the String <code>s</code>, the next unpaired
   * percent sign, or at the end of the String if the
   * last character is a percent sign.
   * @param s  Control string.
   * @param start Position in the string
   *     <code>s</code> to begin looking for the start
   *     of a control string.
   * @return the substring from the start position
   *     to the beginning of the control string.
   */
  private String nonControl(String s,int start) {
    String ret="";
    cPos=s.indexOf("%",start);
    if (cPos==-1) cPos=s.length();
    return s.substring(start,cPos);
  }
  /**
   * Format an array of objects.  Byte, Short,
   * Integer, Long, Float, Double, and Character
   * arguments are treated as wrappers for primitive
   * types.
   * @param o The array of objects to format.
   * @return  The formatted String.
   */
  public String sprintf(Object[] o) {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    int i=0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else {
        if (cs.isPositionalSpecification()) {
          i=cs.getArgumentPosition()-1;
          if (cs.isPositionalFieldWidth()) {
            int ifw=cs.getArgumentPositionForFieldWidth()-1;
            cs.setFieldWidthWithArg(((Integer)o[ifw]).intValue());
          }
          if (cs.isPositionalPrecision()) {
            int ipr=cs.getArgumentPositionForPrecision()-1;
            cs.setPrecisionWithArg(((Integer)o[ipr]).intValue());
          }
        }
        else {
          if (cs.isVariableFieldWidth()) {
            cs.setFieldWidthWithArg(((Integer)o[i]).intValue());
            i++;
          }
          if (cs.isVariablePrecision()) {
            cs.setPrecisionWithArg(((Integer)o[i]).intValue());
            i++;
          }
        }
        if (o[i] instanceof Byte)
          sb.append(cs.internalsprintf(
          ((Byte)o[i]).byteValue()));
        else if (o[i] instanceof Short)
          sb.append(cs.internalsprintf(
          ((Short)o[i]).shortValue()));
        else if (o[i] instanceof Integer)
          sb.append(cs.internalsprintf(
          ((Integer)o[i]).intValue()));
        else if (o[i] instanceof Long)
          sb.append(cs.internalsprintf(
          ((Long)o[i]).longValue()));
        else if (o[i] instanceof Float)
          sb.append(cs.internalsprintf(
          ((Float)o[i]).floatValue()));
        else if (o[i] instanceof Double)
          sb.append(cs.internalsprintf(
          ((Double)o[i]).doubleValue()));
        else if (o[i] instanceof Character)
          sb.append(cs.internalsprintf(
          ((Character)o[i]).charValue()));
        else if (o[i] instanceof String)
          sb.append(cs.internalsprintf(
          (String)o[i]));
        else
          sb.append(cs.internalsprintf(
          o[i]));
        if (!cs.isPositionalSpecification())
          i++;
      }
    }
    return sb.toString();
  }
  /**
   * Format nothing.  Just use the control string.
   * @return  the formatted String.
   */
  public String sprintf() {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
    }
    return sb.toString();
  }
  /**
   * Format an int.
   * @param x The int to format.
   * @return  The formatted String.
   * @exception IllegalArgumentException if the
   *     conversion character is f, e, E, g, G, s,
   *     or S.
   */
  public String sprintf(int x)
      throws IllegalArgumentException {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else sb.append(cs.internalsprintf(x));
    }
    return sb.toString();
  }
  /**
   * Format an long.
   * @param x The long to format.
   * @return  The formatted String.
   * @exception IllegalArgumentException if the
   *     conversion character is f, e, E, g, G, s,
   *     or S.
   */
  public String sprintf(long x)
      throws IllegalArgumentException {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else sb.append(cs.internalsprintf(x));
    }
    return sb.toString();
  }
  /**
   * Format a double.
   * @param x The double to format.
   * @return  The formatted String.
   * @exception IllegalArgumentException if the
   *     conversion character is c, C, s, S,
   *     d, d, x, X, or o.
   */
  public String sprintf(double x)
      throws IllegalArgumentException {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else sb.append(cs.internalsprintf(x));
    }
    return sb.toString();
  }
  /**
   * Format a String.
   * @param x The String to format.
   * @return  The formatted String.
   * @exception IllegalArgumentException if the
   *   conversion character is neither s nor S.
   */
  public String sprintf(String x)
      throws IllegalArgumentException {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else sb.append(cs.internalsprintf(x));
    }
    return sb.toString();
  }
  /**
   * Format an Object.  Convert wrapper types to
   * their primitive equivalents and call the
   * appropriate internal formatting method. Convert
   * Strings using an internal formatting method for
   * Strings. Otherwise use the default formatter
   * (use toString).
   * @param x the Object to format.
   * @return  the formatted String.
   * @exception IllegalArgumentException if the
   *    conversion character is inappropriate for
   *    formatting an unwrapped value.
   */
  public String sprintf(Object x)
      throws IllegalArgumentException {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else {
        if (x instanceof Byte)
          sb.append(cs.internalsprintf(
          ((Byte)x).byteValue()));
        else if (x instanceof Short)
          sb.append(cs.internalsprintf(
          ((Short)x).shortValue()));
        else if (x instanceof Integer)
          sb.append(cs.internalsprintf(
          ((Integer)x).intValue()));
        else if (x instanceof Long)
          sb.append(cs.internalsprintf(
          ((Long)x).longValue()));
        else if (x instanceof Float)
          sb.append(cs.internalsprintf(
          ((Float)x).floatValue()));
        else if (x instanceof Double)
          sb.append(cs.internalsprintf(
          ((Double)x).doubleValue()));
        else if (x instanceof Character)
          sb.append(cs.internalsprintf(
          ((Character)x).charValue()));
        else if (x instanceof String)
          sb.append(cs.internalsprintf(
          (String)x));
        else
          sb.append(cs.internalsprintf(x));
      }
    }
    return sb.toString();
  }
  /**
   *<p>
   * ConversionSpecification allows the formatting of
   * a single primitive or object embedded within a
   * string.  The formatting is controlled by a
   * format string.  Only one Java primitive or
   * object can be formatted at a time.
   *<p>
   * A format string is a Java string that contains
   * a control string.  The control string starts at
   * the first percent sign (%) in the string,
   * provided that this percent sign
   *<ol>
   *<li>is not escaped protected by a matching % or
   *     is not an escape % character,
   *<li>is not at the end of the format string, and
   *<li>precedes a sequence of characters that parses
   *     as a valid control string.
   *</ol>
   *<p>
   * A control string takes the form:
   *<pre> % ['-+ #0]* [0..9]* { . [0..9]* }+
   *                { [hlL] }+ [idfgGoxXeEcs]
   *</pre>
   *<p>
   * The behavior is like printf.  One (hopefully the
   * only) exception is that the minimum number of
   * exponent digits is 3 instead of 2 for e and E
   * formats when the optional L is used before the
   * e, E, g, or G conversion character.  The 
   * optional L does not imply conversion to a long
   * long double.
   */
  private class ConversionSpecification {
    /**
     * Constructor.  Used to prepare an instance
     * to hold a literal, not a control string.
     */
    ConversionSpecification() { }
    /**
     * Constructor for a conversion specification.
     * The argument must begin with a % and end
     * with the conversion character for the
     * conversion specification.
      * @param fmtArg  String specifying the
     *     conversion specification.
      * @exception IllegalArgumentException if the
     *     input string is null, zero length, or
     *     otherwise malformed.
     */
    ConversionSpecification(String fmtArg)
        throws IllegalArgumentException {
      if (fmtArg==null)
        throw new NullPointerException();
      if (fmtArg.length()==0)
        throw new IllegalArgumentException(
        "Control strings must have positive"+
        " lengths.");
      if (fmtArg.charAt(0)=='%') {
        fmt = fmtArg;
        pos=1;
        setArgPosition();
        setFlagCharacters();
        setFieldWidth();
        setPrecision();
        setOptionalHL();
        if (setConversionCharacter()) {
          if (pos==fmtArg.length()) {
            if(leadingZeros&&leftJustify)
              leadingZeros=false;
            if(precisionSet&&leadingZeros){
              if(conversionCharacter=='d'
              ||conversionCharacter=='i'
              ||conversionCharacter=='o'
              ||conversionCharacter=='x')
              {
                leadingZeros=false;
              }
            }
          }
          else
            throw new IllegalArgumentException(
            "Malformed conversion specification="+
            fmtArg);
        }
        else
          throw new IllegalArgumentException(
          "Malformed conversion specification="+
          fmtArg);
      }
      else
        throw new IllegalArgumentException(
        "Control strings must begin with %.");
    }
    /**
     * Set the String for this instance.
     * @param s the String to store.
     */
    void setLiteral(String s) {
      fmt = s;
    }
    /**
     * Get the String for this instance.  Translate
     * any escape sequences.
     *
     * @return s the stored String.
     */
    String getLiteral() {
      StringBuffer sb=new StringBuffer();
      int i=0;
      while (i<fmt.length()) {
        if (fmt.charAt(i)=='\\') {
          i++;
          if (i<fmt.length()) {
            char c=fmt.charAt(i);
            switch(c) {
            case 'a':
              sb.append((char)0x07);
              break;
            case 'b':
              sb.append('\b');
              break;
            case 'f':
              sb.append('\f');
              break;
            case 'n':
              sb.append(System.getProperty("line.separator"));
              break;
            case 'r':
              sb.append('\r');
              break;
            case 't':
              sb.append('\t');
              break;
            case 'v':
              sb.append((char)0x0b);
              break;
            case '\\':
              sb.append('\\');
              break;
            }
            i++;
          }
          else
            sb.append('\\');
        }
        else
          i++;
      }
      return fmt;
    }
    /**
     * Get the conversion character that tells what
     * type of control character this instance has.
     *
     * @return the conversion character.
     */
    char getConversionCharacter() {
      return conversionCharacter;
    }
    /**
     * Check whether the specifier has a variable
     * field width that is going to be set by an
     * argument.
     * @return <code>true</code> if the conversion
     *   uses an * field width; otherwise
     *   <code>false</code>.
     */
    boolean isVariableFieldWidth() {
      return variableFieldWidth;
    }
    /**
     * Set the field width with an argument.  A
     * negative field width is taken as a - flag
     * followed by a positive field width.
     * @param fw the field width.
     */
    void setFieldWidthWithArg(int fw) {
      if (fw<0) leftJustify = true;
      fieldWidthSet = true;
      fieldWidth = Math.abs(fw);
    }
    /**
     * Check whether the specifier has a variable
     * precision that is going to be set by an
     * argument.
     * @return <code>true</code> if the conversion
     *   uses an * precision; otherwise
     *   <code>false</code>.
     */
    boolean isVariablePrecision() {
      return variablePrecision;
    }
    /**
     * Set the precision with an argument.  A
     * negative precision will be changed to zero.
     * @param pr the precision.
     */
    void setPrecisionWithArg(int pr) {
      precisionSet = true;
      precision = Math.max(pr,0);
    }
    /**
     * Format an int argument using this conversion
      * specification.
     * @param s the int to format.
     * @return the formatted String.
     * @exception IllegalArgumentException if the
     *     conversion character is f, e, E, g, or G.
     */
    String internalsprintf(int s)
        throws IllegalArgumentException {
      String s2 = "";
      switch(conversionCharacter) {
      case 'd':
      case 'i':
        if (optionalh)
          s2 = printDFormat((short)s);
        else if (optionall)
          s2 = printDFormat((long)s);
        else
          s2 = printDFormat(s);
        break;
      case 'x':
      case 'X':
        if (optionalh)
          s2 = printXFormat((short)s);
        else if (optionall)
          s2 = printXFormat((long)s);
        else
          s2 = printXFormat(s);
        break;
      case 'o':
        if (optionalh)
          s2 = printOFormat((short)s);
        else if (optionall)
          s2 = printOFormat((long)s);
        else
          s2 = printOFormat(s);
        break;
      case 'c':
      case 'C':
        s2 = printCFormat((char)s);
        break;
      default:
        throw new IllegalArgumentException(
          "Cannot format a int with a format using a "+
          conversionCharacter+
          " conversion character.");
      }
      return s2;
    }
    /**
     * Format a long argument using this conversion
     * specification.
     * @param s the long to format.
     * @return the formatted String.
     * @exception IllegalArgumentException if the
     *     conversion character is f, e, E, g, or G.
     */
    String internalsprintf(long s)
        throws IllegalArgumentException {
      String s2 = "";
      switch(conversionCharacter) {
      case 'd':
      case 'i':
        if (optionalh)
          s2 = printDFormat((short)s);
        else if (optionall)
          s2 = printDFormat(s);
        else
          s2 = printDFormat((int)s);
        break;
      case 'x':
      case 'X':
        if (optionalh)
          s2 = printXFormat((short)s);
        else if (optionall)
          s2 = printXFormat(s);
        else
          s2 = printXFormat((int)s);
        break;
      case 'o':
        if (optionalh)
          s2 = printOFormat((short)s);
        else if (optionall)
          s2 = printOFormat(s);
        else
          s2 = printOFormat((int)s);
        break;
      case 'c':
      case 'C':
        s2 = printCFormat((char)s);
        break;
      default:
        throw new IllegalArgumentException(
        "Cannot format a long with a format using a "+
        conversionCharacter+" conversion character.");
      }
      return s2;
    }
    /**
     * Format a double argument using this conversion
     * specification.
     * @param s the double to format.
     * @return the formatted String.
     * @exception IllegalArgumentException if the
     *     conversion character is c, C, s, S, i, d,
     *     x, X, or o.
     */
    String internalsprintf(double s)
        throws IllegalArgumentException {
      String s2 = "";
      switch(conversionCharacter) {
      case 'f':
        s2 = printFFormat(s);
        break;
      case 'E':
      case 'e':
        s2 = printEFormat(s);
        break;
      case 'G':
      case 'g':
        s2 = printGFormat(s);
        break;
      default:
        throw new IllegalArgumentException("Cannot "+
        "format a double with a format using a "+
        conversionCharacter+" conversion character.");
      }
      return s2;
    }
    /**
     * Format a String argument using this conversion
     * specification.
     * @param s the String to format.
     * @return the formatted String.
     * @exception IllegalArgumentException if the
     *   conversion character is neither s nor S.
     */
    String internalsprintf(String s)
        throws IllegalArgumentException {
      String s2 = "";
      if(conversionCharacter=='s'
      || conversionCharacter=='S')
        s2 = printSFormat(s);
      else
        throw new IllegalArgumentException("Cannot "+
        "format a String with a format using a "+
        conversionCharacter+" conversion character.");
      return s2;
    }
    /**
     * Format an Object argument using this conversion
     * specification.
     * @param s the Object to format.
     * @return the formatted String.
     * @exception IllegalArgumentException if the
     *     conversion character is neither s nor S.
     */
    String internalsprintf(Object s) {
      String s2 = "";
      if(conversionCharacter=='s'
      || conversionCharacter=='S')
        s2 = printSFormat(s.toString());
      else
        throw new IllegalArgumentException(
          "Cannot format a String with a format using"+
          " a "+conversionCharacter+
          " conversion character.");
      return s2;
    }
    /**
     * For f format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  '+' character means that the conversion
     * will always begin with a sign (+ or -).  The
     * blank flag character means that a non-negative
     * input will be preceded with a blank.  If both
     * a '+' and a ' ' are specified, the blank flag
     * is ignored.  The '0' flag character implies that
     * padding to the field width will be done with
     * zeros instead of blanks.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the number of digits
     * to appear after the radix character.  Padding is
     * with trailing 0s.
     */
    private char[] fFormatDigits(double x) {
      // int defaultDigits=6;
      String sx,sxOut;
      int i,j,k;
      int n1In,n2In;
      int expon=0;
      boolean minusSign=false;
      if (x>0.0)
        sx = Double.toString(x);
      else if (x<0.0) {
        sx = Double.toString(-x);
        minusSign=true;
      }
      else {
        sx = Double.toString(x);
        if (sx.charAt(0)=='-') {
          minusSign=true;
          sx=sx.substring(1);
        }
      }
      int ePos = sx.indexOf('E');
      int rPos = sx.indexOf('.');
      if (rPos!=-1) n1In=rPos;
      else if (ePos!=-1) n1In=ePos;
      else n1In=sx.length();
      if (rPos!=-1) {
        if (ePos!=-1) n2In = ePos-rPos-1;
        else n2In = sx.length()-rPos-1;
      }
      else
        n2In = 0;
      if (ePos!=-1) {
        int ie=ePos+1;
        expon=0;
        if (sx.charAt(ie)=='-') {
          for (++ie; ie<sx.length(); ie++)
            if (sx.charAt(ie)!='0') break;
          if (ie<sx.length())
            expon=-Integer.parseInt(sx.substring(ie));
        }
        else {
          if (sx.charAt(ie)=='+') ++ie;
          for (; ie<sx.length(); ie++)
            if (sx.charAt(ie)!='0') break;
          if (ie<sx.length())
            expon=Integer.parseInt(sx.substring(ie));
        }
      }
      int p;
      if (precisionSet) p = precision;
      else p = defaultDigits-1;
      char[] ca1 = sx.toCharArray();
      char[] ca2 = new char[n1In+n2In];
      char[] ca3,ca4,ca5;
      for (j=0; j<n1In; j++)
        ca2[j] = ca1[j];
      i = j+1;
      for (k=0; k<n2In; j++,i++,k++)
        ca2[j] = ca1[i];
      if (n1In+expon<=0) {
        ca3 = new char[-expon+n2In];
        for (j=0,k=0; k<(-n1In-expon); k++,j++)
          ca3[j]='0';
        for (i=0; i<(n1In+n2In); i++,j++)
          ca3[j]=ca2[i];
      }
      else
        ca3 = ca2;
      boolean carry=false;
      if (p<-expon+n2In) {
        if (expon<0) i = p;
        else i = p+n1In;
        carry=checkForCarry(ca3,i);
        if (carry)
          carry=startSymbolicCarry(ca3,i-1,0);
      }
      if (n1In+expon<=0) {
        ca4 = new char[2+p];
        if (!carry) ca4[0]='0';
        else ca4[0]='1';
        if(alternateForm||!precisionSet||precision!=0){
          ca4[1]='.';
          for(i=0,j=2;i<Math.min(p,ca3.length);i++,j++)
            ca4[j]=ca3[i];
          for (; j<ca4.length; j++) ca4[j]='0';
        }
      }
      else {
        if (!carry) {
          if(alternateForm||!precisionSet
          ||precision!=0)
            ca4 = new char[n1In+expon+p+1];
          else
            ca4 = new char[n1In+expon];
          j=0;
        }
        else {
          if(alternateForm||!precisionSet
          ||precision!=0)
            ca4 = new char[n1In+expon+p+2];
          else
            ca4 = new char[n1In+expon+1];
          ca4[0]='1';
          j=1;
        }
        for (i=0; i<Math.min(n1In+expon,ca3.length); i++,j++)
          ca4[j]=ca3[i];
        for (; i<n1In+expon; i++,j++)
          ca4[j]='0';
        if(alternateForm||!precisionSet||precision!=0){
          ca4[j]='.'; j++;
          for (k=0; i<ca3.length && k<p; i++,j++,k++)
            ca4[j]=ca3[i];
          for (; j<ca4.length; j++) ca4[j]='0';
        }
      }
      int nZeros=0;
      if (!leftJustify && leadingZeros) {
        int xThousands=0;
        if (thousands) {
          int xlead=0;
          if (ca4[0]=='+'||ca4[0]=='-'||ca4[0]==' ')
            xlead=1;
          int xdp=xlead;
          for (; xdp<ca4.length; xdp++)
            if (ca4[xdp]=='.') break;
          xThousands=(xdp-xlead)/3;
        }
        if (fieldWidthSet)
          nZeros = fieldWidth-ca4.length;
        if ((!minusSign&&(leadingSign||leadingSpace))||minusSign)
          nZeros--;
        nZeros-=xThousands;
        if (nZeros<0) nZeros=0;
      }
      j=0;
      if ((!minusSign&&(leadingSign||leadingSpace))||minusSign) {
        ca5 = new char[ca4.length+nZeros+1];
        j++;
      }
      else
        ca5 = new char[ca4.length+nZeros];
      if (!minusSign) {
        if (leadingSign) ca5[0]='+';
        if (leadingSpace) ca5[0]=' ';
      }
      else
        ca5[0]='-';
      for (i=0; i<nZeros; i++,j++)
        ca5[j]='0';
      for (i=0; i<ca4.length; i++,j++) ca5[j]=ca4[i];
  
      int lead=0;
      if (ca5[0]=='+'||ca5[0]=='-'||ca5[0]==' ')
        lead=1;
      int dp=lead;
      for (; dp<ca5.length; dp++)
        if (ca5[dp]=='.') break;
      int nThousands=(dp-lead)/3;
      // Localize the decimal point.
      if (dp<ca5.length)
        ca5[dp]=dfs.getDecimalSeparator();
      char[] ca6 = ca5;
      if (thousands && nThousands>0) {
        ca6 = new char[ca5.length+nThousands+lead];
        ca6[0]=ca5[0];
        for (i=lead,k=lead; i<dp; i++) {
          if (i>0 && (dp-i)%3==0) {
            // ca6[k]=',';
            ca6[k]=dfs.getGroupingSeparator();
            ca6[k+1]=ca5[i];
            k+=2;
          }
          else {
            ca6[k]=ca5[i]; k++;
          }
        }
        for (; i<ca5.length; i++,k++) {
          ca6[k]=ca5[i];
		}
      }
      return ca6;
    }
	/**
	 * An intermediate routine on the way to creating
	 * an f format String.  The method decides whether
	 * the input double value is an infinity,
	 * not-a-number, or a finite double and formats
	 * each type of input appropriately.
	 * @param x the double value to be formatted.
	 * @return the converted double value.
	 */
    private String fFormatString(double x) {
      boolean noDigits=false;
      char[] ca6,ca7;
      if (Double.isInfinite(x)) {
        if (x==Double.POSITIVE_INFINITY) {
          if (leadingSign) ca6 = "+Inf".toCharArray();
          else if (leadingSpace)
            ca6 = " Inf".toCharArray();
          else ca6 = "Inf".toCharArray();
        }
        else
          ca6 = "-Inf".toCharArray();
        noDigits = true;
      }
      else if (Double.isNaN(x)) {
        if (leadingSign) ca6 = "+NaN".toCharArray();
        else if (leadingSpace)
          ca6 = " NaN".toCharArray();
        else ca6 = "NaN".toCharArray();
        noDigits = true;
      }
      else
        ca6 = fFormatDigits(x);
      ca7 = applyFloatPadding(ca6,false);
      return new String(ca7);
    }
    /**
     * For e format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  '+' character means that the conversion
     * will always begin with a sign (+ or -).  The
     * blank flag character means that a non-negative
     * input will be preceded with a blank.  If both a
     * '+' and a ' ' are specified, the blank flag is
     * ignored.  The '0' flag character implies that
     * padding to the field width will be done with
     * zeros instead of blanks.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear after the radix character.
     * Padding is with trailing 0s.
     *
     * The behavior is like printf.  One (hopefully the
     * only) exception is that the minimum number of
     * exponent digits is 3 instead of 2 for e and E
     * formats when the optional L is used before the
     * e, E, g, or G conversion character. The optional
     * L does not imply conversion to a long long
     * double.
     */
    private char[] eFormatDigits(double x,char eChar) {
      char[] ca1,ca2,ca3;
      // int defaultDigits=6;
      String sx,sxOut;
      int i,j,k,p;
      int n1In,n2In;
      int expon=0;
      int ePos,rPos,eSize;
      boolean minusSign=false;
      if (x>0.0)
        sx = Double.toString(x);
      else if (x<0.0) {
        sx = Double.toString(-x);
        minusSign=true;
      }
      else {
        sx = Double.toString(x);
        if (sx.charAt(0)=='-') {
          minusSign=true;
          sx=sx.substring(1);
        }
      }
      ePos = sx.indexOf('E');
      if (ePos==-1) ePos = sx.indexOf('e');
      rPos = sx.indexOf('.');
      if (rPos!=-1) n1In=rPos;
      else if (ePos!=-1) n1In=ePos;
      else n1In=sx.length();
      if (rPos!=-1) {
        if (ePos!=-1) n2In = ePos-rPos-1;
        else n2In = sx.length()-rPos-1;
      }
      else
        n2In = 0;
      if (ePos!=-1) {
        int ie=ePos+1;
        expon=0;
        if (sx.charAt(ie)=='-') {
          for (++ie; ie<sx.length(); ie++)
            if (sx.charAt(ie)!='0') break;
          if (ie<sx.length())
            expon=-Integer.parseInt(sx.substring(ie));
        }
        else {
          if (sx.charAt(ie)=='+') ++ie;
          for (; ie<sx.length(); ie++)
            if (sx.charAt(ie)!='0') break;
          if (ie<sx.length())
            expon=Integer.parseInt(sx.substring(ie));
        }
      }
      if (rPos!=-1) expon += rPos-1;
      if (precisionSet) p = precision;
      else p = defaultDigits-1;
      if (rPos!=-1 && ePos!=-1)
        ca1=(sx.substring(0,rPos)+
          sx.substring(rPos+1,ePos)).toCharArray();
      else if (rPos!=-1)
        ca1 = (sx.substring(0,rPos)+
            sx.substring(rPos+1)).toCharArray();
      else if (ePos!=-1)
        ca1 = sx.substring(0,ePos).toCharArray();
      else
        ca1 = sx.toCharArray();
      boolean carry=false;
      int i0=0;
      if (ca1[0]!='0')
        i0 = 0;
      else
        for (i0=0; i0<ca1.length; i0++)
          if (ca1[i0]!='0') break;
      if (i0+p<ca1.length-1) {
        carry=checkForCarry(ca1,i0+p+1);
        if (carry)
          carry = startSymbolicCarry(ca1,i0+p,i0);
        if (carry) {
          ca2 = new char[i0+p+1];
          ca2[i0]='1';
          for (j=0; j<i0; j++) ca2[j]='0';
          for (i=i0,j=i0+1; j<p+1; i++,j++)
            ca2[j] = ca1[i];
          expon++;
          ca1 = ca2;
        }
      }
      if (Math.abs(expon)<100 && !optionalL) eSize=4;
      else eSize=5;
      if (alternateForm||!precisionSet||precision!=0)
        ca2 = new char[2+p+eSize];
      else
        ca2 = new char[1+eSize];
      if (ca1[0]!='0') {
        ca2[0] = ca1[0];
        j=1;
      }
      else {
        for (j=1; j<(ePos==-1?ca1.length:ePos); j++)
          if (ca1[j]!='0') break;
        if ((ePos!=-1 && j<ePos)||
            (ePos==-1 && j<ca1.length)) {
          ca2[0] = ca1[j];
          expon -= j;
          j++;
        }
        else {
          ca2[0]='0';
          j=2;
        }
      }
      if (alternateForm||!precisionSet||precision!=0) {
        ca2[1] = '.';
        i=2;
      }
      else
        i=1;
      for (k=0; k<p && j<ca1.length; j++,i++,k++)
        ca2[i] = ca1[j];
      for (;i<ca2.length-eSize; i++)
        ca2[i] = '0';
      ca2[i++] = eChar;
      if (expon<0) ca2[i++]='-';
      else ca2[i++]='+';
      expon = Math.abs(expon);
      if (expon>=100) {
        switch(expon/100) {
        case 1: ca2[i]='1'; break;
        case 2: ca2[i]='2'; break;
        case 3: ca2[i]='3'; break;
        case 4: ca2[i]='4'; break;
        case 5: ca2[i]='5'; break;
        case 6: ca2[i]='6'; break;
        case 7: ca2[i]='7'; break;
        case 8: ca2[i]='8'; break;
        case 9: ca2[i]='9'; break;
        }
        i++;
      }
      switch((expon%100)/10) {
      case 0: ca2[i]='0'; break;
      case 1: ca2[i]='1'; break;
      case 2: ca2[i]='2'; break;
      case 3: ca2[i]='3'; break;
      case 4: ca2[i]='4'; break;
      case 5: ca2[i]='5'; break;
      case 6: ca2[i]='6'; break;
      case 7: ca2[i]='7'; break;
      case 8: ca2[i]='8'; break;
      case 9: ca2[i]='9'; break;
      }
      i++;
      switch(expon%10) {
      case 0: ca2[i]='0'; break;
      case 1: ca2[i]='1'; break;
      case 2: ca2[i]='2'; break;
      case 3: ca2[i]='3'; break;
      case 4: ca2[i]='4'; break;
      case 5: ca2[i]='5'; break;
      case 6: ca2[i]='6'; break;
      case 7: ca2[i]='7'; break;
      case 8: ca2[i]='8'; break;
      case 9: ca2[i]='9'; break;
      }
      int nZeros=0;
      if (!leftJustify && leadingZeros) {
        int xThousands=0;
        if (thousands) {
          int xlead=0;
          if (ca2[0]=='+'||ca2[0]=='-'||ca2[0]==' ')
            xlead=1;
          int xdp=xlead;
          for (; xdp<ca2.length; xdp++)
            if (ca2[xdp]=='.') break;
          xThousands=(xdp-xlead)/3;
        }
        if (fieldWidthSet)
          nZeros = fieldWidth-ca2.length;
        if ((!minusSign&&(leadingSign||leadingSpace))||minusSign)
          nZeros--;
        nZeros-=xThousands;
        if (nZeros<0) nZeros=0;
      }
      j=0;
      if ((!minusSign&&(leadingSign || leadingSpace))||minusSign) {
        ca3 = new char[ca2.length+nZeros+1];
        j++;
      }
      else
        ca3 = new char[ca2.length+nZeros];
      if (!minusSign) {
        if (leadingSign) ca3[0]='+';
        if (leadingSpace) ca3[0]=' ';
      }
      else
        ca3[0]='-';
      for (k=0; k<nZeros; j++,k++)
        ca3[j]='0';
      for (i=0; i<ca2.length && j<ca3.length; i++,j++)
        ca3[j]=ca2[i];
  
      int lead=0;
      if (ca3[0]=='+'||ca3[0]=='-'||ca3[0]==' ')
        lead=1;
      int dp=lead;
      for (; dp<ca3.length; dp++)
        if (ca3[dp]=='.') break;
      int nThousands=dp/3;
      // Localize the decimal point.
      if (dp < ca3.length)
        ca3[dp] = dfs.getDecimalSeparator();
      char[] ca4 = ca3;
      if (thousands && nThousands>0) {
        ca4 = new char[ca3.length+nThousands+lead];
        ca4[0]=ca3[0];
        for (i=lead,k=lead; i<dp; i++) {
          if (i>0 && (dp-i)%3==0) {
            // ca4[k]=',';
            ca4[k]=dfs.getGroupingSeparator();
            ca4[k+1]=ca3[i];
            k+=2;
          }
          else {
            ca4[k]=ca3[i]; k++;
          }
        }
        for (; i<ca3.length; i++,k++)
          ca4[k]=ca3[i];
      }
      return ca4;
    }
    /**
     * Check to see if the digits that are going to
     * be truncated because of the precision should
     * force a round in the preceding digits.
     * @param ca1 the array of digits
     * @param icarry the index of the first digit that
     *     is to be truncated from the print
     * @return <code>true</code> if the truncation forces
     *     a round that will change the print
     */
    private boolean checkForCarry(char[] ca1,int icarry) {
      boolean carry=false;
      if (icarry<ca1.length) {
        if (ca1[icarry]=='6'||ca1[icarry]=='7'
        ||ca1[icarry]=='8'||ca1[icarry]=='9') carry=true;
        else if (ca1[icarry]=='5') {
          int ii=icarry+1;
          for (;ii<ca1.length; ii++)
            if (ca1[ii]!='0') break;
          carry=ii<ca1.length;
          if (!carry&&icarry>0) {
            carry=(ca1[icarry-1]=='1'||ca1[icarry-1]=='3'
              ||ca1[icarry-1]=='5'||ca1[icarry-1]=='7'
              ||ca1[icarry-1]=='9');
          }
        }
      }
      return carry;
    }
    /**
     * Start the symbolic carry process.  The process
     * is not quite finished because the symbolic
     * carry may change the length of the string and
     * change the exponent (in e format).
     * @param cLast index of the last digit changed
     *     by the round
     * @param cFirst index of the first digit allowed
     *     to be changed by this phase of the round
     * @return <code>true</code> if the carry forces
     *     a round that will change the print still
     *     more
     */
    private boolean startSymbolicCarry(
              char[] ca,int cLast,int cFirst) {
      boolean carry=true;
      for (int i=cLast; carry && i>=cFirst; i--) {
        carry = false;
        switch(ca[i]) {
        case '0': ca[i]='1'; break;
        case '1': ca[i]='2'; break;
        case '2': ca[i]='3'; break;
        case '3': ca[i]='4'; break;
        case '4': ca[i]='5'; break;
        case '5': ca[i]='6'; break;
        case '6': ca[i]='7'; break;
        case '7': ca[i]='8'; break;
        case '8': ca[i]='9'; break;
        case '9': ca[i]='0'; carry=true; break;
        }
      }
      return carry;
    }
	/**
	 * An intermediate routine on the way to creating
	 * an e format String.  The method decides whether
	 * the input double value is an infinity,
	 * not-a-number, or a finite double and formats
	 * each type of input appropriately.
	 * @param x the double value to be formatted.
	 * @param eChar an 'e' or 'E' to use in the
	 *     converted double value.
	 * @return the converted double value.
	 */
    private String eFormatString(double x,char eChar) {
      boolean noDigits=false;
      char[] ca4,ca5;
      if (Double.isInfinite(x)) {
        if (x==Double.POSITIVE_INFINITY) {
          if (leadingSign) ca4 = "+Inf".toCharArray();
          else if (leadingSpace)
            ca4 = " Inf".toCharArray();
          else ca4 = "Inf".toCharArray();
        }
        else
          ca4 = "-Inf".toCharArray();
        noDigits = true;
      }
      else if (Double.isNaN(x)) {
        if (leadingSign) ca4 = "+NaN".toCharArray();
        else if (leadingSpace)
          ca4 = " NaN".toCharArray();
        else ca4 = "NaN".toCharArray();
        noDigits = true;
      }
      else
        ca4 = eFormatDigits(x,eChar);
      ca5 = applyFloatPadding(ca4,false);
      return new String(ca5);
    }
    /**
     * Apply zero or blank, left or right padding.
     * @param ca4 array of characters before padding is
     *     finished
     * @param noDigits NaN or signed Inf
     * @return a padded array of characters
     */
    private char[] applyFloatPadding(
          char[] ca4,boolean noDigits) {
      char[] ca5 = ca4;
      if (fieldWidthSet) {
        int i,j,nBlanks;
        if (leftJustify) {
          nBlanks = fieldWidth-ca4.length;
          if (nBlanks > 0) {
            ca5 = new char[ca4.length+nBlanks];
            for (i=0; i<ca4.length; i++)
              ca5[i] = ca4[i];
            for (j=0; j<nBlanks; j++,i++)
              ca5[i] = ' ';
          }
        }
        else if (!leadingZeros || noDigits) {
          nBlanks = fieldWidth-ca4.length;
          if (nBlanks > 0) {
            ca5 = new char[ca4.length+nBlanks];
            for (i=0; i<nBlanks; i++)
              ca5[i] = ' ';
            for (j=0; j<ca4.length; i++,j++)
              ca5[i] = ca4[j];
          }
        }
        else if (leadingZeros) {
          nBlanks = fieldWidth-ca4.length;
          if (nBlanks > 0) {
            ca5 = new char[ca4.length+nBlanks];
            i=0; j=0;
            if (ca4[0]=='-') { ca5[0]='-'; i++; j++; }
            for (int k=0; k<nBlanks; i++,k++)
              ca5[i] = '0';
            for (; j<ca4.length; i++,j++)
              ca5[i] = ca4[j];
          }
        }
      }
      return ca5;
    }
    /**
     * Format method for the f conversion character.
     * @param x the double to format.
     * @return the formatted String.
     */
    private String printFFormat(double x) {
      return fFormatString(x);
    }
    /**
     * Format method for the e or E conversion
     * character.
     * @param x the double to format.
     * @return the formatted String.
     */
    private String printEFormat(double x) {
      if (conversionCharacter=='e')
        return eFormatString(x,'e');
      else
        return eFormatString(x,'E');
    }
    /**
     * Format method for the g conversion character.
     *
     * For g format, the flag character '-', means that
     *  the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  '+' character means that the conversion
     * will always begin with a sign (+ or -).  The
     * blank flag character means that a non-negative
     * input will be preceded with a blank.  If both a
     * '+' and a ' ' are specified, the blank flag is
     * ignored.  The '0' flag character implies that
     * padding to the field width will be done with
     * zeros instead of blanks.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear after the radix character.
     * Padding is with trailing 0s.
     * @param x the double to format.
     * @return the formatted String.
     */
    private String printGFormat(double x) {
      String sx,sy,sz,ret;
      int savePrecision=precision;
      int i;
      char[] ca4,ca5;
      boolean noDigits=false;
      if (Double.isInfinite(x)) {
        if (x==Double.POSITIVE_INFINITY) {
          if (leadingSign) ca4 = "+Inf".toCharArray();
          else if (leadingSpace)
            ca4 = " Inf".toCharArray();
          else ca4 = "Inf".toCharArray();
        }
        else
          ca4 = "-Inf".toCharArray();
        noDigits = true;
      }
      else if (Double.isNaN(x)) {
        if (leadingSign) ca4 = "+NaN".toCharArray();
        else if (leadingSpace)
          ca4 = " NaN".toCharArray();
        else ca4 = "NaN".toCharArray();
        noDigits = true;
      }
      else {
        if (!precisionSet) precision=defaultDigits;
        if (precision==0) precision=1;
        int ePos=-1;
        if (conversionCharacter=='g') {
          sx = eFormatString(x,'e').trim();
          ePos=sx.indexOf('e');
        }
        else {
          sx = eFormatString(x,'E').trim();
          ePos=sx.indexOf('E');
        }
        i=ePos+1;
        int expon=0;
        if (sx.charAt(i)=='-') {
          for (++i; i<sx.length(); i++)
            if (sx.charAt(i)!='0') break;
          if (i<sx.length())
            expon=-Integer.parseInt(sx.substring(i));
        }
        else {
          if (sx.charAt(i)=='+') ++i;
          for (; i<sx.length(); i++)
            if (sx.charAt(i)!='0') break;
          if (i<sx.length())
            expon=Integer.parseInt(sx.substring(i));
        }
        // Trim trailing zeros.
        // If the radix character is not followed by
        // a digit, trim it, too.
        if (!alternateForm) {
          if (expon>=-4 && expon<precision)
            sy = fFormatString(x).trim();
          else
            sy = sx.substring(0,ePos);
          i=sy.length()-1;
          for (; i>=0; i--)
            if (sy.charAt(i)!='0') break;
          if (i>=0 && sy.charAt(i)=='.') i--;
          if (i==-1) sz="0";
          else if (!Character.isDigit(sy.charAt(i)))
            sz=sy.substring(0,i+1)+"0";
          else sz=sy.substring(0,i+1);
          if (expon>=-4 && expon<precision)
            ret=sz;
          else
            ret=sz+sx.substring(ePos);
        }
        else {
          if (expon>=-4 && expon<precision)
            ret = fFormatString(x).trim();
          else
            ret = sx;
        }
        // leading space was trimmed off during
        // construction
        if (leadingSpace) if (x>=0) ret = " "+ret;
        ca4 = ret.toCharArray();
      }
      // Pad with blanks or zeros.
      ca5 = applyFloatPadding(ca4,false);
      precision=savePrecision;
      return new String(ca5);
    }
    /**
     * Format method for the d conversion specifer and
     * short argument.
     *
     * For d format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  A '+' character means that the conversion
     * will always begin with a sign (+ or -).  The
     * blank flag character means that a non-negative
     * input will be preceded with a blank.  If both a
     * '+' and a ' ' are specified, the blank flag is
     * ignored.  The '0' flag character implies that
     * padding to the field width will be done with
     * zeros instead of blanks.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the short to format.
     * @return the formatted String.
     */
    private String printDFormat(short x) {
      return printDFormat(Short.toString(x));
    }
    /**
     * Format method for the d conversion character and
     * long argument.
     *
     * For d format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  A '+' character means that the conversion
     * will always begin with a sign (+ or -).  The
     * blank flag character means that a non-negative
     * input will be preceded with a blank.  If both a
     * '+' and a ' ' are specified, the blank flag is
     * ignored.  The '0' flag character implies that
     * padding to the field width will be done with
     * zeros instead of blanks.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the long to format.
     * @return the formatted String.
     */
    private String printDFormat(long x) {
      return printDFormat(Long.toString(x));
    }
    /**
     * Format method for the d conversion character and
     * int argument.
     *
     * For d format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  A '+' character means that the conversion
     * will always begin with a sign (+ or -).  The
     * blank flag character means that a non-negative
     * input will be preceded with a blank.  If both a
     * '+' and a ' ' are specified, the blank flag is
     * ignored.  The '0' flag character implies that
     * padding to the field width will be done with
     * zeros instead of blanks.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the int to format.
     * @return the formatted String.
     */
    private String printDFormat(int x) {
      return printDFormat(Integer.toString(x));
    }
    /**
     * Utility method for formatting using the d
     * conversion character.
     * @param sx the String to format, the result of
     *     converting a short, int, or long to a
     *     String.
     * @return the formatted String.
     */
    private String printDFormat(String sx) {
      int nLeadingZeros=0;
      int nBlanks=0,n=0;
      int i=0,jFirst=0;
      boolean neg = sx.charAt(0)=='-';
      if (sx.equals("0")&&precisionSet&&precision==0)
        sx="";
      if (!neg) {
        if (precisionSet && sx.length() < precision)
          nLeadingZeros = precision-sx.length();
      }
      else {
        if (precisionSet&&(sx.length()-1)<precision)
          nLeadingZeros = precision-sx.length()+1;
      }
      if (nLeadingZeros<0) nLeadingZeros=0;
      if (fieldWidthSet) {
        nBlanks = fieldWidth-nLeadingZeros-sx.length();
        if (!neg&&(leadingSign||leadingSpace))
          nBlanks--;
      }
      if (nBlanks<0) nBlanks=0;
      if (leadingSign) n++;
      else if (leadingSpace) n++;
      n += nBlanks;
      n += nLeadingZeros;
      n += sx.length();
      char[] ca = new char[n];
      if (leftJustify) {
        if (neg) ca[i++] = '-';
        else if (leadingSign) ca[i++] = '+';
        else if (leadingSpace) ca[i++] = ' ';
        char[] csx = sx.toCharArray();
        jFirst = neg?1:0;
        for (int j=0; j<nLeadingZeros; i++,j++) 
          ca[i]='0';
        for (int j=jFirst; j<csx.length; j++,i++)
          ca[i] = csx[j];
        for (int j=0; j<nBlanks; i++,j++)
          ca[i] = ' ';
      }
      else {
        if (!leadingZeros) {
          for (i=0; i<nBlanks; i++)
            ca[i] = ' ';
          if (neg) ca[i++] = '-';
          else if (leadingSign) ca[i++] = '+';
          else if (leadingSpace) ca[i++] = ' ';
        }
        else {
          if (neg) ca[i++] = '-';
          else if (leadingSign) ca[i++] = '+';
          else if (leadingSpace) ca[i++] = ' ';
          for (int j=0; j<nBlanks; j++,i++)
            ca[i] = '0';
        }
        for (int j=0; j<nLeadingZeros; j++,i++)
          ca[i] = '0';
        char[] csx = sx.toCharArray();
        jFirst = neg?1:0;
        for (int j=jFirst; j<csx.length; j++,i++)
          ca[i] = csx[j];
      }
      return new String(ca);
    }
    /**
     * Format method for the x conversion character and
     * short argument.
     *
     * For x format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  The '#' flag character means to lead with
     * '0x'.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the short to format.
     * @return the formatted String.
     */
    private String printXFormat(short x) {
      String sx=null;
      if (x == Short.MIN_VALUE)
        sx = "8000";
      else if (x < 0) {
        String t;
        if (x==Short.MIN_VALUE)
          t = "0";
        else {
          t = Integer.toString(
            (~(-x-1))^Short.MIN_VALUE,16);
          if (t.charAt(0)=='F'||t.charAt(0)=='f')
            t = t.substring(16,32);
        }
        switch (t.length()) {
        case 1:
          sx = "800"+t;
          break;
        case 2:
          sx = "80"+t;
          break;
        case 3:
          sx = "8"+t;
          break;
        case 4:
          switch (t.charAt(0)) {
          case '1':
            sx = "9"+t.substring(1,4);
            break;
          case '2':
            sx = "a"+t.substring(1,4);
            break;
          case '3':
            sx = "b"+t.substring(1,4);
            break;
          case '4':
            sx = "c"+t.substring(1,4);
            break;
          case '5':
            sx = "d"+t.substring(1,4);
            break;
          case '6':
            sx = "e"+t.substring(1,4);
            break;
          case '7':
            sx = "f"+t.substring(1,4);
            break;
          }
          break;
        }
      }
      else
        sx = Integer.toString((int)x,16);
      return printXFormat(sx);
    }
    /**
     * Format method for the x conversion character and
     * long argument.
     *
     * For x format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  The '#' flag character means to lead with
     * '0x'.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the long to format.
     * @return the formatted String.
     */
    private String printXFormat(long x) {
      String sx=null;
      if (x == Long.MIN_VALUE)
        sx = "8000000000000000";
      else if (x < 0) {
        String t = Long.toString(
          (~(-x-1))^Long.MIN_VALUE,16);
        switch (t.length()) {
        case 1:
          sx = "800000000000000"+t;
          break;
        case 2:
          sx = "80000000000000"+t;
          break;
        case 3:
          sx = "8000000000000"+t;
          break;
        case 4:
          sx = "800000000000"+t;
          break;
        case 5:
          sx = "80000000000"+t;
          break;
        case 6:
          sx = "8000000000"+t;
          break;
        case 7:
          sx = "800000000"+t;
          break;
        case 8:
          sx = "80000000"+t;
          break;
        case 9:
          sx = "8000000"+t;
          break;
        case 10:
          sx = "800000"+t;
          break;
        case 11:
          sx = "80000"+t;
          break;
        case 12:
          sx = "8000"+t;
          break;
        case 13:
          sx = "800"+t;
          break;
        case 14:
          sx = "80"+t;
          break;
        case 15:
          sx = "8"+t;
          break;
        case 16:
          switch (t.charAt(0)) {
          case '1':
            sx = "9"+t.substring(1,16);
            break;
          case '2':
            sx = "a"+t.substring(1,16);
            break;
          case '3':
            sx = "b"+t.substring(1,16);
            break;
          case '4':
            sx = "c"+t.substring(1,16);
            break;
          case '5':
            sx = "d"+t.substring(1,16);
            break;
          case '6':
            sx = "e"+t.substring(1,16);
            break;
          case '7':
            sx = "f"+t.substring(1,16);
            break;
          }
          break;
        }
      }
      else
        sx = Long.toString(x,16);
      return printXFormat(sx);
    }
    /**
     * Format method for the x conversion character and
     * int argument.
     *
     * For x format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  The '#' flag character means to lead with
     * '0x'.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the int to format.
     * @return the formatted String.
     */
    private String printXFormat(int x) {
      String sx=null;
      if (x == Integer.MIN_VALUE)
        sx = "80000000";
      else if (x < 0) {
        String t = Integer.toString(
          (~(-x-1))^Integer.MIN_VALUE,16);
        switch (t.length()) {
        case 1:
          sx = "8000000"+t;
          break;
        case 2:
          sx = "800000"+t;
          break;
        case 3:
          sx = "80000"+t;
          break;
        case 4:
          sx = "8000"+t;
          break;
        case 5:
          sx = "800"+t;
          break;
        case 6:
          sx = "80"+t;
          break;
        case 7:
          sx = "8"+t;
          break;
        case 8:
          switch (t.charAt(0)) {
          case '1':
            sx = "9"+t.substring(1,8);
            break;
          case '2':
            sx = "a"+t.substring(1,8);
            break;
          case '3':
            sx = "b"+t.substring(1,8);
            break;
          case '4':
            sx = "c"+t.substring(1,8);
            break;
          case '5':
            sx = "d"+t.substring(1,8);
            break;
          case '6':
            sx = "e"+t.substring(1,8);
            break;
          case '7':
            sx = "f"+t.substring(1,8);
            break;
          }
          break;
        }
      }
      else
        sx = Integer.toString(x,16);
      return printXFormat(sx);
    }
    /**
     * Utility method for formatting using the x
     * conversion character.
     * @param sx the String to format, the result of
     *     converting a short, int, or long to a
     *     String.
     * @return the formatted String.
     */
    private String printXFormat(String sx) {
      int nLeadingZeros = 0;
      int nBlanks = 0;
      if (sx.equals("0")&&precisionSet&&precision==0)
        sx="";
      if (precisionSet)
        nLeadingZeros = precision-sx.length();
      if (nLeadingZeros<0) nLeadingZeros=0;
      if (fieldWidthSet) {
        nBlanks = fieldWidth-nLeadingZeros-sx.length();
        if (alternateForm) nBlanks = nBlanks - 2;
      }
      if (nBlanks<0) nBlanks=0;
      int n=0;
      if (alternateForm) n+=2;
      n += nLeadingZeros;
      n += sx.length();
      n += nBlanks;
      char[] ca = new char[n];
      int i=0;
      if (leftJustify) {
        if (alternateForm) {
          ca[i++]='0'; ca[i++]='x';
        }
        for (int j=0; j<nLeadingZeros; j++,i++)
          ca[i]='0';
        char[] csx = sx.toCharArray();
        for (int j=0; j<csx.length; j++,i++)
          ca[i] = csx[j];
        for (int j=0; j<nBlanks; j++,i++)
          ca[i] = ' ';
      }
      else {
        if (!leadingZeros)
          for (int j=0; j<nBlanks; j++,i++)
            ca[i] = ' ';
        if (alternateForm) {
          ca[i++]='0'; ca[i++]='x';
        }
        if (leadingZeros)
          for (int j=0; j<nBlanks; j++,i++)
            ca[i] = '0';
        for (int j=0; j<nLeadingZeros; j++,i++)
          ca[i]='0';
        char[] csx = sx.toCharArray();
        for (int j=0; j<csx.length; j++,i++)
          ca[i] = csx[j];
      }
      String caReturn=new String(ca);
      if (conversionCharacter=='X')
        caReturn = caReturn.toUpperCase();
      return caReturn;
    }
    /**
     * Format method for the o conversion character and
     * short argument.
     *
     * For o format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the 
     * left.  The '#' flag character means that the
     * output begins with a leading 0 and the precision
     * is increased by 1.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the short to format.
     * @return the formatted String.
     */
    private String printOFormat(short x) {
      String sx=null;
      if (x == Short.MIN_VALUE)
        sx = "100000";
      else if (x < 0) {
        String t = Integer.toString(
          (~(-x-1))^Short.MIN_VALUE,8);
        switch (t.length()) {
        case 1:
          sx = "10000"+t;
          break;
        case 2:
          sx = "1000"+t;
          break;
        case 3:
          sx = "100"+t;
          break;
        case 4:
          sx = "10"+t;
          break;
        case 5:
          sx = "1"+t;
          break;
        }
      }
      else
        sx = Integer.toString((int)x,8);
      return printOFormat(sx);
    }
    /**
     * Format method for the o conversion character and
     * long argument.
     *
     * For o format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the 
     * left.  The '#' flag character means that the
     * output begins with a leading 0 and the precision
     * is increased by 1.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the long to format.
     * @return the formatted String.
     */
    private String printOFormat(long x) {
      String sx=null;
      if (x == Long.MIN_VALUE)
        sx = "1000000000000000000000";
      else if (x < 0) {
        String t = Long.toString(
          (~(-x-1))^Long.MIN_VALUE,8);
        switch (t.length()) {
        case 1:
          sx = "100000000000000000000"+t;
          break;
        case 2:
          sx = "10000000000000000000"+t;
          break;
        case 3:
          sx = "1000000000000000000"+t;
          break;
        case 4:
          sx = "100000000000000000"+t;
          break;
        case 5:
          sx = "10000000000000000"+t;
          break;
        case 6:
          sx = "1000000000000000"+t;
          break;
        case 7:
          sx = "100000000000000"+t;
          break;
        case 8:
          sx = "10000000000000"+t;
          break;
        case 9:
          sx = "1000000000000"+t;
          break;
        case 10:
          sx = "100000000000"+t;
          break;
        case 11:
          sx = "10000000000"+t;
          break;
        case 12:
          sx = "1000000000"+t;
          break;
        case 13:
          sx = "100000000"+t;
          break;
        case 14:
          sx = "10000000"+t;
          break;
        case 15:
          sx = "1000000"+t;
          break;
        case 16:
          sx = "100000"+t;
          break;
        case 17:
          sx = "10000"+t;
          break;
        case 18:
          sx = "1000"+t;
          break;
        case 19:
          sx = "100"+t;
          break;
        case 20:
          sx = "10"+t;
          break;
        case 21:
          sx = "1"+t;
          break;
        }
      }
      else
        sx = Long.toString(x,8);
      return printOFormat(sx);
    }
    /**
     * Format method for the o conversion character and
     * int argument.
     *
     * For o format, the flag character '-', means that
     * the output should be left justified within the
     * field.  The default is to pad with blanks on the
     * left.  The '#' flag character means that the
     * output begins with a leading 0 and the precision
     * is increased by 1.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is to
     * add no padding.  Padding is with blanks by
     * default.
     *
     * The precision, if set, is the minimum number of
     * digits to appear.  Padding is with leading 0s.
     * @param x the int to format.
     * @return the formatted String.
     */
    private String printOFormat(int x) {
      String sx=null;
      if (x == Integer.MIN_VALUE)
        sx = "20000000000";
      else if (x < 0) {
        String t = Integer.toString(
          (~(-x-1))^Integer.MIN_VALUE,8);
        switch (t.length()) {
        case 1:
          sx = "2000000000"+t;
          break;
        case 2:
          sx = "200000000"+t;
          break;
        case 3:
          sx = "20000000"+t;
          break;
        case 4:
          sx = "2000000"+t;
          break;
        case 5:
          sx = "200000"+t;
          break;
        case 6:
          sx = "20000"+t;
          break;
        case 7:
          sx = "2000"+t;
          break;
        case 8:
          sx = "200"+t;
          break;
        case 9:
          sx = "20"+t;
          break;
        case 10:
          sx = "2"+t;
          break;
        case 11:
          sx = "3"+t.substring(1);
          break;
        }
      }
      else
        sx = Integer.toString(x,8);
      return printOFormat(sx);
    }
    /**
     * Utility method for formatting using the o
     * conversion character.
     * @param sx the String to format, the result of
     *     converting a short, int, or long to a
     *     String.
     * @return the formatted String.
     */
    private String printOFormat(String sx) {
      int nLeadingZeros = 0;
      int nBlanks = 0;
      if (sx.equals("0")&&precisionSet&&precision==0)
        sx="";
      if (precisionSet)
        nLeadingZeros = precision-sx.length();
      if (alternateForm) nLeadingZeros++;
      if (nLeadingZeros<0) nLeadingZeros=0;
      if (fieldWidthSet)
        nBlanks = fieldWidth-nLeadingZeros-sx.length();
      if (nBlanks<0) nBlanks=0;
      int n=nLeadingZeros+sx.length()+nBlanks;
      char[] ca = new char[n];
      int i;
      if (leftJustify) {
        for (i=0; i<nLeadingZeros; i++) ca[i]='0';
        char[] csx = sx.toCharArray();
        for (int j=0; j<csx.length; j++,i++)
          ca[i] = csx[j];
        for (int j=0; j<nBlanks; j++,i++) ca[i] = ' ';
      }
      else {
        if (leadingZeros)
          for (i=0; i<nBlanks; i++) ca[i]='0';
        else
          for (i=0; i<nBlanks; i++) ca[i]=' ';
        for (int j=0; j<nLeadingZeros; j++,i++)
          ca[i]='0';
        char[] csx = sx.toCharArray();
        for (int j=0; j<csx.length; j++,i++)
          ca[i] = csx[j];
      }
      return new String(ca);
    }
    /**
     * Format method for the c conversion character and
     * char argument.
     *
     * The only flag character that affects c format is
     * the '-', meaning that the output should be left
     * justified within the field.  The default is to
     * pad with blanks on the left.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  Padding is with
     * blanks by default.  The default width is 1.
     *
     * The precision, if set, is ignored.
     * @param x the char to format.
     * @return the formatted String.
     */
    private String printCFormat(char x) {
      int nPrint = 1;
      int width = fieldWidth;
      if (!fieldWidthSet) width = nPrint;
      char[] ca = new char[width];
      int i=0;
      if (leftJustify) {
        ca[0] = x;
        for (i=1; i<=width-nPrint; i++) ca[i]=' ';
      }
      else {
        for (i=0; i<width-nPrint; i++) ca[i]=' ';
        ca[i] = x;
      }
      return new String(ca);
    }
    /**
     * Format method for the s conversion character and
     * String argument.
     *
     * The only flag character that affects s format is
     * the '-', meaning that the output should be left
     * justified within the field.  The default is to
     * pad with blanks on the left.
     *
     * The field width is treated as the minimum number
     * of characters to be printed.  The default is the
     * smaller of the number of characters in the the
     * input and the precision.  Padding is with blanks
     * by default.
     *
     * The precision, if set, specifies the maximum
     * number of characters to be printed from the
     * string.  A null digit string is treated
     * as a 0.  The default is not to set a maximum
     * number of characters to be printed.
     * @param x the String to format.
     * @return the formatted String.
     */
    private String printSFormat(String x) {
      int nPrint = x.length();
      int width = fieldWidth;
      if (precisionSet && nPrint>precision)
        nPrint=precision;
      if (!fieldWidthSet) width = nPrint;
      int n=0;
      if (width>nPrint) n+=width-nPrint;
      if (nPrint>=x.length()) n+= x.length();
      else n+= nPrint;
      char[] ca = new char[n];
      int i=0;
      if (leftJustify) {
        if (nPrint>=x.length()) {
          char[] csx = x.toCharArray();
          for (i=0; i<x.length(); i++) ca[i]=csx[i];
        }
        else {
          char[] csx =
            x.substring(0,nPrint).toCharArray();
          for (i=0; i<nPrint; i++) ca[i]=csx[i];
        }
        for (int j=0; j<width-nPrint; j++,i++)
          ca[i]=' ';
      }
      else {
        for (i=0; i<width-nPrint; i++) ca[i]=' ';
        if (nPrint>=x.length()) {
          char[] csx = x.toCharArray();
          for (int j=0; j<x.length(); i++,j++)
            ca[i]=csx[j];
        }
        else {
          char[] csx =
            x.substring(0,nPrint).toCharArray();
          for (int j=0; j<nPrint; i++,j++)
            ca[i]=csx[j];
        }
      }
      return new String(ca);
    }
    /**
     * Check for a conversion character.  If it is
     * there, store it.
     * @param x the String to format.
     * @return <code>true</code> if the conversion
     *     character is there, and
     *     <code>false</code> otherwise.
     */
    private boolean setConversionCharacter() {
      /* idfgGoxXeEcs */
      boolean ret = false;
      conversionCharacter='\0';
      if (pos < fmt.length()) {
        char c = fmt.charAt(pos);
        if (c=='i'||c=='d'||c=='f'||c=='g'||c=='G'
        || c=='o' || c=='x' || c=='X' || c=='e'
        || c=='E' || c=='c' || c=='s' || c=='%') {
          conversionCharacter = c;
          pos++;
          ret = true;
        }
      }
      return ret;
    }
    /**
     * Check for an h, l, or L in a format.  An L is
     * used to control the minimum number of digits
     * in an exponent when using floating point
     * formats.  An l or h is used to control
     * conversion of the input to a long or short,
     * respectively, before formatting.  If any of
     * these is present, store them.
     */
    private void setOptionalHL() {
      optionalh=false;
      optionall=false;
      optionalL=false;
      if (pos < fmt.length()) {
        char c = fmt.charAt(pos);
        if (c=='h') { optionalh=true; pos++; }
        else if (c=='l') { optionall=true; pos++; }
        else if (c=='L') { optionalL=true; pos++; }
      }
    }
    /**
     * Set the precision.
     */
    private void setPrecision() {
      int firstPos = pos;
      precisionSet = false;
      if (pos<fmt.length()&&fmt.charAt(pos)=='.') {
        pos++;
        if ((pos < fmt.length())
        && (fmt.charAt(pos)=='*')) {
          pos++;
          if (!setPrecisionArgPosition()) {
            variablePrecision = true;
            precisionSet = true;
          }
          return;
        }
        else {
          while (pos < fmt.length()) {
            char c = fmt.charAt(pos);
            if (Character.isDigit(c)) pos++;
            else break;
          }
          if (pos > firstPos+1) {
            String sz = fmt.substring(firstPos+1,pos);
            precision = Integer.parseInt(sz);
            precisionSet = true;
          }
        }
      }
    }
    /**
     * Set the field width.
     */
    private void setFieldWidth() {
      int firstPos = pos;
      fieldWidth = 0;
      fieldWidthSet = false;
      if ((pos < fmt.length())
      && (fmt.charAt(pos)=='*')) {
        pos++;
        if (!setFieldWidthArgPosition()) {
          variableFieldWidth = true;
          fieldWidthSet = true;
        }
      }
      else {
        while (pos < fmt.length()) {
          char c = fmt.charAt(pos);
          if (Character.isDigit(c)) pos++;
          else break;
        }
        if (firstPos<pos && firstPos < fmt.length()) {
          String sz = fmt.substring(firstPos,pos);
          fieldWidth = Integer.parseInt(sz);
          fieldWidthSet = true;
        }
      }
    }
    /**
     * Store the digits <code>n</code> in %n$ forms.
     */
    private void setArgPosition() {
      int xPos;
      for (xPos=pos; xPos<fmt.length(); xPos++) {
        if (!Character.isDigit(fmt.charAt(xPos)))
          break;
      }
      if (xPos>pos && xPos<fmt.length()) {
        if (fmt.charAt(xPos)=='$') {
          positionalSpecification = true;
          argumentPosition=
            Integer.parseInt(fmt.substring(pos,xPos));
          pos=xPos+1;
        }
      }
    }
    /**
     * Store the digits <code>n</code> in *n$ forms.
     */
    private boolean setFieldWidthArgPosition() {
      boolean ret=false;
      int xPos;
      for (xPos=pos; xPos<fmt.length(); xPos++) {
        if (!Character.isDigit(fmt.charAt(xPos)))
          break;
      }
      if (xPos>pos && xPos<fmt.length()) {
        if (fmt.charAt(xPos)=='$') {
          positionalFieldWidth = true;
          argumentPositionForFieldWidth=
            Integer.parseInt(fmt.substring(pos,xPos));
          pos=xPos+1;
          ret=true;
        }
      }
      return ret;
    }
    /**
     * Store the digits <code>n</code> in *n$ forms.
     */
    private boolean setPrecisionArgPosition() {
      boolean ret=false;
      int xPos;
      for (xPos=pos; xPos<fmt.length(); xPos++) {
        if (!Character.isDigit(fmt.charAt(xPos)))
          break;
      }
      if (xPos>pos && xPos<fmt.length()) {
        if (fmt.charAt(xPos)=='$') {
          positionalPrecision = true;
          argumentPositionForPrecision=
            Integer.parseInt(fmt.substring(pos,xPos));
          pos=xPos+1;
          ret=true;
        }
      }
      return ret;
    }
    boolean isPositionalSpecification() {
      return positionalSpecification;
    }
    int getArgumentPosition() { return argumentPosition; }
    boolean isPositionalFieldWidth() {
      return positionalFieldWidth;
    }
    int getArgumentPositionForFieldWidth() {
      return argumentPositionForFieldWidth;
    }
    boolean isPositionalPrecision() {
      return positionalPrecision;
    }
    int getArgumentPositionForPrecision() {
      return argumentPositionForPrecision;
    }
    /**
     * Set flag characters, one of '-+#0 or a space.
     */
    private void setFlagCharacters() {
      /* '-+ #0 */
      thousands = false;
      leftJustify = false;
      leadingSign = false;
      leadingSpace = false;
      alternateForm = false;
      leadingZeros = false;
      for ( ; pos < fmt.length(); pos++) {
        char c = fmt.charAt(pos);
        if (c == '\'') thousands = true;
        else if (c == '-') {
          leftJustify = true;
          leadingZeros = false;
        }
        else if (c == '+') {
          leadingSign = true;
          leadingSpace = false;
        }
        else if (c == ' ') {
          if (!leadingSign) leadingSpace = true;
        }
        else if (c == '#') alternateForm = true;
        else if (c == '0') {
          if (!leftJustify) leadingZeros = true;
        }
        else break;
      }
    }
    /**
     * The integer portion of the result of a decimal
     * conversion (i, d, u, f, g, or G) will be
     * formatted with thousands' grouping characters.
     * For other conversions the flag is ignored.
     */
    private boolean thousands = false;
    /**
     * The result of the conversion will be
     * left-justified within the field.
     */
    private boolean leftJustify = false;
    /**
     * The result of a signed conversion will always
     * begin with a sign (+ or -).
     */
    private boolean leadingSign = false;
    /**
     * Flag indicating that left padding with spaces is
     * specified.
     */
    private boolean leadingSpace = false;
    /**
     * For an o conversion, increase the precision to
     * force the first digit of the result to be a
     * zero.  For x (or X) conversions, a non-zero
     * result will have 0x (or 0X) prepended to it.
     * For e, E, f, g, or G conversions, the result
     * will always contain a radix character, even if
     * no digits follow the point.  For g and G
     * conversions, trailing zeros will not be removed
     * from the result.
     */
    private boolean alternateForm = false;
    /**
     * Flag indicating that left padding with zeroes is
     * specified.
     */
    private boolean leadingZeros = false;
    /**
     * Flag indicating that the field width is *.
     */
    private boolean variableFieldWidth = false;
    /**
     * If the converted value has fewer bytes than the
     * field width, it will be padded with spaces or
     * zeroes.
     */
    private int fieldWidth = 0;
    /**
     * Flag indicating whether or not the field width
     * has been set.
     */
    private boolean fieldWidthSet = false;
    /**
     * The minimum number of digits to appear for the
     * d, i, o, u, x, or X conversions.  The number of
     * digits to appear after the radix character for
     * the e, E, and f conversions.  The maximum number
     *  of significant digits for the g and G 
     * conversions.  The maximum number of bytes to be
     * printed from a string in s and S conversions.
     */
    private int precision = 0;
    /** Default precision. */
    private final static int defaultDigits=6; 
    /**
     * Flag indicating that the precision is *.
     */
    private boolean variablePrecision = false;
    /**
     * Flag indicating whether or not the precision has
     * been set.
     */
    private boolean precisionSet = false;
    /*
     */
    private boolean positionalSpecification=false;
    private int argumentPosition=0;
    private boolean positionalFieldWidth=false;
    private int argumentPositionForFieldWidth=0;
    private boolean positionalPrecision=false;
    private int argumentPositionForPrecision=0;
    /**
     * Flag specifying that a following d, i, o, u, x,
     * or X conversion character applies to a type
     * short int.
     */
    private boolean optionalh = false;
    /**
     * Flag specifying that a following d, i, o, u, x,
     * or X conversion character applies to a type lont
     * int argument.
     */
    private boolean optionall = false;
    /**
     * Flag specifying that a following e, E, f, g, or
     * G conversion character applies to a type double
     * argument.  This is a noop in Java.
     */
    private boolean optionalL = false;
    /** Control string type. */
    private char conversionCharacter = '\0';
    /**
     * Position within the control string.  Used by
     * the constructor.
     */
    private int pos = 0;
    /** Literal or control format string. */
    private String fmt;
  }
  /** Vector of control strings and format literals. */
  private Vector vFmt = new Vector();
  /** Character position.  Used by the constructor. */
  private int cPos=0;
  /** Character position.  Used by the constructor. */
  private DecimalFormatSymbols dfs=null;
}
