use of org.mvel2.ParserContext in project drools by kiegroup.
the class PatternBuilder method getFieldValue.
private FieldValue getFieldValue(RuleBuildContext context, ValueType vtype, String value) {
try {
MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL = true;
MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING = true;
MVEL.COMPILER_OPT_ALLOW_RESOLVE_INNERCLASSES_WITH_DOTNOTATION = true;
MVEL.COMPILER_OPT_SUPPORT_JAVA_STYLE_CLASS_LITERALS = true;
MVELDialectRuntimeData data = (MVELDialectRuntimeData) context.getPkg().getDialectRuntimeRegistry().getDialectData("mvel");
ParserConfiguration pconf = data.getParserConfiguration();
ParserContext pctx = new ParserContext(pconf);
Object o = MVELSafeHelper.getEvaluator().executeExpression(MVEL.compileExpression(value, pctx));
if (o != null && vtype == null) {
// was a compilation problem else where, so guess valuetype so we can continue
vtype = ValueType.determineValueType(o.getClass());
}
return context.getCompilerFactory().getFieldFactory().getFieldValue(o, vtype);
} catch (final Exception e) {
// we will fallback to regular preducates, so don't raise an error
}
return null;
}
use of org.mvel2.ParserContext in project drools by kiegroup.
the class ConditionAnalyzer method analyzeNode.
private Expression analyzeNode(ASTNode node) {
node = analyzeRegEx(analyzeSubstatement(node));
if (node instanceof LiteralNode) {
LiteralNode literalNode = (LiteralNode) node;
return new FixedExpression(literalNode.getEgressType(), literalNode.getLiteralValue());
}
if (node instanceof BinaryOperation) {
BinaryOperation op = (BinaryOperation) node;
return new AritmeticExpression(analyzeNode(op.getLeft()), AritmeticOperator.fromMvelOpCode(op.getOperation()), analyzeNode(op.getRight()));
}
if (node instanceof TypeCast) {
ExecutableStatement statement = ((TypeCast) node).getStatement();
if (statement instanceof ExecutableAccessor) {
ExecutableAccessor accessor = (ExecutableAccessor) statement;
return new CastExpression(node.getEgressType(), analyzeNode(accessor.getNode()));
} else {
ExecutableLiteral literal = (ExecutableLiteral) statement;
return new CastExpression(node.getEgressType(), new FixedExpression(literal.getLiteral()));
}
}
if (node instanceof Union) {
ASTNode main = ((Union) node).getMain();
Accessor accessor = node.getAccessor();
EvaluatedExpression expression = new EvaluatedExpression();
expression.firstExpression = analyzeNode(main);
if (accessor instanceof DynamicGetAccessor) {
AccessorNode accessorNode = (AccessorNode) ((DynamicGetAccessor) accessor).getSafeAccessor();
expression.addInvocation(analyzeAccessorInvocation(accessorNode, node, null, null));
} else if (accessor instanceof AccessorNode) {
AccessorNode accessorNode = (AccessorNode) accessor;
while (accessorNode != null) {
expression.addInvocation(analyzeAccessorInvocation(accessorNode, node, null, null));
accessorNode = accessorNode.getNextNode();
}
} else {
throw new RuntimeException("Unexpected accessor: " + accessor);
}
return expression;
}
if (node instanceof Sign) {
ExecutableStatement statement = getFieldValue(Sign.class, "stmt", (Sign) node);
if (statement instanceof ExecutableAccessor) {
ExecutableAccessor accessor = (ExecutableAccessor) statement;
return new AritmeticExpression(new FixedExpression(0), AritmeticOperator.SUB, analyzeNode(accessor.getNode()));
} else {
ExecutableLiteral literal = (ExecutableLiteral) statement;
return new AritmeticExpression(new FixedExpression(0), AritmeticOperator.SUB, new FixedExpression(literal.getLiteral()));
}
}
Accessor accessor = node.getAccessor();
if (accessor instanceof IndexedVariableAccessor) {
String variableName = node.getName();
int dot = variableName.indexOf('.');
if (dot > 0) {
variableName = variableName.substring(0, dot);
}
Class<?> variableType = getVariableType(variableName);
return new VariableExpression(variableName, analyzeExpressionNode(((AccessorNode) accessor).getNextNode(), node, variableType), variableType != null ? variableType : node.getEgressType());
}
if (accessor == null && node instanceof NewObjectNode) {
accessor = ((NewObjectNode) node).getNewObjectOptimizer();
}
if (accessor instanceof VariableAccessor) {
VariableAccessor variableAccessor = (VariableAccessor) accessor;
AccessorNode accessorNode = variableAccessor.getNextNode();
if (accessorNode == null || !isStaticAccessor(accessorNode)) {
String variableName = (String) (variableAccessor.getProperty());
Class<?> variableType = getVariableType(variableName);
if (variableType != null) {
return new VariableExpression(variableName, analyzeExpressionNode(accessorNode, node, variableType), variableType);
} else {
if (node.getLiteralValue() instanceof ParserContext) {
ParserContext pCtx = (ParserContext) node.getLiteralValue();
// it's not a variable but a method invocation on this
Class<?> thisClass = pCtx.getInputs().get("this");
try {
return new EvaluatedExpression(new MethodInvocation(thisClass.getMethod(variableName)));
} catch (NoSuchMethodException e) {
if (node.getEgressType() == Class.class) {
// there's no method on this with the given name, check if it is a class literal
Class<?> classLiteral = pCtx.getParserConfiguration().getImport(variableName);
if (classLiteral != null) {
return new FixedExpression(Class.class, classLiteral);
}
}
throw new RuntimeException(e);
}
}
}
}
}
if (accessor == null) {
throw new RuntimeException("Null accessor on node: " + node);
}
return analyzeNodeAccessor(accessor, node);
}
use of org.mvel2.ParserContext in project mvel by mvel.
the class ForEachNode method handleCond.
private void handleCond(char[] condition, int start, int offset, int fields, ParserContext pCtx) {
int cursor = start;
int end = start + offset;
while (cursor < end && condition[cursor] != ':') cursor++;
if (cursor == end || condition[cursor] != ':')
throw new CompileException("expected : in foreach", condition, cursor);
int x;
if ((x = (item = createStringTrimmed(condition, start, cursor - start)).indexOf(' ')) != -1) {
String tk = new String(condition, start, x).trim();
try {
itemType = ParseTools.findClass(null, tk, pCtx);
item = new String(condition, start + x, (cursor - start) - x).trim();
} catch (ClassNotFoundException e) {
throw new CompileException("cannot resolve identifier: " + tk, condition, start);
}
}
// this.start = ++cursor;
this.start = cursor + 1;
this.offset = offset - (cursor - start) - 1;
if ((fields & COMPILE_IMMEDIATE) != 0) {
Class egress = (this.condition = (ExecutableStatement) subCompileExpression(expr, this.start, this.offset, pCtx)).getKnownEgressType();
if (itemType != null && egress.isArray()) {
enforceTypeSafety(itemType, getBaseComponentType(this.condition.getKnownEgressType()));
} else if (pCtx.isStrongTyping()) {
determineIterType(egress);
}
}
}
use of org.mvel2.ParserContext in project mvel by mvel.
the class ForNode method buildForEach.
private boolean buildForEach(char[] condition, int start, int offset, int blockStart, int blockEnd, int fields, ParserContext pCtx) {
int end = start + offset;
int cursor = nextCondPart(condition, start, end, false);
boolean varsEscape = false;
try {
ParserContext spCtx;
if (pCtx != null) {
spCtx = pCtx.createSubcontext().createColoringSubcontext();
} else {
spCtx = new ParserContext();
}
this.initializer = (ExecutableStatement) subCompileExpression(condition, start, cursor - start - 1, spCtx);
if (pCtx != null) {
pCtx.pushVariableScope();
}
try {
expectType(pCtx, this.condition = (ExecutableStatement) subCompileExpression(condition, start = cursor, (cursor = nextCondPart(condition, start, end, false)) - start - 1, spCtx), Boolean.class, ((fields & COMPILE_IMMEDIATE) != 0));
} catch (CompileException e) {
if (e.getExpr().length == 0) {
e.setExpr(expr);
while (start < expr.length && ParseTools.isWhitespace(expr[start])) {
start++;
}
e.setCursor(start);
}
throw e;
}
this.after = (ExecutableStatement) subCompileExpression(condition, start = cursor, (nextCondPart(condition, start, end, true)) - start, spCtx);
if (spCtx != null && (fields & COMPILE_IMMEDIATE) != 0 && spCtx.isVariablesEscape()) {
if (pCtx != spCtx)
pCtx.addVariables(spCtx.getVariables());
varsEscape = true;
} else if (spCtx != null && pCtx != null) {
pCtx.addVariables(spCtx.getVariables());
}
this.compiledBlock = (ExecutableStatement) subCompileExpression(expr, blockStart, blockEnd, spCtx);
if (pCtx != null) {
pCtx.setInputs(spCtx.getInputs());
}
} catch (NegativeArraySizeException e) {
throw new CompileException("wrong syntax; did you mean to use 'foreach'?", expr, start);
}
return varsEscape;
}
use of org.mvel2.ParserContext in project mvel by mvel.
the class InlineCollectionNode method parseGraph.
private void parseGraph(boolean compile, Class type, ParserContext pCtx) {
CollectionParser parser = new CollectionParser();
if (type == null) {
collectionGraph = ((List) parser.parseCollection(expr, start, offset, compile, pCtx)).get(0);
} else {
collectionGraph = ((List) parser.parseCollection(expr, start, offset, compile, type, pCtx)).get(0);
}
trailingStart = parser.getCursor() + 2;
trailingOffset = offset - (trailingStart - start);
if (this.egressType == null)
this.egressType = collectionGraph.getClass();
}
Aggregations