added support for field access searches

added proper detection/handling for constructors

9 files changed, 460 insertions, 78 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 33eef08a..770172e3 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -34,6 +34,7 @@ import cuchaz.enigma.analysis.SourceIndexVisitor;
 import cuchaz.enigma.mapping.ArgumentEntry;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.ClassMapping;
+import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.Mappings;
@@ -185,6 +186,10 @@ public class Deobfuscator
                 {
                         m_renamer.setMethodTreeName( (MethodEntry)obfEntry, newName );
                 }
+                else if( obfEntry instanceof ConstructorEntry )
+                {
+                        m_renamer.setClassName( obfEntry.getClassEntry(), newName );
+                }
                 else if( obfEntry instanceof ArgumentEntry )
                 {
                         m_renamer.setArgumentName( (ArgumentEntry)obfEntry, newName );
@@ -210,6 +215,10 @@ public class Deobfuscator
                 {
                         return translator.translateEntry( (MethodEntry)deobfEntry );
                 }
+                else if( deobfEntry instanceof ConstructorEntry )
+                {
+                        return translator.translateEntry( (ConstructorEntry)deobfEntry );
+                }
                 else if( deobfEntry instanceof ArgumentEntry )
                 {
                         return translator.translateEntry( (ArgumentEntry)deobfEntry );
@@ -235,6 +244,10 @@ public class Deobfuscator
                 {
                         return translator.translateEntry( (MethodEntry)obfEntry );
                 }
+                else if( obfEntry instanceof ConstructorEntry )
+                {
+                        return translator.translateEntry( (ConstructorEntry)obfEntry );
+                }
                 else if( obfEntry instanceof ArgumentEntry )
                 {
                         return translator.translateEntry( (ArgumentEntry)obfEntry );
@@ -263,6 +276,11 @@ public class Deobfuscator
                         String deobfName = translator.translate( (MethodEntry)obfEntry );
                         return deobfName != null && !deobfName.equals( obfEntry.getName() );
                 }
+                else if( obfEntry instanceof ConstructorEntry )
+                {
+                        String deobfName = translator.translate( obfEntry.getClassEntry() );
+                        return deobfName != null && !deobfName.equals( obfEntry.getClassName() );
+                }
                 else if( obfEntry instanceof ArgumentEntry )
                 {
                         return translator.translate( (ArgumentEntry)obfEntry ) != null;
@@ -282,16 +300,20 @@ public class Deobfuscator
                 }
                 else if( obfEntry instanceof FieldEntry )
                 {
-                        return m_jarIndex.getObfClassNames().contains( ((FieldEntry)obfEntry).getClassName() );
+                        return m_jarIndex.getObfClassNames().contains( obfEntry.getClassName() );
                 }
                 else if( obfEntry instanceof MethodEntry )
                 {
-                        return m_jarIndex.getObfClassNames().contains( ((MethodEntry)obfEntry).getClassName() );
+                        return m_jarIndex.getObfClassNames().contains( obfEntry.getClassName() );
+                }
+                else if( obfEntry instanceof ConstructorEntry )
+                {
+                        return m_jarIndex.getObfClassNames().contains( obfEntry.getClassName() );
                 }
                 else if( obfEntry instanceof ArgumentEntry )
                 {
-                        // arguments only appear in method delcarations
-                        // since we only show declrations for obf classes, these are always obfuscated
+                        // arguments only appear in method declarations
+                        // since we only show declarations for obf classes, these are always obfuscated
                         return true;
                 }
                 
diff --git a/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java b/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java
new file mode 100644
index 00000000..0427b3be
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Translator;
+
+public class FieldCallsTreeNode extends DefaultMutableTreeNode
+{
+        private static final long serialVersionUID = -7934108091928699835L;
+        
+        private Translator m_deobfuscatingTranslator;
+        private FieldEntry m_entry;
+        
+        public FieldCallsTreeNode( Translator deobfuscatingTranslator, FieldEntry fieldEntry )
+        {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_entry = fieldEntry;
+        }
+        
+        public FieldEntry getFieldEntry( )
+        {
+                return m_entry;
+        }
+        
+        @Override
+        public String toString( )
+        {
+                String className = m_deobfuscatingTranslator.translateClass( m_entry.getClassName() );
+                if( className == null )
+                {
+                        className = m_entry.getClassName();
+                }
+                
+                String targetName = m_deobfuscatingTranslator.translate( m_entry );
+                if( targetName == null )
+                {
+                        targetName = m_entry.getName();
+                }
+                return className + "." + targetName;
+        }
+        
+        public void load( JarIndex index, boolean recurse )
+        {
+                // get all the child nodes
+                for( Entry entry : index.getFieldCallers( m_entry ) )
+                {
+                        if( entry instanceof MethodEntry )
+                        {
+                                add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (MethodEntry)entry ) );
+                        }
+                        else if( entry instanceof ConstructorEntry )
+                        {
+                                add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (ConstructorEntry)entry ) );
+                        }
+                }
+                
+                if( recurse && children != null )
+                {
+                        for( Object node : children )
+                        {
+                                if( node instanceof MethodCallsTreeNode )
+                                {
+                                        ((MethodCallsTreeNode)node).load( index, true );
+                                }
+                        }
+                }
+        }
+}
diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
index 06b01736..96bddc17 100644
--- a/src/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -27,17 +27,26 @@ import javassist.CannotCompileException;
 import javassist.ClassPool;
 import javassist.CtBehavior;
 import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
 import javassist.NotFoundException;
 import javassist.bytecode.Descriptor;
