Add m-esr52 at 52.6.0

13 files changed, 2392 insertions, 0 deletions

diff --git a/mobile/android/thirdparty/org/json/simple/ItemList.java b/mobile/android/thirdparty/org/json/simple/ItemList.java
new file mode 100644
index 000000000..07231e673
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/ItemList.java
@@ -0,0 +1,147 @@
+/*

+ * $Id: ItemList.java,v 1.1 2006/04/15 14:10:48 platform Exp $

+ * Created on 2006-3-24

+ */

+package org.json.simple;

+

+import java.util.ArrayList;

+import java.util.List;

+import java.util.StringTokenizer;

+

+/**

+ * |a:b:c| => |a|,|b|,|c|

+ * |:| => ||,||

+ * |a:| => |a|,||

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ */

+public class ItemList {

+	private String sp=",";

+	List items=new ArrayList();

+	

+	

+	public ItemList(){}

+	

+	

+	public ItemList(String s){

+		this.split(s,sp,items);

+	}

+	

+	public ItemList(String s,String sp){

+		this.sp=s;

+		this.split(s,sp,items);

+	}

+	

+	public ItemList(String s,String sp,boolean isMultiToken){

+		split(s,sp,items,isMultiToken);

+	}

+	

+	public List getItems(){

+		return this.items;

+	}

+	

+	public String[] getArray(){

+		return (String[])this.items.toArray();

+	}

+	

+	public void split(String s,String sp,List append,boolean isMultiToken){

+		if(s==null || sp==null)

+			return;

+		if(isMultiToken){

+			StringTokenizer tokens=new StringTokenizer(s,sp);

+			while(tokens.hasMoreTokens()){

+				append.add(tokens.nextToken().trim());

+			}

+		}

+		else{

+			this.split(s,sp,append);

+		}

+	}

+	

+	public void split(String s,String sp,List append){

+		if(s==null || sp==null)

+			return;

+		int pos=0;

+		int prevPos=0;

+		do{

+			prevPos=pos;

+			pos=s.indexOf(sp,pos);

+			if(pos==-1)

+				break;

+			append.add(s.substring(prevPos,pos).trim());

+			pos+=sp.length();

+		}while(pos!=-1);

+		append.add(s.substring(prevPos).trim());

+	}

+	

+	public void setSP(String sp){

+		this.sp=sp;

+	}

+	

+	public void add(int i,String item){

+		if(item==null)

+			return;

+		items.add(i,item.trim());

+	}

+

+	public void add(String item){

+		if(item==null)

+			return;

+		items.add(item.trim());

+	}

+	

+	public void addAll(ItemList list){

+		items.addAll(list.items);

+	}

+	

+	public void addAll(String s){

+		this.split(s,sp,items);

+	}

+	

+	public void addAll(String s,String sp){

+		this.split(s,sp,items);

+	}

+	

+	public void addAll(String s,String sp,boolean isMultiToken){

+		this.split(s,sp,items,isMultiToken);

+	}

+	

+	/**

+	 * @param i 0-based

+	 * @return

+	 */

+	public String get(int i){

+		return (String)items.get(i);

+	}

+	

+	public int size(){

+		return items.size();

+	}

+

+	public String toString(){

+		return toString(sp);

+	}

+	

+	public String toString(String sp){

+		StringBuffer sb=new StringBuffer();

+		

+		for(int i=0;i<items.size();i++){

+			if(i==0)

+				sb.append(items.get(i));

+			else{

+				sb.append(sp);

+				sb.append(items.get(i));

+			}

+		}

+		return sb.toString();

+

+	}

+	

+	public void clear(){

+		items.clear();

+	}

+	

+	public void reset(){

+		sp=",";

+		items.clear();

+	}

+}

diff --git a/mobile/android/thirdparty/org/json/simple/JSONArray.java b/mobile/android/thirdparty/org/json/simple/JSONArray.java
new file mode 100644
index 000000000..57167f482
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/JSONArray.java
@@ -0,0 +1,107 @@
+/*

+ * $Id: JSONArray.java,v 1.1 2006/04/15 14:10:48 platform Exp $

+ * Created on 2006-4-10

+ */

+package org.json.simple;

+

