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

diff --git a/libjava/classpath/javax/swing/SpinnerNumberModel.java b/libjava/classpath/javax/swing/SpinnerNumberModel.java
new file mode 100644
index 000000000..af3fea65f
--- /dev/null
+++ b/libjava/classpath/javax/swing/SpinnerNumberModel.java
@@ -0,0 +1,361 @@
+/* SpinnerNumberModel.java --
+   Copyright (C) 2002, 2004, 2006 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 javax.swing;
+
+import java.io.Serializable;
+
+import javax.swing.event.ChangeEvent;
+
+/**
+ * A model used by the {@link JSpinner} component.
+ *
+ * @author Ka-Hing Cheung
+ * @since 1.4
+ */
+public class SpinnerNumberModel extends AbstractSpinnerModel
+  implements Serializable
+{
+  /**
+   * For compatability with Sun's JDK
+   */
+  private static final long serialVersionUID = 7279176385485777821L;
+
+  /** The current value. */
+  private Number value;
+
+  /** The minimum value (or <code>null</code>). */
+  private Comparable minimum;
+
+  /** The maximum value (or <code>null</code>). */
+  private Comparable maximum;
+
+  /** The step size. */
+  private Number stepSize;
+
+  /**
+   * Creates a <code>SpinnerNumberModel</code> with initial value 0, step 1,
+   * and no maximum nor minimum.
+   */
+  public SpinnerNumberModel()
+  {
+    this(new Integer(0), null, null, new Integer(1));
+  }
+
+  /**
+   * Creates a <code>SpinnerNumberModel</code> with double precision.
+   *
+   * @param value the initial value
+   * @param minimum the minimum value
+   * @param maximum the maximum value
+   * @param stepSize the step size
+   * @throws IllegalArgumentException if minimum &lt;= value &lt;= maximum does
+   *         not hold.
+   */
+  public SpinnerNumberModel(double value, double minimum, double maximum,
+                            double stepSize)
+  {
+    this(new Double(value), new Double(minimum), new Double(maximum),
+         new Double(stepSize));
+  }
+
+  /**
+   * Creates a <code>SpinnerNumberModel</code> with integer precision.
+   *
+   * @param value the initial value
+   * @param minimum the minimum value
+   * @param maximum the maximum value
+   * @param stepSize the step size
+   * @throws IllegalArgumentException if minimum &lt;= value &lt;= maximum does
+   *         not hold.
+   */
+  public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize)
+  {
+    this(new Integer(value), new Integer(minimum), new Integer(maximum),
+         new Integer(stepSize));
+  }
+
+  /**
+   * Creates a <code>SpinnerNumberModel</code> with the given attributes.  The
+   * caller should ensure that both <code>minimum</code> and
+   * <code>maximum</code> are serializable.
+   *
+   * @param value the initial value (<code>null</code> not permitted).
+   * @param minimum the minimum value (<code>null</code> permitted).
+   * @param maximum the maximum value (<code>null</code> permitted).
+   * @param stepSize the step size  (<code>null</code> not permitted).
+   *
+   * @throws IllegalArgumentException if minimum &lt;= value &lt;= maximum
+   *         does not hold
+   * @throws IllegalArgumentException if <code>value</code> is
+   *         <code>null</code>.
+   * @throws IllegalArgumentException if <code>stepSize</code> is
+   *         <code>null</code>.
+   */
+  public SpinnerNumberModel(Number value, Comparable minimum,
+                            Comparable maximum, Number stepSize)
+  {
+    if (stepSize == null)
+      throw new IllegalArgumentException("stepSize may not be null");
+    if (value == null)
+      throw new IllegalArgumentException("value may not be null");
+    if (minimum != null)
+      {
+        if (minimum.compareTo(value) > 0)
+          throw new IllegalArgumentException("minimum is not <= value");
+      }
+    if (maximum != null)
+      {
+        if (maximum.compareTo(value) < 0)
+          throw new IllegalArgumentException("maximum is not >= value");
+      }
+
+    this.value = value;
+    this.stepSize = stepSize;
+    this.minimum = minimum;
+    this.maximum = maximum;
+  }
+
+  /**
+   * Sets the current value and, if the new value is different to the old
+   * value, sends a {@link ChangeEvent} to all registered listeners.
+   *
+   * @param value the new value (<code>null</code> not permitted, must be an
+   *              instance of <code>Number</code>).
+   *
+   * @throws IllegalArgumentException if <code>value</code> is not an instance
+   *         of <code>Number</code>.
+   */
+  public void setValue(Object value)
+  {
+    if (! (value instanceof Number))
+      throw new IllegalArgumentException("value must be a Number");
+
+    if (!this.value.equals(value))
+      {
+        this.value = (Number) value;
+        fireStateChanged();
+      }
+  }
+
+  /**
+   * Returns the current value, which for this class is always an instance of
+   * {@link Number}.
+   *
+   * @return The current value.
+   *
+   * @see #getNumber()
+   */
+  public Object getValue()
+  {
+    return value;
+  }
+
+  /**
+   * Returns the next value, or <code>null</code> if adding the step size to
+   * the current value results in a value greater than the maximum value.
+   * The current value is not changed.
+   *
+   * @return The next value, or <code>null</code> if the current value is the
+   *         maximum value represented by this model.
+   */
+  public Object getNextValue()
+  {
+    Number num;
+
+    if (value instanceof Double)
+      num = new Double(value.doubleValue() + stepSize.doubleValue());
+    else if (value instanceof Float)
+      num = new Double(value.floatValue() + stepSize.floatValue());
+    else if (value instanceof Long)
+      num = new Long(value.longValue() + stepSize.longValue());
+    else if (value instanceof Integer)
+      num = new Integer(value.intValue() + stepSize.intValue());
+    else if (value instanceof Short)
+      num = new Short((short) (value.shortValue() + stepSize.shortValue()));
+    else
+      num = new Byte((byte) (value.byteValue() + stepSize.byteValue()));
+
+    // check upper bound if set
+    if ((maximum != null) && maximum.compareTo(num) < 0)
+      num = null;
+
+    return num;
+  }
+
+  /**
+   * Returns the previous value, or <code>null</code> if subtracting the
+   * step size from the current value results in a value less than the minimum
+   * value.  The current value is not changed.
+   *
+   * @return The previous value, or <code>null</code> if the current value
+   *         is the minimum value represented by this model.
+   */
+  public Object getPreviousValue()
+  {
+    Number num;
+
+    if (value instanceof Double)
+      num = new Double(value.doubleValue() - stepSize.doubleValue());
+    else if (value instanceof Float)
+      num = new Double(value.floatValue() - stepSize.floatValue());
+    else if (value instanceof Long)
+      num = new Long(value.longValue() - stepSize.longValue());
+    else if (value instanceof Integer)
+      num = new Integer(value.intValue() - stepSize.intValue());
+    else if (value instanceof Short)
+      num = new Short((short) (value.shortValue() - stepSize.shortValue()));
+    else
+      num = new Byte((byte) (value.byteValue() - stepSize.byteValue()));
+
+    // check lower bound if set
+    if ((minimum != null) && minimum.compareTo(num) > 0)
+      num = null;
+
+    return num;
+  }
+
+  /**
+   * Returns the current value.
+   *
+   * @return The current value.
+   */
+  public Number getNumber()
+  {
+    return value;
+  }
+
+  /**
+   * Returns the minimum value, or <code>null</code> if there is no minimum.
+   *
+   * @return The minimum value.
+   *
+   * @see #setMinimum(Comparable)
+   */
+  public Comparable getMinimum()
+  {
+    return minimum;
+  }
+
+  /**
+   * Sets the minimum value and, if the new value is different to the old
+   * value, sends a {@link ChangeEvent} to all registered listeners.  A
+   * <code>null</code> value is interpreted as "no minimum value".  No check
+   * is made to ensure that the new minimum is less than or equal to the
+   * current value, the caller is responsible for ensuring that this
+   * relationship holds.  In addition, the caller should ensure that
+   * <code>newMinimum</code> is {@link Serializable}.
+   *
+   * @param newMinimum  the new minimum value (<code>null</code> permitted).
+   *
+   * @see #getMinimum()
+   */
+  public void setMinimum(Comparable newMinimum)
+  {
+    if (minimum != null ? !minimum.equals(newMinimum) : newMinimum != null)
+      {
+        minimum = newMinimum;
+        fireStateChanged();
+      }
+  }
+
+  /**
+   * Returns the maximum value, or <code>null</code> if there is no maximum.
+   *
+   * @return The maximum value.
+   *
+   * @see #getMinimum()
+   * @see #setMaximum(Comparable)
+   */
+  public Comparable getMaximum()
+  {
+    return maximum;
+  }
+
+  /**
+   * Sets the maximum value and, if the new value is different to the old
+   * value, sends a {@link ChangeEvent} to all registered listeners.  A
+   * <code>null</code> value is interpreted as "no maximum value".  No check
+   * is made to ensure that the new maximum is greater than or equal to the
+   * current value, the caller is responsible for ensuring that this
+   * relationship holds. In addition, the caller should ensure that
+   * <code>newMaximum</code> is {@link Serializable}.
+   *
+   * @param newMaximum  the new maximum (<code>null</code> permitted).
+   *
+   * @see #getMaximum()
+   */
+  public void setMaximum(Comparable newMaximum)
+  {
+    if (maximum != null ? !maximum.equals(newMaximum) : newMaximum != null)
+      {
+        maximum = newMaximum;
+        fireStateChanged();
+      }
+  }
+
+  /**
+   * Returns the step size.
+   *
+   * @return The step size (never <code>null</code>).
+   */
+  public Number getStepSize()
+  {
+    return stepSize;
+  }
+
+  /**
+   * Sets the step size and, if the new step size is different to the old
+   * step size, sends a {@link ChangeEvent} to all registered listeners.
+   *
+   * @param newStepSize  the new step size (<code>null</code> not permitted).
+   *
+   * @throws IllegalArgumentException if <code>newStepSize</code> is
+   *         <code>null</code>.
+   */
+  public void setStepSize(Number newStepSize)
+  {
+    if (newStepSize == null)
+      throw new IllegalArgumentException();
+
+    if (!stepSize.equals(newStepSize))
+      {
+        stepSize = newStepSize;
+        fireStateChanged();
+      }
+  }
+}