+ */
+public class JSONValue {
+ /**
+ * Parse JSON text into java object from the input source.
+ * Please use parseWithException() if you don't want to ignore the exception.
+ *
+ * @see org.json.simple.parser.JSONParser#parse(Reader)
+ * @see #parseWithException(Reader)
+ *
+ * @param in
+ * @return Instance of the following:
+ * org.json.simple.JSONObject,
+ * org.json.simple.JSONArray,
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean,
+ * null
+ *
+ */
+ public static Object parse(Reader in){
+ try{
+ JSONParser parser=new JSONParser();
+ return parser.parse(in);
+ }
+ catch(Exception e){
+ return null;
+ }
+ }
+
+ public static Object parse(String s){
+ StringReader in=new StringReader(s);
+ return parse(in);
+ }
+
+ /**
+ * Parse JSON text into java object from the input source.
+ *
+ * @see org.json.simple.parser.JSONParser
+ *
+ * @param in
+ * @return Instance of the following:
+ * org.json.simple.JSONObject,
+ * org.json.simple.JSONArray,
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean,
+ * null
+ *
+ * @throws IOException
+ * @throws ParseException
+ */
+ public static Object parseWithException(Reader in) throws IOException, ParseException{
+ JSONParser parser=new JSONParser();
+ return parser.parse(in);
+ }
+
+ public static Object parseWithException(String s) throws ParseException{
+ JSONParser parser=new JSONParser();
+ return parser.parse(s);
+ }
+
+ /**
+ * Encode an object into JSON text and write it to out.
+ *
+ * If this object is a Map or a List, and it's also a JSONStreamAware or a JSONAware, JSONStreamAware or JSONAware will be considered firstly.
+ *
+ * DO NOT call this method from writeJSONString(Writer) of a class that implements both JSONStreamAware and (Map or List) with
+ * "this" as the first parameter, use JSONObject.writeJSONString(Map, Writer) or JSONArray.writeJSONString(List, Writer) instead.
+ *
+ * @see org.json.simple.JSONObject#writeJSONString(Map, Writer)
+ * @see org.json.simple.JSONArray#writeJSONString(List, Writer)
+ *
+ * @param value
+ * @param writer
+ */
+ public static void writeJSONString(Object value, Writer out) throws IOException {
+ if(value == null){
+ out.write("null");
+ return;
+ }
+
+ if(value instanceof String){
+ out.write('\"');
+ out.write(escape((String)value));
+ out.write('\"');
+ return;
+ }
+
+ if(value instanceof Double){
+ if(((Double)value).isInfinite() || ((Double)value).isNaN())
+ out.write("null");
+ else
+ out.write(value.toString());
+ return;
+ }
+
+ if(value instanceof Float){
+ if(((Float)value).isInfinite() || ((Float)value).isNaN())
+ out.write("null");
+ else
+ out.write(value.toString());
+ return;
+ }
+
+ if(value instanceof Number){
+ out.write(value.toString());
+ return;
+ }
+
+ if(value instanceof Boolean){
+ out.write(value.toString());
+ return;
+ }
+
+ if((value instanceof JSONStreamAware)){
+ ((JSONStreamAware)value).writeJSONString(out);
+ return;
+ }
+
+ if((value instanceof JSONAware)){
+ out.write(((JSONAware)value).toJSONString());
+ return;
+ }
+
+ if(value instanceof Map){
+ JSONObject.writeJSONString((Map)value, out);
+ return;
+ }
+
+ if(value instanceof List){
+ JSONArray.writeJSONString((List)value, out);
+ return;
+ }
+
+ out.write(value.toString());
+ }
+
+ /**
+ * Convert an object to JSON text.
+ *
+ * If this object is a Map or a List, and it's also a JSONAware, JSONAware will be considered firstly.
+ *
+ * DO NOT call this method from toJSONString() of a class that implements both JSONAware and Map or List with
+ * "this" as the parameter, use JSONObject.toJSONString(Map) or JSONArray.toJSONString(List) instead.
+ *
+ * @see org.json.simple.JSONObject#toJSONString(Map)
+ * @see org.json.simple.JSONArray#toJSONString(List)
+ *
+ * @param value
+ * @return JSON text, or "null" if value is null or it's an NaN or an INF number.
+ */
+ public static String toJSONString(Object value){
+ if(value == null)
+ return "null";
+
+ if(value instanceof String)
+ return "\""+escape((String)value)+"\"";
+
+ if(value instanceof Double){
+ if(((Double)value).isInfinite() || ((Double)value).isNaN())
+ return "null";
+ else
+ return value.toString();
+ }
+
+ if(value instanceof Float){
+ if(((Float)value).isInfinite() || ((Float)value).isNaN())
+ return "null";
+ else
+ return value.toString();
+ }
+
+ if(value instanceof Number)
+ return value.toString();
+
+ if(value instanceof Boolean)
+ return value.toString();
+
+ if((value instanceof JSONAware))
+ return ((JSONAware)value).toJSONString();
+
+ if(value instanceof Map)
+ return JSONObject.toJSONString((Map)value);
+
+ if(value instanceof List)
+ return JSONArray.toJSONString((List)value);
+
+ return value.toString();
+ }
+
+ /**
+ * Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).
+ * @param s
+ * @return
+ */
+ public static String escape(String s){
+ if(s==null)
+ return null;
+ StringBuffer sb = new StringBuffer();
+ escape(s, sb);
+ return sb.toString();
+ }
+
+ /**
+ * @param s - Must not be null.
+ * @param sb
+ */
+ static void escape(String s, StringBuffer sb) {
+ for(int i=0;i='\u0000' && ch<='\u001F') || (ch>='\u007F' && ch<='\u009F') || (ch>='\u2000' && ch<='\u20FF')){
+ String ss=Integer.toHexString(ch);
+ sb.append("\\u");
+ for(int k=0;k<4-ss.length();k++){
+ sb.append('0');
+ }
+ sb.append(ss.toUpperCase());
+ }
+ else{
+ sb.append(ch);
+ }
+ }
+ }//for
+ }
+
+}
diff --git a/src/java/org/json/simple/LICENSE.txt b/src/java/org/json/simple/LICENSE.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/src/java/org/json/simple/LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/src/java/org/json/simple/parser/ContainerFactory.java b/src/java/org/json/simple/parser/ContainerFactory.java
new file mode 100644
index 0000000..366ac4d
--- /dev/null
+++ b/src/java/org/json/simple/parser/ContainerFactory.java
@@ -0,0 +1,23 @@
+package org.json.simple.parser;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Container factory for creating containers for JSON object and JSON array.
+ *
+ * @see org.json.simple.parser.JSONParser#parse(java.io.Reader, ContainerFactory)
+ *
+ * @author FangYidong
+ */
+public interface ContainerFactory {
+ /**
+ * @return A Map instance to store JSON object, or null if you want to use org.json.simple.JSONObject.
+ */
+ Map createObjectContainer();
+
+ /**
+ * @return A List instance to store JSON array, or null if you want to use org.json.simple.JSONArray.
+ */
+ List creatArrayContainer();
+}
diff --git a/src/java/org/json/simple/parser/ContentHandler.java b/src/java/org/json/simple/parser/ContentHandler.java
new file mode 100644
index 0000000..ae8d065
--- /dev/null
+++ b/src/java/org/json/simple/parser/ContentHandler.java
@@ -0,0 +1,110 @@
+package org.json.simple.parser;
+
+import java.io.IOException;
+
+/**
+ * A simplified and stoppable SAX-like content handler for stream processing of JSON text.
+ *
+ * @see org.xml.sax.ContentHandler
+ * @see org.json.simple.parser.JSONParser#parse(java.io.Reader, ContentHandler, boolean)
+ *
+ * @author FangYidong
+ */
+public interface ContentHandler {
+ /**
+ * Receive notification of the beginning of JSON processing.
+ * The parser will invoke this method only once.
+ *
+ * @throws ParseException
+ * - JSONParser will stop and throw the same exception to the caller when receiving this exception.
+ */
+ void startJSON() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of JSON processing.
+ *
+ * @throws ParseException
+ */
+ void endJSON() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the beginning of a JSON object.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ * - JSONParser will stop and throw the same exception to the caller when receiving this exception.
+ * @see #endJSON
+ */
+ boolean startObject() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of a JSON object.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #startObject
+ */
+ boolean endObject() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the beginning of a JSON object entry.
+ *
+ * @param key - Key of a JSON object entry.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #endObjectEntry
+ */
+ boolean startObjectEntry(String key) throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of the value of previous object entry.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #startObjectEntry
+ */
+ boolean endObjectEntry() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the beginning of a JSON array.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #endArray
+ */
+ boolean startArray() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the end of a JSON array.
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ *
+ * @see #startArray
+ */
+ boolean endArray() throws ParseException, IOException;
+
+ /**
+ * Receive notification of the JSON primitive values:
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean
+ * null
+ *
+ * @param value - Instance of the following:
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean
+ * null
+ *
+ * @return false if the handler wants to stop parsing after return.
+ * @throws ParseException
+ */
+ boolean primitive(Object value) throws ParseException, IOException;
+
+}
diff --git a/src/java/org/json/simple/parser/JSONParser.java b/src/java/org/json/simple/parser/JSONParser.java
new file mode 100644
index 0000000..9acaa37
--- /dev/null
+++ b/src/java/org/json/simple/parser/JSONParser.java
@@ -0,0 +1,533 @@
+/*
+ * $Id: JSONParser.java,v 1.1 2006/04/15 14:10:48 platform Exp $
+ * Created on 2006-4-15
+ */
+package org.json.simple.parser;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+
+/**
+ * Parser for JSON text. Please note that JSONParser is NOT thread-safe.
+ *
+ * @author FangYidong
+ */
+public class JSONParser {
+ public static final int S_INIT=0;
+ public static final int S_IN_FINISHED_VALUE=1;//string,number,boolean,null,object,array
+ public static final int S_IN_OBJECT=2;
+ public static final int S_IN_ARRAY=3;
+ public static final int S_PASSED_PAIR_KEY=4;
+ public static final int S_IN_PAIR_VALUE=5;
+ public static final int S_END=6;
+ public static final int S_IN_ERROR=-1;
+
+ private LinkedList handlerStatusStack;
+ private Yylex lexer = new Yylex((Reader)null);
+ private Yytoken token = null;
+ private int status = S_INIT;
+
+ private int peekStatus(LinkedList statusStack){
+ if(statusStack.size()==0)
+ return -1;
+ Integer status=(Integer)statusStack.getFirst();
+ return status.intValue();
+ }
+
+ /**
+ * Reset the parser to the initial state without resetting the underlying reader.
+ *
+ */
+ public void reset(){
+ token = null;
+ status = S_INIT;
+ handlerStatusStack = null;
+ }
+
+ /**
+ * Reset the parser to the initial state with a new character reader.
+ *
+ * @param in - The new character reader.
+ * @throws IOException
+ * @throws ParseException
+ */
+ public void reset(Reader in){
+ lexer.yyreset(in);
+ reset();
+ }
+
+ /**
+ * @return The position of the beginning of the current token.
+ */
+ public int getPosition(){
+ return lexer.getPosition();
+ }
+
+ public Object parse(String s) throws ParseException{
+ return parse(s, (ContainerFactory)null);
+ }
+
+ public Object parse(String s, ContainerFactory containerFactory) throws ParseException{
+ StringReader in=new StringReader(s);
+ try{
+ return parse(in, containerFactory);
+ }
+ catch(IOException ie){
+ /*
+ * Actually it will never happen.
+ */
+ throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
+ }
+ }
+
+ public Object parse(Reader in) throws IOException, ParseException{
+ return parse(in, (ContainerFactory)null);
+ }
+
+ /**
+ * Parse JSON text into java object from the input source.
+ *
+ * @param in
+ * @param containerFactory - Use this factory to createyour own JSON object and JSON array containers.
+ * @return Instance of the following:
+ * org.json.simple.JSONObject,
+ * org.json.simple.JSONArray,
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean,
+ * null
+ *
+ * @throws IOException
+ * @throws ParseException
+ */
+ public Object parse(Reader in, ContainerFactory containerFactory) throws IOException, ParseException{
+ reset(in);
+ LinkedList statusStack = new LinkedList();
+ LinkedList valueStack = new LinkedList();
+
+ try{
+ do{
+ nextToken();
+ switch(status){
+ case S_INIT:
+ switch(token.type){
+ case Yytoken.TYPE_VALUE:
+ status=S_IN_FINISHED_VALUE;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(token.value);
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(createObjectContainer(containerFactory));
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(createArrayContainer(containerFactory));
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+
+ case S_IN_FINISHED_VALUE:
+ if(token.type==Yytoken.TYPE_EOF)
+ return valueStack.removeFirst();
+ else
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+
+ case S_IN_OBJECT:
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ if(token.value instanceof String){
+ String key=(String)token.value;
+ valueStack.addFirst(key);
+ status=S_PASSED_PAIR_KEY;
+ statusStack.addFirst(new Integer(status));
+ }
+ else{
+ status=S_IN_ERROR;
+ }
+ break;
+ case Yytoken.TYPE_RIGHT_BRACE:
+ if(valueStack.size()>1){
+ statusStack.removeFirst();
+ valueStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ break;
+ default:
+ status=S_IN_ERROR;
+ break;
+ }//inner switch
+ break;
+
+ case S_PASSED_PAIR_KEY:
+ switch(token.type){
+ case Yytoken.TYPE_COLON:
+ break;
+ case Yytoken.TYPE_VALUE:
+ statusStack.removeFirst();
+ String key=(String)valueStack.removeFirst();
+ Map parent=(Map)valueStack.getFirst();
+ parent.put(key,token.value);
+ status=peekStatus(statusStack);
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ statusStack.removeFirst();
+ key=(String)valueStack.removeFirst();
+ parent=(Map)valueStack.getFirst();
+ List newArray=createArrayContainer(containerFactory);
+ parent.put(key,newArray);
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newArray);
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ statusStack.removeFirst();
+ key=(String)valueStack.removeFirst();
+ parent=(Map)valueStack.getFirst();
+ Map newObject=createObjectContainer(containerFactory);
+ parent.put(key,newObject);
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newObject);
+ break;
+ default:
+ status=S_IN_ERROR;
+ }
+ break;
+
+ case S_IN_ARRAY:
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ List val=(List)valueStack.getFirst();
+ val.add(token.value);
+ break;
+ case Yytoken.TYPE_RIGHT_SQUARE:
+ if(valueStack.size()>1){
+ statusStack.removeFirst();
+ valueStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ val=(List)valueStack.getFirst();
+ Map newObject=createObjectContainer(containerFactory);
+ val.add(newObject);
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newObject);
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ val=(List)valueStack.getFirst();
+ List newArray=createArrayContainer(containerFactory);
+ val.add(newArray);
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ valueStack.addFirst(newArray);
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+ case S_IN_ERROR:
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }//switch
+ if(status==S_IN_ERROR){
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+ }while(token.type!=Yytoken.TYPE_EOF);
+ }
+ catch(IOException ie){
+ throw ie;
+ }
+
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+
+ private void nextToken() throws ParseException, IOException{
+ token = lexer.yylex();
+ if(token == null)
+ token = new Yytoken(Yytoken.TYPE_EOF, null);
+ }
+
+ private Map createObjectContainer(ContainerFactory containerFactory){
+ if(containerFactory == null)
+ return new JSONObject();
+ Map m = containerFactory.createObjectContainer();
+
+ if(m == null)
+ return new JSONObject();
+ return m;
+ }
+
+ private List createArrayContainer(ContainerFactory containerFactory){
+ if(containerFactory == null)
+ return new JSONArray();
+ List l = containerFactory.creatArrayContainer();
+
+ if(l == null)
+ return new JSONArray();
+ return l;
+ }
+
+ public void parse(String s, ContentHandler contentHandler) throws ParseException{
+ parse(s, contentHandler, false);
+ }
+
+ public void parse(String s, ContentHandler contentHandler, boolean isResume) throws ParseException{
+ StringReader in=new StringReader(s);
+ try{
+ parse(in, contentHandler, isResume);
+ }
+ catch(IOException ie){
+ /*
+ * Actually it will never happen.
+ */
+ throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
+ }
+ }
+
+ public void parse(Reader in, ContentHandler contentHandler) throws IOException, ParseException{
+ parse(in, contentHandler, false);
+ }
+
+ /**
+ * Stream processing of JSON text.
+ *
+ * @see ContentHandler
+ *
+ * @param in
+ * @param contentHandler
+ * @param isResume - Indicates if it continues previous parsing operation.
+ * If set to true, resume parsing the old stream, and parameter 'in' will be ignored.
+ * If this method is called for the first time in this instance, isResume will be ignored.
+ *
+ * @throws IOException
+ * @throws ParseException
+ */
+ public void parse(Reader in, ContentHandler contentHandler, boolean isResume) throws IOException, ParseException{
+ if(!isResume){
+ reset(in);
+ handlerStatusStack = new LinkedList();
+ }
+ else{
+ if(handlerStatusStack == null){
+ isResume = false;
+ reset(in);
+ handlerStatusStack = new LinkedList();
+ }
+ }
+
+ LinkedList statusStack = handlerStatusStack;
+
+ try{
+ do{
+ switch(status){
+ case S_INIT:
+ contentHandler.startJSON();
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_VALUE:
+ status=S_IN_FINISHED_VALUE;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.primitive(token.value))
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObject())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startArray())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+
+ case S_IN_FINISHED_VALUE:
+ nextToken();
+ if(token.type==Yytoken.TYPE_EOF){
+ contentHandler.endJSON();
+ status = S_END;
+ return;
+ }
+ else{
+ status = S_IN_ERROR;
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+
+ case S_IN_OBJECT:
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ if(token.value instanceof String){
+ String key=(String)token.value;
+ status=S_PASSED_PAIR_KEY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObjectEntry(key))
+ return;
+ }
+ else{
+ status=S_IN_ERROR;
+ }
+ break;
+ case Yytoken.TYPE_RIGHT_BRACE:
+ if(statusStack.size()>1){
+ statusStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ if(!contentHandler.endObject())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ break;
+ }//inner switch
+ break;
+
+ case S_PASSED_PAIR_KEY:
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_COLON:
+ break;
+ case Yytoken.TYPE_VALUE:
+ statusStack.removeFirst();
+ status=peekStatus(statusStack);
+ if(!contentHandler.primitive(token.value))
+ return;
+ if(!contentHandler.endObjectEntry())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ statusStack.removeFirst();
+ statusStack.addFirst(new Integer(S_IN_PAIR_VALUE));
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startArray())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ statusStack.removeFirst();
+ statusStack.addFirst(new Integer(S_IN_PAIR_VALUE));
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObject())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ }
+ break;
+
+ case S_IN_PAIR_VALUE:
+ /*
+ * S_IN_PAIR_VALUE is just a marker to indicate the end of an object entry, it doesn't proccess any token,
+ * therefore delay consuming token until next round.
+ */
+ statusStack.removeFirst();
+ status = peekStatus(statusStack);
+ if(!contentHandler.endObjectEntry())
+ return;
+ break;
+
+ case S_IN_ARRAY:
+ nextToken();
+ switch(token.type){
+ case Yytoken.TYPE_COMMA:
+ break;
+ case Yytoken.TYPE_VALUE:
+ if(!contentHandler.primitive(token.value))
+ return;
+ break;
+ case Yytoken.TYPE_RIGHT_SQUARE:
+ if(statusStack.size()>1){
+ statusStack.removeFirst();
+ status=peekStatus(statusStack);
+ }
+ else{
+ status=S_IN_FINISHED_VALUE;
+ }
+ if(!contentHandler.endArray())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_BRACE:
+ status=S_IN_OBJECT;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startObject())
+ return;
+ break;
+ case Yytoken.TYPE_LEFT_SQUARE:
+ status=S_IN_ARRAY;
+ statusStack.addFirst(new Integer(status));
+ if(!contentHandler.startArray())
+ return;
+ break;
+ default:
+ status=S_IN_ERROR;
+ }//inner switch
+ break;
+
+ case S_END:
+ return;
+
+ case S_IN_ERROR:
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }//switch
+ if(status==S_IN_ERROR){
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+ }while(token.type!=Yytoken.TYPE_EOF);
+ }
+ catch(IOException ie){
+ status = S_IN_ERROR;
+ throw ie;
+ }
+ catch(ParseException pe){
+ status = S_IN_ERROR;
+ throw pe;
+ }
+ catch(RuntimeException re){
+ status = S_IN_ERROR;
+ throw re;
+ }
+ catch(Error e){
+ status = S_IN_ERROR;
+ throw e;
+ }
+
+ status = S_IN_ERROR;
+ throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
+ }
+}
diff --git a/src/java/org/json/simple/parser/ParseException.java b/src/java/org/json/simple/parser/ParseException.java
new file mode 100644
index 0000000..f497cd9
--- /dev/null
+++ b/src/java/org/json/simple/parser/ParseException.java
@@ -0,0 +1,90 @@
+package org.json.simple.parser;
+
+/**
+ * ParseException explains why and where the error occurs in source JSON text.
+ *
+ * @author FangYidong
+ *
+ */
+public class ParseException extends Exception {
+ private static final long serialVersionUID = -7880698968187728548L;
+
+ public static final int ERROR_UNEXPECTED_CHAR = 0;
+ public static final int ERROR_UNEXPECTED_TOKEN = 1;
+ public static final int ERROR_UNEXPECTED_EXCEPTION = 2;
+
+ private int errorType;
+ private Object unexpectedObject;
+ private int position;
+
+ public ParseException(int errorType){
+ this(-1, errorType, null);
+ }
+
+ public ParseException(int errorType, Object unexpectedObject){
+ this(-1, errorType, unexpectedObject);
+ }
+
+ public ParseException(int position, int errorType, Object unexpectedObject){
+ this.position = position;
+ this.errorType = errorType;
+ this.unexpectedObject = unexpectedObject;
+ }
+
+ public int getErrorType() {
+ return errorType;
+ }
+
+ public void setErrorType(int errorType) {
+ this.errorType = errorType;
+ }
+
+ /**
+ * @see org.json.simple.parser.JSONParser#getPosition()
+ *
+ * @return The character position (starting with 0) of the input where the error occurs.
+ */
+ public int getPosition() {
+ return position;
+ }
+
+ public void setPosition(int position) {
+ this.position = position;
+ }
+
+ /**
+ * @see org.json.simple.parser.Yytoken
+ *
+ * @return One of the following base on the value of errorType:
+ * ERROR_UNEXPECTED_CHAR java.lang.Character
+ * ERROR_UNEXPECTED_TOKEN org.json.simple.parser.Yytoken
+ * ERROR_UNEXPECTED_EXCEPTION java.lang.Exception
+ */
+ public Object getUnexpectedObject() {
+ return unexpectedObject;
+ }
+
+ public void setUnexpectedObject(Object unexpectedObject) {
+ this.unexpectedObject = unexpectedObject;
+ }
+
+ public String toString(){
+ StringBuffer sb = new StringBuffer();
+
+ switch(errorType){
+ case ERROR_UNEXPECTED_CHAR:
+ sb.append("Unexpected character (").append(unexpectedObject).append(") at position ").append(position).append(".");
+ break;
+ case ERROR_UNEXPECTED_TOKEN:
+ sb.append("Unexpected token ").append(unexpectedObject).append(" at position ").append(position).append(".");
+ break;
+ case ERROR_UNEXPECTED_EXCEPTION:
+ sb.append("Unexpected exception at position ").append(position).append(": ").append(unexpectedObject);
+ break;
+ default:
+ sb.append("Unkown error at position ").append(position).append(".");
+ break;
+ }
+ return sb.toString();
+ }
+}
diff --git a/src/java/org/json/simple/parser/Yylex.java b/src/java/org/json/simple/parser/Yylex.java
new file mode 100644
index 0000000..42ce508
--- /dev/null
+++ b/src/java/org/json/simple/parser/Yylex.java
@@ -0,0 +1,688 @@
+/* The following code was generated by JFlex 1.4.2 */
+
+package org.json.simple.parser;
+
+class Yylex {
+
+ /** This character denotes the end of file */
+ public static final int YYEOF = -1;
+
+ /** initial size of the lookahead buffer */
+ private static final int ZZ_BUFFERSIZE = 16384;
+
+ /** lexical states */
+ public static final int YYINITIAL = 0;
+ public static final int STRING_BEGIN = 2;
+
+ /**
+ * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
+ * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
+ * at the beginning of a line
+ * l is of the form l = 2*k, k a non negative integer
+ */
+ private static final int ZZ_LEXSTATE[] = {
+ 0, 0, 1, 1
+ };
+
+ /**
+ * Translates characters to character classes
+ */
+ private static final String ZZ_CMAP_PACKED =
+ "\11\0\1\7\1\7\2\0\1\7\22\0\1\7\1\0\1\11\10\0"+
+ "\1\6\1\31\1\2\1\4\1\12\12\3\1\32\6\0\4\1\1\5"+
+ "\1\1\24\0\1\27\1\10\1\30\3\0\1\22\1\13\2\1\1\21"+
+ "\1\14\5\0\1\23\1\0\1\15\3\0\1\16\1\24\1\17\1\20"+
+ "\5\0\1\25\1\0\1\26\uff82\0";
+
+ /**
+ * Translates characters to character classes
+ */
+ private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
+
+ /**
+ * Translates DFA states to action switch labels.
+ */
+ private static final int [] ZZ_ACTION = zzUnpackAction();
+
+ private static final String ZZ_ACTION_PACKED_0 =
+ "\2\0\2\1\1\2\1\3\1\4\3\1\1\5\1\6"+
+ "\1\7\1\10\1\11\1\12\1\13\1\14\1\15\5\0"+
+ "\1\14\1\16\1\17\1\20\1\21\1\22\1\23\1\24"+
+ "\1\0\1\25\1\0\1\25\4\0\1\26\1\27\2\0"+
+ "\1\30";
+
+ private static int [] zzUnpackAction() {
+ int [] result = new int[45];
+ int offset = 0;
+ offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
+ return result;
+ }
+
+ private static int zzUnpackAction(String packed, int offset, int [] result) {
+ int i = 0; /* index in packed string */
+ int j = offset; /* index in unpacked array */
+ int l = packed.length();
+ while (i < l) {
+ int count = packed.charAt(i++);
+ int value = packed.charAt(i++);
+ do result[j++] = value; while (--count > 0);
+ }
+ return j;
+ }
+
+
+ /**
+ * Translates a state to a row index in the transition table
+ */
+ private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
+
+ private static final String ZZ_ROWMAP_PACKED_0 =
+ "\0\0\0\33\0\66\0\121\0\154\0\207\0\66\0\242"+
+ "\0\275\0\330\0\66\0\66\0\66\0\66\0\66\0\66"+
+ "\0\363\0\u010e\0\66\0\u0129\0\u0144\0\u015f\0\u017a\0\u0195"+
+ "\0\66\0\66\0\66\0\66\0\66\0\66\0\66\0\66"+
+ "\0\u01b0\0\u01cb\0\u01e6\0\u01e6\0\u0201\0\u021c\0\u0237\0\u0252"+
+ "\0\66\0\66\0\u026d\0\u0288\0\66";
+
+ private static int [] zzUnpackRowMap() {
+ int [] result = new int[45];
+ int offset = 0;
+ offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
+ return result;
+ }
+
+ private static int zzUnpackRowMap(String packed, int offset, int [] result) {
+ int i = 0; /* index in packed string */
+ int j = offset; /* index in unpacked array */
+ int l = packed.length();
+ while (i < l) {
+ int high = packed.charAt(i++) << 16;
+ result[j++] = high | packed.charAt(i++);
+ }
+ return j;
+ }
+
+ /**
+ * The transition table of the DFA
+ */
+ private static final int ZZ_TRANS [] = {
+ 2, 2, 3, 4, 2, 2, 2, 5, 2, 6,
+ 2, 2, 7, 8, 2, 9, 2, 2, 2, 2,
+ 2, 10, 11, 12, 13, 14, 15, 16, 16, 16,
+ 16, 16, 16, 16, 16, 17, 18, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 4, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 4, 19, 20, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 20, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 5, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 21, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 22, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 23, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 16, 16, 16, 16, 16, 16, 16,
+ 16, -1, -1, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ -1, -1, -1, -1, -1, -1, -1, -1, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 34, 35, -1, -1,
+ 34, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 36, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 37, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 38, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 39, -1, 39, -1, 39, -1, -1,
+ -1, -1, -1, 39, 39, -1, -1, -1, -1, 39,
+ 39, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 33, -1, 20, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 20, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 35,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 38, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 40,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 41, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 42, -1, 42, -1, 42,
+ -1, -1, -1, -1, -1, 42, 42, -1, -1, -1,
+ -1, 42, 42, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 43, -1, 43, -1, 43, -1, -1, -1,
+ -1, -1, 43, 43, -1, -1, -1, -1, 43, 43,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
+ -1, 44, -1, 44, -1, -1, -1, -1, -1, 44,
+ 44, -1, -1, -1, -1, 44, 44, -1, -1, -1,
+ -1, -1, -1, -1, -1,
+ };
+
+ /* error codes */
+ private static final int ZZ_UNKNOWN_ERROR = 0;
+ private static final int ZZ_NO_MATCH = 1;
+ private static final int ZZ_PUSHBACK_2BIG = 2;
+
+ /* error messages for the codes above */
+ private static final String ZZ_ERROR_MSG[] = {
+ "Unkown internal scanner error",
+ "Error: could not match input",
+ "Error: pushback value was too large"
+ };
+
+ /**
+ * ZZ_ATTRIBUTE[aState] contains the attributes of state aState
+ */
+ private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
+
+ private static final String ZZ_ATTRIBUTE_PACKED_0 =
+ "\2\0\1\11\3\1\1\11\3\1\6\11\2\1\1\11"+
+ "\5\0\10\11\1\0\1\1\1\0\1\1\4\0\2\11"+
+ "\2\0\1\11";
+
+ private static int [] zzUnpackAttribute() {
+ int [] result = new int[45];
+ int offset = 0;
+ offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
+ return result;
+ }
+
+ private static int zzUnpackAttribute(String packed, int offset, int [] result) {
+ int i = 0; /* index in packed string */
+ int j = offset; /* index in unpacked array */
+ int l = packed.length();
+ while (i < l) {
+ int count = packed.charAt(i++);
+ int value = packed.charAt(i++);
+ do result[j++] = value; while (--count > 0);
+ }
+ return j;
+ }
+
+ /** the input device */
+ private java.io.Reader zzReader;
+
+ /** the current state of the DFA */
+ private int zzState;
+
+ /** the current lexical state */
+ private int zzLexicalState = YYINITIAL;
+
+ /** this buffer contains the current text to be matched and is
+ the source of the yytext() string */
+ private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
+
+ /** the textposition at the last accepting state */
+ private int zzMarkedPos;
+
+ /** the current text position in the buffer */
+ private int zzCurrentPos;
+
+ /** startRead marks the beginning of the yytext() string in the buffer */
+ private int zzStartRead;
+
+ /** endRead marks the last character in the buffer, that has been read
+ from input */
+ private int zzEndRead;
+
+ /** number of newlines encountered up to the start of the matched text */
+ private int yyline;
+
+ /** the number of characters up to the start of the matched text */
+ private int yychar;
+
+ /**
+ * the number of characters from the last newline up to the start of the
+ * matched text
+ */
+ private int yycolumn;
+
+ /**
+ * zzAtBOL == true <=> the scanner is currently at the beginning of a line
+ */
+ private boolean zzAtBOL = true;
+
+ /** zzAtEOF == true <=> the scanner is at the EOF */
+ private boolean zzAtEOF;
+
+ /* user code: */
+private StringBuffer sb=new StringBuffer();
+
+int getPosition(){
+ return yychar;
+}
+
+
+
+ /**
+ * Creates a new scanner
+ * There is also a java.io.InputStream version of this constructor.
+ *
+ * @param in the java.io.Reader to read input from.
+ */
+ Yylex(java.io.Reader in) {
+ this.zzReader = in;
+ }
+
+ /**
+ * Creates a new scanner.
+ * There is also java.io.Reader version of this constructor.
+ *
+ * @param in the java.io.Inputstream to read input from.
+ */
+ Yylex(java.io.InputStream in) {
+ this(new java.io.InputStreamReader(in));
+ }
+
+ /**
+ * Unpacks the compressed character translation table.
+ *
+ * @param packed the packed character translation table
+ * @return the unpacked character translation table
+ */
+ private static char [] zzUnpackCMap(String packed) {
+ char [] map = new char[0x10000];
+ int i = 0; /* index in packed string */
+ int j = 0; /* index in unpacked array */
+ while (i < 90) {
+ int count = packed.charAt(i++);
+ char value = packed.charAt(i++);
+ do map[j++] = value; while (--count > 0);
+ }
+ return map;
+ }
+
+
+ /**
+ * Refills the input buffer.
+ *
+ * @return false, iff there was new input.
+ *
+ * @exception java.io.IOException if any I/O-Error occurs
+ */
+ private boolean zzRefill() throws java.io.IOException {
+
+ /* first: make room (if you can) */
+ if (zzStartRead > 0) {
+ System.arraycopy(zzBuffer, zzStartRead,
+ zzBuffer, 0,
+ zzEndRead-zzStartRead);
+
+ /* translate stored positions */
+ zzEndRead-= zzStartRead;
+ zzCurrentPos-= zzStartRead;
+ zzMarkedPos-= zzStartRead;
+ zzStartRead = 0;
+ }
+
+ /* is the buffer big enough? */
+ if (zzCurrentPos >= zzBuffer.length) {
+ /* if not: blow it up */
+ char newBuffer[] = new char[zzCurrentPos*2];
+ System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
+ zzBuffer = newBuffer;
+ }
+
+ /* finally: fill the buffer with new input */
+ int numRead = zzReader.read(zzBuffer, zzEndRead,
+ zzBuffer.length-zzEndRead);
+
+ if (numRead > 0) {
+ zzEndRead+= numRead;
+ return false;
+ }
+ // unlikely but not impossible: read 0 characters, but not at end of stream
+ if (numRead == 0) {
+ int c = zzReader.read();
+ if (c == -1) {
+ return true;
+ } else {
+ zzBuffer[zzEndRead++] = (char) c;
+ return false;
+ }
+ }
+
+ // numRead < 0
+ return true;
+ }
+
+
+ /**
+ * Closes the input stream.
+ */
+ public final void yyclose() throws java.io.IOException {
+ zzAtEOF = true; /* indicate end of file */
+ zzEndRead = zzStartRead; /* invalidate buffer */
+
+ if (zzReader != null)
+ zzReader.close();
+ }
+
+
+ /**
+ * Resets the scanner to read from a new input stream.
+ * Does not close the old reader.
+ *
+ * All internal variables are reset, the old input stream
+ * cannot be reused (internal buffer is discarded and lost).
+ * Lexical state is set to ZZ_INITIAL.
+ *
+ * @param reader the new input stream
+ */
+ public final void yyreset(java.io.Reader reader) {
+ zzReader = reader;
+ zzAtBOL = true;
+ zzAtEOF = false;
+ zzEndRead = zzStartRead = 0;
+ zzCurrentPos = zzMarkedPos = 0;
+ yyline = yychar = yycolumn = 0;
+ zzLexicalState = YYINITIAL;
+ }
+
+
+ /**
+ * Returns the current lexical state.
+ */
+ public final int yystate() {
+ return zzLexicalState;
+ }
+
+
+ /**
+ * Enters a new lexical state
+ *
+ * @param newState the new lexical state
+ */
+ public final void yybegin(int newState) {
+ zzLexicalState = newState;
+ }
+
+
+ /**
+ * Returns the text matched by the current regular expression.
+ */
+ public final String yytext() {
+ return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
+ }
+
+
+ /**
+ * Returns the character at position pos from the
+ * matched text.
+ *
+ * It is equivalent to yytext().charAt(pos), but faster
+ *
+ * @param pos the position of the character to fetch.
+ * A value from 0 to yylength()-1.
+ *
+ * @return the character at position pos
+ */
+ public final char yycharat(int pos) {
+ return zzBuffer[zzStartRead+pos];
+ }
+
+
+ /**
+ * Returns the length of the matched text region.
+ */
+ public final int yylength() {
+ return zzMarkedPos-zzStartRead;
+ }
+
+
+ /**
+ * Reports an error that occured while scanning.
+ *
+ * In a wellformed scanner (no or only correct usage of
+ * yypushback(int) and a match-all fallback rule) this method
+ * will only be called with things that "Can't Possibly Happen".
+ * If this method is called, something is seriously wrong
+ * (e.g. a JFlex bug producing a faulty scanner etc.).
+ *
+ * Usual syntax/scanner level error handling should be done
+ * in error fallback rules.
+ *
+ * @param errorCode the code of the errormessage to display
+ */
+ private void zzScanError(int errorCode) {
+ String message;
+ try {
+ message = ZZ_ERROR_MSG[errorCode];
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
+ }
+
+ throw new Error(message);
+ }
+
+
+ /**
+ * Pushes the specified amount of characters back into the input stream.
+ *
+ * They will be read again by then next call of the scanning method
+ *
+ * @param number the number of characters to be read again.
+ * This number must not be greater than yylength()!
+ */
+ public void yypushback(int number) {
+ if ( number > yylength() )
+ zzScanError(ZZ_PUSHBACK_2BIG);
+
+ zzMarkedPos -= number;
+ }
+
+
+ /**
+ * Resumes scanning until the next regular expression is matched,
+ * the end of input is encountered or an I/O-Error occurs.
+ *
+ * @return the next token
+ * @exception java.io.IOException if any I/O-Error occurs
+ */
+ public Yytoken yylex() throws java.io.IOException, ParseException {
+ int zzInput;
+ int zzAction;
+
+ // cached fields:
+ int zzCurrentPosL;
+ int zzMarkedPosL;
+ int zzEndReadL = zzEndRead;
+ char [] zzBufferL = zzBuffer;
+ char [] zzCMapL = ZZ_CMAP;
+
+ int [] zzTransL = ZZ_TRANS;
+ int [] zzRowMapL = ZZ_ROWMAP;
+ int [] zzAttrL = ZZ_ATTRIBUTE;
+
+ while (true) {
+ zzMarkedPosL = zzMarkedPos;
+
+ yychar+= zzMarkedPosL-zzStartRead;
+
+ zzAction = -1;
+
+ zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
+
+ zzState = ZZ_LEXSTATE[zzLexicalState];
+
+
+ zzForAction: {
+ while (true) {
+
+ if (zzCurrentPosL < zzEndReadL)
+ zzInput = zzBufferL[zzCurrentPosL++];
+ else if (zzAtEOF) {
+ zzInput = YYEOF;
+ break zzForAction;
+ }
+ else {
+ // store back cached positions
+ zzCurrentPos = zzCurrentPosL;
+ zzMarkedPos = zzMarkedPosL;
+ boolean eof = zzRefill();
+ // get translated positions and possibly new buffer
+ zzCurrentPosL = zzCurrentPos;
+ zzMarkedPosL = zzMarkedPos;
+ zzBufferL = zzBuffer;
+ zzEndReadL = zzEndRead;
+ if (eof) {
+ zzInput = YYEOF;
+ break zzForAction;
+ }
+ else {
+ zzInput = zzBufferL[zzCurrentPosL++];
+ }
+ }
+ int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
+ if (zzNext == -1) break zzForAction;
+ zzState = zzNext;
+
+ int zzAttributes = zzAttrL[zzState];
+ if ( (zzAttributes & 1) == 1 ) {
+ zzAction = zzState;
+ zzMarkedPosL = zzCurrentPosL;
+ if ( (zzAttributes & 8) == 8 ) break zzForAction;
+ }
+
+ }
+ }
+
+ // store back cached position
+ zzMarkedPos = zzMarkedPosL;
+
+ switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
+ case 11:
+ { sb.append(yytext());
+ }
+ case 25: break;
+ case 4:
+ { sb.delete(0, sb.length());yybegin(STRING_BEGIN);
+ }
+ case 26: break;
+ case 16:
+ { sb.append('\b');
+ }
+ case 27: break;
+ case 6:
+ { return new Yytoken(Yytoken.TYPE_RIGHT_BRACE,null);
+ }
+ case 28: break;
+ case 23:
+ { Boolean val=Boolean.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
+ }
+ case 29: break;
+ case 22:
+ { return new Yytoken(Yytoken.TYPE_VALUE, null);
+ }
+ case 30: break;
+ case 13:
+ { yybegin(YYINITIAL);return new Yytoken(Yytoken.TYPE_VALUE, sb.toString());
+ }
+ case 31: break;
+ case 12:
+ { sb.append('\\');
+ }
+ case 32: break;
+ case 21:
+ { Double val=Double.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
+ }
+ case 33: break;
+ case 1:
+ { throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_CHAR, new Character(yycharat(0)));
+ }
+ case 34: break;
+ case 8:
+ { return new Yytoken(Yytoken.TYPE_RIGHT_SQUARE,null);
+ }
+ case 35: break;
+ case 19:
+ { sb.append('\r');
+ }
+ case 36: break;
+ case 15:
+ { sb.append('/');
+ }
+ case 37: break;
+ case 10:
+ { return new Yytoken(Yytoken.TYPE_COLON,null);
+ }
+ case 38: break;
+ case 14:
+ { sb.append('"');
+ }
+ case 39: break;
+ case 5:
+ { return new Yytoken(Yytoken.TYPE_LEFT_BRACE,null);
+ }
+ case 40: break;
+ case 17:
+ { sb.append('\f');
+ }
+ case 41: break;
+ case 24:
+ { try{
+ int ch=Integer.parseInt(yytext().substring(2),16);
+ sb.append((char)ch);
+ }
+ catch(Exception e){
+ throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_EXCEPTION, e);
+ }
+ }
+ case 42: break;
+ case 20:
+ { sb.append('\t');
+ }
+ case 43: break;
+ case 7:
+ { return new Yytoken(Yytoken.TYPE_LEFT_SQUARE,null);
+ }
+ case 44: break;
+ case 2:
+ { Long val=Long.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
+ }
+ case 45: break;
+ case 18:
+ { sb.append('\n');
+ }
+ case 46: break;
+ case 9:
+ { return new Yytoken(Yytoken.TYPE_COMMA,null);
+ }
+ case 47: break;
+ case 3:
+ {
+ }
+ case 48: break;
+ default:
+ if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
+ zzAtEOF = true;
+ return null;
+ }
+ else {
+ zzScanError(ZZ_NO_MATCH);
+ }
+ }
+ }
+ }
+
+
+}
diff --git a/src/java/org/json/simple/parser/Yytoken.java b/src/java/org/json/simple/parser/Yytoken.java
new file mode 100644
index 0000000..ff14e27
--- /dev/null
+++ b/src/java/org/json/simple/parser/Yytoken.java
@@ -0,0 +1,58 @@
+/*
+ * $Id: Yytoken.java,v 1.1 2006/04/15 14:10:48 platform Exp $
+ * Created on 2006-4-15
+ */
+package org.json.simple.parser;
+
+/**
+ * @author FangYidong
+ */
+public class Yytoken {
+ public static final int TYPE_VALUE=0;//JSON primitive value: string,number,boolean,null
+ public static final int TYPE_LEFT_BRACE=1;
+ public static final int TYPE_RIGHT_BRACE=2;
+ public static final int TYPE_LEFT_SQUARE=3;
+ public static final int TYPE_RIGHT_SQUARE=4;
+ public static final int TYPE_COMMA=5;
+ public static final int TYPE_COLON=6;
+ public static final int TYPE_EOF=-1;//end of file
+
+ public int type=0;
+ public Object value=null;
+
+ public Yytoken(int type,Object value){
+ this.type=type;
+ this.value=value;
+ }
+
+ public String toString(){
+ StringBuffer sb = new StringBuffer();
+ switch(type){
+ case TYPE_VALUE:
+ sb.append("VALUE(").append(value).append(")");
+ break;
+ case TYPE_LEFT_BRACE:
+ sb.append("LEFT BRACE({)");
+ break;
+ case TYPE_RIGHT_BRACE:
+ sb.append("RIGHT BRACE(})");
+ break;
+ case TYPE_LEFT_SQUARE:
+ sb.append("LEFT SQUARE([)");
+ break;
+ case TYPE_RIGHT_SQUARE:
+ sb.append("RIGHT SQUARE(])");
+ break;
+ case TYPE_COMMA:
+ sb.append("COMMA(,)");
+ break;
+ case TYPE_COLON:
+ sb.append("COLON(:)");
+ break;
+ case TYPE_EOF:
+ sb.append("END OF FILE");
+ break;
+ }
+ return sb.toString();
+ }
+}
diff --git a/src/jsp/index.jsp b/src/jsp/index.jsp
index 2b05847..3370626 100644
--- a/src/jsp/index.jsp
+++ b/src/jsp/index.jsp
@@ -7,8 +7,8 @@
I2PControl
-| Torrents: | <%=I2PControlController.getTorrents().size()%>
- |
| Peers: | <%=I2PControlController.getTorrents().countPeers()%>
+ |
| Status: | <%=I2PControlController.getTestString()%>
+ |
| Status again: | <%=I2PControlController.getTestString()%>
|