[kaffe] CVS kaffe (guilhem): Added some missing file from a previous commit.

Kaffe CVS cvs-commits at kaffe.org
Thu Jul 29 12:40:02 PDT 2004


PatchSet 5026 
Date: 2004/07/29 14:42:17
Author: guilhem
Branch: HEAD
Tag: (none) 
Log:
Added some missing file from a previous commit.

Members: 
	ChangeLog:1.2584->1.2585 
	libraries/javalib/java/lang/VMObject.java:INITIAL->1.1 
	libraries/javalib/java/lang/VMThread.java:INITIAL->1.1 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.2584 kaffe/ChangeLog:1.2585
--- kaffe/ChangeLog:1.2584	Thu Jul 29 14:24:47 2004
+++ kaffe/ChangeLog	Thu Jul 29 14:42:17 2004
@@ -1,5 +1,7 @@
 2004-07-29  Guilhem Lavaux <guilhem at kaffe.org>
 
+	* libraries/javalib/Klasses.jar.bootstrap: Regenerated.
+
 	* include/Makefile.am: Added header generation for
 	java/lang/VMObject and java/lang/VMThread.
 
===================================================================
Checking out kaffe/libraries/javalib/java/lang/VMObject.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/java/lang/VMObject.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/java/lang/VMObject.java	Thu Jul 29 19:40:01 2004
@@ -0,0 +1,113 @@
+/* VMObject.java -- Reference implementation for VM hooks used by Object
+   Copyright (C) 1998, 2002 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package java.lang;
+
+/**
+ * Object is the ultimate superclass of every class (excepting interfaces).
+ * As such, it needs help from the VM.
+ *
+ * @author John Keiser
+ * @author Eric Blake <ebb9 at email.byu.edu>
+ */
+final class VMObject
+{
+  /**
+   * The VM is expected to make a field-for-field shallow copy of the
+   * argument. Thus, the copy has the same runtime type as the argument.
+   * Note, however, that the cloned object must still be finalizable, even
+   * if the original has already had finalize() invoked on it.
+   *
+   * @param c the Cloneable to clone
+   * @return the clone
+   */
+  static native Object clone(Cloneable c);
+
+  /**
+   * Wakes up one of the threads that is waiting on this Object's monitor.
+   * Only the owner of a lock on the Object may call this method. The Thread
+   * to wake up is chosen arbitrarily.
+   *
+   * @param o the object doing the notify
+   * @throw IllegalMonitorStateException if this Thread does not own the
+   *        lock on the Object
+   */
+  static native void notify(Object o) throws IllegalMonitorStateException;
+
+  /**
+   * Wakes up all of the threads waiting on this Object's monitor.  Only
+   * the owner of the lock on this Object may call this method.
+   *
+   * @param o the object doing the notifyAll
+   * @throws IllegalMonitorStateException if this Thread does not own the
+   *         lock on the Object
+   */
+  static native void notifyAll(Object o) throws IllegalMonitorStateException;
+
+  /**
+   * Waits a specified amount of time for notify() or notifyAll() to be
+   * called on this Object.  The VM does not have to pay attention to the
+   * ns argument, if it does not have that much granularity.
+   *
+   * @param o the object to suspend on
+   * @param ms milliseconds to wait (1,000 milliseconds = 1 second)
+   * @param ns nanoseconds to wait beyond ms (1,000,000 nanoseconds
+   *        == 1 millisecond)
+   * @throws IllegalMonitorStateException if this Thread does not own the
+   *         lock on the Object
+   * @throws InterruptedException if some other Thread interrupts this Thread
+   */
+  static void wait(Object o, long ms, int ns)
+    throws IllegalMonitorStateException, InterruptedException
+  {
+    Thread current = Thread.currentThread();
+    VMThread vmt = current.vmThread;
+    
+    if (current.interrupted())
+      throw new InterruptedException();
+    
+    vmt.holder = o;
+    nativeWait(o, ms, ns);
+    vmt.holder = null;
+    
+    if (current.interrupted())
+      throw new InterruptedException();
+  }
+
+  static native void nativeWait(Object o, long ms, int ns)
+      throws IllegalMonitorStateException, InterruptedException;
+}
===================================================================
Checking out kaffe/libraries/javalib/java/lang/VMThread.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/java/lang/VMThread.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/java/lang/VMThread.java	Thu Jul 29 19:40:01 2004
@@ -0,0 +1,488 @@
+/* VMThread -- VM interface for Thread of executable code
+   Copyright (C) 2003, 2004 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package java.lang;
+
+import kaffe.util.Ptr;
+
+/**
+ * VM interface for Thread of executable code. Holds VM dependent state.
+ * It is deliberately package local and final and should only be accessed
+ * by the Thread class.
+ * <p>
+ * This is the GNU Classpath reference implementation, it should be adapted
+ * for a specific VM.
+ * <p>
+ * The following methods must be implemented:
+ * <ul>
+ * <li>native void start(long stacksize);
+ * <li>native void interrupt();
+ * <li>native boolean isInterrupted();
+ * <li>native void suspend();
+ * <li>native void resume();
+ * <li>native void nativeSetPriority(int priority);
+ * <li>native void nativeStop(Throwable t);
+ * <li>native static Thread currentThread();
+ * <li>static native void yield();
+ * <li>static native void sleep(long ms, int ns) throws InterruptedException;
+ * <li>static native boolean interrupted();
+ * </ul>
+ * All other methods may be implemented to make Thread handling more efficient
+ * or to implement some optional (and sometimes deprecated) behaviour. Default
+ * implementations are provided but it is highly recommended to optimize them
+ * for a specific VM.
+ * 
+ * @author Jeroen Frijters (jeroen at frijters.net)
+ * @author Dalibor Topic (robilad at kaffe.org)
+ * @author Guilhem Lavaux (guilhem at kaffe.org) 
+ */
+final class VMThread
+{
+    /**
+     * The Thread object that this VM state belongs to.
+     * Used in currentThread() and start().
+     * Note: when this thread dies, this reference is *not* cleared
+     */
+    volatile Thread thread;
+
+    /**
+     * Flag that is set when the thread runs, used by stop() to protect against
+     * stop's getting lost.
+     */
+    private volatile boolean running;
+
+    /**
+     * Kaffe Specific: Pointer to the jthread identifier.
+     */
+    private Ptr jthreadID;
+
+    /**
+     * Kaffe Specific: Object instance to fall asleep.
+     */
+    private Object sleeper;
+
+    /**
+     * Kaffe Specific: Object which is holding the thread.
+     */
+    Object holder;
+    
+    /**
+     * Kaffe Specific: Thread is being interrupted.
+     */ 
+    private boolean interrupting;
+    
+    /**
+     * Private constructor, create VMThreads with the static create method.
+     *
+     * @param thread The Thread object that was just created.
+     */
+    private VMThread(Thread thread)
+    {
+	this.thread = thread;
+    }
+
+    /**
+     * This method is the initial Java code that gets executed when a native
+     * thread starts. It's job is to coordinate with the rest of the VMThread
+     * logic and to start executing user code and afterwards handle clean up.
+     */
+    private void run()
+    {
+	try
+	{
+	    try
+	    {
+		running = true;
+		synchronized(thread)
+		{
+		    Throwable t = thread.stillborn;
+		    if(t != null)
+		    {
+			thread.stillborn = null;
+			throw t;
+		    }
+		}
+		thread.run();
+	    }
+	    catch(Throwable t)
+	    {
+		try
+		{
+		    thread.group.uncaughtException(thread, t);
+		}
+		catch(Throwable ignore)
+		{
+		}
+	    }
+	}
+	finally
+	{
+	    // Setting runnable to false is partial protection against stop
+	    // being called while we're cleaning up. To be safe all code in
+	    // VMThread be unstoppable.
+	    running = false;
+	    thread.die();
+	    synchronized(this)
+	    {
+		// release the threads waiting to join us
+		notifyAll();
+	    }
+	}
+    }
+
+    /**
+     * Creates a native Thread. This is called from the start method of Thread.
+     * The Thread is started.
+     *
+     * @param thread The newly created Thread object
+     * @param stacksize Indicates the requested stacksize. Normally zero,
+     * non-zero values indicate requested stack size in bytes but it is up
+     * to the specific VM implementation to interpret them and may be ignored.
+     */
+    static void create(Thread thread, long stacksize)
+    {
+	VMThread vmThread = new VMThread(thread);
+	vmThread.start(stacksize);
+	thread.vmThread = vmThread;
+    }
+
+    /**
+     * Gets the name of the thread. Usually this is the name field of the
+     * associated Thread object, but some implementation might choose to
+     * return the name of the underlying platform thread.
+     */
+    String getName()
+    {
+	return thread.name;
+    }
+
+    /**
+     * Set the name of the thread. Usually this sets the name field of the
+     * associated Thread object, but some implementations might choose to
+     * set the name of the underlying platform thread.
+     * @param name The new name
+     */
+    void setName(String name)
+    {
+	thread.name = name;
+    }
+
+    /**
+     * Set the thread priority field in the associated Thread object and
+     * calls the native method to set the priority of the underlying
+     * platform thread.
+     * @param priority The new priority
+     */
+    void setPriority(int priority)
+    {
+	thread.priority = priority;
+	nativeSetPriority(priority);
+    }
+
+    /**
+     * Returns the priority. Usually this is the priority field from the
+     * associated Thread object, but some implementation might choose to
+     * return the priority of the underlying platform thread.
+     * @return this Thread's priority
+     */
+    int getPriority()
+    {
+        return thread.priority;
+    }
+
+    /**
+     * Returns true if the thread is a daemon thread. Usually this is the
+     * daemon field from the associated Thread object, but some
+     * implementation might choose to return the daemon state of the underlying
+     * platform thread.
+     * @return whether this is a daemon Thread or not
+     */
+    boolean isDaemon()
+    {
+        return thread.daemon;
+    }
+
+    /**
+     * Returns the number of stack frames in this Thread.
+     * Will only be called when when a previous call to suspend() returned true.
+     *
+     * @deprecated unsafe operation
+     */
+    int countStackFrames()
+    {
+	return 0;
+    }
+
+    /**
+     * Wait the specified amount of time for the Thread in question to die.
+     *
+     * <p>Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do
+     * not offer that fine a grain of timing resolution. Besides, there is
+     * no guarantee that this thread can start up immediately when time expires,
+     * because some other thread may be active.  So don't expect real-time
+     * performance.
+     *
+     * @param ms the number of milliseconds to wait, or 0 for forever
+     * @param ns the number of extra nanoseconds to sleep (0-999999)
+     * @throws InterruptedException if the Thread is interrupted; it's
+     *         <i>interrupted status</i> will be cleared
+     */
+    synchronized void join(long ms, int ns) throws InterruptedException
+    {
+	// round up
+	ms += (ns != 0) ? 1 : 0;
+
+	long end = System.currentTimeMillis() + ms;
+
+	// Apparently, some VMs will return from wait without notify having
+	// been called, so we loop and test the vmThread field in our
+	// corresponding Thread object.
+	while(thread.vmThread != null)
+	{
+	    // We use the VMThread object to wait on, because this is a private
+	    // object, so client code cannot call notify on us.
+	    wait(ms);
+	    if(ms != 0)
+	    {
+		long now = System.currentTimeMillis();
+		ms = end - now;
+		if(ms <= 0)
+		{
+		    break;
+		}
+	    }
+	}
+    }
+
+    /**
+     * Cause this Thread to stop abnormally and throw the specified exception.
+     * If you stop a Thread that has not yet started, the stop is ignored
+     * (contrary to what the JDK documentation says).
+     * <b>WARNING</b>This bypasses Java security, and can throw a checked
+     * exception which the call stack is unprepared to handle. Do not abuse 
+     * this power.
+     *
+     * <p>This is inherently unsafe, as it can interrupt synchronized blocks and
+     * leave data in bad states.
+     *
+     * <p><b>NOTE</b> stop() should take care not to stop a thread if it is
+     * executing code in this class.
+     *
+     * @param t the Throwable to throw when the Thread dies
+     * @deprecated unsafe operation, try not to use
+     */
+    void stop(Throwable t)
+    {
+	// Note: we assume that we own the lock on thread
+	// (i.e. that Thread.stop() is synchronized)
+	if(running)
+	    nativeStop(t);
+	else
+	    thread.stillborn = t;
+    }
+
+    /**
+     * Create a native thread on the underlying platform and start it executing
+     * on the run method of this object.
+     * @param stacksize the requested size of the native thread stack
+     */
+    native void start(long stacksize);
+
+    /**
+     * Interrupt this thread.
+     */
+    void interrupt()
+    {
+      interrupting = true;
+      Object h = holder;
+      if (h != null)
+	{
+	  holder = null;
+	  synchronized(h)
+	    {
+	      h.notify();
+	    }
+	}
+      else
+	nativeInterrupt();
+    }
+
+    private native void nativeInterrupt();
+
+    /**
+     * Determine whether this Thread has been interrupted, but leave
+     * the <i>interrupted status</i> alone in the process.
+     *
+     * @return whether the Thread has been interrupted
+     */
+    boolean isInterrupted()
+    {
+      return interrupting || nativeIsInterrupted();
+    }
+
+    private native boolean nativeIsInterrupted();
+
+    /**
+     * Suspend this Thread.  It will not come back, ever, unless it is resumed.
+     */
+    void suspend()
+    {
+      throw new SecurityException("Suspending a running thread is deprecated and not supported in KaffeVM.");
+    }
+
+    /**
+     * Resume this Thread.  If the thread is not suspended, this method does
+     * nothing.
+     */
+    void resume()
+    {
+      throw new SecurityException("Resuming a running thread is deprecated and not supported in KaffeVM.");
+    }
+
+    /**
+     * Set the priority of the underlying platform thread.
+     *
+     * @param priority the new priority
+     */
+    native void nativeSetPriority(int priority);
+
+    /**
+     * Asynchronously throw the specified throwable in this Thread.
+     *
+     * @param t the exception to throw
+     */
+    void nativeStop(Throwable t)
+    {
+      throw new SecurityException("Stopping a running thread is deprecated and not supported in KaffeVM.");
+    }
+
+    /**
+     * Return the Thread object associated with the currently executing
+     * thread.
+     *
+     * @return the currently executing Thread
+     */
+    native static Thread currentThread();
+
+    /**
+     * Yield to another thread. The Thread will not lose any locks it holds
+     * during this time. There are no guarantees which thread will be
+     * next to run, and it could even be this one, but most VMs will choose
+     * the highest priority thread that has been waiting longest.
+     */
+    static native void yield();
+
+    /**
+     * Suspend the current Thread's execution for the specified amount of
+     * time. The Thread will not lose any locks it has during this time. There
+     * are no guarantees which thread will be next to run, but most VMs will
+     * choose the highest priority thread that has been waiting longest.
+     *
+     * <p>Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do
+     * not offer that fine a grain of timing resolution. Besides, there is
+     * no guarantee that this thread can start up immediately when time expires,
+     * because some other thread may be active.  So don't expect real-time
+     * performance.
+     *
+     * @param ms the number of milliseconds to sleep, or 0 for forever
+     * @param ns the number of extra nanoseconds to sleep (0-999999)
+     * @throws InterruptedException if the Thread is interrupted; it's
+     *         <i>interrupted status</i> will be cleared
+     * @throws IllegalArgumentException if ns is invalid
+     */
+    static void sleep(long ms, int ns) throws InterruptedException
+    {
+      VMThread curr = currentThread().vmThread;
+	
+      if (curr.sleeper == null)
+	curr.sleeper = new Object();
+	
+      synchronized (curr.sleeper)
+	{
+	  curr.sleeper.wait(ms, ns);
+	}
+    }
+
+    /**
+     * Determine whether the current Thread has been interrupted, and clear
+     * the <i>interrupted status</i> in the process.
+     *
+     * @return whether the current Thread has been interrupted
+     */
+    static boolean interrupted()
+    {
+      VMThread vmt = Thread.currentThread().vmThread;
+      boolean i = nativeInterrupted() || vmt.interrupting;
+
+      vmt.interrupting = false;
+      return i;
+    }
+
+    static native boolean nativeInterrupted();
+
+    /**
+     * Kaffe Specific: finalize thread
+     */
+    native protected void finalize() throws Throwable;
+
+    /**
+     * Checks whether the current thread holds the monitor on a given object.
+     * This allows you to do <code>assert Thread.holdsLock(obj)</code>.
+     *
+     * @param obj the object to check
+     * @return true if the current thread is currently synchronized on obj
+     * @throws NullPointerException if obj is null
+     */
+    static boolean holdsLock(Object obj) 
+    {
+      /* Use obj.notify to check if the current thread holds
+       * the monitor of the object.
+       * If it doesn't, notify will throw an exception.
+       */
+      try 
+	{
+	  obj.notify();
+	  // okay, current thread holds lock
+	  return true;
+	}
+      catch (IllegalMonitorStateException e)
+	{
+	  // it doesn't hold the lock
+	  return false;
+	}
+    }
+}



More information about the kaffe mailing list