KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > bcel > classfile > StackMap


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 JavaDoc;
20 import java.io.DataOutputStream JavaDoc;
21 import java.io.IOException JavaDoc;
22 import org.apache.bcel.Constants;
23
24 /**
25  * This class represents a stack map attribute used for
26  * preverification of Java classes for the <a
27  * HREF="http://java.sun.com/j2me/"> Java 2 Micro Edition</a>
28  * (J2ME). This attribute is used by the <a
29  * HREF="http://java.sun.com/products/cldc/">KVM</a> and contained
30  * within the Code attribute of a method. See CLDC specification
31  * 5.3.1.2
32  *
33  * @version $Id: StackMap.java 386056 2006-03-15 11:31:56Z tcurdt $
34  * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
35  * @see Code
36  * @see StackMapEntry
37  * @see StackMapType
38  */

39 public final class StackMap extends Attribute implements Node {
40
41     private int map_length;
42     private StackMapEntry[] map; // Table of stack map entries
43

44
45     /*
46      * @param name_index Index of name
47      * @param length Content length in bytes
48      * @param map Table of stack map entries
49      * @param constant_pool Array of constants
50      */

51     public StackMap(int name_index, int length, StackMapEntry[] map, ConstantPool constant_pool) {
52         super(Constants.ATTR_STACK_MAP, name_index, length, constant_pool);
53         setStackMap(map);
54     }
55
56
57     /**
58      * Construct object from file stream.
59      * @param name_index Index of name
60      * @param length Content length in bytes
61      * @param file Input stream
62      * @param constant_pool Array of constants
63      * @throws IOException
64      */

65     StackMap(int name_index, int length, DataInputStream JavaDoc file, ConstantPool constant_pool)
66             throws IOException JavaDoc {
67         this(name_index, length, (StackMapEntry[]) null, constant_pool);
68         map_length = file.readUnsignedShort();
69         map = new StackMapEntry[map_length];
70         for (int i = 0; i < map_length; i++) {
71             map[i] = new StackMapEntry(file, constant_pool);
72         }
73     }
74
75
76     /**
77      * Dump line number table attribute to file stream in binary format.
78      *
79      * @param file Output file stream
80      * @throws IOException
81      */

82     public final void dump( DataOutputStream JavaDoc file ) throws IOException JavaDoc {
83         super.dump(file);
84         file.writeShort(map_length);
85         for (int i = 0; i < map_length; i++) {
86             map[i].dump(file);
87         }
88     }
89
90
91     /**
92      * @return Array of stack map entries
93      */

94     public final StackMapEntry[] getStackMap() {
95         return map;
96     }
97
98
99     /**
100      * @param map Array of stack map entries
101      */

102     public final void setStackMap( StackMapEntry[] map ) {
103         this.map = map;
104         map_length = (map == null) ? 0 : map.length;
105     }
106
107
108     /**
109      * @return String representation.
110      */

111     public final String JavaDoc toString() {
112         StringBuffer JavaDoc buf = new StringBuffer JavaDoc("StackMap(");
113         for (int i = 0; i < map_length; i++) {
114             buf.append(map[i].toString());
115             if (i < map_length - 1) {
116                 buf.append(", ");
117             }
118         }
119         buf.append(')');
120         return buf.toString();
121     }
122
123
124     /**
125      * @return deep copy of this attribute
126      */

127     public Attribute copy( ConstantPool _constant_pool ) {
128         StackMap c = (StackMap) clone();
129         c.map = new StackMapEntry[map_length];
130         for (int i = 0; i < map_length; i++) {
131             c.map[i] = map[i].copy();
132         }
133         c.constant_pool = _constant_pool;
134         return c;
135     }
136
137
138     /**
139      * Called by objects that are traversing the nodes of the tree implicitely
140      * defined by the contents of a Java class. I.e., the hierarchy of methods,
141      * fields, attributes, etc. spawns a tree of objects.
142      *
143      * @param v Visitor object
144      */

145     public void accept( Visitor v ) {
146         v.visitStackMap(this);
147     }
148
149
150     public final int getMapLength() {
151         return map_length;
152     }
153 }
154
Popular Tags