Merge branch 'release/10.0' of ssh://cloud.finedevelop.com:7999/~zhouping/base-third into feature/10.0

# Conflicts:
#	build.third_step1-jdk11.gradle
#	build.third_step1.gradle

build.third_step1-jdk11.gradle

@@ -31,9 +31,10 @@ sourceSets{
 	main{
 		java{
 			srcDirs=[
-				"${srcDir}/fine-asm/src/main/java",
+				"${srcDir}/fine-deprecated-utils/src",
-				"${srcDir}/fine-antlr4/src/main/java",
+				"${srcDir}/fine-asm/src",
-				"${srcDir}/fine-aspectj/src/main/java",
+				"${srcDir}/fine-antlr4/src",
+				"${srcDir}/fine-aspectj/src",
 				"${srcDir}/fine-antlr-old/src/main/java",
 				"${srcDir}/fine-bouncycastle/src/main/java",
 				"${srcDir}/fine-classmate/src/main/java",

build.third_step1.gradle

@@ -32,9 +32,10 @@ sourceSets{
 	main{
 		java{
 			srcDirs=[
-				"${srcDir}/fine-asm/src/main/java",
+				"${srcDir}/fine-deprecated-utils/src",
-				"${srcDir}/fine-antlr4/src/main/java",
+				"${srcDir}/fine-asm/src",
-				"${srcDir}/fine-aspectj/src/main/java",
+				"${srcDir}/fine-antlr4/src",
+				"${srcDir}/fine-aspectj/src",
 				"${srcDir}/fine-antlr-old/src/main/java",
 				"${srcDir}/fine-bouncycastle/src/main/java",
 				"${srcDir}/fine-classmate/src/main/java",

fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java

@@ -0,0 +1,798 @@
+package edu.emory.mathcs.backport.java.util;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * 该类由前面版本third包反编译生成，用于兼容新引擎旧版本插件，7-8月份删除
+ */
+@Deprecated
+public class Arrays {
+    private Arrays() {
+    }
+
+    public static void sort(long[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(long[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(int[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(int[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(short[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(short[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(char[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(char[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(byte[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(byte[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(double[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(double[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(float[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(float[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(Object[] a) {
+        java.util.Arrays.sort(a);
+    }
+
+    public static void sort(Object[] a, int fromIndex, int toIndex) {
+        java.util.Arrays.sort(a, fromIndex, toIndex);
+    }
+
+    public static void sort(Object[] a, Comparator c) {
+        java.util.Arrays.sort(a, c);
+    }
+
+    public static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) {
+        java.util.Arrays.sort(a, fromIndex, toIndex, c);
+    }
+
+    public static int binarySearch(long[] a, long key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(int[] a, int key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(short[] a, short key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(char[] a, char key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(byte[] a, byte key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(double[] a, double key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(float[] a, float key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(Object[] a, Object key) {
+        return java.util.Arrays.binarySearch(a, key);
+    }
+
+    public static int binarySearch(Object[] a, Object key, Comparator c) {
+        return java.util.Arrays.binarySearch(a, key, c);
+    }
+
+    public static boolean equals(long[] a, long[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(int[] a, int[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(short[] a, short[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(char[] a, char[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(byte[] a, byte[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(boolean[] a, boolean[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(double[] a, double[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(float[] a, float[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(Object[] a, Object[] a2) {
+        return java.util.Arrays.equals(a, a2);
+    }
+
+    public static void fill(long[] a, long val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(long[] a, int fromIndex, int toIndex, long val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(int[] a, int val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(int[] a, int fromIndex, int toIndex, int val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(short[] a, short val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(short[] a, int fromIndex, int toIndex, short val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(char[] a, char val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(char[] a, int fromIndex, int toIndex, char val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(byte[] a, byte val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(boolean[] a, boolean val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(double[] a, double val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(double[] a, int fromIndex, int toIndex, double val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(float[] a, float val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(float[] a, int fromIndex, int toIndex, float val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static void fill(Object[] a, Object val) {
+        java.util.Arrays.fill(a, val);
+    }
+
+    public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
+        java.util.Arrays.fill(a, fromIndex, toIndex, val);
+    }
+
+    public static Object[] copyOf(Object[] original, int newLength) {
+        return copyOf(original, newLength, original.getClass());
+    }
+
+    public static Object[] copyOf(Object[] original, int newLength, Class newType) {
+        Object[] arr = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength);
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static byte[] copyOf(byte[] original, int newLength) {
+        byte[] arr = new byte[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static short[] copyOf(short[] original, int newLength) {
+        short[] arr = new short[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static int[] copyOf(int[] original, int newLength) {
+        int[] arr = new int[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static long[] copyOf(long[] original, int newLength) {
+        long[] arr = new long[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static char[] copyOf(char[] original, int newLength) {
+        char[] arr = new char[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static float[] copyOf(float[] original, int newLength) {
+        float[] arr = new float[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static double[] copyOf(double[] original, int newLength) {
+        double[] arr = new double[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static boolean[] copyOf(boolean[] original, int newLength) {
+        boolean[] arr = new boolean[newLength];
+        int len = original.length < newLength ? original.length : newLength;
+        System.arraycopy(original, 0, arr, 0, len);
+        return arr;
+    }
+
+    public static Object[] copyOfRange(Object[] original, int from, int to) {
+        return copyOfRange(original, from, to, original.getClass());
+    }
+
+    public static Object[] copyOfRange(Object[] original, int from, int to, Class newType) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            Object[] arr = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength);
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static byte[] copyOfRange(byte[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            byte[] arr = new byte[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static short[] copyOfRange(short[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            short[] arr = new short[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static int[] copyOfRange(int[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            int[] arr = new int[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static long[] copyOfRange(long[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            long[] arr = new long[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static char[] copyOfRange(char[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            char[] arr = new char[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static float[] copyOfRange(float[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            float[] arr = new float[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static double[] copyOfRange(double[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            double[] arr = new double[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static boolean[] copyOfRange(boolean[] original, int from, int to) {
+        int newLength = to - from;
+        if (newLength < 0) {
+            throw new IllegalArgumentException(from + " > " + to);
+        } else {
+            boolean[] arr = new boolean[newLength];
+            int ceil = original.length - from;
+            int len = ceil < newLength ? ceil : newLength;
+            System.arraycopy(original, from, arr, 0, len);
+            return arr;
+        }
+    }
+
+    public static List asList(Object[] a) {
+        return java.util.Arrays.asList(a);
+    }
+
+    public static int hashCode(long[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                long e = a[i];
+                hash = 31 * hash + (int)(e ^ e >>> 32);
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(int[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                hash = 31 * hash + a[i];
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(short[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                hash = 31 * hash + a[i];
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(char[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                hash = 31 * hash + a[i];
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(byte[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                hash = 31 * hash + a[i];
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(boolean[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                hash = 31 * hash + (a[i] ? 1231 : 1237);
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(float[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                hash = 31 * hash + Float.floatToIntBits(a[i]);
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(double[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                long e = Double.doubleToLongBits(a[i]);
+                hash = 31 * hash + (int)(e ^ e >>> 32);
+            }
+
+            return hash;
+        }
+    }
+
+    public static int hashCode(Object[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                Object e = a[i];
+                hash = 31 * hash + (e == null ? 0 : e.hashCode());
+            }
+
+            return hash;
+        }
+    }
+
+    public static int deepHashCode(Object[] a) {
+        if (a == null) {
+            return 0;
+        } else {
+            int hash = 1;
+
+            for(int i = 0; i < a.length; ++i) {
+                Object e = a[i];
+                hash = 31 * hash + (e instanceof Object[] ? deepHashCode((Object[])e) : (e instanceof byte[] ? hashCode((byte[])e) : (e instanceof short[] ? hashCode((short[])e) : (e instanceof int[] ? hashCode((int[])e) : (e instanceof long[] ? hashCode((long[])e) : (e instanceof char[] ? hashCode((char[])e) : (e instanceof boolean[] ? hashCode((boolean[])e) : (e instanceof float[] ? hashCode((float[])e) : (e instanceof double[] ? hashCode((double[])e) : (e != null ? e.hashCode() : 0))))))))));
+            }
+
+            return hash;
+        }
+    }
+
+    public static boolean deepEquals(Object[] a1, Object[] a2) {
+        if (a1 == a2) {
+            return true;
+        } else if (a1 != null && a2 != null) {
+            int len = a1.length;
+            if (len != a2.length) {
+                return false;
+            } else {
+                for(int i = 0; i < len; ++i) {
+                    Object e1 = a1[i];
+                    Object e2 = a2[i];
+                    if (e1 != e2) {
+                        if (e1 == null) {
+                            return false;
+                        }
+
+                        boolean eq = e1.getClass() == e2.getClass() && !e1.getClass().isArray() ? (e1 instanceof Object[] && e2 instanceof Object[] ? deepEquals((Object[])e1, (Object[])e2) : (e1 instanceof byte[] && e2 instanceof byte[] ? equals((byte[])e1, (byte[])e2) : (e1 instanceof short[] && e2 instanceof short[] ? equals((short[])e1, (short[])e2) : (e1 instanceof int[] && e2 instanceof int[] ? equals((int[])e1, (int[])e2) : (e1 instanceof long[] && e2 instanceof long[] ? equals((long[])e1, (long[])e2) : (e1 instanceof char[] && e2 instanceof char[] ? equals((char[])e1, (char[])e2) : (e1 instanceof boolean[] && e2 instanceof boolean[] ? equals((boolean[])e1, (boolean[])e2) : (e1 instanceof float[] && e2 instanceof float[] ? equals((float[])e1, (float[])e2) : (e1 instanceof double[] && e2 instanceof double[] ? equals((double[])e1, (double[])e2) : e1.equals(e2)))))))))) : e1.equals(e2);
+                        if (!eq) {
+                            return false;
+                        }
+                    }
+                }
+
+                return true;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    public static String toString(long[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(int[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(short[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(char[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(byte[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(boolean[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(float[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(double[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String toString(Object[] a) {
+        if (a == null) {
+            return "null";
+        } else if (a.length == 0) {
+            return "[]";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            buf.append('[').append(a[0]);
+
+            for(int i = 1; i < a.length; ++i) {
+                buf.append(", ").append(a[i]);
+            }
+
+            buf.append(']');
+            return buf.toString();
+        }
+    }
+
+    public static String deepToString(Object[] a) {
+        if (a == null) {
+            return "null";
+        } else {
+            StringBuffer buf = new StringBuffer();
+            deepToString(a, buf, new ArrayList());
+            return buf.toString();
+        }
+    }
+
+    private static void deepToString(Object[] a, StringBuffer buf, List seen) {
+        seen.add(a);
+        buf.append('[');
+
+        for(int i = 0; i < a.length; ++i) {
+            if (i > 0) {
+                buf.append(", ");
+            }
+
+            Object e = a[i];
+            if (e == null) {
+                buf.append("null");
+            } else if (!e.getClass().isArray()) {
+                buf.append(e.toString());
+            } else if (e instanceof Object[]) {
+                if (seen.contains(e)) {
+                    buf.append("[...]");
+                } else {
+                    deepToString((Object[])e, buf, seen);
+                }
+            } else {
+                buf.append(e instanceof byte[] ? toString((byte[])e) : (e instanceof short[] ? toString((short[])e) : (e instanceof int[] ? toString((int[])e) : (e instanceof long[] ? toString((long[])e) : (e instanceof char[] ? toString((char[])e) : (e instanceof boolean[] ? toString((boolean[])e) : (e instanceof float[] ? toString((float[])e) : (e instanceof double[] ? toString((double[])e) : ""))))))));
+            }
+        }
+
+        buf.append(']');
+        seen.remove(seen.size() - 1);
+    }
+}