diff --git a/src/org/ntlab/traceDebugger/VariableLabelProvider.java b/src/org/ntlab/traceDebugger/VariableLabelProvider.java index b45d03c..8ab29fe 100644 --- a/src/org/ntlab/traceDebugger/VariableLabelProvider.java +++ b/src/org/ntlab/traceDebugger/VariableLabelProvider.java @@ -10,6 +10,8 @@ import org.eclipse.swt.widgets.Display; import org.eclipse.ui.ISharedImages; import org.eclipse.ui.PlatformUI; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; public class VariableLabelProvider extends LabelProvider implements ITableLabelProvider, ITableColorProvider { @@ -17,6 +19,18 @@ public String getColumnText(Object element, int columnIndex) { if (element instanceof TreeNode) { Object value = ((TreeNode)element).getValue(); + if (value instanceof String) { + String name = (String)value; + switch (columnIndex) { + case 0: + return name.substring(0, name.indexOf(":")); + case 1: + String valueName = name.substring(name.indexOf(":") + 1); + valueName = valueName.substring(valueName.lastIndexOf(" ") + 1); + boolean isConstructor = name.contains("Constructor"); + return getReadableName(valueName, isConstructor); + } + } if (value instanceof Variable) { Variable variableData = (Variable)value; String variableName = variableData.getVariableName(); @@ -85,4 +99,38 @@ } return null; } + + private String getReadableName(String name, boolean isConstrutor) { + if (!(name.contains("("))) { + String[] splits = name.split("\\."); + if (splits.length < 2) return name; + return splits[splits.length - 2] + "." + splits[splits.length - 1]; + } + StringBuilder sb = new StringBuilder(); + String receiverTypeAndMethodName = name.substring(0, name.indexOf("(")); + String[] receiverTypeAndMethodNameSplits = receiverTypeAndMethodName.split("\\."); + if (receiverTypeAndMethodNameSplits.length < 2) { + sb.append(receiverTypeAndMethodName); + } else { + if (!isConstrutor) { + sb.append(receiverTypeAndMethodNameSplits[receiverTypeAndMethodNameSplits.length - 2]); + sb.append("."); + } + sb.append(receiverTypeAndMethodNameSplits[receiverTypeAndMethodNameSplits.length - 1]); + } + sb.append("("); + String argsName = name.substring(name.indexOf("(") + 1, name.lastIndexOf(")")); + String delimiter = ""; + for (String argName : argsName.split(",")) { + String[] argNameSplits = argName.split("\\."); + if (argNameSplits.length < 1) { + sb.append(delimiter + argName); + } else { + sb.append(delimiter + argNameSplits[argNameSplits.length - 1]); + } + delimiter = ","; + } + sb.append(")"); + return sb.toString(); + } } diff --git a/src/org/ntlab/traceDebugger/VariableView.java b/src/org/ntlab/traceDebugger/VariableView.java index 3fe5b62..7c22827 100644 --- a/src/org/ntlab/traceDebugger/VariableView.java +++ b/src/org/ntlab/traceDebugger/VariableView.java @@ -201,11 +201,15 @@ VariableType variableType = selectedVariable.getVariableType(); if (variableType.equals(VariableType.USE_VALUE)) { manager.add(jumpAction); + jumpAction.setText("Jump to Definition"); + jumpAction.setToolTipText("Jump to Definition"); } else if (variableType.equals(VariableType.USE_RETURN)) { manager.add(jumpAction); if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { manager.add(deltaActionForThisToAnother); - } + } + jumpAction.setText("Jump to Addition"); + jumpAction.setToolTipText("Jump to Addition"); } else if (variableType.isDef()) { if (updateDeltaActionForContainerToComponentTexts(selectedVariable)) { manager.add(deltaActionForContainerToComponent); diff --git a/src/org/ntlab/traceDebugger/Variables.java b/src/org/ntlab/traceDebugger/Variables.java index c290f45..88e8b3e 100644 --- a/src/org/ntlab/traceDebugger/Variables.java +++ b/src/org/ntlab/traceDebugger/Variables.java @@ -207,7 +207,11 @@ } private void createSpecialVariables(TracePoint from, TracePoint to, boolean isReturned) { - List list = new ArrayList<>(); +// List list = new ArrayList<>(); + List specialVariablesOfUseSide = new ArrayList<>(); + List specialVariablesDefSide = new ArrayList<>(); + String parentNodeNameOfUseSide = null; + String parentNodeNameOfDefSide = null; if (from != null) { // ���s�����use�v�f Statement fromStatement = from.getStatement(); @@ -219,8 +223,9 @@ String valueObjId = fa.getValueObjId(); Variable container = new Variable(Variable.CONTAINER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_CONTAINER); Variable value = new Variable(Variable.VALUE_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_VALUE); - list.add(value); - list.add(container); + specialVariablesOfUseSide.add(container); + specialVariablesOfUseSide.add(value); + parentNodeNameOfUseSide = "PreviousFieldAccess:" + fa.getFieldName(); } else if (fromStatement instanceof MethodInvocation) { MethodInvocation mi = (MethodInvocation)fromStatement; MethodExecution calledME = mi.getCalledMethodExecution(); @@ -232,8 +237,13 @@ String valueObjId = returnValue.getId(); Variable receiver = new Variable(Variable.RECEIVER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_RECEIVER); Variable returned = new Variable(Variable.RETURN_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_RETURN); - list.add(returned); - list.add(receiver); + specialVariablesOfUseSide.add(receiver); + specialVariablesOfUseSide.add(returned); + if (calledME.isConstructor()) { + parentNodeNameOfUseSide = "ReturnConstructor:" + calledME.getSignature(); + } else { + parentNodeNameOfUseSide = "ReturnMethod:" + calledME.getSignature(); + } } } } @@ -249,8 +259,9 @@ String valueObjId = fu.getValueObjId(); Variable container = new Variable(Variable.CONTAINER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_CONTAINER); Variable value = new Variable(Variable.VALUE_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_VALUE); - list.add(value); - list.add(container); + specialVariablesDefSide.add(container); + specialVariablesDefSide.add(value); + parentNodeNameOfDefSide = "NextUpdate:" + fu.getFieldName(); } else if (toStatement instanceof MethodInvocation) { MethodInvocation mi = (MethodInvocation)toStatement; MethodExecution calledME = mi.getCalledMethodExecution(); @@ -263,23 +274,60 @@ String valueObjId = argObj.getId(); Variable receiver = new Variable(Variable.RECEIVER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_RECEIVER); Variable arg = new Variable(Variable.ARG_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_ARG); - list.add(arg); - list.add(receiver); + specialVariablesDefSide.add(receiver); + specialVariablesDefSide.add(arg); + if (calledME.isConstructor()) { + parentNodeNameOfDefSide = "NextConstructor:" + calledME.getSignature(); + } else { + parentNodeNameOfDefSide = "NextMethod:" + calledME.getSignature(); + } } - } + } } - - for (Variable variable : list) { + if (parentNodeNameOfUseSide != null) { + setSpecialVariableNodes(parentNodeNameOfUseSide, specialVariablesOfUseSide); + } + if (parentNodeNameOfDefSide != null) { + setSpecialVariableNodes(parentNodeNameOfDefSide, specialVariablesDefSide); + } + +// for (Variable variable : list) { +// variable.createNextHierarchyState(); +// roots.add(0, variable); +// MyTreeNode variableNode = new MyTreeNode(variable); +//// rootTreeNodes.add(0, variableNode); +// List childList = new ArrayList<>(); +// variableNode.setChildList(childList); +// for (int i = 0; i < variable.getChildren().size(); i++) { +// Variable childVariable = variable.getChildren().get(i); +// createVariablesTreeNodeList(variableNode, childList, i, childVariable); +// } +// } + } + + private void setSpecialVariableNodes(String parentNodeName, List specialVariables) { + MyTreeNode parentNode = new MyTreeNode(parentNodeName); + rootTreeNodes.add(0, parentNode); + MyTreeNode[] children = new MyTreeNode[specialVariables.size()]; + for (int i = 0; i < specialVariables.size(); i++) { + Variable variable = specialVariables.get(i); variable.createNextHierarchyState(); roots.add(0, variable); MyTreeNode variableNode = new MyTreeNode(variable); - rootTreeNodes.add(0, variableNode); - List childList = new ArrayList<>(); - variableNode.setChildList(childList); - for (int i = 0; i < variable.getChildren().size(); i++) { - Variable childVariable = variable.getChildren().get(i); - createVariablesTreeNodeList(variableNode, childList, i, childVariable); - } + children[i] = variableNode; + variableNode.setParent(parentNode); + createChildNodesOfSpecialVariableNode(variableNode); + } + parentNode.setChildren(children); + } + + private void createChildNodesOfSpecialVariableNode(MyTreeNode variableNode) { + List childList = new ArrayList<>(); + variableNode.setChildList(childList); + Variable variable = (Variable)variableNode.getValue(); + for (int i = 0; i < variable.getChildren().size(); i++) { + Variable childVariable = variable.getChildren().get(i); + createVariablesTreeNodeList(variableNode, childList, i, childVariable); } } @@ -290,7 +338,7 @@ } private void resetSpecialValues() { - for (int i = roots.size() - 1; i >=0; i--) { + for (int i = roots.size() - 1; i >= 0; i--) { Variable root = roots.get(i); String variableName = root.getVariableName(); if (variableName.equals(Variable.CONTAINER_VARIABLE_NAME) @@ -299,6 +347,11 @@ || variableName.equals(Variable.ARG_VARIABLE_NAME) || variableName.equals(Variable.RETURN_VARIABLE_NAME)) { roots.remove(i); + } + } + for (int i = rootTreeNodes.size() - 1; i >= 0; i--) { + MyTreeNode node = rootTreeNodes.get(i); + if (node.getValue() instanceof String) { rootTreeNodes.remove(i); } }