package java.util;

import java.io.BufferedWriter;

import java.io.Closeable;

import java.io.IOException;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FileNotFoundException;

import java.io.Flushable;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintStream;

import java.io.UnsupportedEncodingException;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.math.MathContext;

import java.math.RoundingMode;

import java.nio.charset.Charset;

import java.nio.charset.IllegalCharsetNameException;

import java.nio.charset.UnsupportedCharsetException;

import java.text.DateFormatSymbols;

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.text.NumberFormat;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import sun.misc.FpUtils;

import sun.misc.DoubleConsts;

import sun.misc.FormattedFloatingDecimal;

public final class Formatter implements Closeable, Flushable {

private Appendable a;

private final Locale l;

private IOException lastException;

private final char zero;

private static double scaleUp;

// 1 (sign) + 19 (max # sig digits) + 1 ('.') + 1 ('e') + 1 (sign)

// + 3 (max # exp digits) + 4 (error) = 30

private static final int MAX_FD_CHARS = 30;

/**

private static Charset toCharset(String csn)

throws UnsupportedEncodingException

{

Objects.requireNonNull(csn, "charsetName");

try {

return Charset.forName(csn);

} catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {

// UnsupportedEncodingException should be thrown

throw new UnsupportedEncodingException(csn);

}

}

private static final Appendable nonNullAppendable(Appendable a) {

if (a == null)

return new StringBuilder();

return a;

}

/* Private constructors */

private Formatter(Locale l, Appendable a) {

this.a = a;

this.l = l;

this.zero = getZero(l);

}

private Formatter(Charset charset, Locale l, File file)

throws FileNotFoundException

{

this(l,

new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset)));

}