+import javassist.expr.ConstructorCall;
 import javassist.expr.ExprEditor;
+import javassist.expr.FieldAccess;
 import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
 
 import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 
 import cuchaz.enigma.Constants;
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.Translator;
 
@@ -46,7 +55,8 @@ public class JarIndex
         private Set<String> m_obfClassNames;
         private Ancestries m_ancestries;
         private Multimap<String,MethodEntry> m_methodImplementations;
-        private Multimap<MethodEntry,MethodEntry> m_methodCalls;
+        private Multimap<Entry,Entry> m_methodCalls;
+        private Multimap<FieldEntry,Entry> m_fieldCalls;
         
         public JarIndex( JarFile jar )
         {
@@ -54,6 +64,7 @@ public class JarIndex
                 m_ancestries = new Ancestries();
                 m_methodImplementations = HashMultimap.create();
                 m_methodCalls = HashMultimap.create();
+                m_fieldCalls = HashMultimap.create();
                 
                 // read the class names
                 Enumeration<JarEntry> enumeration = jar.entries();
@@ -133,14 +144,30 @@ public class JarIndex
         {
                 // get the method entry
                 String className = Descriptor.toJvmName( behavior.getDeclaringClass().getName() );
-                final MethodEntry methodEntry = new MethodEntry(
-                        new ClassEntry( className ),
-                        behavior.getName(),
-                        behavior.getSignature()
-                );
-                
-                // index implementation
-                m_methodImplementations.put( className, methodEntry );
+                final Entry thisEntry;
+                if( behavior instanceof CtMethod )
+                {
+                        MethodEntry methodEntry = new MethodEntry(
+                                new ClassEntry( className ),
+                                behavior.getName(),
+                                behavior.getSignature()
+                        );
+                        thisEntry = methodEntry;
+                        
+                        // index implementation
+                        m_methodImplementations.put( className, methodEntry );
+                }
+                else if( behavior instanceof CtConstructor )
+                {
+                        thisEntry = new ConstructorEntry(
+                                new ClassEntry( className ),
+                                behavior.getSignature()
+                        );
+                }
+                else
+                {
+                        throw new IllegalArgumentException( "behavior must be a method or a constructor!" );
+                }
                 
                 // index method calls
                 try
@@ -150,20 +177,53 @@ public class JarIndex
                                 @Override
                                 public void edit( MethodCall call )
                                 {
-                                        // is this a jar class?
                                         String className = Descriptor.toJvmName( call.getClassName() );
-                                        if( !m_obfClassNames.contains( className ) )
-                                        {
-                                                return;
-                                        }
-                                        
-                                        // make entry for the called method
                                         MethodEntry calledMethodEntry = new MethodEntry(
                                                 new ClassEntry( className ),
                                                 call.getMethodName(),
                                                 call.getSignature()
                                         );
-                                        m_methodCalls.put( calledMethodEntry, methodEntry );
+                                        m_methodCalls.put( calledMethodEntry, thisEntry );
+                                }
+                                
+                                @Override
+                                public void edit( FieldAccess call )
+                                {
+                                        String className = Descriptor.toJvmName( call.getClassName() );
+                                        FieldEntry calledFieldEntry = new FieldEntry(
+                                                new ClassEntry( className ),
+                                                call.getFieldName()
+                                        );
+                                        m_fieldCalls.put( calledFieldEntry, thisEntry );
+                                }
+                                
+                                @Override
+                                public void edit( ConstructorCall call )
+                                {
+                                        String className = Descriptor.toJvmName( call.getClassName() );
+                                        ConstructorEntry calledConstructorEntry = new ConstructorEntry(
+                                                new ClassEntry( className ),
+                                                call.getSignature()
+                                        );
+                                        m_methodCalls.put( calledConstructorEntry, thisEntry );
+                                }
+                                
+                                @Override
+                                public void edit( NewExpr call )
+                                {
+                                        String className = Descriptor.toJvmName( call.getClassName() );
+                                        ConstructorEntry calledConstructorEntry = new ConstructorEntry(
+                                                new ClassEntry( className ),
+                                                call.getSignature()
+                                        );
+                                        
+                                        // TEMP
+                                        if( className.equals( "bgw" ) )
+                                        {
+                                                System.out.println( calledConstructorEntry + " called by " + thisEntry );
+                                        }
+                                        
+                                        m_methodCalls.put( calledConstructorEntry, thisEntry );
                                 }
                         } );
                 }
