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, 742 insertions, 0 deletions

diff --git a/libjava/classpath/java/awt/BorderLayout.java b/libjava/classpath/java/awt/BorderLayout.java
new file mode 100644
index 000000000..c06eb834b
--- /dev/null
+++ b/libjava/classpath/java/awt/BorderLayout.java
@@ -0,0 +1,742 @@
+/* BorderLayout.java -- A layout manager class
+   Copyright (C) 1999, 2002, 2005  Free Software Foundation, Inc.
+
+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;
+
+
+/**
+  * This class implements a layout manager that positions components
+  * in certain sectors of the parent container.
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  * @author Rolf W. Rasmussen  (rolfwr@ii.uib.no)
+  */
+public class BorderLayout implements LayoutManager2, java.io.Serializable
+{
+
+  /**
+   * Constant indicating the top of the container
+   */
+  public static final String NORTH = "North";
+
+  /**
+   * Constant indicating the bottom of the container
+   */
+  public static final String SOUTH = "South";
+
+  /**
+   * Constant indicating the right side of the container
+   */
+  public static final String EAST = "East";
+
+  /**
+   * Constant indicating the left side of the container
+   */
+  public static final String WEST = "West";
+
+  /**
+   * Constant indicating the center of the container
+   */
+  public static final String CENTER = "Center";
+
+
+  /**
+   * The constant indicating the position before the first line of the
+   * layout.  The exact position depends on the writing system: For a
+   * top-to-bottom orientation, it is the same as {@link #NORTH}, for
+   * a bottom-to-top orientation, it is the same as {@link #SOUTH}.
+   *
+   * <p>This constant is an older name for {@link #PAGE_START} which
+   * has exactly the same value.
+   *
+   * @since 1.2
+   */
+  public static final String BEFORE_FIRST_LINE = "First";
+
+  /**
+   * The constant indicating the position after the last line of the
+   * layout.  The exact position depends on the writing system: For a
+   * top-to-bottom orientation, it is the same as {@link #SOUTH}, for
+   * a bottom-to-top orientation, it is the same as {@link #NORTH}.
+   *
+   * <p>This constant is an older name for {@link #PAGE_END} which
+   * has exactly the same value.
+   *
+   * @since 1.2
+   */
+  public static final String AFTER_LAST_LINE = "Last";
+
+  /**
+   * The constant indicating the position before the first item of the
+   * layout.  The exact position depends on the writing system: For a
+   * left-to-right orientation, it is the same as {@link #WEST}, for
+   * a right-to-left orientation, it is the same as {@link #EAST}.
+   *
+   * <p>This constant is an older name for {@link #LINE_START} which
+   * has exactly the same value.
+   *
+   * @since 1.2
+   */
+  public static final String BEFORE_LINE_BEGINS = "Before";
+
+  /**
+   * The constant indicating the position after the last item of the
+   * layout.  The exact position depends on the writing system: For a
+   * left-to-right orientation, it is the same as {@link #EAST}, for
+   * a right-to-left orientation, it is the same as {@link #WEST}.
+   *
+   * <p>This constant is an older name for {@link #LINE_END} which
+   * has exactly the same value.
+   *
+   * @since 1.2
+   */
+  public static final String AFTER_LINE_ENDS = "After";
+
+  /**
+   * The constant indicating the position before the first line of the
+   * layout.  The exact position depends on the writing system: For a
+   * top-to-bottom orientation, it is the same as {@link #NORTH}, for
+   * a bottom-to-top orientation, it is the same as {@link #SOUTH}.
+   *
+   * @since 1.4
+   */
+  public static final String PAGE_START = BEFORE_FIRST_LINE;
+
+  /**
+   * The constant indicating the position after the last line of the
+   * layout.  The exact position depends on the writing system: For a
+   * top-to-bottom orientation, it is the same as {@link #SOUTH}, for
+   * a bottom-to-top orientation, it is the same as {@link #NORTH}.
+   *
+   * @since 1.4
+   */
+  public static final String PAGE_END = AFTER_LAST_LINE;
+
+  /**
+   * The constant indicating the position before the first item of the
+   * layout.  The exact position depends on the writing system: For a
+   * left-to-right orientation, it is the same as {@link #WEST}, for
+   * a right-to-left orientation, it is the same as {@link #EAST}.
+   *
+   * @since 1.4
+   */
+  public static final String LINE_START = BEFORE_LINE_BEGINS;
+
+  /**
+   * The constant indicating the position after the last item of the
+   * layout.  The exact position depends on the writing system: For a
+   * left-to-right orientation, it is the same as {@link #EAST}, for
+   * a right-to-left orientation, it is the same as {@link #WEST}.
+   *
+   * @since 1.4
+   */
+  public static final String LINE_END = AFTER_LINE_ENDS;
+
+
+  /**
+   * Serialization constant.
+   */
+  private static final long serialVersionUID = -8658291919501921765L;
+
+
+  /**
+   * @serial
+   */
+  private Component north;
+
+  /**
+   * @serial
+   */
+  private Component south;
+
+  /**
+   * @serial
+   */
+  private Component east;
+
+  /**
+   * @serial
+   */
+  private Component west;
+
+  /**
+   * @serial
+  */
+  private Component center;
+
+  /**
+   * @serial
+   */
+  private Component firstLine;
+
+  /**
+   * @serial
+   */
+  private Component lastLine;
+
+  /**
+   * @serial
+   */
+  private Component firstItem;
+
+  /**
+   * @serial
+   */
+  private Component lastItem;
+
+  /**
+   * @serial The horizontal gap between components
+   */
+  private int hgap;
+
+  /**
+   * @serial The vertical gap between components
+   */
+  private int vgap;
+
+
+  // Some constants for use with calcSize().
+  private static final int MIN = 0;
+  private static final int MAX = 1;
+  private static final int PREF = 2;
+
+
+  /**
+   * Initializes a new instance of <code>BorderLayout</code> with no
+   * horiztonal or vertical gaps between components.
+   */
+  public BorderLayout()
+  {
+    this(0,0);
+  }
+
+  /**
+   * Initializes a new instance of <code>BorderLayout</code> with the
+   * specified horiztonal and vertical gaps between components.
+   *
+   * @param hgap The horizontal gap between components.
+   * @param vgap The vertical gap between components.
+   */
+  public BorderLayout(int hgap, int vgap)
+  {
+    this.hgap = hgap;
+    this.vgap = vgap;
+  }
+
+  /**
+   * Returns the horitzontal gap value.
+   *
+   * @return The horitzontal gap value.
+   */
+  public int getHgap()
+  {
+    return(hgap);
+  }
+
+  /**
+   * Sets the horizontal gap to the specified value.
+   *
+   * @param hgap The new horizontal gap.
+   */
+  public void setHgap(int hgap)
+  {
+    this.hgap = hgap;
+  }
+
+  /**
+   * Returns the vertical gap value.
+   *
+   * @return The vertical gap value.
+   */
+  public int getVgap()
+  {
+    return(vgap);
+  }
+
+  /**
+   * Sets the vertical gap to the specified value.
+   *
+   * @param vgap The new vertical gap value.
+   */
+  public void setVgap(int vgap)
+  {
+    this.vgap = vgap;
+  }
+
+  /**
+   * Adds a component to the layout in the specified constraint position,
+   * which must be one of the string constants defined in this class.
+   *
+   * @param component The component to add.
+   * @param constraints The constraint string.
+   *
+   * @exception IllegalArgumentException If the constraint object is not
+   * a string, or is not one of the specified constants in this class.
+   */
+  public void addLayoutComponent(Component component, Object constraints)
+  {
+    if (constraints != null && ! (constraints instanceof String))
+      throw new IllegalArgumentException("Constraint must be a string");
+
+    addLayoutComponent((String) constraints, component);
+  }
+
+  /**
+   * Adds a component to the layout in the specified constraint position,
+   * which must be one of the string constants defined in this class.
+   *
+   * @param constraints The constraint string.
+   * @param component The component to add.
+   *
+   * @exception IllegalArgumentException If the constraint object is not
+   *            one of the specified constants in this class.
+   *
+   * @deprecated This method is deprecated in favor of
+   *             <code>addLayoutComponent(Component, Object)</code>.
+   */
+  public void addLayoutComponent(String constraints, Component component)
+  {
+    String str = constraints;
+
+    if (str == null || str.equals(CENTER))
+      center = component;
+    else if (str.equals(NORTH))
+      north = component;
+    else if (str.equals(SOUTH))
+      south = component;
+    else if (str.equals(EAST))
+      east = component;
+    else if (str.equals(WEST))
+      west = component;
+    else if (str.equals(BEFORE_FIRST_LINE))
+      firstLine = component;
+    else if (str.equals(AFTER_LAST_LINE))
+      lastLine = component;
+    else if (str.equals(BEFORE_LINE_BEGINS))
+      firstItem = component;
+    else if (str.equals(AFTER_LINE_ENDS))
+      lastItem = component;
+    else
+      throw new IllegalArgumentException("Constraint value not valid: " + str);
+  }
+
+  /**
+   * Removes the specified component from the layout.
+   *
+   * @param component The component to remove from the layout.
+   */
+  public void removeLayoutComponent(Component component)
+  {
+    if (north == component)
+      north = null;
+    if (south == component)
+      south = null;
+    if (east == component)
+      east = null;
+    if (west == component)
+      west = null;
+    if (center == component)
+      center = null;
+    if (firstItem == component)
+      firstItem = null;
+    if (lastItem == component)
+      lastItem = null;
+    if (firstLine == component)
+      firstLine = null;
+    if (lastLine == component)
+      lastLine = null;
+  }
+
+  /**
+   * Returns the minimum size of the specified container using this layout.
+   *
+   * @param target The container to calculate the minimum size for.
+   *
+   * @return The minimum size of the container
+   */
+  public Dimension minimumLayoutSize(Container target)
+  {
+    return calcSize(target, MIN);
+  }
+
+  /**
+   * Returns the preferred size of the specified container using this layout.
+   *
+   * @param target The container to calculate the preferred size for.
+   *
+   * @return The preferred size of the container
+   */
+  public Dimension preferredLayoutSize(Container target)
+  {
+    return calcSize(target, PREF);
+  }
+
+  /**
+   * Returns the maximum size of the specified container using this layout.
+   *
+   * @param target The container to calculate the maximum size for.
+   *
+   * @return The maximum size of the container
+   */
+  public Dimension maximumLayoutSize(Container target)
+  {
+    return new Dimension (Integer.MAX_VALUE, Integer.MAX_VALUE);
+  }
+
+  /**
+   * Returns the X axis alignment, which is a <code>float</code> indicating
+   * where along the X axis this container wishs to position its layout.
+   * 0 indicates align to the left, 1 indicates align to the right, and 0.5
+   * indicates align to the center.
+   *
+   * @param parent The parent container.
+   *
+   * @return The X alignment value.
+   */
+  public float getLayoutAlignmentX(Container parent)
+  {
+    return 0.5F;
+  }
+
+  /**
+   * Returns the Y axis alignment, which is a <code>float</code> indicating
+   * where along the Y axis this container wishs to position its layout.
+   * 0 indicates align to the top, 1 indicates align to the bottom, and 0.5
+   * indicates align to the center.
+   *
+   * @param parent The parent container.
+   *
+   * @return The Y alignment value.
+   */
+  public float getLayoutAlignmentY(Container parent)
+  {
+    return 0.5F;
+  }
+
+  /**
+   * Instructs this object to discard any layout information it might
+   * have cached.
+   *
+   * @param parent The parent container.
+   */
+  public void invalidateLayout(Container parent)
+  {
+    // Nothing to do here.
+  }
+
+  /**
+   * Lays out the specified container according to the constraints in this
+   * object.
+   *
+   * @param target The container to lay out.
+   */
+  public void layoutContainer(Container target)
+  {
+    synchronized (target.getTreeLock())
+      {
+        Insets i = target.getInsets();
+        int top = i.top;
+        int bottom = target.height - i.bottom;
+        int left = i.left;
+        int right = target.width - i.right;
+
+        boolean left_to_right = target.getComponentOrientation().isLeftToRight();
+
+        Component my_north = north;
+        Component my_east = east;
+        Component my_south = south;
+        Component my_west = west;
+
+        // Note that we currently don't handle vertical layouts.
+        // Neither does JDK 1.3.
+        if (firstLine != null)
+          my_north = firstLine;
+        if (lastLine != null)
+          my_south = lastLine;
+        if (firstItem != null)
+          {
+            if (left_to_right)
+              my_west = firstItem;
+            else
+              my_east = firstItem;
+          }
+        if (lastItem != null)
+          {
+            if (left_to_right)
+              my_east = lastItem;
+            else
+              my_west = lastItem;
+          }
+
+        if (my_north != null)
+          {
+            Dimension n = calcCompSize(my_north, PREF);
+            my_north.setBounds(left, top, right - left, n.height);
+            top += n.height + vgap;
+          }
+
+        if (my_south != null)
+          {
+            Dimension s = calcCompSize(my_south, PREF);
+            my_south.setBounds(left, bottom - s.height, right - left, s.height);
+            bottom -= s.height + vgap;
+          }
+
+        if (my_east != null)
+          {
+            Dimension e = calcCompSize(my_east, PREF);
+            my_east.setBounds(right - e.width, top, e.width, bottom - top);
+            right -= e.width + hgap;
+          }
+
+        if (my_west != null)
+          {
+            Dimension w = calcCompSize(my_west, PREF);
+            my_west.setBounds(left, top, w.width, bottom - top);
+            left += w.width + hgap;
+          }
+
+        if (center != null)
+          center.setBounds(left, top, right - left, bottom - top);
+      }
+  }
+
+  /**
+   * Returns a string representation of this layout manager.
+   *
+   * @return A string representation of this object.
+   */
+  public String toString()
+  {
+    return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
+  }
+
+  private Dimension calcCompSize(Component comp, int what)
+  {
+    if (comp == null || ! comp.isVisible())
+      return new Dimension(0, 0);
+    if (what == MIN)
+      return comp.getMinimumSize();
+    else if (what == MAX)
+      return comp.getMaximumSize();
+    return comp.getPreferredSize();
+  }
+
+  /**
+   * This is a helper function used to compute the various sizes for this
+   * layout.
+   */
+  private Dimension calcSize(Container target, int what)
+  {
+    synchronized (target.getTreeLock())
+      {
+        Insets ins = target.getInsets();
+
+        ComponentOrientation orient = target.getComponentOrientation ();
+        boolean left_to_right = orient.isLeftToRight ();
+
+        Component my_north = north;
+        Component my_east = east;
+        Component my_south = south;
+        Component my_west = west;
+
+        // Note that we currently don't handle vertical layouts.  Neither
+        // does JDK 1.3.
+        if (firstLine != null)
+          my_north = firstLine;
+        if (lastLine != null)
+          my_south = lastLine;
+        if (firstItem != null)
+          {
+            if (left_to_right)
+              my_west = firstItem;
+            else
+              my_east = firstItem;
+          }
+        if (lastItem != null)
+          {
+            if (left_to_right)
+              my_east = lastItem;
+            else
+              my_west = lastItem;
+          }
+
+        Dimension ndim = calcCompSize(my_north, what);
+        Dimension sdim = calcCompSize(my_south, what);
+        Dimension edim = calcCompSize(my_east, what);
+        Dimension wdim = calcCompSize(my_west, what);
+        Dimension cdim = calcCompSize(center, what);
+
+        int width = edim.width + cdim.width + wdim.width + (hgap * 2);
+        // Check for overflow.
+        if (width < edim.width || width < cdim.width || width < cdim.width)
+          width = Integer.MAX_VALUE;
+
+        if (ndim.width > width)
+          width = ndim.width;
+        if (sdim.width > width)
+          width = sdim.width;
+
+        width += (ins.left + ins.right);
+
+        int height = edim.height;
+        if (cdim.height > height)
+          height = cdim.height;
+        if (wdim.height > height)
+          height = wdim.height;
+
+        int addedHeight = height + (ndim.height + sdim.height + (vgap * 2)
+                                    + ins.top + ins.bottom);
+        // Check for overflow.
+        if (addedHeight < height)
+          height = Integer.MAX_VALUE;
+        else
+          height = addedHeight;
+
+        return(new Dimension(width, height));
+      }
+  }
+
+  /**
+   * Return the component at the indicated location, or null if no component
+   * is at that location.  The constraints argument must be one of the
+   * location constants specified by this class.
+   * @param constraints the location
+   * @return the component at that location, or null
+   * @throws IllegalArgumentException if the constraints argument is not
+   * recognized
+   * @since 1.5
+   */
+  public Component getLayoutComponent(Object constraints)
+  {
+    if (constraints == CENTER)
+      return center;
+    if (constraints == NORTH)
+      return north;
+    if (constraints == EAST)
+      return east;
+    if (constraints == SOUTH)
+      return south;
+    if (constraints == WEST)
+      return west;
+    if (constraints == PAGE_START)
+      return firstLine;
+    if (constraints == PAGE_END)
+      return lastLine;
+    if (constraints == LINE_START)
+      return firstItem;
+    if (constraints == LINE_END)
+      return lastItem;
+    throw new IllegalArgumentException("constraint " + constraints
+                                       + " is not recognized");
+  }
+
+  /**
+   * Return the component at the specified location, which must be one
+   * of the absolute constants such as CENTER or SOUTH.  The container's
+   * orientation is used to map this location to the correct corresponding
+   * component, so for instance in a right-to-left container, a request
+   * for the EAST component could return the LINE_END component.  This will
+   * return null if no component is available at the given location.
+   * @param container the container whose orientation is used
+   * @param constraints the absolute location of the component
+   * @return the component at the location, or null
+   * @throws IllegalArgumentException if the constraint is not recognized
+   */
+  public Component getLayoutComponent(Container container, Object constraints)
+  {
+    ComponentOrientation orient = container.getComponentOrientation();
+    if (constraints == CENTER)
+      return center;
+    // Note that we don't support vertical layouts.
+    if (constraints == NORTH)
+      return north;
+    if (constraints == SOUTH)
+      return south;
+    if (constraints == WEST)
+      {
+        // Note that relative layout takes precedence.
+        if (orient.isLeftToRight())
+          return firstItem == null ? west : firstItem;
+        return lastItem == null ? west : lastItem;
+      }
+    if (constraints == EAST)
+      {
+        // Note that relative layout takes precedence.
+        if (orient.isLeftToRight())
+          return lastItem == null ? east : lastItem;
+        return firstItem == null ? east : firstItem;
+      }
+    throw new IllegalArgumentException("constraint " + constraints
+                                       + " is not recognized");
+  }
+
+  /**
+   * Return the constraint corresponding to a component in this layout.
+   * If the component is null, or is not in this layout, returns null.
+   * Otherwise, this will return one of the constraint constants defined
+   * in this class.
+   * @param c the component
+   * @return the constraint, or null
+   * @since 1.5
+   */
+  public Object getConstraints(Component c)
+  {
+    if (c == null)
+      return null;
+    if (c == center)
+      return CENTER;
+    if (c == north)
+      return NORTH;
+    if (c == east)
+      return EAST;
+    if (c == south)
+      return SOUTH;
+    if (c == west)
+      return WEST;
+    if (c == firstLine)
+      return PAGE_START;
+    if (c == lastLine)
+      return PAGE_END;
+    if (c == firstItem)
+      return LINE_START;
+    if (c == lastItem)
+      return LINE_END;
+    return null;
+  }
+}