| author | shurailine |
| Tue, 21 Feb 2017 15:38:07 -0800 | |
| changeset 44015 | 27aa35eb727c |
| parent 38838 | 3d6ea76b35d6 |
| permissions | -rw-r--r-- |
| 33919 | 1 |
/* |
|
37641
6949903ba85a
8151777: Add "@index" tag to the sampleapi generator
ksrini
parents:
35426
diff
changeset
|
2 |
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. |
| 33919 | 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 |
package sampleapi.generator; |
|
25 |
||
26 |
import java.io.File; |
|
27 |
import java.io.FileWriter; |
|
28 |
import java.io.IOException; |
|
29 |
import java.util.ArrayList; |
|
| 38838 | 30 |
import java.util.HashMap; |
31 |
import java.util.Map; |
|
| 33919 | 32 |
import javax.xml.parsers.DocumentBuilderFactory; |
33 |
import org.w3c.dom.Element; |
|
34 |
import org.w3c.dom.Node; |
|
35 |
import org.w3c.dom.NodeList; |
|
36 |
||
37 |
import com.sun.source.util.JavacTask; |
|
38 |
import com.sun.tools.javac.api.JavacTool; |
|
39 |
import com.sun.tools.javac.api.JavacTaskImpl; |
|
40 |
import com.sun.tools.javac.util.Context; |
|
41 |
import com.sun.tools.javac.util.Name; |
|
42 |
import com.sun.tools.javac.util.Names; |
|
43 |
import com.sun.tools.javac.util.List; |
|
44 |
import com.sun.tools.javac.util.ListBuffer; |
|
45 |
import com.sun.tools.javac.tree.TreeMaker; |
|
46 |
import com.sun.tools.javac.tree.JCTree; |
|
47 |
import com.sun.tools.javac.tree.JCTree.*; |
|
48 |
import com.sun.tools.javac.code.Flags; |
|
49 |
import com.sun.tools.javac.code.Type; |
|
50 |
import com.sun.tools.javac.code.TypeTag; |
|
51 |
import com.sun.tools.javac.code.Symbol; |
|
52 |
import com.sun.tools.javac.code.Symtab; |
|
| 44015 | 53 |
import java.nio.file.Path; |
| 33919 | 54 |
|
55 |
import sampleapi.util.*; |
|
56 |
||
57 |
public class PackageGenerator {
|
|
58 |
||
| 44015 | 59 |
public String packageName; |
| 33919 | 60 |
String packageDirName; |
| 44015 | 61 |
public String id; |
| 33919 | 62 |
|
63 |
ArrayList<JCCompilationUnit> topLevels; |
|
| 38838 | 64 |
Map<String, Integer> nameIndex; |
| 44015 | 65 |
public Map<String, JCClassDecl> idBases; |
| 38838 | 66 |
Map<String, JCAnnotation> idAnnos; |
| 33919 | 67 |
|
68 |
TreeMaker make; |
|
69 |
Names names; |
|
70 |
Symtab syms; |
|
71 |
DocumentBuilderFactory factory; |
|
72 |
Documentifier documentifier; |
|
| 38838 | 73 |
boolean fx; |
| 33919 | 74 |
|
75 |
public PackageGenerator() {
|
|
76 |
JavacTool jt = JavacTool.create(); |
|
77 |
JavacTask task = jt.getTask(null, null, null, null, null, null); |
|
78 |
Context ctx = ((JavacTaskImpl)task).getContext(); |
|
79 |
||
80 |
make = TreeMaker.instance(ctx); |
|
81 |
names = Names.instance(ctx); |
|
82 |
syms = Symtab.instance(ctx); |
|
83 |
factory = DocumentBuilderFactory.newInstance(); |
|
84 |
||
85 |
documentifier = Documentifier.instance(ctx); |
|
86 |
} |
|
87 |
||
| 38838 | 88 |
boolean isDataSetProcessed = false; |
| 33919 | 89 |
|
| 44015 | 90 |
public static PackageGenerator processDataSet(Element rootElement) {
|
91 |
PackageGenerator result = new PackageGenerator(); |
|
92 |
result.isDataSetProcessed = true; |
|
93 |
result.topLevels = new ArrayList<>(); |
|
94 |
result.nameIndex = new HashMap<>(); |
|
95 |
result.idBases = new HashMap<>(); |
|
96 |
result.idAnnos = new HashMap<>(); |
|
97 |
result.fx = false; |
|
98 |
||
99 |
if (!rootElement.getTagName().equals("package")) {
|
|
100 |
throw new IllegalStateException("Unexpected tag name: "
|
|
101 |
+ rootElement.getTagName()); |
|
102 |
} |
|
103 |
result.packageName = rootElement.getAttribute("name");
|
|
104 |
result.id = rootElement.getAttribute("id");
|
|
105 |
result.fx = "fx".equals(rootElement.getAttribute("style"));
|
|
106 |
result.packageDirName = result.packageName.replace('.', '/');
|
|
107 |
||
108 |
// process nodes (toplevels) |
|
109 |
NodeList nodeList = rootElement.getChildNodes(); |
|
110 |
for (int i = 0; i < nodeList.getLength(); i++) {
|
|
111 |
Node node = nodeList.item(i); |
|
112 |
||
113 |
if (!(node instanceof Element)) {
|
|
114 |
continue; |
|
115 |
} |
|
116 |
result.processTopLevel((Element) node); |
|
117 |
} |
|
118 |
return result; |
|
119 |
} |
|
120 |
||
121 |
public void generate(Path outDir) {
|
|
122 |
if (!isDataSetProcessed) |
|
123 |
throw new RuntimeException("No Data Set processed");
|
|
| 33919 | 124 |
|
125 |
try {
|
|
| 44015 | 126 |
File pkgDir = new File(outDir.toFile(), packageDirName); |
| 33919 | 127 |
pkgDir.mkdirs(); |
128 |
||
129 |
for (JCCompilationUnit decl : topLevels) {
|
|
| 38838 | 130 |
JCClassDecl classDecl = (JCClassDecl) decl.getTypeDecls().get(0); |
131 |
File outFile |
|
132 |
= new File(pkgDir, classDecl.getSimpleName().toString() + ".java"); |
|
| 33919 | 133 |
FileWriter writer = new FileWriter(outFile); |
134 |
writer.write(decl.toString()); |
|
135 |
writer.flush(); |
|
136 |
writer.close(); |
|
137 |
} |
|
138 |
||
139 |
// package-info |
|
140 |
File outFile = new File(pkgDir, "package-info.java"); |
|
141 |
FileWriter writer = new FileWriter(outFile); |
|
142 |
writer.write("/**\n");
|
|
143 |
writer.write(documentifier.getDocGenerator().getPackageComment()); |
|
144 |
writer.write("*/\n");
|
|
| 38838 | 145 |
writer.write("package " + packageName + ";\n");
|
146 |
writer.flush(); |
|
147 |
writer.close(); |
|
148 |
||
149 |
// overview |
|
150 |
outFile = new File(pkgDir, "overview.html"); |
|
151 |
writer = new FileWriter(outFile); |
|
152 |
writer.write("<html>\n");
|
|
153 |
writer.write("<head>\n<title>" + packageName + "</title>\n</head>\n");
|
|
154 |
writer.write("<body>\n");
|
|
155 |
writer.write("<p>Package " + packageName + " overview.\n");
|
|
156 |
writer.write("</body>\n");
|
|
157 |
writer.write("</html>\n");
|
|
| 33919 | 158 |
writer.flush(); |
159 |
writer.close(); |
|
160 |
} catch (IOException e) {
|
|
| 44015 | 161 |
throw new RuntimeException("Error writing output");
|
| 33919 | 162 |
} |
163 |
} |
|
164 |
||
165 |
// levels' processing methods |
|
166 |
||
167 |
void processTopLevel(Element tlTag) {
|
|
168 |
String kind = tlTag.getTagName(); |
|
169 |
||
170 |
if (kind.equals("annodecl")) {
|
|
171 |
// decls stored separately, does not affect bases |
|
172 |
String declId = tlTag.getAttribute("id");
|
|
173 |
if (!declId.startsWith("@"))
|
|
174 |
declId = "@" + declId; |
|
175 |
idAnnos.put(declId, processAnnoDecl(tlTag)); |
|
176 |
return; |
|
177 |
} |
|
178 |
||
179 |
ListBuffer<JCTree>[] bases = processBases(tlTag, null); |
|
180 |
||
181 |
for (JCTree base : bases[0]) { // [0] - bases namely
|
|
182 |
JCPackageDecl pkg = make.PackageDecl( |
|
183 |
List.<JCAnnotation>nil(), |
|
184 |
make.QualIdent( |
|
185 |
new Symbol.PackageSymbol( |
|
186 |
names.fromString(packageName), |
|
187 |
null))); |
|
188 |
ListBuffer<JCTree> topLevelParts = new ListBuffer<>(); |
|
189 |
topLevelParts.append(pkg); |
|
190 |
topLevelParts.appendList(bases[1]); // [1] imports |
|
191 |
topLevelParts.append(base); |
|
192 |
||
193 |
JCCompilationUnit topLevel = make.TopLevel(topLevelParts.toList()); |
|
194 |
documentifier.documentify(topLevel, fx); |
|
195 |
topLevels.add(topLevel); |
|
196 |
} |
|
197 |
} |
|
198 |
||
| 38838 | 199 |
ListBuffer<JCTree>[] processBases(Element baseTag, HashMap<String, Integer> scope) {
|
| 33919 | 200 |
String kind = baseTag.getTagName(); |
201 |
String baseName = baseTag.getAttribute("basename");
|
|
202 |
String typeParam = baseTag.getAttribute("tparam");
|
|
203 |
String baseId = baseTag.getAttribute("id");
|
|
| 44015 | 204 |
System.out.println("Found class id: " + baseId);
|
| 33919 | 205 |
|
206 |
long kindFlag = 0; |
|
207 |
switch (kind) {
|
|
208 |
case "class": |
|
209 |
// no flags for class |
|
210 |
break; |
|
211 |
case "interface": |
|
212 |
kindFlag |= Flags.INTERFACE; |
|
213 |
break; |
|
214 |
case "enum": |
|
215 |
kindFlag |= Flags.ENUM; |
|
216 |
break; |
|
217 |
case "annotation": |
|
218 |
kindFlag |= Flags.ANNOTATION | Flags.INTERFACE; |
|
219 |
break; |
|
220 |
} |
|
221 |
||
222 |
// go through other nodes; add modifiers to multiplier |
|
223 |
NodeList nodes = baseTag.getChildNodes(); |
|
224 |
ListBuffer<JCTree> bases = new ListBuffer<>(); |
|
225 |
ListBuffer<JCTree> members = new ListBuffer<>(); |
|
226 |
ListBuffer<JCTree> imports = new ListBuffer<>(); |
|
227 |
JCExpression extType = null; |
|
228 |
ListBuffer<JCExpression> implTypes = new ListBuffer<>(); |
|
229 |
SimpleMultiplier multiply = new SimpleMultiplier(); |
|
230 |
for (int i = 0; i < nodes.getLength(); i++) {
|
|
231 |
Node node = nodes.item(i); |
|
232 |
||
233 |
if (!(node instanceof Element)) |
|
234 |
continue; |
|
| 38838 | 235 |
Element element = (Element)node; |
236 |
switch (element.getTagName()) {
|
|
| 33919 | 237 |
case "modifier": |
| 38838 | 238 |
multiply.addAxis(element.getTextContent()); |
| 33919 | 239 |
break; |
240 |
case "anno": |
|
| 38838 | 241 |
multiply.addAxis(element.getTextContent()); |
| 33919 | 242 |
break; |
243 |
case "member": |
|
244 |
// process members here |
|
| 38838 | 245 |
members.appendList(processMembers(element, baseName, kind)); |
| 33919 | 246 |
break; |
247 |
case "extend": |
|
| 38838 | 248 |
String classId = element.getAttribute("id"); // this pkg
|
249 |
String classRef = element.getAttribute("ref"); // external
|
|
| 33919 | 250 |
if (classId.length() !=0 && |
251 |
idBases.containsKey(classId)) {
|
|
252 |
// if have base, take methods from base members |
|
253 |
JCClassDecl baseDecl = idBases.get(classId); |
|
254 |
extType = make.Type( |
|
255 |
getTypeByName( |
|
256 |
baseDecl.getSimpleName().toString())); |
|
257 |
members.appendList(processMethods(baseDecl.getMembers(), false)); |
|
258 |
} else if (classRef.length() !=0) {
|
|
259 |
extType = make.Type(getTypeByName(classRef)); |
|
260 |
} |
|
261 |
break; |
|
262 |
case "implement": |
|
| 38838 | 263 |
String interfaceId = element.getAttribute("id");
|
264 |
String interfaceRef = element.getAttribute("ref");
|
|
| 33919 | 265 |
if (interfaceId.length() != 0 && |
266 |
idBases.containsKey(interfaceId)) {
|
|
267 |
JCClassDecl baseDecl = idBases.get(interfaceId); |
|
268 |
implTypes.add( |
|
269 |
make.Type( |
|
270 |
getTypeByName( |
|
271 |
baseDecl.getSimpleName().toString()))); |
|
272 |
members.appendList(processMethods(baseDecl.getMembers(), true)); |
|
273 |
} else if (interfaceRef.length() != 0) {
|
|
274 |
implTypes.add(make.Type(getTypeByName(interfaceRef))); |
|
275 |
} |
|
276 |
break; |
|
277 |
case "import": |
|
278 |
imports.append( |
|
279 |
make.Import( |
|
| 38838 | 280 |
make.Ident(names.fromString(element.getTextContent())), |
| 33919 | 281 |
false)); |
282 |
} |
|
283 |
} |
|
284 |
||
285 |
// process modifiers through multiplier |
|
286 |
multiply.initIterator(); |
|
287 |
while (multiply.hasNext()) {
|
|
288 |
ArrayList<String> tuple = multiply.getNext(); |
|
289 |
||
290 |
long declFlags = kindFlag; |
|
291 |
ListBuffer<JCAnnotation> annos = new ListBuffer<>(); |
|
292 |
for (String modifier : tuple) {
|
|
293 |
if (modifier.startsWith("@") && idAnnos.containsKey(modifier))
|
|
294 |
annos.add(idAnnos.get(modifier)); // it's anno |
|
295 |
else |
|
296 |
declFlags |= getFlagByName(modifier); // it's modifier |
|
297 |
} |
|
298 |
||
299 |
String declName = (scope == null) |
|
300 |
? getUniqName(baseName) |
|
301 |
: baseName + getUniqIndex(scope, baseName); |
|
302 |
JCClassDecl baseDecl = make.ClassDef( |
|
303 |
make.Modifiers(declFlags, annos.toList()), |
|
304 |
names.fromString(declName), |
|
305 |
processTypeParams(typeParam), // type params |
|
306 |
extType, // ext |
|
307 |
implTypes.toList(), // impl |
|
308 |
members.toList()); // members |
|
309 |
||
310 |
// fix constructors names |
|
311 |
fixConstructorNames(baseDecl); |
|
312 |
||
313 |
bases.append(baseDecl); |
|
314 |
||
315 |
// for non-empty ids store first base occurence from multiplied sequence |
|
316 |
if (baseId.length() != 0) {
|
|
317 |
idBases.put(baseId, baseDecl); |
|
318 |
baseId = ""; |
|
319 |
} |
|
320 |
} |
|
321 |
||
322 |
return new ListBuffer[] { bases, imports };
|
|
323 |
} |
|
324 |
||
325 |
List<JCTypeParameter> processTypeParams(String typeParams) {
|
|
326 |
||
327 |
if (typeParams == null || typeParams.length() == 0) |
|
328 |
return List.<JCTypeParameter>nil(); // empty |
|
329 |
||
330 |
String[] typeVarsArr = typeParams.split(",");
|
|
331 |
ListBuffer<JCTypeParameter> typeParamsDecls = new ListBuffer<>(); |
|
332 |
||
333 |
for (String typeVar : typeVarsArr) {
|
|
334 |
typeParamsDecls.add( |
|
335 |
make.TypeParameter(names.fromString(typeVar), |
|
336 |
List.<JCExpression>nil())); |
|
337 |
} |
|
338 |
||
339 |
return typeParamsDecls.toList(); |
|
340 |
} |
|
341 |
||
342 |
ListBuffer<JCTree> processMembers(Element memberTag, String name, String kind) {
|
|
343 |
ListBuffer<JCTree> members = new ListBuffer<>(); |
|
344 |
NodeList nodes = memberTag.getChildNodes(); |
|
| 38838 | 345 |
HashMap<String, Integer> scope = new HashMap<>(); |
| 33919 | 346 |
for (int i = 0; i < nodes.getLength(); i++) {
|
347 |
Node node = nodes.item(i); |
|
348 |
||
349 |
if (!(node instanceof Element)) |
|
350 |
continue; |
|
351 |
||
352 |
switch (((Element)node).getTagName()) {
|
|
353 |
case "field": |
|
354 |
members.appendList(processFields((Element)node, scope)); |
|
355 |
break; |
|
356 |
case "serialfield": |
|
357 |
members.append(processSerialFields((Element)node)); |
|
358 |
break; |
|
359 |
case "constant": |
|
360 |
members.appendList(processConstants((Element)node, scope)); |
|
361 |
break; |
|
362 |
case "constructor": |
|
363 |
members.appendList(processMethods((Element)node, scope, true, true)); |
|
364 |
break; |
|
365 |
case "method": |
|
366 |
boolean needBody = kind.equals("class") || kind.equals("enum");
|
|
367 |
members.appendList(processMethods((Element)node, scope, needBody, false)); |
|
368 |
break; |
|
369 |
case "class": |
|
370 |
case "interface": |
|
371 |
case "enum": |
|
372 |
case "annotation": |
|
373 |
members.appendList(processBases((Element)node, scope)[0]); |
|
374 |
break; |
|
375 |
} |
|
376 |
} |
|
377 |
||
378 |
return members; |
|
379 |
} |
|
380 |
||
| 38838 | 381 |
ListBuffer<JCTree> processFields(Element fieldsNode, HashMap<String, Integer> scope) {
|
| 33919 | 382 |
String kind = fieldsNode.getTagName(); |
383 |
String baseName = fieldsNode.getAttribute("basename");
|
|
384 |
||
385 |
ListBuffer<JCTree> fields = new ListBuffer<>(); |
|
386 |
NodeList nodes = fieldsNode.getChildNodes(); |
|
387 |
SimpleMultiplier multiply = new SimpleMultiplier(); // for modifiers |
|
388 |
String[] types = new String[] {};
|
|
389 |
for (int i = 0; i < nodes.getLength(); i++) {
|
|
390 |
Node node = nodes.item(i); |
|
391 |
||
392 |
if (!(node instanceof Element)) |
|
393 |
continue; |
|
394 |
||
395 |
// parse type and modifiers |
|
396 |
switch (((Element)node).getTagName()) {
|
|
397 |
case "modifier": |
|
398 |
multiply.addAxis(((Element)node).getTextContent()); |
|
399 |
break; |
|
400 |
case "anno": |
|
401 |
multiply.addAxis(((Element)node).getTextContent()); |
|
402 |
case "type": |
|
403 |
types = ((Element)node).getTextContent().split("\\|");
|
|
404 |
break; |
|
405 |
} |
|
406 |
} |
|
407 |
||
408 |
// process through modifiers and types |
|
409 |
multiply.initIterator(); |
|
410 |
while (multiply.hasNext()) {
|
|
411 |
ArrayList<String> tuple = multiply.getNext(); |
|
412 |
||
413 |
long declFlags = 0; |
|
414 |
ListBuffer<JCAnnotation> annos = new ListBuffer<>(); |
|
415 |
for (String modifier : tuple) {
|
|
416 |
if (modifier.startsWith("@") && idAnnos.containsKey(modifier))
|
|
417 |
annos.add(idAnnos.get(modifier)); // it's anno |
|
418 |
else |
|
419 |
declFlags |= getFlagByName(modifier); // it's modifier |
|
420 |
} |
|
421 |
||
422 |
||
423 |
for (String type : types) {
|
|
424 |
String declName = baseName + getUniqIndex(scope, baseName); |
|
425 |
||
426 |
Type initType = getTypeByName(type); |
|
427 |
JCExpression initExpr = null; |
|
428 |
if ((declFlags & Flags.STATIC) != 0) // static to be initialized |
|
429 |
initExpr = make.Literal(initType.isPrimitive() ? |
|
430 |
initType.getTag() : |
|
431 |
TypeTag.BOT, |
|
432 |
"String".equals(type) |
|
433 |
? new String("blah-blah-blah")
|
|
| 38838 | 434 |
: Integer.valueOf(0)); |
| 33919 | 435 |
|
436 |
JCVariableDecl fieldDecl = make.VarDef( |
|
437 |
make.Modifiers(declFlags, annos.toList()), |
|
438 |
names.fromString(declName), |
|
439 |
make.Type(getTypeByName(type)), |
|
440 |
initExpr); |
|
441 |
||
442 |
fields.append(fieldDecl); |
|
443 |
} |
|
444 |
} |
|
445 |
||
446 |
return fields; |
|
447 |
} |
|
448 |
||
449 |
JCTree processSerialFields(Element sfNode) {
|
|
450 |
String baseName = sfNode.getAttribute("basename");
|
|
451 |
String[] fieldTypes = sfNode.getTextContent().split(",");
|
|
452 |
||
453 |
ListBuffer<JCExpression> serialFields = new ListBuffer<>(); |
|
| 38838 | 454 |
HashMap<String, Integer> scope = new HashMap<>(); |
| 33919 | 455 |
|
456 |
for (String fType : fieldTypes) {
|
|
457 |
String fieldName = baseName + getUniqIndex(scope, baseName); |
|
458 |
serialFields.add( |
|
459 |
make.NewClass( |
|
460 |
null, |
|
461 |
null, |
|
462 |
make.Type(getTypeByName("ObjectStreamField")),
|
|
463 |
List.from( |
|
464 |
new JCTree.JCExpression[] {
|
|
465 |
make.Literal(fieldName), |
|
466 |
make.Ident(names.fromString(fType + ".class")) |
|
467 |
}), |
|
468 |
null)); |
|
469 |
} |
|
470 |
||
471 |
JCTree sfDecl = make.VarDef( |
|
472 |
make.Modifiers( |
|
473 |
Flags.PRIVATE | Flags.STATIC | Flags.FINAL), |
|
474 |
names.fromString("serialPersistentFields"),
|
|
475 |
make.TypeArray( |
|
476 |
make.Type(getTypeByName("ObjectStreamField"))),
|
|
477 |
make.NewArray( |
|
478 |
null, |
|
479 |
List.<JCExpression>nil(), |
|
480 |
serialFields.toList())); |
|
481 |
||
482 |
return sfDecl; |
|
483 |
} |
|
484 |
||
| 38838 | 485 |
ListBuffer<JCTree> processConstants(Element constNode, HashMap<String, Integer> scope) {
|
| 33919 | 486 |
String baseName = constNode.getAttribute("basename");
|
487 |
int count = 1; |
|
488 |
try {
|
|
489 |
count = Integer.parseInt(constNode.getAttribute("count"));
|
|
490 |
} catch (Exception e) {} // nothing to do, will use count = 1
|
|
491 |
||
492 |
long declFlags = Flags.PUBLIC | Flags.STATIC | Flags.FINAL | Flags.ENUM; |
|
493 |
ListBuffer<JCTree> fields = new ListBuffer<>(); |
|
494 |
||
495 |
for (int i = 0; i < count; i++) {
|
|
496 |
String declName = baseName + |
|
497 |
((count == 1) ? "" : getUniqIndex(scope, baseName)); |
|
498 |
||
499 |
JCVariableDecl constDecl = make.VarDef( |
|
500 |
make.Modifiers(declFlags), |
|
501 |
names.fromString(declName), |
|
502 |
null, // no need for type in enum decl |
|
503 |
null); // no init |
|
504 |
||
505 |
fields.append(constDecl); |
|
506 |
} |
|
507 |
return fields; |
|
508 |
} |
|
509 |
||
| 38838 | 510 |
ListBuffer<JCTree> processMethods(Element methodsNode, HashMap<String, Integer> scope, boolean needBody, boolean isConstructor) {
|
| 33919 | 511 |
String kind = methodsNode.getTagName(); |
512 |
String baseName = methodsNode.getAttribute("basename");
|
|
513 |
String name = methodsNode.getAttribute("name");
|
|
514 |
String methodTypeParam = methodsNode.getAttribute("tparam");
|
|
515 |
||
516 |
ListBuffer<JCTree> methods = new ListBuffer<>(); |
|
517 |
NodeList nodes = methodsNode.getChildNodes(); |
|
518 |
SimpleMultiplier multiply = new SimpleMultiplier(); // for modifiers |
|
519 |
String[] types = new String[0]; |
|
520 |
String[] params = new String[] { "none" }; // default - no params
|
|
521 |
ListBuffer<Type> throwTypes = new ListBuffer<>(); |
|
522 |
for (int i = 0; i < nodes.getLength(); i++) {
|
|
523 |
Node node = nodes.item(i); |
|
524 |
||
525 |
if (!(node instanceof Element)) |
|
526 |
continue; |
|
527 |
||
528 |
// parse type and modifiers |
|
529 |
switch (((Element)node).getTagName()) {
|
|
530 |
case "modifier": |
|
531 |
multiply.addAxis(((Element)node).getTextContent()); |
|
532 |
break; |
|
533 |
case "anno": |
|
534 |
multiply.addAxis(((Element)node).getTextContent()); |
|
535 |
break; |
|
536 |
case "type": |
|
537 |
types = ((Element)node).getTextContent().split("\\|");
|
|
538 |
break; |
|
539 |
case "param": |
|
540 |
params = ((Element)node).getTextContent().split("\\|");
|
|
541 |
break; |
|
542 |
case "throw": |
|
543 |
throwTypes.add( |
|
544 |
getTypeByName(((Element)node).getTextContent())); |
|
545 |
break; |
|
546 |
||
547 |
} |
|
548 |
} |
|
549 |
||
550 |
// constructor? |
|
551 |
if (isConstructor) {
|
|
552 |
baseName = "constructor"; |
|
553 |
types = new String[] { "" };
|
|
554 |
} |
|
555 |
||
556 |
// direct name not indexed |
|
557 |
boolean isDirectName = false; |
|
558 |
if (name.length() > 0) {
|
|
559 |
baseName = name; |
|
560 |
isDirectName = true; |
|
561 |
} |
|
562 |
||
563 |
// process through modifiers and types |
|
564 |
multiply.initIterator(); |
|
565 |
while (multiply.hasNext()) {
|
|
566 |
ArrayList<String> tuple = multiply.getNext(); |
|
567 |
||
568 |
long declFlags = 0; |
|
569 |
ListBuffer<JCAnnotation> annos = new ListBuffer<>(); |
|
570 |
for (String modifier : tuple) {
|
|
571 |
if (modifier.startsWith("@") && idAnnos.containsKey(modifier))
|
|
572 |
annos.add(idAnnos.get(modifier)); // it's anno |
|
573 |
else |
|
574 |
declFlags |= getFlagByName(modifier); // it's modifier |
|
575 |
} |
|
576 |
||
577 |
for (String type : types) {
|
|
578 |
String declName = baseName |
|
579 |
+ ((isConstructor || isDirectName) |
|
580 |
? "" : getUniqIndex(scope, baseName)); |
|
581 |
||
582 |
JCBlock body = null; |
|
583 |
if (needBody && (declFlags & Flags.ABSTRACT) == 0) { // create body
|
|
584 |
List<JCStatement> bodyStatements = List.<JCStatement>nil(); |
|
585 |
if (!type.equals("") && !type.equals("void")) { // create return statement
|
|
586 |
Type retType = getTypeByName(type); |
|
587 |
bodyStatements = List.<JCStatement>of( |
|
588 |
make.Return( |
|
589 |
make.Literal( |
|
590 |
retType.isPrimitive() ? |
|
591 |
retType.getTag() : |
|
592 |
TypeTag.BOT, |
|
| 38838 | 593 |
Integer.valueOf(0)))); |
| 33919 | 594 |
} |
595 |
body = make.Block(0, bodyStatements); |
|
596 |
} |
|
597 |
||
598 |
// same method by different params (if they exist) |
|
599 |
for (String param : params) {
|
|
600 |
||
601 |
JCMethodDecl methodDecl = |
|
602 |
make.MethodDef( |
|
603 |
make.Modifiers(declFlags, annos.toList()), |
|
604 |
names.fromString(declName), |
|
605 |
isConstructor ? null : make.Type(getTypeByName(type)), |
|
606 |
processTypeParams(methodTypeParam), // type params |
|
607 |
null, // no receiver |
|
608 |
processParams(param), // formal params |
|
609 |
make.Types(throwTypes.toList()), // throws |
|
610 |
body, |
|
611 |
null); // no default value YET |
|
612 |
||
613 |
methods.append(methodDecl); |
|
614 |
} |
|
615 |
} |
|
616 |
} |
|
617 |
||
618 |
return methods; |
|
619 |
} |
|
620 |
||
621 |
JCAnnotation processAnnoDecl(Element annoDeclNode) {
|
|
622 |
String annoId = annoDeclNode.getAttribute("id");
|
|
623 |
||
624 |
ListBuffer<JCExpression> args = new ListBuffer<>(); |
|
625 |
String className = ""; |
|
626 |
||
627 |
NodeList nodes = annoDeclNode.getChildNodes(); |
|
628 |
for (int i = 0; i < nodes.getLength(); i++) {
|
|
629 |
Node node = nodes.item(i); |
|
630 |
||
631 |
if (!(node instanceof Element)) |
|
632 |
continue; |
|
633 |
||
634 |
switch (((Element)node).getTagName()) {
|
|
635 |
case "class": |
|
636 |
className = ((Element)node).getTextContent(); |
|
637 |
break; |
|
638 |
case "arg": |
|
639 |
String argName = ((Element)node).getAttribute("name");
|
|
640 |
String argValue = ((Element)node).getAttribute("value");
|
|
641 |
||
642 |
JCExpression arg; |
|
643 |
if (argName.length() == 0) |
|
644 |
arg = make.Ident(names.fromString(argValue)); |
|
645 |
else |
|
646 |
arg = make.Assign( |
|
647 |
make.Ident(names.fromString(argName)), |
|
648 |
make.Ident(names.fromString(argValue))); |
|
649 |
||
650 |
args.add(arg); |
|
651 |
break; |
|
652 |
} |
|
653 |
} |
|
654 |
||
655 |
return make.Annotation( |
|
656 |
make.Ident(names.fromString(className)), |
|
657 |
args.toList()); |
|
658 |
} |
|
659 |
||
660 |
ListBuffer<JCTree> processMethods(List<JCTree> tree, boolean needBody) {
|
|
661 |
// for "extends" clause; returns methods only |
|
662 |
ListBuffer<JCTree> methods = new ListBuffer<>(); |
|
663 |
for (JCTree memberDecl : tree) {
|
|
664 |
if (memberDecl instanceof JCMethodDecl) {
|
|
665 |
JCMethodDecl methodDecl = (JCMethodDecl)memberDecl; |
|
666 |
JCTree retTypeTree = methodDecl.getReturnType(); |
|
667 |
||
668 |
// skip constructors |
|
669 |
if (retTypeTree == null) |
|
670 |
continue; |
|
671 |
||
672 |
if (needBody) {
|
|
673 |
// here we need to 'implement' interface declared methods |
|
674 |
Type retType = retTypeTree.type; |
|
675 |
||
676 |
List<JCStatement> bodyStatements = List.<JCStatement>nil(); |
|
677 |
if (retType.getTag() != TypeTag.VOID) |
|
678 |
bodyStatements = List.<JCStatement>of( |
|
679 |
make.Return( |
|
680 |
make.Literal( |
|
681 |
retType.isPrimitive() ? |
|
682 |
retType.getTag() : |
|
683 |
TypeTag.BOT, |
|
| 38838 | 684 |
Integer.valueOf(0)))); |
| 33919 | 685 |
|
686 |
JCBlock body = make.Block(0, bodyStatements); |
|
687 |
||
688 |
methodDecl = make.MethodDef( |
|
689 |
methodDecl.getModifiers(), |
|
690 |
methodDecl.getName(), |
|
691 |
(JCExpression)methodDecl.getReturnType(), |
|
692 |
methodDecl.getTypeParameters(), |
|
693 |
methodDecl.getReceiverParameter(), |
|
694 |
methodDecl.getParameters(), |
|
695 |
methodDecl.getThrows(), |
|
696 |
body, |
|
697 |
(JCExpression)methodDecl.getDefaultValue()); |
|
698 |
} |
|
699 |
||
700 |
methods.add(methodDecl); |
|
701 |
} |
|
702 |
} |
|
703 |
return methods; |
|
704 |
} |
|
705 |
||
706 |
void fixConstructorNames(JCClassDecl baseDecl) {
|
|
707 |
ListBuffer<JCTree> newMembers = new ListBuffer<>(); |
|
708 |
List<JCTree> members = baseDecl.getMembers(); |
|
709 |
Name name = baseDecl.getSimpleName(); |
|
710 |
||
711 |
for (JCTree memberDecl : members) {
|
|
712 |
JCTree newDecl = memberDecl; |
|
713 |
||
714 |
if (memberDecl instanceof JCMethodDecl) {
|
|
715 |
JCMethodDecl methodDecl = (JCMethodDecl)memberDecl; |
|
716 |
JCTree retTypeTree = methodDecl.getReturnType(); |
|
717 |
||
718 |
if (retTypeTree == null) |
|
719 |
newDecl = make.MethodDef( |
|
720 |
methodDecl.getModifiers(), |
|
721 |
name, |
|
722 |
(JCExpression)methodDecl.getReturnType(), |
|
723 |
methodDecl.getTypeParameters(), |
|
724 |
methodDecl.getReceiverParameter(), |
|
725 |
methodDecl.getParameters(), |
|
726 |
methodDecl.getThrows(), |
|
727 |
methodDecl.getBody(), |
|
728 |
(JCExpression)methodDecl.getDefaultValue()); |
|
729 |
} |
|
730 |
||
731 |
newMembers.add(newDecl); |
|
732 |
} |
|
733 |
||
734 |
baseDecl.defs = newMembers.toList(); |
|
735 |
} |
|
736 |
||
737 |
List<JCVariableDecl> processParams(String paramTypes) {
|
|
738 |
||
739 |
if ("none".equals(paramTypes))
|
|
740 |
return List.<JCVariableDecl>nil(); // empty |
|
741 |
||
742 |
String[] typesArr = paramTypes.split(",(?!(\\w+,)*\\w+>)");
|
|
743 |
ListBuffer<JCVariableDecl> paramsDecls = new ListBuffer<>(); |
|
744 |
||
745 |
int i = 0; |
|
746 |
for (String typeName : typesArr) {
|
|
747 |
String paramName = "param" |
|
748 |
+ (typesArr.length == 1 ? "" : String.valueOf(i)); |
|
749 |
paramsDecls.add( |
|
750 |
make.VarDef(make.Modifiers(0), |
|
751 |
names.fromString(paramName), |
|
752 |
make.Type(getTypeByName(typeName)), |
|
753 |
null)); |
|
754 |
i++; |
|
755 |
} |
|
756 |
||
757 |
return paramsDecls.toList(); |
|
758 |
} |
|
759 |
||
760 |
// |
|
761 |
// util methods |
|
762 |
// |
|
763 |
||
764 |
String getUniqName(String name) {
|
|
765 |
if (!nameIndex.containsKey(name)) |
|
| 38838 | 766 |
nameIndex.put(name, 0); |
| 33919 | 767 |
Integer index = nameIndex.get(name); |
768 |
String uniqName = name + index; |
|
769 |
nameIndex.put(name, index + 1); |
|
770 |
return uniqName; |
|
771 |
} |
|
772 |
||
| 38838 | 773 |
int getUniqIndex(HashMap<String, Integer> scope, String name) {
|
| 33919 | 774 |
if (!scope.containsKey(name)) |
| 38838 | 775 |
scope.put(name, 0); |
| 33919 | 776 |
Integer index = scope.get(name); |
777 |
scope.put(name, index + 1); |
|
778 |
return index; |
|
779 |
} |
|
780 |
||
781 |
long getFlagByName(String modifierName) {
|
|
782 |
switch (modifierName) {
|
|
783 |
case "public": |
|
784 |
return Flags.PUBLIC; |
|
785 |
case "private": |
|
786 |
return Flags.PRIVATE; |
|
787 |
case "protected": |
|
788 |
return Flags.PROTECTED; |
|
789 |
case "static": |
|
790 |
return Flags.STATIC; |
|
791 |
case "final": |
|
792 |
return Flags.FINAL; |
|
793 |
case "abstract": |
|
794 |
return Flags.ABSTRACT; |
|
795 |
case "strictfp": |
|
796 |
return Flags.STRICTFP; |
|
797 |
default: |
|
798 |
return 0; |
|
799 |
} |
|
800 |
} |
|
801 |
||
802 |
Type getTypeByName(String typeName) {
|
|
803 |
//check for primitive types |
|
804 |
switch (typeName) {
|
|
805 |
case "void": |
|
806 |
return syms.voidType; |
|
807 |
case "boolean": |
|
808 |
return syms.booleanType; |
|
809 |
case "byte": |
|
810 |
return syms.byteType; |
|
811 |
case "char": |
|
812 |
return syms.charType; |
|
813 |
case "double": |
|
814 |
return syms.doubleType; |
|
815 |
case "float": |
|
816 |
return syms.floatType; |
|
817 |
case "int": |
|
818 |
return syms.intType; |
|
819 |
case "long": |
|
820 |
return syms.longType; |
|
821 |
default: |
|
822 |
return getTypeByName(typeName, List.<Type>nil()); |
|
823 |
} |
|
824 |
} |
|
825 |
||
826 |
Type getTypeByName(String typeName, List<Type> tparams) {
|
|
827 |
return new Type.ClassType( |
|
828 |
Type.noType, |
|
829 |
tparams, |
|
830 |
new Symbol.ClassSymbol(0, names.fromString(typeName), null)); |
|
831 |
} |
|
832 |
} |