@@ -202,7 +262,9 @@ public class JarIndex
         public ClassInheritanceTreeNode getClassInheritance( Translator deobfuscatingTranslator, ClassEntry obfClassEntry )
         {
                 // get the root node
-                List<String> ancestry = m_ancestries.getAncestry( obfClassEntry.getName() );
+                List<String> ancestry = Lists.newArrayList();
+                ancestry.add( obfClassEntry.getName() );
+                ancestry.addAll( m_ancestries.getAncestry( obfClassEntry.getName() ) );
                 ClassInheritanceTreeNode rootNode = new ClassInheritanceTreeNode( deobfuscatingTranslator, ancestry.get( ancestry.size() - 1 ) );
                 
                 // expand all children recursively
@@ -241,9 +303,14 @@ public class JarIndex
                 return rootNode;
         }
         
-        public Collection<MethodEntry> getMethodCallers( MethodEntry methodEntry )
+        public Collection<Entry> getFieldCallers( FieldEntry fieldEntry )
+        {
+                return m_fieldCalls.get( fieldEntry );
+        }
+        
+        public Collection<Entry> getMethodCallers( Entry entry )
         {
-                return m_methodCalls.get( methodEntry );
+                return m_methodCalls.get( entry );
         }
         
         private String getMethodKey( String name, String signature )
diff --git a/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java b/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java
index dedfb2e7..b5cf4c33 100644
--- a/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java
+++ b/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java
@@ -10,12 +10,15 @@
  ******************************************************************************/
 package cuchaz.enigma.analysis;
 
-import java.util.List;
+import java.util.Set;
 
 import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeNode;
 
-import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.Translator;
 
@@ -24,72 +27,117 @@ public class MethodCallsTreeNode extends DefaultMutableTreeNode
         private static final long serialVersionUID = -3658163700783307520L;
         
         private Translator m_deobfuscatingTranslator;
-        private MethodEntry m_entry;
+        private MethodEntry m_methodEntry;
+        private ConstructorEntry m_constructorEntry;
         
         public MethodCallsTreeNode( Translator deobfuscatingTranslator, MethodEntry entry )
         {
                 m_deobfuscatingTranslator = deobfuscatingTranslator;
-                m_entry = entry;
+                m_methodEntry = entry;
+                m_constructorEntry = null;
+        }
+        
+        public MethodCallsTreeNode( Translator deobfuscatingTranslator, ConstructorEntry entry )
+        {
+                m_deobfuscatingTranslator = deobfuscatingTranslator;
+                m_methodEntry = null;
+                m_constructorEntry = entry;
         }
         
         public MethodEntry getMethodEntry( )
         {
-                return m_entry;
+                return m_methodEntry;
         }
         
