316 lines
7.1 KiB
Java
316 lines
7.1 KiB
Java
package cn.citycraft.plugins.json;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.Reader;
|
|
import java.io.StringReader;
|
|
|
|
/*
|
|
* Copyright (c) 2002 JSON.org
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* The Software shall be used for Good, not Evil.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
public class JSONTokener {
|
|
|
|
private long character;
|
|
private boolean eof;
|
|
private long index;
|
|
private long line;
|
|
private char previous;
|
|
private final Reader reader;
|
|
private boolean usePrevious;
|
|
|
|
public JSONTokener(final Reader reader) {
|
|
this.reader = reader.markSupported() ? reader : new BufferedReader(reader);
|
|
this.eof = false;
|
|
this.usePrevious = false;
|
|
this.previous = 0;
|
|
this.index = 0;
|
|
this.character = 1;
|
|
this.line = 1;
|
|
}
|
|
|
|
public JSONTokener(final InputStream inputStream) throws JSONException {
|
|
this(new InputStreamReader(inputStream));
|
|
}
|
|
|
|
public JSONTokener(final String s) {
|
|
this(new StringReader(s));
|
|
}
|
|
|
|
public void back() throws JSONException {
|
|
if (this.usePrevious || this.index <= 0) {
|
|
throw new JSONException("Stepping back two steps is not supported");
|
|
}
|
|
this.index -= 1;
|
|
this.character -= 1;
|
|
this.usePrevious = true;
|
|
this.eof = false;
|
|
}
|
|
|
|
public static int dehexchar(final char c) {
|
|
if (c >= '0' && c <= '9') {
|
|
return c - '0';
|
|
}
|
|
if (c >= 'A' && c <= 'F') {
|
|
return c - ('A' - 10);
|
|
}
|
|
if (c >= 'a' && c <= 'f') {
|
|
return c - ('a' - 10);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public boolean end() {
|
|
return this.eof && !this.usePrevious;
|
|
}
|
|
|
|
public boolean more() throws JSONException {
|
|
this.next();
|
|
if (this.end()) {
|
|
return false;
|
|
}
|
|
this.back();
|
|
return true;
|
|
}
|
|
|
|
public char next() throws JSONException {
|
|
int c;
|
|
if (this.usePrevious) {
|
|
this.usePrevious = false;
|
|
c = this.previous;
|
|
} else {
|
|
try {
|
|
c = this.reader.read();
|
|
} catch (final IOException exception) {
|
|
throw new JSONException(exception);
|
|
}
|
|
|
|
if (c <= 0) { // End of stream
|
|
this.eof = true;
|
|
c = 0;
|
|
}
|
|
}
|
|
this.index += 1;
|
|
if (this.previous == '\r') {
|
|
this.line += 1;
|
|
this.character = c == '\n' ? 0 : 1;
|
|
} else if (c == '\n') {
|
|
this.line += 1;
|
|
this.character = 0;
|
|
} else {
|
|
this.character += 1;
|
|
}
|
|
this.previous = (char) c;
|
|
return this.previous;
|
|
}
|
|
|
|
public char next(final char c) throws JSONException {
|
|
final char n = this.next();
|
|
if (n != c) {
|
|
throw this.syntaxError("Expected '" + c + "' and instead saw '" + n + "'");
|
|
}
|
|
return n;
|
|
}
|
|
|
|
public String next(final int n) throws JSONException {
|
|
if (n == 0) {
|
|
return "";
|
|
}
|
|
|
|
final char[] chars = new char[n];
|
|
int pos = 0;
|
|
|
|
while (pos < n) {
|
|
chars[pos] = this.next();
|
|
if (this.end()) {
|
|
throw this.syntaxError("Substring bounds error");
|
|
}
|
|
pos += 1;
|
|
}
|
|
return new String(chars);
|
|
}
|
|
|
|
public char nextClean() throws JSONException {
|
|
for (;;) {
|
|
final char c = this.next();
|
|
if (c == 0 || c > ' ') {
|
|
return c;
|
|
}
|
|
}
|
|
}
|
|
|
|
public String nextString(final char quote) throws JSONException {
|
|
char c;
|
|
final StringBuffer sb = new StringBuffer();
|
|
for (;;) {
|
|
c = this.next();
|
|
switch (c) {
|
|
case 0:
|
|
case '\n':
|
|
case '\r':
|
|
throw this.syntaxError("Unterminated string");
|
|
case '\\':
|
|
c = this.next();
|
|
switch (c) {
|
|
case 'b':
|
|
sb.append('\b');
|
|
break;
|
|
case 't':
|
|
sb.append('\t');
|
|
break;
|
|
case 'n':
|
|
sb.append('\n');
|
|
break;
|
|
case 'f':
|
|
sb.append('\f');
|
|
break;
|
|
case 'r':
|
|
sb.append('\r');
|
|
break;
|
|
case 'u':
|
|
sb.append((char) Integer.parseInt(this.next(4), 16));
|
|
break;
|
|
case '"':
|
|
case '\'':
|
|
case '\\':
|
|
case '/':
|
|
sb.append(c);
|
|
break;
|
|
default:
|
|
throw this.syntaxError("Illegal escape.");
|
|
}
|
|
break;
|
|
default:
|
|
if (c == quote) {
|
|
return sb.toString();
|
|
}
|
|
sb.append(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
public String nextTo(final char delimiter) throws JSONException {
|
|
final StringBuffer sb = new StringBuffer();
|
|
for (;;) {
|
|
final char c = this.next();
|
|
if (c == delimiter || c == 0 || c == '\n' || c == '\r') {
|
|
if (c != 0) {
|
|
this.back();
|
|
}
|
|
return sb.toString().trim();
|
|
}
|
|
sb.append(c);
|
|
}
|
|
}
|
|
|
|
public String nextTo(final String delimiters) throws JSONException {
|
|
char c;
|
|
final StringBuffer sb = new StringBuffer();
|
|
for (;;) {
|
|
c = this.next();
|
|
if (delimiters.indexOf(c) >= 0 || c == 0 || c == '\n' || c == '\r') {
|
|
if (c != 0) {
|
|
this.back();
|
|
}
|
|
return sb.toString().trim();
|
|
}
|
|
sb.append(c);
|
|
}
|
|
}
|
|
|
|
public Object nextValue() throws JSONException {
|
|
char c = this.nextClean();
|
|
String string;
|
|
|
|
switch (c) {
|
|
case '"':
|
|
case '\'':
|
|
return this.nextString(c);
|
|
case '{':
|
|
this.back();
|
|
return new JSONObject(this);
|
|
case '[':
|
|
this.back();
|
|
return new JSONArray(this);
|
|
}
|
|
|
|
/*
|
|
* Handle unquoted text. This could be the values true, false, or
|
|
* null, or it can be a number. An implementation (such as this one)
|
|
* is allowed to also accept non-standard forms.
|
|
*
|
|
* Accumulate characters until we reach the end of the text or a
|
|
* formatting character.
|
|
*/
|
|
|
|
final StringBuffer sb = new StringBuffer();
|
|
while (c >= ' ' && ",:]}/\\\"[{;=#".indexOf(c) < 0) {
|
|
sb.append(c);
|
|
c = this.next();
|
|
}
|
|
this.back();
|
|
|
|
string = sb.toString().trim();
|
|
if ("".equals(string)) {
|
|
throw this.syntaxError("Missing value");
|
|
}
|
|
return JSONObject.stringToValue(string);
|
|
}
|
|
|
|
public char skipTo(final char to) throws JSONException {
|
|
char c;
|
|
try {
|
|
final long startIndex = this.index;
|
|
final long startCharacter = this.character;
|
|
final long startLine = this.line;
|
|
this.reader.mark(1000000);
|
|
do {
|
|
c = this.next();
|
|
if (c == 0) {
|
|
this.reader.reset();
|
|
this.index = startIndex;
|
|
this.character = startCharacter;
|
|
this.line = startLine;
|
|
return c;
|
|
}
|
|
} while (c != to);
|
|
} catch (final IOException exc) {
|
|
throw new JSONException(exc);
|
|
}
|
|
|
|
this.back();
|
|
return c;
|
|
}
|
|
|
|
public JSONException syntaxError(final String message) {
|
|
return new JSONException(message + this.toString());
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return " at " + this.index + " [character " + this.character + " line " + this.line + "]";
|
|
}
|
|
}
|