1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import java.lang.reflect.Method;
25 import java.util.ArrayList;
26
27 public class MethodIdentifierParser {
28
29 private String logString;
30 private String className;
31 private String methodName;
32 private String methodDescriptor;
33
34 /**
35 * This is a utility class for parsing the log entries for a method. It supplies
36 * a few select methods for reflecting the class and method from that information.
37 *
38 * Example log entries:
39 * "java.util.TreeMap.successor(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;"
40 */
41
42 public MethodIdentifierParser(String logString) {
43 this.logString = logString;
44
45 int i = logString.lastIndexOf("."); // find start of method name
46 className = logString.substring(0, i); // classname is everything before
47 int i2 = logString.indexOf("("); // Signature starts with an '('
48 methodName = logString.substring(i+1, i2);
49 methodDescriptor = logString.substring(i2, logString.length());
50
51 // Add sanity check for extracted fields
52 }
53
54 public Method getMethod() throws NoSuchMethodException, SecurityException, ClassNotFoundException, Exception {
55 try {
56 return Class.forName(className).getDeclaredMethod(methodName, getParamenterDescriptorArray());
57 } catch (UnexpectedTokenException e) {
58 throw new Exception("Parse failed");
59 }
60 }
61
62 public Class<?>[] getParamenterDescriptorArray() throws ClassNotFoundException, UnexpectedTokenException {
63 ParameterDecriptorIterator s = new ParameterDecriptorIterator(methodDescriptor);
64 Class<?> paramType;
65 ArrayList<Class<?>> list = new ArrayList<Class<?>>();
66 while ((paramType = s.nextParamType()) != null) {
67 list.add(paramType);
68 }
69 if (list.size() > 0) {
70 return list.toArray(new Class<?>[list.size()]);
71 } else {
72 return null;
73 }
74 }
75
76 class ParameterDecriptorIterator {
77
78 // This class uses charAt() indexing for startMark and i
79 // That is when i points to the last char it can be retrieved with
80 // charAt(i). Including the last char for a subString requires
81 // substring(startMark, i+1);
82
83 private String methodDescriptor;
84 private int startMark;
85
86 public ParameterDecriptorIterator(String signature) {
87 this.methodDescriptor = signature;
88 this.startMark = 0;
89 if (signature.charAt(0) == '(') {
90 this.startMark = 1;
91 }
92 }
93
94 public Class<?> nextParamType() throws UnexpectedTokenException {
95 int i = startMark;
96 while (methodDescriptor.length() > i) {
97 switch (methodDescriptor.charAt(i)) {
98 case 'C':
99 case 'B':
100 case 'I':
101 case 'J':
102 case 'Z':
103 case 'F':
104 case 'D':
105 case 'S':
106 // Primitive class case, but we may have gotten here with [ as first token
107 break;
108 case 'L':
109 // Internal class name suffixed by ';'
110 while (methodDescriptor.charAt(i) != ';') {
111 i++;
112 }
113 break;
114 case '[':
115 i++; // arrays -> do another pass
116 continue;
117 case ')':
118 return null; // end found
119 case 'V':
120 case ';':
121 default:
122 throw new UnexpectedTokenException(methodDescriptor, i);
123 }
124 break;
125 }
126 if (i == startMark) {
127 // Single char -> primitive class case
128 startMark++; // Update for next iteration
129 switch (methodDescriptor.charAt(i)) {
130 case 'C':
131 return char.class;
132 case 'B':
133 return byte.class;
134 case 'I':
135 return int.class;
136 case 'J':
137 return long.class;
138 case 'F':
139 return float.class;
140 case 'D':
141 return double.class;
142 case 'S':
143 return short.class;
144 case 'Z':
145 return boolean.class;
146 default:
147 throw new UnexpectedTokenException(methodDescriptor, i);
148 }
149 } else {
150 // Multi char case
151 String nextParam;
152 if (methodDescriptor.charAt(startMark) == 'L') {
153 // When reflecting a class the leading 'L' and trailing';' must be removed.
154 // (When reflecting an array of classes, they must remain...)
155 nextParam = methodDescriptor.substring(startMark+1, i);
156 } else {
157 // Any kind of array - simple case, use whole descriptor when reflecting.
158 nextParam = methodDescriptor.substring(startMark, i+1);
159 }
160 startMark = ++i; // Update for next iteration
161 try {
162 // The parameter descriptor uses JVM internal class identifier with '/' as
163 // package separator, but Class.forName expects '.'.
164 nextParam = nextParam.replace('/', '.');
165 return Class.forName(nextParam);
166 } catch (ClassNotFoundException e) {
167 System.out.println("Class not Found: " + nextParam);
168 return null;
169 }
170 }
171 }
172 }
173
174 class UnexpectedTokenException extends Exception {
175 String descriptor;
176 int i;
177 public UnexpectedTokenException(String descriptor, int i) {
178 this.descriptor = descriptor;
179 this.i = i;
180 }
181
182 @Override
183 public String toString() {
184 return "Unexpected token at: " + i + " in signature: " + descriptor;
185 }
186
187 private static final long serialVersionUID = 1L;
188 }
189
190 public void debugPrint() {
191 System.out.println("mlf in: " + logString);
192 System.out.println("mlf class: " + className);
193 System.out.println("mlf method: " + methodName);
194 System.out.println("mlf methodDescriptor: " + methodDescriptor);
195 }
196 }