/**

public Formatter() {

this(Locale.getDefault(Locale.Category.FORMAT), new StringBuilder());

}

/**

public Formatter(Appendable a) {

this(Locale.getDefault(Locale.Category.FORMAT), nonNullAppendable(a));

}

/**

public Formatter(Locale l) {

this(l, new StringBuilder());

}

/**

public Formatter(Appendable a, Locale l) {

this(l, nonNullAppendable(a));

}

/**

public Formatter(String fileName) throws FileNotFoundException {

this(Locale.getDefault(Locale.Category.FORMAT),

new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))));

}

/**

public Formatter(String fileName, String csn)

throws FileNotFoundException, UnsupportedEncodingException

{

this(fileName, csn, Locale.getDefault(Locale.Category.FORMAT));

}

/**

public Formatter(String fileName, String csn, Locale l)

throws FileNotFoundException, UnsupportedEncodingException

{

this(toCharset(csn), l, new File(fileName));

}

/**

public Formatter(File file) throws FileNotFoundException {

this(Locale.getDefault(Locale.Category.FORMAT),

new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))));

}

/**

public Formatter(File file, String csn)

throws FileNotFoundException, UnsupportedEncodingException

{

this(file, csn, Locale.getDefault(Locale.Category.FORMAT));

}

/**

public Formatter(File file, String csn, Locale l)

throws FileNotFoundException, UnsupportedEncodingException

{

this(toCharset(csn), l, file);

}

/**

public Formatter(PrintStream ps) {

this(Locale.getDefault(Locale.Category.FORMAT),

(Appendable)Objects.requireNonNull(ps));

}

/**

public Formatter(OutputStream os) {

this(Locale.getDefault(Locale.Category.FORMAT),

new BufferedWriter(new OutputStreamWriter(os)));

}

/**

public Formatter(OutputStream os, String csn)

throws UnsupportedEncodingException

{

this(os, csn, Locale.getDefault(Locale.Category.FORMAT));

}

/**

public Formatter(OutputStream os, String csn, Locale l)

throws UnsupportedEncodingException

{

this(l, new BufferedWriter(new OutputStreamWriter(os, csn)));

}

private static char getZero(Locale l) {

if ((l != null) && !l.equals(Locale.US)) {

DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l);

return dfs.getZeroDigit();

} else {

return '0';

}

}

/**

public Locale locale() {

ensureOpen();

return l;

}

/**

public Appendable out() {

ensureOpen();

return a;

}

/**

public String toString() {

ensureOpen();

return a.toString();

}

/**

public void flush() {

ensureOpen();

if (a instanceof Flushable) {

try {

((Flushable)a).flush();

} catch (IOException ioe) {

lastException = ioe;

}

}

}

/**

public void close() {

if (a == null)

return;

try {

if (a instanceof Closeable)

((Closeable)a).close();

} catch (IOException ioe) {

lastException = ioe;

} finally {

a = null;

}

}

private void ensureOpen() {

if (a == null)

throw new FormatterClosedException();

}

/**

public IOException ioException() {

return lastException;

}

/**

public Formatter format(String format, Object ... args) {

return format(l, format, args);

}

/**

public Formatter format(Locale l, String format, Object ... args) {

ensureOpen();

// index of last argument referenced

int last = -1;

// last ordinary index

int lasto = -1;

FormatString[] fsa = parse(format);

for (int i = 0; i < fsa.length; i++) {

FormatString fs = fsa[i];

int index = fs.index();

try {

switch (index) {

case -2: // fixed string, "%n", or "%%"

fs.print(null, l);

break;

case -1: // relative index

if (last < 0 || (args != null && last > args.length - 1))

throw new MissingFormatArgumentException(fs.toString());

fs.print((args == null ? null : args[last]), l);

break;

case 0: // ordinary index

lasto++;

last = lasto;

if (args != null && lasto > args.length - 1)

throw new MissingFormatArgumentException(fs.toString());

fs.print((args == null ? null : args[lasto]), l);

break;

default: // explicit index

last = index - 1;

if (args != null && last > args.length - 1)

throw new MissingFormatArgumentException(fs.toString());

fs.print((args == null ? null : args[last]), l);

break;

}

} catch (IOException x) {

lastException = x;

}

}

return this;

}

// %[argument_index$][flags][width][.precision][t]conversion

private static final String formatSpecifier

= "%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])";

private static Pattern fsPattern = Pattern.compile(formatSpecifier);

/**

private FormatString[] parse(String s) {

ArrayList<FormatString> al = new ArrayList<>();

Matcher m = fsPattern.matcher(s);

for (int i = 0, len = s.length(); i < len; ) {

if (m.find(i)) {

// Anything between the start of the string and the beginning

// of the format specifier is either fixed text or contains

// an invalid format string.

if (m.start() != i) {

// Make sure we didn't miss any invalid format specifiers

checkText(s, i, m.start());

// Assume previous characters were fixed text

al.add(new FixedString(s.substring(i, m.start())));

}

al.add(new FormatSpecifier(m));

i = m.end();

} else {

// No more valid format specifiers. Check for possible invalid

// format specifiers.

checkText(s, i, len);

// The rest of the string is fixed text

al.add(new FixedString(s.substring(i)));

break;

}

}

return al.toArray(new FormatString[al.size()]);

}

private static void checkText(String s, int start, int end) {

for (int i = start; i < end; i++) {

// Any '%' found in the region starts an invalid format specifier.

if (s.charAt(i) == '%') {

char c = (i == end - 1) ? '%' : s.charAt(i + 1);

throw new UnknownFormatConversionException(String.valueOf(c));

}

}

}

private interface FormatString {

int index();

void print(Object arg, Locale l) throws IOException;

String toString();

}

private class FixedString implements FormatString {

private String s;

FixedString(String s) { this.s = s; }

public int index() { return -2; }

public void print(Object arg, Locale l)

throws IOException { a.append(s); }

public String toString() { return s; }

}

public enum BigDecimalLayoutForm { SCIENTIFIC, DECIMAL_FLOAT };

private class FormatSpecifier implements FormatString {

private int index = -1;

private Flags f = Flags.NONE;

private int width;

private int precision;

private boolean dt = false;

private char c;

private int index(String s) {

if (s != null) {

try {

index = Integer.parseInt(s.substring(0, s.length() - 1));

} catch (NumberFormatException x) {

assert(false);

}

} else {

index = 0;

}

return index;

}

public int index() {

return index;

}

private Flags flags(String s) {

f = Flags.parse(s);

if (f.contains(Flags.PREVIOUS))

index = -1;

return f;

}

Flags flags() {

return f;

}

private int width(String s) {

width = -1;

if (s != null) {

try {

width = Integer.parseInt(s);

if (width < 0)

throw new IllegalFormatWidthException(width);

} catch (NumberFormatException x) {

assert(false);

}

}

return width;

}

int width() {

return width;

}

private int precision(String s) {

precision = -1;

if (s != null) {

try {

// remove the '.'

precision = Integer.parseInt(s.substring(1));

if (precision < 0)

throw new IllegalFormatPrecisionException(precision);

} catch (NumberFormatException x) {

assert(false);

}

}

return precision;

}

int precision() {

return precision;

}

private char conversion(String s) {

c = s.charAt(0);

if (!dt) {

if (!Conversion.isValid(c))

throw new UnknownFormatConversionException(String.valueOf(c));

if (Character.isUpperCase(c))

f.add(Flags.UPPERCASE);

c = Character.toLowerCase(c);

if (Conversion.isText(c))

index = -2;

}

return c;

}

private char conversion() {

return c;

}

FormatSpecifier(Matcher m) {

int idx = 1;

index(m.group(idx++));

flags(m.group(idx++));

width(m.group(idx++));

precision(m.group(idx++));

String tT = m.group(idx++);

if (tT != null) {

dt = true;

if (tT.equals("T"))

f.add(Flags.UPPERCASE);

}

conversion(m.group(idx));

if (dt)

checkDateTime();

else if (Conversion.isGeneral(c))

checkGeneral();

else if (Conversion.isCharacter(c))

checkCharacter();

else if (Conversion.isInteger(c))

checkInteger();

else if (Conversion.isFloat(c))

checkFloat();

else if (Conversion.isText(c))

checkText();

else

throw new UnknownFormatConversionException(String.valueOf(c));

}

public void print(Object arg, Locale l) throws IOException {

if (dt) {

printDateTime(arg, l);

return;

}

switch(c) {

case Conversion.DECIMAL_INTEGER:

case Conversion.OCTAL_INTEGER:

case Conversion.HEXADECIMAL_INTEGER:

printInteger(arg, l);

break;

case Conversion.SCIENTIFIC:

case Conversion.GENERAL:

case Conversion.DECIMAL_FLOAT:

case Conversion.HEXADECIMAL_FLOAT:

printFloat(arg, l);

break;

case Conversion.CHARACTER:

case Conversion.CHARACTER_UPPER:

printCharacter(arg);

break;

case Conversion.BOOLEAN:

printBoolean(arg);

break;

case Conversion.STRING:

printString(arg, l);

break;

case Conversion.HASHCODE:

printHashCode(arg);

break;

case Conversion.LINE_SEPARATOR:

a.append(System.lineSeparator());

break;

case Conversion.PERCENT_SIGN:

a.append('%');

break;

default:

assert false;

}

}

private void printInteger(Object arg, Locale l) throws IOException {

if (arg == null)

print("null");

else if (arg instanceof Byte)

print(((Byte)arg).byteValue(), l);

else if (arg instanceof Short)

print(((Short)arg).shortValue(), l);

else if (arg instanceof Integer)

print(((Integer)arg).intValue(), l);

else if (arg instanceof Long)

print(((Long)arg).longValue(), l);

else if (arg instanceof BigInteger)

print(((BigInteger)arg), l);

else

failConversion(c, arg);

}

private void printFloat(Object arg, Locale l) throws IOException {

if (arg == null)

print("null");

else if (arg instanceof Float)

print(((Float)arg).floatValue(), l);

else if (arg instanceof Double)

print(((Double)arg).doubleValue(), l);

else if (arg instanceof BigDecimal)

print(((BigDecimal)arg), l);

else

failConversion(c, arg);

}

private void printDateTime(Object arg, Locale l) throws IOException {

if (arg == null) {

print("null");

return;

}

Calendar cal = null;

// Instead of Calendar.setLenient(true), perhaps we should

// wrap the IllegalArgumentException that might be thrown?

if (arg instanceof Long) {

// Note that the following method uses an instance of the

// default time zone (TimeZone.getDefaultRef().

cal = Calendar.getInstance(l == null ? Locale.US : l);

cal.setTimeInMillis((Long)arg);

} else if (arg instanceof Date) {

// Note that the following method uses an instance of the

// default time zone (TimeZone.getDefaultRef().

cal = Calendar.getInstance(l == null ? Locale.US : l);

cal.setTime((Date)arg);

} else if (arg instanceof Calendar) {

cal = (Calendar) ((Calendar)arg).clone();

cal.setLenient(true);

} else {

failConversion(c, arg);

}

// Use the provided locale so that invocations of

// localizedMagnitude() use optimizations for null.

print(cal, c, l);

}

private void printCharacter(Object arg) throws IOException {

if (arg == null) {

print("null");

return;

}

String s = null;

if (arg instanceof Character) {

s = ((Character)arg).toString();

} else if (arg instanceof Byte) {

byte i = ((Byte)arg).byteValue();

if (Character.isValidCodePoint(i))

s = new String(Character.toChars(i));

else

throw new IllegalFormatCodePointException(i);

} else if (arg instanceof Short) {

short i = ((Short)arg).shortValue();

if (Character.isValidCodePoint(i))

s = new String(Character.toChars(i));

else

throw new IllegalFormatCodePointException(i);

} else if (arg instanceof Integer) {

int i = ((Integer)arg).intValue();

if (Character.isValidCodePoint(i))

s = new String(Character.toChars(i));

else

throw new IllegalFormatCodePointException(i);

} else {

failConversion(c, arg);

}

print(s);

}

private void printString(Object arg, Locale l) throws IOException {

if (arg instanceof Formattable) {

Formatter fmt = Formatter.this;

if (fmt.locale() != l)

fmt = new Formatter(fmt.out(), l);

((Formattable)arg).formatTo(fmt, f.valueOf(), width, precision);

} else {

if (f.contains(Flags.ALTERNATE))

failMismatch(Flags.ALTERNATE, 's');

if (arg == null)

print("null");

else

print(arg.toString());

}

}

private void printBoolean(Object arg) throws IOException {

String s;

if (arg != null)

s = ((arg instanceof Boolean)

? ((Boolean)arg).toString()

: Boolean.toString(true));

else

s = Boolean.toString(false);

print(s);

}

private void printHashCode(Object arg) throws IOException {

String s = (arg == null

? "null"

: Integer.toHexString(arg.hashCode()));

print(s);

}

private void print(String s) throws IOException {

if (precision != -1 && precision < s.length())

s = s.substring(0, precision);

if (f.contains(Flags.UPPERCASE))

s = s.toUpperCase();

a.append(justify(s));

}

private String justify(String s) {

if (width == -1)

return s;

StringBuilder sb = new StringBuilder();

boolean pad = f.contains(Flags.LEFT_JUSTIFY);

int sp = width - s.length();

if (!pad)

for (int i = 0; i < sp; i++) sb.append(' ');

sb.append(s);

if (pad)

for (int i = 0; i < sp; i++) sb.append(' ');

return sb.toString();

}

public String toString() {

StringBuilder sb = new StringBuilder('%');

// Flags.UPPERCASE is set internally for legal conversions.

Flags dupf = f.dup().remove(Flags.UPPERCASE);

sb.append(dupf.toString());

if (index > 0)

sb.append(index).append('$');

if (width != -1)

sb.append(width);

if (precision != -1)

sb.append('.').append(precision);

if (dt)

sb.append(f.contains(Flags.UPPERCASE) ? 'T' : 't');

sb.append(f.contains(Flags.UPPERCASE)

? Character.toUpperCase(c) : c);

return sb.toString();

}

private void checkGeneral() {

if ((c == Conversion.BOOLEAN || c == Conversion.HASHCODE)

&& f.contains(Flags.ALTERNATE))

failMismatch(Flags.ALTERNATE, c);

// '-' requires a width

if (width == -1 && f.contains(Flags.LEFT_JUSTIFY))

throw new MissingFormatWidthException(toString());

checkBadFlags(Flags.PLUS, Flags.LEADING_SPACE, Flags.ZERO_PAD,

Flags.GROUP, Flags.PARENTHESES);

}

private void checkDateTime() {

if (precision != -1)

throw new IllegalFormatPrecisionException(precision);

if (!DateTime.isValid(c))

throw new UnknownFormatConversionException("t" + c);

checkBadFlags(Flags.ALTERNATE, Flags.PLUS, Flags.LEADING_SPACE,

Flags.ZERO_PAD, Flags.GROUP, Flags.PARENTHESES);

// '-' requires a width

if (width == -1 && f.contains(Flags.LEFT_JUSTIFY))

throw new MissingFormatWidthException(toString());

}

private void checkCharacter() {

if (precision != -1)

throw new IllegalFormatPrecisionException(precision);

checkBadFlags(Flags.ALTERNATE, Flags.PLUS, Flags.LEADING_SPACE,

Flags.ZERO_PAD, Flags.GROUP, Flags.PARENTHESES);

// '-' requires a width

if (width == -1 && f.contains(Flags.LEFT_JUSTIFY))

throw new MissingFormatWidthException(toString());

}

private void checkInteger() {

checkNumeric();

if (precision != -1)

throw new IllegalFormatPrecisionException(precision);

if (c == Conversion.DECIMAL_INTEGER)

checkBadFlags(Flags.ALTERNATE);

else if (c == Conversion.OCTAL_INTEGER)

checkBadFlags(Flags.GROUP);

else

checkBadFlags(Flags.GROUP);

}

private void checkBadFlags(Flags ... badFlags) {

for (int i = 0; i < badFlags.length; i++)

if (f.contains(badFlags[i]))

failMismatch(badFlags[i], c);

}

private void checkFloat() {

checkNumeric();