public override ITypedValue GetValueInternal(ExpressionState state)
{
var left = LeftOperand.GetValueInternal(state).Value;
var right = RightOperand.GetValueInternal(state).Value;
if (!(right is IList) || ((IList)right).Count != 2)
{
throw new SpelEvaluationException(RightOperand.StartPosition, SpelMessage.BETWEEN_RIGHT_OPERAND_MUST_BE_TWO_ELEMENT_LIST);
}
var list = (IList)right;
var low = list[0];
var high = list[1];
var comp = state.TypeComparator;
try
{
return(BooleanTypedValue.ForValue(comp.Compare(left, low) >= 0 && comp.Compare(left, high) <= 0));
}
catch (SpelEvaluationException ex)
{
ex.Position = StartPosition;
throw;
}
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
if (_constant != null)
{
return(_constant);
}
else
{
var returnValue = new Dictionary <object, object>();
var childcount = ChildCount;
for (var c = 0; c < childcount; c++)
{
// Allow for key being PropertyOrFieldReference like Indexer on maps
var keyChild = GetChild(c++);
object key = null;
if (keyChild is PropertyOrFieldReference reference)
{
key = reference.Name;
}
else
{
key = keyChild.GetValue(state);
}
var value = GetChild(c).GetValue(state);
returnValue[key] = value;
}
return(new TypedValue(returnValue));
}
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var newValue = _children[1].GetValueInternal(state);
GetChild(0).SetValue(state, newValue.Value);
return(newValue);
}
public void Test_UnaryPlusWithNumberOperand()
{
var expressionState = new ExpressionState(new StandardEvaluationContext());
{
var realLiteral = new RealLiteral("123.00", -1, -1, 123.0);
var o = new OpPlus(-1, -1, realLiteral);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(double), value.TypeDescriptor);
Assert.Equal(typeof(double), value.TypeDescriptor);
Assert.Equal(realLiteral.GetLiteralValue().Value, value.Value);
}
{
var intLiteral = new IntLiteral("123", -1, -1, 123);
var o = new OpPlus(-1, -1, intLiteral);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(int), value.TypeDescriptor);
Assert.Equal(typeof(int), value.TypeDescriptor);
Assert.Equal(intLiteral.GetLiteralValue().Value, value.Value);
}
{
var longLiteral = new LongLiteral("123", -1, -1, 123L);
var o = new OpPlus(-1, -1, longLiteral);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(long), value.TypeDescriptor);
Assert.Equal(typeof(long), value.TypeDescriptor);
Assert.Equal(longLiteral.GetLiteralValue().Value, value.Value);
}
}
public void Test_BinaryPlusWithNumberOperands()
{
var expressionState = new ExpressionState(new StandardEvaluationContext());
{
var n1 = new RealLiteral("123.00", -1, -1, 123.0);
var n2 = new RealLiteral("456.00", -1, -1, 456.0);
var o = new OpPlus(-1, -1, n1, n2);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(double), value.TypeDescriptor);
Assert.Equal(typeof(double), value.TypeDescriptor);
Assert.Equal(123.0d + 456.0d, value.Value);
}
{
var n1 = new LongLiteral("123", -1, -1, 123L);
var n2 = new LongLiteral("456", -1, -1, 456L);
var o = new OpPlus(-1, -1, n1, n2);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(long), value.TypeDescriptor);
Assert.Equal(typeof(long), value.TypeDescriptor);
Assert.Equal(123L + 456L, value.Value);
}
{
var n1 = new IntLiteral("123", -1, -1, 123);
var n2 = new IntLiteral("456", -1, -1, 456);
var o = new OpPlus(-1, -1, n1, n2);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(int), value.TypeDescriptor);
Assert.Equal(typeof(int), value.TypeDescriptor);
Assert.Equal(123 + 456, value.Value);
}
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var value = state.LookupVariable(_name);
if (value == TypedValue.NULL)
{
throw new SpelEvaluationException(StartPosition, SpelMessage.FUNCTION_NOT_DEFINED, _name);
}
if (value.Value is not MethodInfo)
{
// Possibly a static Java method registered as a function
throw new SpelEvaluationException(SpelMessage.FUNCTION_REFERENCE_CANNOT_BE_INVOKED, _name, value.GetType());
}
try
{
return(ExecuteFunctionJLRMethod(state, (MethodInfo)value.Value));
}
catch (SpelEvaluationException ex)
{
ex.Position = StartPosition;
throw;
}
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
if (_name.Equals(_THIS))
{
return(state.GetActiveContextObject());
}
if (_name.Equals(_ROOT))
{
var obj = state.RootContextObject;
_exitTypeDescriptor = CodeFlow.ToDescriptorFromObject(obj.Value);
return(obj);
}
var result = state.LookupVariable(_name);
var value = result.Value;
if (value == null || !value.GetType().IsPublic)
{
// If the type is not public then when generateCode produces a checkcast to it
// then an IllegalAccessError will occur.
// If resorting to Object isn't sufficient, the hierarchy could be traversed for
// the first public type.
_exitTypeDescriptor = "Ljava/lang/Object";
}
else
{
_exitTypeDescriptor = CodeFlow.ToDescriptorFromObject(value);
}
// a null value will mean either the value was null or the variable was not found
return(result);
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
// Possible optimization here if we cache the discovered type reference, but can we do that?
var typeName = (string)_children[0].GetValueInternal(state).Value;
if (typeName == null)
{
throw new InvalidOperationException("No type name");
}
if (!typeName.Contains(".") && char.IsLower(typeName[0]))
{
var tc = SpelTypeCode.ForName(typeName.ToUpper());
if (tc != SpelTypeCode.OBJECT)
{
// It is a primitive type
var atype = MakeArrayIfNecessary(tc.Type);
_exitTypeDescriptor = TypeDescriptor.TYPE;
_type = atype;
return(new TypedValue(atype));
}
}
var clazz = state.FindType(typeName);
clazz = MakeArrayIfNecessary(clazz);
_exitTypeDescriptor = TypeDescriptor.TYPE;
_type = clazz;
return(new TypedValue(clazz));
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var rightOperand = RightOperand;
var left = LeftOperand.GetValueInternal(state);
var right = rightOperand.GetValueInternal(state);
var leftValue = left.Value;
var rightValue = right.Value;
BooleanTypedValue result;
if (!(rightValue is Type))
{
throw new SpelEvaluationException(RightOperand.StartPosition, SpelMessage.INSTANCEOF_OPERATOR_NEEDS_CLASS_OPERAND, rightValue == null ? "null" : rightValue.GetType().FullName);
}
var rightClass = (Type)rightValue;
if (leftValue == null)
{
result = BooleanTypedValue.FALSE; // null is not an instanceof anything
}
else
{
result = BooleanTypedValue.ForValue(rightClass.IsAssignableFrom(leftValue.GetType()));
}
_type = rightClass;
if (rightOperand is TypeReference)
{
// Can only generate bytecode where the right operand is a direct type reference,
// not if it is indirect (for example when right operand is a variable reference)
_exitTypeDescriptor = "Z";
}
return(result);
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var leftOperand = LeftOperand.GetValueInternal(state).Value;
var rightOperand = RightOperand.GetValueInternal(state).Value;
if (IsNumber(leftOperand) && IsNumber(rightOperand))
{
var leftConv = (IConvertible)leftOperand;
var rightConv = (IConvertible)rightOperand;
if (leftOperand is decimal || rightOperand is decimal)
{
var leftVal = leftConv.ToDecimal(CultureInfo.InvariantCulture);
var rightVal = rightConv.ToDecimal(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal / rightVal));
}
else if (leftOperand is double || rightOperand is double)
{
var leftVal = leftConv.ToDouble(CultureInfo.InvariantCulture);
var rightVal = rightConv.ToDouble(CultureInfo.InvariantCulture);
_exitTypeDescriptor = TypeDescriptor.D;
return(new TypedValue(leftVal / rightVal));
}
else if (leftOperand is float || rightOperand is float)
{
var leftVal = leftConv.ToSingle(CultureInfo.InvariantCulture);
var rightVal = rightConv.ToSingle(CultureInfo.InvariantCulture);
_exitTypeDescriptor = TypeDescriptor.F;
return(new TypedValue(leftVal / rightVal));
}
// Look at need to add support for .NET types not present in Java, e.g. ulong, ushort, byte, uint
else if (leftOperand is long || rightOperand is long)
{
var leftVal = leftConv.ToInt64(CultureInfo.InvariantCulture);
var rightVal = rightConv.ToInt64(CultureInfo.InvariantCulture);
_exitTypeDescriptor = TypeDescriptor.J;
return(new TypedValue(leftVal / rightVal));
}
else if (CodeFlow.IsIntegerForNumericOp(leftOperand) || CodeFlow.IsIntegerForNumericOp(rightOperand))
{
var leftVal = leftConv.ToInt32(CultureInfo.InvariantCulture);
var rightVal = rightConv.ToInt32(CultureInfo.InvariantCulture);
_exitTypeDescriptor = TypeDescriptor.I;
return(new TypedValue(leftVal / rightVal));
}
else
{
var leftVal = leftConv.ToDouble(CultureInfo.InvariantCulture);
var rightVal = rightConv.ToDouble(CultureInfo.InvariantCulture);
// Unknown Number subtypes -> best guess is double division
// Look at need to add support for .NET types not present in Java, e.g. ulong, ushort, byte, uint
return(new TypedValue(leftVal / rightVal));
}
}
return(state.Operate(Operation.DIVIDE, leftOperand, rightOperand));
}
public DebuggerTrap(RdlSyntaxNode node, ExpressionState state, OnExpressionBegin expBeginCallback,
OnExpressionEnd expEndCallback)
{
_node = node;
_state = state;
_expBeginCallback = expBeginCallback;
_expEndCallback = expEndCallback;
}
public MethodValueRef(MethodReference mref, ExpressionState state, object[] arguments)
{
_mref = mref;
_evaluationContext = state.EvaluationContext;
_value = state.GetActiveContextObject().Value;
_targetType = state.GetActiveContextObject().TypeDescriptor;
_arguments = arguments;
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var valueRef = GetValueRef(state);
var result = valueRef.GetValue();
_exitTypeDescriptor = _children[_children.Length - 1].ExitDescriptor;
return(result);
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var leftValue = LeftOperand.GetValueInternal(state).Value;
var rightValue = RightOperand.GetValueInternal(state).Value;
_leftActualDescriptor = CodeFlow.ToDescriptorFromObject(leftValue);
_rightActualDescriptor = CodeFlow.ToDescriptorFromObject(rightValue);
return(BooleanTypedValue.ForValue(!EqualityCheck(state.EvaluationContext, leftValue, rightValue)));
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
if (!GetBooleanValue(state, LeftOperand))
{
// no need to evaluate right operand
return(BooleanTypedValue.FALSE);
}
return(BooleanTypedValue.ForValue(GetBooleanValue(state, RightOperand)));
}
public void Test_UnaryPlusWithStringLiteral()
{
var expressionState = new ExpressionState(new StandardEvaluationContext());
var str = new StringLiteral("word", -1, -1, "word");
var o = new OpPlus(-1, -1, str);
Assert.Throws <SpelEvaluationException>(() => o.GetValueInternal(expressionState));
}
private void PopulateUIntArray(ExpressionState state, object newArray, ITypeConverter typeConverter, InlineList initializer)
{
var newIntArray = (uint[])newArray;
for (var i = 0; i < newIntArray.Length; i++)
{
var typedValue = initializer.GetChild(i).GetTypedValue(state);
newIntArray[i] = ExpressionUtils.ToUInt(typeConverter, typedValue);
}
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var leftOp = LeftOperand;
var rightOp = RightOperand;
var leftOperand = leftOp.GetValueInternal(state).Value;
var rightOperand = rightOp.GetValueInternal(state).Value;
if (IsNumber(leftOperand) && IsNumber(rightOperand))
{
var leftConv = (IConvertible)leftOperand;
var rightConv = (IConvertible)rightOperand;
if (leftOperand is decimal)
{
var rightVal = rightConv.ToInt32(CultureInfo.InvariantCulture);
var leftVal = leftConv.ToDouble(CultureInfo.InvariantCulture);
var result = Math.Pow(leftVal, rightVal) as IConvertible;
return(new TypedValue(result.ToDecimal(CultureInfo.InvariantCulture)));
}
// else if (leftNumber instanceof BigInteger) {
// BigInteger leftBigInteger = NumberUtils.convertNumberToTargetClass(leftNumber, typeof(BigInteger));
// return new TypedValue(leftBigInteger.pow(rightNumber.intValue()));
// }
else if (leftOperand is double || rightOperand is double)
{
var rightVal = rightConv.ToDouble(CultureInfo.InvariantCulture);
var leftVal = leftConv.ToDouble(CultureInfo.InvariantCulture);
return(new TypedValue(Math.Pow(leftVal, rightVal)));
}
else if (leftOperand is float || rightOperand is float)
{
var rightVal = rightConv.ToSingle(CultureInfo.InvariantCulture);
var leftVal = leftConv.ToSingle(CultureInfo.InvariantCulture);
return(new TypedValue(Math.Pow(leftVal, rightVal)));
}
var r = rightConv.ToDouble(CultureInfo.InvariantCulture);
var l = leftConv.ToDouble(CultureInfo.InvariantCulture);
var d = Math.Pow(l, r);
var asLong = (long)d;
if (asLong > int.MaxValue || leftOperand is long || rightOperand is long)
{
return(new TypedValue((long)asLong));
}
else
{
return(new TypedValue((int)asLong));
}
}
return(state.Operate(Operation.POWER, leftOperand, rightOperand));
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var leftOperand = LeftOperand.GetValueInternal(state).Value;
var rightOperand = RightOperand.GetValueInternal(state).Value;
if (IsNumber(leftOperand) && IsNumber(rightOperand))
{
var leftNumber = (IConvertible)leftOperand;
var rightNumber = (IConvertible)rightOperand;
if (leftNumber is decimal || rightNumber is decimal)
{
var leftVal = leftNumber.ToDecimal(CultureInfo.InvariantCulture);
var rightVal = rightNumber.ToDecimal(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal % rightVal));
}
else if (leftNumber is double || rightNumber is double)
{
_exitTypeDescriptor = "D";
var leftVal = leftNumber.ToDouble(CultureInfo.InvariantCulture);
var rightVal = rightNumber.ToDouble(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal % rightVal));
}
else if (leftNumber is float || rightNumber is float)
{
_exitTypeDescriptor = "F";
var leftVal = leftNumber.ToSingle(CultureInfo.InvariantCulture);
var rightVal = rightNumber.ToSingle(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal % rightVal));
}
else if (leftNumber is long || rightNumber is long)
{
_exitTypeDescriptor = "J";
var leftVal = leftNumber.ToInt64(CultureInfo.InvariantCulture);
var rightVal = rightNumber.ToInt64(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal % rightVal));
}
else if (CodeFlow.IsIntegerForNumericOp(leftNumber) || CodeFlow.IsIntegerForNumericOp(rightNumber))
{
_exitTypeDescriptor = "I";
var leftVal = leftNumber.ToInt32(CultureInfo.InvariantCulture);
var rightVal = rightNumber.ToInt32(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal % rightVal));
}
else
{
// Unknown Number subtypes -> best guess is double division
var leftVal = leftNumber.ToDouble(CultureInfo.InvariantCulture);
var rightVal = rightNumber.ToDouble(CultureInfo.InvariantCulture);
return(new TypedValue(leftVal % rightVal));
}
}
return(state.Operate(Operation.MODULUS, leftOperand, rightOperand));
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var evaluationContext = state.EvaluationContext;
var value = state.GetActiveContextObject().Value;
var targetType = state.GetActiveContextObject().TypeDescriptor;
var arguments = GetArguments(state);
var result = GetValueInternal(evaluationContext, value, targetType, arguments);
UpdateExitTypeDescriptor(result.Value);
return(result);
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
if (_isArrayConstructor)
{
return(CreateArray(state));
}
else
{
return(CreateNewInstance(state));
}
}
private void PopulateReferenceTypeArray(ExpressionState state, object newArray, ITypeConverter typeConverter, InlineList initializer, Type componentType)
{
var newObjectArray = (object[])newArray;
for (var i = 0; i < newObjectArray.Length; i++)
{
var elementNode = initializer.GetChild(i);
var arrayEntry = elementNode.GetValue(state);
newObjectArray[i] = typeConverter.ConvertValue(arrayEntry, arrayEntry?.GetType(), componentType);
}
}
private TypedValue ExecuteFunctionJLRMethod(ExpressionState state, MethodInfo method)
{
var functionArgs = GetArguments(state);
if (!method.IsVarArgs())
{
var declaredParamCount = method.GetParameters().Length;
if (declaredParamCount != functionArgs.Length)
{
throw new SpelEvaluationException(SpelMessage.INCORRECT_NUMBER_OF_ARGUMENTS_TO_FUNCTION, functionArgs.Length, declaredParamCount);
}
}
if (!method.IsStatic)
{
throw new SpelEvaluationException(StartPosition, SpelMessage.FUNCTION_MUST_BE_STATIC, ClassUtils.GetQualifiedMethodName(method), _name);
}
// Convert arguments if necessary and remap them for varargs if required
var converter = state.EvaluationContext.TypeConverter;
var argumentConversionOccurred = ReflectionHelper.ConvertAllArguments(converter, functionArgs, method);
if (method.IsVarArgs())
{
functionArgs = ReflectionHelper.SetupArgumentsForVarargsInvocation(ClassUtils.GetParameterTypes(method), functionArgs);
}
var compilable = false;
try
{
var result = method.Invoke(method.GetType(), functionArgs);
compilable = !argumentConversionOccurred;
return(new TypedValue(result, result?.GetType() ?? method.ReturnType));
}
catch (Exception ex)
{
throw new SpelEvaluationException(StartPosition, ex, SpelMessage.EXCEPTION_DURING_FUNCTION_CALL, _name, ex.Message);
}
finally
{
if (compilable)
{
_exitTypeDescriptor = CodeFlow.ToDescriptor(method.ReturnType);
_method = method;
}
else
{
_exitTypeDescriptor = null;
_method = null;
}
}
}
private object[] GetArguments(ExpressionState state)
{
// Compute arguments to the function
var arguments = new object[ChildCount];
for (var i = 0; i < arguments.Length; i++)
{
arguments[i] = _children[i].GetValueInternal(state).Value;
}
return(arguments);
}
protected internal override IValueRef GetValueRef(ExpressionState state)
{
var arguments = GetArguments(state);
if (state.GetActiveContextObject().Value == null)
{
ThrowIfNotNullSafe(GetArgumentTypes(arguments));
return(NullValueRef.INSTANCE);
}
return(new MethodValueRef(this, state, arguments));
}
public void Test_BinaryPlusWithStringOperands()
{
var expressionState = new ExpressionState(new StandardEvaluationContext());
var n1 = new StringLiteral("\"foo\"", -1, -1, "\"foo\"");
var n2 = new StringLiteral("\"bar\"", -1, -1, "\"bar\"");
var o = new OpPlus(-1, -1, n1, n2);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(string), value.TypeDescriptor);
Assert.Equal(typeof(string), value.TypeDescriptor);
Assert.Equal("foobar", value.Value);
}
public void Test_BinaryPlusWithRightStringOperand()
{
var expressionState = new ExpressionState(new StandardEvaluationContext());
var n1 = new LongLiteral("123", -1, -1, 123);
var n2 = new StringLiteral("\" is a number\"", -1, -1, "\" is a number\"");
var o = new OpPlus(-1, -1, n1, n2);
var value = o.GetValueInternal(expressionState);
Assert.Equal(typeof(string), value.TypeDescriptor);
Assert.Equal(typeof(string), value.TypeDescriptor);
Assert.Equal("123 is a number", value.Value);
}
private static string ConvertTypedValueToString(ITypedValue value, ExpressionState state)
{
var typeConverter = state.EvaluationContext.TypeConverter;
var typeDescriptor = typeof(string);
if (typeConverter.CanConvert(value.TypeDescriptor, typeDescriptor))
{
var val = typeConverter.ConvertValue(value.Value, value.TypeDescriptor, typeDescriptor);
return(val == null ? "null" : val.ToString());
}
return(value.Value == null ? "null" : value.Value.ToString());
}
private void expr_StackChanged(object sender, EventArgs e)
{
Expression expr = sender as Expression;
ExpressionState state = new ExpressionState()
{
OperatorStack = expr.CurrentOperatorStack,
ValueStack = expr.CurrentValueStack,
Value = expr.CurrentValue
};
_stateOverTime.Add(state);
}
public override ITypedValue GetValueInternal(ExpressionState state)
{
var tv = GetValueInternal(state.GetActiveContextObject(), state.EvaluationContext, state.Configuration.AutoGrowNullReferences);
var accessorToUse = _cachedReadAccessor;
if (accessorToUse is ICompilablePropertyAccessor accessor)
{
var descriptor = ComputeExitDescriptor(tv.Value, accessor.GetPropertyType());
SetExitTypeDescriptor(descriptor);
}
return(tv);
}
