# Java 版本的 Sprintf 字符串格式化函数

// String s  = new PrintfFormat("a = %02d").sprintf(new Object[]{new Integer(2)});// System.out.println(s);//// (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;
alternateForm = false;
for ( ; pos < fmt.length(); pos++) {
char c = fmt.charAt(pos);
if (c == '/'') thousands = true;
else if (c == '-') {
leftJustify = true;
}
else if (c == '+') {
}
else if (c == ' ') {
}
else if (c == '#') alternateForm = true;
else if (c == '0') {
}
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 -).
*/
/**
* Flag indicating that left padding with spaces is
* specified.
*/
/**
* 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.
*/
/**
* 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
*/
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;
}
• 本文已收录于以下专栏：

## Javascript 版本的 Sprintf 字符串格式化函数

/*** sprintf.js -- POSIX sprintf(3) style formatting function for JavaScript** Copyright (c) 2006-...
• subchen
• 2007年09月19日 10:27
• 1957

## 【Python_Demo_1】使用Python实现C语言中sprintf()格式化字符串写入函数

#coding = utf-8 #===================================================================================...
• maweifei
• 2016年11月16日 11:32
• 1836

## 格式化字符串漏洞简介

• PrettyDay
• 2015年12月20日 23:27
• 4614

## php中的sprintf()函数的format格式字符串

• beyond__devil
• 2016年10月04日 22:54
• 4963

## sprintf为什么有安全隐患

• wangfenglin995
• 2015年06月29日 23:12
• 2104

## python字符串的格式化，百分号方法，s,d,f,sep，键等

• ifubing
• 2018年02月01日 11:05
• 12

## java的String.format()函数

JAVA字符串格式化-String.format()的使用 参考url:http://blog.csdn.net/lonely_fireworks/article/details/79621...
• masterShaw
• 2016年11月18日 13:53
• 4041

## 字符串格式化 sprintf

sprintf 是个变参函数，定义如下： int sprintf( char *buffer, const char *format [, argument] … );除了前两个参数类型固定外，后面...
• qq_34882983
• 2016年11月07日 23:20
• 1200

## sprintf 字符串格式化

It may be old-fashioned, but I still find printf (and sprintf and _vsnprintf) incredibly useful, bot...
• guang670248515
• 2017年04月15日 21:11
• 488

## sprintf 字符串格式化

It may be old-fashioned, but I still find printf (and sprintf and _vsnprintf) incredibly useful, bot...
• xjbzju
• 2011年07月03日 20:09
• 3648

举报原因： 您举报文章：Java 版本的 Sprintf 字符串格式化函数 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)