plugins/java-decompiler/engine/src/org/jetbrains/java/decompiler/modules/renamer/IdentifierConverter.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.jetbrains.java.decompiler.modules.renamer;

 import org.jetbrains.java.decompiler.code.CodeConstants;
 import org.jetbrains.java.decompiler.main.DecompilerContext;
 import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences;
 import org.jetbrains.java.decompiler.main.extern.IIdentifierRenamer;
 import org.jetbrains.java.decompiler.struct.StructClass;
 import org.jetbrains.java.decompiler.struct.StructContext;
 import org.jetbrains.java.decompiler.struct.StructField;
 import org.jetbrains.java.decompiler.struct.StructMethod;
 import org.jetbrains.java.decompiler.struct.gen.FieldDescriptor;
 import org.jetbrains.java.decompiler.struct.gen.MethodDescriptor;
 import org.jetbrains.java.decompiler.struct.gen.VarType;
 import org.jetbrains.java.decompiler.util.VBStyleCollection;

 import java.io.IOException;
 import java.util.*;

 public class IdentifierConverter {

   private StructContext context;

   private IIdentifierRenamer helper;

   private PoolInterceptor interceptor;

   private List<ClassWrapperNode> rootClasses = new ArrayList<ClassWrapperNode>();

   private List<ClassWrapperNode> rootInterfaces = new ArrayList<ClassWrapperNode>();

   private HashMap<String, HashMap<String, String>> interfaceNameMaps = new HashMap<String, HashMap<String, String>>();

   public void rename(StructContext context) {

     try {
       this.context = context;

       String user_class = (String)DecompilerContext.getProperty(IFernflowerPreferences.USER_RENAMER_CLASS);
       if (user_class != null) {
         try {
           helper = (IIdentifierRenamer)IdentifierConverter.class.getClassLoader().loadClass(user_class).newInstance();
         }
         catch (Exception ex) {
           // ignore errors
         }
       }

       if (helper == null) {
         helper = new ConverterHelper();
       }

       interceptor = new PoolInterceptor(helper);

       buildInheritanceTree();

       renameAllClasses();

       renameInterfaces();

       renameClasses();

       DecompilerContext.setPoolInterceptor(interceptor);
       context.reloadContext();
     }
     catch (IOException ex) {
       throw new RuntimeException("Renaming failed!");
     }
   }

   private void renameClasses() {

     List<ClassWrapperNode> lstClasses = getReversePostOrderListIterative(rootClasses);

     HashMap<String, HashMap<String, String>> classNameMaps = new HashMap<String, HashMap<String, String>>();

     for (ClassWrapperNode node : lstClasses) {

       StructClass cl = node.getClassStruct();
       HashMap<String, String> names = new HashMap<String, String>();

       // merge informations on super class
       if (cl.superClass != null) {
         HashMap<String, String> mapClass = classNameMaps.get(cl.superClass.getString());
         if (mapClass != null) {
           names.putAll(mapClass);
         }
       }

       // merge informations on interfaces
       for (String intrName : cl.getInterfaceNames()) {
         HashMap<String, String> mapInt = interfaceNameMaps.get(intrName);
         if (mapInt != null) {
           names.putAll(mapInt);
         }
         else {
           StructClass clintr = context.getClass(intrName);
           if (clintr != null) {
             names.putAll(processExternalInterface(clintr));
           }
         }
       }

       renameClassIdentifiers(cl, names);

       if (!node.getSubclasses().isEmpty()) {
         classNameMaps.put(cl.qualifiedName, names);
       }
     }
   }

   private HashMap<String, String> processExternalInterface(StructClass cl) {

     HashMap<String, String> names = new HashMap<String, String>();

     for (String intrName : cl.getInterfaceNames()) {

       HashMap<String, String> mapInt = interfaceNameMaps.get(intrName);
       if (mapInt != null) {
         names.putAll(mapInt);
       }
       else {
         StructClass clintr = context.getClass(intrName);
         if (clintr != null) {
           names.putAll(processExternalInterface(clintr));
         }
       }
     }

     renameClassIdentifiers(cl, names);

     return names;
   }

   private void renameInterfaces() {

     List<ClassWrapperNode> lstInterfaces = getReversePostOrderListIterative(rootInterfaces);

     HashMap<String, HashMap<String, String>> interfaceNameMaps = new HashMap<String, HashMap<String, String>>();

     // rename methods and fields
     for (ClassWrapperNode node : lstInterfaces) {

       StructClass cl = node.getClassStruct();
       HashMap<String, String> names = new HashMap<String, String>();

       // merge informations on super interfaces
       for (String intrName : cl.getInterfaceNames()) {
         HashMap<String, String> mapInt = interfaceNameMaps.get(intrName);
         if (mapInt != null) {
           names.putAll(mapInt);
         }
       }

       renameClassIdentifiers(cl, names);

       interfaceNameMaps.put(cl.qualifiedName, names);
     }

     this.interfaceNameMaps = interfaceNameMaps;
   }

   private void renameAllClasses() {

     // order not important
     List<ClassWrapperNode> lstAllClasses = new ArrayList<ClassWrapperNode>(getReversePostOrderListIterative(rootInterfaces));
     lstAllClasses.addAll(getReversePostOrderListIterative(rootClasses));

     // rename all interfaces and classes
     for (ClassWrapperNode node : lstAllClasses) {
       renameClass(node.getClassStruct());
     }
   }

   private void renameClass(StructClass cl) {

     if (!cl.isOwn()) {
       return;
     }

     String classOldFullName = cl.qualifiedName;

     // TODO: rename packages
     String clsimplename = ConverterHelper.getSimpleClassName(classOldFullName);
     if (helper.toBeRenamed(IIdentifierRenamer.ELEMENT_CLASS, clsimplename, null, null)) {
       String classNewFullName;

       do {
         classNewFullName = ConverterHelper.replaceSimpleClassName(classOldFullName,
                                                                   helper.getNextClassname(classOldFullName, ConverterHelper
                                                                     .getSimpleClassName(classOldFullName)));
       }
       while (context.getClasses().containsKey(classNewFullName));

       interceptor.addName(classOldFullName, classNewFullName);
     }
   }

   private void renameClassIdentifiers(StructClass cl, HashMap<String, String> names) {

     // all classes are already renamed
     String classOldFullName = cl.qualifiedName;
     String classNewFullName = interceptor.getName(classOldFullName);

     if (classNewFullName == null) {
       classNewFullName = classOldFullName;
     }

     // methods
     HashSet<String> setMethodNames = new HashSet<String>();
     for (StructMethod md : cl.getMethods()) {
       setMethodNames.add(md.getName());
     }

     VBStyleCollection<StructMethod, String> methods = cl.getMethods();
     for (int i = 0; i < methods.size(); i++) {

       StructMethod mt = methods.get(i);
       String key = methods.getKey(i);

       boolean isPrivate = mt.hasModifier(CodeConstants.ACC_PRIVATE);

       String name = mt.getName();
       if (!cl.isOwn() || mt.hasModifier(CodeConstants.ACC_NATIVE)) {
         // external and native methods must not be renamed
         if (!isPrivate) {
           names.put(key, name);
         }
       }
       else if (helper.toBeRenamed(IIdentifierRenamer.ELEMENT_METHOD, classOldFullName, name, mt.getDescriptor())) {
         if (isPrivate || !names.containsKey(key)) {
           do {
             name = helper.getNextMethodname(classOldFullName, name, mt.getDescriptor());
           }
           while (setMethodNames.contains(name));

           if (!isPrivate) {
             names.put(key, name);
           }
         }
         else {
           name = names.get(key);
         }

         interceptor.addName(classOldFullName + " " + mt.getName() + " " + mt.getDescriptor(),
                             classNewFullName + " " + name + " " + buildNewDescriptor(false, mt.getDescriptor()));
       }
     }

     // external fields are not being renamed
     if (!cl.isOwn()) {
       return;
     }

     // fields
     // FIXME: should overloaded fields become the same name?
     HashSet<String> setFieldNames = new HashSet<String>();
     for (StructField fd : cl.getFields()) {
       setFieldNames.add(fd.getName());
     }

     for (StructField fd : cl.getFields()) {
       if (helper.toBeRenamed(IIdentifierRenamer.ELEMENT_FIELD, classOldFullName, fd.getName(), fd.getDescriptor())) {
         String newname;

         do {
           newname = helper.getNextFieldname(classOldFullName, fd.getName(), fd.getDescriptor());
         }
         while (setFieldNames.contains(newname));

         interceptor.addName(classOldFullName + " " + fd.getName() + " " + fd.getDescriptor(),
                             classNewFullName + " " + newname + " " + buildNewDescriptor(true, fd.getDescriptor()));
       }
     }
   }

   private String buildNewDescriptor(boolean isField, String descriptor) {

     boolean updated = false;

     if (isField) {
       FieldDescriptor fd = FieldDescriptor.parseDescriptor(descriptor);

       VarType ftype = fd.type;
       if (ftype.type == CodeConstants.TYPE_OBJECT) {
         String newclname = interceptor.getName(ftype.value);
         if (newclname != null) {
           ftype.value = newclname;
           updated = true;
         }
       }

       if (updated) {
         return fd.getDescriptor();
       }
     }
     else {

       MethodDescriptor md = MethodDescriptor.parseDescriptor(descriptor);
       // params
       for (VarType partype : md.params) {
         if (partype.type == CodeConstants.TYPE_OBJECT) {
           String newclname = interceptor.getName(partype.value);
           if (newclname != null) {
             partype.value = newclname;
             updated = true;
           }
         }
       }

       // return value
       if (md.ret.type == CodeConstants.TYPE_OBJECT) {
         String newclname = interceptor.getName(md.ret.value);
         if (newclname != null) {
           md.ret.value = newclname;
           updated = true;
         }
       }

       if (updated) {
         return md.getDescriptor();
       }
     }

     return descriptor;
   }

   private static List<ClassWrapperNode> getReversePostOrderListIterative(List<ClassWrapperNode> roots) {

     List<ClassWrapperNode> res = new ArrayList<ClassWrapperNode>();

     LinkedList<ClassWrapperNode> stackNode = new LinkedList<ClassWrapperNode>();
     LinkedList<Integer> stackIndex = new LinkedList<Integer>();

     HashSet<ClassWrapperNode> setVisited = new HashSet<ClassWrapperNode>();

     for (ClassWrapperNode root : roots) {
       stackNode.add(root);
       stackIndex.add(0);
     }

     while (!stackNode.isEmpty()) {

       ClassWrapperNode node = stackNode.getLast();
       int index = stackIndex.removeLast();

       setVisited.add(node);

       List<ClassWrapperNode> lstSubs = node.getSubclasses();

       for (; index < lstSubs.size(); index++) {
         ClassWrapperNode sub = lstSubs.get(index);
         if (!setVisited.contains(sub)) {
           stackIndex.add(index + 1);

           stackNode.add(sub);
           stackIndex.add(0);

           break;
         }
       }

       if (index == lstSubs.size()) {
         res.add(0, node);

         stackNode.removeLast();
       }
     }

     return res;
   }


   private void buildInheritanceTree() {

     Map<String, ClassWrapperNode> nodes = new HashMap<String, ClassWrapperNode>();
     Map<String, StructClass> classes = context.getClasses();

     List<ClassWrapperNode> rootClasses = new ArrayList<ClassWrapperNode>();
     List<ClassWrapperNode> rootInterfaces = new ArrayList<ClassWrapperNode>();

     for (StructClass cl : classes.values()) {

       if (!cl.isOwn()) {
         continue;
       }

       LinkedList<StructClass> stack = new LinkedList<StructClass>();
       LinkedList<ClassWrapperNode> stackSubnodes = new LinkedList<ClassWrapperNode>();

       stack.add(cl);
       stackSubnodes.add(null);

       while (!stack.isEmpty()) {

         StructClass clstr = stack.removeFirst();
         ClassWrapperNode child = stackSubnodes.removeFirst();

         ClassWrapperNode node = nodes.get(clstr.qualifiedName);
         boolean isNewNode = (node == null);

         if (isNewNode) {
           nodes.put(clstr.qualifiedName, node = new ClassWrapperNode(clstr));
         }

         if (child != null) {
           node.addSubclass(child);
         }

         if (!isNewNode) {
           break;
         }
         else {
           boolean isInterface = clstr.hasModifier(CodeConstants.ACC_INTERFACE);
           boolean found_parent = false;

           if (isInterface) {
             for (String intrName : clstr.getInterfaceNames()) {
               StructClass clparent = classes.get(intrName);
               if (clparent != null) {
                 stack.add(clparent);
                 stackSubnodes.add(node);
                 found_parent = true;
               }
             }
           }
           else {
             if (clstr.superClass != null) { // null iff java/lang/Object
               StructClass clparent = classes.get(clstr.superClass.getString());

               if (clparent != null) {
                 stack.add(clparent);
                 stackSubnodes.add(node);
                 found_parent = true;
               }
             }
           }

           if (!found_parent) { // no super class or interface
             (isInterface ? rootInterfaces : rootClasses).add(node);
           }
         }
       }
     }

     this.rootClasses = rootClasses;
     this.rootInterfaces = rootInterfaces;
   }
 }
	/*
	* Copyright 2000-2014 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.jetbrains.java.decompiler.modules.renamer;

	import org.jetbrains.java.decompiler.code.CodeConstants;
	import org.jetbrains.java.decompiler.main.DecompilerContext;
	import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences;
	import org.jetbrains.java.decompiler.main.extern.IIdentifierRenamer;
	import org.jetbrains.java.decompiler.struct.StructClass;
	import org.jetbrains.java.decompiler.struct.StructContext;
	import org.jetbrains.java.decompiler.struct.StructField;
	import org.jetbrains.java.decompiler.struct.StructMethod;
	import org.jetbrains.java.decompiler.struct.gen.FieldDescriptor;
	import org.jetbrains.java.decompiler.struct.gen.MethodDescriptor;
	import org.jetbrains.java.decompiler.struct.gen.VarType;
	import org.jetbrains.java.decompiler.util.VBStyleCollection;

	import java.io.IOException;
	import java.util.*;

	public class IdentifierConverter {

	private StructContext context;

	private IIdentifierRenamer helper;

	private PoolInterceptor interceptor;

	private List<ClassWrapperNode> rootClasses = new ArrayList<ClassWrapperNode>();

	private List<ClassWrapperNode> rootInterfaces = new ArrayList<ClassWrapperNode>();

	private HashMap<String, HashMap<String, String>> interfaceNameMaps = new HashMap<String, HashMap<String, String>>();

	public void rename(StructContext context) {

	try {
	this.context = context;

	String user_class = (String)DecompilerContext.getProperty(IFernflowerPreferences.USER_RENAMER_CLASS);
	if (user_class != null) {
	try {
	helper = (IIdentifierRenamer)IdentifierConverter.class.getClassLoader().loadClass(user_class).newInstance();
	}
	catch (Exception ex) {
	// ignore errors
	}
	}

	if (helper == null) {
	helper = new ConverterHelper();
	}

	interceptor = new PoolInterceptor(helper);

	buildInheritanceTree();

	renameAllClasses();

	renameInterfaces();

	renameClasses();

	DecompilerContext.setPoolInterceptor(interceptor);
	context.reloadContext();
	}
	catch (IOException ex) {
	throw new RuntimeException("Renaming failed!");
	}
	}

	private void renameClasses() {

	List<ClassWrapperNode> lstClasses = getReversePostOrderListIterative(rootClasses);

	HashMap<String, HashMap<String, String>> classNameMaps = new HashMap<String, HashMap<String, String>>();

	for (ClassWrapperNode node : lstClasses) {

	StructClass cl = node.getClassStruct();
	HashMap<String, String> names = new HashMap<String, String>();

	// merge informations on super class
	if (cl.superClass != null) {
	HashMap<String, String> mapClass = classNameMaps.get(cl.superClass.getString());
	if (mapClass != null) {
	names.putAll(mapClass);
	}
	}

	// merge informations on interfaces
	for (String intrName : cl.getInterfaceNames()) {
	HashMap<String, String> mapInt = interfaceNameMaps.get(intrName);
	if (mapInt != null) {
	names.putAll(mapInt);
	}
	else {
	StructClass clintr = context.getClass(intrName);
	if (clintr != null) {
	names.putAll(processExternalInterface(clintr));
	}
	}
	}

	renameClassIdentifiers(cl, names);

	if (!node.getSubclasses().isEmpty()) {
	classNameMaps.put(cl.qualifiedName, names);
	}
	}
	}

	private HashMap<String, String> processExternalInterface(StructClass cl) {

	HashMap<String, String> names = new HashMap<String, String>();

	for (String intrName : cl.getInterfaceNames()) {

	HashMap<String, String> mapInt = interfaceNameMaps.get(intrName);
	if (mapInt != null) {
	names.putAll(mapInt);
	}
	else {
	StructClass clintr = context.getClass(intrName);
	if (clintr != null) {
	names.putAll(processExternalInterface(clintr));
	}
	}
	}

	renameClassIdentifiers(cl, names);

	return names;
	}

	private void renameInterfaces() {

	List<ClassWrapperNode> lstInterfaces = getReversePostOrderListIterative(rootInterfaces);

	HashMap<String, HashMap<String, String>> interfaceNameMaps = new HashMap<String, HashMap<String, String>>();

	// rename methods and fields
	for (ClassWrapperNode node : lstInterfaces) {

	StructClass cl = node.getClassStruct();
	HashMap<String, String> names = new HashMap<String, String>();

	// merge informations on super interfaces
	for (String intrName : cl.getInterfaceNames()) {
	HashMap<String, String> mapInt = interfaceNameMaps.get(intrName);
	if (mapInt != null) {
	names.putAll(mapInt);
	}
	}

	renameClassIdentifiers(cl, names);

	interfaceNameMaps.put(cl.qualifiedName, names);
	}

	this.interfaceNameMaps = interfaceNameMaps;
	}

	private void renameAllClasses() {

	// order not important
	List<ClassWrapperNode> lstAllClasses = new ArrayList<ClassWrapperNode>(getReversePostOrderListIterative(rootInterfaces));
	lstAllClasses.addAll(getReversePostOrderListIterative(rootClasses));

	// rename all interfaces and classes
	for (ClassWrapperNode node : lstAllClasses) {
	renameClass(node.getClassStruct());
	}
	}

	private void renameClass(StructClass cl) {

	if (!cl.isOwn()) {
	return;
	}

	String classOldFullName = cl.qualifiedName;

	// TODO: rename packages
	String clsimplename = ConverterHelper.getSimpleClassName(classOldFullName);
	if (helper.toBeRenamed(IIdentifierRenamer.ELEMENT_CLASS, clsimplename, null, null)) {
	String classNewFullName;

	do {
	classNewFullName = ConverterHelper.replaceSimpleClassName(classOldFullName,
	helper.getNextClassname(classOldFullName, ConverterHelper
	.getSimpleClassName(classOldFullName)));
	}
	while (context.getClasses().containsKey(classNewFullName));

	interceptor.addName(classOldFullName, classNewFullName);
	}
	}

	private void renameClassIdentifiers(StructClass cl, HashMap<String, String> names) {

	// all classes are already renamed
	String classOldFullName = cl.qualifiedName;
	String classNewFullName = interceptor.getName(classOldFullName);

	if (classNewFullName == null) {
	classNewFullName = classOldFullName;
	}

	// methods
	HashSet<String> setMethodNames = new HashSet<String>();
	for (StructMethod md : cl.getMethods()) {
	setMethodNames.add(md.getName());
	}

	VBStyleCollection<StructMethod, String> methods = cl.getMethods();
	for (int i = 0; i < methods.size(); i++) {

	StructMethod mt = methods.get(i);
	String key = methods.getKey(i);

	boolean isPrivate = mt.hasModifier(CodeConstants.ACC_PRIVATE);

	String name = mt.getName();
	if (!cl.isOwn() \|\| mt.hasModifier(CodeConstants.ACC_NATIVE)) {
	// external and native methods must not be renamed
	if (!isPrivate) {
	names.put(key, name);
	}
	}
	else if (helper.toBeRenamed(IIdentifierRenamer.ELEMENT_METHOD, classOldFullName, name, mt.getDescriptor())) {
	if (isPrivate \|\| !names.containsKey(key)) {
	do {
	name = helper.getNextMethodname(classOldFullName, name, mt.getDescriptor());
	}
	while (setMethodNames.contains(name));

	if (!isPrivate) {
	names.put(key, name);
	}
	}
	else {
	name = names.get(key);
	}

	interceptor.addName(classOldFullName + " " + mt.getName() + " " + mt.getDescriptor(),
	classNewFullName + " " + name + " " + buildNewDescriptor(false, mt.getDescriptor()));
	}
	}

	// external fields are not being renamed
	if (!cl.isOwn()) {
	return;
	}

	// fields
	// FIXME: should overloaded fields become the same name?
	HashSet<String> setFieldNames = new HashSet<String>();
	for (StructField fd : cl.getFields()) {
	setFieldNames.add(fd.getName());
	}

	for (StructField fd : cl.getFields()) {
	if (helper.toBeRenamed(IIdentifierRenamer.ELEMENT_FIELD, classOldFullName, fd.getName(), fd.getDescriptor())) {
	String newname;

	do {
	newname = helper.getNextFieldname(classOldFullName, fd.getName(), fd.getDescriptor());
	}
	while (setFieldNames.contains(newname));

	interceptor.addName(classOldFullName + " " + fd.getName() + " " + fd.getDescriptor(),
	classNewFullName + " " + newname + " " + buildNewDescriptor(true, fd.getDescriptor()));
	}
	}
	}

	private String buildNewDescriptor(boolean isField, String descriptor) {

	boolean updated = false;

	if (isField) {
	FieldDescriptor fd = FieldDescriptor.parseDescriptor(descriptor);

	VarType ftype = fd.type;
	if (ftype.type == CodeConstants.TYPE_OBJECT) {
	String newclname = interceptor.getName(ftype.value);
	if (newclname != null) {
	ftype.value = newclname;
	updated = true;
	}
	}

	if (updated) {
	return fd.getDescriptor();
	}
	}
	else {

	MethodDescriptor md = MethodDescriptor.parseDescriptor(descriptor);
	// params
	for (VarType partype : md.params) {
	if (partype.type == CodeConstants.TYPE_OBJECT) {
	String newclname = interceptor.getName(partype.value);
	if (newclname != null) {
	partype.value = newclname;
	updated = true;
	}
	}
	}

	// return value
	if (md.ret.type == CodeConstants.TYPE_OBJECT) {
	String newclname = interceptor.getName(md.ret.value);
	if (newclname != null) {
	md.ret.value = newclname;
	updated = true;
	}
	}

	if (updated) {
	return md.getDescriptor();
	}
	}

	return descriptor;
	}

	private static List<ClassWrapperNode> getReversePostOrderListIterative(List<ClassWrapperNode> roots) {

	List<ClassWrapperNode> res = new ArrayList<ClassWrapperNode>();

	LinkedList<ClassWrapperNode> stackNode = new LinkedList<ClassWrapperNode>();
	LinkedList<Integer> stackIndex = new LinkedList<Integer>();

	HashSet<ClassWrapperNode> setVisited = new HashSet<ClassWrapperNode>();

	for (ClassWrapperNode root : roots) {
	stackNode.add(root);
	stackIndex.add(0);
	}

	while (!stackNode.isEmpty()) {

	ClassWrapperNode node = stackNode.getLast();
	int index = stackIndex.removeLast();

	setVisited.add(node);

	List<ClassWrapperNode> lstSubs = node.getSubclasses();

	for (; index < lstSubs.size(); index++) {
	ClassWrapperNode sub = lstSubs.get(index);
	if (!setVisited.contains(sub)) {
	stackIndex.add(index + 1);

	stackNode.add(sub);
	stackIndex.add(0);

	break;
	}
	}

	if (index == lstSubs.size()) {
	res.add(0, node);

	stackNode.removeLast();
	}
	}

	return res;
	}


	private void buildInheritanceTree() {

	Map<String, ClassWrapperNode> nodes = new HashMap<String, ClassWrapperNode>();
	Map<String, StructClass> classes = context.getClasses();

	List<ClassWrapperNode> rootClasses = new ArrayList<ClassWrapperNode>();
	List<ClassWrapperNode> rootInterfaces = new ArrayList<ClassWrapperNode>();

	for (StructClass cl : classes.values()) {

	if (!cl.isOwn()) {
	continue;
	}

	LinkedList<StructClass> stack = new LinkedList<StructClass>();
	LinkedList<ClassWrapperNode> stackSubnodes = new LinkedList<ClassWrapperNode>();

	stack.add(cl);
	stackSubnodes.add(null);

	while (!stack.isEmpty()) {

	StructClass clstr = stack.removeFirst();
	ClassWrapperNode child = stackSubnodes.removeFirst();

	ClassWrapperNode node = nodes.get(clstr.qualifiedName);
	boolean isNewNode = (node == null);

	if (isNewNode) {
	nodes.put(clstr.qualifiedName, node = new ClassWrapperNode(clstr));
	}

	if (child != null) {
	node.addSubclass(child);
	}

	if (!isNewNode) {
	break;
	}
	else {
	boolean isInterface = clstr.hasModifier(CodeConstants.ACC_INTERFACE);
	boolean found_parent = false;

	if (isInterface) {
	for (String intrName : clstr.getInterfaceNames()) {
	StructClass clparent = classes.get(intrName);
	if (clparent != null) {
	stack.add(clparent);
	stackSubnodes.add(node);
	found_parent = true;
	}
	}
	}
	else {
	if (clstr.superClass != null) { // null iff java/lang/Object
	StructClass clparent = classes.get(clstr.superClass.getString());

	if (clparent != null) {
	stack.add(clparent);
	stackSubnodes.add(node);
	found_parent = true;
	}
	}
	}

	if (!found_parent) { // no super class or interface
	(isInterface ? rootInterfaces : rootClasses).add(node);
	}
	}
	}
	}

	this.rootClasses = rootClasses;
	this.rootInterfaces = rootInterfaces;
	}
	}