diff --git a/src/org/ntlab/traceDebugger/Variable.java b/src/org/ntlab/traceDebugger/Variable.java index 664e21c..99aa106 100644 --- a/src/org/ntlab/traceDebugger/Variable.java +++ b/src/org/ntlab/traceDebugger/Variable.java @@ -20,6 +20,7 @@ public class Variable { private String variableName; + private VariableType variableType; private String fullyQualifiedVariableName; private String valueClassName; private String valueId; @@ -34,24 +35,47 @@ private boolean alreadyCreatedChildHierarchy = false; private boolean alreadyCreatedGrandChildHierarchy = false; private Map additionalAttributes = new HashMap<>(); + public static final String RETURN_VARIABLE_NAME = "return"; + public static final String ARG_VARIABLE_NAME = "arg"; + public static final String RECEIVER_VARIABLE_NAME = "receiver"; + public static final String VALUE_VARIABLE_NAME = "value"; + public static final String CONTAINER_VARIABLE_NAME = "container"; + + public enum VariableType { + USE_VALUE, USE_CONTAINER, USE_RECEIVER, USE_RETURN, + DEF_VALUE, DEF_CONTAINER, DEF_RECEIVER, DEF_ARG, + PARAMETER; + public boolean isContainerSide() { + return this.equals(USE_CONTAINER) || this.equals(DEF_CONTAINER) + || this.equals(USE_RECEIVER) || this.equals(DEF_RECEIVER); + } + public boolean isDef() { + return this.equals(DEF_CONTAINER) || this.equals(DEF_VALUE) + || this.equals(DEF_RECEIVER) || this.equals(DEF_ARG); + } + public boolean isUse() { + return this.equals(USE_CONTAINER) || this.equals(USE_VALUE) + || this.equals(USE_RECEIVER) || this.equals(USE_RETURN); + } + } public Variable(String variableName, String containerClassName, String containerId, String valueClassName, String valueId, TracePoint before, boolean isReturned) { - this(variableName, containerClassName, containerId, valueClassName, valueId, null, before, isReturned); + this(variableName, containerClassName, containerId, valueClassName, valueId, before, isReturned, VariableType.USE_VALUE); } public Variable(String variableName, String containerClassName, String containerId, - String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned) { - init(variableName, variableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, before, isReturned); + String valueClassName, String valueId, TracePoint before, boolean isReturned, VariableType variableType) { + init(variableName, variableName, containerClassName, containerId, valueClassName, valueId, null, before, isReturned, variableType); } public Variable(String variableName, String fullyQualifiedVariableName, String containerClassName, String containerId, - String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned) { - init(variableName, fullyQualifiedVariableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, before, isReturned); + String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned, VariableType variableType) { + init(variableName, fullyQualifiedVariableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, before, isReturned, variableType); } private void init(String variableName, String fullyQualifiedVariableName, String containerClassName, String containerId, - String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned) { + String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned, VariableType variableType) { this.variableName = variableName; this.fullyQualifiedVariableName = fullyQualifiedVariableName; this.containerClassName = containerClassName; @@ -66,16 +90,21 @@ this.alreadyCreatedGrandChildHierarchy = false; this.children.clear(); this.additionalAttributes.clear(); + this.variableType = variableType; } public void update(String valueClassName, String valueId, TracePoint lastUpdatePoint, boolean isReturned) { - init(variableName, fullyQualifiedVariableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, lastUpdatePoint, isReturned); + init(variableName, fullyQualifiedVariableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, lastUpdatePoint, isReturned, variableType); } public String getVariableName() { return variableName; } + public VariableType getVariableType() { + return variableType; + } + public String getFullyQualifiedVariableName() { return fullyQualifiedVariableName; } @@ -196,7 +225,12 @@ private void getFieldsState() { // �t�B�[���h��ID��Type���擾���ĕ\�� - IType type = JavaElementFinder.findIType(null, valueClassName); + IType type = null; + if (variableType.isContainerSide()) { + type = JavaElementFinder.findIType(null, containerClassName); + } else { + type = JavaElementFinder.findIType(null, valueClassName); + } if (type == null) return; getFieldsState(type); getFieldStateForSuperClass(type); // �e�N���X��k���Ă����A�����̃N���X�Œ�`���ꂽ�t�B�[���h�̏����擾���Ă��� (�������������������Ĕ��ɏd���Ȃ�) @@ -243,10 +277,10 @@ // �t�B�[���h��ID��Type���擾(String) String fieldObjId = (fieldUpdate != null) ? fieldUpdate.getValueObjId() : "0"; String fieldType = (fieldUpdate != null) ? fieldUpdate.getValueClassName() : "---"; - Variable fieldData = new Variable(fieldName, fullyQualifiedFieldName, valueClassName, valueId, fieldType, fieldObjId, updateTracePoint, before, isReturned); + Variable fieldData = new Variable(fieldName, fullyQualifiedFieldName, valueClassName, valueId, fieldType, fieldObjId, updateTracePoint, before, isReturned, VariableType.USE_VALUE); this.addChild(fieldData); } else { - Variable fieldData = new Variable(fieldName, fullyQualifiedFieldName, valueClassName, valueId, "?", "???", updateTracePoint, before, isReturned); + Variable fieldData = new Variable(fieldName, fullyQualifiedFieldName, valueClassName, valueId, "?", "???", updateTracePoint, before, isReturned, VariableType.USE_VALUE); this.addChild(fieldData); } } diff --git a/src/org/ntlab/traceDebugger/VariableLabelProvider.java b/src/org/ntlab/traceDebugger/VariableLabelProvider.java index 2e65e31..8706392 100644 --- a/src/org/ntlab/traceDebugger/VariableLabelProvider.java +++ b/src/org/ntlab/traceDebugger/VariableLabelProvider.java @@ -19,9 +19,9 @@ Object value = ((TreeNode)element).getValue(); if (value instanceof Variable) { Variable variableData = (Variable)value; + String variableName = variableData.getVariableName(); switch (columnIndex) { case 0: - String variableName = variableData.getVariableName(); if (variableName.contains("[")) { return variableName.substring(variableName.lastIndexOf("[")); } else if (variableName.contains(".")) { @@ -29,11 +29,18 @@ } return variableName; case 1: - String simpleName = variableData.getValueClassName(); + String simpleName; + String id; + if (variableData.getVariableType().isContainerSide()) { + simpleName = variableData.getContainerClassName(); + id = variableData.getContainerId(); + } else { + simpleName = variableData.getValueClassName(); + id = variableData.getValueId(); + } simpleName = simpleName.substring(simpleName.lastIndexOf(".") + 1); -// return variableData.getClassName() + " (" + "id = " + variableData.getId() + ")"; - return simpleName + " (" + "id = " + variableData.getValueId() + ")"; - } + return simpleName + " (" + "id = " + id + ")"; + } } } return "�e�X�g�p�e�L�X�g" + columnIndex; diff --git a/src/org/ntlab/traceDebugger/VariableView.java b/src/org/ntlab/traceDebugger/VariableView.java index 62ad5c9..ac9683b 100644 --- a/src/org/ntlab/traceDebugger/VariableView.java +++ b/src/org/ntlab/traceDebugger/VariableView.java @@ -35,14 +35,16 @@ import org.eclipse.ui.part.ViewPart; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.Variable.VariableType; import org.ntlab.traceDebugger.analyzerProvider.Alias; import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; +import org.ntlab.traceDebugger.analyzerProvider.VariableUpdatePointFinder; public class VariableView extends ViewPart { private TreeViewer viewer; private IAction jumpAction; - private IAction deltaAction; - private IAction deltaActionForCollection; +// private IAction deltaAction; +// private IAction deltaActionForCollection; private IAction deltaActionForContainerToComponent; private IAction deltaActionForThisToAnother; private Variable selectedVariable; @@ -133,25 +135,35 @@ private void createActions() { jumpAction = new Action() { public void run() { - TracePoint tp = selectedVariable.getLastUpdatePoint(); + TracePoint tp = null; + TracePoint before = DebuggingController.getInstance().getCurrentTp(); + VariableType variableType = selectedVariable.getVariableType(); + if (variableType.equals(VariableType.USE_VALUE)) { + String containerId = selectedVariable.getContainerId(); + String fieldName = selectedVariable.getFullyQualifiedVariableName(); + tp = VariableUpdatePointFinder.getInstance().getPoint(containerId, fieldName, before); + } else if (variableType.equals(VariableType.USE_RETURN)) { + String receiverId = selectedVariable.getContainerId(); + String valueId = selectedVariable.getValueId(); + tp = VariableUpdatePointFinder.getInstance().getDefinitionInvocationPoint(receiverId, valueId, before); + } if (tp == null) return; DebuggingController controller = DebuggingController.getInstance(); controller.jumpToTheTracePoint(tp, false); - controller.stepOverAction(); } }; - jumpAction.setText("Jump to Related Point"); - jumpAction.setToolTipText("Jump to Related Point"); + jumpAction.setText("Jump to Definition"); + jumpAction.setToolTipText("Jump to Definition"); - deltaAction = new Action() { - @Override - public void run() { - DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); - newDeltaMarkerView.extractDelta(selectedVariable, true); - } - }; - deltaAction.setText("Extract Delta"); - deltaAction.setToolTipText("Extract Delta"); +// deltaAction = new Action() { +// @Override +// public void run() { +// DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); +// newDeltaMarkerView.extractDelta(selectedVariable, true); +// } +// }; +// deltaAction.setText("Extract Delta"); +// deltaAction.setToolTipText("Extract Delta"); deltaActionForContainerToComponent = new Action() { @Override @@ -173,27 +185,27 @@ deltaActionForThisToAnother.setText("Extract Delta"); deltaActionForThisToAnother.setToolTipText("Extract Delta"); - deltaActionForCollection = new Action() { - @Override - public void run() { -// InputDialog inputContainerIdDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer id", "87478208", null); - InputDialog inputContainerIdDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer id", "155140910", null); - if (inputContainerIdDialog.open() != InputDialog.OK) return; - String containerId = inputContainerIdDialog.getValue(); -// InputDialog inputContainerTypeDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer type", "java.util.LinkedHashSet", null); - InputDialog inputContainerTypeDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer type", "java.util.ArrayList", null); - if (inputContainerTypeDialog.open() != InputDialog.OK) return; - String containerType = inputContainerTypeDialog.getValue(); - String valueId = selectedVariable.getValueId(); - String valueType = selectedVariable.getValueClassName(); - TracePoint tp = DebuggingController.getInstance().getCurrentTp(); - Variable variable = new Variable("tmp", containerType, containerId, valueType, valueId, tp, false); - DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); - newDeltaMarkerView.extractDelta(variable, true); - } - }; - deltaActionForCollection.setText("Extract Delta for Collection"); - deltaActionForCollection.setToolTipText("Extract Delta for Collection"); +// deltaActionForCollection = new Action() { +// @Override +// public void run() { +//// InputDialog inputContainerIdDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer id", "87478208", null); +// InputDialog inputContainerIdDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer id", "155140910", null); +// if (inputContainerIdDialog.open() != InputDialog.OK) return; +// String containerId = inputContainerIdDialog.getValue(); +//// InputDialog inputContainerTypeDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer type", "java.util.LinkedHashSet", null); +// InputDialog inputContainerTypeDialog = new InputDialog(null, "Extract Delta for Collection", "Input cotainer type", "java.util.ArrayList", null); +// if (inputContainerTypeDialog.open() != InputDialog.OK) return; +// String containerType = inputContainerTypeDialog.getValue(); +// String valueId = selectedVariable.getValueId(); +// String valueType = selectedVariable.getValueClassName(); +// TracePoint tp = DebuggingController.getInstance().getCurrentTp(); +// Variable variable = new Variable("tmp", containerType, containerId, valueType, valueId, tp, false); +// DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); +// newDeltaMarkerView.extractDelta(variable, true); +// } +// }; +// deltaActionForCollection.setText("Extract Delta for Collection"); +// deltaActionForCollection.setToolTipText("Extract Delta for Collection"); } private void createToolBar() { @@ -211,17 +223,30 @@ @Override public void menuAboutToShow(IMenuManager manager) { // �E�N���b�N����x�ɌĂяo����� - manager.add(jumpAction); - updateDeltaActionsTexts(selectedVariable); - if (selectedVariable.getVariableName().equals(Variables.RETURN_VARIABLE_NAME)) { - manager.add(deltaActionForContainerToComponent); - manager.add(deltaActionForThisToAnother); - manager.add(deltaActionForCollection); - } else { - manager.add(deltaAction); - manager.add(deltaActionForCollection); + VariableType variableType = selectedVariable.getVariableType(); + if (variableType.equals(VariableType.USE_VALUE)) { + manager.add(jumpAction); + } else if (variableType.equals(VariableType.USE_RETURN)) { + manager.add(jumpAction); + if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { + manager.add(deltaActionForThisToAnother); + } + } else if (variableType.isDef()) { + if (updateDeltaActionForContainerToComponentTexts(selectedVariable)) { + manager.add(deltaActionForContainerToComponent); + } + if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { + String text1 = deltaActionForThisToAnother.getText(); + String text2 = deltaActionForContainerToComponent.getText(); + if (!(text1.equals(text2))) { + manager.add(deltaActionForThisToAnother); + } + } + } else if (variableType.equals(VariableType.PARAMETER)) { + if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { + manager.add(deltaActionForThisToAnother); + } } -// manager.add(deltaActionForCollection); manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); } }); @@ -235,12 +260,11 @@ viewer.setInput(variables.getVariablesTreeNodesList()); viewer.refresh(); } - - private void updateDeltaActionsTexts(Variable variable) { + + private boolean updateDeltaActionForContainerToComponentTexts(Variable variable) { String valueId = selectedVariable.getValueId(); String valueClassName = selectedVariable.getValueClassName(); valueClassName = valueClassName.substring(valueClassName.lastIndexOf(".") + 1); - String containerId = selectedVariable.getContainerId(); String containerClassName = selectedVariable.getContainerClassName(); if (containerId != null && containerClassName != null) { @@ -248,13 +272,18 @@ String textForContainerToComponent = String.format("Extract Delta (%s: %s �� %s: %s)", containerId, containerClassName, valueId, valueClassName); deltaActionForContainerToComponent.setText(textForContainerToComponent); deltaActionForContainerToComponent.setToolTipText(textForContainerToComponent); - deltaAction.setText(textForContainerToComponent); - deltaAction.setToolTipText(textForContainerToComponent); + return true; } else { - deltaAction.setText("Extract Delta"); - deltaAction.setToolTipText("Extract Delta"); + deltaActionForContainerToComponent.setText(""); + deltaActionForContainerToComponent.setToolTipText(""); + return false; } - + } + + private boolean updateDeltaActionForThisToAnotherTexts(Variable variable) { + String valueId = selectedVariable.getValueId(); + String valueClassName = selectedVariable.getValueClassName(); + valueClassName = valueClassName.substring(valueClassName.lastIndexOf(".") + 1); TracePoint before = selectedVariable.getBeforeTracePoint(); String thisId = before.getMethodExecution().getThisObjId(); String thisClassName = before.getMethodExecution().getThisClassName(); @@ -262,9 +291,14 @@ thisClassName = thisClassName.substring(thisClassName.lastIndexOf(".") + 1); String textForThisToAnother = String.format("Extract Delta (%s: %s �� %s: %s)", thisId, thisClassName, valueId, valueClassName); deltaActionForThisToAnother.setText(textForThisToAnother); - deltaActionForThisToAnother.setToolTipText(textForThisToAnother); + deltaActionForThisToAnother.setToolTipText(textForThisToAnother); + return true; + } else { + deltaActionForThisToAnother.setText(""); + deltaActionForThisToAnother.setToolTipText(""); + return false; } - } + } public void updateVariablesByTracePoint(TracePoint tp, boolean isReturned) { updateVariablesByTracePoint(null, tp, isReturned); @@ -276,7 +310,7 @@ } public void updateVariablesForDifferential(TracePoint from, TracePoint to, boolean isReturned) { - variables.updateForDifferentialAndReturnValue(from, to, isReturned); + variables.updateForDifferential(from, to, isReturned); // viewer.setInput(variables.getVariablesTreeNodes()); viewer.refresh(); } diff --git a/src/org/ntlab/traceDebugger/Variables.java b/src/org/ntlab/traceDebugger/Variables.java index 7c254fe..cfea586 100644 --- a/src/org/ntlab/traceDebugger/Variables.java +++ b/src/org/ntlab/traceDebugger/Variables.java @@ -10,35 +10,27 @@ import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.JavaModelException; import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayUpdate; +import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldAccess; import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldUpdate; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodInvocation; import org.ntlab.traceAnalysisPlatform.tracer.trace.ObjectReference; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; - -import com.sun.org.apache.regexp.internal.RE; +import org.ntlab.traceDebugger.Variable.VariableType; public class Variables { private static final Variables theInstance = new Variables(); private List roots = new ArrayList<>(); private List rootTreeNodes = new ArrayList<>(); private Map> containerIdToDifferentialUpdateTracePoints = new HashMap<>(); // �ϐ������X�V�ӏ����L�� - public static final String RETURN_VARIABLE_NAME = "return"; - + public static final String VARIABLE_TYPE_KEY = "variableType"; + public static Variables getInstance() { return theInstance; } public List getVariablesTreeNodesList() { - rootTreeNodes.clear(); - if (roots.isEmpty()) { - return rootTreeNodes; - } - for (int i = 0; i < roots.size(); i++) { - Variable rootVariableData = roots.get(i); - createVariablesTreeNodeList(null, rootTreeNodes, i, rootVariableData); - } return rootTreeNodes; } @@ -68,48 +60,14 @@ private void updateAllObjectData(TracePoint from, TracePoint to, boolean isReturned) { resetData(); - if (from != null) { - Variable returnVariable = updateReturnValue(from, to, isReturned); - roots.add(0, returnVariable); - } MethodExecution me = to.getMethodExecution(); updateRootThisState(me, to, isReturned); - updateArgsState(me, to, isReturned); - } - - private Variable updateReturnValue(TracePoint from, TracePoint to, boolean isReturned) { - Statement statement = from.getStatement(); - ObjectReference ref = null; - MethodExecution me = null; - if (statement instanceof MethodInvocation) { - MethodInvocation mi = (MethodInvocation)statement; - me = mi.getCalledMethodExecution(); - ref = mi.getCalledMethodExecution().getReturnValue(); - } else if (isReturned) { - me = from.getMethodExecution(); - ref = me.getReturnValue(); + updateArgsState(me, to, isReturned); + for (int i = 0; i < roots.size(); i++) { + Variable rootVariableData = roots.get(i); + createVariablesTreeNodeList(null, rootTreeNodes, i, rootVariableData); } - if (ref != null) { - String returnValueClassName = ref.getActualType(); - if (returnValueClassName.equals("void")) return null; - String returnValueId = ref.getId(); - String thisObjId = me.getThisObjId(); - String thisClassName = me.getThisClassName(); - Variable variable = new Variable(RETURN_VARIABLE_NAME, thisClassName, thisObjId, returnValueClassName, returnValueId, from, isReturned); - variable.createNextHierarchyState(); -// if (roots.size() > 0) { -// Variable old = roots.get(0); -// if (old.getVariableName().equals(RETURN_VARIABLE_NAME)) { -// roots.set(0, variable); -// } else { -// roots.add(0, variable); -// } -// } else { -// roots.add(0, variable); -// } - return variable; - } - return null; + createSpecialVariables(from, to, isReturned); } private void updateRootThisState(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { @@ -133,7 +91,7 @@ ObjectReference arg = args.get(i); String argId = arg.getId(); String argType = arg.getActualType(); - Variable argData = new Variable(argName, null, null, argType, argId, tp, isReturned); + Variable argData = new Variable(argName, null, null, argType, argId, tp, isReturned, VariableType.PARAMETER); argData.createNextHierarchyState(); roots.add(argData); } @@ -188,75 +146,20 @@ } tracePoints.add(tp.duplicate()); } + + public void updateForDifferential(TracePoint from, TracePoint to, boolean isReturned) { + updateForDifferential(); + resetSpecialValues(); + createSpecialVariables(from, to, isReturned); + } - public void updateForDifferential() { + private void updateForDifferential() { for (Variable variable : roots) { updateForDifferential(variable); } containerIdToDifferentialUpdateTracePoints.clear(); } - -// public void updateForDifferentialAndReturnValue(TracePoint from, TracePoint to, boolean isReturned) { -// updateForDifferential(); -// updateReturnValue(from, to, isReturned); -// Variable variable = roots.get(0); -// if (variable.getVariableName().equals(RETURN_VARIABLE_NAME)) { -// MyTreeNode node = new MyTreeNode(variable); -// Object top = rootTreeNodes.get(0).getValue(); -// if (top instanceof Variable && ((Variable)top).getVariableName().equals(RETURN_VARIABLE_NAME)) { -// rootTreeNodes.set(0, node); -// } else { -// rootTreeNodes.add(0, node); -// } -// List childList = new ArrayList<>(); -// node.setChildList(childList); -// for (int i = 0; i < variable.getChildren().size(); i++) { -// Variable childVariable = variable.getChildren().get(i); -// createVariablesTreeNodeList(node, childList, i, childVariable); -// } -// } -// } - - public void updateForDifferentialAndReturnValue(TracePoint from, TracePoint to, boolean isReturned) { - updateForDifferential(); - Variable newReturnValue = updateReturnValue(from, to, isReturned); - if (newReturnValue != null) { - int fromLineNo = from.getStatement().getLineNo(); - int toLineNo = to.getStatement().getLineNo(); - MethodExecution fromME = from.getMethodExecution(); - MethodExecution toME = to.getMethodExecution(); -// boolean isStepToNewLine = (fromLineNo != toLineNo) || (!(fromME.equals(toME))); - boolean isStepToNewLine = (!(fromME.equals(toME))); - setNewReturnVariableOnRoots(newReturnValue, isStepToNewLine); - } - } - private void setNewReturnVariableOnRoots(Variable newVariable, boolean isStepToNewLine) { - MyTreeNode newVariableNode = new MyTreeNode(newVariable); - if (roots.size() > 0) { - Variable old = roots.get(0); - if (old.getVariableName().equals(RETURN_VARIABLE_NAME)) { - if (isStepToNewLine) { - for (int i = roots.size() - 1; i >= 0; i--) { - Variable root = roots.get(i); - if ((root.getVariableName().equals(RETURN_VARIABLE_NAME))) { - roots.remove(i); - rootTreeNodes.remove(i); - } - } - } - } - } - roots.add(0, newVariable); - rootTreeNodes.add(0, newVariableNode); - List childList = new ArrayList<>(); - newVariableNode.setChildList(childList); - for (int i = 0; i < newVariable.getChildren().size(); i++) { - Variable childVariable = newVariable.getChildren().get(i); - createVariablesTreeNodeList(newVariableNode, childList, i, childVariable); - } - } - private void updateForDifferential(Variable variable) { Set containerIdList = containerIdToDifferentialUpdateTracePoints.keySet(); String containerId = variable.getContainerId(); @@ -294,12 +197,104 @@ } } + private void createSpecialVariables(TracePoint from, TracePoint to, boolean isReturned) { + List list = new ArrayList<>(); + if (from != null) { + // ���s�����use�v�f + Statement fromStatement = from.getStatement(); + if (fromStatement instanceof FieldAccess) { + FieldAccess fa = (FieldAccess)fromStatement; + String containerClassName = fa.getContainerClassName(); + String containerObjId = fa.getContainerObjId(); + String valueClassName = fa.getValueClassName(); + 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); + } else if (fromStatement instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation)fromStatement; + MethodExecution calledME = mi.getCalledMethodExecution(); + ObjectReference returnValue = calledME.getReturnValue(); + if (returnValue != null) { + String containerClassName = calledME.getThisClassName(); + String containerObjId = calledME.getThisObjId(); + String valueClassName = returnValue.getActualType(); + 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); + } + } + } + + if (to != null) { + // ���s���O��def�v�f + Statement toStatement = to.getStatement(); + if (toStatement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)toStatement; + String containerClassName = fu.getContainerClassName(); + String containerObjId = fu.getContainerObjId(); + String valueClassName = fu.getValueClassName(); + 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); + } else if (toStatement instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation)toStatement; + MethodExecution calledME = mi.getCalledMethodExecution(); + List args = calledME.getArguments(); + if (args.size() == 1) { + ObjectReference argObj = args.get(0); + String containerClassName = calledME.getThisClassName(); + String containerObjId = calledME.getThisObjId(); + String valueClassName = argObj.getActualType(); + 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); + } + } + } + + 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); + } + } + } + public void resetData() { roots.clear(); rootTreeNodes.clear(); containerIdToDifferentialUpdateTracePoints.clear(); } + private void resetSpecialValues() { + 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) + || variableName.equals(Variable.VALUE_VARIABLE_NAME) + || variableName.equals(Variable.RECEIVER_VARIABLE_NAME) + || variableName.equals(Variable.ARG_VARIABLE_NAME) + || variableName.equals(Variable.RETURN_VARIABLE_NAME)) { + roots.remove(i); + rootTreeNodes.remove(i); + } + } + } + private MyTreeNode getTreeNodeFor(Variable variable, List nodes) { for (MyTreeNode node : nodes) { if (node.getValue().equals(variable)) return node; diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java index 2331de1..231abcb 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java @@ -44,7 +44,9 @@ String srcClassName = variable.getContainerClassName(); String dstId = variable.getValueId(); String dstClassName = variable.getValueClassName(); - TracePoint before = variable.getBeforeTracePoint(); + TracePoint before = variable.getBeforeTracePoint(); + before = before.duplicate(); + before.stepNext(); Reference reference = new Reference(srcId, dstId, srcClassName, dstClassName); reference.setCollection(srcClassName.startsWith("java.util.")); // true�ɂ���ƃR���N�V�����ȊO���o�ł��Ȃ��Ȃ� diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java b/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java index 66f7131..8f558ce 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java @@ -9,6 +9,8 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldUpdate; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodInvocation; +import org.ntlab.traceAnalysisPlatform.tracer.trace.ObjectReference; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; import org.ntlab.traceAnalysisPlatform.tracer.trace.ThreadInstance; import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; @@ -18,6 +20,7 @@ private static VariableUpdatePointFinder theInstance = new VariableUpdatePointFinder(); private Trace trace; private Map>> updatePoints = new HashMap<>(); + private Map>> definitionInvocationPoints = new HashMap<>(); public void setTrace(Trace trace) { this.trace = trace; @@ -29,13 +32,16 @@ } private void init() { - registerVariableUpdatePoints(); + registerUpdatePoints(); System.out.println(updatePoints); - sort(); + System.out.println(definitionInvocationPoints); + sort(updatePoints); + sort(definitionInvocationPoints); System.out.println(updatePoints); + System.out.println(definitionInvocationPoints); } - private void registerVariableUpdatePoints() { + private void registerUpdatePoints() { for (Map.Entry entry : trace.getAllThreads().entrySet()) { ThreadInstance thread = entry.getValue(); for (MethodExecution me : thread.getRoot()) { @@ -43,28 +49,50 @@ while (start.stepFull()) { Statement statement = start.getStatement(); if (statement instanceof FieldUpdate) { - FieldUpdate fu = (FieldUpdate)statement; - String objectId = fu.getContainerObjId(); - String fieldName = fu.getFieldName(); - Map> innerMap = updatePoints.get(objectId); - if (innerMap == null) { - innerMap = new HashMap<>(); - updatePoints.put(objectId, innerMap); - } - List tracePoints = innerMap.get(fieldName); - if (tracePoints == null) { - tracePoints = new ArrayList<>(); - innerMap.put(fieldName, tracePoints); - } - tracePoints.add(start.duplicate()); + registerFieldUpdatePoints(start, (FieldUpdate)statement); + } else if (statement instanceof MethodInvocation) { + registerdefinitionInvocationPoints(start, (MethodInvocation)statement); } } } } } - private void sort() { - for (Map> innerMap : updatePoints.values()) { + private void registerFieldUpdatePoints(TracePoint tp, FieldUpdate fu) { + String objectId = fu.getContainerObjId(); + String fieldName = fu.getFieldName(); + register(updatePoints, objectId, fieldName, tp); + } + + private void registerdefinitionInvocationPoints(TracePoint tp, MethodInvocation mi) { + MethodExecution calledME = mi.getCalledMethodExecution(); + String methodName = calledME.getSignature(); + List args = calledME.getArguments(); + if (methodName.contains(".add(") || methodName.contains(".addElement(")) { + if (args.size() == 1) { + String receiverId = calledME.getThisObjId(); + String argId = args.get(0).getId(); + register(definitionInvocationPoints, receiverId, argId, tp); + } + } + } + + private void register(Map>> map, String key1, String key2, TracePoint tp) { + Map> innerMap = map.get(key1); + if (innerMap == null) { + innerMap = new HashMap<>(); + map.put(key1, innerMap); + } + List tracePoints = innerMap.get(key2); + if (tracePoints == null) { + tracePoints = new ArrayList<>(); + innerMap.put(key2, tracePoints); + } + tracePoints.add(tp.duplicate()); + } + + private void sort(Map>> map) { + for (Map> innerMap : map.values()) { for (List tracePoints : innerMap.values()) { Collections.sort(tracePoints, new Comparator() { @Override @@ -77,11 +105,19 @@ } } } - + public TracePoint getPoint(String objectId, String fieldName, TracePoint before) { - Map> innerMap = updatePoints.get(objectId); + return getPoint(updatePoints, objectId, fieldName, before); + } + + public TracePoint getDefinitionInvocationPoint(String receiverId, String argId, TracePoint before) { + return getPoint(definitionInvocationPoints, receiverId, argId, before); + } + + private TracePoint getPoint(Map>> map, String key1, String key2, TracePoint before) { + Map> innerMap = map.get(key1); if (innerMap == null) return null; - List tracePoints = innerMap.get(fieldName); + List tracePoints = innerMap.get(key2); if (tracePoints == null) return null; long beforeTime = before.getStatement().getTimeStamp(); TracePoint tmp = null; @@ -90,6 +126,6 @@ if (time >= beforeTime) return tmp; tmp = tp; } - return tmp; + return tmp; } }