JSONtokener的源代码，了解JSONtokener.
当我们一个服务器从android客户端接受数据的时候，我就需要JSONtokener对象，
在此我给大家把源码给找了出来。当然这个是最全的源码网站，包括JSONtokener用到的包。
直接给大家附上http://opensourcejavaphp.net/java/json/net/sf/json/util/JSONTokener.java.html
JSONTokener.java
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sf.json.util;
import net.sf.json.JSONArray;
import net.sf.json.JSONException;
import net.sf.json.JSONNull;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.regexp.RegexpUtils;
/**
* A JSONTokener takes a source string and extracts characters and tokens from
* it. It is used by the JSONObject and JSONArray constructors to parse JSON
* source strings.
*
* @author JSON.org
* @version 4
*/
public class JSONTokener {
/**
* Get the hex value of a character (base16).
*
* @param c A character between '0' and '9' or between 'A' and 'F' or between
* 'a' and 'f'.
* @return An int between 0 and 15, or -1 if c was not a hex digit.
*/
public static int dehexchar( 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;
}
/**
* The index of the next character.
*/
private int myIndex;
/**
* The source string being tokenized.
*/
private String mySource;
/**
* Construct a JSONTokener from a string.
*
* @param s A source string.
*/
public JSONTokener( String s ) {
this.myIndex = 0;
if( s!= null ) {
s = s.trim();
} else {
s = "";
}
if( s.length() > 0 ){
char first = s.charAt( 0 );
char last = s.charAt( s.length() - 1 );
if( first == '[' && last != ']' ) {
throw syntaxError( "Found starting '[' but missing ']' at the end." );
}
if( first == '{' && last != '}' ) {
throw syntaxError( "Found starting '{' but missing '}' at the end." );
}
}
this.mySource = s;
}
/**
* 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.
*/
public void back() {
if( this.myIndex > 0 ){
this.myIndex -= 1;
}
}
public int length() {
if( this.mySource == null ){
return 0;
}
return this.mySource.length();
}
public boolean matches( String pattern ) {
String str = this.mySource.substring( this.myIndex );
return RegexpUtils.getMatcher( pattern )
.matches( str );
}
/**
* Determine if the source string still contains characters that next() can
* consume.
*
* @return true if not yet at the end of the source.
*/
public boolean more() {
return this.myIndex < this.mySource.length();
}
/**
* Get the next character in the source string.
*
* @return The next character, or 0 if past the end of the source string.
*/
public char next() {
if( more() ){
char c = this.mySource.charAt( this.myIndex );
this.myIndex += 1;
return c;
}
return 0;
}
/**
* Consume the next character, and check that it matches a specified
* character.
*
* @param c The character to match.
* @return The character.
* @throws JSONException if the character does not match.
*/
public char next( char c ) {
char n = next();
if( n != c ){
throw syntaxError( "Expected '" + c + "' and instead saw '" + n + "'." );
}
return n;
}
/**
* Get the next n characters.
*
* @param n The number of characters to take.
* @return A string of n characters.
* @throws JSONException Substring bounds error if there are not n characters
* remaining in the source string.
*/
public String next( int n ) {
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 );
}
/**
* Get the next char in the string, skipping whitespace and comments
* (slashslash, slashstar, and hash).
*
* @throws JSONException
* @return A character, or 0 if there are no more characters.
*/
public char nextClean() {
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;
}
}
}
/**
* 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.
*
* @param quote The quoting character, either " (double
* quote) or ' (single quote).
* @return A String.
* @throws JSONException Unterminated string.
*/
public String nextString( char quote ) {
char c;
StringBuffer sb = new StringBuffer();
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 );
}
}
}
/**
* Get the text up but not including the specified character or the end of
* line, whichever comes first.
*
* @param d A delimiter character.
* @return A string.
*/
public String nextTo( char d ) {
StringBuffer sb = new StringBuffer();
for( ;; ){
char c = next();
if( c == d || c == 0 || c == '\n' || c == '\r' ){
if( c != 0 ){
back();
}
return sb.toString()
.trim();
}
sb.append( c );
}
}
/**
* Get the text up but not including one of the specified delimeter
* characters or the end of line, whichever comes first.
*
* @param delimiters A set of delimiter characters.
* @return A string, trimmed.
*/
public String nextTo( String delimiters ) {
char c;
StringBuffer sb = new StringBuffer();
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 );
}
}
/**
* Get the next value. The value can be a Boolean, Double, Integer,
* JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object.
*
* @throws JSONException If syntax error.
* @return An object.
*/
public Object nextValue() {
return nextValue( new JsonConfig() );
}
/**
* Get the next value. The value can be a Boolean, Double, Integer,
* JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object.
*
* @throws JSONException If syntax error.
* @return An object.
*/
public Object nextValue( JsonConfig jsonConfig ) {
char c = nextClean();
String s;
switch( c ){
case '"':
case '\'':
return nextString( c );
case '{':
back();
return JSONObject.fromObject( this, jsonConfig );
case '[':
back();
return JSONArray.fromObject( this, jsonConfig );
default:
// empty
}
/*
* 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.
*/
StringBuffer sb = new StringBuffer();
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.equals( "null" ) ||
(jsonConfig.isJavascriptCompliant() && s.equals("undefined"))){
return JSONNull.getInstance();
}
/*
* 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;
}
}
}
}
if( JSONUtils.isFunctionHeader( s ) || JSONUtils.isFunction( s ) ){
return s;
}
switch( peek() ){
case ',':
case '}':
case '{':
case '[':
case ']':
throw new JSONException( "Unquotted string '" + s + "'" );
}
return s;
}
/**
* Look at the next character in the source string.
*
* @return The next character, or 0 if past the end of the source string.
*/
public char peek() {
if( more() ){
char c = this.mySource.charAt( this.myIndex );
return c;
}
return 0;
}
public void reset() {
this.myIndex = 0;
}
/**
* Skip characters until past the requested string. If it is not found, we
* are left at the end of the source.
*
* @param to A string to skip past.
*/
public void skipPast( String to ) {
this.myIndex = this.mySource.indexOf( to, this.myIndex );
if( this.myIndex < 0 ){
this.myIndex = this.mySource.length();
}else{
this.myIndex += to.length();
}
}
/**
* Skip characters until the next character is the requested character. If
* the requested character is not found, no characters are skipped.
*
* @param to A character to skip to.
* @return The requested character, or zero if the requested character is not
* found.
*/
public char skipTo( char to ) {
char c;
int index = this.myIndex;
do{
c = next();
if( c == 0 ){
this.myIndex = index;
return c;
}
}while( c != to );
back();
return c;
}
/**
* Make a JSONException to signal a syntax error.
*
* @param message The error message.
* @return A JSONException object, suitable for throwing
*/
public JSONException syntaxError( String message ) {
return new JSONException( message + toString() );
}
/**
* Make a printable string of this JSONTokener.
*
* @return " at character [this.myIndex] of [this.mySource]"
*/
public String toString() {
return " at character " + this.myIndex + " of " + this.mySource;
}
}