-        public String getDeobfClassName( )
+        public ConstructorEntry getConstructorEntry( )
         {
-                return m_deobfuscatingTranslator.translateClass( m_entry.getClassName() );
+                return m_constructorEntry;
         }
         
-        public String getDeobfMethodName( )
+        public Entry getEntry( )
         {
-                return m_deobfuscatingTranslator.translate( m_entry );
+                if( m_methodEntry != null )
+                {
+                        return m_methodEntry;
+                }
+                else if( m_constructorEntry != null )
+                {
+                        return m_constructorEntry;
+                }
+                throw new Error( "Illegal state!" );
         }
         
         @Override
         public String toString( )
         {
-                String className = getDeobfClassName();
-                if( className == null )
+                if( m_methodEntry != null )
                 {
-                        className = m_entry.getClassName();
+                        String className = m_deobfuscatingTranslator.translateClass( m_methodEntry.getClassName() );
+                        if( className == null )
+                        {
+                                className = m_methodEntry.getClassName();
+                        }
+                        
+                        String methodName = m_deobfuscatingTranslator.translate( m_methodEntry );
+                        if( methodName == null )
+                        {
+                                methodName = m_methodEntry.getName();
+                        }
+                        return className + "." + methodName + "()";
                 }
-                
-                String methodName = getDeobfMethodName();
-                if( methodName == null )
+                else if( m_constructorEntry != null )
                 {
-                        methodName = m_entry.getName();
+                        String className = m_deobfuscatingTranslator.translateClass( m_constructorEntry.getClassName() );
+                        if( className == null )
+                        {
+                                className = m_constructorEntry.getClassName();
+                        }
+                        return className + "()";
                 }
-                return className + "." + methodName + "()";
+                throw new Error( "Illegal state!" );
         }
         
         public void load( JarIndex index, boolean recurse )
         {
                 // get all the child nodes
-                List<MethodCallsTreeNode> nodes = Lists.newArrayList();
-                for( MethodEntry entry : index.getMethodCallers( m_entry ) )
+                for( Entry entry : index.getMethodCallers( getEntry() ) )
                 {
-                        nodes.add( new MethodCallsTreeNode( m_deobfuscatingTranslator, entry ) );
-                }
-                
-                // add them to this node
-                for( MethodCallsTreeNode node : nodes )
-                {
-                        this.add( node );
+                        if( entry instanceof MethodEntry )
+                        {
+                                add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (MethodEntry)entry ) );
+                        }
+                        else if( entry instanceof ConstructorEntry )
+                        {
+                                add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (ConstructorEntry)entry ) );
+                        }
                 }
                 
-                if( recurse )
+                if( recurse && children != null )
                 {
-                        for( MethodCallsTreeNode node : nodes )
+                        for( Object child : children )
                         {
-                                // don't recurse into self
-                                if( node.getMethodEntry().equals( m_entry ) )
+                                if( child instanceof MethodCallsTreeNode )
                                 {
-                                        continue;
+                                        MethodCallsTreeNode node = (MethodCallsTreeNode)child;
+                                        
+                                        // don't recurse into ancestor
+                                        Set<Entry> ancestors = Sets.newHashSet();
+                                        TreeNode n = (TreeNode)node;
+                                        while( n.getParent() != null )
+                                        {
+                                                n = n.getParent();
+                                                if( n instanceof MethodCallsTreeNode )
+                                                {
+                                                        ancestors.add( ((MethodCallsTreeNode)n).getEntry() );
+                                                }
+                                        }
+                                        if( ancestors.contains( node.getEntry() ) )
+                                        {
+                                                continue;
+                                        }
+                                        
+                                        node.load( index, true );
                                 }
-                                
-                                node.load( index, true );
                         }
                 }
         }
diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
index 0ba5996c..6c14ee99 100644
--- a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
+++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
@@ -93,6 +93,7 @@ import com.strobel.decompiler.patterns.Pattern;
 
 import cuchaz.enigma.mapping.ArgumentEntry;
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MethodEntry;
 
