Ignore:
Timestamp:
Apr 27, 2004, 8:39:34 PM (22 years ago)
Author:
bird
Message:

GCC v3.3.3 sources.

Location:
branches/GNU/src/gcc
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/GNU/src/gcc

    • Property svn:ignore

      •  

        old new  
        2626configure.vr
        2727configure.vrs
         28
        2829Makefile
        29 dir.info
        3030lost+found
        3131update.out

  • branches/GNU/src/gcc/libjava/java/lang/ClassNotFoundException.java

    • Property cvs2svn:cvs-rev changed from 1.1 to 1.1.1.2
    r1390 r1391  
    1 /* ClassNotFoundException.java -- exception thrown when attempting to load
    2    a class when no definition for the class can be found.
    3    Copyright (C) 1998 Free Software Foundation, Inc.
     1/* ClassNotFoundException.java -- thrown when class definition cannot be found
     2   Copyright (C) 1998, 2002 Free Software Foundation, Inc.
    43
    54This file is part of GNU Classpath.
    … …  
    98the Free Software Foundation; either version 2, or (at your option)
    109any later version.
    11  
     10
    1211GNU Classpath is distributed in the hope that it will be useful, but
    1312WITHOUT ANY WARRANTY; without even the implied warranty of
    … …  
    4039package java.lang;
    4140
    42 import java.io.ObjectOutputStream;
    43 import java.io.ObjectInputStream;
    44 import java.io.IOException;
    45 import java.io.PrintStream;
    46 import java.io.PrintWriter;
    47 
    4841/**
    49  * Exceptions may be thrown by one part of a Java program and caught
    50  * by another in order to deal with exceptional conditions.  This
    51  * exception can by thrown by specific methods of <code>ClassLoader</code>
    52  * and <code>Class</code> when attempting to load a class when no definition
    53  * for the specified class can be found.
     42 * Thrown when a class is requested by reflection, but the class definition
     43 * cannot be found. This exception is often chained from another Throwable.
    5444 *
    55  * @since JDK 1.0
    56  *
    5745 * @author Brian Jones
     46
     47
     48
     49
     50
    5851 */
    5952public class ClassNotFoundException extends Exception
    6053{
    61   static final long serialVersionUID = 9176873029745254542L;
     54  /**
     55   * Compatible with JDK 1.0+.
     56   */
     57  private static final long serialVersionUID = 9176873029745254542L;
    6258
    63   private Throwable ex = null;
    64  
    6559  /**
    66    * Create an exception without a message.
     60   * The cause of this exception (duplicates the one stored in Throwable).
     61   *
     62   * @serial the exception cause
     63   * @since 1.2
     64   */
     65  private final Throwable ex;
     66
     67  /**
     68   * Create an exception without a message. Note that this initializes the
     69   * cause to null.
    6770   */
    6871  public ClassNotFoundException()
    69     {
    70       super();
    71     }
     72  {
     73    );
     74  }
    7275
    7376  /**
    74    * Create an exception with a message.
     77   * Create an exception with a message. Note that this initializes the
     78   * cause to null.
     79   *
     80   * @param s the message
    7581   */
    7682  public ClassNotFoundException(String s)
    77     {
    78       super(s);
    79     }
     83  {
     84    );
     85  }
    8086
    8187  /**
    82    * Create an exception with a message and include the exception
     88   * Create an exception with a message and
    8389   * which occurred while loading the class.
    8490   *
    85    * @param ex the exception which occurred while loading the class
    86    *
    87    * @since JDK 1.2
     91   * @param
     92   *
     93   * @since 1.2
    8894   */
    8995  public ClassNotFoundException(String s, Throwable ex)
    90     {
    91       super(s);
    92       this.ex = ex;
    93     }
     96  {
     97    );
     98    this.ex = ex;
     99  }
    94100
    95101  /**
    96    * Returns the exception which occurred while loading the class,
    97    * otherwise returns null.
    98    *
    99    * @since JDK 1.2
     102   * Returns the exception which occurred while loading the class,
     103   * otherwise returns null. This is a legacy method; the preferred choice
     104   * now is {@link Throwable#getCause()}.
     105   *
     106   * @return the cause of this exception
     107   * @since 1.2
    100108   */
    101109  public Throwable getException()
    102     {
    103       return ex;
    104     }
     110  {
     111    return ex;
     112  }
    105113
    106114  /**
    107    * Print a stack trace of the exception that occurred.
     115   * Returns the exception which occurred while loading the class,
     116   * otherwise returns null.
     117   *
     118   * @return the cause of this exception
     119   * @since 1.4
    108120   */
    109   public void printStackTrace()
    110     {
    111       if (ex == null)
    112         {
    113           super.printStackTrace();
    114         }
    115       else
    116         {
    117           ex.printStackTrace();
    118         }
    119     }
    120 
    121   /**
    122    * Print a stack trace of the exception that occurred to
    123    * the specified <code>PrintStream</code>.
    124    */
    125   public void printStackTrace(PrintStream ps)
    126     {
    127       if (ex == null)
    128         {
    129           super.printStackTrace(ps);
    130         }
    131       else
    132         {
    133           ex.printStackTrace(ps);
    134         }
    135     }
    136 
    137   /**
    138    * Print a stack trace of the exception that occurred to
    139    * the specified <code>PrintWriter</code>.
    140    */
    141   public void printStackTrace(PrintWriter pw)
    142     {
    143       if (ex == null)
    144         {
    145           super.printStackTrace(pw);
    146         }
    147       else
    148         {
    149           ex.printStackTrace(pw);
    150         }
    151     }
    152 
    153   /**
    154    * Serialize the object in a manner binary compatible with the JDK 1.2
    155    */
    156   private void writeObject(java.io.ObjectOutputStream s)
    157     throws IOException
    158     {
    159       ObjectOutputStream.PutField oFields;
    160       oFields = s.putFields();
    161       oFields.put("ex", this.ex);
    162       s.writeFields();
    163     }
    164 
    165   /**
    166    * Deserialize the object in a manner binary compatible with the JDK 1.2
    167    */   
    168   private void readObject(java.io.ObjectInputStream s)
    169     throws IOException, ClassNotFoundException
    170     {
    171       ObjectInputStream.GetField oFields;
    172       oFields = s.readFields();
    173       ex = (Throwable)oFields.get("ex", (Throwable)null);
    174     }
     121  public Throwable getCause()
     122  {
     123    return ex;
     124  }
    175125}
Note: See TracChangeset for help on using the changeset viewer.