diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java new file mode 100644 index 0000000..bdf1355 --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java @@ -0,0 +1,216 @@ +package org.ntlab.reversedebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.jdt.core.IJavaElement; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.IMethod; +import org.eclipse.jdt.core.IType; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jdt.core.JavaModelException; +import org.eclipse.jdt.core.Signature; +import org.eclipse.jdt.ui.JavaUI; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.PartInitException; +import org.ntlab.debuggingControl.MethodCaller; + +import com.sun.jdi.ClassNotLoadedException; +import com.sun.jdi.IncompatibleThreadStateException; +import com.sun.jdi.InvalidTypeException; +import com.sun.jdi.InvocationException; +import com.sun.jdi.ObjectReference; +import com.sun.jdi.StringReference; +import com.sun.jdi.ThreadReference; +import com.sun.jdi.Value; +import com.sun.jdi.VirtualMachine; + +public class JavaEditorOperator { + private static final String TRACE = "org.ntlab.traceCollector.tracer.trace"; + + public void openSrcFile(MethodCaller alias) { + System.out.println("JavaEditorOpenSrcFile(MethodCaller)���Ă΂ꂽ��!"); + try { + ObjectReference methodExecution = (ObjectReference)alias.callInstanceMethod("getMethodExecution"); + MethodCaller meCaller = new MethodCaller(alias.getVm(), alias.getThread(), methodExecution); + openSrcFileOfMethodExecution(meCaller); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + /** + * �����œn����meCaller���ɂ���methodExecution����`����Ă���N���X�̃\�[�X�R�[�h��Ώ�Eclipse�̃G�f�B�^�ŊJ������ + * + * @param meCaller + */ + private void openSrcFileOfMethodExecution(MethodCaller meCaller) + throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { + IType type = findIType(meCaller); + if (type != null) { + IMethod method = findIMethod(meCaller, type); + if (method != null) { + openSrcFileOfIMethod(type, method); + } + } + } + + /** + * �����œn����IType��IMethod�ɑΉ�����\�[�X�R�[�h��Ώ�Eclipse�̃G�f�B�^�ŊJ������ + * + * @param type + * @param method + */ + private void openSrcFileOfIMethod(IType type, IMethod method) throws InvalidTypeException, ClassNotLoadedException, + InvocationException, IncompatibleThreadStateException { + openInJavaEditor(type, method); + } + + private IType findIType(MethodCaller meCaller) throws InvalidTypeException, + ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { + StringReference declaringClassName = (StringReference)meCaller.callInstanceMethod("getDeclaringClassName"); + String projectPath = getLoaderPath(meCaller, declaringClassName); + IType type = null; + if (projectPath != null) { + IJavaProject javaProject = findJavaProject(projectPath); + if (javaProject != null) { + StringReference methodSignature = (StringReference)meCaller.callInstanceMethod("getSignature"); + try { + type = javaProject.findType(declaringClassName.value()); + } catch (JavaModelException e) { + e.printStackTrace(); + } + } + } + return type; + } + + private String getLoaderPath(MethodCaller meCaller, StringReference declaringClassName) + throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { + ObjectReference classInfo = (ObjectReference)meCaller.callStaticMethod(TRACE, "TraceJSON", "getClassInfo", declaringClassName); + if (classInfo == null) { + declaringClassName = (StringReference)meCaller.callInstanceMethod("getThisClassName"); + classInfo = (ObjectReference)meCaller.callStaticMethod(TRACE, "TraceJSON", "getClassInfo", declaringClassName); + } + String loaderPath = null; + if (classInfo != null) { + // �Ȃ���loaderPath���擾�ł��Ă��Ȃ����߁A���ۂɏo�͂����JSON�g���[�X���Q�l�ɂ���path����^���Ă݂� + MethodCaller classInfoMethodCaller = new MethodCaller(meCaller.getVm(), meCaller.getThread(), classInfo); + String path = ((StringReference)classInfoMethodCaller.callInstanceMethod("getPath")).value(); + String declaringClassNameString = declaringClassName.value().replace(".", "/"); + loaderPath = path.substring(0, path.indexOf(declaringClassNameString)); // path����N���X�̊��S���薼�ȍ~��S�ĊO�������̂�projectPath�ɂ��Ă݂� + } + return loaderPath; + } + + private IJavaProject findJavaProject(String projectPath) { + IJavaProject javaProject = null; + IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); + IProject[] projects = root.getProjects(); + for (IProject project : projects) { + if (checkProjectPath(project, projectPath)) { + javaProject = JavaCore.create(project); + break; + } + } + return javaProject; + } + + private boolean checkProjectPath(IProject project, String projectPath) { + String projectLocation = project.getLocation().toString(); + if (projectPath.startsWith(projectLocation)) { + String[] projectPathSplit = projectPath.split(projectLocation); + return (projectPathSplit[1].charAt(0) == '/'); // �v���W�F�N�g���̑O����v�ɂ�鑼�v���W�F�N�g�Ƃ̌딻�������� + } + return false; + } + + private void openInJavaEditor(IType type, IMethod method) { + try { + if (type != null && method != null) { + IEditorPart editor = JavaUI.openInEditor(type); + if (!type.isLocal() && !type.isMember()) { + JavaUI.revealInEditor(editor, (IJavaElement) method); + } + } + } catch (PartInitException | JavaModelException e) { + e.printStackTrace(); + } + } + + private IMethod findIMethod(MethodCaller meCaller, IType type) throws InvalidTypeException, + ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { + IMethod method = null; + if (type != null) { + StringReference methodSignature = (StringReference)meCaller.callInstanceMethod("getSignature"); + method = findIMethod(type, methodSignature.value()); + } + return method; + } + + private IMethod findIMethod(IType type, String methodSignature) { + try { + for (IMethod method : type.getMethods()) { + if (checkMethodSignature(type, method, methodSignature)) { + return method; + } + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + return null; + } + + private boolean checkMethodSignature(IType type, IMethod method, String methodSignature) { + String fqcn = type.getFullyQualifiedName(); + try { + StringBuilder jdtMethodSignature = new StringBuilder(); + jdtMethodSignature.append((method.isConstructor()) ? (fqcn + "(") : (fqcn + "." + method.getElementName() + "(")); + if (methodSignature.contains(jdtMethodSignature)) { + // ������v���Ă����ꍇ�Ɍ���A�������X�g����������ł���v���邩�ǂ����𔻒� (�I�[�o�[���[�h�ɂ��딻��������) + jdtMethodSignature.append(String.join(",", parseFQCNParameters(type, method)) + ")"); // �S�����̃V�O�l�`�������S����N���X���ɕϊ�����,�ŋ�؂��������� + return methodSignature.contains(jdtMethodSignature); + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + return false; + } + + /** + * IMethod����擾�ł���S�����̃V�O�l�`�������S����N���X���ɒu�������Ċi�[�������X�g��Ԃ� + * + * @param type + * @param method + * @return + */ + private List parseFQCNParameters(IType type, IMethod method) throws JavaModelException { + List parameters = new ArrayList<>(); + for (String parameterType : method.getParameterTypes()) { + String readableType = Signature.toString(parameterType); // �V�O�l�`���̕�������^���̕�����ɕϊ� (�z��͌���[]���‚�) + String[] readableTypeSplit = { "", "" }; // �^����[]�̕����p + int firstBracketIndex = readableType.indexOf("[]"); + final int NO_BRACKET_INDEX = -1; + if (firstBracketIndex == NO_BRACKET_INDEX) { + readableTypeSplit[0] = readableType; // �^�� + } else { + readableTypeSplit[0] = readableType.substring(0, firstBracketIndex); // �^�� + readableTypeSplit[1] = readableType.substring(firstBracketIndex); // �^���̌���[]�S�� + } + String[][] resolveType = type.resolveType(readableTypeSplit[0]); // �p�b�P�[�W���ƃN���X���̑g�ݍ��킹���擾 + if (resolveType != null) { + if (resolveType[0][0].isEmpty()) { + readableTypeSplit[0] = (resolveType[0][1]); // �f�t�H���g�p�b�P�[�W�̏ꍇ�̓p�b�P�[�W����.�͓���Ȃ� + } else { + readableTypeSplit[0] = (resolveType[0][0] + "." + resolveType[0][1]); // ���S����N���X�� + } + } + parameters.add(readableTypeSplit[0] + readableTypeSplit[1]); + } + return parameters; + } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java index 54c0759..ce6d7c6 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java @@ -5,6 +5,9 @@ import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.IToolBarManager; import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.TableViewer; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Composite; @@ -13,11 +16,14 @@ import org.eclipse.ui.ISharedImages; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.part.ViewPart; +import org.ntlab.debuggingControl.MethodCaller; public class ObjectFlowAliasView extends ViewPart { private TableViewer viewer; - private IAction updateAction; + private IAction refreshAction; + private IAction resetAction; private ObjectFlowAliases objectFlowAliases = ObjectFlowAliases.getInstance(); + private JavaEditorOperator javaEditorOperator = new JavaEditorOperator(); public ObjectFlowAliasView() { // TODO Auto-generated constructor stub @@ -42,10 +48,24 @@ tableColumns[i].setText(tableColumnTexts[i]); tableColumns[i].setWidth(tableColumnWidth[i]); } - viewer.setContentProvider(new ArrayContentProvider()); viewer.setLabelProvider(new ObjectFlowAliasLabelProvider()); viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); + + // �I�������J�����ɑΉ�����G�C���A�X������郁�\�b�h���s���̑S�ẴV�[�h�G�C���A�X�̈ꗗ�𐶐����郊�X�i�[��o�^ + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + System.out.println(element); + if (element instanceof MethodCaller) { + MethodCaller alias = (MethodCaller)element; + SeedAliases.getInstance().createSeedAliases(alias); + javaEditorOperator.openSrcFile(alias); + } + } + }); createActions(); createToolBar(); createMenuBar(); @@ -58,24 +78,36 @@ } private void createActions() { - updateAction = new Action() { + refreshAction = new Action() { @Override public void run() { viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); } }; - updateAction.setText("�e�L�X�g"); - updateAction.setToolTipText("�c�[���`�b�v�e�L�X�g"); - updateAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + refreshAction.setText("�e�L�X�g"); + refreshAction.setToolTipText("�c�[���`�b�v�e�L�X�g"); + refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + + resetAction = new Action() { + @Override + public void run() { + objectFlowAliases.reset(); + } + }; + resetAction.setText("�e�L�X�g"); + resetAction.setToolTipText("�c�[���`�b�v�e�L�X�g"); + resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_WARN_TSK)); } private void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); - mgr.add(updateAction); + mgr.add(refreshAction); + mgr.add(resetAction); } private void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); - mgr.add(updateAction); + mgr.add(refreshAction); + mgr.add(resetAction); } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java index dd821d8..212b61b 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java @@ -30,12 +30,16 @@ return theInstance; } + public void reset() { + objectFlowAliases.clear(); + } + public List> getObjectFlow() { return objectFlowAliases; } - public List> getObjectFlow(MethodCaller alias) { - createObjectFlow(alias); + public List> getObjectFlow(MethodCaller seedAlias) { + createObjectFlow(seedAlias); return objectFlowAliases; } @@ -52,18 +56,18 @@ return list; } - public List getObjectFlowSingleList(MethodCaller alias, boolean hasBound) { - createObjectFlow(alias); + public List getObjectFlowSingleList(MethodCaller seedAlias, boolean hasBound) { + createObjectFlow(seedAlias); return getObjectFlowSingleList(hasBound); } - public void createObjectFlow(MethodCaller alias) { + public void createObjectFlow(MethodCaller seedAlias) { System.out.println("ObjectFlowAliases#createObjectFlow(MethodCaller)���Ă΂ꂽ��!"); - MethodCaller mc = new MethodCaller(alias.getVm(), alias.getThread()); + MethodCaller mc = new MethodCaller(seedAlias.getVm(), seedAlias.getThread()); objectFlowAliases.clear(); try { // �I�������G�C���A�X���N�_�ɃI�u�W�F�N�g�t���[���Ăяo���Č��ʂ����X�g�Ŏ󂯎�� - ObjectReference aliasListsReference = (ObjectReference)alias.callStaticMethod(TRACE, "TraceJSON", "getObjectFlow", alias.getObj()); + ObjectReference aliasListsReference = (ObjectReference)seedAlias.callStaticMethod(TRACE, "TraceJSON", "getObjectFlow", seedAlias.getObj()); // �擾�������X�g�̒��g�����[�v�ʼn񂵂Ȃ�����o��, �Ǘ��p�̃��X�g�ɋl�ߒ��� int aliasListsSize = ((IntegerValue)mc.setObj(aliasListsReference).callInstanceMethod("size")).value(); @@ -74,7 +78,7 @@ int aliasListSize = ((IntegerValue)mc.setObj(aliasListReference).callInstanceMethod("size")).value(); for (int j = 0; j < aliasListSize; j++) { ObjectReference aliasReference = (ObjectReference)mc.setObj(aliasListReference).callInstanceMethod("get", mc.getVm().mirrorOf(j)); - list.add(new MethodCaller(alias.getVm(), alias.getThread(), aliasReference)); + list.add(new MethodCaller(seedAlias.getVm(), seedAlias.getThread(), aliasReference)); } } } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java index c7c2571..f904df2 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java @@ -9,6 +9,7 @@ import org.eclipse.jface.action.IToolBarManager; import org.eclipse.jface.viewers.ArrayContentProvider; import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.TableViewer; import org.eclipse.swt.SWT; @@ -24,8 +25,9 @@ public class SeedAliasView extends ViewPart { private TableViewer viewer; - private IAction updateAction; - private SeedAliases seedAliases = new SeedAliases(); + private IAction refreshAction; + private IAction resetAction; + private SeedAliases seedAliases = SeedAliases.getInstance(); public SeedAliasView() { // TODO Auto-generated constructor stub @@ -50,10 +52,22 @@ tableColumns[i].setText(tableColumnTexts[i]); tableColumns[i].setWidth(tableColumnWidth[i]); } - viewer.setContentProvider(new ArrayContentProvider()); viewer.setLabelProvider(new SeedAliasLabelProvider()); viewer.setInput(seedAliases.getSeedAliases()); + + // �I�������J�����ɑΉ�����V�[�h�G�C���A�X���N�_�ɃI�u�W�F�N�g�t���[�����s�����郊�X�i�[��o�^ + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + if (element instanceof MethodCaller) { + MethodCaller seedAlias = (MethodCaller)element; + ObjectFlowAliases.getInstance().createObjectFlow(seedAlias); + } + } + }); createActions(); createToolBar(); createMenuBar(); @@ -66,25 +80,39 @@ } private void createActions() { - updateAction = new Action() { + refreshAction = new Action() { + @Override + public void run() { + if (seedAliases.getSeedAliases().isEmpty()) { + seedAliases.initSeedAliases(); + } + viewer.refresh(); + } + }; + refreshAction.setText("�e�L�X�g"); + refreshAction.setToolTipText("�c�[���`�b�v�e�L�X�g"); + refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + + resetAction = new Action() { @Override public void run() { seedAliases.reset(); - viewer.setInput(seedAliases.getSeedAliases()); - } + } }; - updateAction.setText("�e�L�X�g"); - updateAction.setToolTipText("�c�[���`�b�v�e�L�X�g"); - updateAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + resetAction.setText("�e�L�X�g"); + resetAction.setToolTipText("�c�[���`�b�v�e�L�X�g"); + resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_WARN_TSK)); } private void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); - mgr.add(updateAction); + mgr.add(refreshAction); + mgr.add(resetAction); } private void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); - mgr.add(updateAction); + mgr.add(refreshAction); + mgr.add(resetAction); } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java index f18e02a..a4ce80d 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java @@ -31,11 +31,19 @@ import com.sun.jdi.VirtualMachine; public class SeedAliases { + public static SeedAliases theInstance = null; private List seedAliases = new ArrayList<>(); private final String TRACER = "org.ntlab.traceCollector.tracer.trace"; - - public SeedAliases() { - init(); + + private SeedAliases() { + initSeedAliases(); + } + + public static SeedAliases getInstance() { + if (theInstance == null) { + theInstance = new SeedAliases(); + } + return theInstance; } public List getSeedAliases() { @@ -44,10 +52,9 @@ public void reset() { seedAliases.clear(); - init(); } - private void init() { + public void initSeedAliases() { // TODO Auto-generated method stub LaunchManager lm = (LaunchManager)DebugPlugin.getDefault().getLaunchManager(); @@ -71,45 +78,64 @@ for (int i = 0; i < allThreads.size(); i++) { ThreadReference thread = allThreads.get(i); if (thread.isSuspended()) { - try { - setSeedAliasList(vm, thread); - } catch (InvalidTypeException - | ClassNotLoadedException - | InvocationException e) { - e.printStackTrace(); - } catch (IncompatibleThreadStateException e) { - e.printStackTrace(); - } + createSeedAliases(vm, thread); } } } } } } - + /** - * �I�����C����͒���, �I�u�W�F�N�g�t���[�̋N�_�ƂȂ�G�C���A�X(�V�[�h�G�C���A�X)�̈ꗗ��T���ăZ�b�g���� + * ���݃f�o�b�K�Ŏ~�܂��Ă���n�_�ł̃��\�b�h���s���̑S�V�[�h�G�C���A�X�ꗗ���Z�b�g���� * @param vm * @param thread */ - private void setSeedAliasList(VirtualMachine vm, ThreadReference thread) throws InvalidTypeException, + private void createSeedAliases(VirtualMachine vm, ThreadReference thread) { + MethodCaller mc = new MethodCaller(vm, thread); + try { + // threadId�̎擾��StringReference�^�ւ̕ϊ� + Value threadIdValue = mc.setObj(thread).callInstanceMethod("getId"); + StringReference threadId = vm.mirrorOf(String.valueOf(((LongValue)threadIdValue).value())); + + // threadId�ɑΉ�����ThreadInstance���擾 + ObjectReference threadInstance = (ObjectReference)mc.callStaticMethod(TRACER, "TraceJSON", "getThreadInstance", threadId); + Value methodExecution = mc.setObj(threadInstance).callInstanceMethod("getCurrentMethodExecution"); + findAllSeedAlias(vm, thread, methodExecution); + } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + /** + * �n���ꂽ�G�C���A�X������郁�\�b�h���s���̑S�V�[�h�G�C���A�X�̈ꗗ���Z�b�g���� + * @param alias + */ + public void createSeedAliases(MethodCaller alias) { + MethodCaller mc = new MethodCaller(alias.getVm(), alias.getThread()); + try { + Value methodExecution = alias.callInstanceMethod("getMethodExecution"); + findAllSeedAlias(alias.getVm(), alias.getThread(), methodExecution); + } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + /** + * �n���ꂽ���\�b�h���s���̑S�V�[�h�G�C���A�X�̈ꗗ��, ���ۂ�traceCollector���ƒʐM���Ď擾���Z�b�g���� + * @param vm + * @param thread + * @param methodExecution + */ + private void findAllSeedAlias(VirtualMachine vm, ThreadReference thread, Value methodExecution) throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { MethodCaller mc = new MethodCaller(vm, thread); - - // threadId�̎擾��StringReference�^�ւ̕ϊ� - Value threadIdValue = mc.setObj(thread).callInstanceMethod("getId"); - StringReference threadId = vm.mirrorOf(String.valueOf(((LongValue)threadIdValue).value())); - - // threadId�ɑΉ�����ThreadInstance���擾 - ObjectReference threadInstance = (ObjectReference)mc.callStaticMethod(TRACER, "TraceJSON", "getThreadInstance", threadId); - - // �f�o�b�K�Ŏ~�߂Ă���n�_�ɊY�����郁�\�b�h���s����, �X�^�[�g�ƂȂ���̃G�C���A�X�̃��X�g���擾���ĕ\������ - Value methodExecution = mc.setObj(threadInstance).callInstanceMethod("getCurrentMethodExecution"); + seedAliases.clear(); ObjectReference seedAliasList = (ObjectReference)mc.callStaticMethod(TRACER, "TraceJSON", "findAllStartAlias", methodExecution); int seedAliasListSize = ((IntegerValue)mc.setObj(seedAliasList).callInstanceMethod("size")).value(); for (int i = 0; i < seedAliasListSize; i++) { - ObjectReference startAlias = (ObjectReference)mc.setObj(seedAliasList).callInstanceMethod("get", vm.mirrorOf(i)); - seedAliases.add(new MethodCaller(vm, thread, startAlias)); + ObjectReference seedAlias = (ObjectReference)mc.setObj(seedAliasList).callInstanceMethod("get", vm.mirrorOf(i)); + seedAliases.add(new MethodCaller(vm, thread, seedAlias)); } } }