Java EvaluationContextImpl类代码示例

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
@Nullable
protected PsiType evaluate(final EvaluationContextImpl evaluationContext) throws EvaluateException {
  final Project project = evaluationContext.getProject();

  ExpressionEvaluator evaluator = DebuggerInvocationUtil.commitAndRunReadAction(project, new EvaluatingComputable<ExpressionEvaluator>() {
    public ExpressionEvaluator compute() throws EvaluateException {
      return EvaluatorBuilderImpl.getInstance().build(myElement, ContextUtil.getSourcePosition(evaluationContext));
    }
  });

  final Value value = evaluator.evaluate(evaluationContext);
  if(value != null){
    return getCastableRuntimeType(project, value);
  }

  throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.surrounded.expression.null"));
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public void calcValue() {
  final DebuggerContextImpl context = getTree().getDebuggerContext();
  update(
    context,
    new Runnable() {
      @Override
      public void run() {
        EvaluationContextImpl evaluationContext = context.createEvaluationContext();
        getDescriptor().setContext(evaluationContext);
        getDescriptor().updateRepresentation(evaluationContext, new DescriptorLabelListener() {
          @Override
          public void labelChanged() {
            updateCaches();
            DebuggerTreeNodeImpl.this.labelChanged();
          }
        });
        childrenChanged(true);
      }
    }, false);
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
private static Value convertToWrapper(EvaluationContextImpl context, PrimitiveValue value, String wrapperTypeName) throws
                                                                                                                          EvaluateException {
  final DebugProcessImpl process = context.getDebugProcess();
  final ClassType wrapperClass = (ClassType)process.findClass(context, wrapperTypeName, null);
  final String methodSignature = "(" + JVMNameUtil.getPrimitiveSignature(value.type().name()) + ")L" + wrapperTypeName.replace('.', '/') + ";";

  List<Method> methods = wrapperClass.methodsByName("valueOf", methodSignature);
  if (methods.size() == 0) { // older JDK version
    methods = wrapperClass.methodsByName(JVMNameUtil.CONSTRUCTOR_NAME, methodSignature);
  }
  if (methods.size() == 0) {
    throw new EvaluateException("Cannot construct wrapper object for value of type " + value.type() + ": Unable to find either valueOf() or constructor method");
  }

  return process.invokeMethod(context, wrapperClass, methods.get(0), Collections.singletonList(value));
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  Object value;
  while (true) {
    value = myConditionEvaluator.evaluate(context);
    if (!(value instanceof BooleanValue)) {
      throw EvaluateExceptionUtil.BOOLEAN_EXPECTED;
    }
    else {
      if (!((BooleanValue)value).booleanValue()) {
        break;
      }
    }

    if (body(context)) break;
  }

  return value;
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  Object value = context.getDebugProcess().getVirtualMachineProxy().mirrorOfVoid();
  while (true) {
    if (body(context)) break;

    value = myConditionEvaluator.evaluate(context);
    if (!(value instanceof BooleanValue)) {
      throw EvaluateExceptionUtil.BOOLEAN_EXPECTED;
    }
    else {
      if (!((BooleanValue)value).booleanValue()) {
        break;
      }
    }
  }

  return value;
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  myEvaluatedIndex = 0;
  myEvaluatedArrayReference = null;
  Value indexValue = (Value)myIndexEvaluator.evaluate(context);
  Value arrayValue = (Value)myArrayReferenceEvaluator.evaluate(context);
  if (!(arrayValue instanceof ArrayReference)) {
    throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.array.reference.expected"));
  }
  myEvaluatedArrayReference = (ArrayReference)arrayValue;
  if (!DebuggerUtils.isInteger(indexValue)) {
    throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.invalid.index.expression"));
  }
  myEvaluatedIndex = ((PrimitiveValue)indexValue).intValue();
  try {
    return myEvaluatedArrayReference.getValue(myEvaluatedIndex);
  }
  catch (Exception e) {
    throw EvaluateExceptionUtil.createEvaluateException(e);
  }
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  Object value = context.getDebugProcess().getVirtualMachineProxy().mirrorOfVoid();
  value = evaluateInitialization(context, value);

  while (true) {
    // condition
    Object codition = evaluateCondition(context);
    if (codition instanceof Boolean) {
      if (!(Boolean)codition) break;
    }
    else if (codition instanceof BooleanValue) {
      if (!((BooleanValue)codition).booleanValue()) break;
    }
    else {
      throw EvaluateExceptionUtil.BOOLEAN_EXPECTED;
    }

    // body
    if (body(context)) break;

    // update
    value = evaluateUpdate(context, value);
  }

  return value;
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  Object value = myConditionEvaluator.evaluate(context);
  if(!(value instanceof BooleanValue)) {
    throw EvaluateExceptionUtil.BOOLEAN_EXPECTED;
  } else {
    if(((BooleanValue)value).booleanValue()) {
      value = myThenEvaluator.evaluate(context);
      myModifier = myThenEvaluator.getModifier();
    }
    else {
      if(myElseEvaluator != null) {
        value = myElseEvaluator.evaluate(context);
        myModifier = myElseEvaluator.getModifier();
      } else {
        value = context.getDebugProcess().getVirtualMachineProxy().mirrorOfVoid();
        myModifier = null;
      }
    }
  }
  return value;
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public static void batchUpdateRepresentation(@NotNull final List<HprofFieldDescriptorImpl> descriptors,
                                             @NotNull DebuggerManagerThreadImpl debuggerManagerThread,
                                             @NotNull final SuspendContextImpl suspendContext) {
  debuggerManagerThread.invokeAndWait(new DebuggerCommandImpl() {
    @Override
    protected void action() throws Exception {
      for (HprofFieldDescriptorImpl descriptor : descriptors) {
        descriptor.updateRepresentation(new EvaluationContextImpl(suspendContext, null, descriptor.getValue()),
                                        new DescriptorLabelListener() {
                                          @Override
                                          public void labelChanged() {
                                          }
                                        });
      }
    }
  });
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
@Override
public Value calcValue(EvaluationContextImpl evaluationContext) {
  assert (myValueData != null);
  switch (myField.getType()) {
    case BOOLEAN:
      return new BooleanValueImpl(myField, myValueData);
    case BYTE:
      return new ByteValueImpl(myField, myValueData);
    case CHAR:
      return new CharValueImpl(myField, myValueData);
    case SHORT:
      return new ShortValueImpl(myField, myValueData);
    case INT:
      return new IntegerValueImpl(myField, myValueData);
    case LONG:
      return new LongValueImpl(myField, myValueData);
    case FLOAT:
      return new FloatValueImpl(myField, myValueData);
    case DOUBLE:
      return new DoubleValueImpl(myField, myValueData);
    default:
      throw new RuntimeException("Invalid type passed ot PrimitiveDescriptorImpl");
  }
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public JavaStaticGroup(StaticDescriptorImpl staticDescriptor,
                       EvaluationContextImpl evaluationContext,
                       NodeManagerImpl nodeManager) {
  super(staticDescriptor.getName());
  myStaticDescriptor = staticDescriptor;
  myEvaluationContext = evaluationContext;
  myNodeManager = nodeManager;
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  Object object = myTypeEvaluator.evaluate(context);
  if (!(object instanceof ReferenceType)) {
    throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.reference.type.expected"));
  }
  return ((ReferenceType)object).classObject();
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
@Override
public Value evaluate(final EvaluationContext context) throws EvaluateException {
  if (!context.getDebugProcess().isAttached()) {
    throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("error.vm.disconnected"));
  }
  try {
    if (context.getFrameProxy() == null) {
      throw EvaluateExceptionUtil.NULL_STACK_FRAME;
    }

    Object value = myEvaluator.evaluate((EvaluationContextImpl)context);

    if (value != null && !(value instanceof Value)) {
      throw EvaluateExceptionUtil
        .createEvaluateException(DebuggerBundle.message("evaluation.error.invalid.expression", ""));
    }

    myValue = (Value)value;
    return myValue;
  }
  catch (Throwable/*IncompatibleThreadStateException*/ e) {
    if (LOG.isDebugEnabled()) {
      LOG.debug(e);
    }
    if (e instanceof EvaluateException) {
      throw ((EvaluateException)e);
    }
    else {
      throw EvaluateExceptionUtil.createEvaluateException(e);
    }
  }
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  myLeftEvaluator.evaluate(context);
  final Modifier modifier = myLeftEvaluator.getModifier();

  final Object right = myRightEvaluator.evaluate(context);
  if(right != null && !(right instanceof Value)) {
    throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.not.rvalue"));
  }

  assign(modifier, right, context);
  
  return right;
}
 

import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; //导入依赖的package包/类
@Override
public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
  Object result = context.getSuspendContext().getDebugProcess().getVirtualMachineProxy().mirrorOfVoid();
  for (Evaluator statement : myStatements) {
    result = statement.evaluate(context);
  }
  return result;
}