1 /*

     2  * reserved comment block

     3  * DO NOT REMOVE OR ALTER!

     4  */

     5 package com.sun.org.apache.bcel.internal.generic;

     6 

     7 /* ====================================================================

     8  * The Apache Software License, Version 1.1

     9  *

    10  * Copyright (c) 2001 The Apache Software Foundation.  All rights

    11  * reserved.

    12  *

    13  * Redistribution and use in source and binary forms, with or without

    14  * modification, are permitted provided that the following conditions

    15  * are met:

    16  *

    17  * 1. Redistributions of source code must retain the above copyright

    18  *    notice, this list of conditions and the following disclaimer.

    19  *

    20  * 2. Redistributions in binary form must reproduce the above copyright

    21  *    notice, this list of conditions and the following disclaimer in

    22  *    the documentation and/or other materials provided with the

    23  *    distribution.

    24  *

    25  * 3. The end-user documentation included with the redistribution,

    26  *    if any, must include the following acknowledgment:

    27  *       "This product includes software developed by the

    28  *        Apache Software Foundation (http://www.apache.org/)."

    29  *    Alternately, this acknowledgment may appear in the software itself,

    30  *    if and wherever such third-party acknowledgments normally appear.

    31  *

    32  * 4. The names "Apache" and "Apache Software Foundation" and

    33  *    "Apache BCEL" must not be used to endorse or promote products

    34  *    derived from this software without prior written permission. For

    35  *    written permission, please contact apache@apache.org.

    36  *

    37  * 5. Products derived from this software may not be called "Apache",

    38  *    "Apache BCEL", nor may "Apache" appear in their name, without

    39  *    prior written permission of the Apache Software Foundation.

    40  *

    41  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

    42  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

    43  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    44  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

    45  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    46  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    47  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

    48  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    49  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

    50  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

    51  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    52  * SUCH DAMAGE.

    53  * ====================================================================

    54  *

    55  * This software consists of voluntary contributions made by many

    56  * individuals on behalf of the Apache Software Foundation.  For more

    57  * information on the Apache Software Foundation, please see

    58  * <http://www.apache.org/>.

    59  */

    60 

    61 import com.sun.org.apache.bcel.internal.Constants;

    62 import com.sun.org.apache.bcel.internal.classfile.*;

    63 

    64 /**

    65  * This class represents an exception handler, i.e., specifies the  region where

    66  * a handler is active and an instruction where the actual handling is done.

    67  * pool as parameters. Opposed to the JVM specification the end of the handled

    68  * region is set to be inclusive, i.e. all instructions between start and end

    69  * are protected including the start and end instructions (handles) themselves.

    70  * The end of the region is automatically mapped to be exclusive when calling

    71  * getCodeException(), i.e., there is no difference semantically.

    72  *

    73  * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>

    74  * @see     MethodGen

    75  * @see     CodeException

    76  * @see     InstructionHandle

    77  */

    78 public final class CodeExceptionGen

    79   implements InstructionTargeter, Cloneable, java.io.Serializable {

    80   private InstructionHandle start_pc;

    81   private InstructionHandle end_pc;

    82   private InstructionHandle handler_pc;

    83   private ObjectType        catch_type;

    84 

    85   /**

    86    * Add an exception handler, i.e., specify region where a handler is active and an

    87    * instruction where the actual handling is done.

    88    *

    89    * @param start_pc Start of handled region (inclusive)

    90    * @param end_pc End of handled region (inclusive)

    91    * @param handler_pc Where handling is done

    92    * @param catch_type which exception is handled, null for ANY

    93    */

    94   public CodeExceptionGen(InstructionHandle start_pc, InstructionHandle end_pc,

    95                           InstructionHandle handler_pc, ObjectType catch_type) {

    96     setStartPC(start_pc);

    97     setEndPC(end_pc);

    98     setHandlerPC(handler_pc);

    99     this.catch_type = catch_type;

   100   }

   101 

   102   /**

   103    * Get CodeException object.<BR>

   104    *

   105    * This relies on that the instruction list has already been dumped

   106    * to byte code or or that the `setPositions' methods has been

   107    * called for the instruction list.

   108    *

   109    * @param cp constant pool

   110    */

   111   public CodeException getCodeException(ConstantPoolGen cp) {

   112     return new CodeException(start_pc.getPosition(),

   113                              end_pc.getPosition() + end_pc.getInstruction().getLength(),

   114                              handler_pc.getPosition(),

   115                              (catch_type == null)? 0 : cp.addClass(catch_type));

   116   }

   117 

   118   /* Set start of handler

   119    * @param start_pc Start of handled region (inclusive)

   120    */

   121   public void setStartPC(InstructionHandle start_pc) {

   122     BranchInstruction.notifyTarget(this.start_pc, start_pc, this);

   123     this.start_pc = start_pc;

   124   }

   125 

   126   /* Set end of handler

   127    * @param end_pc End of handled region (inclusive)

   128    */

   129   public void setEndPC(InstructionHandle end_pc) {

   130     BranchInstruction.notifyTarget(this.end_pc, end_pc, this);

   131     this.end_pc = end_pc;

   132   }

   133 

   134   /* Set handler code

   135    * @param handler_pc Start of handler

   136    */

   137   public void setHandlerPC(InstructionHandle handler_pc) {

   138     BranchInstruction.notifyTarget(this.handler_pc, handler_pc, this);

   139     this.handler_pc = handler_pc;

   140   }

   141 

   142   /**

   143    * @param old_ih old target, either start or end

   144    * @param new_ih new target

   145    */

   146   public void updateTarget(InstructionHandle old_ih, InstructionHandle new_ih) {

   147     boolean targeted = false;

   148 

   149     if(start_pc == old_ih) {

   150       targeted = true;

   151       setStartPC(new_ih);

   152     }

   153 

   154     if(end_pc == old_ih) {

   155       targeted = true;

   156       setEndPC(new_ih);

   157     }

   158 

   159     if(handler_pc == old_ih) {

   160       targeted = true;

   161       setHandlerPC(new_ih);

   162     }

   163 

   164     if(!targeted)

   165       throw new ClassGenException("Not targeting " + old_ih + ", but {" + start_pc + ", " +

   166                                   end_pc + ", " + handler_pc + "}");

   167   }

   168 

   169   /**

   170    * @return true, if ih is target of this handler

   171    */

   172   public boolean containsTarget(InstructionHandle ih) {

   173     return (start_pc == ih) || (end_pc == ih) || (handler_pc == ih);

   174   }

   175 

   176   /** Sets the type of the Exception to catch. Set 'null' for ANY. */

   177   public void              setCatchType(ObjectType catch_type)        { this.catch_type = catch_type; }

   178   /** Gets the type of the Exception to catch, 'null' for ANY. */

   179   public ObjectType        getCatchType()                             { return catch_type; }

   180 

   181   /** @return start of handled region (inclusive)

   182    */

   183   public InstructionHandle getStartPC()                               { return start_pc; }

   184 

   185   /** @return end of handled region (inclusive)

   186    */

   187   public InstructionHandle getEndPC()                                 { return end_pc; }

   188 

   189   /** @return start of handler

   190    */

   191   public InstructionHandle getHandlerPC()                             { return handler_pc; }

   192 

   193   public String toString() {

   194     return "CodeExceptionGen(" + start_pc + ", " + end_pc + ", " + handler_pc + ")";

   195   }

   196 

   197   public Object clone() {

   198     try {

   199       return super.clone();

   200     } catch(CloneNotSupportedException e) {

   201       System.err.println(e);

   202       return null;

   203     }

   204   }

   205 }