001: /*
002: * Copyright 2002-2003 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 sun.tools.javap;
027:
028: import java.util.*;
029: import java.io.*;
030:
031: /**
032: * Returns java type signature.
033: *
034: * @author Sucheta Dambalkar
035: */
036: public class TypeSignature {
037:
038: String parameters = null;
039: String returntype = null;
040: String fieldtype = null;
041: int argumentlength = 0;
042:
043: public TypeSignature(String JVMSignature) {
044:
045: if (JVMSignature != null) {
046: if (JVMSignature.indexOf("(") == -1) {
047: //This is a field type.
048: this .fieldtype = getFieldTypeSignature(JVMSignature);
049: } else {
050: String parameterdes = null;
051: if ((JVMSignature.indexOf(")") - 1) > (JVMSignature
052: .indexOf("("))) {
053: //Get parameter signature.
054: parameterdes = JVMSignature.substring(JVMSignature
055: .indexOf("(") + 1, JVMSignature
056: .indexOf(")"));
057: this .parameters = getParametersHelper(parameterdes);
058: } else
059: this .parameters = "()";
060: //Get return type signature.
061: String returndes = JVMSignature.substring(JVMSignature
062: .lastIndexOf(")") + 1);
063: this .returntype = getReturnTypeHelper(returndes);
064: }
065: }
066: }
067:
068: /**
069: * Returns java type signature of a field.
070: */
071: public String getFieldTypeSignature(String fielddes) {
072: if (fielddes.startsWith("L")) {
073: return (getObjectType(fielddes));
074: } else if (fielddes.startsWith("[")) {
075: return (getArrayType(fielddes));
076: } else
077: return (getBaseType(fielddes));
078: }
079:
080: /**
081: * Returns java type signature of a parameter.
082: */
083: public String getParametersHelper(String parameterdes) {
084: Vector parameters = new Vector();
085: int startindex = -1;
086: int endindex = -1;
087: String param = "";
088:
089: while (parameterdes != null) {
090:
091: if (parameterdes.startsWith("L")) {
092: //parameter is a object.
093: startindex = parameterdes.indexOf("L");
094: endindex = parameterdes.indexOf(";");
095: if (startindex < parameterdes.length()) {
096: if (endindex == parameterdes.length() - 1) {
097: //last parameter
098: param = parameterdes.substring(startindex);
099: parameterdes = null;
100: } else if (endindex + 1 < parameterdes.length()) {
101: //rest parameters
102: param = parameterdes.substring(startindex,
103: endindex + 1);
104: parameterdes = parameterdes
105: .substring(endindex + 1);
106:
107: }
108: parameters.add(getObjectType(param));
109: }
110: } else if (parameterdes.startsWith("[")) {
111: //parameter is an array.
112: String componentType = "";
113: int enddim = -1;
114: int st = 0;
115: while (true) {
116: if (st < parameterdes.length()) {
117: if (parameterdes.charAt(st) == '[') {
118:
119: enddim = st;
120: st++;
121: } else
122: break;
123: } else
124: break;
125: }
126:
127: if (enddim + 1 < parameterdes.length()) {
128: /* Array dimension.*/
129: param = parameterdes.substring(0, enddim + 1);
130:
131: }
132:
133: int stotherparam = param.lastIndexOf("[") + 1;
134:
135: if (stotherparam < parameterdes.length()) {
136: componentType = parameterdes
137: .substring(stotherparam);
138: }
139:
140: if (componentType.startsWith("L")) {
141: //parameter is array of objects.
142: startindex = parameterdes.indexOf("L");
143: endindex = parameterdes.indexOf(";");
144:
145: if (endindex == parameterdes.length() - 1) {
146: //last parameter
147: param += parameterdes.substring(startindex);
148: parameterdes = null;
149: } else if (endindex + 1 < parameterdes.length()) {
150: //rest parameters
151: param += parameterdes.substring(startindex,
152: endindex + 1);
153: parameterdes = parameterdes
154: .substring(endindex + 1);
155: }
156: } else {
157: //parameter is array of base type.
158: if (componentType.length() == 1) {
159: //last parameter.
160: param += componentType;
161: parameterdes = null;
162: } else if (componentType.length() > 1) {
163: //rest parameters.
164: param += componentType.substring(0, 1);
165: parameterdes = componentType.substring(1);
166: }
167: }
168: parameters.add(getArrayType(param));
169:
170: } else {
171:
172: //parameter is of base type.
173: if (parameterdes.length() == 1) {
174: //last parameter
175: param = parameterdes;
176: parameterdes = null;
177: } else if (parameterdes.length() > 1) {
178: //rest parameters.
179: param = parameterdes.substring(0, 1);
180: parameterdes = parameterdes.substring(1);
181: }
182: parameters.add(getBaseType(param));
183: }
184: }
185:
186: /* number of arguments of a method.*/
187: argumentlength = parameters.size();
188:
189: /* java type signature.*/
190: String parametersignature = "(";
191: int i;
192:
193: for (i = 0; i < parameters.size(); i++) {
194: parametersignature += (String) parameters.elementAt(i);
195: if (i != parameters.size() - 1) {
196: parametersignature += ", ";
197: }
198: }
199: parametersignature += ")";
200: return parametersignature;
201: }
202:
203: /**
204: * Returns java type signature for a return type.
205: */
206: public String getReturnTypeHelper(String returndes) {
207: return getFieldTypeSignature(returndes);
208: }
209:
210: /**
211: * Returns java type signature for a base type.
212: */
213: public String getBaseType(String baseType) {
214: if (baseType != null) {
215: if (baseType.equals("B"))
216: return "byte";
217: else if (baseType.equals("C"))
218: return "char";
219: else if (baseType.equals("D"))
220: return "double";
221: else if (baseType.equals("F"))
222: return "float";
223: else if (baseType.equals("I"))
224: return "int";
225: else if (baseType.equals("J"))
226: return "long";
227: else if (baseType.equals("S"))
228: return "short";
229: else if (baseType.equals("Z"))
230: return "boolean";
231: else if (baseType.equals("V"))
232: return "void";
233: }
234: return null;
235: }
236:
237: /**
238: * Returns java type signature for a object type.
239: */
240: public String getObjectType(String JVMobjectType) {
241: String objectType = "";
242: int startindex = JVMobjectType.indexOf("L") + 1;
243: int endindex = JVMobjectType.indexOf(";");
244: if ((startindex != -1) && (endindex != -1)) {
245: if ((startindex < JVMobjectType.length())
246: && (endindex < JVMobjectType.length())) {
247: objectType = JVMobjectType.substring(startindex,
248: endindex);
249: }
250: objectType = objectType.replace('/', '.');
251: return objectType;
252: }
253: return null;
254: }
255:
256: /**
257: * Returns java type signature for array type.
258: */
259: public String getArrayType(String arrayType) {
260: if (arrayType != null) {
261: String dimention = "";
262:
263: while (arrayType.indexOf("[") != -1) {
264: dimention += "[]";
265:
266: int startindex = arrayType.indexOf("[") + 1;
267: if (startindex <= arrayType.length()) {
268: arrayType = arrayType.substring(startindex);
269: }
270: }
271:
272: String componentType = "";
273: if (arrayType.startsWith("L")) {
274: componentType = getObjectType(arrayType);
275: } else {
276: componentType = getBaseType(arrayType);
277: }
278: return componentType + dimention;
279: }
280: return null;
281: }
282:
283: /**
284: * Returns java type signature for parameters.
285: */
286: public String getParameters() {
287: return parameters;
288: }
289:
290: /**
291: * Returns java type signature for return type.
292: */
293: public String getReturnType() {
294: return returntype;
295: }
296:
297: /**
298: * Returns java type signature for field type.
299: */
300: public String getFieldType() {
301: return fieldtype;
302: }
303:
304: /**
305: * Return number of arguments of a method.
306: */
307: public int getArgumentlength() {
308: return argumentlength;
309: }
310: }
|