[multiple changes]

1999-08-09  Anthony Green  <green@cygnus.com>

        * gij.cc: New file.

        * include/config.h.in: Rebuilt.
        * acconfig.h: Add INTERPRETER.

        * configure: Rebuilt.

        * Makefile.in: Rebuilt.
        * Makefile.am (libffi_files): Identify the libffi object files for
        inclusion in libgcj.
        (LIBFFIINCS): Define.

        * interpret.cc (gnu::gcj::runtime::MethodInvocation::continue1):
        Dummy definition for configurations without an interpreter.

        * java/net/natPlainSocketImpl.cc (getOption): Disamiguate call to
        java::lang::Boolean constructor.

        * include/java-interp.h: Always include java-cpool.h.

        * java/lang/natClassLoader.cc (getVMClassLoader0): Always return 0
        when INTERPRETER not defined.

        * java/lang/Class.h (finalize): Define.

        * gnu/gcj/util/path/DirectoryPathEntry.java (getURL): Catch
        IOException from File.getCanonicalPath.
        (getStream): Likewise.

        * NEWS: More news.
        * THANKS: More thanks.

1999-08-09  Kresten Krab Thorup  <krab@gnu.org>

        * resolve.cc (get_ffi_type_from_signature): Generate uint16 for
        jchar type.
        (_Jv_PrepareClass): Allow non-abstract classes to
        have abstract subclasses.
        (_Jv_ResolvePoolEntry): Revert subclass check for protected
        fields and methods.
        * interpret.cc (continue1/perform_invoke): Don't sign extend
        uint16 return val.
        (continue1/lshl,lshr): Push long, not int.
        (continue1/ulshr): Use UINT64, not long long.
        * defineclass.cc (handleFieldsEnd): Handle case when all fields
        are static.
        * java/lang/natClass.cc (forName): Add call to _Jv_InitClass.
        * java/lang/FirstThread.java (run): Add top-level exception
        handler.
        (run0): Renamed from run.

1999-08-08  Kresten Krab Thorup  <krab@gnu.org>

        * configure.in (--with-interpreter): Added.
        * include/config.h.in (INTERPRETER): Added.

        * java/lang/ClassLoader.java: File replaced.
        * java/lang/VMClassLoader.java: New file.
        * java/lang/natClassLoader.cc: New file.
        * gnu/gcj/runtime/MethodInvocation.java: New file.
        * gnu/gcj/util/path/SearchPath.java: New file.
        * gnu/gcj/util/path/PathEntry.java: New file.
        * gnu/gcj/util/path/DirectoryPathEntry.java: New file.
        * gnu/gcj/util/path/ZipPathEntry.java: New file.
        * gnu/gcj/util/path/URLPathEntry.java: New file.
        * gnu/gcj/util/path/CacheEntry.java: New file.
        * include/java-interp.h: New file.
        * include/java-cpool.h: New file.
        * include/java-insns.h: New file.
        * defineclass.cc: New file.
        * interpret.cc: New file.
        * resolve.cc: New file.

        * java/lang/natClass.cc (loaded_classes, _Jv_RegisterClass,
        _Jv_RegisterClasses, _Jv_FindClassInCache, _Jv_FindClass,
        _Jv_NewClass, _Jv_FindArrayClass): Moved to natClassLoader.cc.
        (finalize): New.
        (STATE_NOTHING, STATE_RESOLVED, STATE_IN_PROGRESS, STATE_DONE,
        STATE_ERROR): Moved to java/lang/Class.h and renamed with JV_
        prefix.
        (initializeClass): Use new JV_ prefixed names.  Also, call
        ClassLoader::resolveClass instead of _Jv_ResolveClass.

        * java/lang/Class.h (JV_STATE_PRELOADING, JV_STATE_LOADING,
        JV_STATE_LOADED, JV_STATE_COMPILED, JV_STATE_PREPARED,
        JV_STATE_LINKED): New.
        (_Jv_WaitForState, _Jv_RegisterInitiatingLoader,
        _Jv_UnregisterClass, _Jv_InternClassStrings): New friends.
        (_Jv_IsInterpretedClass, _Jv_InitField, _Jv_LookupDeclaredMethod,
        _Jv_DetermineVTableIndex, _Jv_ResolvePoolEntry, _Jv_PrepareClass,
        _Jv_ClassReader, _Jv_InterpClass, _Jv_InterpMethod,
        _Jv_InterpMethodInvocation): New friends for interpreter.
        (finalize): New.
        (CONSTANT_Class, CONSTANT_String, etc.): Moved to
        include/java-cpool.h and renamed with JV_ prefix.

        * include/jvm.h (_Jv_makeUtf8Const, _Jv_makeUtf8TypeConst): New
        decls.
        (_Jv_UnregisterClass): New decl.

        * java/lang/natClassLoader.cc (_Jv_FindArrayClass): Added
        class loader argument.
        (_Jv_FindClass): Use class loader.

        * prims.cc (_Jv_makeUtf8Const): New function.
        (_Jv_NewObjectArray): Change use of _Jv_FindArrayClass.
        (_Jv_NewPrimArray): Ditto.
        (_Jv_FindClassFromSignature): Ditto.
        * java/lang/reflect/natArray.cc (newInstance): Ditto.
        * java/lang/reflect/natMethod.cc (getType): Ditto.

        * include/java-field.h (_Jv_Field::isRef): Make robust for
        non-resolved contexts.

        * boehm.cc (_Jv_MarkObj): Mark interpreter-related fields.
        Also, don't mark class->next field.

        * java/lang/VirtualMachineError.java: Added FIXME note.

        * configure.in (INTERPSPEC): New spec.
        * libgcj.spec.in: Added INTERPSPEC.
        * Makefile.am: Added gcjh friends for java/lang/VMClassLoader and
        gnu/gcj/runtime/MethodInvocation.
        (libgcj_la_SOURCES): Added resolve.cc defineclass.cc interpret.cc.
        (ordinary_java_source_files): Added above mentioned java classes.

        * configure: Rebuilt.
        * Makefile.in: Rebuilt.

