@Override public Value evaluate(ParseSession session) { return BaseExprParser.this.evaluateProperty(session, target.evaluate(session), propertyName); }
@Override public Value evaluate(ParseSession session) { return node.evaluate(session).xxcrement(session, "pre-" + operation, increment); }
@Override public final Value apply(ParseSession session, Object info) { final Node[] params = (Node[])info; final Value[] values = new Value[params.length]; for (int i = 0; i < params.length; i++) values[i] = params[i].evaluate(session); return this.apply(session, values); }
@Override public Value evaluate(ParseSession session) { return node.evaluate(session).xxcrement(session, "post-" + operation, increment); }
private static Object createEmpty(ParseSession session, Class<?> elemType, List<Node> dims) { final int length = dims.get(0).evaluate(session).checkIntegral(session, "array creation"); final Object array = Array.newInstance(elemType, length); final List<Node> remainingDims = dims.subList(1, dims.size()); if (!remainingDims.isEmpty() && remainingDims.get(0) != null) { for (int i = 0; i < length; i++) Array.set(array, i, EmptyArrayNode.createEmpty(session, elemType.getComponentType(), remainingDims)); } return array; } }
@Override public Value evaluate(ParseSession session) { return op.apply(session, arg.evaluate(session)); }
private static Object createLiteral(ParseSession session, Class<?> elemType, List<?> values) { final int length = values.size(); final Object array = Array.newInstance(elemType, length); for (int i = 0; i < length; i++) { if (elemType.isArray()) Array.set(array, i, LiteralArrayNode.createLiteral(session, elemType.getComponentType(), (List<?>)values.get(i))); else { try { Array.set(array, i, ((Node)values.get(i)).evaluate(session).get(session)); } catch (Exception e) { throw new EvalException("error setting array value: " + e, e); } } } return array; }
private Object resolveAndEvaluate(ParseSession session, TypeInferringNode node, Class<?> type) { return node.resolve(session, TypeToken.of(type)).evaluate(session).get(session); }
@Override public Value evaluate(ParseSession session) { // Get left-hand value, which must be an LValue final LValue lvalue = lhs.evaluate(session).asLValue("assignment"); // Calculate new value Value value = rhs.evaluate(session); if (op != Op.EQUALS) value = Op.forSymbol(op.getSymbol().replaceAll("=", "")).apply(session, lvalue, value); // Assign new value to lvalue lvalue.set(session, value); // Done return value; }
@Override public Value evaluate(final ParseSession session) { return new ConstValue(classNode.resolveClass(session).isInstance(target.evaluate(session).get(session))); }
private Object invoke(ParseSession session, Object[] args) throws Throwable { // Sanity check if ((args != null ? args.length : 0) != this.params.size()) throw new EvalException("internal error: wrong # params"); // Set up parameter values int index = 0; final HashMap<String, ValueValue> paramMap = new HashMap<>(); for (Param param : this.params) paramMap.put(param.getName(), new ValueValue(new ConstValue(args[index++]))); // Evaluate expression with new parameters in place final HashMap<String, ValueValue> previousParams = this.frame.get(); this.frame.set(paramMap); try { return this.body.evaluate(session).get(session); } finally { if (previousParams != null) this.frame.set(previousParams); else this.frame.remove(); } }
@Override public Value apply(ParseSession session, Object result) { // Handle second and third forms Integer storageId = null; if (result instanceof Node) storageId = (((Node)result).evaluate(session)).checkIntegral(session, "queryIndex()"); else if (result instanceof Integer) storageId = (Integer)result; if (storageId != null) return this.apply(session, (int)storageId); // Handle first form final Node[] params = (Node[])result; final Class<?> objectType = params[0].evaluate(session).checkType(session, this.getName(), Class.class); final String fieldName = params[1].evaluate(session).checkType(session, this.getName(), String.class); final Class<?>[] valueTypes = new Class<?>[params.length - 2]; for (int i = 0; i < valueTypes.length; i++) valueTypes[i] = params[2 + i].evaluate(session).checkType(session, this.getName(), Class.class); return this.apply(session, objectType, fieldName, valueTypes); }
@Override public Value evaluate(ParseSession session) { for (Node node : new Node[] { lhNode, rhNode }) { if (node.evaluate(session).checkBoolean(session, "logical `or'")) return new ConstValue(true); } return new ConstValue(false); }
@Override public Value evaluate(ParseSession session) { for (Node node : new Node[] { lhNode, rhNode }) { if (!node.evaluate(session).checkBoolean(session, "logical `and'")) return new ConstValue(false); } return new ConstValue(true); }
@Override public <T> Node resolve(ParseSession session, TypeToken<T> type) { // Evaluate target instance final Object target = this.node.evaluate(session).checkNotNull(session, "method " + name + "() invocation"); // Resolve instance method final Method shape = MethodUtil.findFunctionalMethod(type.getRawType()); final Method method = MethodUtil.findMatchingMethod(target.getClass(), this.name, true, shape.getGenericParameterTypes(), shape.getReturnType() != void.class ? shape.getReturnType() : null, false); // Create proxy final MethodHandles.Lookup lookup = MethodHandles.publicLookup(); try { final MethodHandle handle = lookup.unreflect(method).bindTo(target); return new ConstNode(new ConstValue(MethodHandleProxies.asInterfaceInstance(type.getRawType(), handle))); } catch (Exception e) { throw new EvalException("failed to resolve method `" + this.name + "' in object of type " + target.getClass().getName(), e); } } }
@Override public Value evaluate(final ParseSession session) { // Evaluate invocation target, if any final Object target = this.klass == null ? this.targetNode.evaluate(session).checkNotNull(session, "method " + name + "() invocation") : null; // Evaluate params final ParamInfo paramInfo = this.evaluateParams(session); // Find matching method final Method method = MethodUtil.findMatchingMethod( target != null ? target.getClass() : this.klass, this.name, true, paramInfo.getParamTypes(), null, this.klass != null); // Fixup varargs this.fixupVarArgs(paramInfo, method); // Fixup type-inferring nodes this.fixupTypeInferringNodes(session, paramInfo, method); // Invoke method final Object result; try { result = MethodUtil.invokeRefreshed(method, target, paramInfo.getParams()); } catch (Exception e) { final Throwable t = e instanceof InvocationTargetException ? ((InvocationTargetException)e).getTargetException() : e; throw new EvalException("error invoking method `" + method.getName() + "()' on " + (target != null ? "object of type " + target.getClass().getName() : method.getDeclaringClass()) + ": " + t, t); } // Return result value return result != null || method.getReturnType() != Void.TYPE ? new ConstValue(result) : Value.NO_VALUE; }
@Override public Value apply(ParseSession session, Object params) { final ParamInfo info = (ParamInfo)params; final int storageId = info.getStorageId(); final Node version = info.getVersion(); // Create object final Transaction tx = session.getTransaction(); final ObjId id = version != null ? tx.create(storageId, version.evaluate(session).checkIntegral(session, "create()")) : tx.create(storageId); return new ConstValue(session.getMode().hasPermazen() ? JTransaction.getCurrent().get(id) : id); }