+import java.io.IOException;

+import java.io.Writer;

+import java.util.ArrayList;

+import java.util.Iterator;

+import java.util.List;

+

+

+/**

+ * A JSON array. JSONObject supports java.util.List interface.

+ * 

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ */

+public class JSONArray extends ArrayList implements List, JSONAware, JSONStreamAware {

+	private static final long serialVersionUID = 3957988303675231981L;

+

+    /**

+     * Encode a list into JSON text and write it to out. 

+     * If this list is also a JSONStreamAware or a JSONAware, JSONStreamAware and JSONAware specific behaviours will be ignored at this top level.

+     * 

+     * @see org.json.simple.JSONValue#writeJSONString(Object, Writer)

+     * 

+     * @param list

+     * @param out

+     */

+	public static void writeJSONString(List list, Writer out) throws IOException{

+		if(list == null){

+			out.write("null");

+			return;

+		}

+		

+		boolean first = true;

+		Iterator iter=list.iterator();

+		

+        out.write('[');

+		while(iter.hasNext()){

+            if(first)

+                first = false;

+            else

+                out.write(',');

+            

+			Object value=iter.next();

+			if(value == null){

+				out.write("null");

+				continue;

+			}

+			

+			JSONValue.writeJSONString(value, out);

+		}

+		out.write(']');

+	}

+	

+	public void writeJSONString(Writer out) throws IOException{

+		writeJSONString(this, out);

+	}

+	

+	/**

+	 * Convert a list to JSON text. The result is a JSON array. 

+	 * If this list is also a JSONAware, JSONAware specific behaviours will be omitted at this top level.

+	 * 

+	 * @see org.json.simple.JSONValue#toJSONString(Object)

+	 * 

+	 * @param list

+	 * @return JSON text, or "null" if list is null.

+	 */

+	public static String toJSONString(List list){

+		if(list == null)

+			return "null";

+		

+        boolean first = true;

+        StringBuffer sb = new StringBuffer();

+		Iterator iter=list.iterator();

+        

+        sb.append('[');

+		while(iter.hasNext()){

+            if(first)

+                first = false;

+            else

+                sb.append(',');

+            

+			Object value=iter.next();

+			if(value == null){

+				sb.append("null");

+				continue;

+			}

+			sb.append(JSONValue.toJSONString(value));

+		}

+        sb.append(']');

+		return sb.toString();

+	}

+

+	public String toJSONString(){

+		return toJSONString(this);

+	}

+	

+	public String toString() {

+		return toJSONString();

+	}

+

+	

+		

+}

diff --git a/mobile/android/thirdparty/org/json/simple/JSONAware.java b/mobile/android/thirdparty/org/json/simple/JSONAware.java
new file mode 100644
index 000000000..89f152510
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/JSONAware.java
@@ -0,0 +1,12 @@
+package org.json.simple;

+

+/**

+ * Beans that support customized output of JSON text shall implement this interface.  

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ */

+public interface JSONAware {

+	/**

+	 * @return JSON text

+	 */

+	String toJSONString();

+}

diff --git a/mobile/android/thirdparty/org/json/simple/JSONObject.java b/mobile/android/thirdparty/org/json/simple/JSONObject.java
new file mode 100644
index 000000000..d4401e114
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/JSONObject.java
@@ -0,0 +1,129 @@
+/*

+ * $Id: JSONObject.java,v 1.1 2006/04/15 14:10:48 platform Exp $

+ * Created on 2006-4-10

+ */

+package org.json.simple;

+

+import java.io.IOException;

+import java.io.Writer;

+import java.util.HashMap;

+import java.util.Iterator;

+import java.util.Map;

+

+/**

+ * A JSON object. Key value pairs are unordered. JSONObject supports java.util.Map interface.

+ * 

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ */

