Update README

Update LICENSE
Merge pull request #324 from dtalex/JSONPointerOnBeans
2026-01-24 00:03:17 -05:00 · 2017-05-16 00:29:00 -05:00 · 2017-04-18 08:32:10 -05:00 · 2017-03-27 20:04:18 -05:00 · 2017-02-25 14:35:02 +01:00 · 2017-02-25 13:27:50 +01:00
19 changed files with 1126 additions and 269 deletions
--- a/CDL.java
+++ b/CDL.java
@@ -41,7 +41,7 @@ SOFTWARE.
 * The names for the elements in the JSONObjects can be taken from the names
 * in the first row.
 * @author JSON.org
- * @version 2015-05-01
+ * @version 2016-05-01
 */
 public class CDL {

@@ -69,7 +69,12 @@ public class CDL {
            for (;;) {
                c = x.next();
                if (c == q) {
-                    break;
+                    //Handle escaped double-quote
+                    if(x.next() != '\"')
+                    {
+                        x.back();
+                        break;
+                    }
                }
                if (c == 0 || c == '\n' || c == '\r') {
                    throw x.syntaxError("Missing close quote '" + q + "'.");
--- a/Cookie.java
+++ b/Cookie.java
@@ -28,7 +28,7 @@ SOFTWARE.
 * Convert a web browser cookie specification to a JSONObject and back.
 * JSON and Cookies are both notations for name/value pairs.
 * @author JSON.org
- * @version 2014-05-03
+ * @version 2015-12-09
 */
 public class Cookie {

--- a/CookieList.java
+++ b/CookieList.java
@@ -29,7 +29,7 @@ import java.util.Iterator;
 /**
 * Convert a web browser cookie list string to a JSONObject and back.
 * @author JSON.org
- * @version 2014-05-03
+ * @version 2015-12-09
 */
 public class CookieList {

--- a/HTTP.java
+++ b/HTTP.java
@@ -25,11 +25,12 @@ SOFTWARE.
 */

 import java.util.Iterator;
+import java.util.Locale;

 /**
 * Convert an HTTP header to a JSONObject and back.
 * @author JSON.org
- * @version 2014-05-03
+ * @version 2015-12-09
 */
 public class HTTP {

@@ -74,7 +75,7 @@ public class HTTP {
        String         token;

        token = x.nextToken();
-        if (token.toUpperCase().startsWith("HTTP")) {
+        if (token.toUpperCase(Locale.ROOT).startsWith("HTTP")) {

 // Response

--- a/HTTPTokener.java
+++ b/HTTPTokener.java
@@ -28,7 +28,7 @@ SOFTWARE.
 * The HTTPTokener extends the JSONTokener to provide additional methods
 * for the parsing of HTTP headers.
 * @author JSON.org
- * @version 2014-05-03
+ * @version 2015-12-09
 */
 public class HTTPTokener extends JSONTokener {

--- a/JSONArray.java
+++ b/JSONArray.java
@@ -28,10 +28,12 @@ import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.lang.reflect.Array;
-import java.math.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;

 /**
@@ -76,7 +78,7 @@ import java.util.Map;
 * </ul>
 *
 * @author JSON.org
- * @version 2015-10-29
+ * @version 2016-08/15
 */
 public class JSONArray implements Iterable<Object> {

@@ -593,7 +595,9 @@ public class JSONArray implements Iterable<Object> {
                return myE;
            }
            return Enum.valueOf(clazz, val.toString());
-        } catch (IllegalArgumentException | NullPointerException e) {
+        } catch (IllegalArgumentException e) {
+            return defaultValue;
+        } catch (NullPointerException e) {
            return defaultValue;
        }
    }
@@ -956,6 +960,80 @@ public class JSONArray implements Iterable<Object> {
        return this;
    }
    
+    /**
+     * Creates a JSONPointer using an initialization string and tries to 
+     * match it to an item within this JSONArray. For example, given a
+     * JSONArray initialized with this document:
+     * <pre>
+     * [
+     *     {"b":"c"}
+     * ]
+     * </pre>
+     * and this JSONPointer string: 
+     * <pre>
+     * "/0/b"
+     * </pre>
+     * Then this method will return the String "c"
+     * A JSONPointerException may be thrown from code called by this method.
+     *
+     * @param jsonPointer string that can be used to create a JSONPointer
+     * @return the item matched by the JSONPointer, otherwise null
+     */
+    public Object query(String jsonPointer) {
+        return query(new JSONPointer(jsonPointer));
+    }
+    
+    /**
+     * Uses a uaer initialized JSONPointer  and tries to 
+     * match it to an item whithin this JSONArray. For example, given a
+     * JSONArray initialized with this document:
+     * <pre>
+     * [
+     *     {"b":"c"}
+     * ]
+     * </pre>
+     * and this JSONPointer: 
+     * <pre>
+     * "/0/b"
+     * </pre>
+     * Then this method will return the String "c"
+     * A JSONPointerException may be thrown from code called by this method.
+     *
+     * @param jsonPointer string that can be used to create a JSONPointer
+     * @return the item matched by the JSONPointer, otherwise null
+     */
+    public Object query(JSONPointer jsonPointer) {
+        return jsonPointer.queryFrom(this);
+    }
+    
+    /**
+     * Queries and returns a value from this object using {@code jsonPointer}, or
+     * returns null if the query fails due to a missing key.
+     * 
+     * @param jsonPointer the string representation of the JSON pointer
+     * @return the queried value or {@code null}
+     * @throws IllegalArgumentException if {@code jsonPointer} has invalid syntax
+     */
+    public Object optQuery(String jsonPointer) {
+    	return optQuery(new JSONPointer(jsonPointer));
+    }
+    
+    /**
+     * Queries and returns a value from this object using {@code jsonPointer}, or
+     * returns null if the query fails due to a missing key.
+     * 
+     * @param The JSON pointer
+     * @return the queried value or {@code null}
+     * @throws IllegalArgumentException if {@code jsonPointer} has invalid syntax
+     */
+    public Object optQuery(JSONPointer jsonPointer) {
+        try {
+            return jsonPointer.queryFrom(this);
+        } catch (JSONPointerException e) {
+            return null;
+        }
+    }
+
    /**
     * Remove an index and close the hole.
     *
@@ -1083,6 +1161,8 @@ public class JSONArray implements Iterable<Object> {
     * <p>
     * Warning: This method assumes that the data structure is acyclical.
     *
+     * @param writer
+     *            Writes the serialized JSON
     * @param indentFactor
     *            The number of spaces to add to each level of indentation.
     * @param indent
@@ -1090,7 +1170,7 @@ public class JSONArray implements Iterable<Object> {
     * @return The writer.
     * @throws JSONException
     */
-    Writer write(Writer writer, int indentFactor, int indent)
+    public Writer write(Writer writer, int indentFactor, int indent)
            throws JSONException {
        try {
            boolean commanate = false;
@@ -1126,4 +1206,29 @@ public class JSONArray implements Iterable<Object> {
            throw new JSONException(e);
        }
    }
+
+    /**
+     * Returns a java.util.List containing all of the elements in this array.
+     * If an element in the array is a JSONArray or JSONObject it will also
+     * be converted.
+     * <p>
+     * Warning: This method assumes that the data structure is acyclical.
+     *
+     * @return a java.util.List containing the elements of this array
+     */
+    public List<Object> toList() {
+        List<Object> results = new ArrayList<Object>(this.myArrayList.size());
+        for (Object element : this.myArrayList) {
+            if (element == null || JSONObject.NULL.equals(element)) {
+                results.add(null);
+            } else if (element instanceof JSONArray) {
+                results.add(((JSONArray) element).toList());
+            } else if (element instanceof JSONObject) {
+                results.add(((JSONObject) element).toMap());
+            } else {
+                results.add(element);
+            }
+        }
+        return results;
+    }
 }
--- a/JSONException.java
+++ b/JSONException.java
@@ -4,7 +4,7 @@ package org.json;
 * The JSONException is thrown by the JSON.org classes when things are amiss.
 *
 * @author JSON.org
- * @version 2015-10-18
+ * @version 2015-12-09
 */
 public class JSONException extends RuntimeException {
    /** Serialization ID */
--- a/JSONML.java
+++ b/JSONML.java
@@ -33,23 +33,24 @@ import java.util.Iterator;
 * the JsonML transform.
 *
 * @author JSON.org
- * @version 2014-05-03
+ * @version 2016-01-30
 */
 public class JSONML {
-
    /**
     * Parse XML values and store them in a JSONArray.
     * @param x       The XMLTokener containing the source string.
     * @param arrayForm true if array form, false if object form.
     * @param ja      The JSONArray that is containing the current tag or null
     *     if we are at the outermost level.
+     * @param keepStrings	Don't type-convert text nodes and attibute values
     * @return A JSONArray if the value is the outermost tag, otherwise null.
     * @throws JSONException
     */
    private static Object parse(
        XMLTokener x,
        boolean    arrayForm,
-        JSONArray  ja
+        JSONArray  ja,
+        boolean keepStrings
    ) throws JSONException {
        String     attribute;
        char       c;
@@ -174,7 +175,7 @@ public class JSONML {
                            if (!(token instanceof String)) {
                                throw x.syntaxError("Missing value");
                            }
-                            newjo.accumulate(attribute, XML.stringToValue((String)token));
+                            newjo.accumulate(attribute, keepStrings ? XML.unescape((String)token) :XML.stringToValue((String)token));
                            token = null;
                        } else {
                            newjo.accumulate(attribute, "");
@@ -193,9 +194,8 @@ public class JSONML {
                        if (ja == null) {
                            if (arrayForm) {
                                return newja;
-                            } else {
-                                return newjo;
                            }
+                            return newjo;
                        }

 // Content, between <...> and </...>
@@ -204,7 +204,7 @@ public class JSONML {
                        if (token != XML.GT) {
                            throw x.syntaxError("Misshaped tag");
                        }
-                        closeTag = (String)parse(x, arrayForm, newja);
+                        closeTag = (String)parse(x, arrayForm, newja, keepStrings);
                        if (closeTag != null) {
                            if (!closeTag.equals(tagName)) {
                                throw x.syntaxError("Mismatched '" + tagName +
@@ -217,9 +217,8 @@ public class JSONML {
                            if (ja == null) {
                                if (arrayForm) {
                                    return newja;
-                                } else {
-                                    return newjo;
                                }
+                                return newjo;
                            }
                        }
                    }
@@ -227,7 +226,7 @@ public class JSONML {
            } else {
                if (ja != null) {
                    ja.put(token instanceof String
-                        ? XML.stringToValue((String)token)
+                        ? keepStrings ? XML.unescape((String)token) :XML.stringToValue((String)token)
                        : token);
                }
            }
@@ -245,10 +244,54 @@ public class JSONML {
     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
     * @param string The source string.
     * @return A JSONArray containing the structured data from the XML string.
-     * @throws JSONException
+     * @throws JSONException Thrown on error converting to a JSONArray
     */
    public static JSONArray toJSONArray(String string) throws JSONException {
-        return toJSONArray(new XMLTokener(string));
+        return (JSONArray)parse(new XMLTokener(string), true, null, false);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child tags.
+     * As opposed to toJSONArray this method does not attempt to convert 
+     * any text node or attribute value to any type 
+     * but just leaves it as a string.
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param string The source string.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(String string, boolean keepStrings) throws JSONException {
+        return (JSONArray)parse(new XMLTokener(string), true, null, keepStrings);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child content and tags.
+     * As opposed to toJSONArray this method does not attempt to convert 
+     * any text node or attribute value to any type 
+     * but just leaves it as a string.
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(XMLTokener x, boolean keepStrings) throws JSONException {
+        return (JSONArray)parse(x, true, null, keepStrings);
    }


@@ -262,28 +305,10 @@ public class JSONML {
     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
     * @param x An XMLTokener.
     * @return A JSONArray containing the structured data from the XML string.
-     * @throws JSONException
+     * @throws JSONException Thrown on error converting to a JSONArray
     */
    public static JSONArray toJSONArray(XMLTokener x) throws JSONException {
-        return (JSONArray)parse(x, true, null);
-    }
-
-
-    /**
-     * Convert a well-formed (but not necessarily valid) XML string into a
-     * JSONObject using the JsonML transform. Each XML tag is represented as
-     * a JSONObject with a "tagName" property. If the tag has attributes, then
-     * the attributes will be in the JSONObject as properties. If the tag
-     * contains children, the object will have a "childNodes" property which
-     * will be an array of strings and JsonML JSONObjects.
-
-     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
-     * @param x An XMLTokener of the XML source text.
-     * @return A JSONObject containing the structured data from the XML string.
-     * @throws JSONException
-     */
-    public static JSONObject toJSONObject(XMLTokener x) throws JSONException {
-           return (JSONObject)parse(x, false, null);
+        return (JSONArray)parse(x, true, null, false);
    }


@@ -298,10 +323,68 @@ public class JSONML {
     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
     * @param string The XML source text.
     * @return A JSONObject containing the structured data from the XML string.
-     * @throws JSONException
+     * @throws JSONException Thrown on error converting to a JSONObject
     */
    public static JSONObject toJSONObject(String string) throws JSONException {
-        return toJSONObject(new XMLTokener(string));
+        return (JSONObject)parse(new XMLTokener(string), false, null, false);
+    }
+    
+    
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param string The XML source text.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {
+        return (JSONObject)parse(new XMLTokener(string), false, null, keepStrings);
+    }
+
+    
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener of the XML source text.
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(XMLTokener x) throws JSONException {
+           return (JSONObject)parse(x, false, null, false);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener of the XML source text.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(XMLTokener x, boolean keepStrings) throws JSONException {
+           return (JSONObject)parse(x, false, null, keepStrings);
    }


@@ -309,7 +392,7 @@ public class JSONML {
     * Reverse the JSONML transformation, making an XML text from a JSONArray.
     * @param ja A JSONArray.
     * @return An XML string.
-     * @throws JSONException
+     * @throws JSONException Thrown on error converting to a string
     */
    public static String toString(JSONArray ja) throws JSONException {
        int                 i;
@@ -393,7 +476,7 @@ public class JSONML {
     * The other properties are attributes with string values.
     * @param jo A JSONObject.
     * @return An XML string.
-     * @throws JSONException
+     * @throws JSONException Thrown on error converting to a string
     */
    public static String toString(JSONObject jo) throws JSONException {
        StringBuilder sb = new StringBuilder();
--- a/JSONObject.java
+++ b/JSONObject.java
@@ -30,7 +30,8 @@ import java.io.Writer;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.math.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HashMap;
@@ -92,7 +93,7 @@ import java.util.Set;
 * </ul>
 *
 * @author JSON.org
- * @version 2015-10-29
+ * @version 2016-08-15
 */
 public class JSONObject {
    /**
@@ -131,6 +132,7 @@ public class JSONObject {
         *
         * @return The string "null".
         */
+        @Override
        public String toString() {
            return "null";
        }
@@ -165,10 +167,6 @@ public class JSONObject {
     *            A JSONObject.
     * @param names
     *            An array of strings.
-     * @throws JSONException
-     * @exception JSONException
-     *                If a value is a non-finite number or if a name is
-     *                duplicated.
     */
    public JSONObject(JSONObject jo, String[] names) {
        this();
@@ -241,7 +239,6 @@ public class JSONObject {
     * @param map
     *            A map object that can be used to initialize the contents of
     *            the JSONObject.
-     * @throws JSONException
     */
    public JSONObject(Map<?, ?> map) {
        this.map = new HashMap<String, Object>();
@@ -841,7 +838,7 @@ public class JSONObject {
        }
        testValidity(number);

-// Shave off trailing zeros and decimal point, if possible.
+        // Shave off trailing zeros and decimal point, if possible.

        String string = number.toString();
        if (string.indexOf('.') > 0 && string.indexOf('e') < 0
@@ -905,7 +902,9 @@ public class JSONObject {
                return myE;
            }
            return Enum.valueOf(clazz, val.toString());
-        } catch (IllegalArgumentException | NullPointerException e) {
+        } catch (IllegalArgumentException e) {
+            return defaultValue;
+        } catch (NullPointerException e) {
            return defaultValue;
        }
    }
@@ -1158,9 +1157,9 @@ public class JSONObject {
                            && Character.isUpperCase(key.charAt(0))
                            && method.getParameterTypes().length == 0) {
                        if (key.length() == 1) {
-                            key = key.toLowerCase();
+                            key = key.toLowerCase(Locale.ROOT);
                        } else if (!Character.isUpperCase(key.charAt(1))) {
-                            key = key.substring(0, 1).toLowerCase()
+                            key = key.substring(0, 1).toLowerCase(Locale.ROOT)
                                    + key.substring(1);
                        }

@@ -1340,6 +1339,79 @@ public class JSONObject {
        return this;
    }

+    /**
+     * Creates a JSONPointer using an intialization string and tries to 
+     * match it to an item within this JSONObject. For example, given a
+     * JSONObject initialized with this document:
+     * <pre>
+     * {
+     *     "a":{"b":"c"}
+     * }
+     * </pre>
+     * and this JSONPointer string: 
+     * <pre>
+     * "/a/b"
+     * </pre>
+     * Then this method will return the String "c".
+     * A JSONPointerException may be thrown from code called by this method.
+     *   
+     * @param jsonPointer string that can be used to create a JSONPointer
+     * @return the item matched by the JSONPointer, otherwise null
+     */
+    public Object query(String jsonPointer) {
+        return query(new JSONPointer(jsonPointer));
+    }
+    /**
+     * Uses a uaer initialized JSONPointer  and tries to 
+     * match it to an item within this JSONObject. For example, given a
+     * JSONObject initialized with this document:
+     * <pre>
+     * {
+     *     "a":{"b":"c"}
+     * }
+     * </pre>
+     * and this JSONPointer: 
+     * <pre>
+     * "/a/b"
+     * </pre>
+     * Then this method will return the String "c".
+     * A JSONPointerException may be thrown from code called by this method.
+     *   
+     * @param jsonPointer string that can be used to create a JSONPointer
+     * @return the item matched by the JSONPointer, otherwise null
+     */
+    public Object query(JSONPointer jsonPointer) {
+        return jsonPointer.queryFrom(this);
+    }
+    
+    /**
+     * Queries and returns a value from this object using {@code jsonPointer}, or
+     * returns null if the query fails due to a missing key.
+     * 
+     * @param jsonPointer the string representation of the JSON pointer
+     * @return the queried value or {@code null}
+     * @throws IllegalArgumentException if {@code jsonPointer} has invalid syntax
+     */
+    public Object optQuery(String jsonPointer) {
+    	return optQuery(new JSONPointer(jsonPointer));
+    }
+    
+    /**
+     * Queries and returns a value from this object using {@code jsonPointer}, or
+     * returns null if the query fails due to a missing key.
+     * 
+     * @param The JSON pointer
+     * @return the queried value or {@code null}
+     * @throws IllegalArgumentException if {@code jsonPointer} has invalid syntax
+     */
+    public Object optQuery(JSONPointer jsonPointer) {
+        try {
+            return jsonPointer.queryFrom(this);
+        } catch (JSONPointerException e) {
+            return null;
+        }
+    }
+
    /**
     * Produce a string in double quotes with backslash sequences in all the
     * right places. A backslash will be inserted within </, producing <\/,
@@ -1482,7 +1554,6 @@ public class JSONObject {
     * @return A simple JSON value.
     */
    public static Object stringToValue(String string) {
-        Double d;
        if (string.equals("")) {
            return string;
        }
@@ -1501,23 +1572,23 @@ public class JSONObject {
         * produced, then the value will just be a string.
         */

-        char b = string.charAt(0);
-        if ((b >= '0' && b <= '9') || b == '-') {
+        char initial = string.charAt(0);
+        if ((initial >= '0' && initial <= '9') || initial == '-') {
            try {
                if (string.indexOf('.') > -1 || string.indexOf('e') > -1
-                        || string.indexOf('E') > -1) {
-                    d = Double.valueOf(string);
+                        || string.indexOf('E') > -1
+                        || "-0".equals(string)) {
+                    Double d = Double.valueOf(string);
                    if (!d.isInfinite() && !d.isNaN()) {
                        return d;
                    }
                } else {
                    Long myLong = new Long(string);
                    if (string.equals(myLong.toString())) {
-                        if (myLong == myLong.intValue()) {
-                            return myLong.intValue();
-                        } else {
-                            return myLong;
+                        if (myLong.longValue() == myLong.intValue()) {
+                            return Integer.valueOf(myLong.intValue());
                        }
+                        return myLong;
                    }
                }
            } catch (Exception ignore) {
@@ -1584,6 +1655,7 @@ public class JSONObject {
     *         brace)</small> and ending with <code>}</code>&nbsp;<small>(right
     *         brace)</small>.
     */
+    @Override
    public String toString() {
        try {
            return this.toString(0);
@@ -1654,7 +1726,18 @@ public class JSONObject {
            throw new JSONException("Bad value from toJSONString: " + object);
        }
        if (value instanceof Number) {
-            return numberToString((Number) value);
+            // not all Numbers may match actual JSON Numbers. i.e. Fractions or Complex
+            final String numberAsString = numberToString((Number) value);
+            try {
+                // Use the BigDecimal constructor for it's parser to validate the format.
+                new BigDecimal(numberAsString);
+                // Close enough to a JSON number that we will return it unquoted
+                return numberAsString;
+            } catch (NumberFormatException ex){
+                // The Number value is not a valid JSON number.
+                // Instead we will quote it as a string
+                return quote(numberAsString);
+            }
        }
        if (value instanceof Boolean || value instanceof JSONObject
                || value instanceof JSONArray) {
@@ -1671,6 +1754,9 @@ public class JSONObject {
        if (value.getClass().isArray()) {
            return new JSONArray(value).toString();
        }
+        if(value instanceof Enum<?>){
+            return quote(((Enum<?>)value).name());
+        }
        return quote(value.toString());
    }

@@ -1698,7 +1784,7 @@ public class JSONObject {
                    || object instanceof Long || object instanceof Boolean
                    || object instanceof Float || object instanceof Double
                    || object instanceof String || object instanceof BigInteger
-                    || object instanceof BigDecimal) {
+                    || object instanceof BigDecimal || object instanceof Enum) {
                return object;
            }

@@ -1744,6 +1830,32 @@ public class JSONObject {
            int indentFactor, int indent) throws JSONException, IOException {
        if (value == null || value.equals(null)) {
            writer.write("null");
+        } else if (value instanceof JSONString) {
+            Object o;
+            try {
+                o = ((JSONString) value).toJSONString();
+            } catch (Exception e) {
+                throw new JSONException(e);
+            }
+            writer.write(o != null ? o.toString() : quote(value.toString()));
+        } else if (value instanceof Number) {
+            // not all Numbers may match actual JSON Numbers. i.e. fractions or Imaginary
+            final String numberAsString = numberToString((Number) value);
+            try {
+                // Use the BigDecimal constructor for it's parser to validate the format.
+                @SuppressWarnings("unused")
+                BigDecimal testNum = new BigDecimal(numberAsString);
+                // Close enough to a JSON number that we will use it unquoted
+                writer.write(numberAsString);
+            } catch (NumberFormatException ex){
+                // The Number value is not a valid JSON number.
+                // Instead we will quote it as a string
+                quote(numberAsString, writer);
+            }
+        } else if (value instanceof Boolean) {
+            writer.write(value.toString());
+        } else if (value instanceof Enum<?>) {
+            writer.write(quote(((Enum<?>)value).name()));
        } else if (value instanceof JSONObject) {
            ((JSONObject) value).write(writer, indentFactor, indent);
        } else if (value instanceof JSONArray) {
@@ -1756,18 +1868,6 @@ public class JSONObject {
            new JSONArray(coll).write(writer, indentFactor, indent);
        } else if (value.getClass().isArray()) {
            new JSONArray(value).write(writer, indentFactor, indent);
-        } else if (value instanceof Number) {
-            writer.write(numberToString((Number) value));
-        } else if (value instanceof Boolean) {
-            writer.write(value.toString());
-        } else if (value instanceof JSONString) {
-            Object o;
-            try {
-                o = ((JSONString) value).toJSONString();
-            } catch (Exception e) {
-                throw new JSONException(e);
-            }
-            writer.write(o != null ? o.toString() : quote(value.toString()));
        } else {
            quote(value.toString(), writer);
        }
@@ -1786,10 +1886,16 @@ public class JSONObject {
     * <p>
     * Warning: This method assumes that the data structure is acyclical.
     *
+     * @param writer
+     *            Writes the serialized JSON
+     * @param indentFactor
+     *            The number of spaces to add to each level of indentation.
+     * @param indent
+     *            The indention of the top level.
     * @return The writer.
     * @throws JSONException
     */
-    Writer write(Writer writer, int indentFactor, int indent)
+    public Writer write(Writer writer, int indentFactor, int indent)
            throws JSONException {
        try {
            boolean commanate = false;
@@ -1835,4 +1941,31 @@ public class JSONObject {
            throw new JSONException(exception);
        }
    }
+
+    /**
+     * Returns a java.util.Map containing all of the entries in this object.
+     * If an entry in the object is a JSONArray or JSONObject it will also
+     * be converted.
+     * <p>
+     * Warning: This method assumes that the data structure is acyclical.
+     *
+     * @return a java.util.Map containing the entries of this object
+     */
+    public Map<String, Object> toMap() {
+        Map<String, Object> results = new HashMap<String, Object>();
+        for (Entry<String, Object> entry : this.map.entrySet()) {
+            Object value;
+            if (entry.getValue() == null || NULL.equals(entry.getValue())) {
+                value = null;
+            } else if (entry.getValue() instanceof JSONObject) {
+                value = ((JSONObject) entry.getValue()).toMap();
+            } else if (entry.getValue() instanceof JSONArray) {
+                value = ((JSONArray) entry.getValue()).toList();
+            } else {
+                value = entry.getValue();
+            }
+            results.put(entry.getKey(), value);
+        }
+        return results;
+    }
 }
--- a/JSONPointer.java
+++ b/JSONPointer.java
@@ -0,0 +1,267 @@
+package org.json;
+
+import static java.lang.String.format;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.*;
+
+/*
+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.
+*/
+
+/**
+ * A JSON Pointer is a simple query language defined for JSON documents by
+ * <a href="https://tools.ietf.org/html/rfc6901">RFC 6901</a>.
+ * 
+ * In a nutshell, JSONPointer allows the user to navigate into a JSON document
+ * using strings, and retrieve targeted objects, like a simple form of XPATH.
+ * Path segments are separated by the '/' char, which signifies the root of
+ * the document when it appears as the first char of the string. Array 
+ * elements are navigated using ordinals, counting from 0. JSONPointer strings
+ * may be extended to any arbitrary number of segments. If the navigation
+ * is successful, the matched item is returned. A matched item may be a
+ * JSONObject, a JSONArray, or a JSON value. If the JSONPointer string building 
+ * fails, an appropriate exception is thrown. If the navigation fails to find
+ * a match, a JSONPointerException is thrown. 
+ * 
+ * @author JSON.org
+ * @version 2016-05-14
+ */
+public class JSONPointer {
+
+    // used for URL encoding and decoding
+    private static final String ENCODING = "utf-8";
+
+    /**
+     * This class allows the user to build a JSONPointer in steps, using
+     * exactly one segment in each step.
+     */
+    public static class Builder {
+
+        // Segments for the eventual JSONPointer string
+        private final List<String> refTokens = new ArrayList<String>();
+
+        /**
+         * Creates a {@code JSONPointer} instance using the tokens previously set using the
+         * {@link #append(String)} method calls.
+         */
+        public JSONPointer build() {
+            return new JSONPointer(refTokens);
+        }
+
+        /**
+         * Adds an arbitary token to the list of reference tokens. It can be any non-null value.
+         * 
+         * Unlike in the case of JSON string or URI fragment representation of JSON pointers, the
+         * argument of this method MUST NOT be escaped. If you want to query the property called
+         * {@code "a~b"} then you should simply pass the {@code "a~b"} string as-is, there is no
+         * need to escape it as {@code "a~0b"}.
+         * 
+         * @param token the new token to be appended to the list
+         * @return {@code this}
+         * @throws NullPointerException if {@code token} is null
+         */
+        public Builder append(String token) {
+            if (token == null) {
+                throw new NullPointerException("token cannot be null");
+            }
+            refTokens.add(token);
+            return this;
+        }
+
+        /**
+         * Adds an integer to the reference token list. Although not necessarily, mostly this token will
+         * denote an array index. 
+         * 
+         * @param arrayIndex the array index to be added to the token list
+         * @return {@code this}
+         */
+        public Builder append(int arrayIndex) {
+            refTokens.add(String.valueOf(arrayIndex));
+            return this;
+        }
+    }
+
+    /**
+     * Static factory method for {@link Builder}. Example usage:
+     * 
+     * <pre><code>
+     * JSONPointer pointer = JSONPointer.builder()
+     *       .append("obj")
+     *       .append("other~key").append("another/key")
+     *       .append("\"")
+     *       .append(0)
+     *       .build();
+     * </code></pre>
+     * 
+     *  @return a builder instance which can be used to construct a {@code JSONPointer} instance by chained
+     *  {@link Builder#append(String)} calls.
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    // Segments for the JSONPointer string
+    private final List<String> refTokens;
+
+    /**
+     * Pre-parses and initializes a new {@code JSONPointer} instance. If you want to
+     * evaluate the same JSON Pointer on different JSON documents then it is recommended
+     * to keep the {@code JSONPointer} instances due to performance considerations.
+     * 
+     * @param pointer the JSON String or URI Fragment representation of the JSON pointer.
+     * @throws IllegalArgumentException if {@code pointer} is not a valid JSON pointer
+     */
+    public JSONPointer(String pointer) {
+        if (pointer == null) {
+            throw new NullPointerException("pointer cannot be null");
+        }
+        if (pointer.isEmpty() || pointer.equals("#")) {
+            refTokens = Collections.emptyList();
+            return;
+        }
+        if (pointer.startsWith("#/")) {
+            pointer = pointer.substring(2);
+            try {
+                pointer = URLDecoder.decode(pointer, ENCODING);
+            } catch (UnsupportedEncodingException e) {
+                throw new RuntimeException(e);
+            }
+        } else if (pointer.startsWith("/")) {
+            pointer = pointer.substring(1);
+        } else {
+            throw new IllegalArgumentException("a JSON pointer should start with '/' or '#/'");
+        }
+        refTokens = new ArrayList<String>();
+        for (String token : pointer.split("/")) {
+            refTokens.add(unescape(token));
+        }
+    }
+
+    public JSONPointer(List<String> refTokens) {
+        this.refTokens = new ArrayList<String>(refTokens);
+    }
+
+    private String unescape(String token) {
+        return token.replace("~1", "/").replace("~0", "~")
+                .replace("\\\"", "\"")
+                .replace("\\\\", "\\");
+    }
+
+    /**
+     * Evaluates this JSON Pointer on the given {@code document}. The {@code document}
+     * is usually a {@link JSONObject} or a {@link JSONArray} instance, but the empty
+     * JSON Pointer ({@code ""}) can be evaluated on any JSON values and in such case the
+     * returned value will be {@code document} itself. 
+     * 
+     * @param document the JSON document which should be the subject of querying.
+     * @return the result of the evaluation
+     * @throws JSONPointerException if an error occurs during evaluation
+     */
+    public Object queryFrom(Object document) {
+        if (refTokens.isEmpty()) {
+            return document;
+        }
+        Object current = document;
+        for (String token : refTokens) {
+            if (current instanceof JSONObject) {
+                current = ((JSONObject) current).opt(unescape(token));
+            } else if (current instanceof JSONArray) {
+                current = readByIndexToken(current, token);
+            } else {
+                throw new JSONPointerException(format(
+                        "value [%s] is not an array or object therefore its key %s cannot be resolved", current,
+                        token));
+            }
+        }
+        return current;
+    }
+
+    /**
+     * Matches a JSONArray element by ordinal position
+     * @param current the JSONArray to be evaluated
+     * @param indexToken the array index in string form
+     * @return the matched object. If no matching item is found a
+     * JSONPointerException is thrown
+     */
+    private Object readByIndexToken(Object current, String indexToken) {
+        try {
+            int index = Integer.parseInt(indexToken);
+            JSONArray currentArr = (JSONArray) current;
+            if (index >= currentArr.length()) {
+                throw new JSONPointerException(format("index %d is out of bounds - the array has %d elements", index,
+                        currentArr.length()));
+            }
+            return currentArr.get(index);
+        } catch (NumberFormatException e) {
+            throw new JSONPointerException(format("%s is not an array index", indexToken), e);
+        }
+    }
+
+    /**
+     * Returns a string representing the JSONPointer path value using string
+     * representation
+     */
+    @Override
+    public String toString() {
+        StringBuilder rval = new StringBuilder("");
+        for (String token: refTokens) {
+            rval.append('/').append(escape(token));
+        }
+        return rval.toString();
+    }
+
+    /**
+     * Escapes path segment values to an unambiguous form.
+     * The escape char to be inserted is '~'. The chars to be escaped 
+     * are ~, which maps to ~0, and /, which maps to ~1. Backslashes
+     * and double quote chars are also escaped.
+     * @param token the JSONPointer segment value to be escaped
+     * @return the escaped value for the token
+     */
+    private String escape(String token) {
+        return token.replace("~", "~0")
+                .replace("/", "~1")
+                .replace("\\", "\\\\")
+                .replace("\"", "\\\"");
+    }
+
+    /**
+     * Returns a string representing the JSONPointer path value using URI
+     * fragment identifier representation
+     */
+    public String toURIFragment() {
+        try {
+            StringBuilder rval = new StringBuilder("#");
+            for (String token : refTokens) {
+                rval.append('/').append(URLEncoder.encode(token, ENCODING));
+            }
+            return rval.toString();
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+}
--- a/JSONPointerException.java
+++ b/JSONPointerException.java
@@ -0,0 +1,45 @@
+package org.json;
+
+/*
+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.
+*/
+
+/**
+ * The JSONPointerException is thrown by {@link JSONPointer} if an error occurs
+ * during evaluating a pointer.
+ * 
+ * @author JSON.org
+ * @version 2016-05-13
+ */
+public class JSONPointerException extends JSONException {
+    private static final long serialVersionUID = 8872944667561856751L;
+
+    public JSONPointerException(String message) {
+        super(message);
+    }
+
+    public JSONPointerException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}
--- a/JSONString.java
+++ b/JSONString.java
--- a/JSONStringer.java
+++ b/JSONStringer.java
@@ -54,7 +54,7 @@ import java.io.StringWriter;
 * <p>
 * This can sometimes be easier than using a JSONObject to build a string.
 * @author JSON.org
- * @version 2008-09-18
+ * @version 2015-12-09
 */
 public class JSONStringer extends JSONWriter {
    /**
--- a/JSONTokener.java
+++ b/JSONTokener.java
@@ -71,7 +71,7 @@ public class JSONTokener {
     * Construct a JSONTokener from an InputStream.
     * @param inputStream The source.
     */
-    public JSONTokener(InputStream inputStream) throws JSONException {
+    public JSONTokener(InputStream inputStream) {
        this(new InputStreamReader(inputStream));
    }

@@ -90,6 +90,8 @@ public class JSONTokener {
     * 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.
+     * @throws JSONException Thrown if trying to step back more than 1 step
+     *  or if already at the start of the string
     */
    public void back() throws JSONException {
        if (this.usePrevious || this.index <= 0) {
@@ -121,6 +123,9 @@ public class JSONTokener {
        return -1;
    }

+    /**
+     * @return true if at the end of the file and we didn't step back
+     */
    public boolean end() {
        return this.eof && !this.usePrevious;
    }
@@ -130,6 +135,8 @@ public class JSONTokener {
     * Determine if the source string still contains characters that next()
     * can consume.
     * @return true if not yet at the end of the source.
+     * @throws JSONException thrown if there is an error stepping forward
+     *  or backward while checking for more data.
     */
    public boolean more() throws JSONException {
        this.next();
@@ -145,6 +152,7 @@ public class JSONTokener {
     * Get the next character in the source string.
     *
     * @return The next character, or 0 if past the end of the source string.
+     * @throws JSONException Thrown if there is an error reading the source string.
     */
    public char next() throws JSONException {
        int c;
@@ -225,7 +233,7 @@ public class JSONTokener {

    /**
     * Get the next char in the string, skipping whitespace.
-     * @throws JSONException
+     * @throws JSONException Thrown if there is an error reading the source string.
     * @return  A character, or 0 if there are no more characters.
     */
    public char nextClean() throws JSONException {
@@ -278,7 +286,11 @@ public class JSONTokener {
                    sb.append('\r');
                    break;
                case 'u':
-                    sb.append((char)Integer.parseInt(this.next(4), 16));
+                    try {
+                        sb.append((char)Integer.parseInt(this.next(4), 16));
+                    } catch (NumberFormatException e) {
+                        throw this.syntaxError("Illegal escape.", e);
+                    }
                    break;
                case '"':
                case '\'':
@@ -305,6 +317,8 @@ public class JSONTokener {
     * end of line, whichever comes first.
     * @param  delimiter A delimiter character.
     * @return   A string.
+     * @throws JSONException Thrown if there is an error while searching
+     *  for the delimiter
     */
    public String nextTo(char delimiter) throws JSONException {
        StringBuilder sb = new StringBuilder();
@@ -326,6 +340,8 @@ public class JSONTokener {
     * characters or the end of line, whichever comes first.
     * @param delimiters A set of delimiter characters.
     * @return A string, trimmed.
+     * @throws JSONException Thrown if there is an error while searching
+     *  for the delimiter
     */
    public String nextTo(String delimiters) throws JSONException {
        char c;
@@ -397,6 +413,8 @@ public class JSONTokener {
     * @param to A character to skip to.
     * @return The requested character, or zero if the requested character
     * is not found.
+     * @throws JSONException Thrown if there is an error while searching
+     *  for the to character
     */
    public char skipTo(char to) throws JSONException {
        char c;
@@ -433,12 +451,23 @@ public class JSONTokener {
        return new JSONException(message + this.toString());
    }

+    /**
+     * Make a JSONException to signal a syntax error.
+     *
+     * @param message The error message.
+     * @param causedBy The throwable that caused the error.
+     * @return  A JSONException object, suitable for throwing
+     */
+    public JSONException syntaxError(String message, Throwable causedBy) {
+        return new JSONException(message + this.toString(), causedBy);
+    }

    /**
     * Make a printable string of this JSONTokener.
     *
     * @return " at {index} [character {character} line {line}]"
     */
+    @Override
    public String toString() {
        return " at " + this.index + " [character " + this.character + " line " +
            this.line + "]";
--- a/JSONWriter.java
+++ b/JSONWriter.java
@@ -1,7 +1,6 @@
 package org.json;

 import java.io.IOException;
-import java.io.Writer;

 /*
 Copyright (c) 2006 JSON.org
@@ -50,11 +49,11 @@ SOFTWARE.
 * <p>
 * The first method called must be <code>array</code> or <code>object</code>.
 * There are no methods for adding commas or colons. JSONWriter adds them for
- * you. Objects and arrays can be nested up to 20 levels deep.
+ * you. Objects and arrays can be nested up to 200 levels deep.
 * <p>
 * This can sometimes be easier than using a JSONObject to build a string.
 * @author JSON.org
- * @version 2011-11-24
+ * @version 2016-08-08
 */
 public class JSONWriter {
    private static final int maxdepth = 200;
@@ -88,12 +87,12 @@ public class JSONWriter {
    /**
     * The writer that will receive the output.
     */
-    protected Writer writer;
+    protected Appendable writer;

    /**
     * Make a fresh JSONWriter. It can be used to build one JSON text.
     */
-    public JSONWriter(Writer w) {
+    public JSONWriter(Appendable w) {
        this.comma = false;
        this.mode = 'i';
        this.stack = new JSONObject[maxdepth];
@@ -114,9 +113,9 @@ public class JSONWriter {
        if (this.mode == 'o' || this.mode == 'a') {
            try {
                if (this.comma && this.mode == 'a') {
-                    this.writer.write(',');
+                    this.writer.append(',');
                }
-                this.writer.write(string);
+                this.writer.append(string);
            } catch (IOException e) {
                throw new JSONException(e);
            }
@@ -163,7 +162,7 @@ public class JSONWriter {
        }
        this.pop(mode);
        try {
-            this.writer.write(c);
+            this.writer.append(c);
        } catch (IOException e) {
            throw new JSONException(e);
        }
@@ -207,10 +206,10 @@ public class JSONWriter {
            try {
                this.stack[this.top - 1].putOnce(string, Boolean.TRUE);
                if (this.comma) {
-                    this.writer.write(',');
+                    this.writer.append(',');
                }
-                this.writer.write(JSONObject.quote(string));
-                this.writer.write(':');
+                this.writer.append(JSONObject.quote(string));
+                this.writer.append(':');
                this.comma = false;
                this.mode = 'o';
                return this;
--- a/23
+++ b/23
@@ -0,0 +1,23 @@
+============================================================================
+
+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.
--- a/48
+++ b/48
@@ -15,14 +15,14 @@ The license includes this restriction: "The software shall be used for good,
 not evil." If your conscience cannot live with that, then choose a different
 package.

-The package compiles on Java 1.8.
+The package compiles on Java 1.6-1.8.


 JSONObject.java: The JSONObject can parse text from a String or a JSONTokener
 to produce a map-like object. The object provides methods for manipulating its
 contents, and for producing a JSON compliant object serialization.

-JSONArray.java: The JSONObject can parse text from a String or a JSONTokener
+JSONArray.java: The JSONArray can parse text from a String or a JSONTokener
 to produce a vector-like object. The object provides methods for manipulating
 its contents, and for producing a JSON compliant array serialization.

@@ -32,6 +32,10 @@ tokens. It can be constructed from a String, Reader, or InputStream.
 JSONException.java: The JSONException is the standard exception type thrown
 by this package.

+JSONPointer.java: Implementation of 
+[JSON Pointer (RFC 6901)](https://tools.ietf.org/html/rfc6901). Supports
+JSON Pointers both in the form of string representation and URI fragment
+representation.

 JSONString.java: The JSONString interface requires a toJSONString method,
 allowing an object to provide its own serialization.
@@ -61,14 +65,48 @@ JSONML.java: JSONML provides support for converting between JSONML and XML.

 XMLTokener.java: XMLTokener extends JSONTokener for parsing XML text.

-Unit tests are maintained in a separate project. Contributing developers can test JSON-java pull requests with the code in this project: https://github.com/stleary/JSON-Java-unit-test
+Unit tests are maintained in a separate project. Contributing developers can test 
+JSON-java pull requests with the code in this project: 
+https://github.com/stleary/JSON-Java-unit-test
+
+Numeric types in this package comply with ECMA-404: The JSON Data Interchange Format 
+(http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf) and 
+RFC 7159: The JavaScript Object Notation (JSON) Data Interchange Format 
+(https://tools.ietf.org/html/rfc7159#section-6). 
+This package fully supports Integer, Long, and Double Java types. Partial support 
+for BigInteger and BigDecimal values in JSONObject and JSONArray objects is provided 
+in the form of get(), opt(), and put() API methods.
+
+Although 1.6 compatibility is currently supported, it is not a project goal and may be
+removed in some future release.
+
+In compliance with RFC7159 page 10 section 9, the parser is more lax with what is valid
+JSON than the Generator. For Example, the tab character (U+0009) is allowed when reading
+JSON Text strings, but when output by the Generator, tab is properly converted to \t in
+the string. Other instances may occur where reading invalid JSON text does not cause an
+error to be generated. Malformed JSON Texts such as missing end " (quote) on strings or
+invalid number formats (1.2e6.3) will cause errors as such documents can not be read
+ reliably.

 Release history:
+20170516    Roll up recent commits.
+
+20160810    Revert code that was breaking opt*() methods.
+
+20160807    This release contains a bug in the JSONObject.opt*() and JSONArray.opt*() methods, 
+it is not recommended for use.
+Java 1.6 compatability fixed, JSONArray.toList() and JSONObject.toMap(),
+RFC4180 compatibility, JSONPointer, some exception fixes, optional XML type conversion. 
+Contains the latest code as of 7 Aug, 2016
+
+20160212    Java 1.6 compatibility, OSGi bundle. Contains the latest code as of 12 Feb, 2016.

 20151123    JSONObject and JSONArray initialization with generics. Contains the
 latest code as of 23 Nov, 2015.

-20150729    Checkpoint for Maven central repository release. Contains the latest code as of 29 July, 2015. 
+20150729    Checkpoint for Maven central repository release. Contains the latest code 
+as of 29 July, 2015. 

-JSON-java releases can be found by searching the Maven repository for groupId "org.json" and artifactId "json". For example: 
+JSON-java releases can be found by searching the Maven repository for groupId "org.json" 
+and artifactId "json". For example: 
 https://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.json%22%20AND%20a%3A%22json%22
--- a/XML.java
+++ b/XML.java
@@ -27,56 +27,100 @@ SOFTWARE.
 import java.util.Iterator;

 /**
- * This provides static methods to convert an XML text into a JSONObject,
- * and to covert a JSONObject into an XML text.
+ * This provides static methods to convert an XML text into a JSONObject, and to
+ * covert a JSONObject into an XML text.
+ * 
 * @author JSON.org
- * @version 2015-10-18
+ * @version 2016-08-10
 */
+@SuppressWarnings("boxing")
 public class XML {
-
    /** The Character '&amp;'. */
-    public static final Character AMP   = '&';
+    public static final Character AMP = '&';

    /** The Character '''. */
-    public static final Character APOS  = '\'';
+    public static final Character APOS = '\'';

    /** The Character '!'. */
-    public static final Character BANG  = '!';
+    public static final Character BANG = '!';

    /** The Character '='. */
-    public static final Character EQ    = '=';
+    public static final Character EQ = '=';

    /** The Character '>'. */
-    public static final Character GT    = '>';
+    public static final Character GT = '>';

    /** The Character '&lt;'. */
-    public static final Character LT    = '<';
+    public static final Character LT = '<';

    /** The Character '?'. */
    public static final Character QUEST = '?';

    /** The Character '"'. */
-    public static final Character QUOT  = '"';
+    public static final Character QUOT = '"';

    /** The Character '/'. */
    public static final Character SLASH = '/';
    
+    /**
+     * Creates an iterator for navigating Code Points in a string instead of
+     * characters. Once Java7 support is dropped, this can be replaced with
+     * <code>
+     * string.codePoints()
+     * </code>
+     * which is available in Java8 and above.
+     * 
+     * @see <a href=
+     *      "http://stackoverflow.com/a/21791059/6030888">http://stackoverflow.com/a/21791059/6030888</a>
+     */
+    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();
+                    }
+                };
+            }
+        };
+    }
+
    /**
     * Replace special characters with XML escapes:
+     * 
     * <pre>
     * &amp; <small>(ampersand)</small> is replaced by &amp;amp;
     * &lt; <small>(less than)</small> is replaced by &amp;lt;
     * &gt; <small>(greater than)</small> is replaced by &amp;gt;
     * &quot; <small>(double quote)</small> is replaced by &amp;quot;
+     * &apos; <small>(single quote / apostrophe)</small> is replaced by &amp;apos;
     * </pre>
-     * @param string The string to be escaped.
+     * 
+     * @param string
+     *            The string to be escaped.
     * @return The escaped string.
     */
    public static String escape(String string) {
        StringBuilder sb = new StringBuilder(string.length());
-        for (int i = 0, length = string.length(); i < length; i++) {
-            char c = string.charAt(i);
-            switch (c) {
+        for (final int cp : codePointIterator(string)) {
+            switch (cp) {
            case '&':
                sb.append("&amp;");
                break;
@@ -93,6 +137,93 @@ public class XML {
                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();
+    }
+    
+    /**
+     * @param cp code point to test
+     * @return true if the code point is not valid for an XML
+     */
+    private static boolean mustEscape(int cp) {
+        /* Valid range from https://www.w3.org/TR/REC-xml/#charsets
+         * 
+         * #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] 
+         * 
+         * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. 
+         */
+        // 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)
+            )
+        ;
+    }
+
+    /**
+     * Removes XML escapes from the string.
+     * 
+     * @param string
+     *            string to remove escapes from
+     * @return string with converted entities
+     */
+    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);
+                    if (entity.charAt(0) == '#') {
+                        int cp;
+                        if (entity.charAt(1) == 'x') {
+                            // hex encoded unicode
+                            cp = Integer.parseInt(entity.substring(2), 16);
+                        } else {
+                            // decimal encoded unicode
+                            cp = Integer.parseInt(entity.substring(1));
+                        }
+                        sb.appendCodePoint(cp);
+                    } else {
+                        if ("quot".equalsIgnoreCase(entity)) {
+                            sb.append('"');
+                        } else if ("amp".equalsIgnoreCase(entity)) {
+                            sb.append('&');
+                        } else if ("apos".equalsIgnoreCase(entity)) {
+                            sb.append('\'');
+                        } else if ("lt".equalsIgnoreCase(entity)) {
+                            sb.append('<');
+                        } else if ("gt".equalsIgnoreCase(entity)) {
+                            sb.append('>');
+                        } else {
+                            sb.append('&').append(entity).append(';');
+                        }
+                    }
+                    // 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 enties.
+                    sb.append(c);
+                }
+            } else {
+                // not part of an entity
                sb.append(c);
            }
        }
@@ -100,10 +231,12 @@ public class XML {
    }

    /**
-     * Throw an exception if the string contains whitespace.
-     * Whitespace is not allowed in tagNames and attributes.
-     * @param string A string.
-     * @throws JSONException
+     * Throw an exception if the string contains whitespace. Whitespace is not
+     * allowed in tagNames and attributes.
+     * 
+     * @param string
+     *            A string.
+     * @throws JSONException Thrown if the string contains whitespace or is empty.
     */
    public static void noSpace(String string) throws JSONException {
        int i, length = string.length();
@@ -112,42 +245,46 @@ public class XML {
        }
        for (i = 0; i < length; i += 1) {
            if (Character.isWhitespace(string.charAt(i))) {
-                throw new JSONException("'" + string +
-                        "' contains a space character.");
+                throw new JSONException("'" + string
+                        + "' contains a space character.");
            }
        }
    }

    /**
     * Scan the content following the named tag, attaching it to the context.
-     * @param x       The XMLTokener containing the source string.
-     * @param context The JSONObject that will include the new material.
-     * @param name    The tag name.
+     * 
+     * @param x
+     *            The XMLTokener containing the source string.
+     * @param context
+     *            The JSONObject that will include the new material.
+     * @param name
+     *            The tag name.
     * @return true if the close tag is processed.
     * @throws JSONException
     */
-    private static boolean parse(XMLTokener x, JSONObject context,
-                                 String name) throws JSONException {
-        char       c;
-        int        i;
+    private static boolean parse(XMLTokener x, JSONObject context, String name, boolean keepStrings)
+            throws JSONException {
+        char c;
+        int i;
        JSONObject jsonobject = null;
-        String     string;
-        String     tagName;
-        Object     token;
+        String string;
+        String tagName;
+        Object token;

-// Test for and skip past these forms:
-//      <!-- ... -->
-//      <!   ...   >
-//      <![  ... ]]>
-//      <?   ...  ?>
-// Report errors for these forms:
-//      <>
-//      <=
-//      <<
+        // Test for and skip past these forms:
+        // <!-- ... -->
+        // <! ... >
+        // <![ ... ]]>
+        // <? ... ?>
+        // Report errors for these forms:
+        // <>
+        // <=
+        // <<

        token = x.nextToken();

-// <!
+        // <!

        if (token == BANG) {
            c = x.next();
@@ -184,13 +321,12 @@ public class XML {
            return false;
        } else if (token == QUEST) {

-// <?
-
+            // <?
            x.skipPast("?>");
            return false;
        } else if (token == SLASH) {

-// Close tag </
+            // Close tag </

            token = x.nextToken();
            if (name == null) {
@@ -207,21 +343,19 @@ public class XML {
        } else if (token instanceof Character) {
            throw x.syntaxError("Misshaped tag");

-// Open tag <
+            // Open tag <

        } else {
-            tagName = (String)token;
+            tagName = (String) token;
            token = null;
            jsonobject = new JSONObject();
            for (;;) {
                if (token == null) {
                    token = x.nextToken();
                }
-
-// attribute = value
-
+                // attribute = value
                if (token instanceof String) {
-                    string = (String)token;
+                    string = (String) token;
                    token = x.nextToken();
                    if (token == EQ) {
                        token = x.nextToken();
@@ -229,15 +363,15 @@ public class XML {
                            throw x.syntaxError("Missing value");
                        }
                        jsonobject.accumulate(string,
-                                XML.stringToValue((String)token));
+                                keepStrings ? unescape((String)token) : stringToValue((String) token));
                        token = null;
                    } else {
                        jsonobject.accumulate(string, "");
                    }

-// Empty tag <.../>

                } else if (token == SLASH) {
+                    // Empty tag <.../>
                    if (x.nextToken() != GT) {
                        throw x.syntaxError("Misshaped tag");
                    }
@@ -248,9 +382,8 @@ public class XML {
                    }
                    return false;

-// Content, between <...> and </...>
-
                } else if (token == GT) {
+                    // Content, between <...> and </...>
                    for (;;) {
                        token = x.nextContent();
                        if (token == null) {
@@ -259,20 +392,19 @@ public class XML {
                            }
                            return false;
                        } else if (token instanceof String) {
-                            string = (String)token;
+                            string = (String) token;
                            if (string.length() > 0) {
                                jsonobject.accumulate("content",
-                                        XML.stringToValue(string));
+                                        keepStrings ? unescape(string) : stringToValue(string));
                            }

-// Nested element
-
                        } else if (token == LT) {
-                            if (parse(x, jsonobject, tagName)) {
+                            // Nested element
+                            if (parse(x, jsonobject, tagName,keepStrings)) {
                                if (jsonobject.length() == 0) {
                                    context.accumulate(tagName, "");
-                                } else if (jsonobject.length() == 1 &&
-                                       jsonobject.opt("content") != null) {
+                                } else if (jsonobject.length() == 1
+                                        && jsonobject.opt("content") != null) {
                                    context.accumulate(tagName,
                                            jsonobject.opt("content"));
                                } else {
@@ -289,159 +421,156 @@ public class XML {
        }
    }
    
-
    /**
-     * Try to convert a string into a number, boolean, or null. If the string
-     * can't be converted, return the string. This is much less ambitious than
-     * JSONObject.stringToValue, especially because it does not attempt to
-     * convert plus forms, octal forms, hex forms, or E forms lacking decimal
-     * points.
-     * @param string A String.
-     * @return A simple JSON value.
+     * This method is the same as {@link JSONObject.stringToValue(String)}
+     * except that this also tries to unescape String values.
+     * 
+     * @param string String to convert
+     * @return JSON value of this string or the string
     */
    public static Object stringToValue(String string) {
-        if ("true".equalsIgnoreCase(string)) {
-            return Boolean.TRUE;
-        }
-        if ("false".equalsIgnoreCase(string)) {
-            return Boolean.FALSE;
-        }
-        if ("null".equalsIgnoreCase(string)) {
-            return JSONObject.NULL;
+        Object ret = JSONObject.stringToValue(string);
+        if(ret instanceof String){
+            return unescape((String)ret);
        }
+        return ret;
+    }

-// If it might be a number, try converting it, first as a Long, and then as a
-// Double. If that doesn't work, return the string.
-
-        try {
-            char initial = string.charAt(0);
-            if (initial == '-' || (initial >= '0' && initial <= '9')) {
-                Long value = new Long(string);
-                if (value.toString().equals(string)) {
-                    return value;
-                }
-            }
-        }  catch (Exception ignore) {
-            try {
-                Double value = new Double(string);
-                if (value.toString().equals(string)) {
-                    return value;
-                }
-            }  catch (Exception ignoreAlso) {
-            }
-        }
-        return string;
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject. Some information may be lost in this transformation because
+     * JSON is a data format and XML is a document format. XML uses elements,
+     * attributes, and content text, while JSON uses unordered collections of
+     * name/value pairs and arrays of values. JSON does not does not like to
+     * distinguish between elements and attributes. Sequences of similar
+     * elements are represented as JSONArrays. Content text may be placed in a
+     * "content" member. Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code>
+     * are ignored.
+     * 
+     * @param string
+     *            The source string.
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown if there is an errors while parsing the string
+     */
+    public static JSONObject toJSONObject(String string) throws JSONException {
+        return toJSONObject(string, false);
    }


    /**
     * Convert a well-formed (but not necessarily valid) XML string into a
-     * JSONObject. Some information may be lost in this transformation
-     * because JSON is a data format and XML is a document format. XML uses
-     * elements, attributes, and content text, while JSON uses unordered
-     * collections of name/value pairs and arrays of values. JSON does not
-     * does not like to distinguish between elements and attributes.
-     * Sequences of similar elements are represented as JSONArrays. Content
-     * text may be placed in a "content" member. Comments, prologs, DTDs, and
-     * <code>&lt;[ [ ]]></code> are ignored.
-     * @param string The source string.
+     * JSONObject. Some information may be lost in this transformation because
+     * JSON is a data format and XML is a document format. XML uses elements,
+     * attributes, and content text, while JSON uses unordered collections of
+     * name/value pairs and arrays of values. JSON does not does not like to
+     * distinguish between elements and attributes. Sequences of similar
+     * elements are represented as JSONArrays. Content text may be placed in a
+     * "content" member. Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code>
+     * are ignored.
+     * 
+     * All values are converted as strings, for 1, 01, 29.0 will not be coerced to
+     * numbers but will instead be the exact value as seen in the XML document.
+     * 
+     * @param string
+     *            The source string.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
     * @return A JSONObject containing the structured data from the XML string.
-     * @throws JSONException
+     * @throws JSONException Thrown if there is an errors while parsing the string
     */
-    public static JSONObject toJSONObject(String string) throws JSONException {
+    public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {
        JSONObject jo = new JSONObject();
        XMLTokener x = new XMLTokener(string);
        while (x.more() && x.skipPast("<")) {
-            parse(x, jo, null);
+            parse(x, jo, null, keepStrings);
        }
        return jo;
    }
-
-
    /**
     * Convert a JSONObject into a well-formed, element-normal XML string.
-     * @param object A JSONObject.
-     * @return  A string.
-     * @throws  JSONException
+     * 
+     * @param object
+     *            A JSONObject.
+     * @return A string.
+     * @throws JSONException Thrown if there is an error parsing the string
     */
    public static String toString(Object object) throws JSONException {
        return toString(object, null);
    }

-
    /**
     * Convert a JSONObject into a well-formed, element-normal XML string.
-     * @param object A JSONObject.
-     * @param tagName The optional name of the enclosing tag.
+     * 
+     * @param object
+     *            A JSONObject.
+     * @param tagName
+     *            The optional name of the enclosing tag.
     * @return A string.
-     * @throws JSONException
+     * @throws JSONException Thrown if there is an error parsing the string
     */
    public static String toString(Object object, String tagName)
            throws JSONException {
-        StringBuilder       sb = new StringBuilder();
-        int                 i;
-        JSONArray           ja;
-        JSONObject          jo;
-        String              key;
-        Iterator<String>    keys;
-        int                 length;
-        String              string;
-        Object              value;
+        StringBuilder sb = new StringBuilder();
+        JSONArray ja;
+        JSONObject jo;
+        String key;
+        Iterator<String> keys;
+        String string;
+        Object value;
+
        if (object instanceof JSONObject) {

-// Emit <tagName>
-
+            // Emit <tagName>
            if (tagName != null) {
                sb.append('<');
                sb.append(tagName);
                sb.append('>');
            }

-// Loop thru the keys.
-
-            jo = (JSONObject)object;
+            // Loop thru the keys.
+            jo = (JSONObject) object;
            keys = jo.keys();
            while (keys.hasNext()) {
                key = keys.next();
                value = jo.opt(key);
                if (value == null) {
                    value = "";
+                } else if (value.getClass().isArray()) {
+                    value = new JSONArray(value);
                }
-                string = value instanceof String ? (String)value : null;
-
-// Emit content in body
+                string = value instanceof String ? (String) value : null;

+                // Emit content in body
                if ("content".equals(key)) {
                    if (value instanceof JSONArray) {
-                        ja = (JSONArray)value;
-                        length = ja.length();
-                        for (i = 0; i < length; i += 1) {
+                        ja = (JSONArray) value;
+                        int i = 0;
+                        for (Object val : ja) {
                            if (i > 0) {
                                sb.append('\n');
                            }
-                            sb.append(escape(ja.get(i).toString()));
+                            sb.append(escape(val.toString()));
+                            i++;
                        }
                    } else {
                        sb.append(escape(value.toString()));
                    }

-// Emit an array of similar keys
+                    // Emit an array of similar keys

                } else if (value instanceof JSONArray) {
-                    ja = (JSONArray)value;
-                    length = ja.length();
-                    for (i = 0; i < length; i += 1) {
-                        value = ja.get(i);
-                        if (value instanceof JSONArray) {
+                    ja = (JSONArray) value;
+                    for (Object val : ja) {
+                        if (val instanceof JSONArray) {
                            sb.append('<');
                            sb.append(key);
                            sb.append('>');
-                            sb.append(toString(value));
+                            sb.append(toString(val));
                            sb.append("</");
                            sb.append(key);
                            sb.append('>');
                        } else {
-                            sb.append(toString(value, key));
+                            sb.append(toString(val, key));
                        }
                    }
                } else if ("".equals(value)) {
@@ -449,7 +578,7 @@ public class XML {
                    sb.append(key);
                    sb.append("/>");

-// Emit a new tag <k>
+                    // Emit a new tag <k>

                } else {
                    sb.append(toString(value, key));
@@ -457,36 +586,36 @@ public class XML {
            }
            if (tagName != null) {

-// Emit the </tagname> close tag
-
+                // Emit the </tagname> close tag
                sb.append("</");
                sb.append(tagName);
                sb.append('>');
            }
            return sb.toString();

-// XML does not have good support for arrays. If an array appears in a place
-// where XML is lacking, synthesize an <array> element.
-
        }
-        if(object!=null){
+
+        if (object != null) {
            if (object.getClass().isArray()) {
                object = new JSONArray(object);
            }

            if (object instanceof JSONArray) {
-                ja = (JSONArray)object;
-                length = ja.length();
-                for (i = 0; i < length; i += 1) {
-                    sb.append(toString(ja.opt(i), tagName == null ? "array" : tagName));
+                ja = (JSONArray) object;
+                for (Object val : ja) {
+                    // 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));
                }
                return sb.toString();
            }
        }
+
        string = (object == null) ? "null" : escape(object.toString());
-        return (tagName == null) ? "\"" + string + "\"" :
-            (string.length() == 0) ? "<" + tagName + "/>" :
-            "<" + tagName + ">" + string + "</" + tagName + ">";
+        return (tagName == null) ? "\"" + string + "\""
+                : (string.length() == 0) ? "<" + tagName + "/>" : "<" + tagName
+                        + ">" + string + "</" + tagName + ">";

    }
 }
--- a/XMLTokener.java
+++ b/XMLTokener.java
@@ -28,7 +28,7 @@ SOFTWARE.
 * The XMLTokener extends the JSONTokener to provide additional methods
 * for the parsing of XML texts.
 * @author JSON.org
- * @version 2014-05-03
+ * @version 2015-12-09
 */
 public class XMLTokener extends JSONTokener {
Author	SHA1	Message	Date
Sean Leary	cbd8b18c4a	Update README	2017-05-16 00:29:00 -05:00
Sean Leary	f12fa9ba5f	Update LICENSE	2017-04-18 08:32:10 -05:00
Sean Leary	80e2ea2a80	Merge pull request #324 from dtalex/JSONPointerOnBeans Allow user to invoke query and optQuery ,with a JSONPointer	2017-03-27 20:04:18 -05:00
alessandro rao	2917104b53	Allow user to invoke query and optQuery ,with a JSONPointer,directly from JSONArray or JSONObject fix JSONArray	2017-02-25 14:35:02 +01:00
alessandro rao	9e0fc5e680	Allow user to invoke query and optQuery ,with a JSONPointer,directly from JSONArray or JSONObject	2017-02-25 13:27:50 +01:00
Sean Leary	724fb888f7	Merge pull request #317 from johnjaylward/fixLocale make sure locale independent data is not upper/lowercased incorrectly…	2017-02-19 21:34:17 -06:00
John J. Aylward	eb806f4c14	make sure locale independent data is not upper/lowercased incorrectly. See #315	2017-02-10 10:07:28 -05:00
Sean Leary	5ff8b4cb08	Merge pull request #304 from omarzina/master [FIX] Update README	2016-12-05 08:58:35 -06:00
joumar	5ef4f58ef1	[FIX] Update README Fixed C&P typo	2016-12-05 11:55:24 -03:00
Sean Leary	413bb53b48	Merge pull request #288 from johnjaylward/XmlEscape Bug fixes for XML Encoding and Decoding	2016-11-24 10:01:14 -06:00
Sean Leary	237376eca6	Merge pull request #292 from erosb/master Provides "#" string evaluation support for JSON Pointer	2016-10-08 10:07:31 -05:00
Bence Erős	e0616a129e	fixing #291	2016-10-05 14:57:42 +02:00
John J. Aylward	93ffca36c3	fixes spacing	2016-09-28 20:23:30 -04:00
John J. Aylward	e477d7002b	fixes object comparison	2016-09-28 20:22:12 -04:00
John J. Aylward	fb1db9341e	Changes encoding to better match the XML spec section 2.2	2016-09-28 20:15:58 -04:00
John J. Aylward	adb0478f66	properly unescape tokens in JSONML for reversability.	2016-09-22 16:23:09 -04:00
John J. Aylward	f58a0f4684	fixes code point appends to string builder	2016-09-22 16:10:49 -04:00
John J. Aylward	c11e09959c	Fixes code point output when unescaping code points. XML escapes are an entire code point, not surrogate pairs like in JSON.	2016-09-22 15:40:26 -04:00
John J. Aylward	68f92eb395	Adds more javadoc.	2016-09-22 14:40:39 -04:00
John J. Aylward	34652a8706	Updates to iterate on code points instead of characters and changes the encoding to only encode control characters as defined by ISO standard.	2016-09-22 14:13:14 -04:00
John J. Aylward	a2d3b59394	Implements unicode escaping similar to JSONObject. * Removes deprecation on XML.stringToValue(). It now provides unescaping for strings to convert XML entities back into values. * New unescape function to handle XML entities -> value conversion.	2016-09-22 12:38:06 -04:00
Sean Leary	c24be0e4ea	Merge pull request #274 from johnjaylward/NumberOutputFix Fix for number output bug.	2016-09-09 11:42:35 -05:00
John J. Aylward	88f65c5bea	Merge branch 'master' of github.com:stleary/JSON-java into NumberOutputFix # Conflicts: # JSONObject.java	2016-08-26 11:32:35 -04:00
Sean Leary	ebe69df8e4	Merge pull request #271 from johnjaylward/EnumCleanup Update enum support to be more fully featured.	2016-08-19 10:28:04 -05:00
John J. Aylward	2f2cd4dfc5	Fix for number output bug. java.lang.Number is currently output without any validation. For all java.* Numbers, this is fine, but for custom Number implementations like Complex or Fraction, the resulting JSON output may be invalid. For example: If a Fraction implementation defines its' toString method as `return numerator + "/" + denominator`, then the resulting JSON output would be something like this: ```json { "fraction" : 1/2 } ``` This is not valid JSON. This commit verifies that the string representation of the number is close to a JSON formatted number by use of the BigDecimal constructor. If the constructor throws a NumberFormatException, then the string value is instead quoted as a string. The example above would instead output like the following: ```json { "fraction" : "1/2" } ```	2016-08-17 12:54:30 -04:00
John J. Aylward	349a209df3	Merge remote-tracking branch 'upstream/master' into EnumCleanup	2016-08-15 10:25:27 -04:00
John J. Aylward	7851e9b2e8	revert back changes to Number support	2016-08-15 10:24:38 -04:00
Sean Leary	7232a95c0b	Update JSONObject.java Fixed some typos committed in #249, since reverted, tracking issue is #263	2016-08-15 01:58:54 -05:00
Sean Leary	f96f505188	Update JSONArray.java Fixed a Javadoc typo, originally fixed in #249, since reverted. This is to address issue #263	2016-08-15 01:53:08 -05:00
John J. Aylward	91107e3e82	Adds support to JSONObject wrap and write methods to explicitly handle Enums. The new way enums are handled is to always place the actual enum in the JSONObject/JSONArray. When writing, we always write the actual "name" of the enum, so even with a toString override on the enum class, the value remains consistant and compatible with the optEnum/getEnum methods. The constructor JSONObject(Object) functions the same way as before when passing an enum and is consistent with other "value" types. For example, when creating a JSONObject with Long, Boolean, BigDecimal as the constructor parameter, the value will be treated as a "bean".	2016-08-11 12:22:31 -04:00
Sean Leary	4e8e24d49d	Merge pull request #259 from run2000/appendable_v2 JSONWriter uses Appendable (v2)	2016-08-10 21:55:10 -05:00
Sean Leary	f881b61c81	Update XML.java Removed a problematic JavaDoc in the header comment to a deprecated method	2016-08-10 15:35:26 -05:00
Sean Leary	37582a44ad	Update README	2016-08-10 09:13:22 -05:00
Sean Leary	154cfda9aa	Merge pull request #261 from stleary/revert-249-master Revert "reduces the use of unnecessary exceptions"	2016-08-10 09:03:57 -05:00
Sean Leary	45a7decba4	Revert "reduces the use of unnecessary exceptions"	2016-08-09 14:22:06 -05:00
Nicholas Cull	0c157cae75	JSONWriter uses Appendable.	2016-08-08 19:40:10 +10:00
Sean Leary	8e079599c4	Update README	2016-08-07 15:19:44 -05:00
Sean Leary	3080b8beeb	Merge pull request #253 from johnjaylward/OptionalTypeConversion Optional type conversion for XML reading	2016-07-31 21:09:07 -05:00
Sean Leary	2c228ecf1a	Merge pull request #249 from Simulant87/master reduces the use of unnecessary exceptions	2016-07-26 23:04:49 -05:00
Nils Faupel	3890bfae52	reduce the use of unnecessary exceptions	2016-07-19 19:59:30 +02:00
Nils Faupel	abf2963bbe	Revert "reduces the use of unnecessary exceptions" This reverts commit `7627d40d10`.	2016-07-19 19:00:42 +02:00
John J. Aylward	09d37e59b8	Cleans up the JSONML changes and adds similar changes to the XML class	2016-07-18 14:42:21 -04:00
John J. Aylward	93704371bb	Updates to the Javadoc for exceptions	2016-07-18 14:12:06 -04:00
Jakob Stemberger	42e0944708	Brings in changes from PR #70 to be updated to HEAD	2016-07-18 13:45:31 -04:00
Simulant	7627d40d10	reduces the use of unnecessary exceptions	2016-07-08 22:17:05 +02:00
Sean Leary	04181fb6e2	Merge pull request #246 from johnjaylward/LicenseFile Add License file	2016-07-02 13:20:54 -05:00
Sean Leary	239e0b7070	Merge pull request #242 from johnjaylward/issue240 Fixes Issue #240	2016-07-02 13:20:21 -05:00
johnjaylward	a8a71898a3	Create LICENSE	2016-06-22 14:49:52 -04:00
johnjaylward	86e8f7b313	Update README fixes typo	2016-06-17 16:39:11 -04:00
John J. Aylward	42791ab12d	Updates README to note that the parser does allow some invalid JSON	2016-06-16 13:01:22 -04:00
johnjaylward	b3abaa5b4c	Merge pull request #1 from stleary/master update from origin	2016-06-16 11:43:05 -04:00
Sean Leary	eb569b58fc	Merge pull request #236 from madsager/master Make nextString throw a JSONException instead of a NumberFormatExcept…	2016-06-07 21:29:02 -05:00
Mads Ager	16a86d73df	Pass in the throwable that caused the error.	2016-06-02 16:11:15 +02:00
Mads Ager	dfa651e777	Make nextString throw a JSONException instead of a NumberFormatException for malformed input.	2016-06-02 15:56:48 +02:00
Sean Leary	612dafc750	Update JSONObject.java	2016-05-20 21:10:17 -05:00
Sean Leary	808320801a	Update JSONArray.java Update version timestamp	2016-05-20 21:09:53 -05:00
Sean Leary	b2bde1f468	Merge pull request #234 from erosb/master fixing stleary/JSON-Java#233	2016-05-20 21:03:06 -05:00
Bence Erős	56be31e7a8	fixing stleary/JSON-Java#233	2016-05-16 14:53:34 +02:00
stleary	9a81b40334	added some JavaDocs	2016-05-14 11:09:51 -05:00
stleary	4a458a9f1c	add timestamps to recent commits, javadocs for JSONObject, JSONArray queryFrom() methods	2016-05-14 09:22:18 -05:00
Sean Leary	8a72509e6e	Merge pull request #222 from erosb/master JSON Pointer implementation	2016-05-13 22:46:52 -05:00
Bence Erős	c044eb14dd	added copying to JSONPointer constructor	2016-05-05 15:59:43 +02:00
Bence Erős	5ae6a66e38	added javadoc & null check in Builder#append(String)	2016-05-03 23:41:51 +02:00
Bence Erős	d833c2d8de	added builder class for JSONPointer, and implemented toString() and toURIFragment()	2016-05-03 23:18:05 +02:00
Sean Leary	f21ffbe189	Update CDL.java Date of last change.	2016-05-02 22:12:29 -05:00
Sean Leary	cad23423ab	Update JSONObject.java Forgot to update date of last change	2016-05-02 22:11:20 -05:00
Sean Leary	ebf08f5651	Merge pull request #226 from stleary/restore-1.6-compatibility fix to compile with 1.6.0_45	2016-05-01 22:59:29 -05:00
Sean Leary	f239dc75ad	Merge pull request #219 from captainIowa/master Added CSV change to CDL.java	2016-05-01 22:55:13 -05:00
stleary	1ca8933a8f	fix to compile with 1.6.0_45	2016-04-28 22:12:16 -05:00
Bence Erős	cbb1546c53	README improvements for stleary/JSON-Java#218	2016-04-28 16:45:17 +02:00
Bence Erős	c1a789a70c	adding missing license headers	2016-04-27 00:11:47 +02:00
Bence Erős	bff352791c	removed @author tag from JSONPointerException	2016-04-27 00:10:45 +02:00
Bence Erős	5223aadd67	added some javadoc to JSONPointer	2016-04-27 00:10:06 +02:00
Bence Erős	45bd72c15d	added JSONObject#query() and JSONPointer#query() methods	2016-04-26 23:48:14 +02:00
Bence Erős	792c6f6a9c	improved failure handling	2016-04-26 23:32:15 +02:00
Bence Erős	5bee7e3b45	escape handling improvements & URL fragment notation handling	2016-04-26 23:00:16 +02:00
Bence Erős	612e41950c	initial implementation of JSONPointer	2016-04-17 23:21:38 +02:00
Brian Russell	86cbfbc864	Added CSV change to CDL.java	2016-04-12 14:13:15 -04:00
Sean Leary	25a87975be	Update date of merge.	2016-03-05 15:20:20 -06:00
Sean Leary	2f3af56535	Update date of merge.	2016-03-05 15:19:45 -06:00
Sean Leary	26477f4e76	Merge pull request #203 from joeferner/to-java Adds JSONArray toList method and JSONObject toMap method	2016-03-05 15:18:38 -06:00
Joe Ferner	f024b52108	Adds JSONArray toList method and JSONObject toMap method	2016-02-27 11:20:25 -05:00
Sean Leary	2657915293	Update README Include some text about 1.6 compatibility and add the latest release information.	2016-02-13 22:26:45 -06:00
Sean Leary	07a0f60b6e	Merge pull request #195 from publishing-systems/master Java 1.6 compatibility.	2016-02-12 18:10:13 -06:00
skreutzer	60349ece54	Java 1.6 compatibility.	2016-02-08 23:30:27 -05:00
Sean Leary	ba2585fe6c	Version date	2016-01-30 15:45:11 -06:00
Sean Leary	93c79ca566	Version date	2016-01-30 15:44:41 -06:00
Sean Leary	62486fdea4	Version date	2016-01-30 15:44:08 -06:00
Sean Leary	97f1b2744f	Merge pull request #188 from johnjaylward/FixNegativeZero Fix negative zero	2016-01-30 15:42:34 -06:00
John J. Aylward	c2b3f2bdb1	adds back in the XML.stringToValue method, but deprecates it.	2016-01-27 15:21:11 -05:00
John J. Aylward	3007fc8ebe	Removes custom XML stringToValue method in favor of keeping a consistent implementation in JSONObject	2016-01-27 15:03:19 -05:00
John J. Aylward	39b1c0cb66	fixes error in -0 check	2016-01-27 10:45:23 -05:00
John J. Aylward	07b2d65e30	Fixes #187 -0 now returns as a double.	2016-01-27 10:39:31 -05:00
John J. Aylward	5b67330b71	Merge branch 'master' of https://github.com/douglascrockford/JSON-java	2016-01-27 09:53:03 -05:00
Sean Leary	9950350f12	Merge pull request #186 from douglascrockford/update-readme-with-number-info Update README with number information	2016-01-03 14:52:50 -06:00
Sean Leary	2b2fac3eb1	Broke up some overly long lines.	2016-01-01 16:17:30 -06:00
Sean Leary	e2a0bb16a2	Update README with number information See https://github.com/douglascrockford/JSON-java/issues/162	2016-01-01 14:11:02 -06:00
Sean Leary	a971736f5b	Update version string for https://github.com/douglascrockford/JSON-java/pull/170	2016-01-01 13:52:12 -06:00
Sean Leary	757fd566ab	Merge pull request #170 from johnjaylward/HandleArraysConsistently Handle arrays consistently	2016-01-01 13:44:57 -06:00
Sean Leary	e6f5047742	Merge pull request #185 from douglascrockford/write-with-indent-params change to public: write(writer, indentfactor, indent)	2015-12-30 15:06:07 -06:00
stleary	8688494876	change to public, write(writer, indentfactor, indent)	2015-12-23 19:53:30 -06:00
John J. Aylward	48302592cf	Merge branch 'master' of https://github.com/douglascrockford/JSON-java	2015-12-09 10:07:36 -05:00
Sean Leary	03dd662e72	Merge pull request #180 from netheril96/my Remove executable bit	2015-12-09 01:08:47 -06:00
Siyuan Ren	23cf659730	Remove executable permission bit from file mode	2015-12-09 09:50:59 +08:00
John J. Aylward	ec8f649467	Merge branch 'master' of https://github.com/douglascrockford/JSON-java	2015-12-08 09:27:54 -05:00
Sean Leary	39e3ccc671	Update version Update version after merge of https://github.com/douglascrockford/JSON-java/pull/179	2015-12-05 20:14:15 -06:00
Sean Leary	2ec538f420	Merge pull request #179 from andrew-fletcher/UpdateJavaDocForJSONOBject Remove throws JSONException JavaDoc from 2 methods that do not throw this exception.	2015-12-05 20:11:40 -06:00
Andrew Fletcher	cadba9400c	Update JavaDoc for JSONObject Constructors Two JSONObject constructors incorrectly specify a @throws JSONException tag in the JavaDoc for those constructors. Remove the relevant JavaDoc.	2015-12-02 10:49:54 -08:00
John J. Aylward	105426b53f	Formatting	2015-10-26 18:35:40 -04:00
John J. Aylward	7886c96204	Changes JSONArray for loops to use the new iterators.	2015-10-26 18:30:41 -04:00
John J. Aylward	91c6f09be8	Modifies XML output to be handled the same for a native java array as well as a JSONArray.	2015-10-26 18:17:37 -04:00