869N/A

0N/Apackage java.util;

0N/A

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

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

869N/Aimport java.io.*;

0N/Aimport java.math.*;

0N/Aimport java.nio.*;

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

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

0N/Aimport java.text.*;

869N/Aimport java.util.Locale;

0N/Aimport sun.misc.LRUCache;

869N/A

824N/Apublic final class Scanner implements Iterator<String> {

824N/A

824N/A // Internal buffer used to hold input

824N/A private CharBuffer buf;

869N/A

869N/A // Size of internal character buffer

869N/A private static final int BUFFER_SIZE = 1024; // change to 1024;

869N/A

869N/A // The index into the buffer currently held by the Scanner

869N/A private int position;

869N/A

869N/A // Internal matcher used for finding delimiters

869N/A private Matcher matcher;

868N/A

824N/A // Pattern used to delimit tokens

868N/A private Pattern delimPattern;

869N/A

869N/A // Pattern found in last hasNext operation

868N/A private Pattern hasNextPattern;

869N/A

869N/A // Position after last hasNext operation

824N/A private int hasNextPosition;

824N/A

869N/A // Result after last hasNext operation

869N/A private String hasNextResult;

869N/A

869N/A // The input source

869N/A private Readable source;

869N/A

869N/A // Boolean is true if source is done

869N/A private boolean sourceClosed = false;

0N/A

869N/A // Boolean indicating more input is required

869N/A private boolean needInput = false;

869N/A

0N/A // Boolean indicating if a delim has been skipped this operation

0N/A private boolean skipped = false;

869N/A

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

869N/A private int savedScannerPosition = -1;

869N/A

0N/A // A cache of the last primitive type scanned

0N/A private Object typeCache = null;

0N/A

0N/A // Boolean indicating if a match result is available

869N/A private boolean matchValid = false;

868N/A

0N/A // Boolean indicating if this scanner has been closed

0N/A private boolean closed = false;

0N/A

0N/A // The current radix used by this scanner

0N/A private int radix = 10;

869N/A

0N/A // The default radix for this scanner

0N/A private int defaultRadix = 10;

0N/A

0N/A // The locale used by this scanner

0N/A private Locale locale = null;

0N/A

46N/A // A cache of the last few recently used Patterns

869N/A private LRUCache<String,Pattern> patternCache =

0N/A new LRUCache<String,Pattern>(7) {

0N/A protected Pattern create(String s) {

46N/A return Pattern.compile(s);

0N/A }

0N/A protected boolean hasName(Pattern p, String s) {

0N/A return p.pattern().equals(s);

0N/A }

869N/A };

0N/A

0N/A // A holder of the last IOException encountered

0N/A private IOException lastException;

0N/A

0N/A // A pattern for java whitespace

0N/A private static Pattern WHITESPACE_PATTERN = Pattern.compile(

869N/A "\\p{javaWhitespace}+");

0N/A

0N/A // A pattern for any token

0N/A private static Pattern FIND_ANY_PATTERN = Pattern.compile("(?s).*");

756N/A

869N/A // A pattern for non-ASCII digits

868N/A private static Pattern NON_ASCII_DIGIT = Pattern.compile(

756N/A "[\\p{javaDigit}&&[^0-9]]");

756N/A

988N/A // Fields and methods to support scanning primitive types

988N/A

988N/A /**

988N/A private String groupSeparator = "\\,";

988N/A private String decimalSeparator = "\\.";

756N/A private String nanString = "NaN";

756N/A private String infinityString = "Infinity";

756N/A private String positivePrefix = "";

869N/A private String negativePrefix = "\\-";

756N/A private String positiveSuffix = "";

869N/A private String negativeSuffix = "";

756N/A

0N/A /**

0N/A private static volatile Pattern boolPattern;

0N/A private static final String BOOLEAN_PATTERN = "true|false";

0N/A private static Pattern boolPattern() {

0N/A Pattern bp = boolPattern;

0N/A if (bp == null)

869N/A boolPattern = bp = Pattern.compile(BOOLEAN_PATTERN,

869N/A Pattern.CASE_INSENSITIVE);

0N/A return bp;

0N/A }

0N/A

0N/A /**

868N/A private Pattern integerPattern;

824N/A private String digits = "0123456789abcdefghijklmnopqrstuvwxyz";

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

824N/A private int SIMPLE_GROUP_INDEX = 5;

869N/A private String buildIntegerPatternString() {

868N/A String radixDigits = digits.substring(0, radix);

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

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

824N/A // whatever parse method is invoked, so ultimately the

869N/A // Scanner will do the right thing

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

869N/A String groupedNumeral = "("+non0Digit+digit+"?"+digit+"?("+

869N/A groupSeparator+digit+digit+digit+")+)";

869N/A // digit++ is the possessive form which is necessary for reducing

869N/A // backtracking that would otherwise cause unacceptable performance

869N/A String numeral = "(("+ digit+"++)|"+groupedNumeral+")";

869N/A String javaStyleInteger = "([-+]?(" + numeral + "))";

869N/A String negativeInteger = negativePrefix + numeral + negativeSuffix;

869N/A String positiveInteger = positivePrefix + numeral + positiveSuffix;

869N/A return "("+ javaStyleInteger + ")|(" +

869N/A positiveInteger + ")|(" +

869N/A negativeInteger + ")";

869N/A }

869N/A private Pattern integerPattern() {

868N/A if (integerPattern == null) {

868N/A integerPattern = patternCache.forName(buildIntegerPatternString());

869N/A }

868N/A return integerPattern;

868N/A }

869N/A

868N/A /**

824N/A private static volatile Pattern separatorPattern;

0N/A private static volatile Pattern linePattern;

869N/A private static final String LINE_SEPARATOR_PATTERN =

868N/A "\r\n|[\n\r\u2028\u2029\u0085]";

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

0N/A

0N/A private static Pattern separatorPattern() {

869N/A Pattern sp = separatorPattern;

868N/A if (sp == null)

0N/A separatorPattern = sp = Pattern.compile(LINE_SEPARATOR_PATTERN);

869N/A return sp;

869N/A }

868N/A

868N/A private static Pattern linePattern() {

869N/A Pattern lp = linePattern;

869N/A if (lp == null)

0N/A linePattern = lp = Pattern.compile(LINE_PATTERN);

0N/A return lp;

869N/A }

869N/A

869N/A /**

869N/A private Pattern floatPattern;

869N/A private Pattern decimalPattern;

869N/A private void buildFloatAndDecimalPattern() {

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

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

869N/A String exponent = "([eE][+-]?"+digit+"+)?";

869N/A String groupedNumeral = "("+non0Digit+digit+"?"+digit+"?("+

868N/A groupSeparator+digit+digit+digit+")+)";

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

869N/A String numeral = "(("+digit+"++)|"+groupedNumeral+")";

0N/A String decimalNumeral = "("+numeral+"|"+numeral +

869N/A decimalSeparator + digit + "*+|"+ decimalSeparator +

0N/A digit + "++)";

0N/A String nonNumber = "(NaN|"+nanString+"|Infinity|"+

869N/A infinityString+")";

868N/A String positiveFloat = "(" + positivePrefix + decimalNumeral +

868N/A positiveSuffix + exponent + ")";

869N/A String negativeFloat = "(" + negativePrefix + decimalNumeral +

869N/A negativeSuffix + exponent + ")";

869N/A String decimal = "(([-+]?" + decimalNumeral + exponent + ")|"+

869N/A positiveFloat + "|" + negativeFloat + ")";

868N/A String hexFloat =

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

0N/A String positiveNonNumber = "(" + positivePrefix + nonNumber +

0N/A positiveSuffix + ")";

0N/A String negativeNonNumber = "(" + negativePrefix + nonNumber +

869N/A negativeSuffix + ")";

0N/A String signedNonNumber = "(([-+]?"+nonNumber+")|" +

0N/A positiveNonNumber + "|" +

0N/A negativeNonNumber + ")";

869N/A floatPattern = Pattern.compile(decimal + "|" + hexFloat + "|" +

869N/A signedNonNumber);

869N/A decimalPattern = Pattern.compile(decimal);

868N/A }

0N/A private Pattern floatPattern() {

0N/A if (floatPattern == null) {

0N/A buildFloatAndDecimalPattern();

0N/A }

869N/A return floatPattern;

869N/A }

0N/A private Pattern decimalPattern() {

869N/A if (decimalPattern == null) {

0N/A buildFloatAndDecimalPattern();

0N/A }

869N/A return decimalPattern;

868N/A }

0N/A

0N/A // Constructors

0N/A

0N/A /**

868N/A private Scanner(Readable source, Pattern pattern) {

868N/A if (source == null)

869N/A throw new NullPointerException("source");

0N/A if (pattern == null)

0N/A throw new NullPointerException("pattern");

869N/A this.source = source;

0N/A delimPattern = pattern;

0N/A buf = CharBuffer.allocate(BUFFER_SIZE);

0N/A buf.limit(0);

0N/A matcher = delimPattern.matcher(buf);

869N/A matcher.useTransparentBounds(true);

0N/A matcher.useAnchoringBounds(false);

0N/A useLocale(Locale.getDefault());

869N/A }

0N/A

0N/A /**

0N/A public Scanner(Readable source) {

0N/A this(source, WHITESPACE_PATTERN);

868N/A }

868N/A

869N/A /**

868N/A public Scanner(InputStream source) {

0N/A this(new InputStreamReader(source), WHITESPACE_PATTERN);

0N/A }

869N/A

0N/A /**

869N/A public Scanner(InputStream source, String charsetName) {

869N/A this(makeReadable(source, charsetName), WHITESPACE_PATTERN);

869N/A }

869N/A

869N/A private static Readable makeReadable(InputStream source,

869N/A String charsetName)

869N/A {

869N/A if (source == null)

869N/A throw new NullPointerException("source");

869N/A InputStreamReader isr = null;

869N/A try {

869N/A isr = new InputStreamReader(source, charsetName);

869N/A } catch (UnsupportedEncodingException uee) {

0N/A IllegalArgumentException iae = new IllegalArgumentException();

868N/A iae.initCause(uee);

0N/A throw iae;

0N/A }

869N/A return isr;

0N/A }

0N/A

869N/A /**

869N/A public Scanner(File source)

869N/A throws FileNotFoundException

869N/A {

869N/A this((ReadableByteChannel)(new FileInputStream(source).getChannel()));

869N/A }

869N/A

869N/A /**

0N/A public Scanner(File source, String charsetName)

0N/A throws FileNotFoundException

0N/A {

0N/A this((ReadableByteChannel)(new FileInputStream(source).getChannel()),

0N/A charsetName);

869N/A }

0N/A

0N/A /**

869N/A public Scanner(FileRef source)

868N/A throws IOException

869N/A {

868N/A this(source.newByteChannel());

868N/A }

869N/A

869N/A /**

0N/A public Scanner(FileRef source, String charsetName)

869N/A throws IOException

0N/A {

0N/A this(source.newByteChannel(), charsetName);

0N/A }

0N/A

869N/A /**

0N/A public Scanner(String source) {

0N/A this(new StringReader(source), WHITESPACE_PATTERN);

869N/A }

0N/A

0N/A /**

0N/A public Scanner(ReadableByteChannel source) {

0N/A this(makeReadable(source), WHITESPACE_PATTERN);

0N/A }

0N/A

0N/A private static Readable makeReadable(ReadableByteChannel source) {

0N/A if (source == null)

869N/A throw new NullPointerException("source");

0N/A String defaultCharsetName =

0N/A java.nio.charset.Charset.defaultCharset().name();

869N/A return Channels.newReader(source,

0N/A java.nio.charset.Charset.defaultCharset().name());

869N/A }

0N/A

0N/A /**

869N/A public Scanner(ReadableByteChannel source, String charsetName) {

868N/A this(makeReadable(source, charsetName), WHITESPACE_PATTERN);

868N/A }

868N/A

0N/A private static Readable makeReadable(ReadableByteChannel source,

0N/A String charsetName)

869N/A {

868N/A if (source == null)

868N/A throw new NullPointerException("source");

869N/A if (!Charset.isSupported(charsetName))

868N/A throw new IllegalArgumentException(charsetName);

868N/A return Channels.newReader(source, charsetName);

868N/A }

868N/A

869N/A // Private primitives used to support scanning

0N/A

0N/A private void saveState() {

869N/A savedScannerPosition = position;

0N/A }

0N/A

0N/A private void revertState() {

0N/A this.position = savedScannerPosition;

869N/A savedScannerPosition = -1;

0N/A skipped = false;

0N/A }

869N/A

0N/A private boolean revertState(boolean b) {

0N/A this.position = savedScannerPosition;

0N/A savedScannerPosition = -1;

0N/A skipped = false;

0N/A return b;

0N/A }

0N/A

869N/A private void cacheResult() {

0N/A hasNextResult = matcher.group();

0N/A hasNextPosition = matcher.end();

0N/A hasNextPattern = matcher.pattern();

0N/A }

869N/A

0N/A private void cacheResult(String result) {

0N/A hasNextResult = result;

869N/A hasNextPosition = matcher.end();

0N/A hasNextPattern = matcher.pattern();

0N/A }

0N/A

0N/A // Clears both regular cache and type cache

869N/A private void clearCaches() {

0N/A hasNextPattern = null;

0N/A typeCache = null;

869N/A }

0N/A

0N/A // Also clears both the regular cache and the type cache

0N/A private String getCachedResult() {

0N/A position = hasNextPosition;

869N/A hasNextPattern = null;

0N/A typeCache = null;

0N/A return hasNextResult;

869N/A }

0N/A

0N/A // Also clears both the regular cache and the type cache

0N/A private void useTypeCache() {

0N/A if (closed)

869N/A throw new IllegalStateException("Scanner closed");

0N/A position = hasNextPosition;

0N/A hasNextPattern = null;

869N/A typeCache = null;

0N/A }

0N/A

0N/A // Tries to read more input. May block.

0N/A private void readInput() {

0N/A if (buf.limit() == buf.capacity())

0N/A makeSpace();

0N/A

869N/A // Prepare to receive data

0N/A int p = buf.position();

0N/A buf.position(buf.limit());

0N/A buf.limit(buf.capacity());

0N/A

869N/A int n = 0;

0N/A try {

0N/A n = source.read(buf);

869N/A } catch (IOException ioe) {

0N/A lastException = ioe;

0N/A n = -1;

0N/A }

0N/A

869N/A if (n == -1) {

0N/A sourceClosed = true;

0N/A needInput = false;

869N/A }

0N/A

0N/A if (n > 0)

0N/A needInput = false;

0N/A

869N/A // Restore current position and limit for reading

0N/A buf.limit(buf.position());

0N/A buf.position(p);

869N/A }

0N/A

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

0N/A // or else there will be space in the buffer

0N/A private boolean makeSpace() {

0N/A clearCaches();

0N/A int offset = savedScannerPosition == -1 ?

0N/A position : savedScannerPosition;

869N/A buf.position(offset);

0N/A // Gain space by compacting buffer

0N/A if (offset > 0) {

0N/A buf.compact();

0N/A translateSavedIndexes(offset);

869N/A position -= offset;

0N/A buf.flip();

0N/A return true;

869N/A }

0N/A // Gain space by growing buffer

0N/A int newSize = buf.capacity() * 2;

0N/A CharBuffer newBuf = CharBuffer.allocate(newSize);

0N/A newBuf.put(buf);

869N/A newBuf.flip();

0N/A translateSavedIndexes(offset);

0N/A position -= offset;

869N/A buf = newBuf;

0N/A matcher.reset(buf);

0N/A return true;

0N/A }

0N/A

869N/A // When a buffer compaction/reallocation occurs the saved indexes must

0N/A // be modified appropriately

0N/A private void translateSavedIndexes(int offset) {

869N/A if (savedScannerPosition != -1)

0N/A savedScannerPosition -= offset;

0N/A }

0N/A

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

869N/A // If there is still input left then InputMismatch

0N/A private void throwFor() {

0N/A skipped = false;

869N/A if ((sourceClosed) && (position == buf.limit()))

0N/A throw new NoSuchElementException();

0N/A else

0N/A throw new InputMismatchException();

0N/A }

869N/A

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

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

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

0N/A private boolean hasTokenInBuffer() {

0N/A matchValid = false;

0N/A matcher.usePattern(delimPattern);

0N/A matcher.region(position, buf.limit());

0N/A

0N/A // Skip delims first

0N/A if (matcher.lookingAt())

869N/A position = matcher.end();

0N/A

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

869N/A if (position == buf.limit())

868N/A return false;

0N/A

0N/A return true;

0N/A }

869N/A

868N/A /*

869N/A private String getCompleteTokenInBuffer(Pattern pattern) {

0N/A matchValid = false;

0N/A

0N/A // Skip delims first

0N/A matcher.usePattern(delimPattern);

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

868N/A matcher.region(position, buf.limit());

0N/A if (matcher.lookingAt()) {

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

0N/A // for more input

869N/A if (matcher.hitEnd() && !sourceClosed) {

868N/A needInput = true;

0N/A return null;

869N/A }

0N/A // The delims were whole and the matcher should skip them

869N/A skipped = true;

0N/A position = matcher.end();

0N/A }

869N/A }

0N/A

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

869N/A if (position == buf.limit()) {

868N/A if (sourceClosed)

0N/A return null;

0N/A needInput = true;

869N/A return null;

868N/A }

869N/A

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

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

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

869N/A // match a partial token instead of the whole thing.

868N/A

869N/A // Then look for next delims

869N/A matcher.region(position, buf.limit());

869N/A boolean foundNextDelim = matcher.find();

868N/A if (foundNextDelim && (matcher.end() == position)) {

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

868N/A // using the automatic advance past a zero length match;

868N/A // Otherwise we have just found the same one we just skipped

869N/A foundNextDelim = matcher.find();

0N/A }

869N/A if (foundNextDelim) {

869N/A // In the rare case that more input could cause the match

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

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

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

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

869N/A // they potentially extend further.

868N/A if (matcher.requireEnd() && !sourceClosed) {

868N/A needInput = true;

869N/A return null;

0N/A }

245N/A int tokenEnd = matcher.start();

869N/A // There is a complete token.

868N/A if (pattern == null) {

869N/A // Must continue with match to provide valid MatchResult

869N/A pattern = FIND_ANY_PATTERN;

549N/A }

869N/A // Attempt to match against the desired pattern

245N/A matcher.usePattern(pattern);

869N/A matcher.region(position, tokenEnd);

245N/A if (matcher.matches()) {

245N/A String s = matcher.group();

868N/A position = matcher.end();

869N/A return s;

869N/A } else { // Complete token but it does not match

869N/A return null;

245N/A }

245N/A }

869N/A

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

245N/A // then we can treat the remainder as a whole token

245N/A if (sourceClosed) {

869N/A if (pattern == null) {

869N/A // Must continue with match to provide valid MatchResult

245N/A pattern = FIND_ANY_PATTERN;

245N/A }

245N/A // Last token; Match the pattern here or throw

245N/A matcher.usePattern(pattern);

0N/A matcher.region(position, buf.limit());

869N/A if (matcher.matches()) {

868N/A String s = matcher.group();

0N/A position = matcher.end();

0N/A return s;

0N/A }

0N/A // Last piece does not match

0N/A return null;

869N/A }

0N/A

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

0N/A // to complete it

0N/A needInput = true;

0N/A return null;

0N/A }

869N/A

0N/A // Finds the specified pattern in the buffer up to horizon.

869N/A // Returns a match for the specified input pattern.

0N/A private String findPatternInBuffer(Pattern pattern, int horizon) {

0N/A matchValid = false;

0N/A matcher.usePattern(pattern);

0N/A int bufferLimit = buf.limit();

869N/A int horizonLimit = -1;

0N/A int searchLimit = bufferLimit;

869N/A if (horizon > 0) {

0N/A horizonLimit = position + horizon;

0N/A if (horizonLimit < bufferLimit)

0N/A searchLimit = horizonLimit;

0N/A }

869N/A matcher.region(position, searchLimit);

0N/A if (matcher.find()) {

869N/A if (matcher.hitEnd() && (!sourceClosed)) {

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

0N/A if (searchLimit != horizonLimit) {

0N/A // Hit an artificial end; try to extend the match

0N/A needInput = true;

869N/A return null;

0N/A }

869N/A // The match could go away depending on what is next

0N/A if ((searchLimit == horizonLimit) && matcher.requireEnd()) {

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

0N/A // that it is at the horizon and the end of input is

0N/A // required for the match.

869N/A needInput = true;

0N/A return null;

869N/A }

0N/A }

0N/A // Did not hit end, or hit real end, or hit horizon

0N/A position = matcher.end();

0N/A return matcher.group();

869N/A }

0N/A

869N/A if (sourceClosed)

0N/A return null;

0N/A

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

0N/A // to the specified horizon yet, get more input

869N/A if ((horizon == 0) || (searchLimit != horizonLimit))

0N/A needInput = true;

869N/A return null;

0N/A }

0N/A

0N/A // Returns a match for the specified input pattern anchored at

0N/A // the current position

869N/A private String matchPatternInBuffer(Pattern pattern) {

0N/A matchValid = false;

869N/A matcher.usePattern(pattern);

0N/A matcher.region(position, buf.limit());

0N/A if (matcher.lookingAt()) {

869N/A if (matcher.hitEnd() && (!sourceClosed)) {

868N/A // Get more input and try again

0N/A needInput = true;

0N/A return null;

0N/A }

869N/A position = matcher.end();

868N/A return matcher.group();

0N/A }

869N/A

868N/A if (sourceClosed)

0N/A return null;

869N/A

869N/A // Read more to find pattern

0N/A needInput = true;

1026N/A return null;

1026N/A }

1026N/A

1026N/A // Throws if the scanner is closed

1026N/A private void ensureOpen() {

1026N/A if (closed)

1026N/A throw new IllegalStateException("Scanner closed");

1026N/A }

1026N/A

1026N/A // Public methods

1017N/A

1017N/A /**

1026N/A public void close() {

1026N/A if (closed)

1026N/A return;

1026N/A if (source instanceof Closeable) {

1026N/A try {

0N/A ((Closeable)source).close();

869N/A } catch (IOException ioe) {

868N/A lastException = ioe;

0N/A }

0N/A }

0N/A sourceClosed = true;

0N/A source = null;

0N/A closed = true;

869N/A }

0N/A

0N/A /**

869N/A public IOException ioException() {

0N/A return lastException;

0N/A }

0N/A

0N/A /**

869N/A public Pattern delimiter() {

0N/A return delimPattern;

0N/A }

0N/A

0N/A /**

0N/A public Scanner useDelimiter(Pattern pattern) {

0N/A delimPattern = pattern;

0N/A return this;

0N/A }

0N/A

869N/A /**

776N/A public Scanner useDelimiter(String pattern) {

776N/A delimPattern = patternCache.forName(pattern);

776N/A return this;

776N/A }

776N/A

776N/A /**

776N/A public Locale locale() {

776N/A return this.locale;

0N/A }

0N/A

869N/A /**

549N/A public Scanner useLocale(Locale locale) {

0N/A if (locale.equals(this.locale))

869N/A return this;

868N/A

0N/A this.locale = locale;

869N/A DecimalFormat df =

868N/A (DecimalFormat)NumberFormat.getNumberInstance(locale);

0N/A DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(locale);

0N/A

869N/A // These must be literalized to avoid collision with regex

868N/A // metacharacters such as dot or parenthesis

0N/A groupSeparator = "\\" + dfs.getGroupingSeparator();

0N/A decimalSeparator = "\\" + dfs.getDecimalSeparator();

0N/A

869N/A // Quoting the nonzero length locale-specific things

868N/A // to avoid potential conflict with metacharacters

869N/A nanString = "\\Q" + dfs.getNaN() + "\\E";

0N/A infinityString = "\\Q" + dfs.getInfinity() + "\\E";

0N/A positivePrefix = df.getPositivePrefix();

0N/A if (positivePrefix.length() > 0)

0N/A positivePrefix = "\\Q" + positivePrefix + "\\E";

869N/A negativePrefix = df.getNegativePrefix();

868N/A if (negativePrefix.length() > 0)

0N/A negativePrefix = "\\Q" + negativePrefix + "\\E";

869N/A positiveSuffix = df.getPositiveSuffix();

0N/A if (positiveSuffix.length() > 0)

0N/A positiveSuffix = "\\Q" + positiveSuffix + "\\E";

0N/A negativeSuffix = df.getNegativeSuffix();

0N/A if (negativeSuffix.length() > 0)

0N/A negativeSuffix = "\\Q" + negativeSuffix + "\\E";

869N/A

868N/A // Force rebuilding and recompilation of locale dependent

0N/A // primitive patterns

869N/A integerPattern = null;

0N/A floatPattern = null;

0N/A

0N/A return this;

0N/A }

0N/A

869N/A /**

0N/A public int radix() {

0N/A return this.defaultRadix;

869N/A }

0N/A

0N/A /**

868N/A public Scanner useRadix(int radix) {

0N/A if ((radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX))

0N/A throw new IllegalArgumentException("radix:"+radix);

0N/A

869N/A if (this.defaultRadix == radix)

868N/A return this;

0N/A this.defaultRadix = radix;

0N/A // Force rebuilding and recompilation of radix dependent patterns

0N/A integerPattern = null;

0N/A return this;

0N/A }

869N/A

0N/A // The next operation should occur in the specified radix but

0N/A // the default is left untouched.

0N/A private void setRadix(int radix) {

914N/A if (this.radix != radix) {

914N/A // Force rebuilding and recompilation of radix dependent patterns

914N/A integerPattern = null;

914N/A this.radix = radix;

914N/A }

914N/A }

914N/A

0N/A /**

0N/A public MatchResult match() {

0N/A if (!matchValid)

0N/A throw new IllegalStateException("No match result available");

0N/A return matcher.toMatchResult();

0N/A }

869N/A

0N/A /**

0N/A public String toString() {

0N/A StringBuilder sb = new StringBuilder();

0N/A sb.append("java.util.Scanner");

0N/A sb.append("[delimiters=" + delimPattern + "]");

0N/A sb.append("[position=" + position + "]");

0N/A sb.append("[match valid=" + matchValid + "]");

869N/A sb.append("[need input=" + needInput + "]");

0N/A sb.append("[source closed=" + sourceClosed + "]");

0N/A sb.append("[skipped=" + skipped + "]");

0N/A sb.append("[group separator=" + groupSeparator + "]");

0N/A sb.append("[decimal separator=" + decimalSeparator + "]");

0N/A sb.append("[positive prefix=" + positivePrefix + "]");

0N/A sb.append("[negative prefix=" + negativePrefix + "]");

869N/A sb.append("[positive suffix=" + positiveSuffix + "]");

0N/A sb.append("[negative suffix=" + negativeSuffix + "]");

0N/A sb.append("[NaN string=" + nanString + "]");

0N/A sb.append("[infinity string=" + infinityString + "]");

0N/A return sb.toString();

0N/A }

0N/A

869N/A /**

0N/A public boolean hasNext() {

0N/A ensureOpen();

0N/A saveState();

0N/A while (!sourceClosed) {

0N/A if (hasTokenInBuffer())

869N/A return revertState(true);

0N/A readInput();

0N/A }

0N/A boolean result = hasTokenInBuffer();

0N/A return revertState(result);

0N/A }

869N/A

868N/A /**