obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 658 insertions, 0 deletions

diff --git a/libjava/classpath/java/awt/EventQueue.java b/libjava/classpath/java/awt/EventQueue.java
new file mode 100644
index 000000000..cb52ae013
--- /dev/null
+++ b/libjava/classpath/java/awt/EventQueue.java
@@ -0,0 +1,658 @@
+/* EventQueue.java --
+   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005  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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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.awt;
+
+import gnu.java.awt.LowPriorityEvent;
+import gnu.java.awt.peer.NativeEventLoopRunningEvent;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.InputEvent;
+import java.awt.event.InputMethodEvent;
+import java.awt.event.InvocationEvent;
+import java.awt.event.PaintEvent;
+import java.awt.peer.ComponentPeer;
+import java.awt.peer.LightweightPeer;
+import java.lang.reflect.InvocationTargetException;
+import java.util.EmptyStackException;
+
+/* Written using on-line Java 2 Platform Standard Edition v1.3 API
+ * Specification, as well as "The Java Class Libraries", 2nd edition
+ * (Addison-Wesley, 1998).
+ * Status:  Believed complete, but untested.
+ */
+
+/**
+ * This class manages a queue of <code>AWTEvent</code> objects that
+ * are posted to it.  The AWT system uses only one event queue for all
+ * events.
+ *
+ * @author Bryce McKinlay
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+public class EventQueue
+{
+  /**
+   * Indicates events that are processed with normal priority. This is normally
+   * all events except PaintEvents.
+   */
+  private static final int NORM_PRIORITY = 0;
+
+  /**
+   * Indicates events that are processed with lowes priority. This is normally
+   * all PaintEvents and LowPriorityEvents.
+   */
+  private static final int LOW_PRIORITY = 1;
+
+  /**
+   * Implements the actual queue. EventQueue has 2 internal queues for
+   * different priorities:
+   * 1 PaintEvents are always dispatched with low priority.
+   * 2. All other events are dispatched with normal priority.
+   *
+   * This makes sure that the actual painting (output) is performed _after_ all
+   * available input has been processed and that the paint regions are
+   * coalesced as much as possible.
+   */
+  private class Queue
+  {
+    /**
+     * The first item in the queue. This is where events are popped from.
+     */
+    AWTEvent queueHead;
+
+    /**
+     * The last item. This is where events are posted to.
+     */
+    AWTEvent queueTail;
+  }
+
+  /**
+   * The three internal event queues.
+   *
+   * @see Queue
+   */
+  private Queue[] queues;
+
+  private EventQueue next;
+  private EventQueue prev;
+  private AWTEvent currentEvent;
+  private long lastWhen = System.currentTimeMillis();
+
+  private EventDispatchThread dispatchThread = new EventDispatchThread(this);
+  private boolean nativeLoopRunning = false;
+
+  private boolean isShutdown ()
+  {
+    // This is the exact self-shutdown condition specified in J2SE:
+    // http://java.sun.com/j2se/1.4.2/docs/api/java/awt/doc-files/AWTThreadIssues.html
+
+    if (nativeLoopRunning)
+      return false;
+
+    if (peekEvent() != null)
+      return false;
+
+    if (Frame.hasDisplayableFrames())
+      return false;
+
+    return true;
+  }
+
+  /**
+   * Initializes a new instance of <code>EventQueue</code>.
+   */
+  public EventQueue()
+  {
+    queues = new Queue[2];
+    queues[NORM_PRIORITY] = new Queue();
+    queues[LOW_PRIORITY] = new Queue();
+  }
+
+  /**
+   * Returns the next event in the queue.  This method will block until
+   * an event is available or until the thread is interrupted.
+   *
+   * @return The next event in the queue.
+   *
+   * @exception InterruptedException If this thread is interrupted while
+   * waiting for an event to be posted to the queue.
+   */
+  public synchronized AWTEvent getNextEvent()
+    throws InterruptedException
+  {
+    if (next != null)
+      return next.getNextEvent();
+
+    AWTEvent res = getNextEventImpl(true);
+
+    while (res == null)
+      {
+        if (isShutdown())
+          {
+            // Explicitly set dispathThread to null.  If we don't do
+            // this, there is a race condition where dispatchThread
+            // can be != null even after the event dispatch thread has
+            // stopped running.  If that happens, then the
+            // dispatchThread == null check in postEventImpl will
+            // fail, and a new event dispatch thread will not be
+            // created, leaving invokeAndWaits waiting indefinitely.
+            dispatchThread = null;
+
+            // Interrupt the event dispatch thread.
+            throw new InterruptedException();
+          }
+
+        wait();
+        res = getNextEventImpl(true);
+      }
+
+    return res;
+  }
+
+  /**
+   * Fetches and possibly removes the next event from the internal queues.
+   * This method returns immediately. When all queues are empty, this returns
+   * <code>null</code>:
+   *
+   * @param remove <true> when the event should be removed from the queue,
+   *        <code>false</code> otherwise
+   *
+   * @return the next event or <code>null</code> when all internal queues
+   *         are empty
+   */
+  private AWTEvent getNextEventImpl(boolean remove)
+  {
+    AWTEvent next = null;
+    for (int i = 0; i < queues.length && next == null; i++)
+      {
+        Queue q = queues[i];
+        if (q.queueHead != null)
+          {
+            // Got an event, remove it.
+            next = q.queueHead;
+            if (remove)
+              {
+                // Unlink event from the queue.
+                q.queueHead = next.queueNext;
+                if (q.queueHead == null)
+                  q.queueTail = null;
+                next.queueNext = null;
+              }
+          }
+      }
+    return next;
+  }
+
+  /**
+   * Returns the next event in the queue without removing it from the queue.
+   * This method will block until an event is available or until the thread
+   * is interrupted.
+   *
+   * @return The next event in the queue.
+   * @specnote Does not block. Returns null if there are no events on the
+   *            queue.
+   */
+  public synchronized AWTEvent peekEvent()
+  {
+    if (next != null)
+      return next.peekEvent();
+
+    return getNextEventImpl(false);
+  }
+
+  /**
+   * Returns the next event in the queue that has the specified id
+   * without removing it from the queue.
+   * This method will block until an event is available or until the thread
+   * is interrupted.
+   *
+   * @param id The event id to return.
+   *
+   * @return The next event in the queue.
+   *
+   * @specnote Does not block. Returns null if there are no matching events
+   *            on the queue.
+   */
+  public synchronized AWTEvent peekEvent(int id)
+  {
+    if (next != null)
+      return next.peekEvent(id);
+
+    AWTEvent evt = null;
+    for (int i = 0; i < queues.length && evt == null; i++)
+      {
+        Queue q = queues[i];
+        evt = q.queueHead;
+        while (evt != null && evt.id != id)
+          evt = evt.queueNext;
+        // At this point we either have found an event (evt != null -> exit
+        // for loop), or we have found no event (evt == null -> search next
+        // internal queue).
+      }
+    return evt;
+  }
+
+  /**
+   * Posts a new event to the queue.
+   *
+   * @param evt The event to post to the queue.
+   *
+   * @exception NullPointerException If event is null.
+   */
+  public void postEvent(AWTEvent evt)
+  {
+    postEventImpl(evt);
+  }
+
+  /**
+   * Sorts events to their priority and calls
+   * {@link #postEventImpl(AWTEvent, int)}.
+   *
+   * @param evt the event to post
+   */
+  private synchronized final void postEventImpl(AWTEvent evt)
+  {
+    int priority = NORM_PRIORITY;
+    if (evt instanceof PaintEvent || evt instanceof LowPriorityEvent)
+      priority = LOW_PRIORITY;
+    // TODO: Maybe let Swing RepaintManager events also be processed with
+    // low priority.
+    if (evt instanceof NativeEventLoopRunningEvent)
+      {
+        nativeLoopRunning = ((NativeEventLoopRunningEvent) evt).isRunning();
+        notify();
+        return;
+      }
+    postEventImpl(evt, priority);
+  }
+
+  /**
+   * Actually performs the event posting. This is needed because the
+   * RI doesn't use the public postEvent() method when transferring events
+   * between event queues in push() and pop().
+   *
+   * @param evt the event to post
+   * @param priority the priority of the event
+   */
+  private final void postEventImpl(AWTEvent evt, int priority)
+  {
+    if (evt == null)
+      throw new NullPointerException();
+
+    if (next != null)
+      {
+        next.postEvent(evt);
+        return;
+      }
+
+    Object source = evt.getSource();
+
+    Queue q = queues[priority];
+    if (source instanceof Component)
+      {
+        // For PaintEvents, ask the ComponentPeer to coalesce the event
+        // when the component is heavyweight.
+        Component comp = (Component) source;
+        ComponentPeer peer = comp.peer;
+        if (peer != null && evt instanceof PaintEvent
+            && ! (peer instanceof LightweightPeer))
+          peer.coalescePaintEvent((PaintEvent) evt);
+
+        // Check for any events already on the queue with the same source
+        // and ID.
+        AWTEvent previous = null;
+        for (AWTEvent qevt = q.queueHead; qevt != null; qevt = qevt.queueNext)
+          {
+            Object src = qevt.getSource();
+            if (qevt.id == evt.id && src == comp)
+              {
+                // If there are, call coalesceEvents on the source component
+                // to see if they can be combined.
+                Component srccmp = (Component) src;
+                AWTEvent coalescedEvt = srccmp.coalesceEvents(qevt, evt);
+                if (coalescedEvt != null)
+                  {
+                    // Yes. Replace the existing event with the combined event.
+                    if (qevt != coalescedEvt)
+                      {
+                        if (previous != null)
+                          {
+                            assert previous.queueNext == qevt;
+                            previous.queueNext = coalescedEvt;
+                          }
+                        else
+                          {
+                            assert q.queueHead == qevt;
+                            q.queueHead = coalescedEvt;
+                          }
+                        coalescedEvt.queueNext = qevt.queueNext;
+                        if (q.queueTail == qevt)
+                          q.queueTail = coalescedEvt;
+                        qevt.queueNext = null;
+                      }
+                    return;
+                  }
+              }
+            previous = qevt;
+          }
+      }
+
+    if (q.queueHead == null)
+      {
+        // We have an empty queue. Set this event both as head and as tail.
+        q.queueHead = evt;
+        q.queueTail = evt;
+      }
+    else
+      {
+        // Note: queueTail should not be null here.
+        q.queueTail.queueNext = evt;
+        q.queueTail = evt;
+      }
+
+    if (dispatchThread == null || !dispatchThread.isAlive())
+      {
+        dispatchThread = new EventDispatchThread(this);
+        dispatchThread.start();
+      }
+
+    notify();
+  }
+
+  /**
+   * Causes runnable to have its run method called in the dispatch thread of the
+   * EventQueue. This will happen after all pending events are processed. The
+   * call blocks until this has happened. This method will throw an Error if
+   * called from the event dispatcher thread.
+   *
+   * @exception InterruptedException If another thread has interrupted
+   * this thread.
+   * @exception InvocationTargetException If an exception is thrown when running
+   * runnable.
+   *
+   * @since 1.2
+   */
+  public static void invokeAndWait(Runnable runnable)
+    throws InterruptedException, InvocationTargetException
+  {
+    if (isDispatchThread ())
+      throw new Error("Can't call invokeAndWait from event dispatch thread");
+
+    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
+    Object notifyObject = new Object();
+
+    InvocationEvent ie =
+      new InvocationEvent(eq, runnable, notifyObject, true);
+
+    synchronized (notifyObject)
+      {
+        eq.postEvent(ie);
+        notifyObject.wait();
+      }
+
+    Exception exception;
+
+    if ((exception = ie.getException()) != null)
+      throw new InvocationTargetException(exception);
+  }
+
+  /**
+   * This arranges for runnable to have its run method called in the
+   * dispatch thread of the EventQueue.  This will happen after all
+   * pending events are processed.
+   *
+   * @since 1.2
+   */
+  public static void invokeLater(Runnable runnable)
+  {
+    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
+
+    InvocationEvent ie =
+      new InvocationEvent(eq, runnable, null, false);
+
+    eq.postEvent(ie);
+  }
+
+  /**
+   * Return true if the current thread is the current AWT event dispatch
+   * thread.
+   */
+  public static boolean isDispatchThread()
+  {
+    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
+
+    /* Find last EventQueue in chain */
+    while (eq.next != null)
+      eq = eq.next;
+
+    return (Thread.currentThread() == eq.dispatchThread);
+  }
+
+  /**
+   * Return the event currently being dispatched by the event
+   * dispatch thread.  If the current thread is not the event
+   * dispatch thread, this method returns null.
+   *
+   * @since 1.4
+   */
+  public static AWTEvent getCurrentEvent()
+  {
+    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
+    Thread ct = Thread.currentThread();
+
+    /* Find out if this thread is the dispatch thread for any of the
+       EventQueues in the chain */
+    while (ct != eq.dispatchThread)
+      {
+        // Try next EventQueue, if any
+        if (eq.next == null)
+           return null;  // Not an event dispatch thread
+        eq = eq.next;
+      }
+
+    return eq.currentEvent;
+  }
+
+  /**
+   * Allows a custom EventQueue implementation to replace this one.
+   * All pending events are transferred to the new queue. Calls to postEvent,
+   * getNextEvent, and peekEvent and others are forwarded to the pushed queue
+   * until it is removed with a pop().
+   *
+   * @exception NullPointerException if newEventQueue is null.
+   */
+  public synchronized void push(EventQueue newEventQueue)
+  {
+    if (newEventQueue == null)
+      throw new NullPointerException ();
+
+    /* Make sure we are at the top of the stack because callers can
+       only get a reference to the one at the bottom using
+       Toolkit.getDefaultToolkit().getSystemEventQueue() */
+    if (next != null)
+      {
+        next.push (newEventQueue);
+        return;
+      }
+
+    /* Make sure we have a live dispatch thread to drive the queue */
+    if (dispatchThread == null)
+      dispatchThread = new EventDispatchThread(this);
+
+    synchronized (newEventQueue)
+      {
+        // The RI transfers the events without calling the new eventqueue's
+        // push(), but using getNextEvent().
+        while (peekEvent() != null)
+          {
+            try
+              {
+                newEventQueue.postEventImpl(getNextEvent());
+              }
+            catch (InterruptedException ex)
+              {
+                // What should we do with this?
+                ex.printStackTrace();
+              }
+          }
+        newEventQueue.prev = this;
+      }
+
+    next = newEventQueue;
+  }
+
+  /** Transfer any pending events from this queue back to the parent queue that
+    * was previously push()ed. Event dispatch from this queue is suspended.
+    *
+    * @exception EmptyStackException If no previous push was made on this
+    * EventQueue.
+    */
+  protected void pop() throws EmptyStackException
+  {
+    /* The order is important here, we must get the prev lock first,
+       or deadlock could occur as callers usually get here following
+       prev's next pointer, and thus obtain prev's lock before trying
+       to get this lock. */
+    EventQueue previous = prev;
+    if (previous == null)
+      throw new EmptyStackException();
+    synchronized (previous)
+      {
+        synchronized (this)
+          {
+            EventQueue nextQueue = next;
+            if (nextQueue != null)
+              {
+                nextQueue.pop();
+              }
+            else
+              {
+                previous.next = null;
+
+                // The RI transfers the events without calling the new eventqueue's
+                // push(), so this should be OK and most effective.
+                while (peekEvent() != null)
+                  {
+                    try
+                      {
+                        previous.postEventImpl(getNextEvent());
+                      }
+                    catch (InterruptedException ex)
+                      {
+                        // What should we do with this?
+                        ex.printStackTrace();
+                      }
+                  }
+                prev = null;
+                // Tell our EventDispatchThread that it can end
+                // execution.
+                if (dispatchThread != null)
+                  {
+                    dispatchThread.interrupt();
+                    dispatchThread = null;
+                  }
+              }
+          }
+      }
+  }
+
+  /**
+   * Dispatches an event. The manner in which the event is dispatched depends
+   * upon the type of the event and the type of the event's source object.
+   *
+   * @exception NullPointerException If event is null.
+   */
+  protected void dispatchEvent(AWTEvent evt)
+  {
+    currentEvent = evt;
+
+    if (evt instanceof InputEvent)
+      lastWhen = ((InputEvent) evt).getWhen();
+    else if (evt instanceof ActionEvent)
+      lastWhen = ((ActionEvent) evt).getWhen();
+    else if (evt instanceof InvocationEvent)
+      lastWhen = ((InvocationEvent) evt).getWhen();
+
+    if (evt instanceof ActiveEvent)
+      {
+        ActiveEvent active_evt = (ActiveEvent) evt;
+        active_evt.dispatch();
+      }
+    else
+      {
+        Object source = evt.getSource();
+
+        if (source instanceof Component)
+          {
+            Component srccmp = (Component) source;
+            srccmp.dispatchEvent(evt);
+          }
+        else if (source instanceof MenuComponent)
+          {
+            MenuComponent srccmp = (MenuComponent) source;
+            srccmp.dispatchEvent(evt);
+          }
+      }
+  }
+
+  /**
+   * Returns the timestamp of the most recent event that had a timestamp, or
+   * the initialization time of the event queue if no events have been fired.
+   * At present, only <code>InputEvent</code>s, <code>ActionEvent</code>s,
+   * <code>InputMethodEvent</code>s, and <code>InvocationEvent</code>s have
+   * timestamps, but this may be added to other events in future versions.
+   * If this is called by the event dispatching thread, it can be any
+   * (sequential) value, but to other threads, the safest bet is to return
+   * System.currentTimeMillis().
+   *
+   * @return the most recent timestamp
+   * @see InputEvent#getWhen()
+   * @see ActionEvent#getWhen()
+   * @see InvocationEvent#getWhen()
+   * @see InputMethodEvent#getWhen()
+   * @since 1.4
+   */
+  public static long getMostRecentEventTime()
+  {
+    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
+    if (Thread.currentThread() != eq.dispatchThread)
+      return System.currentTimeMillis();
+    return eq.lastWhen;
+  }
+}