mcs/class/System.Core/System.Linq.Expressions/BinaryExpression.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 //
  19 // Authors:
  20 //        Antonello Provenzano  <antonello@deveel.com>
  21 //        Federico Di Gregorio  <fog@initd.org>
  22 //
  23
  24 using System.Reflection;
  25 using System.Text;
  26
  27 namespace System.Linq.Expressions
  28 {
  29     public sealed class BinaryExpression : Expression
  30     {
  31         #region .ctor
  32         internal BinaryExpression (ExpressionType nt, Expression left, Expression right, MethodInfo method, Type type)
  33             : base(nt, type)
  34         {
  35             this.left = left;
  36             this.right = right;
  37             this.method = method;
  38         }
  39
  40         internal BinaryExpression (ExpressionType nt, Expression left, Expression right, Type type)
  41             : this(nt, left, right, null, type)
  42         {
  43         }
  44         #endregion
  45
  46         #region Fields
  47         private Expression left;
  48         private Expression right;
  49         private MethodInfo method;
  50         #endregion
  51
  52         #region Properties
  53         public Expression Left {
  54             get { return left; }
  55         }
  56
  57         public Expression Right {
  58             get { return right; }
  59         }
  60
  61         public MethodInfo Method {
  62             get { return method; }
  63         }
  64
  65         [MonoTODO]
  66         public bool IsLifted {
  67             get { return false; }
  68         }
  69
  70         [MonoTODO]
  71         public bool IsLiftedToNull {
  72             get { return false; }
  73         }
  74         #endregion
  75
  76         #region Internal Methods
  77                 static void AppendFormat (StringBuilder sb, string format, params object [] args)
  78                 {
  79                         sb.AppendFormat (format, args);
  80                 }
  81
  82         internal override void BuildString(StringBuilder builder)
  83         {
  84             switch (NodeType)
  85             {
  86             case ExpressionType.Add:
  87                 AppendFormat (builder, "({0} + {1})", left, right);
  88                 break;
  89
  90             case ExpressionType.AddChecked:
  91                 AppendFormat (builder, "({0} + {1})", left, right);
  92                 break;
  93
  94             // See below for ExpressionType.And.
  95
  96             case ExpressionType.AndAlso:
  97                 AppendFormat (builder, "({0} && {1})", left, right);
  98                 break;
  99
 100             case ExpressionType.ArrayIndex:
 101                 AppendFormat (builder, "{0}[{1}]", left, right);
 102                 break;
 103
 104             case ExpressionType.Coalesce:
 105                 AppendFormat (builder, "({0} ?? {1})", left, right);
 106                 break;
 107
 108             case ExpressionType.Divide:
 109                 AppendFormat (builder, "({0} / {1})", left, right);
 110                 break;
 111
 112             case ExpressionType.Equal:
 113                 AppendFormat (builder, "({0} == {1})", left, right);
 114                 break;
 115
 116             case ExpressionType.ExclusiveOr:
 117                 AppendFormat (builder, "({0} ^ {1})", left, right);
 118                 break;
 119
 120             case ExpressionType.GreaterThan:
 121                 AppendFormat (builder, "({0} > {1})", left, right);
 122                 break;
 123
 124             case ExpressionType.GreaterThanOrEqual:
 125                 AppendFormat (builder, "({0} >= {1})", left, right);
 126                 break;
 127
 128             case ExpressionType.LeftShift:
 129                 AppendFormat (builder, "({0} << {1})", left, right);
 130                 break;
 131
 132             case ExpressionType.LessThan:
 133                 AppendFormat (builder, "({0} < {1})", left, right);
 134                 break;
 135
 136             case ExpressionType.LessThanOrEqual:
 137                 AppendFormat (builder, "({0} <= {1})", left, right);
 138                 break;
 139
 140             case ExpressionType.Modulo:
 141                 AppendFormat (builder, "({0} % {1})", left, right);
 142                 break;
 143
 144             case ExpressionType.Multiply:
 145                 AppendFormat (builder, "({0} * {1})", left, right);
 146                 break;
 147
 148             case ExpressionType.MultiplyChecked:
 149                 AppendFormat (builder, "({0} * {1})", left, right);
 150                 break;
 151
 152             case ExpressionType.NotEqual:
 153                 AppendFormat (builder, "({0} != {1})", left, right);
 154                 break;
 155
 156             // See below for ExpressionType.Or.
 157
 158             case ExpressionType.OrElse:
 159                 AppendFormat (builder, "({0} ^ {1})", left, right);
 160                 break;
 161
 162             case ExpressionType.RightShift:
 163                 AppendFormat (builder, "({0} >> {1})", left, right);
 164                 break;
 165
 166             case ExpressionType.Subtract:
 167                 AppendFormat (builder, "({0} - {1})", left, right);
 168                 break;
 169
 170             case ExpressionType.SubtractChecked:
 171                 AppendFormat (builder, "({0} - {1})", left, right);
 172                 break;
 173
 174             // 'ExpressionType.And' and 'ExpressionType.Or' are special because
 175             // when the arguments' type is a bool the operator changes from '&'
 176             // or '|' to 'And' or 'Or'.
 177             // FIXME: is this correct or it is an error in MS implementation?
 178
 179             case ExpressionType.And:
 180                 if (Type == typeof(bool))
 181                     AppendFormat (builder, "({0} And {1})", left, right);
 182                 else
 183                     AppendFormat (builder, "({0} & {1})", left, right);
 184                 break;
 185
 186             case ExpressionType.Or:
 187                 if (Type == typeof(bool))
 188                     AppendFormat (builder, "({0} Or {1})", left, right);
 189                 else
 190                     AppendFormat (builder, "({0} | {1})", left, right);
 191                 break;
 192             }
 193         }
 194         #endregion
 195     }
 196 }