/** The Character '&'. */

public static final Character AMP = '&';

/** The Character '''. */

public static final Character APOS = '\'';

/** The Character '!'. */

public static final Character BANG = '!';

/** The Character '='. */

public static final Character EQ = '=';

/** The Character '>'. */

public static final Character GT = '>';

/** The Character '<'. */

public static final Character LT = '<';

/** The Character '?'. */

public static final Character QUEST = '?';

/** The Character '"'. */

public static final Character QUOT = '"';

/** The Character '/'. */

public static final Character SLASH = '/';

/**

public static final String NULL_ATTR = "xsi:nil";

/**

private static Iterable<Integer> codePointIterator(final String string) {

return new Iterable<Integer>() {

@Override

public Iterator<Integer> iterator() {

return new Iterator<Integer>() {

private int nextIndex = 0;

private int length = string.length();

@Override

public boolean hasNext() {

return this.nextIndex < this.length;

}

@Override

public Integer next() {

int result = string.codePointAt(this.nextIndex);

this.nextIndex += Character.charCount(result);

return result;

}

@Override

public void remove() {

throw new UnsupportedOperationException();

}

};

}

};

}

/**

public static String escape(String string) {

StringBuilder sb = new StringBuilder(string.length());

for (final int cp : codePointIterator(string)) {

switch (cp) {

case '&':

sb.append("&amp;");

break;

case '<':

sb.append("&lt;");

break;

case '>':

sb.append("&gt;");

break;

case '"':

sb.append("&quot;");

break;

case '\'':

sb.append("&apos;");

break;

default:

if (mustEscape(cp)) {

sb.append("&#x");

sb.append(Integer.toHexString(cp));

sb.append(';');

} else {

sb.appendCodePoint(cp);

}

}

}

return sb.toString();

}

/**

private static boolean mustEscape(int cp) {

/* Valid range from https://www.w3.org/TR/REC-xml/#charsets

// isISOControl is true when (cp >= 0 && cp <= 0x1F) || (cp >= 0x7F && cp <= 0x9F)

// all ISO control characters are out of range except tabs and new lines

return (Character.isISOControl(cp)

&& cp != 0x9

&& cp != 0xA

&& cp != 0xD

) || !(

// valid the range of acceptable characters that aren't control

(cp >= 0x20 && cp <= 0xD7FF)

|| (cp >= 0xE000 && cp <= 0xFFFD)

|| (cp >= 0x10000 && cp <= 0x10FFFF)

)

;

}

/**

public static String unescape(String string) {

StringBuilder sb = new StringBuilder(string.length());

for (int i = 0, length = string.length(); i < length; i++) {

char c = string.charAt(i);

if (c == '&') {

final int semic = string.indexOf(';', i);

if (semic > i) {

final String entity = string.substring(i + 1, semic);

sb.append(XMLTokener.unescapeEntity(entity));

// skip past the entity we just parsed.

i += entity.length() + 1;

} else {

// this shouldn't happen in most cases since the parser

// errors on unclosed entries.

sb.append(c);

}

} else {

// not part of an entity

sb.append(c);

}

}

return sb.toString();

}

/**

public static void noSpace(String string) throws JSONException {

int i, length = string.length();

if (length == 0) {

throw new JSONException("Empty string.");

}

for (i = 0; i < length; i += 1) {

if (Character.isWhitespace(string.charAt(i))) {

throw new JSONException("'" + string

+ "' contains a space character.");

}

}

}

/**

private static boolean parse(XMLTokener x, JSONObject context, String name, XMLParserConfiguration config)

throws JSONException {

char c;

int i;

JSONObject jsonObject = null;

String string;

String tagName;

Object token;

// Test for and skip past these forms:

// <!-- ... -->

// <! ... >

// <![ ... ]]>

// <? ... ?>

// Report errors for these forms:

// <>

// <=

// <<

token = x.nextToken();

// <!

if (token == BANG) {

c = x.next();

if (c == '-') {

if (x.next() == '-') {

x.skipPast("-->");

return false;

}

x.back();

} else if (c == '[') {

token = x.nextToken();

if ("CDATA".equals(token)) {

if (x.next() == '[') {

string = x.nextCDATA();

if (string.length() > 0) {

context.accumulate(config.cDataTagName, string);

}

return false;

}

}

throw x.syntaxError("Expected 'CDATA['");

}

i = 1;

do {

token = x.nextMeta();

if (token == null) {

throw x.syntaxError("Missing '>' after '<!'.");

} else if (token == LT) {

i += 1;

} else if (token == GT) {

i -= 1;

}

} while (i > 0);

return false;

} else if (token == QUEST) {

// <?

x.skipPast("?>");

return false;

} else if (token == SLASH) {

// Close tag </

token = x.nextToken();

if (name == null) {

throw x.syntaxError("Mismatched close tag " + token);

}

if (!token.equals(name)) {

throw x.syntaxError("Mismatched " + name + " and " + token);

}

if (x.nextToken() != GT) {

throw x.syntaxError("Misshaped close tag");

}

return true;

} else if (token instanceof Character) {

throw x.syntaxError("Misshaped tag");

// Open tag <

} else {

tagName = (String) token;

token = null;

jsonObject = new JSONObject();

boolean nilAttributeFound = false;

for (;;) {

if (token == null) {

token = x.nextToken();

}

// attribute = value

if (token instanceof String) {

string = (String) token;

token = x.nextToken();

if (token == EQ) {

token = x.nextToken();

if (!(token instanceof String)) {

throw x.syntaxError("Missing value");

}

if (config.convertNilAttributeToNull

&& NULL_ATTR.equals(string)

&& Boolean.parseBoolean((String) token)) {

nilAttributeFound = true;

} else if (!nilAttributeFound) {

jsonObject.accumulate(string,

config.keepStrings

? ((String) token)

: stringToValue((String) token));

}

token = null;

} else {

jsonObject.accumulate(string, "");

}

} else if (token == SLASH) {

// Empty tag <.../>

if (x.nextToken() != GT) {

throw x.syntaxError("Misshaped tag");

}

if (nilAttributeFound) {

context.accumulate(tagName, JSONObject.NULL);

} else if (jsonObject.length() > 0) {

context.accumulate(tagName, jsonObject);

} else {

context.accumulate(tagName, "");

}

return false;

} else if (token == GT) {

// Content, between <...> and </...>

for (;;) {

token = x.nextContent();

if (token == null) {

if (tagName != null) {

throw x.syntaxError("Unclosed tag " + tagName);

}

return false;

} else if (token instanceof String) {

string = (String) token;

if (string.length() > 0) {

jsonObject.accumulate(config.cDataTagName,

config.keepStrings ? string : stringToValue(string));

}

} else if (token == LT) {

// Nested element

if (parse(x, jsonObject, tagName, config)) {

if (jsonObject.length() == 0) {

context.accumulate(tagName, "");

} else if (jsonObject.length() == 1

&& jsonObject.opt(config.cDataTagName) != null) {

context.accumulate(tagName, jsonObject.opt(config.cDataTagName));

} else {

context.accumulate(tagName, jsonObject);

}

return false;

}

}

}

} else {

throw x.syntaxError("Misshaped tag");

}

}

}

}

/**

// To maintain compatibility with the Android API, this method is a direct copy of

// the one in JSONObject. Changes made here should be reflected there.

public static Object stringToValue(String string) {

if (string.equals("")) {

return string;

}

if (string.equalsIgnoreCase("true")) {

return Boolean.TRUE;

}

if (string.equalsIgnoreCase("false")) {

return Boolean.FALSE;

}

if (string.equalsIgnoreCase("null")) {

return JSONObject.NULL;

}

/*

char initial = string.charAt(0);

if ((initial >= '0' && initial <= '9') || initial == '-') {

try {

// if we want full Big Number support this block can be replaced with:

// return stringToNumber(string);

if (string.indexOf('.') > -1 || string.indexOf('e') > -1

|| string.indexOf('E') > -1 || "-0".equals(string)) {

Double d = Double.valueOf(string);

if (!d.isInfinite() && !d.isNaN()) {

return d;

}

} else {

Long myLong = Long.valueOf(string);

if (string.equals(myLong.toString())) {

if (myLong.longValue() == myLong.intValue()) {

return Integer.valueOf(myLong.intValue());

}

return myLong;

}

}

} catch (Exception ignore) {

}

}

return string;

}

/**

public static JSONObject toJSONObject(String string) throws JSONException {

return toJSONObject(string, XMLParserConfiguration.ORIGINAL);

}

/**

public static JSONObject toJSONObject(Reader reader) throws JSONException {

return toJSONObject(reader, XMLParserConfiguration.ORIGINAL);

}

/**

public static JSONObject toJSONObject(Reader reader, boolean keepStrings) throws JSONException {

if(keepStrings) {

return toJSONObject(reader, XMLParserConfiguration.KEEP_STRINGS);

}

return toJSONObject(reader, XMLParserConfiguration.ORIGINAL);

}

/**

public static JSONObject toJSONObject(Reader reader, XMLParserConfiguration config) throws JSONException {

JSONObject jo = new JSONObject();

XMLTokener x = new XMLTokener(reader);

while (x.more()) {

x.skipPast("<");

if(x.more()) {

parse(x, jo, null, config);

}

}

return jo;

}

/**

public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {

return toJSONObject(new StringReader(string), keepStrings);

}

/**

public static JSONObject toJSONObject(String string, XMLParserConfiguration config) throws JSONException {

return toJSONObject(new StringReader(string), config);

}

/**

public static String toString(Object object) throws JSONException {

return toString(object, null, XMLParserConfiguration.ORIGINAL);

}

/**

public static String toString(final Object object, final String tagName) {

return toString(object, tagName, XMLParserConfiguration.ORIGINAL);

}

/**

public static String toString(final Object object, final String tagName, final XMLParserConfiguration config)

throws JSONException {

StringBuilder sb = new StringBuilder();

JSONArray ja;

JSONObject jo;

String string;

if (object instanceof JSONObject) {

// Emit <tagName>

if (tagName != null) {

sb.append('<');

sb.append(tagName);

sb.append('>');

}

// Loop thru the keys.

// don't use the new entrySet accessor to maintain Android Support

jo = (JSONObject) object;

for (final String key : jo.keySet()) {

Object value = jo.opt(key);

if (value == null) {

value = "";

} else if (value.getClass().isArray()) {

value = new JSONArray(value);

}

// Emit content in body

if (key.equals(config.cDataTagName)) {

if (value instanceof JSONArray) {

ja = (JSONArray) value;

int jaLength = ja.length();

// don't use the new iterator API to maintain support for Android

for (int i = 0; i < jaLength; i++) {

if (i > 0) {

sb.append('\n');

}

Object val = ja.opt(i);

sb.append(escape(val.toString()));

}

} else {

sb.append(escape(value.toString()));

}

// Emit an array of similar keys

} else if (value instanceof JSONArray) {

ja = (JSONArray) value;

int jaLength = ja.length();

// don't use the new iterator API to maintain support for Android

for (int i = 0; i < jaLength; i++) {

Object val = ja.opt(i);

if (val instanceof JSONArray) {

sb.append('<');

sb.append(key);

sb.append('>');

sb.append(toString(val, null, config));

sb.append("</");

sb.append(key);

sb.append('>');

} else {

sb.append(toString(val, key, config));

}

}

} else if ("".equals(value)) {

sb.append('<');

sb.append(key);

sb.append("/>");

// Emit a new tag <k>

} else {

sb.append(toString(value, key, config));

}

}

if (tagName != null) {

// Emit the </tagName> close tag

sb.append("</");

sb.append(tagName);

sb.append('>');

}

return sb.toString();

}

if (object != null && (object instanceof JSONArray || object.getClass().isArray())) {

if(object.getClass().isArray()) {

ja = new JSONArray(object);

} else {

ja = (JSONArray) object;

}

int jaLength = ja.length();

// don't use the new iterator API to maintain support for Android

for (int i = 0; i < jaLength; i++) {

Object val = ja.opt(i);

// XML does not have good support for arrays. If an array

// appears in a place where XML is lacking, synthesize an

// <array> element.

sb.append(toString(val, tagName == null ? "array" : tagName, config));

}

return sb.toString();

}

string = (object == null) ? "null" : escape(object.toString());

return (tagName == null) ? "\"" + string + "\""

: (string.length() == 0) ? "<" + tagName + "/>" : "<" + tagName

+ ">" + string + "</" + tagName + ">";

}