Beispiel #1
0
  @Override
  public Value evaluate(final EvaluationContext evaluationContext) throws EvaluateException {
    DebugProcess process = evaluationContext.getDebugProcess();

    ClassLoaderReference classLoader;
    try {
      classLoader = getClassLoader(evaluationContext, process);
    } catch (Exception e) {
      throw new EvaluateException("Error creating evaluation class loader: " + e, e);
    }

    String version = ((VirtualMachineProxyImpl) process.getVirtualMachineProxy()).version();
    JavaSdkVersion sdkVersion = JdkVersionUtil.getVersion(version);
    Collection<OutputFileObject> classes =
        compile(sdkVersion != null ? sdkVersion.getDescription() : null);

    try {
      defineClasses(classes, evaluationContext, process, classLoader);
    } catch (Exception e) {
      throw new EvaluateException("Error during classes definition " + e, e);
    }

    try {
      // invoke base evaluator on call code
      final Project project =
          ApplicationManager.getApplication()
              .runReadAction(
                  new Computable<Project>() {
                    @Override
                    public Project compute() {
                      return myPsiContext.getProject();
                    }
                  });
      ExpressionEvaluator evaluator =
          DebuggerInvocationUtil.commitAndRunReadAction(
              project,
              new EvaluatingComputable<ExpressionEvaluator>() {
                @Override
                public ExpressionEvaluator compute() throws EvaluateException {
                  final TextWithImports callCode = getCallCode();
                  PsiElement copyContext = myData.getAnchor();
                  final CodeFragmentFactory factory =
                      DebuggerUtilsEx.findAppropriateCodeFragmentFactory(callCode, copyContext);
                  return factory
                      .getEvaluatorBuilder()
                      .build(
                          factory.createCodeFragment(callCode, copyContext, project),
                          ContextUtil.getSourcePosition(evaluationContext));
                }
              });
      ((EvaluationContextImpl) evaluationContext).setClassLoader(classLoader);
      return evaluator.evaluate(evaluationContext);
    } catch (Exception e) {
      throw new EvaluateException("Error during generated code invocation " + e, e);
    }
  }
Beispiel #2
0
 private static ClassLoaderReference getClassLoader(
     EvaluationContext context, DebugProcess process)
     throws EvaluateException, InvocationException, InvalidTypeException, ClassNotLoadedException,
         IncompatibleThreadStateException {
   // TODO: cache
   ClassType loaderClass =
       (ClassType) process.findClass(context, "java.net.URLClassLoader", context.getClassLoader());
   Method ctorMethod =
       loaderClass.concreteMethodByName("<init>", "([Ljava/net/URL;Ljava/lang/ClassLoader;)V");
   ClassLoaderReference reference =
       (ClassLoaderReference)
           process.newInstance(
               context,
               loaderClass,
               ctorMethod,
               Arrays.asList(createURLArray(context), context.getClassLoader()));
   keep(reference, context);
   return reference;
 }
Beispiel #3
0
 private static ArrayReference mirrorOf(
     byte[] bytes, EvaluationContext context, DebugProcess process)
     throws EvaluateException, InvalidTypeException, ClassNotLoadedException {
   ArrayType arrayClass =
       (ArrayType) process.findClass(context, "byte[]", context.getClassLoader());
   ArrayReference reference = process.newInstance(arrayClass, bytes.length);
   keep(reference, context);
   for (int i = 0; i < bytes.length; i++) {
     reference.setValue(
         i, ((VirtualMachineProxyImpl) process.getVirtualMachineProxy()).mirrorOf(bytes[i]));
   }
   return reference;
 }
Beispiel #4
0
 private static ArrayReference createURLArray(EvaluationContext context)
     throws EvaluateException, InvocationException, InvalidTypeException, ClassNotLoadedException,
         IncompatibleThreadStateException {
   DebugProcess process = context.getDebugProcess();
   ArrayType arrayType =
       (ArrayType) process.findClass(context, "java.net.URL[]", context.getClassLoader());
   ArrayReference arrayRef = arrayType.newInstance(1);
   keep(arrayRef, context);
   ClassType classType =
       (ClassType) process.findClass(context, "java.net.URL", context.getClassLoader());
   VirtualMachineProxyImpl proxy = (VirtualMachineProxyImpl) process.getVirtualMachineProxy();
   StringReference url = proxy.mirrorOf("file:a");
   keep(url, context);
   ObjectReference reference =
       process.newInstance(
           context,
           classType,
           classType.concreteMethodByName("<init>", "(Ljava/lang/String;)V"),
           Collections.singletonList(url));
   keep(reference, context);
   arrayRef.setValues(Collections.singletonList(reference));
   return arrayRef;
 }
Beispiel #5
0
 public static void keep(Value value, EvaluationContext context) {
   if (value instanceof ObjectReference) {
     ((SuspendContextImpl) context.getSuspendContext()).keep((ObjectReference) value);
   }
 }
Beispiel #6
0
 private static void keep(ObjectReference reference, EvaluationContext context) {
   ((SuspendContextImpl) context.getSuspendContext()).keep(reference);
 }