j2s.compiler.status=enable
+#a semicolon-separated list of package-level file paths to be excluded
+j2s.excluded.paths=test;testng;util
+
#a semicolon-separated list of package (foo.) or class (foo.bar) replacements to be made
j2s.class.replacements=org.apache.log4j.->jalview.javascript.log4j.
#output will be comma-separated: called method,caller class
#j2s.log.all.calls=true
-#a semicolon-separated list of package-level file paths to be excluded
-#j2s.excluded.paths=test;testng
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
+org.eclipse.jdt.core.compiler.release=disabled
org.eclipse.jdt.core.compiler.source=1.8
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
int yPos = Math.max(5, (screenSize.height - 650) / 2);
setBounds(xPos, yPos, 900, 650);
}
- /**
- * BH 2018
- *
- * @j2sNative
- */
- {
-
+
+ boolean doFullLoad = /** @j2sNative ! */true;
+
+ if (doFullLoad) {
+
jconsole = new Console(this, showjconsole);
// add essential build information
jconsole.setHeader("Jalview Version: "
});
- } // end BH 2018 ignore
+ }
this.setDropTarget(new java.awt.dnd.DropTarget(desktop, this));
* Javascript does not call componentResized on initial display,
* so do the update here
*/
- /** @j2sNative this.updateOverviewImage(); */
+ boolean doUpdate = /** @j2sNative true || */ false;
+ if (doUpdate)
+ updateOverviewImage();
}
/*
return answer.toString();
}
+//
// /**
// * Changes the locale of the messages.
// *
// /**
// * @j2sNative
// *
-// * Class.forName("java.util.ResourceBundle");
+// * Class.forName$("java.util.ResourceBundle");
// */
// {}
// return ResourceBundle.getBundle(resource);
* BH SwingJS no notify()
* @j2sNative
*
- * interpolator.run();
+ * interpolator.run$();
*
*/
{
--- /dev/null
+/*
+ * $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();
+ }
+}
--- /dev/null
+/*
+ * $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.StringWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+/**
+ * A JSON array. JSONObject supports java.util.List interface.
+ *
+ * @author FangYidong<fangyidong@yahoo.com.cn>
+ */
+public class JSONArray extends ArrayList implements JSONAware, JSONStreamAware {
+ private static final long serialVersionUID = 3957988303675231981L;
+
+ /**
+ * Constructs an empty JSONArray.
+ */
+ public JSONArray(){
+ super();
+ }
+
+ /**
+ * Constructs a JSONArray containing the elements of the specified
+ * collection, in the order they are returned by the collection's iterator.
+ *
+ * @param c the collection whose elements are to be placed into this JSONArray
+ */
+ public JSONArray(Collection c){
+ super(c);
+ }
+
+ /**
+ * 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 collection
+ * @param out
+ */
+ public static void writeJSONString(Collection collection, Writer out) throws IOException{
+ if(collection == null){
+ out.write("null");
+ return;
+ }
+
+ boolean first = true;
+ Iterator iter=collection.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 collection
+ * @return JSON text, or "null" if list is null.
+ */
+ public static String toJSONString(Collection collection){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(collection, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(byte[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(byte[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(short[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(short[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(int[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(int[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(long[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(long[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(float[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(float[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(double[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(double[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(boolean[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(boolean[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(char[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[\"");
+ out.write(String.valueOf(array[0]));
+
+ for(int i = 1; i < array.length; i++){
+ out.write("\",\"");
+ out.write(String.valueOf(array[i]));
+ }
+
+ out.write("\"]");
+ }
+ }
+
+ public static String toJSONString(char[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void writeJSONString(Object[] array, Writer out) throws IOException{
+ if(array == null){
+ out.write("null");
+ } else if(array.length == 0) {
+ out.write("[]");
+ } else {
+ out.write("[");
+ JSONValue.writeJSONString(array[0], out);
+
+ for(int i = 1; i < array.length; i++){
+ out.write(",");
+ JSONValue.writeJSONString(array[i], out);
+ }
+
+ out.write("]");
+ }
+ }
+
+ public static String toJSONString(Object[] array){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(array, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public String toJSONString(){
+ return toJSONString(this);
+ }
+
+ /**
+ * Returns a string representation of this array. This is equivalent to
+ * calling {@link JSONArray#toJSONString()}.
+ */
+ public String toString() {
+ return toJSONString();
+ }
+}
--- /dev/null
+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();
+}
--- /dev/null
+/*
+ * $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.StringWriter;
+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;
+
+
+ public JSONObject() {
+ super();
+ }
+
+ /**
+ * Allows creation of a JSONObject from a Map. After that, both the
+ * generated JSONObject and the Map can be modified independently.
+ *
+ * @param map
+ */
+ public JSONObject(Map map) {
+ super(map);
+ }
+
+
+ /**
+ * 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){
+ final StringWriter writer = new StringWriter();
+
+ try {
+ writeJSONString(map, writer);
+ return writer.toString();
+ } catch (IOException e) {
+ // This should never happen with a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ public String toJSONString(){
+ return toJSONString(this);
+ }
+
+ public String toString(){
+ return toJSONString();
+ }
+
+ public static String toString(String key,Object value){
+ StringBuffer sb = new StringBuffer();
+ sb.append('\"');
+ if(key == null)
+ sb.append("null");
+ else
+ JSONValue.escape(key, sb);
+ sb.append('\"').append(':');
+
+ sb.append(JSONValue.toJSONString(value));
+
+ 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);
+ }
+}
--- /dev/null
+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;
+}
--- /dev/null
+/*
+ * $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.StringWriter;
+import java.io.Writer;
+import java.util.Collection;
+// 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
+ *
+ * @deprecated this method may throw an {@code Error} instead of returning
+ * {@code null}; please use {@link JSONValue#parseWithException(Reader)}
+ * instead
+ */
+ public static Object parse(Reader in){
+ try{
+ JSONParser parser=new JSONParser();
+ return parser.parse(in);
+ }
+ catch(Exception e){
+ return null;
+ }
+ }
+
+ /**
+ * Parse JSON text into java object from the given string.
+ * Please use parseWithException() if you don't want to ignore the exception.
+ *
+ * @see org.json.simple.parser.JSONParser#parse(Reader)
+ * @see #parseWithException(Reader)
+ *
+ * @param s
+ * @return Instance of the following:
+ * org.json.simple.JSONObject,
+ * org.json.simple.JSONArray,
+ * java.lang.String,
+ * java.lang.Number,
+ * java.lang.Boolean,
+ * null
+ *
+ * @deprecated this method may throw an {@code Error} instead of returning
+ * {@code null}; please use {@link JSONValue#parseWithException(String)}
+ * instead
+ */
+ 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 Collection){
+ JSONArray.writeJSONString((Collection)value, out);
+ return;
+ }
+
+ if(value instanceof byte[]){
+ JSONArray.writeJSONString((byte[])value, out);
+ return;
+ }
+
+ if(value instanceof short[]){
+ JSONArray.writeJSONString((short[])value, out);
+ return;
+ }
+
+ if(value instanceof int[]){
+ JSONArray.writeJSONString((int[])value, out);
+ return;
+ }
+
+ if(value instanceof long[]){
+ JSONArray.writeJSONString((long[])value, out);
+ return;
+ }
+
+ if(value instanceof float[]){
+ JSONArray.writeJSONString((float[])value, out);
+ return;
+ }
+
+ if(value instanceof double[]){
+ JSONArray.writeJSONString((double[])value, out);
+ return;
+ }
+
+ if(value instanceof boolean[]){
+ JSONArray.writeJSONString((boolean[])value, out);
+ return;
+ }
+
+ if(value instanceof char[]){
+ JSONArray.writeJSONString((char[])value, out);
+ return;
+ }
+
+ if(value instanceof Object[]){
+ JSONArray.writeJSONString((Object[])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){
+ final StringWriter writer = new StringWriter();
+
+ try{
+ writeJSONString(value, writer);
+ return writer.toString();
+ } catch(IOException e){
+ // This should never happen for a StringWriter
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * 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) {
+ final int len = s.length();
+ for(int i=0;i<len;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
+ }
+
+}
--- /dev/null
+https://github.com/SwingJS/json-simple.git
+forked 6/23/2018 from https://github.com/fangyidong/json-simple/tree/master/src/main/java/org/json/simple
+Bob Hanson
+hansonr@stolaf.edu
\ No newline at end of file
--- /dev/null
+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();
+}
--- /dev/null
+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;
+
+}
--- /dev/null
+/*
+ * $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);
+ }
+}
--- /dev/null
+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 = -7880698968187728547L;
+
+ 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 getMessage() {
+ 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();
+ }
+}
--- /dev/null
+/* 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.codePointAt(i++) << 16;
+ result[j++] = high | packed.codePointAt(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 = null;
+ sb = new StringBuffer();
+ 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);
+ }
+ }
+ }
+ }
+
+
+}
--- /dev/null
+/*
+ * $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();
+ }
+}
-The srcjar2 directory just holds Java source for third-party dependency
+The srcjar_unused directory just holds Java source for third-party dependency
jar files used by the Java version of Jalview that are not used in JavaScript
or at least have not been used yet.
-20180724064133
+20180812000030
--- /dev/null
+20180812000030
git://source.jalview.org / jalview.git / commitdiff