001: /*
002: * Copyright 1999-2005 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package com.sun.tools.javac.jvm;
027:
028: import java.util.*;
029:
030: import com.sun.tools.javac.util.*;
031: import com.sun.tools.javac.code.Symbol.*;
032: import com.sun.tools.javac.code.Type;
033:
034: /** An internal structure that corresponds to the constant pool of a classfile.
035: *
036: * <p><b>This is NOT part of any API supported by Sun Microsystems. If
037: * you write code that depends on this, you do so at your own risk.
038: * This code and its internal interfaces are subject to change or
039: * deletion without notice.</b>
040: */
041: @Version("@(#)Pool.java 1.29 07/05/05")
042: public class Pool {
043:
044: public static final int MAX_ENTRIES = 0xFFFF;
045: public static final int MAX_STRING_LENGTH = 0xFFFF;
046:
047: /** Index of next constant to be entered.
048: */
049: int pp;
050:
051: /** The initial pool buffer.
052: */
053: Object[] pool;
054:
055: /** A hashtable containing all constants in the pool.
056: */
057: Map<Object, Integer> indices;
058:
059: /** Construct a pool with given number of elements and element array.
060: */
061: public Pool(int pp, Object[] pool) {
062: this .pp = pp;
063: this .pool = pool;
064: this .indices = new HashMap<Object, Integer>(pool.length);
065: for (int i = 1; i < pp; i++) {
066: if (pool[i] != null)
067: indices.put(pool[i], i);
068: }
069: }
070:
071: /** Construct an empty pool.
072: */
073: public Pool() {
074: this (1, new Object[64]);
075: }
076:
077: /** Return the number of entries in the constant pool.
078: */
079: public int numEntries() {
080: return pp;
081: }
082:
083: /** Remove everything from this pool.
084: */
085: public void reset() {
086: pp = 1;
087: indices.clear();
088: }
089:
090: /** Double pool buffer in size.
091: */
092: private void doublePool() {
093: Object[] newpool = new Object[pool.length * 2];
094: System.arraycopy(pool, 0, newpool, 0, pool.length);
095: pool = newpool;
096: }
097:
098: /** Place an object in the pool, unless it is already there.
099: * If object is a symbol also enter its owner unless the owner is a
100: * package. Return the object's index in the pool.
101: */
102: public int put(Object value) {
103: if (value instanceof MethodSymbol)
104: value = new Method((MethodSymbol) value);
105: else if (value instanceof VarSymbol)
106: value = new Variable((VarSymbol) value);
107: // assert !(value instanceof Type.TypeVar);
108: Integer index = indices.get(value);
109: if (index == null) {
110: // System.err.println("put " + value + " " + value.getClass());//DEBUG
111: index = pp;
112: indices.put(value, index);
113: if (pp == pool.length)
114: doublePool();
115: pool[pp++] = value;
116: if (value instanceof Long || value instanceof Double) {
117: if (pp == pool.length)
118: doublePool();
119: pool[pp++] = null;
120: }
121: }
122: return index.intValue();
123: }
124:
125: /** Return the given object's index in the pool,
126: * or -1 if object is not in there.
127: */
128: public int get(Object o) {
129: Integer n = indices.get(o);
130: return n == null ? -1 : n.intValue();
131: }
132:
133: static class Method extends DelegatedSymbol {
134: MethodSymbol m;
135:
136: Method(MethodSymbol m) {
137: super (m);
138: this .m = m;
139: }
140:
141: public boolean equals(Object other) {
142: if (!(other instanceof Method))
143: return false;
144: MethodSymbol o = ((Method) other).m;
145: return o.name == m.name && o.owner == m.owner
146: && o.type.equals(m.type);
147: }
148:
149: public int hashCode() {
150: return m.name.hashCode() * 33 + m.owner.hashCode() * 9
151: + m.type.hashCode();
152: }
153: }
154:
155: static class Variable extends DelegatedSymbol {
156: VarSymbol v;
157:
158: Variable(VarSymbol v) {
159: super (v);
160: this .v = v;
161: }
162:
163: public boolean equals(Object other) {
164: if (!(other instanceof Variable))
165: return false;
166: VarSymbol o = ((Variable) other).v;
167: return o.name == v.name && o.owner == v.owner
168: && o.type.equals(v.type);
169: }
170:
171: public int hashCode() {
172: return v.name.hashCode() * 33 + v.owner.hashCode() * 9
173: + v.type.hashCode();
174: }
175: }
176: }
|