libjava/java/lang/reflect/Field.java

   1 /* java.lang.reflect.Field - reflection of Java fields
   2    Copyright (C) 1998, 2001, 2005, 2006 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.lang.reflect;
  40
  41 import gnu.java.lang.ClassHelper;
  42
  43 import gnu.java.lang.reflect.FieldSignatureParser;
  44
  45 /**
  46  * The Field class represents a member variable of a class. It also allows
  47  * dynamic access to a member, via reflection. This works for both
  48  * static and instance fields. Operations on Field objects know how to
  49  * do widening conversions, but throw {@link IllegalArgumentException} if
  50  * a narrowing conversion would be necessary. You can query for information
  51  * on this Field regardless of location, but get and set access may be limited
  52  * by Java language access controls. If you can't do it in the compiler, you
  53  * can't normally do it here either.<p>
  54  *
  55  * <B>Note:</B> This class returns and accepts types as Classes, even
  56  * primitive types; there are Class types defined that represent each
  57  * different primitive type.  They are <code>java.lang.Boolean.TYPE,
  58  * java.lang.Byte.TYPE,</code>, also available as <code>boolean.class,
  59  * byte.class</code>, etc.  These are not to be confused with the
  60  * classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are
  61  * real classes.<p>
  62  *
  63  * Also note that this is not a serializable class.  It is entirely feasible
  64  * to make it serializable using the Externalizable interface, but this is
  65  * on Sun, not me.
  66  *
  67  * @author John Keiser
  68  * @author Eric Blake <ebb9@email.byu.edu>
  69  * @author Per Bothner <bothner@cygnus.com>
  70  * @see Member
  71  * @see Class
  72  * @see Class#getField(String)
  73  * @see Class#getDeclaredField(String)
  74  * @see Class#getFields()
  75  * @see Class#getDeclaredFields()
  76  * @since 1.1
  77  * @status updated to 1.4
  78  */
  79 public final class Field
  80   extends AccessibleObject implements Member
  81 {
  82   private Class declaringClass;
  83   private String name;
  84
  85   // Offset in bytes from the start of declaringClass's fields array.
  86   private int offset;
  87
  88   // The Class (or primitive TYPE) of this field.
  89   private Class type;
  90
  91   private static final int FIELD_MODIFIERS
  92     = Modifier.FINAL | Modifier.PRIVATE | Modifier.PROTECTED
  93       | Modifier.PUBLIC | Modifier.STATIC | Modifier.TRANSIENT
  94       | Modifier.VOLATILE;
  95
  96   // This is instantiated by Class sometimes, but it uses C++ and
  97   // avoids the Java protection check.
  98   Field ()
  99   {
 100   }
 101
 102   /**
 103    * Gets the class that declared this field, or the class where this field
 104    * is a non-inherited member.
 105    * @return the class that declared this member
 106    */
 107   public Class getDeclaringClass()
 108   {
 109     return declaringClass;
 110   }
 111
 112   /**
 113    * Gets the name of this field.
 114    * @return the name of this field
 115    */
 116   public native String getName();
 117
 118   /**
 119    * Return the raw modifiers for this field.
 120    * @return the field's modifiers
 121    */
 122   private native int getModifiersInternal();
 123
 124   /**
 125    * Gets the modifiers this field uses.  Use the <code>Modifier</code>
 126    * class to interpret the values.  A field can only have a subset of the
 127    * following modifiers: public, private, protected, static, final,
 128    * transient, and volatile.
 129    *
 130    * @return an integer representing the modifiers to this Member
 131    * @see Modifier
 132    */
 133   public int getModifiers()
 134   {
 135     return getModifiersInternal() & FIELD_MODIFIERS;
 136   }
 137
 138   /**
 139    * Return true if this field is synthetic, false otherwise.
 140    * @since 1.5
 141    */
 142   public boolean isSynthetic()
 143   {
 144     return (getModifiersInternal() & Modifier.SYNTHETIC) != 0;
 145   }
 146
 147   /**
 148    * Return true if this field represents an enum constant,
 149    * false otherwise.
 150    * @since 1.5
 151    */
 152   public boolean isEnumConstant()
 153   {
 154     return (getModifiersInternal() & Modifier.ENUM) != 0;
 155   }
 156
 157   /**
 158    * Gets the type of this field.
 159    * @return the type of this field
 160    */
 161   public native Class getType();
 162
 163   /**
 164    * Compare two objects to see if they are semantically equivalent.
 165    * Two Fields are semantically equivalent if they have the same declaring
 166    * class, name, and type. Since you can't creat a Field except through
 167    * the VM, this is just the == relation.
 168    *
 169    * @param o the object to compare to
 170    * @return <code>true</code> if they are equal; <code>false</code> if not
 171    */
 172   public boolean equals (Object fld)
 173   {
 174     if (! (fld instanceof Field))
 175       return false;
 176     Field f = (Field) fld;
 177     return declaringClass == f.declaringClass && offset == f.offset;
 178   }
 179
 180   /**
 181    * Get the hash code for the Field. The Field hash code is the hash code
 182    * of its name XOR'd with the hash code of its class name.
 183    *
 184    * @return the hash code for the object.
 185    */
 186   public int hashCode()
 187   {
 188     return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
 189   }
 190
 191   /**
 192    * Get a String representation of the Field. A Field's String
 193    * representation is "&lt;modifiers&gt; &lt;type&gt;
 194    * &lt;class&gt;.&lt;fieldname&gt;".<br> Example:
 195    * <code>public transient boolean gnu.parse.Parser.parseComplete</code>
 196    *
 197    * @return the String representation of the Field
 198    */
 199   public String toString ()
 200   {
 201     StringBuffer sbuf = new StringBuffer ();
 202     int mods = getModifiers();
 203     if (mods != 0)
 204       {
 205         Modifier.toString(mods, sbuf);
 206         sbuf.append(' ');
 207       }
 208     Method.appendClassName (sbuf, getType ());
 209     sbuf.append(' ');
 210     Method.appendClassName (sbuf, getDeclaringClass());
 211     sbuf.append('.');
 212     sbuf.append(getName());
 213     return sbuf.toString();
 214   }
 215
 216   public String toGenericString()
 217   {
 218     StringBuilder sb = new StringBuilder(64);
 219     Modifier.toString(getModifiers(), sb).append(' ');
 220     sb.append(getGenericType()).append(' ');
 221     sb.append(getDeclaringClass().getName()).append('.');
 222     sb.append(getName());
 223     return sb.toString();
 224   }
 225
 226   /**
 227    * Get the value of this Field.  If it is primitive, it will be wrapped
 228    * in the appropriate wrapper type (boolean = java.lang.Boolean).<p>
 229    *
 230    * If the field is static, <code>o</code> will be ignored. Otherwise, if
 231    * <code>o</code> is null, you get a <code>NullPointerException</code>,
 232    * and if it is incompatible with the declaring class of the field, you
 233    * get an <code>IllegalArgumentException</code>.<p>
 234    *
 235    * Next, if this Field enforces access control, your runtime context is
 236    * evaluated, and you may have an <code>IllegalAccessException</code> if
 237    * you could not access this field in similar compiled code. If the field
 238    * is static, and its class is uninitialized, you trigger class
 239    * initialization, which may end in a
 240    * <code>ExceptionInInitializerError</code>.<p>
 241    *
 242    * Finally, the field is accessed, and primitives are wrapped (but not
 243    * necessarily in new objects). This method accesses the field of the
 244    * declaring class, even if the instance passed in belongs to a subclass
 245    * which declares another field to hide this one.
 246    *
 247    * @param o the object to get the value of this Field from
 248    * @return the value of the Field
 249    * @throws IllegalAccessException if you could not normally access this field
 250    *         (i.e. it is not public)
 251    * @throws IllegalArgumentException if <code>o</code> is not an instance of
 252    *         the class or interface declaring this field
 253    * @throws NullPointerException if <code>o</code> is null and this field
 254    *         requires an instance
 255    * @throws ExceptionInInitializerError if accessing a static field triggered
 256    *         class initialization, which then failed
 257    * @see #getBoolean(Object)
 258    * @see #getByte(Object)
 259    * @see #getChar(Object)
 260    * @see #getShort(Object)
 261    * @see #getInt(Object)
 262    * @see #getLong(Object)
 263    * @see #getFloat(Object)
 264    * @see #getDouble(Object)
 265    */
 266   public Object get(Object obj)
 267     throws IllegalAccessException
 268   {
 269     return get(null, obj);
 270   }
 271
 272   /**
 273    * Get the value of this boolean Field. If the field is static,
 274    * <code>o</code> will be ignored.
 275    *
 276    * @param o the object to get the value of this Field from
 277    * @return the value of the Field
 278    * @throws IllegalAccessException if you could not normally access this field
 279    *         (i.e. it is not public)
 280    * @throws IllegalArgumentException if this is not a boolean field of
 281    *         <code>o</code>, or if <code>o</code> is not an instance of the
 282    *         declaring class of this field
 283    * @throws NullPointerException if <code>o</code> is null and this field
 284    *         requires an instance
 285    * @throws ExceptionInInitializerError if accessing a static field triggered
 286    *         class initialization, which then failed
 287    * @see #get(Object)
 288    */
 289   public boolean getBoolean(Object obj)
 290     throws IllegalAccessException
 291   {
 292     return getBoolean(null, obj);
 293   }
 294
 295   /**
 296    * Get the value of this byte Field. If the field is static,
 297    * <code>o</code> will be ignored.
 298    *
 299    * @param o the object to get the value of this Field from
 300    * @return the value of the Field
 301    * @throws IllegalAccessException if you could not normally access this field
 302    *         (i.e. it is not public)
 303    * @throws IllegalArgumentException if this is not a byte field of
 304    *         <code>o</code>, or if <code>o</code> is not an instance of the
 305    *         declaring class of this field
 306    * @throws NullPointerException if <code>o</code> is null and this field
 307    *         requires an instance
 308    * @throws ExceptionInInitializerError if accessing a static field triggered
 309    *         class initialization, which then failed
 310    * @see #get(Object)
 311    */
 312   public byte getByte(Object obj)
 313     throws IllegalAccessException
 314   {
 315     return getByte(null, obj);
 316   }
 317
 318   /**
 319    * Get the value of this Field as a char. If the field is static,
 320    * <code>o</code> will be ignored.
 321    *
 322    * @throws IllegalAccessException if you could not normally access this field
 323    *         (i.e. it is not public)
 324    * @throws IllegalArgumentException if this is not a char field of
 325    *         <code>o</code>, or if <code>o</code> is not an instance
 326    *         of the declaring class of this field
 327    * @throws NullPointerException if <code>o</code> is null and this field
 328    *         requires an instance
 329    * @throws ExceptionInInitializerError if accessing a static field triggered
 330    *         class initialization, which then failed
 331    * @see #get(Object)
 332    */
 333   public char getChar(Object obj)
 334     throws IllegalAccessException
 335   {
 336     return getChar(null, obj);
 337   }
 338
 339   /**
 340    * Get the value of this Field as a short. If the field is static,
 341    * <code>o</code> will be ignored.
 342    *
 343    * @param o the object to get the value of this Field from
 344    * @return the value of the Field
 345    * @throws IllegalAccessException if you could not normally access this field
 346    *         (i.e. it is not public)
 347    * @throws IllegalArgumentException if this is not a byte or short
 348    *         field of <code>o</code>, or if <code>o</code> is not an instance
 349    *         of the declaring class of this field
 350    * @throws NullPointerException if <code>o</code> is null and this field
 351    *         requires an instance
 352    * @throws ExceptionInInitializerError if accessing a static field triggered
 353    *         class initialization, which then failed
 354    * @see #get(Object)
 355    */
 356   public short getShort(Object obj)
 357     throws IllegalAccessException
 358   {
 359     return getShort(null, obj);
 360   }
 361
 362   /**
 363    * Get the value of this Field as an int. If the field is static,
 364    * <code>o</code> will be ignored.
 365    *
 366    * @param o the object to get the value of this Field from
 367    * @return the value of the Field
 368    * @throws IllegalAccessException if you could not normally access this field
 369    *         (i.e. it is not public)
 370    * @throws IllegalArgumentException if this is not a byte, short, char, or
 371    *         int field of <code>o</code>, or if <code>o</code> is not an
 372    *         instance of the declaring class of this field
 373    * @throws NullPointerException if <code>o</code> is null and this field
 374    *         requires an instance
 375    * @throws ExceptionInInitializerError if accessing a static field triggered
 376    *         class initialization, which then failed
 377    * @see #get(Object)
 378    */
 379   public int getInt(Object obj)
 380     throws IllegalAccessException
 381   {
 382     return getInt(null, obj);
 383   }
 384
 385   /**
 386    * Get the value of this Field as a long. If the field is static,
 387    * <code>o</code> will be ignored.
 388    *
 389    * @param o the object to get the value of this Field from
 390    * @return the value of the Field
 391    * @throws IllegalAccessException if you could not normally access this field
 392    *         (i.e. it is not public)
 393    * @throws IllegalArgumentException if this is not a byte, short, char, int,
 394    *         or long field of <code>o</code>, or if <code>o</code> is not an
 395    *         instance of the declaring class of this field
 396    * @throws NullPointerException if <code>o</code> is null and this field
 397    *         requires an instance
 398    * @throws ExceptionInInitializerError if accessing a static field triggered
 399    *         class initialization, which then failed
 400    * @see #get(Object)
 401    */
 402   public long getLong(Object obj)
 403     throws IllegalAccessException
 404   {
 405     return getLong(null, obj);
 406   }
 407
 408   /**
 409    * Get the value of this Field as a float. If the field is static,
 410    * <code>o</code> will be ignored.
 411    *
 412    * @param o the object to get the value of this Field from
 413    * @return the value of the Field
 414    * @throws IllegalAccessException if you could not normally access this field
 415    *         (i.e. it is not public)
 416    * @throws IllegalArgumentException if this is not a byte, short, char, int,
 417    *         long, or float field of <code>o</code>, or if <code>o</code> is
 418    *         not an instance of the declaring class of this field
 419    * @throws NullPointerException if <code>o</code> is null and this field
 420    *         requires an instance
 421    * @throws ExceptionInInitializerError if accessing a static field triggered
 422    *         class initialization, which then failed
 423    * @see #get(Object)
 424    */
 425   public float getFloat(Object obj)
 426     throws IllegalAccessException
 427   {
 428     return getFloat(null, obj);
 429   }
 430
 431   /**
 432    * Get the value of this Field as a double. If the field is static,
 433    * <code>o</code> will be ignored.
 434    *
 435    * @param o the object to get the value of this Field from
 436    * @return the value of the Field
 437    * @throws IllegalAccessException if you could not normally access this field
 438    *         (i.e. it is not public)
 439    * @throws IllegalArgumentException if this is not a byte, short, char, int,
 440    *         long, float, or double field of <code>o</code>, or if
 441    *         <code>o</code> is not an instance of the declaring class of this
 442    *         field
 443    * @throws NullPointerException if <code>o</code> is null and this field
 444    *         requires an instance
 445    * @throws ExceptionInInitializerError if accessing a static field triggered
 446    *         class initialization, which then failed
 447    * @see #get(Object)
 448    */
 449   public double getDouble(Object obj)
 450     throws IllegalAccessException
 451   {
 452     return getDouble(null, obj);
 453   }
 454
 455   private native boolean getBoolean (Class caller, Object obj)
 456     throws IllegalArgumentException, IllegalAccessException;
 457
 458   private native char getChar (Class caller, Object obj)
 459     throws IllegalArgumentException, IllegalAccessException;
 460
 461   private native byte getByte (Class caller, Object obj)
 462     throws IllegalArgumentException, IllegalAccessException;
 463
 464   private native short getShort (Class caller, Object obj)
 465     throws IllegalArgumentException, IllegalAccessException;
 466
 467   private native int getInt (Class caller, Object obj)
 468     throws IllegalArgumentException, IllegalAccessException;
 469
 470   private native long getLong (Class caller, Object obj)
 471     throws IllegalArgumentException, IllegalAccessException;
 472
 473   private native float getFloat (Class caller, Object obj)
 474     throws IllegalArgumentException, IllegalAccessException;
 475
 476   private native double getDouble (Class caller, Object obj)
 477     throws IllegalArgumentException, IllegalAccessException;
 478
 479   private native Object get (Class caller, Object obj)
 480     throws IllegalArgumentException, IllegalAccessException;
 481
 482   /**
 483    * Set the value of this Field.  If it is a primitive field, the value
 484    * will be unwrapped from the passed object (boolean = java.lang.Boolean).<p>
 485    *
 486    * If the field is static, <code>o</code> will be ignored. Otherwise, if
 487    * <code>o</code> is null, you get a <code>NullPointerException</code>,
 488    * and if it is incompatible with the declaring class of the field, you
 489    * get an <code>IllegalArgumentException</code>.<p>
 490    *
 491    * Next, if this Field enforces access control, your runtime context is
 492    * evaluated, and you may have an <code>IllegalAccessException</code> if
 493    * you could not access this field in similar compiled code. This also
 494    * occurs whether or not there is access control if the field is final.
 495    * If the field is primitive, and unwrapping your argument fails, you will
 496    * get an <code>IllegalArgumentException</code>; likewise, this error
 497    * happens if <code>value</code> cannot be cast to the correct object type.
 498    * If the field is static, and its class is uninitialized, you trigger class
 499    * initialization, which may end in a
 500    * <code>ExceptionInInitializerError</code>.<p>
 501    *
 502    * Finally, the field is set with the widened value. This method accesses
 503    * the field of the declaring class, even if the instance passed in belongs
 504    * to a subclass which declares another field to hide this one.
 505    *
 506    * @param o the object to set this Field on
 507    * @param value the value to set this Field to
 508    * @throws IllegalAccessException if you could not normally access this field
 509    *         (i.e. it is not public)
 510    * @throws IllegalArgumentException if <code>value</code> cannot be
 511    *         converted by a widening conversion to the underlying type of
 512    *         the Field, or if <code>o</code> is not an instance of the class
 513    *         declaring this field
 514    * @throws NullPointerException if <code>o</code> is null and this field
 515    *         requires an instance
 516    * @throws ExceptionInInitializerError if accessing a static field triggered
 517    *         class initialization, which then failed
 518    * @see #setBoolean(Object, boolean)
 519    * @see #setByte(Object, byte)
 520    * @see #setChar(Object, char)
 521    * @see #setShort(Object, short)
 522    * @see #setInt(Object, int)
 523    * @see #setLong(Object, long)
 524    * @see #setFloat(Object, float)
 525    * @see #setDouble(Object, double)
 526    */
 527   public void set(Object object, Object value)
 528     throws IllegalAccessException
 529   {
 530     set(null, object, value);
 531   }
 532
 533   /**
 534    * Set this boolean Field. If the field is static, <code>o</code> will be
 535    * ignored.
 536    *
 537    * @param o the object to set this Field on
 538    * @param value the value to set this Field to
 539    * @throws IllegalAccessException if you could not normally access this field
 540    *         (i.e. it is not public)
 541    * @throws IllegalArgumentException if this is not a boolean field, or if
 542    *         <code>o</code> is not an instance of the class declaring this
 543    *         field
 544    * @throws NullPointerException if <code>o</code> is null and this field
 545    *         requires an instance
 546    * @throws ExceptionInInitializerError if accessing a static field triggered
 547    *         class initialization, which then failed
 548    * @see #set(Object, Object)
 549    */
 550   public void setBoolean(Object obj, boolean b)
 551     throws IllegalAccessException
 552   {
 553     setBoolean(null, obj, b, true);
 554   }
 555
 556   /**
 557    * Set this byte Field. If the field is static, <code>o</code> will be
 558    * ignored.
 559    *
 560    * @param o the object to set this Field on
 561    * @param value the value to set this Field to
 562    * @throws IllegalAccessException if you could not normally access this field
 563    *         (i.e. it is not public)
 564    * @throws IllegalArgumentException if this is not a byte, short, int, long,
 565    *         float, or double field, or if <code>o</code> is not an instance
 566    *         of the class declaring this field
 567    * @throws NullPointerException if <code>o</code> is null and this field
 568    *         requires an instance
 569    * @throws ExceptionInInitializerError if accessing a static field triggered
 570    *         class initialization, which then failed
 571    * @see #set(Object, Object)
 572    */
 573   public void setByte(Object obj, byte b)
 574     throws IllegalAccessException
 575   {
 576     setByte(null, obj, b, true);
 577   }
 578
 579   /**
 580    * Set this char Field. If the field is static, <code>o</code> will be
 581    * ignored.
 582    *
 583    * @param o the object to set this Field on
 584    * @param value the value to set this Field to
 585    * @throws IllegalAccessException if you could not normally access this field
 586    *         (i.e. it is not public)
 587    * @throws IllegalArgumentException if this is not a char, int, long,
 588    *         float, or double field, or if <code>o</code> is not an instance
 589    *         of the class declaring this field
 590    * @throws NullPointerException if <code>o</code> is null and this field
 591    *         requires an instance
 592    * @throws ExceptionInInitializerError if accessing a static field triggered
 593    *         class initialization, which then failed
 594    * @see #set(Object, Object)
 595    */
 596   public void setChar(Object obj, char c)
 597     throws IllegalAccessException
 598   {
 599     setChar(null, obj, c, true);
 600   }
 601
 602   /**
 603    * Set this short Field. If the field is static, <code>o</code> will be
 604    * ignored.
 605    *
 606    * @param o the object to set this Field on
 607    * @param value the value to set this Field to
 608    * @throws IllegalAccessException if you could not normally access this field
 609    *         (i.e. it is not public)
 610    * @throws IllegalArgumentException if this is not a short, int, long,
 611    *         float, or double field, or if <code>o</code> is not an instance
 612    *         of the class declaring this field
 613    * @throws NullPointerException if <code>o</code> is null and this field
 614    *         requires an instance
 615    * @throws ExceptionInInitializerError if accessing a static field triggered
 616    *         class initialization, which then failed
 617    * @see #set(Object, Object)
 618    */
 619   public void setShort(Object obj,  short s)
 620     throws IllegalAccessException
 621   {
 622     setShort(null, obj, s, true);
 623   }
 624
 625   /**
 626    * Set this int Field. If the field is static, <code>o</code> will be
 627    * ignored.
 628    *
 629    * @param o the object to set this Field on
 630    * @param value the value to set this Field to
 631    * @throws IllegalAccessException if you could not normally access this field
 632    *         (i.e. it is not public)
 633    * @throws IllegalArgumentException if this is not an int, long, float, or
 634    *         double field, or if <code>o</code> is not an instance of the
 635    *         class declaring this field
 636    * @throws NullPointerException if <code>o</code> is null and this field
 637    *         requires an instance
 638    * @throws ExceptionInInitializerError if accessing a static field triggered
 639    *         class initialization, which then failed
 640    * @see #set(Object, Object)
 641    */
 642   public void setInt(Object obj, int i)
 643     throws IllegalAccessException
 644   {
 645     setInt(null, obj, i, true);
 646   }
 647
 648   /**
 649    * Set this long Field. If the field is static, <code>o</code> will be
 650    * ignored.
 651    *
 652    * @param o the object to set this Field on
 653    * @param value the value to set this Field to
 654    * @throws IllegalAccessException if you could not normally access this field
 655    *         (i.e. it is not public)
 656    * @throws IllegalArgumentException if this is not a long, float, or double
 657    *         field, or if <code>o</code> is not an instance of the class
 658    *         declaring this field
 659    * @throws NullPointerException if <code>o</code> is null and this field
 660    *         requires an instance
 661    * @throws ExceptionInInitializerError if accessing a static field triggered
 662    *         class initialization, which then failed
 663    * @see #set(Object, Object)
 664    */
 665   public void setLong(Object obj, long l)
 666     throws IllegalArgumentException, IllegalAccessException
 667   {
 668     setLong(null, obj, l, true);
 669   }
 670
 671   /**
 672    * Set this float Field. If the field is static, <code>o</code> will be
 673    * ignored.
 674    *
 675    * @param o the object to set this Field on
 676    * @param value the value to set this Field to
 677    * @throws IllegalAccessException if you could not normally access this field
 678    *         (i.e. it is not public)
 679    * @throws IllegalArgumentException if this is not a float or long field, or
 680    *         if <code>o</code> is not an instance of the class declaring this
 681    *         field
 682    * @throws NullPointerException if <code>o</code> is null and this field
 683    *         requires an instance
 684    * @throws ExceptionInInitializerError if accessing a static field triggered
 685    *         class initialization, which then failed
 686    * @see #set(Object, Object)
 687    */
 688   public void setFloat(Object obj, float f)
 689     throws IllegalAccessException
 690   {
 691     setFloat(null, obj, f, true);
 692   }
 693
 694   /**
 695    * Set this double Field. If the field is static, <code>o</code> will be
 696    * ignored.
 697    *
 698    * @param o the object to set this Field on
 699    * @param value the value to set this Field to
 700    * @throws IllegalAccessException if you could not normally access this field
 701    *         (i.e. it is not public)
 702    * @throws IllegalArgumentException if this is not a double field, or if
 703    *         <code>o</code> is not an instance of the class declaring this
 704    *         field
 705    * @throws NullPointerException if <code>o</code> is null and this field
 706    *         requires an instance
 707    * @throws ExceptionInInitializerError if accessing a static field triggered
 708    *         class initialization, which then failed
 709    * @see #set(Object, Object)
 710    */
 711   public void setDouble(Object obj, double d)
 712     throws IllegalAccessException
 713   {
 714     setDouble(null, obj, d, true);
 715   }
 716
 717   /**
 718    * Return the generic type of the field. If the field type is not a generic
 719    * type, the method returns the same as <code>getType()</code>.
 720    *
 721    * @throws GenericSignatureFormatError if the generic signature does
 722    *         not conform to the format specified in the Virtual Machine
 723    *         specification, version 3.
 724    * @since 1.5
 725    */
 726   public Type getGenericType()
 727   {
 728     String signature = getSignature();
 729     if (signature == null)
 730       return getType();
 731     FieldSignatureParser p = new FieldSignatureParser(getDeclaringClass(),
 732                                                       signature);
 733     return p.getFieldType();
 734   }
 735
 736   /**
 737    * Return the String in the Signature attribute for this field. If there
 738    * is no Signature attribute, return null.
 739    */
 740   private String getSignature()
 741   {
 742     // FIXME: libgcj doesn't record Signature attributes yet.
 743     return null;
 744   }
 745
 746   native void setByte (Class caller, Object obj, byte b, boolean checkFinal)
 747     throws IllegalArgumentException, IllegalAccessException;
 748
 749   native void setShort (Class caller, Object obj, short s, boolean checkFinal)
 750     throws IllegalArgumentException, IllegalAccessException;
 751
 752   native void setInt (Class caller, Object obj, int i, boolean checkFinal)
 753     throws IllegalArgumentException, IllegalAccessException;
 754
 755   native void setLong (Class caller, Object obj, long l, boolean checkFinal)
 756     throws IllegalArgumentException, IllegalAccessException;
 757
 758   native void setFloat (Class caller, Object obj, float f, boolean checkFinal)
 759     throws IllegalArgumentException, IllegalAccessException;
 760
 761   native void setDouble (Class caller, Object obj, double d,
 762                          boolean checkFinal)
 763     throws IllegalArgumentException, IllegalAccessException;
 764
 765   native void setChar (Class caller, Object obj, char c, boolean checkFinal)
 766     throws IllegalArgumentException, IllegalAccessException;
 767
 768   native void setBoolean (Class caller, Object obj, boolean b,
 769                           boolean checkFinal)
 770     throws IllegalArgumentException, IllegalAccessException;
 771
 772   native void set (Class caller, Object obj, Object val, Class type,
 773                    boolean checkFinal)
 774     throws IllegalArgumentException, IllegalAccessException;
 775
 776   private void set (Class caller, Object object, Object value)
 777     throws IllegalArgumentException, IllegalAccessException
 778   {
 779     Class type = getType();
 780     if (! type.isPrimitive())
 781       set(caller, object, value, type, true);
 782     else if (value instanceof Byte)
 783       setByte(caller, object, ((Byte) value).byteValue(), true);
 784     else if (value instanceof Short)
 785       setShort (caller, object, ((Short) value).shortValue(), true);
 786     else if (value instanceof Integer)
 787       setInt(caller, object, ((Integer) value).intValue(), true);
 788     else if (value instanceof Long)
 789       setLong(caller, object, ((Long) value).longValue(), true);
 790     else if (value instanceof Float)
 791       setFloat(caller, object, ((Float) value).floatValue(), true);
 792     else if (value instanceof Double)
 793       setDouble(caller, object, ((Double) value).doubleValue(), true);
 794     else if (value instanceof Character)
 795       setChar(caller, object, ((Character) value).charValue(), true);
 796     else if (value instanceof Boolean)
 797       setBoolean(caller, object, ((Boolean) value).booleanValue(), true);
 798     else
 799       throw new IllegalArgumentException();
 800   }
 801 }