private ASTNode analyzeRegEx(ASTNode node) { if (node instanceof RegExMatch) { return ((ExecutableAccessor)((RegExMatch)node).getStatement()).getNode(); } return node; }
private ASTNode analyzeSubstatement(ASTNode node) { if (node instanceof Substatement) { return ((ExecutableAccessor)((Substatement)node).getStatement()).getNode(); } return node; }
private ASTNode unwrapSubstatement(ASTNode node) { if (node instanceof LineLabel) { return node.nextASTNode; } return node instanceof Substatement ? ((ExecutableAccessor)((Substatement)node).getStatement()).getNode() : node; }
public ConditionAnalyzer(ExecutableStatement stmt, Declaration[] declarations, String conditionClass) { this.declarations = declarations; this.conditionClass = conditionClass; if (stmt instanceof ExecutableLiteral) { executableLiteral = (ExecutableLiteral)stmt; } else if (stmt instanceof CompiledExpression) { node = ((CompiledExpression)stmt).getFirstNode(); } else { node = ((ExecutableAccessor)stmt).getNode(); } }
private ASTNode unwrapNegation(ASTNode node) { if (node instanceof Negation) { ExecutableStatement statement = ((Negation)node).getStatement(); return statement instanceof ExecutableAccessor ? ((ExecutableAccessor)statement).getNode() : null; } return node; }
private ASTNode getRootNode() { if (executableStatement instanceof ExecutableLiteral) { return null; } return executableStatement instanceof CompiledExpression ? ((CompiledExpression) executableStatement).getFirstNode() : ((ExecutableAccessor) executableStatement).getNode(); } }
private Expression statementToExpression(ExecutableStatement param, Class paramType) { if (param instanceof ExecutableLiteral) { return new FixedExpression(paramType, ((ExecutableLiteral)param).getLiteral()); } else if (param instanceof ExecutableAccessor) { return analyzeNode(((ExecutableAccessor)param).getNode()); } else { throw new RuntimeException("Unknown ExecutableStatement type: " + param); } }
public static void testMVELList() { ExecutableAccessor s = (ExecutableAccessor) MVEL.compileExpression("['Foo244','Bar','Foo244','Bar','Foo244','Bar','Foo244','Bar','Foo244','Bar']"); List list; s.getNode().getReducedValueAccelerated(null, null, null); for (int i = 0; i < COUNT; i++) { list = (List) s.getNode().getAccessor().getValue(null, null, null); assert "Foo244".equals(list.get(0)) && "Foo244".equals(list.get(2)) && list.size() == 10; } }
private Object addSubstatement(ExecutableStatement stmt) { if (stmt instanceof ExecutableAccessor) { ExecutableAccessor ea = (ExecutableAccessor) stmt; if (ea.getNode().isIdentifier() && !ea.getNode().isDeepProperty()) { loadVariableByName(ea.getNode().getName()); return null; } } compiledInputs.add(stmt); assert debug("ALOAD 0"); mv.visitVarInsn(ALOAD, 0); assert debug("GETFIELD p" + (compiledInputs.size() - 1)); mv.visitFieldInsn(GETFIELD, className, "p" + (compiledInputs.size() - 1), "L" + NAMESPACE + "compiler/ExecutableStatement;"); assert debug("ALOAD 2"); mv.visitVarInsn(ALOAD, 2); assert debug("ALOAD 3"); mv.visitVarInsn(ALOAD, 3); assert debug("INVOKEINTERFACE ExecutableStatement.getValue"); mv.visitMethodInsn(INVOKEINTERFACE, getInternalName(ExecutableStatement.class), "getValue", "(Ljava/lang/Object;L" + NAMESPACE + "integration/VariableResolverFactory;)Ljava/lang/Object;"); return null; }
private Object addSubstatement(ExecutableStatement stmt) { if (stmt instanceof ExecutableAccessor) { ExecutableAccessor ea = (ExecutableAccessor) stmt; if (ea.getNode().isIdentifier() && !ea.getNode().isDeepProperty()) { loadVariableByName(ea.getNode().getName()); return null; } } compiledInputs.add(stmt); assert debug("ALOAD 0"); mv.visitVarInsn(ALOAD, 0); assert debug("GETFIELD p" + (compiledInputs.size() - 1)); mv.visitFieldInsn(GETFIELD, className, "p" + (compiledInputs.size() - 1), "L" + NAMESPACE + "compiler/ExecutableStatement;"); assert debug("ALOAD 2"); mv.visitVarInsn(ALOAD, 2); assert debug("ALOAD 3"); mv.visitVarInsn(ALOAD, 3); assert debug("INVOKEINTERFACE ExecutableStatement.getValue"); mv.visitMethodInsn(INVOKEINTERFACE, getInternalName(ExecutableStatement.class), "getValue", "(Ljava/lang/Object;L" + NAMESPACE + "integration/VariableResolverFactory;)Ljava/lang/Object;"); return null; }
private Object addSubstatement(ExecutableStatement stmt) { if (stmt instanceof ExecutableAccessor) { ExecutableAccessor ea = (ExecutableAccessor) stmt; if (ea.getNode().isIdentifier() && !ea.getNode().isDeepProperty()) { loadVariableByName(ea.getNode().getName()); return null; } } compiledInputs.add(stmt); assert debug("ALOAD 0"); mv.visitVarInsn(ALOAD, 0); assert debug("GETFIELD p" + (compiledInputs.size() - 1)); mv.visitFieldInsn(GETFIELD, className, "p" + (compiledInputs.size() - 1), "L" + NAMESPACE + "compiler/ExecutableStatement;"); assert debug("ALOAD 2"); mv.visitVarInsn(ALOAD, 2); assert debug("ALOAD 3"); mv.visitVarInsn(ALOAD, 3); assert debug("INVOKEINTERFACE ExecutableStatement.getValue"); mv.visitMethodInsn(INVOKEINTERFACE, getInternalName(ExecutableStatement.class), "getValue", "(Ljava/lang/Object;L" + NAMESPACE + "integration/VariableResolverFactory;)Ljava/lang/Object;"); return null; }
private Method extractMethod(WithNode.ParmValuePair parmValuePair) { Serializable setExpression = parmValuePair.getSetExpression(); if (setExpression != null) { SetterAccessor setterAccessor = (SetterAccessor)((CompiledAccExpression) setExpression).getAccessor(); return setterAccessor.getMethod(); } else { ExecutableAccessor accessor = (ExecutableAccessor)parmValuePair.getStatement(); AccessorNode accessorNode = (AccessorNode)accessor.getNode().getAccessor(); MethodAccessor methodAccessor = (MethodAccessor)accessorNode.getNextNode(); return methodAccessor.getMethod(); } }
private Condition analyzeCondition(ASTNode node) { boolean isNegated = false; if (node instanceof Negation) { isNegated = true; ExecutableStatement statement = ((Negation)node).getStatement(); if (statement instanceof ExecutableLiteral) { return new FixedValueCondition(!(Boolean)((ExecutableLiteral)statement).getLiteral()); } node = ((ExecutableAccessor)statement).getNode(); } node = analyzeSubstatement(node); if (node instanceof LiteralNode && node.getEgressType() == Boolean.class) { boolean literalValue = (Boolean)node.getLiteralValue(); return new FixedValueCondition(isNegated ? !literalValue : literalValue); } if (node instanceof Negation) { isNegated = !isNegated; node = ((ExecutableAccessor)((Negation)node).getStatement()).getNode(); node = analyzeSubstatement(node); } if (node instanceof And || node instanceof Or) { return analyzeCombinedCondition((BooleanNode)node, isNegated); } return analyzeSingleCondition(node, isNegated); }
ExecutableAccessor index = (ExecutableAccessor)arrayAccessorNest.getIndex(); return new ArrayAccessInvocation( formerInvocation != null ? formerInvocation.getReturnType() : Object[].class, analyzeNode(index.getNode()) ); ListAccessorNest listAccessorNest = (ListAccessorNest)accessorNode; ExecutableAccessor index = (ExecutableAccessor)listAccessorNest.getIndex(); return new ListAccessInvocation(listType, analyzeNode(index.getNode())); return new MapAccessInvocation(keyType, valueType, new FixedExpression(keyType, ((ExecutableLiteral)statement).getLiteral())); } else { return new MapAccessInvocation(keyType, valueType, analyzeNode(((ExecutableAccessor)statement).getNode()));
if (statement instanceof ExecutableAccessor) { ExecutableAccessor accessor = (ExecutableAccessor) statement; return new CastExpression(node.getEgressType(), analyzeNode(accessor.getNode())); } else { ExecutableLiteral literal = (ExecutableLiteral) statement; if (statement instanceof ExecutableAccessor) { ExecutableAccessor accessor = (ExecutableAccessor) statement; return new AritmeticExpression(new FixedExpression(0), AritmeticOperator.SUB, analyzeNode(accessor.getNode())); } else { ExecutableLiteral literal = (ExecutableLiteral) statement;
condition.right = new FixedExpression(String.class, pattern.pattern()); } else { condition.right = analyzeNode(((ExecutableAccessor)regExNode.getPatternStatement()).getNode());