1/*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5/*
6 * Licensed to the Apache Software Foundation (ASF) under one or more
7 * contributor license agreements.  See the NOTICE file distributed with
8 * this work for additional information regarding copyright ownership.
9 * The ASF licenses this file to You under the Apache License, Version 2.0
10 * (the "License"); you may not use this file except in compliance with
11 * the License.  You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
21
22package com.sun.org.apache.bcel.internal.classfile;
23
24
25import  com.sun.org.apache.bcel.internal.Constants;
26import  java.io.*;
27
28/**
29 * This class represents the type of a local variable or item on stack
30 * used in the StackMap entries.
31 *
32 * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
33 * @see     StackMapEntry
34 * @see     StackMap
35 * @see     Constants
36 */
37public final class StackMapType implements Cloneable {
38  private byte         type;
39  private int          index = -1; // Index to CONSTANT_Class or offset
40  private ConstantPool constant_pool;
41
42  /**
43   * Construct object from file stream.
44   * @param file Input stream
45   * @throws IOException
46   */
47  StackMapType(DataInputStream file, ConstantPool constant_pool) throws IOException
48  {
49    this(file.readByte(), -1, constant_pool);
50
51    if(hasIndex())
52      setIndex(file.readShort());
53
54    setConstantPool(constant_pool);
55  }
56
57  /**
58   * @param type type tag as defined in the Constants interface
59   * @param index index to constant pool, or byte code offset
60   */
61  public StackMapType(byte type, int index, ConstantPool constant_pool) {
62    setType(type);
63    setIndex(index);
64    setConstantPool(constant_pool);
65  }
66
67  public void setType(byte t) {
68    if((t < Constants.ITEM_Bogus) || (t > Constants.ITEM_NewObject))
69      throw new RuntimeException("Illegal type for StackMapType: " + t);
70    type = t;
71  }
72
73  public byte getType()       { return type; }
74  public void setIndex(int t) { index = t; }
75
76  /** @return index to constant pool if type == ITEM_Object, or offset
77   * in byte code, if type == ITEM_NewObject, and -1 otherwise
78   */
79  public int  getIndex()      { return index; }
80
81  /**
82   * Dump type entries to file.
83   *
84   * @param file Output file stream
85   * @throws IOException
86   */
87  public final void dump(DataOutputStream file) throws IOException
88  {
89    file.writeByte(type);
90    if(hasIndex())
91      file.writeShort(getIndex());
92  }
93
94  /** @return true, if type is either ITEM_Object or ITEM_NewObject
95   */
96  public final boolean hasIndex() {
97    return ((type == Constants.ITEM_Object) ||
98            (type == Constants.ITEM_NewObject));
99  }
100
101  private String printIndex() {
102    if(type == Constants.ITEM_Object)
103      return ", class=" + constant_pool.constantToString(index, Constants.CONSTANT_Class);
104    else if(type == Constants.ITEM_NewObject)
105      return ", offset=" + index;
106    else
107      return "";
108  }
109
110  /**
111   * @return String representation
112   */
113  public final String toString() {
114    return "(type=" + Constants.ITEM_NAMES[type] + printIndex() + ")";
115  }
116
117  /**
118   * @return deep copy of this object
119   */
120  public StackMapType copy() {
121    try {
122      return (StackMapType)clone();
123    } catch(CloneNotSupportedException e) {}
124
125    return null;
126  }
127
128  /**
129   * @return Constant pool used by this object.
130   */
131  public final ConstantPool getConstantPool() { return constant_pool; }
132
133  /**
134   * @param constant_pool Constant pool to be used for this object.
135   */
136  public final void setConstantPool(ConstantPool constant_pool) {
137    this.constant_pool = constant_pool;
138  }
139}
140