示例#1
0
        public int TransformTernOp(TernOp expr)
        {
            ExtractCILIndex(expr);
            XILInstr xi;

            switch (expr.Operation)
            {
            case TernOp.Kind.Conditional:
                xi = ISet.Select();
                expr.Children[1].Accept(this);
                expr.Children[2].Accept(this);
                expr.Children[0].Accept(this);
                break;

            case TernOp.Kind.Slice:
                xi = ISet.Slice();
                expr.Children[0].Accept(this);
                expr.Children[1].Accept(this);
                expr.Children[2].Accept(this);
                break;

            default: throw new NotImplementedException();
            }

            Emit(xi, expr, 3, expr.ResultType);

            return(0);
        }
        public Expression TransformTernOp(TernOp x)
        {
            switch (x.Operation)
            {
            case TernOp.Kind.Conditional:
            {
                Expression d1 = der(x.Operands[1]).Simplify();
                Expression d2 = der(x.Operands[2]).Simplify();
                if (d1.Equals(d2))
                {
                    return(d1);
                }
                else
                {
                    return(Expression.Conditional(
                               x.Operands[0], d1, d2));
                }
            }

            case TernOp.Kind.Slice:
                throw new NotImplementedException();

            default:
                throw new NotImplementedException();
            }
        }
 public Expression TransformTernOp(TernOp expr)
 {
     if (expr.IsConst())
     {
         object result = expr.Eval(new DefaultEvaluator());
         return(LiteralReference.CreateConstant(result));
     }
     else
     {
         return(expr);
     }
 }
示例#4
0
 /// <summary>
 /// Transforms a ternary expression. The default implementation clones it.
 /// </summary>
 /// <param name="expr">ternary expression</param>
 /// <returns>transformation result</returns>
 public virtual Expression TransformTernOp(TernOp expr)
 {
     return(expr.CloneThis(expr.Children.Select(e => e.Transform(this)).ToArray()));
 }
 public bool TransformTernOp(TernOp expr)
 {
     return(expr.Operands[0].Accept(this) &&
            expr.Operands[1].Accept(this) &&
            expr.Operands[2].Accept(this));
 }
示例#6
0
            public NotateFunc GetNotation(TernOp.Kind op)
            {
                switch (op)
                {
                    case TernOp.Kind.Conditional:
                        return (string[] args) => args[1] + " when " + args[0] + " else " + args[2];

                    case TernOp.Kind.Slice:
                        return (string[] args) => args[0] + "(" + args[1] + " downto " + args[2] + ")";

                    default:
                        throw new NotImplementedException();
                }
            }
示例#7
0
 public EOperatorAssociativity GetOperatorAssociativity(TernOp.Kind op)
 {
     return EOperatorAssociativity.RightAssociative;
 }
示例#8
0
 public int GetOperatorOrder(TernOp.Kind op)
 {
     switch (op)
     {
         case TernOp.Kind.Conditional: return -1;
         case TernOp.Kind.Slice: return -1;
         default: throw new NotImplementedException();
     }
 }
 /// <summary>
 /// Transforms a ternary expression. The default implementation clones it.
 /// </summary>
 /// <param name="expr">ternary expression</param>
 /// <returns>transformation result</returns>
 public virtual Expression TransformTernOp(TernOp expr)
 {
     return expr.CloneThis(expr.Children.Select(e => e.Transform(this)).ToArray());
 }