View Javadoc
1 package org.apache.bcel.classfile; 2 3 /* ==================================================================== 4 * The Apache Software License, Version 1.1 5 * 6 * Copyright (c) 2001 The Apache Software Foundation. All rights 7 * reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in 18 * the documentation and/or other materials provided with the 19 * distribution. 20 * 21 * 3. The end-user documentation included with the redistribution, 22 * if any, must include the following acknowledgment: 23 * "This product includes software developed by the 24 * Apache Software Foundation (http://www.apache.org/)." 25 * Alternately, this acknowledgment may appear in the software itself, 26 * if and wherever such third-party acknowledgments normally appear. 27 * 28 * 4. The names "Apache" and "Apache Software Foundation" and 29 * "Apache BCEL" must not be used to endorse or promote products 30 * derived from this software without prior written permission. For 31 * written permission, please contact apache@apache.org. 32 * 33 * 5. Products derived from this software may not be called "Apache", 34 * "Apache BCEL", nor may "Apache" appear in their name, without 35 * prior written permission of the Apache Software Foundation. 36 * 37 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 38 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 39 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 40 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR 41 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 44 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 45 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 46 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 47 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 48 * SUCH DAMAGE. 49 * ==================================================================== 50 * 51 * This software consists of voluntary contributions made by many 52 * individuals on behalf of the Apache Software Foundation. For more 53 * information on the Apache Software Foundation, please see 54 * <http://www.apache.org/>;. 55 */ 56 57 import org.apache.bcel.Constants; 58 import java.io.*; 59 60 /*** 61 * This class represents a chunk of Java byte code contained in a 62 * method. It is instantiated by the 63 * <em>Attribute.readAttribute()</em> method. A <em>Code</em> 64 * attribute contains informations about operand stack, local 65 * variables, byte code and the exceptions handled within this 66 * method. 67 * 68 * This attribute has attributes itself, namely <em>LineNumberTable</em> which 69 * is used for debugging purposes and <em>LocalVariableTable</em> which 70 * contains information about the local variables. 71 * 72 * @version $Id: Code.java,v 1.2 2002/03/11 16:16:35 mdahm Exp $ 73 * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A> 74 * @see Attribute 75 * @see CodeException 76 * @see LineNumberTable 77 * @see LocalVariableTable 78 */ 79 public final class Code extends Attribute { 80 private int max_stack; // Maximum size of stack used by this method 81 private int max_locals; // Number of local variables 82 private int code_length; // Length of code in bytes 83 private byte[] code; // Actual byte code 84 85 private int exception_table_length; 86 private CodeException[] exception_table; // Table of handled exceptions 87 private int attributes_count; // Attributes of code: LineNumber 88 private Attribute[] attributes; // or LocalVariable 89 90 /*** 91 * Initialize from another object. Note that both objects use the same 92 * references (shallow copy). Use copy() for a physical copy. 93 */ 94 public Code(Code c) { 95 this(c.getNameIndex(), c.getLength(), c.getMaxStack(), c.getMaxLocals(), 96 c.getCode(), c.getExceptionTable(), c.getAttributes(), 97 c.getConstantPool()); 98 } 99 100 /*** 101 * @param name_index Index pointing to the name <em>Code</em> 102 * @param length Content length in bytes 103 * @param file Input stream 104 * @param constant_pool Array of constants 105 */ 106 Code(int name_index, int length, DataInputStream file, 107 ConstantPool constant_pool) throws IOException 108 { 109 // Initialize with some default values which will be overwritten later 110 this(name_index, length, 111 file.readUnsignedShort(), file.readUnsignedShort(), 112 (byte[])null, (CodeException[])null, (Attribute[])null, 113 constant_pool); 114 115 code_length = file.readInt(); 116 code = new byte[code_length]; // Read byte code 117 file.readFully(code); 118 119 /* Read exception table that contains all regions where an exception 120 * handler is active, i.e., a try { ... } catch() block. 121 */ 122 exception_table_length = file.readUnsignedShort(); 123 exception_table = new CodeException[exception_table_length]; 124 125 for(int i=0; i < exception_table_length; i++) 126 exception_table[i] = new CodeException(file); 127 128 /* Read all attributes, currently `LineNumberTable' and 129 * `LocalVariableTable' 130 */ 131 attributes_count = file.readUnsignedShort(); 132 attributes = new Attribute[attributes_count]; 133 for(int i=0; i < attributes_count; i++) 134 attributes[i] = Attribute.readAttribute(file, constant_pool); 135 136 /* Adjust length, because of setAttributes in this(), s.b. length 137 * is incorrect, because it didn't take the internal attributes 138 * into account yet! Very subtle bug, fixed in 3.1.1. 139 */ 140 this.length = length; 141 } 142 143 /*** 144 * @param name_index Index pointing to the name <em>Code</em> 145 * @param length Content length in bytes 146 * @param max_stack Maximum size of stack 147 * @param max_locals Number of local variables 148 * @param code Actual byte code 149 * @param exception_table Table of handled exceptions 150 * @param attributes Attributes of code: LineNumber or LocalVariable 151 * @param constant_pool Array of constants 152 */ 153 public Code(int name_index, int length, 154 int max_stack, int max_locals, 155 byte[] code, 156 CodeException[] exception_table, 157 Attribute[] attributes, 158 ConstantPool constant_pool) 159 { 160 super(Constants.ATTR_CODE, name_index, length, constant_pool); 161 162 this.max_stack = max_stack; 163 this.max_locals = max_locals; 164 165 setCode(code); 166 setExceptionTable(exception_table); 167 setAttributes(attributes); // Overwrites length! 168 } 169 170 /*** 171 * Called by objects that are traversing the nodes of the tree implicitely 172 * defined by the contents of a Java class. I.e., the hierarchy of methods, 173 * fields, attributes, etc. spawns a tree of objects. 174 * 175 * @param v Visitor object 176 */ 177 public void accept(Visitor v) { 178 v.visitCode(this); 179 } 180 181 /*** 182 * Dump code attribute to file stream in binary format. 183 * 184 * @param file Output file stream 185 * @throws IOException 186 */ 187 public final void dump(DataOutputStream file) throws IOException 188 { 189 super.dump(file); 190 191 file.writeShort(max_stack); 192 file.writeShort(max_locals); 193 file.writeInt(code_length); 194 file.write(code, 0, code_length); 195 196 file.writeShort(exception_table_length); 197 for(int i=0; i < exception_table_length; i++) 198 exception_table[i].dump(file); 199 200 file.writeShort(attributes_count); 201 for(int i=0; i < attributes_count; i++) 202 attributes[i].dump(file); 203 } 204 205 /*** 206 * @return Collection of code attributes. 207 * @see Attribute 208 */ 209 public final Attribute[] getAttributes() { return attributes; } 210 211 /*** 212 * @return LineNumberTable of Code, if it has one 213 */ 214 public LineNumberTable getLineNumberTable() { 215 for(int i=0; i < attributes_count; i++) 216 if(attributes[i] instanceof LineNumberTable) 217 return (LineNumberTable)attributes[i]; 218 219 return null; 220 } 221 222 /*** 223 * @return LocalVariableTable of Code, if it has one 224 */ 225 public LocalVariableTable getLocalVariableTable() { 226 for(int i=0; i < attributes_count; i++) 227 if(attributes[i] instanceof LocalVariableTable) 228 return (LocalVariableTable)attributes[i]; 229 230 return null; 231 } 232 233 /*** 234 * @return Actual byte code of the method. 235 */ 236 public final byte[] getCode() { return code; } 237 238 /*** 239 * @return Table of handled exceptions. 240 * @see CodeException 241 */ 242 public final CodeException[] getExceptionTable() { return exception_table; } 243 244 /*** 245 * @return Number of local variables. 246 */ 247 public final int getMaxLocals() { return max_locals; } 248 249 /*** 250 * @return Maximum size of stack used by this method. 251 */ 252 253 public final int getMaxStack() { return max_stack; } 254 255 /*** 256 * @return the internal length of this code attribute (minus the first 6 bytes) 257 * and excluding all its attributes 258 */ 259 private final int getInternalLength() { 260 return 2 /*max_stack*/ + 2 /*max_locals*/ + 4 /*code length*/ 261 + code_length /*byte-code*/ 262 + 2 /*exception-table length*/ 263 + 8 * exception_table_length /* exception table */ 264 + 2 /* attributes count */; 265 } 266 267 /*** 268 * @return the full size of this code attribute, minus its first 6 bytes, 269 * including the size of all its contained attributes 270 */ 271 private final int calculateLength() { 272 int len = 0; 273 274 for(int i=0; i < attributes_count; i++) 275 len += attributes[i].length + 6 /*attribute header size*/; 276 277 return len + getInternalLength(); 278 } 279 280 /*** 281 * @param attributes. 282 */ 283 public final void setAttributes(Attribute[] attributes) { 284 this.attributes = attributes; 285 attributes_count = (attributes == null)? 0 : attributes.length; 286 length = calculateLength(); // Adjust length 287 } 288 289 /*** 290 * @param code byte code 291 */ 292 public final void setCode(byte[] code) { 293 this.code = code; 294 code_length = (code == null)? 0 : code.length; 295 } 296 297 /*** 298 * @param exception_table exception table 299 */ 300 public final void setExceptionTable(CodeException[] exception_table) { 301 this.exception_table = exception_table; 302 exception_table_length = (exception_table == null)? 0 : 303 exception_table.length; 304 } 305 306 /*** 307 * @param max_locals maximum number of local variables 308 */ 309 public final void setMaxLocals(int max_locals) { 310 this.max_locals = max_locals; 311 } 312 313 /*** 314 * @param max_stack maximum stack size 315 */ 316 public final void setMaxStack(int max_stack) { 317 this.max_stack = max_stack; 318 } 319 320 /*** 321 * @return String representation of code chunk. 322 */ 323 public final String toString(boolean verbose) { 324 StringBuffer buf; 325 326 buf = new StringBuffer("Code(max_stack = " + max_stack + 327 ", max_locals = " + max_locals + 328 ", code_length = " + code_length + ")\n" + 329 Utility.codeToString(code, constant_pool, 0, -1, verbose)); 330 331 if(exception_table_length > 0) { 332 buf.append("\nException handler(s) = \n" + "From\tTo\tHandler\tType\n"); 333 334 for(int i=0; i < exception_table_length; i++) 335 buf.append(exception_table[i].toString(constant_pool, verbose) + "\n"); 336 } 337 338 if(attributes_count > 0) { 339 buf.append("\nAttribute(s) = \n"); 340 341 for(int i=0; i < attributes_count; i++) 342 buf.append(attributes[i].toString() + "\n"); 343 } 344 345 return buf.toString(); 346 } 347 348 /*** 349 * @return String representation of code chunk. 350 */ 351 public final String toString() { 352 return toString(true); 353 } 354 355 /*** 356 * @return deep copy of this attribute 357 */ 358 public Attribute copy(ConstantPool constant_pool) { 359 Code c = (Code)clone(); 360 c.code = (byte[])code.clone(); 361 c.constant_pool = constant_pool; 362 363 c.exception_table = new CodeException[exception_table_length]; 364 for(int i=0; i < exception_table_length; i++) 365 c.exception_table[i] = exception_table[i].copy(); 366 367 c.attributes = new Attribute[attributes_count]; 368 for(int i=0; i < attributes_count; i++) 369 c.attributes[i] = attributes[i].copy(constant_pool); 370 371 return c; 372 } 373 }

This page was automatically generated by Maven