@@ -158,7 +159,9 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void>
         public Void visitConstructorDeclaration( ConstructorDeclaration node, SourceIndex index )
         {
                 MethodDefinition def = node.getUserData( Keys.METHOD_DEFINITION );
-                index.add( node.getNameToken(), new ClassEntry( def.getDeclaringType().getInternalName() ) );
+                ClassEntry classEntry = new ClassEntry( def.getDeclaringType().getInternalName() );
+                ConstructorEntry constructorEntry = new ConstructorEntry( classEntry, def.getSignature() );
+                index.addDeclaration( node.getNameToken(), constructorEntry );
                 
                 return recurse( node, index );
         }
diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java
index 072fb3a5..1d2d3ab1 100644
--- a/src/cuchaz/enigma/gui/Gui.java
+++ b/src/cuchaz/enigma/gui/Gui.java
@@ -67,11 +67,13 @@ import com.google.common.collect.Lists;
 
 import cuchaz.enigma.Constants;
 import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.FieldCallsTreeNode;
 import cuchaz.enigma.analysis.MethodCallsTreeNode;
 import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
 import cuchaz.enigma.analysis.Token;
 import cuchaz.enigma.mapping.ArgumentEntry;
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.EntryPair;
 import cuchaz.enigma.mapping.FieldEntry;
@@ -419,7 +421,7 @@ public class Gui
                                         Object node = path.getLastPathComponent();
                                         if( node instanceof MethodCallsTreeNode )
                                         {
-                                                m_controller.openEntry( ((MethodCallsTreeNode)node).getMethodEntry() );
+                                                m_controller.openEntry( ((MethodCallsTreeNode)node).getEntry() );
                                         }
                                 }
                         }
@@ -438,7 +440,7 @@ public class Gui
                 m_tabs = new JTabbedPane();
                 m_tabs.setPreferredSize( new Dimension( 250, 0 ) );
                 m_tabs.addTab( "Inheritance", inheritancePanel );
-                m_tabs.addTab( "Method Calls", callPanel );
+                m_tabs.addTab( "Call Graph", callPanel );
                 JSplitPane splitRight = new JSplitPane( JSplitPane.HORIZONTAL_SPLIT, true, centerPanel, m_tabs );
                 splitRight.setResizeWeight( 1 ); // let the left side take all the slack
                 splitRight.resetToPreferredSizes();
@@ -770,6 +772,10 @@ public class Gui
                 {
                         showMethodEntryPair( (EntryPair<? extends MethodEntry>)pair );
                 }
+                else if( pair.deobf instanceof ConstructorEntry )
+                {
+                        showConstructorEntryPair( (EntryPair<? extends ConstructorEntry>)pair );
+                }
                 else if( pair.deobf instanceof ArgumentEntry )
                 {
                         showArgumentEntryPair( (EntryPair<? extends ArgumentEntry>)pair );
@@ -800,6 +806,12 @@ public class Gui
                 addNameValue( m_infoPanel, "Signature", pair.deobf.getSignature() );
         }
         