+public class JSONObject extends HashMap implements Map, JSONAware, JSONStreamAware{

+	private static final long serialVersionUID = -503443796854799292L;

+

+    /**

+     * Encode a map into JSON text and write it to out.

+     * If this map is also a JSONAware or JSONStreamAware, JSONAware or JSONStreamAware specific behaviours will be ignored at this top level.

+     * 

+     * @see org.json.simple.JSONValue#writeJSONString(Object, Writer)

+     * 

+     * @param map

+     * @param out

+     */

+	public static void writeJSONString(Map map, Writer out) throws IOException {

+		if(map == null){

+			out.write("null");

+			return;

+		}

+		

+		boolean first = true;

+		Iterator iter=map.entrySet().iterator();

+		

+        out.write('{');

+		while(iter.hasNext()){

+            if(first)

+                first = false;

+            else

+                out.write(',');

+			Map.Entry entry=(Map.Entry)iter.next();

+            out.write('\"');

+            out.write(escape(String.valueOf(entry.getKey())));

+            out.write('\"');

+            out.write(':');

+			JSONValue.writeJSONString(entry.getValue(), out);

+		}

+		out.write('}');

+	}

+

+	public void writeJSONString(Writer out) throws IOException{

+		writeJSONString(this, out);

+	}

+	

+	/**

+	 * Convert a map to JSON text. The result is a JSON object. 

+	 * If this map is also a JSONAware, JSONAware specific behaviours will be omitted at this top level.

+	 * 

+	 * @see org.json.simple.JSONValue#toJSONString(Object)

+	 * 

+	 * @param map

+	 * @return JSON text, or "null" if map is null.

+	 */

+	public static String toJSONString(Map map){

+		if(map == null)

+			return "null";

+		

+        StringBuffer sb = new StringBuffer();

+        boolean first = true;

+		Iterator iter=map.entrySet().iterator();

+		

+        sb.append('{');

+		while(iter.hasNext()){

+            if(first)

+                first = false;

+            else

+                sb.append(',');

+            

+			Map.Entry entry=(Map.Entry)iter.next();

+			toJSONString(String.valueOf(entry.getKey()),entry.getValue(), sb);

+		}

+        sb.append('}');

+		return sb.toString();

+	}

+	

+	public String toJSONString(){

+		return toJSONString(this);

+	}

+	

+	private static String toJSONString(String key,Object value, StringBuffer sb){

+		sb.append('\"');

+        if(key == null)

+            sb.append("null");

+        else

+            JSONValue.escape(key, sb);

+		sb.append('\"').append(':');

+		

+		sb.append(JSONValue.toJSONString(value));

+		

+		return sb.toString();

+	}

+	

+	public String toString(){

+		return toJSONString();

+	}

+

+	public static String toString(String key,Object value){

+        StringBuffer sb = new StringBuffer();

+		toJSONString(key, value, sb);

+        return sb.toString();

+	}

+	

+	/**

+	 * Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).

+	 * It's the same as JSONValue.escape() only for compatibility here.

+	 * 

+	 * @see org.json.simple.JSONValue#escape(String)

+	 * 

+	 * @param s

+	 * @return

+	 */

+	public static String escape(String s){

+		return JSONValue.escape(s);

+	}

+}

diff --git a/mobile/android/thirdparty/org/json/simple/JSONStreamAware.java b/mobile/android/thirdparty/org/json/simple/JSONStreamAware.java
new file mode 100644
index 000000000..c2287c459
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/JSONStreamAware.java
@@ -0,0 +1,15 @@
+package org.json.simple;

+

+import java.io.IOException;

+import java.io.Writer;

+

+/**

+ * Beans that support customized output of JSON text to a writer shall implement this interface.  

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ */

+public interface JSONStreamAware {

+	/**

+	 * write JSON string to out.

+	 */

+	void writeJSONString(Writer out) throws IOException;

+}

diff --git a/mobile/android/thirdparty/org/json/simple/JSONValue.java b/mobile/android/thirdparty/org/json/simple/JSONValue.java
new file mode 100644
index 000000000..aba3c40c2
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/JSONValue.java
@@ -0,0 +1,272 @@
+/*

+ * $Id: JSONValue.java,v 1.1 2006/04/15 14:37:04 platform Exp $

+ * Created on 2006-4-15

+ */

+package org.json.simple;

+

+import java.io.IOException;

+import java.io.Reader;

+import java.io.StringReader;

+import java.io.Writer;

+import java.util.List;

+import java.util.Map;

+

+import org.json.simple.parser.JSONParser;

+import org.json.simple.parser.ParseException;

