vars) {
try {
return evalToBoolean(expression, null, vars);
}
catch (EndWithValue end) {
return convert(end.getValue(), Boolean.class);
}
}
/**
* Performs an analysis compile, which will populate the ParserContext with type, input and variable information,
* but will not produce a payload.
*
* @param expression - the expression to analyze
* @param ctx - the parser context
*/
public static void analysisCompile(char[] expression, ParserContext ctx) {
ExpressionCompiler compiler = new ExpressionCompiler(expression);
compiler.setVerifyOnly(true);
compiler.compile(ctx);
}
public static void analysisCompile(String expression, ParserContext ctx) {
analysisCompile(expression.toCharArray(), ctx);
}
public static Class analyze(char[] expression, ParserContext ctx) {
ExpressionCompiler compiler = new ExpressionCompiler(expression);
compiler.setVerifyOnly(true);
compiler.compile(ctx);
return compiler.getReturnType();
}
public static Class analyze(String expression, ParserContext ctx) {
return analyze(expression.toCharArray(), ctx);
}
/**
* Compiles an expression and returns a Serializable object containing the compiled expression. The returned value
* can be reused for higher-performance evaluation of the expression. It is used in a straight forward way:
*
*
* // Compile the expression
* Serializable compiled = MVEL.compileExpression("x * 10");
*
* // Create a Map to hold the variables.
* Map vars = new HashMap();
*
* // Create a factory to envelop the variable map
* VariableResolverFactory factory = new MapVariableResolverFactory(vars);
*
* int total = 0;
* for (int i = 0; i < 100; i++) {
* // Update the 'x' variable.
* vars.put("x", i);
*
* // Execute the expression against the compiled payload and factory, and add the result to the total variable.
* total += (Integer) MVEL.executeExpression(compiled, factory);
* }
*
* // Total should be 49500
* assert total == 49500;
*
*
* The above example demonstrates a compiled expression being reused ina tight, closed, loop. Doing this greatly
* improves performance as re-parsing of the expression is not required, and the runtime can dynamically compile
* the expression to bytecode of necessary.
*
* @param expression A String contaiing the expression to be compiled.
* @return The cacheable compiled payload.
*/
public static Serializable compileExpression(String expression) {
return compileExpression(expression, null, null, null);
}
/**
* Compiles an expression and returns a Serializable object containing the compiled expression. This method
* also accept a Map of imports. The Map's keys are String's representing the imported, short-form name of the
* Classes or Methods imported. An import of a Method is essentially a static import. This is a substitute for
* needing to declare import statements within the actual script.
*
*
* Map imports = new HashMap();
* imports.put("HashMap", java.util.HashMap.class); // import a class
* imports.put("time", MVEL.getStaticMethod(System.class, "currentTimeMillis", new Class[0])); // import a static method
*
* // Compile the expression
* Serializable compiled = MVEL.compileExpression("map = new HashMap(); map.put('time', time()); map.time");
*
* // Execute with a blank Map to allow vars to be declared.
* Long val = (Long) MVEL.executeExpression(compiled, new HashMap());
*
* assert val > 0;
*
*
* @param expression A String contaiing the expression to be compiled.
* @param imports A String-Class/String-Method pair Map containing imports for the compiler.
* @return The cacheable compiled payload.
*/
public static Serializable compileExpression(String expression, Map imports) {
return compileExpression(expression, imports, null, null);
}
/**
* Compiles an expression and returns a Serializable object containing the compiled expression. This method
* accepts a Map of imports and Interceptors. See {@link #compileExpression(String,Map)} for information on
* imports. The imports parameter in this method is optional and it is safe to pass a null
* value.
* {@link org.mvel2.integration.Interceptor Interceptors} are markers within an expression that allow external hooks
* to be tied into the expression.
*
*
* // Create a Map to hold the interceptors.
* Map interceptors = new HashMap();
*
* // Create a simple interceptor.
* Interceptor logInterceptor = new Interceptor() {
* public int doBefore(ASTNode node, VariableResolverFactory factory) {
* System.out.println("Interceptor called before!");
* }
*
* public int doAfter(Object exitValue, ASTNode node, VariableResolverFactory factory) {
* System.out.println("Interceptor called after!");
* }
* };
*
* // Add the interceptor to the Map.
* interceptors.put("log", logInterceptor);
*
* // Create an expression
* String expr = "list = [1,2,3,4,5]; @log for (item : list) { System.out.println(item); };
*
* Serializable compiled = MVEL.compileExpression(expr, null, interceptors);
*
* // Execute expression with a blank Map to allow vars to be declared.
* MVEL.executeExpression(compiled, new HashMap());
*
*
* The above example demonstrates inserting an interceptor into a piece of code. The @log interceptor
* wraps the subsequent statement. In this case, the interceptor is fired before the for loop and
* after the for loop finishes.
*
* @param expression A String containing the expression to be evaluated.
* @param imports A String-Class/String-Method pair Map containing imports for the compiler.
* @param interceptors A Map of registered interceptors.
* @return A cacheable compiled payload.
*/
public static Serializable compileExpression(String expression, Map imports,
Map interceptors) {
return compileExpression(expression, imports, interceptors, null);
}
/**
* Compiles an expression, and accepts a {@link ParserContext} instance. The ParserContext object is the
* fine-grained configuration object for the MVEL parser and compiler.
*
* @param expression A string containing the expression to be compiled.
* @param ctx The parser context
* @return A cacheable compiled payload.
*/
public static Serializable compileExpression(String expression, ParserContext ctx) {
return optimizeTree(new ExpressionCompiler(expression).compile(ctx));
}
public static Serializable compileExpression(String expression, Map imports,
Map interceptors, String sourceName) {
return compileExpression(expression, new ParserContext(imports, interceptors, sourceName));
}
public static Serializable compileExpression(char[] expression, ParserContext ctx) {
return optimizeTree(new ExpressionCompiler(expression).compile(ctx));
}
/**
* Compiles an expression and returns a Serializable object containing the compiled
* expression.
*
* @param expression The expression to be compiled
* @param imports Imported classes
* @param interceptors Map of named interceptos
* @param sourceName The name of the source file being evaluated (optional)
* @return The cacheable compiled payload
*/
public static Serializable compileExpression(char[] expression, Map imports,
Map interceptors, String sourceName) {
return compileExpression(expression, new ParserContext(imports, interceptors, sourceName));
}
public static Serializable compileExpression(char[] expression) {
return compileExpression(expression, null, null, null);
}
public static Serializable compileExpression(char[] expression, Map imports) {
return compileExpression(expression, imports, null, null);
}
public static Serializable compileExpression(char[] expression, Map imports, Map interceptors) {
return compileExpression(expression, imports, interceptors, null);
}
public static Serializable compileGetExpression(String expression) {
return new CompiledAccExpression(expression.toCharArray(), Object.class, new ParserContext());
}
public static Serializable compileGetExpression(String expression, ParserContext ctx) {
return new CompiledAccExpression(expression.toCharArray(), Object.class, ctx);
}
public static Serializable compileGetExpression(char[] expression) {
return new CompiledAccExpression(expression, Object.class, new ParserContext());
}
public static Serializable compileGetExpression(char[] expression, ParserContext ctx) {
return new CompiledAccExpression(expression, Object.class, ctx);
}
public static Serializable compileSetExpression(String expression) {
return new CompiledAccExpression(expression.toCharArray(), Object.class, new ParserContext());
}
public static Serializable compileSetExpression(String expression, ParserContext ctx) {
return new CompiledAccExpression(expression.toCharArray(), Object.class, ctx);
}
public static Serializable compileSetExpression(String expression, Class ingressType, ParserContext ctx) {
return new CompiledAccExpression(expression.toCharArray(), ingressType, ctx);
}
public static Serializable compileSetExpression(char[] expression) {
return new CompiledAccExpression(expression, Object.class, new ParserContext());
}
public static Serializable compileSetExpression(char[] expression, ParserContext ctx) {
return new CompiledAccExpression(expression, Object.class, ctx);
}
public static Serializable compileSetExpression(char[] expression, Class ingressType, ParserContext ctx) {
return new CompiledAccExpression(expression, ingressType, ctx);
}
public static void executeSetExpression(Serializable compiledSet, Object ctx, Object value) {
((CompiledAccExpression) compiledSet).setValue(ctx, ctx, MVELRuntime.IMMUTABLE_DEFAULT_FACTORY, value);
}
public static void executeSetExpression(Serializable compiledSet, Object ctx, VariableResolverFactory vrf, Object value) {
((CompiledAccExpression) compiledSet).setValue(ctx, ctx, vrf, value);
}
public static Object executeExpression(Object compiledExpression) {
try {
return ((ExecutableStatement) compiledExpression).getValue(null, MVELRuntime.IMMUTABLE_DEFAULT_FACTORY);
}
catch (EndWithValue e) {
return e.getValue();
}
}
/**
* Executes a compiled expression.
*
* @param compiledExpression -
* @param ctx -
* @param vars -
* @return -
* @see #compileExpression(String)
*/
@SuppressWarnings({"unchecked"})
public static Object executeExpression(final Object compiledExpression, final Object ctx, final Map vars) {
try {
return ((ExecutableStatement) compiledExpression).getValue(ctx, vars != null ? new MapVariableResolverFactory(vars) : null);
}
catch (EndWithValue end) {
return end.getValue();
}
}
public static Object executeExpression(final Object compiledExpression, final Object ctx, final VariableResolverFactory resolverFactory) {
try {
return ((ExecutableStatement) compiledExpression).getValue(ctx, resolverFactory);
}
catch (EndWithValue end) {
return end.getValue();
}
}
/**
* Executes a compiled expression.
*
* @param compiledExpression -
* @param factory -
* @return -
* @see #compileExpression(String)
*/
public static Object executeExpression(final Object compiledExpression, final VariableResolverFactory factory) {
try {
return ((ExecutableStatement) compiledExpression).getValue(null, factory);
}
catch (EndWithValue end) {
return end.getValue();
}
}
/**
* Executes a compiled expression.
*
* @param compiledExpression -
* @param ctx -
* @return -
* @see #compileExpression(String)
*/
public static Object executeExpression(final Object compiledExpression, final Object ctx) {
try {
return ((ExecutableStatement) compiledExpression).getValue(ctx, MVELRuntime.IMMUTABLE_DEFAULT_FACTORY);
}
catch (EndWithValue end) {
return end.getValue();
}
}
/**
* Executes a compiled expression.
*
* @param compiledExpression -
* @param vars -
* @return -
* @see #compileExpression(String)
*/
@SuppressWarnings({"unchecked"})
public static Object executeExpression(final Object compiledExpression, final Map vars) {
try {
return ((ExecutableStatement) compiledExpression).getValue(null, new MapVariableResolverFactory(vars));
}
catch (EndWithValue end) {
return end.getValue();
}
}
/**
* Execute a compiled expression and convert the result to a type
*
* @param compiledExpression -
* @param ctx -
* @param vars -
* @param toType -
* @return -
*/
@SuppressWarnings({"unchecked"})
public static T executeExpression(final Object compiledExpression, final Object ctx, final Map vars, Class toType) {
try {
return convert(executeExpression(compiledExpression, ctx, vars), toType);
}
catch (EndWithValue end) {
return convert(end.getValue(), toType);
}
}
public static T executeExpression(final Object compiledExpression, final Object ctx, final VariableResolverFactory vars, Class toType) {
try {
return convert(executeExpression(compiledExpression, ctx, vars), toType);
}
catch (EndWithValue end) {
return convert(end.getValue(), toType);
}
}
/**
* Execute a compiled expression and convert the result to a type
*
* @param compiledExpression -
* @param vars -
* @param toType -
* @return -
*/
@SuppressWarnings({"unchecked"})
public static T executeExpression(final Object compiledExpression, Map vars, Class toType) {
try {
return convert(executeExpression(compiledExpression, vars), toType);
}
catch (EndWithValue end) {
return convert(end.getValue(), toType);
}
}
/**
* Execute a compiled expression and convert the result to a type.
*
* @param compiledExpression -
* @param ctx -
* @param toType -
* @return -
*/
public static T executeExpression(final Object compiledExpression, final Object ctx, Class toType) {
try {
return convert(executeExpression(compiledExpression, ctx), toType);
}
catch (EndWithValue end) {
return convert(end.getValue(), toType);
}
}
public static void executeExpression(Iterable compiledExpression) {
for (CompiledExpression ce : compiledExpression) {
ce.getValue(null, null);
}
}
public static void executeExpression(Iterable compiledExpression, Object ctx) {
for (CompiledExpression ce : compiledExpression) {
ce.getValue(ctx, null);
}
}
public static void executeExpression(Iterable compiledExpression, Map vars) {
executeExpression(compiledExpression, null, new MapVariableResolverFactory(vars));
}
public static void executeExpression(Iterable compiledExpression, Object ctx, Map vars) {
executeExpression(compiledExpression, ctx, new MapVariableResolverFactory(vars));
}
public static void executeExpression(Iterable compiledExpression, Object ctx, VariableResolverFactory vars) {
for (CompiledExpression ce : compiledExpression) {
ce.getValue(ctx, vars);
}
}
public static Object[] executeAllExpression(Serializable[] compiledExpressions, Object ctx, VariableResolverFactory vars) {
if (compiledExpressions == null) return GetterAccessor.EMPTY;
Object[] o = new Object[compiledExpressions.length];
for (int i = 0; i < compiledExpressions.length; i++) {
o[i] = executeExpression(compiledExpressions[i], ctx, vars);
}
return o;
}
public static Object executeDebugger(CompiledExpression expression, Object ctx, VariableResolverFactory vars) {
try {
if (expression.isImportInjectionRequired()) {
return execute(true, expression, ctx, new ClassImportResolverFactory(expression
.getParserContext().getParserConfiguration(), vars));
} else {
return execute(true, expression, ctx, vars);
}
}
catch (EndWithValue e) {
return e.getValue();
}
}
public static String parseMacros(String input, Map macros) {
return new MacroProcessor(macros).parse(input);
}
public static String preprocess(char[] input, PreProcessor[] preprocessors) {
char[] ex = input;
for (PreProcessor proc : preprocessors) {
ex = proc.parse(ex);
}
return new String(ex);
}
public static String preprocess(String input, PreProcessor[] preprocessors) {
return preprocess(input.toCharArray(), preprocessors);
}
public static Object getProperty(String property, Object ctx) {
return PropertyAccessor.get(property, ctx);
}
public static void setProperty(Object ctx, String property, Object value) {
PropertyAccessor.set(ctx, property, value);
}
/**
* A simple utility method to get a static method from a class with no checked exception. With throw a
* RuntimeException if the method is not found or is not a static method.
*
* @param cls The class containing the static method
* @param methodName The method name
* @param signature The signature of the method
* @return An instance of the Method
*/
public static Method getStaticMethod(Class cls, String methodName, Class[] signature) {
try {
Method m = cls.getMethod(methodName, signature);
if ((m.getModifiers() & Modifier.STATIC) == 0)
throw new RuntimeException("method not a static method: " + methodName);
return m;
}
catch (NoSuchMethodException e) {
throw new RuntimeException("no such method: " + methodName);
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/ 0000755 0001750 0001750 00000000000 11412747044 022061 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/ 0000755 0001750 0001750 00000000000 11412747044 023505 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/DynamicSetAccessor.java 0000644 0001750 0001750 00000006535 11110327536 030077 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.dynamic;
import org.mvel2.ParserContext;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizerFactory;
import static java.lang.System.currentTimeMillis;
public class DynamicSetAccessor implements DynamicAccessor {
private char[] property;
private boolean opt = false;
private int runcount = 0;
private long stamp;
private ParserContext context;
private final Accessor _safeAccessor;
private Accessor _accessor;
private String description;
public DynamicSetAccessor(ParserContext context, char[] property, Accessor _accessor) {
assert _accessor != null;
this._safeAccessor = this._accessor = _accessor;
this.context = context;
this.property = property;
this.stamp = System.currentTimeMillis();
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (!opt) {
if (++runcount > DynamicOptimizer.tenuringThreshold) {
if ((currentTimeMillis() - stamp) < DynamicOptimizer.timeSpan) {
opt = true;
return optimize(ctx, elCtx, variableFactory, value);
}
else {
runcount = 0;
stamp = currentTimeMillis();
}
}
}
_accessor.setValue(ctx, elCtx, variableFactory, value);
return value;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
throw new RuntimeException("value cannot be read with this accessor");
}
private Object optimize(Object ctx, Object elCtx, VariableResolverFactory variableResolverFactory, Object value) {
if (DynamicOptimizer.classLoader.isOverloaded()) {
DynamicOptimizer.enforceTenureLimit();
}
AccessorOptimizer ao = OptimizerFactory.getAccessorCompiler("ASM");
_accessor = ao.optimizeSetAccessor(context, property, ctx, elCtx,
variableResolverFactory, false, value, value != null ? value.getClass() : Object.class);
assert _accessor != null;
return value;
}
public void deoptimize() {
this._accessor = this._safeAccessor;
opt = false;
runcount = 0;
stamp = currentTimeMillis();
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Class getKnownEgressType() {
return _safeAccessor.getKnownEgressType();
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/DynamicGetAccessor.java 0000644 0001750 0001750 00000007511 11151132047 030052 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.dynamic;
import org.mvel2.ParserContext;
import org.mvel2.compiler.Accessor;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizerFactory;
import static java.lang.System.currentTimeMillis;
public class DynamicGetAccessor implements DynamicAccessor {
private char[] property;
private long stamp;
private int type;
private int runcount;
private boolean opt = false;
private ParserContext context;
private Accessor _safeAccessor;
private Accessor _accessor;
public DynamicGetAccessor(ParserContext context, char[] property, int type, Accessor _accessor) {
this._safeAccessor = this._accessor = _accessor;
this.type = type;
this.property = property;
this.context = context;
stamp = currentTimeMillis();
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (!opt) {
if (++runcount > DynamicOptimizer.tenuringThreshold) {
if ((currentTimeMillis() - stamp) < DynamicOptimizer.timeSpan) {
opt = true;
return optimize(ctx, elCtx, variableFactory);
}
else {
runcount = 0;
stamp = currentTimeMillis();
}
}
}
return _accessor.getValue(ctx, elCtx, variableFactory);
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
runcount++;
return _accessor.setValue(ctx, elCtx, variableFactory, value);
}
private Object optimize(Object ctx, Object elCtx, VariableResolverFactory variableResolverFactory) {
if (DynamicOptimizer.classLoader.isOverloaded()) {
DynamicOptimizer.enforceTenureLimit();
}
AccessorOptimizer ao = OptimizerFactory.getAccessorCompiler("ASM");
switch (type) {
case DynamicOptimizer.REGULAR_ACCESSOR:
_accessor = ao.optimizeAccessor(context, property, ctx, elCtx, variableResolverFactory, false, null);
return ao.getResultOptPass();
case DynamicOptimizer.OBJ_CREATION:
_accessor = ao.optimizeObjectCreation(context, property, ctx, elCtx, variableResolverFactory);
return _accessor.getValue(ctx, elCtx, variableResolverFactory);
case DynamicOptimizer.COLLECTION:
_accessor = ao.optimizeCollection(AbstractParser.getCurrentThreadParserContext(), ctx, null, property, ctx, elCtx, variableResolverFactory);
return _accessor.getValue(ctx, elCtx, variableResolverFactory);
}
return null;
}
public void deoptimize() {
this._accessor = this._safeAccessor;
opt = false;
runcount = 0;
stamp = currentTimeMillis();
}
public long getStamp() {
return stamp;
}
public int getRuncount() {
return runcount;
}
public Class getKnownEgressType() {
return _safeAccessor.getKnownEgressType();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/DynamicCollectionAccessor.java 0000644 0001750 0001750 00000006432 11151132047 031427 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.dynamic;
import org.mvel2.compiler.Accessor;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.OptimizerFactory;
import org.mvel2.ParserContext;
import static java.lang.System.currentTimeMillis;
public class DynamicCollectionAccessor implements DynamicAccessor {
private Object rootObject;
private Class colType;
private char[] property;
private long stamp;
private int type;
private int runcount;
private boolean opt = false;
private Accessor _safeAccessor;
private Accessor _accessor;
public DynamicCollectionAccessor(Object rootObject, Class colType, char[] property, int type, Accessor _accessor) {
this.rootObject = rootObject;
this.colType = colType;
this._safeAccessor = this._accessor = _accessor;
this.type = type;
this.property = property;
stamp = currentTimeMillis();
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (!opt) {
if (++runcount > DynamicOptimizer.tenuringThreshold) {
if ((currentTimeMillis() - stamp) < DynamicOptimizer.timeSpan) {
opt = true;
return optimize(AbstractParser.getCurrentThreadParserContext(), ctx, elCtx, variableFactory);
}
else {
runcount = 0;
stamp = currentTimeMillis();
}
}
}
return _accessor.getValue(ctx, elCtx, variableFactory);
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
runcount++;
return _accessor.setValue(ctx, elCtx, variableFactory, value);
}
private Object optimize(ParserContext pCtx, Object ctx, Object elCtx, VariableResolverFactory variableResolverFactory) {
if (DynamicOptimizer.classLoader.isOverloaded()) {
DynamicOptimizer.enforceTenureLimit();
}
_accessor = OptimizerFactory.getAccessorCompiler("ASM").optimizeCollection(pCtx, rootObject, colType, property, ctx, elCtx, variableResolverFactory);
return _accessor.getValue(ctx, elCtx, variableResolverFactory);
}
public void deoptimize() {
this._accessor = this._safeAccessor;
opt = false;
runcount = 0;
stamp = currentTimeMillis();
}
public long getStamp() {
return stamp;
}
public int getRuncount() {
return runcount;
}
public Class getKnownEgressType() {
return colType;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/DynamicAccessor.java 0000644 0001750 0001750 00000001501 11077457613 027423 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.dynamic;
import org.mvel2.compiler.Accessor;
public interface DynamicAccessor extends Accessor {
public void deoptimize();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/DynamicClassLoader.java 0000644 0001750 0001750 00000004674 11363353131 030057 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.dynamic;
import org.mvel2.util.MVELClassLoader;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
import java.util.LinkedList;
public class DynamicClassLoader extends ClassLoader implements MVELClassLoader {
private int totalClasses;
private int tenureLimit;
private final LinkedList allAccessors = new LinkedList();
// private static boolean sunJVM;
// private static Object sunUnsafe;
static {
// try {
// Field f = Unsafe.class.getDeclaredField("theUnsafe");
// f.setAccessible(true);
// sunUnsafe = f.get(null);
// sunJVM = true;
// }
// catch (Throwable t) {
// t.printStackTrace();
// sunJVM = false;
// }
}
public DynamicClassLoader(ClassLoader classLoader, int tenureLimit) {
super(classLoader);
this.tenureLimit = tenureLimit;
}
public Class defineClassX(String className, byte[] b, int start, int end) {
totalClasses++;
// if (sunJVM) {
// return ((Unsafe) sunUnsafe).defineClass(className, b, start, end);
// }
// else {
return super.defineClass(className, b, start, end);
// }
}
public int getTotalClasses() {
return totalClasses;
}
public DynamicAccessor registerDynamicAccessor(DynamicAccessor accessor) {
allAccessors.add(accessor);
assert accessor != null;
return accessor;
}
public void deoptimizeAll() {
synchronized (allAccessors) {
for (DynamicAccessor a : allAccessors) {
if (a != null) a.deoptimize();
}
}
}
public boolean isOverloaded() {
return tenureLimit < totalClasses;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/dynamic/DynamicOptimizer.java 0000644 0001750 0001750 00000010103 11261146517 027632 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.dynamic;
import org.mvel2.ParserContext;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AbstractOptimizer;
import org.mvel2.optimizers.AccessorOptimizer;
import static org.mvel2.optimizers.OptimizerFactory.SAFE_REFLECTIVE;
import static org.mvel2.optimizers.OptimizerFactory.getAccessorCompiler;
import static org.mvel2.optimizers.impl.asm.ASMAccessorOptimizer.setMVELClassLoader;
import static java.lang.Thread.currentThread;
public class DynamicOptimizer extends AbstractOptimizer implements AccessorOptimizer {
private AccessorOptimizer firstStage = getAccessorCompiler(SAFE_REFLECTIVE);
public static DynamicClassLoader classLoader;
public static int tenuringThreshold = 50;
public static long timeSpan = 100;
public static int maximumTenure = 1500;
public static int totalRecycled = 0;
private static volatile boolean useSafeClassloading = false;
public void init() {
_init();
}
private static void _init() {
setMVELClassLoader(classLoader = new DynamicClassLoader(currentThread().getContextClassLoader(), maximumTenure));
}
public static void enforceTenureLimit() {
if (classLoader.isOverloaded()) {
classLoader.deoptimizeAll();
totalRecycled = +classLoader.getTotalClasses();
_init();
}
}
public static final int REGULAR_ACCESSOR = 0;
public Accessor optimizeAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean rootThisRef, Class ingressType) {
return classLoader.registerDynamicAccessor(new DynamicGetAccessor(pCtx, property, 0,
firstStage.optimizeAccessor(pCtx, property, ctx, thisRef, factory, rootThisRef, ingressType)));
}
public static final int SET_ACCESSOR = 1;
public Accessor optimizeSetAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean rootThisRef, Object value, Class valueType) {
return classLoader.registerDynamicAccessor(new DynamicSetAccessor(pCtx, property,
firstStage.optimizeSetAccessor(pCtx, property, ctx, thisRef, factory, rootThisRef, value, valueType)));
}
public static final int COLLECTION = 2;
public Accessor optimizeCollection(ParserContext pCtx, Object rootObject, Class type, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory) {
return classLoader.registerDynamicAccessor(new DynamicCollectionAccessor(rootObject, type, property, 2,
firstStage.optimizeCollection(pCtx, rootObject, type, property, ctx, thisRef, factory)));
}
public static final int OBJ_CREATION = 3;
public Accessor optimizeObjectCreation(ParserContext pCtx, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory) {
return classLoader.registerDynamicAccessor(new DynamicGetAccessor(pCtx, property, 3,
firstStage.optimizeObjectCreation(pCtx, property, ctx, thisRef, factory)));
}
public Object getResultOptPass() {
return firstStage.getResultOptPass();
}
public Class getEgressType() {
return firstStage.getEgressType();
}
public boolean isLiteralOnly() {
return firstStage.isLiteralOnly();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/OptimizationNotSupported.java 0000644 0001750 0001750 00000002175 11077457613 030015 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers;
public class OptimizationNotSupported extends RuntimeException {
public OptimizationNotSupported() {
super();
}
public OptimizationNotSupported(String message) {
super(message);
}
public OptimizationNotSupported(String message, Throwable cause) {
super(message, cause);
}
public OptimizationNotSupported(Throwable cause) {
super(cause);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/AbstractOptimizer.java 0000644 0001750 0001750 00000022702 11345736415 026402 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers;
import org.mvel2.CompileException;
import org.mvel2.compiler.AbstractParser;
import static org.mvel2.util.ParseTools.*;
import static java.lang.Thread.currentThread;
import java.lang.reflect.Method;
/**
* @author Christopher Brock
*/
public class AbstractOptimizer extends AbstractParser {
protected static final int BEAN = 0;
protected static final int METH = 1;
protected static final int COL = 2;
protected static final int WITH = 3;
protected int start = 0;
protected boolean collection = false;
protected boolean nullSafe = false;
protected Class currType = null;
/**
* Try static access of the property, and return an instance of the Field, Method of Class if successful.
*
* @return - Field, Method or Class instance.
*/
protected Object tryStaticAccess() {
int begin = cursor;
try {
/**
* Try to resolve this *smartly* as a static class reference.
*
* This starts at the end of the token and starts to step backwards to figure out whether
* or not this may be a static class reference. We search for method calls simply by
* inspecting for ()'s. The first union area we come to where no brackets are present is our
* test-point for a class reference. If we find a class, we pass the reference to the
* property accessor along with trailing methods (if any).
*
*/
boolean meth = false;
int last = length;
for (int i = length - 1; i > 0; i--) {
switch (expr[i]) {
case '.':
if (!meth) {
try {
return Class.forName(new String(expr, 0, cursor = last), true, pCtx != null ?
pCtx.getParserConfiguration().getClassLoader() : currentThread().getContextClassLoader());
}
catch (ClassNotFoundException e) {
Class cls = Class.forName(new String(expr, 0, i), true, pCtx != null ?
pCtx.getParserConfiguration().getClassLoader() : currentThread().getContextClassLoader());
String name = new String(expr, i + 1, expr.length - i - 1);
try {
return cls.getField(name);
}
catch (NoSuchFieldException nfe) {
for (Method m : cls.getMethods()) {
if (name.equals(m.getName())) return m;
}
return null;
}
}
}
meth = false;
last = i;
break;
case '}':
i--;
for (int d = 1; i > 0 && d != 0; i--) {
switch (expr[i]) {
case '}':
d++;
break;
case '{':
d--;
break;
case '"':
case '\'':
char s = expr[i];
while (i > 0 && (expr[i] != s && expr[i - 1] != '\\')) i--;
}
}
break;
case ')':
i--;
for (int d = 1; i > 0 && d != 0; i--) {
switch (expr[i]) {
case ')':
d++;
break;
case '(':
d--;
break;
case '"':
case '\'':
char s = expr[i];
while (i > 0 && (expr[i] != s && expr[i - 1] != '\\')) i--;
}
}
meth = true;
last = i++;
break;
case '\'':
while (--i > 0) {
if (expr[i] == '\'' && expr[i - 1] != '\\') {
break;
}
}
break;
case '"':
while (--i > 0) {
if (expr[i] == '"' && expr[i - 1] != '\\') {
break;
}
}
break;
}
}
}
catch (Exception cnfe) {
cursor = begin;
}
return null;
}
protected int nextSubToken() {
skipWhitespace();
nullSafe = false;
switch (expr[start = cursor]) {
case '[':
return COL;
case '.':
if ((start + 1) != length) {
switch (expr[cursor = ++start]) {
case '?':
skipWhitespace();
if ((cursor = ++start) == length) {
throw new CompileException("unexpected end of statement");
}
nullSafe = true;
fields = -1;
break;
case '{':
return WITH;
default:
if (isWhitespace(expr[start])) {
skipWhitespace();
start = cursor;
}
}
}
else {
throw new CompileException("unexpected end of statement");
}
break;
}
//noinspection StatementWithEmptyBody
while (++cursor < length && isIdentifierPart(expr[cursor])) ;
if (cursor < length) {
skipWhitespace();
switch (expr[cursor]) {
case '[':
return COL;
case '(':
return METH;
default:
return BEAN;
}
}
return 0;
}
protected String capture() {
/**
* Trim off any whitespace.
*/
return new String(expr, start = trimRight(start), trimLeft(cursor) - start);
}
/**
* Skip to the next non-whitespace position.
*/
protected void whiteSpaceSkip() {
if (cursor < length)
//noinspection StatementWithEmptyBody
while (isWhitespace(expr[cursor]) && ++cursor != length) ;
}
/**
* @param c - character to scan to.
* @return - returns true is end of statement is hit, false if the scan scar is countered.
*/
protected boolean scanTo(char c) {
for (; cursor < length; cursor++) {
switch (expr[cursor]) {
case '\'':
case '"':
cursor = captureStringLiteral(expr[cursor], expr, cursor, expr.length);
default:
if (expr[cursor] == c) {
return false;
}
}
}
return true;
}
protected int findLastUnion() {
int split = -1;
int depth = 0;
for (int i = expr.length - 1; i != 0; i--) {
switch (expr[i]) {
case '}':
case ']':
depth++;
break;
case '{':
case '[':
if (--depth == 0) {
split = i;
collection = true;
}
break;
case '.':
if (depth == 0) {
split = i;
}
break;
}
if (split != -1) break;
}
return split;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/AccessorOptimizer.java 0000644 0001750 0001750 00000003422 11151132047 026361 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers;
import org.mvel2.ParserContext;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
public interface AccessorOptimizer {
public void init();
public Accessor optimizeAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean rootThisRef, Class ingressType);
public Accessor optimizeSetAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean rootThisRef, Object value, Class ingressType);
public Accessor optimizeCollection(ParserContext pCtx, Object collectionGraph, Class type, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory);
public Accessor optimizeObjectCreation(ParserContext pCtx, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory);
public Object getResultOptPass();
public Class getEgressType();
public boolean isLiteralOnly();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/OptimizerFactory.java 0000644 0001750 0001750 00000010247 11077457613 026251 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers;
import org.mvel2.CompileException;
import org.mvel2.optimizers.dynamic.DynamicOptimizer;
import org.mvel2.optimizers.impl.asm.ASMAccessorOptimizer;
import org.mvel2.optimizers.impl.refl.ReflectiveAccessorOptimizer;
import static java.lang.Thread.currentThread;
import java.util.HashMap;
import java.util.Map;
public class OptimizerFactory {
public static String DYNAMIC = "dynamic";
public static String SAFE_REFLECTIVE = "reflective";
private static String defaultOptimizer;
private static final Map accessorCompilers = new HashMap();
private static ThreadLocal> threadOptimizer
= new ThreadLocal>();
static {
accessorCompilers.put(SAFE_REFLECTIVE, new ReflectiveAccessorOptimizer());
accessorCompilers.put(DYNAMIC, new DynamicOptimizer());
/**
* By default, activate the JIT if ASM is present in the classpath
*/
try {
currentThread().getContextClassLoader().loadClass("org.mvel2.asm.ClassWriter");
accessorCompilers.put("ASM", new ASMAccessorOptimizer());
}
catch (ClassNotFoundException e) {
defaultOptimizer = SAFE_REFLECTIVE;
}
catch (Throwable e) {
e.printStackTrace();
System.err.println("[MVEL] Notice: Possible incorrect version of ASM present (3.0 required). " +
"Disabling JIT compiler. Reflective Optimizer will be used.");
defaultOptimizer = SAFE_REFLECTIVE;
}
if (Boolean.getBoolean("mvel2.disable.jit"))
setDefaultOptimizer(SAFE_REFLECTIVE);
else
setDefaultOptimizer(DYNAMIC);
}
public static AccessorOptimizer getDefaultAccessorCompiler() {
try {
return accessorCompilers.get(defaultOptimizer).getClass().newInstance();
}
catch (Exception e) {
throw new CompileException("unable to instantiate accessor compiler", e);
}
}
public static AccessorOptimizer getAccessorCompiler(String name) {
try {
return accessorCompilers.get(name).getClass().newInstance();
}
catch (Exception e) {
throw new CompileException("unable to instantiate accessor compiler", e);
}
}
public static AccessorOptimizer getThreadAccessorOptimizer() {
if (threadOptimizer.get() == null) {
threadOptimizer.set(getDefaultAccessorCompiler().getClass());
}
try {
return threadOptimizer.get().newInstance();
}
catch (Exception e) {
throw new CompileException("unable to instantiate accessor compiler", e);
}
}
public static void setThreadAccessorOptimizer(Class optimizer) {
if (optimizer == null) throw new RuntimeException("null optimizer");
threadOptimizer.set(optimizer);
}
public static void setDefaultOptimizer(String name) {
try {
//noinspection unchecked
AccessorOptimizer ao = accessorCompilers.get(defaultOptimizer = name);
ao.init();
setThreadAccessorOptimizer(ao.getClass());
}
catch (Exception e) {
throw new CompileException("unable to instantiate accessor compiler", e);
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/OptimizerHook.java 0000644 0001750 0001750 00000002677 11077457613 025552 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers;
import org.mvel2.compiler.Accessor;
/**
* @author Christopher Brock
*/
public interface OptimizerHook {
/**
* Should answer back whether or not this hook understands how to work with the current
* optimizer.
*
* @param optimizer - class type of the current optimizer being used
* @return boolean
*/
public boolean isOptimizerSupported(Class optimizer);
/**
* The optimizer should delegate back to the hook through this method, passing an instance of itself
* in the current state.
*
* @param optimizer - instance of optimizer
* @return boolean
*/
public Accessor generateAccessor(AccessorOptimizer optimizer);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/ 0000755 0001750 0001750 00000000000 11412747042 023020 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/ 0000755 0001750 0001750 00000000000 11412747044 023752 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/collection/ 0000755 0001750 0001750 00000000000 11412747044 026105 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/collection/MapCreator.java 0000644 0001750 0001750 00000003503 11073655510 031005 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.collection;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import java.util.HashMap;
import java.util.Map;
/**
* @author Christopher Brock
*/
public class MapCreator implements Accessor {
private Accessor[] keys;
private Accessor[] vals;
private int size;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
Map map = new HashMap(size * 2);
for (int i = size - 1; i != -1; i--) {
//noinspection unchecked
map.put(keys[i].getValue(ctx, elCtx, variableFactory), vals[i].getValue(ctx, elCtx, variableFactory));
}
return map;
}
public MapCreator(Accessor[] keys, Accessor[] vals) {
this.size = (this.keys = keys).length;
this.vals = vals;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
// not implemented
return null;
}
public Class getKnownEgressType() {
return Map.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/collection/ExprValueAccessor.java 0000644 0001750 0001750 00000005634 11222477143 032355 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.collection;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.Accessor;
import org.mvel2.compiler.ExecutableLiteral;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.getSubComponentType;
/**
* @author Christopher Brock
*/
public class ExprValueAccessor implements Accessor {
public ExecutableStatement stmt;
public ExprValueAccessor(String ex, Class expectedType, Object ctx, VariableResolverFactory factory, ParserContext pCtx) {
stmt = (ExecutableStatement) ParseTools.subCompileExpression(ex.toCharArray(), pCtx);
//if (expectedType.isArray()) {
Class tt = getSubComponentType(expectedType);
Class et = stmt.getKnownEgressType();
if (stmt.getKnownEgressType() != null && !tt.isAssignableFrom(et)) {
if ((stmt instanceof ExecutableLiteral) && canConvert(et, tt)) {
try {
stmt = new ExecutableLiteral(convert(stmt.getValue(ctx, factory), tt));
return;
}
catch (IllegalArgumentException e) {
// fall through;
}
}
if (pCtx != null && pCtx.isStrongTyping())
throw new CompileException("was expecting type: " + tt + "; but found type: " + (et == null ? "null" : et.getName()));
}
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
return stmt.getValue(elCtx, variableFactory);
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
// not implemented
return null;
}
public ExecutableStatement getStmt() {
return stmt;
}
public void setStmt(ExecutableStatement stmt) {
this.stmt = stmt;
}
public Class getKnownEgressType() {
return stmt.getKnownEgressType();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/collection/ArrayCreator.java 0000644 0001750 0001750 00000004202 11076220016 031333 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.collection;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Array;
import static java.lang.reflect.Array.newInstance;
/**
* @author Christopher Brock
*/
public class ArrayCreator implements Accessor {
public Accessor[] template;
private Class arrayType;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (Object.class.equals(arrayType)) {
Object[] newArray = new Object[template.length];
for (int i = 0; i < newArray.length; i++) {
newArray[i] = template[i].getValue(ctx, elCtx, variableFactory);
}
return newArray;
}
else {
Object newArray = newInstance(arrayType, template.length);
for (int i = 0; i < template.length; i++) {
Array.set(newArray, i, template[i].getValue(ctx, elCtx, variableFactory));
}
return newArray;
}
}
public ArrayCreator(Accessor[] template, Class arrayType) {
this.template = template;
this.arrayType = arrayType;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public Class getKnownEgressType() {
return arrayType;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/collection/ListCreator.java 0000644 0001750 0001750 00000003230 11073655510 031200 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.collection;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.FastList;
import java.util.List;
/**
* @author Christopher Brock
*/
public class ListCreator implements Accessor {
public Accessor[] values;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
Object[] template = new Object[values.length];
for (int i = 0; i < values.length; i++) {
template[i] = values[i].getValue(ctx, elCtx, variableFactory);
}
return new FastList(template);
}
public ListCreator(Accessor[] values) {
this.values = values;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public Class getKnownEgressType() {
return List.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/collection/MDArrayCreator.java 0000644 0001750 0001750 00000004346 11073655510 031575 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.collection;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Array;
import static java.lang.reflect.Array.newInstance;
/**
* @author Christopher Brock
*/
public class MDArrayCreator implements Accessor {
public Accessor[] template;
private Class arrayType;
private int dimension;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (Object.class.equals(arrayType)) {
Object[] newArray = new Object[template.length];
for (int i = 0; i < newArray.length; i++)
newArray[i] = template[i].getValue(ctx, elCtx, variableFactory);
return newArray;
}
else {
Object newArray = newInstance(arrayType, template.length);
for (int i = 0; i < template.length; i++) {
Object o = template[i].getValue(ctx, elCtx, variableFactory);
Array.set(newArray, i, o);
}
return newArray;
}
}
public MDArrayCreator(Accessor[] template, Class arrayType, int dimension) {
this.template = template;
this.arrayType = arrayType;
this.dimension = dimension;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public Class getKnownEgressType() {
return arrayType;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/ReflectiveAccessorOptimizer.java 0000644 0001750 0001750 00000130742 11371320442 032273 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.impl.refl;
import org.mvel2.*;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import static org.mvel2.MVEL.eval;
import org.mvel2.ast.Function;
import org.mvel2.ast.TypeDescriptor;
import static org.mvel2.ast.TypeDescriptor.getClassReference;
import org.mvel2.compiler.Accessor;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.compiler.PropertyVerifier;
import org.mvel2.integration.GlobalListenerFactory;
import static org.mvel2.integration.GlobalListenerFactory.*;
import org.mvel2.integration.PropertyHandler;
import static org.mvel2.integration.PropertyHandlerFactory.*;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AbstractOptimizer;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.impl.refl.collection.ArrayCreator;
import org.mvel2.optimizers.impl.refl.collection.ExprValueAccessor;
import org.mvel2.optimizers.impl.refl.collection.ListCreator;
import org.mvel2.optimizers.impl.refl.collection.MapCreator;
import org.mvel2.optimizers.impl.refl.nodes.*;
import org.mvel2.util.ArrayTools;
import static org.mvel2.util.CompilerTools.expectType;
import org.mvel2.util.MethodStub;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.*;
import static org.mvel2.util.PropertyTools.getFieldOrAccessor;
import static org.mvel2.util.PropertyTools.getFieldOrWriteAccessor;
import org.mvel2.util.StringAppender;
import static java.lang.Integer.parseInt;
import java.lang.reflect.*;
import static java.lang.reflect.Array.getLength;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
public class ReflectiveAccessorOptimizer extends AbstractOptimizer implements AccessorOptimizer {
private AccessorNode rootNode;
private AccessorNode currNode;
private Object ctx;
private Object thisRef;
private Object val;
private VariableResolverFactory variableFactory;
private static final int DONE = -1;
private static final Object[] EMPTYARG = new Object[0];
private static final Class[] EMPTYCLS = new Class[0];
private boolean first = true;
private boolean literal = false;
private static final Map REFLECTIVE_ACCESSOR_CACHE =
new WeakHashMap();
private Class ingressType;
private Class returnType;
public ReflectiveAccessorOptimizer() {
}
public void init() {
}
private ReflectiveAccessorOptimizer(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory variableFactory) {
this.pCtx = pCtx;
this.expr = property;
this.length = property != null ? property.length : 0;
this.ctx = ctx;
this.variableFactory = variableFactory;
this.thisRef = thisRef;
}
private static int createSignatureHash(String expr, Object ctx) {
if (ctx == null) {
return expr.hashCode();
}
else {
return expr.hashCode() + ctx.getClass().hashCode();
}
}
public static Object get(String expression, Object ctx) {
int hash = createSignatureHash(expression, ctx);
Accessor accessor = REFLECTIVE_ACCESSOR_CACHE.get(hash);
if (accessor != null) {
return accessor.getValue(ctx, null, null);
}
else {
REFLECTIVE_ACCESSOR_CACHE.put(hash, accessor = new ReflectiveAccessorOptimizer()
.optimizeAccessor(getCurrentThreadParserContext(),
expression.toCharArray(), ctx, null, null, false, null));
return accessor.getValue(ctx, null, null);
}
}
public Accessor optimizeAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean root, Class ingressType) {
this.rootNode = this.currNode = null;
this.start = this.cursor = 0;
this.first = true;
this.length = (this.expr = property).length;
this.ctx = ctx;
this.thisRef = thisRef;
this.variableFactory = factory;
this.ingressType = ingressType;
this.pCtx = pCtx;
return compileGetChain();
}
public Accessor optimizeSetAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean rootThisRef, Object value, Class ingressType) {
this.rootNode = this.currNode = null;
this.start = this.cursor = 0;
this.first = true;
this.length = (this.expr = property).length;
this.ctx = ctx;
this.thisRef = thisRef;
this.variableFactory = factory;
this.ingressType = ingressType;
char[] root = null;
int split = findLastUnion();
PropertyVerifier verifier = new PropertyVerifier(property, this.pCtx = pCtx);
if (split != -1) {
root = subset(property, 0, split++);
//todo: must use the property verifier.
property = subset(property, split, property.length - split);
}
if (root != null) {
this.length = (this.expr = root).length;
compileGetChain();
ctx = this.val;
}
if (ctx == null) {
throw new PropertyAccessException("could not access property: " + new String(property) + "; parent is null: " + new String(expr));
}
try {
this.length = (this.expr = property).length;
this.cursor = this.start = 0;
skipWhitespace();
if (collection) {
int start = cursor;
if (cursor == length)
throw new PropertyAccessException("unterminated '['");
if (scanTo(']'))
throw new PropertyAccessException("unterminated '['");
String ex = new String(property, start, cursor - start);
if (ctx instanceof Map) {
if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(Map.class)) {
propHandlerSet(ex, ctx, Map.class, value);
}
else {
//noinspection unchecked
((Map) ctx).put(eval(ex, ctx, variableFactory), convert(value, returnType = verifier.analyze()));
addAccessorNode(new MapAccessorNest(ex, returnType));
}
return rootNode;
}
else if (ctx instanceof List) {
if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(List.class)) {
propHandlerSet(ex, ctx, List.class, value);
}
else {
//noinspection unchecked
((List) ctx).set(eval(ex, ctx, variableFactory, Integer.class), convert(value, returnType = verifier.analyze()));
addAccessorNode(new ListAccessorNest(ex, returnType));
}
return rootNode;
}
else if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(ctx.getClass())) {
propHandlerSet(ex, ctx, ctx.getClass(), value);
return rootNode;
}
else if (ctx.getClass().isArray()) {
if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(Array.class)) {
propHandlerSet(ex, ctx, Array.class, value);
}
else {
//noinspection unchecked
Array.set(ctx, eval(ex, ctx, variableFactory, Integer.class), convert(value, getBaseComponentType(ctx.getClass())));
addAccessorNode(new ArrayAccessorNest(ex));
}
return rootNode;
}
else {
throw new PropertyAccessException("cannot bind to collection property: " + new String(property) +
": not a recognized collection type: " + ctx.getClass());
}
}
else if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(ctx.getClass())) {
propHandlerSet(new String(property), ctx, ctx.getClass(), value);
return rootNode;
}
String tk = new String(property);
if (hasSetListeners()) {
notifySetListeners(ctx, tk, variableFactory, value);
addAccessorNode(new Notify(tk));
}
Member member = getFieldOrWriteAccessor(ctx.getClass(), tk, value == null ? null : ingressType);
if (member instanceof Field) {
Field fld = (Field) member;
if (value != null && !fld.getType().isAssignableFrom(value.getClass())) {
if (!canConvert(fld.getType(), value.getClass())) {
throw new ConversionException("cannot convert type: "
+ value.getClass() + ": to " + fld.getType());
}
fld.set(ctx, convert(value, fld.getType()));
addAccessorNode(new DynamicFieldAccessor(fld));
}
else {
fld.set(ctx, value);
addAccessorNode(new FieldAccessor(fld));
}
}
else if (member != null) {
Method meth = (Method) member;
if (value != null && !meth.getParameterTypes()[0].isAssignableFrom(value.getClass())) {
if (!canConvert(meth.getParameterTypes()[0], value.getClass())) {
throw new ConversionException("cannot convert type: "
+ value.getClass() + ": to " + meth.getParameterTypes()[0]);
}
meth.invoke(ctx, convert(value, meth.getParameterTypes()[0]));
}
else {
meth.invoke(ctx, value);
}
addAccessorNode(new SetterAccessor(meth));
}
else if (ctx instanceof Map) {
//noinspection unchecked
((Map) ctx).put(tk, value);
addAccessorNode(new MapAccessor(tk));
}
else {
throw new PropertyAccessException("could not access property (" + tk + ") in: " + ingressType.getName());
}
}
catch (InvocationTargetException e) {
throw new PropertyAccessException("could not access property", e);
}
catch (IllegalAccessException e) {
throw new PropertyAccessException("could not access property", e);
}
return rootNode;
}
private Accessor compileGetChain() {
Object curr = ctx;
try {
if (!MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING) {
while (cursor < length) {
switch (nextSubToken()) {
case BEAN:
curr = getBeanProperty(curr, capture());
break;
case METH:
curr = getMethod(curr, capture());
break;
case COL:
curr = getCollectionProperty(curr, capture());
break;
case WITH:
curr = getWithProperty(curr);
break;
case DONE:
break;
}
first = false;
if (curr != null) returnType = curr.getClass();
if (nullSafe && cursor < length) {
if (curr == null) return null;
addAccessorNode(new NullSafe());
}
}
}
else {
while (cursor < length) {
switch (nextSubToken()) {
case BEAN:
curr = getBeanPropertyAO(curr, capture());
break;
case METH:
curr = getMethod(curr, capture());
break;
case COL:
curr = getCollectionPropertyAO(curr, capture());
break;
case WITH:
curr = getWithProperty(curr);
break;
case DONE:
break;
}
first = false;
if (curr != null) returnType = curr.getClass();
if (nullSafe && cursor < length) {
if (curr == null) return null;
addAccessorNode(new NullSafe());
}
}
}
val = curr;
if (pCtx.isStrictTypeEnforcement()) {
this.returnType = new PropertyVerifier(this.expr, pCtx).analyze();
}
return rootNode;
}
catch (InvocationTargetException e) {
throw new PropertyAccessException(new String(expr) + ": " + e.getTargetException().getMessage(), e);
}
catch (IllegalAccessException e) {
throw new PropertyAccessException(new String(expr) + ": " + e.getMessage(), e);
}
catch (IndexOutOfBoundsException e) {
throw new PropertyAccessException(new String(expr) + ": array index out of bounds.", e);
}
catch (CompileException e) {
throw e;
}
catch (NullPointerException e) {
throw new PropertyAccessException(new String(expr), e);
}
catch (Exception e) {
throw new CompileException(e.getMessage(), e);
}
}
private void addAccessorNode(AccessorNode an) {
if (rootNode == null)
rootNode = currNode = an;
else {
currNode = currNode.setNextNode(an);
}
}
private Object getWithProperty(Object ctx) {
String root = new String(expr, 0, cursor - 1).trim();
int start = cursor + 1;
cursor = balancedCaptureWithLineAccounting(expr, cursor, '{', pCtx);
WithAccessor wa = new WithAccessor(root, subset(expr, start, cursor++ - start), ingressType, false);
addAccessorNode(wa);
return wa.getValue(ctx, thisRef, variableFactory);
}
private Object getBeanPropertyAO(Object ctx, String property)
throws Exception {
if (GlobalListenerFactory.hasGetListeners()) {
notifyGetListeners(ctx, property, variableFactory);
addAccessorNode(new Notify(property));
}
if (ctx != null && hasPropertyHandler(ctx.getClass())) return propHandler(property, ctx, ctx.getClass());
return getBeanProperty(ctx, property);
}
private Object getBeanProperty(Object ctx, String property) throws Exception {
if ((currType = !first || pCtx == null ? null : pCtx.getVarOrInputTypeOrNull(property)) == Object.class
&& !pCtx.isStrongTyping()) {
currType = null;
}
if (first) {
if ("this".equals(property)) {
addAccessorNode(new ThisValueAccessor());
return this.thisRef;
}
else if (variableFactory != null && variableFactory.isResolveable(property)) {
if (variableFactory.isIndexedFactory() && variableFactory.isTarget(property)) {
int idx;
addAccessorNode(new IndexedVariableAccessor(idx = variableFactory.variableIndexOf(property)));
VariableResolver vr = variableFactory.getIndexedVariableResolver(idx);
if (vr == null) {
variableFactory.setIndexedVariableResolver(idx, variableFactory.getVariableResolver(property));
}
return variableFactory.getIndexedVariableResolver(idx).getValue();
}
else {
addAccessorNode(new VariableAccessor(property));
return variableFactory.getVariableResolver(property).getValue();
}
}
}
//noinspection unchecked
Class cls = (ctx instanceof Class ? ((Class) ctx) : ctx != null ? ctx.getClass() : null);
if (hasPropertyHandler(cls)) {
PropertyHandlerAccessor acc = new PropertyHandlerAccessor(property, cls, getPropertyHandler(cls));
addAccessorNode(acc);
return acc.getValue(ctx, thisRef, variableFactory);
}
Member member = cls != null ? getFieldOrAccessor(cls, property) : null;
Object o;
if (member instanceof Method) {
try {
o = ((Method) member).invoke(ctx, EMPTYARG);
if (hasNullPropertyHandler()) {
addAccessorNode(new GetterAccessorNH((Method) member, getNullPropertyHandler()));
if (o == null) o = getNullPropertyHandler().getProperty(member.getName(), ctx, variableFactory);
}
else {
addAccessorNode(new GetterAccessor((Method) member));
}
}
catch (IllegalAccessException e) {
Method iFaceMeth = determineActualTargetMethod((Method) member);
if (iFaceMeth == null)
throw new PropertyAccessException("could not access field: " + cls.getName() + "." + property);
o = iFaceMeth.invoke(ctx, EMPTYARG);
if (hasNullPropertyHandler()) {
addAccessorNode(new GetterAccessorNH((Method) member, getNullMethodHandler()));
if (o == null) o = getNullMethodHandler().getProperty(member.getName(), ctx, variableFactory);
}
else {
addAccessorNode(new GetterAccessor(iFaceMeth));
}
}
return o;
}
else if (member != null) {
Field f = (Field) member;
if ((f.getModifiers() & Modifier.STATIC) != 0) {
o = f.get(null);
if (hasNullPropertyHandler()) {
addAccessorNode(new StaticVarAccessorNH((Field) member, getNullMethodHandler()));
if (o == null) o = getNullMethodHandler().getProperty(member.getName(), ctx, variableFactory);
}
else {
addAccessorNode(new StaticVarAccessor((Field) member));
}
}
else {
o = f.get(ctx);
if (hasNullPropertyHandler()) {
addAccessorNode(new FieldAccessorNH((Field) member, getNullMethodHandler()));
if (o == null) o = getNullMethodHandler().getProperty(member.getName(), ctx, variableFactory);
}
else {
addAccessorNode(new FieldAccessor((Field) member));
}
}
return o;
}
else if (ctx instanceof Map && (((Map) ctx).containsKey(property) || nullSafe)) {
addAccessorNode(new MapAccessor(property));
return ((Map) ctx).get(property);
}
else if (ctx != null && "length".equals(property) && ctx.getClass().isArray()) {
addAccessorNode(new ArrayLength());
return getLength(ctx);
}
else if (LITERALS.containsKey(property)) {
addAccessorNode(new StaticReferenceAccessor(ctx = LITERALS.get(property)));
return ctx;
}
else {
Object tryStaticMethodRef = tryStaticAccess();
if (tryStaticMethodRef != null) {
if (tryStaticMethodRef instanceof Class) {
addAccessorNode(new StaticReferenceAccessor(tryStaticMethodRef));
return tryStaticMethodRef;
}
else if (tryStaticMethodRef instanceof Field) {
addAccessorNode(new StaticVarAccessor((Field) tryStaticMethodRef));
return ((Field) tryStaticMethodRef).get(null);
}
else {
addAccessorNode(new StaticReferenceAccessor(tryStaticMethodRef));
return tryStaticMethodRef;
}
}
else if (ctx instanceof Class) {
Class c = (Class) ctx;
for (Method m : c.getMethods()) {
if (property.equals(m.getName())) {
if (MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL) {
o = m.invoke(null, EMPTY_OBJ_ARR);
if (hasNullMethodHandler()) {
addAccessorNode(new MethodAccessorNH(m, new ExecutableStatement[0], getNullMethodHandler()));
if (o == null)
o = getNullMethodHandler().getProperty(m.getName(), ctx, variableFactory);
}
else {
addAccessorNode(new MethodAccessor(m, new ExecutableStatement[0]));
}
return o;
}
else {
addAccessorNode(new StaticReferenceAccessor(m));
return m;
}
}
}
try {
Class subClass = findClass(variableFactory, c.getName() + "$" + property, pCtx);
addAccessorNode(new StaticReferenceAccessor(subClass));
return subClass;
}
catch (ClassNotFoundException cnfe) {
// fall through.
}
}
else if (MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL) {
return getMethod(ctx, property);
}
throw new PropertyAccessException("could not access: " + property + "; in class: " + (ctx == null ? "null" : ctx.getClass().getName()));
}
}
/**
* Handle accessing a property embedded in a collections, map, or array
*
* @param ctx -
* @param prop -
* @return -
* @throws Exception -
*/
private Object getCollectionProperty(Object ctx, String prop) throws Exception {
if (prop.length() > 0) {
ctx = getBeanProperty(ctx, prop);
}
int start = ++cursor;
skipWhitespace();
if (cursor == length)
throw new CompileException("unterminated '['");
String item;
if (scanTo(']'))
throw new CompileException("unterminated '['");
item = new String(expr, start, cursor - start);
boolean itemSubExpr = true;
Object idx = null;
try {
idx = parseInt(item);
itemSubExpr = false;
}
catch (Exception e) {
// not a number;
}
ExecutableStatement itemStmt = null;
if (itemSubExpr) {
idx = (itemStmt = (ExecutableStatement) subCompileExpression(item.toCharArray(), pCtx)).getValue(ctx, thisRef, variableFactory);
}
++cursor;
if (ctx instanceof Map) {
if (itemSubExpr) {
addAccessorNode(new MapAccessorNest(itemStmt, null));
}
else {
addAccessorNode(new MapAccessor(parseInt(item)));
}
return ((Map) ctx).get(idx);
}
else if (ctx instanceof List) {
if (itemSubExpr) {
addAccessorNode(new ListAccessorNest(itemStmt, null));
}
else {
addAccessorNode(new ListAccessor(parseInt(item)));
}
return ((List) ctx).get((Integer) idx);
}
else if (ctx.getClass().isArray()) {
if (itemSubExpr) {
addAccessorNode(new ArrayAccessorNest(itemStmt));
}
else {
addAccessorNode(new ArrayAccessor(parseInt(item)));
}
return Array.get(ctx, (Integer) idx);
}
else if (ctx instanceof CharSequence) {
if (itemSubExpr) {
addAccessorNode(new IndexedCharSeqAccessorNest(itemStmt));
}
else {
addAccessorNode(new IndexedCharSeqAccessor(parseInt(item)));
}
return ((CharSequence) ctx).charAt((Integer) idx);
}
else {
TypeDescriptor tDescr = new TypeDescriptor(expr, 0);
if (tDescr.isArray()) {
Class cls = getClassReference((Class) ctx, tDescr, variableFactory, pCtx);
rootNode = new StaticReferenceAccessor(cls);
return cls;
}
throw new CompileException("illegal use of []: unknown type: "
+ ctx.getClass().getName());
}
}
private Object getCollectionPropertyAO(Object ctx, String prop) throws Exception {
if (prop.length() > 0) {
ctx = getBeanPropertyAO(ctx, prop);
}
int start = ++cursor;
skipWhitespace();
if (cursor == length)
throw new CompileException("unterminated '['");
String item;
if (scanTo(']'))
throw new CompileException("unterminated '['");
item = new String(expr, start, cursor - start);
boolean itemSubExpr = true;
Object idx = null;
try {
idx = parseInt(item);
itemSubExpr = false;
}
catch (Exception e) {
// not a number;
}
ExecutableStatement itemStmt = null;
if (itemSubExpr) {
idx = (itemStmt = (ExecutableStatement) subCompileExpression(item.toCharArray(), pCtx)).getValue(ctx, thisRef, variableFactory);
}
++cursor;
if (ctx instanceof Map) {
if (hasPropertyHandler(Map.class)) {
return propHandler(item, ctx, Map.class);
}
else {
if (itemSubExpr) {
addAccessorNode(new MapAccessorNest(itemStmt, null));
}
else {
addAccessorNode(new MapAccessor(parseInt(item)));
}
return ((Map) ctx).get(idx);
}
}
else if (ctx instanceof List) {
if (hasPropertyHandler(List.class)) {
return propHandler(item, ctx, List.class);
}
else {
if (itemSubExpr) {
addAccessorNode(new ListAccessorNest(itemStmt, null));
}
else {
addAccessorNode(new ListAccessor(parseInt(item)));
}
return ((List) ctx).get((Integer) idx);
}
}
else if (ctx.getClass().isArray()) {
if (hasPropertyHandler(Array.class)) {
return propHandler(item, ctx, Array.class);
}
else {
if (itemSubExpr) {
addAccessorNode(new ArrayAccessorNest(itemStmt));
}
else {
addAccessorNode(new ArrayAccessor(parseInt(item)));
}
return Array.get(ctx, (Integer) idx);
}
}
else if (ctx instanceof CharSequence) {
if (hasPropertyHandler(CharSequence.class)) {
return propHandler(item, ctx, CharSequence.class);
}
else {
if (itemSubExpr) {
addAccessorNode(new IndexedCharSeqAccessorNest(itemStmt));
}
else {
addAccessorNode(new IndexedCharSeqAccessor(parseInt(item)));
}
return ((CharSequence) ctx).charAt((Integer) idx);
}
}
else {
TypeDescriptor tDescr = new TypeDescriptor(expr, 0);
if (tDescr.isArray()) {
Class cls = getClassReference((Class) ctx, tDescr, variableFactory, pCtx);
rootNode = new StaticReferenceAccessor(cls);
return cls;
}
throw new CompileException("illegal use of []: unknown type: "
+ ctx.getClass().getName());
}
}
/**
* Find an appropriate method, execute it, and return it's response.
*
* @param ctx -
* @param name -
* @return -
* @throws Exception -
*/
@SuppressWarnings({"unchecked"})
private Object getMethod(Object ctx, String name) throws Exception {
int st = cursor;
String tk = cursor != length
&& expr[cursor] == '(' && ((cursor = balancedCapture(expr, cursor, '(')) - st) > 1 ?
new String(expr, st + 1, cursor - st - 1) : "";
cursor++;
Object[] args;
Class[] argTypes;
Accessor[] es;
if (tk.length() == 0) {
args = ParseTools.EMPTY_OBJ_ARR;
argTypes = ParseTools.EMPTY_CLS_ARR;
es = null;
}
else {
String[] subtokens = parseParameterList(tk.toCharArray(), 0, -1);
es = new ExecutableStatement[subtokens.length];
args = new Object[subtokens.length];
argTypes = new Class[subtokens.length];
for (int i = 0; i < subtokens.length; i++) {
args[i] = (es[i] = (ExecutableStatement) subCompileExpression(subtokens[i].toCharArray(), pCtx))
.getValue(this.ctx, thisRef, variableFactory);
}
if (pCtx.isStrictTypeEnforcement()) {
for (int i = 0; i < args.length; i++) {
argTypes[i] = es[i].getKnownEgressType();
}
}
else {
for (int i = 0; i < args.length; i++) {
if (es[i].getKnownEgressType() == Object.class) {
argTypes[i] = args[i] == null ? null : args[i].getClass();
}
else {
argTypes[i] = es[i].getKnownEgressType();
}
}
}
}
if (first && variableFactory != null && variableFactory.isResolveable(name)) {
Object ptr = variableFactory.getVariableResolver(name).getValue();
if (ptr instanceof Method) {
ctx = ((Method) ptr).getDeclaringClass();
name = ((Method) ptr).getName();
}
else if (ptr instanceof MethodStub) {
ctx = ((MethodStub) ptr).getClassReference();
name = ((MethodStub) ptr).getMethodName();
}
else if (ptr instanceof Function) {
Function func = (Function) ptr;
if (!name.equals(func.getName())) {
getBeanProperty(ctx, name);
addAccessorNode(new DynamicFunctionAccessor(es));
}
else {
addAccessorNode(new FunctionAccessor((Function) ptr, es));
}
return ((Function) ptr).call(ctx, thisRef, variableFactory, args);
}
else {
throw new OptimizationFailure("attempt to optimize a method call for a reference that does not point to a method: "
+ name + " (reference is type: " + (ctx != null ? ctx.getClass().getName() : null) + ")");
}
first = false;
}
if (ctx == null) {
throw new PropertyAccessException("unable to access property (null parent): " + name);
}
/**
* If the target object is an instance of java.lang.Class itself then do not
* adjust the Class scope target.
*/
Class cls = currType != null ? currType : (ctx instanceof Class ? (Class) ctx : ctx.getClass());
currType = null;
Method m;
Class[] parameterTypes = null;
/**
* If we have not cached the method then we need to go ahead and try to resolve it.
*/
/**
* Try to find an instance method from the class target.
*/
if ((m = getBestCandidate(argTypes, name, cls, cls.getMethods(), false)) != null) {
parameterTypes = m.getParameterTypes();
}
if (m == null) {
/**
* If we didn't find anything, maybe we're looking for the actual java.lang.Class methods.
*/
if ((m = getBestCandidate(argTypes, name, cls, cls.getClass().getDeclaredMethods(), false)) != null) {
parameterTypes = m.getParameterTypes();
}
}
if (m == null) {
StringAppender errorBuild = new StringAppender();
if ("size".equals(name) && args.length == 0 && cls.isArray()) {
addAccessorNode(new ArrayLength());
return getLength(ctx);
}
for (int i = 0; i < args.length; i++) {
errorBuild.append(args[i] != null ? args[i].getClass().getName() : null);
if (i < args.length - 1) errorBuild.append(", ");
}
throw new PropertyAccessException("unable to resolve method: " + cls.getName() + "."
+ name + "(" + errorBuild.toString() + ") [arglength=" + args.length + "]");
}
else {
if (es != null) {
ExecutableStatement cExpr;
for (int i = 0; i < es.length; i++) {
cExpr = (ExecutableStatement) es[i];
if (cExpr.getKnownIngressType() == null) {
cExpr.setKnownIngressType(parameterTypes[i]);
cExpr.computeTypeConversionRule();
}
if (!cExpr.isConvertableIngressEgress()) {
args[i] = convert(args[i], parameterTypes[i]);
}
}
}
else {
/**
* Coerce any types if required.
*/
for (int i = 0; i < args.length; i++)
args[i] = convert(args[i], parameterTypes[i]);
}
Object o = getWidenedTarget(m).invoke(ctx, args);
if (hasNullMethodHandler()) {
addAccessorNode(new MethodAccessorNH(getWidenedTarget(m), (ExecutableStatement[]) es, getNullMethodHandler()));
if (o == null) o = getNullMethodHandler().getProperty(m.getName(), ctx, variableFactory);
}
else {
addAccessorNode(new MethodAccessor(getWidenedTarget(m), (ExecutableStatement[]) es));
}
/**
* return the response.
*/
return o;
}
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) throws Exception {
return rootNode.getValue(ctx, elCtx, variableFactory);
}
private Accessor _getAccessor(Object o, Class type) {
if (o instanceof List) {
Accessor[] a = new Accessor[((List) o).size()];
int i = 0;
for (Object item : (List) o) {
a[i++] = _getAccessor(item, type);
}
returnType = List.class;
return new ListCreator(a);
}
else if (o instanceof Map) {
Accessor[] k = new Accessor[((Map) o).size()];
Accessor[] v = new Accessor[k.length];
int i = 0;
for (Object item : ((Map) o).keySet()) {
k[i] = _getAccessor(item, type); // key
v[i++] = _getAccessor(((Map) o).get(item), type); // value
}
returnType = Map.class;
return new MapCreator(k, v);
}
else if (o instanceof Object[]) {
Accessor[] a = new Accessor[((Object[]) o).length];
int i = 0;
int dim = 0;
if (type != null) {
String nm = type.getName();
while (nm.charAt(dim) == '[') dim++;
}
else {
type = Object[].class;
dim = 1;
}
try {
Class base = getBaseComponentType(type);
Class cls = dim > 1 ? findClass(null, repeatChar('[', dim - 1) + "L" + base.getName() + ";", pCtx)
: type;
for (Object item : (Object[]) o) {
expectType(a[i++] = _getAccessor(item, cls), base, true);
}
return new ArrayCreator(a, getSubComponentType(type));
}
catch (ClassNotFoundException e) {
throw new RuntimeException("this error should never throw:" + getBaseComponentType(type).getName(), e);
}
}
else {
if (returnType == null) returnType = Object.class;
if (type.isArray()) {
return new ExprValueAccessor((String) o, type, ctx, variableFactory, pCtx);
}
else {
return new ExprValueAccessor((String) o, Object.class, ctx, variableFactory, pCtx);
}
}
}
public Accessor optimizeCollection(ParserContext pCtx, Object o, Class type, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory) {
this.returnType = type;
this.ctx = ctx;
this.variableFactory = factory;
this.pCtx = pCtx;
Accessor root = _getAccessor(o, returnType);
if (property != null && property.length > 0) {
return new Union(root, property);
}
else {
return root;
}
}
public Accessor optimizeObjectCreation(ParserContext pCtx, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory) {
this.length = (this.expr = property).length;
this.cursor = 0;
this.pCtx = pCtx;
try {
return compileConstructor(property, ctx, factory);
}
catch (CompileException e) {
throw e;
}
catch (Exception e) {
throw new CompileException("could not create constructor: " + e.getMessage(), e);
}
}
private void setRootNode(AccessorNode rootNode) {
this.rootNode = this.currNode = rootNode;
}
private AccessorNode getRootNode() {
return rootNode;
}
public Object getResultOptPass() {
return val;
}
@SuppressWarnings({"WeakerAccess"})
public AccessorNode compileConstructor(char[] expression, Object ctx, VariableResolverFactory vars) throws
InstantiationException, IllegalAccessException, InvocationTargetException,
ClassNotFoundException, NoSuchMethodException {
String[] cnsRes = captureContructorAndResidual(expression);
String[] constructorParms = parseMethodOrConstructor(cnsRes[0].toCharArray());
if (constructorParms != null) {
String s = new String(subset(expression, 0, ArrayTools.findFirst('(', expression)));
Class cls = ParseTools.findClass(vars, s, pCtx);
ExecutableStatement[] cStmts = new ExecutableStatement[constructorParms.length];
for (int i = 0; i < constructorParms.length; i++) {
cStmts[i] = (ExecutableStatement) subCompileExpression(constructorParms[i].toCharArray(), pCtx);
}
Object[] parms = new Object[constructorParms.length];
for (int i = 0; i < constructorParms.length; i++) {
parms[i] = cStmts[i].getValue(ctx, vars);
}
Constructor cns = getBestConstructorCandidate(parms, cls, pCtx.isStrongTyping());
if (cns == null) {
StringBuilder error = new StringBuilder();
for (int i = 0; i < parms.length; i++) {
error.append(parms[i].getClass().getName());
if (i + 1 < parms.length) error.append(", ");
}
throw new CompileException("unable to find constructor: " + cls.getName() + "(" + error.toString() + ")");
}
for (int i = 0; i < parms.length; i++) {
//noinspection unchecked
parms[i] = convert(parms[i], cns.getParameterTypes()[i]);
}
AccessorNode ca = new ConstructorAccessor(cns, cStmts);
if (cnsRes.length > 1) {
ReflectiveAccessorOptimizer compiledOptimizer
= new ReflectiveAccessorOptimizer(pCtx, cnsRes[1].toCharArray(), cns.newInstance(parms), ctx, vars);
compiledOptimizer.ingressType = cns.getDeclaringClass();
compiledOptimizer.setRootNode(ca);
compiledOptimizer.compileGetChain();
ca = compiledOptimizer.getRootNode();
this.val = compiledOptimizer.getResultOptPass();
}
return ca;
}
else {
Constructor cns = Class.forName(new String(expression), true, Thread.currentThread().getContextClassLoader())
.getConstructor(EMPTYCLS);
AccessorNode ca = new ConstructorAccessor(cns, null);
if (cnsRes.length > 1) {
//noinspection NullArgumentToVariableArgMethod
ReflectiveAccessorOptimizer compiledOptimizer
= new ReflectiveAccessorOptimizer(getCurrentThreadParserContext(),
cnsRes[1].toCharArray(), cns.newInstance(null), ctx, vars);
compiledOptimizer.setRootNode(ca);
compiledOptimizer.compileGetChain();
ca = compiledOptimizer.getRootNode();
this.val = compiledOptimizer.getResultOptPass();
}
return ca;
}
}
public Class getEgressType() {
return returnType;
}
public boolean isLiteralOnly() {
return literal;
}
private Object propHandler(String property, Object ctx, Class handler) {
PropertyHandler ph = getPropertyHandler(handler);
addAccessorNode(new PropertyHandlerAccessor(property, handler, ph));
return ph.getProperty(property, ctx, variableFactory);
}
public void propHandlerSet(String property, Object ctx, Class handler, Object value) {
PropertyHandler ph = getPropertyHandler(handler);
addAccessorNode(new PropertyHandlerAccessor(property, handler, ph));
ph.setProperty(property, ctx, variableFactory, value);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ 0000755 0001750 0001750 00000000000 11412747043 025061 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ArrayLength.java 0000644 0001750 0001750 00000002707 11077457613 030162 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.integration.VariableResolverFactory;
import static java.lang.reflect.Array.getLength;
/**
* @author Christopher Brock
*/
public class ArrayLength extends BaseAccessor {
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (nextNode != null) {
return nextNode.getValue(getLength(ctx), elCtx, variableFactory);
}
else {
return getLength(ctx);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public Class getKnownEgressType() {
return Integer.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ArrayAccessor.java 0000644 0001750 0001750 00000004217 11077457613 030501 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Array;
public class ArrayAccessor implements AccessorNode {
private AccessorNode nextNode;
private int index;
public ArrayAccessor() {
}
public ArrayAccessor(int index) {
this.index = index;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(Array.get(ctx, index), elCtx, vars);
}
else {
return Array.get(ctx, index);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (nextNode != null) {
return nextNode.setValue(Array.get(ctx, index), elCtx, variableFactory, value);
}
else {
Array.set(ctx, index, value);
return value;
}
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return Object[].class;
}
public String toString() {
return "Array Accessor -> [" + index + "]";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/FunctionAccessor.java 0000644 0001750 0001750 00000003766 11131071777 031212 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.ast.Function;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
public class FunctionAccessor extends BaseAccessor {
private Function function;
private Accessor[] parameters;
public FunctionAccessor(Function function, Accessor[] parms) {
this.function = function;
this.parameters = parms;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
Object[] parms = null;
if (parameters != null && parameters.length != 0) {
parms = new Object[parameters.length];
for (int i = 0; i < parms.length; i++) {
parms[i] = parameters[i].getValue(ctx, elCtx, variableFactory);
}
}
if (nextNode != null) {
return nextNode.getValue(function.call(ctx, elCtx, variableFactory, parms), elCtx, variableFactory);
}
else {
return function.call(ctx, elCtx, variableFactory, parms);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
throw new RuntimeException("can't write to function");
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/MethodAccessor.java 0000644 0001750 0001750 00000017627 11223436064 030642 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.getBestCandidate;
import static org.mvel2.util.ParseTools.getWidenedTarget;
import java.lang.reflect.Method;
public class MethodAccessor implements AccessorNode {
private AccessorNode nextNode;
private Method method;
private Class[] parameterTypes;
private ExecutableStatement[] parms;
private int length;
private boolean coercionNeeded = false;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (!coercionNeeded) {
try {
if (nextNode != null) {
return nextNode.getValue(method.invoke(ctx, executeAll(elCtx, vars)), elCtx, vars);
}
else {
return method.invoke(ctx, executeAll(elCtx, vars));
}
}
catch (IllegalArgumentException e) {
if (ctx != null && method.getDeclaringClass() != ctx.getClass()) {
Method o = getBestCandidate(parameterTypes, method.getName(), ctx.getClass(), ctx.getClass().getMethods(), true);
if (o != null) {
return executeOverrideTarget(getWidenedTarget(o), ctx, elCtx, vars);
}
}
coercionNeeded = true;
return getValue(ctx, elCtx, vars);
}
catch (Exception e) {
throw new CompileException("cannot invoke method: " + method.getName(), e);
}
}
else {
try {
if (nextNode != null) {
return nextNode.getValue(method.invoke(ctx, executeAndCoerce(parameterTypes, elCtx, vars)), elCtx, vars);
}
else {
return method.invoke(ctx, executeAndCoerce(parameterTypes, elCtx, vars));
}
}
catch (IllegalArgumentException e) {
Object[] vs = executeAndCoerce(parameterTypes, elCtx, vars);
Method newMeth;
if ((newMeth = getWidenedTarget(getBestCandidate(vs, method.getName(), ctx.getClass(),
ctx.getClass().getMethods(), false))) != null) {
return executeOverrideTarget(newMeth, ctx, elCtx, vars);
}
else {
throw e;
}
}
catch (Exception e) {
throw new CompileException("cannot invoke method: " + method.getName(), e);
}
}
}
private Object executeOverrideTarget(Method o, Object ctx, Object elCtx, VariableResolverFactory vars) {
if (!coercionNeeded) {
try {
try {
if (nextNode != null) {
return nextNode.getValue(o.invoke(ctx, executeAll(elCtx, vars)), elCtx, vars);
}
else {
return o.invoke(ctx, executeAll(elCtx, vars));
}
}
catch (IllegalArgumentException e) {
if (coercionNeeded) throw e;
coercionNeeded = true;
return executeOverrideTarget(o, ctx, elCtx, vars);
}
}
catch (Exception e2) {
throw new CompileException("unable to invoke method", e2);
}
}
else {
try {
if (nextNode != null) {
return nextNode.getValue(o.invoke(ctx, executeAndCoerce(o.getParameterTypes(), elCtx, vars)), elCtx, vars);
}
else {
return o.invoke(ctx, executeAndCoerce(o.getParameterTypes(), elCtx, vars));
}
}
catch (IllegalAccessException e) {
throw new CompileException("unable to invoke method (expected target: " + method.getDeclaringClass().getName() + "::" + method.getName() + "; " +
"actual target: " + ctx.getClass().getName() + "::" + method.getName() + "; coercionNeeded=" + (coercionNeeded ? "yes" : "no") + ")");
}
catch (Exception e2) {
throw new CompileException("unable to invoke method (expected target: " + method.getDeclaringClass().getName() + "::" + method.getName() + "; " +
"actual target: " + ctx.getClass().getName() + "::" + method.getName() + "; coercionNeeded=" + (coercionNeeded ? "yes" : "no") + ")");
}
}
}
private Object[] executeAll(Object ctx, VariableResolverFactory vars) {
if (length == 0) return GetterAccessor.EMPTY;
Object[] vals = new Object[length];
for (int i = 0; i < length; i++) {
vals[i] = parms[i].getValue(ctx, vars);
}
return vals;
}
private Object[] executeAndCoerce(Class[] target, Object elCtx, VariableResolverFactory vars) {
Object[] values = new Object[length];
for (int i = 0; i < length; i++) {
//noinspection unchecked
values[i] = convert(parms[i].getValue(elCtx, vars), target[i]);
}
return values;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
this.length = (this.parameterTypes = this.method.getParameterTypes()).length;
}
public ExecutableStatement[] getParms() {
return parms;
}
public void setParms(ExecutableStatement[] parms) {
this.parms = parms;
}
public MethodAccessor() {
}
public MethodAccessor(Method method, ExecutableStatement[] parms) {
this.method = method;
this.length = (this.parameterTypes = this.method.getParameterTypes()).length;
this.parms = parms;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
return nextNode.setValue(method.invoke(ctx, executeAll(elCtx, variableFactory)), elCtx, variableFactory, value);
}
catch (IllegalArgumentException e) {
if (ctx != null && method.getDeclaringClass() != ctx.getClass()) {
Method o = getBestCandidate(parameterTypes, method.getName(), ctx.getClass(), ctx.getClass().getMethods(), true);
if (o != null) {
return nextNode.setValue(executeOverrideTarget(o, ctx, elCtx, variableFactory), elCtx, variableFactory, value);
}
}
coercionNeeded = true;
return setValue(ctx, elCtx, variableFactory, value);
}
catch (Exception e) {
throw new CompileException("cannot invoke method", e);
}
}
public Class getKnownEgressType() {
return method.getReturnType();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/IndexedCharSeqAccessor.java 0000644 0001750 0001750 00000004025 11123077476 032244 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
public class IndexedCharSeqAccessor implements AccessorNode {
private AccessorNode nextNode;
private int index;
public IndexedCharSeqAccessor() {
}
public IndexedCharSeqAccessor(int index) {
this.index = index;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(((String) ctx).charAt(index), elCtx, vars);
}
else {
return ((String) ctx).charAt(index);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return nextNode.setValue(((String) ctx).charAt(index), elCtx, variableFactory, value);
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public String toString() {
return "Array Accessor -> [" + index + "]";
}
public Class getKnownEgressType() {
return Character.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ConstructorAccessor.java 0000644 0001750 0001750 00000007140 11077457613 031746 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Constructor;
public class ConstructorAccessor extends BaseAccessor {
private Constructor constructor;
private Class[] parmTypes;
private ExecutableStatement[] parms;
private int length;
private boolean coercionNeeded = false;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
try {
if (!coercionNeeded) {
try {
if (nextNode != null) {
return nextNode.getValue(constructor.newInstance(executeAll(elCtx, variableFactory)), elCtx, variableFactory);
}
else {
return constructor.newInstance(executeAll(elCtx, variableFactory));
}
}
catch (IllegalArgumentException e) {
coercionNeeded = true;
return getValue(ctx, elCtx, variableFactory);
}
}
else {
if (nextNode != null) {
return nextNode.getValue(constructor.newInstance(executeAndCoerce(parmTypes, elCtx, variableFactory)),
elCtx, variableFactory);
}
else {
return constructor.newInstance(executeAndCoerce(parmTypes, elCtx, variableFactory));
}
}
}
catch (Exception e) {
throw new CompileException("cannot construct object", e);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
private Object[] executeAll(Object ctx, VariableResolverFactory vars) {
if (length == 0) return GetterAccessor.EMPTY;
Object[] vals = new Object[length];
for (int i = 0; i < length; i++) {
vals[i] = parms[i].getValue(ctx, vars);
}
return vals;
}
private Object[] executeAndCoerce(Class[] target, Object elCtx, VariableResolverFactory vars) {
Object[] values = new Object[length];
for (int i = 0; i < length; i++) {
//noinspection unchecked
values[i] = convert(parms[i].getValue(elCtx, vars), target[i]);
}
return values;
}
public ConstructorAccessor(Constructor constructor, ExecutableStatement[] parms) {
this.constructor = constructor;
this.length = (this.parmTypes = constructor.getParameterTypes()).length;
this.parms = parms;
}
public Class getKnownEgressType() {
return constructor.getClass();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/GetterAccessor.java 0000644 0001750 0001750 00000012035 11313753100 030631 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.MVEL.getProperty;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ReflectionUtil;
import static org.mvel2.util.ParseTools.getBestCandidate;
import static org.mvel2.util.ReflectionUtil.getPropertyFromAccessor;
import java.lang.reflect.Method;
public class GetterAccessor implements AccessorNode {
private AccessorNode nextNode;
private final Method method;
public static final Object[] EMPTY = new Object[0];
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
if (nextNode != null) {
return nextNode.getValue(method.invoke(ctx, EMPTY), elCtx, vars);
}
else {
return method.invoke(ctx, EMPTY);
}
}
catch (IllegalArgumentException e) {
if (ctx != null && method.getDeclaringClass() != ctx.getClass()) {
Method o = getBestCandidate(EMPTY, method.getName(), ctx.getClass(), ctx.getClass().getMethods(), true);
if (o != null) {
return executeOverrideTarget(o, ctx, elCtx, vars);
}
}
/**
* HACK: Try to access this another way.
*/
if (nextNode != null) {
return nextNode.getValue(getProperty(getPropertyFromAccessor(method.getName()), ctx), elCtx, vars);
}
else {
return getProperty(getPropertyFromAccessor(method.getName()), ctx);
}
}
catch (NullPointerException e) {
if (ctx == null) {
throw new CompileException("unable to invoke method: " + method.getDeclaringClass().getName() + "." + method.getName() + ": " +
"target of method is null", e);
}
else {
throw new CompileException("cannot invoke getter: " + method.getName() + " (see trace)", e);
}
}
catch (Exception e) {
throw new CompileException("cannot invoke getter: " + method.getName()
+ " [declr.class: " + method.getDeclaringClass().getName() + "; act.class: "
+ (ctx != null ? ctx.getClass().getName() : "null") + "] (see trace)", e);
}
}
public GetterAccessor(Method method) {
this.method = method;
}
public Method getMethod() {
return method;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public AccessorNode getNextNode() {
return nextNode;
}
public String toString() {
return method.getDeclaringClass().getName() + "." + method.getName();
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
try {
if (nextNode != null) {
return nextNode.setValue(method.invoke(ctx, EMPTY), elCtx, vars, value);
}
else {
throw new CompileException("bad payload");
}
}
catch (IllegalArgumentException e) {
/**
* HACK: Try to access this another way.
*/
if (nextNode != null) {
return nextNode.setValue(getProperty(getPropertyFromAccessor(method.getName()), ctx), elCtx, vars, value);
}
else {
return getProperty(getPropertyFromAccessor(method.getName()), ctx);
}
}
catch (CompileException e) {
throw e;
}
catch (Exception e) {
throw new CompileException("error " + method.getName() + ": " + e.getClass().getName() + ":" + e.getMessage(), e);
}
}
public Class getKnownEgressType() {
return method.getReturnType();
}
private Object executeOverrideTarget(Method o, Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
if (nextNode != null) {
return nextNode.getValue(o.invoke(ctx, EMPTY), elCtx, vars);
}
else {
return o.invoke(ctx, EMPTY);
}
}
catch (Exception e2) {
throw new CompileException("unable to invoke method", e2);
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/VariableAccessor.java 0000644 0001750 0001750 00000004570 11077457613 031152 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
public class VariableAccessor implements AccessorNode {
private AccessorNode nextNode;
private String property;
public VariableAccessor(String property) {
this.property = property;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vrf) {
if (vrf == null)
throw new CompileException("cannot access property in optimized accessor: " + property);
if (nextNode != null) {
return nextNode.getValue(vrf.getVariableResolver(property).getValue(), elCtx, vrf);
}
else {
return vrf.getVariableResolver(property).getValue();
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (nextNode != null) {
return nextNode.setValue(variableFactory.getVariableResolver(property).getValue(), elCtx, variableFactory, value);
}
else {
variableFactory.getVariableResolver(property).setValue(value);
}
return value;
}
public Object getProperty() {
return property;
}
public void setProperty(String property) {
this.property = property;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/Union.java 0000644 0001750 0001750 00000005331 11123077476 027023 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import static org.mvel2.compiler.AbstractParser.getCurrentThreadParserContext;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizerFactory;
/**
* @author Christopher Brock
*/
public class Union implements Accessor {
private Accessor accessor;
private char[] nextExpr;
private Accessor nextAccessor;
public Union(Accessor accessor, char[] nextAccessor) {
this.accessor = accessor;
this.nextExpr = nextAccessor;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (nextAccessor == null) {
return get(ctx, elCtx, variableFactory);
}
else {
return nextAccessor.getValue(get(ctx, elCtx, variableFactory), elCtx, variableFactory);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return nextAccessor.setValue(get(ctx, elCtx, variableFactory), elCtx, variableFactory, value);
}
private Object get(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (nextAccessor == null) {
Object o = accessor.getValue(ctx, elCtx, variableFactory);
AccessorOptimizer ao = OptimizerFactory.getDefaultAccessorCompiler();
Class ingress = accessor.getKnownEgressType();
nextAccessor = ao.optimizeAccessor(getCurrentThreadParserContext(), nextExpr, o, elCtx, variableFactory,
false, ingress);
return ao.getResultOptPass();
}
else {
return accessor.getValue(ctx, elCtx, variableFactory);
}
}
public Class getLeftIngressType() {
return accessor.getKnownEgressType();
}
public Class getKnownEgressType() {
return nextAccessor.getKnownEgressType();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/Notify.java 0000644 0001750 0001750 00000002122 11121621456 027165 0 ustar drazzib drazzib package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.GlobalListenerFactory;
public class Notify implements AccessorNode {
private String name;
private AccessorNode nextNode;
public Notify(String name) {
this.name = name;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vrf) {
GlobalListenerFactory.notifyGetListeners(ctx, name, vrf);
return nextNode.getValue(ctx, elCtx, vrf);
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
GlobalListenerFactory.notifySetListeners(ctx, name, variableFactory, value);
return nextNode.setValue(ctx, elCtx, variableFactory, value);
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/MapAccessorNest.java 0000644 0001750 0001750 00000006165 11077457613 030776 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.DataConversion;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import java.util.Map;
/**
* @author Christopher Brock
*/
public class MapAccessorNest implements AccessorNode {
private AccessorNode nextNode;
private ExecutableStatement property;
private Class conversionType;
public MapAccessorNest() {
}
public MapAccessorNest(ExecutableStatement property, Class conversionType) {
this.property = property;
this.conversionType = conversionType;
}
public MapAccessorNest(String property, Class conversionType) {
this.property = (ExecutableStatement) subCompileExpression(property.toCharArray());
this.conversionType = conversionType;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vrf) {
if (nextNode != null) {
return nextNode.getValue(((Map) ctx).get(property.getValue(ctx, elCtx, vrf)), elCtx, vrf);
}
else {
return ((Map) ctx).get(property.getValue(ctx, elCtx, vrf));
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
if (nextNode != null) {
return nextNode.setValue(((Map) ctx).get(property.getValue(ctx, elCtx, vars)), elCtx, vars, value);
}
else {
if (conversionType != null) {
((Map) ctx).put(property.getValue(ctx, elCtx, vars), value = DataConversion.convert(value, conversionType));
}
else {
((Map) ctx).put(property.getValue(ctx, elCtx, vars), value);
}
return value;
}
}
public ExecutableStatement getProperty() {
return property;
}
public void setProperty(ExecutableStatement property) {
this.property = property;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public String toString() {
return "Map Accessor -> [" + property + "]";
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ThisValueAccessor.java 0000644 0001750 0001750 00000003435 11123077476 031325 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
public class ThisValueAccessor implements AccessorNode {
private AccessorNode nextNode;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return this.nextNode.getValue(elCtx, elCtx, vars);
}
else {
return elCtx;
}
}
public ThisValueAccessor() {
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (nextNode == null) throw new CompileException("assignment to reserved variable 'this' not permitted");
return this.nextNode.setValue(elCtx, elCtx, variableFactory, value);
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/GetterAccessorNH.java 0000644 0001750 0001750 00000011315 11123062273 031062 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.MVEL.getProperty;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.PropertyHandler;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.getBestCandidate;
import java.lang.reflect.Method;
public class GetterAccessorNH implements AccessorNode {
private AccessorNode nextNode;
private final Method method;
private PropertyHandler nullHandler;
public static final Object[] EMPTY = new Object[0];
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
return nullHandle(method.getName(), method.invoke(ctx, EMPTY), ctx, elCtx, vars);
}
catch (IllegalArgumentException e) {
if (ctx != null && method.getDeclaringClass() != ctx.getClass()) {
Method o = getBestCandidate(EMPTY, method.getName(), ctx.getClass(), ctx.getClass().getMethods(), true);
if (o != null) {
return executeOverrideTarget(o, ctx, elCtx, vars);
}
}
/**
* HACK: Try to access this another way.
*/
return nullHandle(method.getName(), getProperty(method.getName() + "()", ctx), ctx, elCtx, vars);
}
catch (Exception e) {
throw new CompileException("cannot invoke getter: " + method.getName()
+ " [declr.class: " + method.getDeclaringClass().getName() + "; act.class: "
+ (ctx != null ? ctx.getClass().getName() : "null") + "]", e);
}
}
public GetterAccessorNH(Method method, PropertyHandler nullHandler) {
this.method = method;
this.nullHandler = nullHandler;
}
public Method getMethod() {
return method;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public AccessorNode getNextNode() {
return nextNode;
}
public String toString() {
return method.getDeclaringClass().getName() + "." + method.getName();
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
try {
Object v = method.invoke(ctx, EMPTY);
if (v == null) v = nullHandler.getProperty(method.getName(), ctx, vars);
return nextNode.setValue(v, elCtx, vars, value);
}
catch (IllegalArgumentException e) {
/**
* HACK: Try to access this another way.
*/
Object v = getProperty(method.getName() + "()", ctx);
if (v == null) v = nullHandler.getProperty(method.getName(), ctx, vars);
return nextNode.setValue(v, elCtx, vars, value);
}
catch (CompileException e) {
throw e;
}
catch (Exception e) {
throw new CompileException("error " + method.getName() + ": " + e.getClass().getName() + ":" + e.getMessage(), e);
}
}
public Class getKnownEgressType() {
return method.getReturnType();
}
private Object executeOverrideTarget(Method o, Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
return nullHandle(o.getName(), o.invoke(ctx, EMPTY), ctx, elCtx, vars);
}
catch (Exception e2) {
throw new CompileException("unable to invoke method", e2);
}
}
private Object nullHandle(String name, Object v, Object ctx, Object elCtx, VariableResolverFactory vars) {
if (v != null) {
if (nextNode != null) {
return nextNode.getValue(v, elCtx, vars);
}
else {
return v;
}
}
else {
if (nextNode != null) {
return nextNode.getValue(nullHandler.getProperty(name, ctx, vars), elCtx, vars);
}
else {
return nullHandler.getProperty(name, ctx, vars);
}
}
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ListAccessor.java 0000644 0001750 0001750 00000004231 11077457613 030332 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.util.List;
public class ListAccessor implements AccessorNode {
private AccessorNode nextNode;
private int index;
public ListAccessor() {
}
public ListAccessor(int index) {
this.index = index;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(((List) ctx).get(index), elCtx, vars);
}
else {
return ((List) ctx).get(index);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
if (nextNode != null) {
return nextNode.setValue(((List) ctx).get(index), elCtx, vars, value);
}
else {
//noinspection unchecked
((List) ctx).set(index, value);
return value;
}
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public String toString() {
return "Array Accessor -> [" + index + "]";
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/BaseAccessor.java 0000644 0001750 0001750 00000002127 11077457613 030273 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
public abstract class BaseAccessor implements AccessorNode {
protected AccessorNode nextNode;
public AccessorNode setNextNode(AccessorNode accessorNode) {
return this.nextNode = accessorNode;
}
public AccessorNode getNextNode() {
return this.nextNode;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/StaticVarAccessor.java 0000644 0001750 0001750 00000004531 11123077476 031317 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import org.mvel2.OptimizationFailure;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Field;
public class StaticVarAccessor implements AccessorNode {
private AccessorNode nextNode;
Field field;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
if (nextNode != null) {
return nextNode.getValue(field.get(null), elCtx, vars);
}
else {
return field.get(null);
}
}
catch (Exception e) {
throw new OptimizationFailure("unable to access static field", e);
}
}
public StaticVarAccessor(Field field) {
this.field = field;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
if (nextNode == null) {
field.set(null, value);
}
else {
return nextNode.setValue(field.get(null), elCtx, variableFactory, value);
}
}
catch (Exception e) {
throw new CompileException("error accessing static variable", e);
}
return value;
}
public Class getKnownEgressType() {
return field.getClass();
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/SetterAccessor.java 0000644 0001750 0001750 00000005321 11167064652 030663 0 ustar drazzib drazzib package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.util.ParseTools.getBestCandidate;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Method;
public class SetterAccessor implements AccessorNode {
private AccessorNode nextNode;
private final Method method;
private Class targetType;
private boolean coercionRequired = false;
public static final Object[] EMPTY = new Object[0];
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
if (coercionRequired) {
return method.invoke(ctx, convert(value, targetType));
}
else {
return method.invoke(ctx, value);
}
}
catch (IllegalArgumentException e) {
if (ctx != null && method.getDeclaringClass() != ctx.getClass()) {
Method o = getBestCandidate(EMPTY, method.getName(), ctx.getClass(), ctx.getClass().getMethods(), true);
if (o != null) {
return executeOverrideTarget(o, ctx, value);
}
}
if (!coercionRequired) {
coercionRequired = true;
return setValue(ctx, elCtx, variableFactory, value);
}
throw new CompileException("unable to bind property", e);
}
catch (Exception e) {
System.out.println("ctx=" + ctx);
throw new CompileException("error calling method: " + method.getDeclaringClass().getName() + "." + method.getName(), e);
}
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
return null;
}
public SetterAccessor(Method method) {
this.method = method;
assert method != null;
this.targetType = method.getParameterTypes()[0];
}
public Method getMethod() {
return method;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public AccessorNode getNextNode() {
return nextNode;
}
public String toString() {
return method.getDeclaringClass().getName() + "." + method.getName();
}
public Class getKnownEgressType() {
return method.getReturnType();
}
private Object executeOverrideTarget(Method o, Object ctx, Object value) {
try {
return o.invoke(ctx, convert(value, targetType));
}
catch (Exception e2) {
throw new CompileException("unable to invoke method", e2);
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ArrayAccessorNest.java 0000644 0001750 0001750 00000006500 11077457613 031330 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import java.lang.reflect.Array;
public class ArrayAccessorNest implements AccessorNode {
private AccessorNode nextNode;
private ExecutableStatement index;
private Class baseComponentType;
private boolean requireConversion;
public ArrayAccessorNest() {
}
public ArrayAccessorNest(String index) {
this.index = (ExecutableStatement) ParseTools.subCompileExpression(index.toCharArray());
}
public ArrayAccessorNest(ExecutableStatement stmt) {
this.index = stmt;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(((Object[]) ctx)[(Integer) index.getValue(ctx, elCtx, vars)], elCtx, vars);
}
else {
return ((Object[]) ctx)[(Integer) index.getValue(ctx, elCtx, vars)];
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
if (nextNode != null) {
return nextNode.setValue(((Object[]) ctx)[(Integer) index.getValue(ctx, elCtx, vars)], elCtx, vars, value);
}
else {
if (baseComponentType == null) {
baseComponentType = ParseTools.getBaseComponentType(ctx.getClass());
requireConversion = baseComponentType != value.getClass() && !baseComponentType.isAssignableFrom(value.getClass());
}
if (requireConversion) {
Object o = convert(value, baseComponentType);
Array.set(ctx, (Integer) index.getValue(ctx, elCtx, vars), o);
return o;
}
else {
Array.set(ctx, (Integer) index.getValue(ctx, elCtx, vars), value);
return value;
}
}
}
public ExecutableStatement getIndex() {
return index;
}
public void setIndex(ExecutableStatement index) {
this.index = index;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return baseComponentType;
}
public String toString() {
return "Array Accessor -> [" + index + "]";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/DynamicSetterAccessor.java 0000644 0001750 0001750 00000004277 11123077476 032201 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Method;
@SuppressWarnings({"unchecked"})
public class DynamicSetterAccessor implements AccessorNode {
// private AccessorNode nextNode;
private final Method method;
private Class targetType;
public static final Object[] EMPTY = new Object[0];
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
return method.invoke(ctx, convert(value, targetType));
}
catch (Exception e) {
throw new CompileException("error binding property", e);
}
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
return null;
}
public DynamicSetterAccessor(Method method) {
this.method = method;
this.targetType = method.getParameterTypes()[0];
}
public Method getMethod() {
return method;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return null;
}
public AccessorNode getNextNode() {
return null;
}
public String toString() {
return method.getDeclaringClass().getName() + "." + method.getName();
}
public Class getKnownEgressType() {
return targetType;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/MapAccessor.java 0000644 0001750 0001750 00000004305 11077457613 030136 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.util.Map;
public class MapAccessor implements AccessorNode {
private AccessorNode nextNode;
private Object property;
public MapAccessor() {
}
public MapAccessor(Object property) {
this.property = property;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vrf) {
if (nextNode != null) {
return nextNode.getValue(((Map) ctx).get(property), elCtx, vrf);
}
else {
return ((Map) ctx).get(property);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
if (nextNode != null) {
return nextNode.setValue(((Map) ctx).get(property), elCtx, vars, value);
}
else {
//noinspection unchecked
((Map) ctx).put(property, value);
return value;
}
}
public Object getProperty() {
return property;
}
public void setProperty(Object property) {
this.property = property;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public String toString() {
return "Map Accessor -> [" + property + "]";
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/IndexedVariableAccessor.java 0000644 0001750 0001750 00000004124 11077457613 032446 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
public class IndexedVariableAccessor implements AccessorNode {
private AccessorNode nextNode;
private int register;
public IndexedVariableAccessor(int register) {
this.register = register;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vrf) {
if (nextNode != null) {
return nextNode.getValue(vrf.getIndexedVariableResolver(register).getValue(), elCtx, vrf);
}
else {
return vrf.getIndexedVariableResolver(register).getValue();
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (nextNode != null) {
return nextNode.setValue(variableFactory.getIndexedVariableResolver(register).getValue(), elCtx, variableFactory, value);
}
else {
variableFactory.getIndexedVariableResolver(register).setValue(value);
return value;
}
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return Object.class;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/FieldAccessorNH.java 0000644 0001750 0001750 00000006152 11123077476 030671 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.PropertyHandler;
import java.lang.reflect.Field;
public class FieldAccessorNH implements AccessorNode {
private AccessorNode nextNode;
private Field field;
private boolean coercionRequired = false;
private PropertyHandler nullHandler;
public FieldAccessorNH(Field field, PropertyHandler handler) {
this.field = field;
this.nullHandler = handler;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
Object v = field.get(ctx);
if (v == null) v = nullHandler.getProperty(field.getName(), elCtx, vars);
if (nextNode != null) {
return nextNode.getValue(v, elCtx, vars);
}
else {
return v;
}
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
if (nextNode != null) {
return nextNode.setValue(ctx, elCtx, variableFactory, value);
}
else if (coercionRequired) {
field.set(ctx, value = convert(ctx, field.getClass()));
return value;
}
else {
field.set(ctx, value);
return value;
}
}
catch (IllegalArgumentException e) {
if (!coercionRequired) {
coercionRequired = true;
return setValue(ctx, elCtx, variableFactory, value);
}
throw new CompileException("unable to bind property", e);
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
public Field getField() {
return field;
}
public void setField(Field field) {
this.field = field;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return field.getClass();
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/ListAccessorNest.java 0000644 0001750 0001750 00000006033 11077457613 031166 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.DataConversion;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import java.util.List;
public class ListAccessorNest implements AccessorNode {
private AccessorNode nextNode;
private ExecutableStatement index;
private Class conversionType;
public ListAccessorNest() {
}
public ListAccessorNest(String index, Class conversionType) {
this.index = (ExecutableStatement) subCompileExpression(index.toCharArray());
this.conversionType = conversionType;
}
public ListAccessorNest(ExecutableStatement index, Class conversionType) {
this.index = index;
this.conversionType = conversionType;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(((List) ctx).get((Integer) index.getValue(ctx, elCtx, vars)), elCtx, vars);
}
else {
return ((List) ctx).get((Integer) index.getValue(ctx, elCtx, vars));
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vars, Object value) {
//noinspection unchecked
if (nextNode != null) {
return nextNode.setValue(((List) ctx).get((Integer) index.getValue(ctx, elCtx, vars)), elCtx, vars, value);
}
else {
if (conversionType != null) {
((List) ctx).set((Integer) index.getValue(ctx, elCtx, vars), value = DataConversion.convert(value, conversionType));
}
else {
((List) ctx).set((Integer) index.getValue(ctx, elCtx, vars), value);
}
return value;
}
}
public ExecutableStatement getIndex() {
return index;
}
public void setIndex(ExecutableStatement index) {
this.index = index;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public String toString() {
return "Array Accessor -> [" + index + "]";
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/FieldAccessor.java 0000644 0001750 0001750 00000006110 11132723576 030434 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Field;
public class FieldAccessor implements AccessorNode {
private AccessorNode nextNode;
private Field field;
private boolean coercionRequired = false;
public FieldAccessor() {
}
public FieldAccessor(Field field) {
this.field = field;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
if (nextNode != null) {
return nextNode.getValue(field.get(ctx), elCtx, vars);
}
else {
return field.get(ctx);
}
}
catch (Exception e) {
throw new CompileException("unable to access field: " + field.getName(), e);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (nextNode != null) {
try {
return nextNode.setValue(field.get(ctx), elCtx, variableFactory, value);
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
try {
if (coercionRequired) {
field.set(ctx, value = convert(ctx, field.getClass()));
return value;
}
else {
field.set(ctx, value);
return value;
}
}
catch (IllegalArgumentException e) {
if (!coercionRequired) {
coercionRequired = true;
return setValue(ctx, elCtx, variableFactory, value);
}
throw new CompileException("unable to bind property", e);
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
public Field getField() {
return field;
}
public void setField(Field field) {
this.field = field;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return field.getClass();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/StaticVarAccessorNH.java 0000644 0001750 0001750 00000005131 11132723576 031541 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import org.mvel2.OptimizationFailure;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.PropertyHandler;
import java.lang.reflect.Field;
public class StaticVarAccessorNH implements AccessorNode {
private AccessorNode nextNode;
Field field;
private PropertyHandler nullHandler;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
Object v = field.get(ctx);
if (v == null) v = nullHandler.getProperty(field.getName(), elCtx, vars);
if (nextNode != null) {
return nextNode.getValue(v, elCtx, vars);
}
else {
return v;
}
}
catch (Exception e) {
throw new OptimizationFailure("unable to access static field", e);
}
}
public StaticVarAccessorNH(Field field, PropertyHandler handler) {
this.field = field;
this.nullHandler = handler;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
if (nextNode == null) {
field.set(null, value);
}
else {
return nextNode.setValue(field.get(null), elCtx, variableFactory, value);
}
}
catch (Exception e) {
throw new CompileException("error accessing static variable", e);
}
return value;
}
public Class getKnownEgressType() {
return field.getClass();
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/IndexedCharSeqAccessorNest.java 0000644 0001750 0001750 00000004542 11123077476 033102 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
public class IndexedCharSeqAccessorNest implements AccessorNode {
private AccessorNode nextNode;
private ExecutableStatement index;
public IndexedCharSeqAccessorNest() {
}
public IndexedCharSeqAccessorNest(ExecutableStatement index) {
this.index = index;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(((String) ctx).charAt((Integer) index.getValue(ctx, elCtx, vars)), elCtx, vars);
}
else {
return ((String) ctx).charAt((Integer) index.getValue(ctx, elCtx, vars));
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return nextNode.setValue(((String) ctx).charAt((Integer) index.getValue(ctx, elCtx, variableFactory)), elCtx,
variableFactory, value);
}
public ExecutableStatement getIndex() {
return index;
}
public void setIndex(ExecutableStatement index) {
this.index = index;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public String toString() {
return "Array Accessor -> [" + index + "]";
}
public Class getKnownEgressType() {
return Character.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/MethodAccessorNH.java 0000644 0001750 0001750 00000012515 11123077476 031066 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.convert;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.PropertyHandler;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.getBestCandidate;
import java.lang.reflect.Method;
public class MethodAccessorNH implements AccessorNode {
private AccessorNode nextNode;
private Method method;
private Class[] parameterTypes;
private ExecutableStatement[] parms;
private int length;
private boolean coercionNeeded = false;
private PropertyHandler nullHandler;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (!coercionNeeded) {
try {
Object v = method.invoke(ctx, executeAll(elCtx, vars));
if (v == null) nullHandler.getProperty(method.getName(), ctx, vars);
if (nextNode != null) {
return nextNode.getValue(v, elCtx, vars);
}
else {
return v;
}
}
catch (IllegalArgumentException e) {
if (ctx != null && method.getDeclaringClass() != ctx.getClass()) {
Method o = getBestCandidate(parameterTypes, method.getName(), ctx.getClass(), ctx.getClass().getMethods(), true);
if (o != null) {
return executeOverrideTarget(o, ctx, elCtx, vars);
}
}
coercionNeeded = true;
return getValue(ctx, elCtx, vars);
}
catch (Exception e) {
throw new CompileException("cannot invoke method", e);
}
}
else {
try {
if (nextNode != null) {
return nextNode.getValue(method.invoke(ctx, executeAndCoerce(parameterTypes, elCtx, vars)), elCtx, vars);
}
else {
return method.invoke(ctx, executeAndCoerce(parameterTypes, elCtx, vars));
}
}
catch (Exception e) {
throw new CompileException("cannot invoke method", e);
}
}
}
private Object executeOverrideTarget(Method o, Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
Object v = o.invoke(ctx, executeAll(elCtx, vars));
if (v == null) v = nullHandler.getProperty(o.getName(), ctx, vars);
if (nextNode != null) {
return nextNode.getValue(v, elCtx, vars);
}
else {
return v;
}
}
catch (Exception e2) {
throw new CompileException("unable to invoke method", e2);
}
}
private Object[] executeAll(Object ctx, VariableResolverFactory vars) {
if (length == 0) return GetterAccessor.EMPTY;
Object[] vals = new Object[length];
for (int i = 0; i < length; i++) {
vals[i] = parms[i].getValue(ctx, vars);
}
return vals;
}
private Object[] executeAndCoerce(Class[] target, Object elCtx, VariableResolverFactory vars) {
Object[] values = new Object[length];
for (int i = 0; i < length; i++) {
//noinspection unchecked
values[i] = convert(parms[i].getValue(elCtx, vars), target[i]);
}
return values;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
this.length = (this.parameterTypes = this.method.getParameterTypes()).length;
}
public ExecutableStatement[] getParms() {
return parms;
}
public void setParms(ExecutableStatement[] parms) {
this.parms = parms;
}
public MethodAccessorNH() {
}
public MethodAccessorNH(Method method, ExecutableStatement[] parms, PropertyHandler handler) {
this.method = method;
this.length = (this.parameterTypes = this.method.getParameterTypes()).length;
this.parms = parms;
this.nullHandler = handler;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return nextNode.setValue(ctx, elCtx, variableFactory, value);
}
public Class getKnownEgressType() {
return method.getReturnType();
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/NullSafe.java 0000644 0001750 0001750 00000001631 11121621456 027432 0 ustar drazzib drazzib package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
public class NullSafe implements AccessorNode {
private AccessorNode nextNode;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (ctx == null) return null;
return nextNode.getValue(ctx, elCtx, variableFactory);
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (ctx == null) return null;
return nextNode.setValue(ctx, elCtx, variableFactory, value);
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode accessorNode) {
return this.nextNode = accessorNode;
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/DynamicFunctionAccessor.java 0000644 0001750 0001750 00000003775 11351236755 032522 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.ast.Function;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
public class DynamicFunctionAccessor extends BaseAccessor {
// private Function function;
private Accessor[] parameters;
public DynamicFunctionAccessor(Accessor[] parms) {
this.parameters = parms;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
Object[] parms = null;
Function function = (Function) ctx;
if (parameters != null && parameters.length != 0) {
parms = new Object[parameters.length];
for (int i = 0; i < parms.length; i++) {
parms[i] = parameters[i].getValue(ctx, elCtx, variableFactory);
}
}
if (nextNode != null) {
return nextNode.getValue(function.call(ctx, elCtx, variableFactory, parms), elCtx, variableFactory);
}
else {
return function.call(ctx, elCtx, variableFactory, parms);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
throw new RuntimeException("can't write to function");
}
public Class getKnownEgressType() {
return Object.class;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/StaticReferenceAccessor.java 0000644 0001750 0001750 00000003632 11123077476 032466 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
public class StaticReferenceAccessor implements AccessorNode {
private AccessorNode nextNode;
Object literal;
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
if (nextNode != null) {
return nextNode.getValue(literal, elCtx, vars);
}
else {
return literal;
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return nextNode.setValue(literal, elCtx, variableFactory, value);
}
public Object getLiteral() {
return literal;
}
public void setLiteral(Object literal) {
this.literal = literal;
}
public StaticReferenceAccessor() {
}
public StaticReferenceAccessor(Object literal) {
this.literal = literal;
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return literal.getClass();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/PropertyHandlerAccessor.java 0000644 0001750 0001750 00000003672 11325411717 032540 0 ustar drazzib drazzib package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.integration.PropertyHandler;
import org.mvel2.integration.VariableResolverFactory;
public class PropertyHandlerAccessor extends BaseAccessor {
private String propertyName;
private PropertyHandler propertyHandler;
private Class conversionType;
public PropertyHandlerAccessor(String propertyName, Class conversionType, PropertyHandler propertyHandler) {
this.propertyName = propertyName;
this.conversionType = conversionType;
this.propertyHandler = propertyHandler;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (!conversionType.isAssignableFrom(ctx.getClass())) {
if (nextNode != null) {
return nextNode.getValue(MVEL.getProperty(propertyName, ctx), elCtx, variableFactory);
}
else {
return MVEL.getProperty(propertyName, ctx);
}
}
try {
if (nextNode != null) {
return nextNode.getValue(propertyHandler.getProperty(propertyName, ctx, variableFactory), elCtx, variableFactory);
}
else {
return propertyHandler.getProperty(propertyName, ctx, variableFactory);
}
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
if (nextNode != null) {
return nextNode.setValue(propertyHandler.getProperty(propertyName, ctx, variableFactory), ctx, variableFactory, value);
}
else {
return propertyHandler.setProperty(propertyName, ctx, variableFactory, value);
}
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/WithAccessor.java 0000644 0001750 0001750 00000007605 11166613027 030332 0 ustar drazzib drazzib package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.MVEL;
import static org.mvel2.MVEL.executeSetExpression;
import org.mvel2.ParserContext;
import org.mvel2.ast.WithNode;
import static org.mvel2.compiler.AbstractParser.getCurrentThreadParserContext;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import org.mvel2.util.PropertyTools;
import static org.mvel2.util.PropertyTools.getReturnType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import java.io.Serializable;
public class WithAccessor implements AccessorNode {
private AccessorNode nextNode;
protected String nestParm;
protected ExecutableStatement nestedStatement;
protected WithNode.ParmValuePair[] withExpressions;
public WithAccessor(String property, char[] block, Class ingressType, boolean strict) {
ParserContext pCtx = getCurrentThreadParserContext();
pCtx.setBlockSymbols(true);
withExpressions = WithNode.compileWithExpressions(block, property, ingressType, pCtx);
// withExpressions = new ExecutablePairs[pvp.length];
//
// for (int i = 0; i < pvp.length; i++) {
// withExpressions[i] = new ExecutablePairs(pvp[i].getParm(),
// (ExecutableStatement) subCompileExpression(pvp[i].getValue().toCharArray()), ingressType, pCtx);
// }
pCtx.setBlockSymbols(false);
}
public AccessorNode getNextNode() {
return this.nextNode;
}
public AccessorNode setNextNode(AccessorNode accessorNode) {
return this.nextNode = accessorNode;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (this.nextNode == null) {
return processWith(ctx, elCtx, variableFactory);
}
else {
return this.nextNode.getValue(processWith(ctx, elCtx, variableFactory), elCtx, variableFactory);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return this.nextNode.setValue(processWith(ctx, elCtx, variableFactory), elCtx, variableFactory, value);
}
public Object processWith(Object ctx, Object thisValue, VariableResolverFactory factory) {
for (WithNode.ParmValuePair pvp : withExpressions) {
if (pvp.getSetExpression() != null) {
executeSetExpression(pvp.getSetExpression(), ctx, factory, pvp.getStatement().getValue(ctx, thisValue, factory));
}
else {
pvp.getStatement().getValue(ctx, thisValue, factory);
}
}
return ctx;
}
public static final class ExecutablePairs implements Serializable {
private Serializable setExpression;
private ExecutableStatement statement;
public ExecutablePairs() {
}
public ExecutablePairs(String parameter, ExecutableStatement statement, Class ingressType, ParserContext pCtx) {
if (parameter != null && parameter.length() != 0) {
this.setExpression = MVEL.compileSetExpression(parameter,
ingressType != null ? getReturnType(ingressType, parameter, pCtx) : Object.class
, getCurrentThreadParserContext());
}
this.statement = statement;
}
public Serializable getSetExpression() {
return setExpression;
}
public void setSetExpression(Serializable setExpression) {
this.setExpression = setExpression;
}
public ExecutableStatement getStatement() {
return statement;
}
public void setStatement(ExecutableStatement statement) {
this.statement = statement;
}
}
public Class getKnownEgressType() {
return Object.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/refl/nodes/DynamicFieldAccessor.java 0000644 0001750 0001750 00000005103 11077457613 031746 0 ustar drazzib drazzib /**
* MVEL (The MVFLEX Expression Language)
*
* Copyright (C) 2007 Christopher Brock, MVFLEX/Valhalla Project and the Codehaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.mvel2.optimizers.impl.refl.nodes;
import org.mvel2.CompileException;
import org.mvel2.DataConversion;
import org.mvel2.compiler.AccessorNode;
import org.mvel2.integration.VariableResolverFactory;
import java.lang.reflect.Field;
@SuppressWarnings({"unchecked"})
public class DynamicFieldAccessor implements AccessorNode {
private AccessorNode nextNode;
private Field field;
private Class targetType;
public DynamicFieldAccessor() {
}
public DynamicFieldAccessor(Field field) {
this.field = field;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory vars) {
try {
if (nextNode != null) {
return nextNode.getValue(field.get(ctx), elCtx, vars);
}
else {
return field.get(ctx);
}
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
try {
if (nextNode != null) {
return nextNode.setValue(field.get(ctx), elCtx, variableFactory, value);
}
else {
field.set(ctx, DataConversion.convert(value, targetType));
return value;
}
}
catch (Exception e) {
throw new CompileException("unable to access field", e);
}
}
public Field getField() {
return field;
}
public void setField(Field field) {
this.field = field;
this.targetType = field.getType();
}
public AccessorNode getNextNode() {
return nextNode;
}
public AccessorNode setNextNode(AccessorNode nextNode) {
return this.nextNode = nextNode;
}
public Class getKnownEgressType() {
return targetType;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/asm/ 0000755 0001750 0001750 00000000000 11412747042 023600 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/asm/ASMAccessorOptimizer.java 0000644 0001750 0001750 00000346162 11363352207 030465 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.impl.asm;
import org.mvel2.*;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import static org.mvel2.MVEL.eval;
import static org.mvel2.MVEL.isAdvancedDebugging;
import org.mvel2.asm.ClassWriter;
import org.mvel2.asm.Label;
import org.mvel2.asm.MethodVisitor;
import org.mvel2.asm.Opcodes;
import static org.mvel2.asm.Opcodes.*;
import static org.mvel2.asm.Type.*;
import org.mvel2.ast.Function;
import org.mvel2.ast.TypeDescriptor;
import static org.mvel2.ast.TypeDescriptor.getClassReference;
import org.mvel2.ast.WithNode;
import org.mvel2.compiler.*;
import org.mvel2.integration.GlobalListenerFactory;
import static org.mvel2.integration.GlobalListenerFactory.hasGetListeners;
import static org.mvel2.integration.GlobalListenerFactory.notifyGetListeners;
import org.mvel2.integration.PropertyHandler;
import static org.mvel2.integration.PropertyHandlerFactory.*;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AbstractOptimizer;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizationNotSupported;
import org.mvel2.optimizers.impl.refl.nodes.Union;
import static org.mvel2.util.ArrayTools.findFirst;
import org.mvel2.util.*;
import static org.mvel2.util.ParseTools.*;
import static org.mvel2.util.PropertyTools.getFieldOrAccessor;
import static org.mvel2.util.PropertyTools.getFieldOrWriteAccessor;
import java.io.FileWriter;
import java.io.IOException;
import static java.lang.String.valueOf;
import static java.lang.System.getProperty;
import static java.lang.Thread.currentThread;
import java.lang.reflect.*;
import static java.lang.reflect.Array.getLength;
import static java.lang.reflect.Modifier.FINAL;
import static java.lang.reflect.Modifier.STATIC;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* Implementation of the MVEL Just-in-Time (JIT) compiler for Property Accessors using the ASM bytecode
* engineering library.
*
*/
@SuppressWarnings({"TypeParameterExplicitlyExtendsObject", "unchecked", "UnusedDeclaration"})
public class ASMAccessorOptimizer extends AbstractOptimizer implements AccessorOptimizer {
private static final String MAP_IMPL = "java/util/HashMap";
private static String LIST_IMPL;
private static String NAMESPACE;
private static final int OPCODES_VERSION;
static {
final String javaVersion = getProperty("java.version");
if (javaVersion.startsWith("1.4"))
OPCODES_VERSION = Opcodes.V1_4;
else if (javaVersion.startsWith("1.5"))
OPCODES_VERSION = Opcodes.V1_5;
else if (javaVersion.startsWith("1.6") || javaVersion.startsWith("1.7"))
OPCODES_VERSION = Opcodes.V1_6;
else
OPCODES_VERSION = Opcodes.V1_2;
String defaultNameSapce = getProperty("mvel2.namespace");
if (defaultNameSapce == null) NAMESPACE = "org/mvel2/";
else NAMESPACE = defaultNameSapce;
String jitListImpl = getProperty("mvel2.jit.list_impl");
if (jitListImpl == null) LIST_IMPL = NAMESPACE + "util/FastList";
else LIST_IMPL = jitListImpl;
}
private Object ctx;
private Object thisRef;
private VariableResolverFactory variableFactory;
private static final Object[] EMPTYARG = new Object[0];
private static final Class[] EMPTYCLS = new Class[0];
private boolean first = true;
private boolean noinit = false;
private boolean deferFinish = false;
private boolean literal = false;
private boolean propNull = false;
private boolean methNull = false;
private String className;
private ClassWriter cw;
private MethodVisitor mv;
private Object val;
private int stacksize = 1;
private int maxlocals = 1;
private long time;
private ArrayList compiledInputs;
private Class ingressType;
private Class returnType;
private int compileDepth = 0;
@SuppressWarnings({"StringBufferField"})
private StringAppender buildLog;
public ASMAccessorOptimizer() {
//do this to confirm we're running the correct version
//otherwise should create a verification error in VM
new ClassWriter(ClassWriter.COMPUTE_MAXS);
}
private ASMAccessorOptimizer(ClassWriter cw, MethodVisitor mv,
ArrayList compiledInputs, String className, StringAppender buildLog, int compileDepth) {
this.cw = cw;
this.mv = mv;
this.compiledInputs = compiledInputs;
this.className = className;
this.buildLog = buildLog;
this.compileDepth = compileDepth + 1;
noinit = true;
deferFinish = true;
}
/**
* Does all the boilerplate for initiating the JIT.
*/
private void _initJIT() {
if (isAdvancedDebugging()) {
buildLog = new StringAppender();
}
cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);
synchronized (Runtime.getRuntime()) {
cw.visit(OPCODES_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, className = "ASMAccessorImpl_"
+ valueOf(cw.hashCode()).replaceAll("\\-", "_") + (System.currentTimeMillis() / 10) +
((int) Math.random() * 100),
null, "java/lang/Object", new String[]{NAMESPACE + "compiler/Accessor"});
}
MethodVisitor m = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null);
m.visitCode();
m.visitVarInsn(Opcodes.ALOAD, 0);
m.visitMethodInsn(INVOKESPECIAL, "java/lang/Object",
"", "()V");
m.visitInsn(RETURN);
m.visitMaxs(1, 1);
m.visitEnd();
(mv = cw.visitMethod(ACC_PUBLIC, "getValue",
"(Ljava/lang/Object;Ljava/lang/Object;L" + NAMESPACE
+ "integration/VariableResolverFactory;)Ljava/lang/Object;", null, null)).visitCode();
}
private void _initJIT2() {
if (isAdvancedDebugging()) {
buildLog = new StringAppender();
}
cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);
synchronized (Runtime.getRuntime()) {
cw.visit(OPCODES_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, className = "ASMAccessorImpl_"
+ valueOf(cw.hashCode()).replaceAll("\\-", "_") + (System.currentTimeMillis() / 10) +
((int) Math.random() * 100),
null, "java/lang/Object", new String[]{NAMESPACE + "compiler/Accessor"});
}
MethodVisitor m = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null);
m.visitCode();
m.visitVarInsn(Opcodes.ALOAD, 0);
m.visitMethodInsn(INVOKESPECIAL, "java/lang/Object",
"", "()V");
m.visitInsn(RETURN);
m.visitMaxs(1, 1);
m.visitEnd();
(mv = cw.visitMethod(ACC_PUBLIC, "setValue",
"(Ljava/lang/Object;Ljava/lang/Object;L" + NAMESPACE
+ "integration/VariableResolverFactory;Ljava/lang/Object;)Ljava/lang/Object;", null, null)).visitCode();
}
public Accessor optimizeAccessor(ParserContext pCtx, char[] property, Object staticContext,
Object thisRef, VariableResolverFactory factory, boolean root, Class ingressType) {
time = System.currentTimeMillis();
if (compiledInputs == null) compiledInputs = new ArrayList();
start = cursor = 0;
this.first = true;
this.val = null;
this.pCtx = pCtx;
this.length = property.length;
this.expr = property;
this.ctx = staticContext;
this.thisRef = thisRef;
this.variableFactory = factory;
this.ingressType = ingressType;
if (!noinit) _initJIT();
return compileAccessor();
}
public Accessor optimizeSetAccessor(ParserContext pCtx, char[] property, Object ctx, Object thisRef,
VariableResolverFactory factory, boolean rootThisRef, Object value, Class ingressType) {
this.start = this.cursor = 0;
this.first = true;
this.ingressType = ingressType;
compiledInputs = new ArrayList();
this.pCtx = pCtx;
this.length = (this.expr = property).length;
this.ctx = ctx;
this.thisRef = thisRef;
this.variableFactory = factory;
char[] root = null;
PropertyVerifier verifier = new PropertyVerifier(property, this.pCtx = pCtx);
int split = findLastUnion();
if (split != -1) {
root = subset(property, 0, split++);
property = subset(property, split, property.length - split);
}
AccessorNode rootAccessor = null;
_initJIT2();
if (root != null) {
this.length = (this.expr = root).length;
// run the compiler but don't finish building.
deferFinish = true;
noinit = true;
compileAccessor();
ctx = this.val;
}
else {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
try {
this.length = (this.expr = property).length;
this.cursor = this.start = 0;
skipWhitespace();
if (collection) {
int start = cursor;
whiteSpaceSkip();
if (cursor == length)
throw new PropertyAccessException("unterminated '['");
if (scanTo(']'))
throw new PropertyAccessException("unterminated '['");
String ex = new String(property, start, cursor - start);
assert debug("CHECKCAST " + ctx.getClass().getName());
mv.visitTypeInsn(CHECKCAST, getInternalName(ctx.getClass()));
if (ctx instanceof Map) {
if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(Map.class)) {
propHandlerByteCodePut(ex, ctx, Map.class, value);
}
else {
//noinspection unchecked
((Map) ctx).put(eval(ex, ctx, variableFactory), convert(value, returnType = verifier.analyze()));
writeLiteralOrSubexpression(subCompileExpression(ex.toCharArray(), pCtx));
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
if (value != null & returnType != value.getClass()) {
dataConversion(returnType);
checkcast(returnType);
}
assert debug("INVOKEINTERFACE Map.put");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
assert debug("POP");
mv.visitInsn(POP);
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
}
}
else if (ctx instanceof List) {
if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(List.class)) {
propHandlerByteCodePut(ex, ctx, List.class, value);
}
else {
//noinspection unchecked
((List) ctx).set(eval(ex, ctx, variableFactory, Integer.class),
convert(value, returnType = verifier.analyze()));
writeLiteralOrSubexpression(subCompileExpression(ex.toCharArray(), pCtx));
unwrapPrimitive(int.class);
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
if (value != null & !value.getClass().isAssignableFrom(returnType)) {
dataConversion(returnType);
checkcast(returnType);
}
assert debug("INVOKEINTERFACE List.set");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "set", "(ILjava/lang/Object;)Ljava/lang/Object;");
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
}
}
else if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(ctx.getClass())) {
propHandlerByteCodePut(ex, ctx, ctx.getClass(), value);
}
else if (ctx.getClass().isArray()) {
if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(Array.class)) {
propHandlerByteCodePut(ex, ctx, Array.class, value);
}
else {
Class type = getBaseComponentType(ctx.getClass());
Object idx = eval(ex, ctx, variableFactory);
writeLiteralOrSubexpression(subCompileExpression(ex.toCharArray(), pCtx), int.class);
if (!(idx instanceof Integer)) {
dataConversion(Integer.class);
idx = DataConversion.convert(idx, Integer.class);
unwrapPrimitive(int.class);
}
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
if (!type.equals(value.getClass())) {
dataConversion(type);
}
if (type.isPrimitive()) wrapPrimitive(type);
arrayStore(type);
//noinspection unchecked
Array.set(ctx, (Integer) idx, convert(value, type));
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
}
}
else {
throw new PropertyAccessException("cannot bind to collection property: " + new String(property)
+ ": not a recognized collection type: " + ctx.getClass());
}
deferFinish = false;
noinit = false;
_finishJIT();
try {
deferFinish = false;
return _initializeAccessor();
}
catch (Exception e) {
throw new CompileException("could not generate accessor", e);
}
}
String tk = new String(property);
Member member = getFieldOrWriteAccessor(ctx.getClass(), tk, value == null ? null : ingressType);
if (GlobalListenerFactory.hasSetListeners()) {
mv.visitVarInsn(ALOAD, 1);
mv.visitLdcInsn(tk);
mv.visitVarInsn(ALOAD, 3);
mv.visitVarInsn(ALOAD, 4);
mv.visitMethodInsn(INVOKESTATIC, NAMESPACE + "integration/GlobalListenerFactory",
"notifySetListeners", "(Ljava/lang/Object;Ljava/lang/String;L" + NAMESPACE
+ "integration/VariableResolverFactory;Ljava/lang/Object;)V");
GlobalListenerFactory.notifySetListeners(ctx, tk, variableFactory, value);
}
if (member instanceof Field) {
assert debug("CHECKCAST " + ctx.getClass().getName());
mv.visitTypeInsn(CHECKCAST, getInternalName(ctx.getClass()));
Field fld = (Field) member;
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
assert debug("CHECKCAST " + fld.getType().getName());
mv.visitTypeInsn(CHECKCAST, getInternalName(fld.getType()));
if (value != null && !fld.getType().isAssignableFrom(value.getClass())) {
if (!canConvert(fld.getType(), value.getClass())) {
throw new ConversionException("cannot convert type: "
+ value.getClass() + ": to " + fld.getType());
}
dataConversion(fld.getType());
fld.set(ctx, convert(value, fld.getType()));
}
else {
fld.set(ctx, value);
}
assert debug("PUTFIELD " + getInternalName(fld.getDeclaringClass()) + "." + tk);
mv.visitFieldInsn(PUTFIELD, getInternalName(fld.getDeclaringClass()), tk, getDescriptor(fld.getType()));
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
}
else if (member != null) {
assert debug("CHECKCAST " + getInternalName(ctx.getClass()));
mv.visitTypeInsn(CHECKCAST, getInternalName(ctx.getClass()));
Method meth = (Method) member;
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
Class targetType = meth.getParameterTypes()[0];
if (value != null && !targetType.isAssignableFrom(value.getClass())) {
if (!canConvert(targetType, value.getClass())) {
throw new ConversionException("cannot convert type: "
+ value.getClass() + ": to " + meth.getParameterTypes()[0]);
}
dataConversion(getWrapperClass(targetType));
if (targetType.isPrimitive()) {
unwrapPrimitive(targetType);
}
else checkcast(targetType);
meth.invoke(ctx, convert(value, meth.getParameterTypes()[0]));
}
else {
checkcast(targetType);
meth.invoke(ctx, value);
}
assert debug("INVOKEVIRTUAL " + getInternalName(meth.getDeclaringClass()) + "." + meth.getName());
mv.visitMethodInsn(INVOKEVIRTUAL, getInternalName(meth.getDeclaringClass()), meth.getName(),
getMethodDescriptor(meth));
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
}
else if (ctx instanceof Map) {
assert debug("CHECKCAST " + getInternalName(ctx.getClass()));
mv.visitTypeInsn(CHECKCAST, getInternalName(ctx.getClass()));
assert debug("LDC '" + tk + "'");
mv.visitLdcInsn(tk);
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
assert debug("INVOKEVIRTUAL java/util/HashMap.put");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/util/HashMap", "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
//noinspection unchecked
((Map) ctx).put(tk, value);
}
else {
throw new PropertyAccessException("could not access property (" + tk + ") in: " + ingressType.getName());
}
}
catch (InvocationTargetException e) {
throw new PropertyAccessException("could not access property", e);
}
catch (IllegalAccessException e) {
throw new PropertyAccessException("could not access property", e);
}
try {
deferFinish = false;
noinit = false;
_finishJIT();
return _initializeAccessor();
}
catch (Exception e) {
throw new CompileException("could not generate accessor", e);
}
}
private void _finishJIT() {
if (deferFinish) return;
if (returnType != null && returnType.isPrimitive()) {
//noinspection unchecked
wrapPrimitive(returnType);
}
if (returnType == void.class) {
assert debug("ACONST_NULL");
mv.visitInsn(ACONST_NULL);
}
assert debug("ARETURN");
mv.visitInsn(ARETURN);
assert debug("\n{METHOD STATS (maxstack=" + stacksize + ")}\n");
mv.visitMaxs(stacksize, maxlocals);
mv.visitEnd();
mv = cw.visitMethod(ACC_PUBLIC, "getKnownEgressType", "()Ljava/lang/Class;", null, null);
mv.visitCode();
mv.visitLdcInsn(org.mvel2.asm.Type.getType(returnType != null ? returnType : Object.class));
mv.visitInsn(ARETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
if (propNull) {
cw.visitField(ACC_PUBLIC, "nullPropertyHandler", "L" + NAMESPACE + "integration/PropertyHandler;", null, null).visitEnd();
}
if (methNull) {
cw.visitField(ACC_PUBLIC, "nullMethodHandler", "L" + NAMESPACE + "integration/PropertyHandler;", null, null).visitEnd();
}
buildInputs();
if (buildLog != null && buildLog.length() != 0 && expr != null) {
mv = cw.visitMethod(ACC_PUBLIC, "toString", "()Ljava/lang/String;", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLdcInsn(buildLog.toString() + "\n\n## { " + new String(expr) + " }");
mv.visitInsn(ARETURN);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
cw.visitEnd();
dumpAdvancedDebugging(); // dump advanced debugging if necessary
}
private Accessor _initializeAccessor() throws Exception {
if (deferFinish) return null;
/**
* Hot load the class we just generated.
*/
Class cls = loadClass(className, cw.toByteArray());
assert debug("[MVEL JIT Completed Optimization <<" + (expr != null ? new String(expr) : "") + ">>]::" + cls
+ " (time: " + (System.currentTimeMillis() - time) + "ms)");
Object o;
try {
if (compiledInputs.size() == 0) {
o = cls.newInstance();
}
else {
Class[] parms = new Class[compiledInputs.size()];
for (int i = 0; i < compiledInputs.size(); i++) {
parms[i] = ExecutableStatement.class;
}
o = cls.getConstructor(parms).newInstance(compiledInputs.toArray(new ExecutableStatement[compiledInputs.size()]));
}
if (propNull) cls.getField("nullPropertyHandler").set(o, getNullPropertyHandler());
if (methNull) cls.getField("nullMethodHandler").set(o, getNullMethodHandler());
}
catch (VerifyError e) {
System.out.println("**** COMPILER BUG! REPORT THIS IMMEDIATELY AT http://jira.codehaus.org/browse/mvel2");
System.out.println("Expression: " + (expr == null ? null : new String(expr)));
throw e;
}
return (Accessor) o;
}
private Accessor compileAccessor() {
assert debug("<>");
Object curr = ctx;
try {
if (!MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING) {
while (cursor < length) {
switch (nextSubToken()) {
case BEAN:
curr = getBeanProperty(curr, capture());
break;
case METH:
curr = getMethod(curr, capture());
break;
case COL:
curr = getCollectionProperty(curr, capture());
break;
case WITH:
curr = getWithProperty(curr);
break;
}
// check to see if a null safety is enabled on this property.
if (fields == -1) {
if (curr == null) {
break;
}
else {
fields = 0;
}
}
first = false;
if (nullSafe && cursor < length) {
assert debug("DUP");
mv.visitInsn(DUP);
Label j = new Label();
assert debug("IFNONNULL : jump");
mv.visitJumpInsn(IFNONNULL, j);
assert debug("ARETURN");
mv.visitInsn(ARETURN);
assert debug("LABEL:jump");
mv.visitLabel(j);
}
}
}
else {
while (cursor < length) {
switch (nextSubToken()) {
case BEAN:
curr = getBeanPropertyAO(curr, capture());
break;
case METH:
curr = getMethod(curr, capture());
break;
case COL:
curr = getCollectionPropertyAO(curr, capture());
break;
case WITH:
curr = getWithProperty(curr);
break;
}
// check to see if a null safety is enabled on this property.
if (fields == -1) {
if (curr == null) {
break;
}
else {
fields = 0;
}
}
first = false;
if (nullSafe && cursor < length) {
assert debug("DUP");
mv.visitInsn(DUP);
Label j = new Label();
assert debug("IFNONNULL : jump");
mv.visitJumpInsn(IFNONNULL, j);
assert debug("ARETURN");
mv.visitInsn(ARETURN);
assert debug("LABEL:jump");
mv.visitLabel(j);
}
}
}
val = curr;
_finishJIT();
return _initializeAccessor();
}
catch (InvocationTargetException e) {
throw new PropertyAccessException(new String(expr), e);
}
catch (IllegalAccessException e) {
throw new PropertyAccessException(new String(expr), e);
}
catch (IndexOutOfBoundsException e) {
throw new PropertyAccessException(new String(expr), e);
}
catch (PropertyAccessException e) {
throw new CompileException(e.getMessage(), e);
}
catch (CompileException e) {
throw e;
}
catch (NullPointerException e) {
throw new PropertyAccessException(new String(expr), e);
}
catch (OptimizationNotSupported e) {
throw e;
}
catch (Exception e) {
throw new CompileException(e.getMessage(), e);
}
}
private Object getWithProperty(Object ctx) {
assert debug("\n ** ENTER -> {with}");
if (first) {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
first = false;
}
String root = new String(expr, 0, cursor - 1).trim();
int start = cursor + 1;
cursor = balancedCaptureWithLineAccounting(expr, cursor, '{', pCtx);
this.returnType = ctx != null ? ctx.getClass() : null;
for (WithNode.ParmValuePair aPvp : WithNode.compileWithExpressions(subset(expr, start, cursor++ - start), root, ingressType, pCtx)) {
assert debug("DUP");
mv.visitInsn(DUP);
assert debug("ASTORE " + (5 + compileDepth) + " (withctx)");
mv.visitVarInsn(ASTORE, 5 + compileDepth);
aPvp.eval(ctx, variableFactory);
if (aPvp.getSetExpression() == null) {
addSubstatement(aPvp.getStatement());
}
else {
compiledInputs.add((ExecutableStatement) aPvp.getSetExpression());
// load set expression
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;");
// ctx
assert debug("ALOAD " + (5 + compileDepth) + "(withctx)");
mv.visitVarInsn(ALOAD, (5 + compileDepth));
// elCtx
assert debug("ALOAD 2");
mv.visitVarInsn(ALOAD, 2);
// variable factory
assert debug("ALOAD 3");
mv.visitVarInsn(ALOAD, 3);
// the value to set.
addSubstatement(aPvp.getStatement());
assert debug("INVOKEINTERFACE Accessor.setValue");
mv.visitMethodInsn(INVOKEINTERFACE, NAMESPACE + "compiler/ExecutableStatement",
"setValue",
"(Ljava/lang/Object;Ljava/lang/Object;L"
+ NAMESPACE + "integration/VariableResolverFactory;Ljava/lang/Object;)Ljava/lang/Object;");
assert debug("POP");
mv.visitInsn(POP);
}
}
return ctx;
}
private Object getBeanPropertyAO(Object ctx, String property)
throws IllegalAccessException, InvocationTargetException {
if (ctx != null && hasPropertyHandler(ctx.getClass())) {
return propHandlerByteCode(property, ctx, ctx.getClass());
}
return getBeanProperty(ctx, property);
}
private Object getBeanProperty(Object ctx, String property)
throws IllegalAccessException, InvocationTargetException {
assert debug("\n ** ENTER -> {bean: " + property + "; ctx=" + ctx + "}");
if ((currType = !first || pCtx == null ? null : pCtx.getVarOrInputTypeOrNull(property)) == Object.class
&& !pCtx.isStrongTyping()) {
currType = null;
}
if (returnType != null && returnType.isPrimitive()) {
//noinspection unchecked
wrapPrimitive(returnType);
}
Class cls = (ctx instanceof Class ? ((Class) ctx) : ctx != null ? ctx.getClass() : null);
if (hasPropertyHandler(cls)) {
PropertyHandler prop = getPropertyHandler(cls);
if (prop instanceof ProducesBytecode) {
((ProducesBytecode) prop).produceBytecodeGet(mv, property, variableFactory);
return prop.getProperty(property, ctx, variableFactory);
}
else {
throw new RuntimeException("unable to compile: custom accessor does not support producing bytecode: "
+ prop.getClass().getName());
}
}
Member member = cls != null ? getFieldOrAccessor(cls, property) : null;
if (member != null && hasGetListeners()) {
mv.visitVarInsn(ALOAD, 1);
mv.visitLdcInsn(member.getName());
mv.visitVarInsn(ALOAD, 3);
mv.visitMethodInsn(INVOKESTATIC, NAMESPACE + "integration/GlobalListenerFactory", "notifyGetListeners",
"(Ljava/lang/Object;Ljava/lang/String;L" + NAMESPACE + "integration/VariableResolverFactory;)V");
notifyGetListeners(ctx, member.getName(), variableFactory);
}
if (first) {
if ("this".equals(property)) {
assert debug("ALOAD 2");
mv.visitVarInsn(ALOAD, 2);
return thisRef;
}
else if (variableFactory != null && variableFactory.isResolveable(property)) {
if (variableFactory.isIndexedFactory() && variableFactory.isTarget(property)) {
int idx;
try {
loadVariableByIndex(idx = variableFactory.variableIndexOf(property));
}
catch (Exception e) {
throw new OptimizationFailure(property);
}
return variableFactory.getIndexedVariableResolver(idx).getValue();
}
else {
try {
loadVariableByName(property);
}
catch (Exception e) {
throw new OptimizationFailure("critical error in JIT", e);
}
return variableFactory.getVariableResolver(property).getValue();
}
}
else {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
}
if (member instanceof Field) {
Object o = ((Field) member).get(ctx);
if (((member.getModifiers() & STATIC) != 0)) {
// Check if the static field reference is a constant and a primitive.
if ((member.getModifiers() & FINAL) != 0 && (o instanceof String || ((Field) member).getType().isPrimitive())) {
o = ((Field) member).get(null);
assert debug("LDC " + valueOf(o));
mv.visitLdcInsn(o);
wrapPrimitive(o.getClass());
if (hasNullPropertyHandler()) {
if (o == null) {
o = getNullPropertyHandler().getProperty(member.getName(), ctx, variableFactory);
}
writeOutNullHandler(member, 0);
}
return o;
}
else {
assert debug("GETSTATIC " + getDescriptor(member.getDeclaringClass()) + "."
+ member.getName() + "::" + getDescriptor(((Field) member).getType()));
mv.visitFieldInsn(GETSTATIC, getInternalName(member.getDeclaringClass()),
member.getName(), getDescriptor(returnType = ((Field) member).getType()));
}
}
else {
assert debug("CHECKCAST " + getInternalName(cls));
mv.visitTypeInsn(CHECKCAST, getInternalName(cls));
assert debug("GETFIELD " + property + ":" + getDescriptor(((Field) member).getType()));
mv.visitFieldInsn(GETFIELD, getInternalName(cls), property, getDescriptor(returnType = ((Field) member)
.getType()));
}
returnType = ((Field) member).getType();
if (hasNullPropertyHandler()) {
if (o == null) {
o = getNullPropertyHandler().getProperty(member.getName(), ctx, variableFactory);
}
writeOutNullHandler(member, 0);
}
return o;
}
else if (member != null) {
Object o;
if (first) {
assert debug("ALOAD 1 (B)");
mv.visitVarInsn(ALOAD, 1);
}
try {
o = ((Method) member).invoke(ctx, EMPTYARG);
if (returnType != member.getDeclaringClass()) {
assert debug("CHECKCAST " + getInternalName(member.getDeclaringClass()));
mv.visitTypeInsn(CHECKCAST, getInternalName(member.getDeclaringClass()));
}
returnType = ((Method) member).getReturnType();
assert debug("INVOKEVIRTUAL " + member.getName() + ":" + returnType);
mv.visitMethodInsn(INVOKEVIRTUAL, getInternalName(member.getDeclaringClass()), member.getName(),
getMethodDescriptor((Method) member));
}
catch (IllegalAccessException e) {
Method iFaceMeth = determineActualTargetMethod((Method) member);
if (iFaceMeth == null)
throw new PropertyAccessException("could not access field: " + cls.getName() + "." + property, e);
assert debug("CHECKCAST " + getInternalName(iFaceMeth.getDeclaringClass()));
mv.visitTypeInsn(CHECKCAST, getInternalName(iFaceMeth.getDeclaringClass()));
returnType = iFaceMeth.getReturnType();
assert debug("INVOKEINTERFACE " + member.getName() + ":" + returnType);
mv.visitMethodInsn(INVOKEINTERFACE, getInternalName(iFaceMeth.getDeclaringClass()), member.getName(),
getMethodDescriptor((Method) member));
o = iFaceMeth.invoke(ctx, EMPTYARG);
}
if (hasNullPropertyHandler()) {
if (o == null) o = getNullPropertyHandler().getProperty(member.getName(), ctx, variableFactory);
writeOutNullHandler(member, 0);
}
return o;
}
else if (ctx instanceof Map && (((Map) ctx).containsKey(property) || nullSafe)) {
assert debug("CHECKCAST java/util/Map");
mv.visitTypeInsn(CHECKCAST, "java/util/Map");
assert debug("LDC: \"" + property + "\"");
mv.visitLdcInsn(property);
assert debug("INVOKEINTERFACE: get");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
return ((Map) ctx).get(property);
}
else if (first && "this".equals(property)) {
assert debug("ALOAD 2");
mv.visitVarInsn(ALOAD, 2); // load the thisRef value.
return this.thisRef;
}
else if ("length".equals(property) && ctx.getClass().isArray()) {
anyArrayCheck(ctx.getClass());
assert debug("ARRAYLENGTH");
mv.visitInsn(ARRAYLENGTH);
wrapPrimitive(int.class);
return getLength(ctx);
}
else if (LITERALS.containsKey(property)) {
Object lit = LITERALS.get(property);
if (lit instanceof Class) {
ldcClassConstant((Class) lit);
}
return lit;
}
else {
Object ts = tryStaticAccess();
if (ts != null) {
if (ts instanceof Class) {
ldcClassConstant((Class) ts);
return ts;
}
else if (ts instanceof Method) {
writeFunctionPointerStub(((Method) ts).getDeclaringClass(), (Method) ts);
return ts;
}
else {
Field f = (Field) ts;
if ((f.getModifiers() & FINAL) != 0) {
Object finalVal = f.get(null);
assert debug("LDC " + valueOf(finalVal));
mv.visitLdcInsn(finalVal);
wrapPrimitive(finalVal.getClass());
return finalVal;
}
else {
assert debug("GETSTATIC " + getInternalName(f.getDeclaringClass()) + "."
+ ((Field) ts).getName() + "::" + getDescriptor(f.getType()));
mv.visitFieldInsn(GETSTATIC, getInternalName(f.getDeclaringClass()),
f.getName(), getDescriptor(returnType = f.getType()));
return f.get(null);
}
}
}
else if (ctx instanceof Class) {
/**
* This is our ugly support for function pointers. This works but needs to be re-thought out at some
* point.
*/
Class c = (Class) ctx;
for (Method m : c.getMethods()) {
if (property.equals(m.getName())) {
if (MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL) {
assert debug("POP");
mv.visitInsn(POP);
assert debug("INVOKESTATIC " + m.getName());
mv.visitMethodInsn(INVOKESTATIC, getInternalName(m.getDeclaringClass()), m.getName(),
getMethodDescriptor(m));
returnType = m.getReturnType();
return m.invoke(null, EMPTY_OBJ_ARR);
}
else {
writeFunctionPointerStub(c, m);
return m;
}
}
}
try {
Class subClass = findClass(variableFactory, c.getName() + "$" + property, pCtx);
ldcClassConstant(subClass);
return subClass;
}
catch (ClassNotFoundException cnfe) {
// fall through.
}
}
else if (MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL) {
return getMethod(ctx, property);
}
throw new PropertyAccessException("could not access: " + property);
}
}
private void writeFunctionPointerStub(Class c, Method m) {
ldcClassConstant(c);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getMethods", "()[Ljava/lang/reflect/Method;");
mv.visitVarInsn(ASTORE, 7);
mv.visitInsn(ICONST_0);
mv.visitVarInsn(ISTORE, 5);
mv.visitVarInsn(ALOAD, 7);
mv.visitInsn(ARRAYLENGTH);
mv.visitVarInsn(ISTORE, 6);
Label l1 = new Label();
mv.visitJumpInsn(GOTO, l1);
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitVarInsn(ALOAD, 7);
mv.visitVarInsn(ILOAD, 5);
mv.visitInsn(AALOAD);
mv.visitVarInsn(ASTORE, 4);
Label l3 = new Label();
mv.visitLabel(l3);
mv.visitLdcInsn(m.getName());
mv.visitVarInsn(ALOAD, 4);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/reflect/Method", "getName", "()Ljava/lang/String;");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z");
Label l4 = new Label();
mv.visitJumpInsn(IFEQ, l4);
Label l5 = new Label();
mv.visitLabel(l5);
mv.visitVarInsn(ALOAD, 4);
mv.visitInsn(ARETURN);
mv.visitLabel(l4);
mv.visitIincInsn(5, 1);
mv.visitLabel(l1);
mv.visitVarInsn(ILOAD, 5);
mv.visitVarInsn(ILOAD, 6);
mv.visitJumpInsn(IF_ICMPLT, l2);
Label l6 = new Label();
mv.visitLabel(l6);
mv.visitInsn(ACONST_NULL);
mv.visitInsn(ARETURN);
deferFinish = true;
}
private Object getCollectionProperty(Object ctx, String prop)
throws IllegalAccessException, InvocationTargetException {
if (prop.trim().length() > 0) {
ctx = getBeanProperty(ctx, prop);
first = false;
}
assert debug("\n ** ENTER -> {collection:<<" + prop + ">>; ctx=" + ctx + "}");
if (first) {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
int start = ++cursor;
skipWhitespace();
if (cursor == length)
throw new CompileException("unterminated '['");
if (scanTo(']'))
throw new CompileException("unterminated '['");
String tk = new String(expr, start, cursor - start);
assert debug("{collection token: [" + tk + "]}");
ExecutableStatement compiled = (ExecutableStatement) subCompileExpression(tk.toCharArray(), pCtx);
Object item = compiled.getValue(ctx, variableFactory);
++cursor;
if (ctx instanceof Map) {
assert debug("CHECKCAST java/util/Map");
mv.visitTypeInsn(CHECKCAST, "java/util/Map");
Class c = writeLiteralOrSubexpression(compiled);
if (c != null && c.isPrimitive()) {
wrapPrimitive(c);
}
assert debug("INVOKEINTERFACE: get");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
return ((Map) ctx).get(item);
}
else if (ctx instanceof List) {
assert debug("CHECKCAST java/util/List");
mv.visitTypeInsn(CHECKCAST, "java/util/List");
writeLiteralOrSubexpression(compiled, int.class);
assert debug("INVOKEINTERFACE: java/util/List.get");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;");
return ((List) ctx).get(convert(item, Integer.class));
}
else if (ctx.getClass().isArray()) {
assert debug("CHECKCAST " + getDescriptor(ctx.getClass()));
mv.visitTypeInsn(CHECKCAST, getDescriptor(ctx.getClass()));
writeLiteralOrSubexpression(compiled, int.class, item.getClass());
Class cls = getBaseComponentType(ctx.getClass());
if (cls.isPrimitive()) {
if (cls == int.class) {
assert debug("IALOAD");
mv.visitInsn(IALOAD);
}
else if (cls == char.class) {
assert debug("CALOAD");
mv.visitInsn(CALOAD);
}
else if (cls == boolean.class) {
assert debug("BALOAD");
mv.visitInsn(BALOAD);
}
else if (cls == double.class) {
assert debug("DALOAD");
mv.visitInsn(DALOAD);
}
else if (cls == float.class) {
assert debug("FALOAD");
mv.visitInsn(FALOAD);
}
else if (cls == short.class) {
assert debug("SALOAD");
mv.visitInsn(SALOAD);
}
else if (cls == long.class) {
assert debug("LALOAD");
mv.visitInsn(LALOAD);
}
else if (cls == byte.class) {
assert debug("BALOAD");
mv.visitInsn(BALOAD);
}
wrapPrimitive(cls);
}
else {
assert debug("AALOAD");
mv.visitInsn(AALOAD);
}
return Array.get(ctx, convert(item, Integer.class));
}
else if (ctx instanceof CharSequence) {
assert debug("CHECKCAST java/lang/CharSequence");
mv.visitTypeInsn(CHECKCAST, "java/lang/CharSequence");
if (item instanceof Integer) {
intPush((Integer) item);
assert debug("INVOKEINTERFACE java/lang/CharSequence.charAt");
mv.visitMethodInsn(INVOKEINTERFACE, "java/lang/CharSequence", "charAt", "(I)C");
wrapPrimitive(char.class);
return ((CharSequence) ctx).charAt((Integer) item);
}
else {
writeLiteralOrSubexpression(compiled, Integer.class);
unwrapPrimitive(int.class);
assert debug("INVOKEINTERFACE java/lang/CharSequence.charAt");
mv.visitMethodInsn(INVOKEINTERFACE, "java/lang/CharSequence", "charAt", "(I)C");
wrapPrimitive(char.class);
return ((CharSequence) ctx).charAt(convert(item, Integer.class));
}
}
else {
TypeDescriptor tDescr = new TypeDescriptor(expr, 0);
if (tDescr.isArray()) {
try {
Class cls = getClassReference((Class) ctx, tDescr, variableFactory, pCtx);
// rootNode = new StaticReferenceAccessor(cls);
ldcClassConstant(cls);
return cls;
}
catch (Exception e) {
//fall through
}
}
throw new CompileException("illegal use of []: unknown type: "
+ (ctx == null ? null : ctx.getClass().getName()));
}
}
private Object getCollectionPropertyAO(Object ctx, String prop)
throws IllegalAccessException, InvocationTargetException {
if (prop.length() > 0) {
ctx = getBeanProperty(ctx, prop);
first = false;
}
assert debug("\n ** ENTER -> {collection:<<" + prop + ">>; ctx=" + ctx + "}");
int start = ++cursor;
skipWhitespace();
if (cursor == length)
throw new CompileException("unterminated '['");
if (scanTo(']'))
throw new CompileException("unterminated '['");
String tk = new String(expr, start, cursor - start);
assert debug("{collection token:<<" + tk + ">>}");
ExecutableStatement compiled = (ExecutableStatement) subCompileExpression(tk.toCharArray());
Object item = compiled.getValue(ctx, variableFactory);
++cursor;
if (ctx instanceof Map) {
if (hasPropertyHandler(Map.class)) {
return propHandlerByteCode(tk, ctx, Map.class);
}
else {
if (first) {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
assert debug("CHECKCAST java/util/Map");
mv.visitTypeInsn(CHECKCAST, "java/util/Map");
Class c = writeLiteralOrSubexpression(compiled);
if (c != null && c.isPrimitive()) {
wrapPrimitive(c);
}
assert debug("INVOKEINTERFACE: Map.get");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
}
return ((Map) ctx).get(item);
}
else if (ctx instanceof List) {
if (hasPropertyHandler(List.class)) {
return propHandlerByteCode(tk, ctx, List.class);
}
else {
if (first) {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
assert debug("CHECKCAST java/util/List");
mv.visitTypeInsn(CHECKCAST, "java/util/List");
writeLiteralOrSubexpression(compiled, int.class);
assert debug("INVOKEINTERFACE: java/util/List.get");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;");
return ((List) ctx).get(convert(item, Integer.class));
}
}
else if (ctx.getClass().isArray()) {
if (hasPropertyHandler(Array.class)) {
return propHandlerByteCode(tk, ctx, Array.class);
}
else {
if (first) {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
assert debug("CHECKCAST " + getDescriptor(ctx.getClass()));
mv.visitTypeInsn(CHECKCAST, getDescriptor(ctx.getClass()));
writeLiteralOrSubexpression(compiled, int.class, item.getClass());
Class cls = getBaseComponentType(ctx.getClass());
if (cls.isPrimitive()) {
if (cls == int.class) {
assert debug("IALOAD");
mv.visitInsn(IALOAD);
}
else if (cls == char.class) {
assert debug("CALOAD");
mv.visitInsn(CALOAD);
}
else if (cls == boolean.class) {
assert debug("BALOAD");
mv.visitInsn(BALOAD);
}
else if (cls == double.class) {
assert debug("DALOAD");
mv.visitInsn(DALOAD);
}
else if (cls == float.class) {
assert debug("FALOAD");
mv.visitInsn(FALOAD);
}
else if (cls == short.class) {
assert debug("SALOAD");
mv.visitInsn(SALOAD);
}
else if (cls == long.class) {
assert debug("LALOAD");
mv.visitInsn(LALOAD);
}
else if (cls == byte.class) {
assert debug("BALOAD");
mv.visitInsn(BALOAD);
}
wrapPrimitive(cls);
}
else {
assert debug("AALOAD");
mv.visitInsn(AALOAD);
}
return Array.get(ctx, convert(item, Integer.class));
}
}
else if (ctx instanceof CharSequence) {
if (hasPropertyHandler(CharSequence.class)) {
return propHandlerByteCode(tk, ctx, CharSequence.class);
}
else {
if (first) {
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
}
assert debug("CHECKCAST java/lang/CharSequence");
mv.visitTypeInsn(CHECKCAST, "java/lang/CharSequence");
if (item instanceof Integer) {
intPush((Integer) item);
assert debug("INVOKEINTERFACE java/lang/CharSequence.charAt");
mv.visitMethodInsn(INVOKEINTERFACE, "java/lang/CharSequence", "charAt", "(I)C");
wrapPrimitive(char.class);
return ((CharSequence) ctx).charAt((Integer) item);
}
else {
writeLiteralOrSubexpression(compiled, Integer.class);
unwrapPrimitive(int.class);
assert debug("INVOKEINTERFACE java/lang/CharSequence.charAt");
mv.visitMethodInsn(INVOKEINTERFACE, "java/lang/CharSequence", "charAt", "(I)C");
wrapPrimitive(char.class);
return ((CharSequence) ctx).charAt(convert(item, Integer.class));
}
}
}
else {
TypeDescriptor tDescr = new TypeDescriptor(expr, 0);
if (tDescr.isArray()) {
try {
Class cls = getClassReference((Class) ctx, tDescr, variableFactory, pCtx);
// rootNode = new StaticReferenceAccessor(cls);
ldcClassConstant(cls);
return cls;
}
catch (Exception e) {
//fall through
}
}
throw new CompileException("illegal use of []: unknown type: " + (ctx == null ? null : ctx.getClass().getName()));
}
}
@SuppressWarnings({"unchecked"})
private Object getMethod(Object ctx, String name)
throws IllegalAccessException, InvocationTargetException {
assert debug("\n ** {method: " + name + "}");
int st = cursor;
String tk = cursor != length && expr[cursor] == '(' && ((cursor = balancedCapture(expr, cursor, '(')) - st) > 1 ?
new String(expr, st + 1, cursor - st - 1) : "";
cursor++;
Object[] preConvArgs;
Object[] args;
Class[] argTypes;
ExecutableStatement[] es;
if (tk.length() == 0) {
args = preConvArgs = ParseTools.EMPTY_OBJ_ARR;
argTypes = ParseTools.EMPTY_CLS_ARR;
es = null;
}
else {
String[] subtokens = parseParameterList(tk.toCharArray(), 0, -1);
es = new ExecutableStatement[subtokens.length];
args = new Object[subtokens.length];
argTypes = new Class[subtokens.length];
preConvArgs = new Object[es.length];
for (int i = 0; i < subtokens.length; i++) {
assert debug("subtoken[" + i + "] { " + subtokens[i] + " }");
preConvArgs[i] = args[i] = (es[i] = (ExecutableStatement) subCompileExpression(subtokens[i].toCharArray(), pCtx))
.getValue(this.ctx, this.thisRef, variableFactory);
}
if (pCtx.isStrictTypeEnforcement()) {
for (int i = 0; i < args.length; i++) {
argTypes[i] = es[i].getKnownEgressType();
}
}
else {
for (int i = 0; i < args.length; i++) {
if (es[i].getKnownEgressType() == Object.class) {
argTypes[i] = args[i] == null ? null : args[i].getClass();
}
else {
argTypes[i] = es[i].getKnownEgressType();
}
}
}
}
if (first && variableFactory != null && variableFactory.isResolveable(name)) {
Object ptr = variableFactory.getVariableResolver(name).getValue();
if (ptr instanceof Method) {
ctx = ((Method) ptr).getDeclaringClass();
name = ((Method) ptr).getName();
}
else if (ptr instanceof MethodStub) {
ctx = ((MethodStub) ptr).getClassReference();
name = ((MethodStub) ptr).getMethodName();
}
else if (ptr instanceof Function) {
if (es != null && es.length != 0) {
compiledInputs.addAll(Arrays.asList(es));
intPush(es.length);
assert debug("ANEWARRAY [" + es.length + "]");
mv.visitTypeInsn(ANEWARRAY, "java/lang/Object");
assert debug("ASTORE 4");
mv.visitVarInsn(ASTORE, 4);
for (int i = 0; i < es.length; i++) {
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
intPush(i);
loadField(i);
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
assert debug("ALOAD 3");
mv.visitIntInsn(ALOAD, 3);
assert debug("INVOKEINTERFACE ExecutableStatement.getValue");
mv.visitMethodInsn(INVOKEINTERFACE, NAMESPACE + "compiler/ExecutableStatement", "getValue",
"(Ljava/lang/Object;L" + NAMESPACE + "integration/VariableResolverFactory;)Ljava/lang/Object;");
assert debug("AASTORE");
mv.visitInsn(AASTORE);
}
}
else {
assert debug("ACONST_NULL");
mv.visitInsn(ACONST_NULL);
assert debug("CHECKCAST java/lang/Object");
mv.visitTypeInsn(CHECKCAST, "[Ljava/lang/Object;");
assert debug("ASTORE 4");
mv.visitVarInsn(ASTORE, 4);
}
if (variableFactory.isIndexedFactory() && variableFactory.isTarget(name)) {
loadVariableByIndex(variableFactory.variableIndexOf(name));
}
else {
loadVariableByName(name);
}
checkcast(Function.class);
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
assert debug("ALOAD 2");
mv.visitVarInsn(ALOAD, 2);
assert debug("ALOAD 3");
mv.visitVarInsn(ALOAD, 3);
assert debug("ALOAD 4");
mv.visitVarInsn(ALOAD, 4);
assert debug("INVOKEVIRTUAL Function.call");
mv.visitMethodInsn(INVOKEVIRTUAL,
getInternalName(Function.class),
"call",
"(Ljava/lang/Object;Ljava/lang/Object;L" + NAMESPACE
+ "integration/VariableResolverFactory;[Ljava/lang/Object;)Ljava/lang/Object;");
return ((Function) ptr).call(ctx, thisRef, variableFactory, args);
}
else {
throw new OptimizationFailure("attempt to optimize a method call for a reference that does not point to a method: "
+ name + " (reference is type: " + (ctx != null ? ctx.getClass().getName() : null) + ")");
}
first = false;
}
else if (returnType != null && returnType.isPrimitive()) {
//noinspection unchecked
wrapPrimitive(returnType);
}
int inputsOffset = compiledInputs.size();
if (es != null) {
for (ExecutableStatement e : es) {
if (e instanceof ExecutableLiteral) {
continue;
}
compiledInputs.add(e);
}
}
if (first) {
assert debug("ALOAD 1 (D) ");
mv.visitVarInsn(ALOAD, 1);
}
/**
* If the target object is an instance of java.lang.Class itself then do not
* adjust the Class scope target.
*/
Class cls = currType != null ? currType : (ctx instanceof Class ? (Class) ctx : ctx.getClass());
currType = null;
Method m;
Class[] parameterTypes = null;
/**
* Try to find an instance method from the class target.
*/
if ((m = getBestCandidate(argTypes, name, cls, cls.getMethods(), false)) != null) {
parameterTypes = m.getParameterTypes();
}
if (m == null) {
/**
* If we didn't find anything, maybe we're looking for the actual java.lang.Class methods.
*/
if ((m = getBestCandidate(argTypes, name, cls, cls.getClass().getDeclaredMethods(), false)) != null) {
parameterTypes = m.getParameterTypes();
}
}
if (m == null) {
StringAppender errorBuild = new StringAppender();
if (parameterTypes != null) {
for (int i = 0; i < args.length; i++) {
errorBuild.append(parameterTypes[i] != null ? parameterTypes[i].getClass().getName() : null);
if (i < args.length - 1) errorBuild.append(", ");
}
}
if ("size".equals(name) && args.length == 0 && cls.isArray()) {
anyArrayCheck(cls);
assert debug("ARRAYLENGTH");
mv.visitInsn(ARRAYLENGTH);
wrapPrimitive(int.class);
return getLength(ctx);
}
throw new CompileException("unable to resolve method: " + cls.getName() + "."
+ name + "(" + errorBuild.toString() + ") [arglength=" + args.length + "]");
}
else {
m = getWidenedTarget(m);
if (es != null) {
ExecutableStatement cExpr;
for (int i = 0; i < es.length; i++) {
if ((cExpr = es[i]).getKnownIngressType() == null) {
cExpr.setKnownIngressType(parameterTypes[i]);
cExpr.computeTypeConversionRule();
}
if (!cExpr.isConvertableIngressEgress()) {
args[i] = convert(args[i], parameterTypes[i]);
}
}
}
else {
/**
* Coerce any types if required.
*/
for (int i = 0; i < args.length; i++) {
args[i] = convert(args[i], parameterTypes[i]);
}
}
if (m.getParameterTypes().length == 0) {
if ((m.getModifiers() & STATIC) != 0) {
assert debug("INVOKESTATIC " + m.getName());
mv.visitMethodInsn(INVOKESTATIC, getInternalName(m.getDeclaringClass()), m.getName(), getMethodDescriptor(m));
}
else {
assert debug("CHECKCAST " + getInternalName(m.getDeclaringClass()));
mv.visitTypeInsn(CHECKCAST, getInternalName(m.getDeclaringClass()));
if (m.getDeclaringClass().isInterface()) {
assert debug("INVOKEINTERFACE " + m.getName());
mv.visitMethodInsn(INVOKEINTERFACE, getInternalName(m.getDeclaringClass()), m.getName(),
getMethodDescriptor(m));
}
else {
assert debug("INVOKEVIRTUAL " + m.getName());
mv.visitMethodInsn(INVOKEVIRTUAL, getInternalName(m.getDeclaringClass()), m.getName(),
getMethodDescriptor(m));
}
}
returnType = m.getReturnType();
stacksize++;
}
else {
if ((m.getModifiers() & STATIC) == 0) {
assert debug("CHECKCAST " + getInternalName(cls));
mv.visitTypeInsn(CHECKCAST, getInternalName(cls));
}
for (int i = 0; i < es.length; i++) {
if (es[i] instanceof ExecutableLiteral) {
ExecutableLiteral literal = (ExecutableLiteral) es[i];
if (literal.getLiteral() == null) {
assert debug("ICONST_NULL");
mv.visitInsn(ACONST_NULL);
continue;
}
else if (parameterTypes[i] == int.class && literal.intOptimized()) {
intPush(literal.getInteger32());
continue;
}
else if (parameterTypes[i] == int.class && preConvArgs[i] instanceof Integer) {
intPush((Integer) preConvArgs[i]);
continue;
}
else if (parameterTypes[i] == boolean.class) {
boolean bool = DataConversion.convert(literal.getLiteral(), Boolean.class);
assert debug(bool ? "ICONST_1" : "ICONST_0");
mv.visitInsn(bool ? ICONST_1 : ICONST_0);
continue;
}
else {
Object lit = literal.getLiteral();
if (parameterTypes[i] == Object.class) {
if (isPrimitiveWrapper(lit.getClass())) {
if (lit.getClass() == Integer.class) {
intPush((Integer) lit);
}
else {
assert debug("LDC " + lit);
mv.visitLdcInsn(lit);
}
wrapPrimitive(lit.getClass());
}
else if (lit instanceof String) {
mv.visitLdcInsn(lit);
checkcast(Object.class);
}
continue;
}
else if (canConvert(parameterTypes[i], lit.getClass())) {
Object c = convert(lit, parameterTypes[i]);
if (c instanceof Class) {
ldcClassConstant((Class) c);
}
else {
assert debug("LDC " + lit + " (" + lit.getClass().getName() + ")");
mv.visitLdcInsn(convert(lit, parameterTypes[i]));
if (isPrimitiveWrapper(parameterTypes[i])) {
wrapPrimitive(lit.getClass());
}
}
continue;
}
}
}
assert debug("ALOAD 0");
mv.visitVarInsn(ALOAD, 0);
assert debug("GETFIELD p" + inputsOffset);
mv.visitFieldInsn(GETFIELD, className, "p" + inputsOffset, "L" + NAMESPACE + "compiler/ExecutableStatement;");
inputsOffset++;
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;");
if (parameterTypes[i].isPrimitive()) {
if (preConvArgs[i] == null ||
(parameterTypes[i] != String.class &&
!parameterTypes[i].isAssignableFrom(preConvArgs[i].getClass()))) {
ldcClassConstant(getWrapperClass(parameterTypes[i]));
assert debug("INVOKESTATIC DataConversion.convert");
mv.visitMethodInsn(INVOKESTATIC, NAMESPACE + "DataConversion", "convert",
"(Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;");
}
unwrapPrimitive(parameterTypes[i]);
}
else if (preConvArgs[i] == null ||
(parameterTypes[i] != String.class &&
!parameterTypes[i].isAssignableFrom(preConvArgs[i].getClass()))) {
ldcClassConstant(parameterTypes[i]);
assert debug("INVOKESTATIC DataConversion.convert");
mv.visitMethodInsn(INVOKESTATIC, NAMESPACE + "DataConversion", "convert",
"(Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;");
assert debug("CHECKCAST " + getInternalName(parameterTypes[i]));
mv.visitTypeInsn(CHECKCAST, getInternalName(parameterTypes[i]));
}
else if (parameterTypes[i] == String.class) {
assert debug("<<>");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/String", "valueOf",
"(Ljava/lang/Object;)Ljava/lang/String;");
}
else {
assert debug("<<>>");
assert debug("<<>>");
assert debug("CHECKCAST " + getInternalName(parameterTypes[i]));
mv.visitTypeInsn(CHECKCAST, getInternalName(parameterTypes[i]));
}
}
if ((m.getModifiers() & STATIC) != 0) {
assert debug("INVOKESTATIC: " + m.getName());
mv.visitMethodInsn(INVOKESTATIC, getInternalName(m.getDeclaringClass()), m.getName(), getMethodDescriptor(m));
}
else {
if (m.getDeclaringClass().isInterface() && (m.getDeclaringClass() != cls
|| (ctx != null && ctx.getClass() != m.getDeclaringClass()))) {
assert debug("INVOKEINTERFACE: " + getInternalName(m.getDeclaringClass()) + "." + m.getName());
mv.visitMethodInsn(INVOKEINTERFACE, getInternalName(m.getDeclaringClass()), m.getName(),
getMethodDescriptor(m));
}
else {
assert debug("INVOKEVIRTUAL: " + getInternalName(cls) + "." + m.getName());
mv.visitMethodInsn(INVOKEVIRTUAL, getInternalName(cls), m.getName(),
getMethodDescriptor(m));
}
}
returnType = m.getReturnType();
stacksize++;
}
Object o = m.invoke(ctx, args);
if (hasNullMethodHandler()) {
writeOutNullHandler(m, 1);
if (o == null) o = getNullMethodHandler().getProperty(m.getName(), ctx, variableFactory);
}
return o;
}
}
private void dataConversion(Class target) {
if (target.equals(Object.class)) return;
ldcClassConstant(target);
assert debug("INVOKESTATIC " + NAMESPACE + "DataConversion.convert");
mv.visitMethodInsn(INVOKESTATIC, NAMESPACE + "DataConversion", "convert",
"(Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;");
}
private static MVELClassLoader classLoader;
public static void setMVELClassLoader(MVELClassLoader cl) {
classLoader = cl;
}
public static MVELClassLoader getMVELClassLoader() {
return classLoader;
}
public void init() {
try {
classLoader = new JITClassLoader(currentThread().getContextClassLoader());
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
private java.lang.Class loadClass(String className, byte[] b) throws Exception {
/**
* This must be synchronized. Two classes cannot be simultaneously deployed in the JVM.
*/
return classLoader.defineClassX(className, b, 0, b.length);
}
private boolean debug(String instruction) {
if (buildLog != null) {
buildLog.append(instruction).append("\n");
}
return true;
}
@SuppressWarnings({"SameReturnValue"})
public String getName() {
return "ASM";
}
public Object getResultOptPass() {
return val;
}
private Class getWrapperClass(Class cls) {
if (cls == boolean.class) {
return Boolean.class;
}
else if (cls == int.class) {
return Integer.class;
}
else if (cls == float.class) {
return Float.class;
}
else if (cls == double.class) {
return Double.class;
}
else if (cls == short.class) {
return Short.class;
}
else if (cls == long.class) {
return Long.class;
}
else if (cls == byte.class) {
return Byte.class;
}
else if (cls == char.class) {
return Character.class;
}
return cls;
}
private void unwrapPrimitive(Class cls) {
if (cls == boolean.class) {
assert debug("CHECKCAST java/lang/Boolean");
mv.visitTypeInsn(CHECKCAST, "java/lang/Boolean");
assert debug("INVOKEVIRTUAL java/lang/Boolean.booleanValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z");
}
else if (cls == int.class) {
assert debug("CHECKCAST java/lang/Integer");
mv.visitTypeInsn(CHECKCAST, "java/lang/Integer");
assert debug("INVOKEVIRTUAL java/lang/Integer.intValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I");
}
else if (cls == float.class) {
assert debug("CHECKCAST java/lang/Float");
mv.visitTypeInsn(CHECKCAST, "java/lang/Float");
assert debug("INVOKEVIRTUAL java/lang/Float.floatValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F");
}
else if (cls == double.class) {
assert debug("CHECKCAST java/lang/Double");
mv.visitTypeInsn(CHECKCAST, "java/lang/Double");
assert debug("INVOKEVIRTUAL java/lang/Double.doubleValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D");
}
else if (cls == short.class) {
assert debug("CHECKCAST java/lang/Short");
mv.visitTypeInsn(CHECKCAST, "java/lang/Short");
assert debug("INVOKEVIRTUAL java/lang/Short.shortValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S");
}
else if (cls == long.class) {
assert debug("CHECKCAST java/lang/Long");
mv.visitTypeInsn(CHECKCAST, "java/lang/Long");
assert debug("INVOKEVIRTUAL java/lang/Long.longValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J");
}
else if (cls == byte.class) {
assert debug("CHECKCAST java/lang/Byte");
mv.visitTypeInsn(CHECKCAST, "java/lang/Byte");
assert debug("INVOKEVIRTUAL java/lang/Byte.byteValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B");
}
else if (cls == char.class) {
assert debug("CHECKCAST java/lang/Character");
mv.visitTypeInsn(CHECKCAST, "java/lang/Character");
assert debug("INVOKEVIRTUAL java/lang/Character.charValue");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C");
}
}
private void wrapPrimitive(Class cls) {
if (OPCODES_VERSION == Opcodes.V1_4) {
/**
* JAVA 1.4 SUCKS! DIE 1.4 DIE!!!
*/
debug("** Using 1.4 Bytecode **");
if (cls == boolean.class || cls == Boolean.class) {
debug("NEW java/lang/Boolean");
mv.visitTypeInsn(NEW, "java/lang/Boolean");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Boolean.::(Z)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Boolean", "", "(Z)V");
}
else if (cls == int.class || cls == Integer.class) {
debug("NEW java/lang/Integer");
mv.visitTypeInsn(NEW, "java/lang/Integer");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Integer.::(I)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Integer", "", "(I)V");
}
else if (cls == float.class || cls == Float.class) {
debug("NEW java/lang/Float");
mv.visitTypeInsn(NEW, "java/lang/Float");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Float.::(F)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Float", "", "(F)V");
}
else if (cls == double.class || cls == Double.class) {
debug("NEW java/lang/Double");
mv.visitTypeInsn(NEW, "java/lang/Double");
debug("DUP X2");
mv.visitInsn(DUP_X2);
debug("DUP X2");
mv.visitInsn(DUP_X2);
debug("POP");
mv.visitInsn(POP);
debug("INVOKESPECIAL java/lang/Double.::(D)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Double", "", "(D)V");
}
else if (cls == short.class || cls == Short.class) {
debug("NEW java/lang/Short");
mv.visitTypeInsn(NEW, "java/lang/Short");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Short.::(S)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Short", "", "(S)V");
}
else if (cls == long.class || cls == Long.class) {
debug("NEW java/lang/Long");
mv.visitTypeInsn(NEW, "java/lang/Long");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Long.::(L)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Float", "", "(L)V");
}
else if (cls == byte.class || cls == Byte.class) {
debug("NEW java/lang/Byte");
mv.visitTypeInsn(NEW, "java/lang/Byte");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Byte.::(B)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Byte", "", "(B)V");
}
else if (cls == char.class || cls == Character.class) {
debug("NEW java/lang/Character");
mv.visitTypeInsn(NEW, "java/lang/Character");
debug("DUP X1");
mv.visitInsn(DUP_X1);
debug("SWAP");
mv.visitInsn(SWAP);
debug("INVOKESPECIAL java/lang/Character.::(C)V");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Character", "", "(C)V");
}
}
else {
if (cls == boolean.class || cls == Boolean.class) {
debug("INVOKESTATIC java/lang/Boolean.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;");
}
else if (cls == int.class || cls == Integer.class) {
debug("INVOKESTATIC java/lang/Integer.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;");
}
else if (cls == float.class || cls == Float.class) {
debug("INVOKESTATIC java/lang/Float.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;");
}
else if (cls == double.class || cls == Double.class) {
debug("INVOKESTATIC java/lang/Double.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;");
}
else if (cls == short.class || cls == Short.class) {
debug("INVOKESTATIC java/lang/Short.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;");
}
else if (cls == long.class || cls == Long.class) {
debug("INVOKESTATIC java/lang/Long.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;");
}
else if (cls == byte.class || cls == Byte.class) {
debug("INVOKESTATIC java/lang/Byte.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;");
}
else if (cls == char.class || cls == Character.class) {
debug("INVOKESTATIC java/lang/Character.valueOf");
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;");
}
}
}
private void anyArrayCheck(Class cls) {
if (cls == boolean[].class) {
assert debug("CHECKCAST [Z");
mv.visitTypeInsn(CHECKCAST, "[Z");
}
else if (cls == int[].class) {
assert debug("CHECKCAST [I");
mv.visitTypeInsn(CHECKCAST, "[I");
}
else if (cls == float[].class) {
assert debug("CHECKCAST [F");
mv.visitTypeInsn(CHECKCAST, "[F");
}
else if (cls == double[].class) {
assert debug("CHECKCAST [D");
mv.visitTypeInsn(CHECKCAST, "[D");
}
else if (cls == short[].class) {
assert debug("CHECKCAST [S");
mv.visitTypeInsn(CHECKCAST, "[S");
}
else if (cls == long[].class) {
assert debug("CHECKCAST [J");
mv.visitTypeInsn(CHECKCAST, "[J");
}
else if (cls == byte[].class) {
assert debug("CHECKCAST [B");
mv.visitTypeInsn(CHECKCAST, "[B");
}
else if (cls == char[].class) {
assert debug("CHECKCAST [C");
mv.visitTypeInsn(CHECKCAST, "[C");
}
else {
assert debug("CHECKCAST [Ljava/lang/Object;");
mv.visitTypeInsn(CHECKCAST, "[Ljava/lang/Object;");
}
}
private void writeOutLiteralWrapped(Object lit) {
if (lit instanceof Integer) {
intPush((Integer) lit);
wrapPrimitive(int.class);
return;
}
assert debug("LDC " + lit);
if (lit instanceof String) {
mv.visitLdcInsn(lit);
}
else if (lit instanceof Long) {
mv.visitLdcInsn(lit);
wrapPrimitive(long.class);
}
else if (lit instanceof Float) {
mv.visitLdcInsn(lit);
wrapPrimitive(float.class);
}
else if (lit instanceof Double) {
mv.visitLdcInsn(lit);
wrapPrimitive(double.class);
}
else if (lit instanceof Short) {
mv.visitLdcInsn(lit);
wrapPrimitive(short.class);
}
else if (lit instanceof Character) {
mv.visitLdcInsn(lit);
wrapPrimitive(char.class);
}
else if (lit instanceof Boolean) {
mv.visitLdcInsn(lit);
wrapPrimitive(boolean.class);
}
else if (lit instanceof Byte) {
mv.visitLdcInsn(lit);
wrapPrimitive(byte.class);
}
}
public void arrayStore(Class cls) {
if (cls.isPrimitive()) {
if (cls == int.class) {
assert debug("IASTORE");
mv.visitInsn(IASTORE);
}
else if (cls == char.class) {
assert debug("CASTORE");
mv.visitInsn(CASTORE);
}
else if (cls == boolean.class) {
assert debug("BASTORE");
mv.visitInsn(BASTORE);
}
else if (cls == double.class) {
assert debug("DASTORE");
mv.visitInsn(DASTORE);
}
else if (cls == float.class) {
assert debug("FASTORE");
mv.visitInsn(FASTORE);
}
else if (cls == short.class) {
assert debug("SASTORE");
mv.visitInsn(SASTORE);
}
else if (cls == long.class) {
assert debug("LASTORE");
mv.visitInsn(LASTORE);
}
else if (cls == byte.class) {
assert debug("BASTORE");
mv.visitInsn(BASTORE);
}
}
else {
assert debug("AASTORE");
mv.visitInsn(AASTORE);
}
}
public void wrapRuntimeConverstion(Class toType) {
ldcClassConstant(getWrapperClass(toType));
assert debug("INVOKESTATIC DataConversion.convert");
mv.visitMethodInsn(INVOKESTATIC, "" + NAMESPACE + "DataConversion", "convert",
"(Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;");
}
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 void loadVariableByName(String name) {
assert debug("ALOAD 3");
mv.visitVarInsn(ALOAD, 3);
assert debug("LDC \"" + name + "\"");
mv.visitLdcInsn(name);
assert debug("INVOKEINTERFACE " + NAMESPACE + "integration/VariableResolverFactory.getVariableResolver");
mv.visitMethodInsn(INVOKEINTERFACE, "" + NAMESPACE + "integration/VariableResolverFactory",
"getVariableResolver", "(Ljava/lang/String;)L" + NAMESPACE + "integration/VariableResolver;");
assert debug("INVOKEINTERFACE " + NAMESPACE + "integration/VariableResolver.getValue");
mv.visitMethodInsn(INVOKEINTERFACE, "" + NAMESPACE + "integration/VariableResolver",
"getValue", "()Ljava/lang/Object;");
returnType = Object.class;
}
private void loadVariableByIndex(int pos) {
assert debug("ALOAD 3");
mv.visitVarInsn(ALOAD, 3);
assert debug("PUSH IDX VAL =" + pos);
intPush(pos);
assert debug("INVOKEINTERFACE " + NAMESPACE + "integration/VariableResolverFactory.getIndexedVariableResolver");
mv.visitMethodInsn(INVOKEINTERFACE, "" + NAMESPACE + "integration/VariableResolverFactory",
"getIndexedVariableResolver", "(I)L" + NAMESPACE + "integration/VariableResolver;");
assert debug("INVOKEINTERFACE " + NAMESPACE + "integration/VariableResolver.getValue");
mv.visitMethodInsn(INVOKEINTERFACE, "" + NAMESPACE + "integration/VariableResolver",
"getValue", "()Ljava/lang/Object;");
returnType = Object.class;
}
private void loadField(int number) {
assert debug("ALOAD 0");
mv.visitVarInsn(ALOAD, 0);
assert debug("GETFIELD p" + number);
mv.visitFieldInsn(GETFIELD, className, "p" + number, "L" + NAMESPACE + "compiler/ExecutableStatement;");
}
private void ldcClassConstant(Class cls) {
if (OPCODES_VERSION == Opcodes.V1_4) {
assert debug("LDC \"" + cls.getName() + "\"");
mv.visitLdcInsn(cls.getName());
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
Label l4 = new Label();
mv.visitJumpInsn(GOTO, l4);
mv.visitTypeInsn(NEW, "java/lang/NoClassDefFoundError");
mv.visitInsn(DUP_X1);
mv.visitInsn(SWAP);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Throwable", "getMessage", "()Ljava/lang/String;");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/NoClassDefFoundError", "", "(Ljava/lang/String;)V");
mv.visitInsn(ATHROW);
mv.visitLabel(l4);
}
else {
assert debug("LDC " + getType(cls));
mv.visitLdcInsn(getType(cls));
}
}
private void buildInputs() {
if (compiledInputs.size() == 0) return;
assert debug("\n{SETTING UP MEMBERS...}\n");
StringAppender constSig = new StringAppender("(");
int size = compiledInputs.size();
for (int i = 0; i < size; i++) {
assert debug("ACC_PRIVATE p" + i);
cw.visitField(ACC_PRIVATE, "p" + i, "L" + NAMESPACE + "compiler/ExecutableStatement;", null, null).visitEnd();
constSig.append("L" + NAMESPACE + "compiler/ExecutableStatement;");
}
constSig.append(")V");
assert debug("\n{CREATING INJECTION CONSTRUCTOR}\n");
MethodVisitor cv = cw.visitMethod(ACC_PUBLIC, "", constSig.toString(), null, null);
cv.visitCode();
assert debug("ALOAD 0");
cv.visitVarInsn(ALOAD, 0);
assert debug("INVOKESPECIAL java/lang/Object.");
cv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V");
for (int i = 0; i < size; i++) {
assert debug("ALOAD 0");
cv.visitVarInsn(ALOAD, 0);
assert debug("ALOAD " + (i + 1));
cv.visitVarInsn(ALOAD, i + 1);
assert debug("PUTFIELD p" + i);
cv.visitFieldInsn(PUTFIELD, className, "p" + i, "L" + NAMESPACE + "compiler/ExecutableStatement;");
}
assert debug("RETURN");
cv.visitInsn(RETURN);
cv.visitMaxs(0, 0);
cv.visitEnd();
assert debug("}");
}
private static final int ARRAY = 0;
private static final int LIST = 1;
private static final int MAP = 2;
private static final int VAL = 3;
private int _getAccessor(Object o, Class type) {
if (o instanceof List) {
assert debug("NEW " + LIST_IMPL);
mv.visitTypeInsn(NEW, LIST_IMPL);
assert debug("DUP");
mv.visitInsn(DUP);
assert debug("DUP");
mv.visitInsn(DUP);
intPush(((List) o).size());
assert debug("INVOKESPECIAL " + LIST_IMPL + ".");
mv.visitMethodInsn(INVOKESPECIAL, LIST_IMPL, "", "(I)V");
for (Object item : (List) o) {
if (_getAccessor(item, type) != VAL) {
assert debug("POP");
mv.visitInsn(POP);
}
assert debug("INVOKEINTERFACE java/util/List.add");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z");
assert debug("POP");
mv.visitInsn(POP);
assert debug("DUP");
mv.visitInsn(DUP);
}
returnType = List.class;
return LIST;
}
else if (o instanceof Map) {
assert debug("NEW " + MAP_IMPL);
mv.visitTypeInsn(NEW, MAP_IMPL);
assert debug("DUP");
mv.visitInsn(DUP);
assert debug("DUP");
mv.visitInsn(DUP);
intPush(((Map) o).size());
assert debug("INVOKESPECIAL " + MAP_IMPL + ".");
mv.visitMethodInsn(INVOKESPECIAL, MAP_IMPL, "", "(I)V");
for (Object item : ((Map) o).keySet()) {
mv.visitTypeInsn(CHECKCAST, "java/util/Map");
if (_getAccessor(item, type) != VAL) {
assert debug("POP");
mv.visitInsn(POP);
}
if (_getAccessor(((Map) o).get(item), type) != VAL) {
assert debug("POP");
mv.visitInsn(POP);
}
assert debug("INVOKEINTERFACE java/util/Map.put");
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
assert debug("POP");
mv.visitInsn(POP);
assert debug("DUP");
mv.visitInsn(DUP);
}
returnType = Map.class;
return MAP;
}
else if (o instanceof Object[]) {
Accessor[] a = new Accessor[((Object[]) o).length];
int i = 0;
int dim = 0;
if (type != null) {
String nm = type.getName();
while (nm.charAt(dim) == '[') dim++;
}
else {
type = Object[].class;
dim = 1;
}
try {
intPush(((Object[]) o).length);
assert debug("ANEWARRAY " + getInternalName(getSubComponentType(type)) + " (" + ((Object[]) o).length + ")");
mv.visitTypeInsn(ANEWARRAY, getInternalName(getSubComponentType(type)));
Class cls = dim > 1 ? findClass(null, repeatChar('[', dim - 1) + "L" + getBaseComponentType(type).getName() + ";", pCtx)
: type;
assert debug("DUP");
mv.visitInsn(DUP);
for (Object item : (Object[]) o) {
intPush(i);
if (_getAccessor(item, cls) != VAL) {
assert debug("POP");
mv.visitInsn(POP);
}
assert debug("AASTORE (" + o.hashCode() + ")");
mv.visitInsn(AASTORE);
assert debug("DUP");
mv.visitInsn(DUP);
i++;
}
}
catch (ClassNotFoundException e) {
throw new RuntimeException("this error should never throw:" + getBaseComponentType(type).getName(), e);
}
return ARRAY;
}
else {
if (type.isArray()) {
writeLiteralOrSubexpression(subCompileExpression(((String) o).toCharArray(), pCtx), getSubComponentType(type));
}
else {
writeLiteralOrSubexpression(subCompileExpression(((String) o).toCharArray(), pCtx));
}
return VAL;
}
}
private Class writeLiteralOrSubexpression(Object stmt) {
return writeLiteralOrSubexpression(stmt, null, null);
}
private Class writeLiteralOrSubexpression(Object stmt, Class desiredTarget) {
return writeLiteralOrSubexpression(stmt, desiredTarget, null);
}
private Class writeLiteralOrSubexpression(Object stmt, Class desiredTarget, Class knownIngressType) {
if (stmt instanceof ExecutableLiteral) {
Class type = ((ExecutableLiteral) stmt).getLiteral().getClass();
assert debug("*** type:" + type + ";desired:" + desiredTarget);
if (type == Integer.class && desiredTarget == int.class) {
intPush(((ExecutableLiteral) stmt).getInteger32());
type = int.class;
}
else if (desiredTarget != null && desiredTarget != type) {
assert debug("*** Converting because desiredType(" + desiredTarget.getClass() + ") is not: " + type);
if (!DataConversion.canConvert(type, desiredTarget)) {
throw new CompileException("was expecting type: " + desiredTarget.getName() + "; but found type: " + type.getName());
}
writeOutLiteralWrapped(convert(((ExecutableLiteral) stmt).getLiteral(), desiredTarget));
}
else {
writeOutLiteralWrapped(((ExecutableLiteral) stmt).getLiteral());
}
return type;
}
else {
literal = false;
addSubstatement((ExecutableStatement) stmt);
Class type;
if (knownIngressType == null) {
type = ((ExecutableStatement) stmt).getKnownEgressType();
}
else {
type = knownIngressType;
}
if (desiredTarget != null && type != desiredTarget) {
if (desiredTarget.isPrimitive()) {
if (type == null) throw new OptimizationFailure("cannot optimize expression: " + new String(expr) +
": cannot determine ingress type for primitive output");
checkcast(type);
unwrapPrimitive(desiredTarget);
}
}
return type;
}
}
private void addPrintOut(String text) {
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn(text);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
}
public Accessor optimizeCollection(ParserContext pCtx, Object o, Class type, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory) {
this.cursor = 0;
this.returnType = type;
if (property != null) this.length = (this.expr = property).length;
this.compiledInputs = new ArrayList();
this.ctx = ctx;
this.thisRef = thisRef;
this.variableFactory = factory;
_initJIT();
literal = true;
_getAccessor(o, type);
_finishJIT();
try {
Accessor compiledAccessor = _initializeAccessor();
if (property != null && property.length > 0) {
return new Union(compiledAccessor, property);
}
else {
return compiledAccessor;
}
}
catch (Exception e) {
throw new OptimizationFailure("could not optimize collection", e);
}
}
private void checkcast(Class cls) {
assert debug("CHECKCAST " + getInternalName(cls));
mv.visitTypeInsn(CHECKCAST, getInternalName(cls));
}
private void intPush(int index) {
if (index < 6) {
switch (index) {
case 0:
assert debug("ICONST_0");
mv.visitInsn(ICONST_0);
break;
case 1:
assert debug("ICONST_1");
mv.visitInsn(ICONST_1);
break;
case 2:
assert debug("ICONST_2");
mv.visitInsn(ICONST_2);
break;
case 3:
assert debug("ICONST_3");
mv.visitInsn(ICONST_3);
break;
case 4:
assert debug("ICONST_4");
mv.visitInsn(ICONST_4);
break;
case 5:
assert debug("ICONST_5");
mv.visitInsn(ICONST_5);
break;
}
}
else if (index > -127 && index < 128) {
assert debug("BIPUSH " + index);
mv.visitIntInsn(BIPUSH, index);
}
else if (index > Short.MAX_VALUE) {
assert debug("LDC " + index);
mv.visitLdcInsn(index);
}
else {
assert debug("SIPUSH " + index);
mv.visitIntInsn(SIPUSH, index);
}
}
public Accessor optimizeObjectCreation(ParserContext pCtx, char[] property, Object ctx, Object thisRef, VariableResolverFactory factory) {
_initJIT();
compiledInputs = new ArrayList();
this.length = (this.expr = property).length;
this.ctx = ctx;
this.thisRef = thisRef;
this.variableFactory = factory;
this.pCtx = pCtx;
String[] cnsRes = captureContructorAndResidual(property);
String[] constructorParms = parseMethodOrConstructor(cnsRes[0].toCharArray());
try {
if (constructorParms != null) {
for (String constructorParm : constructorParms) {
compiledInputs.add((ExecutableStatement) subCompileExpression(constructorParm.toCharArray(), pCtx));
}
Class cls = findClass(factory, new String(subset(property, 0, findFirst('(', property))), pCtx);
assert debug("NEW " + getInternalName(cls));
mv.visitTypeInsn(NEW, getInternalName(cls));
assert debug("DUP");
mv.visitInsn(DUP);
Object[] parms = new Object[constructorParms.length];
int i = 0;
for (ExecutableStatement es : compiledInputs) {
parms[i++] = es.getValue(ctx, factory);
}
Constructor cns = getBestConstructorCandidate(parms, cls, pCtx.isStrongTyping());
if (cns == null) {
StringBuilder error = new StringBuilder();
for (int x = 0; x < parms.length; x++) {
error.append(parms[x].getClass().getName());
if (x + 1 < parms.length) error.append(", ");
}
throw new CompileException("unable to find constructor: " + cls.getName() + "(" + error.toString() + ")");
}
this.returnType = cns.getDeclaringClass();
Class tg;
for (i = 0; i < constructorParms.length; i++) {
assert debug("ALOAD 0");
mv.visitVarInsn(ALOAD, 0);
assert debug("GETFIELD p" + i);
mv.visitFieldInsn(GETFIELD, className, "p" + i, "L" + NAMESPACE + "compiler/ExecutableStatement;");
assert debug("ALOAD 2");
mv.visitVarInsn(ALOAD, 2);
assert debug("ALOAD 3");
mv.visitVarInsn(ALOAD, 3);
assert debug("INVOKEINTERFACE " + NAMESPACE + "compiler/ExecutableStatement.getValue");
mv.visitMethodInsn(INVOKEINTERFACE, "" + NAMESPACE
+ "compiler/ExecutableStatement", "getValue", "(Ljava/lang/Object;L" + NAMESPACE
+ "integration/VariableResolverFactory;)Ljava/lang/Object;");
tg = cns.getParameterTypes()[i].isPrimitive()
? getWrapperClass(cns.getParameterTypes()[i]) : cns.getParameterTypes()[i];
if (parms[i] != null && !parms[i].getClass().isAssignableFrom(cns.getParameterTypes()[i])) {
ldcClassConstant(tg);
assert debug("INVOKESTATIC " + NAMESPACE + "DataConversion.convert");
mv.visitMethodInsn(INVOKESTATIC, "" + NAMESPACE + "DataConversion", "convert",
"(Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;");
if (cns.getParameterTypes()[i].isPrimitive()) {
unwrapPrimitive(cns.getParameterTypes()[i]);
}
else {
assert debug("CHECKCAST " + getInternalName(tg));
mv.visitTypeInsn(CHECKCAST, getInternalName(tg));
}
}
else {
assert debug("CHECKCAST " + getInternalName(cns.getParameterTypes()[i]));
mv.visitTypeInsn(CHECKCAST, getInternalName(cns.getParameterTypes()[i]));
}
}
assert debug("INVOKESPECIAL " + getInternalName(cls) + ". : " + getConstructorDescriptor(cns));
mv.visitMethodInsn(INVOKESPECIAL, getInternalName(cls), "", getConstructorDescriptor(cns));
_finishJIT();
Accessor acc = _initializeAccessor();
if (cnsRes.length > 1 && cnsRes[1] != null && !cnsRes[1].trim().equals("")) {
return new Union(acc, cnsRes[1].toCharArray());
}
return acc;
}
else {
Class cls = findClass(factory, new String(property), pCtx);
assert debug("NEW " + getInternalName(cls));
mv.visitTypeInsn(NEW, getInternalName(cls));
assert debug("DUP");
mv.visitInsn(DUP);
Constructor cns = cls.getConstructor(EMPTYCLS);
assert debug("INVOKESPECIAL ");
mv.visitMethodInsn(INVOKESPECIAL, getInternalName(cls), "", getConstructorDescriptor(cns));
_finishJIT();
Accessor acc = _initializeAccessor();
if (cnsRes.length > 1 && cnsRes[1] != null && !cnsRes[1].trim().equals("")) {
return new Union(acc, cnsRes[1].toCharArray());
}
return acc;
}
}
catch (ClassNotFoundException e) {
throw new CompileException("class or class reference not found: " + new String(property));
}
catch (Exception e) {
throw new OptimizationFailure("could not optimize construtor: " + new String(property), e);
}
}
public Class getEgressType() {
return returnType;
}
private void dumpAdvancedDebugging() {
if (buildLog == null) return;
System.out.println("JIT Compiler Dump for: <<" + (expr == null ? null : new String(expr))
+ ">>\n-------------------------------\n");
System.out.println(buildLog.toString());
System.out.println("\n\n");
if (MVEL.isFileDebugging()) {
try {
FileWriter writer = ParseTools.getDebugFileWriter();
writer.write(buildLog.toString());
writer.flush();
writer.close();
}
catch (IOException e) {
//empty
}
}
}
private Object propHandlerByteCode(String property, Object ctx, Class handler) {
PropertyHandler ph = getPropertyHandler(handler);
if (ph instanceof ProducesBytecode) {
assert debug("<<3rd-Party Code Generation>>");
((ProducesBytecode) ph).produceBytecodeGet(mv, property, variableFactory);
return ph.getProperty(property, ctx, variableFactory);
}
else {
throw new RuntimeException("unable to compile: custom accessor does not support producing bytecode: "
+ ph.getClass().getName());
}
}
private void propHandlerByteCodePut(String property, Object ctx, Class handler, Object value) {
PropertyHandler ph = getPropertyHandler(handler);
if (ph instanceof ProducesBytecode) {
assert debug("<<3rd-Party Code Generation>>");
((ProducesBytecode) ph).produceBytecodePut(mv, property, variableFactory);
ph.setProperty(property, ctx, variableFactory, value);
}
else {
throw new RuntimeException("unable to compile: custom accessor does not support producing bytecode: "
+ ph.getClass().getName());
}
}
private void writeOutNullHandler(Member member, int type) {
assert debug("DUP");
mv.visitInsn(DUP);
Label j = new Label();
assert debug("IFNONNULL : jump");
mv.visitJumpInsn(IFNONNULL, j);
assert debug("POP");
mv.visitInsn(POP);
assert debug("ALOAD 0");
mv.visitVarInsn(ALOAD, 0);
if (type == 0) {
this.propNull = true;
assert debug("GETFIELD 'nullPropertyHandler'");
mv.visitFieldInsn(GETFIELD, className, "nullPropertyHandler", "L" + NAMESPACE + "integration/PropertyHandler;");
}
else {
this.methNull = true;
assert debug("GETFIELD 'nullMethodHandler'");
mv.visitFieldInsn(GETFIELD, className, "nullMethodHandler", "L" + NAMESPACE + "integration/PropertyHandler;");
}
assert debug("LDC '" + member.getName() + "'");
mv.visitLdcInsn(member.getName());
assert debug("ALOAD 1");
mv.visitVarInsn(ALOAD, 1);
assert debug("ALOAD 3");
mv.visitVarInsn(ALOAD, 3);
assert debug("INVOKEINTERFACE PropertyHandler.getProperty");
mv.visitMethodInsn(INVOKEINTERFACE, NAMESPACE + "integration/PropertyHandler", "getProperty",
"(Ljava/lang/String;Ljava/lang/Object;L" + NAMESPACE + "integration/VariableResolverFactory;)Ljava/lang/Object;");
assert debug("LABEL:jump");
mv.visitLabel(j);
}
public boolean isLiteralOnly() {
return literal;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/optimizers/impl/asm/ProducesBytecode.java 0000644 0001750 0001750 00000005106 11077457613 027721 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.optimizers.impl.asm;
import org.mvel2.asm.MethodVisitor;
import org.mvel2.integration.VariableResolverFactory;
/**
* A {@link org.mvel2.integration.PropertyHandler} that implements this class advertises the to the
* {@link ASMAccessorOptimizer} that it is able to generate bytecode for it's custom resolvers.
*
* The two methods defined by this interface (one for get, and one for set accessors) are passed an
* ASM MethodVistor object. It is to be assumed by the implementor that the JIT has already produced
* the necessary bytecode up until this point. The implementor most only implement the necessary bytecode
* instructions to retrieve the property, leaving the resultant value on the stack. DO NOT implement
* bytecode that calls a return instruction such as ARETURN. This will be done automatically by the JIT.
*
* See the following example:
*
* public void produceBytecodeGet(MethodVisitor mv, String propertyName, VariableResolverFactory variableResolverFactory) {
* mv.visitTypeInsn(CHECKCAST, "org/mvel/tests/main/res/SampleBean");
* mv.visitLdcInsn(propertyName);
* mv.visitMethodInsn(INVOKEVIRTUAL, "org/mvel/tests/main/res/SampleBean", "getProperty", "(Ljava/lang/String;)Ljava/lang/Object;");
* }
*
* This example (correctly) presumes that the property of interest exists on the stack, and simply performs the necessary
* CHECKCAST, and call to the needed method in the accessor to translate the property call.
*
* This is taken from a working example which you can examine in the MVEL unit tests.
* The class is: org.mvel.tests.main.res.SampleBeanAccessor
*/
public interface ProducesBytecode {
public void produceBytecodeGet(MethodVisitor mv, String propertyName, VariableResolverFactory factory);
public void produceBytecodePut(MethodVisitor mv, String propertyName, VariableResolverFactory factory);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/debug/ 0000755 0001750 0001750 00000000000 11412747041 020737 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/debug/Debugger.java 0000644 0001750 0001750 00000001740 11077457613 023342 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.debug;
public interface Debugger {
public static int CONTINUE = 0;
public static int STEP = 1;
public static int STEP_OVER = STEP;
/**
* When a breakpoint is recached,
*
* @param frame
* @return continuation command
*/
public int onBreak(Frame frame);
} mvel-2.0.18.orig/src/main/java/org/mvel2/debug/DebugTools.java 0000644 0001750 0001750 00000032510 11165737230 023656 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.debug;
import org.mvel2.Operator;
import static org.mvel2.Operator.ADD;
import static org.mvel2.Operator.SUB;
import org.mvel2.ast.*;
import org.mvel2.compiler.CompiledExpression;
import org.mvel2.compiler.ExecutableAccessor;
import org.mvel2.compiler.ExecutableLiteral;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ASTIterator;
import org.mvel2.util.ASTLinkedList;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* @author Christopher Brock
*/
public class DebugTools {
public static String decompile(Serializable expr) {
if (expr instanceof CompiledExpression) return decompile((CompiledExpression) expr);
else if (expr instanceof ExecutableAccessor)
return "CANNOT DECOMPILE OPTIMIZED STATEMENT (Run with -Dmvel.optimizer=false)";
else if (expr instanceof ExecutableLiteral) {
return "LITERAL: " + ((ExecutableLiteral) expr).getValue(null, null);
}
else return "NOT A KNOWN PAYLOAD: " + expr.getClass().getName();
}
public static String decompile(CompiledExpression cExp) {
return decompile(cExp, false, new DecompileContext());
}
private static final class DecompileContext {
public int node = 0;
}
private static String decompile(CompiledExpression cExp, boolean nest, DecompileContext context) {
ASTIterator iter = new ASTLinkedList(cExp.getFirstNode());
ASTNode tk;
StringBuffer sbuf = new StringBuffer();
if (!nest) {
sbuf.append("Expression Decompile\n-------------\n");
}
while (iter.hasMoreNodes()) {
sbuf.append("(").append(context.node++).append(") ");
if ((tk = iter.nextNode()) instanceof NestedStatement
&& ((NestedStatement) tk).getNestedStatement() instanceof CompiledExpression) {
//noinspection StringConcatenationInsideStringBufferAppend
sbuf.append("NEST [" + tk.getClass().getSimpleName() + "]: { " + tk.getName() + " }\n");
sbuf.append(decompile((CompiledExpression) ((NestedStatement) tk).getNestedStatement(), true, context));
}
if (tk instanceof Substatement
&& ((Substatement) tk).getStatement() instanceof CompiledExpression) {
//noinspection StringConcatenationInsideStringBufferAppend
sbuf.append("NEST [" + tk.getClass().getSimpleName() + "]: { " + tk.getName() + " }\n");
sbuf.append(decompile((CompiledExpression) ((Substatement) tk).getStatement(), true, context));
}
// else if (tk instanceof Function) {
// sbuf.append("FUNCTION [" + tk.getName() + "]: ")
// .append(decompile((CompiledExpression) ((Function)tk).getCompiledBlock(), true, context));
// }
else if (tk.isDebuggingSymbol()) {
//noinspection StringConcatenationInsideStringBufferAppend
sbuf.append("DEBUG_SYMBOL :: " + tk.toString());
}
else if (tk.isLiteral()) {
sbuf.append("LITERAL :: ").append(tk.getLiteralValue()).append("'");
}
else if (tk.isOperator()) {
sbuf.append("OPERATOR [").append(getOperatorName(tk.getOperator())).append("]: ")
.append(tk.getName());
if (tk.isOperator(Operator.END_OF_STMT)) sbuf.append("\n");
}
else if (tk.isIdentifier()) {
sbuf.append("REFERENCE :: ").append(tk.getClass().getSimpleName()).append(":").append(tk.getName());
}
else if (tk instanceof BinaryOperation) {
BinaryOperation bo = (BinaryOperation) tk;
sbuf.append("OPERATION [" + getOperatorName(bo.getOperation()) + "] {").append(bo.getLeft().getName())
.append("} {").append(bo.getRight().getName()).append("}");
}
else {
//noinspection StringConcatenationInsideStringBufferAppend
sbuf.append("NODE [" + tk.getClass().getSimpleName() + "] :: " + tk.getName());
}
sbuf.append("\n");
}
sbuf.append("==END==");
return sbuf.toString();
}
public static String getOperatorSymbol(int operator) {
switch (operator) {
case ADD:
return "+";
case SUB:
return "-";
case Operator.ASSIGN:
return "=";
case Operator.ASSIGN_ADD:
return "=+";
case Operator.ASSIGN_STR_APPEND:
return "=+";
case Operator.ASSIGN_SUB:
return "=";
case Operator.BW_AND:
return "&";
case Operator.BW_OR:
return "|";
case Operator.BW_SHIFT_LEFT:
return "<<";
case Operator.BW_SHIFT_RIGHT:
return ">>";
case Operator.BW_USHIFT_LEFT:
return "<<<";
case Operator.BW_USHIFT_RIGHT:
return ">>>";
case Operator.BW_XOR:
return "^";
case Operator.CONTAINS:
return "contains";
case Operator.CONVERTABLE_TO:
return "convertable_to";
case Operator.DEC:
return "--";
case Operator.DEC_ASSIGN:
return "++";
case Operator.DIV:
return "/";
case Operator.DO:
return "do";
case Operator.ELSE:
return "else";
case Operator.END_OF_STMT:
return ";";
case Operator.EQUAL:
return "==";
case Operator.FOR:
return "for";
case Operator.FOREACH:
return "foreach";
case Operator.FUNCTION:
return "function";
case Operator.GETHAN:
return ">=";
case Operator.GTHAN:
return ">";
case Operator.IF:
return "if";
case Operator.INC:
return "++";
case Operator.INC_ASSIGN:
return "++";
case Operator.INSTANCEOF:
return "instanceof";
case Operator.LETHAN:
return "<=";
case Operator.LTHAN:
return "<";
case Operator.MOD:
return "%";
case Operator.MULT:
return "*";
case Operator.NEQUAL:
return "!=";
case Operator.NEW:
return "new";
case Operator.AND:
return "&&";
case Operator.OR:
return "||";
case Operator.POWER:
return "**";
case Operator.PROJECTION:
return "PROJECT";
case Operator.REGEX:
return "REGEX";
case Operator.RETURN:
return "RETURN";
case Operator.SIMILARITY:
return "SIMILARITY";
case Operator.SOUNDEX:
return "SOUNDEX";
case Operator.STR_APPEND:
return "+";
case Operator.SWITCH:
return "SWITCH";
case Operator.TERNARY:
return "TERNARY_IF";
case Operator.TERNARY_ELSE:
return "TERNARY_ELSE";
case Operator.WHILE:
return "while";
case Operator.CHOR:
return "or";
}
return "UNKNOWN_OPERATOR";
}
public static String getOperatorName(int operator) {
switch (operator) {
case ADD:
return "ADD";
case SUB:
return "SUBTRACT";
case Operator.ASSIGN:
return "ASSIGN";
case Operator.ASSIGN_ADD:
return "ASSIGN_ADD";
case Operator.ASSIGN_STR_APPEND:
return "ASSIGN_STR_APPEND";
case Operator.ASSIGN_SUB:
return "ASSIGN_SUB";
case Operator.BW_AND:
return "BIT_AND";
case Operator.BW_OR:
return "BIT_OR";
case Operator.BW_SHIFT_LEFT:
return "BIT_SHIFT_LEFT";
case Operator.BW_SHIFT_RIGHT:
return "BIT_SHIFT_RIGHT";
case Operator.BW_USHIFT_LEFT:
return "BIT_UNSIGNED_SHIFT_LEFT";
case Operator.BW_USHIFT_RIGHT:
return "BIT_UNSIGNED_SHIFT_RIGHT";
case Operator.BW_XOR:
return "BIT_XOR";
case Operator.CONTAINS:
return "CONTAINS";
case Operator.CONVERTABLE_TO:
return "CONVERTABLE_TO";
case Operator.DEC:
return "DECREMENT";
case Operator.DEC_ASSIGN:
return "DECREMENT_ASSIGN";
case Operator.DIV:
return "DIVIDE";
case Operator.DO:
return "DO";
case Operator.ELSE:
return "ELSE";
case Operator.END_OF_STMT:
return "END_OF_STATEMENT";
case Operator.EQUAL:
return "EQUAL";
case Operator.FOR:
return "FOR";
case Operator.FOREACH:
return "FOREACH";
case Operator.FUNCTION:
return "FUNCTION";
case Operator.GETHAN:
return "GREATER_THAN_OR_EQUAL";
case Operator.GTHAN:
return "GREATHER_THAN";
case Operator.IF:
return "IF";
case Operator.INC:
return "INCREMENT";
case Operator.INC_ASSIGN:
return "INCREMENT_ASSIGN";
case Operator.INSTANCEOF:
return "INSTANCEOF";
case Operator.LETHAN:
return "LESS_THAN_OR_EQUAL";
case Operator.LTHAN:
return "LESS_THAN";
case Operator.MOD:
return "MODULUS";
case Operator.MULT:
return "MULTIPLY";
case Operator.NEQUAL:
return "NOT_EQUAL";
case Operator.NEW:
return "NEW_OBJECT";
case Operator.AND:
return "AND";
case Operator.OR:
return "OR";
case Operator.POWER:
return "POWER_OF";
case Operator.PROJECTION:
return "PROJECT";
case Operator.REGEX:
return "REGEX";
case Operator.RETURN:
return "RETURN";
case Operator.SIMILARITY:
return "SIMILARITY";
case Operator.SOUNDEX:
return "SOUNDEX";
case Operator.STR_APPEND:
return "STR_APPEND";
case Operator.SWITCH:
return "SWITCH";
case Operator.TERNARY:
return "TERNARY_IF";
case Operator.TERNARY_ELSE:
return "TERNARY_ELSE";
case Operator.WHILE:
return "WHILE";
case Operator.CHOR:
return "CHAINED_OR";
}
return "UNKNOWN_OPERATOR";
}
public static Class determineType(String name, CompiledExpression compiledExpression) {
ASTIterator iter = new ASTLinkedList(compiledExpression.getFirstNode());
ASTNode node;
while (iter.hasMoreNodes()) {
if (name.equals((node = iter.nextNode()).getName()) && node.isAssignment()) {
return node.getEgressType();
}
}
return null;
}
public static Map getAllVariableResolvers(VariableResolverFactory rootFactory) {
Map allVariableResolvers = new HashMap();
VariableResolverFactory vrf = rootFactory;
do {
for (String var : vrf.getKnownVariables()) {
allVariableResolvers.put(var, vrf.getVariableResolver(var));
}
}
while ((vrf = vrf.getNextFactory()) != null);
return allVariableResolvers;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/debug/DebuggerContext.java 0000644 0001750 0001750 00000006246 11077457613 024715 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.debug;
import org.mvel2.ast.LineLabel;
import org.mvel2.compiler.CompiledExpression;
import org.mvel2.integration.VariableResolverFactory;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class DebuggerContext {
private Map> breakpoints;
private Debugger debugger;
private int debuggerState = 0;
public DebuggerContext() {
breakpoints = new HashMap>();
}
public Map> getBreakpoints() {
return breakpoints;
}
public void setBreakpoints(Map> breakpoints) {
this.breakpoints = breakpoints;
}
public Debugger getDebugger() {
return debugger;
}
public void setDebugger(Debugger debugger) {
this.debugger = debugger;
}
public int getDebuggerState() {
return debuggerState;
}
public void setDebuggerState(int debuggerState) {
this.debuggerState = debuggerState;
}
// utility methods
public void registerBreakpoint(String sourceFile, int lineNumber) {
if (!breakpoints.containsKey(sourceFile)) breakpoints.put(sourceFile, new HashSet());
breakpoints.get(sourceFile).add(lineNumber);
}
public void removeBreakpoint(String sourceFile, int lineNumber) {
if (!breakpoints.containsKey(sourceFile)) return;
breakpoints.get(sourceFile).remove(lineNumber);
}
public void clearAllBreakpoints() {
breakpoints.clear();
}
public boolean hasBreakpoints() {
return breakpoints.size() != 0;
}
public boolean hasBreakpoint(LineLabel label) {
return breakpoints.containsKey(label.getSourceFile()) && breakpoints.get(label.getSourceFile()).
contains(label.getLineNumber());
}
public boolean hasBreakpoint(String sourceFile, int lineNumber) {
return breakpoints.containsKey(sourceFile) && breakpoints.get(sourceFile).contains(lineNumber);
}
public boolean hasDebugger() {
return debugger != null;
}
public int checkBreak(LineLabel label, VariableResolverFactory factory, CompiledExpression expression) {
if (debuggerState == Debugger.STEP || hasBreakpoint(label)) {
if (debugger == null) throw new RuntimeException("no debugger registered to handle breakpoint");
return debuggerState = debugger.onBreak(new Frame(label, factory, expression.getParserContext()));
}
return 0;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/debug/Frame.java 0000644 0001750 0001750 00000003226 11154053737 022644 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.debug;
import org.mvel2.ParserContext;
import org.mvel2.ast.LineLabel;
import org.mvel2.integration.VariableResolverFactory;
public class Frame {
private LineLabel label;
private VariableResolverFactory factory;
private ParserContext parserContext;
public Frame(LineLabel label, VariableResolverFactory factory, ParserContext pCtx) {
this.label = label;
this.factory = factory;
this.parserContext = pCtx;
}
public String getSourceName() {
return label.getSourceFile();
}
public int getLineNumber() {
return label.getLineNumber();
}
public VariableResolverFactory getFactory() {
return factory;
}
public void setFactory(VariableResolverFactory factory) {
this.factory = factory;
}
public ParserContext getParserContext() {
return parserContext;
}
public void setParserContext(ParserContext parserContext) {
this.parserContext = parserContext;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ConversionException.java 0000644 0001750 0001750 00000002074 11077457613 024535 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
public class ConversionException extends PropertyAccessException {
public ConversionException() {
super();
}
public ConversionException(String message) {
super(message);
}
public ConversionException(String message, Throwable cause) {
super(message, cause);
}
public ConversionException(Throwable cause) {
super(cause);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/MVELRuntime.java 0000644 0001750 0001750 00000021742 11223434233 022625 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import static org.mvel2.Operator.*;
import org.mvel2.ast.ASTNode;
import org.mvel2.ast.LineLabel;
import org.mvel2.compiler.CompiledExpression;
import org.mvel2.debug.Debugger;
import org.mvel2.debug.DebuggerContext;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.ImmutableDefaultFactory;
import org.mvel2.util.ExecutionStack;
import static org.mvel2.util.PropertyTools.isEmpty;
/**
* This class contains the runtime for running compiled MVEL expressions.
*/
@SuppressWarnings({"CaughtExceptionImmediatelyRethrown"})
public class MVELRuntime {
public static final ImmutableDefaultFactory IMMUTABLE_DEFAULT_FACTORY = new ImmutableDefaultFactory();
private static ThreadLocal debuggerContext;
/**
* Main interpreter.
*
* @param debugger Run in debug mode
* @param expression The compiled expression object
* @param ctx The root context object
* @param variableFactory The variable factory to be injected
* @return The resultant value
* @see org.mvel2.MVEL
*/
public static Object execute(boolean debugger, final CompiledExpression expression, final Object ctx,
VariableResolverFactory variableFactory) {
Object v1, v2;
ExecutionStack stk = new ExecutionStack();
ASTNode tk = expression.getFirstNode();
Integer operator;
if (tk == null) return null;
try {
do {
if (tk.fields == -1) {
/**
* This may seem silly and redundant, however, when an MVEL script recurses into a block
* or substatement, a new runtime loop is entered. Since the debugger state is not
* passed through the AST, it is not possible to forward the state directly. So when we
* encounter a debugging symbol, we check the thread local to see if there is are registered
* breakpoints. If we find them, we assume that we are debugging.
*
* The consequence of this of course, is that it's not ideal to compile expressions with
* debugging symbols which you plan to use in a production enviroment.
*/
if (debugger || (debugger = hasDebuggerContext())) {
try {
debuggerContext.get().checkBreak((LineLabel) tk, variableFactory, expression);
}
catch (NullPointerException e) {
// do nothing for now. this isn't as calus as it seems.
}
}
continue;
}
else if (stk.isEmpty()) {
stk.push(tk.getReducedValueAccelerated(ctx, ctx, variableFactory));
}
switch (operator = tk.getOperator()) {
case NOOP:
continue;
case TERNARY:
if (!stk.popBoolean()) {
//noinspection StatementWithEmptyBody
while (tk.nextASTNode != null && !(tk = tk.nextASTNode).isOperator(TERNARY_ELSE)) ;
}
stk.clear();
continue;
case TERNARY_ELSE:
return stk.pop();
case END_OF_STMT:
/**
* If the program doesn't end here then we wipe anything off the stack that remains.
* Althought it may seem like intuitive stack optimizations could be leveraged by
* leaving hanging values on the stack, trust me it's not a good idea.
*/
if (tk.nextASTNode != null) {
stk.clear();
}
continue;
}
stk.push(tk.nextASTNode.getReducedValueAccelerated(ctx, ctx, variableFactory), operator);
try {
while (stk.isReduceable()) {
if ((Integer) stk.peek() == CHOR) {
stk.pop();
v1 = stk.pop();
v2 = stk.pop();
if (!isEmpty(v2) || !isEmpty(v1)) {
stk.clear();
stk.push(!isEmpty(v2) ? v2 : v1);
}
else stk.push(null);
}
else {
stk.op();
}
}
}
catch (ClassCastException e) {
throw new CompileException("syntax error or incomptable types", e);
}
catch (CompileException e) {
throw e;
}
catch (Exception e) {
throw new CompileException("failed to compile sub expression", e);
}
}
while ((tk = tk.nextASTNode) != null);
return stk.peek();
}
catch (NullPointerException e) {
if (tk != null && tk.isOperator() && tk.nextASTNode != null) {
throw new CompileException("incomplete statement: "
+ tk.getName() + " (possible use of reserved keyword as identifier: " + tk.getName() + ")");
}
else {
throw e;
}
}
}
/**
* Register a debugger breakpoint.
*
* @param source - the source file the breakpoint is registered in
* @param line - the line number of the breakpoint
*/
public static void registerBreakpoint(String source, int line) {
ensureDebuggerContext();
debuggerContext.get().registerBreakpoint(source, line);
}
/**
* Remove a specific breakpoint.
*
* @param source - the source file the breakpoint is registered in
* @param line - the line number of the breakpoint to be removed
*/
public static void removeBreakpoint(String source, int line) {
if (hasDebuggerContext()) {
debuggerContext.get().removeBreakpoint(source, line);
}
}
/**
* Tests whether or not a debugger context exist.
*
* @return boolean
*/
private static boolean hasDebuggerContext() {
return debuggerContext != null && debuggerContext.get() != null;
}
/**
* Ensures that debugger context exists.
*/
private static void ensureDebuggerContext() {
if (debuggerContext == null) debuggerContext = new ThreadLocal();
if (debuggerContext.get() == null) debuggerContext.set(new DebuggerContext());
}
/**
* Reset all the currently registered breakpoints.
*/
public static void clearAllBreakpoints() {
if (hasDebuggerContext()) {
debuggerContext.get().clearAllBreakpoints();
}
}
/**
* Tests whether or not breakpoints have been declared.
*
* @return boolean
*/
public static boolean hasBreakpoints() {
return hasDebuggerContext() && debuggerContext.get().hasBreakpoints();
}
/**
* Sets the Debugger instance to handle breakpoints. A debugger may only be registered once per thread.
* Calling this method more than once will result in the second and subsequent calls to simply fail silently.
* To re-register the Debugger, you must call {@link #resetDebugger}
*
* @param debugger - debugger instance
*/
public static void setThreadDebugger(Debugger debugger) {
ensureDebuggerContext();
debuggerContext.get().setDebugger(debugger);
}
/**
* Reset all information registered in the debugger, including the actual attached Debugger and registered
* breakpoints.
*/
public static void resetDebugger() {
debuggerContext = null;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/DataConversion.java 0000644 0001750 0001750 00000010227 11124346473 023441 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import org.mvel2.conversion.*;
import org.mvel2.util.FastList;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
/**
* The DataConversion factory is where all of MVEL's type converters are registered with the runtime.
*
* @author Mike Brock
* @see ConversionHandler
*/
public class DataConversion {
private static final Map CONVERTERS
= new HashMap(38 * 2, 0.5f);
static {
ConversionHandler ch;
CONVERTERS.put(Integer.class, ch = new IntegerCH());
CONVERTERS.put(int.class, ch);
CONVERTERS.put(Short.class, ch = new ShortCH());
CONVERTERS.put(short.class, ch);
CONVERTERS.put(Long.class, ch = new LongCH());
CONVERTERS.put(long.class, ch);
CONVERTERS.put(Character.class, ch = new CharCH());
CONVERTERS.put(char.class, ch);
CONVERTERS.put(Byte.class, ch = new ByteCH());
CONVERTERS.put(byte.class, ch);
CONVERTERS.put(Float.class, ch = new FloatCH());
CONVERTERS.put(float.class, ch);
CONVERTERS.put(Double.class, ch = new DoubleCH());
CONVERTERS.put(double.class, ch);
CONVERTERS.put(Boolean.class, ch = new BooleanCH());
CONVERTERS.put(boolean.class, ch);
CONVERTERS.put(String.class, new StringCH());
CONVERTERS.put(Object.class, new ObjectCH());
CONVERTERS.put(char[].class, ch = new CharArrayCH());
CONVERTERS.put(Character[].class, ch);
CONVERTERS.put(String[].class, new StringArrayCH());
CONVERTERS.put(Integer[].class, new IntArrayCH());
CONVERTERS.put(int[].class, new PrimArrayHandler(int[].class));
CONVERTERS.put(long[].class, new PrimArrayHandler(long[].class));
CONVERTERS.put(double[].class, new PrimArrayHandler(double[].class));
CONVERTERS.put(float[].class, new PrimArrayHandler(float[].class));
CONVERTERS.put(short[].class, new PrimArrayHandler(short[].class));
CONVERTERS.put(boolean[].class, new PrimArrayHandler(boolean[].class));
CONVERTERS.put(BigDecimal.class, new BigDecimalCH());
CONVERTERS.put(BigInteger.class, new BigIntegerCH());
CONVERTERS.put(List.class, ch = new ListCH());
CONVERTERS.put(FastList.class, ch);
CONVERTERS.put(ArrayList.class, ch);
CONVERTERS.put(LinkedList.class, ch);
CONVERTERS.put(Set.class, ch = new SetCH());
CONVERTERS.put(HashSet.class, ch);
CONVERTERS.put(LinkedHashSet.class, ch);
CONVERTERS.put(TreeSet.class, ch);
}
public static boolean canConvert(Class toType, Class convertFrom) {
return (CONVERTERS.containsKey(toType)
&& CONVERTERS.get(toType).canConvertFrom(convertFrom))
|| toType.isAssignableFrom(convertFrom);
}
public static T convert(Object in, Class toType) {
if (in == null) return null;
if (toType == in.getClass() || toType.isAssignableFrom(in.getClass())) {
return (T) in;
}
return (T) CONVERTERS.get(toType).convertFrom(in);
}
/**
* Register a new {@link ConversionHandler} with the factory.
*
* @param type - Target type represented by the conversion handler.
* @param handler - An instance of the handler.
*/
public static void addConversionHandler(Class type, ConversionHandler handler) {
CONVERTERS.put(type, handler);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/MVELInterpretedRuntime.java 0000644 0001750 0001750 00000030367 11355143606 025045 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import static org.mvel2.Operator.*;
import org.mvel2.ast.ASTNode;
import org.mvel2.ast.Substatement;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.compiler.BlankLiteral;
import org.mvel2.compiler.EndWithValue;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import org.mvel2.util.ExecutionStack;
import static org.mvel2.util.ParseTools.findClassImportResolverFactory;
import java.util.Map;
/**
* The MVEL interpreted runtime, used for fast parse and execution of scripts.
*/
@SuppressWarnings({"CaughtExceptionImmediatelyRethrown"})
public class MVELInterpretedRuntime extends AbstractParser {
public Object parse() {
try {
stk = new ExecutionStack();
dStack = new ExecutionStack();
cursor = 0;
return parseAndExecuteInterpreted();
}
catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
throw new ParseException("unexpected end of statement", expr, length);
}
catch (NullPointerException e) {
e.printStackTrace();
if (cursor >= length) {
throw new ParseException("unexpected end of statement", expr, length);
}
else {
throw e;
}
}
catch (EndWithValue end) {
return end.getValue();
}
finally {
if (parserContext != null) contextControl(REMOVE, null, null);
}
}
private Object holdOverRegister;
/**
* Main interpreter loop.
*
* @return value
*/
private Object parseAndExecuteInterpreted() {
ASTNode tk = null;
int operator;
lastWasIdentifier = false;
try {
while ((tk = nextToken()) != null) {
holdOverRegister = null;
if (lastWasIdentifier && lastNode.isDiscard()) {
stk.discard();
}
/**
* If we are at the beginning of a statement, then we immediately push the first token
* onto the stack.
*/
if (stk.isEmpty()) {
stk.push(tk.getReducedValue(ctx, ctx, variableFactory));
/**
* If this is a substatement, we need to move the result into the d-stack to preserve
* proper execution order.
*/
if (tk instanceof Substatement && (tk = nextToken()) != null) {
if (isArithmeticOperator(operator = tk.getOperator())) {
stk.push(nextToken().getReducedValue(ctx, ctx, variableFactory), operator);
if (procBooleanOperator(arithmeticFunctionReduction(operator)) == -1)
return stk.peek();
else
continue;
}
}
else {
continue;
}
}
switch (procBooleanOperator(operator = tk.getOperator())) {
case OP_TERMINATE:
return stk.peek();
case OP_RESET_FRAME:
continue;
case OP_OVERFLOW:
if (!tk.isOperator()) {
if (!(stk.peek() instanceof Class)) {
throw new CompileException("unexpected token: " + tk.getName());
}
variableFactory.createVariable(tk.getName(), null, (Class) stk.peek());
}
continue;
}
stk.push(nextToken().getReducedValue(ctx, ctx, variableFactory), operator);
switch ((operator = arithmeticFunctionReduction(operator))) {
case OP_TERMINATE:
return stk.peek();
case OP_RESET_FRAME:
continue;
}
if (procBooleanOperator(operator) == -1) return stk.peek();
}
if (holdOverRegister != null) {
return holdOverRegister;
}
}
catch (CompileException e) {
e.setExpr(expr);
e.setLineNumber(line + e.getLineNumber());
e.setCursor(cursor);
throw e;
}
catch (NullPointerException e) {
if (tk != null && tk.isOperator()) {
CompileException ce = new CompileException("incomplete statement: "
+ tk.getName() + " (possible use of reserved keyword as identifier: " + tk.getName() + ")", e);
ce.setExpr(expr);
ce.setLineNumber(line);
ce.setCursor(cursor);
throw ce;
}
else {
throw e;
}
}
return stk.peek();
}
private int procBooleanOperator(int operator) {
switch (operator) {
case NOOP:
return -2;
case AND:
reduceRight();
if (!stk.peekBoolean()) {
if (unwindStatement(operator)) {
return -1;
}
else {
stk.clear();
return 0;
}
}
else {
stk.discard();
return 0;
}
case OR:
reduceRight();
if (stk.peekBoolean()) {
if (unwindStatement(operator)) {
return -1;
}
else {
stk.clear();
return 0;
}
}
else {
stk.discard();
return 0;
}
case CHOR:
if (!BlankLiteral.INSTANCE.equals(stk.peek())) {
return -1;
}
break;
case TERNARY:
if (!stk.popBoolean()) {
stk.clear();
ASTNode tk;
while ((tk = nextToken()) != null && !tk.isOperator(Operator.TERNARY_ELSE)) {
//nothing
}
}
return 0;
case TERNARY_ELSE:
captureToEOS();
return 0;
case END_OF_STMT:
/**
* Assignments are a special scenario for dealing with the stack. Assignments are basically like
* held-over failures that basically kickstart the parser when an assignment operator is is
* encountered. The originating token is captured, and the the parser is told to march on. The
* resultant value on the stack is then used to populate the target variable.
*
* The other scenario in which we don't want to wipe the stack, is when we hit the end of the
* statement, because that top stack value is the value we want back from the parser.
*/
if (hasMore()) {
holdOverRegister = stk.pop();
stk.clear();
}
return 0;
}
return 1;
}
/**
* This method peforms the equivilent of an XSWAP operation to flip the operator
* over to the top of the stack, and loads the stored values on the d-stack onto
* the main program stack.
*/
private void reduceRight() {
if (dStack.isEmpty()) return;
Object o = stk.pop();
stk.push(dStack.pop());
stk.push(o);
stk.push(dStack.pop());
reduce();
}
private boolean hasMore() {
return cursor <= length;
}
/**
* This method is called to unwind the current statement without any reduction or further parsing.
*
* @param operator -
* @return -
*/
private boolean unwindStatement(int operator) {
ASTNode tk;
switch (operator) {
case AND:
while ((tk = nextToken()) != null && !tk.isOperator(Operator.END_OF_STMT) && !tk.isOperator(Operator.OR)) {
//nothing
}
break;
default:
while ((tk = nextToken()) != null && !tk.isOperator(Operator.END_OF_STMT)) {
//nothing
}
}
return tk == null;
}
public MVELInterpretedRuntime setExpressionArray(char[] expressionArray) {
this.length = (this.expr = expressionArray).length;
return this;
}
MVELInterpretedRuntime(char[] expression, Object ctx, Map variables) {
this.expr = expression;
this.length = expr.length;
this.ctx = ctx;
this.variableFactory = new MapVariableResolverFactory(variables);
}
MVELInterpretedRuntime(char[] expression, Object ctx) {
this.expr = expression;
this.length = expr.length;
this.ctx = ctx;
this.variableFactory = MVELRuntime.IMMUTABLE_DEFAULT_FACTORY;
}
MVELInterpretedRuntime(String expression) {
setExpression(expression);
this.variableFactory = MVELRuntime.IMMUTABLE_DEFAULT_FACTORY;
}
MVELInterpretedRuntime(char[] expression) {
this.length = (this.expr = expression).length;
}
public MVELInterpretedRuntime(char[] expr, Object ctx, VariableResolverFactory resolverFactory) {
this.length = (this.expr = expr).length;
this.ctx = ctx;
this.variableFactory = resolverFactory;
}
MVELInterpretedRuntime(char[] expr, Object ctx, VariableResolverFactory resolverFactory, boolean returnBigDecimal) {
this.length = (this.expr = expr).length;
this.ctx = ctx;
this.variableFactory = resolverFactory;
}
MVELInterpretedRuntime(Object ctx, Map variables) {
this.ctx = ctx;
this.variableFactory = new MapVariableResolverFactory(variables);
}
public MVELInterpretedRuntime(String expression, Object ctx, VariableResolverFactory resolverFactory) {
setExpression(expression);
this.ctx = ctx;
this.variableFactory = resolverFactory;
}
MVELInterpretedRuntime(String expression, Object ctx, VariableResolverFactory resolverFactory, boolean returnBigDecimal) {
setExpression(expression);
this.ctx = ctx;
this.variableFactory = resolverFactory;
}
MVELInterpretedRuntime(String expression, VariableResolverFactory resolverFactory) {
setExpression(expression);
this.variableFactory = resolverFactory;
}
MVELInterpretedRuntime(String expression, Object ctx) {
setExpression(expression);
this.ctx = ctx;
}
protected boolean hasImport(String name) {
if (pCtx == null) pCtx = getParserContext();
if (pCtx.hasImport(name)) {
return true;
}
else {
VariableResolverFactory vrf = findClassImportResolverFactory(variableFactory);
return vrf != null && vrf.isResolveable(name);
}
}
protected Class getImport(String name) {
if (pCtx == null) pCtx = getParserContext();
if (pCtx.hasImport(name)) return pCtx.getImport(name);
return (Class) findClassImportResolverFactory(variableFactory).getVariableResolver(name).getValue();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ErrorDetail.java 0000644 0001750 0001750 00000003630 11077457613 022744 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 MVFLEX/Valhalla Project and the Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
public class ErrorDetail {
private int row;
private int col;
private boolean critical;
private String message;
public ErrorDetail(String message, boolean critical) {
this.message = message;
this.critical = critical;
}
public ErrorDetail(int row, int col, boolean critical, String message) {
this.row = row;
this.col = col;
this.critical = critical;
this.message = message;
}
public int getRow() {
return row;
}
public void setRow(int row) {
this.row = row;
}
public int getCol() {
return col;
}
public void setCol(int col) {
this.col = col;
}
public boolean isCritical() {
return critical;
}
public void setCritical(boolean critical) {
this.critical = critical;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String toString() {
if (critical) {
return "(" + row + "," + col + ") " + message;
}
else {
return "(" + row + "," + col + ") WARNING: " + message;
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/ 0000755 0001750 0001750 00000000000 11412747045 021467 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/BlankLiteral.java 0000644 0001750 0001750 00000003164 11342137100 024665 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import static java.lang.reflect.Array.getLength;
import static org.mvel2.util.ParseTools.isNumeric;
import java.io.Serializable;
import static java.lang.String.valueOf;
import java.lang.reflect.Array;
import java.util.Collection;
public class BlankLiteral implements Serializable {
public static final BlankLiteral INSTANCE = new BlankLiteral();
public BlankLiteral() {
}
public boolean equals(Object obj) {
if (obj == null || "".equals(valueOf(obj))) {
return true;
}
else if (isNumeric(obj)) {
return "0".equals(valueOf(obj));
}
else if (obj instanceof Collection) {
return ((Collection) obj).size() == 0;
}
else if (obj.getClass().isArray()) {
return getLength(obj) == 0;
}
return false;
}
public String toString() {
return "";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/EndWithValue.java 0000644 0001750 0001750 00000001737 11077457613 024707 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
/**
* @author Christopher Brock
*/
public class EndWithValue extends RuntimeException {
private Object value;
public EndWithValue(Object value) {
this.value = value;
}
public Object getValue() {
return value;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/CompiledExpression.java 0000644 0001750 0001750 00000013573 11224677601 026160 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import static org.mvel2.MVELRuntime.execute;
import org.mvel2.ParserContext;
import org.mvel2.ast.ASTNode;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.ClassImportResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import static org.mvel2.optimizers.OptimizerFactory.setThreadAccessorOptimizer;
import org.mvel2.util.ASTLinkedList;
import org.mvel2.util.StringAppender;
import java.io.Serializable;
public class CompiledExpression implements Serializable, ExecutableStatement {
private ASTNode firstNode;
private Class knownEgressType;
private Class knownIngressType;
private boolean convertableIngressEgress;
private boolean optimized = false;
private boolean importInjectionRequired = false;
private boolean literalOnly;
private Class accessorOptimizer;
private String sourceName;
private ParserContext parserContext;
public CompiledExpression(ASTLinkedList astMap, String sourceName, Class egressType, ParserContext ctx, boolean literalOnly) {
this.firstNode = astMap.firstNode();
this.sourceName = sourceName;
this.knownEgressType = astMap.isSingleNode() ? astMap.firstNonSymbol().getEgressType() : egressType;
this.literalOnly = literalOnly;
setParserContext(ctx);
}
public ASTNode getFirstNode() {
return firstNode;
}
public boolean isSingleNode() {
return firstNode != null && firstNode.nextASTNode == null;
}
public Class getKnownEgressType() {
return knownEgressType;
}
public void setKnownEgressType(Class knownEgressType) {
this.knownEgressType = knownEgressType;
}
public Class getKnownIngressType() {
return knownIngressType;
}
public void setKnownIngressType(Class knownIngressType) {
this.knownIngressType = knownIngressType;
}
public boolean isConvertableIngressEgress() {
return convertableIngressEgress;
}
public void setConvertableIngressEgress(boolean convertableIngressEgress) {
this.convertableIngressEgress = convertableIngressEgress;
}
public void computeTypeConversionRule() {
if (knownIngressType != null && knownEgressType != null) {
convertableIngressEgress = knownIngressType.isAssignableFrom(knownEgressType);
}
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (!optimized) setupOptimizers();
return getValue(ctx, variableFactory);
}
public Object getValue(Object staticContext, VariableResolverFactory factory) {
if (!optimized) setupOptimizers();
if (importInjectionRequired) {
return execute(false, this, staticContext, new ClassImportResolverFactory(parserContext.getParserConfiguration(), factory));
}
else {
return execute(false, this, staticContext, factory);
}
}
public Object getDirectValue(Object staticContext, VariableResolverFactory factory) {
if (importInjectionRequired) {
return execute(false, this, staticContext, new ClassImportResolverFactory(parserContext.getParserConfiguration(), factory));
}
else {
return execute(false, this, staticContext, factory);
}
}
private void setupOptimizers() {
if (accessorOptimizer != null) setThreadAccessorOptimizer(accessorOptimizer);
optimized = true;
}
public boolean isOptimized() {
return optimized;
}
public void setOptimized(boolean optimized) {
this.optimized = optimized;
}
public Class getAccessorOptimizer() {
return accessorOptimizer;
}
public void setAccessorOptimizer(Class accessorOptimizer) {
this.accessorOptimizer = accessorOptimizer;
}
public String getSourceName() {
return sourceName;
}
public void setSourceName(String sourceName) {
this.sourceName = sourceName;
}
public boolean intOptimized() {
return false;
}
public ParserContext getParserContext() {
return parserContext;
}
public void setParserContext(ParserContext parserContext) {
if ((this.parserContext = parserContext) != null) {
this.importInjectionRequired =
parserContext.getImports() != null && parserContext.getImports().size() != 0;
}
}
public boolean isImportInjectionRequired() {
return importInjectionRequired;
}
public void setImportInjectionRequired(boolean importInjectionRequired) {
this.importInjectionRequired = importInjectionRequired;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public boolean isLiteralOnly() {
return literalOnly;
}
public String toString() {
StringAppender appender = new StringAppender();
ASTNode node = firstNode;
while (node != null) {
appender.append(node.toString()).append(";\n");
node = node.nextASTNode;
}
return appender.toString();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/ExecutableAccessor.java 0000644 0001750 0001750 00000004733 11274355331 026104 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.ast.ASTNode;
import org.mvel2.integration.VariableResolverFactory;
public class ExecutableAccessor implements ExecutableStatement {
private ASTNode node;
private Class ingress;
private Class egress;
private boolean convertable;
public ExecutableAccessor(ASTNode node, Class egress) {
this.node = node;
this.egress = egress;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
return node.getReducedValueAccelerated(ctx, elCtx, variableFactory);
}
public Object getValue(Object staticContext, VariableResolverFactory factory) {
return node.getReducedValueAccelerated(staticContext, staticContext, factory);
}
public void setKnownIngressType(Class type) {
this.ingress = type;
}
public void setKnownEgressType(Class type) {
this.egress = type;
}
public Class getKnownIngressType() {
return ingress;
}
public Class getKnownEgressType() {
return egress;
}
public boolean isConvertableIngressEgress() {
return convertable;
}
public void computeTypeConversionRule() {
if (ingress != null && egress != null) {
convertable = ingress.isAssignableFrom(egress);
}
}
public boolean intOptimized() {
return false;
}
public ASTNode getNode() {
return node;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public boolean isLiteralOnly() {
return false;
}
@Override
public String toString() {
return node.toString();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/ExpressionCompiler.java 0000644 0001750 0001750 00000047217 11355143606 026176 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.*;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import static org.mvel2.Operator.PTABLE;
import org.mvel2.ast.*;
import static org.mvel2.ast.ASTNode.COMPILE_IMMEDIATE;
import org.mvel2.util.*;
import static org.mvel2.ast.ASTNode.OPT_SUBTR;
import static org.mvel2.util.CompilerTools.finalizePayload;
import static org.mvel2.util.CompilerTools.signNumber;
import static org.mvel2.util.ParseTools.subCompileExpression;
import static org.mvel2.util.ParseTools.unboxPrimitive;
/**
* This is the main MVEL compiler.
*/
public class ExpressionCompiler extends AbstractParser {
private Class returnType;
private boolean verifyOnly = false;
private boolean verifying = true;
private boolean secondPassOptimization = false;
public CompiledExpression compile() {
return compile(contextControl(GET_OR_CREATE, null, this));
}
@Deprecated
/**
* @deprecated use {@link org.mvel2.MVEL#compileExpression(String, org.mvel2.ParserContext)} instead.
* @param ctx
* @return compile payload.
*/
public CompiledExpression compile(ParserContext ctx) {
try {
this.debugSymbols = (this.pCtx = ctx).isDebugSymbols();
newContext(ctx);
return _compile();
}
finally {
//noinspection ThrowFromFinallyBlock
removeContext();
if (pCtx.isFatalError()) {
contextControl(REMOVE, null, null);
StringAppender err = new StringAppender();
for (ErrorDetail e : pCtx.getErrorList()) {
err.append("\n - ").append("(").append(e.getRow()).append(",").append(e.getCol()).append(")")
.append(" ").append(e.getMessage());
}
//noinspection ThrowFromFinallyBlock
throw new CompileException("Failed to compile: " + pCtx.getErrorList().size()
+ " compilation error(s): " + err.toString(), pCtx.getErrorList());
}
}
}
/**
* Initiate an in-context compile. This method should really only be called by the internal API.
*
* @return compiled expression object
*/
public CompiledExpression _compile() {
ASTNode tk;
ASTNode tkOp;
ASTNode tkOp2;
ASTNode tkLA;
ASTNode tkLA2;
int op, lastOp = -1;
ASTLinkedList astBuild = new ASTLinkedList();
stk = new ExecutionStack();
dStack = new ExecutionStack();
compileMode = true;
boolean firstLA;
if (pCtx == null) pCtx = getParserContext();
try {
if (verifying) {
pCtx.initializeTables();
}
fields |= COMPILE_IMMEDIATE;
while ((tk = nextToken()) != null) {
/**
* If this is a debug symbol, just add it and continue.
*/
if (tk.fields == -1) {
astBuild.addTokenNode(tk);
continue;
}
/**
* Record the type of the current node..
*/
returnType = tk.getEgressType();
if (tk instanceof Substatement) {
ExpressionCompiler subCompiler = new ExpressionCompiler(tk.getNameAsArray(), pCtx);
tk.setAccessor(subCompiler._compile());
returnType = subCompiler.getReturnType();
}
/**
* This kludge of code is to handle compile-time literal reduction. We need to avoid
* reducing for certain literals like, 'this', ternary and ternary else.
*/
if (!verifyOnly && tk.isLiteral()) {
if (literalOnly == -1) literalOnly = 1;
if ((tkOp = nextTokenSkipSymbols()) != null && tkOp.isOperator()
&& !tkOp.isOperator(Operator.TERNARY) && !tkOp.isOperator(Operator.TERNARY_ELSE)) {
/**
* If the next token is ALSO a literal, then we have a candidate for a compile-time literal
* reduction.
*/
if ((tkLA = nextTokenSkipSymbols()) != null && tkLA.isLiteral()
&& tkOp.getOperator() < 34 && ((lastOp == -1
|| (lastOp < PTABLE.length && PTABLE[lastOp] < PTABLE[tkOp.getOperator()])))) {
stk.push(tk.getLiteralValue(), tkLA.getLiteralValue(), op = tkOp.getOperator());
/**
* Reduce the token now.
*/
if (isArithmeticOperator(op)) {
if (!compileReduce(op, astBuild)) continue;
}
else {
reduce();
}
firstLA = true;
/**
* Now we need to check to see if this is a continuing reduction.
*/
while ((tkOp2 = nextTokenSkipSymbols()) != null) {
if (isBooleanOperator(tkOp2.getOperator())) {
astBuild.addTokenNode(new LiteralNode(stk.pop()), verify(pCtx, tkOp2));
break;
}
else if ((tkLA2 = nextTokenSkipSymbols()) != null) {
if (tkLA2.isLiteral()) {
stk.push(tkLA2.getLiteralValue(), op = tkOp2.getOperator());
if (isArithmeticOperator(op)) {
compileReduce(op, astBuild);
}
else {
reduce();
}
}
else {
/**
* A reducable line of literals has ended. We must now terminate here and
* leave the rest to be determined at runtime.
*/
if (!stk.isEmpty()) {
astBuild.addTokenNode(new LiteralNode(getStackValueResult()));
}
astBuild.addTokenNode(new OperatorNode(tkOp2.getOperator()), verify(pCtx, tkLA2));
break;
}
firstLA = false;
literalOnly = 0;
}
else {
if (firstLA) {
/**
* There are more tokens, but we can't reduce anymore. So
* we create a reduced token for what we've got.
*/
astBuild.addTokenNode(new LiteralNode(getStackValueResult()));
}
else {
/**
* We have reduced additional tokens, but we can't reduce
* anymore.
*/
astBuild.addTokenNode(new LiteralNode(getStackValueResult()), tkOp2);
if (tkLA2 != null) astBuild.addTokenNode(verify(pCtx, tkLA2));
}
break;
}
}
/**
* If there are no more tokens left to parse, we check to see if
* we've been doing any reducing, and if so we create the token
* now.
*/
if (!stk.isEmpty())
astBuild.addTokenNode(new LiteralNode(getStackValueResult()));
continue;
}
else {
astBuild.addTokenNode(verify(pCtx, tk), verify(pCtx, tkOp));
if (tkLA != null) astBuild.addTokenNode(verify(pCtx, tkLA));
continue;
}
}
else if (tkOp != null && !tkOp.isOperator() && !(tk.getLiteralValue() instanceof Class)) {
throw new CompileException("unexpected token: " + tkOp.getName());
}
else {
literalOnly = 0;
astBuild.addTokenNode(verify(pCtx, tk));
if (tkOp != null) astBuild.addTokenNode(verify(pCtx, tkOp));
continue;
}
}
else {
if (tk.isOperator()) {
lastOp = tk.getOperator();
}
else {
literalOnly = 0;
}
}
astBuild.addTokenNode(verify(pCtx, tk));
}
astBuild.finish();
if (verifying && !verifyOnly) {
pCtx.processTables();
}
if (!stk.isEmpty()) {
throw new CompileException("COMPILE ERROR: non-empty stack after compile.");
}
if (!verifyOnly) {
return new CompiledExpression(finalizePayload(astBuild, secondPassOptimization, pCtx), pCtx.getSourceFile(), returnType, pCtx, literalOnly == 1);
}
else {
return null;
}
}
catch (NullPointerException e) {
throw new CompileException("not a statement, or badly formed structure", e);
}
catch (CompileException e) {
e.setExpr(expr);
e.setLineNumber(pCtx.getLineCount());
e.setCursor(cursor);
e.setColumn(cursor - pCtx.getLineOffset());
throw e;
}
catch (Throwable e) {
parserContext.set(null);
if (e instanceof RuntimeException) throw (RuntimeException) e;
else {
throw new CompileException(e.getMessage(), e);
}
}
}
private Object getStackValueResult() {
return (fields & OPT_SUBTR) == 0 ? stk.pop() : signNumber(stk.pop());
}
private boolean compileReduce(int opCode, ASTLinkedList astBuild) {
switch (arithmeticFunctionReduction(opCode)) {
case -1:
/**
* The reduction failed because we encountered a non-literal,
* so we must now back out and cleanup.
*/
stk.xswap_op();
astBuild.addTokenNode(new LiteralNode(stk.pop()));
astBuild.addTokenNode(
(OperatorNode) splitAccumulator.pop(),
verify(pCtx, (ASTNode) splitAccumulator.pop())
);
return false;
case -2:
/**
* Back out completely, pull everything back off the stack and add the instructions
* to the output payload as they are.
*/
LiteralNode rightValue = new LiteralNode(stk.pop());
OperatorNode operator = new OperatorNode((Integer) stk.pop());
astBuild.addTokenNode(new LiteralNode(stk.pop()), operator);
astBuild.addTokenNode(rightValue, (OperatorNode) splitAccumulator.pop());
astBuild.addTokenNode(verify(pCtx, (ASTNode) splitAccumulator.pop()));
}
return true;
}
private static boolean isBooleanOperator(int operator) {
return operator == Operator.AND || operator == Operator.OR || operator == Operator.TERNARY || operator == Operator.TERNARY_ELSE;
}
protected ASTNode verify(ParserContext pCtx, ASTNode tk) {
if (tk.isOperator() && (tk.getOperator().equals(Operator.AND) || tk.getOperator().equals(Operator.OR))) {
secondPassOptimization = true;
}
if (tk.isDiscard() || tk.isOperator()) {
return tk;
}
else if (tk.isLiteral()) {
/**
* Convert literal values from the default ASTNode to the more-efficient LiteralNode.
*/
if ((fields & COMPILE_IMMEDIATE) != 0 && tk.getClass() == ASTNode.class) {
return new LiteralNode(tk.getLiteralValue());
}
else {
return tk;
}
}
if (verifying) {
if (tk.isIdentifier()) {
PropertyVerifier propVerifier = new PropertyVerifier(tk.getNameAsArray(), pCtx);
if (tk instanceof Union) {
propVerifier.setCtx(((Union) tk).getLeftEgressType());
tk.setEgressType(returnType = propVerifier.analyze());
}
else {
tk.setEgressType(returnType = propVerifier.analyze());
if (propVerifier.isClassLiteral()) {
return new LiteralNode(returnType);
}
if (propVerifier.isResolvedExternally()) {
pCtx.addInput(tk.getAbsoluteName(), propVerifier.isDeepProperty() ? Object.class : returnType);
}
}
}
else if (tk.isAssignment()) {
Assignment a = (Assignment) tk;
if (a.getAssignmentVar() != null) {
PropertyVerifier propVerifier = new PropertyVerifier(a.getAssignmentVar(), pCtx);
tk.setEgressType(returnType = propVerifier.analyze());
if (!a.isNewDeclaration() && propVerifier.isResolvedExternally()) {
pCtx.addInput(tk.getAbsoluteName(), returnType);
}
ExecutableStatement c = (ExecutableStatement) subCompileExpression(a.getExpression(), pCtx);
if (pCtx.isStrictTypeEnforcement()) {
/**
* If we're using strict type enforcement, we need to see if this coercion can be done now,
* or fail epicly.
*/
if (!returnType.isAssignableFrom(c.getKnownEgressType()) && c.isLiteralOnly()) {
if (canConvert(c.getKnownEgressType(), returnType)) {
/**
* We convert the literal to the proper type.
*/
try {
a.setValueStatement(new ExecutableLiteral(convert(c.getValue(null, null), returnType)));
return tk;
}
catch (Exception e) {
// fall through.
}
}
else if (returnType.isPrimitive()
&& unboxPrimitive(c.getKnownEgressType()).equals(returnType)) {
/**
* We ignore boxed primitive cases, since MVEL does not recognize primitives.
*/
return tk;
}
throw new CompileException(
"cannot assign type " + c.getKnownEgressType().getName()
+ " to " + returnType.getName());
}
}
}
}
else if (tk instanceof NewObjectNode) {
// this is a bit of a hack for now.
NewObjectNode n = (NewObjectNode) tk;
String[] parms = ParseTools.parseMethodOrConstructor(tk.getNameAsArray());
if (parms != null) {
for (String p : parms) {
MVEL.analyze(p, pCtx);
}
}
}
returnType = tk.getEgressType();
}
if (!tk.isLiteral() && tk.getClass() == ASTNode.class && (tk.getFields() & ASTNode.ARRAY_TYPE_LITERAL) == 0) {
if (pCtx.isStrongTyping()) tk.strongTyping();
tk.storePctx();
tk.storeInLiteralRegister(pCtx);
}
return tk;
}
public ExpressionCompiler(String expression) {
setExpression(expression);
}
public ExpressionCompiler(String expression, boolean verifying) {
setExpression(expression);
this.verifying = verifying;
}
public ExpressionCompiler(char[] expression) {
setExpression(expression);
}
public ExpressionCompiler(String expression, ParserContext ctx) {
setExpression(expression);
contextControl(SET, ctx, this);
}
public ExpressionCompiler(char[] expression, ParserContext ctx) {
setExpression(expression);
contextControl(SET, ctx, this);
}
public boolean isVerifying() {
return verifying;
}
public void setVerifying(boolean verifying) {
this.verifying = verifying;
}
public boolean isVerifyOnly() {
return verifyOnly;
}
public void setVerifyOnly(boolean verifyOnly) {
this.verifyOnly = verifyOnly;
}
public Class getReturnType() {
return returnType;
}
public void setReturnType(Class returnType) {
this.returnType = returnType;
}
public String getExpression() {
return new String(expr);
}
public ParserContext getParserContextState() {
return pCtx;
}
public void removeParserContext() {
removeContext();
}
public boolean isLiteralOnly() {
return literalOnly == 1;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/ExecutableStatement.java 0000644 0001750 0001750 00000002501 11077457613 026304 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.integration.VariableResolverFactory;
import java.io.Serializable;
public interface ExecutableStatement extends Accessor, Serializable, Cloneable {
public Object getValue(Object staticContext, VariableResolverFactory factory);
public void setKnownIngressType(Class type);
public void setKnownEgressType(Class type);
public Class getKnownIngressType();
public Class getKnownEgressType();
public boolean isConvertableIngressEgress();
public void computeTypeConversionRule();
public boolean intOptimized();
public boolean isLiteralOnly();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/ExecutableAccessorSafe.java 0000644 0001750 0001750 00000005007 11253550035 026671 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.ast.ASTNode;
import org.mvel2.ast.Safe;
import org.mvel2.integration.VariableResolverFactory;
public class ExecutableAccessorSafe implements ExecutableStatement, Safe {
private ASTNode node;
private Class ingress;
private Class egress;
private boolean convertable;
public ExecutableAccessorSafe(ASTNode node) {
this.node = node;
}
public ExecutableAccessorSafe(ASTNode node, Class returnType) {
this.node = node;
this.egress = returnType;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
return node.getReducedValueAccelerated(ctx, elCtx, variableFactory);
}
public Object getValue(Object staticContext, VariableResolverFactory factory) {
return node.getReducedValueAccelerated(staticContext, staticContext, factory);
}
public void setKnownIngressType(Class type) {
this.ingress = type;
}
public void setKnownEgressType(Class type) {
this.egress = type;
}
public Class getKnownIngressType() {
return ingress;
}
public Class getKnownEgressType() {
return egress;
}
public boolean isConvertableIngressEgress() {
return convertable;
}
public void computeTypeConversionRule() {
if (ingress != null && egress != null) {
convertable = ingress.isAssignableFrom(egress);
}
}
public boolean intOptimized() {
return false;
}
public ASTNode getNode() {
return node;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public boolean isLiteralOnly() {
return false;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/Accessor.java 0000644 0001750 0001750 00000002045 11077457613 024103 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.integration.VariableResolverFactory;
public interface Accessor {
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory);
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value);
public Class getKnownEgressType();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/AbstractParser.java 0000644 0001750 0001750 00000324442 11367363624 025271 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.CompileException;
import org.mvel2.ErrorDetail;
import org.mvel2.Operator;
import static org.mvel2.Operator.*;
import org.mvel2.ParserContext;
import org.mvel2.ast.*;
import static org.mvel2.ast.TypeDescriptor.getClassReference;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ArrayTools.findFirst;
import static org.mvel2.util.ArrayTools.isLiteralOnly;
import org.mvel2.util.ExecutionStack;
import org.mvel2.util.FunctionParser;
import static org.mvel2.util.ParseTools.*;
import static org.mvel2.util.PropertyTools.isEmpty;
import org.mvel2.util.ProtoParser;
import org.mvel2.util.Soundex;
import java.io.Serializable;
import static java.lang.Boolean.FALSE;
import static java.lang.Boolean.TRUE;
import static java.lang.Double.parseDouble;
import static java.lang.Runtime.getRuntime;
import static java.lang.System.getProperty;
import static java.lang.Thread.currentThread;
import java.util.HashMap;
import java.util.WeakHashMap;
/**
* This is the core parser that the subparsers extend.
*
* @author Christopher Brock
*/
public class AbstractParser implements Serializable {
protected char[] expr;
protected int cursor;
protected int start;
protected int length;
protected int fields;
protected static final int OP_OVERFLOW = -2;
protected static final int OP_TERMINATE = -1;
protected static final int OP_RESET_FRAME = 0;
protected static final int OP_CONTINUE = 1;
protected boolean greedy = true;
protected boolean lastWasIdentifier = false;
protected boolean lastWasLineLabel = false;
protected boolean lastWasComment = false;
protected boolean compileMode = false;
protected int literalOnly = -1;
protected int lastLineStart = 0;
protected int line = 0;
protected ASTNode lastNode;
private static final WeakHashMap EX_PRECACHE = new WeakHashMap(15);
public static HashMap LITERALS;
public static HashMap OPERATORS;
protected ExecutionStack stk;
protected ExecutionStack splitAccumulator = new ExecutionStack();
protected static ThreadLocal parserContext;
protected ParserContext pCtx;
protected ExecutionStack dStack;
protected Object ctx;
protected VariableResolverFactory variableFactory;
protected boolean debugSymbols = false;
static {
setupParser();
}
/**
* This method is internally called by the static initializer for AbstractParser in order to setup the parser.
* The static initialization populates the operator and literal tables for the parser. In some situations, like
* OSGi, it may be necessary to utilize this manually.
*/
public static void setupParser() {
if (LITERALS == null || LITERALS.isEmpty()) {
LITERALS = new HashMap();
OPERATORS = new HashMap();
LITERALS.put("true", TRUE);
LITERALS.put("false", FALSE);
LITERALS.put("null", null);
LITERALS.put("nil", null);
LITERALS.put("empty", BlankLiteral.INSTANCE);
/**
* Add System and all the class wrappers from the JCL.
*/
LITERALS.put("System", System.class);
LITERALS.put("String", String.class);
LITERALS.put("CharSequence", CharSequence.class);
LITERALS.put("Integer", Integer.class);
LITERALS.put("int", Integer.class);
LITERALS.put("Long", Long.class);
LITERALS.put("long", Long.class);
LITERALS.put("Boolean", Boolean.class);
LITERALS.put("boolean", Boolean.class);
LITERALS.put("Short", Short.class);
LITERALS.put("short", Short.class);
LITERALS.put("Character", Character.class);
LITERALS.put("char", Character.class);
LITERALS.put("Double", Double.class);
LITERALS.put("double", Double.class);
LITERALS.put("Float", Float.class);
LITERALS.put("float", Float.class);
LITERALS.put("Byte", Byte.class);
LITERALS.put("byte", Byte.class);
LITERALS.put("Math", Math.class);
LITERALS.put("Void", Void.class);
LITERALS.put("Object", Object.class);
LITERALS.put("Number", Number.class);
LITERALS.put("Class", Class.class);
LITERALS.put("ClassLoader", ClassLoader.class);
LITERALS.put("Runtime", Runtime.class);
LITERALS.put("Thread", Thread.class);
LITERALS.put("Compiler", Compiler.class);
LITERALS.put("StringBuffer", StringBuffer.class);
LITERALS.put("ThreadLocal", ThreadLocal.class);
LITERALS.put("SecurityManager", SecurityManager.class);
LITERALS.put("StrictMath", StrictMath.class);
LITERALS.put("Array", java.lang.reflect.Array.class);
if (parseDouble(getProperty("java.version").substring(0, 3)) >= 1.5) {
try {
LITERALS.put("StringBuilder", currentThread().getContextClassLoader().loadClass("java.lang.StringBuilder"));
}
catch (Exception e) {
throw new RuntimeException("cannot resolve a built-in literal", e);
}
}
setLanguageLevel(Boolean.getBoolean("mvel.future.lang.support") ? 6 : 5);
}
}
protected ASTNode nextTokenSkipSymbols() {
ASTNode n = nextToken();
if (n != null && n.getFields() == -1) n = nextToken();
return n;
}
/**
* Retrieve the next token in the expression.
*
* @return -
*/
protected ASTNode nextToken() {
try {
/**
* If the cursor is at the end of the expression, we have nothing more to do:
* return null.
*/
if (!splitAccumulator.isEmpty()) {
lastNode = (ASTNode) splitAccumulator.pop();
if (cursor >= length && lastNode instanceof EndOfStatement) {
return nextToken();
}
else {
return lastNode;
}
}
else if (cursor >= length) {
return null;
}
int brace, idx;
start = cursor;
char[] tmp;
String name;
/**
* Because of parser recursion for sub-expression parsing, we sometimes need to remain
* certain field states. We do not reset for assignments, boolean mode, list creation or
* a capture only mode.
*/
boolean capture = false, union = false;
if ((fields & ASTNode.COMPILE_IMMEDIATE) != 0 && pCtx == null) {
debugSymbols = (pCtx = getParserContext()).isDebugSymbols();
}
if (debugSymbols) {
if (!lastWasLineLabel) {
if (pCtx.getSourceFile() == null) {
throw new CompileException("unable to produce debugging symbols: source name must be provided.");
}
line = pCtx.getLineCount();
skipWhitespace();
if (!pCtx.isKnownLine(pCtx.getSourceFile(), pCtx.setLineCount(line)) && !pCtx.isBlockSymbols()) {
lastWasLineLabel = true;
pCtx.setLineAndOffset(line, cursor);
return lastNode = pCtx.setLastLineLabel(new LineLabel(pCtx.getSourceFile(), line));
}
}
else {
lastWasComment = lastWasLineLabel = false;
}
}
/**
* Skip any whitespace currently under the starting point.
*/
skipWhitespace();
/**
* From here to the end of the method is the core MVEL parsing code. Fiddling around here is asking for
* trouble unless you really know what you're doing.
*/
start = cursor;
Mainloop:
while (cursor != length) {
if (isIdentifierPart(expr[cursor])) {
capture = true;
cursor++;
while (cursor != length && isIdentifierPart(expr[cursor])) cursor++;
}
/**
* If the current character under the cursor is a valid
* part of an identifier, we keep capturing.
*/
if (capture) {
String t;
if (OPERATORS.containsKey(t = new String(expr, start, cursor - start))) {
switch (OPERATORS.get(t)) {
case NEW:
if (!isIdentifierPart(expr[start = cursor = trimRight(cursor)])) {
throw new CompileException("unexpected character (expected identifier): "
+ expr[cursor], expr, cursor);
}
/**
* Capture the beginning part of the token.
*/
do {
captureToNextTokenJunction();
skipWhitespace();
}
while (cursor < length && expr[cursor] == '[');
/**
* If it's not a dimentioned array, continue capturing if necessary.
*/
if (cursor < length && !lastNonWhite(']')) captureToEOT();
TypeDescriptor descr = new TypeDescriptor(subArray(start, cursor), fields);
if (pCtx == null) pCtx = getParserContext();
if (pCtx.hasProtoImport(descr.getClassName())) {
return lastNode = new NewPrototypeNode(descr);
}
lastNode = new NewObjectNode(descr, fields, pCtx);
skipWhitespace();
if (cursor != length && expr[cursor] == '{') {
if (!((NewObjectNode) lastNode).getTypeDescr().isUndimensionedArray()) {
throw new CompileException(
"conflicting syntax: dimensioned array with initializer block",
expr, cursor);
}
start = cursor;
Class egressType = lastNode.getEgressType();
if (egressType == null) {
try {
egressType = getClassReference(pCtx, descr);
}
catch (ClassNotFoundException e) {
throw new CompileException("could not instantiate class", e);
}
}
cursor = balancedCaptureWithLineAccounting(expr, cursor, expr[cursor], pCtx) + 1;
if (tokenContinues()) {
lastNode = new InlineCollectionNode(expr, start, start = cursor, fields,
egressType, pCtx);
captureToEOT();
return lastNode = new Union(expr, start + 1, cursor, fields, lastNode);
}
else {
return lastNode = new InlineCollectionNode(expr, start, cursor, fields,
egressType, pCtx);
}
}
else if (((NewObjectNode) lastNode).getTypeDescr().isUndimensionedArray()) {
throw new CompileException("array initializer expected", expr, cursor);
}
return lastNode;
case ASSERT:
start = cursor = trimRight(cursor);
captureToEOS();
return lastNode = new AssertNode(subArray(start, cursor--), fields, pCtx);
case RETURN:
start = cursor = trimRight(cursor);
captureToEOS();
return lastNode = new ReturnNode(subArray(start, cursor), fields, pCtx);
case IF:
return captureCodeBlock(ASTNode.BLOCK_IF);
case ELSE:
throw new CompileException("else without if", cursor);
case FOREACH:
return captureCodeBlock(ASTNode.BLOCK_FOREACH);
case WHILE:
return captureCodeBlock(ASTNode.BLOCK_WHILE);
case UNTIL:
return captureCodeBlock(ASTNode.BLOCK_UNTIL);
case FOR:
return captureCodeBlock(ASTNode.BLOCK_FOR);
case WITH:
return captureCodeBlock(ASTNode.BLOCK_WITH);
case DO:
return captureCodeBlock(ASTNode.BLOCK_DO);
case PROTO:
return captureCodeBlock(PROTO);
case ISDEF:
start = cursor = trimRight(cursor);
captureToNextTokenJunction();
return lastNode = new IsDef(subArray(start, cursor));
case IMPORT:
start = cursor = trimRight(cursor);
captureToEOS();
ImportNode importNode = new ImportNode(subArray(start, cursor));
if (pCtx == null) pCtx = getParserContext();
if (importNode.isPackageImport()) {
pCtx.addPackageImport(importNode.getPackageImport());
}
else {
pCtx.addImport(importNode.getImportClass().getSimpleName(), importNode.getImportClass());
}
return lastNode = importNode;
case IMPORT_STATIC:
start = cursor = trimRight(cursor);
captureToEOS();
return lastNode = new StaticImportNode(subArray(start, cursor));
case FUNCTION:
lastNode = captureCodeBlock(FUNCTION);
start = cursor + 1;
return lastNode;
case UNTYPED_VAR:
int end;
start = cursor + 1;
while (true) {
captureToEOT();
end = cursor;
skipWhitespace();
if (cursor != length && expr[cursor] == '=') {
if (end == (cursor = start))
throw new CompileException("illegal use of reserved word: var");
continue Mainloop;
}
else {
name = new String(subArray(start, end));
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
splitAccumulator.add(lastNode = new IndexedDeclTypedVarNode(idx, Object.class));
}
else {
splitAccumulator.add(lastNode = new DeclTypedVarNode(name, Object.class,
fields, pCtx));
}
}
if (cursor == length || expr[cursor] != ',') break;
else {
cursor++;
skipWhitespace();
start = cursor;
}
}
return (ASTNode) splitAccumulator.pop();
}
}
skipWhitespace();
/**
* If we *were* capturing a token, and we just hit a non-identifier
* character, we stop and figure out what to do.
*/
if (cursor != length && expr[cursor] == '(') {
cursor = balancedCaptureWithLineAccounting(expr, cursor, '(', pCtx) + 1;
}
/**
* If we encounter any of the following cases, we are still dealing with
* a contiguous token.
*/
CaptureLoop:
while (cursor != length) {
switch (expr[cursor]) {
case '.':
union = true;
cursor++;
skipWhitespace();
continue;
case '?':
if (lookToLast() == '.') {
union = true;
cursor++;
continue;
}
else {
break CaptureLoop;
}
case '+':
switch (lookAhead()) {
case '+':
name = new String(subArray(start, trimLeft(cursor)));
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
lastNode = new IndexedPostFixIncNode(idx);
}
else {
lastNode = new PostFixIncNode(name);
}
cursor += 2;
expectEOS();
return lastNode;
case '=':
name = createStringTrimmed(expr, start, cursor - start);
start = cursor += 2;
captureToEOS();
if (union) {
return lastNode = new DeepAssignmentNode(subArray(start, cursor), fields,
ADD, name, pCtx);
}
else if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedAssignmentNode(subArray(start, cursor), fields,
ADD, name, idx, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
ADD, fields, pCtx);
}
}
if (isDigit(lookAhead()) &&
cursor > 1 && (expr[cursor - 1] == 'E' || expr[cursor - 1] == 'e')
&& isDigit(expr[cursor - 2])) {
cursor++;
// capture = true;
continue Mainloop;
}
break CaptureLoop;
case '-':
switch (lookAhead()) {
case '-':
name = new String(subArray(start, trimLeft(cursor)));
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
lastNode = new IndexedPostFixDecNode(idx);
}
else {
lastNode = new PostFixDecNode(name);
}
cursor += 2;
expectEOS();
return lastNode;
case '=':
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 2;
captureToEOS();
if (union) {
return lastNode = new DeepAssignmentNode(subArray(start, cursor), fields,
SUB, t, pCtx);
}
else if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
SUB, idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
SUB, fields, pCtx);
}
}
if (isDigit(lookAhead()) &&
cursor > 1 && (expr[cursor - 1] == 'E' || expr[cursor - 1] == 'e')
&& isDigit(expr[cursor - 2])) {
cursor++;
capture = true;
continue Mainloop;
}
break CaptureLoop;
/**
* Exit immediately for any of these cases.
*/
case '!':
case ',':
case '"':
case '\'':
case ';':
case ':':
break CaptureLoop;
case '\u00AB': // special compact code for recursive parses
case '\u00BB':
case '\u00AC':
case '&':
case '^':
case '|':
case '*':
case '/':
case '%':
char op = expr[cursor];
if (lookAhead() == '=') {
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 2;
captureToEOS();
if (union) {
return lastNode = new DeepAssignmentNode(subArray(start, cursor), fields,
opLookup(op), t, pCtx);
}
else if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
opLookup(op), idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
opLookup(op), fields, pCtx);
}
}
break CaptureLoop;
case '<':
if ((lookAhead() == '<' && lookAhead(2) == '=')) {
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 3;
captureToEOS();
if (union) {
return lastNode = new DeepAssignmentNode(subArray(start, cursor), fields,
BW_SHIFT_LEFT, t, pCtx);
}
else if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
BW_SHIFT_LEFT, idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
BW_SHIFT_LEFT, fields, pCtx);
}
}
break CaptureLoop;
case '>':
if (lookAhead() == '>') {
if (lookAhead(2) == '=') {
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 3;
captureToEOS();
if (union) {
return lastNode = new DeepAssignmentNode(subArray(start, cursor), fields,
BW_SHIFT_RIGHT, t, pCtx);
}
else if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
BW_SHIFT_RIGHT, idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
BW_SHIFT_RIGHT, fields, pCtx);
}
}
else if ((lookAhead(2) == '>' && lookAhead(3) == '=')) {
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 4;
captureToEOS();
if (union) {
return lastNode = new DeepAssignmentNode(subArray(start, cursor), fields,
BW_USHIFT_RIGHT, t, pCtx);
}
else if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
BW_USHIFT_RIGHT, idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
BW_USHIFT_RIGHT, fields, pCtx);
}
}
}
break CaptureLoop;
case '(':
cursor = balancedCaptureWithLineAccounting(expr, cursor, '(', pCtx) + 1;
continue;
case '[':
cursor = balancedCaptureWithLineAccounting(expr, cursor, '[', pCtx) + 1;
continue;
case '{':
if (!union) break CaptureLoop;
cursor = balancedCaptureWithLineAccounting(expr, cursor, '{', pCtx) + 1;
continue;
case '~':
if (lookAhead() == '=') {
tmp = subArray(start, trimLeft(cursor));
start = cursor += 2;
captureToEOT();
return lastNode = new RegExMatch(tmp, fields, subArray(start, cursor), pCtx);
}
break CaptureLoop;
case '=':
if (lookAhead() == '+') {
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 2;
if (!isNextIdentifierOrLiteral()) {
throw new CompileException("unexpected symbol '" + expr[cursor] + "'", expr, cursor);
}
captureToEOS();
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
ADD, idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
ADD, fields, pCtx);
}
}
else if (lookAhead() == '-') {
name = new String(expr, start, trimLeft(cursor) - start);
start = cursor += 2;
if (!isNextIdentifierOrLiteral()) {
throw new CompileException("unexpected symbol '" + expr[cursor] + "'", expr, cursor);
}
captureToEOS();
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedOperativeAssign(subArray(start, cursor),
SUB, idx, fields, pCtx);
}
else {
return lastNode = new OperativeAssign(name, subArray(start, cursor),
SUB, fields, pCtx);
}
}
if (greedy && lookAhead() != '=') {
cursor++;
if (union) {
captureToEOS();
return lastNode = new DeepAssignmentNode(subArray(start, cursor),
fields | ASTNode.ASSIGN, pCtx);
}
else if (lastWasIdentifier) {
return procTypedNode(false);
}
else if (pCtx != null && ((idx = pCtx.variableIndexOf(t)) != -1
|| (pCtx.isIndexAllocation()))) {
captureToEOS();
IndexedAssignmentNode ian = new IndexedAssignmentNode(subArray(start, cursor),
ASTNode.ASSIGN, idx, pCtx);
if (idx == -1) {
pCtx.addIndexedVariable(t = ian.getAssignmentVar());
ian.setRegister(pCtx.variableIndexOf(t));
}
return lastNode = ian;
}
else {
captureToEOS();
return lastNode = new AssignmentNode(subArray(start, cursor),
fields | ASTNode.ASSIGN, pCtx);
}
}
break CaptureLoop;
default:
if (cursor != length) {
if (isIdentifierPart(expr[cursor])) {
if (!union) {
break CaptureLoop;
}
cursor++;
while (cursor != length && isIdentifierPart(expr[cursor])) cursor++;
}
else if ((cursor + 1) != length && isIdentifierPart(expr[cursor + 1])) {
break CaptureLoop;
}
else {
cursor++;
}
}
else {
break CaptureLoop;
}
}
}
/**
* Produce the token.
*/
trimWhitespace();
return createPropertyToken(start, cursor);
}
else {
switch (expr[cursor]) {
case '.': {
cursor++;
if (isDigit(expr[cursor])) {
capture = true;
continue;
}
expectNextChar_IW('{');
return lastNode = new ThisWithNode(subArray(start, cursor - 1),
subArray(cursor + 1,
(cursor = balancedCaptureWithLineAccounting(expr,
start = cursor, '{', pCtx) + 1) - 1), fields, pCtx);
}
case '@': {
start++;
captureToEOT();
if (pCtx == null || (pCtx.getInterceptors() == null || !pCtx.getInterceptors().
containsKey(name = new String(expr, start, cursor - start)))) {
throw new CompileException("reference to undefined interceptor: "
+ new String(expr, start, cursor - start), expr, cursor);
}
return lastNode = new InterceptorWrapper(pCtx.getInterceptors().get(name), nextToken());
}
case '=':
return createOperator(expr, start, (cursor += 2));
case '-':
if (lookAhead() == '-') {
cursor += 2;
skipWhitespace();
start = cursor;
captureIdentifier();
name = new String(subArray(start, cursor));
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedPreFixDecNode(idx);
}
else {
return lastNode = new PreFixDecNode(name);
}
}
else if ((cursor == 0 || (lastNode != null &&
(lastNode instanceof BooleanNode || lastNode.isOperator())))
&& !isDigit(lookAhead())) {
captureToEOT();
return new Sign(expr, start, cursor, fields, pCtx);
}
else if ((cursor != 0 && !isWhitespace(expr[cursor - 1]) && (
!(lastNode != null && (lastNode instanceof BooleanNode || lastNode.isOperator()))))
|| !isDigit(lookAhead())) {
return createOperator(expr, start, cursor++ + 1);
}
else if ((cursor - 1) != 0 || (!isDigit(expr[cursor - 1])) && isDigit(lookAhead())) {
cursor++;
break;
}
else {
throw new CompileException("not a statement", expr, cursor);
}
case '+':
if (lookAhead() == '+') {
cursor += 2;
skipWhitespace();
start = cursor;
captureIdentifier();
name = new String(subArray(start, cursor));
if (pCtx != null && (idx = pCtx.variableIndexOf(name)) != -1) {
return lastNode = new IndexedPreFixIncNode(idx);
}
else {
return lastNode = new PreFixIncNode(name);
}
}
return createOperator(expr, start, cursor++ + 1);
case '*':
if (lookAhead() == '*') {
cursor++;
}
return createOperator(expr, start, cursor++ + 1);
case ';':
cursor++;
lastWasIdentifier = false;
return lastNode = new EndOfStatement();
case '#':
case '/':
case '?':
case ':':
case '^':
case '%': {
return createOperator(expr, start, cursor++ + 1);
}
case '(': {
cursor++;
boolean singleToken = true;
boolean lastWS = false;
skipWhitespace();
for (brace = 1; cursor != length && brace != 0; cursor++) {
switch (expr[cursor]) {
case '(':
brace++;
break;
case ')':
brace--;
break;
case '\'':
cursor = captureStringLiteral('\'', expr, cursor, length);
break;
case '"':
cursor = captureStringLiteral('"', expr, cursor, length);
break;
case 'i':
if (brace == 1 && lookAhead() == 'n' && isWhitespace(lookAhead(2))) {
for (int level = brace; cursor != length; cursor++) {
switch (expr[cursor]) {
case '(':
brace++;
break;
case ')':
if (--brace < level) {
cursor++;
if (tokenContinues()) {
lastNode = new Fold(subset(expr, trimRight(start + 1),
cursor - start - 2), fields, pCtx);
if (expr[start = cursor] == '.') start++;
captureToEOT();
return lastNode = new Union(expr, trimRight(start),
cursor, fields, lastNode);
}
else {
return lastNode = new Fold(subset(expr, trimRight(start + 1),
cursor - start - 2), fields, pCtx);
}
}
break;
case '\'':
cursor = captureStringLiteral('\'', expr, cursor, length);
break;
case '"':
cursor = captureStringLiteral('\"', expr, cursor, length);
break;
}
}
throw new CompileException("unterminated projection; closing parathesis required",
expr, cursor);
}
break;
default:
/**
* Check to see if we should disqualify this current token as a potential
* type-cast candidate.
*/
if (lastWS) {
if (expr[cursor] != '.') {
switch (expr[cursor]) {
case '[':
case ']':
break;
default:
if (!(isIdentifierPart(expr[cursor]) || expr[cursor] == '.')) {
singleToken = false;
}
}
}
}
else if (isWhitespace(expr[cursor]) || cursor == 1) {
lastWS = true;
skipWhitespace();
cursor--;
}
}
}
if (brace != 0) {
throw new CompileException("unbalanced braces in expression: (" + brace + "):",
expr, cursor);
}
tmp = null;
if (singleToken) {
int st;
TypeDescriptor tDescr = new TypeDescriptor(
tmp = subset(expr, st = trimRight(start + 1),
trimLeft(cursor - 1) - st), fields);
Class cls;
try {
if (tDescr.isClass() && (cls = getClassReference(pCtx, tDescr)) != null) {
start = cursor;
captureToEOS();
return lastNode = new TypeCast(subset(expr, start, cursor - start),
cls, fields, pCtx);
}
}
catch (ClassNotFoundException e) {
// fallthrough
}
}
if (tmp != null) {
return handleUnion(handleSubstatement(new Substatement(tmp, fields, pCtx)));
}
else {
return handleUnion(
handleSubstatement(
new Substatement(
subset(expr, start = trimRight(start + 1),
trimLeft(cursor - 1) - start), fields, pCtx)));
}
}
case '}':
case ']':
case ')': {
throw new CompileException("unbalanced braces", expr, cursor);
}
case '>': {
if (expr[cursor + 1] == '>') {
if (expr[cursor += 2] == '>') cursor++;
return createOperator(expr, start, cursor);
}
else if (expr[cursor + 1] == '=') {
return createOperator(expr, start, cursor += 2);
}
else {
return createOperator(expr, start, ++cursor);
}
}
case '<': {
if (expr[++cursor] == '<') {
if (expr[++cursor] == '<') cursor++;
return createOperator(expr, start, cursor);
}
else if (expr[cursor] == '=') {
return createOperator(expr, start, ++cursor);
}
else {
return createOperator(expr, start, cursor);
}
}
case '\'':
case '"':
lastNode = new LiteralNode(handleStringEscapes(subset(expr, start + 1,
(cursor = captureStringLiteral(expr[cursor], expr, cursor, length)) - start - 1))
, String.class);
cursor++;
if (tokenContinues()) {
return lastNode = handleUnion(lastNode);
}
return lastNode;
case '&': {
if (expr[cursor++ + 1] == '&') {
return createOperator(expr, start, ++cursor);
}
else {
return createOperator(expr, start, cursor);
}
}
case '|': {
if (expr[cursor++ + 1] == '|') {
return createOperator(expr, start, ++cursor);
}
else {
return createOperator(expr, start, cursor);
}
}
case '~':
if ((cursor++ - 1 != 0 || !isIdentifierPart(lookBehind()))
&& isDigit(expr[cursor])) {
start = cursor;
captureToEOT();
return lastNode = new Invert(subset(expr, start, cursor - start), fields, pCtx);
}
else if (expr[cursor] == '(') {
start = cursor--;
captureToEOT();
return lastNode = new Invert(subset(expr, start, cursor - start), fields, pCtx);
}
else {
if (expr[cursor] == '=') cursor++;
return createOperator(expr, start, cursor);
}
case '!': {
++cursor;
if (isNextIdentifier()) {
if (lastNode != null && !lastNode.isOperator()) {
throw new CompileException("unexpected operator '!'", expr, cursor);
}
start = cursor;
captureToEOT();
if ("new".equals(name = new String(expr, start, cursor - start))
|| "isdef".equals(name)) {
captureToEOT();
return lastNode = new Negation(subset(expr, start, cursor - start), fields, pCtx);
}
else {
return lastNode = new Negation(name.toCharArray(), fields, pCtx);
}
}
else if (expr[cursor] == '(') {
start = cursor--;
captureToEOT();
return lastNode = new Negation(subset(expr, start, cursor - start), fields, pCtx);
}
else if (expr[cursor] != '=')
throw new CompileException("unexpected operator '!'", expr, cursor, null);
else {
return createOperator(expr, start, ++cursor);
}
}
case '[':
case '{':
cursor = balancedCaptureWithLineAccounting(expr, cursor, expr[cursor], pCtx) + 1;
if (tokenContinues()) {
lastNode = new InlineCollectionNode(expr, start, start = cursor, fields, pCtx);
captureToEOT();
if (expr[start] == '.') start++;
return lastNode = new Union(expr, start, cursor, fields, lastNode);
}
else {
return lastNode = new InlineCollectionNode(expr, start, cursor, fields, pCtx);
}
default:
cursor++;
}
}
}
if (start == cursor)
return null;
else
return createPropertyToken(start, cursor);
}
catch (NumberFormatException e) {
CompileException c = new CompileException("badly formatted number: " + e.getMessage(), expr, cursor, e);
c.setLineNumber(line);
c.setColumn(cursor - lastLineStart);
throw c;
}
catch (StringIndexOutOfBoundsException e) {
CompileException c = new CompileException("unexpected end of statement", expr, cursor, e);
c.setLineNumber(line);
c.setColumn(cursor - lastLineStart);
throw c;
}
catch (ArrayIndexOutOfBoundsException e) {
CompileException c = new CompileException("unexpected end of statement", expr, cursor, e);
c.setLineNumber(line);
c.setColumn(cursor - lastLineStart);
throw c;
}
catch (CompileException e) {
e.setExpr(expr);
e.setLineNumber(pCtx == null ? 1 : pCtx.getLineCount());
e.setCursor(cursor);
e.setColumn(cursor - (pCtx == null ? 0 : pCtx.getLineOffset()));
throw e;
}
}
public ASTNode handleSubstatement(Substatement stmt) {
if (stmt.getStatement() != null && stmt.getStatement().isLiteralOnly()) {
return new LiteralNode(stmt.getStatement().getValue(null, null, null));
}
else {
return stmt;
}
}
/**
* Handle a union between a closed statement and a residual property chain.
* @param node
* @return
*/
protected ASTNode handleUnion(ASTNode node) {
if (cursor != length) {
skipWhitespace();
int union = -1;
switch (expr[cursor]) {
case '.':
union = cursor + 1;
break;
case '[':
union = cursor;
}
if (union != -1) {
captureToEOT();
return lastNode = new Union(expr, union, cursor, fields, node);
}
}
return lastNode = node;
}
/**
* Create an operator node.
* @param expr
* @param start
* @param end
* @return
*/
private ASTNode createOperator(final char[] expr, final int start, final int end) {
lastWasIdentifier = false;
return lastNode = new OperatorNode(OPERATORS.get(new String(expr, start, end - start)));
}
/**
* Create a copy of an array based on a sub-range. Works faster than System.arrayCopy() for arrays shorter than
* 1000 elements in most cases, so the parser uses this internally.
* @param start
* @param end
* @return
*/
private char[] subArray(final int start, final int end) {
if (start >= end) return new char[0];
char[] newA = new char[end - start];
for (int i = 0; i != newA.length; i++) {
newA[i] = expr[i + start];
}
return newA;
}
/**
* Generate a property token
* @param start
* @param end
* @return
*/
private ASTNode createPropertyToken(int start, int end) {
String tmp;
if (isLiteralOnly(expr, start, end)) {
if (pCtx != null && pCtx.hasImports()) {
char[] _subset = subset(expr, start, cursor - start);
int offset;
if ((offset = findFirst('.', _subset)) != -1) {
String iStr = new String(_subset, 0, offset);
if (pCtx.hasImport(iStr)) {
lastWasIdentifier = true;
return lastNode = new LiteralDeepPropertyNode(subset(_subset, offset + 1, _subset.length
- offset - 1),
fields, pCtx.getImport(iStr));
}
}
else {
if (pCtx.hasImport(tmp = new String(_subset))) {
lastWasIdentifier = true;
return lastNode = new LiteralNode(pCtx.getStaticOrClassImport(tmp));
}
}
}
if (LITERALS.containsKey(tmp = new String(expr, start, end - start))) {
lastWasIdentifier = true;
return lastNode = new LiteralNode(LITERALS.get(tmp));
}
else if (OPERATORS.containsKey(tmp)) {
lastWasIdentifier = false;
return lastNode = new OperatorNode(OPERATORS.get(tmp));
}
else if (lastWasIdentifier) {
return procTypedNode(true);
}
}
lastWasIdentifier = true;
return lastNode = new ASTNode(expr, start, end, fields);
}
/**
* Process the current typed node
* @param decl
* @return
*/
private ASTNode procTypedNode(boolean decl) {
while (true) {
if (lastNode.getLiteralValue() instanceof String) {
TypeDescriptor tDescr = new TypeDescriptor(((String) lastNode.getLiteralValue()).toCharArray(), 0);
try {
lastNode.setLiteralValue(getClassReference(pCtx, tDescr));
lastNode.discard();
}
catch (Exception e) {
// fall through;
}
}
if (lastNode.isLiteral() && lastNode.getLiteralValue() instanceof Class) {
lastNode.discard();
captureToEOS();
if (decl) {
splitAccumulator.add(new DeclTypedVarNode(new String(expr, start, cursor - start),
(Class) lastNode.getLiteralValue(), fields | ASTNode.ASSIGN, pCtx));
}
else {
captureToEOS();
splitAccumulator.add(new TypedVarNode(subArray(start, cursor), fields | ASTNode.ASSIGN, (Class)
lastNode.getLiteralValue(), pCtx));
}
}
else if (lastNode instanceof Proto) {
captureToEOS();
if (decl) {
splitAccumulator.add(new DeclProtoVarNode(new String(expr, start, cursor - start),
(Proto) lastNode, fields | ASTNode.ASSIGN, pCtx));
}
else {
splitAccumulator.add(new ProtoVarNode(subArray(start, cursor), fields | ASTNode.ASSIGN, (Proto)
lastNode, pCtx));
}
}
// this redundant looking code is needed to work with the interpreter and MVELSH properly.
else if ((fields & ASTNode.COMPILE_IMMEDIATE) == 0) {
if (stk.peek() instanceof Class) {
captureToEOS();
if (decl) {
splitAccumulator.add(new DeclTypedVarNode(new String(expr, start, cursor - start),
(Class) stk.pop(), fields | ASTNode.ASSIGN, pCtx));
}
else {
splitAccumulator.add(new TypedVarNode(subArray(start, cursor), fields | ASTNode.ASSIGN, (Class)
stk.pop(), pCtx));
}
}
else if (stk.peek() instanceof Proto) {
captureToEOS();
if (decl) {
splitAccumulator.add(new DeclProtoVarNode(new String(expr, start, cursor - start),
(Proto) stk.pop(), fields | ASTNode.ASSIGN, pCtx));
}
else {
splitAccumulator.add(new ProtoVarNode(subArray(start, cursor), fields | ASTNode.ASSIGN, (Proto)
stk.pop(), pCtx));
}
}
else {
throw new CompileException("unknown class or illegal statement: " + lastNode.getLiteralValue(), expr, cursor);
}
}
else {
throw new CompileException("unknown class or illegal statement: " + lastNode.getLiteralValue(), expr, cursor);
}
skipWhitespace();
if (cursor < length && expr[cursor] == ',') {
start = ++cursor;
splitAccumulator.add(new EndOfStatement());
}
else {
return (ASTNode) splitAccumulator.pop();
}
}
}
/**
* Generate a code block token.
* @param condStart
* @param condEnd
* @param blockStart
* @param blockEnd
* @param type
* @return
*/
private ASTNode createBlockToken(final int condStart,
final int condEnd, final int blockStart, final int blockEnd, int type) {
lastWasIdentifier = false;
cursor++;
if (isStatementNotManuallyTerminated()) {
splitAccumulator.add(new EndOfStatement());
}
switch (type) {
case ASTNode.BLOCK_IF:
return new IfNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
case ASTNode.BLOCK_FOR:
for (int i = condStart; i < condEnd; i++) {
if (expr[i] == ';')
return new ForNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
else if (expr[i] == ':')
break;
}
case ASTNode.BLOCK_FOREACH:
return new ForEachNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
case ASTNode.BLOCK_WHILE:
return new WhileNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
case ASTNode.BLOCK_UNTIL:
return new UntilNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
case ASTNode.BLOCK_DO:
return new DoNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
case ASTNode.BLOCK_DO_UNTIL:
return new DoUntilNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), pCtx);
default:
return new WithNode(subArray(condStart, condEnd), subArray(blockStart, blockEnd), fields, pCtx);
}
}
/**
* Capture a code block by type.
* @param type
* @return
*/
private ASTNode captureCodeBlock(int type) {
boolean cond = true;
ASTNode first = null;
ASTNode tk = null;
switch (type) {
case ASTNode.BLOCK_IF: {
do {
if (tk != null) {
captureToNextTokenJunction();
skipWhitespace();
cond = expr[cursor] != '{' && expr[cursor] == 'i' && expr[++cursor] == 'f'
&& expr[cursor = incNextNonBlank()] == '(';
}
if (((IfNode) (tk = _captureBlock(tk, expr, cond, type))).getElseBlock() != null) {
cursor++;
return first;
}
if (first == null) first = tk;
if (cursor != length && expr[cursor] != ';') {
cursor++;
}
}
while (ifThenElseBlockContinues());
return first;
}
case ASTNode.BLOCK_DO:
skipWhitespace();
return _captureBlock(null, expr, false, type);
default: // either BLOCK_WITH or BLOCK_FOREACH
captureToNextTokenJunction();
skipWhitespace();
return _captureBlock(null, expr, true, type);
}
}
private ASTNode _captureBlock(ASTNode node, final char[] expr, boolean cond, int type) {
skipWhitespace();
int startCond = 0;
int endCond = 0;
int blockStart;
int blockEnd;
String name;
/**
* Functions are a special case we handle differently from the rest of block parsing
*/
switch (type) {
case FUNCTION: {
int start = cursor;
captureToNextTokenJunction();
if (cursor == length) {
throw new CompileException("unexpected end of statement", expr, start);
}
/**
* Check to see if the name is legal.
*/
if (isReservedWord(name = createStringTrimmed(expr, start, cursor - start))
|| isNotValidNameorLabel(name))
throw new CompileException("illegal function name or use of reserved word", expr, cursor);
if (pCtx == null) pCtx = getParserContext();
FunctionParser parser = new FunctionParser(name, cursor, expr.length, expr, pCtx, splitAccumulator);
Function function = parser.parse();
cursor = parser.getCursor();
return lastNode = function;
}
case PROTO:
if (ProtoParser.isUnresolvedWaiting()) {
if (pCtx == null) pCtx = getParserContext();
ProtoParser.checkForPossibleUnresolvedViolations(expr, cursor, pCtx);
}
int start = cursor;
captureToNextTokenJunction();
if (isReservedWord(name = createStringTrimmed(expr, start, cursor - start))
|| isNotValidNameorLabel(name))
throw new CompileException("illegal prototype name or use of reserved word", expr, cursor);
if (expr[cursor = nextNonBlank()] != '{') {
throw new CompileException("expected '{' but found: " + expr[cursor]);
}
cursor = balancedCaptureWithLineAccounting(expr, start = cursor + 1, '{', pCtx);
if (pCtx == null) pCtx = getParserContext();
ProtoParser parser = new ProtoParser(expr, start, cursor, name, pCtx, fields, splitAccumulator);
Proto proto = parser.parse();
if (pCtx == null) pCtx = getParserContext();
pCtx.addImport(proto);
proto.setCursorPosition(start, cursor);
cursor = parser.getCursor();
ProtoParser.notifyForLateResolution(proto);
return lastNode = proto;
default:
if (cond) {
if (expr[cursor] != '(') {
throw new CompileException("expected '(' but encountered: " + expr[cursor]);
}
/**
* This block is an: IF, FOREACH or WHILE node.
*/
endCond = cursor = balancedCaptureWithLineAccounting(expr, startCond = cursor, '(', pCtx);
startCond++;
cursor++;
}
}
skipWhitespace();
if (cursor >= length) {
throw new CompileException("unexpected end of statement", expr, cursor);
}
else if (expr[cursor] == '{') {
blockEnd = cursor = balancedCaptureWithLineAccounting(expr, blockStart = cursor, '{', pCtx);
}
else {
blockStart = cursor - 1;
captureToEOSorEOL();
blockEnd = cursor + 1;
}
if (type == ASTNode.BLOCK_IF) {
IfNode ifNode = (IfNode) node;
if (node != null) {
if (!cond) {
return ifNode.setElseBlock(subArray(trimRight(blockStart + 1), trimLeft(blockEnd - 1)));
}
else {
return ifNode.setElseIf((IfNode) createBlockToken(startCond, endCond, trimRight(blockStart + 1),
trimLeft(blockEnd), type));
}
}
else {
return createBlockToken(startCond, endCond, blockStart + 1, blockEnd, type);
}
}
else if (type == ASTNode.BLOCK_DO) {
cursor++;
skipWhitespace();
start = cursor;
captureToNextTokenJunction();
if ("while".equals(name = new String(expr, start, cursor - start))) {
skipWhitespace();
startCond = cursor + 1;
endCond = cursor = balancedCaptureWithLineAccounting(expr, cursor, '(', pCtx);
return createBlockToken(startCond, endCond, trimRight(blockStart + 1), trimLeft(blockEnd), type);
}
else if ("until".equals(name)) {
skipWhitespace();
startCond = cursor + 1;
endCond = cursor = balancedCaptureWithLineAccounting(expr, cursor, '(', pCtx);
return createBlockToken(startCond, endCond, trimRight(blockStart + 1), trimLeft(blockEnd),
ASTNode.BLOCK_DO_UNTIL);
}
else {
throw new CompileException("expected 'while' or 'until' but encountered: " + name, expr, cursor);
}
}
// DON"T REMOVE THIS COMMENT!
// else if (isFlag(ASTNode.BLOCK_FOREACH) || isFlag(ASTNode.BLOCK_WITH)) {
else {
return createBlockToken(startCond, endCond, trimRight(blockStart + 1), trimLeft(blockEnd), type);
}
}
/**
* Checking from the current cursor position, check to see if the if-then-else block continues.
*
* @return boolean value
*/
protected boolean ifThenElseBlockContinues() {
if ((cursor + 4) < length) {
if (expr[cursor] != ';') cursor--;
skipWhitespace();
return expr[cursor] == 'e' && expr[cursor + 1] == 'l' && expr[cursor + 2] == 's' && expr[cursor + 3] == 'e'
&& (isWhitespace(expr[cursor + 4]) || expr[cursor + 4] == '{');
}
return false;
}
/**
* Checking from the current cursor position, check to see if we're inside a contiguous identifier.
*
* @return -
*/
protected boolean tokenContinues() {
if (cursor == length) return false;
else if (expr[cursor] == '.' || expr[cursor] == '[') return true;
else if (isWhitespace(expr[cursor])) {
int markCurrent = cursor;
skipWhitespace();
if (cursor != length && (expr[cursor] == '.' || expr[cursor] == '[')) return true;
cursor = markCurrent;
}
return false;
}
/**
* The parser should find a statement ending condition when this is called, otherwise everything should blow up.
*/
protected void expectEOS() {
skipWhitespace();
if (cursor != length && expr[cursor] != ';') {
switch (expr[cursor]) {
case '&':
if (lookAhead() == '&') return;
else break;
case '|':
if (lookAhead() == '|') return;
else break;
case '!':
if (lookAhead() == '=') return;
else break;
case '<':
case '>':
return;
case '=': {
switch (lookAhead()) {
case '=':
case '+':
case '-':
case '*':
return;
}
break;
}
case '+':
case '-':
case '/':
case '*':
if (lookAhead() == '=') return;
else break;
}
throw new CompileException("expected end of statement but encountered: "
+ (cursor == length ? "" : expr[cursor]), expr, cursor);
}
}
/**
* Checks to see if the next part of the statement is an identifier part.
*
* @return boolean true if next part is identifier part.
*/
protected boolean isNextIdentifier() {
while (cursor != length && isWhitespace(expr[cursor])) cursor++;
return cursor != length && isIdentifierPart(expr[cursor]);
}
/**
* Capture from the current cursor position, to the end of the statement.
*/
protected void captureToEOS() {
while (cursor != length) {
switch (expr[cursor]) {
case '(':
case '[':
case '{':
if ((cursor = balancedCaptureWithLineAccounting(expr, cursor, expr[cursor], pCtx)) >= length)
return;
break;
case '"':
case '\'':
cursor = captureStringLiteral(expr[cursor], expr, cursor, length);
break;
case ',':
case ';':
case '}':
return;
}
cursor++;
}
}
/**
* From the current cursor position, capture to the end of statement, or the end of line, whichever comes first.
*/
protected void captureToEOSorEOL() {
while (cursor != length && (expr[cursor] != '\n' && expr[cursor] != '\r' && expr[cursor] != ';')) {
cursor++;
}
}
/**
* From the current cursor position, capture to the end of the line.
*/
protected void captureToEOL() {
while (cursor != length && (expr[cursor] != '\n')) cursor++;
}
/**
* Capture to the end of the current identifier under the cursor.
*/
protected void captureIdentifier() {
boolean captured = false;
if (cursor == length) throw new CompileException("unexpected end of statement: EOF", expr, cursor);
while (cursor != length) {
switch (expr[cursor]) {
case ';':
return;
default: {
if (!isIdentifierPart(expr[cursor])) {
if (captured) return;
throw new CompileException("unexpected symbol (was expecting an identifier): " + expr[cursor],
expr, cursor);
}
else {
captured = true;
}
}
}
cursor++;
}
}
/**
* From the current cursor position, capture to the end of the current token.
*/
protected void captureToEOT() {
skipWhitespace();
do {
switch (expr[cursor]) {
case '(':
case '[':
case '{':
if ((cursor = balancedCaptureWithLineAccounting(expr, cursor, expr[cursor], pCtx)) == -1) {
throw new CompileException("unbalanced braces", expr, cursor);
}
break;
case ',':
case '=':
case '&':
case '|':
case ';':
return;
case '.':
skipWhitespace();
break;
case '\'':
cursor = captureStringLiteral('\'', expr, cursor, length);
break;
case '"':
cursor = captureStringLiteral('"', expr, cursor, length);
break;
default:
if (isWhitespace(expr[cursor])) {
skipWhitespace();
if (cursor < length && expr[cursor] == '.') {
if (cursor != length) cursor++;
skipWhitespace();
break;
}
else {
trimWhitespace();
return;
}
}
}
}
while (++cursor != length);
}
protected boolean lastNonWhite(char c) {
int i = cursor - 1;
while (isWhitespace(expr[i])) i--;
return c == expr[i];
}
/**
* From the specified cursor position, trim out any whitespace between the current position and the end of the
* last non-whitespace character.
*
* @param pos - current position
* @return new position.
*/
protected int trimLeft(int pos) {
if (pos > length) pos = length;
while (pos > 0 && pos >= start && isWhitespace(expr[pos - 1])) pos--;
return pos;
}
/**
* From the specified cursor position, trim out any whitespace between the current position and beginning of the
* first non-whitespace character.
*
* @param pos -
* @return -
*/
protected int trimRight(int pos) {
while (pos != length && isWhitespace(expr[pos])) pos++;
return pos;
}
/**
* If the cursor is currently pointing to whitespace, move the cursor forward to the first non-whitespace
* character, but account for carraige returns in the script (updates parser field: line).
*/
protected void skipWhitespace() {
Skip:
while (cursor != length) {
switch (expr[cursor]) {
case '\n':
line++;
lastLineStart = cursor;
case '\r':
cursor++;
continue;
case '/':
if (cursor + 1 != length) {
switch (expr[cursor + 1]) {
case '/':
expr[cursor++] = ' ';
while (cursor != length && expr[cursor] != '\n') expr[cursor++] = ' ';
if (cursor != length) expr[cursor++] = ' ';
line++;
lastLineStart = cursor;
continue;
case '*':
int len = length - 1;
expr[cursor++] = ' ';
while (cursor != len && !(expr[cursor] == '*' && expr[cursor + 1] == '/')) {
if (expr[cursor] == '\n') {
line++;
lastLineStart = cursor;
}
expr[cursor++] = ' ';
}
if (cursor != len) expr[cursor++] = expr[cursor++] = ' ';
continue;
default:
break Skip;
}
}
default:
if (!isWhitespace(expr[cursor])) break Skip;
}
cursor++;
}
}
/**
* From the current cursor position, capture to the end of the next token junction.
*/
protected void captureToNextTokenJunction() {
while (cursor != length) {
switch (expr[cursor]) {
case '{':
case '(':
return;
case '[':
cursor = balancedCaptureWithLineAccounting(expr, cursor, '[', pCtx) + 1;
continue;
default:
if (isWhitespace(expr[cursor])) {
return;
}
cursor++;
}
}
}
/**
* From the current cursor position, trim backward over any whitespace to the first non-whitespace character.
*/
protected void trimWhitespace() {
while (cursor != 0 && isWhitespace(expr[cursor - 1])) cursor--;
}
/**
* Set and finesse the expression, trimming an leading or proceeding whitespace.
*
* @param expression
*/
protected void setExpression(String expression) {
if (expression != null && expression.length() != 0) {
synchronized (EX_PRECACHE) {
if ((this.expr = EX_PRECACHE.get(expression)) == null) {
length = (this.expr = expression.toCharArray()).length;
// trim any whitespace.
while (length != 0 && isWhitespace(this.expr[length - 1])) length--;
char[] e = new char[length];
for (int i = 0; i != e.length; i++)
e[i] = expr[i];
EX_PRECACHE.put(expression, e);
}
else {
length = this.expr.length;
}
}
}
}
/**
* Set and finesse the expression, trimming an leading or proceeding whitespace.
*
* @param expression
*/
protected void setExpression(char[] expression) {
length = (this.expr = expression).length;
while (length != 0 && isWhitespace(this.expr[length - 1])) length--;
}
/**
* Return the previous non-whitespace character.
*
* @return -
*/
protected char lookToLast() {
if (cursor == 0) return 0;
int temp = cursor;
while (temp != 0 && isWhitespace(expr[--temp])) ;
return expr[temp];
}
/**
* Return the last character (delta -1 of cursor position).
*
* @return -
*/
protected char lookBehind() {
if (cursor == 0) return 0;
else return expr[cursor - 1];
}
/**
* Return the next character (delta 1 of cursor position).
*
* @return -
*/
protected char lookAhead() {
if (cursor + 1 < length) {
return expr[cursor + 1];
}
else {
return 0;
}
}
/**
* Return the character, forward of the currrent cursor position based on the specified range delta.
*
* @param range -
* @return -
*/
protected char lookAhead(int range) {
if ((cursor + range) >= length) return 0;
else {
return expr[cursor + range];
}
}
/**
* Returns true if the next is an identifier or literal.
* @return
*/
protected boolean isNextIdentifierOrLiteral() {
int tmp = cursor;
if (tmp == length) return false;
else {
while (tmp != length && isWhitespace(expr[tmp])) tmp++;
if (tmp == length) return false;
char n = expr[tmp];
return isIdentifierPart(n) || isDigit(n) || n == '\'' || n == '"';
}
}
/**
* Increment one cursor position, and move cursor to next non-blank part.
* @return
*/
public int incNextNonBlank() {
cursor++;
return nextNonBlank();
}
/**
* Move to next cursor position from current cursor position.
* @return
*/
public int nextNonBlank() {
if ((cursor + 1) >= length) {
throw new CompileException("unexpected end of statement", expr, cursor);
}
int i = cursor;
while (i != length && isWhitespace(expr[i])) i++;
return i;
}
/**
* Expect the next specified character or fail
* @param c
*/
public void expectNextChar_IW(char c) {
nextNonBlank();
if (cursor == length) throw new CompileException("unexpected end of statement", expr, cursor);
if (expr[cursor] != c)
throw new CompileException("unexpected character ('" + expr[cursor] + "'); was expecting: " + c);
}
/**
* NOTE: This method assumes that the current position of the cursor is at the end of a logical statement, to
* begin with.
*
* Determines whether or not the logical statement is manually terminated with a statement separator (';').
*
* @return -
*/
protected boolean isStatementNotManuallyTerminated() {
if (cursor >= length) return false;
int c = cursor;
while (c != length && isWhitespace(expr[c])) c++;
return !(c != length && expr[c] == ';');
}
protected ParserContext getParserContext() {
if (parserContext == null || parserContext.get() == null) {
newContext();
}
return parserContext.get();
}
public static ParserContext getCurrentThreadParserContext() {
return contextControl(GET_OR_CREATE, null, null);
}
public static void setCurrentThreadParserContext(ParserContext pCtx) {
contextControl(SET, pCtx, null);
}
/**
* Create a new ParserContext in the current thread.
*/
public void newContext() {
contextControl(SET, new ParserContext(), this);
}
/**
* Create a new ParserContext in the current thread, using the one specified.
*
* @param pCtx -
*/
public void newContext(ParserContext pCtx) {
contextControl(SET, pCtx, this);
}
/**
* Remove the current ParserContext from the thread.
*/
public void removeContext() {
contextControl(REMOVE, null, this);
}
public static ParserContext contextControl(int operation, ParserContext pCtx, AbstractParser parser) {
synchronized (getRuntime()) {
if (parserContext == null) parserContext = new ThreadLocal();
switch (operation) {
case SET:
pCtx.setRootParser(parser);
parserContext.set(pCtx);
return pCtx;
case REMOVE:
parserContext.set(null);
return null;
case GET_OR_CREATE:
if (parserContext.get() == null) {
parserContext.set(new ParserContext(parser));
}
case GET:
return parserContext.get();
}
}
return null;
}
protected static final int SET = 0;
protected static final int REMOVE = 1;
protected static final int GET = 2;
protected static final int GET_OR_CREATE = 3;
protected static String getCurrentSourceFileName() {
if (parserContext != null && parserContext.get() != null) {
return parserContext.get().getSourceFile();
}
return null;
}
protected void addFatalError(String message) {
getParserContext().addError(new ErrorDetail(getParserContext().getLineCount(),
cursor - getParserContext().getLineOffset(), true, message));
}
protected void addFatalError(String message, int row, int cols) {
getParserContext().addError(new ErrorDetail(row, cols, true, message));
}
protected void addWarning(String message) {
getParserContext().addError(new ErrorDetail(message, false));
}
public static final int LEVEL_5_CONTROL_FLOW = 5;
public static final int LEVEL_4_ASSIGNMENT = 4;
public static final int LEVEL_3_ITERATION = 3;
public static final int LEVEL_2_MULTI_STATEMENT = 2;
public static final int LEVEL_1_BASIC_LANG = 1;
public static final int LEVEL_0_PROPERTY_ONLY = 0;
public static void setLanguageLevel(int level) {
OPERATORS.clear();
OPERATORS.putAll(loadLanguageFeaturesByLevel(level));
}
public static HashMap loadLanguageFeaturesByLevel(int languageLevel) {
HashMap operatorsTable = new HashMap();
switch (languageLevel) {
case 6: // prototype definition
operatorsTable.put("proto", PROTO);
case 5: // control flow operations
operatorsTable.put("if", IF);
operatorsTable.put("else", ELSE);
operatorsTable.put("?", TERNARY);
operatorsTable.put("switch", SWITCH);
operatorsTable.put("function", FUNCTION);
operatorsTable.put("def", FUNCTION);
case 4: // assignment
operatorsTable.put("=", ASSIGN);
operatorsTable.put("var", UNTYPED_VAR);
operatorsTable.put("+=", ASSIGN_ADD);
operatorsTable.put("-=", ASSIGN_SUB);
operatorsTable.put("/=", ASSIGN_DIV);
operatorsTable.put("%=", ASSIGN_MOD);
case 3: // iteration
operatorsTable.put("foreach", FOREACH);
operatorsTable.put("while", WHILE);
operatorsTable.put("until", UNTIL);
operatorsTable.put("for", FOR);
operatorsTable.put("do", DO);
case 2: // multi-statement
operatorsTable.put("return", RETURN);
operatorsTable.put(";", END_OF_STMT);
case 1: // boolean, math ops, projection, assertion, objection creation, block setters, imports
operatorsTable.put("+", ADD);
operatorsTable.put("-", SUB);
operatorsTable.put("*", MULT);
operatorsTable.put("**", POWER);
operatorsTable.put("/", DIV);
operatorsTable.put("%", MOD);
operatorsTable.put("==", EQUAL);
operatorsTable.put("!=", NEQUAL);
operatorsTable.put(">", GTHAN);
operatorsTable.put(">=", GETHAN);
operatorsTable.put("<", LTHAN);
operatorsTable.put("<=", LETHAN);
operatorsTable.put("&&", AND);
operatorsTable.put("and", AND);
operatorsTable.put("||", OR);
operatorsTable.put("or", CHOR);
operatorsTable.put("~=", REGEX);
operatorsTable.put("instanceof", INSTANCEOF);
operatorsTable.put("is", INSTANCEOF);
operatorsTable.put("contains", CONTAINS);
operatorsTable.put("soundslike", SOUNDEX);
operatorsTable.put("strsim", SIMILARITY);
operatorsTable.put("convertable_to", CONVERTABLE_TO);
operatorsTable.put("isdef", ISDEF);
operatorsTable.put("#", STR_APPEND);
operatorsTable.put("&", BW_AND);
operatorsTable.put("|", BW_OR);
operatorsTable.put("^", BW_XOR);
operatorsTable.put("<<", BW_SHIFT_LEFT);
operatorsTable.put("<<<", BW_USHIFT_LEFT);
operatorsTable.put(">>", BW_SHIFT_RIGHT);
operatorsTable.put(">>>", BW_USHIFT_RIGHT);
operatorsTable.put("new", Operator.NEW);
operatorsTable.put("in", PROJECTION);
operatorsTable.put("with", WITH);
operatorsTable.put("assert", ASSERT);
operatorsTable.put("import", IMPORT);
operatorsTable.put("import_static", IMPORT_STATIC);
operatorsTable.put("++", INC);
operatorsTable.put("--", DEC);
case 0: // Property access and inline collections
operatorsTable.put(":", TERNARY_ELSE);
}
return operatorsTable;
}
/**
* Remove the current parser context from the thread.
*/
public static void resetParserContext() {
contextControl(REMOVE, null, null);
}
protected static boolean isArithmeticOperator(int operator) {
return operator != -1 && operator < 6;
}
/**
* Reduce the current operations on the stack.
* @param operator
* @return
*/
protected int arithmeticFunctionReduction(int operator) {
ASTNode tk;
int operator2;
/**
* If the next token is an operator, we check to see if it has a higher
* precdence.
*/
if ((tk = nextToken()) != null) {
if (isArithmeticOperator(operator2 = tk.getOperator()) && PTABLE[operator2] > PTABLE[operator]) {
stk.xswap();
/**
* The current arith. operator is of higher precedence the last.
*/
tk = nextToken();
/**
* Check to see if we're compiling or executing interpretively. If we're compiling, we really
* need to stop if this is not a literal.
*/
if (compileMode && !tk.isLiteral()) {
// BAIL OUT!
splitAccumulator.push(tk);
splitAccumulator.push(new OperatorNode(operator2));
return tk instanceof Substatement ? -2 : OP_TERMINATE;
}
dStack.push(operator = operator2, tk.getReducedValue(ctx, ctx, variableFactory));
while (true) {
// look ahead again
if ((tk = nextToken()) != null && (operator2 = tk.getOperator()) != -1
&& operator2 != 37 && PTABLE[operator2] > PTABLE[operator]) {
// if we have back to back operations on the stack, we don't xswap
if (dStack.isReduceable()) {
stk.copyx2(dStack);
}
/**
* This operator is of higher precedence, or the same level precedence. push to the RHS.
*/
dStack.push(operator = operator2, nextToken().getReducedValue(ctx, ctx, variableFactory));
continue;
}
else if (tk != null && operator2 != -1 && operator2 != 37) {
if (PTABLE[operator2] == PTABLE[operator]) {
if (!dStack.isEmpty()) dreduce();
else {
while (stk.isReduceable()) {
stk.xswap_op();
}
}
/**
* This operator is of the same level precedence. push to the RHS.
*/
dStack.push(operator = operator2, nextToken().getReducedValue(ctx, ctx, variableFactory));
continue;
}
else {
/**
* The operator doesn't have higher precedence. Therfore reduce the LHS.
*/
while (dStack.size() > 1) {
dreduce();
}
operator = tk.getOperator();
// Reduce the lesser or equal precedence operations.
while (stk.size() != 1 && stk.peek2() instanceof Integer &&
((operator2 = (Integer) stk.peek2()) < PTABLE.length) &&
PTABLE[operator2] >= PTABLE[operator]) {
stk.xswap_op();
}
}
}
else {
/**
* There are no more tokens.
*/
if (dStack.size() > 1) {
dreduce();
}
if (stk.isReduceable()) stk.xswap();
break;
}
if ((tk = nextToken()) != null) {
switch (operator) {
case AND: {
if (!(stk.peekBoolean())) return OP_TERMINATE;
else {
splitAccumulator.add(tk);
return AND;
}
}
case OR: {
if ((stk.peekBoolean())) return OP_TERMINATE;
else {
splitAccumulator.add(tk);
return OR;
}
}
default:
stk.push(operator, tk.getReducedValue(ctx, ctx, variableFactory));
}
}
}
}
else if (!tk.isOperator()) {
throw new CompileException("unexpected token: " + tk.getName());
}
else {
reduce();
splitAccumulator.push(tk);
}
}
// while any values remain on the stack
// keep XSWAPing and reducing, until there is nothing left.
while (stk.isReduceable()) {
reduce();
if (stk.isReduceable()) stk.xswap();
}
return OP_RESET_FRAME;
}
private void dreduce() {
stk.copy2(dStack);
stk.op();
}
/**
* This method is called when we reach the point where we must subEval a trinary operation in the expression.
* (ie. val1 op val2). This is not the same as a binary operation, although binary operations would appear
* to have 3 structures as well. A binary structure (or also a junction in the expression) compares the
* current state against 2 downrange structures (usually an op and a val).
*/
protected void reduce() {
Object v1, v2;
int operator;
try {
switch (operator = (Integer) stk.pop()) {
case ADD:
case SUB:
case DIV:
case MULT:
case MOD:
case EQUAL:
case NEQUAL:
case GTHAN:
case LTHAN:
case GETHAN:
case LETHAN:
case POWER:
stk.op(operator);
break;
case AND:
v1 = stk.pop();
stk.push(((Boolean) stk.pop()) && ((Boolean) v1));
break;
case OR:
v1 = stk.pop();
stk.push(((Boolean) stk.pop()) || ((Boolean) v1));
break;
case CHOR:
v1 = stk.pop();
if (!isEmpty(v2 = stk.pop()) || !isEmpty(v1)) {
stk.clear();
stk.push(!isEmpty(v2) ? v2 : v1);
return;
}
else stk.push(null);
break;
case REGEX:
stk.push(java.util.regex.Pattern.compile(java.lang.String.valueOf(stk.pop()))
.matcher(java.lang.String.valueOf(stk.pop())).matches());
break;
case INSTANCEOF:
stk.push(((Class) stk.pop()).isInstance(stk.pop()));
break;
case CONVERTABLE_TO:
stk.push(org.mvel2.DataConversion.canConvert(stk.peek2().getClass(), (Class) stk.pop2()));
break;
case CONTAINS:
stk.push(containsCheck(stk.peek2(), stk.pop2()));
break;
case BW_AND:
stk.push(asInt(stk.peek2()) & asInt(stk.pop2()));
break;
case BW_OR:
stk.push(asInt(stk.peek2()) | asInt(stk.pop2()));
break;
case BW_XOR:
stk.push(asInt(stk.peek2()) ^ asInt(stk.pop2()));
break;
case BW_SHIFT_LEFT:
stk.push(asInt(stk.peek2()) << asInt(stk.pop2()));
break;
case BW_USHIFT_LEFT:
int iv2 = asInt(stk.peek2());
if (iv2 < 0) iv2 *= -1;
stk.push(iv2 << asInt(stk.pop2()));
break;
case BW_SHIFT_RIGHT:
stk.push(asInt(stk.peek2()) >> asInt(stk.pop2()));
break;
case BW_USHIFT_RIGHT:
stk.push(asInt(stk.peek2()) >>> asInt(stk.pop2()));
break;
case SOUNDEX:
stk.push(Soundex.soundex(java.lang.String.valueOf(stk.pop()))
.equals(Soundex.soundex(java.lang.String.valueOf(stk.pop()))));
break;
case SIMILARITY:
stk.push(similarity(java.lang.String.valueOf(stk.pop()), java.lang.String.valueOf(stk.pop())));
break;
}
}
catch (ClassCastException e) {
throw new CompileException("syntax error or incompatable types", expr, cursor, e);
}
catch (ArithmeticException e) {
throw new CompileException("arithmetic error: " + e.getMessage(), e);
}
catch (Exception e) {
throw new CompileException("failed to subEval expression", e);
}
}
private static int asInt(final Object o) {
return (Integer) o;
}
public ParserContext getPCtx() {
return pCtx;
}
public void setPCtx(ParserContext pCtx) {
this.debugSymbols = (this.pCtx = pCtx).isDebugSymbols();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/ExecutableLiteral.java 0000644 0001750 0001750 00000005010 11132471451 025716 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.ast.Safe;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class ExecutableLiteral implements ExecutableStatement, Safe {
private Object literal;
private int integer32;
private boolean intOptimized;
public ExecutableLiteral(Object literal) {
if ((this.literal = literal) instanceof Integer) this.integer32 = (Integer) literal;
}
public ExecutableLiteral(int literal) {
this.literal = this.integer32 = literal;
this.intOptimized = true;
}
public int getInteger32() {
return integer32;
}
public void setInteger32(int integer32) {
this.integer32 = integer32;
}
public Object getValue(Object staticContext, VariableResolverFactory factory) {
return literal;
}
public void setKnownIngressType(Class type) {
}
public void setKnownEgressType(Class type) {
}
public Class getKnownIngressType() {
return null;
}
public Class getKnownEgressType() {
return this.literal == null ? Object.class : this.literal.getClass();
}
public boolean isConvertableIngressEgress() {
return false;
}
public void computeTypeConversionRule() {
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
return literal;
}
public Object getLiteral() {
return literal;
}
public boolean intOptimized() {
return intOptimized;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
// not implemented
return null;
}
public boolean isLiteralOnly() {
return true;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/AccessorNode.java 0000644 0001750 0001750 00000001605 11077457613 024712 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import java.io.Serializable;
public interface AccessorNode extends Accessor, Serializable {
public AccessorNode getNextNode();
public AccessorNode setNextNode(AccessorNode accessorNode);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/CompiledAccExpression.java 0000644 0001750 0001750 00000006250 11167215375 026563 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.ParserContext;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.optimizers.OptimizerFactory.getThreadAccessorOptimizer;
import java.io.Serializable;
public class CompiledAccExpression implements ExecutableStatement, Serializable {
private char[] expression;
private transient Accessor accessor;
private ParserContext context;
private Class ingressType;
public CompiledAccExpression(char[] expression, Class ingressType, ParserContext context) {
this.expression = expression;
this.context = context;
this.ingressType = ingressType != null ? ingressType : Object.class;
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory vrf, Object value) {
if (accessor == null) {
if (ingressType == Object.class && value != null) ingressType = value.getClass();
accessor = getThreadAccessorOptimizer()
.optimizeSetAccessor(context, expression, ctx, ctx, vrf, false, value, ingressType);
}
else {
accessor.setValue(ctx, elCtx, vrf, value);
}
return value;
}
public Object getValue(Object staticContext, VariableResolverFactory factory) {
if (accessor == null) {
accessor = getThreadAccessorOptimizer()
.optimizeAccessor(context, expression, staticContext, staticContext, factory, false, ingressType);
}
return accessor.getValue(staticContext, staticContext, factory);
}
public void setKnownIngressType(Class type) {
this.ingressType = type;
}
public void setKnownEgressType(Class type) {
}
public Class getKnownIngressType() {
return ingressType;
}
public Class getKnownEgressType() {
return null;
}
public boolean isConvertableIngressEgress() {
return false;
}
public void computeTypeConversionRule() {
}
public boolean intOptimized() {
return false;
}
public boolean isLiteralOnly() {
return false;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
if (accessor == null) {
accessor = getThreadAccessorOptimizer().optimizeAccessor(context, expression, ctx, elCtx,
variableFactory, false, ingressType);
}
return accessor.getValue(ctx, elCtx, variableFactory);
}
public Accessor getAccessor() {
return accessor;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/compiler/PropertyVerifier.java 0000644 0001750 0001750 00000042312 11332105653 025646 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.compiler;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.PropertyAccessException;
import org.mvel2.ast.Function;
import org.mvel2.optimizers.AbstractOptimizer;
import org.mvel2.optimizers.impl.refl.nodes.WithAccessor;
import static org.mvel2.util.ParseTools.*;
import static org.mvel2.util.PropertyTools.getFieldOrAccessor;
import org.mvel2.util.StringAppender;
import java.lang.reflect.*;
import java.util.*;
/**
* This verifier is used by the compiler to enforce rules such as type strictness. It is, as side-effect, also
* responsible for extracting type information.
*
* @author Mike Brock
* @author Dhanji Prasanna
*/
public class PropertyVerifier extends AbstractOptimizer {
private static final int DONE = -1;
private static final int NORM = 0;
private static final int METH = 1;
private static final int COL = 2;
private static final int WITH = 3;
private List inputs = new LinkedList();
private boolean first = false;
private boolean classLiteral = false;
private boolean resolvedExternally;
private boolean deepProperty = false;
private Map paramTypes;
private Class ctx = null;
public PropertyVerifier(char[] property, ParserContext parserContext) {
this.length = (this.expr = property).length;
this.pCtx = parserContext;
}
public PropertyVerifier(char[] property, ParserContext parserContext, Class contextType) {
this.length = (this.expr = property).length;
this.pCtx = parserContext;
this.ctx = contextType;
}
public PropertyVerifier(String property, ParserContext parserContext) {
this.length = (this.expr = property.toCharArray()).length;
this.pCtx = parserContext;
}
public PropertyVerifier(String property, ParserContext parserContext, Class root) {
this.length = (this.expr = property.toCharArray()).length;
this.pCtx = parserContext;
this.ctx = root;
}
public List getInputs() {
return inputs;
}
public void setInputs(List inputs) {
this.inputs = inputs;
}
/**
* Analyze the statement and return the known egress type.
*
* @return known engress type
*/
public Class analyze() {
resolvedExternally = true;
if (ctx == null) {
ctx = Object.class;
first = true;
}
while (cursor < length) {
classLiteral = false;
switch (nextSubToken()) {
case NORM:
ctx = getBeanProperty(ctx, capture());
break;
case METH:
ctx = getMethod(ctx, capture());
break;
case COL:
ctx = getCollectionProperty(ctx, capture());
break;
case WITH:
ctx = getWithProperty(ctx);
break;
case DONE:
break;
}
if (!first) deepProperty = true;
first = false;
}
return ctx;
}
private void recordTypeParmsForProperty(String property) {
if (pCtx.isStrictTypeEnforcement()) {
if ((paramTypes = pCtx.getTypeParameters(property)) == null) {
pCtx.addTypeParameters(property, pCtx.getVarOrInputType(property));
}
pCtx.setLastTypeParameters(pCtx.getTypeParametersAsArray(property));
}
}
/**
* Process bean property
*
* @param ctx - the ingress type
* @param property - the property component
* @return known egress type.
*/
private Class getBeanProperty(Class ctx, String property) {
if (first) {
if (pCtx.hasVarOrInput(property)) {
if (pCtx.isStrictTypeEnforcement()) {
recordTypeParmsForProperty(property);
}
return pCtx.getVarOrInputType(property);
}
else if (pCtx.hasImport(property)) {
resolvedExternally = false;
return pCtx.getImport(property);
}
else if (!pCtx.isStrongTyping()) {
return Object.class;
}
else if (pCtx.hasVarOrInput("this")) {
if (pCtx.isStrictTypeEnforcement()) {
recordTypeParmsForProperty("this");
}
ctx = pCtx.getVarOrInputType("this");
}
}
start = cursor;
boolean switchStateReg;
Member member = ctx != null ? getFieldOrAccessor(ctx, property) : null;
if (member instanceof Field) {
if (pCtx.isStrictTypeEnforcement()) {
Field f = ((Field) member);
if (f.getGenericType() != null && f.getGenericType() instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) f.getGenericType();
pCtx.setLastTypeParameters(pt.getActualTypeArguments());
Type[] gpt = pt.getActualTypeArguments();
Type[] classArgs = ((Class) pt.getRawType()).getTypeParameters();
if (gpt.length > 0 && paramTypes == null) paramTypes = new HashMap();
for (int i = 0; i < gpt.length; i++) {
paramTypes.put(classArgs[i].toString(), (Class) gpt[i]);
}
}
return f.getType();
}
else {
return ((Field) member).getType();
}
}
else if (member != null) {
Method method = (Method) member;
if (pCtx.isStrictTypeEnforcement()) {
//if not a field, then this is a property getter
Type parametricReturnType = method.getGenericReturnType();
//push return type parameters onto parser context, only if this is a parametric type
if (parametricReturnType instanceof ParameterizedType) {
pCtx.setLastTypeParameters(((ParameterizedType) parametricReturnType).getActualTypeArguments());
}
}
Class rt = method.getReturnType();
return rt.isPrimitive() ? boxPrimitive(rt) : rt;
}
else if (pCtx != null && pCtx.hasImport(property)) {
return pCtx.getImport(property);
}
else if (pCtx.getLastTypeParameters() != null
&& ((Collection.class.isAssignableFrom(ctx) && !(switchStateReg = false))
|| (Map.class.isAssignableFrom(ctx) && (switchStateReg = true)))) {
Class parm = (Class) pCtx.getLastTypeParameters()[switchStateReg ? 1 : 0];
pCtx.setLastTypeParameters(null);
return parm;
}
else {
Object tryStaticMethodRef = tryStaticAccess();
if (tryStaticMethodRef != null) {
if (tryStaticMethodRef instanceof Class) {
classLiteral = true;
resolvedExternally = false;
return (Class) tryStaticMethodRef;
}
else if (tryStaticMethodRef instanceof Field) {
try {
return ((Field) tryStaticMethodRef).get(null).getClass();
}
catch (Exception e) {
throw new CompileException("in verifier: ", e);
}
}
else {
try {
return ((Method) tryStaticMethodRef).getReturnType();
}
catch (Exception e) {
throw new CompileException("in verifier: ", e);
}
}
}
else if (ctx != null && ctx.getClass() == Class.class) {
for (Method m : ctx.getMethods()) {
if (property.equals(m.getName())) {
return m.getReturnType();
}
}
}
if (pCtx.isStrictTypeEnforcement()) {
addFatalError("unqualified type in strict mode for: " + property);
}
return Object.class;
}
}
/**
* Process collection property
*
* @param ctx - the ingress type
* @param property - the property component
* @return known egress type
*/
private Class getCollectionProperty(Class ctx, String property) {
if (first) {
if (pCtx.hasVarOrInput(property)) {
ctx = getSubComponentType(pCtx.getVarOrInputType(property));
}
else if (pCtx.hasImport(property)) {
resolvedExternally = false;
ctx = getSubComponentType(pCtx.getImport(property));
}
else {
ctx = Object.class;
}
}
if (pCtx.isStrictTypeEnforcement()) {
if (Map.class.isAssignableFrom(property.length() != 0 ? ctx = getBeanProperty(ctx, property) : ctx)) {
ctx = (Class) pCtx.getLastTypeParameters()[1];
}
else if (Collection.class.isAssignableFrom(ctx)) {
ctx = (Class) pCtx.getLastTypeParameters()[0];
}
else if (ctx.isArray()) {
ctx = getBaseComponentType(ctx);
}
else if (pCtx.isStrongTyping()) {
throw new CompileException("unknown collection type: " + ctx + "; property=" + property);
}
}
else {
ctx = Object.class;
}
++cursor;
skipWhitespace();
int start = cursor;
if (cursor == length)
throw new PropertyAccessException("unterminated '['");
if (scanTo(']')) {
addFatalError("unterminated [ in token");
}
ExpressionCompiler compiler = new ExpressionCompiler(new String(expr, start, cursor - start));
compiler.setVerifyOnly(true);
compiler.compile(pCtx);
++cursor;
return ctx;
}
/**
* Process method
*
* @param ctx - the ingress type
* @param name - the property component
* @return known egress type.
*/
private Class getMethod(Class ctx, String name) {
int st = cursor;
/**
* Check to see if this is the first element in the statement.
*/
if (first) {
first = false;
/**
* It's the first element in the statement, therefore we check to see if there is a static import of a
* native Java method or an MVEL function.
*/
if (pCtx.hasImport(name)) {
Method m = pCtx.getStaticImport(name).getMethod();
/**
* Replace the method parameters.
*/
ctx = m.getDeclaringClass();
name = m.getName();
}
else if (pCtx.hasFunction(name)) {
resolvedExternally = false;
Function f = pCtx.getFunction(name);
f.checkArgumentCount(parseParameterList((((cursor = balancedCapture(expr, cursor, '(')) - st) > 1 ?
new String(expr, st + 1, cursor - st - 1) : "").toCharArray(), 0, -1).length);
return f.getEgressType();
}
}
/**
* Get the arguments for the method.
*/
String tk = ((cursor = balancedCapture(expr, cursor, '(')) - st) > 1 ? new String(expr, st + 1, cursor - st - 1) : "";
cursor++;
/**
* Parse out the arguments list.
*/
Class[] args;
String[] subtokens = parseParameterList(tk.toCharArray(), 0, -1);
if (subtokens.length == 0) {
args = new Class[0];
subtokens = new String[0];
}
else {
// ParserContext subCtx = pCtx.createSubcontext();
args = new Class[subtokens.length];
/**
* Subcompile all the arguments to determine their known types.
*/
// ExpressionCompiler compiler;
CompiledExpression ce;
for (int i = 0; i < subtokens.length; i++) {
args[i] = MVEL.analyze(subtokens[i], pCtx);
}
}
/**
* If the target object is an instance of java.lang.Class itself then do not
* adjust the Class scope target.
*/
Method m;
/**
* If we have not cached the method then we need to go ahead and try to resolve it.
*/
if ((m = getBestCandidate(args, name, ctx, ctx.getMethods(), pCtx.isStrongTyping())) == null) {
if ((m = getBestCandidate(args, name, ctx, ctx.getDeclaredMethods(), pCtx.isStrongTyping())) == null) {
StringAppender errorBuild = new StringAppender();
for (int i = 0; i < args.length; i++) {
errorBuild.append(args[i] != null ? args[i].getName() : null);
if (i < args.length - 1) errorBuild.append(", ");
}
if ("size".equals(name) && args.length == 0 && ctx.isArray()) {
return Integer.class;
}
if (pCtx.isStrictTypeEnforcement()) {
addFatalError("unable to resolve method using strict-mode: "
+ ctx.getName() + "." + name + "(" + errorBuild.toString() + ")");
}
return Object.class;
}
}
/**
* If we're in strict mode, we look for generic type information.
*/
if (pCtx.isStrictTypeEnforcement() && m.getGenericReturnType() != null) {
Map typeArgs = new HashMap();
Type[] gpt = m.getGenericParameterTypes();
Class z;
ParameterizedType pt;
for (int i = 0; i < gpt.length; i++) {
if (gpt[i] instanceof ParameterizedType) {
pt = (ParameterizedType) gpt[i];
if ((z = pCtx.getImport(subtokens[i])) != null) {
/**
* We record the value of the type parameter to our typeArgs Map.
*/
if (pt.getRawType().equals(Class.class)) {
/**
* If this is an instance of Class, we deal with the special parameterization case.
*/
typeArgs.put(pt.getActualTypeArguments()[0].toString(), z);
}
else {
typeArgs.put(gpt[i].toString(), z);
}
}
}
}
/**
* Get the return type argument
*/
Type parametricReturnType = m.getGenericReturnType();
String returnTypeArg = parametricReturnType.toString();
//push return type parameters onto parser context, only if this is a parametric type
if (parametricReturnType instanceof ParameterizedType) {
pCtx.setLastTypeParameters(((ParameterizedType) parametricReturnType).getActualTypeArguments());
}
if (paramTypes != null && paramTypes.containsKey(returnTypeArg)) {
/**
* If the paramTypes Map contains the known type, return that type.
*/
return paramTypes.get(returnTypeArg);
}
else if (typeArgs.containsKey(returnTypeArg)) {
/**
* If the generic type was declared as part of the method, it will be in this
* Map.
*/
return typeArgs.get(returnTypeArg);
}
}
return m.getReturnType();
}
private Class getWithProperty(Class ctx) {
String root = new String(expr, 0, cursor - 1).trim();
int start = cursor + 1;
cursor = balancedCaptureWithLineAccounting(expr, cursor, '{', pCtx);
new WithAccessor(root, subset(expr, start, cursor++ - start), ctx, pCtx.isStrictTypeEnforcement());
return ctx;
}
public boolean isResolvedExternally() {
return resolvedExternally;
}
public boolean isClassLiteral() {
return classLiteral;
}
public boolean isDeepProperty() {
return deepProperty;
}
public Class getCtx() {
return ctx;
}
public void setCtx(Class ctx) {
this.ctx = ctx;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ImmutableElementException.java 0000644 0001750 0001750 00000002256 11100376377 025635 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
/**
* Exception thrown by internal immutable structures if any modifications are attempted.
*/
public class ImmutableElementException extends RuntimeException {
public ImmutableElementException() {
super();
}
public ImmutableElementException(String s) {
super(s);
}
public ImmutableElementException(String s, Throwable throwable) {
super(s, throwable);
}
public ImmutableElementException(Throwable throwable) {
super(throwable);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/MacroProcessor.java 0000644 0001750 0001750 00000011102 11165767772 023472 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import org.mvel2.compiler.AbstractParser;
import static org.mvel2.util.ParseTools.isWhitespace;
import static org.mvel2.util.ParseTools.isIdentifierPart;
import static org.mvel2.util.ParseTools.captureStringLiteral;
import org.mvel2.util.StringAppender;
import org.mvel2.util.ParseTools;
import java.util.Map;
/**
* A simple, fast, macro processor. This processor works by simply replacing a matched identifier with a set of code.
*/
public class MacroProcessor extends AbstractParser implements PreProcessor {
private Map macros;
public MacroProcessor() {
}
public MacroProcessor(Map macros) {
this.macros = macros;
}
public char[] parse(char[] input) {
setExpression(input);
StringAppender appender = new StringAppender();
int start;
boolean macroArmed = true;
String token;
for (; cursor < length; cursor++) {
start = cursor;
while (cursor < length && isIdentifierPart(expr[cursor])) cursor++;
if (cursor > start) {
if (macros.containsKey(token = new String(expr, start, cursor - start)) && macroArmed) {
appender.append(macros.get(token).doMacro());
}
else {
appender.append(token);
}
}
if (cursor < length) {
switch (expr[cursor]) {
case '\\':
cursor++;
break;
case '/':
start = cursor;
if (cursor + 1 != length) {
switch (expr[cursor + 1]) {
case '/':
while (cursor != length && expr[cursor] != '\n') cursor++;
break;
case '*':
int len = length-1;
while (cursor != len && !(expr[cursor] == '*' && expr[cursor+1] == '/')) cursor++;
cursor += 2;
break;
}
}
if (cursor < length) cursor++;
appender.append(new String(expr, start, cursor - start));
if (cursor < length) cursor--;
break;
case '"':
case '\'':
appender.append(new String(expr, (start = cursor),
(cursor = captureStringLiteral(expr[cursor], expr, cursor, length)) - start));
if (cursor >= length) break;
else if (isIdentifierPart(expr[cursor])) cursor--;
default:
switch (expr[cursor]) {
case '.':
macroArmed = false;
break;
case ';':
case '{':
case '(':
macroArmed = true;
break;
}
appender.append(expr[cursor]);
}
}
}
return appender.toChars();
}
public String parse(String input) {
return new String(parse(input.toCharArray()));
}
public Map getMacros() {
return macros;
}
public void setMacros(Map macros) {
this.macros = macros;
}
public void captureToWhitespace() {
while (cursor < length && !isWhitespace(expr[cursor])) cursor++;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/DataTypes.java 0000644 0001750 0001750 00000003463 11224677601 022425 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 MVFLEX/Valhalla Project and the Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
/**
* Contains constants for standard internal types.
*/
public interface DataTypes {
public static final int NULL = -1;
public static final int OBJECT = 0;
public static final int STRING = 1;
public static final int SHORT = 100;
public static final int INTEGER = 101;
public static final int LONG = 102;
public static final int DOUBLE = 103;
public static final int FLOAT = 104;
public static final int BOOLEAN = 7;
public static final int CHAR = 8;
public static final int BYTE = 9;
public static final int W_SHORT = 105;
public static final int W_INTEGER = 106;
public static final int W_LONG = 107;
public static final int W_FLOAT = 108;
public static final int W_DOUBLE = 109;
public static final int W_CHAR = 112;
public static final int W_BYTE = 113;
public static final int W_BOOLEAN = 15;
public static final int BIG_DECIMAL = 110;
public static final int BIG_INTEGER = 111;
public static final int EMPTY = 200;
public static final int UNIT = 300;
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ 0000755 0001750 0001750 00000000000 11412747052 020442 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/ast/PreFixIncNode.java 0000644 0001750 0001750 00000003126 11153102156 023734 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class PreFixIncNode extends ASTNode {
private String name;
public PreFixIncNode(String name) {
this.name = name;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getVariableResolver(name);
vResolver.setValue(ctx = MathProcessor.doOperations(vResolver.getValue(), Operator.ADD, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IfNode.java 0000644 0001750 0001750 00000010061 11114570772 022451 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import java.util.HashMap;
/**
* @author Christopher Brock
*/
public class IfNode extends ASTNode implements NestedStatement {
protected char[] block;
protected ExecutableStatement condition;
protected ExecutableStatement nestedStatement;
protected IfNode elseIf;
protected ExecutableStatement elseBlock;
public IfNode(char[] condition, char[] block, int fields, ParserContext pCtx) {
if ((this.name = condition) == null || condition.length == 0) {
throw new CompileException("statement expected");
}
this.block = block;
if ((fields & COMPILE_IMMEDIATE) != 0) {
expectType(this.condition = (ExecutableStatement) subCompileExpression(condition, pCtx), Boolean.class, true);
this.nestedStatement = (ExecutableStatement) subCompileExpression(block, pCtx);
}
}
public IfNode(ExecutableStatement condition, ExecutableStatement nestedStatement, ExecutableStatement elseBlock) {
expectType(this.condition = condition, Boolean.class, true);
this.nestedStatement = nestedStatement;
this.elseBlock = elseBlock;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if ((Boolean) condition.getValue(ctx, thisValue, factory)) {
return nestedStatement.getValue(ctx, thisValue, new MapVariableResolverFactory(new HashMap(0), factory));
}
else if (elseIf != null) {
return elseIf.getReducedValueAccelerated(ctx, thisValue, new MapVariableResolverFactory(new HashMap(0), factory));
}
else if (elseBlock != null) {
return elseBlock.getValue(ctx, thisValue, new MapVariableResolverFactory(new HashMap(0), factory));
}
else {
return null;
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
if ((Boolean) eval(name, ctx, factory)) {
return eval(block, ctx, new MapVariableResolverFactory(new HashMap(0), factory));
}
else if (elseIf != null) {
return elseIf.getReducedValue(ctx, thisValue, new MapVariableResolverFactory(new HashMap(0), factory));
}
else if (elseBlock != null) {
return elseBlock.getValue(ctx, thisValue, new MapVariableResolverFactory(new HashMap(0), factory));
}
else {
return null;
}
}
public ExecutableStatement getNestedStatement() {
return nestedStatement;
}
public IfNode setElseIf(IfNode elseIf) {
return this.elseIf = elseIf;
}
public ExecutableStatement getElseBlock() {
return elseBlock;
}
public IfNode setElseBlock(char[] block) {
elseBlock = (ExecutableStatement) subCompileExpression(block);
return this;
}
public String toString() {
return new String(name);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/NewObjectNode.java 0000644 0001750 0001750 00000030106 11363353131 023767 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.*;
import static org.mvel2.DataConversion.convert;
import static org.mvel2.MVEL.analyze;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.Accessor;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import static org.mvel2.optimizers.OptimizerFactory.getThreadAccessorOptimizer;
import org.mvel2.util.ArrayTools;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.CompilerTools.getInjectedImports;
import static org.mvel2.util.ArrayTools.findFirst;
import static org.mvel2.util.ParseTools.*;
import java.io.Serializable;
import static java.lang.Thread.currentThread;
import static java.lang.reflect.Array.newInstance;
import static org.mvel2.util.ParseTools.getBestConstructorCandidate;
import java.lang.reflect.Constructor;
import java.util.Arrays;
/**
* @author Christopher Brock
*/
@SuppressWarnings({"ManualArrayCopy"})
public class NewObjectNode extends ASTNode {
private transient Accessor newObjectOptimizer;
private TypeDescriptor typeDescr;
public NewObjectNode(TypeDescriptor typeDescr, int fields, ParserContext pCtx) {
this.typeDescr = typeDescr;
this.fields = fields;
this.name = typeDescr.getClassNameArray();
if ((fields & COMPILE_IMMEDIATE) != 0) {
if (pCtx != null && pCtx.hasImport(typeDescr.getClassName())) {
pCtx.setAllowBootstrapBypass(false);
egressType = pCtx.getImport(typeDescr.getClassName());
}
else {
try {
egressType = Class.forName(typeDescr.getClassName(), true, currentThread().getContextClassLoader());
}
catch (ClassNotFoundException e) {
if (pCtx != null && pCtx.isStrongTyping())
pCtx.addError(new ErrorDetail("could not resolve class: " + typeDescr.getClassName(), true));
// do nothing.
}
}
if (egressType != null) {
rewriteClassReferenceToFQCN(fields);
if (typeDescr.isArray()) {
try {
egressType = findClass(null,
repeatChar('[', typeDescr.getArrayLength()) + "L" + egressType.getName() + ";", pCtx);
}
catch (Exception e) {
e.printStackTrace();
// for now, don't handle this.
}
}
}
if (pCtx != null && pCtx.isStrongTyping()) {
if (egressType == null) {
pCtx.addError(new ErrorDetail("could not resolve class: " + typeDescr.getClassName(), true));
return;
}
if (!typeDescr.isArray()) {
final String[] constructorParms = parseMethodOrConstructor(captureContructorAndResidual(name)[0].toCharArray());
final Class[] parms = new Class[constructorParms.length];
for (int i = 0; i < parms.length; i++) {
parms[i] = analyze(constructorParms[i], pCtx);
}
if (getBestConstructorCandidate(parms, egressType, true) == null) {
if (pCtx.isStrongTyping())
pCtx.addError(new ErrorDetail("could not resolve constructor " + typeDescr.getClassName()
+ Arrays.toString(parms), pCtx.isStrongTyping()));
}
}
}
}
}
private void rewriteClassReferenceToFQCN(int fields) {
String FQCN = egressType.getName();
if (typeDescr.getClassName().indexOf('.') == -1) {
int idx = ArrayTools.findFirst('(', name);
char[] fqcn = FQCN.toCharArray();
if (idx == -1) {
this.name = new char[idx = fqcn.length];
for (int i = 0; i < idx; i++)
this.name[i] = fqcn[i];
}
else {
char[] newName = new char[fqcn.length + (name.length - idx)];
for (int i = 0; i < fqcn.length; i++)
newName[i] = fqcn[i];
int i0 = name.length - idx;
int i1 = fqcn.length;
for (int i = 0; i < i0; i++)
newName[i + i1] = name[i + idx];
this.name = newName;
}
this.typeDescr.updateClassName(name, fields);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (newObjectOptimizer == null) {
if (egressType == null) {
/**
* This means we couldn't resolve the type at the time this AST node was created, which means
* we have to attempt runtime resolution.
*/
if (factory != null && factory.isResolveable(typeDescr.getClassName())) {
try {
egressType = (Class) factory.getVariableResolver(typeDescr.getClassName()).getValue();
rewriteClassReferenceToFQCN(COMPILE_IMMEDIATE);
if (typeDescr.isArray()) {
try {
egressType = findClass(factory,
repeatChar('[', typeDescr.getArrayLength()) + "L" + egressType.getName() + ";", null);
}
catch (Exception e) {
// for now, don't handle this.
}
}
}
catch (ClassCastException e) {
throw new CompileException("cannot construct object: " + typeDescr.getClassName() + " is not a class reference", e);
}
}
}
if (typeDescr.isArray()) {
return (newObjectOptimizer = new NewObjectArray(getBaseComponentType(egressType.getComponentType()), typeDescr.getCompiledArraySize()))
.getValue(ctx, thisValue, factory);
}
AccessorOptimizer optimizer = getThreadAccessorOptimizer();
ParserContext pCtx = new ParserContext();
pCtx.getParserConfiguration().setAllImports(getInjectedImports(factory));
newObjectOptimizer = optimizer.optimizeObjectCreation(pCtx, name, ctx, thisValue, factory);
/**
* Check to see if the optimizer actually produced the object during optimization. If so,
* we return that value now.
*/
if (optimizer.getResultOptPass() != null) {
egressType = optimizer.getEgressType();
return optimizer.getResultOptPass();
}
}
return newObjectOptimizer.getValue(ctx, thisValue, factory);
}
private static final Class[] EMPTYCLS = new Class[0];
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
if (typeDescr.isArray()) {
Class cls = findClass(factory, typeDescr.getClassName(), null);
int[] s = new int[typeDescr.getArrayLength()];
ArraySize[] arraySize = typeDescr.getArraySize();
for (int i = 0; i < s.length; i++) {
s[i] = convert(eval(arraySize[i].value, ctx, factory), Integer.class);
}
return newInstance(cls, s);
}
else {
String[] cnsRes = captureContructorAndResidual(name);
String[] constructorParms = parseMethodOrConstructor(cnsRes[0].toCharArray());
if (constructorParms != null) {
Class cls = findClass(factory, new String(subset(name, 0, findFirst('(', name))), null);
Object[] parms = new Object[constructorParms.length];
for (int i = 0; i < constructorParms.length; i++) {
parms[i] = eval(constructorParms[i], ctx, factory);
}
Constructor cns = getBestConstructorCandidate(parms, cls, false);
if (cns == null)
throw new CompileException("unable to find constructor for: " + cls.getName());
for (int i = 0; i < parms.length; i++) {
//noinspection unchecked
parms[i] = convert(parms[i], cns.getParameterTypes()[i]);
}
if (cnsRes.length > 1) {
return PropertyAccessor.get(cnsRes[1], cns.newInstance(parms), factory, thisValue);
}
else {
return cns.newInstance(parms);
}
}
else {
Constructor cns = Class.forName(typeDescr.getClassName(), true, currentThread().getContextClassLoader())
.getConstructor(EMPTYCLS);
if (cnsRes.length > 1) {
return PropertyAccessor.get(cnsRes[1], cns.newInstance(), factory, thisValue);
}
else {
return cns.newInstance();
}
}
}
}
catch (CompileException e) {
throw e;
}
catch (ClassNotFoundException e) {
throw new CompileException("unable to resolve class: " + e.getMessage(), e);
}
catch (NoSuchMethodException e) {
throw new CompileException("cannot resolve constructor: " + e.getMessage());
}
catch (Exception e) {
throw new CompileException("could not instantiate class: " + e.getMessage());
}
}
public Accessor getNewObjectOptimizer() {
return newObjectOptimizer;
}
public static class NewObjectArray implements Accessor, Serializable {
private ExecutableStatement[] sizes;
private Class arrayType;
public NewObjectArray(Class arrayType, ExecutableStatement[] sizes) {
this.arrayType = arrayType;
this.sizes = sizes;
}
public Object getValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory) {
int[] s = new int[sizes.length];
for (int i = 0; i < s.length; i++) {
s[i] = convert(sizes[i].getValue(ctx, elCtx, variableFactory), Integer.class);
}
return newInstance(arrayType, s);
}
public Object setValue(Object ctx, Object elCtx, VariableResolverFactory variableFactory, Object value) {
return null;
}
public Class getKnownEgressType() {
try {
return Class.forName("[L" + arrayType.getName() + ";");
}
catch (ClassNotFoundException cne) {
return null;
}
}
}
public TypeDescriptor getTypeDescr() {
return typeDescr;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Instance.java 0000644 0001750 0001750 00000002570 11104132451 023042 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.compiler.Accessor;
import org.mvel2.util.ParseTools;
import org.mvel2.util.CompilerTools;
import org.mvel2.MVEL;
import org.mvel2.CompileException;
public class Instance extends ASTNode {
private ASTNode stmt;
private ASTNode clsStmt;
public Instance(ASTNode stmt, ASTNode clsStmt) {
this.stmt = stmt;
this.clsStmt = clsStmt;
CompilerTools.expectType(clsStmt, Class.class, true);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Class) clsStmt.getReducedValueAccelerated(ctx, thisValue, factory)).isInstance(stmt.getReducedValueAccelerated(ctx, thisValue, factory));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
Class i = (Class) clsStmt.getReducedValue(ctx, thisValue, factory);
if (i == null) throw new ClassCastException();
return i.isInstance(stmt.getReducedValue(ctx, thisValue, factory));
}
catch (ClassCastException e) {
throw new CompileException("not a class reference: " + clsStmt.getName());
}
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/OperatorNode.java 0000644 0001750 0001750 00000003246 11155433536 023716 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import static org.mvel2.debug.DebugTools.getOperatorSymbol;
import org.mvel2.integration.VariableResolverFactory;
public class OperatorNode extends ASTNode {
private Integer operator;
public OperatorNode(Integer operator) {
assert operator != null;
this.literal = this.operator = operator;
}
public boolean isOperator() {
return true;
}
public boolean isOperator(Integer operator) {
return operator.equals(this.operator);
}
public Integer getOperator() {
return operator;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new CompileException("illegal use of operator: " + getOperatorSymbol(operator));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new CompileException("illegal use of operator: " + getOperatorSymbol(operator));
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IntAdd.java 0000644 0001750 0001750 00000001721 11307306541 022446 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.Operator;
public class IntAdd extends BinaryOperation implements IntOptimized {
public IntAdd(ASTNode left, ASTNode right) {
super(Operator.ADD);
this.left = left;
this.right = right;
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValueAccelerated(ctx, thisValue, factory))
+ ((Integer) right.getReducedValueAccelerated(ctx, thisValue, factory));
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValue(ctx, thisValue, factory))
+ ((Integer) right.getReducedValue(ctx, thisValue, factory));
}
@Override
public Class getEgressType() {
return Integer.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Negation.java 0000644 0001750 0001750 00000004403 11212317476 023053 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.subCompileExpression;
public class Negation extends ASTNode {
private ExecutableStatement stmt;
public Negation(char[] name, int fields, ParserContext pCtx) {
this.name = name;
if ((fields & COMPILE_IMMEDIATE) != 0) {
if (((this.stmt = (ExecutableStatement) subCompileExpression(name, pCtx)).getKnownEgressType() != null)
&& (!ParseTools.boxPrimitive(stmt.getKnownEgressType()).isAssignableFrom(Boolean.class))) {
throw new CompileException("negation operator cannot be applied to non-boolean type");
}
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return !((Boolean) stmt.getValue(ctx, thisValue, factory));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
return !((Boolean) MVEL.eval(name, ctx, factory));
}
catch (NullPointerException e) {
throw new CompileException("negation operator applied to a null value", e);
}
catch (ClassCastException e) {
throw new CompileException("negation operator applied to non-boolean expression", e);
}
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedPreFixIncNode.java 0000644 0001750 0001750 00000003167 11153102156 025242 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class IndexedPreFixIncNode extends ASTNode {
private int register;
public IndexedPreFixIncNode(int register) {
this.register = register;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getIndexedVariableResolver(register);
vResolver.setValue(ctx = MathProcessor.doOperations(vResolver.getValue(), Operator.ADD, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ForNode.java 0000644 0001750 0001750 00000007526 11114570772 022655 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import static org.mvel2.util.ParseTools.subset;
import java.util.HashMap;
/**
* @author Christopher Brock
*/
public class ForNode extends BlockNode {
protected String item;
protected ExecutableStatement initializer;
protected ExecutableStatement condition;
protected ExecutableStatement compiledBlock;
protected ExecutableStatement after;
public ForNode(char[] condition, char[] block, int fields, ParserContext pCtx) {
handleCond(this.name = condition, fields);
this.compiledBlock = (ExecutableStatement) subCompileExpression(this.block = block, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
for (initializer.getValue(ctx, thisValue, factory); (Boolean) condition.getValue(ctx, thisValue, factory); after.getValue(ctx, thisValue, factory)) {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
for (initializer.getValue(ctx, thisValue, factory = new MapVariableResolverFactory(new HashMap(0), factory)); (Boolean) condition.getValue(ctx, thisValue, factory); after.getValue(ctx, thisValue, factory)) {
compiledBlock.getValue(ctx, thisValue, factory);
}
return null;
}
public ForNode() {
super(); //To change body of overridden methods use File | Settings | File Templates.
}
private void handleCond(char[] condition, int fields) {
int start = 0;
int cursor = nextCondPart(condition, start, false);
try {
this.initializer = (ExecutableStatement) subCompileExpression(subset(condition, start, cursor - start - 1));
expectType(this.condition = (ExecutableStatement) subCompileExpression(subset(condition, start = cursor,
(cursor = nextCondPart(condition, start, false)) - start - 1)), Boolean.class, ((fields & COMPILE_IMMEDIATE) != 0));
this.after = (ExecutableStatement)
subCompileExpression(subset(condition, start = cursor, (nextCondPart(condition, start, true)) - start));
}
catch (NegativeArraySizeException e) {
throw new CompileException("wrong syntax; did you mean to use 'foreach'?");
}
}
private static int nextCondPart(char[] condition, int cursor, boolean allowEnd) {
for (; cursor < condition.length; cursor++) {
if (condition[cursor] == ';') return ++cursor;
}
if (!allowEnd) throw new CompileException("expected ;");
return cursor;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Fold.java 0000644 0001750 0001750 00000012477 11154053737 022207 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.DefaultLocalVariableResolverFactory;
import org.mvel2.integration.impl.ItemResolverFactory;
import org.mvel2.util.CompilerTools;
import org.mvel2.util.FastList;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.*;
import java.util.Collection;
import java.util.List;
import java.util.Iterator;
public class Fold extends ASTNode {
private ExecutableStatement subEx;
private ExecutableStatement dataEx;
private ExecutableStatement constraintEx;
public Fold(char[] name, int fields, ParserContext pCtx) {
this.name = name;
int cursor = 0;
for (; cursor < name.length; cursor++) {
if (isWhitespace(name[cursor])) {
while (cursor < name.length && isWhitespace(name[cursor])) cursor++;
if (name[cursor] == 'i' && name[cursor + 1] == 'n' && isJunct(name[cursor + 2])) {
break;
}
}
}
subEx = (ExecutableStatement) subCompileExpression(subset(name, 0, cursor - 1), pCtx);
int start = cursor += 2; // skip 'in'
for (; cursor < name.length; cursor++) {
if (isWhitespace(name[cursor])) {
while (cursor < name.length && isWhitespace(name[cursor])) cursor++;
if (name[cursor] == 'i' && name[cursor + 1] == 'f' && isJunct(name[cursor + 2])) {
int s = cursor + 2;
constraintEx = (ExecutableStatement) subCompileExpression(subset(name, s, name.length - s), pCtx);
break;
}
}
}
expectType(dataEx = (ExecutableStatement) subCompileExpression(subset(name, start, cursor - start), pCtx),
Collection.class, ((fields & COMPILE_IMMEDIATE) != 0));
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
ItemResolverFactory.ItemResolver itemR = new ItemResolverFactory.ItemResolver("$");
ItemResolverFactory itemFactory = new ItemResolverFactory(itemR, new DefaultLocalVariableResolverFactory(factory));
List list;
if (constraintEx != null) {
Collection col = ((Collection) dataEx.getValue(ctx, thisValue, factory));
list = new FastList(col.size());
for (Object o : col) {
itemR.value = o;
if ((Boolean) constraintEx.getValue(ctx, thisValue, itemFactory)) {
list.add(subEx.getValue(o, thisValue, itemFactory));
}
}
}
else {
Collection col = ((Collection) dataEx.getValue(ctx, thisValue, factory));
list = new FastList(col.size());
for (Object o : col) {
list.add(subEx.getValue(itemR.value = o, thisValue, itemFactory));
}
}
return list;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
ItemResolverFactory.ItemResolver itemR = new ItemResolverFactory.ItemResolver("$");
ItemResolverFactory itemFactory = new ItemResolverFactory(itemR, new DefaultLocalVariableResolverFactory(factory));
List list;
if (constraintEx != null) {
Object x = dataEx.getValue(ctx, thisValue, factory);
if (!(x instanceof Collection))
throw new CompileException("was expecting type: Collection; but found type: "
+ (x == null ? "null" : x.getClass().getName()));
list = new FastList(((Collection) x).size());
for (Object o : (Collection) x) {
itemR.value = o;
if ((Boolean) constraintEx.getValue(ctx, thisValue, itemFactory)) {
list.add(subEx.getValue(o, thisValue, itemFactory));
}
}
}
else {
Object x = dataEx.getValue(ctx, thisValue, factory);
if (!(x instanceof Collection))
throw new CompileException("was expecting type: Collection; but found type: "
+ (x == null ? "null" : x.getClass().getName()));
list = new FastList(((Collection) x).size());
for (Object o : (Collection) x) {
list.add(subEx.getValue(itemR.value = o, thisValue, itemFactory));
}
}
return list;
}
public Class getEgressType() {
return Collection.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedAssignmentNode.java 0000644 0001750 0001750 00000012252 11162250032 025513 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.MVEL;
import static org.mvel2.MVEL.compileSetExpression;
import org.mvel2.ParserContext;
import org.mvel2.compiler.CompiledAccExpression;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ArrayTools.findFirst;
import static org.mvel2.util.ParseTools.*;
/**
* @author Christopher Brock
*/
public class IndexedAssignmentNode extends ASTNode implements Assignment {
private String name;
private int register;
private transient CompiledAccExpression accExpr;
private char[] indexTarget;
private char[] index;
private char[] stmt;
private ExecutableStatement statement;
private boolean col = false;
public IndexedAssignmentNode(char[] expr, int fields, int operation, String name, int register, ParserContext pCtx) {
super.name = expr;
this.register = register;
int assignStart;
if (operation != -1) {
checkNameSafety(this.name = name);
this.egressType = (statement = (ExecutableStatement)
subCompileExpression(stmt = createShortFormOperativeAssignment(name, expr, operation), pCtx)).getKnownEgressType();
}
else if ((assignStart = find(expr, '=')) != -1) {
this.name = createStringTrimmed(expr, 0, assignStart);
this.egressType = (statement
= (ExecutableStatement) subCompileExpression(stmt = subset(expr, assignStart + 1), pCtx))
.getKnownEgressType();
if (col = ((endOfName = (short) findFirst('[', indexTarget = this.name.toCharArray())) > 0)) {
if (((this.fields |= COLLECTION) & COMPILE_IMMEDIATE) != 0) {
accExpr = (CompiledAccExpression) compileSetExpression(indexTarget, pCtx);
}
this.name = new String(expr, 0, endOfName);
index = subset(indexTarget, endOfName, indexTarget.length - endOfName);
}
checkNameSafety(this.name);
}
else {
checkNameSafety(this.name = new String(expr));
}
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.addVariable(name, egressType);
}
}
public IndexedAssignmentNode(char[] expr, int fields, int register, ParserContext pCtx) {
this(expr, fields, -1, null, register, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accExpr == null) {
accExpr = (CompiledAccExpression) compileSetExpression(indexTarget);
}
if (col) {
accExpr.setValue(ctx, thisValue, factory, ctx = statement.getValue(ctx, thisValue, factory));
}
else if (statement != null) {
if (factory.isIndexedFactory()) {
factory.createIndexedVariable(register, name, ctx = statement.getValue(ctx, thisValue, factory));
}
else {
factory.createVariable(name, ctx = statement.getValue(ctx, thisValue, factory));
}
}
else {
if (factory.isIndexedFactory()) {
factory.createIndexedVariable(register, name, null);
}
else {
factory.createVariable(name, statement.getValue(ctx, thisValue, factory));
}
return Void.class;
}
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
checkNameSafety(name);
if (col) {
MVEL.setProperty(factory.getIndexedVariableResolver(register).getValue(), new String(index), ctx = MVEL.eval(stmt, ctx, factory));
}
else {
factory.createIndexedVariable(register, name, ctx = MVEL.eval(stmt, ctx, factory));
}
return ctx;
}
public String getAssignmentVar() {
return name;
}
public char[] getExpression() {
return stmt;
}
public int getRegister() {
return register;
}
public void setRegister(int register) {
this.register = register;
}
public boolean isAssignment() {
return true;
}
public boolean isNewDeclaration() {
return false;
}
public void setValueStatement(ExecutableStatement stmt) {
this.statement = stmt;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/LiteralNode.java 0000644 0001750 0001750 00000003436 11151622475 023516 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.compiler.BlankLiteral;
/**
* @author Christopher Brock
*/
public class LiteralNode extends ASTNode {
public LiteralNode(Object literal, Class type) {
this(literal);
this.egressType = type;
}
public LiteralNode(Object literal) {
if ((this.literal = literal) != null) {
if ((this.egressType = literal.getClass()) == BlankLiteral.class) this.egressType = Object.class;
}
else {
this.egressType = Object.class;
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return literal;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return literal;
}
public Object getLiteralValue() {
return literal;
}
public void setLiteralValue(Object literal) {
this.literal = literal;
}
public boolean isLiteral() {
return true;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/BlockNode.java 0000644 0001750 0001750 00000001544 11077457613 023161 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
/**
* @author Christopher Brock
*/
public class BlockNode extends ASTNode {
protected char[] block;
public BlockNode() {
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/NewPrototypeNode.java 0000644 0001750 0001750 00000001440 11252763061 024571 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.ParserContext;
import org.mvel2.integration.VariableResolverFactory;
public class NewPrototypeNode extends ASTNode {
private String protoName;
public NewPrototypeNode(TypeDescriptor t) {
this.protoName = t.getClassName();
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Proto) factory.getVariableResolver(protoName).getValue())
.newInstance(ctx, thisValue, factory);
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Proto) factory.getVariableResolver(protoName).getValue())
.newInstance(ctx, thisValue, factory);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedPostFixDecNode.java 0000644 0001750 0001750 00000003361 11154053737 025432 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.util.ParseTools;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class IndexedPostFixDecNode extends ASTNode {
private int register;
public IndexedPostFixDecNode(int register) {
this.register = register;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getIndexedVariableResolver(register);
// ctx = vResolver.getValue();
vResolver.setValue(MathProcessor.doOperations(ParseTools.resolveType(ctx = vResolver.getValue()),
ctx, Operator.SUB, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/UntilNode.java 0000644 0001750 0001750 00000004607 11114570772 023217 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.ParserContext;
import java.util.HashMap;
/**
* @author Christopher Brock
*/
public class UntilNode extends BlockNode {
protected String item;
protected ExecutableStatement condition;
protected ExecutableStatement compiledBlock;
public UntilNode(char[] condition, char[] block, int fields, ParserContext pCtx) {
expectType(this.condition = (ExecutableStatement) subCompileExpression(this.name = condition, pCtx),
Boolean.class, ((fields & COMPILE_IMMEDIATE) != 0));
this.compiledBlock = (ExecutableStatement) subCompileExpression(this.block = block, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
while (!(Boolean) condition.getValue(ctx, thisValue, factory)) {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
while (!(Boolean) condition.getValue(ctx, thisValue, factory)) {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
return null;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Union.java 0000644 0001750 0001750 00000004503 11154053737 022402 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.PropertyAccessor;
import static org.mvel2.compiler.AbstractParser.getCurrentThreadParserContext;
import org.mvel2.compiler.Accessor;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizerFactory;
public class Union extends ASTNode {
private ASTNode main;
private transient Accessor accessor;
public Union(char[] expr, int start, int end, int fields, ASTNode main) {
super(expr, start, end, fields);
this.main = main;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accessor != null) {
return accessor.getValue(main.getReducedValueAccelerated(ctx, thisValue, factory), thisValue, factory);
}
else {
AccessorOptimizer o = OptimizerFactory.getThreadAccessorOptimizer();
accessor = o.optimizeAccessor(getCurrentThreadParserContext(), name,
main.getReducedValueAccelerated(ctx, thisValue, factory), thisValue, factory, false, main.getEgressType());
return o.getResultOptPass();
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return PropertyAccessor.get(
name,
main.getReducedValue(ctx, thisValue, factory), factory, thisValue);
}
public Class getLeftEgressType() {
return main.getEgressType();
}
public String toString() {
return (main != null ? main.toString() : "") + "-[union]->" + (accessor != null ? accessor.toString() : "");
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ReturnNode.java 0000644 0001750 0001750 00000003401 11114570772 023372 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.Accessor;
import org.mvel2.compiler.EndWithValue;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.ParserContext;
/**
* @author Christopher Brock
*/
public class ReturnNode extends ASTNode {
public ReturnNode(char[] expr, int fields, ParserContext pCtx){
this.name = expr;
if ((fields & COMPILE_IMMEDIATE) != 0) {
setAccessor((Accessor) subCompileExpression(expr, pCtx));
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accessor == null) {
setAccessor((Accessor) subCompileExpression(this.name));
}
throw new EndWithValue(accessor.getValue(ctx, thisValue, factory));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new EndWithValue(eval(this.name, ctx, factory));
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/DeclProtoVarNode.java 0000644 0001750 0001750 00000005017 11253516374 024466 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.checkNameSafety;
/**
* @author Christopher Brock
*/
public class DeclProtoVarNode extends ASTNode implements Assignment {
private String name;
public DeclProtoVarNode(String name, Proto type, int fields, ParserContext pCtx) {
this.egressType = Proto.ProtoInstance.class;
checkNameSafety(this.name = name);
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.addVariable(name, egressType, true);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (!factory.isResolveable(name)) factory.createVariable(name, null, egressType);
else throw new CompileException("variable defined within scope: " + name);
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (!factory.isResolveable(name)) factory.createVariable(name, null, egressType);
else throw new CompileException("variable defined within scope: " + name);
return null;
}
public String getName() {
return name;
}
public String getAssignmentVar() {
return name;
}
public char[] getExpression() {
return new char[0];
}
public boolean isAssignment() {
return true;
}
public boolean isNewDeclaration() {
return true;
}
public void setValueStatement(ExecutableStatement stmt) {
throw new RuntimeException("illegal operation");
}
public String toString() {
return "var:" + name;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Sign.java 0000644 0001750 0001750 00000007046 11235611312 022204 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.boxPrimitive;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.io.Serializable;
public class Sign extends ASTNode {
private Signer signer;
private ExecutableStatement stmt;
public Sign(char[] expr, int start, int end, int fields, ParserContext pCtx) {
super(expr, start + 1, end, fields);
if ((fields & COMPILE_IMMEDIATE) != 0) {
stmt = (ExecutableStatement) ParseTools.subCompileExpression(name, pCtx);
egressType = stmt.getKnownEgressType();
if (egressType != null && egressType != Object.class) {
initSigner(egressType);
}
}
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return sign(stmt.getValue(ctx, thisValue, factory));
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return sign(MVEL.eval(name, thisValue, factory));
}
private Object sign(Object o) {
if (o == null) return null;
if (signer == null) {
if (egressType == null || egressType == Object.class) egressType = o.getClass();
initSigner(egressType);
}
return signer.sign(o);
}
private void initSigner(Class type) {
if (Integer.class.isAssignableFrom(type = boxPrimitive(type))) signer = new IntegerSigner();
else if (Double.class.isAssignableFrom(type)) signer = new DoubleSigner();
else if (Long.class.isAssignableFrom(type)) signer = new LongSigner();
else if (Float.class.isAssignableFrom(type)) signer = new FloatSigner();
else if (Short.class.isAssignableFrom(type)) signer = new ShortSigner();
else if (BigInteger.class.isAssignableFrom(type)) signer = new BigIntSigner();
else if (BigDecimal.class.isAssignableFrom(type)) signer = new BigDecSigner();
else {
throw new CompileException("illegal use of '-': cannot be applied to: " + type.getName());
}
}
private interface Signer extends Serializable {
public Object sign(Object o);
}
private class IntegerSigner implements Signer {
public Object sign(Object o) {
return -((Integer) o);
}
}
private class ShortSigner implements Signer {
public Object sign(Object o) {
return -((Short) o);
}
}
private class LongSigner implements Signer {
public Object sign(Object o) {
return -((Long) o);
}
}
private class DoubleSigner implements Signer {
public Object sign(Object o) {
return -((Double) o);
}
}
private class FloatSigner implements Signer {
public Object sign(Object o) {
return -((Float) o);
}
}
private class BigIntSigner implements Signer {
public Object sign(Object o) {
return new BigInteger(String.valueOf(-(((BigInteger) o).longValue())));
}
}
private class BigDecSigner implements Signer {
public Object sign(Object o) {
return new BigDecimal(-((BigInteger) o).longValue());
}
}
@Override
public boolean isIdentifier() {
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ThisWithNode.java 0000644 0001750 0001750 00000003612 11111332212 023640 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import static org.mvel2.MVEL.executeSetExpression;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class ThisWithNode extends WithNode {
public ThisWithNode(char[] expr, char[] block, int fields, ParserContext pCtx) {
super(expr, block, fields, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (thisValue == null) throw new CompileException("with-block against null pointer (this)");
for (ParmValuePair pvp : withExpressions) {
if (pvp.getSetExpression() != null) {
executeSetExpression(pvp.getSetExpression(), thisValue, factory, pvp.getStatement().getValue(ctx, thisValue, factory));
}
else {
pvp.getStatement().getValue(thisValue, thisValue, factory);
}
}
return thisValue;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IntOptimized.java 0000644 0001750 0001750 00000000072 11244064005 023714 0 ustar drazzib drazzib package org.mvel2.ast;
public interface IntOptimized {
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/BinaryOperation.java 0000644 0001750 0001750 00000013665 11244064005 024416 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import org.mvel2.Operator;
import static org.mvel2.Operator.PTABLE;
import org.mvel2.ParserContext;
import static org.mvel2.debug.DebugTools.getOperatorSymbol;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.math.MathProcessor.doOperations;
import static org.mvel2.util.CompilerTools.getReturnTypeFromOp;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.boxPrimitive;
public class BinaryOperation extends BooleanNode {
private final int operation;
private int lType = -1;
private int rType = -1;
public BinaryOperation(int operation) {
this.operation = operation;
}
public BinaryOperation(int operation, ASTNode left, ASTNode right) {
this.operation = operation;
if ((this.left = left) == null) {
throw new CompileException("not a statement");
}
if ((this.right = right) == null) {
throw new CompileException("not a statement");
}
egressType = getReturnTypeFromOp(operation, left.egressType, right.egressType);
}
public BinaryOperation(int operation, ASTNode left, ASTNode right, ParserContext ctx) {
this.operation = operation;
if ((this.left = left) == null) {
throw new CompileException("not a statement");
}
if ((this.right = right) == null) {
throw new CompileException("not a statement");
}
if (ctx.isStrongTyping()) {
switch (operation) {
case Operator.ADD:
/**
* In the special case of Strings, the return type may leftward propogate.
*/
if (left.getEgressType() == String.class || right.getEgressType() == String.class) {
egressType = String.class;
lType = ParseTools.__resolveType(left.egressType);
rType = ParseTools.__resolveType(right.egressType);
return;
}
default:
if (!left.getEgressType().isAssignableFrom(right.getEgressType())) {
if (right.isLiteral() && canConvert(right.getEgressType(), left.getEgressType())) {
this.right = new LiteralNode(convert(right.getReducedValueAccelerated(null, null, null), left.getEgressType()));
}
else if (!(Number.class.isAssignableFrom(right.getEgressType()) && Number.class.isAssignableFrom(left.getEgressType()))
&& ((!right.getEgressType().isPrimitive() && !left.getEgressType().isPrimitive())
|| (!canConvert(boxPrimitive(left.getEgressType()), boxPrimitive(right.getEgressType()))))) {
throw new CompileException("incompatible types in statement: " + right.getEgressType() + " (compared from: " + left.getEgressType() + ")");
}
}
}
}
if (this.left.isLiteral() && this.right.isLiteral()) {
if (this.left.egressType == this.right.egressType) {
lType = rType = ParseTools.__resolveType(left.egressType);
}
else {
lType = ParseTools.__resolveType(this.left.egressType);
rType = ParseTools.__resolveType(this.right.egressType);
}
}
egressType = getReturnTypeFromOp(operation, this.left.egressType, this.right.egressType);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return doOperations(lType, left.getReducedValueAccelerated(ctx, thisValue, factory), operation, rType, right.getReducedValueAccelerated(ctx, thisValue, factory));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new RuntimeException("unsupported AST operation");
}
public int getOperation() {
return operation;
}
public BinaryOperation getRightBinary() {
return right != null && right instanceof BinaryOperation ? (BinaryOperation) right : null;
}
public void setRightMost(ASTNode right) {
BinaryOperation n = this;
while (n.right != null && n.right instanceof BinaryOperation) {
n = (BinaryOperation) n.right;
}
n.right = right;
if (n == this) {
if ((rType = ParseTools.__resolveType(n.right.getEgressType())) == 0) rType = -1;
}
}
public ASTNode getRightMost() {
BinaryOperation n = this;
while (n.right != null && n.right instanceof BinaryOperation) {
n = (BinaryOperation) n.right;
}
return n.right;
}
public int getPrecedence() {
return PTABLE[operation];
}
public boolean isGreaterPrecedence(BinaryOperation o) {
return o.getPrecedence() > PTABLE[operation];
}
@Override
public boolean isLiteral() {
return false;
}
public String toString() {
return "(" + left + " " + getOperatorSymbol(operation) + " " + right + ")";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ArraySize.java 0000644 0001750 0001750 00000001553 11077457613 023232 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import java.io.Serializable;
public class ArraySize implements Serializable {
public ArraySize(char[] value) {
this.value = value;
}
public char[] value;
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Substatement.java 0000644 0001750 0001750 00000003530 11224677601 023767 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
public class Substatement extends ASTNode {
private ExecutableStatement statement;
public Substatement(char[] expr, int fields, ParserContext pCtx) {
this.name = expr;
if (((this.fields = fields) & COMPILE_IMMEDIATE) != 0) {
this.egressType = (this.statement = (ExecutableStatement) subCompileExpression(this.name, pCtx))
.getKnownEgressType();
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return statement.getValue(ctx, thisValue, factory);
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return MVEL.eval(this.name, ctx, factory);
}
public ExecutableStatement getStatement() {
return statement;
}
public String toString() {
return statement == null ? "(" + new String(name) + ")" : statement.toString();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Strsim.java 0000644 0001750 0001750 00000002714 11104141054 022556 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.CompilerTools;
import static org.mvel2.util.ParseTools.similarity;
public class Strsim extends ASTNode {
private ASTNode stmt;
private ASTNode soundslike;
public Strsim(ASTNode stmt, ASTNode clsStmt) {
this.stmt = stmt;
this.soundslike = clsStmt;
CompilerTools.expectType(clsStmt, String.class, true);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return similarity(String.valueOf(soundslike.getReducedValueAccelerated(ctx, thisValue, factory)),
((String) stmt.getReducedValueAccelerated(ctx, thisValue, factory)));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
String i = String.valueOf(soundslike.getReducedValue(ctx, thisValue, factory));
if (i == null) throw new ClassCastException();
String x = (String) stmt.getReducedValue(ctx, thisValue, factory);
if (x == null) throw new CompileException("not a string: " + stmt.getName());
return similarity(i,x);
}
catch (ClassCastException e) {
throw new CompileException("not a string: " + soundslike.getName());
}
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/EndOfStatement.java 0000644 0001750 0001750 00000002735 11077457613 024204 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class EndOfStatement extends ASTNode {
public EndOfStatement() {
this.literal = getOperator();
}
public boolean isOperator() {
return true;
}
public boolean isOperator(Integer operator) {
return operator == Operator.END_OF_STMT;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return null;
}
public Integer getOperator() {
return Operator.END_OF_STMT;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/RegExMatchNode.java 0000644 0001750 0001750 00000003265 11077457613 024120 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.eval;
import org.mvel2.integration.VariableResolverFactory;
import static java.lang.String.valueOf;
import static java.util.regex.Pattern.compile;
public class RegExMatchNode extends ASTNode {
private ASTNode node;
private ASTNode patternNode;
public RegExMatchNode(ASTNode matchNode, ASTNode patternNode) {
this.node = matchNode;
this.patternNode = patternNode;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return compile(valueOf(patternNode.getReducedValueAccelerated(ctx, thisValue, factory))).matcher(valueOf(node.getReducedValueAccelerated(ctx, thisValue, factory))).matches();
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return compile(valueOf(eval(name, ctx, factory))).matcher(valueOf(eval(name, ctx, factory))).matches();
}
public Class getEgressType() {
return Boolean.class;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IsDef.java 0000644 0001750 0001750 00000002751 11210544111 022267 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.PropertyTools.getFieldOrAccessor;
public class IsDef extends ASTNode {
public IsDef(char[] expr) {
this.nameCache = new String(this.name = expr);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return factory.isResolveable(nameCache) || (thisValue != null && getFieldOrAccessor(thisValue.getClass(), nameCache) != null);
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return factory.isResolveable(nameCache) || (thisValue != null && getFieldOrAccessor(thisValue.getClass(), nameCache) != null);
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedPreFixDecNode.java 0000644 0001750 0001750 00000003165 11153102156 025222 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class IndexedPreFixDecNode extends ASTNode {
private int register;
public IndexedPreFixDecNode(int register) {
this.register = register;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getIndexedVariableResolver(register);
vResolver.setValue(ctx = MathProcessor.doOperations(vResolver.getValue(), Operator.SUB, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/PostFixDecNode.java 0000644 0001750 0001750 00000003126 11153102156 024115 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class PostFixDecNode extends ASTNode {
private String name;
public PostFixDecNode(String name) {
this.name = name;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getVariableResolver(name);
vResolver.setValue(MathProcessor.doOperations(ctx = vResolver.getValue(), Operator.SUB, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Invert.java 0000644 0001750 0001750 00000003667 11115170774 022571 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.CompilerTools;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
public class Invert extends ASTNode {
private ExecutableStatement stmt;
public Invert(char[] name, int fields, ParserContext pCtx) {
this.name = name;
if ((fields & COMPILE_IMMEDIATE) != 0) {
expectType(this.stmt = (ExecutableStatement) subCompileExpression(name, pCtx), Integer.class, true);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ~((Integer) stmt.getValue(ctx, thisValue, factory));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
Object o = MVEL.eval(name, ctx, factory);
if (o instanceof Integer) {
return ~((Integer) o);
}
else {
throw new CompileException("was expecting type: Integer; but found type: " + (o == null ? "null" : o.getClass().getName()));
}
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/AssertNode.java 0000644 0001750 0001750 00000004646 11163351223 023360 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
/**
* @author Christopher Brock
*/
public class AssertNode extends ASTNode {
public ExecutableStatement assertion;
public ExecutableStatement fail;
public AssertNode(char[] expr, int fields, ParserContext pCtx) {
this.name = expr;
if ((fields & COMPILE_IMMEDIATE) != 0) {
assertion = (ExecutableStatement) subCompileExpression(expr, pCtx);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
if (!((Boolean) assertion.getValue(ctx, thisValue, factory))) {
throw new AssertionError("assertion failed in expression: " + new String(this.name));
}
else {
return true;
}
}
catch (ClassCastException e) {
throw new CompileException("assertion does not contain a boolean statement");
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
if (!((Boolean) MVEL.eval(this.name, ctx, factory))) {
throw new AssertionError("assertion failed in expression: " + new String(this.name));
}
else {
return true;
}
}
catch (ClassCastException e) {
throw new CompileException("assertion does not contain a boolean statement");
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/DoUntilNode.java 0000644 0001750 0001750 00000004563 11114570772 023503 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.ParserContext;
import java.util.HashMap;
/**
* @author Christopher Brock
*/
public class DoUntilNode extends BlockNode {
protected String item;
protected ExecutableStatement condition;
protected ExecutableStatement compiledBlock;
public DoUntilNode(char[] condition, char[] block, ParserContext pCtx) {
expectType(this.condition = (ExecutableStatement) subCompileExpression(this.name = condition, pCtx),
Boolean.class, ((fields & COMPILE_IMMEDIATE) != 0));
this.compiledBlock = (ExecutableStatement) subCompileExpression(this.block = block, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory lc = new MapVariableResolverFactory(new HashMap(0), factory);
do {
compiledBlock.getValue(ctx, thisValue, lc);
}
while (!(Boolean) condition.getValue(ctx, thisValue, lc));
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory lc = new MapVariableResolverFactory(new HashMap(0), factory);
do {
compiledBlock.getValue(ctx, thisValue, lc);
}
while (!(Boolean) condition.getValue(ctx, thisValue, lc));
return null;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/AssignmentNode.java 0000644 0001750 0001750 00000010162 11165573105 024224 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.MVEL;
import static org.mvel2.MVEL.compileSetExpression;
import org.mvel2.ParserContext;
import org.mvel2.PropertyAccessor;
import org.mvel2.compiler.CompiledAccExpression;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ArrayTools.findFirst;
import static org.mvel2.util.ParseTools.*;
/**
* @author Christopher Brock
*/
public class AssignmentNode extends ASTNode implements Assignment {
private String varName;
private transient CompiledAccExpression accExpr;
private char[] indexTarget;
private String index;
private char[] stmt;
private ExecutableStatement statement;
private boolean col = false;
public AssignmentNode(char[] expr, int fields, ParserContext pCtx) {
this.name = expr;
int assignStart;
if ((assignStart = find(expr, '=')) != -1) {
this.varName = createStringTrimmed(expr, 0, assignStart);
stmt = subset(expr, assignStart + 1);
if ((fields & COMPILE_IMMEDIATE) != 0) {
this.egressType = (statement = (ExecutableStatement) subCompileExpression(stmt, pCtx)).getKnownEgressType();
}
if (col = ((endOfName = findFirst('[', indexTarget = this.varName.toCharArray())) > 0)) {
if (((this.fields |= COLLECTION) & COMPILE_IMMEDIATE) != 0) {
accExpr = (CompiledAccExpression) compileSetExpression(indexTarget, pCtx);
}
this.varName = new String(expr, 0, endOfName);
index = new String(indexTarget, endOfName, indexTarget.length - endOfName);
}
checkNameSafety(this.varName);
}
else {
checkNameSafety(this.varName = new String(expr));
}
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.addVariable(this.varName, egressType);
}
this.name = this.varName.toCharArray();
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accExpr == null) {
accExpr = (CompiledAccExpression) compileSetExpression(indexTarget);
}
if (col) {
return accExpr.setValue(ctx, thisValue, factory, statement.getValue(ctx, thisValue, factory));
}
else if (statement != null) {
return factory.createVariable(varName, statement.getValue(ctx, thisValue, factory)).getValue();
}
else {
factory.createVariable(varName, null);
return null;
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
checkNameSafety(varName);
if (col) {
PropertyAccessor.set(factory.getVariableResolver(varName).getValue(), factory, index, ctx = MVEL.eval(stmt, ctx, factory));
}
else {
return factory.createVariable(varName, MVEL.eval(stmt, ctx, factory)).getValue();
}
return ctx;
}
public String getAssignmentVar() {
return varName;
}
public char[] getExpression() {
return stmt;
}
public boolean isNewDeclaration() {
return false;
}
public void setValueStatement(ExecutableStatement stmt) {
this.statement = stmt;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Contains.java 0000644 0001750 0001750 00000003021 11077457613 023067 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.containsCheck;
public class Contains extends ASTNode {
private ASTNode stmt;
private ASTNode stmt2;
public Contains(ASTNode stmt, ASTNode stmt2) {
this.stmt = stmt;
this.stmt2 = stmt2;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return containsCheck(stmt.getReducedValueAccelerated(ctx, thisValue, factory), stmt2.getReducedValueAccelerated(ctx, thisValue, factory));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new RuntimeException("operation not supported");
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Convertable.java 0000644 0001750 0001750 00000002701 11104135617 023545 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.DataConversion;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.CompilerTools;
public class Convertable extends ASTNode {
private ASTNode stmt;
private ASTNode clsStmt;
public Convertable(ASTNode stmt, ASTNode clsStmt) {
this.stmt = stmt;
this.clsStmt = clsStmt;
CompilerTools.expectType(clsStmt, Class.class, true);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
Object o = stmt.getReducedValueAccelerated(ctx, thisValue, factory);
return o != null && DataConversion.canConvert(
(Class) clsStmt.getReducedValueAccelerated(ctx, thisValue, factory), o.getClass());
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
Object o = stmt.getReducedValue(ctx, thisValue, factory);
if (o == null) return false;
Class i = (Class) clsStmt.getReducedValue(ctx, thisValue, factory);
if (i == null) throw new ClassCastException();
return DataConversion.canConvert(i,o.getClass());
}
catch (ClassCastException e) {
throw new CompileException("not a class reference: " + clsStmt.getName());
}
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IntMult.java 0000644 0001750 0001750 00000001724 11307306541 022702 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.integration.VariableResolverFactory;
public class IntMult extends BinaryOperation implements IntOptimized {
public IntMult(ASTNode left, ASTNode right) {
super(Operator.MULT);
this.left = left;
this.right = right;
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValueAccelerated(ctx, thisValue, factory))
* ((Integer) right.getReducedValueAccelerated(ctx, thisValue, factory));
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValue(ctx, thisValue, factory))
* ((Integer) right.getReducedValue(ctx, thisValue, factory));
}
@Override
public Class getEgressType() {
return Integer.class;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/TypedVarNode.java 0000644 0001750 0001750 00000006005 11115170774 023653 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.eval;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.*;
/**
* @author Christopher Brock
*/
public class TypedVarNode extends ASTNode implements Assignment {
private String name;
private char[] stmt;
private ExecutableStatement statement;
public TypedVarNode(String name, Class type) {
this.name = name;
this.egressType = type;
}
public TypedVarNode(char[] expr, int fields, Class type, ParserContext pCtx) {
this.egressType = type;
this.fields = fields;
int assignStart;
if ((assignStart = find(super.name = expr, '=')) != -1) {
checkNameSafety(name = createStringTrimmed(expr, 0, assignStart));
if (((fields |= ASSIGN) & COMPILE_IMMEDIATE) != 0) {
statement = (ExecutableStatement) subCompileExpression(stmt = subset(expr, assignStart + 1), pCtx);
}
else {
stmt = subset(expr, assignStart + 1);
}
}
else {
checkNameSafety(name = new String(expr));
}
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.addVariable(name, egressType, true);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (statement == null) statement = (ExecutableStatement) subCompileExpression(stmt);
factory.createVariable(name, ctx = statement.getValue(ctx, thisValue, factory), egressType);
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createVariable(name, ctx = eval(stmt, thisValue, factory), egressType);
return ctx;
}
public String getName() {
return name;
}
public String getAssignmentVar() {
return name;
}
public char[] getExpression() {
return stmt;
}
public boolean isNewDeclaration() {
return true;
}
public void setValueStatement(ExecutableStatement stmt) {
this.statement = stmt;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/TypeCast.java 0000644 0001750 0001750 00000005427 11274117371 023052 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.util.CompilerTools;
import org.mvel2.ParserContext;
import org.mvel2.DataConversion;
import org.mvel2.CompileException;
public class TypeCast extends ASTNode {
private ExecutableStatement statement;
private boolean widen;
public TypeCast(char[] expr, Class cast, int fields, ParserContext pCtx) {
this.egressType = cast;
this.name = expr;
if ((fields & COMPILE_IMMEDIATE) != 0) {
if ((statement = (ExecutableStatement) subCompileExpression(name, pCtx)).getKnownEgressType() != Object.class
&& !canConvert(cast, statement.getKnownEgressType())) {
if (statement.getKnownEgressType().isAssignableFrom(cast)) {
widen = true;
} else {
throw new CompileException("unable to cast type: " + statement.getKnownEgressType() + "; to: " + cast);
}
}
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
//noinspection unchecked
return widen ? typeCheck(statement.getValue(ctx, thisValue, factory), egressType) : convert(statement.getValue(ctx, thisValue, factory), egressType);
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
//noinspection unchecked
return widen ? typeCheck(eval(name, ctx, factory), egressType) : convert(eval(name, ctx, factory), egressType);
}
private static Object typeCheck(Object inst, Class type) {
if (inst == null) return null;
if (type.isInstance(inst)) {
return inst;
}
else {
throw new ClassCastException(inst.getClass().getName() + " cannot be cast to: " + type.getClass().getName());
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/OperativeAssign.java 0000644 0001750 0001750 00000004575 11153102156 024413 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.util.ParseTools;
import org.mvel2.math.MathProcessor;
import org.mvel2.ParserContext;
public class OperativeAssign extends ASTNode {
private String varName;
private ExecutableStatement statement;
private final int operation;
private int knownInType = -1;
public OperativeAssign(String variableName, char[] expr, int operation, int fields, ParserContext pCtx) {
this.varName = variableName;
this.operation = operation;
this.name = expr;
if ((fields & COMPILE_IMMEDIATE) != 0) {
egressType = (statement = (ExecutableStatement) subCompileExpression(expr, pCtx)).getKnownEgressType();
if (pCtx.isStrongTyping()) {
knownInType = ParseTools.__resolveType(egressType);
}
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver resolver = factory.getVariableResolver(varName);
resolver.setValue(ctx = MathProcessor.doOperations(resolver.getValue(), operation, knownInType, statement.getValue(ctx, thisValue, factory)));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver resolver = factory.getVariableResolver(varName);
resolver.setValue(ctx = MathProcessor.doOperations(resolver.getValue(), operation, eval(name, ctx, factory)));
return ctx;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/BooleanNode.java 0000644 0001750 0001750 00000001000 11144173417 023461 0 ustar drazzib drazzib package org.mvel2.ast;
public abstract class BooleanNode extends ASTNode {
protected ASTNode left;
protected ASTNode right;
public ASTNode getLeft() {
return this.left;
}
public ASTNode getRight() {
return this.right;
}
public void setLeft(ASTNode node) {
this.left = node;
}
public void setRight(ASTNode node) {
this.right = node;
}
public abstract void setRightMost(ASTNode right);
public abstract ASTNode getRightMost();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/NestedStatement.java 0000644 0001750 0001750 00000001602 11077457613 024423 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
/**
* @author Christopher Brock
*/
public interface NestedStatement {
public ExecutableStatement getNestedStatement();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IntSub.java 0000644 0001750 0001750 00000001723 11307306541 022511 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.Operator;
public class IntSub extends BinaryOperation implements IntOptimized {
public IntSub(ASTNode left, ASTNode right) {
super(Operator.SUB);
this.left = left;
this.right = right;
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValueAccelerated(ctx, thisValue, factory))
- ((Integer) right.getReducedValueAccelerated(ctx, thisValue, factory));
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValue(ctx, thisValue, factory))
- ((Integer) right.getReducedValue(ctx, thisValue, factory));
}
@Override
public Class getEgressType() {
return Integer.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Safe.java 0000644 0001750 0001750 00000001431 11077457613 022172 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
/**
* Marker interface to tell MVEL it can safely hard-reference.
*/
public interface Safe {
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/DoNode.java 0000644 0001750 0001750 00000004647 11114570772 022472 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.ParserContext;
import java.util.HashMap;
/**
* @author Christopher Brock
*/
public class DoNode extends BlockNode {
protected String item;
protected ExecutableStatement condition;
protected ExecutableStatement compiledBlock;
public DoNode(char[] condition, char[] block, int fields, ParserContext pCtx) {
this.condition = (ExecutableStatement) subCompileExpression(this.name = condition, pCtx);
expectType(this.condition, Boolean.class, ((fields & COMPILE_IMMEDIATE) != 0));
this.compiledBlock = (ExecutableStatement) subCompileExpression(this.block = block, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
do {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
while ((Boolean) condition.getValue(ctx, thisValue, factory));
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
do {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
while ((Boolean) condition.getValue(ctx, thisValue, factory));
return null;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/DeepAssignmentNode.java 0000644 0001750 0001750 00000007424 11166754071 025035 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.compileSetExpression;
import static org.mvel2.MVEL.eval;
import org.mvel2.ParserContext;
import static org.mvel2.PropertyAccessor.set;
import static org.mvel2.compiler.AbstractParser.getCurrentThreadParserContext;
import org.mvel2.compiler.CompiledAccExpression;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.*;
/**
* @author Christopher Brock
*/
public class DeepAssignmentNode extends ASTNode implements Assignment {
private String property;
private char[] stmt;
private CompiledAccExpression acc;
private ExecutableStatement statement;
public DeepAssignmentNode(char[] expr, int fields, int operation, String name, ParserContext pCtx) {
this.fields |= DEEP_PROPERTY | fields;
this.name = expr;
int mark;
if (operation != -1) {
this.egressType = ((statement =
(ExecutableStatement) subCompileExpression(stmt =
createShortFormOperativeAssignment(this.property = name, expr, operation), pCtx))).getKnownEgressType();
}
else if ((mark = find(expr, '=')) != -1) {
property = createStringTrimmed(expr, 0, mark);
stmt = subset(expr, mark + 1);
if ((fields & COMPILE_IMMEDIATE) != 0) {
statement = (ExecutableStatement) subCompileExpression(stmt, pCtx);
}
}
else {
property = new String(expr);
}
if ((fields & COMPILE_IMMEDIATE) != 0) {
acc = (CompiledAccExpression) compileSetExpression(property.toCharArray(), pCtx);
}
}
public DeepAssignmentNode(char[] expr, int fields, ParserContext pCtx) {
this(expr, fields, -1, null, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (statement == null) {
statement = (ExecutableStatement) subCompileExpression(stmt);
acc = (CompiledAccExpression) compileSetExpression(property.toCharArray(), statement.getKnownEgressType(),
getCurrentThreadParserContext());
}
acc.setValue(ctx, thisValue, factory, ctx = statement.getValue(ctx, thisValue, factory));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
set(ctx, factory, property, ctx = eval(stmt, ctx, factory));
return ctx;
}
@Override
public String getAbsoluteName() {
return property.substring(0, property.indexOf('.'));
}
public String getAssignmentVar() {
return property;
}
public char[] getExpression() {
return stmt;
}
public boolean isNewDeclaration() {
return false;
}
public boolean isAssignment() {
return true;
}
public void setValueStatement(ExecutableStatement stmt) {
this.statement = stmt;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/DeclTypedVarNode.java 0000644 0001750 0001750 00000004772 11155416072 024452 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.checkNameSafety;
/**
* @author Christopher Brock
*/
public class DeclTypedVarNode extends ASTNode implements Assignment {
private String name;
public DeclTypedVarNode(String name, Class type, int fields, ParserContext pCtx) {
this.egressType = type;
checkNameSafety(this.name = name);
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.addVariable(name, egressType, true);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (!factory.isResolveable(name)) factory.createVariable(name, null, egressType);
else throw new CompileException("variable defined within scope: " + name);
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (!factory.isResolveable(name)) factory.createVariable(name, null, egressType);
else throw new CompileException("variable defined within scope: " + name);
return null;
}
public String getName() {
return name;
}
public String getAssignmentVar() {
return name;
}
public char[] getExpression() {
return new char[0];
}
public boolean isAssignment() {
return true;
}
public boolean isNewDeclaration() {
return true;
}
public void setValueStatement(ExecutableStatement stmt) {
throw new RuntimeException("illegal operation");
}
public String toString() {
return "var:" + name;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Or.java 0000644 0001750 0001750 00000004112 11144173417 021663 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import org.mvel2.ast.BooleanNode;
public class Or extends BooleanNode {
public Or(ASTNode left, ASTNode right, boolean strongTyping) {
expectType(this.left = left, Boolean.class, strongTyping);
expectType(this.right = right, Boolean.class, strongTyping);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return (((Boolean) left.getReducedValueAccelerated(ctx, thisValue, factory))
|| ((Boolean) right.getReducedValueAccelerated(ctx, thisValue, factory)));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new RuntimeException("improper use of AST element");
}
public void setRightMost(ASTNode right) {
Or n = this;
while (n.right != null && n.right instanceof Or) {
n = (Or) n.right;
}
n.right = right;
}
public ASTNode getRightMost() {
Or n = this;
while (n.right != null && n.right instanceof Or) {
n = (Or) n.right;
}
return n.right;
}
public String toString() {
return "(" + left.toString() + " || " + right.toString() + ")";
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ASTNode.java 0000644 0001750 0001750 00000032057 11354152713 022550 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import static org.mvel2.Operator.NOOP;
import org.mvel2.ParserConfiguration;
import org.mvel2.ParserContext;
import static org.mvel2.PropertyAccessor.get;
import org.mvel2.compiler.Accessor;
import org.mvel2.debug.DebugTools;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizationNotSupported;
import static org.mvel2.optimizers.OptimizerFactory.*;
import static org.mvel2.util.CompilerTools.getInjectedImports;
import static org.mvel2.util.ParseTools.handleNumericConversion;
import static org.mvel2.util.ParseTools.isNumber;
import java.io.Serializable;
import static java.lang.Thread.currentThread;
@SuppressWarnings({"ManualArrayCopy", "CaughtExceptionImmediatelyRethrown"})
public class ASTNode implements Cloneable, Serializable {
public static final int LITERAL = 1;
public static final int DEEP_PROPERTY = 1 << 1;
public static final int OPERATOR = 1 << 2;
public static final int IDENTIFIER = 1 << 3;
public static final int COMPILE_IMMEDIATE = 1 << 4;
public static final int NUMERIC = 1 << 5;
public static final int INVERT = 1 << 6;
public static final int ASSIGN = 1 << 7;
public static final int COLLECTION = 1 << 8;
public static final int THISREF = 1 << 9;
public static final int INLINE_COLLECTION = 1 << 10;
public static final int BLOCK_IF = 1 << 11;
public static final int BLOCK_FOREACH = 1 << 12;
public static final int BLOCK_WITH = 1 << 13;
public static final int BLOCK_UNTIL = 1 << 14;
public static final int BLOCK_WHILE = 1 << 15;
public static final int BLOCK_DO = 1 << 16;
public static final int BLOCK_DO_UNTIL = 1 << 17;
public static final int BLOCK_FOR = 1 << 18;
public static final int OPT_SUBTR = 1 << 19;
public static final int DEFERRED_TYPE_RES = 1 << 23;
public static final int STRONG_TYPING = 1 << 24;
public static final int PCTX_STORED = 1 << 25;
public static final int ARRAY_TYPE_LITERAL = 1 << 26;
public static final int NOJIT = 1 << 27;
public static final int DEOP = 1 << 28;
public static final int DISCARD = 1 << 29;
// *** //
protected int firstUnion;
protected int endOfName;
public int fields = 0;
protected Class egressType;
protected char[] name;
protected String nameCache;
protected Object literal;
protected transient volatile Accessor accessor;
protected volatile Accessor safeAccessor;
protected int cursorPosition;
public ASTNode nextASTNode;
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accessor != null) {
try {
return accessor.getValue(ctx, thisValue, factory);
}
catch (ClassCastException ce) {
if ((fields & DEOP) == 0) {
accessor = null;
fields |= DEOP | NOJIT;
synchronized (this) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
}
else {
throw ce;
}
}
}
else {
if ((fields & DEOP) != 0) {
fields ^= DEOP;
}
AccessorOptimizer optimizer;
Object retVal = null;
if ((fields & NOJIT) != 0) {
optimizer = getAccessorCompiler(SAFE_REFLECTIVE);
}
else {
optimizer = getDefaultAccessorCompiler();
}
ParserContext pCtx;
if ((fields & PCTX_STORED) != 0) {
pCtx = (ParserContext) literal;
}
else {
pCtx = new ParserContext(new ParserConfiguration(getInjectedImports(factory), null));
}
try {
setAccessor(optimizer.optimizeAccessor(pCtx, name, ctx, thisValue, factory, true, egressType));
}
catch (OptimizationNotSupported ne) {
setAccessor((optimizer = getAccessorCompiler(SAFE_REFLECTIVE))
.optimizeAccessor(pCtx, name, ctx, thisValue, factory, true, null));
}
if (accessor == null) {
return get(name, ctx, factory, thisValue);
}
if (retVal == null) {
retVal = optimizer.getResultOptPass();
}
if (egressType == null) {
egressType = optimizer.getEgressType();
}
return retVal;
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
if ((fields & (LITERAL)) != 0) {
return literal;
}
else {
return get(name, ctx, factory, thisValue);
}
}
protected String getAbsoluteRootElement() {
if ((fields & (DEEP_PROPERTY | COLLECTION)) != 0) {
return new String(name, 0, getAbsoluteFirstPart());
}
return nameCache;
}
public Class getEgressType() {
return egressType;
}
public void setEgressType(Class egressType) {
this.egressType = egressType;
}
protected String getAbsoluteRemainder() {
return (fields & COLLECTION) != 0 ? new String(name, endOfName, name.length - endOfName)
: ((fields & DEEP_PROPERTY) != 0 ? new String(name, firstUnion + 1, name.length - firstUnion - 1) : null);
}
public char[] getNameAsArray() {
return name;
}
private int getAbsoluteFirstPart() {
if ((fields & COLLECTION) != 0) {
if (firstUnion < 0 || endOfName < firstUnion) return endOfName;
else return firstUnion;
}
else if ((fields & DEEP_PROPERTY) != 0) {
return firstUnion;
}
else {
return -1;
}
}
public String getAbsoluteName() {
if (firstUnion > 0) {
return new String(name, 0, getAbsoluteFirstPart());
}
else {
return getName();
}
}
public String getName() {
if (nameCache != null) {
return nameCache;
}
else if (name != null) {
return nameCache = new String(name);
}
return "";
}
public Object getLiteralValue() {
return literal;
}
public void storeInLiteralRegister(Object o) {
this.literal = o;
}
public void setLiteralValue(Object literal) {
this.literal = literal;
this.fields |= LITERAL;
}
protected Object tryStaticAccess(Object thisRef, VariableResolverFactory factory) {
try {
/**
* Try to resolve this *smartly* as a static class reference.
*
* This starts at the end of the token and starts to step backwards to figure out whether
* or not this may be a static class reference. We search for method calls simply by
* inspecting for ()'s. The first union area we come to where no brackets are present is our
* test-point for a class reference. If we find a class, we pass the reference to the
* property accessor along with trailing methods (if any).
*
*/
boolean meth = false;
int depth = 0;
int last = name.length;
for (int i = last - 1; i > 0; i--) {
switch (name[i]) {
case '.':
if (depth == 0 && !meth) {
try {
Class.forName(new String(name, 0, i), true, currentThread().getContextClassLoader());
return get(new String(name, last, name.length - last),
Class.forName(new String(name, 0, last), true, currentThread().getContextClassLoader()), factory, thisRef);
}
catch (ClassNotFoundException e) {
return get(new String(name, i + 1, name.length - i - 1),
Class.forName(new String(name, 0, i), true, currentThread().getContextClassLoader()), factory, thisRef);
}
}
meth = false;
last = i;
break;
case ')':
depth++;
break;
case '(':
if (--depth == 0) meth = true;
break;
}
}
}
catch (Exception cnfe) {
// do nothing.
}
return null;
}
@SuppressWarnings({"SuspiciousMethodCalls"})
protected void setName(char[] name) {
if (isNumber(name)) {
egressType = (literal = handleNumericConversion(name)).getClass();
if (((fields |= NUMERIC | LITERAL | IDENTIFIER) & INVERT) != 0) {
try {
literal = ~((Integer) literal);
}
catch (ClassCastException e) {
throw new CompileException("bitwise (~) operator can only be applied to integers");
}
}
return;
}
this.literal = new String(name);
Scan:
for (int i = 0; i < name.length; i++) {
switch (name[i]) {
case '.':
if (firstUnion == 0) {
firstUnion = i;
}
break;
case '[':
if (firstUnion == 0) {
firstUnion = i;
}
if (endOfName == 0) {
endOfName = i;
if (i < name.length && name[i+1] == ']') fields |= ARRAY_TYPE_LITERAL;
break Scan;
}
}
}
if ((fields & INLINE_COLLECTION) != 0) {
return;
}
if (firstUnion > 0) {
fields |= DEEP_PROPERTY | IDENTIFIER;
}
else {
fields |= IDENTIFIER;
}
}
public Accessor setAccessor(Accessor accessor) {
return this.accessor = accessor;
}
public boolean isIdentifier() {
return (fields & IDENTIFIER) != 0;
}
public boolean isLiteral() {
return (fields & LITERAL) != 0;
}
public boolean isThisVal() {
return (fields & THISREF) != 0;
}
public boolean isOperator() {
return (fields & OPERATOR) != 0;
}
public boolean isOperator(Integer operator) {
return (fields & OPERATOR) != 0 && operator.equals(literal);
}
public Integer getOperator() {
return NOOP;
}
protected boolean isCollection() {
return (fields & COLLECTION) != 0;
}
public boolean isAssignment() {
return ((fields & ASSIGN) != 0);
}
public boolean isDeepProperty() {
return ((fields & DEEP_PROPERTY) != 0);
}
public void setAsLiteral() {
fields |= LITERAL;
}
public int getCursorPosition() {
return cursorPosition;
}
public void setCursorPosition(int cursorPosition) {
this.cursorPosition = cursorPosition;
}
public boolean isDiscard() {
return fields != -1 && (fields & DISCARD) != 0;
}
public void discard() {
this.fields |= DISCARD;
}
public void strongTyping() {
this.fields |= STRONG_TYPING;
}
public void storePctx() {
this.fields |= PCTX_STORED;
}
public boolean isDebuggingSymbol() {
return this.fields == -1;
}
public int getFields() {
return fields;
}
public Accessor getAccessor() {
return accessor;
}
public boolean canSerializeAccessor() {
return safeAccessor != null;
}
public ASTNode() {
}
public ASTNode(char[] expr, int start, int end, int fields) {
this.fields = fields;
name = new char[end - (this.cursorPosition = start)];
for (int i = 0; i < name.length; i++) {
name[i] = expr[i + start];
}
setName(name);
}
public String toString() {
return isOperator() ? "<<" + DebugTools.getOperatorName(getOperator()) + ">>" : String.valueOf(literal);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedPostFixIncNode.java 0000644 0001750 0001750 00000003171 11153102156 025434 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class IndexedPostFixIncNode extends ASTNode {
private int register;
public IndexedPostFixIncNode(int register) {
this.register = register;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getIndexedVariableResolver(register);
vResolver.setValue(MathProcessor.doOperations(ctx = vResolver.getValue(), Operator.ADD, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedDeclTypedVarNode.java 0000644 0001750 0001750 00000003615 11077457613 025757 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class IndexedDeclTypedVarNode extends ASTNode implements Assignment {
private int register;
public IndexedDeclTypedVarNode(int register, Class type) {
this.egressType = type;
this.register = register;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createIndexedVariable(register, null, egressType);
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createIndexedVariable(register, null, egressType);
return null;
}
public String getAssignmentVar() {
return null;
}
public char[] getExpression() {
return new char[0];
}
public boolean isAssignment() {
return true;
}
public boolean isNewDeclaration() {
return true;
}
public void setValueStatement(ExecutableStatement stmt) {
throw new RuntimeException("illegal operation");
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Function.java 0000644 0001750 0001750 00000014231 11163351223 023065 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.compiler.EndWithValue;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.compiler.ExpressionCompiler;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.impl.DefaultLocalVariableResolverFactory;
import org.mvel2.integration.impl.FunctionVariableResolverFactory;
import static org.mvel2.util.ParseTools.parseParameterDefList;
import static org.mvel2.util.ParseTools.subCompileExpression;
import java.util.Map;
@SuppressWarnings({"unchecked"})
public class Function extends ASTNode implements Safe {
protected String name;
protected ExecutableStatement compiledBlock;
protected String[] parameters;
protected int parmNum;
public Function(String name, char[] parameters, char[] block, ParserContext pCtx) {
if ((this.name = name) == null || name.length() == 0) {
this.name = null;
}
parmNum = (this.parameters = parseParameterDefList(parameters, 0, parameters.length)).length;
pCtx.declareFunction(this);
ParserContext ctx = new ParserContext(pCtx.getParserConfiguration());
ctx.setIndexAllocation(true);
/**
* To prevent the function parameters from being counted as
* external inputs, we must add them explicitly here.
*/
for (String s : this.parameters) {
ctx.addVariable(s, Object.class);
ctx.addIndexedVariable(s);
}
/**
* Compile the expression so we can determine the input-output delta.
*/
ExpressionCompiler compiler = new ExpressionCompiler(block);
compiler.setVerifyOnly(true);
compiler.compile(ctx);
/**
* Add globals as inputs
*/
if (pCtx.getVariables() != null) {
for (Map.Entry e : pCtx.getVariables().entrySet()) {
ctx.addInput(e.getKey(), e.getValue());
}
ctx.processTables();
}
ctx.addIndexedVariables(ctx.getVariables().keySet());
ctx.getVariables().clear();
this.compiledBlock = (ExecutableStatement) subCompileExpression(block, ctx);
AbstractParser.setCurrentThreadParserContext(pCtx);
this.parameters = new String[ctx.getIndexedVariables().size()];
int i = 0;
for (String s : ctx.getIndexedVariables()) {
this.parameters[i++] = s;
}
this.egressType = this.compiledBlock.getKnownEgressType();
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (name != null) {
if (factory.isResolveable(name)) throw new CompileException("duplicate function: " + name);
factory.createVariable(name, this);
}
return this;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (name != null) {
if (factory.isResolveable(name)) throw new CompileException("duplicate function: " + name);
factory.createVariable(name, this);
}
return this;
}
public Object call(Object ctx, Object thisValue, VariableResolverFactory factory, Object[] parms) {
try {
if (parms != null && parms.length != 0) {
// detect tail recursion
if (factory instanceof FunctionVariableResolverFactory
&& ((FunctionVariableResolverFactory) factory).getIndexedVariableResolvers().length == parms.length) {
FunctionVariableResolverFactory fvrf = (FunctionVariableResolverFactory) factory;
if (fvrf.getFunction().equals(this)) {
VariableResolver[] swapVR = fvrf.getIndexedVariableResolvers();
fvrf.updateParameters(parms);
try {
return compiledBlock.getValue(ctx, thisValue, fvrf);
}
finally {
fvrf.setIndexedVariableResolvers(swapVR);
}
}
}
return compiledBlock.getValue(ctx, thisValue, new FunctionVariableResolverFactory(this, factory, parameters, parms));
}
else {
return compiledBlock.getValue(ctx, thisValue, new DefaultLocalVariableResolverFactory(factory));
}
}
catch (EndWithValue end) {
return end.getValue();
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String[] getParameters() {
return parameters;
}
public void setParameters(String[] parameters) {
this.parameters = parameters;
}
public boolean hasParameters() {
return this.parameters != null && this.parameters.length != 0;
}
public void checkArgumentCount(int passing) {
if (passing != parmNum) {
throw new CompileException("bad number of arguments in function call: "
+ passing + " (expected: " + (parmNum == 0 ? "none" : parmNum) + ")");
}
}
public ExecutableStatement getCompiledBlock() {
return compiledBlock;
}
public String toString() {
return "FunctionDef:" + (name == null ? "Anonymous" : name);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/PreFixDecNode.java 0000644 0001750 0001750 00000003124 11153102156 023714 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class PreFixDecNode extends ASTNode {
private String name;
public PreFixDecNode(String name) {
this.name = name;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getVariableResolver(name);
vResolver.setValue(ctx = MathProcessor.doOperations(vResolver.getValue(), Operator.SUB, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/LineLabel.java 0000644 0001750 0001750 00000003575 11077457613 023156 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class LineLabel extends ASTNode {
private String sourceFile;
private int lineNumber;
public LineLabel(int lineNumber) {
this.lineNumber = lineNumber;
this.fields = -1;
}
public LineLabel(String sourceFile, int lineNumber) {
this.lineNumber = lineNumber;
this.sourceFile = sourceFile;
this.fields = -1;
}
public String getSourceFile() {
return sourceFile;
}
public void setSourceFile(String sourceFile) {
this.sourceFile = sourceFile;
}
public int getLineNumber() {
return lineNumber;
}
public void setLineNumber(int lineNumber) {
this.lineNumber = lineNumber;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return null;
}
public String toString() {
return "[SourceLine:" + lineNumber + "]";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/And.java 0000644 0001750 0001750 00000004125 11144173417 022011 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import org.mvel2.ast.BooleanNode;
public class And extends BooleanNode {
public And(ASTNode left, ASTNode right, boolean strongTyping) {
expectType(this.left = left, Boolean.class, strongTyping);
expectType(this.right = right, Boolean.class, strongTyping);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return (((Boolean) left.getReducedValueAccelerated(ctx, thisValue, factory))
&& ((Boolean) right.getReducedValueAccelerated(ctx, thisValue, factory)));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
throw new RuntimeException("improper use of AST element");
}
public String toString() {
return "(" + left.toString() + " && " + right.toString() + ")";
}
public void setRightMost(ASTNode right) {
And n = this;
while (n.right != null && n.right instanceof And) {
n = (And) n.right;
}
n.right = right;
}
public ASTNode getRightMost() {
And n = this;
while (n.right != null && n.right instanceof And) {
n = (And) n.right;
}
return n.right;
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/PostFixIncNode.java 0000644 0001750 0001750 00000003124 11153102156 024131 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.DataTypes;
import org.mvel2.math.MathProcessor;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class PostFixIncNode extends ASTNode {
private String name;
public PostFixIncNode(String name) {
this.name = name;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver vResolver = factory.getVariableResolver(name);
vResolver.setValue(MathProcessor.doOperations(ctx = vResolver.getValue(), Operator.ADD, DataTypes.INTEGER, 1));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/InterceptorWrapper.java 0000644 0001750 0001750 00000003237 11077457613 025161 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.integration.Interceptor;
import org.mvel2.integration.VariableResolverFactory;
/**
* @author Christopher Brock
*/
public class InterceptorWrapper extends ASTNode {
private Interceptor interceptor;
private ASTNode node;
public InterceptorWrapper(Interceptor interceptor, ASTNode node) {
this.interceptor = interceptor;
this.node = node;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
interceptor.doBefore(node, factory);
interceptor.doAfter(ctx = node.getReducedValueAccelerated(ctx, thisValue, factory), node, factory);
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
interceptor.doBefore(node, factory);
interceptor.doAfter(ctx = node.getReducedValue(ctx, thisValue, factory), node, factory);
return ctx;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/TypeDescriptor.java 0000644 0001750 0001750 00000014475 11253250512 024271 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import static org.mvel2.ast.ASTNode.COMPILE_IMMEDIATE;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ArrayTools.findFirst;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.*;
import java.io.Serializable;
import static java.lang.Character.isDigit;
import java.util.Iterator;
import java.util.LinkedList;
public class TypeDescriptor implements Serializable {
private String className;
private char[] classNameArray;
private ArraySize[] arraySize;
private ExecutableStatement[] compiledArraySize;
int endRange;
public TypeDescriptor() {
}
public TypeDescriptor(char[] name, int fields) {
updateClassName(this.classNameArray = name, fields);
}
public void updateClassName(char[] name, int fields) {
this.classNameArray = name;
if (name.length == 0 || !ParseTools.isIdentifierPart(name[0]) || isDigit(name[0])) return;
if ((endRange = findFirst('(', name)) == -1) {
if ((endRange = findFirst('[', name)) != -1) {
className = new String(name, 0, endRange);
int to;
LinkedList sizes = new LinkedList();
while (endRange < name.length) {
while (endRange < name.length && isWhitespace(name[endRange])) endRange++;
if (endRange == name.length || name[endRange] == '{') break;
if (name[endRange] != '[') {
throw new CompileException("unexpected token in contstructor", name, endRange);
}
to = balancedCapture(name, endRange, '[');
sizes.add(subset(name, ++endRange, to - endRange));
endRange = to + 1;
}
Iterator iter = sizes.iterator();
arraySize = new ArraySize[sizes.size()];
for (int i = 0; i < arraySize.length; i++)
arraySize[i] = new ArraySize(iter.next());
if ((fields & COMPILE_IMMEDIATE) != 0) {
compiledArraySize = new ExecutableStatement[arraySize.length];
for (int i = 0; i < compiledArraySize.length; i++)
compiledArraySize[i] = (ExecutableStatement) subCompileExpression(arraySize[i].value);
}
return;
}
className = new String(name);
}
else {
className = new String(name, 0, endRange);
}
}
public boolean isArray() {
return arraySize != null;
}
public int getArrayLength() {
return arraySize.length;
}
public ArraySize[] getArraySize() {
return arraySize;
}
public ExecutableStatement[] getCompiledArraySize() {
return compiledArraySize;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public boolean isClass() {
return className != null && className.length() != 0;
}
public int getEndRange() {
return endRange;
}
public void setEndRange(int endRange) {
this.endRange = endRange;
}
public static Class getClassReference(Class baseType,
TypeDescriptor tDescr,
VariableResolverFactory factory, ParserContext ctx) throws ClassNotFoundException {
return findClass(factory, repeatChar('[', tDescr.arraySize.length) + "L" + baseType.getName() + ";", ctx);
}
public static Class getClassReference(ParserContext ctx, Class cls, TypeDescriptor tDescr) throws ClassNotFoundException {
if (tDescr.isArray()) {
cls = findClass(null, repeatChar('[', tDescr.arraySize.length) + "L" + cls.getName() + ";", ctx);
}
return cls;
}
public static Class getClassReference(ParserContext ctx, TypeDescriptor tDescr) throws ClassNotFoundException {
Class cls;
if (ctx != null && ctx.hasImport(tDescr.className)) {
cls = ctx.getImport(tDescr.className);
if (tDescr.isArray()) {
cls = findClass(null, repeatChar('[', tDescr.arraySize.length) + "L" + cls.getName() + ";", ctx);
}
}
else if (ctx == null && hasContextFreeImport(tDescr.className)) {
cls = getContextFreeImport(tDescr.className);
if (tDescr.isArray()) {
cls = findClass(null, repeatChar('[', tDescr.arraySize.length) + "L" + cls.getName() + ";", ctx);
}
}
else {
cls = createClass(tDescr.getClassName(), ctx);
if (tDescr.isArray()) {
cls = findClass(null, repeatChar('[', tDescr.arraySize.length) + "L" + cls.getName() + ";", ctx);
}
}
return cls;
}
public boolean isUndimensionedArray() {
if (arraySize != null) {
for (ArraySize anArraySize : arraySize) {
if (anArraySize.value.length == 0) return true;
}
}
return false;
}
public static boolean hasContextFreeImport(String name) {
return AbstractParser.LITERALS.containsKey(name) && AbstractParser.LITERALS.get(name) instanceof Class;
}
public static Class getContextFreeImport(String name) {
return (Class) AbstractParser.LITERALS.get(name);
}
public char[] getClassNameArray() {
return classNameArray;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ForEachNode.java 0000644 0001750 0001750 00000017400 11205051661 023416 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.DefaultLocalVariableResolverFactory;
import org.mvel2.integration.impl.ItemResolverFactory;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.*;
import java.lang.reflect.Array;
import java.util.Iterator;
/**
* @author Christopher Brock
*/
public class ForEachNode extends BlockNode {
protected String item;
protected Class itemType;
private char[] cond;
protected ExecutableStatement condition;
protected ExecutableStatement compiledBlock;
private static final int ITERABLE = 0;
private static final int ARRAY = 1;
private static final int CHARSEQUENCE = 2;
private static final int INTEGER = 3;
private int type = -1;
public ForEachNode(char[] condition, char[] block, int fields, ParserContext pCtx) {
handleCond(this.name = condition, this.fields = fields, pCtx);
this.block = block;
if ((fields & COMPILE_IMMEDIATE) != 0) {
if (pCtx.isStrictTypeEnforcement() && itemType != null) {
pCtx = pCtx.createSubcontext();
pCtx.addInput(item, itemType);
}
this.compiledBlock = (ExecutableStatement) subCompileExpression(block, pCtx);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
ItemResolverFactory.ItemResolver itemR = new ItemResolverFactory.ItemResolver(item);
ItemResolverFactory itemFactory = new ItemResolverFactory(itemR, new DefaultLocalVariableResolverFactory(factory));
Object iterCond = condition.getValue(ctx, thisValue, factory);
if (type == -1) {
determineIterType(iterCond.getClass());
}
switch (type) {
case ARRAY:
int len = Array.getLength(iterCond);
for (int i = 0; i < len; i++) {
itemR.setValue(Array.get(iterCond, i));
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
break;
case CHARSEQUENCE:
for (Object o : iterCond.toString().toCharArray()) {
itemR.setValue(o);
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
break;
case INTEGER:
int max = (Integer) iterCond + 1;
for (int i = 1; i != max; i++) {
itemR.setValue(i);
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
break;
case ITERABLE:
for (Object o : (Iterable) iterCond) {
itemR.setValue(o);
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
break;
}
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
ItemResolverFactory.ItemResolver itemR = new ItemResolverFactory.ItemResolver(item);
ItemResolverFactory itemFactory = new ItemResolverFactory(itemR, new DefaultLocalVariableResolverFactory(factory));
Object iterCond = MVEL.eval(cond, thisValue, factory);
if (itemType != null && itemType.isArray())
enforceTypeSafety(itemType, getBaseComponentType(iterCond.getClass()));
this.compiledBlock = (ExecutableStatement) subCompileExpression(block);
if (iterCond instanceof Iterable) {
for (Object o : (Iterable) iterCond) {
itemR.setValue(o);
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
}
else if (iterCond != null && iterCond.getClass().isArray()) {
int len = Array.getLength(iterCond);
for (int i = 0; i < len; i++) {
itemR.setValue(Array.get(iterCond, i));
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
}
else if (iterCond instanceof CharSequence) {
for (Object o : iterCond.toString().toCharArray()) {
itemR.setValue(o);
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
}
else if (iterCond instanceof Integer) {
int max = (Integer) iterCond + 1;
for (int i = 1; i != max; i++) {
itemR.setValue(i);
compiledBlock.getValue(ctx, thisValue, itemFactory);
}
}
else {
throw new CompileException("non-iterable type: " + (iterCond != null ? iterCond.getClass().getName() : "null"));
}
return null;
}
private void handleCond(char[] condition, int fields, ParserContext pCtx) {
int cursor = 0;
while (cursor < condition.length && condition[cursor] != ':') cursor++;
if (cursor == condition.length || condition[cursor] != ':')
throw new CompileException("expected : in foreach");
int x;
if ((x = (item = createStringTrimmed(condition, 0, cursor)).indexOf(' ')) != -1) {
String tk = new String(condition, 0, x).trim();
try {
itemType = ParseTools.findClass(null, tk, pCtx);
item = new String(condition, x, cursor - x).trim();
}
catch (ClassNotFoundException e) {
throw new CompileException("cannot resolve identifier: " + tk);
}
}
this.cond = subset(condition, ++cursor);
if ((fields & COMPILE_IMMEDIATE) != 0) {
Class egress = (this.condition = (ExecutableStatement) subCompileExpression(this.cond, pCtx)).getKnownEgressType();
if (itemType != null && egress.isArray()) {
enforceTypeSafety(itemType, getBaseComponentType(this.condition.getKnownEgressType()));
}
else if (pCtx.isStrongTyping()) {
determineIterType(egress);
}
}
}
private void determineIterType(Class t) {
if (Iterable.class.isAssignableFrom(t)) {
type = ITERABLE;
}
else if (t.isArray()) {
type = ARRAY;
}
else if (CharSequence.class.isAssignableFrom(t)) {
type = CHARSEQUENCE;
}
else if (Integer.class.isAssignableFrom(t)) {
type = INTEGER;
}
else {
throw new CompileException("non-iterable type: " + t.getName());
}
}
private static void enforceTypeSafety(Class required, Class actual) {
if (!required.isAssignableFrom(actual)) {
throw new CompileException("type mismatch in foreach: expected: "
+ required.getName() + "; but found: " + getBaseComponentType(actual));
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IndexedOperativeAssign.java 0000644 0001750 0001750 00000004244 11115170774 025716 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.math.MathProcessor;
import org.mvel2.ParserContext;
public class IndexedOperativeAssign extends ASTNode {
private final int register;
private ExecutableStatement statement;
private final int operation;
public IndexedOperativeAssign(char[] expr, int operation, int register, int fields, ParserContext pCtx) {
this.operation = operation;
this.name = expr;
this.register = register;
if ((fields & COMPILE_IMMEDIATE) != 0) {
statement = (ExecutableStatement) subCompileExpression(expr, pCtx);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver resolver = factory.getIndexedVariableResolver(register);
resolver.setValue(ctx = MathProcessor.doOperations(resolver.getValue(), operation, statement.getValue(ctx, thisValue, factory)));
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolver resolver = factory.getIndexedVariableResolver(register);
resolver.setValue(ctx = MathProcessor.doOperations(resolver.getValue(), operation, eval(name, ctx, factory)));
return ctx;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Soundslike.java 0000644 0001750 0001750 00000002747 11104135617 023433 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.CompilerTools;
import static org.mvel2.util.Soundex.soundex;
public class Soundslike extends ASTNode {
private ASTNode stmt;
private ASTNode soundslike;
public Soundslike(ASTNode stmt, ASTNode clsStmt) {
this.stmt = stmt;
this.soundslike = clsStmt;
CompilerTools.expectType(clsStmt, String.class, true);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return soundex(String.valueOf(soundslike.getReducedValueAccelerated(ctx, thisValue, factory)))
.equals(soundex((String) stmt.getReducedValueAccelerated(ctx, thisValue, factory)));
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
String i = String.valueOf(soundslike.getReducedValue(ctx, thisValue, factory));
if (i == null) throw new ClassCastException();
String x = (String) stmt.getReducedValue(ctx, thisValue, factory);
if (x == null) throw new CompileException("not a string: " + stmt.getName());
return soundex(i).equals(soundex(x));
}
catch (ClassCastException e) {
throw new CompileException("not a string: " + soundslike.getName());
}
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/LiteralDeepPropertyNode.java 0000644 0001750 0001750 00000004005 11110327536 026045 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.PropertyAccessor.get;
import static org.mvel2.compiler.AbstractParser.getCurrentThreadParserContext;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import static org.mvel2.optimizers.OptimizerFactory.getThreadAccessorOptimizer;
/**
* @author Christopher Brock
*/
@SuppressWarnings({"CaughtExceptionImmediatelyRethrown"})
public class LiteralDeepPropertyNode extends ASTNode {
private Object literal;
public LiteralDeepPropertyNode(char[] expr, int fields, Object literal) {
this.fields = fields;
this.name = expr;
this.literal = literal;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accessor != null) {
return accessor.getValue(literal, thisValue, factory);
}
else {
AccessorOptimizer aO = getThreadAccessorOptimizer();
accessor = aO.optimizeAccessor(getCurrentThreadParserContext(), name, literal, thisValue, factory, false, null);
return aO.getResultOptPass();
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return get(name, literal, factory, thisValue);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ImportNode.java 0000644 0001750 0001750 00000005176 11147075773 023407 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.findClassImportResolverFactory;
/**
* @author Christopher Brock
*/
public class ImportNode extends ASTNode {
private Class importClass;
private boolean packageImport;
private short offset;
private static final char[] WC_TEST = new char[]{'.', '*'};
public ImportNode(char[] expr) {
this.name = expr;
if (ParseTools.endsWith(expr, WC_TEST)) {
packageImport = true;
offset = (short) ParseTools.findLast(expr, '.');
}
else {
try {
this.importClass = Class.forName(new String(expr), true, Thread.currentThread().getContextClassLoader());
}
catch (ClassNotFoundException e) {
throw new CompileException("class not found: " + new String(expr));
}
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (!packageImport) {
return findClassImportResolverFactory(factory).addClass(importClass);
}
else {
findClassImportResolverFactory(factory).addPackageImport(new String(name, 0, (int) offset));
return null;
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
public Class getImportClass() {
return importClass;
}
public boolean isPackageImport() {
return packageImport;
}
public void setPackageImport(boolean packageImport) {
this.packageImport = packageImport;
}
public String getPackageImport() {
return new String(name, 0, offset);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/WithNode.java 0000644 0001750 0001750 00000021456 11246517502 023036 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import static org.mvel2.MVEL.executeSetExpression;
import org.mvel2.Operator;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.*;
import static org.mvel2.util.ParseTools.parseWithExpressions;
import static org.mvel2.util.PropertyTools.getReturnType;
import org.mvel2.util.StringAppender;
import org.mvel2.util.ParseTools;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
* @author Christopher Brock
*/
public class WithNode extends BlockNode implements NestedStatement {
protected String nestParm;
protected ExecutableStatement nestedStatement;
protected ParmValuePair[] withExpressions;
public WithNode(char[] expr, char[] block, int fields, ParserContext pCtx) {
nestParm = createStringTrimmed(this.name = expr);
this.block = block;
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.setBlockSymbols(true);
egressType = (nestedStatement = (ExecutableStatement)
subCompileExpression(nestParm.toCharArray(), pCtx)).getKnownEgressType();
withExpressions = compileWithExpressions(block, nestParm, egressType, pCtx);
pCtx.setBlockSymbols(false);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
Object ctxObject = nestedStatement.getValue(ctx, thisValue, factory);
if (ctxObject == null) throw new CompileException("with-block against null pointer");
for (ParmValuePair pvp : withExpressions) {
pvp.eval(ctxObject, factory);
}
return ctxObject;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
parseWithExpressions(nestParm, block, 0, block.length, ctx = MVEL.eval(name, ctx, factory), factory);
return ctx;
}
public static ParmValuePair[] compileWithExpressions(char[] block, String nestParm, Class egressType, ParserContext pCtx) {
/**
*
* MAINTENANCE NOTE: AN INTERPRETED MODE VERSION OF THIS CODE IS DUPLICATED IN: ParseTools
*
*/
List parms = new ArrayList();
String parm = "";
int start = 0;
int end = -1;
int oper = -1;
for (int i = 0; i < block.length; i++) {
switch (block[i]) {
case '{':
case '[':
case '(':
i = balancedCapture(block, i, block[i]);
continue;
case '/':
if (i < block.length && block[i + 1] == '/') {
while (i < block.length && block[i] != '\n') block[i++] = ' ';
if (parm == null) start = i;
}
else if (i < block.length && block[i + 1] == '*') {
int len = block.length - 1;
while (i < len && !(block[i] == '*' && block[i + 1] == '/')) {
block[i++] = ' ';
}
block[i++] = ' ';
block[i++] = ' ';
if (parm == null) start = i;
}
else if (i < block.length && block[i + 1] == '=') {
oper = Operator.DIV;
}
continue;
case '%':
case '*':
case '-':
case '+':
if (i + 1 < block.length && block[i + 1] == '=') {
oper = opLookup(block[i]);
}
continue;
case '=':
parm = createStringTrimmed(block, start, i - start - (oper != -1 ? 1 : 0));
start = i + 1;
continue;
case ',':
if (end == -1) end = i;
if (parm == null || parm.length() == 0) {
parms.add(
new ParmValuePair(null, (ExecutableStatement)
subCompileExpression(
new StringAppender(nestParm).append('.')
.append(subset(block, start, end - start)).toChars(), pCtx), egressType, pCtx)
);
oper = -1;
start = ++i;
}
else {
parms.add(new ParmValuePair(
parm,
(ExecutableStatement) subCompileExpression(
createShortFormOperativeAssignment(nestParm + "." + parm,
subset(block, start, end - start), oper), pCtx
)
, egressType, pCtx));
parm = null;
oper = -1;
start = ++i;
}
end = -1;
break;
}
}
if (start != (end = block.length)) {
if (parm == null || "".equals(parm)) {
parms.add(
new ParmValuePair(null, (ExecutableStatement)
subCompileExpression(new StringAppender(nestParm).append('.')
.append(subset(block, start, end - start)).toChars(), pCtx), egressType, pCtx)
);
}
else {
parms.add(new ParmValuePair(
parm,
(ExecutableStatement) subCompileExpression(
createShortFormOperativeAssignment(nestParm + "." + parm, subset(block, start, end - start), oper),
pCtx
)
, egressType, pCtx));
}
}
ParmValuePair[] withExpressions;
parms.toArray(withExpressions = new ParmValuePair[parms.size()]);
return withExpressions;
}
public ExecutableStatement getNestedStatement() {
return nestedStatement;
}
public ParmValuePair[] getWithExpressions() {
return withExpressions;
}
public static final class ParmValuePair implements Serializable {
private Serializable setExpression;
private ExecutableStatement statement;
public ParmValuePair() {
}
public ParmValuePair(String parameter, ExecutableStatement statement, Class ingressType, ParserContext pCtx) {
if (parameter != null && parameter.length() != 0) {
this.setExpression = MVEL.compileSetExpression(parameter,
ingressType != null ? getReturnType(ingressType, parameter, pCtx) : Object.class
, pCtx);
}
this.statement = statement;
}
public Serializable getSetExpression() {
return setExpression;
}
public void setSetExpression(Serializable setExpression) {
this.setExpression = setExpression;
}
public ExecutableStatement getStatement() {
return statement;
}
public void setStatement(ExecutableStatement statement) {
this.statement = statement;
}
public void eval(Object ctx, VariableResolverFactory factory) {
if (setExpression == null) {
this.statement.getValue(ctx, factory);
}
else {
MVEL.executeSetExpression(setExpression, ctx, factory, this.statement.getValue(ctx, factory));
}
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/IntDiv.java 0000644 0001750 0001750 00000002056 11307306541 022502 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.Operator;
import org.mvel2.integration.VariableResolverFactory;
public class IntDiv extends BinaryOperation implements IntOptimized {
public IntDiv(ASTNode left, ASTNode right) {
super(Operator.MULT);
this.left = left;
this.right = right;
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValueAccelerated(ctx, thisValue, factory))
/ ((Integer) right.getReducedValueAccelerated(ctx, thisValue, factory));
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return ((Integer) left.getReducedValue(ctx, thisValue, factory))
/ ((Integer) right.getReducedValue(ctx, thisValue, factory));
}
@Override
public void setRight(ASTNode node) {
super.setRight(node);
}
@Override
public Class getEgressType() {
return Integer.class;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/InlineCollectionNode.java 0000644 0001750 0001750 00000014004 11222477143 025344 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.CompileException;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.optimizers.AccessorOptimizer;
import org.mvel2.optimizers.OptimizerFactory;
import org.mvel2.util.CollectionParser;
import static org.mvel2.util.ParseTools.*;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author Christopher Brock
*/
public class InlineCollectionNode extends ASTNode {
private Object collectionGraph;
private char[] trailing;
public InlineCollectionNode(char[] expr, int start, int end, int fields, ParserContext pctx) {
super(expr, start, end, fields | INLINE_COLLECTION);
if ((fields & COMPILE_IMMEDIATE) != 0) {
parseGraph(true, null, pctx);
AccessorOptimizer ao = OptimizerFactory.getThreadAccessorOptimizer();
accessor = ao.optimizeCollection(pctx, collectionGraph, egressType, trailing, null, null, null);
egressType = ao.getEgressType();
}
}
public InlineCollectionNode(char[] expr, int start, int end, int fields, Class type, ParserContext pctx) {
super(expr, start, end, fields | INLINE_COLLECTION);
this.egressType = type;
if ((fields & COMPILE_IMMEDIATE) != 0) {
parseGraph(true, type, pctx);
AccessorOptimizer ao = OptimizerFactory.getThreadAccessorOptimizer();
accessor = ao.optimizeCollection(pctx,collectionGraph, egressType, trailing, null, null, null);
egressType = ao.getEgressType();
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (accessor != null) {
return accessor.getValue(ctx, thisValue, factory);
}
else {
AccessorOptimizer ao = OptimizerFactory.getThreadAccessorOptimizer();
if (collectionGraph == null) parseGraph(true, null, null);
accessor = ao.optimizeCollection(AbstractParser.getCurrentThreadParserContext(), collectionGraph, egressType, trailing, ctx, thisValue, factory);
egressType = ao.getEgressType();
return accessor.getValue(ctx, thisValue, factory);
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
parseGraph(false, egressType, null);
return execGraph(collectionGraph, egressType, ctx, factory);
}
private void parseGraph(boolean compile, Class type, ParserContext pCtx) {
CollectionParser parser = new CollectionParser();
if (type == null) {
collectionGraph = ((List) parser.parseCollection(name, compile, pCtx)).get(0);
}
else {
collectionGraph = ((List) parser.parseCollection(name, compile, type, pCtx)).get(0);
}
if (parser.getCursor() + 2 < name.length)
trailing = subset(name, parser.getCursor() + 2);
if (this.egressType == null) this.egressType = collectionGraph.getClass();
}
private Object execGraph(Object o, Class type, Object ctx, VariableResolverFactory factory) {
if (o instanceof List) {
ArrayList list = new ArrayList(((List)o).size());
for (Object item : (List) o) {
list.add(execGraph(item, type, ctx, factory));
}
return list;
}
else if (o instanceof Map) {
HashMap map = new HashMap();
for (Object item : ((Map) o).keySet()) {
map.put(execGraph(item, type, ctx, factory), execGraph(((Map)o).get(item), type, ctx, factory));
}
return map;
}
else if (o instanceof Object[]) {
int dim = 0;
if (type != null) {
String nm = type.getName();
while (nm.charAt(dim) == '[') dim++;
}
else {
type = Object[].class;
dim = 1;
}
Object newArray = Array.newInstance(getSubComponentType(type), ((Object[])o).length);
try {
Class cls = dim > 1 ? findClass(null, repeatChar('[', dim - 1) + "L" + getBaseComponentType(type).getName() + ";", AbstractParser.getCurrentThreadParserContext())
: type;
int c = 0;
for (Object item : (Object[]) o) {
Array.set(newArray, c++, execGraph(item, cls, ctx, factory));
}
return newArray;
}
catch (IllegalArgumentException e) {
throw new CompileException("type mismatch in array", e);
}
catch (ClassNotFoundException e) {
throw new RuntimeException("this error should never throw:" + getBaseComponentType(type).getName(), e);
}
}
else {
if (type.isArray()) {
return MVEL.eval((String) o, ctx, factory, getBaseComponentType(type));
}
else {
return MVEL.eval((String) o, ctx, factory);
}
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/RegExMatch.java 0000644 0001750 0001750 00000005551 11155605450 023301 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import static org.mvel2.MVEL.eval;
import org.mvel2.compiler.ExecutableLiteral;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.subCompileExpression;
import static java.lang.String.valueOf;
import java.util.regex.Pattern;
import static java.util.regex.Pattern.compile;
import java.util.regex.PatternSyntaxException;
public class RegExMatch extends ASTNode {
private ExecutableStatement stmt;
private ExecutableStatement patternStmt;
private char[] pattern;
private Pattern p;
public RegExMatch(char[] expr, int fields, char[] pattern, ParserContext pCtx) {
this.name = expr;
this.pattern = pattern;
if ((fields & COMPILE_IMMEDIATE) != 0) {
this.stmt = (ExecutableStatement) subCompileExpression(expr);
if ((this.patternStmt = (ExecutableStatement)
subCompileExpression(pattern, pCtx)) instanceof ExecutableLiteral) {
try {
p = compile(valueOf(patternStmt.getValue(null, null)));
}
catch (PatternSyntaxException e) {
throw new CompileException("bad regular expression", e);
}
}
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (p == null) {
return compile(valueOf(patternStmt.getValue(ctx, thisValue, factory))).matcher(valueOf(stmt.getValue(ctx, thisValue, factory))).matches();
}
else {
return p.matcher(valueOf(stmt.getValue(ctx, thisValue, factory))).matches();
}
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
try {
return compile(valueOf(eval(pattern, ctx, factory))).matcher(valueOf(eval(name, ctx, factory))).matches();
}
catch (PatternSyntaxException e) {
throw new CompileException("bad regular expression", e);
}
}
public Class getEgressType() {
return Boolean.class;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Assignment.java 0000644 0001750 0001750 00000001671 11077457613 023432 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
public interface Assignment {
public String getAssignmentVar();
public char[] getExpression();
public boolean isNewDeclaration();
public void setValueStatement(ExecutableStatement stmt);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/WhileNode.java 0000644 0001750 0001750 00000004603 11114570772 023170 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import static org.mvel2.util.CompilerTools.expectType;
import static org.mvel2.util.ParseTools.subCompileExpression;
import org.mvel2.ParserContext;
import java.util.HashMap;
/**
* @author Christopher Brock
*/
public class WhileNode extends BlockNode {
protected String item;
protected ExecutableStatement condition;
protected ExecutableStatement compiledBlock;
public WhileNode(char[] condition, char[] block, int fields, ParserContext pCtx) {
expectType(this.condition = (ExecutableStatement) subCompileExpression(this.name = condition, pCtx),
Boolean.class, ((fields & COMPILE_IMMEDIATE) != 0));
this.compiledBlock = (ExecutableStatement) subCompileExpression(this.block = block, pCtx);
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
while ((Boolean) condition.getValue(ctx, thisValue, factory)) {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
VariableResolverFactory ctxFactory = new MapVariableResolverFactory(new HashMap(0), factory);
while ((Boolean) condition.getValue(ctx, thisValue, factory)) {
compiledBlock.getValue(ctx, thisValue, ctxFactory);
}
return null;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/ast/StaticImportNode.java 0000644 0001750 0001750 00000005054 11155605450 024540 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import org.mvel2.CompileException;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ArrayTools.findLast;
import static org.mvel2.util.ParseTools.subset;
import static java.lang.Thread.currentThread;
import java.lang.reflect.Method;
import static java.lang.reflect.Modifier.isStatic;
/**
* @author Christopher Brock
*/
public class StaticImportNode extends ASTNode {
private Class declaringClass;
private String methodName;
private transient Method method;
public StaticImportNode(char[] expr) {
try {
declaringClass = Class.forName(new String(subset(expr, 0, findLast('.', this.name = expr))),
true, currentThread().getContextClassLoader());
methodName = new String(subset(expr, findLast('.', expr) + 1));
if (resolveMethod() == null) {
throw new CompileException("can not find method for static import: "
+ declaringClass.getName() + "." + methodName);
}
}
catch (Exception e) {
throw new CompileException("unable to import class", e);
}
}
private Method resolveMethod() {
for (Method meth : declaringClass.getMethods()) {
if (isStatic(meth.getModifiers()) && methodName.equals(meth.getName())) {
return method = meth;
}
}
return null;
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createVariable(methodName, method == null ? method = resolveMethod() : method);
return null;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
return getReducedValueAccelerated(ctx, thisValue, factory);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/Proto.java 0000644 0001750 0001750 00000032744 11257005261 022416 0 ustar drazzib drazzib package org.mvel2.ast;
import org.mvel2.CompileException;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import org.mvel2.UnresolveablePropertyException;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import org.mvel2.integration.impl.SimpleValueResolver;
import org.mvel2.util.CallableProxy;
import org.mvel2.util.SimpleIndexHashMapWrapper;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
public class Proto extends ASTNode {
private String name;
private Map receivers;
private int cursorStart;
private int cursorEnd;
public Proto(String name) {
this.name = name;
this.receivers = new SimpleIndexHashMapWrapper();
}
public Receiver declareReceiver(String name, Function function) {
Receiver r = new Receiver(null, ReceiverType.FUNCTION, function);
receivers.put(name, r);
return r;
}
public Receiver declareReceiver(String name, Class type, ExecutableStatement initCode) {
Receiver r = new Receiver(null, ReceiverType.PROPERTY, initCode);
receivers.put(name, r);
return r;
}
public Receiver declareReceiver(String name, ReceiverType type, ExecutableStatement initCode) {
Receiver r = new Receiver(null, type, initCode);
receivers.put(name, r);
return r;
}
public ProtoInstance newInstance(Object ctx, Object thisCtx, VariableResolverFactory factory) {
return new ProtoInstance(this, ctx, thisCtx, factory);
}
@Override
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createVariable(name, this);
return this;
}
@Override
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createVariable(name, this);
return this;
}
public class Receiver implements CallableProxy {
private ReceiverType type;
private Object receiver;
private ExecutableStatement initValue;
private ProtoInstance instance;
public Receiver(ProtoInstance protoInstance, ReceiverType type, Object receiver) {
this.instance = protoInstance;
this.type = type;
this.receiver = receiver;
}
public Receiver(ProtoInstance protoInstance, ReceiverType type, ExecutableStatement stmt) {
this.instance = protoInstance;
this.type = type;
this.initValue = stmt;
}
public Object call(Object ctx, Object thisCtx, VariableResolverFactory factory, Object[] parms) {
switch (type) {
case FUNCTION:
return ((Function) receiver).call(ctx, thisCtx, new InvokationContextFactory(factory, instance.instanceStates), parms);
case PROPERTY:
return receiver;
case DEFERRED:
throw new CompileException("unresolved prototype receiver");
}
return null;
}
public Receiver init(ProtoInstance instance, Object ctx, Object thisCtx, VariableResolverFactory factory) {
return new Receiver(instance, type,
type == ReceiverType.PROPERTY && initValue != null ? initValue.getValue(ctx, thisCtx, factory) :
receiver);
}
public void setType(ReceiverType type) {
this.type = type;
}
public void setInitValue(ExecutableStatement initValue) {
this.initValue = initValue;
}
}
public enum ReceiverType {
DEFERRED, FUNCTION, PROPERTY
}
public class ProtoInstance implements Map {
private Proto protoType;
private VariableResolverFactory instanceStates;
private SimpleIndexHashMapWrapper receivers;
public ProtoInstance(Proto protoType, Object ctx, Object thisCtx, VariableResolverFactory factory) {
this.protoType = protoType;
receivers = new SimpleIndexHashMapWrapper();
for (Map.Entry entry : protoType.receivers.entrySet()) {
receivers.put(entry.getKey(), entry.getValue().init(this, ctx, thisCtx, factory));
}
instanceStates = new ProtoContextFactory(receivers);
}
public Proto getProtoType() {
return protoType;
}
public int size() {
return receivers.size();
}
public boolean isEmpty() {
return receivers.isEmpty();
}
public boolean containsKey(Object key) {
return receivers.containsKey(key);
}
public boolean containsValue(Object value) {
return receivers.containsValue(value);
}
public Receiver get(Object key) {
return receivers.get(key);
}
public Receiver put(String key, Receiver value) {
return receivers.put(key, value);
}
public Receiver remove(Object key) {
return receivers.remove(key);
}
public void putAll(Map m) {
}
public void clear() {
}
public Set keySet() {
return receivers.keySet();
}
public Collection values() {
return receivers.values();
}
public Set> entrySet() {
return receivers.entrySet();
}
}
@Override
public String getName() {
return name;
}
@Override
public String toString() {
return "proto " + name;
}
public class ProtoContextFactory extends MapVariableResolverFactory {
private final SimpleIndexHashMapWrapper variableResolvers;
public ProtoContextFactory(SimpleIndexHashMapWrapper variables) {
super(variables);
variableResolvers = new SimpleIndexHashMapWrapper(variables, true);
}
@Override
public VariableResolver createVariable(String name, Object value) {
VariableResolver vr;
try {
(vr = getVariableResolver(name)).setValue(value);
return vr;
}
catch (UnresolveablePropertyException e) {
addResolver(name, vr = new ProtoResolver(variables, name)).setValue(value);
return vr;
}
}
@Override
public VariableResolver createVariable(String name, Object value, Class type) {
VariableResolver vr;
try {
vr = getVariableResolver(name);
}
catch (UnresolveablePropertyException e) {
vr = null;
}
if (vr != null && vr.getType() != null) {
throw new CompileException("variable already defined within scope: " + vr.getType() + " " + name);
}
else {
addResolver(name, vr = new ProtoResolver(variables, name, type)).setValue(value);
return vr;
}
}
@Override
public void setIndexedVariableNames(String[] indexedVariableNames) {
//
}
@Override
public String[] getIndexedVariableNames() {
//
return null;
}
@Override
public VariableResolver createIndexedVariable(int index, String name, Object value, Class type) {
VariableResolver vr = this.variableResolvers != null ? this.variableResolvers.getByIndex(index) : null;
if (vr != null && vr.getType() != null) {
throw new CompileException("variable already defined within scope: " + vr.getType() + " " + name);
}
else {
return createIndexedVariable(variableIndexOf(name), name, value);
}
}
@Override
public VariableResolver createIndexedVariable(int index, String name, Object value) {
VariableResolver vr = variableResolvers.getByIndex(index);
if (vr == null) {
vr = new SimpleValueResolver(value);
variableResolvers.putAtIndex(index, vr);
}
else {
vr.setValue(value);
}
return indexedVariableResolvers[index];
}
@Override
public VariableResolver getIndexedVariableResolver(int index) {
return variableResolvers.getByIndex(index);
}
@Override
public VariableResolver setIndexedVariableResolver(int index, VariableResolver resolver) {
variableResolvers.putAtIndex(index, resolver);
return resolver;
}
@Override
public int variableIndexOf(String name) {
return variableResolvers.indexOf(name);
}
public VariableResolver getVariableResolver(String name) {
VariableResolver vr = variableResolvers.get(name);
if (vr != null) {
return vr;
}
else if (variables.containsKey(name)) {
variableResolvers.put(name, vr = new ProtoResolver(variables, name));
return vr;
}
else if (nextFactory != null) {
return nextFactory.getVariableResolver(name);
}
throw new UnresolveablePropertyException("unable to resolve variable '" + name + "'");
}
}
public class ProtoResolver implements VariableResolver {
private String name;
private Class knownType;
private Map variableMap;
public ProtoResolver(Map variableMap, String name) {
this.variableMap = variableMap;
this.name = name;
}
public ProtoResolver(Map variableMap, String name, Class knownType) {
this.name = name;
this.knownType = knownType;
this.variableMap = variableMap;
}
public void setName(String name) {
this.name = name;
}
public void setStaticType(Class knownType) {
this.knownType = knownType;
}
public String getName() {
return name;
}
public Class getType() {
return knownType;
}
public void setValue(Object value) {
if (knownType != null && value != null && value.getClass() != knownType) {
if (!canConvert(knownType, value.getClass())) {
throw new CompileException("cannot assign " + value.getClass().getName() + " to type: "
+ knownType.getName());
}
try {
value = convert(value, knownType);
}
catch (Exception e) {
throw new CompileException("cannot convert value of " + value.getClass().getName()
+ " to: " + knownType.getName());
}
}
((Receiver) variableMap.get(name)).receiver = value;
}
public Object getValue() {
return ((Receiver) variableMap.get(name)).receiver;
}
public int getFlags() {
return 0;
}
}
public class InvokationContextFactory extends MapVariableResolverFactory {
private VariableResolverFactory protoContext;
public InvokationContextFactory(VariableResolverFactory next, VariableResolverFactory protoContext) {
this.nextFactory = next;
this.protoContext = protoContext;
}
@Override
public VariableResolver createVariable(String name, Object value) {
if (isResolveable(name) && !protoContext.isResolveable(name)) {
return nextFactory.createVariable(name, value);
}
else {
return protoContext.createVariable(name, value);
}
}
@Override
public VariableResolver createVariable(String name, Object value, Class type) {
if (isResolveable(name) && !protoContext.isResolveable(name)) {
return nextFactory.createVariable(name, value, type);
}
else {
return protoContext.createVariable(name, value, type);
}
}
@Override
public VariableResolver getVariableResolver(String name) {
if (isResolveable(name) && !protoContext.isResolveable(name)) {
return nextFactory.getVariableResolver(name);
}
else {
return protoContext.getVariableResolver(name);
}
}
@Override
public boolean isTarget(String name) {
return protoContext.isTarget(name);
}
@Override
public boolean isResolveable(String name) {
return protoContext.isResolveable(name) || nextFactory.isResolveable(name);
}
@Override
public boolean isIndexedFactory() {
return true;
}
}
public void setCursorPosition(int start, int end) {
this.cursorStart = start;
this.cursorEnd = end;
}
public int getCursorStart() {
return cursorStart;
}
public int getCursorEnd() {
return cursorEnd;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/ast/ProtoVarNode.java 0000644 0001750 0001750 00000006002 11253516374 023671 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.ast;
import static org.mvel2.MVEL.eval;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExecutableStatement;
import org.mvel2.integration.VariableResolverFactory;
import static org.mvel2.util.ParseTools.*;
/**
* @author Christopher Brock
*/
public class ProtoVarNode extends ASTNode implements Assignment {
private String name;
private char[] stmt;
private ExecutableStatement statement;
public ProtoVarNode(String name, Proto type) {
this.name = name;
this.egressType = Proto.ProtoInstance.class;
}
public ProtoVarNode(char[] expr, int fields, Proto type, ParserContext pCtx) {
this.egressType = Proto.ProtoInstance.class;
this.fields = fields;
int assignStart;
if ((assignStart = find(super.name = expr, '=')) != -1) {
checkNameSafety(name = createStringTrimmed(expr, 0, assignStart));
if (((fields |= ASSIGN) & COMPILE_IMMEDIATE) != 0) {
statement = (ExecutableStatement) subCompileExpression(stmt = subset(expr, assignStart + 1), pCtx);
}
else {
stmt = subset(expr, assignStart + 1);
}
}
else {
checkNameSafety(name = new String(expr));
}
if ((fields & COMPILE_IMMEDIATE) != 0) {
pCtx.addVariable(name, egressType, true);
}
}
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) {
if (statement == null) statement = (ExecutableStatement) subCompileExpression(stmt);
factory.createVariable(name, ctx = statement.getValue(ctx, thisValue, factory), egressType);
return ctx;
}
public Object getReducedValue(Object ctx, Object thisValue, VariableResolverFactory factory) {
factory.createVariable(name, ctx = eval(stmt, thisValue, factory), egressType);
return ctx;
}
public String getName() {
return name;
}
public String getAssignmentVar() {
return name;
}
public char[] getExpression() {
return stmt;
}
public boolean isNewDeclaration() {
return true;
}
public void setValueStatement(ExecutableStatement stmt) {
this.statement = stmt;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/PreProcessor.java 0000644 0001750 0001750 00000001606 11100376377 023151 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
/**
* A preprocessor used for pre-processing any expressions before being parsed/compiled.
*/
public interface PreProcessor {
public char[] parse(char[] input);
public String parse(String input);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/Unit.java 0000644 0001750 0001750 00000001460 11077457613 021446 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
public interface Unit extends ConversionHandler {
public double getValue();
public void setValue(double value);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/Operator.java 0000644 0001750 0001750 00000011430 11252763061 022310 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
/**
* Contains a list of constants representing internal operators.
*/
public interface Operator {
public static final int NOOP = -1;
/**
* The index positions of the operator precedence values
* correspond to the actual operator itself. So ADD is PTABLE[0],
* SUB is PTABLE[1] and so on.
*/
public static final int[] PTABLE = {
10, // ADD
10, // SUB
11, // MULT
11, // DIV
11, // MOD
12, // POWER
6, // BW_AND
4, // BW_OR
5, // BW_XOR
9, // BW_SHIFT_RIGHT
9, // BW_SHIFT_LEFT
9, // BW_USHIFT_LEFT
5, // BW_NOT
8, // LTHAN
8, // GTHAN
8, // LETHAN
8, // GETHAN
7, // EQUAL
7, // NEQUAL
13, // STR_APPEND
3, // AND
2, // OR
2, // CHOR
13, // REGEX
8, // INSTANCEOF
13, // CONTAINS
13, // SOUNDEX
13, // SIMILARITY
0, // TERNARY
0, // TERNARY ELSE
13, // ASSIGN
13, // INC_ASSIGN
13 // DEC ASSIGN
};
public static final int ADD = 0;
public static final int SUB = 1;
public static final int MULT = 2;
public static final int DIV = 3;
public static final int MOD = 4;
public static final int POWER = 5;
public static final int BW_AND = 6;
public static final int BW_OR = 7;
public static final int BW_XOR = 8;
public static final int BW_SHIFT_RIGHT = 9;
public static final int BW_SHIFT_LEFT = 10;
public static final int BW_USHIFT_RIGHT = 11;
public static final int BW_USHIFT_LEFT = 12;
public static final int BW_NOT = 13;
public static final int LTHAN = 14;
public static final int GTHAN = 15;
public static final int LETHAN = 16;
public static final int GETHAN = 17;
public static final int EQUAL = 18;
public static final int NEQUAL = 19;
public static final int STR_APPEND = 20;
public static final int AND = 21;
public static final int OR = 22;
public static final int CHOR = 23;
public static final int REGEX = 24;
public static final int INSTANCEOF = 25;
public static final int CONTAINS = 26;
public static final int SOUNDEX = 27;
public static final int SIMILARITY = 28;
public static final int TERNARY = 29;
public static final int TERNARY_ELSE = 30;
public static final int ASSIGN = 31;
public static final int INC_ASSIGN = 32;
public static final int DEC_ASSIGN = 33;
public static final int NEW = 34;
public static final int PROJECTION = 35;
public static final int CONVERTABLE_TO = 36;
public static final int END_OF_STMT = 37;
public static final int FOREACH = 38;
public static final int IF = 39;
public static final int ELSE = 40;
public static final int WHILE = 41;
public static final int UNTIL = 42;
public static final int FOR = 43;
public static final int SWITCH = 44;
public static final int DO = 45;
public static final int WITH = 46;
public static final int ISDEF = 47;
public static final int PROTO = 48;
public static final int INC = 50;
public static final int DEC = 51;
public static final int ASSIGN_ADD = 52;
public static final int ASSIGN_SUB = 53;
public static final int ASSIGN_STR_APPEND = 54;
public static final int ASSIGN_DIV = 55;
public static final int ASSIGN_MOD = 56;
public static final int ASSIGN_OR = 57;
public static final int ASSIGN_AND = 58;
public static final int ASSIGN_XOR = 59;
public static final int ASSIGN_LSHIFT = 60;
public static final int ASSIGN_RSHIFT = 61;
public static final int ASSIGN_RUSHIFT = 62;
public static final int IMPORT_STATIC = 95;
public static final int IMPORT = 96;
public static final int ASSERT = 97;
public static final int UNTYPED_VAR = 98;
public static final int RETURN = 99;
public static final int FUNCTION = 100;
}
mvel-2.0.18.orig/src/main/java/org/mvel2/Macro.java 0000644 0001750 0001750 00000001454 11077457613 021573 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
/**
* @author Christopher Brock
*/
public interface Macro {
public String doMacro();
}
mvel-2.0.18.orig/src/main/java/org/mvel2/UnresolveablePropertyException.java 0000644 0001750 0001750 00000002711 11077457613 026761 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import org.mvel2.ast.ASTNode;
/**
* @author Christopher Brock
*/
public class UnresolveablePropertyException extends RuntimeException {
private String name;
public UnresolveablePropertyException(ASTNode astNode, Throwable throwable) {
super("unable to resolve token: " + astNode.getName(), throwable);
this.name = astNode.getName();
}
public UnresolveablePropertyException(ASTNode astNode) {
super("unable to resolve token: " + astNode.getName());
this.name = astNode.getName();
}
public UnresolveablePropertyException(String name) {
super("unable to resolve token: " + name);
this.name = name;
}
public String getName() {
return name;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/ 0000755 0001750 0001750 00000000000 11412747053 021652 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateRuntime.java 0000644 0001750 0001750 00000027517 11317165145 025650 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import org.mvel2.templates.res.Node;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.templates.util.TemplateTools;
import org.mvel2.templates.util.io.StandardOutputStream;
import org.mvel2.templates.util.io.StringAppenderStream;
import org.mvel2.util.StringAppender;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;
import static org.mvel2.templates.TemplateCompiler.compileTemplate;
/**
* This is the root of the template runtime, and contains various utility methods for executing templates.
*/
public class TemplateRuntime {
private char[] template;
private TemplateRegistry namedTemplateRegistry;
private Node rootNode;
public TemplateRuntime(char[] template, TemplateRegistry namedTemplateRegistry, Node rootNode) {
this.template = template;
this.namedTemplateRegistry = namedTemplateRegistry;
this.rootNode = rootNode;
}
public static Object eval(File file, Object ctx, VariableResolverFactory vars, TemplateRegistry registry) {
return execute(compileTemplate(TemplateTools.readInFile(file)), ctx, vars, registry);
}
public static Object eval(InputStream instream) {
return eval(instream, null, (VariableResolverFactory) null, null);
}
public static Object eval(InputStream instream, Object ctx) {
return eval(instream, ctx, (VariableResolverFactory) null, null);
}
public static Object eval(InputStream instream, Object ctx, VariableResolverFactory vars) {
return eval(instream, ctx, vars);
}
public static Object eval(InputStream instream, Object ctx, Map vars) {
return eval(instream, ctx, new MapVariableResolverFactory(vars), null);
}
public static Object eval(InputStream instream, Object ctx, Map vars, TemplateRegistry registry) {
return execute(compileTemplate(TemplateTools.readStream(instream)), ctx, new MapVariableResolverFactory(vars), registry);
}
public static Object eval(InputStream instream, Object ctx, VariableResolverFactory vars, TemplateRegistry registry) {
return execute(compileTemplate(TemplateTools.readStream(instream)), ctx, vars, registry);
}
public static void eval(InputStream instream, Object ctx, VariableResolverFactory vars, TemplateRegistry register, OutputStream stream) {
execute(compileTemplate(TemplateTools.readStream(instream)), ctx, vars, register, stream);
}
public static Object eval(String template, Map vars) {
return execute(compileTemplate(template), null, new MapVariableResolverFactory(vars));
}
public static void eval(String template, Map vars, OutputStream stream) {
execute(compileTemplate(template), null, new MapVariableResolverFactory(vars), null, stream);
}
public static Object eval(String template, Object ctx) {
return execute(compileTemplate(template), ctx);
}
public static Object eval(String template, Object ctx, Map vars) {
return execute(compileTemplate(template), ctx, new MapVariableResolverFactory(vars));
}
public static void eval(String template, Object ctx, Map vars, OutputStream stream) {
execute(compileTemplate(template), ctx, new MapVariableResolverFactory(vars), null, stream);
}
public static Object eval(String template, Object ctx, VariableResolverFactory vars) {
return execute(compileTemplate(template), ctx, vars);
}
public static void eval(String template, Object ctx, VariableResolverFactory vars, TemplateOutputStream stream) {
execute(compileTemplate(template), ctx, vars, null, stream);
}
public static void eval(String template, Object ctx, VariableResolverFactory vars, OutputStream stream) {
execute(compileTemplate(template), ctx, vars, null, stream);
}
public static Object eval(String template, Map vars, TemplateRegistry registry) {
return execute(compileTemplate(template), null, new MapVariableResolverFactory(vars), registry);
}
public static void eval(String template, Map vars, TemplateRegistry registry, TemplateOutputStream stream) {
execute(compileTemplate(template), null, new MapVariableResolverFactory(vars), registry, stream);
}
public static void eval(String template, Map vars, TemplateRegistry registry, OutputStream stream) {
execute(compileTemplate(template), null, new MapVariableResolverFactory(vars), registry, stream);
}
public static Object eval(String template, Object ctx, Map vars, TemplateRegistry registry) {
return execute(compileTemplate(template), ctx, new MapVariableResolverFactory(vars), registry);
}
public static void eval(String template, Object ctx, Map vars, TemplateRegistry registry, OutputStream stream) {
execute(compileTemplate(template), ctx, new MapVariableResolverFactory(vars), registry, stream);
}
public static Object eval(String template, Object ctx, VariableResolverFactory vars, TemplateRegistry registry) {
return execute(compileTemplate(template), ctx, vars, registry);
}
public static void eval(String template, Object ctx, VariableResolverFactory vars, TemplateRegistry registry, OutputStream stream) {
execute(compileTemplate(template), ctx, vars, registry, stream);
}
public static void eval(String template, Object ctx, VariableResolverFactory vars, TemplateRegistry registry, TemplateOutputStream stream) {
execute(compileTemplate(template), ctx, vars, registry, stream);
}
public static Object execute(CompiledTemplate compiled) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), null, null, null);
}
public static void execute(CompiledTemplate compiled, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), null, null, null);
}
public static Object execute(CompiledTemplate compiled, Object context) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), context, null, null);
}
public static void execute(CompiledTemplate compiled, Object context, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), context, null, null);
}
public static Object execute(CompiledTemplate compiled, Map vars) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), null, new MapVariableResolverFactory(vars), null);
}
public static void execute(CompiledTemplate compiled, Map vars, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), null, new MapVariableResolverFactory(vars), null);
}
public static Object execute(CompiledTemplate compiled, Object context, Map vars) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), context, new MapVariableResolverFactory(vars), null);
}
public static void execute(CompiledTemplate compiled, Object context, Map vars, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), context, new MapVariableResolverFactory(vars), null);
}
public static Object execute(CompiledTemplate compiled, Object context, TemplateRegistry registry) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), context, null, registry);
}
public static void execute(CompiledTemplate compiled, Object context, TemplateRegistry registry, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), context, null, registry);
}
public static Object execute(CompiledTemplate compiled, Object context, Map vars, TemplateRegistry registry) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), context, new MapVariableResolverFactory(vars), registry);
}
public static void execute(CompiledTemplate compiled, Object context, Map vars, TemplateRegistry registry, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), context, new MapVariableResolverFactory(vars), registry);
}
public static Object execute(CompiledTemplate compiled, Object context, VariableResolverFactory factory) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), context, factory, null);
}
public static void execute(CompiledTemplate compiled, Object context, VariableResolverFactory factory, OutputStream stream) {
execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), context, factory, null);
}
public static Object execute(CompiledTemplate compiled, Object context, VariableResolverFactory factory, TemplateRegistry registry) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StringAppender(), context, factory, registry);
}
public static Object execute(CompiledTemplate compiled, Object context, VariableResolverFactory factory, TemplateRegistry registry, OutputStream stream) {
return execute(compiled.getRoot(), compiled.getTemplate(), new StandardOutputStream(stream), context, factory, registry);
}
public static Object execute(CompiledTemplate compiled, Object context, VariableResolverFactory factory, TemplateRegistry registry, TemplateOutputStream stream) {
return execute(compiled.getRoot(), compiled.getTemplate(), stream, context, factory, registry);
}
public static Object execute(Node root, char[] template,
StringAppender appender, Object context,
VariableResolverFactory factory, TemplateRegistry registry) {
return new TemplateRuntime(template, registry, root).execute(appender, context, factory);
}
public static Object execute(Node root, char[] template,
TemplateOutputStream appender, Object context,
VariableResolverFactory factory, TemplateRegistry registry) {
return new TemplateRuntime(template, registry, root).execute(appender, context, factory);
}
public Object execute(StringAppender appender, Object context, VariableResolverFactory factory) {
return execute(new StringAppenderStream(appender), context, factory);
}
public Object execute(TemplateOutputStream stream, Object context, VariableResolverFactory factory) {
return rootNode.eval(this, stream, context, factory);
}
public Node getRootNode() {
return rootNode;
}
public void setRootNode(Node rootNode) {
this.rootNode = rootNode;
}
public char[] getTemplate() {
return template;
}
public void setTemplate(char[] template) {
this.template = template;
}
public TemplateRegistry getNamedTemplateRegistry() {
return namedTemplateRegistry;
}
public void setNamedTemplateRegistry(TemplateRegistry namedTemplateRegistry) {
this.namedTemplateRegistry = namedTemplateRegistry;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/SimpleTemplateRegistry.java 0000644 0001750 0001750 00000003105 11077457613 027201 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class SimpleTemplateRegistry implements TemplateRegistry {
private Map NAMED_TEMPLATES = new HashMap();
public void addNamedTemplate(String name, CompiledTemplate template) {
NAMED_TEMPLATES.put(name, template);
}
public CompiledTemplate getNamedTemplate(String name) {
CompiledTemplate t = NAMED_TEMPLATES.get(name);
if (t == null) throw new TemplateError("no named template exists '" + name + "'");
return t;
}
public Iterator iterator() {
return NAMED_TEMPLATES.keySet().iterator();
}
public Set getNames() {
return NAMED_TEMPLATES.keySet();
}
public boolean contains(String name) {
return NAMED_TEMPLATES.containsKey(name);
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateDebug.java 0000644 0001750 0001750 00000002075 11077457613 025252 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
import org.mvel2.templates.res.Node;
public class TemplateDebug {
public static void decompile(CompiledTemplate t, char[] template) {
int i = 1;
for (Node n = t.getRoot(); n != null; n = n.getNext()) {
System.out.println((i++) + "> " + n.toString() + "['" + new String(template, n.getBegin(), n.getEnd() - n.getBegin()) + "']");
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/CompiledTemplate.java 0000644 0001750 0001750 00000002406 11312502302 025730 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
import org.mvel2.templates.res.Node;
import java.io.Serializable;
public class CompiledTemplate implements Serializable {
private char[] template;
private Node root;
public CompiledTemplate(char[] template, Node root) {
this.template = template;
this.root = root;
}
public char[] getTemplate() {
return template;
}
public void setTemplate(char[] template) {
this.template = template;
}
public Node getRoot() {
return root;
}
public void setRoot(Node root) {
this.root = root;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateRuntimeError.java 0000644 0001750 0001750 00000002573 11077457613 026664 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
public class TemplateRuntimeError extends RuntimeException {
public TemplateRuntimeError() {
super(); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateRuntimeError(String s) {
super(s); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateRuntimeError(String s, Throwable throwable) {
super(s, throwable); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateRuntimeError(Throwable throwable) {
super(throwable); //To change body of overridden methods use File | Settings | File Templates.
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateSyntaxError.java 0000644 0001750 0001750 00000002566 11077457613 026531 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
public class TemplateSyntaxError extends RuntimeException {
public TemplateSyntaxError() {
super(); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateSyntaxError(String s) {
super(s); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateSyntaxError(String s, Throwable throwable) {
super(s, throwable); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateSyntaxError(Throwable throwable) {
super(throwable); //To change body of overridden methods use File | Settings | File Templates.
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateCompiler.java 0000644 0001750 0001750 00000043553 11317165145 025775 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
import org.mvel2.CompileException;
import org.mvel2.ParserContext;
import org.mvel2.compiler.AbstractParser;
import org.mvel2.templates.res.*;
import org.mvel2.templates.util.TemplateTools;
import org.mvel2.util.ExecutionStack;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.balancedCaptureWithLineAccounting;
import static org.mvel2.util.ParseTools.subset;
import java.io.File;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
/**
* The TemplateCompiler class is used for pre-compiling MVEL Templates. To execute a compiled template see
* {@link TemplateRuntime}
*
* @author Mike Brock
*/
@SuppressWarnings({"ManualArrayCopy"})
public class TemplateCompiler {
private char[] template;
private int length;
private int start;
private int cursor;
private int lastTextRangeEnding;
private int line;
private int colStart;
private boolean codeCache = false;
private Map> customNodes;
private static final Map OPCODES = new HashMap();
static {
OPCODES.put("if", Opcodes.IF);
OPCODES.put("else", Opcodes.ELSE);
OPCODES.put("elseif", Opcodes.ELSE);
OPCODES.put("end", Opcodes.END);
OPCODES.put("foreach", Opcodes.FOREACH);
OPCODES.put("includeNamed", Opcodes.INCLUDE_NAMED);
OPCODES.put("include", Opcodes.INCLUDE_FILE);
OPCODES.put("comment", Opcodes.COMMENT);
OPCODES.put("code", Opcodes.CODE);
OPCODES.put("eval", Opcodes.EVAL);
OPCODES.put("declare", Opcodes.DECLARE);
OPCODES.put("stop", Opcodes.STOP);
}
public CompiledTemplate compile() {
return new CompiledTemplate(template, compileFrom(null, new ExecutionStack()));
}
public Node compileFrom(Node root, ExecutionStack stack) {
line = 1;
Node n = root;
if (root == null) {
n = root = new TextNode(0, 0);
}
IfNode last;
Integer opcode;
String name;
int x;
try {
while (cursor < length) {
switch (template[cursor]) {
case '\n':
line++;
colStart = cursor + 1;
break;
case '@':
case '$':
if (isNext(template[cursor])) {
start = ++cursor;
(n = markTextNode(n)).setEnd(n.getEnd() + 1);
lastTextRangeEnding = ++cursor;
continue;
}
if ((x = captureOrbToken()) != -1) {
start = x;
switch ((opcode = OPCODES.get(name = new String(capture()))) == null ? 0 : opcode) {
case Opcodes.IF:
/**
* Capture any residual text node, and push the if statement on the nesting stack.
*/
stack.push(n = markTextNode(n).next =
codeCache ? new CompiledIfNode(start, name, template, captureOrbInternal(), start)
: new IfNode(start, name, template, captureOrbInternal(), start));
n.setTerminus(new TerminalNode());
break;
case Opcodes.ELSE:
if (!stack.isEmpty() && stack.peek() instanceof IfNode) {
markTextNode(n).next = (last = (IfNode) stack.pop()).getTerminus();
last.demarcate(last.getTerminus(), template);
last.next = n = codeCache ? new CompiledIfNode(start, name, template, captureOrbInternal(), start)
: new IfNode(start, name, template, captureOrbInternal(), start);
n.setTerminus(last.getTerminus());
stack.push(n);
}
break;
case Opcodes.FOREACH:
stack.push(
n = markTextNode(n).next = codeCache ? new CompiledForEachNode(start, name, template, captureOrbInternal(), start)
: new ForEachNode(start, name, template, captureOrbInternal(), start)
);
n.setTerminus(new TerminalNode());
break;
case Opcodes.INCLUDE_FILE:
n = markTextNode(n).next =
codeCache ? new CompiledIncludeNode(start, name, template, captureOrbInternal(), start = cursor + 1)
: new IncludeNode(start, name, template, captureOrbInternal(), start = cursor + 1);
break;
case Opcodes.INCLUDE_NAMED:
n = markTextNode(n).next =
codeCache ? new CompiledNamedIncludeNode(start, name, template, captureOrbInternal(), start = cursor + 1)
: new NamedIncludeNode(start, name, template, captureOrbInternal(), start = cursor + 1);
break;
case Opcodes.CODE:
n = markTextNode(n)
.next = codeCache ? new CompiledCodeNode(start, name, template, captureOrbInternal(), start = cursor + 1)
: new CodeNode(start, name, template, captureOrbInternal(), start = cursor + 1);
break;
case Opcodes.EVAL:
n = markTextNode(n).next =
codeCache ? new CompiledEvalNode(start, name, template, captureOrbInternal(), start = cursor + 1)
: new EvalNode(start, name, template, captureOrbInternal(), start = cursor + 1);
break;
case Opcodes.COMMENT:
n = markTextNode(n)
.next = new CommentNode(start, name, template, captureOrbInternal(), start = cursor + 1);
break;
case Opcodes.DECLARE:
stack.push(n = markTextNode(n).next =
codeCache ?
new CompiledDeclareNode(start, name, template, captureOrbInternal(), start = cursor + 1)
: new DeclareNode(start, name, template, captureOrbInternal(), start = cursor + 1));
n.setTerminus(new TerminalNode());
break;
case Opcodes.END:
n = markTextNode(n);
Node end = (Node) stack.pop();
Node terminal = end.getTerminus();
terminal.setCStart(captureOrbInternal());
terminal.setEnd((lastTextRangeEnding = start) - 1);
terminal.calculateContents(template);
if (end.demarcate(terminal, template)) n = n.next = terminal;
else n = terminal;
break;
default:
if (name.length() == 0) {
n = markTextNode(n).next =
codeCache ?
new CompiledExpressionNode(start, name, template, captureOrbInternal(), start = cursor + 1)
: new ExpressionNode(start, name, template, captureOrbInternal(), start = cursor + 1);
} else if (customNodes != null && customNodes.containsKey(name)) {
Class customNode = customNodes.get(name);
try {
(n = markTextNode(n).next = (customNode.newInstance())).setBegin(start);
n.setName(name);
n.setCStart(captureOrbInternal());
n.setCEnd(start = cursor + 1);
n.setEnd(n.getCEnd());
n.setContents(subset(template, n.getCStart(), n.getCEnd() - n.getCStart() - 1));
if (n.isOpenNode()) {
stack.push(n);
}
}
catch (InstantiationException e) {
throw new RuntimeException("unable to instantiate custom node class: " + customNode.getName());
}
catch (IllegalAccessException e) {
throw new RuntimeException("unable to instantiate custom node class: " + customNode.getName());
}
} else {
throw new RuntimeException("unknown token type: " + name);
}
}
}
}
cursor++;
}
}
catch (RuntimeException e) {
CompileException ce = new CompileException(e.getMessage(), e);
ce.setExpr(template);
if (e instanceof CompileException) {
CompileException ce2 = (CompileException) e;
if (ce2.getCursor() != -1) {
ce.setCursor(ce2.getCursor());
if (ce2.getColumn() == -1) ce.setColumn(ce.getCursor() - colStart);
else ce.setColumn(ce2.getColumn());
}
}
ce.setLineNumber(line);
throw ce;
}
if (!stack.isEmpty()) {
CompileException ce = new CompileException("unclosed @" + ((Node) stack.peek()).getName() + "{} block. expected @end{}", template, cursor);
ce.setColumn(cursor - colStart);
ce.setLineNumber(line);
throw ce;
}
if (start < template.length) {
n = n.next = new TextNode(start, template.length);
}
n.next = new EndNode();
n = root;
do {
if (n.getLength() != 0) {
break;
}
}
while ((n = n.getNext()) != null);
if (n != null && n.getLength() == template.length - 1) {
if (n instanceof ExpressionNode) {
return codeCache ? new CompiledTerminalExpressionNode(n) : new TerminalExpressionNode(n);
} else {
return n;
}
}
return root;
}
// Parse Utilities Start Here
public boolean isNext(char c) {
return cursor != length && template[cursor + 1] == c;
}
public int captureOrbToken() {
int newStart = ++cursor;
while ((cursor != length) && ParseTools.isIdentifierPart(template[cursor])) cursor++;
if (cursor != length && template[cursor] == '{') return newStart;
return -1;
}
public int captureOrbInternal() {
try {
ParserContext pCtx = new ParserContext();
cursor = balancedCaptureWithLineAccounting(template, start = cursor, '{', pCtx);
line += pCtx.getLineCount();
int ret = start + 1;
start = cursor + 1;
return ret;
}
catch (CompileException e) {
e.setLineNumber(line);
e.setColumn((cursor - colStart) + 1);
throw e;
}
}
public char[] capture() {
char[] newChar = new char[cursor - start];
for (int i = 0; i < newChar.length; i++) {
newChar[i] = template[i + start];
}
return newChar;
}
public Node markTextNode(Node n) {
int s = (n.getEnd() > lastTextRangeEnding ? n.getEnd() : lastTextRangeEnding);
if (s < start) {
return n.next = new TextNode(s, lastTextRangeEnding = start - 1);
}
return n;
}
public static CompiledTemplate compileTemplate(String template) {
return new TemplateCompiler(template, true).compile();
}
public static CompiledTemplate compileTemplate(char[] template) {
return new TemplateCompiler(template, true).compile();
}
public static CompiledTemplate compileTemplate(CharSequence template) {
return new TemplateCompiler(template, true).compile();
}
public static CompiledTemplate compileTemplate(String template, Map> customNodes) {
return new TemplateCompiler(template, customNodes, true).compile();
}
public static CompiledTemplate compileTemplate(char[] template, Map> customNodes) {
return new TemplateCompiler(template, customNodes, true).compile();
}
public static CompiledTemplate compileTemplate(CharSequence template, Map> customNodes) {
return new TemplateCompiler(template, customNodes, true).compile();
}
public static CompiledTemplate compileTemplate(InputStream stream) {
return compileTemplate(stream, null);
}
public static CompiledTemplate compileTemplate(InputStream stream, Map> customNodes) {
return new TemplateCompiler(TemplateTools.readStream(stream), customNodes, true).compile();
}
public static CompiledTemplate compileTemplate(File file) {
return compileTemplate(file, null);
}
public static CompiledTemplate compileTemplate(File file, Map> customNodes) {
return new TemplateCompiler(TemplateTools.readInFile(file), customNodes, true).compile();
}
public TemplateCompiler(String template) {
this.length = (this.template = template.toCharArray()).length;
}
public TemplateCompiler(char[] template) {
this.length = (this.template = template).length;
}
public TemplateCompiler(String template, boolean codeCache) {
this.length = (this.template = template.toCharArray()).length;
this.codeCache = codeCache;
}
public TemplateCompiler(char[] template, boolean codeCache) {
this.length = (this.template = template).length;
this.codeCache = codeCache;
}
public TemplateCompiler(CharSequence sequence) {
this.length = (this.template = sequence.toString().toCharArray()).length;
}
public TemplateCompiler(CharSequence sequence, boolean codeCache) {
this.length = (this.template = sequence.toString().toCharArray()).length;
this.codeCache = codeCache;
}
public TemplateCompiler(String template, Map> customNodes) {
this.length = (this.template = template.toCharArray()).length;
this.customNodes = customNodes;
}
public TemplateCompiler(char[] template, Map> customNodes) {
this.length = (this.template = template).length;
this.customNodes = customNodes;
}
public TemplateCompiler(CharSequence sequence, Map> customNodes) {
this.length = (this.template = sequence.toString().toCharArray()).length;
this.customNodes = customNodes;
}
public TemplateCompiler(String template, Map> customNodes, boolean codeCache) {
this.length = (this.template = template.toCharArray()).length;
this.customNodes = customNodes;
this.codeCache = codeCache;
}
public TemplateCompiler(char[] template, Map> customNodes, boolean codeCache) {
this.length = (this.template = template).length;
this.customNodes = customNodes;
this.codeCache = codeCache;
}
public TemplateCompiler(CharSequence sequence, Map> customNodes, boolean codeCache) {
this.length = (this.template = sequence.toString().toCharArray()).length;
this.customNodes = customNodes;
this.codeCache = codeCache;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/ 0000755 0001750 0001750 00000000000 11412747053 022443 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/IncludeNode.java 0000644 0001750 0001750 00000010161 11317165145 025476 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateError;
import org.mvel2.templates.TemplateRuntime;
import static org.mvel2.templates.util.TemplateTools.captureToEOS;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.ExecutionStack;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import java.io.*;
public class IncludeNode extends Node {
private static final StackThreadLocal relativePathStack;
private char[] includeExpression;
private char[] preExpression;
private static class StackThreadLocal extends ThreadLocal {
protected T initialValue() {
ExecutionStack stk = new ExecutionStack();
stk.push(".");
return (T) stk;
}
}
static {
relativePathStack = new StackThreadLocal();
}
public IncludeNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
int mark;
this.includeExpression = subset(contents, 0, mark = captureToEOS(contents, 0));
if (mark != contents.length) this.preExpression = subset(contents, ++mark, contents.length - mark);
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
String file = MVEL.eval(includeExpression, ctx, factory, String.class);
if (this.preExpression != null) {
MVEL.eval(preExpression, ctx, factory);
}
if (next != null) {
return next.eval(runtime, appender.append(String.valueOf(TemplateRuntime.eval(readInFile(file), ctx, factory))), ctx, factory);
}
else {
return appender.append(String.valueOf(MVEL.eval(readInFile(file), ctx, factory)));
}
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
private static Object peek() {
return relativePathStack.get().peek();
}
public static Object pop() {
return relativePathStack.get().pop();
}
private static void push(String path) {
relativePathStack.get().push(path);
}
public static String readInFile(String fileName) {
File file = new File(String.valueOf(peek()) + "/" + fileName);
try {
FileInputStream instream = new FileInputStream(file);
BufferedInputStream bufstream = new BufferedInputStream(instream);
push(file.getParent());
byte[] buf = new byte[10];
int read;
int i;
StringAppender appender = new StringAppender();
while ((read = bufstream.read(buf)) != -1) {
for (i = 0; i < read; i++) {
appender.append((char) buf[i]);
}
}
bufstream.close();
instream.close();
pop();
return appender.toString();
}
catch (FileNotFoundException e) {
throw new TemplateError("cannot include template '" + fileName + "': file not found.");
}
catch (IOException e) {
throw new TemplateError("unknown I/O exception while including '" + fileName + "' (stacktrace nested)", e);
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/IfNode.java 0000644 0001750 0001750 00000004012 11317165145 024447 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.PrintWriter;
public class IfNode extends Node {
protected Node trueNode;
protected Node elseNode;
public IfNode(int begin, String name, char[] template, int start, int end) {
super(begin, name, template, start, end);
}
public Node getTrueNode() {
return trueNode;
}
public void setTrueNode(ExpressionNode trueNode) {
this.trueNode = trueNode;
}
public Node getElseNode() {
return elseNode;
}
public void setElseNode(ExpressionNode elseNode) {
this.elseNode = elseNode;
}
public boolean demarcate(Node terminatingNode, char[] template) {
trueNode = next;
next = terminus;
return true;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (contents.length == 0 || MVEL.eval(contents, ctx, factory, Boolean.class)) {
return trueNode.eval(runtime, appender, ctx, factory);
}
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/TextNode.java 0000644 0001750 0001750 00000003470 11164527565 025054 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.PrintWriter;
public class TextNode extends Node {
public TextNode(int begin, int end) {
this.begin = begin;
this.end = end;
}
public TextNode(int begin, int end, ExpressionNode next) {
this.begin = begin;
this.end = end;
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
int len = end - begin;
if (len != 0) {
appender.append(new String(runtime.getTemplate(), begin, len));
}
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public String toString() {
return "TextNode(" + begin + "," + end + ")";
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
public void calculateContents(char[] template) {
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledIncludeNode.java 0000644 0001750 0001750 00000011761 11317165145 027162 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.CompiledTemplate;
import org.mvel2.templates.TemplateCompiler;
import org.mvel2.templates.TemplateError;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.ExecutionStack;
import org.mvel2.util.StringAppender;
import java.io.*;
import static org.mvel2.templates.util.TemplateTools.captureToEOS;
import static org.mvel2.util.ParseTools.subset;
public class CompiledIncludeNode extends Node {
private static final StackThreadLocal relativePathStack;
private char[] includeExpression;
private char[] preExpression;
private Serializable cIncludeExpression;
private Serializable cPreExpression;
private long fileDateStamp;
private CompiledTemplate cFileCache;
private static class StackThreadLocal extends ThreadLocal {
protected T initialValue() {
ExecutionStack stk = new ExecutionStack();
stk.push(".");
return (T) stk;
}
}
static {
relativePathStack = new StackThreadLocal();
}
public CompiledIncludeNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
int mark;
cIncludeExpression = MVEL.compileExpression(this.includeExpression = subset(contents, 0, mark = captureToEOS(contents, 0)));
if (mark != contents.length)
cPreExpression = MVEL.compileExpression(this.preExpression = subset(contents, ++mark, contents.length - mark));
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
String file = MVEL.executeExpression(cIncludeExpression, ctx, factory, String.class);
if (this.cPreExpression != null) {
MVEL.executeExpression(cPreExpression, ctx, factory);
}
if (next != null) {
return next.eval(runtime, appender.append(String.valueOf(TemplateRuntime.eval(readFile(file, ctx, factory), ctx, factory))), ctx, factory);
} else {
return appender.append(String.valueOf(MVEL.eval(readFile(file, ctx, factory), ctx, factory)));
}
}
private String readFile(String fileName, Object ctx, VariableResolverFactory factory) {
File file = getFile(fileName);
if (fileDateStamp == 0 || fileDateStamp != file.lastModified()) {
fileDateStamp = file.lastModified();
cFileCache = TemplateCompiler.compileTemplate(readInFile(file));
}
return String.valueOf(TemplateRuntime.execute(cFileCache, ctx, factory));
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
private static Object peek() {
return relativePathStack.get().peek();
}
public static Object pop() {
return relativePathStack.get().pop();
}
private static void push(String path) {
relativePathStack.get().push(path);
}
public static File getFile(String fileName) {
return new File(String.valueOf(peek()) + "/" + fileName);
}
public static String readInFile(File file) {
try {
FileInputStream instream = new FileInputStream(file);
BufferedInputStream bufstream = new BufferedInputStream(instream);
push(file.getParent());
byte[] buf = new byte[10];
int read;
int i;
StringAppender appender = new StringAppender();
while ((read = bufstream.read(buf)) != -1) {
for (i = 0; i < read; i++) {
appender.append((char) buf[i]);
}
}
bufstream.close();
instream.close();
pop();
return appender.toString();
}
catch (FileNotFoundException e) {
throw new TemplateError("cannot include template '" + file.getPath() + "': file not found.");
}
catch (IOException e) {
throw new TemplateError("unknown I/O exception while including '" + file.getPath() + "' (stacktrace nested)", e);
}
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/ExpressionNode.java 0000644 0001750 0001750 00000004353 11317165145 026260 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import static java.lang.String.valueOf;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
public class ExpressionNode extends Node {
public ExpressionNode() {
}
public ExpressionNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
}
public ExpressionNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
appender.append(valueOf(MVEL.eval(contents, ctx, factory)));
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
public String toString() {
return "ExpressionNode:" + name + "{" + (contents == null ? "" : new String(contents)) + "} (start=" + begin + ";end=" + end + ")";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledDeclareNode.java 0000644 0001750 0001750 00000004340 11317165145 027131 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.CompiledTemplate;
import org.mvel2.templates.SimpleTemplateRegistry;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
import static org.mvel2.util.ParseTools.subset;
public class CompiledDeclareNode extends Node {
private Node nestedNode;
private Serializable ce;
public CompiledDeclareNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (runtime.getNamedTemplateRegistry() == null) {
runtime.setNamedTemplateRegistry(new SimpleTemplateRegistry());
}
runtime.getNamedTemplateRegistry()
.addNamedTemplate(MVEL.executeExpression(ce, ctx, factory, String.class),
new CompiledTemplate(runtime.getTemplate(), nestedNode));
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
Node n = nestedNode = next;
while (n.getNext() != null) n = n.next;
n.next = new EndNode();
next = terminus;
return false;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledEvalNode.java 0000644 0001750 0001750 00000004520 11317165145 026461 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.compiler.CompiledExpression;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
import static java.lang.String.valueOf;
import static org.mvel2.util.ParseTools.subset;
public class CompiledEvalNode extends Node {
private Serializable ce;
public CompiledEvalNode() {
}
public CompiledEvalNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
}
public CompiledEvalNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
appender.append(String.valueOf(TemplateRuntime.eval(valueOf(MVEL.executeExpression(ce, ctx, factory)), ctx, factory)));
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
public String toString() {
return "EvalNode:" + name + "{" + (contents == null ? "" : new String(contents)) + "} (start=" + begin + ";end=" + end + ")";
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/Node.java 0000644 0001750 0001750 00000006543 11164527565 024213 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import java.io.Serializable;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
public abstract class Node implements Serializable {
protected String name;
protected char[] contents;
protected int begin;
protected int cStart;
protected int cEnd;
protected int end;
public Node next;
protected Node terminus;
public Node() {
}
public Node(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
}
public Node(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
this.next = next;
}
public abstract Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory);
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char[] getContents() {
return contents;
}
public void setContents(char[] contents) {
this.contents = contents;
}
public int getBegin() {
return begin;
}
public void setBegin(int begin) {
this.begin = begin;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
public int getCStart() {
return cStart;
}
public void setCStart(int cStart) {
this.cStart = cStart;
}
public int getCEnd() {
return cEnd;
}
public void setCEnd(int cEnd) {
this.cEnd = cEnd;
}
public boolean isOpenNode() {
return false;
}
public abstract boolean demarcate(Node terminatingNode, char[] template);
public Node getNext() {
return next;
}
public Node setNext(Node next) {
return this.next = next;
}
public Node getTerminus() {
return terminus;
}
public void setTerminus(Node terminus) {
this.terminus = terminus;
}
public void calculateContents(char[] template) {
this.contents = subset(template, cStart, end - cStart);
}
public int getLength() {
return this.end - this.begin;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledForEachNode.java 0000644 0001750 0001750 00000012504 11317165145 027102 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.TemplateRuntimeError;
import org.mvel2.templates.util.ArrayIterator;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.ParseTools;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class CompiledForEachNode extends Node {
public Node nestedNode;
private Serializable[] ce;
private String[] item;
private String[] expression;
private char[] sepExpr;
private Serializable cSepExpr;
public CompiledForEachNode() {
}
public CompiledForEachNode(int begin, String name, char[] template, int start, int end) {
super(begin, name, template, start, end);
configure();
}
public Node getNestedNode() {
return nestedNode;
}
public void setNestedNode(Node nestedNode) {
this.nestedNode = nestedNode;
}
public boolean demarcate(Node terminatingnode, char[] template) {
nestedNode = next;
next = terminus;
sepExpr = terminatingnode.getContents();
if (sepExpr.length == 0) {
sepExpr = null;
}
else {
cSepExpr = MVEL.compileExpression(sepExpr);
}
return false;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
Iterator[] iters = new Iterator[item.length];
Object o;
for (int i = 0; i < iters.length; i++) {
if ((o = MVEL.executeExpression(ce[i], ctx, factory)) instanceof Iterable) {
iters[i] = ((Iterable) o).iterator();
}
else if (o instanceof Object[]) {
iters[i] = new ArrayIterator((Object[]) o);
}
else {
throw new TemplateRuntimeError("cannot iterate object type: " + o.getClass().getName());
}
}
Map locals = new HashMap();
MapVariableResolverFactory localFactory = new MapVariableResolverFactory(locals, factory);
int iterate = iters.length;
while (true) {
for (int i = 0; i < iters.length; i++) {
if (!iters[i].hasNext()) {
iterate--;
locals.put(item[i], "");
}
else {
locals.put(item[i], iters[i].next());
}
}
if (iterate != 0) {
nestedNode.eval(runtime, appender, ctx, localFactory);
if (sepExpr != null) {
for (Iterator it : iters) {
if (it.hasNext()) {
appender.append(String.valueOf(MVEL.executeExpression(cSepExpr, ctx, factory)));
break;
}
}
}
}
else break;
}
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
private void configure() {
ArrayList items = new ArrayList();
ArrayList expr = new ArrayList();
int start = 0;
for (int i = 0; i < contents.length; i++) {
switch (contents[i]) {
case ':':
items.add(ParseTools.createStringTrimmed(contents, start, i - start));
start = i + 1;
break;
case ',':
if (expr.size() != (items.size() - 1)) {
throw new CompileException("unexpected character ',' in foreach tag", cStart + i);
}
expr.add(ParseTools.createStringTrimmed(contents, start, i - start));
start = i + 1;
break;
}
}
if (start < contents.length) {
if (expr.size() != (items.size() - 1)) {
throw new CompileException("expected character ':' in foreach tag", cEnd);
}
expr.add(ParseTools.createStringTrimmed(contents, start, contents.length - start));
}
item = new String[items.size()];
int i = 0;
for (String s : items) item[i++] = s;
ce = new Serializable[(expression = new String[expr.size()]).length];
i = 0;
for (String s : expr) {
ce[i] = MVEL.compileExpression(expression[i++] = s);
}
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/EndNode.java 0000644 0001750 0001750 00000002510 11164527565 024630 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
public class EndNode extends Node {
public Object eval(TemplateRuntime runtie, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
return appender.toString();
}
public String toString() {
return "EndNode";
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CodeNode.java 0000644 0001750 0001750 00000004213 11164527565 024776 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.OutputStream;
public class CodeNode extends Node {
public CodeNode() {
}
public CodeNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
}
public CodeNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
MVEL.eval(contents, ctx, factory);
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
public String toString() {
return "CodeNode:" + name + "{" + (contents == null ? "" : new String(contents)) + "} (start=" + begin + ";end=" + end + ")";
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledExpressionNode.java 0000644 0001750 0001750 00000004263 11317165145 027735 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
import static java.lang.String.valueOf;
import static org.mvel2.util.ParseTools.subset;
public class CompiledExpressionNode extends ExpressionNode {
private Serializable ce;
public CompiledExpressionNode() {
}
public CompiledExpressionNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
}
public CompiledExpressionNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
appender.append(valueOf(MVEL.executeExpression(ce, ctx, factory)));
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public String toString() {
return "ExpressionNode:" + name + "{" + (contents == null ? "" : new String(contents)) + "} (start=" + begin + ";end=" + end + ")";
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/TerminalNode.java 0000644 0001750 0001750 00000002652 11164527565 025704 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.PrintWriter;
public class TerminalNode extends Node {
public TerminalNode() {
}
public TerminalNode(int begin, int end) {
this.begin = begin;
this.end = end;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/EvalNode.java 0000644 0001750 0001750 00000004205 11312023501 024764 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import static java.lang.String.valueOf;
import static org.mvel2.util.ParseTools.subset;
public class EvalNode extends Node {
public EvalNode() {
}
public EvalNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
}
public EvalNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
appender.append(String.valueOf(TemplateRuntime.eval(valueOf(MVEL.eval(contents, ctx, factory)), ctx, factory)));
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
public String toString() {
return "EvalNode:" + name + "{" + (contents == null ? "" : new String(contents)) + "} (start=" + begin + ";end=" + end + ")";
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/Opcodes.java 0000644 0001750 0001750 00000002142 11312023501 024661 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
public interface Opcodes {
public static int IF = 1;
public static int ELSE = 2;
public static int FOREACH = 3;
public static int END = 10;
public static int INCLUDE_FILE = 50;
public static int INCLUDE_NAMED = 51;
public static int COMMENT = 52;
public static int CODE = 53;
public static int EVAL = 55;
public static int DECLARE = 54;
public static int STOP = 70;
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/NamedIncludeNode.java 0000644 0001750 0001750 00000004751 11164527565 026463 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import static org.mvel2.templates.util.TemplateTools.captureToEOS;
import org.mvel2.templates.util.TemplateOutputStream;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.PrintWriter;
public class NamedIncludeNode extends Node {
private char[] includeExpression;
private char[] preExpression;
public NamedIncludeNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
int mark;
this.includeExpression = subset(contents, 0, mark = captureToEOS(contents, 0));
if (mark != contents.length) this.preExpression = subset(contents, ++mark, contents.length - mark);
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (preExpression != null) {
MVEL.eval(preExpression, ctx, factory);
}
if (next != null) {
return next.eval(runtime,
appender.append(String.valueOf(TemplateRuntime.execute(runtime.getNamedTemplateRegistry().getNamedTemplate(MVEL.eval(includeExpression, ctx, factory, String.class)), ctx, factory))), ctx, factory);
}
else {
return appender.append(String.valueOf(TemplateRuntime.execute(runtime.getNamedTemplateRegistry().getNamedTemplate(MVEL.eval(includeExpression, ctx, factory, String.class)), ctx, factory)));
}
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledCodeNode.java 0000644 0001750 0001750 00000004254 11317165145 026450 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
import static org.mvel2.util.ParseTools.subset;
public class CompiledCodeNode extends Node {
private Serializable ce;
public CompiledCodeNode() {
}
public CompiledCodeNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
}
public CompiledCodeNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
MVEL.executeExpression(ce, ctx, factory);
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
public String toString() {
return "CodeNode:" + name + "{" + (contents == null ? "" : new String(contents)) + "} (start=" + begin + ";end=" + end + ")";
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CommentNode.java 0000644 0001750 0001750 00000003347 11164527565 025535 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
public class CommentNode extends Node {
public CommentNode() {
}
public CommentNode(int begin, String name, char[] template, int start, int end) {
this.name = name;
this.end = this.cEnd = end;
}
public CommentNode(int begin, String name, char[] template, int start, int end, Node next) {
this.begin = begin;
this.end = this.cEnd = end;
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (next != null)
return next.eval(runtime, appender, ctx, factory);
else
return null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/DeclareNode.java 0000644 0001750 0001750 00000004355 11164527565 025472 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.CompiledTemplate;
import org.mvel2.templates.SimpleTemplateRegistry;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
public class DeclareNode extends Node {
private Node nestedNode;
public DeclareNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (runtime.getNamedTemplateRegistry() == null) {
runtime.setNamedTemplateRegistry(new SimpleTemplateRegistry());
}
runtime.getNamedTemplateRegistry()
.addNamedTemplate(MVEL.eval(contents, ctx, factory, String.class),
new CompiledTemplate(runtime.getTemplate(), nestedNode));
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
public boolean demarcate(Node terminatingNode, char[] template) {
Node n = nestedNode = next;
while (n.getNext() != null) n = n.next;
n.next = new EndNode();
next = terminus;
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/ForEachNode.java 0000644 0001750 0001750 00000012005 11164527565 025431 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.TemplateRuntimeError;
import org.mvel2.templates.util.ArrayIterator;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.ParseTools;
import org.mvel2.util.StringAppender;
import java.util.*;
import java.io.PrintStream;
import java.io.PrintWriter;
public class ForEachNode extends Node {
public Node nestedNode;
private String[] item;
private String[] expression;
private char[] sepExpr;
public ForEachNode() {
}
public ForEachNode(int begin, String name, char[] template, int start, int end) {
super(begin, name, template, start, end);
configure();
}
public Node getNestedNode() {
return nestedNode;
}
public void setNestedNode(Node nestedNode) {
this.nestedNode = nestedNode;
}
public boolean demarcate(Node terminatingnode, char[] template) {
nestedNode = next;
next = terminus;
sepExpr = terminatingnode.getContents();
if (sepExpr.length == 0) sepExpr = null;
return false;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
Iterator[] iters = new Iterator[item.length];
Object o;
for (int i = 0; i < iters.length; i++) {
if ((o = MVEL.eval(expression[i], ctx, factory)) instanceof Iterable) {
iters[i] = ((Iterable) o).iterator();
}
else if (o instanceof Object[]) {
iters[i] = new ArrayIterator((Object[]) o);
}
else {
throw new TemplateRuntimeError("cannot iterate object type: " + o.getClass().getName());
}
}
Map locals = new HashMap();
MapVariableResolverFactory localFactory = new MapVariableResolverFactory(locals, factory);
int iterate = iters.length;
while (true) {
for (int i = 0; i < iters.length; i++) {
if (!iters[i].hasNext()) {
iterate--;
locals.put(item[i], "");
}
else {
locals.put(item[i], iters[i].next());
}
}
if (iterate != 0) {
nestedNode.eval(runtime, appender, ctx, localFactory);
if (sepExpr != null) {
for (Iterator it : iters) {
if (it.hasNext()) {
appender.append(String.valueOf(MVEL.eval(sepExpr, ctx, factory)));
break;
}
}
}
}
else break;
}
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
private void configure() {
ArrayList items = new ArrayList();
ArrayList expr = new ArrayList();
int start = 0;
for (int i = 0; i < contents.length; i++) {
switch (contents[i]) {
case ':':
items.add(ParseTools.createStringTrimmed(contents, start, i - start));
start = i + 1;
break;
case ',':
if (expr.size() != (items.size() - 1)) {
throw new CompileException("unexpected character ',' in foreach tag", cStart + i);
}
expr.add(ParseTools.createStringTrimmed(contents, start, i - start));
start = i + 1;
break;
}
}
if (start < contents.length) {
if (expr.size() != (items.size() - 1)) {
throw new CompileException("expected character ':' in foreach tag", cEnd);
}
expr.add(ParseTools.createStringTrimmed(contents, start, contents.length - start));
}
item = new String[items.size()];
int i = 0;
for (String s : items) item[i++] = s;
expression = new String[expr.size()];
i = 0;
for (String s : expr) expression[i++] = s;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledNamedIncludeNode.java 0000644 0001750 0001750 00000005235 11317165145 030126 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
import static org.mvel2.templates.util.TemplateTools.captureToEOS;
import static org.mvel2.util.ParseTools.subset;
public class CompiledNamedIncludeNode extends Node {
private char[] includeExpression;
private char[] preExpression;
private Serializable cIncludeExpression;
private Serializable cPreExpression;
public CompiledNamedIncludeNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
int mark;
this.cIncludeExpression = MVEL.compileExpression(this.includeExpression = subset(contents, 0, mark = captureToEOS(contents, 0)));
if (mark != contents.length)
this.cPreExpression = MVEL.compileExpression(this.preExpression = subset(contents, ++mark, contents.length - mark));
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (preExpression != null) {
MVEL.executeExpression(cPreExpression, ctx, factory);
}
if (next != null) {
return next.eval(runtime,
appender.append(String.valueOf(TemplateRuntime.execute(runtime.getNamedTemplateRegistry().getNamedTemplate(MVEL.executeExpression(cIncludeExpression, ctx, factory, String.class)), ctx, factory))), ctx, factory);
} else {
return appender.append(String.valueOf(TemplateRuntime.execute(runtime.getNamedTemplateRegistry().getNamedTemplate(MVEL.executeExpression(cIncludeExpression, ctx, factory, String.class)), ctx, factory)));
}
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/TerminalExpressionNode.java 0000644 0001750 0001750 00000004115 11164527565 027760 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import static org.mvel2.util.ParseTools.subset;
import org.mvel2.util.StringAppender;
import java.io.PrintStream;
import java.io.PrintWriter;
public class TerminalExpressionNode extends Node {
public TerminalExpressionNode() {
}
public TerminalExpressionNode(Node node) {
this.begin = node.begin;
this.name = node.name;
this.contents = node.contents;
}
public TerminalExpressionNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
}
public TerminalExpressionNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
return MVEL.eval(contents, ctx, factory);
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledTerminalExpressionNode.java 0000644 0001750 0001750 00000004302 11317165145 031423 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
import static org.mvel2.util.ParseTools.subset;
public class CompiledTerminalExpressionNode extends TerminalExpressionNode {
private Serializable ce;
public CompiledTerminalExpressionNode() {
}
public CompiledTerminalExpressionNode(Node node) {
this.begin = node.begin;
this.name = node.name;
ce = MVEL.compileExpression(this.contents = node.contents);
}
public CompiledTerminalExpressionNode(int begin, String name, char[] template, int start, int end) {
this.begin = begin;
this.name = name;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
}
public CompiledTerminalExpressionNode(int begin, String name, char[] template, int start, int end, Node next) {
this.name = name;
this.begin = begin;
ce = MVEL.compileExpression(this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1));
this.next = next;
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
return MVEL.executeExpression(ce, ctx, factory);
}
public boolean demarcate(Node terminatingNode, char[] template) {
return false;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/res/CompiledIfNode.java 0000644 0001750 0001750 00000003040 11317165145 026124 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.res;
import org.mvel2.MVEL;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.Serializable;
public class CompiledIfNode extends IfNode {
private Serializable ce;
public CompiledIfNode(int begin, String name, char[] template, int start, int end) {
super(begin, name, template, start, end);
ce = MVEL.compileExpression(contents);
}
public Object eval(TemplateRuntime runtime, TemplateOutputStream appender, Object ctx, VariableResolverFactory factory) {
if (contents.length == 0 || MVEL.executeExpression(ce, ctx, factory, Boolean.class)) {
return trueNode.eval(runtime, appender, ctx, factory);
}
return next != null ? next.eval(runtime, appender, ctx, factory) : null;
}
} mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/ 0000755 0001750 0001750 00000000000 11412747053 022627 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/TemplateTools.java 0000644 0001750 0001750 00000007320 11301035750 026257 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.util;
import org.mvel2.templates.TemplateError;
import org.mvel2.templates.res.Node;
import org.mvel2.templates.res.TerminalNode;
import static org.mvel2.util.ParseTools.balancedCapture;
import org.mvel2.util.StringAppender;
import java.io.*;
import java.nio.ByteBuffer;
import static java.nio.ByteBuffer.allocateDirect;
import java.nio.channels.FileChannel;
public class TemplateTools {
public static Node getLastNode(Node node) {
Node n = node;
while (true) {
if (n.getNext() instanceof TerminalNode) return n;
n = n.getNext();
}
}
public static int captureToEOS(char[] expression, int cursor) {
int length = expression.length;
while (cursor != length) {
switch (expression[cursor]) {
case '(':
case '[':
case '{':
cursor = balancedCapture(expression, cursor, expression[cursor]);
break;
case ';':
case '}':
return cursor;
}
cursor++;
}
return cursor;
}
public static String readInFile(String file) {
return readInFile(new File(file));
}
public static String readInFile(File file) {
try {
FileChannel fc = new FileInputStream(file).getChannel();
ByteBuffer buf = allocateDirect(10);
StringAppender appender = new StringAppender();
int read;
while (true) {
buf.rewind();
if ((read = fc.read(buf)) != -1) {
buf.rewind();
for (; read != 0; read--) {
appender.append((char) buf.get());
}
}
else {
break;
}
}
fc.close();
return appender.toString();
}
catch (FileNotFoundException e) {
throw new TemplateError("cannot include template '" + file.getName() + "': file not found.");
}
catch (IOException e) {
throw new TemplateError("unknown I/O exception while including '" + file.getName() + "' (stacktrace nested)", e);
}
}
public static String readStream(InputStream instream) {
try {
byte[] buf = new byte[10];
StringAppender appender = new StringAppender();
int read;
while ((read = instream.read(buf)) != -1) {
for (int i = 0; i < read; i++) {
appender.append((char) buf[i]);
}
}
return appender.toString();
}
catch (NullPointerException e) {
if (instream == null) {
throw new TemplateError("null input stream", e);
}
else {
throw e;
}
}
catch (IOException e) {
throw new TemplateError("unknown I/O exception while including (stacktrace nested)", e);
}
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/io/ 0000755 0001750 0001750 00000000000 11412747053 023236 5 ustar drazzib drazzib mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/io/StringAppenderStream.java 0000644 0001750 0001750 00000001457 11164527565 030221 0 ustar drazzib drazzib package org.mvel2.templates.util.io;
import org.mvel2.templates.util.TemplateOutputStream;
import org.mvel2.util.StringAppender;
/**
* Created by IntelliJ IDEA.
* User: christopherbrock
* Date: 31-Mar-2009
* Time: 7:36:24 PM
* To change this template use File | Settings | File Templates.
*/
public class StringAppenderStream implements TemplateOutputStream {
private StringAppender appender;
public StringAppenderStream(StringAppender appender) {
this.appender = appender;
}
public TemplateOutputStream append(CharSequence c) {
appender.append(c);
return this;
}
public TemplateOutputStream append(char[] c) {
appender.append(c);
return this;
}
@Override
public String toString() {
return appender.toString();
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/io/StandardOutputStream.java 0000644 0001750 0001750 00000001417 11164527565 030251 0 ustar drazzib drazzib package org.mvel2.templates.util.io;
import org.mvel2.templates.util.TemplateOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
public class StandardOutputStream implements TemplateOutputStream {
private OutputStream outputStream;
private PrintWriter printWriter;
public StandardOutputStream(OutputStream outputStream) {
this.printWriter = new PrintWriter(this.outputStream = outputStream);
}
public TemplateOutputStream append(CharSequence c) {
printWriter.append(c);
return this;
}
public TemplateOutputStream append(char[] c) {
for (char i : c) {
printWriter.append(i);
}
return this;
}
@Override
public String toString() {
return null;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/ArrayIterator.java 0000644 0001750 0001750 00000002112 11077457613 026265 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates.util;
import java.util.Iterator;
public class ArrayIterator implements Iterator {
private Object[] array;
private int cursor = 0;
public ArrayIterator(Object[] array) {
this.array = array;
}
public boolean hasNext() {
return cursor != array.length;
}
public Object next() {
return array[cursor++];
}
public void remove() {
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/util/TemplateOutputStream.java 0000644 0001750 0001750 00000000267 11164527565 027657 0 ustar drazzib drazzib package org.mvel2.templates.util;
public interface TemplateOutputStream {
public TemplateOutputStream append(CharSequence c);
public TemplateOutputStream append(char[] c);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateRegistry.java 0000644 0001750 0001750 00000001752 11077457613 026035 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
import java.util.Iterator;
import java.util.Set;
public interface TemplateRegistry {
Iterator iterator();
Set getNames();
boolean contains(String name);
void addNamedTemplate(String name, CompiledTemplate template);
CompiledTemplate getNamedTemplate(String name);
}
mvel-2.0.18.orig/src/main/java/org/mvel2/templates/TemplateError.java 0000644 0001750 0001750 00000002530 11077457613 025311 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2.templates;
public class TemplateError extends RuntimeException {
public TemplateError() {
super(); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateError(String s) {
super(s); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateError(String s, Throwable throwable) {
super(s, throwable); //To change body of overridden methods use File | Settings | File Templates.
}
public TemplateError(Throwable throwable) {
super(throwable); //To change body of overridden methods use File | Settings | File Templates.
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/CompileException.java 0000644 0001750 0001750 00000011244 11301035750 023757 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import static org.mvel2.util.ParseTools.isWhitespace;
import static org.mvel2.util.ParseTools.repeatChar;
import org.mvel2.util.StringAppender;
import static java.lang.String.copyValueOf;
import java.util.ArrayList;
import java.util.List;
/**
* Standard exception thrown for all general compile and some runtime failures.
*/
public class CompileException extends RuntimeException {
private char[] expr;
private int cursor = 0;
private int msgOffset = 0;
private int lineNumber = 1;
private int column = 0;
private int lastLineStart = 0;
private List errors;
public CompileException() {
super();
}
public CompileException(String message) {
super(message);
}
public CompileException(String message, List errors) {
super(message);
this.errors = errors;
}
public CompileException(String message, int cursor) {
super(message);
this.cursor = cursor;
}
public String toString() {
return generateErrorMessage();
}
public CompileException(String message, char[] expr, int cursor, Throwable e) {
super(message, e);
this.expr = expr;
this.cursor = cursor;
}
public CompileException(String message, char[] expr, int cursor) {
super(message);
this.expr = expr;
this.cursor = cursor;
}
public CompileException(String message, Throwable cause) {
super(message, cause);
}
public CompileException(Throwable cause) {
super(cause);
}
@Override
public String getMessage() {
return generateErrorMessage();
}
private CharSequence showCodeNearError(char[] expr, int cursor) {
if (expr == null) return "Unknown";
int start = cursor - 10;
int end = (cursor + 20);
if (end > expr.length) {
end = expr.length - 1;
start -= 20;
}
if (start < 0) {
start = 0;
}
while (start < end && isWhitespace(expr[start])) start++;
CharSequence cs = null;
try {
cs = copyValueOf(expr, start, end - start);
}
catch (StringIndexOutOfBoundsException e) {
System.out.println("");
throw e;
}
msgOffset = start;
return cs;
}
private String generateErrorMessage() {
StringAppender appender = new StringAppender().append("[Error: " + super.getMessage() + "]\n");
int offset = appender.length();
appender.append("[Near : {... ");
offset = appender.length() - offset;
appender.append(showCodeNearError(expr, cursor))
.append(" ....}]\n")
.append(repeatChar(' ', offset));
if ((offset = cursor - msgOffset - 1) < 0) offset = 0;
appender.append(repeatChar(' ', offset)).append("^");
if (lineNumber != -1) {
appender.append('\n')
.append("[Line: " + lineNumber + ", Column: " + column + "]");
}
return appender.toString();
}
public char[] getExpr() {
return expr;
}
public int getCursor() {
return cursor;
}
public List getErrors() {
return errors != null ? errors : new ArrayList(0);
}
public void setErrors(List errors) {
this.errors = errors;
}
public int getLineNumber() {
return lineNumber;
}
public void setLineNumber(int lineNumber) {
this.lineNumber = lineNumber;
}
public int getColumn() {
return column;
}
public void setColumn(int column) {
this.column = column;
}
public void setExpr(char[] expr) {
this.expr = expr;
}
public void setCursor(int cursor) {
this.cursor = cursor;
}
public int getLastLineStart() {
return lastLineStart;
}
public void setLastLineStart(int lastLineStart) {
this.lastLineStart = lastLineStart;
}
}
mvel-2.0.18.orig/src/main/java/org/mvel2/PropertyAccessor.java 0000644 0001750 0001750 00000122401 11324125240 024014 0 ustar drazzib drazzib /**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mvel2;
import static org.mvel2.DataConversion.canConvert;
import static org.mvel2.DataConversion.convert;
import static org.mvel2.MVEL.eval;
import org.mvel2.ast.Function;
import org.mvel2.ast.Proto;
import org.mvel2.ast.TypeDescriptor;
import static org.mvel2.ast.TypeDescriptor.getClassReference;
import static org.mvel2.compiler.AbstractParser.LITERALS;
import static org.mvel2.compiler.AbstractParser.getCurrentThreadParserContext;
import org.mvel2.integration.GlobalListenerFactory;
import static org.mvel2.integration.GlobalListenerFactory.notifySetListeners;
import static org.mvel2.integration.PropertyHandlerFactory.*;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.util.MethodStub;
import org.mvel2.util.ParseTools;
import static org.mvel2.util.ParseTools.*;
import static org.mvel2.util.PropertyTools.getFieldOrAccessor;
import static org.mvel2.util.PropertyTools.getFieldOrWriteAccessor;
import org.mvel2.util.StringAppender;
import static java.lang.Character.isJavaIdentifierPart;
import static java.lang.Thread.currentThread;
import java.lang.ref.WeakReference;
import java.lang.reflect.*;
import static java.lang.reflect.Array.getLength;
import java.util.*;
@SuppressWarnings({"unchecked"})
/**
* The property accessor class is used for extracting properties from objects instances.
*/
public class PropertyAccessor {
private int start = 0;
private int cursor = 0;
private char[] property;
private int length;
private Object thisReference;
private Object ctx;
private Object curr;
private boolean first = true;
private boolean nullHandle = false;
private VariableResolverFactory variableFactory;
private static final int DONE = -1;
private static final int NORM = 0;
private static final int METH = 1;
private static final int COL = 2;
private static final int WITH = 3;
private static final Object[] EMPTYARG = new Object[0];
private static final WeakHashMap>> READ_PROPERTY_RESOLVER_CACHE;
private static final WeakHashMap>> WRITE_PROPERTY_RESOLVER_CACHE;
private static final WeakHashMap>> METHOD_RESOLVER_CACHE;
private static final WeakHashMap> METHOD_PARMTYPES_CACHE;
static {
READ_PROPERTY_RESOLVER_CACHE = (new WeakHashMap>>(10));
WRITE_PROPERTY_RESOLVER_CACHE = (new WeakHashMap>>(10));
METHOD_RESOLVER_CACHE = (new WeakHashMap>>(10));
METHOD_PARMTYPES_CACHE = new WeakHashMap>(10);
}
public PropertyAccessor(char[] property, Object ctx) {
this.property = property;
this.length = property.length;
this.ctx = ctx;
}
public PropertyAccessor(char[] property, Object ctx, VariableResolverFactory resolver, Object thisReference) {
this.length = (this.property = property).length;
this.ctx = ctx;
this.variableFactory = resolver;
this.thisReference = thisReference;
}
public PropertyAccessor(char[] property, Object ctx, Object thisRef, VariableResolverFactory resolver, Object thisReference) {
this.length = (this.property = property).length;
this.ctx = ctx;
this.thisReference = thisRef;
this.variableFactory = resolver;
this.thisReference = thisReference;
}
public PropertyAccessor(VariableResolverFactory resolver, Object thisReference) {
this.variableFactory = resolver;
this.thisReference = thisReference;
}
public PropertyAccessor(char[] property, int offset, int end, Object ctx, VariableResolverFactory resolver) {
this.property = property;
this.cursor = offset;
this.length = end;
this.ctx = ctx;
this.variableFactory = resolver;
}
public PropertyAccessor(String property, Object ctx) {
this.length = (this.property = property.toCharArray()).length;
this.ctx = ctx;
}
public static Object get(String property, Object ctx) {
return new PropertyAccessor(property, ctx).get();
}
public static Object get(char[] property, Object ctx, VariableResolverFactory resolver, Object thisReference) {
return new PropertyAccessor(property, ctx, resolver, thisReference).get();
}
public static Object get(char[] property, int offset, int end, Object ctx, VariableResolverFactory resolver) {
return new PropertyAccessor(property, offset, end, ctx, resolver).get();
}
public static Object get(String property, Object ctx, VariableResolverFactory resolver, Object thisReference) {
return new PropertyAccessor(property.toCharArray(), ctx, resolver, thisReference).get();
}
public static void set(Object ctx, String property, Object value) {
new PropertyAccessor(property, ctx).set(value);
}
public static void set(Object ctx, VariableResolverFactory resolver, String property, Object value) {
new PropertyAccessor(property.toCharArray(), ctx, resolver, null).set(value);
}
private Object get() {
curr = ctx;
try {
if (!MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING) {
while (cursor < length) {
switch (nextToken()) {
case NORM:
curr = getBeanProperty(curr, capture());
break;
case METH:
curr = getMethod(curr, capture());
break;
case COL:
curr = getCollectionProperty(curr, capture());
break;
case WITH:
curr = getWithProperty(curr);
break;
case DONE:
}
if (nullHandle) {
if (curr == null) {
return null;
}
else {
nullHandle = false;
}
}
first = false;
}
return curr;
}
else {
while (cursor < length) {
switch (nextToken()) {
case NORM:
if ((curr = getBeanPropertyAO(curr, capture())) == null && hasNullPropertyHandler()) {
curr = getNullPropertyHandler().getProperty(capture(), ctx, variableFactory);
}
break;
case METH:
if ((curr = getMethod(curr, capture())) == null && hasNullMethodHandler()) {
curr = getNullMethodHandler().getProperty(capture(), ctx, variableFactory);
}
break;
case COL:
curr = getCollectionPropertyAO(curr, capture());
break;
case WITH:
curr = getWithProperty(curr);
break;
case DONE:
}
if (nullHandle) {
if (curr == null) {
return null;
}
else {
nullHandle = false;
}
}
first = false;
}
return curr;
}
}
catch (InvocationTargetException e) {
throw new PropertyAccessException("could not access property", e);
}
catch (IllegalAccessException e) {
throw new PropertyAccessException("could not access property", e);
}
catch (IndexOutOfBoundsException e) {
throw new PropertyAccessException("array or collections index out of bounds in property: " + new String(property), e);
}
catch (PropertyAccessException e) {
throw new PropertyAccessException("failed to access property: " + new String(property) + ": " + e.getMessage(), e);
}
catch (CompileException e) {
throw e;
}
catch (NullPointerException e) {
throw new PropertyAccessException("null pointer exception in property: " + new String(property), e);
}
catch (Exception e) {
throw new PropertyAccessException("unknown exception in expression: " + new String(property), e);
}
}
private void set(Object value) {
curr = ctx;
try {
int oLength = length;
length = findAbsoluteLast(property);
if ((curr = get()) == null)
throw new PropertyAccessException("cannot bind to null context: " + new String(property));
length = oLength;
if (nextToken() == COL) {
int start = ++cursor;
whiteSpaceSkip();
if (cursor == length || scanTo(']'))
throw new PropertyAccessException("unterminated '['");
String ex = new String(property, start, cursor - start);
if (!MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING) {
if (curr instanceof Map) {
//noinspection unchecked
((Map) curr).put(eval(ex, this.ctx, this.variableFactory), value);
}
else if (curr instanceof List) {
//noinspection unchecked
((List) curr).set(eval(ex, this.ctx, this.variableFactory, Integer.class), value);
}
else if (hasPropertyHandler(curr.getClass())) {
getPropertyHandler(curr.getClass()).setProperty(ex, ctx, variableFactory, value);
}
else if (curr.getClass().isArray()) {
Array.set(curr, eval(ex, this.ctx, this.variableFactory, Integer.class), convert(value, getBaseComponentType(curr.getClass())));
}
else {
throw new PropertyAccessException("cannot bind to collection property: " + new String(property) + ": not a recognized collection type: " + ctx.getClass());
}
return;
}
else {
notifySetListeners(ctx, ex, variableFactory, value);
if (curr instanceof Map) {
//noinspection unchecked
if (hasPropertyHandler(Map.class))
getPropertyHandler(Map.class).setProperty(ex, curr, variableFactory, value);
else
((Map) curr).put(eval(ex, this.ctx, this.variableFactory), value);
}
else if (curr instanceof List) {
//noinspection unchecked
if (hasPropertyHandler(List.class))
getPropertyHandler(List.class).setProperty(ex, curr, variableFactory, value);
else
((List) curr).set(eval(ex, this.ctx, this.variableFactory, Integer.class), value);
}
else if (curr.getClass().isArray()) {
if (hasPropertyHandler(Array.class))
getPropertyHandler(Array.class).setProperty(ex, curr, variableFactory, value);
else
Array.set(curr, eval(ex, this.ctx, this.variableFactory, Integer.class), convert(value, getBaseComponentType(curr.getClass())));
}
else if (hasPropertyHandler(curr.getClass())) {
getPropertyHandler(curr.getClass()).setProperty(ex, curr, variableFactory, value);
}
else {
throw new PropertyAccessException("cannot bind to collection property: " + new String(property) + ": not a recognized collection type: " + ctx.getClass());
}
return;
}
}
else if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(curr.getClass())) {
getPropertyHandler(curr.getClass()).setProperty(capture(), curr, variableFactory, value);
return;
}
String tk = capture();
Member member = checkWriteCache(curr.getClass(), tk == null ? 0 : tk.hashCode());
if (member == null) {
addWriteCache(curr.getClass(), tk.hashCode(),
(member = value != null ? getFieldOrWriteAccessor(curr.getClass(), tk, value.getClass()) : getFieldOrWriteAccessor(curr.getClass(), tk)));
}
if (member instanceof Method) {
Method meth = (Method) member;
Class[] paramaterTypes = checkParmTypesCache(meth);
if (value != null && !paramaterTypes[0].isAssignableFrom(value.getClass())) {
if (!canConvert(paramaterTypes[0], value.getClass())) {
throw new ConversionException("cannot convert type: "
+ value.getClass() + ": to " + meth.getParameterTypes()[0]);
}
meth.invoke(curr, convert(value, paramaterTypes[0]));
}
else {
meth.invoke(curr, value);
}
}
else if (member != null) {
Field fld = (Field) member;
if (value != null && !fld.getType().isAssignableFrom(value.getClass())) {
if (!canConvert(fld.getType(), value.getClass())) {
throw new ConversionException("cannot convert type: "
+ value.getClass() + ": to " + fld.getType());
}
fld.set(curr, convert(value, fld.getType()));
}
else {
fld.set(curr, value);
}
}
else if (curr instanceof Map) {
//noinspection unchecked
((Map) curr).put(eval(tk, this.ctx, this.variableFactory), value);
}
else {
throw new PropertyAccessException("could not access/write property (" + tk + ") in: "
+ (curr == null ? "Unknown" : curr.getClass().getName()));
}
}
catch (InvocationTargetException e) {
throw new PropertyAccessException("could not access property", e);
}
catch (IllegalAccessException e) {
throw new PropertyAccessException("could not access property", e);
}
}
private int nextToken() {
switch (property[start = cursor]) {
case '[':
return COL;
case '.':
// ++cursor;
while (cursor < length && isWhitespace(property[cursor])) cursor++;
if ((start + 1) != length) {
switch (property[cursor = ++start]) {
case '?':
cursor = ++start;
nullHandle = true;
break;
case '{':
return WITH;
}
}
}
while (cursor < length && isWhitespace(property[cursor])) cursor++;
start = cursor;
//noinspection StatementWithEmptyBody
while (++cursor < length && isJavaIdentifierPart(property[cursor])) ;
if (cursor < length) {
while (isWhitespace(property[cursor])) cursor++;
switch (property[cursor]) {
case '[':
return COL;
case '(':
return METH;
default:
return 0;
}
}
return 0;
}
private String capture() {
return new String(property, start, trimLeft(cursor) - start);
}
protected int trimLeft(int pos) {
while (pos > 0 && isWhitespace(property[pos - 1])) pos--;
return pos;
}
public static void clearPropertyResolverCache() {
READ_PROPERTY_RESOLVER_CACHE.clear();
WRITE_PROPERTY_RESOLVER_CACHE.clear();
METHOD_RESOLVER_CACHE.clear();
}
public static void reportCacheSizes() {
System.out.println("read property cache: " + READ_PROPERTY_RESOLVER_CACHE.size());
for (Class cls : READ_PROPERTY_RESOLVER_CACHE.keySet()) {
System.out.println(" [" + cls.getName() + "]: " + READ_PROPERTY_RESOLVER_CACHE.get(cls).size() + " entries.");
}
System.out.println("write property cache: " + WRITE_PROPERTY_RESOLVER_CACHE.size());
for (Class cls : WRITE_PROPERTY_RESOLVER_CACHE.keySet()) {
System.out.println(" [" + cls.getName() + "]: " + WRITE_PROPERTY_RESOLVER_CACHE.get(cls).size() + " entries.");
}
System.out.println("method cache: " + METHOD_RESOLVER_CACHE.size());
for (Class cls : METHOD_RESOLVER_CACHE.keySet()) {
System.out.println(" [" + cls.getName() + "]: " + METHOD_RESOLVER_CACHE.get(cls).size() + " entries.");
}
}
private static void addReadCache(Class cls, Integer property, Member member) {
synchronized (READ_PROPERTY_RESOLVER_CACHE) {
WeakHashMap> nestedMap = READ_PROPERTY_RESOLVER_CACHE.get(cls);
if (nestedMap == null) {
READ_PROPERTY_RESOLVER_CACHE.put(cls, nestedMap = new WeakHashMap>());
}
nestedMap.put(property, new WeakReference(member));
}
}
private static Member checkReadCache(Class cls, Integer property) {
WeakHashMap> map = READ_PROPERTY_RESOLVER_CACHE.get(cls);
if (map != null) {
WeakReference member = map.get(property);
if (member != null) return member.get();
}
return null;
}
private static void addWriteCache(Class cls, Integer property, Member member) {
synchronized (WRITE_PROPERTY_RESOLVER_CACHE) {
WeakHashMap> map = WRITE_PROPERTY_RESOLVER_CACHE.get(cls);
if (map == null) {
WRITE_PROPERTY_RESOLVER_CACHE.put(cls, map = new WeakHashMap>());
}
map.put(property, new WeakReference(member));
}
}
private static Member checkWriteCache(Class cls, Integer property) {
Map> map = WRITE_PROPERTY_RESOLVER_CACHE.get(cls);
if (map != null) {
WeakReference member = map.get(property);
if (member != null) return member.get();
}
return null;
}
public static Class[] checkParmTypesCache(Method member) {
WeakReference pt = METHOD_PARMTYPES_CACHE.get(member);
Class[] ret;
if (pt == null || (ret = pt.get()) == null) {
METHOD_PARMTYPES_CACHE.put(member, pt = new WeakReference