public static AbstractType EvaluateType(IExpression x, ResolutionContext ctxt)
{
var ev = new ExpressionTypeEvaluation(ctxt);
if (!Debugger.IsAttached)
{
try { return(x.Accept(ev)); }
catch { return(null); }
}
else
{
return(x.Accept(ev));
}
}
public static string Generate(IExpression expression)
{
var visitor = new ExpressionVisitor();
expression.Accept(visitor);
return(visitor.GetFinalValue());
}
public IExpression Simplify(IExpression input)
{
mWasChanged = false;
mCalculatedExpression = ExpressionCloner.Clone(input);
mCalculatedExpression.Accept(this);
return(mCalculatedExpression);
}
public object Evaluate()
{
if (expression == null)
{
throw new ExpressionEvaluatorException("the expression should not be empty or null");
}
object result;
try
{
ExpressionLexer lexer = new ExpressionLexer(expression);
ExpressionParser parser = new ExpressionParser(
new TokenStream(lexer),
context);
ExpressionNode tree = parser.Parse();
ExpressionVisitor visitor = new ExpressionVisitor(context);
IExpression expr = ExpressionBuilder.Build(tree);
expr.Accept(visitor);
result = visitor.EvaluationResult;
}
catch (Exception e) // reports all unexpected exceptions
{
context.ReportError(
String.Format(
"failed to evaluate expression '{0}' : '{1}'",
expression,
e.Message));
result = expression;
}
return(result);
}
public void Compile(IExpression expression)
{
Require.NotNull(expression, "expression");
expression.Accept(new Visitor(this));
if (
(expression.Type.IsValueType || _resolver.Options.ResultType.IsValueType) &&
expression.Type != _resolver.Options.ResultType
) {
try
{
ExtendedConvertToType(expression.Type, _resolver.Options.ResultType, true);
}
catch (Exception ex)
{
throw new ExpressionsException("Cannot convert expression result to expected result type", ExpressionsExceptionType.InvalidExplicitCast, ex);
}
_il.Emit(OpCodes.Box, _resolver.Options.ResultType);
}
else if (expression.Type.IsValueType)
{
_il.Emit(OpCodes.Box, expression.Type);
}
else if (!_resolver.Options.ResultType.IsAssignableFrom(expression.Type))
{
throw new ExpressionsException("Cannot convert expression result to expected result type", ExpressionsExceptionType.TypeMismatch);
}
_il.Emit(OpCodes.Ret);
}
public void Compile(IExpression expression)
{
Require.NotNull(expression, "expression");
expression.Accept(new Visitor(this));
if (
(expression.Type.IsValueType || _resolver.Options.ResultType.IsValueType) &&
expression.Type != _resolver.Options.ResultType
)
{
try
{
ExtendedConvertToType(expression.Type, _resolver.Options.ResultType, true);
}
catch (Exception ex)
{
throw new ExpressionsException("Cannot convert expression result to expected result type", ExpressionsExceptionType.InvalidExplicitCast, ex);
}
_il.Emit(OpCodes.Box, _resolver.Options.ResultType);
}
else if (expression.Type.IsValueType)
{
_il.Emit(OpCodes.Box, expression.Type);
}
else if (!_resolver.Options.ResultType.IsAssignableFrom(expression.Type))
{
throw new ExpressionsException("Cannot convert expression result to expected result type", ExpressionsExceptionType.TypeMismatch);
}
_il.Emit(OpCodes.Ret);
}
protected static TResult GetResultFor(IExpression expression)
{
var visitor = new TSelf();
expression.Accept(visitor);
return(visitor.Result);
}
protected Boolean CheckIfChangedOnceResolved(IExpression expression)
{
var resolver = new CheckIfChangedOnceResolved_IExpressionResolver(this);
expression.Accept(resolver);
return(resolver.Result);
}
private void ProcessPredicateCreationPattern(ILProcessor il, Instruction queryInvocation)
{
MethodReference predicateReference = GetMethodReferenceFromInlinePredicatePattern(queryInvocation);
MethodDefinition predicateMethod = Resolve(predicateReference);
IExpression expression = _optimizer.GetExpression(predicateMethod);
if (expression == null)
{
return;
}
IDictionary <FieldReference, FieldDefinition> fields;
TypeDefinition syntheticPredicate = NewSyntheticPredicateFor(expression, predicateMethod, out fields);
expression.Accept(new UpdateFieldReferences(fields));
_optimizer.OptimizePredicate(syntheticPredicate, predicateMethod, expression);
RemovePreviousInstrunctions(il, queryInvocation, 2);
InjectSyntheticPredicateInstantiation(
queryInvocation,
il,
syntheticPredicate,
fields.Keys,
predicateReference.DeclaringType);
ReplaceByExecuteEnhancedFilter(queryInvocation);
}
private static IList <IFieldRef> CollectAccessedFields(IExpression expression)
{
var fieldCollector = new FieldCollectorVisitor();
expression.Accept(fieldCollector);
return(fieldCollector.Fields);
}
private void VisitAndEncloseIfNecessary(IExpression child, Operator parentOperator)
{
if (child is ExpressionNode on && on.Operator.Precedence < parentOperator.Precedence)
{
stringBuilder.Append("(");
child.Accept(this);
stringBuilder.Append(")");
}
public void VisitFunction(string functionName, IExpression argument)
{
argument.Accept(this);
var argumentValue = m_stack.Pop();
var func = m_functionContext.GetFunction(functionName);
m_stack.Push(func(argumentValue));
}
private void Emit(IExpression expression, Type type)
{
expression.Accept(this);
if (expression.Type != type)
{
_compiler.ExtendedConvertToType(expression.Type, type, false);
}
}
public static bool IsExpressionValid(
Context context,
Scope environment,
IExpression expression)
{
var self = new ExpressionAnalyzer(context, environment);
return(expression.Accept(self));
}
public void Accept(Visitor.VisitorBase visitor)
{
if (visitor.VisitEnter(this))
{
visitor.Visit(this);
inner.Accept(visitor);
}
visitor.VisitLeave(this);
}
public override void Accept(Visitor.VisitorBase visitor)
{
if (visitor.VisitEnter(this))
{
visitor.Visit(this);
innerExpression.Accept(visitor);
}
visitor.VisitLeave(this);
}
public void Accept(IGenericExpressionVisitor visitor)
{
IExpression expressions = Expressions.FirstOrDefault(current => current != null);
if (expressions != null)
{
expressions.Accept(visitor);
}
}
public void Accept(Visitor.VisitorBase visitor)
{
if (visitor.VisitEnter(this))
{
visitor.Visit(this);
expression.Accept(visitor);
}
visitor.VisitLeave(this);
}
public void VisitFunction(string functionName, IExpression argument)
{
argument.Accept(this);
var argumentExpression = m_stack.Pop();
var func = m_callContext.GetFunction(functionName);
m_stack.Push(Expression.Call(func, argumentExpression));
}
public void Accept(Visitor.VisitorBase visitor)
{
if (visitor.VisitEnter(this))
{
left.Accept(visitor);
visitor.Visit(this);
right.Accept(visitor);
}
visitor.VisitLeave(this);
}
public virtual void InjectOptimization(IExpression expr)
{
_editor.AddInterface(TypeRef(typeof (IDb4oEnhancedFilter)));
_builder = _editor.NewPublicMethod(PlatformName(OptimizeQueryMethodName), TypeRef
(typeof (void)), new[] {TypeRef(typeof (IQuery))});
var predicateClass = _editor.Type;
expr.Accept(new SODAExpressionBuilder(this, predicateClass));
_builder.Pop();
_builder.EndMethod();
}
public void VisitBinary(IExpression left, BinaryOperatorType type, IExpression right)
{
left.Accept(this);
var leftExpression = m_stack.Pop();
right.Accept(this);
var rightExpression = m_stack.Pop();
switch (type)
{
case BinaryOperatorType.Add:
m_stack.Push(Expression.Add(leftExpression, rightExpression));
break;
case BinaryOperatorType.Sub:
m_stack.Push(Expression.Subtract(leftExpression, rightExpression));
break;
case BinaryOperatorType.Mul:
m_stack.Push(Expression.Multiply(leftExpression, rightExpression));
break;
case BinaryOperatorType.Div:
m_stack.Push(Expression.Divide(leftExpression, rightExpression));
break;
case BinaryOperatorType.Mod:
m_stack.Push(Expression.Modulo(leftExpression, rightExpression));
break;
case BinaryOperatorType.Pow:
m_stack.Push(Expression.Call(typeof(Math).GetMethod("Pow", new[] { typeof(double) }),
Expression.Convert(leftExpression, typeof(double)), Expression.Convert(rightExpression, typeof(double))));
break;
case BinaryOperatorType.And:
m_stack.Push(Expression.And(Expression.Convert(leftExpression, typeof(int)), Expression.Convert(rightExpression, typeof(int))));
break;
case BinaryOperatorType.Or:
m_stack.Push(Expression.Or(Expression.Convert(leftExpression, typeof(int)), Expression.Convert(rightExpression, typeof(int))));
break;
case BinaryOperatorType.Lsh:
m_stack.Push(Expression.LeftShift(Expression.Convert(leftExpression, typeof(int)), Expression.Convert(rightExpression, typeof(int))));
break;
case BinaryOperatorType.Rsh:
m_stack.Push(Expression.RightShift(Expression.Convert(leftExpression, typeof(int)), Expression.Convert(rightExpression, typeof(int))));
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public bool IsEqual(IExpression firstExpression, IExpression secondExpression)
{
mSecondExpressions.Clear();
firstExpression.Accept(this);
mFirstExpressions = mSecondExpressions;
mSecondExpressions = new List <IExpression>();
secondExpression.Accept(this);
var result = CheckEqualityOfLists();
return(result);
}
private string Decompile(IExpression expression)
{
StringWriter writer = new StringWriter();
IVisitor decompiler = new DecompileVisitor(writer);
expression.Accept(decompiler);
writer.Close();
return(writer.ToString());
}
public virtual void InjectOptimization(IExpression expr)
{
_editor.AddInterface(TypeRef(typeof(IDb4oEnhancedFilter)));
_builder = _editor.NewPublicMethod(PlatformName(OptimizeQueryMethodName), TypeRef
(typeof(void)), new ITypeRef[] { TypeRef(typeof(IQuery)) });
ITypeRef predicateClass = _editor.Type;
expr.Accept(new SODAMethodBuilder.SODAExpressionBuilder(this, predicateClass));
_builder.Pop();
_builder.EndMethod();
}
public void Accept(IGenericExpressionVisitor visitor)
{
if (string.IsNullOrWhiteSpace(Name))
{
expression.Accept(visitor);
}
else
{
visitor.VisitIdentifierExpression(this);
}
}
public void VisitBinary(IExpression left, BinaryOperatorType type, IExpression right)
{
left.Accept(this);
var leftValue = m_stack.Pop();
right.Accept(this);
var rightValue = m_stack.Pop();
switch (type)
{
case BinaryOperatorType.Add:
m_stack.Push(leftValue + rightValue);
break;
case BinaryOperatorType.Sub:
m_stack.Push(leftValue - rightValue);
break;
case BinaryOperatorType.Mul:
m_stack.Push(leftValue * rightValue);
break;
case BinaryOperatorType.Div:
m_stack.Push(leftValue / rightValue);
break;
case BinaryOperatorType.Mod:
m_stack.Push(leftValue % rightValue);
break;
case BinaryOperatorType.Pow:
m_stack.Push(Math.Pow(leftValue, rightValue));
break;
case BinaryOperatorType.And:
m_stack.Push((int)leftValue & (int)rightValue);
break;
case BinaryOperatorType.Or:
m_stack.Push((int)leftValue | (int)rightValue);
break;
case BinaryOperatorType.Lsh:
m_stack.Push((int)leftValue << (int)rightValue);
break;
case BinaryOperatorType.Rsh:
m_stack.Push((int)leftValue >> (int)rightValue);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public override void Accept(ISqlAstVisitor visitor)
{
if (_replaceExpr == null)
{
visitor.Visit(this);
}
else
{
_replaceExpr.Accept(visitor);
}
}
public SlowRowVirtualChannel(IExpression virtualExpression, int virtualParameterId, int slowRowRateInMilliHz,
IParametersSymbolTable symbolTable, ISlowRowStorage <TTime> slowRowStorage, ITimeUtils <TTime> timeUtils)
{
m_virtualParameterId = virtualParameterId;
m_slowRowRateInMilliHz = slowRowRateInMilliHz;
m_timeUtils = timeUtils;
m_context = new SlowRowExpressionContext <TTime>(slowRowStorage);
var compiler = new CompileVisitor(m_context, symbolTable, new DefaultCallContext());
virtualExpression.Accept(compiler);
m_evaluate = compiler.GetCompiledExpression();
}
public SingleLoggedParameterVirtualChannel(IExpression virtualExpression, int virtualParameterId, int loggedParameterId, int loggedParameterFrequencyInMilliHz,
IParametersSymbolTable symbolTable, ISlowRowStorage <TTime> slowRowStorage, ITimeUtils <TTime> timeUtils)
{
m_virtualParameterId = virtualParameterId;
m_loggedParameterFrequencyInMilliHz = loggedParameterFrequencyInMilliHz;
m_timeUtils = timeUtils;
m_context = new SingleValueWithSlowRowExpressionContext <TTime>(slowRowStorage, loggedParameterId);
var compiler = new CompileVisitor(m_context, symbolTable, new DefaultCallContext());
virtualExpression.Accept(compiler);
m_evaluate = compiler.GetCompiledExpression();
}
private void Place(IOperation operation, IExpression expr, Boolean postOperation)
{
if (postOperation)
{
expr.Accept(this);
}
_assigning = true;
expr.Accept(this);
_assigning = false;
var store = ExtractLast();
expr.Accept(this);
_operations.Add(operation);
_operations.Add(store);
if (postOperation)
{
_operations.Add(PopOperation.Instance);
}
}
public void VisitBinary(IExpression left, BinaryOperatorType type, IExpression right)
{
m_stringBuilder.Append("(");
left.Accept(this);
switch (type)
{
case BinaryOperatorType.Add:
m_stringBuilder.Append("+");
break;
case BinaryOperatorType.Sub:
m_stringBuilder.Append("-");
break;
case BinaryOperatorType.Mul:
m_stringBuilder.Append("*");
break;
case BinaryOperatorType.Div:
m_stringBuilder.Append("/");
break;
case BinaryOperatorType.Mod:
m_stringBuilder.Append("%");
break;
case BinaryOperatorType.Pow:
m_stringBuilder.Append("^");
break;
case BinaryOperatorType.And:
m_stringBuilder.Append("&");
break;
case BinaryOperatorType.Or:
m_stringBuilder.Append("|");
break;
case BinaryOperatorType.Lsh:
m_stringBuilder.Append("<<");
break;
case BinaryOperatorType.Rsh:
m_stringBuilder.Append(">>");
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
right.Accept(this);
m_stringBuilder.Append(")");
}
private void Emit(IExpression expression, Type type)
{
expression.Accept(this);
if (expression.Type != type)
_compiler.ExtendedConvertToType(expression.Type, type, false);
}
private void FlattenConcatArguments(List<IExpression> arguments, IExpression argument)
{
var binaryExpression = argument as BinaryExpression;
if (
binaryExpression != null &&
binaryExpression.ExpressionType == ExpressionType.Add
)
{
FlattenConcatArguments(arguments, binaryExpression.Left);
FlattenConcatArguments(arguments, binaryExpression.Right);
}
else
{
arguments.Add(argument.Accept(this));
}
}
public virtual void OptimizeQuery(IExpression expr, IQuery query, object predicate
, INativeClassFactory classSource, IReferenceResolver referenceResolver)
{
expr.Accept(new SODAQueryBuilder.SODAQueryVisitor(query, predicate, classSource,
referenceResolver));
}