CodeException xref

View Javadoc

    1   /*
    2    * Copyright  2000-2004 The Apache Software Foundation
    3    *
    4    *  Licensed under the Apache License, Version 2.0 (the "License");
    5    *  you may not use this file except in compliance with the License.
    6    *  You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   *  Unless required by applicable law or agreed to in writing, software
    11   *  distributed under the License is distributed on an "AS IS" BASIS,
    12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   *  See the License for the specific language governing permissions and
    14   *  limitations under the License.
    15   *
    16   */
    17  package org.apache.bcel.classfile;
    18
    19  import java.io.DataInputStream;
    20  import java.io.DataOutputStream;
    21  import java.io.IOException;
    22  import java.io.Serializable;
    23  import org.apache.bcel.Constants;
    24
    25  /***
    26   * This class represents an entry in the exception table of the <em>Code</em>
    27   * attribute and is used only there. It contains a range in which a
    28   * particular exception handler is active.
    29   *
    30   * @version $Id: CodeException.java 386056 2006-03-15 11:31:56Z tcurdt $
    31   * @author  <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
    32   * @see     Code
    33   */
    34  public final class CodeException implements Cloneable, Constants, Node, Serializable {
    35
    36      private int start_pc; // Range in the code the exception handler is
    37      private int end_pc; // active. start_pc is inclusive, end_pc exclusive
    38      private int handler_pc; /* Starting address of exception handler, i.e.,
    39       * an offset from start of code.
    40       */
    41      private int catch_type; /* If this is zero the handler catches any
    42       * exception, otherwise it points to the
    43       * exception class which is to be caught.
    44       */
    45
    46
    47      /***
    48       * Initialize from another object.
    49       */
    50      public CodeException(CodeException c) {
    51          this(c.getStartPC(), c.getEndPC(), c.getHandlerPC(), c.getCatchType());
    52      }
    53
    54
    55      /***
    56       * Construct object from file stream.
    57       * @param file Input stream
    58       * @throws IOException
    59       */
    60      CodeException(DataInputStream file) throws IOException {
    61          this(file.readUnsignedShort(), file.readUnsignedShort(), file.readUnsignedShort(), file
    62                  .readUnsignedShort());
    63      }
    64
    65
    66      /***
    67       * @param start_pc Range in the code the exception handler is active,
    68       * start_pc is inclusive while
    69       * @param end_pc is exclusive
    70       * @param handler_pc Starting address of exception handler, i.e.,
    71       * an offset from start of code.
    72       * @param catch_type If zero the handler catches any
    73       * exception, otherwise it points to the exception class which is
    74       * to be caught.
    75       */
    76      public CodeException(int start_pc, int end_pc, int handler_pc, int catch_type) {
    77          this.start_pc = start_pc;
    78          this.end_pc = end_pc;
    79          this.handler_pc = handler_pc;
    80          this.catch_type = catch_type;
    81      }
    82
    83
    84      /***
    85       * Called by objects that are traversing the nodes of the tree implicitely
    86       * defined by the contents of a Java class. I.e., the hierarchy of methods,
    87       * fields, attributes, etc. spawns a tree of objects.
    88       *
    89       * @param v Visitor object
    90       */
    91      public void accept( Visitor v ) {
    92          v.visitCodeException(this);
    93      }
    94
    95
    96      /***
    97       * Dump code exception to file stream in binary format.
    98       *
    99       * @param file Output file stream
    100      * @throws IOException
    101      */
    102     public final void dump( DataOutputStream file ) throws IOException {
    103         file.writeShort(start_pc);
    104         file.writeShort(end_pc);
    105         file.writeShort(handler_pc);
    106         file.writeShort(catch_type);
    107     }
    108
    109
    110     /***
    111      * @return 0, if the handler catches any exception, otherwise it points to
    112      * the exception class which is to be caught.
    113      */
    114     public final int getCatchType() {
    115         return catch_type;
    116     }
    117
    118
    119     /***
    120      * @return Exclusive end index of the region where the handler is active.
    121      */
    122     public final int getEndPC() {
    123         return end_pc;
    124     }
    125
    126
    127     /***
    128      * @return Starting address of exception handler, relative to the code.
    129      */
    130     public final int getHandlerPC() {
    131         return handler_pc;
    132     }
    133
    134
    135     /***
    136      * @return Inclusive start index of the region where the handler is active.
    137      */
    138     public final int getStartPC() {
    139         return start_pc;
    140     }
    141
    142
    143     /***
    144      * @param catch_type the type of exception that is caught
    145      */
    146     public final void setCatchType( int catch_type ) {
    147         this.catch_type = catch_type;
    148     }
    149
    150
    151     /***
    152      * @param end_pc end of handled block
    153      */
    154     public final void setEndPC( int end_pc ) {
    155         this.end_pc = end_pc;
    156     }
    157
    158
    159     /***
    160      * @param handler_pc where the actual code is
    161      */
    162     public final void setHandlerPC( int handler_pc ) {
    163         this.handler_pc = handler_pc;
    164     }
    165
    166
    167     /***
    168      * @param start_pc start of handled block
    169      */
    170     public final void setStartPC( int start_pc ) {
    171         this.start_pc = start_pc;
    172     }
    173
    174
    175     /***
    176      * @return String representation.
    177      */
    178     public final String toString() {
    179         return "CodeException(start_pc = " + start_pc + ", end_pc = " + end_pc + ", handler_pc = "
    180                 + handler_pc + ", catch_type = " + catch_type + ")";
    181     }
    182
    183
    184     /***
    185      * @return String representation.
    186      */
    187     public final String toString( ConstantPool cp, boolean verbose ) {
    188         String str;
    189         if (catch_type == 0) {
    190             str = "<Any exception>(0)";
    191         } else {
    192             str = Utility.compactClassName(cp.getConstantString(catch_type, CONSTANT_Class), false)
    193                     + (verbose ? "(" + catch_type + ")" : "");
    194         }
    195         return start_pc + "\t" + end_pc + "\t" + handler_pc + "\t" + str;
    196     }
    197
    198
    199     public final String toString( ConstantPool cp ) {
    200         return toString(cp, true);
    201     }
    202
    203
    204     /***
    205      * @return deep copy of this object
    206      */
    207     public CodeException copy() {
    208         try {
    209             return (CodeException) clone();
    210         } catch (CloneNotSupportedException e) {
    211         }
    212         return null;
    213     }
    214 }