Wed, 02 Jul 2008 12:56:02 -0700
6719955: Update copyright year
Summary: Update copyright year for files that have been modified in 2008
Reviewed-by: ohair, tbell
1 /*
2 * Copyright 2002-2008 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
27 package sun.tools.javap;
29 import java.util.*;
30 import java.io.*;
32 /**
33 * Returns java type signature.
34 *
35 * @author Sucheta Dambalkar
36 */
37 public class TypeSignature {
39 String parameters = null;
40 String returntype = null;
41 String fieldtype = null;
42 int argumentlength = 0;
44 public TypeSignature(String JVMSignature){
46 if(JVMSignature != null){
47 if(JVMSignature.indexOf("(") == -1){
48 //This is a field type.
49 this.fieldtype = getFieldTypeSignature(JVMSignature);
50 }else {
51 String parameterdes = null;
52 if((JVMSignature.indexOf(")")-1) > (JVMSignature.indexOf("("))){
53 //Get parameter signature.
54 parameterdes =
55 JVMSignature.substring(JVMSignature.indexOf("(")+1,
56 JVMSignature.indexOf(")"));
57 this.parameters = getParametersHelper(parameterdes);
58 }else this.parameters = "()";
59 //Get return type signature.
60 String returndes = JVMSignature.substring(JVMSignature.lastIndexOf(")")+1);
61 this.returntype = getReturnTypeHelper(returndes);
62 }
63 }
64 }
66 /**
67 * Returns java type signature of a field.
68 */
69 public String getFieldTypeSignature(String fielddes){
70 if(fielddes.startsWith("L")){
71 return(getObjectType(fielddes));
72 }else if(fielddes.startsWith("[")){
73 return(getArrayType(fielddes));
74 }else
75 return(getBaseType(fielddes));
76 }
78 /**
79 * Returns java type signature of a parameter.
80 */
81 public String getParametersHelper(String parameterdes){
82 Vector<String> parameters = new Vector<String>();
83 int startindex = -1;
84 int endindex = -1;
85 String param = "";
87 while(parameterdes != null){
89 if(parameterdes.startsWith("L")){
90 //parameter is a object.
91 startindex = parameterdes.indexOf("L");
92 endindex = parameterdes.indexOf(";");
93 if(startindex < parameterdes.length()) {
94 if(endindex == parameterdes.length()-1) {
95 //last parameter
96 param = parameterdes.substring(startindex);
97 parameterdes = null;
98 }else if(endindex+1 < parameterdes.length()){
99 //rest parameters
100 param = parameterdes.substring(startindex, endindex+1);
101 parameterdes = parameterdes.substring(endindex+1);
103 }
104 parameters.add(getObjectType(param));
105 }
106 }else if(parameterdes.startsWith("[")){
107 //parameter is an array.
108 String componentType = "";
109 int enddim = -1;
110 int st = 0;
111 while(true){
112 if(st < parameterdes.length()){
113 if(parameterdes.charAt(st) == '['){
115 enddim = st;
116 st++;
117 }
118 else break;
119 }
120 else break;
121 }
123 if(enddim+1 < parameterdes.length()){
124 /* Array dimension.*/
125 param = parameterdes.substring(0,enddim+1);
127 }
129 int stotherparam = param.lastIndexOf("[")+1;
131 if(stotherparam < parameterdes.length()){
132 componentType = parameterdes.substring(stotherparam);
133 }
135 if(componentType.startsWith("L")){
136 //parameter is array of objects.
137 startindex = parameterdes.indexOf("L");
138 endindex = parameterdes.indexOf(";");
140 if(endindex == parameterdes.length()-1){
141 //last parameter
142 param += parameterdes.substring(startindex);
143 parameterdes = null;
144 }else if(endindex+1 < parameterdes.length()){
145 //rest parameters
146 param += parameterdes.substring(startindex, endindex+1);
147 parameterdes = parameterdes.substring(endindex+1);
148 }
149 }else{
150 //parameter is array of base type.
151 if(componentType.length() == 1){
152 //last parameter.
153 param += componentType;
154 parameterdes = null;
155 }
156 else if (componentType.length() > 1) {
157 //rest parameters.
158 param += componentType.substring(0,1);
159 parameterdes = componentType.substring(1);
160 }
161 }
162 parameters.add(getArrayType(param));
165 }else {
167 //parameter is of base type.
168 if(parameterdes.length() == 1){
169 //last parameter
170 param = parameterdes;
171 parameterdes = null;
172 }
173 else if (parameterdes.length() > 1) {
174 //rest parameters.
175 param = parameterdes.substring(0,1);
176 parameterdes = parameterdes.substring(1);
177 }
178 parameters.add(getBaseType(param));
179 }
180 }
182 /* number of arguments of a method.*/
183 argumentlength = parameters.size();
185 /* java type signature.*/
186 String parametersignature = "(";
187 int i;
189 for(i = 0; i < parameters.size(); i++){
190 parametersignature += parameters.elementAt(i);
191 if(i != parameters.size()-1){
192 parametersignature += ", ";
193 }
194 }
195 parametersignature += ")";
196 return parametersignature;
197 }
199 /**
200 * Returns java type signature for a return type.
201 */
202 public String getReturnTypeHelper(String returndes){
203 return getFieldTypeSignature(returndes);
204 }
206 /**
207 * Returns java type signature for a base type.
208 */
209 public String getBaseType(String baseType){
210 if(baseType != null){
211 if(baseType.equals("B")) return "byte";
212 else if(baseType.equals("C")) return "char";
213 else if(baseType.equals("D")) return "double";
214 else if(baseType.equals("F")) return "float";
215 else if(baseType.equals("I")) return "int";
216 else if(baseType.equals("J")) return "long";
217 else if(baseType.equals("S")) return "short";
218 else if(baseType.equals("Z")) return "boolean";
219 else if(baseType.equals("V")) return "void";
220 }
221 return null;
222 }
224 /**
225 * Returns java type signature for a object type.
226 */
227 public String getObjectType(String JVMobjectType) {
228 String objectType = "";
229 int startindex = JVMobjectType.indexOf("L")+1;
230 int endindex = JVMobjectType.indexOf(";");
231 if((startindex != -1) && (endindex != -1)){
232 if((startindex < JVMobjectType.length()) && (endindex < JVMobjectType.length())){
233 objectType = JVMobjectType.substring(startindex, endindex);
234 }
235 objectType = objectType.replace('/','.');
236 return objectType;
237 }
238 return null;
239 }
241 /**
242 * Returns java type signature for array type.
243 */
244 public String getArrayType(String arrayType) {
245 if(arrayType != null){
246 String dimention = "";
248 while(arrayType.indexOf("[") != -1){
249 dimention += "[]";
251 int startindex = arrayType.indexOf("[")+1;
252 if(startindex <= arrayType.length()){
253 arrayType = arrayType.substring(startindex);
254 }
255 }
257 String componentType = "";
258 if(arrayType.startsWith("L")){
259 componentType = getObjectType(arrayType);
260 }else {
261 componentType = getBaseType(arrayType);
262 }
263 return componentType+dimention;
264 }
265 return null;
266 }
268 /**
269 * Returns java type signature for parameters.
270 */
271 public String getParameters(){
272 return parameters;
273 }
275 /**
276 * Returns java type signature for return type.
277 */
278 public String getReturnType(){
279 return returntype;
280 }
282 /**
283 * Returns java type signature for field type.
284 */
285 public String getFieldType(){
286 return fieldtype;
287 }
289 /**
290 * Return number of arguments of a method.
291 */
292 public int getArgumentlength(){
293 return argumentlength;
294 }
295 }