001: /*
002: * ASM: a very small and fast Java bytecode manipulation framework
003: * Copyright (c) 2000-2005 INRIA, France Telecom
004: * All rights reserved.
005: *
006: * Redistribution and use in source and binary forms, with or without
007: * modification, are permitted provided that the following conditions
008: * are met:
009: * 1. Redistributions of source code must retain the above copyright
010: * notice, this list of conditions and the following disclaimer.
011: * 2. Redistributions in binary form must reproduce the above copyright
012: * notice, this list of conditions and the following disclaimer in the
013: * documentation and/or other materials provided with the distribution.
014: * 3. Neither the name of the copyright holders nor the names of its
015: * contributors may be used to endorse or promote products derived from
016: * this software without specific prior written permission.
017: *
018: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
019: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
020: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
021: * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
022: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
023: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
024: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
025: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
026: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
027: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
028: * THE POSSIBILITY OF SUCH DAMAGE.
029: */
030: package org.objectweb.asm.optimizer;
031:
032: import java.util.HashMap;
033:
034: import org.objectweb.asm.Type;
035:
036: /**
037: * A constant pool.
038: *
039: * @author Eric Bruneton
040: */
041: @SuppressWarnings("unchecked")
042: public class ConstantPool extends HashMap {
043:
044: private final Constant key1 = new Constant();
045:
046: private final Constant key2 = new Constant();
047:
048: private final Constant key3 = new Constant();
049:
050: public Constant newInteger(final int value) {
051: key1.set(value);
052: Constant result = get(key1);
053: if (result == null) {
054: result = new Constant(key1);
055: put(result);
056: }
057: return result;
058: }
059:
060: public Constant newFloat(final float value) {
061: key1.set(value);
062: Constant result = get(key1);
063: if (result == null) {
064: result = new Constant(key1);
065: put(result);
066: }
067: return result;
068: }
069:
070: public Constant newLong(final long value) {
071: key1.set(value);
072: Constant result = get(key1);
073: if (result == null) {
074: result = new Constant(key1);
075: put(result);
076: }
077: return result;
078: }
079:
080: public Constant newDouble(final double value) {
081: key1.set(value);
082: Constant result = get(key1);
083: if (result == null) {
084: result = new Constant(key1);
085: put(result);
086: }
087: return result;
088: }
089:
090: public Constant newUTF8(final String value) {
091: key1.set('s', value, null, null);
092: Constant result = get(key1);
093: if (result == null) {
094: result = new Constant(key1);
095: put(result);
096: }
097: return result;
098: }
099:
100: private Constant newString(final String value) {
101: key2.set('S', value, null, null);
102: Constant result = get(key2);
103: if (result == null) {
104: newUTF8(value);
105: result = new Constant(key2);
106: put(result);
107: }
108: return result;
109: }
110:
111: public Constant newClass(final String value) {
112: key2.set('C', value, null, null);
113: Constant result = get(key2);
114: if (result == null) {
115: newUTF8(value);
116: result = new Constant(key2);
117: put(result);
118: }
119: return result;
120: }
121:
122: public Constant newConst(final Object cst) {
123: if (cst instanceof Integer) {
124: int val = ((Integer) cst).intValue();
125: return newInteger(val);
126: } else if (cst instanceof Float) {
127: float val = ((Float) cst).floatValue();
128: return newFloat(val);
129: } else if (cst instanceof Long) {
130: long val = ((Long) cst).longValue();
131: return newLong(val);
132: } else if (cst instanceof Double) {
133: double val = ((Double) cst).doubleValue();
134: return newDouble(val);
135: } else if (cst instanceof String) {
136: return newString((String) cst);
137: } else if (cst instanceof Type) {
138: Type t = (Type) cst;
139: return newClass(t.getSort() == Type.OBJECT ? t
140: .getInternalName() : t.getDescriptor());
141: } else {
142: throw new IllegalArgumentException("value " + cst);
143: }
144: }
145:
146: public Constant newField(final String owner, final String name,
147: final String desc) {
148: key3.set('G', owner, name, desc);
149: Constant result = get(key3);
150: if (result == null) {
151: newClass(owner);
152: newNameType(name, desc);
153: result = new Constant(key3);
154: put(result);
155: }
156: return result;
157: }
158:
159: public Constant newMethod(final String owner, final String name,
160: final String desc, final boolean itf) {
161: key3.set(itf ? 'N' : 'M', owner, name, desc);
162: Constant result = get(key3);
163: if (result == null) {
164: newClass(owner);
165: newNameType(name, desc);
166: result = new Constant(key3);
167: put(result);
168: }
169: return result;
170: }
171:
172: public Constant newNameType(final String name, final String desc) {
173: key2.set('T', name, desc, null);
174: Constant result = get(key2);
175: if (result == null) {
176: newUTF8(name);
177: newUTF8(desc);
178: result = new Constant(key2);
179: put(result);
180: }
181: return result;
182: }
183:
184: private Constant get(final Constant key) {
185: return (Constant) get((Object) key);
186: }
187:
188: private void put(final Constant cst) {
189: put(cst, cst);
190: }
191: }
|