+

+

+/**

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ */

+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.

+     * <p>

+     * 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.

+     * <p>

+     * 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.

+	 * <p>

+	 * If this object is a Map or a List, and it's also a JSONAware, JSONAware will be considered firstly.

+	 * <p>

+	 * 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<s.length();i++){

+			char ch=s.charAt(i);

+			switch(ch){

+			case '"':

+				sb.append("\\\"");

+				break;

+			case '\\':

+				sb.append("\\\\");

+				break;

+			case '\b':

+				sb.append("\\b");

+				break;

+			case '\f':

+				sb.append("\\f");

+				break;

+			case '\n':

+				sb.append("\\n");

+				break;

+			case '\r':

+				sb.append("\\r");

+				break;

+			case '\t':

+				sb.append("\\t");

+				break;

+			case '/':

+				sb.append("\\/");

+				break;

+			default:

+                //Reference: http://www.unicode.org/versions/Unicode5.1.0/

+				if((ch>='\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/mobile/android/thirdparty/org/json/simple/LICENSE.txt b/mobile/android/thirdparty/org/json/simple/LICENSE.txt
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/mobile/android/thirdparty/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/mobile/android/thirdparty/org/json/simple/parser/ContainerFactory.java b/mobile/android/thirdparty/org/json/simple/parser/ContainerFactory.java
new file mode 100644
index 000000000..366ac4dea
--- /dev/null
+++ b/mobile/android/thirdparty/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<fangyidong@yahoo.com.cn>

+ */

+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/mobile/android/thirdparty/org/json/simple/parser/ContentHandler.java b/mobile/android/thirdparty/org/json/simple/parser/ContentHandler.java
new file mode 100644
index 000000000..ae8d06557
--- /dev/null
+++ b/mobile/android/thirdparty/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<fangyidong@yahoo.com.cn>

+ */

+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/mobile/android/thirdparty/org/json/simple/parser/JSONParser.java b/mobile/android/thirdparty/org/json/simple/parser/JSONParser.java
new file mode 100644
index 000000000..9acaa377f
--- /dev/null
+++ b/mobile/android/thirdparty/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<fangyidong@yahoo.com.cn>

+ */

+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/mobile/android/thirdparty/org/json/simple/parser/ParseException.java b/mobile/android/thirdparty/org/json/simple/parser/ParseException.java
new file mode 100644
index 000000000..a5a5407f9
--- /dev/null
+++ b/mobile/android/thirdparty/org/json/simple/parser/ParseException.java
@@ -0,0 +1,96 @@
+package org.json.simple.parser;

+

+/**

+ * ParseException explains why and where the error occurs in source JSON text.

+ *

+ * @author FangYidong<fangyidong@yahoo.com.cn>

+ *

+ */

+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, Throwable throwable) {

+		this(-1, errorType, null, throwable);

+	}

+

+	public ParseException(int errorType, Object unexpectedObject) {

+		this(-1, errorType, unexpectedObject);

+	}

+

+	public ParseException(int position, int errorType, Object unexpectedObject) {

+    this(-1, errorType, unexpectedObject, null);

+	}

+

+	public ParseException(int position, int errorType, Object unexpectedObject, Throwable throwable) {

+	  super(throwable);

+	  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;

+	}

+

+	@Override

+  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/mobile/android/thirdparty/org/json/simple/parser/Yylex.java b/mobile/android/thirdparty/org/json/simple/parser/Yylex.java
new file mode 100644
index 000000000..42ce508eb
--- /dev/null
+++ b/mobile/android/thirdparty/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 <code>aState</code>

+   */

+  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      <code>false</code>, 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 

+   * <b>cannot</b> be reused (internal buffer is discarded and lost).

+   * Lexical state is set to <tt>ZZ_INITIAL</tt>.

+   *

+   * @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 <tt>pos</tt> 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/mobile/android/thirdparty/org/json/simple/parser/Yytoken.java b/mobile/android/thirdparty/org/json/simple/parser/Yytoken.java
new file mode 100644
index 000000000..ff14e27c1
--- /dev/null
+++ b/mobile/android/thirdparty/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<fangyidong@yahoo.com.cn>

+ */

+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();

+	}

+}