1/* 2 * Copyright (C) 2007 The Android Open Source Project 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 17package com.android.dx.cf.attrib; 18 19import com.android.dx.cf.code.ByteCatchList; 20import com.android.dx.cf.code.BytecodeArray; 21import com.android.dx.cf.iface.AttributeList; 22import com.android.dx.util.MutabilityException; 23 24/** 25 * Attribute class for standard {@code Code} attributes. 26 */ 27public final class AttCode extends BaseAttribute { 28 /** {@code non-null;} attribute name for attributes of this type */ 29 public static final String ATTRIBUTE_NAME = "Code"; 30 31 /** {@code >= 0;} the stack size */ 32 private final int maxStack; 33 34 /** {@code >= 0;} the number of locals */ 35 private final int maxLocals; 36 37 /** {@code non-null;} array containing the bytecode per se */ 38 private final BytecodeArray code; 39 40 /** {@code non-null;} the exception table */ 41 private final ByteCatchList catches; 42 43 /** {@code non-null;} the associated list of attributes */ 44 private final AttributeList attributes; 45 46 /** 47 * Constructs an instance. 48 * 49 * @param maxStack {@code >= 0;} the stack size 50 * @param maxLocals {@code >= 0;} the number of locals 51 * @param code {@code non-null;} array containing the bytecode per se 52 * @param catches {@code non-null;} the exception table 53 * @param attributes {@code non-null;} the associated list of attributes 54 */ 55 public AttCode(int maxStack, int maxLocals, BytecodeArray code, 56 ByteCatchList catches, AttributeList attributes) { 57 super(ATTRIBUTE_NAME); 58 59 if (maxStack < 0) { 60 throw new IllegalArgumentException("maxStack < 0"); 61 } 62 63 if (maxLocals < 0) { 64 throw new IllegalArgumentException("maxLocals < 0"); 65 } 66 67 if (code == null) { 68 throw new NullPointerException("code == null"); 69 } 70 71 try { 72 if (catches.isMutable()) { 73 throw new MutabilityException("catches.isMutable()"); 74 } 75 } catch (NullPointerException ex) { 76 // Translate the exception. 77 throw new NullPointerException("catches == null"); 78 } 79 80 try { 81 if (attributes.isMutable()) { 82 throw new MutabilityException("attributes.isMutable()"); 83 } 84 } catch (NullPointerException ex) { 85 // Translate the exception. 86 throw new NullPointerException("attributes == null"); 87 } 88 89 this.maxStack = maxStack; 90 this.maxLocals = maxLocals; 91 this.code = code; 92 this.catches = catches; 93 this.attributes = attributes; 94 } 95 96 public int byteLength() { 97 return 10 + code.byteLength() + catches.byteLength() + 98 attributes.byteLength(); 99 } 100 101 /** 102 * Gets the maximum stack size. 103 * 104 * @return {@code >= 0;} the maximum stack size 105 */ 106 public int getMaxStack() { 107 return maxStack; 108 } 109 110 /** 111 * Gets the number of locals. 112 * 113 * @return {@code >= 0;} the number of locals 114 */ 115 public int getMaxLocals() { 116 return maxLocals; 117 } 118 119 /** 120 * Gets the bytecode array. 121 * 122 * @return {@code non-null;} the bytecode array 123 */ 124 public BytecodeArray getCode() { 125 return code; 126 } 127 128 /** 129 * Gets the exception table. 130 * 131 * @return {@code non-null;} the exception table 132 */ 133 public ByteCatchList getCatches() { 134 return catches; 135 } 136 137 /** 138 * Gets the associated attribute list. 139 * 140 * @return {@code non-null;} the attribute list 141 */ 142 public AttributeList getAttributes() { 143 return attributes; 144 } 145} 146