+        private void showConstructorEntryPair( EntryPair<? extends ConstructorEntry> pair )
+        {
+                addNameValue( m_infoPanel, "Constructor", pair.deobf.getClassEntry().getName() );
+                addNameValue( m_infoPanel, "Signature", pair.deobf.getSignature() );
+        }
+        
         private void showArgumentEntryPair( EntryPair<? extends ArgumentEntry> pair )
         {
                 addNameValue( m_infoPanel, "Argument", pair.deobf.getName() );
@@ -815,7 +827,7 @@ public class Gui
                 container.add( panel );
                 
                 JLabel label = new JLabel( name + ":", JLabel.RIGHT );
-                label.setPreferredSize( new Dimension( 80, label.getPreferredSize().height ) );
+                label.setPreferredSize( new Dimension( 100, label.getPreferredSize().height ) );
                 panel.add( label );
                 
                 panel.add( unboldLabel( new JLabel( value, JLabel.LEFT ) ) );
@@ -824,23 +836,27 @@ public class Gui
         private void onCaretMove( int pos )
         {
                 Token token = m_controller.getToken( pos );
-                m_renameMenu.setEnabled( token != null );
-                if( token == null )
-                {
-                        clearEntryPair();
-                        return;
-                }
+                boolean isToken = token != null;
                 
                 m_selectedEntryPair = m_controller.getEntryPair( token );
-                boolean isClassEntry = m_selectedEntryPair.obf instanceof ClassEntry;
-                boolean isFieldEntry = m_selectedEntryPair.obf instanceof FieldEntry;
-                boolean isMethodEntry = m_selectedEntryPair.obf instanceof MethodEntry;
+                boolean isClassEntry = isToken && m_selectedEntryPair.obf instanceof ClassEntry;
+                boolean isFieldEntry = isToken && m_selectedEntryPair.obf instanceof FieldEntry;
+                boolean isMethodEntry = isToken && m_selectedEntryPair.obf instanceof MethodEntry;
+                boolean isConstructorEntry = isToken && m_selectedEntryPair.obf instanceof ConstructorEntry;
                 
-                showEntryPair( m_selectedEntryPair );
+                if( isToken )
+                {
+                        showEntryPair( m_selectedEntryPair );
+                }
+                else
+                {
+                        clearEntryPair();
+                }
                 
-                m_showInheritanceMenu.setEnabled( isClassEntry || isMethodEntry );
-                m_showCallsMenu.setEnabled( isMethodEntry );
-                m_openEntryMenu.setEnabled( isClassEntry || isFieldEntry || isMethodEntry );
+                m_renameMenu.setEnabled( isToken );
+                m_showInheritanceMenu.setEnabled( isClassEntry || isMethodEntry || isConstructorEntry );
+                m_showCallsMenu.setEnabled( isFieldEntry || isMethodEntry || isConstructorEntry );
+                m_openEntryMenu.setEnabled( isClassEntry || isFieldEntry || isMethodEntry || isConstructorEntry );
                 m_openPreviousMenu.setEnabled( m_controller.hasPreviousEntry() );
         }
         
@@ -945,11 +961,21 @@ public class Gui
                         return;
                 }
                 
-                if( m_selectedEntryPair.obf instanceof MethodEntry )
+                if( m_selectedEntryPair.obf instanceof FieldEntry )
+                {
+                        FieldCallsTreeNode node = m_controller.getFieldCalls( (FieldEntry)m_selectedEntryPair.obf );
+                        m_callsTree.setModel( new DefaultTreeModel( node ) );
+                }
+                else if( m_selectedEntryPair.obf instanceof MethodEntry )
                 {
                         MethodCallsTreeNode node = m_controller.getMethodCalls( (MethodEntry)m_selectedEntryPair.obf );
                         m_callsTree.setModel( new DefaultTreeModel( node ) );
                 }
+                else if( m_selectedEntryPair.obf instanceof ConstructorEntry )
+                {
+                        MethodCallsTreeNode node = m_controller.getMethodCalls( (ConstructorEntry)m_selectedEntryPair.obf );
+                        m_callsTree.setModel( new DefaultTreeModel( node ) );
+                }
                 
                 m_tabs.setSelectedIndex( 1 );
                 redraw();
diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java
index b54aeba3..534b0cc5 100644
--- a/src/cuchaz/enigma/gui/GuiController.java
+++ b/src/cuchaz/enigma/gui/GuiController.java
@@ -21,13 +21,16 @@ import com.google.common.collect.Lists;
 
 import cuchaz.enigma.Deobfuscator;
 import cuchaz.enigma.analysis.ClassInheritanceTreeNode;
+import cuchaz.enigma.analysis.FieldCallsTreeNode;
 import cuchaz.enigma.analysis.MethodCallsTreeNode;
 import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
 import cuchaz.enigma.analysis.SourceIndex;
 import cuchaz.enigma.analysis.Token;
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.EntryPair;
+import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MappingsReader;
 import cuchaz.enigma.mapping.MappingsWriter;
 import cuchaz.enigma.mapping.MethodEntry;
@@ -118,6 +121,10 @@ public class GuiController
                 }
                 
                 Entry deobfEntry = m_index.getEntry( token );
+                if( deobfEntry == null )
+                {
+                        return null;
+                }
                 return new EntryPair<Entry>( m_deobfuscator.obfuscateEntry( deobfEntry ), deobfEntry );
         }
         
@@ -149,16 +156,41 @@ public class GuiController
                 return MethodInheritanceTreeNode.findNode( rootNode, obfMethodEntry );
         }
         
