/// <summary> /// Retrieves the value of the expression /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Evaluated expression value</returns> public override ExpressionValue Evaluate(IEvaluationContext evalContext) { var cond = Condition.Evaluate(evalContext); if (Condition.EvaluationError != null) { EvaluationError = Condition.EvaluationError; return(ExpressionValue.Error); } if (cond.AsBool()) { var trueValue = TrueExpression.Evaluate(evalContext); if (TrueExpression.EvaluationError == null) { return(trueValue); } EvaluationError = TrueExpression.EvaluationError; return(ExpressionValue.Error); } var falseValue = FalseExpression.Evaluate(evalContext); if (FalseExpression.EvaluationError == null) { return(falseValue); } EvaluationError = FalseExpression.EvaluationError; return(ExpressionValue.Error); }
/// <summary> /// Retrieves the value of the expression /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Evaluated expression value</returns> public override ushort Evaluate(IEvaluationContext evalContext) { var cond = Condition.Evaluate(evalContext); if (Condition.EvaluationError != null) { EvaluationError = Condition.EvaluationError; return(0); } if (cond != 0) { var trueValue = TrueExpression.Evaluate(evalContext); if (TrueExpression.EvaluationError == null) { return(trueValue); } EvaluationError = TrueExpression.EvaluationError; return(0); } var falseValue = FalseExpression.Evaluate(evalContext); if (FalseExpression.EvaluationError == null) { return(falseValue); } EvaluationError = FalseExpression.EvaluationError; return(0); }
public override void Compile(ICompiler cmp, bool reverse) { int gid = group.Number; LinkRef tail = cmp.NewLink(); if (FalseExpression == null) { // IfDefined :1 // <yes_exp> // 1: <tail> cmp.EmitIfDefined(gid, tail); TrueExpression.Compile(cmp, reverse); } else { // IfDefined :1 // <yes_expr> // Jump :2 // 1: <no_expr> // 2: <tail> LinkRef false_expr = cmp.NewLink(); cmp.EmitIfDefined(gid, false_expr); TrueExpression.Compile(cmp, reverse); cmp.EmitJump(tail); cmp.ResolveLink(false_expr); FalseExpression.Compile(cmp, reverse); } cmp.ResolveLink(tail); }
public override void SetParent(Expression parent) { Parent = parent; Condition.SetParent(this); TrueExpression.SetParent(this); FalseExpression.SetParent(this); }
public override IEnumerable <BindingParserNode> EnumerateNodes() { return (base.EnumerateNodes() .Concat(ConditionExpression.EnumerateNodes()) .Concat(TrueExpression.EnumerateNodes()) .Concat(FalseExpression.EnumerateNodes())); }
public override bool IsEquivalentTo(AstNode otherNode) { var otherConditional = otherNode as Conditional; return(otherConditional != null && Condition.IsEquivalentTo(otherConditional.Condition) && TrueExpression.IsEquivalentTo(otherConditional.TrueExpression) && FalseExpression.IsEquivalentTo(otherConditional.FalseExpression)); }
public override void Clone(JsNode node) { base.Clone(node); var node2 = (JsConditionalExpression)node; node2.Condition = Condition.Clone(); node2.TrueExpression = TrueExpression.Clone(); node2.FalseExpression = FalseExpression.Clone(); }
public override void Walk(PythonWalker walker) { if (walker.Walk(this)) { Test?.Walk(walker); TrueExpression?.Walk(walker); FalseExpression?.Walk(walker); } walker.PostWalk(this); }
public override ExpressionCode GenerateCode() { var stringCode = Condition.GenerateCode().Code; stringCode += " ? " + TrueExpression.GenerateCode().Code; stringCode += " : " + FalseExpression.GenerateCode().Code; return(new ExpressionCode { Code = stringCode, Type = TrueExpression.GenerateCode().Type }); }
protected virtual void VisitWhereNotIn(WhereNotInExpression expression) { IWhereExpression exp = new TrueExpression(); foreach (var value in expression.Values) { exp = new AndAlsoExpression(exp, new WhereNotEqualsExpression(null, expression.FieldName, value)); } this.VisitWhere(exp); }
public override dynamic Evaluate(SymbolTable table) { if (EvaluationExpression.Evaluate(table)) { return(TrueExpression.Evaluate(table)); } else { return(FalseExpression.Evaluate(table)); } }
private Expression FindTrueExpression() { for (int i = 0; i < mExpressions.Count; i++) { if (mExpressions[i].mType == Expression.eType.TYPE_TRUE) { TrueExpression expression = (TrueExpression)mExpressions[i]; return(expression); } } return(null); }
internal override void AppendTo(SqlStringBuilder builder) { builder.Append("CASE WHEN "); TestExpression.AppendTo(builder); builder.Append(" THEN "); TrueExpression.AppendTo(builder); if (FalseExpression != null) { builder.Append(" ELSE "); FalseExpression.AppendTo(builder); } }
public void CreateAndEvaluateTrueExpression() { TrueExpression expression = new TrueExpression(); Assert.IsNotNull(expression); Assert.IsTrue((bool)expression.Value); Machine machine = new Machine(); expression.Evaluate(machine); Assert.AreEqual(1, machine.StackCount); Assert.IsTrue((bool)machine.Pop()); }
public override string ToString() { StringBuilder buf = new StringBuilder(); buf.Append("("); buf.Append(ConditionExpression == null ? DSDefinitions.Keyword.Null : ConditionExpression.ToString()); buf.Append(" ? "); buf.Append(TrueExpression == null ? DSDefinitions.Keyword.Null : TrueExpression.ToString()); buf.Append(" : "); buf.Append(FalseExpression == null ? DSDefinitions.Keyword.Null : FalseExpression.ToString()); buf.Append(")"); return(buf.ToString()); }
public override bool IsComplex() { bool comp = false; if (TrueExpression != null) { comp |= TrueExpression.IsComplex(); } if (FalseExpression != null) { comp |= FalseExpression.IsComplex(); } return(comp | GetFixedWidth() <= 0); }
public override PrimitiveType FindPrimitiveType() { if (TrueExpression != null && FalseExpression != null) { // if the primitive type of both true and false expressions is the same, then // we know the primitive type. Otherwise we do not. PrimitiveType trueType = TrueExpression.FindPrimitiveType(); if (trueType == FalseExpression.FindPrimitiveType()) { return(trueType); } } // nope -- they don't match, so we don't know return(PrimitiveType.Other); }
public override bool IsComplex() { if (group == null) { return(Alternate.IsComplex()); } if (TrueExpression != null && TrueExpression.IsComplex()) { return(true); } if (FalseExpression != null && FalseExpression.IsComplex()) { return(true); } return(GetFixedWidth() <= 0); }
public override bool Equals(object other) { if (null == ConditionExpression || null == TrueExpression || null == FalseExpression) { return(false); } var otherNode = other as InlineConditionalNode; if (null == otherNode) { return(false); } return(ConditionExpression.Equals(otherNode.ConditionExpression) && TrueExpression.Equals(otherNode.TrueExpression) && FalseExpression.Equals(otherNode.FalseExpression)); }
/// <summary> /// Retrieves the value of the expression /// </summary> /// <param name="evalContext">Evaluation context</param> /// <param name="checkOnly"></param> /// <returns>Evaluated expression value</returns> public override ExpressionValue Evaluate(IExpressionEvaluationContext evalContext, bool checkOnly = false) { // --- Check for condition expression errors var cond = Condition.Evaluate(evalContext); if (Condition.EvaluationError != null) { EvaluationError = Condition.EvaluationError; return(ExpressionValue.Error); } if (cond.Type == ExpressionValueType.ByteArray) { EvaluationError = "A byte array cannot be used as a condition"; return(ExpressionValue.Error); } if (checkOnly) { return(ExpressionValue.NonEvaluated); } if (cond.AsBool()) { // --- Condition is true var trueValue = TrueExpression.Evaluate(evalContext); if (TrueExpression.EvaluationError == null) { return(trueValue); } EvaluationError = TrueExpression.EvaluationError; return(ExpressionValue.Error); } // --- Condition is false var falseValue = FalseExpression.Evaluate(evalContext); if (FalseExpression.EvaluationError == null) { return(falseValue); } EvaluationError = FalseExpression.EvaluationError; return(ExpressionValue.Error); }
public override async Task WalkAsync(PythonWalkerAsync walker, CancellationToken cancellationToken = default) { if (await walker.WalkAsync(this, cancellationToken)) { if (Test != null) { await Test.WalkAsync(walker, cancellationToken); } if (TrueExpression != null) { await TrueExpression.WalkAsync(walker, cancellationToken); } if (FalseExpression != null) { await FalseExpression.WalkAsync(walker, cancellationToken); } } await walker.PostWalkAsync(this, cancellationToken); }
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) { TrueExpression.AppendCodeString(res, ast, format); res.Append(this.GetPreceedingWhiteSpace(ast)); res.Append("if"); if (!ast.HasVerbatim) { res.Append(' '); } Test.AppendCodeString(res, ast, format); res.Append(this.GetSecondWhiteSpace(ast)); if (!this.IsIncompleteNode(ast)) { res.Append("else"); if (!ast.HasVerbatim) { res.Append(' '); } FalseExpression.AppendCodeString(res, ast, format); } }
protected override void GenerateInner(CodeGenerator generator) { if (Condition.Precedence > PrecedenceGroup.Ternary) { generator.Write(TokenType.Punctuation, '('); } Condition.Generate(generator); if (Condition.Precedence > PrecedenceGroup.Ternary) { generator.Write(TokenType.Punctuation, ')'); } generator.Write(TokenType.Space, ' '); generator.Write(TokenType.Punctuation, '?'); generator.Write(TokenType.Space, ' '); if (TrueExpression.Precedence >= PrecedenceGroup.Ternary) { generator.Write(TokenType.Punctuation, '('); } TrueExpression.Generate(generator); if (TrueExpression.Precedence >= PrecedenceGroup.Ternary) { generator.Write(TokenType.Punctuation, ')'); } generator.Write(TokenType.Space, ' '); generator.Write(TokenType.Punctuation, ':'); generator.Write(TokenType.Space, ' '); if (FalseExpression.Precedence >= PrecedenceGroup.Ternary) { generator.Write(TokenType.Punctuation, '('); } FalseExpression.Generate(generator); if (FalseExpression.Precedence >= PrecedenceGroup.Ternary) { generator.Write(TokenType.Punctuation, ')'); } }
/// <summary> /// Retrieves the value of the expression /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Evaluated expression value</returns> public override ExpressionValue Evaluate(IExpressionEvaluationContext evalContext) { var cond = Condition.Evaluate(evalContext); if (!cond.IsValid) { return(ExpressionValue.Error); } if (cond.Value != 0) { var result = TrueExpression.Evaluate(evalContext); SuggestTypeOf(TrueExpression); return(result); } else { var result = FalseExpression.Evaluate(evalContext); SuggestTypeOf(FalseExpression); return(result); } }
public override ValueExpression Evaluate(IParserContext context) { bool result = context.ToBoolean(Condition.Evaluate(context).Value); ValueExpression expression = null; if (result) { expression = TrueExpression.Evaluate(context); } else if (FalseExpression != null) { expression = FalseExpression.Evaluate(context); } if (expression is ReturnValueExpression) { return(expression); } return(Exp.NullValue(TokenPosition)); }
protected override CType __GetCType(IIdentifierTypeResolver Resolver) { var TrueType = TrueExpression.GetCachedCType(Resolver); var FalseType = FalseExpression.GetCachedCType(Resolver); if (TrueType == FalseType) { return(TrueType); } else { var TrueSize = TrueType.GetSize(null); var FalseSize = FalseType.GetSize(null); if (TrueSize > FalseSize) { return(TrueType); } if (FalseSize > TrueSize) { return(FalseType); } throw (new NotImplementedException()); } }
protected override void VisitTrue(TrueExpression expression) { this.LinqExpression = PredicateBuilder.And(LinqExpression, it => true); }
public override object Eval(RuntimeContext context) { return((bool)Test.Eval(context) ? TrueExpression.Eval(context) : FalseExpression.Eval(context)); }
public override string ToDisplayString() => $"{ConditionExpression.ToDisplayString()}?{TrueExpression.ToDisplayString()}:{FalseExpression.ToDisplayString()}";
protected override void VisitTrue(TrueExpression expression) { ThrowNotSupported(); }
protected abstract void VisitTrue(TrueExpression expression);
protected override void VisitTrue(TrueExpression expression) { clauseText.AppendFormat("(true)"); }