0N/A

763N/Apackage java.util;

0N/A

0N/Aimport java.nio.file.Path;

0N/Aimport java.nio.file.Files;

0N/Aimport java.util.regex.*;

0N/Aimport java.io.*;

0N/Aimport java.math.*;

0N/Aimport java.nio.*;

0N/Aimport java.nio.channels.*;

0N/Aimport java.nio.charset.*;

0N/Aimport java.text.*;

0N/Aimport java.util.Locale;

0N/Aimport sun.misc.LRUCache;

0N/A

public final class Scanner implements Iterator<String>, Closeable {

// Internal buffer used to hold input

private CharBuffer buf;

// Size of internal character buffer

private static final int BUFFER_SIZE = 1024; // change to 1024;

// The index into the buffer currently held by the Scanner

private int position;

// Internal matcher used for finding delimiters

private Matcher matcher;

// Pattern used to delimit tokens

private Pattern delimPattern;

// Pattern found in last hasNext operation

private Pattern hasNextPattern;

// Position after last hasNext operation

private int hasNextPosition;

// Result after last hasNext operation

private String hasNextResult;

// The input source

private Readable source;

// Boolean is true if source is done

private boolean sourceClosed = false;

// Boolean indicating more input is required

private boolean needInput = false;

// Boolean indicating if a delim has been skipped this operation

private boolean skipped = false;

// A store of a position that the scanner may fall back to

private int savedScannerPosition = -1;

// A cache of the last primitive type scanned

private Object typeCache = null;

// Boolean indicating if a match result is available

private boolean matchValid = false;

// Boolean indicating if this scanner has been closed

private boolean closed = false;

// The current radix used by this scanner

private int radix = 10;

// The default radix for this scanner

private int defaultRadix = 10;

// The locale used by this scanner

private Locale locale = null;

// A cache of the last few recently used Patterns

private LRUCache<String,Pattern> patternCache =

new LRUCache<String,Pattern>(7) {

protected Pattern create(String s) {

return Pattern.compile(s);

}

protected boolean hasName(Pattern p, String s) {

return p.pattern().equals(s);

}

};

// A holder of the last IOException encountered

private IOException lastException;

// A pattern for java whitespace

private static Pattern WHITESPACE_PATTERN = Pattern.compile(

"\\p{javaWhitespace}+");

// A pattern for any token

private static Pattern FIND_ANY_PATTERN = Pattern.compile("(?s).*");

// A pattern for non-ASCII digits

private static Pattern NON_ASCII_DIGIT = Pattern.compile(

"[\\p{javaDigit}&&[^0-9]]");

// Fields and methods to support scanning primitive types

/**

private String groupSeparator = "\\,";

private String decimalSeparator = "\\.";

private String nanString = "NaN";

private String infinityString = "Infinity";

private String positivePrefix = "";

private String negativePrefix = "\\-";

private String positiveSuffix = "";

private String negativeSuffix = "";

/**

private static volatile Pattern boolPattern;

private static final String BOOLEAN_PATTERN = "true|false";

private static Pattern boolPattern() {

Pattern bp = boolPattern;

if (bp == null)

boolPattern = bp = Pattern.compile(BOOLEAN_PATTERN,

Pattern.CASE_INSENSITIVE);

return bp;

}

/**

private Pattern integerPattern;

private String digits = "0123456789abcdefghijklmnopqrstuvwxyz";

private String non0Digit = "[\\p{javaDigit}&&[^0]]";

private int SIMPLE_GROUP_INDEX = 5;

private String buildIntegerPatternString() {

String radixDigits = digits.substring(0, radix);

// \\p{javaDigit} is not guaranteed to be appropriate

// here but what can we do? The final authority will be

// whatever parse method is invoked, so ultimately the

// Scanner will do the right thing

String digit = "((?i)["+radixDigits+"]|\\p{javaDigit})";

String groupedNumeral = "("+non0Digit+digit+"?"+digit+"?("+

groupSeparator+digit+digit+digit+")+)";

// digit++ is the possessive form which is necessary for reducing

// backtracking that would otherwise cause unacceptable performance

String numeral = "(("+ digit+"++)|"+groupedNumeral+")";

String javaStyleInteger = "([-+]?(" + numeral + "))";

String negativeInteger = negativePrefix + numeral + negativeSuffix;

String positiveInteger = positivePrefix + numeral + positiveSuffix;

return "("+ javaStyleInteger + ")|(" +

positiveInteger + ")|(" +

negativeInteger + ")";

}

private Pattern integerPattern() {

if (integerPattern == null) {

integerPattern = patternCache.forName(buildIntegerPatternString());

}

return integerPattern;

}

/**

private static volatile Pattern separatorPattern;

private static volatile Pattern linePattern;

private static final String LINE_SEPARATOR_PATTERN =

"\r\n|[\n\r\u2028\u2029\u0085]";

private static final String LINE_PATTERN = ".*("+LINE_SEPARATOR_PATTERN+")|.+$";

private static Pattern separatorPattern() {

Pattern sp = separatorPattern;

if (sp == null)

separatorPattern = sp = Pattern.compile(LINE_SEPARATOR_PATTERN);

return sp;

}

private static Pattern linePattern() {

Pattern lp = linePattern;

if (lp == null)

linePattern = lp = Pattern.compile(LINE_PATTERN);

return lp;

}

/**

private Pattern floatPattern;

private Pattern decimalPattern;

private void buildFloatAndDecimalPattern() {

// \\p{javaDigit} may not be perfect, see above

String digit = "([0-9]|(\\p{javaDigit}))";

String exponent = "([eE][+-]?"+digit+"+)?";

String groupedNumeral = "("+non0Digit+digit+"?"+digit+"?("+

groupSeparator+digit+digit+digit+")+)";

// Once again digit++ is used for performance, as above

String numeral = "(("+digit+"++)|"+groupedNumeral+")";

String decimalNumeral = "("+numeral+"|"+numeral +

decimalSeparator + digit + "*+|"+ decimalSeparator +

digit + "++)";

String nonNumber = "(NaN|"+nanString+"|Infinity|"+

infinityString+")";

String positiveFloat = "(" + positivePrefix + decimalNumeral +

positiveSuffix + exponent + ")";

String negativeFloat = "(" + negativePrefix + decimalNumeral +

negativeSuffix + exponent + ")";

String decimal = "(([-+]?" + decimalNumeral + exponent + ")|"+

positiveFloat + "|" + negativeFloat + ")";

String hexFloat =

"[-+]?0[xX][0-9a-fA-F]*\\.[0-9a-fA-F]+([pP][-+]?[0-9]+)?";

String positiveNonNumber = "(" + positivePrefix + nonNumber +

positiveSuffix + ")";

String negativeNonNumber = "(" + negativePrefix + nonNumber +

negativeSuffix + ")";

String signedNonNumber = "(([-+]?"+nonNumber+")|" +

positiveNonNumber + "|" +

negativeNonNumber + ")";

floatPattern = Pattern.compile(decimal + "|" + hexFloat + "|" +

signedNonNumber);

decimalPattern = Pattern.compile(decimal);

}

private Pattern floatPattern() {

if (floatPattern == null) {

buildFloatAndDecimalPattern();

}

return floatPattern;

}

private Pattern decimalPattern() {

if (decimalPattern == null) {

buildFloatAndDecimalPattern();

}

return decimalPattern;

}

// Constructors

/**

private Scanner(Readable source, Pattern pattern) {

assert source != null : "source should not be null";

assert pattern != null : "pattern should not be null";

this.source = source;

delimPattern = pattern;

buf = CharBuffer.allocate(BUFFER_SIZE);

buf.limit(0);

matcher = delimPattern.matcher(buf);

matcher.useTransparentBounds(true);

matcher.useAnchoringBounds(false);

useLocale(Locale.getDefault(Locale.Category.FORMAT));

}

/**

public Scanner(Readable source) {

this(Objects.nonNull(source, "source"), WHITESPACE_PATTERN);

}

/**

public Scanner(InputStream source) {

this(new InputStreamReader(source), WHITESPACE_PATTERN);

}

/**

public Scanner(InputStream source, String charsetName) {

this(makeReadable(Objects.nonNull(source, "source"), toCharset(charsetName)),

WHITESPACE_PATTERN);

}

/**

private static Charset toCharset(String csn) {

Objects.nonNull(csn, "charsetName");

try {

return Charset.forName(csn);

} catch (IllegalCharsetNameException|UnsupportedCharsetException e) {

// IllegalArgumentException should be thrown

throw new IllegalArgumentException(e);

}

}

private static Readable makeReadable(InputStream source, Charset charset) {

return new InputStreamReader(source, charset);

}

/**

public Scanner(File source) throws FileNotFoundException {

this((ReadableByteChannel)(new FileInputStream(source).getChannel()));

}

/**

public Scanner(File source, String charsetName)

throws FileNotFoundException

{

this(Objects.nonNull(source), toDecoder(charsetName));

}

private Scanner(File source, CharsetDecoder dec)

throws FileNotFoundException

{

this(makeReadable((ReadableByteChannel)(new FileInputStream(source).getChannel()), dec));

}

private static CharsetDecoder toDecoder(String charsetName) {

Objects.nonNull(charsetName, "charsetName");

try {

return Charset.forName(charsetName).newDecoder();

} catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {

throw new IllegalArgumentException(charsetName);

}

}

private static Readable makeReadable(ReadableByteChannel source,

CharsetDecoder dec) {

return Channels.newReader(source, dec, -1);

}

/**

public Scanner(Path source)

throws IOException

{

this(Files.newInputStream(source));

}

/**

public Scanner(Path source, String charsetName) throws IOException {

this(Objects.nonNull(source), toCharset(charsetName));

}

private Scanner(Path source, Charset charset) throws IOException {

this(makeReadable(Files.newInputStream(source), charset));

}

/**

public Scanner(String source) {

this(new StringReader(source), WHITESPACE_PATTERN);

}

/**

public Scanner(ReadableByteChannel source) {

this(makeReadable(Objects.nonNull(source, "source")),

WHITESPACE_PATTERN);

}

private static Readable makeReadable(ReadableByteChannel source) {

return makeReadable(source, Charset.defaultCharset().newDecoder());

}

/**

public Scanner(ReadableByteChannel source, String charsetName) {

this(makeReadable(Objects.nonNull(source, "source"), toDecoder(charsetName)),

WHITESPACE_PATTERN);

}

// Private primitives used to support scanning

private void saveState() {

savedScannerPosition = position;

}

private void revertState() {

this.position = savedScannerPosition;

savedScannerPosition = -1;

skipped = false;

}

private boolean revertState(boolean b) {

this.position = savedScannerPosition;

savedScannerPosition = -1;

skipped = false;

return b;

}

private void cacheResult() {

hasNextResult = matcher.group();

hasNextPosition = matcher.end();

hasNextPattern = matcher.pattern();

}

private void cacheResult(String result) {

hasNextResult = result;

hasNextPosition = matcher.end();

hasNextPattern = matcher.pattern();

}

// Clears both regular cache and type cache

private void clearCaches() {

hasNextPattern = null;

typeCache = null;

}

// Also clears both the regular cache and the type cache

private String getCachedResult() {

position = hasNextPosition;

hasNextPattern = null;

typeCache = null;

return hasNextResult;

}

// Also clears both the regular cache and the type cache

private void useTypeCache() {

if (closed)

throw new IllegalStateException("Scanner closed");

position = hasNextPosition;

hasNextPattern = null;

typeCache = null;

}

// Tries to read more input. May block.

private void readInput() {

if (buf.limit() == buf.capacity())

makeSpace();

// Prepare to receive data

int p = buf.position();

buf.position(buf.limit());

buf.limit(buf.capacity());

int n = 0;

try {

n = source.read(buf);

} catch (IOException ioe) {

lastException = ioe;

n = -1;

}

if (n == -1) {

sourceClosed = true;

needInput = false;

}

if (n > 0)

needInput = false;

// Restore current position and limit for reading

buf.limit(buf.position());

buf.position(p);

}

// After this method is called there will either be an exception

// or else there will be space in the buffer

private boolean makeSpace() {

clearCaches();

int offset = savedScannerPosition == -1 ?

position : savedScannerPosition;

buf.position(offset);

// Gain space by compacting buffer

if (offset > 0) {

buf.compact();

translateSavedIndexes(offset);

position -= offset;

buf.flip();

return true;

}

// Gain space by growing buffer

int newSize = buf.capacity() * 2;

CharBuffer newBuf = CharBuffer.allocate(newSize);

newBuf.put(buf);

newBuf.flip();

translateSavedIndexes(offset);

position -= offset;

buf = newBuf;

matcher.reset(buf);

return true;

}

// When a buffer compaction/reallocation occurs the saved indexes must

// be modified appropriately

private void translateSavedIndexes(int offset) {

if (savedScannerPosition != -1)

savedScannerPosition -= offset;

}

// If we are at the end of input then NoSuchElement;

// If there is still input left then InputMismatch

private void throwFor() {

skipped = false;

if ((sourceClosed) && (position == buf.limit()))

throw new NoSuchElementException();

else

throw new InputMismatchException();

}

// Returns true if a complete token or partial token is in the buffer.

// It is not necessary to find a complete token since a partial token

// means that there will be another token with or without more input.

private boolean hasTokenInBuffer() {

matchValid = false;

matcher.usePattern(delimPattern);

matcher.region(position, buf.limit());

// Skip delims first

if (matcher.lookingAt())

position = matcher.end();

// If we are sitting at the end, no more tokens in buffer

if (position == buf.limit())

return false;

return true;

}

/*

private String getCompleteTokenInBuffer(Pattern pattern) {

matchValid = false;

// Skip delims first

matcher.usePattern(delimPattern);

if (!skipped) { // Enforcing only one skip of leading delims

matcher.region(position, buf.limit());

if (matcher.lookingAt()) {

// If more input could extend the delimiters then we must wait

// for more input

if (matcher.hitEnd() && !sourceClosed) {

needInput = true;

return null;

}

// The delims were whole and the matcher should skip them

skipped = true;

position = matcher.end();

}

}

// If we are sitting at the end, no more tokens in buffer

if (position == buf.limit()) {

if (sourceClosed)

return null;

needInput = true;

return null;

}

// Must look for next delims. Simply attempting to match the

// pattern at this point may find a match but it might not be

// the first longest match because of missing input, or it might

// match a partial token instead of the whole thing.

// Then look for next delims

matcher.region(position, buf.limit());

boolean foundNextDelim = matcher.find();

if (foundNextDelim && (matcher.end() == position)) {

// Zero length delimiter match; we should find the next one

// using the automatic advance past a zero length match;

// Otherwise we have just found the same one we just skipped

foundNextDelim = matcher.find();

}

if (foundNextDelim) {

// In the rare case that more input could cause the match

// to be lost and there is more input coming we must wait

// for more input. Note that hitting the end is okay as long

// as the match cannot go away. It is the beginning of the

// next delims we want to be sure about, we don't care if

// they potentially extend further.

if (matcher.requireEnd() && !sourceClosed) {

needInput = true;

return null;

}

int tokenEnd = matcher.start();

// There is a complete token.

if (pattern == null) {

// Must continue with match to provide valid MatchResult

pattern = FIND_ANY_PATTERN;

}

// Attempt to match against the desired pattern

matcher.usePattern(pattern);

matcher.region(position, tokenEnd);

if (matcher.matches()) {

String s = matcher.group();

position = matcher.end();

return s;

} else { // Complete token but it does not match

return null;

}

}

// If we can't find the next delims but no more input is coming,

// then we can treat the remainder as a whole token

if (sourceClosed) {

if (pattern == null) {

// Must continue with match to provide valid MatchResult

pattern = FIND_ANY_PATTERN;

}

// Last token; Match the pattern here or throw

matcher.usePattern(pattern);

matcher.region(position, buf.limit());

if (matcher.matches()) {

String s = matcher.group();

position = matcher.end();

return s;

}

// Last piece does not match

return null;

}

// There is a partial token in the buffer; must read more

// to complete it

needInput = true;

return null;

}

// Finds the specified pattern in the buffer up to horizon.

// Returns a match for the specified input pattern.

private String findPatternInBuffer(Pattern pattern, int horizon) {

matchValid = false;

matcher.usePattern(pattern);

int bufferLimit = buf.limit();

int horizonLimit = -1;

int searchLimit = bufferLimit;

if (horizon > 0) {

horizonLimit = position + horizon;

if (horizonLimit < bufferLimit)

searchLimit = horizonLimit;

}

matcher.region(position, searchLimit);

if (matcher.find()) {

if (matcher.hitEnd() && (!sourceClosed)) {

// The match may be longer if didn't hit horizon or real end

if (searchLimit != horizonLimit) {

// Hit an artificial end; try to extend the match

needInput = true;

return null;

}

// The match could go away depending on what is next

if ((searchLimit == horizonLimit) && matcher.requireEnd()) {

// Rare case: we hit the end of input and it happens

// that it is at the horizon and the end of input is

// required for the match.

needInput = true;

return null;

}

}

// Did not hit end, or hit real end, or hit horizon

position = matcher.end();

return matcher.group();

}

if (sourceClosed)

return null;

// If there is no specified horizon, or if we have not searched

// to the specified horizon yet, get more input

if ((horizon == 0) || (searchLimit != horizonLimit))

needInput = true;

return null;

}

// Returns a match for the specified input pattern anchored at

// the current position

private String matchPatternInBuffer(Pattern pattern) {

matchValid = false;

matcher.usePattern(pattern);

matcher.region(position, buf.limit());

if (matcher.lookingAt()) {

if (matcher.hitEnd() && (!sourceClosed)) {

// Get more input and try again

needInput = true;

return null;

}

position = matcher.end();

return matcher.group();

}

if (sourceClosed)

return null;

// Read more to find pattern

needInput = true;

return null;

}

// Throws if the scanner is closed

private void ensureOpen() {

if (closed)

throw new IllegalStateException("Scanner closed");

}

// Public methods

/**

public void close() {

if (closed)

return;

if (source instanceof Closeable) {

try {

((Closeable)source).close();

} catch (IOException ioe) {

lastException = ioe;

}

}

sourceClosed = true;

source = null;

closed = true;

}

/**

public IOException ioException() {

return lastException;

}

/**

public Pattern delimiter() {

return delimPattern;

}

/**

public Scanner useDelimiter(Pattern pattern) {

delimPattern = pattern;

return this;

}

/**

public Scanner useDelimiter(String pattern) {

delimPattern = patternCache.forName(pattern);

return this;

}

/**

public Locale locale() {

return this.locale;

}

/**

public Scanner useLocale(Locale locale) {

if (locale.equals(this.locale))

return this;

this.locale = locale;

DecimalFormat df =

(DecimalFormat)NumberFormat.getNumberInstance(locale);

DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(locale);

// These must be literalized to avoid collision with regex

// metacharacters such as dot or parenthesis

groupSeparator = "\\" + dfs.getGroupingSeparator();

decimalSeparator = "\\" + dfs.getDecimalSeparator();

// Quoting the nonzero length locale-specific things

// to avoid potential conflict with metacharacters

nanString = "\\Q" + dfs.getNaN() + "\\E";

infinityString = "\\Q" + dfs.getInfinity() + "\\E";

positivePrefix = df.getPositivePrefix();

if (positivePrefix.length() > 0)

positivePrefix = "\\Q" + positivePrefix + "\\E";

negativePrefix = df.getNegativePrefix();

if (negativePrefix.length() > 0)

negativePrefix = "\\Q" + negativePrefix + "\\E";

positiveSuffix = df.getPositiveSuffix();

if (positiveSuffix.length() > 0)

positiveSuffix = "\\Q" + positiveSuffix + "\\E";

negativeSuffix = df.getNegativeSuffix();

if (negativeSuffix.length() > 0)

negativeSuffix = "\\Q" + negativeSuffix + "\\E";

// Force rebuilding and recompilation of locale dependent

// primitive patterns

integerPattern = null;

floatPattern = null;

return this;

}

/**

public int radix() {

return this.defaultRadix;

}

/**

public Scanner useRadix(int radix) {

if ((radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX))

throw new IllegalArgumentException("radix:"+radix);

if (this.defaultRadix == radix)

return this;

this.defaultRadix = radix;

// Force rebuilding and recompilation of radix dependent patterns

integerPattern = null;

return this;

}

// The next operation should occur in the specified radix but

// the default is left untouched.

private void setRadix(int radix) {

if (this.radix != radix) {

// Force rebuilding and recompilation of radix dependent patterns

integerPattern = null;

this.radix = radix;

}

}

/**

public MatchResult match() {

if (!matchValid)

throw new IllegalStateException("No match result available");

return matcher.toMatchResult();

}

/**

public String toString() {

StringBuilder sb = new StringBuilder();

sb.append("java.util.Scanner");

sb.append("[delimiters=" + delimPattern + "]");

sb.append("[position=" + position + "]");

sb.append("[match valid=" + matchValid + "]");

sb.append("[need input=" + needInput + "]");

sb.append("[source closed=" + sourceClosed + "]");

sb.append("[skipped=" + skipped + "]");

sb.append("[group separator=" + groupSeparator + "]");

sb.append("[decimal separator=" + decimalSeparator + "]");

sb.append("[positive prefix=" + positivePrefix + "]");

sb.append("[negative prefix=" + negativePrefix + "]");

sb.append("[positive suffix=" + positiveSuffix + "]");

sb.append("[negative suffix=" + negativeSuffix + "]");

sb.append("[NaN string=" + nanString + "]");

sb.append("[infinity string=" + infinityString + "]");

return sb.toString();

}

/**

public boolean hasNext() {