-        public MethodCallsTreeNode getMethodCalls( MethodEntry obfMethodEntry )
+        public FieldCallsTreeNode getFieldCalls( FieldEntry obfFieldEntry )
         {
-                MethodCallsTreeNode rootNode = new MethodCallsTreeNode(
+                FieldCallsTreeNode rootNode = new FieldCallsTreeNode(
                         m_deobfuscator.getTranslator( TranslationDirection.Deobfuscating ),
-                        obfMethodEntry
+                        obfFieldEntry
                 );
                 rootNode.load( m_deobfuscator.getJarIndex(), true );
                 return rootNode;
         }
         
+        public MethodCallsTreeNode getMethodCalls( Entry obfEntry )
+        {
+                MethodCallsTreeNode rootNode;
+                if( obfEntry instanceof MethodEntry )
+                {
+                        rootNode = new MethodCallsTreeNode(
+                                m_deobfuscator.getTranslator( TranslationDirection.Deobfuscating ),
+                                (MethodEntry)obfEntry
+                        );
+                }
+                else if( obfEntry instanceof ConstructorEntry )
+                {
+                        rootNode = new MethodCallsTreeNode(
+                                m_deobfuscator.getTranslator( TranslationDirection.Deobfuscating ),
+                                (ConstructorEntry)obfEntry
+                        );
+                }
+                else
+                {
+                        throw new IllegalArgumentException( "entry must be a MethodEntry or a ConstructorEntry!" );
+                }
+                rootNode.load( m_deobfuscator.getJarIndex(), true );
+                return rootNode;
+        }
+        
         public void rename( Entry obfEntry, String newName )
         {
                 m_deobfuscator.rename( obfEntry, newName );
diff --git a/src/cuchaz/enigma/mapping/ConstructorEntry.java b/src/cuchaz/enigma/mapping/ConstructorEntry.java
new file mode 100644
index 00000000..e0fa7cf6
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ConstructorEntry.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.mapping;
+
+import java.io.Serializable;
+
+import cuchaz.enigma.Util;
+
+public class ConstructorEntry implements Entry, Serializable
+{
+        private static final long serialVersionUID = -868346075317366758L;
+        
+        private ClassEntry m_classEntry;
+        private String m_signature;
+        
+        public ConstructorEntry( ClassEntry classEntry, String signature )
+        {
+                if( classEntry == null )
+                {
+                        throw new IllegalArgumentException( "Class cannot be null!" );
+                }
+                if( signature == null )
+                {
+                        throw new IllegalArgumentException( "Method signature cannot be null!" );
+                }
+                
+                m_classEntry = classEntry;
+                m_signature = signature;
+        }
+        
+        public ConstructorEntry( ConstructorEntry other )
+        {
+                m_classEntry = new ClassEntry( other.m_classEntry );
+                m_signature = other.m_signature;
+        }
+        
+        @Override
+        public ClassEntry getClassEntry( )
+        {
+                return m_classEntry;
+        }
+
+        @Override
+        public String getName( )
+        {
+                return m_classEntry.getName();
+        }
+        
+        public String getSignature( )
+        {
+                return m_signature;
+        }
+        
+        @Override
+        public String getClassName( )
+        {
+                return m_classEntry.getName();
+        }
+        
+        @Override
+        public int hashCode( )
+        {
+                return Util.combineHashesOrdered( m_classEntry, m_signature );
+        }
+        
+        @Override
+        public boolean equals( Object other )
+        {
+                if( other instanceof ConstructorEntry )
+                {
+                        return equals( (ConstructorEntry)other );
+                }
+                return false;
+        }
+        
+        public boolean equals( ConstructorEntry other )
+        {
+                return m_classEntry.equals( other.m_classEntry ) && m_signature.equals( other.m_signature );
+        }
+        
+        @Override
+        public String toString( )
+        {
+                return m_classEntry.getName() + m_signature;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
index 02565c94..50433214 100644
--- a/src/cuchaz/enigma/mapping/Translator.java
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -135,6 +135,14 @@ public class Translator
                 );
         }
         
+        public ConstructorEntry translateEntry( ConstructorEntry in )
+        {
+                return new ConstructorEntry(
+                        translateEntry( in.getClassEntry() ),
+                        translateSignature( in.getSignature() )
+                );
+        }
+        
         public String translate( ArgumentEntry in )
         {
                 for( String className : getSelfAndAncestors( in.getClassName() ) )