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); }
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)); }