| Methods Summary |
|---|
| public void | back()Back up one character. This provides a sort of lookahead capability,
so that you can test for a digit or letter before attempting to parse
the next number or identifier.
if (this.myIndex > 0) {
this.myIndex -= 1;
}
|
| public static int | dehexchar(char c)Get the hex value of a character (base16).
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 | more()Determine if the source string still contains characters that next()
can consume.
return this.myIndex < this.mySource.length();
|
| public char | next()Get the next character in the source string.
if (more()) {
char c = this.mySource.charAt(this.myIndex);
this.myIndex += 1;
return c;
}
return 0;
|
| public char | next(char c)Consume the next character, and check that it matches a specified
character.
char n = next();
if (n != c) {
throw syntaxError("Expected '" + c + "' and instead saw '" +
n + "'.");
}
return n;
|
| public java.lang.String | next(int n)Get the next n characters.
int i = this.myIndex;
int j = i + n;
if (j >= this.mySource.length()) {
throw syntaxError("Substring bounds error");
}
this.myIndex += n;
return this.mySource.substring(i, j);
|
| public char | nextClean()Get the next char in the string, skipping whitespace
and comments (slashslash, slashstar, and hash).
for (;;) {
char c = next();
if (c == '/") {
switch (next()) {
case '/":
do {
c = next();
} while (c != '\n" && c != '\r" && c != 0);
break;
case '*":
for (;;) {
c = next();
if (c == 0) {
throw syntaxError("Unclosed comment.");
}
if (c == '*") {
if (next() == '/") {
break;
}
back();
}
}
break;
default:
back();
return '/";
}
} else if (c == '#") {
do {
c = next();
} while (c != '\n" && c != '\r" && c != 0);
} else if (c == 0 || c > ' ") {
return c;
}
}
|
| public java.lang.String | nextString(char quote)Return the characters up to the next close quote character.
Backslash processing is done. The formal JSON format does not
allow strings in single quotes, but an implementation is allowed to
accept them.
char c;
StringBuilder sb = new StringBuilder();
for (;;) {
c = next();
switch (c) {
case 0:
case '\n":
case '\r":
throw syntaxError("Unterminated string");
case '\\":
c = 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(next(4), 16));
break;
case 'x" :
sb.append((char) Integer.parseInt(next(2), 16));
break;
default:
sb.append(c);
}
break;
default:
if (c == quote) {
return sb.toString();
}
sb.append(c);
}
}
|
| public java.lang.String | nextTo(char d)Get the text up but not including the specified character or the
end of line, whichever comes first.
StringBuilder sb = new StringBuilder();
for (;;) {
char c = next();
if (c == d || c == 0 || c == '\n" || c == '\r") {
if (c != 0) {
back();
}
return sb.toString().trim();
}
sb.append(c);
}
|
| public java.lang.String | nextTo(java.lang.String delimiters)Get the text up but not including one of the specified delimeter
characters or the end of line, whichever comes first.
char c;
StringBuilder sb = new StringBuilder();
for (;;) {
c = next();
if (delimiters.indexOf(c) >= 0 || c == 0 ||
c == '\n" || c == '\r") {
if (c != 0) {
back();
}
return sb.toString().trim();
}
sb.append(c);
}
|
| public java.lang.Object | nextValue()Get the next value. The value can be a Boolean, Double, Integer,
JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object.
char c = nextClean();
String s;
switch (c) {
case '"":
case '\'":
return nextString(c);
case '{":
back();
return new JSONObject(this);
case '[":
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.
*/
StringBuilder sb = new StringBuilder();
char b = c;
while (c >= ' " && ",:]}/\\\"[{;=#".indexOf(c) < 0) {
sb.append(c);
c = next();
}
back();
/*
* If it is true, false, or null, return the proper value.
*/
s = sb.toString().trim();
if (s.equals("")) {
throw syntaxError("Missing value.");
}
if (s.equalsIgnoreCase("true")) {
return Boolean.TRUE;
}
if (s.equalsIgnoreCase("false")) {
return Boolean.FALSE;
}
if (s.equalsIgnoreCase("null")) {
return JSONObject.NULL;
}
/*
* If it might be a number, try converting it. We support the 0- and 0x-
* conventions. If a number cannot be produced, then the value will just
* be a string. Note that the 0-, 0x-, plus, and implied string
* conventions are non-standard. A JSON parser is free to accept
* non-JSON forms as long as it accepts all correct JSON forms.
*/
if ((b >= '0" && b <= '9") || b == '." || b == '-" || b == '+") {
if (b == '0") {
if (s.length() > 2 &&
(s.charAt(1) == 'x" || s.charAt(1) == 'X")) {
try {
return new Integer(Integer.parseInt(s.substring(2),
16));
} catch (Exception e) {
/* Ignore the error */
}
} else {
try {
return new Integer(Integer.parseInt(s, 8));
} catch (Exception e) {
/* Ignore the error */
}
}
}
try {
return new Integer(s);
} catch (Exception e) {
try {
return new Long(s);
} catch (Exception f) {
try {
return new Double(s);
} catch (Exception g) {
return s;
}
}
}
}
return s;
|
| public void | skipPast(java.lang.String to)Skip characters until past the requested string.
If it is not found, we are left at the end of the source.
this.myIndex = this.mySource.indexOf(to, this.myIndex);
if (this.myIndex < 0) {
this.myIndex = this.mySource.length();
} else {
this.myIndex += to.length();
}
|
| public char | skipTo(char to)Skip characters until the next character is the requested character.
If the requested character is not found, no characters are skipped.
char c;
int index = this.myIndex;
do {
c = next();
if (c == 0) {
this.myIndex = index;
return c;
}
} while (c != to);
back();
return c;
|
| public org.json.JSONException | syntaxError(java.lang.String message)Make a JSONException to signal a syntax error.
return new JSONException(message + toString());
|
| public java.lang.String | toString()Make a printable string of this JSONTokener.
return " at character " + this.myIndex + " of " + this.mySource;
|
