(4.2, only for legay Jmol) adding more efficient @j2sOverride and

BobHanson · BobHanson · commit 8d78ad03ad30 · 2024-02-25T10:35:22.000-06:00
@j2sIgnore and @j2sIgnoreSuper

avoids SearchAndExecuteMethod better
diff --git a/sources/net.sf.j2s.java.core/dist_to_jsmol/Jmol-j2s-site.zip b/sources/net.sf.j2s.java.core/dist_to_jsmol/Jmol-j2s-site.zip
diff --git a/sources/net.sf.j2s.java.core/site-resources_4.2/jsmol/js/j2sjmol.js b/sources/net.sf.j2s.java.core/site-resources_4.2/jsmol/js/j2sjmol.js
@@ -894,7 +894,7 @@ Clazz.defineMethod = function (clazzThis, funName, funBody, funParams) {
 	if (!f$.stacks || f$.claxxReference !== clazzThis) {
 		//Generate a new delegating method for the class                
     var id = ++SAEMid;
-    console.log("SAEM " + clazzThis.__CLASS_NAME__ + "." + funName);
+    //console.log("SAEM " + clazzThis.__CLASS_NAME__ + "." + funName);
   	var delegate = function () {
   		return searchAndExecuteMethod(id, this, arguments.callee.claxxReference, arguments.callee.methodName, arguments);
   	};
diff --git a/sources/net.sf.j2s.java.core/src_4.2/com/jcraft/jzlib/InflaterInputStream.java b/sources/net.sf.j2s.java.core/src_4.2/com/jcraft/jzlib/InflaterInputStream.java
@@ -84,6 +84,9 @@ public int readByteAsInt() throws IOException {
     return read(byte1, 0, 1) == -1 ? -1 : byte1[0] & 0xff;
   }
 
+  /**
+   * @j2sOverride
+   */
   @Override
   public int read(byte[] b, int off, int len) throws IOException {
     return readInf(b, off, len);
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/io/BufferedInputStream.java b/sources/net.sf.j2s.java.core/src_4.2/java/io/BufferedInputStream.java
@@ -304,6 +304,9 @@ private int isRead(byte[] b, int off, int len) throws IOException {
 	}
 
 	/**
+	 * 
+	 * @j2sOverride
+	 * 
      * Reads bytes from this byte-input stream into the specified byte array,
      * starting at the given offset.
      *
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/io/ByteArrayInputStream.java b/sources/net.sf.j2s.java.core/src_4.2/java/io/ByteArrayInputStream.java
@@ -148,6 +148,8 @@ public synchronized int readByteAsInt() {
     }
 
     /**
+     * @j2sOverride
+
      * Reads up to <code>len</code> bytes of data into an array of bytes
      * from this input stream.
      * If <code>pos</code> equals <code>count</code>,
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/io/DataInputStream.java b/sources/net.sf.j2s.java.core/src_4.2/java/io/DataInputStream.java
@@ -104,6 +104,8 @@ public DataInputStream(InputStream in) {
   //    }
 
   /**
+   * @j2sOverride
+   * 
    * Reads up to <code>len</code> bytes of data from the contained input stream
    * into an array of bytes. An attempt is made to read as many as
    * <code>len</code> bytes, but a smaller number may be read, possibly zero.
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/io/FilterInputStream.java b/sources/net.sf.j2s.java.core/src_4.2/java/io/FilterInputStream.java
@@ -111,6 +111,8 @@ public int readByteAsInt() throws IOException {
 //    }
 
     /**
+     * @j2sOverride
+     *  
      * Reads up to <code>len</code> bytes of data from this input stream
      * into an array of bytes. If <code>len</code> is not zero, the method
      * blocks until some input is available; otherwise, no
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/util/ArrayList.java b/sources/net.sf.j2s.java.core/src_4.2/java/util/ArrayList.java
@@ -45,28 +45,36 @@ public class ArrayList<E> extends AbstractList<E> implements List<E>, Cloneable,
 	private transient E[] array;
 
 	/**
+	 * @j2sIgnore
+	 * 
 	 * Constructs a new instance of ArrayList with zero capacity.
 	 */
 	public ArrayList() {
 		this(0);
 	}
 
 	/**
+	 * @j2sIgnore
 	 * Constructs a new instance of ArrayList with the specified capacity.
 	 * 
 	 * @param capacity
 	 *            the initial capacity of this ArrayList
 	 */
 	public ArrayList(int capacity) {
-		firstIndex = lastIndex = 0;
+		setCapacity(capacity);
+	}
+
+	private void setCapacity(int capacity) {
 		try {
 			array = newElementArray(capacity);
 		} catch (NegativeArraySizeException e) {
 			throw new IllegalArgumentException();
 		}
-	}
 
+	}
 	/**
+	 * @j2sIgnoreSuperConstructor
+	 * 
 	 * Constructs a new instance of ArrayList containing the elements in the
 	 * specified collection. The ArrayList will have an initial capacity which
 	 * is 110% of the size of the collection. The order of the elements in this
@@ -76,8 +84,25 @@ public ArrayList(int capacity) {
 	 *            the collection of elements to add
 	 */
 	public ArrayList(Collection<? extends E> collection) {
-		int size = collection.size();
 		firstIndex = lastIndex = 0;
+		int n = -1;
+		/**
+		 * @j2sNative
+		 *  if (!collection) {
+		 *    n = 0;
+		 *  } else if (typeof collection == "number") {
+		 *     n = collection;
+		 *  }
+		 *  
+		 *  
+		 *  
+		 */
+		{}
+		if (n >= 0) {
+			setCapacity(n);
+			return;
+		}
+		int size = collection.size();
 		array = newElementArray(size + (size / 10));
 		addAll(collection);
 	}
@@ -103,6 +128,10 @@ private E[] newElementArray(int size) {
 	 */
 	@Override
     public void add(int location, E object) {
+		add2(location, object);
+	}
+
+	public void add2(int location, E object) {
 		int size = size();
 		if (0 < location && location < size) {
 			if (firstIndex == 0 && lastIndex == array.length) {
@@ -131,7 +160,6 @@ public void add(int location, E object) {
 		} else {
             throw new IndexOutOfBoundsException();
         }
-
 		modCount++;
 	}
 
@@ -639,6 +667,8 @@ public Object[] toArray() {
 	}
 
 	/**
+	 * @j2sOverride
+	 * 
 	 * Answers an array containing all elements contained in this ArrayList. If
 	 * the specified array is large enough to hold the elements, the specified
 	 * array is used, otherwise an array of the same type is created. If the
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/util/Arrays.java b/sources/net.sf.j2s.java.core/src_4.2/java/util/Arrays.java
@@ -43,6 +43,8 @@ private Arrays() {
     
 
     /**
+     * @j2sIgnore
+     * 
      * Assigns the specified Object reference to each element of the specified
      * array of Objects.
      *
@@ -71,6 +73,15 @@ public static void fill(Object[] a, Object val) {
      *	       <tt>toIndex &gt; a.length</tt>
      */
     public static void fill(Object[] a, int fromIndex, int toIndex,Object val){
+    	/**
+    	 * @j2sNative
+    	 *  if (arguments.length == 2) {
+    	 *     val = arguments[1];
+    	 *     fromIndex = 0;
+    	 *     toIndex = a.length;
+    	 *  }
+    	 */
+    	{}
         rangeCheck(a.length, fromIndex, toIndex);
         for (int i=fromIndex; i<toIndex; i++)
             a[i] = val;
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/util/Hashtable.java b/sources/net.sf.j2s.java.core/src_4.2/java/util/Hashtable.java
@@ -161,6 +161,8 @@ public class Hashtable<K,V>
     private transient int modCount;
 
 	/**
+     *  @j2sIgnore
+     *  
 	 * SwingJS note: This constructor DOES NOT allow JavaScript Map object for
 	 * Hashtable<String,?>.
 	 * 
@@ -173,7 +175,6 @@ public class Hashtable<K,V>
 	 *                                     zero, or if the load factor is
 	 *                                     nonpositive.
 	 * 
-     *              @j2sIgnore
 	 */
 	public Hashtable(int capacity, float loadFactor) {
 		super();
@@ -212,9 +213,12 @@ public Hashtable(int initialCapacity) {
      * 
 	 * @j2sIgnoreSuperConstructor
      */
-    @SuppressWarnings("unused")
 	public Hashtable() {
-		super();
+    	initHT();
+    }
+
+    @SuppressWarnings("unused")
+    protected void initHT() {
 		Hashtable map = null;
 		int capacity = 11;
 		float loadFactor = 0.75f;
@@ -248,9 +252,9 @@ public Hashtable() {
 		__setJS();
 		if (map != null)
 			putAll(map);
-    }
+	}
 
-    /**
+	/**
      * Constructs a new hashtable with the same mappings as the given
      * Map.  The hashtable is created with an initial capacity sufficient to
      * hold the mappings in the given Map and a default load factor (0.75).
@@ -762,6 +766,8 @@ public synchronized Object clone() {
 	}
 
     /**
+     * @j2sOverride
+     * 
      * Returns a string representation of this <tt>Hashtable</tt> object
      * in the form of a set of entries, enclosed in braces and separated
      * by the ASCII characters "<tt>,&nbsp;</tt>" (comma and space). Each
@@ -777,21 +783,20 @@ public synchronized String toString() {
         if (max == -1)
             return "{}";
 
-        StringBuilder sb = new StringBuilder();
         Iterator<Map.Entry<K,V>> it = entrySet().iterator();
 
-        sb.append('{');
+        String sb = "{";
         for (int i = 0; ; i++) {
             Map.Entry<K,V> e = it.next();
             K key = e.getKey();
             V value = e.getValue();
-            sb.append(key   == this ? "(this Map)" : key.toString());
-            sb.append('=');
-            sb.append(value == this ? "(this Map)" : value.toString());
+            sb += (key == this ? "(this Map)" : key.toString());
+            sb += "=";
+            sb += (value == this ? "(this Map)" : value.toString());
 
             if (i == max)
-                return sb.append('}').toString();
-            sb.append(", ");
+                return sb + '}';
+            sb += ", ";
         }
     }
 
@@ -1432,6 +1437,7 @@ static void __set(Map map, Object key, Object value) {
 		 * 
 		 * map.__m.set(key == null ? null : key + "", value)
 		 */
+		{}
 	}
 
 	/**
@@ -1491,6 +1497,7 @@ static void __ensureJavaMap(Map map) {
 			 *          m.clear();
 			 * 		}
 			 */
+		{}
 	}
 	
 	/**
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/util/Properties.java b/sources/net.sf.j2s.java.core/src_4.2/java/util/Properties.java
@@ -78,21 +78,25 @@ public class Properties extends Hashtable<Object,Object> {
 			KEY_DONE = 4, IGNORE = 5;
 
 	/**
+	 * @j2sIgnore;
 	 * Constructs a new Properties object.
 	 */
 	public Properties() {
-		super();
 	}
 
 	/**
+	 * @j2sIgnoreSuperConstructor
+	 * 
 	 * Constructs a new Properties object using the specified default
 	 * properties.
 	 * 
 	 * @param properties
 	 *            the default properties
 	 */
 	public Properties(Properties properties) {
-		defaults = properties;
+		initHT(); 
+		// check null just for JavaScript undefined
+		defaults = (properties == null ? null : properties);
 	}
 
 	private String dumpString(String buffer, String string, boolean key) {
diff --git a/sources/net.sf.j2s.java.core/src_4.2/java/util/StringTokenizer.java b/sources/net.sf.j2s.java.core/src_4.2/java/util/StringTokenizer.java
@@ -39,6 +39,8 @@ public class StringTokenizer implements Enumeration<Object> {
 	private int position;
 
 	/**
+	 * @j2sIgnore
+	 * 
 	 * Constructs a new StringTokenizer for string using whitespace as the
 	 * delimiter, returnDelimiters is false.
 	 * 
@@ -50,6 +52,8 @@ public StringTokenizer(String string) {
 	}
 
 	/**
+	 * @j2sIgnore
+	 * 
 	 * Constructs a new StringTokenizer for string using the specified
 	 * delimiters, returnDelimiters is false.
 	 * 
@@ -63,25 +67,29 @@ public StringTokenizer(String string, String delimiters) {
 	}
 
 	/**
-	 * Constructs a new StringTokenizer for string using the specified
-	 * delimiters and returning delimiters as tokens when specified.
+	 * Constructs a new StringTokenizer for string using the specified delimiters
+	 * and returning delimiters as tokens when specified.
 	 * 
-	 * @param string
-	 *            the string to be tokenized
-	 * @param delimiters
-	 *            the delimiters to use
-	 * @param returnDelimiters
-	 *            true to return each delimiter as a token
+	 * @param string           the string to be tokenized
+	 * @param delimiters       the delimiters to use
+	 * @param returnDelimiters true to return each delimiter as a token
 	 */
-	public StringTokenizer(String string, String delimiters,
-			boolean returnDelimiters) {
-		if (string != null) {
-			this.string = string;
-			this.delimiters = delimiters;
-			this.returnDelimiters = returnDelimiters;
-			this.position = 0;
-		} else
+	public StringTokenizer(String string, String delimiters, boolean returnDelimiters) {
+		/**
+		 * @j2sNative
+		 * 
+		 * switch (arguments.length) { 
+		 * case 1: delimiters = " \t\n\r\f"; 
+		 * case 2: returnDelimiters = false; 
+		 * }
+		 */
+		{}
+		if (string == null)
 			throw new NullPointerException();
+		this.string = string;
+		this.delimiters = delimiters;
+		this.returnDelimiters = returnDelimiters;
+		this.position = 0;
 	}
 
 	/**
@@ -160,6 +168,11 @@ public Object nextElement() {
 	 *                if no tokens remain
 	 */
 	public String nextToken() {
+		/**
+		 * @j2sNative
+		 * (arguments.length == 1) && (this.delimiters = arguments[0]);	
+		 */
+		{}
 		int i = position;
 		int length = string.length();
 
@@ -187,6 +200,7 @@ public String nextToken() {
 	}
 
 	/**
+	 * @j2sIgnore
 	 * Returns the next token in the string as a String. The delimiters used are
 	 * changed to the specified delimiters.
 	 * 

Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,9 @@ public int readByteAsInt() throws IOException {`
`84`	`84`	`return read(byte1, 0, 1) == -1 ? -1 : byte1[0] & 0xff;`
`85`	`85`	`}`
`86`	`86`
	`87`	`+ /**`
	`88`	`+ * @j2sOverride`
	`89`	`+ */`
`87`	`90`	`@Override`
`88`	`91`	`public int read(byte[] b, int off, int len) throws IOException {`
`89`	`92`	`return readInf(b, off, len);`
Original file line number	Diff line number	Diff line change
`@@ -304,6 +304,9 @@ private int isRead(byte[] b, int off, int len) throws IOException {`
`304`	`304`	`}`
`305`	`305`
`306`	`306`	`/**`
	`307`	`+ *`
	`308`	`+ * @j2sOverride`
	`309`	`+ *`
`307`	`310`	`* Reads bytes from this byte-input stream into the specified byte array,`
`308`	`311`	`* starting at the given offset.`
`309`	`312`	`*`
Original file line number	Diff line number	Diff line change
`@@ -148,6 +148,8 @@ public synchronized int readByteAsInt() {`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`/**`
	`151`	`+ * @j2sOverride`
	`152`	`+`
`151`	`153`	`* Reads up to <code>len</code> bytes of data into an array of bytes`
`152`	`154`	`* from this input stream.`
`153`	`155`	`* If <code>pos</code> equals <code>count</code>,`