public String toString() {
StringBuilder sb = new StringBuilder();
if (!access.equals(Access.NONE)) sb.append(access.toString()).append(" ");
if (_static) sb.append("static").append(" ");
if (_interface) sb.append("interface").append(" ");
else if (_abstract) sb.append("abstract class").append(" ");
else sb.append("class").append(" ");
sb.append(name).append(" ");
sb.append("extends ").append(superclass);
if (!interfaceList.isEmpty()) {
sb.append(" ").append("implements ");
for (int i = 0; i < interfaceList.size() - 1; i++)
sb.append(interfaceList.get(i)).append(", ");
sb.append(interfaceList.get(interfaceList.size() - 1));
}
sb.append("\n\n").append("Fields:");
for (FieldObject field : fieldList) sb.append("\n").append(field.toString());
sb.append("\n\n").append("Constructors:");
for (ConstructorObject constructor : constructorList)
sb.append("\n").append(constructor.toString());
sb.append("\n\n").append("Methods:");
for (MethodObject method : methodList) sb.append("\n").append(method.toString());
return sb.toString();
}
public void createFieldObject() throws IOException {
while (freePixel()) {
/** Creating Player/Ball Object * */
Point currentPoint = getNextFreePixel();
points = new ArrayList<Point>();
calcNeighbors(currentPoint);
if (points.size() > 20) {
FieldObject fo = new FieldObject();
fo.setPoints(points);
allBlackObjects.add(fo);
// allBlackObjects.add(currentObject);
}
}
// System.out.println(allBlackObjects.size() + " Object/s");
// System.out.println("---------------------------------");
Iterator<FieldObject> allBlackObjectsIt = allBlackObjects.iterator();
System.out.println(allBlackObjects.size() + " Objects found.");
while (allBlackObjectsIt.hasNext()) {
FieldObject currentObject = allBlackObjectsIt.next();
writeObject(currentObject);
// Iterator<Point> currentObjectIt = currentObject.iterator();
// while (currentObjectIt.hasNext()) {
// Point currentPoint = currentObjectIt.next();
// // System.out.println(currentPoint.getX() + "/" +
// // currentPoint.getY());
//
// }
}
}
public boolean isFriend(String className) {
if (superclass != null) {
if (superclass.getClassType().equals(className)) return true;
}
for (TypeObject interfaceType : interfaceList) {
if (interfaceType.getClassType().equals(className)) return true;
}
for (FieldObject field : fieldList) {
TypeObject fieldType = field.getType();
if (checkFriendship(fieldType, className)) return true;
}
for (ConstructorObject constructor : constructorList) {
ListIterator<ParameterObject> parameterIterator = constructor.getParameterListIterator();
while (parameterIterator.hasNext()) {
ParameterObject parameter = parameterIterator.next();
TypeObject parameterType = parameter.getType();
if (checkFriendship(parameterType, className)) return true;
}
for (CreationObject creation : constructor.getCreations()) {
TypeObject creationType = creation.getType();
if (checkFriendship(creationType, className)) return true;
}
}
for (MethodObject method : methodList) {
TypeObject returnType = method.getReturnType();
if (checkFriendship(returnType, className)) return true;
ListIterator<ParameterObject> parameterIterator = method.getParameterListIterator();
while (parameterIterator.hasNext()) {
ParameterObject parameter = parameterIterator.next();
TypeObject parameterType = parameter.getType();
if (checkFriendship(parameterType, className)) return true;
}
for (CreationObject creation : method.getCreations()) {
TypeObject creationType = creation.getType();
if (checkFriendship(creationType, className)) return true;
}
}
if (superclass != null) {
ClassObject superclassObject =
ASTReader.getSystemObject().getClassObject(superclass.getClassType());
if (superclassObject != null) return superclassObject.isFriend(className);
}
return false;
}
private List<ClassObject> parseAST(CompilationUnit compilationUnit, IFile iFile) {
List<ClassObject> classObjects = new ArrayList<ClassObject>();
List<AbstractTypeDeclaration> topLevelTypeDeclarations = compilationUnit.types();
for (AbstractTypeDeclaration abstractTypeDeclaration : topLevelTypeDeclarations) {
if (abstractTypeDeclaration instanceof TypeDeclaration) {
TypeDeclaration topLevelTypeDeclaration = (TypeDeclaration) abstractTypeDeclaration;
List<TypeDeclaration> typeDeclarations = new ArrayList<TypeDeclaration>();
typeDeclarations.add(topLevelTypeDeclaration);
typeDeclarations.addAll(getRecursivelyInnerTypes(topLevelTypeDeclaration));
for (TypeDeclaration typeDeclaration : typeDeclarations) {
final ClassObject classObject = new ClassObject();
classObject.setIFile(iFile);
classObject.setName(typeDeclaration.resolveBinding().getQualifiedName());
classObject.setTypeDeclaration(typeDeclaration);
if (typeDeclaration.isInterface()) {
classObject.setInterface(true);
}
int modifiers = typeDeclaration.getModifiers();
if ((modifiers & Modifier.ABSTRACT) != 0) classObject.setAbstract(true);
if ((modifiers & Modifier.PUBLIC) != 0) classObject.setAccess(Access.PUBLIC);
else if ((modifiers & Modifier.PROTECTED) != 0) classObject.setAccess(Access.PROTECTED);
else if ((modifiers & Modifier.PRIVATE) != 0) classObject.setAccess(Access.PRIVATE);
else classObject.setAccess(Access.NONE);
if ((modifiers & Modifier.STATIC) != 0) classObject.setStatic(true);
Type superclassType = typeDeclaration.getSuperclassType();
if (superclassType != null) {
ITypeBinding binding = superclassType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
classObject.setSuperclass(typeObject);
}
List<Type> superInterfaceTypes = typeDeclaration.superInterfaceTypes();
for (Type interfaceType : superInterfaceTypes) {
ITypeBinding binding = interfaceType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
classObject.addInterface(typeObject);
}
FieldDeclaration[] fieldDeclarations = typeDeclaration.getFields();
for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
Type fieldType = fieldDeclaration.getType();
ITypeBinding binding = fieldType.resolveBinding();
List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
for (VariableDeclarationFragment fragment : fragments) {
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
typeObject.setArrayDimension(
typeObject.getArrayDimension() + fragment.getExtraDimensions());
FieldObject fieldObject =
new FieldObject(typeObject, fragment.getName().getIdentifier());
fieldObject.setClassName(classObject.getName());
fieldObject.setVariableDeclarationFragment(fragment);
int fieldModifiers = fieldDeclaration.getModifiers();
if ((fieldModifiers & Modifier.PUBLIC) != 0) fieldObject.setAccess(Access.PUBLIC);
else if ((fieldModifiers & Modifier.PROTECTED) != 0)
fieldObject.setAccess(Access.PROTECTED);
else if ((fieldModifiers & Modifier.PRIVATE) != 0)
fieldObject.setAccess(Access.PRIVATE);
else fieldObject.setAccess(Access.NONE);
if ((fieldModifiers & Modifier.STATIC) != 0) fieldObject.setStatic(true);
classObject.addField(fieldObject);
}
}
MethodDeclaration[] methodDeclarations = typeDeclaration.getMethods();
for (MethodDeclaration methodDeclaration : methodDeclarations) {
String methodName = methodDeclaration.getName().getIdentifier();
final ConstructorObject constructorObject = new ConstructorObject();
constructorObject.setMethodDeclaration(methodDeclaration);
constructorObject.setName(methodName);
constructorObject.setClassName(classObject.getName());
int methodModifiers = methodDeclaration.getModifiers();
if ((methodModifiers & Modifier.PUBLIC) != 0)
constructorObject.setAccess(Access.PUBLIC);
else if ((methodModifiers & Modifier.PROTECTED) != 0)
constructorObject.setAccess(Access.PROTECTED);
else if ((methodModifiers & Modifier.PRIVATE) != 0)
constructorObject.setAccess(Access.PRIVATE);
else constructorObject.setAccess(Access.NONE);
List<SingleVariableDeclaration> parameters = methodDeclaration.parameters();
for (SingleVariableDeclaration parameter : parameters) {
Type parameterType = parameter.getType();
ITypeBinding binding = parameterType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
typeObject.setArrayDimension(
typeObject.getArrayDimension() + parameter.getExtraDimensions());
if (parameter.isVarargs()) {
typeObject.setArrayDimension(1);
}
ParameterObject parameterObject =
new ParameterObject(typeObject, parameter.getName().getIdentifier());
parameterObject.setSingleVariableDeclaration(parameter);
constructorObject.addParameter(parameterObject);
}
Block methodBody = methodDeclaration.getBody();
if (methodBody != null) {
MethodBodyObject methodBodyObject = new MethodBodyObject(methodBody);
constructorObject.setMethodBody(methodBodyObject);
}
if (methodDeclaration.isConstructor()) {
classObject.addConstructor(constructorObject);
} else {
MethodObject methodObject = new MethodObject(constructorObject);
List<IExtendedModifier> extendedModifiers = methodDeclaration.modifiers();
for (IExtendedModifier extendedModifier : extendedModifiers) {
if (extendedModifier.isAnnotation()) {
Annotation annotation = (Annotation) extendedModifier;
if (annotation.getTypeName().getFullyQualifiedName().equals("Test")) {
methodObject.setTestAnnotation(true);
break;
}
}
}
Type returnType = methodDeclaration.getReturnType2();
ITypeBinding binding = returnType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
methodObject.setReturnType(typeObject);
if ((methodModifiers & Modifier.ABSTRACT) != 0) methodObject.setAbstract(true);
if ((methodModifiers & Modifier.STATIC) != 0) methodObject.setStatic(true);
if ((methodModifiers & Modifier.SYNCHRONIZED) != 0)
methodObject.setSynchronized(true);
if ((methodModifiers & Modifier.NATIVE) != 0) methodObject.setNative(true);
classObject.addMethod(methodObject);
FieldInstructionObject fieldInstruction = methodObject.isGetter();
if (fieldInstruction != null)
systemObject.addGetter(methodObject.generateMethodInvocation(), fieldInstruction);
fieldInstruction = methodObject.isSetter();
if (fieldInstruction != null)
systemObject.addSetter(methodObject.generateMethodInvocation(), fieldInstruction);
fieldInstruction = methodObject.isCollectionAdder();
if (fieldInstruction != null)
systemObject.addCollectionAdder(
methodObject.generateMethodInvocation(), fieldInstruction);
MethodInvocationObject methodInvocation = methodObject.isDelegate();
if (methodInvocation != null)
systemObject.addDelegate(methodObject.generateMethodInvocation(), methodInvocation);
}
}
classObjects.add(classObject);
}
}
}
return classObjects;
}
/**
* @param field
* @param subFieldElements
*/
private void setSubFields(FieldObject field, List<Element> subFieldElements) {
List<FieldObject> subFields = new ArrayList<FieldObject>();
fields.put(field.getType(), subFields);
for (Element subElement : subFieldElements) {
FieldObject subField = new FieldObject();
subField.setType(subElement.getAttributeValue("type"));
subField.setClientType(subElement.getAttributeValue("clientType"));
if (StringUtils.isEmpty(subField.getClientType())) {
subField.setClientType(GeneratorHelper.getClientClassName(subField.getType()) + "Data");
}
subField.setSmallName(subElement.getAttributeValue("name"));
subField.setComment(subElement.getAttributeValue("comment"));
if (subElement.getAttributeValue("list") != null) {
subField.setList(subElement.getAttributeValue("list").equals("true") ? true : false);
field.setHasListField(true);
}
subFields.add(subField);
List<Element> subsubFieldElements = subElement.getChildren("field", NAME_SPACE);
if (subsubFieldElements.size() > 0) {
this.setSubFields(subField, subsubFieldElements);
}
// 如果不是系统定义的类型则说明是子消息
if (!new ArrayListWrapper(sysTypes).contains(subField.getType())) {
subField.setIsNewType(true);
if (subField.getType().indexOf("_") > 0) {
subField.setType(GeneratorHelper.generateServerClassName(subField.getType()));
}
}
}
field.setSubFields(subFields);
// 如果配置了子节点，而且类型中不存在包名，则说明是新定义的类型
if (field.getType().indexOf(".") == -1) {
field.setNeedCreateType(true);
}
}
/**
* 设置消息对象的字段
*
* @param msgObj
* @param msgElement
*/
private void setMsgObjFields(
MessageObject msgObj, List fElements, boolean isClient, boolean isCppClient) {
for (Iterator j = fElements.iterator(); j.hasNext(); ) {
Element fElement = (Element) j.next();
FieldObject field = new FieldObject();
field.setType(fElement.getAttributeValue("type"));
field.setClientType(fElement.getAttributeValue("clientType"));
if (StringUtils.isEmpty(field.getClientType())) {
field.setClientType(GeneratorHelper.getClientClassName(field.getType()) + "Data");
}
field.setSmallName(fElement.getAttributeValue("name"));
field.setComment(fElement.getAttributeValue("comment"));
if (fElement.getAttribute("defaultValue") != null) {
String defaultValue = fElement.getAttributeValue("defaultValue");
if (StringUtils.isEmpty(defaultValue)) {
if (!TYPE_STRING.equals(field.getType())) {
defaultValue = "0";
} else {
defaultValue = "";
}
}
if (TYPE_STRING.equals(field.getType())) {
defaultValue = "\"" + defaultValue + "\"";
}
field.setDefaultValue("=" + defaultValue);
} else {
field.setDefaultValue("");
}
List<Element> subFieldElements = fElement.getChildren("field", NAME_SPACE);
if (fElement.getAttributeValue("bytes") != null) {
field.setBytes(fElement.getAttributeValue("bytes").equals("true") ? true : false);
}
if (fElement.getAttributeValue("list") != null) {
field.setList(fElement.getAttributeValue("list").equals("true") ? true : false);
msgObj.setHasListField(true);
}
boolean isSubMsg = "true".equalsIgnoreCase(fElement.getAttributeValue("subMsg"));
field.setSubMsg(isSubMsg);
if (isSubMsg) {
field.setSubMsgType(GeneratorHelper.generateServerClassName(field.getType()));
msgObj.setListMsg(true);
if (isCppClient) {
field.setList(true);
msgObj.setHasListField(true);
field.setType("_LZOBEX_" + field.getType());
}
}
// 如果不是系统定义的类型则说明是子消息
if (!new ArrayListWrapper(sysTypes).contains(field.getType())) {
if (!isCppClient || !field.isSubMsg()) {
field.setIsNewType(true);
if (!isClient && field.getType().indexOf("_") > 0) {
field.setType(GeneratorHelper.generateServerClassName(field.getType()));
}
}
}
if (subFieldElements.size() > 0) {
this.setSubFields(field, subFieldElements);
} else {
if (isClient && field.getIsNewType()) { // 客户端生成消息的时候要为其补全
field.setSubFields(fields.get(field.getType()));
}
if (!isClient && field.getList() && field.getIsNewType()) {
String type = field.getType();
field.setSubFields(msgs.get(type).getFields());
}
}
if (field.isSubMsg() && !isCppClient) {
msgObj.addSubMsg(field);
} else {
msgObj.addField(field);
}
}
}
/**
* 生成客户端数据模型
*
* @param messages
*/
private void createClientModel(List<MessageObject> messages, String module) {
Map<String, FieldObject> newTypeFields = new HashMap<String, FieldObject>();
for (MessageObject msgObj : messages) {
List<FieldObject> fields = msgObj.getFields();
for (FieldObject fieldObject : fields) {
if (fieldObject.getIsNewType()) {
// 先遍历它的子类型
for (FieldObject subfieldObject : fieldObject.getSubFields()) {
if (subfieldObject.getIsNewType()) {
// 先遍历子类型的子类型
for (FieldObject subsubfieldObject : subfieldObject.getSubFields()) {
if (subsubfieldObject.getIsNewType()) {
// 先遍历子类型的子类型
for (FieldObject sssfieldObject : subsubfieldObject.getSubFields()) {
if (sssfieldObject.getIsNewType()) {
sssfieldObject.setType(sssfieldObject.getClientType());
if (sssfieldObject.getClientType().contains(".")) {
sssfieldObject.setType(
GeneratorHelper.getClientClassName(sssfieldObject.getType()));
continue;
}
newTypeFields.put(sssfieldObject.getClientType(), sssfieldObject);
}
}
subsubfieldObject.setType(subsubfieldObject.getClientType());
if (subsubfieldObject.getClientType().contains(".")) {
subsubfieldObject.setType(
GeneratorHelper.getClientClassName(subsubfieldObject.getType()));
continue;
}
newTypeFields.put(subsubfieldObject.getClientType(), subsubfieldObject);
}
}
//
subfieldObject.setType(subfieldObject.getClientType());
if (subfieldObject.getClientType().contains(".")) {
subfieldObject.setType(
GeneratorHelper.getClientClassName(subfieldObject.getType()));
continue;
}
newTypeFields.put(subfieldObject.getClientType(), subfieldObject);
}
}
fieldObject.setType(fieldObject.getClientType());
if (fieldObject.getClientType().contains(".")) {
fieldObject.setType(GeneratorHelper.getClientClassName(fieldObject.getType()));
continue;
}
newTypeFields.put(fieldObject.getClientType(), fieldObject);
}
}
}
for (FieldObject fieldObject : newTypeFields.values()) {
VelocityContext context = new VelocityContext();
context.put("modulename", module);
context.put("model", fieldObject);
String outputFilePath;
if (replaceDirectly) {
outputFilePath = dataPath + fieldObject.getType() + ".as";
} else {
outputFilePath =
clientRootPath
+ File.separator
+ module
+ File.separator
+ "data"
+ File.separator
+ fieldObject.getType()
+ ".as";
}
try {
GeneratorHelper.generate(context, clientModelTemplate, outputFilePath);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void writeObject(FieldObject fieldObject) throws IOException {
obj_nr++;
int HX = 0;
int HY = 0;
int LX = 999;
int LY = 999;
proNumber = 6;
Iterator<Point> getOffsetIt = fieldObject.getPoints().iterator();
// GET OFFSET
BufferedImage bufImgObj = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D gObject = (Graphics2D) bufImgObj.getGraphics();
gObject.setColor(fieldObject.getAvgColor());
while (getOffsetIt.hasNext()) {
Point point = getOffsetIt.next();
int x = point.getX();
int y = point.getY();
if (x > HX) {
HX = x;
}
if (y > HY) {
HY = y;
}
if (x < LX) {
LX = x;
}
if (y < LY) {
LY = y;
}
// gObject.setBackground(Color.green);
gObject.drawLine(point.getX(), point.getY(), point.getX(), point.getY());
}
// ERSTELLE SNIPPETFILE
File fileSnippet = new File("d://snippets/snippet_" + cap_nr + "_" + obj_nr + ".png");
// ERSTELLE OBJECTFILE
String pathnameObject = "d://LIGA/objects/obj_" + cap_nr + "_" + obj_nr + ".png";
File fileObject = new File(pathnameObject);
BufferedImage bufImgSni = new BufferedImage(HX - LX, HY - LY, BufferedImage.TYPE_INT_RGB);
// ERSTELLE GRAFIK
Graphics2D gSnippet = (Graphics2D) bufImgSni.getGraphics();
Iterator<Point> currentObjIt = points.iterator();
// ERSTELLE G-BILD OBJEKT OHNE OFFSET
while (currentObjIt.hasNext()) {
Point p1 = currentObjIt.next();
gSnippet.drawLine(p1.getX() - LX, p1.getY() - LY, p1.getX() - LX, p1.getY() - LY);
}
gSnippet.dispose();
gObject.dispose();
// CREATE CURRENT MATCH
if (bufImgSni.getWidth() < 40 || bufImgSni.getHeight() < 40) {
BufferedImage biggerSni =
new BufferedImage(
bufImgSni.getWidth() + 20,
bufImgSni.getHeight() + 20,
BufferedImage.TYPE_BYTE_BINARY);
Graphics2D gTest = (Graphics2D) biggerSni.getGraphics();
gTest.drawImage(bufImgSni, 0, 0, null);
gTest.dispose();
bufImgSni = biggerSni;
}
System.out.println("Checking Snippet " + obj_nr + "...");
// ImageIO.write(bufImgSni, "png", fileSnippet);
// currentMatch = cbo.startComparing(bufImgSni, LX, LY);
System.out.println("-----------------------\n");
ImageIO.write(bufImgObj, "png", fileObject);
}
private ClassObject parseBytecode(File file) {
final ClassObject co = new ClassObject();
try {
FileInputStream fin = new FileInputStream(file);
ClassReader cr = new ClassReader(new DataInputStream(fin));
ClassNode cn = new ClassNode();
cr.accept(cn, ClassReader.SKIP_DEBUG);
String name = cn.name;
co.setName(name.replaceAll("/", "."));
if ((cn.access & Opcodes.ACC_INTERFACE) != 0) co.setInterface(true);
else if ((cn.access & Opcodes.ACC_ABSTRACT) != 0) co.setAbstract(true);
if ((cn.access & Opcodes.ACC_PUBLIC) != 0) co.setAccess(Access.PUBLIC);
else if ((cn.access & Opcodes.ACC_PROTECTED) != 0) co.setAccess(Access.PROTECTED);
else if ((cn.access & Opcodes.ACC_PRIVATE) != 0) co.setAccess(Access.PRIVATE);
if ((cn.access & Opcodes.ACC_STATIC) != 0) co.setStatic(true);
String superClass = cn.superName;
co.setSuperclass(superClass.replaceAll("/", "."));
List interfaces = cn.interfaces;
for (Object anInterface : interfaces) {
String interfaceString = (String) anInterface;
co.addInterface(interfaceString.replaceAll("/", "."));
}
List fields = cn.fields;
for (Object field : fields) {
FieldNode fieldNode = (FieldNode) field;
Type fieldType = Type.getType(fieldNode.desc);
TypeObject typeObject = new TypeObject(fieldType.getClassName());
if (fieldNode.signature != null) {
TraceSignatureVisitor v = new TraceSignatureVisitor(ClassReader.SKIP_DEBUG);
SignatureReader r = new SignatureReader(fieldNode.signature);
r.accept(v);
String declaration = v.getDeclaration();
if (declaration.contains("<") && declaration.contains(">"))
typeObject.setGeneric(
declaration.substring(declaration.indexOf("<") + 1, declaration.lastIndexOf(">")));
}
FieldObject fo = new FieldObject(typeObject, fieldNode.name);
if ((fieldNode.access & Opcodes.ACC_PUBLIC) != 0) fo.setAccess(Access.PUBLIC);
else if ((fieldNode.access & Opcodes.ACC_PROTECTED) != 0) fo.setAccess(Access.PROTECTED);
else if ((fieldNode.access & Opcodes.ACC_PRIVATE) != 0) fo.setAccess(Access.PRIVATE);
if ((fieldNode.access & Opcodes.ACC_STATIC) != 0) fo.setStatic(true);
co.addField(fo);
}
List methods = cn.methods;
for (Object method : methods) {
MethodNode methodNode = (MethodNode) method;
final ConstructorObject constructorObject = new ConstructorObject();
if ((methodNode.access & Opcodes.ACC_PUBLIC) != 0)
constructorObject.setAccess(Access.PUBLIC);
else if ((methodNode.access & Opcodes.ACC_PROTECTED) != 0)
constructorObject.setAccess(Access.PROTECTED);
else if ((methodNode.access & Opcodes.ACC_PRIVATE) != 0)
constructorObject.setAccess(Access.PRIVATE);
if (methodNode.signature != null) {
TraceSignatureVisitor v = new TraceSignatureVisitor(ClassReader.SKIP_DEBUG);
SignatureReader r = new SignatureReader(methodNode.signature);
r.accept(v);
String declaration = v.getDeclaration();
String temp = declaration;
if (temp.startsWith("(")) temp = temp.substring(1, temp.length());
if (temp.endsWith("")) temp = temp.substring(0, temp.length() - 1);
if (!temp.equals("")) {
ParameterAnalyzer analyzer = new ParameterAnalyzer(temp);
for (String token : analyzer.getParameters()) {
if (token.contains("<") && token.contains(">")) {
TypeObject typeObject = new TypeObject(token.substring(0, token.indexOf("<")));
typeObject.setGeneric(
token.substring(token.indexOf("<") + 1, token.lastIndexOf(">")));
constructorObject.addParameter(typeObject);
} else {
constructorObject.addParameter(new TypeObject(token));
}
}
}
} else {
Type[] argumentTypes = Type.getArgumentTypes(methodNode.desc);
for (Type argumentType : argumentTypes)
constructorObject.addParameter(new TypeObject(argumentType.getClassName()));
}
if (methodNode.instructions.size() > 0) {
Map<String, Integer> labelIndexMap = new HashMap<String, Integer>();
List<LoopObject> activeLoops = new ArrayList<LoopObject>();
Iterator insnIt = methodNode.instructions.iterator();
int index = 0;
while (insnIt.hasNext()) {
AbstractInsnNode ainsn = (AbstractInsnNode) insnIt.next();
if (ainsn instanceof LabelNode) {
LabelNode labelNode = (LabelNode) ainsn;
Label label = labelNode.getLabel();
LoopObject loop = new LoopObject(label.toString());
activeLoops.add(loop);
labelIndexMap.put(label.toString(), index);
}
if (ainsn instanceof JumpInsnNode) {
JumpInsnNode jumpNode = (JumpInsnNode) ainsn;
Label label = jumpNode.label.getLabel();
if (labelIndexMap.containsKey(label.toString())) {
LoopObject matchingLoop = null;
for (LoopObject loop : activeLoops) {
if (loop.getLabel().equals(label.toString())) {
matchingLoop = loop;
break;
}
}
if (matchingLoop != null) {
constructorObject.addLoop(matchingLoop);
activeLoops.remove(matchingLoop);
}
}
}
if (ainsn instanceof FieldInsnNode) {
FieldInsnNode fieldInsnNode = (FieldInsnNode) ainsn;
Type fieldType = Type.getType(fieldInsnNode.desc);
FieldInstructionObject fieldObject =
new FieldInstructionObject(
fieldInsnNode.owner.replaceAll("/", "."),
fieldType.getClassName(),
fieldInsnNode.name);
constructorObject.addFieldInstruction(fieldObject);
for (LoopObject loop : activeLoops) {
loop.addFieldInstruction(fieldObject);
}
}
if ((ainsn.getOpcode() == Opcodes.INVOKEVIRTUAL)
|| (ainsn.getOpcode() == Opcodes.INVOKESTATIC)
|| (ainsn.getOpcode() == Opcodes.INVOKESPECIAL)
|| (ainsn.getOpcode() == Opcodes.INVOKEINTERFACE)) {
MethodInsnNode minsn = (MethodInsnNode) ainsn;
MethodInvocationObject mio =
new MethodInvocationObject(
minsn.owner.replaceAll("/", "."),
minsn.name,
Type.getReturnType(minsn.desc).getClassName());
Type[] argTypes = Type.getArgumentTypes(minsn.desc);
for (Type argType : argTypes) mio.addParameter(argType.getClassName());
constructorObject.addMethodInvocation(mio);
for (LoopObject loop : activeLoops) {
loop.addMethodInvocation(mio);
}
}
if ((ainsn.getOpcode() == Opcodes.NEW) || (ainsn.getOpcode() == Opcodes.ANEWARRAY)) {
TypeInsnNode tinsn = (TypeInsnNode) ainsn;
constructorObject.addObjectInstantiation(tinsn.desc.replaceAll("/", "."));
}
index++;
}
}
if (methodNode.name.equals("<init>")) {
constructorObject.setName(co.getName());
co.addConstructor(constructorObject);
} else {
Type returnType = Type.getReturnType(methodNode.desc);
constructorObject.setName(methodNode.name);
MethodObject methodObject = new MethodObject(constructorObject);
TypeObject typeObject = new TypeObject(returnType.getClassName());
if (methodNode.signature != null) {
TraceSignatureVisitor v = new TraceSignatureVisitor(ClassReader.SKIP_DEBUG);
SignatureReader r = new SignatureReader(methodNode.signature);
r.accept(v);
String genericReturnType = v.getReturnType();
if (genericReturnType.contains("<") && genericReturnType.contains(">"))
typeObject.setGeneric(
genericReturnType.substring(
genericReturnType.indexOf("<") + 1, genericReturnType.lastIndexOf(">")));
}
methodObject.setReturnType(typeObject);
methodObject.setClassName(co.getName());
if ((methodNode.access & Opcodes.ACC_ABSTRACT) != 0) methodObject.setAbstract(true);
if ((methodNode.access & Opcodes.ACC_STATIC) != 0) methodObject.setStatic(true);
co.addMethod(methodObject);
}
}
fin.close();
} catch (FileNotFoundException fnfe) {
fnfe.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
return co;
}
