0N/A

0N/Apackage java.util;

0N/A

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

3471N/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;

3479N/A

0N/Aimport sun.misc.LRUCache;

0N/A

2574N/Apublic final class Scanner implements Iterator<String>, Closeable {

0N/A

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

0N/A private CharBuffer buf;

0N/A

0N/A // Size of internal character buffer

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

0N/A

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

0N/A private int position;

0N/A

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

0N/A private Matcher matcher;

0N/A

0N/A // Pattern used to delimit tokens

0N/A private Pattern delimPattern;

0N/A

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

0N/A private Pattern hasNextPattern;

0N/A

0N/A // Position after last hasNext operation

0N/A private int hasNextPosition;

0N/A

0N/A // Result after last hasNext operation

0N/A private String hasNextResult;

0N/A

0N/A // The input source

0N/A private Readable source;

0N/A

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

0N/A private boolean sourceClosed = false;

0N/A

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

0N/A private boolean needInput = false;

0N/A

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

0N/A private boolean skipped = false;

0N/A

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

0N/A private int savedScannerPosition = -1;

0N/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

0N/A private boolean matchValid = false;

0N/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;

0N/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

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

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

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

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

0N/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 }

0N/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(

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

0N/A

0N/A // A pattern for any token

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

0N/A

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

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

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

0N/A

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

0N/A

0N/A /**

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

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

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

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

0N/A private String positivePrefix = "";

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

0N/A private String positiveSuffix = "";

0N/A private String negativeSuffix = "";

0N/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)

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

0N/A Pattern.CASE_INSENSITIVE);

0N/A return bp;

0N/A }

0N/A

0N/A /**

0N/A private Pattern integerPattern;

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

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

0N/A private int SIMPLE_GROUP_INDEX = 5;

0N/A private String buildIntegerPatternString() {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

0N/A negativeInteger + ")";

0N/A }

0N/A private Pattern integerPattern() {

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

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

0N/A }

0N/A return integerPattern;

0N/A }

0N/A

0N/A /**

0N/A private static volatile Pattern separatorPattern;

0N/A private static volatile Pattern linePattern;

0N/A private static final String LINE_SEPARATOR_PATTERN =

0N/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() {

0N/A Pattern sp = separatorPattern;

0N/A if (sp == null)

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

0N/A return sp;

0N/A }

0N/A

0N/A private static Pattern linePattern() {

0N/A Pattern lp = linePattern;

0N/A if (lp == null)

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

0N/A return lp;

0N/A }

0N/A

0N/A /**

0N/A private Pattern floatPattern;

0N/A private Pattern decimalPattern;

0N/A private void buildFloatAndDecimalPattern() {

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

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

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

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

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

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

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

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

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

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

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

0N/A infinityString+")";

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

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

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

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

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

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

0N/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 +

0N/A negativeSuffix + ")";

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

0N/A positiveNonNumber + "|" +

0N/A negativeNonNumber + ")";

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

0N/A signedNonNumber);

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

0N/A }

0N/A private Pattern floatPattern() {

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

0N/A buildFloatAndDecimalPattern();

0N/A }

0N/A return floatPattern;

0N/A }

0N/A private Pattern decimalPattern() {

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

0N/A buildFloatAndDecimalPattern();

0N/A }

0N/A return decimalPattern;

0N/A }

0N/A

0N/A // Constructors

0N/A

0N/A /**

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

3377N/A assert source != null : "source should not be null";

3377N/A assert pattern != null : "pattern should not be null";

0N/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);

0N/A matcher.useTransparentBounds(true);

0N/A matcher.useAnchoringBounds(false);

2700N/A useLocale(Locale.getDefault(Locale.Category.FORMAT));

0N/A }

0N/A

0N/A /**

0N/A public Scanner(Readable source) {

3479N/A this(Objects.requireNonNull(source, "source"), WHITESPACE_PATTERN);

0N/A }

0N/A

0N/A /**

0N/A public Scanner(InputStream source) {

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

0N/A }

0N/A

0N/A /**

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

3479N/A this(makeReadable(Objects.requireNonNull(source, "source"), toCharset(charsetName)),

3377N/A WHITESPACE_PATTERN);

0N/A }

0N/A

3377N/A /**

3377N/A private static Charset toCharset(String csn) {

3479N/A Objects.requireNonNull(csn, "charsetName");

0N/A try {

3377N/A return Charset.forName(csn);

3377N/A } catch (IllegalCharsetNameException|UnsupportedCharsetException e) {

3377N/A // IllegalArgumentException should be thrown

3377N/A throw new IllegalArgumentException(e);

0N/A }

3377N/A }

3377N/A

3377N/A private static Readable makeReadable(InputStream source, Charset charset) {

3377N/A return new InputStreamReader(source, charset);

0N/A }

0N/A

0N/A /**

3377N/A public Scanner(File source) throws FileNotFoundException {

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

0N/A }

0N/A

0N/A /**

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

0N/A throws FileNotFoundException

0N/A {

3479N/A this(Objects.requireNonNull(source), toDecoder(charsetName));

3377N/A }

3377N/A

3377N/A private Scanner(File source, CharsetDecoder dec)

3377N/A throws FileNotFoundException

3377N/A {

3377N/A this(makeReadable((ReadableByteChannel)(new FileInputStream(source).getChannel()), dec));

3377N/A }

3377N/A

3377N/A private static CharsetDecoder toDecoder(String charsetName) {

3479N/A Objects.requireNonNull(charsetName, "charsetName");

3377N/A try {

3377N/A return Charset.forName(charsetName).newDecoder();

3377N/A } catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {

3377N/A throw new IllegalArgumentException(charsetName);

3377N/A }

3377N/A }

3377N/A

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

3377N/A CharsetDecoder dec) {

3377N/A return Channels.newReader(source, dec, -1);

0N/A }

0N/A

0N/A /**

3471N/A public Scanner(Path source)

893N/A throws IOException

893N/A {

3471N/A this(Files.newInputStream(source));

893N/A }

893N/A

893N/A /**

3471N/A public Scanner(Path source, String charsetName) throws IOException {

3479N/A this(Objects.requireNonNull(source), toCharset(charsetName));

3377N/A }

3377N/A

3471N/A private Scanner(Path source, Charset charset) throws IOException {

3471N/A this(makeReadable(Files.newInputStream(source), charset));

893N/A }

893N/A

893N/A /**

0N/A public Scanner(String source) {

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

0N/A }

0N/A

0N/A /**

0N/A public Scanner(ReadableByteChannel source) {

3479N/A this(makeReadable(Objects.requireNonNull(source, "source")),

3377N/A WHITESPACE_PATTERN);

0N/A }

0N/A

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

3377N/A return makeReadable(source, Charset.defaultCharset().newDecoder());

0N/A }

0N/A

0N/A /**

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

3479N/A this(makeReadable(Objects.requireNonNull(source, "source"), toDecoder(charsetName)),

3377N/A WHITESPACE_PATTERN);

0N/A }

0N/A

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

0N/A

0N/A private void saveState() {

0N/A savedScannerPosition = position;

0N/A }

0N/A

0N/A private void revertState() {

0N/A this.position = savedScannerPosition;

0N/A savedScannerPosition = -1;

0N/A skipped = false;

0N/A }

0N/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

0N/A private void cacheResult() {

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

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

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

0N/A }

0N/A

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

0N/A hasNextResult = result;

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

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

0N/A }

0N/A

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

0N/A private void clearCaches() {

0N/A hasNextPattern = null;

0N/A typeCache = null;

0N/A }

0N/A

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

0N/A private String getCachedResult() {

0N/A position = hasNextPosition;

0N/A hasNextPattern = null;

0N/A typeCache = null;

0N/A return hasNextResult;

0N/A }

0N/A

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

0N/A private void useTypeCache() {

0N/A if (closed)

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

0N/A position = hasNextPosition;

0N/A hasNextPattern = null;

0N/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

0N/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

0N/A int n = 0;

0N/A try {

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

0N/A } catch (IOException ioe) {

0N/A lastException = ioe;

0N/A n = -1;

0N/A }

0N/A

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

0N/A sourceClosed = true;

0N/A needInput = false;

0N/A }

0N/A

0N/A if (n > 0)

0N/A needInput = false;

0N/A

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

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

0N/A buf.position(p);

0N/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;

0N/A buf.position(offset);

0N/A // Gain space by compacting buffer

0N/A if (offset > 0) {

0N/A buf.compact();

0N/A translateSavedIndexes(offset);

0N/A position -= offset;

0N/A buf.flip();

0N/A return true;

0N/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);

0N/A newBuf.flip();

0N/A translateSavedIndexes(offset);

0N/A position -= offset;

0N/A buf = newBuf;

0N/A matcher.reset(buf);

0N/A return true;

0N/A }

0N/A

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

0N/A // be modified appropriately

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

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

0N/A savedScannerPosition -= offset;

0N/A }

0N/A

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

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

0N/A private void throwFor() {

0N/A skipped = false;

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

0N/A throw new NoSuchElementException();

0N/A else

0N/A throw new InputMismatchException();

0N/A }

0N/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

0N/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())

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

0N/A

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

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

0N/A return false;

0N/A

0N/A return true;

0N/A }

0N/A

0N/A /*

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

0N/A matchValid = false;

0N/A

0N/A // Skip delims first

0N/A matcher.usePattern(delimPattern);

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

0N/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

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

0N/A needInput = true;

0N/A return null;

0N/A }

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

0N/A skipped = true;

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

0N/A }

0N/A }

0N/A

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

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

0N/A if (sourceClosed)

0N/A return null;

0N/A needInput = true;

0N/A return null;

0N/A }

0N/A

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

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

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

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

0N/A

0N/A // Then look for next delims

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

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

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

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

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

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

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

0N/A }

0N/A if (foundNextDelim) {

0N/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

0N/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

0N/A // they potentially extend further.

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

0N/A needInput = true;

0N/A return null;

0N/A }

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

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

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

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

0N/A pattern = FIND_ANY_PATTERN;

0N/A }

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

0N/A matcher.usePattern(pattern);

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

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

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

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

0N/A return s;

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

0N/A return null;

0N/A }

0N/A }

0N/A

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

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

0N/A if (sourceClosed) {

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

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

0N/A pattern = FIND_ANY_PATTERN;

0N/A }

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

0N/A matcher.usePattern(pattern);

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

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

0N/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;

0N/A }

0N/A

0N/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 }

0N/A

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

0N/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();

0N/A int horizonLimit = -1;

0N/A int searchLimit = bufferLimit;

0N/A if (horizon > 0) {

0N/A horizonLimit = position + horizon;

0N/A if (horizonLimit < bufferLimit)

0N/A searchLimit = horizonLimit;

0N/A }

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

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

0N/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;

0N/A return null;

0N/A }

0N/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.

0N/A needInput = true;

0N/A return null;

0N/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();

0N/A }

0N/A

0N/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

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

0N/A needInput = true;

0N/A return null;

0N/A }

0N/A

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

0N/A // the current position

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

0N/A matchValid = false;

0N/A matcher.usePattern(pattern);

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

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

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

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

0N/A needInput = true;

0N/A return null;

0N/A }

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

0N/A return matcher.group();

0N/A }

0N/A

0N/A if (sourceClosed)

0N/A return null;

0N/A

0N/A // Read more to find pattern

0N/A needInput = true;

0N/A return null;

0N/A }

0N/A

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

0N/A private void ensureOpen() {

0N/A if (closed)

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

0N/A }

0N/A

0N/A // Public methods

0N/A

0N/A /**

0N/A public void close() {

0N/A if (closed)

0N/A return;

0N/A if (source instanceof Closeable) {

0N/A try {

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

0N/A } catch (IOException ioe) {

0N/A lastException = ioe;

0N/A }

0N/A }

0N/A sourceClosed = true;

0N/A source = null;

0N/A closed = true;

0N/A }

0N/A

0N/A /**

0N/A public IOException ioException() {

0N/A return lastException;

0N/A }

0N/A

0N/A /**

0N/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

0N/A /**

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

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

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public Locale locale() {

0N/A return this.locale;

0N/A }

0N/A

0N/A /**

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

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

0N/A return this;

0N/A

0N/A this.locale = locale;

0N/A DecimalFormat df =

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

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

0N/A

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

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

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

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

0N/A

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

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

0N/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";

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

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

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

0N/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";

0N/A

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

0N/A // primitive patterns

0N/A integerPattern = null;

0N/A floatPattern = null;

0N/A

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public int radix() {

0N/A return this.defaultRadix;

0N/A }

0N/A

0N/A /**

0N/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

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

0N/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 }

0N/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) {

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

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

0N/A integerPattern = null;

0N/A this.radix = radix;

0N/A }

0N/A }

0N/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 }

0N/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 + "]");

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

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

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