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

diff --git a/libjava/classpath/java/awt/geom/RoundRectangle2D.java b/libjava/classpath/java/awt/geom/RoundRectangle2D.java
new file mode 100644
index 000000000..19a7b4237
--- /dev/null
+++ b/libjava/classpath/java/awt/geom/RoundRectangle2D.java
@@ -0,0 +1,584 @@
+/* RoundRectangle2D.java -- represents a rectangle with rounded corners
+   Copyright (C) 2000, 2002, 2003, 2004, 2006, 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.geom;
+
+
+
+/** This class implements a rectangle with rounded corners.
+ * @author Tom Tromey (tromey@cygnus.com)
+ * @date December 3, 2000
+ */
+public abstract class RoundRectangle2D extends RectangularShape
+{
+  /**
+   * Return the arc height of this round rectangle.  The arc height and width
+   * control the roundness of the corners of the rectangle.
+   *
+   * @return The arc height.
+   *
+   * @see #getArcWidth()
+   */
+  public abstract double getArcHeight();
+
+  /**
+   * Return the arc width of this round rectangle.  The arc width and height
+   * control the roundness of the corners of the rectangle.
+   *
+   * @return The arc width.
+   *
+   * @see #getArcHeight()
+   */
+  public abstract double getArcWidth();
+
+  /**
+   * Set the values of this round rectangle.
+   *
+   * @param x The x coordinate
+   * @param y The y coordinate
+   * @param w The width
+   * @param h The height
+   * @param arcWidth The arc width
+   * @param arcHeight The arc height
+   */
+  public abstract void setRoundRect(double x, double y, double w, double h,
+                                    double arcWidth, double arcHeight);
+
+  /**
+   * Create a RoundRectangle2D.  This is protected because this class
+   * is abstract and cannot be instantiated.
+   */
+  protected RoundRectangle2D()
+  {
+  }
+
+  /**
+   * Return true if this object contains the specified point.
+   * @param x The x coordinate
+   * @param y The y coordinate
+   */
+  public boolean contains(double x, double y)
+  {
+    double mx = getX();
+    double mw = getWidth();
+    if (x < mx || x >= mx + mw)
+      return false;
+    double my = getY();
+    double mh = getHeight();
+    if (y < my || y >= my + mh)
+      return false;
+
+    // Now check to see if the point is in range of an arc.
+    double dy = Math.min(Math.abs(my - y), Math.abs(my + mh - y));
+    double dx = Math.min(Math.abs(mx - x), Math.abs(mx + mw - x));
+
+    // The arc dimensions are that of the corresponding ellipse
+    // thus a 90 degree segment is half of that.
+    double aw = getArcWidth() / 2.0;
+    double ah = getArcHeight() / 2.0;
+    if (dx > aw || dy > ah)
+      return true;
+
+    // At this point DX represents the distance from the nearest edge
+    // of the rectangle.  But we want to transform it to represent the
+    // scaled distance from the center of the ellipse that forms the
+    // arc.  Hence this code:
+    dy = (ah - dy) / ah;
+    dx = (aw - dx) / aw;
+
+    return dx * dx + dy * dy <= 1.0;
+  }
+
+  /**
+   * Return true if this object contains the specified rectangle
+   * @param x The x coordinate
+   * @param y The y coordinate
+   * @param w The width
+   * @param h The height
+   */
+  public boolean contains(double x, double y, double w, double h)
+  {
+    // We have to check all four points here (for ordinary rectangles
+    // we can just check opposing corners).
+    return (contains(x, y) && contains(x, y + h) && contains(x + w, y + h)
+           && contains(x + w, y));
+  }
+
+  /**
+   * Return a new path iterator which iterates over this rectangle.
+   *
+   * @param at An affine transform to apply to the object
+   */
+  public PathIterator getPathIterator(final AffineTransform at)
+  {
+    double arcW = Math.min(getArcWidth(), getWidth());
+    double arcH = Math.min(getArcHeight(), getHeight());
+
+    // check for special cases...
+    if (arcW <= 0 || arcH <= 0)
+      {
+        Rectangle2D r = new Rectangle2D.Double(getX(), getY(), getWidth(),
+                getHeight());
+        return r.getPathIterator(at);
+      }
+    else if (arcW >= getWidth() && arcH >= getHeight())
+      {
+        Ellipse2D e = new Ellipse2D.Double(getX(), getY(), getWidth(),
+                getHeight());
+        return e.getPathIterator(at);
+      }
+
+    // otherwise return the standard case...
+    return new PathIterator()
+      {
+        double x = getX();
+        double y = getY();
+        double w = getWidth();
+        double h = getHeight();
+        double arcW = Math.min(getArcWidth(), w);
+        double arcH = Math.min(getArcHeight(), h);
+        Arc2D.Double arc = new Arc2D.Double();
+        PathIterator corner;
+        int step = -1;
+
+        public int currentSegment(double[] coords)
+        {
+          if (corner != null) // steps 1, 3, 5 and 7
+          {
+            int r = corner.currentSegment(coords);
+            if (r == SEG_MOVETO)
+              r = SEG_LINETO;
+            return r;
+          }
+          if (step == -1)
+          {
+            // move to the start position
+            coords[0] = x + w - arcW / 2;
+            coords[1] = y;
+          }
+          else if (step == 0)
+          {
+            // top line
+            coords[0] = x + arcW / 2;
+            coords[1] = y;
+          }
+          else if (step == 2)
+          {
+            // left line
+            coords[0] = x;
+            coords[1] = y + h - arcH / 2;
+          }
+          else if (step == 4)
+          {
+            // bottom line
+            coords[0] = x + w - arcW / 2;
+            coords[1] = y + h;
+          }
+          else if (step == 6)
+          {
+            // right line
+              coords[0] = x + w;
+              coords[1] = y + arcH / 2;
+          }
+          if (at != null)
+            at.transform(coords, 0, coords, 0, 1);
+          return step == -1 ? SEG_MOVETO : SEG_LINETO;
+        }
+
+        public int currentSegment(float[] coords) {
+          if (corner != null) // steps 1, 3, 5 and 7
+          {
+            int r = corner.currentSegment(coords);
+            if (r == SEG_MOVETO)
+              r = SEG_LINETO;
+            return r;
+          }
+          if (step == -1)
+          {
+            // move to the start position
+            coords[0] = (float) (x + w - arcW / 2);
+            coords[1] = (float) y;
+          }
+          else if (step == 0)
+          {
+            // top line
+            coords[0] = (float) (x + arcW / 2);
+            coords[1] = (float) y;
+          }
+          else if (step == 2)
+          {
+            // left line
+            coords[0] = (float) x;
+            coords[1] = (float) (y + h - arcH / 2);
+          }
+          else if (step == 4)
+          {
+            // bottom line
+            coords[0] = (float) (x + w - arcW / 2);
+            coords[1] = (float) (y + h);
+          }
+          else if (step == 6)
+          {
+            // right line
+            coords[0] = (float) (x + w);
+            coords[1] = (float) (y + arcH / 2);
+          }
+        if (at != null)
+          at.transform(coords, 0, coords, 0, 1);
+        return step == -1 ? SEG_MOVETO : SEG_LINETO;
+      }
+
+      public int getWindingRule() {
+        return WIND_NON_ZERO;
+      }
+
+      public boolean isDone() {
+        return step >= 8;
+      }
+
+      public void next()
+      {
+        if (corner != null)
+          {
+            corner.next();
+            if (corner.isDone())
+              {
+                corner = null;
+                step++;
+              }
+          }
+        else
+          {
+            step++;
+            if (step == 1)
+              {
+                // create top left corner
+                arc.setArc(x, y, arcW, arcH, 90, 90, Arc2D.OPEN);
+                corner = arc.getPathIterator(at);
+              }
+            else if (step == 3)
+              {
+                // create bottom left corner
+                arc.setArc(x, y + h - arcH, arcW, arcH, 180, 90,
+                        Arc2D.OPEN);
+                corner = arc.getPathIterator(at);
+              }
+            else if (step == 5)
+              {
+                // create bottom right corner
+                arc.setArc(x + w - arcW, y + h - arcH, arcW, arcH, 270, 90,
+                        Arc2D.OPEN);
+                corner = arc.getPathIterator(at);
+              }
+            else if (step == 7)
+              {
+                // create top right corner
+                arc.setArc(x + w - arcW, y, arcW, arcH, 0, 90, Arc2D.OPEN);
+                corner = arc.getPathIterator(at);
+              }
+          }
+      }
+    };
+  }
+
+  /**
+   * Return true if the given rectangle intersects this shape.
+   * @param x The x coordinate
+   * @param y The y coordinate
+   * @param w The width
+   * @param h The height
+   */
+  public boolean intersects(double x, double y, double w, double h)
+  {
+    // Check if any corner is within the rectangle
+    return (contains(x, y) || contains(x, y + h) || contains(x + w, y + h)
+           || contains(x + w, y));
+  }
+
+  /**
+   * Set the boundary of this round rectangle.
+   * @param x The x coordinate
+   * @param y The y coordinate
+   * @param w The width
+   * @param h The height
+   */
+  public void setFrame(double x, double y, double w, double h)
+  {
+    // This is a bit lame.
+    setRoundRect(x, y, w, h, getArcWidth(), getArcHeight());
+  }
+
+  /**
+   * Set the values of this round rectangle to be the same as those
+   * of the argument.
+   * @param rr The round rectangle to copy
+   */
+  public void setRoundRect(RoundRectangle2D rr)
+  {
+    setRoundRect(rr.getX(), rr.getY(), rr.getWidth(), rr.getHeight(),
+                 rr.getArcWidth(), rr.getArcHeight());
+  }
+
+  /**
+   * A subclass of RoundRectangle which keeps its parameters as
+   * doubles.
+   */
+  public static class Double extends RoundRectangle2D
+  {
+    /** The height of the corner arc.  */
+    public double archeight;
+
+    /** The width of the corner arc.  */
+    public double arcwidth;
+
+    /** The x coordinate of this object.  */
+    public double x;
+
+    /** The y coordinate of this object.  */
+    public double y;
+
+    /** The width of this object.  */
+    public double width;
+
+    /** The height of this object.  */
+    public double height;
+
+    /**
+     * Construct a new instance, with all parameters set to 0.
+     */
+    public Double()
+    {
+    }
+
+    /**
+     * Construct a new instance with the given arguments.
+     * @param x The x coordinate
+     * @param y The y coordinate
+     * @param w The width
+     * @param h The height
+     * @param arcWidth The arc width
+     * @param arcHeight The arc height
+     */
+    public Double(double x, double y, double w, double h, double arcWidth,
+                  double arcHeight)
+    {
+      this.x = x;
+      this.y = y;
+      this.width = w;
+      this.height = h;
+      this.arcwidth = arcWidth;
+      this.archeight = arcHeight;
+    }
+
+    public double getArcHeight()
+    {
+      return archeight;
+    }
+
+    public double getArcWidth()
+    {
+      return arcwidth;
+    }
+
+    public Rectangle2D getBounds2D()
+    {
+      return new Rectangle2D.Double(x, y, width, height);
+    }
+
+    public double getX()
+    {
+      return x;
+    }
+
+    public double getY()
+    {
+      return y;
+    }
+
+    public double getWidth()
+    {
+      return width;
+    }
+
+    public double getHeight()
+    {
+      return height;
+    }
+
+    public boolean isEmpty()
+    {
+      return width <= 0 || height <= 0;
+    }
+
+    public void setRoundRect(double x, double y, double w, double h,
+                             double arcWidth, double arcHeight)
+    {
+      this.x = x;
+      this.y = y;
+      this.width = w;
+      this.height = h;
+      this.arcwidth = arcWidth;
+      this.archeight = arcHeight;
+    }
+  } // class Double
+
+  /**
+   * A subclass of RoundRectangle which keeps its parameters as
+   * floats.
+   */
+  public static class Float extends RoundRectangle2D
+  {
+    /** The height of the corner arc.  */
+    public float archeight;
+
+    /** The width of the corner arc.  */
+    public float arcwidth;
+
+    /** The x coordinate of this object.  */
+    public float x;
+
+    /** The y coordinate of this object.  */
+    public float y;
+
+    /** The width of this object.  */
+    public float width;
+
+    /** The height of this object.  */
+    public float height;
+
+    /**
+     * Construct a new instance, with all parameters set to 0.
+     */
+    public Float()
+    {
+    }
+
+    /**
+     * Construct a new instance with the given arguments.
+     * @param x The x coordinate
+     * @param y The y coordinate
+     * @param w The width
+     * @param h The height
+     * @param arcWidth The arc width
+     * @param arcHeight The arc height
+     */
+    public Float(float x, float y, float w, float h, float arcWidth,
+                 float arcHeight)
+    {
+      this.x = x;
+      this.y = y;
+      this.width = w;
+      this.height = h;
+      this.arcwidth = arcWidth;
+      this.archeight = arcHeight;
+    }
+
+    public double getArcHeight()
+    {
+      return archeight;
+    }
+
+    public double getArcWidth()
+    {
+      return arcwidth;
+    }
+
+    public Rectangle2D getBounds2D()
+    {
+      return new Rectangle2D.Float(x, y, width, height);
+    }
+
+    public double getX()
+    {
+      return x;
+    }
+
+    public double getY()
+    {
+      return y;
+    }
+
+    public double getWidth()
+    {
+      return width;
+    }
+
+    public double getHeight()
+    {
+      return height;
+    }
+
+    public boolean isEmpty()
+    {
+      return width <= 0 || height <= 0;
+    }
+
+    /**
+     * Sets the dimensions for this rounded rectangle.
+     *
+     * @param x  the x-coordinate of the top left corner.
+     * @param y  the y-coordinate of the top left corner.
+     * @param w  the width of the rectangle.
+     * @param h  the height of the rectangle.
+     * @param arcWidth  the arc width.
+     * @param arcHeight  the arc height.
+     *
+     * @see #setRoundRect(double, double, double, double, double, double)
+     */
+    public void setRoundRect(float x, float y, float w, float h,
+                             float arcWidth, float arcHeight)
+    {
+      this.x = x;
+      this.y = y;
+      this.width = w;
+      this.height = h;
+      this.arcwidth = arcWidth;
+      this.archeight = arcHeight;
+    }
+
+    public void setRoundRect(double x, double y, double w, double h,
+                             double arcWidth, double arcHeight)
+    {
+      this.x = (float) x;
+      this.y = (float) y;
+      this.width = (float) w;
+      this.height = (float) h;
+      this.arcwidth = (float) arcWidth;
+      this.archeight = (float) arcHeight;
+    }
+  } // class Float
+} // class RoundRectangle2D