mirror of https://github.com/octoleo/plantuml.git
214 lines
6.4 KiB
Java
214 lines
6.4 KiB
Java
/* ========================================================================
|
|
* PlantUML : a free UML diagram generator
|
|
* ========================================================================
|
|
*
|
|
* (C) Copyright 2009-2020, Arnaud Roques
|
|
*
|
|
* Project Info: http://plantuml.com
|
|
*
|
|
* If you like this project or if you find it useful, you can support us at:
|
|
*
|
|
* http://plantuml.com/patreon (only 1$ per month!)
|
|
* http://plantuml.com/paypal
|
|
*
|
|
* This file is part of PlantUML.
|
|
*
|
|
* PlantUML is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* PlantUML distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
* License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
* USA.
|
|
*
|
|
*
|
|
* Original Author: Arnaud Roques
|
|
*
|
|
*/
|
|
package smetana.core.debug;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.PrintWriter;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
import gen.annotation.HasND_Rank;
|
|
import gen.annotation.Original;
|
|
import gen.annotation.Reviewed;
|
|
|
|
public class Purify {
|
|
|
|
private final Map<String, Method> methods = new LinkedHashMap<String, Method>();
|
|
private final File out2 = new File("../out-smetana", "smetana.txt");
|
|
private PrintWriter pw2;
|
|
private int currentLevel;
|
|
|
|
public Purify() {
|
|
try {
|
|
out2.getParentFile().mkdirs();
|
|
pw2 = new PrintWriter(out2);
|
|
System.err.println("CREATING " + out2.getAbsolutePath());
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
synchronized void logline(String s) {
|
|
System.err.println(s);
|
|
if (pw2 == null)
|
|
return;
|
|
pw2.println(s);
|
|
pw2.flush();
|
|
}
|
|
|
|
public synchronized void entering(String signature, String methodNameDeclared) {
|
|
if (methods.containsKey(signature) == false) {
|
|
try {
|
|
final Method method = recordMe(methodNameDeclared);
|
|
methods.put(signature, method);
|
|
final String key = getKey(method);
|
|
if (key.length() > 2 && key.equals(signature) == false) {
|
|
throw new IllegalStateException(signature);
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
System.exit(0);
|
|
}
|
|
}
|
|
currentLevel++;
|
|
traceCall(pw2, signature, methodNameDeclared);
|
|
}
|
|
|
|
public synchronized void leaving(String signature, String methodName) {
|
|
currentLevel--;
|
|
}
|
|
|
|
private void traceCall(PrintWriter pw, String signature, String methodNameDeclared) {
|
|
final Method m = methods.get(signature);
|
|
final String line = String.format("(%02d) %-26.26s [%-10.10s] %s", currentLevel, signature, getReviewedWhen(m),
|
|
methodNameDeclared);
|
|
if (SmetanaDebug.VERY_VERBOSE)
|
|
System.err.println(line);
|
|
if (pw == null)
|
|
return;
|
|
pw.println(line);
|
|
pw.flush();
|
|
}
|
|
|
|
private synchronized Method recordMe(String methodNameDeclared) throws ClassNotFoundException {
|
|
final Throwable creationPoint = new Throwable();
|
|
creationPoint.fillInStackTrace();
|
|
final StackTraceElement ste3 = creationPoint.getStackTrace()[3];
|
|
final StackTraceElement ste4 = creationPoint.getStackTrace()[4];
|
|
final String className = ste3.getClassName();
|
|
final String methodName3 = ste3.getMethodName();
|
|
final String methodName4 = ste4.getMethodName();
|
|
|
|
final Class<?> theClass = Class.forName(className);
|
|
final Method theMethod3 = getTheMethod(theClass, methodName3);
|
|
|
|
if (methodNameDeclared.equals(theMethod3.getName())) {
|
|
return theMethod3;
|
|
}
|
|
|
|
final Method theMethod4 = getTheMethod(theClass, methodName4);
|
|
if (checkWarning(methodNameDeclared, theMethod3) && methodNameDeclared.equals(theMethod4.getName())) {
|
|
return theMethod4;
|
|
}
|
|
creationPoint.printStackTrace();
|
|
System.exit(0);
|
|
throw new IllegalArgumentException();
|
|
}
|
|
|
|
private synchronized boolean checkWarning(String methodNameDeclared, final Method theMethod3) {
|
|
if ((methodNameDeclared + "_").equals(theMethod3.getName())) {
|
|
return true;
|
|
}
|
|
if ((methodNameDeclared + "_w_").equals(theMethod3.getName())) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private synchronized Method getTheMethod(Class<?> theClass, String methodName2) {
|
|
for (Method method : theClass.getDeclaredMethods()) {
|
|
if (method.getName().equals(methodName2)) {
|
|
return method;
|
|
}
|
|
}
|
|
final Throwable creationPoint = new Throwable();
|
|
creationPoint.fillInStackTrace();
|
|
creationPoint.printStackTrace();
|
|
System.exit(0);
|
|
throw new IllegalArgumentException();
|
|
}
|
|
|
|
public void reset() {
|
|
methods.clear();
|
|
}
|
|
|
|
public void printMe() {
|
|
final List<Entry<String, Method>> reverse = new ArrayList<Entry<String, Method>>(methods.entrySet());
|
|
Collections.reverse(reverse);
|
|
for (Entry<String, Method> ent : reverse) {
|
|
final String signature = ent.getKey();
|
|
final Method m = ent.getValue();
|
|
final String reviewedWhen = getReviewedWhen(m);
|
|
final String version = getVersion(m);
|
|
final String path = getPath(m);
|
|
final String hasND_Rank = hasND_Rank(m) ? "*" : " ";
|
|
System.err.println(String.format("%-8s %-26s %-12s %s %-30s %s", version, signature, reviewedWhen,
|
|
hasND_Rank, m.getName(), path));
|
|
}
|
|
}
|
|
|
|
private String getVersion(Method method) {
|
|
final Original original = method.getDeclaredAnnotation(Original.class);
|
|
if (original == null)
|
|
return "XX";
|
|
return original.version();
|
|
}
|
|
|
|
private String getPath(Method method) {
|
|
final Original original = method.getDeclaredAnnotation(Original.class);
|
|
if (original == null)
|
|
return "XX";
|
|
return original.path();
|
|
}
|
|
|
|
private String getReviewedWhen(Method method) {
|
|
final Reviewed reviewed = method.getDeclaredAnnotation(Reviewed.class);
|
|
if (reviewed == null) {
|
|
return "?";
|
|
}
|
|
return reviewed.when();
|
|
}
|
|
|
|
private boolean hasND_Rank(Method method) {
|
|
final HasND_Rank reviewed = method.getDeclaredAnnotation(HasND_Rank.class);
|
|
return reviewed != null;
|
|
}
|
|
|
|
private String getKey(Method method) {
|
|
final Original original = method.getDeclaredAnnotation(Original.class);
|
|
if (original == null) {
|
|
return "?";
|
|
}
|
|
return original.key();
|
|
}
|
|
|
|
}
|