From-SVN: r28597

7 files changed, 646 insertions, 0 deletions

diff --git a/libjava/gnu/gcj/runtime/MethodInvocation.java b/libjava/gnu/gcj/runtime/MethodInvocation.java
new file mode 100644
index 0000000..d1664ba
--- /dev/null
+++ b/libjava/gnu/gcj/runtime/MethodInvocation.java
@@ -0,0 +1,32 @@
+// MethodInvocation.java - wrapper used by the interpreter.
+// (the native method is implemented in interpret.cc)
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author:  Kresten Krab Thorup <krab@gnu.org>  */
+
+package gnu.gcj.runtime;
+
+import gnu.gcj.RawData;
+
+final class MethodInvocation {
+
+  private static Throwable continue0 (RawData meth, RawData inv)
+  {
+    try {
+      continue1 (meth, inv);
+    } catch (Throwable ex) {
+      return ex;
+    }
+    return null;
+  }
+
+  private static native void continue1 (RawData meth, RawData inv);
+
+}
diff --git a/libjava/gnu/gcj/util/path/CacheEntry.java b/libjava/gnu/gcj/util/path/CacheEntry.java
new file mode 100644
index 0000000..949200b
--- /dev/null
+++ b/libjava/gnu/gcj/util/path/CacheEntry.java
@@ -0,0 +1,65 @@
+// CacheEntry.java -- directory cache
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author: Kresten Krab Thorup <krab@gnu.org>  */
+
+package gnu.gcj.util.path;
+
+import java.util.*;
+import java.util.zip.*;
+import java.io.*;
+import java.net.*;
+
+
+final class CacheEntry {
+    String   dir;
+    String[] files;
+    long     time;
+    
+    CacheEntry (String d)
+    {
+	dir = d;
+	files = new File(dir).list();
+	time = System.currentTimeMillis ();
+    }
+    
+    void touch ()
+    {
+	time = System.currentTimeMillis ();
+    }
+    
+    final long EXPIRATION_TIME_MS = 1000;
+    
+    boolean is_old () {
+	return (System.currentTimeMillis () - time) > EXPIRATION_TIME_MS;
+    }
+    
+    public int hashCode () { return dir.hashCode(); }
+    boolean contains (String file) { 
+	if (files == null)
+	    return false;
+	
+	int index = file.lastIndexOf(SearchPath.file_seperator_char);
+	String f;
+	
+	if (index == -1)
+	    f = file;
+	else
+	    f = file.substring (index+1);
+	
+	for (int i = 0; i < files.length; i++)
+	    {
+		if (f.equals (files[i])) return true;
+	    }
+	
+	return false;
+    }
+}
+
diff --git a/libjava/gnu/gcj/util/path/DirectoryPathEntry.java b/libjava/gnu/gcj/util/path/DirectoryPathEntry.java
new file mode 100644
index 0000000..a9ca602
--- /dev/null
+++ b/libjava/gnu/gcj/util/path/DirectoryPathEntry.java
@@ -0,0 +1,136 @@
+// DirectoryPathEntry.java -- search path element for directories
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author: Kresten Krab Thorup <krab@gnu.org>  */
+
+package gnu.gcj.util.path;
+
+import java.util.*;
+import java.util.zip.*;
+import java.io.*;
+import java.net.*;
+
+final class DirectoryPathEntry extends PathEntry
+{
+  final File dir;
+  final String base_canon;
+
+  public String toString () { return base_canon; }
+
+  DirectoryPathEntry (File f)
+    throws java.io.IOException
+  {
+    if (!f.isAbsolute ())
+      throw new IllegalArgumentException ();
+
+    dir = f; 
+    base_canon = dir.getCanonicalPath ();
+  }
+
+  /*
+   *  We maintain a cache of files, so that we 
+   *  can avoid many calls to stat(), which are
+   *  very expensive.
+   *
+   *  seen_cache contains (as keys) the directories 
+   *  which we have visited so far.  The values are 
+   *  instances of CacheEntry, containing a time stamp,
+   *  and a list of files in that directory.
+   *
+   */
+
+  private Hashtable seen_cache = new Hashtable ();
+
+  private boolean in_cache (File f)
+  {
+    String rel_dir = f.getParent ();
+    CacheEntry ent;
+
+    if (rel_dir == null)
+      throw new IllegalArgumentException ();
+
+    ent = (CacheEntry) seen_cache.get (rel_dir);
+    if (ent == null)
+      {
+	ent = new CacheEntry (rel_dir);
+	seen_cache.put (rel_dir, ent);
+      }
+
+    if (ent.contains (f.getPath ()))
+      {
+	return true;
+      }
+
+    if ( ent.is_old () )
+      {
+	if (f.exists ())
+	  {
+	    seen_cache.remove (rel_dir);
+	    return true;
+	  }
+	else
+	  {
+	    ent.touch ();
+	  }
+      }
+
+    return false;
+  }
+
+  URL getURL (String file) {
+    try {
+      File f = new File((new File (dir, file).getCanonicalPath ()));
+	    
+      if (! f.getCanonicalPath ().startsWith (base_canon))
+	throw new IllegalArgumentException (file);
+
+		
+      if (in_cache (f))
+	return new URL ("file", "", f.getPath ());
+      else
+	return null;
+
+    } catch (IOException x) {
+      return null;
+    }
+  }
+
+  InputStream getStream (String file) {
+    try {			
+      File f = new File((new File (dir, file)).getCanonicalPath ());
+
+      if (! f.getCanonicalPath ().startsWith (base_canon))
+	throw new IllegalArgumentException (file);
+
+      if (in_cache (f))
+	return new FileInputStream (f);
+      else
+	return null;
+    } catch (IOException x) {
+      return null;
+    }
+  }
+
+  byte[] getBytes (String file) {
+    File f = new File (dir, file);
+
+    try {			
+      if (in_cache (f))
+	return readbytes (new FileInputStream (f),
+			  (int) f.length ());
+      else
+	return null;
+    } catch (IOException x) {
+      return null;
+    }
+  }
+
+}
+
diff --git a/libjava/gnu/gcj/util/path/PathEntry.java b/libjava/gnu/gcj/util/path/PathEntry.java
new file mode 100644
index 0000000..f83fc17
--- /dev/null
+++ b/libjava/gnu/gcj/util/path/PathEntry.java
@@ -0,0 +1,55 @@
+// PathEntry.java -- abstract element of search paths
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author: Kresten Krab Thorup <krab@gnu.org>  */
+
+package gnu.gcj.util.path;
+
+import java.util.*;
+import java.util.zip.*;
+import java.io.*;
+import java.net.*;
+
+abstract class PathEntry {
+  abstract URL getURL (String file);
+  abstract InputStream getStream (String file);
+  abstract byte[] getBytes (String file);
+
+  /**
+   *  Utility routine like InputStream.read(byte[], 0, len), but will
+   *  read fully, even if all the data is not available at once.  
+   */
+  protected static byte[] readbytes (InputStream is, int length)
+  {
+    try {
+
+      byte[] data = new byte[length];
+      int read; 
+      int off = 0;
+	    
+      while (off != length)
+	{
+	  read = is.read (data, off, (int) (length-off));
+
+	  if (read == -1) 
+	    return null;
+
+	  off += read;
+	}
+	    
+      return data;
+    } catch (IOException x) {
+      return null;
+    }
+  }
+
+}
+
+
diff --git a/libjava/gnu/gcj/util/path/SearchPath.java b/libjava/gnu/gcj/util/path/SearchPath.java
new file mode 100644
index 0000000..ffc2ca8
--- /dev/null
+++ b/libjava/gnu/gcj/util/path/SearchPath.java
@@ -0,0 +1,205 @@
+// SearchPath.java -- generic search path utility
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author: Kresten Krab Thorup <krab@gnu.org>  */
+
+
+package gnu.gcj.util.path;
+
+import java.util.*;
+import java.util.zip.*;
+import java.io.*;
+import java.net.*;
+
+final public class SearchPath {
+
+    final static String path_seperator
+      = System.getProperty ("path.separator");
+    final static char   path_seperator_char
+      = path_seperator.charAt (0);
+    final static String file_seperator
+      = System.getProperty ("file.separator");
+    final static char   file_seperator_char
+      = file_seperator.charAt (0);
+
+    private Vector path;
+
+    /**
+     *  Constructs a SearchPath object, given a system path.
+     *  The system path is expected to be seperated by the string 
+     *  defined by the <code>path.seperator</code> property.  
+     *  (<code>":"</code> on unix, <code>;</code> on Windows, etc.).
+     *  The path may contain names of directories, or names of
+     *  .zip or .jar files.  Elements that are neither of these
+     *  are ignored.
+     * @param sys_path the search path
+     */
+
+    SearchPath (String sys_path)
+    {
+	StringTokenizer st = new StringTokenizer (sys_path, path_seperator);
+	init (st);
+    }
+
+    /**
+     *  Constructs a SearchPath object, given a Vector of 
+     *  <code>String</code>, <code>File</code> or <code>URL</code>
+     *  objects.  
+     *  The path may contain names of directories, or names of
+     *  .zip or .jar files.  Elements that are neither of these
+     *  are ignored.
+     * @param p the vector of search path elements
+     */
+
+    SearchPath (Vector p)
+    {
+	init (p.elements ());
+    }
+
+    public URL getURL (String element)
+    {
+	URL result;
+
+	Enumeration e = path.elements ();
+	while (e.hasMoreElements ())
+	    {
+		PathEntry ent = (PathEntry) e.nextElement ();
+
+		result = ent.getURL (element);
+		
+		if (result != null) 
+		    {
+			return result;
+		    }
+	    }
+
+	return null;
+    }
+    
+
+    public InputStream getStream (String element)
+    {
+	InputStream result;
+
+	Enumeration e = path.elements ();
+	while (e.hasMoreElements ())
+	    {
+		PathEntry ent = (PathEntry) e.nextElement ();
+
+		result = ent.getStream (element);
+		
+		if (result != null) 
+		    {
+			return result;
+		    }
+	    }
+
+	return null;
+    }
+    
+
+    public byte[] getBytes (String element)
+    {
+	byte[] result;
+
+	Enumeration e = path.elements ();
+	while (e.hasMoreElements ())
+	    {
+		PathEntry ent = (PathEntry) e.nextElement ();
+		result = ent.getBytes (element);		
+		if (result != null) 
+		    {
+			System.out.println ("loading " + ent 
+					    + "(" + element + ")");
+			return result;
+		    }
+	    }
+
+	return null;
+    }
+    
+
+
+    private void init (Enumeration st)
+    {
+	path = new Vector ();
+	while (st.hasMoreElements ()) 
+	    {  
+		Object e = st.nextElement ();
+
+		String elem;
+		File efile;
+
+		if (e instanceof URL)
+		    {
+			path.addElement (new URLPathEntry ((URL) e));
+			continue;
+		    }
+
+		if (e instanceof File)
+		    {
+			efile = (File) e; 
+			elem = efile.getPath ();
+		    }
+
+		else if (e instanceof String)
+		    {
+			elem = (String) e;
+			efile   = new File (elem); 
+		    }
+
+		else
+		    throw new IllegalArgumentException ();
+
+		// make sure it is absolute, so we won't get 
+		// trouble if the cwd is changed...
+		if (! efile.isAbsolute ())
+		    efile = new File (efile.getAbsolutePath ());
+
+		if (efile.isDirectory ())
+		    {
+			try {
+			    path.addElement(new DirectoryPathEntry (efile));
+			} catch (IOException x) {
+			    /* ignore for now */
+			}
+		    }
+
+		else if (efile.isFile ())
+		    {
+			int ext = elem.lastIndexOf ('.');
+			if (ext == -1)
+			    continue;
+
+			if (!elem.substring(ext+1).equalsIgnoreCase("zip"))
+			    continue;
+
+			ZipPathEntry zpe = null;
+			try {
+			    zpe = new ZipPathEntry (efile);
+			} catch (ZipException zx) {
+			    System.err.println ("SearchPath::ZipException");
+			    zpe = null;
+			} catch (MalformedURLException mx) {
+			    System.err.println ("SearchPath::URLException");
+			    zpe = null;
+			} catch (IOException iox) {
+			    System.err.println ("SearchPath::IOException");
+			    zpe = null;
+			}
+			if (zpe != null) path.addElement (zpe);
+		    }
+	    }
+	
+    }
+    
+    
+}
+
diff --git a/libjava/gnu/gcj/util/path/URLPathEntry.java b/libjava/gnu/gcj/util/path/URLPathEntry.java
new file mode 100644
index 0000000..68f9200
--- /dev/null
+++ b/libjava/gnu/gcj/util/path/URLPathEntry.java
@@ -0,0 +1,67 @@
+// URLPathEntry.java -- search path element for URL's
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author: Kresten Krab Thorup <krab@gnu.org>  */
+
+package gnu.gcj.util.path;
+
+import java.util.*;
+import java.util.zip.*;
+import java.io.*;
+import java.net.*;
+
+final class URLPathEntry extends PathEntry {
+    final URL base;
+
+    URLPathEntry (URL f) {
+	base = f;
+    }
+
+    public String toString () { return base.toString (); }
+
+    URL getURL (String file) {
+
+	try {
+	    URL res = new URL (base, file);
+	    InputStream is = res.openStream (); // exc if not found
+	    is.close ();
+	    return res;
+	} catch (java.io.IOException x) {
+	    return null;
+	}
+    }
+
+    InputStream getStream (String file) {
+
+	try {
+	    URL res = new URL (base, file);
+	    return res.openStream ();
+	} catch (java.io.IOException x) {
+	    return null;
+	}
+
+    }
+
+    byte[] getBytes (String file) {
+
+	try {
+	    URL res = new URL (base, file);
+	    URLConnection conn = res.openConnection ();
+	    int len = conn.getContentLength ();
+	    if (len == -1) return null;
+	    return readbytes (conn.getInputStream (), len);
+	} catch (java.io.IOException x) {
+	    return null;
+	}
+
+    }
+
+}
+
diff --git a/libjava/gnu/gcj/util/path/ZipPathEntry.java b/libjava/gnu/gcj/util/path/ZipPathEntry.java
new file mode 100644
index 0000000..ac02262
--- /dev/null
+++ b/libjava/gnu/gcj/util/path/ZipPathEntry.java
@@ -0,0 +1,86 @@
+// ZipPathEntry.java -- search path element for directories
+
+/* Copyright (C) 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* Author: Kresten Krab Thorup <krab@gnu.org>  */
+
+package gnu.gcj.util.path;
+
+import java.util.*;
+import java.util.zip.*;
+import java.io.*;
+import java.net.*;
+
+
+final class ZipPathEntry extends PathEntry {
+    final ZipFile zip;
+    final URL     file;
+
+    public String toString () { return zip.getName (); }
+
+    ZipPathEntry (File f) 
+	throws MalformedURLException, ZipException, IOException
+    {
+	file = new URL ("file", "", f.getPath ());
+	zip  = new ZipFile (f);
+	zip.readDirectory ();
+    }
+
+    /* 
+       The url for a zip-file resource is,
+	   
+       <code>file:///path/file.zip#name</code>
+	   
+       Then, it is URLConnection's problem to handle that.
+    */
+
+    URL getURL (String f) {
+
+	ZipEntry ent = zip.getEntry (f);
+
+	try {
+	    if (ent != null)
+		return new URL (file, "#"+f);
+	    else
+		return null;
+	} catch (IOException x) {
+	    return null;
+	}
+    }
+
+    InputStream getStream (String f) {
+
+	ZipEntry ent = zip.getEntry (f);
+
+	try {
+	    if (ent != null)
+		return zip.getInputStream (ent);
+	    else
+		return null;
+	} catch (IOException x) {
+	    return null;
+	}
+    }
+
+    byte[] getBytes (String f) {
+	ZipEntry ent = zip.getEntry (f);
+
+	try {
+	    if (ent != null)
+		return readbytes (zip.getInputStream (ent),
+				  (int) ent.getSize ());
+	    else
+		return null;
+	} catch (IOException x) {
+	    return null;
+	}
+	    
+    }
+}
+