1 // ---------------------------------------------------------------------------
2 // Copyright (C) 2005 Microsoft Corporation All Rights Reserved
3 // ---------------------------------------------------------------------------
4 
5 #define CODE_ANALYSIS
6 using System.CodeDom;
7 using System.Collections.Generic;
8 using System.Diagnostics.CodeAnalysis;
9 using System.Globalization;
10 using System.Reflection;
11 using System.Workflow.ComponentModel;
12 using System.Workflow.ComponentModel.Compiler;
13 using System.Workflow.Activities.Common;
14 
15 namespace System.Workflow.Activities.Rules
16 {
17     #region ArithmeticLiteral Class
18     internal abstract class ArithmeticLiteral
19     {
20         #region Properties
21         /// <summary>
22         /// The type of the literal
23         /// </summary>
24         internal protected Type m_type;
25 
26         /// <summary>
27         /// Return the name of the type
28         /// </summary>
29         protected virtual string TypeName
30         {
31             get { return m_type.FullName; }
32         }
33 
34         /// <summary>
35         /// Get the boxed literal
36         /// </summary>
37         internal abstract object Value { get; }
38 
39         /// <summary>
40         /// A delegate for literal factory methods
41         /// </summary>
42         /// <param name="literalValue"></param>
43         /// <returns></returns>
LiteralMaker(object literalValue)44         private delegate ArithmeticLiteral LiteralMaker(object literalValue);
45 
46         /// <summary>
47         /// Collection of literal factory methods indexed by type
48         /// </summary>
49         private static Dictionary<Type, LiteralMaker> types = CreateTypesDictionary();
50 
51         /// <summary>
52         /// Group types by characteristics so we can check if operation is allowed
53         /// </summary>
54         [Flags()]
55         private enum TypeFlags
56         {
57             UInt16 = 0x01,
58             Int32 = 0x02,
59             UInt32 = 0x04,
60             Int64 = 0x08,
61             UInt64 = 0x10,
62             Single = 0x20,
63             Double = 0x40,
64             Decimal = 0x80,
65             Boolean = 0x100,
66             String = 0x800,
67             Nullable = 0x10000
68         };
69 
70         /// <summary>
71         /// Collection of TypeFlags for the supported value types indexed by type
72         /// </summary>
73         private static Dictionary<Type, TypeFlags> supportedTypes = CreateSupportedTypesDictionary();
74 
CreateTypesDictionary()75         private static Dictionary<Type, LiteralMaker> CreateTypesDictionary()
76         {
77             // Create the literal class factory delegates
78             Dictionary<Type, LiteralMaker> dictionary = new Dictionary<Type, LiteralMaker>(16);
79             dictionary.Add(typeof(byte), MakeByte);
80             dictionary.Add(typeof(sbyte), MakeSByte);
81             dictionary.Add(typeof(char), MakeChar);
82             dictionary.Add(typeof(short), MakeShort);
83             dictionary.Add(typeof(int), MakeInt);
84             dictionary.Add(typeof(long), MakeLong);
85             dictionary.Add(typeof(ushort), MakeUShort);
86             dictionary.Add(typeof(uint), MakeUInt);
87             dictionary.Add(typeof(ulong), MakeULong);
88             dictionary.Add(typeof(float), MakeFloat);
89             dictionary.Add(typeof(double), MakeDouble);
90             dictionary.Add(typeof(decimal), MakeDecimal);
91             dictionary.Add(typeof(bool), MakeBoolean);
92             dictionary.Add(typeof(string), MakeString);
93 
94             dictionary.Add(typeof(byte?), MakeByte);
95             dictionary.Add(typeof(sbyte?), MakeSByte);
96             dictionary.Add(typeof(char?), MakeChar);
97             dictionary.Add(typeof(short?), MakeShort);
98             dictionary.Add(typeof(int?), MakeInt);
99             dictionary.Add(typeof(long?), MakeLong);
100             dictionary.Add(typeof(ushort?), MakeUShort);
101             dictionary.Add(typeof(uint?), MakeUInt);
102             dictionary.Add(typeof(ulong?), MakeULong);
103             dictionary.Add(typeof(float?), MakeFloat);
104             dictionary.Add(typeof(double?), MakeDouble);
105             dictionary.Add(typeof(decimal?), MakeDecimal);
106             dictionary.Add(typeof(bool?), MakeBoolean);
107             return dictionary;
108         }
109 
CreateSupportedTypesDictionary()110         static private Dictionary<Type, TypeFlags> CreateSupportedTypesDictionary()
111         {
112             Dictionary<Type, TypeFlags> dictionary = new Dictionary<Type, TypeFlags>(26);
113             dictionary.Add(typeof(byte), TypeFlags.UInt16);
114             dictionary.Add(typeof(byte?), TypeFlags.Nullable | TypeFlags.UInt16);
115             dictionary.Add(typeof(sbyte), TypeFlags.Int32);
116             dictionary.Add(typeof(sbyte?), TypeFlags.Nullable | TypeFlags.Int32);
117             dictionary.Add(typeof(char), TypeFlags.UInt16);
118             dictionary.Add(typeof(char?), TypeFlags.Nullable | TypeFlags.UInt16);
119             dictionary.Add(typeof(short), TypeFlags.Int32);
120             dictionary.Add(typeof(short?), TypeFlags.Nullable | TypeFlags.Int32);
121             dictionary.Add(typeof(int), TypeFlags.Int32);
122             dictionary.Add(typeof(int?), TypeFlags.Nullable | TypeFlags.Int32);
123             dictionary.Add(typeof(long), TypeFlags.Int64);
124             dictionary.Add(typeof(long?), TypeFlags.Nullable | TypeFlags.Int64);
125             dictionary.Add(typeof(ushort), TypeFlags.UInt16);
126             dictionary.Add(typeof(ushort?), TypeFlags.Nullable | TypeFlags.UInt16);
127             dictionary.Add(typeof(uint), TypeFlags.UInt32);
128             dictionary.Add(typeof(uint?), TypeFlags.Nullable | TypeFlags.UInt32);
129             dictionary.Add(typeof(ulong), TypeFlags.UInt64);
130             dictionary.Add(typeof(ulong?), TypeFlags.Nullable | TypeFlags.UInt64);
131             dictionary.Add(typeof(float), TypeFlags.Single);
132             dictionary.Add(typeof(float?), TypeFlags.Nullable | TypeFlags.Single);
133             dictionary.Add(typeof(double), TypeFlags.Double);
134             dictionary.Add(typeof(double?), TypeFlags.Nullable | TypeFlags.Double);
135             dictionary.Add(typeof(decimal), TypeFlags.Decimal);
136             dictionary.Add(typeof(decimal?), TypeFlags.Nullable | TypeFlags.Decimal);
137             dictionary.Add(typeof(bool), TypeFlags.Boolean);
138             dictionary.Add(typeof(bool?), TypeFlags.Nullable | TypeFlags.Boolean);
139             dictionary.Add(typeof(string), TypeFlags.String);
140             return dictionary;
141         }
142         #endregion
143 
144         #region Factory Methods
MakeLiteral(Type literalType, object literalValue)145         internal static ArithmeticLiteral MakeLiteral(Type literalType, object literalValue)
146         {
147             LiteralMaker f;
148             if (literalValue == null)
149                 return new NullArithmeticLiteral(literalType);
150             return (types.TryGetValue(literalType, out f)) ? f(literalValue) : null;
151         }
152 
153         /// <summary>
154         /// Factory function for a byte type
155         /// </summary>
156         /// <param name="literalValue"></param>
157         /// <returns></returns>
MakeByte(object literalValue)158         private static ArithmeticLiteral MakeByte(object literalValue)
159         {
160             return new UShortArithmeticLiteral((byte)literalValue);
161         }
162 
163         /// <summary>
164         /// Factory function for a sbyte type
165         /// </summary>
166         /// <param name="literalValue"></param>
167         /// <returns></returns>
MakeSByte(object literalValue)168         private static ArithmeticLiteral MakeSByte(object literalValue)
169         {
170             return new IntArithmeticLiteral((sbyte)literalValue);
171         }
172 
173         /// <summary>
174         /// Factory function for a char type
175         /// </summary>
176         /// <param name="literalValue"></param>
177         /// <returns></returns>
MakeChar(object literalValue)178         private static ArithmeticLiteral MakeChar(object literalValue)
179         {
180             char c = (char)literalValue;
181             return new CharArithmeticLiteral(c);
182         }
183 
184         /// <summary>
185         /// Factory function for a decimal type
186         /// </summary>
187         /// <param name="literalValue"></param>
188         /// <returns></returns>
MakeDecimal(object literalValue)189         private static ArithmeticLiteral MakeDecimal(object literalValue)
190         {
191             return new DecimalArithmeticLiteral((decimal)literalValue);
192         }
193 
194         /// <summary>
195         /// Factory function for an Int16 type
196         /// </summary>
197         /// <param name="literalValue"></param>
198         /// <returns></returns>
MakeShort(object literalValue)199         private static ArithmeticLiteral MakeShort(object literalValue)
200         {
201             return new IntArithmeticLiteral((short)literalValue);
202         }
203 
204         /// <summary>
205         /// Factory function for an Int32 type
206         /// </summary>
207         /// <param name="literalValue"></param>
208         /// <returns></returns>
MakeInt(object literalValue)209         private static ArithmeticLiteral MakeInt(object literalValue)
210         {
211             return new IntArithmeticLiteral((int)literalValue);
212         }
213 
214         /// <summary>
215         /// Factory function for an Int64 type
216         /// </summary>
217         /// <param name="literalValue"></param>
218         /// <returns></returns>
MakeLong(object literalValue)219         private static ArithmeticLiteral MakeLong(object literalValue)
220         {
221             return new LongArithmeticLiteral((long)literalValue);
222         }
223 
224         /// <summary>
225         /// Factory function for an UInt16 type
226         /// </summary>
227         /// <param name="literalValue"></param>
228         /// <returns></returns>
MakeUShort(object literalValue)229         private static ArithmeticLiteral MakeUShort(object literalValue)
230         {
231             return new UShortArithmeticLiteral((ushort)literalValue);
232         }
233 
234         /// <summary>
235         /// Factory function for an UInt32 type
236         /// </summary>
237         /// <param name="literalValue"></param>
238         /// <returns></returns>
MakeUInt(object literalValue)239         private static ArithmeticLiteral MakeUInt(object literalValue)
240         {
241             return new UIntArithmeticLiteral((uint)literalValue);
242         }
243 
244         /// <summary>
245         /// Factory function for an UInt64 type
246         /// </summary>
247         /// <param name="literalValue"></param>
248         /// <returns></returns>
MakeULong(object literalValue)249         private static ArithmeticLiteral MakeULong(object literalValue)
250         {
251             return new ULongArithmeticLiteral((ulong)literalValue);
252         }
253 
254         /// <summary>
255         /// Factory function for a float type
256         /// </summary>
257         /// <param name="literalValue"></param>
258         /// <returns></returns>
MakeFloat(object literalValue)259         private static ArithmeticLiteral MakeFloat(object literalValue)
260         {
261             return new FloatArithmeticLiteral((float)literalValue);
262         }
263 
264         /// <summary>
265         /// Factory function for a double type
266         /// </summary>
267         /// <param name="literalValue"></param>
268         /// <returns></returns>
MakeDouble(object literalValue)269         private static ArithmeticLiteral MakeDouble(object literalValue)
270         {
271             return new DoubleArithmeticLiteral((double)literalValue);
272         }
273 
274         /// <summary>
275         /// Factory function for a bool type
276         /// </summary>
277         /// <param name="literalValue"></param>
278         /// <returns></returns>
MakeBoolean(object literalValue)279         private static ArithmeticLiteral MakeBoolean(object literalValue)
280         {
281             return new BooleanArithmeticLiteral((bool)literalValue);
282         }
283 
284         /// <summary>
285         /// Factory function for a String type
286         /// </summary>
287         /// <param name="literalValue"></param>
288         /// <returns></returns>
MakeString(object literalValue)289         private static ArithmeticLiteral MakeString(object literalValue)
290         {
291             return new StringArithmeticLiteral(literalValue.ToString());
292         }
293         #endregion
294 
295         #region Type Checking Methods
296 
ResultType( CodeBinaryOperatorType operation, Type lhs, CodeExpression lhsExpression, Type rhs, CodeExpression rhsExpression, RuleValidation validator, out ValidationError error)297         internal static RuleBinaryExpressionInfo ResultType(
298             CodeBinaryOperatorType operation,
299             Type lhs,
300             CodeExpression lhsExpression,
301             Type rhs,
302             CodeExpression rhsExpression,
303             RuleValidation validator,
304             out ValidationError error)
305         {
306             // do we support the types natively?
307             TypeFlags lhsType, rhsType;
308             if (supportedTypes.TryGetValue(lhs, out lhsType) && supportedTypes.TryGetValue(rhs, out rhsType))
309             {
310                 Type resultType = ResultType(operation, lhsType, rhsType);
311                 if (resultType != null)
312                 {
313                     error = null;
314                     return new RuleBinaryExpressionInfo(lhs, rhs, resultType);
315                 }
316                 else
317                 {
318                     string message = string.Format(CultureInfo.CurrentCulture, Messages.ArithOpBadTypes, operation.ToString(),
319                         (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs),
320                         (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs));
321                     error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
322                     return null;
323                 }
324             }
325             else
326             {
327                 // not natively supported, see if user overrides operator
328                 MethodInfo opOverload = Literal.MapOperatorToMethod(operation, lhs, lhsExpression, rhs, rhsExpression, validator, out error);
329                 if (opOverload != null)
330                     return new RuleBinaryExpressionInfo(lhs, rhs, opOverload);
331                 else
332                     return null;
333             }
334         }
335 
336         [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
ResultType(CodeBinaryOperatorType operation, TypeFlags lhsType, TypeFlags rhsType)337         private static Type ResultType(CodeBinaryOperatorType operation, TypeFlags lhsType, TypeFlags rhsType)
338         {
339             TypeFlags combined = (lhsType | rhsType);
340             bool nullable = (combined & TypeFlags.Nullable) == TypeFlags.Nullable;
341             if (nullable) combined ^= TypeFlags.Nullable;
342 
343             switch (operation)
344             {
345                 case CodeBinaryOperatorType.Add:
346                     // string + anything or anything + string always work
347                     if ((lhsType == TypeFlags.String) || (rhsType == TypeFlags.String))
348                         return typeof(string);
349                     goto case CodeBinaryOperatorType.Divide;
350 
351                 case CodeBinaryOperatorType.Divide:
352                 case CodeBinaryOperatorType.Modulus:
353                 case CodeBinaryOperatorType.Multiply:
354                 case CodeBinaryOperatorType.Subtract:
355                     switch (combined)
356                     {
357                         case TypeFlags.Decimal:
358                         case TypeFlags.Decimal | TypeFlags.UInt16:
359                         case TypeFlags.Decimal | TypeFlags.Int32:
360                         case TypeFlags.Decimal | TypeFlags.UInt32:
361                         case TypeFlags.Decimal | TypeFlags.Int64:
362                         case TypeFlags.Decimal | TypeFlags.UInt64:
363                             return (nullable) ? typeof(decimal?) : typeof(decimal);
364                         case TypeFlags.Double:
365                         case TypeFlags.Double | TypeFlags.UInt16:
366                         case TypeFlags.Double | TypeFlags.Int32:
367                         case TypeFlags.Double | TypeFlags.UInt32:
368                         case TypeFlags.Double | TypeFlags.Int64:
369                         case TypeFlags.Double | TypeFlags.UInt64:
370                         case TypeFlags.Double | TypeFlags.Single:
371                             return (nullable) ? typeof(double?) : typeof(double);
372                         case TypeFlags.Single:
373                         case TypeFlags.Single | TypeFlags.UInt16:
374                         case TypeFlags.Single | TypeFlags.Int32:
375                         case TypeFlags.Single | TypeFlags.UInt32:
376                         case TypeFlags.Single | TypeFlags.Int64:
377                         case TypeFlags.Single | TypeFlags.UInt64:
378                             return (nullable) ? typeof(float?) : typeof(float);
379                         case TypeFlags.Int64:
380                         case TypeFlags.Int64 | TypeFlags.UInt16:
381                         case TypeFlags.Int64 | TypeFlags.Int32:
382                         case TypeFlags.Int64 | TypeFlags.UInt32:
383                         case TypeFlags.Int32 | TypeFlags.UInt32:
384                             return (nullable) ? typeof(long?) : typeof(long);
385                         case TypeFlags.UInt64:
386                         case TypeFlags.UInt64 | TypeFlags.UInt16:
387                         case TypeFlags.UInt64 | TypeFlags.UInt32:
388                             return (nullable) ? typeof(ulong?) : typeof(ulong);
389                         case TypeFlags.Int32:
390                         case TypeFlags.UInt16:
391                         case TypeFlags.Int32 | TypeFlags.UInt16:
392                             return (nullable) ? typeof(int?) : typeof(int);
393                         case TypeFlags.UInt32:
394                         case TypeFlags.UInt32 | TypeFlags.UInt16:
395                             return (nullable) ? typeof(uint?) : typeof(uint);
396                     }
397                     break;
398 
399                 case CodeBinaryOperatorType.BitwiseAnd:
400                 case CodeBinaryOperatorType.BitwiseOr:
401                     switch (combined)
402                     {
403                         case TypeFlags.Int64:
404                         case TypeFlags.Int64 | TypeFlags.UInt16:
405                         case TypeFlags.Int64 | TypeFlags.Int32:
406                         case TypeFlags.Int64 | TypeFlags.UInt32:
407                         case TypeFlags.Int32 | TypeFlags.UInt32:
408                             return (nullable) ? typeof(long?) : typeof(long);
409                         case TypeFlags.UInt64:
410                         case TypeFlags.UInt64 | TypeFlags.UInt16:
411                         case TypeFlags.UInt64 | TypeFlags.UInt32:
412                             return (nullable) ? typeof(ulong?) : typeof(ulong);
413                         case TypeFlags.Int32:
414                         case TypeFlags.UInt16:
415                         case TypeFlags.Int32 | TypeFlags.UInt16:
416                             return (nullable) ? typeof(int?) : typeof(int);
417                         case TypeFlags.UInt32:
418                         case TypeFlags.UInt32 | TypeFlags.UInt16:
419                             return (nullable) ? typeof(uint?) : typeof(uint);
420                         case TypeFlags.Boolean:
421                             return (nullable) ? typeof(bool?) : typeof(bool);
422                     }
423                     break;
424             }
425             return null;
426         }
427         #endregion
428 
429         #region Value Type Dispatch Methods
Add(ArithmeticLiteral v)430         internal virtual object Add(ArithmeticLiteral v)
431         {
432             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.TypeName, CodeBinaryOperatorType.Add, this.TypeName);
433             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.Add, this.m_type);
434         }
Add()435         internal virtual object Add()
436         {
437             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.Add, this.TypeName);
438             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.Add, this.m_type);
439         }
Add(int v)440         internal virtual object Add(int v)
441         {
442             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
443             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
444         }
Add(long v)445         internal virtual object Add(long v)
446         {
447             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
448             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
449         }
Add(char v)450         internal virtual object Add(char v)
451         {
452             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
453             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
454         }
Add(ushort v)455         internal virtual object Add(ushort v)
456         {
457             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
458             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
459         }
Add(uint v)460         internal virtual object Add(uint v)
461         {
462             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
463             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
464         }
Add(ulong v)465         internal virtual object Add(ulong v)
466         {
467             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
468             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
469         }
Add(float v)470         internal virtual object Add(float v)
471         {
472             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
473             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
474         }
Add(double v)475         internal virtual object Add(double v)
476         {
477             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
478             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
479         }
Add(decimal v)480         internal virtual object Add(decimal v)
481         {
482             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
483             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
484         }
Add(bool v)485         internal virtual object Add(bool v)
486         {
487             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
488             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
489         }
Add(string v)490         internal virtual object Add(string v)
491         {
492             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Add, this.TypeName);
493             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Add, this.m_type);
494         }
495 
Subtract(ArithmeticLiteral v)496         internal virtual object Subtract(ArithmeticLiteral v)
497         {
498             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.TypeName, CodeBinaryOperatorType.Subtract, this.TypeName);
499             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.Subtract, this.m_type);
500         }
Subtract()501         internal virtual object Subtract()
502         {
503             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.Subtract, this.TypeName);
504             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.Subtract, this.m_type);
505         }
Subtract(int v)506         internal virtual object Subtract(int v)
507         {
508             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
509             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
510         }
Subtract(long v)511         internal virtual object Subtract(long v)
512         {
513             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
514             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
515         }
Subtract(ushort v)516         internal virtual object Subtract(ushort v)
517         {
518             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
519             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
520         }
Subtract(uint v)521         internal virtual object Subtract(uint v)
522         {
523             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
524             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
525         }
Subtract(ulong v)526         internal virtual object Subtract(ulong v)
527         {
528             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
529             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
530         }
Subtract(float v)531         internal virtual object Subtract(float v)
532         {
533             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
534             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
535         }
Subtract(double v)536         internal virtual object Subtract(double v)
537         {
538             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
539             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
540         }
Subtract(decimal v)541         internal virtual object Subtract(decimal v)
542         {
543             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Subtract, this.TypeName);
544             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Subtract, this.m_type);
545         }
546 
Multiply(ArithmeticLiteral v)547         internal virtual object Multiply(ArithmeticLiteral v)
548         {
549             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.TypeName, CodeBinaryOperatorType.Multiply, this.TypeName);
550             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.Multiply, this.m_type);
551         }
Multiply()552         internal virtual object Multiply()
553         {
554             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.Multiply, this.TypeName);
555             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.Multiply, this.m_type);
556         }
Multiply(int v)557         internal virtual object Multiply(int v)
558         {
559             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
560             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
561         }
Multiply(long v)562         internal virtual object Multiply(long v)
563         {
564             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
565             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
566         }
Multiply(ushort v)567         internal virtual object Multiply(ushort v)
568         {
569             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
570             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
571         }
Multiply(uint v)572         internal virtual object Multiply(uint v)
573         {
574             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
575             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
576         }
Multiply(ulong v)577         internal virtual object Multiply(ulong v)
578         {
579             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
580             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
581         }
Multiply(float v)582         internal virtual object Multiply(float v)
583         {
584             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
585             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
586         }
Multiply(double v)587         internal virtual object Multiply(double v)
588         {
589             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
590             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
591         }
Multiply(decimal v)592         internal virtual object Multiply(decimal v)
593         {
594             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Multiply, this.TypeName);
595             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Multiply, this.m_type);
596         }
597 
Divide(ArithmeticLiteral v)598         internal virtual object Divide(ArithmeticLiteral v)
599         {
600             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.TypeName, CodeBinaryOperatorType.Divide, this.TypeName);
601             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.Divide, this.m_type);
602         }
Divide()603         internal virtual object Divide()
604         {
605             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.Divide, this.TypeName);
606             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.Divide, this.m_type);
607         }
Divide(int v)608         internal virtual object Divide(int v)
609         {
610             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
611             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
612         }
Divide(long v)613         internal virtual object Divide(long v)
614         {
615             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
616             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
617         }
Divide(ushort v)618         internal virtual object Divide(ushort v)
619         {
620             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
621             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
622         }
Divide(uint v)623         internal virtual object Divide(uint v)
624         {
625             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
626             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
627         }
Divide(ulong v)628         internal virtual object Divide(ulong v)
629         {
630             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
631             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
632         }
Divide(float v)633         internal virtual object Divide(float v)
634         {
635             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
636             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
637         }
Divide(double v)638         internal virtual object Divide(double v)
639         {
640             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
641             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
642         }
Divide(decimal v)643         internal virtual object Divide(decimal v)
644         {
645             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Divide, this.TypeName);
646             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Divide, this.m_type);
647         }
648 
Modulus(ArithmeticLiteral v)649         internal virtual object Modulus(ArithmeticLiteral v)
650         {
651             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.m_type, CodeBinaryOperatorType.Modulus, this.TypeName);
652             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.Modulus, this.m_type);
653         }
Modulus()654         internal virtual object Modulus()
655         {
656             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.Modulus, this.TypeName);
657             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.Modulus, this.m_type);
658         }
Modulus(int v)659         internal virtual object Modulus(int v)
660         {
661             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
662             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
663         }
Modulus(long v)664         internal virtual object Modulus(long v)
665         {
666             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
667             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
668         }
Modulus(ushort v)669         internal virtual object Modulus(ushort v)
670         {
671             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
672             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
673         }
Modulus(uint v)674         internal virtual object Modulus(uint v)
675         {
676             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
677             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
678         }
Modulus(ulong v)679         internal virtual object Modulus(ulong v)
680         {
681             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
682             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
683         }
Modulus(float v)684         internal virtual object Modulus(float v)
685         {
686             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
687             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
688         }
Modulus(double v)689         internal virtual object Modulus(double v)
690         {
691             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
692             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
693         }
Modulus(decimal v)694         internal virtual object Modulus(decimal v)
695         {
696             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.Modulus, this.TypeName);
697             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.Modulus, this.m_type);
698         }
699 
BitAnd(ArithmeticLiteral v)700         internal virtual object BitAnd(ArithmeticLiteral v)
701         {
702             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.m_type, CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
703             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.BitwiseAnd, this.m_type);
704         }
BitAnd()705         internal virtual object BitAnd()
706         {
707             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
708             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
709         }
BitAnd(int v)710         internal virtual object BitAnd(int v)
711         {
712             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
713             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
714         }
BitAnd(long v)715         internal virtual object BitAnd(long v)
716         {
717             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
718             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
719         }
BitAnd(ushort v)720         internal virtual object BitAnd(ushort v)
721         {
722             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
723             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
724         }
BitAnd(uint v)725         internal virtual object BitAnd(uint v)
726         {
727             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
728             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
729         }
BitAnd(ulong v)730         internal virtual object BitAnd(ulong v)
731         {
732             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
733             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
734         }
BitAnd(float v)735         internal virtual object BitAnd(float v)
736         {
737             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
738             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
739         }
BitAnd(double v)740         internal virtual object BitAnd(double v)
741         {
742             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
743             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
744         }
BitAnd(decimal v)745         internal virtual object BitAnd(decimal v)
746         {
747             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
748             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
749         }
BitAnd(bool v)750         internal virtual object BitAnd(bool v)
751         {
752             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.TypeName);
753             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseAnd, this.m_type);
754         }
755 
BitOr(ArithmeticLiteral v)756         internal virtual object BitOr(ArithmeticLiteral v)
757         {
758             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.TypeName, CodeBinaryOperatorType.BitwiseOr, this.TypeName);
759             throw new RuleEvaluationIncompatibleTypesException(message, v.m_type, CodeBinaryOperatorType.BitwiseOr, this.m_type);
760         }
BitOr()761         internal virtual object BitOr()
762         {
763             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, Messages.NullValue, CodeBinaryOperatorType.BitwiseOr, this.TypeName);
764             throw new RuleEvaluationIncompatibleTypesException(message, typeof(void), CodeBinaryOperatorType.BitwiseOr, this.m_type);
765         }
BitOr(int v)766         internal virtual object BitOr(int v)
767         {
768             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
769             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
770         }
BitOr(long v)771         internal virtual object BitOr(long v)
772         {
773             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
774             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
775         }
BitOr(ushort v)776         internal virtual object BitOr(ushort v)
777         {
778             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
779             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
780         }
BitOr(uint v)781         internal virtual object BitOr(uint v)
782         {
783             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
784             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
785         }
BitOr(ulong v)786         internal virtual object BitOr(ulong v)
787         {
788             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
789             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
790         }
BitOr(float v)791         internal virtual object BitOr(float v)
792         {
793             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
794             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
795         }
BitOr(double v)796         internal virtual object BitOr(double v)
797         {
798             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
799             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
800         }
BitOr(decimal v)801         internal virtual object BitOr(decimal v)
802         {
803             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
804             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
805         }
BitOr(bool v)806         internal virtual object BitOr(bool v)
807         {
808             string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleArithmeticTypes, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.TypeName);
809             throw new RuleEvaluationIncompatibleTypesException(message, v.GetType(), CodeBinaryOperatorType.BitwiseOr, this.m_type);
810         }
811         #endregion
812     }
813     #endregion
814 
815     #region IntArithmeticLiteral Class
816     internal class IntArithmeticLiteral : ArithmeticLiteral
817     {
818         private int m_value;
IntArithmeticLiteral(int literalValue)819         internal IntArithmeticLiteral(int literalValue)
820         {
821             m_value = literalValue;
822             m_type = typeof(int);
823         }
824 
825         internal override object Value
826         {
827             get { return m_value; }
828         }
829         #region Add
Add(ArithmeticLiteral v)830         internal override object Add(ArithmeticLiteral v)
831         {
832             return v.Add(m_value);
833         }
Add()834         internal override object Add()
835         {
836             return null;
837         }
Add(int v)838         internal override object Add(int v)
839         {
840             return (v + m_value);
841         }
Add(long v)842         internal override object Add(long v)
843         {
844             return (v + m_value);
845         }
Add(char v)846         internal override object Add(char v)
847         {
848             return (v + m_value);
849         }
Add(ushort v)850         internal override object Add(ushort v)
851         {
852             return (v + m_value);
853         }
Add(uint v)854         internal override object Add(uint v)
855         {
856             return (v + m_value);
857         }
Add(ulong v)858         internal override object Add(ulong v)
859         {
860             // this should only happen when using a constant (+ve) int and an ulong
861             // if that's not the case, you get an error
862             return (m_value >= 0) ? (v + (ulong)m_value) : base.Add(v);
863         }
Add(float v)864         internal override object Add(float v)
865         {
866             return (v + m_value);
867         }
Add(double v)868         internal override object Add(double v)
869         {
870             return (v + m_value);
871         }
Add(decimal v)872         internal override object Add(decimal v)
873         {
874             return (v + m_value);
875         }
Add(string v)876         internal override object Add(string v)
877         {
878             return (v + m_value.ToString(CultureInfo.CurrentCulture));
879         }
880         #endregion
881         #region Subtract
Subtract(ArithmeticLiteral v)882         internal override object Subtract(ArithmeticLiteral v)
883         {
884             return v.Subtract(m_value);
885         }
Subtract()886         internal override object Subtract()
887         {
888             return null;
889         }
Subtract(int v)890         internal override object Subtract(int v)
891         {
892             return (v - m_value);
893         }
Subtract(long v)894         internal override object Subtract(long v)
895         {
896             return (v - m_value);
897         }
Subtract(ushort v)898         internal override object Subtract(ushort v)
899         {
900             return (v - m_value);
901         }
Subtract(uint v)902         internal override object Subtract(uint v)
903         {
904             return (v - m_value);
905         }
Subtract(ulong v)906         internal override object Subtract(ulong v)
907         {
908             // this should only happen when using a constant (+ve) int and an ulong
909             // if that's not the case, you get an error
910             return (m_value >= 0) ? (v - (ulong)m_value) : base.Subtract(v);
911         }
Subtract(float v)912         internal override object Subtract(float v)
913         {
914             return (v - m_value);
915         }
Subtract(double v)916         internal override object Subtract(double v)
917         {
918             return (v - m_value);
919         }
Subtract(decimal v)920         internal override object Subtract(decimal v)
921         {
922             return (v - m_value);
923         }
924         #endregion
925         #region Multiply
Multiply(ArithmeticLiteral v)926         internal override object Multiply(ArithmeticLiteral v)
927         {
928             return v.Multiply(m_value);
929         }
Multiply()930         internal override object Multiply()
931         {
932             return null;
933         }
Multiply(int v)934         internal override object Multiply(int v)
935         {
936             return (v * m_value);
937         }
Multiply(long v)938         internal override object Multiply(long v)
939         {
940             return (v * m_value);
941         }
Multiply(ushort v)942         internal override object Multiply(ushort v)
943         {
944             return (v * m_value);
945         }
Multiply(uint v)946         internal override object Multiply(uint v)
947         {
948             return (v * m_value);
949         }
Multiply(ulong v)950         internal override object Multiply(ulong v)
951         {
952             // this should only happen when using a constant (+ve) int and an ulong
953             // if that's not the case, you get an error
954             return (m_value >= 0) ? (v * (ulong)m_value) : base.Multiply(v);
955         }
Multiply(float v)956         internal override object Multiply(float v)
957         {
958             return (v * m_value);
959         }
Multiply(double v)960         internal override object Multiply(double v)
961         {
962             return (v * m_value);
963         }
Multiply(decimal v)964         internal override object Multiply(decimal v)
965         {
966             return (v * m_value);
967         }
968         #endregion
969         #region Divide
Divide(ArithmeticLiteral v)970         internal override object Divide(ArithmeticLiteral v)
971         {
972             return v.Divide(m_value);
973         }
Divide()974         internal override object Divide()
975         {
976             return null;
977         }
Divide(int v)978         internal override object Divide(int v)
979         {
980             return (v / m_value);
981         }
Divide(long v)982         internal override object Divide(long v)
983         {
984             return (v / m_value);
985         }
Divide(ushort v)986         internal override object Divide(ushort v)
987         {
988             return (v / m_value);
989         }
Divide(uint v)990         internal override object Divide(uint v)
991         {
992             return (v / m_value);
993         }
Divide(ulong v)994         internal override object Divide(ulong v)
995         {
996             // this should only happen when using a constant (+ve) int and an ulong
997             // if that's not the case, you get an error
998             return (m_value >= 0) ? (v / (ulong)m_value) : base.Divide(v);
999         }
Divide(float v)1000         internal override object Divide(float v)
1001         {
1002             return (v / m_value);
1003         }
Divide(double v)1004         internal override object Divide(double v)
1005         {
1006             return (v / m_value);
1007         }
Divide(decimal v)1008         internal override object Divide(decimal v)
1009         {
1010             return (v / m_value);
1011         }
1012         #endregion
1013         #region Modulus
Modulus(ArithmeticLiteral v)1014         internal override object Modulus(ArithmeticLiteral v)
1015         {
1016             return v.Modulus(m_value);
1017         }
Modulus()1018         internal override object Modulus()
1019         {
1020             return null;
1021         }
Modulus(int v)1022         internal override object Modulus(int v)
1023         {
1024             return (v % m_value);
1025         }
Modulus(long v)1026         internal override object Modulus(long v)
1027         {
1028             return (v % m_value);
1029         }
Modulus(ushort v)1030         internal override object Modulus(ushort v)
1031         {
1032             return (v % m_value);
1033         }
Modulus(uint v)1034         internal override object Modulus(uint v)
1035         {
1036             return (v % m_value);
1037         }
Modulus(ulong v)1038         internal override object Modulus(ulong v)
1039         {
1040             // this should only happen when using a constant (+ve) int and an ulong
1041             // if that's not the case, you get an error
1042             return (m_value >= 0) ? (v % (ulong)m_value) : base.Modulus(v);
1043         }
Modulus(float v)1044         internal override object Modulus(float v)
1045         {
1046             return (v % m_value);
1047         }
Modulus(double v)1048         internal override object Modulus(double v)
1049         {
1050             return (v % m_value);
1051         }
Modulus(decimal v)1052         internal override object Modulus(decimal v)
1053         {
1054             return (v % m_value);
1055         }
1056         #endregion
1057         #region BitAnd
BitAnd(ArithmeticLiteral v)1058         internal override object BitAnd(ArithmeticLiteral v)
1059         {
1060             return v.BitAnd(m_value);
1061         }
BitAnd()1062         internal override object BitAnd()
1063         {
1064             return null;
1065         }
BitAnd(int v)1066         internal override object BitAnd(int v)
1067         {
1068             return (v & m_value);
1069         }
BitAnd(long v)1070         internal override object BitAnd(long v)
1071         {
1072             return (v & m_value);
1073         }
BitAnd(ushort v)1074         internal override object BitAnd(ushort v)
1075         {
1076             return (v & m_value);
1077         }
BitAnd(uint v)1078         internal override object BitAnd(uint v)
1079         {
1080             return (v & m_value);
1081         }
BitAnd(ulong v)1082         internal override object BitAnd(ulong v)
1083         {
1084             // this should only happen when using a constant (+ve) int and an ulong
1085             // if that's not the case, you get an error
1086             return (m_value >= 0) ? (v & (ulong)m_value) : base.BitAnd(v);
1087         }
1088         #endregion
1089         #region BitOr
BitOr(ArithmeticLiteral v)1090         internal override object BitOr(ArithmeticLiteral v)
1091         {
1092             return v.BitOr(m_value);
1093         }
BitOr()1094         internal override object BitOr()
1095         {
1096             return null;
1097         }
BitOr(int v)1098         internal override object BitOr(int v)
1099         {
1100             return (v | m_value);
1101         }
BitOr(long v)1102         internal override object BitOr(long v)
1103         {
1104             long l = m_value;
1105             return (v | l);
1106         }
BitOr(ushort v)1107         internal override object BitOr(ushort v)
1108         {
1109             return (v | m_value);
1110         }
BitOr(uint v)1111         internal override object BitOr(uint v)
1112         {
1113             long l = m_value;
1114             return (v | l);
1115         }
BitOr(ulong v)1116         internal override object BitOr(ulong v)
1117         {
1118             // this should only happen when using a constant (+ve) int and an ulong
1119             // if that's not the case, you get an error
1120             long l = m_value;
1121             return (l >= 0) ? (v | (ulong)l) : base.BitOr(v);
1122         }
1123         #endregion
1124     }
1125     #endregion
1126 
1127     #region LongArithmeticLiteral Class
1128     internal class LongArithmeticLiteral : ArithmeticLiteral
1129     {
1130         private long m_value;
LongArithmeticLiteral(long literalValue)1131         internal LongArithmeticLiteral(long literalValue)
1132         {
1133             m_value = literalValue;
1134             m_type = typeof(long);
1135         }
1136 
1137         internal override object Value
1138         {
1139             get { return m_value; }
1140         }
1141         #region Add
Add(ArithmeticLiteral v)1142         internal override object Add(ArithmeticLiteral v)
1143         {
1144             return v.Add(m_value);
1145         }
Add()1146         internal override object Add()
1147         {
1148             return null;
1149         }
Add(int v)1150         internal override object Add(int v)
1151         {
1152             return (v + m_value);
1153         }
Add(long v)1154         internal override object Add(long v)
1155         {
1156             return (v + m_value);
1157         }
Add(char v)1158         internal override object Add(char v)
1159         {
1160             return (v + m_value);
1161         }
Add(ushort v)1162         internal override object Add(ushort v)
1163         {
1164             return (v + m_value);
1165         }
Add(uint v)1166         internal override object Add(uint v)
1167         {
1168             return (v + m_value);
1169         }
Add(ulong v)1170         internal override object Add(ulong v)
1171         {
1172             // this should only happen when using a constant (+ve) long and an ulong
1173             // if that's not the case, you get an error
1174             return (m_value >= 0) ? (v + (ulong)m_value) : base.Add(v);
1175         }
Add(float v)1176         internal override object Add(float v)
1177         {
1178             return (v + m_value);
1179         }
Add(double v)1180         internal override object Add(double v)
1181         {
1182             return (v + m_value);
1183         }
Add(decimal v)1184         internal override object Add(decimal v)
1185         {
1186             return (v + m_value);
1187         }
Add(string v)1188         internal override object Add(string v)
1189         {
1190             return (v + m_value.ToString(CultureInfo.CurrentCulture));
1191         }
1192         #endregion
1193         #region Subtract
Subtract(ArithmeticLiteral v)1194         internal override object Subtract(ArithmeticLiteral v)
1195         {
1196             return v.Subtract(m_value);
1197         }
Subtract()1198         internal override object Subtract()
1199         {
1200             return null;
1201         }
Subtract(int v)1202         internal override object Subtract(int v)
1203         {
1204             return (v - m_value);
1205         }
Subtract(long v)1206         internal override object Subtract(long v)
1207         {
1208             return (v - m_value);
1209         }
Subtract(ushort v)1210         internal override object Subtract(ushort v)
1211         {
1212             return (v - m_value);
1213         }
Subtract(uint v)1214         internal override object Subtract(uint v)
1215         {
1216             return (v - m_value);
1217         }
Subtract(ulong v)1218         internal override object Subtract(ulong v)
1219         {
1220             // this should only happen when using a constant (+ve) long and an ulong
1221             // if that's not the case, you get an error
1222             return (m_value >= 0) ? (v - (ulong)m_value) : base.Subtract(v);
1223         }
Subtract(float v)1224         internal override object Subtract(float v)
1225         {
1226             return (v - m_value);
1227         }
Subtract(double v)1228         internal override object Subtract(double v)
1229         {
1230             return (v - m_value);
1231         }
Subtract(decimal v)1232         internal override object Subtract(decimal v)
1233         {
1234             return (v - m_value);
1235         }
1236         #endregion
1237         #region Multiply
Multiply(ArithmeticLiteral v)1238         internal override object Multiply(ArithmeticLiteral v)
1239         {
1240             return v.Multiply(m_value);
1241         }
Multiply()1242         internal override object Multiply()
1243         {
1244             return null;
1245         }
Multiply(int v)1246         internal override object Multiply(int v)
1247         {
1248             return (v * m_value);
1249         }
Multiply(long v)1250         internal override object Multiply(long v)
1251         {
1252             return (v * m_value);
1253         }
Multiply(ushort v)1254         internal override object Multiply(ushort v)
1255         {
1256             return (v * m_value);
1257         }
Multiply(uint v)1258         internal override object Multiply(uint v)
1259         {
1260             return (v * m_value);
1261         }
Multiply(ulong v)1262         internal override object Multiply(ulong v)
1263         {
1264             // this should only happen when using a constant (+ve) long and an ulong
1265             // if that's not the case, you get an error
1266             return (m_value >= 0) ? (v * (ulong)m_value) : base.Multiply(v);
1267         }
Multiply(float v)1268         internal override object Multiply(float v)
1269         {
1270             return (v * m_value);
1271         }
Multiply(double v)1272         internal override object Multiply(double v)
1273         {
1274             return (v * m_value);
1275         }
Multiply(decimal v)1276         internal override object Multiply(decimal v)
1277         {
1278             return (v * m_value);
1279         }
1280         #endregion
1281         #region Divide
Divide(ArithmeticLiteral v)1282         internal override object Divide(ArithmeticLiteral v)
1283         {
1284             return v.Divide(m_value);
1285         }
Divide()1286         internal override object Divide()
1287         {
1288             return null;
1289         }
Divide(int v)1290         internal override object Divide(int v)
1291         {
1292             return (v / m_value);
1293         }
Divide(long v)1294         internal override object Divide(long v)
1295         {
1296             return (v / m_value);
1297         }
Divide(ushort v)1298         internal override object Divide(ushort v)
1299         {
1300             return (v / m_value);
1301         }
Divide(uint v)1302         internal override object Divide(uint v)
1303         {
1304             return (v / m_value);
1305         }
Divide(ulong v)1306         internal override object Divide(ulong v)
1307         {
1308             // this should only happen when using a constant (+ve) long and an ulong
1309             // if that's not the case, you get an error
1310             return (m_value >= 0) ? (v / (ulong)m_value) : base.Divide(v);
1311         }
Divide(float v)1312         internal override object Divide(float v)
1313         {
1314             return (v / m_value);
1315         }
Divide(double v)1316         internal override object Divide(double v)
1317         {
1318             return (v / m_value);
1319         }
Divide(decimal v)1320         internal override object Divide(decimal v)
1321         {
1322             return (v / m_value);
1323         }
1324         #endregion
1325         #region Modulus
Modulus(ArithmeticLiteral v)1326         internal override object Modulus(ArithmeticLiteral v)
1327         {
1328             return v.Modulus(m_value);
1329         }
Modulus()1330         internal override object Modulus()
1331         {
1332             return null;
1333         }
Modulus(int v)1334         internal override object Modulus(int v)
1335         {
1336             return (v % m_value);
1337         }
Modulus(long v)1338         internal override object Modulus(long v)
1339         {
1340             return (v % m_value);
1341         }
Modulus(ushort v)1342         internal override object Modulus(ushort v)
1343         {
1344             return (v % m_value);
1345         }
Modulus(uint v)1346         internal override object Modulus(uint v)
1347         {
1348             return (v % m_value);
1349         }
Modulus(ulong v)1350         internal override object Modulus(ulong v)
1351         {
1352             // this should only happen when using a constant (+ve) long and an ulong
1353             // if that's not the case, you get an error
1354             return (m_value >= 0) ? (v % (ulong)m_value) : base.Modulus(v);
1355         }
Modulus(float v)1356         internal override object Modulus(float v)
1357         {
1358             return (v % m_value);
1359         }
Modulus(double v)1360         internal override object Modulus(double v)
1361         {
1362             return (v % m_value);
1363         }
Modulus(decimal v)1364         internal override object Modulus(decimal v)
1365         {
1366             return (v % m_value);
1367         }
1368         #endregion
1369         #region BitAnd
BitAnd(ArithmeticLiteral v)1370         internal override object BitAnd(ArithmeticLiteral v)
1371         {
1372             return v.BitAnd(m_value);
1373         }
BitAnd()1374         internal override object BitAnd()
1375         {
1376             return null;
1377         }
BitAnd(int v)1378         internal override object BitAnd(int v)
1379         {
1380             return (v & m_value);
1381         }
BitAnd(long v)1382         internal override object BitAnd(long v)
1383         {
1384             return (v & m_value);
1385         }
BitAnd(ushort v)1386         internal override object BitAnd(ushort v)
1387         {
1388             return (v & m_value);
1389         }
BitAnd(uint v)1390         internal override object BitAnd(uint v)
1391         {
1392             return (v & m_value);
1393         }
BitAnd(ulong v)1394         internal override object BitAnd(ulong v)
1395         {
1396             // this should only happen when using a constant (+ve) long and an ulong
1397             // if that's not the case, you get an error
1398             return (m_value >= 0) ? (v & (ulong)m_value) : base.BitAnd(v);
1399         }
1400         #endregion
1401         #region BitOr
BitOr(ArithmeticLiteral v)1402         internal override object BitOr(ArithmeticLiteral v)
1403         {
1404             return v.BitOr(m_value);
1405         }
BitOr()1406         internal override object BitOr()
1407         {
1408             return null;
1409         }
BitOr(int v)1410         internal override object BitOr(int v)
1411         {
1412             long l = v;
1413             return (l | m_value);
1414         }
BitOr(long v)1415         internal override object BitOr(long v)
1416         {
1417             return (v | m_value);
1418         }
BitOr(ushort v)1419         internal override object BitOr(ushort v)
1420         {
1421             return (v | m_value);
1422         }
BitOr(uint v)1423         internal override object BitOr(uint v)
1424         {
1425             return (v | m_value);
1426         }
BitOr(ulong v)1427         internal override object BitOr(ulong v)
1428         {
1429             // this should only happen when using a constant (+ve) long and an ulong
1430             // if that's not the case, you get an error
1431             return (m_value >= 0) ? (v | (ulong)m_value) : base.BitOr(v);
1432         }
1433         #endregion
1434     }
1435     #endregion
1436 
1437     #region CharArithmeticLiteral Class
1438     internal class CharArithmeticLiteral : ArithmeticLiteral
1439     {
1440         private char m_value;
CharArithmeticLiteral(char literalValue)1441         internal CharArithmeticLiteral(char literalValue)
1442         {
1443             m_value = literalValue;
1444             m_type = typeof(char);
1445         }
1446 
1447         internal override object Value
1448         {
1449             get { return m_value; }
1450         }
1451         #region Add
Add(ArithmeticLiteral v)1452         internal override object Add(ArithmeticLiteral v)
1453         {
1454             return v.Add(m_value);
1455         }
Add()1456         internal override object Add()
1457         {
1458             return null;
1459         }
Add(int v)1460         internal override object Add(int v)
1461         {
1462             return (v + m_value);
1463         }
Add(long v)1464         internal override object Add(long v)
1465         {
1466             return (v + m_value);
1467         }
Add(char v)1468         internal override object Add(char v)
1469         {
1470             return (v + m_value);
1471         }
Add(ushort v)1472         internal override object Add(ushort v)
1473         {
1474             return (v + m_value);
1475         }
Add(uint v)1476         internal override object Add(uint v)
1477         {
1478             return (v + m_value);
1479         }
Add(ulong v)1480         internal override object Add(ulong v)
1481         {
1482             return (v + m_value);
1483         }
Add(float v)1484         internal override object Add(float v)
1485         {
1486             return (v + m_value);
1487         }
Add(double v)1488         internal override object Add(double v)
1489         {
1490             return (v + m_value);
1491         }
Add(decimal v)1492         internal override object Add(decimal v)
1493         {
1494             return (v + m_value);
1495         }
Add(string v)1496         internal override object Add(string v)
1497         {
1498             return (v + m_value.ToString(CultureInfo.CurrentCulture));
1499         }
1500         #endregion
1501         #region Subtract
Subtract(ArithmeticLiteral v)1502         internal override object Subtract(ArithmeticLiteral v)
1503         {
1504             return v.Subtract(m_value);
1505         }
Subtract()1506         internal override object Subtract()
1507         {
1508             return null;
1509         }
Subtract(int v)1510         internal override object Subtract(int v)
1511         {
1512             return (v - m_value);
1513         }
Subtract(long v)1514         internal override object Subtract(long v)
1515         {
1516             return (v - m_value);
1517         }
Subtract(ushort v)1518         internal override object Subtract(ushort v)
1519         {
1520             return (v - m_value);
1521         }
Subtract(uint v)1522         internal override object Subtract(uint v)
1523         {
1524             return (v - m_value);
1525         }
Subtract(ulong v)1526         internal override object Subtract(ulong v)
1527         {
1528             return (v - m_value);
1529         }
Subtract(float v)1530         internal override object Subtract(float v)
1531         {
1532             return (v - m_value);
1533         }
Subtract(double v)1534         internal override object Subtract(double v)
1535         {
1536             return (v - m_value);
1537         }
Subtract(decimal v)1538         internal override object Subtract(decimal v)
1539         {
1540             return (v - m_value);
1541         }
1542         #endregion
1543         #region Multiply
Multiply(ArithmeticLiteral v)1544         internal override object Multiply(ArithmeticLiteral v)
1545         {
1546             return v.Multiply(m_value);
1547         }
Multiply()1548         internal override object Multiply()
1549         {
1550             return null;
1551         }
Multiply(int v)1552         internal override object Multiply(int v)
1553         {
1554             return (v * m_value);
1555         }
Multiply(long v)1556         internal override object Multiply(long v)
1557         {
1558             return (v * m_value);
1559         }
Multiply(ushort v)1560         internal override object Multiply(ushort v)
1561         {
1562             return (v * m_value);
1563         }
Multiply(uint v)1564         internal override object Multiply(uint v)
1565         {
1566             return (v * m_value);
1567         }
Multiply(ulong v)1568         internal override object Multiply(ulong v)
1569         {
1570             return (v * m_value);
1571         }
Multiply(float v)1572         internal override object Multiply(float v)
1573         {
1574             return (v * m_value);
1575         }
Multiply(double v)1576         internal override object Multiply(double v)
1577         {
1578             return (v * m_value);
1579         }
Multiply(decimal v)1580         internal override object Multiply(decimal v)
1581         {
1582             return (v * m_value);
1583         }
1584         #endregion
1585         #region Divide
Divide(ArithmeticLiteral v)1586         internal override object Divide(ArithmeticLiteral v)
1587         {
1588             return v.Divide(m_value);
1589         }
Divide()1590         internal override object Divide()
1591         {
1592             return null;
1593         }
Divide(int v)1594         internal override object Divide(int v)
1595         {
1596             return (v / m_value);
1597         }
Divide(long v)1598         internal override object Divide(long v)
1599         {
1600             return (v / m_value);
1601         }
Divide(ushort v)1602         internal override object Divide(ushort v)
1603         {
1604             return (v / m_value);
1605         }
Divide(uint v)1606         internal override object Divide(uint v)
1607         {
1608             return (v / m_value);
1609         }
Divide(ulong v)1610         internal override object Divide(ulong v)
1611         {
1612             return (v / m_value);
1613         }
Divide(float v)1614         internal override object Divide(float v)
1615         {
1616             return (v / m_value);
1617         }
Divide(double v)1618         internal override object Divide(double v)
1619         {
1620             return (v / m_value);
1621         }
Divide(decimal v)1622         internal override object Divide(decimal v)
1623         {
1624             return (v / m_value);
1625         }
1626         #endregion
1627         #region Modulus
Modulus(ArithmeticLiteral v)1628         internal override object Modulus(ArithmeticLiteral v)
1629         {
1630             return v.Modulus(m_value);
1631         }
Modulus()1632         internal override object Modulus()
1633         {
1634             return null;
1635         }
Modulus(int v)1636         internal override object Modulus(int v)
1637         {
1638             return (v % m_value);
1639         }
Modulus(long v)1640         internal override object Modulus(long v)
1641         {
1642             return (v % m_value);
1643         }
Modulus(ushort v)1644         internal override object Modulus(ushort v)
1645         {
1646             return (v % m_value);
1647         }
Modulus(uint v)1648         internal override object Modulus(uint v)
1649         {
1650             return (v % m_value);
1651         }
Modulus(ulong v)1652         internal override object Modulus(ulong v)
1653         {
1654             return (v % m_value);
1655         }
Modulus(float v)1656         internal override object Modulus(float v)
1657         {
1658             return (v % m_value);
1659         }
Modulus(double v)1660         internal override object Modulus(double v)
1661         {
1662             return (v % m_value);
1663         }
Modulus(decimal v)1664         internal override object Modulus(decimal v)
1665         {
1666             return (v % m_value);
1667         }
1668         #endregion
1669         #region BitAnd
BitAnd(ArithmeticLiteral v)1670         internal override object BitAnd(ArithmeticLiteral v)
1671         {
1672             return v.BitAnd(m_value);
1673         }
BitAnd()1674         internal override object BitAnd()
1675         {
1676             return null;
1677         }
BitAnd(int v)1678         internal override object BitAnd(int v)
1679         {
1680             return (v & m_value);
1681         }
BitAnd(long v)1682         internal override object BitAnd(long v)
1683         {
1684             return (v & m_value);
1685         }
BitAnd(ushort v)1686         internal override object BitAnd(ushort v)
1687         {
1688             return (v & m_value);
1689         }
BitAnd(uint v)1690         internal override object BitAnd(uint v)
1691         {
1692             return (v & m_value);
1693         }
BitAnd(ulong v)1694         internal override object BitAnd(ulong v)
1695         {
1696             return (v & m_value);
1697         }
1698         #endregion
1699         #region BitOr
BitOr(ArithmeticLiteral v)1700         internal override object BitOr(ArithmeticLiteral v)
1701         {
1702             return v.BitOr(m_value);
1703         }
BitOr()1704         internal override object BitOr()
1705         {
1706             return null;
1707         }
BitOr(int v)1708         internal override object BitOr(int v)
1709         {
1710             return (v | m_value);
1711         }
BitOr(long v)1712         internal override object BitOr(long v)
1713         {
1714             return (v | m_value);
1715         }
BitOr(ushort v)1716         internal override object BitOr(ushort v)
1717         {
1718             return (v | m_value);
1719         }
BitOr(uint v)1720         internal override object BitOr(uint v)
1721         {
1722             return (v | m_value);
1723         }
BitOr(ulong v)1724         internal override object BitOr(ulong v)
1725         {
1726             return (v | m_value);
1727         }
1728         #endregion
1729     }
1730     #endregion
1731 
1732     #region UShortArithmeticLiteral Class
1733     internal class UShortArithmeticLiteral : ArithmeticLiteral
1734     {
1735         private ushort m_value;
UShortArithmeticLiteral(ushort literalValue)1736         internal UShortArithmeticLiteral(ushort literalValue)
1737         {
1738             m_value = literalValue;
1739             m_type = typeof(ushort);
1740         }
1741 
1742         internal override object Value
1743         {
1744             get { return m_value; }
1745         }
1746         #region Add
Add(ArithmeticLiteral v)1747         internal override object Add(ArithmeticLiteral v)
1748         {
1749             return v.Add(m_value);
1750         }
Add()1751         internal override object Add()
1752         {
1753             return null;
1754         }
Add(int v)1755         internal override object Add(int v)
1756         {
1757             return (v + m_value);
1758         }
Add(long v)1759         internal override object Add(long v)
1760         {
1761             return (v + m_value);
1762         }
Add(char v)1763         internal override object Add(char v)
1764         {
1765             return (v + m_value);
1766         }
Add(ushort v)1767         internal override object Add(ushort v)
1768         {
1769             return (v + m_value);
1770         }
Add(uint v)1771         internal override object Add(uint v)
1772         {
1773             return (v + m_value);
1774         }
Add(ulong v)1775         internal override object Add(ulong v)
1776         {
1777             return (v + m_value);
1778         }
Add(float v)1779         internal override object Add(float v)
1780         {
1781             return (v + m_value);
1782         }
Add(double v)1783         internal override object Add(double v)
1784         {
1785             return (v + m_value);
1786         }
Add(decimal v)1787         internal override object Add(decimal v)
1788         {
1789             return (v + m_value);
1790         }
Add(string v)1791         internal override object Add(string v)
1792         {
1793             return (v + m_value.ToString(CultureInfo.CurrentCulture));
1794         }
1795         #endregion
1796         #region Subtract
Subtract(ArithmeticLiteral v)1797         internal override object Subtract(ArithmeticLiteral v)
1798         {
1799             return v.Subtract(m_value);
1800         }
Subtract()1801         internal override object Subtract()
1802         {
1803             return null;
1804         }
Subtract(int v)1805         internal override object Subtract(int v)
1806         {
1807             return (v - m_value);
1808         }
Subtract(long v)1809         internal override object Subtract(long v)
1810         {
1811             return (v - m_value);
1812         }
Subtract(ushort v)1813         internal override object Subtract(ushort v)
1814         {
1815             return (v - m_value);
1816         }
Subtract(uint v)1817         internal override object Subtract(uint v)
1818         {
1819             return (v - m_value);
1820         }
Subtract(ulong v)1821         internal override object Subtract(ulong v)
1822         {
1823             return (v - m_value);
1824         }
Subtract(float v)1825         internal override object Subtract(float v)
1826         {
1827             return (v - m_value);
1828         }
Subtract(double v)1829         internal override object Subtract(double v)
1830         {
1831             return (v - m_value);
1832         }
Subtract(decimal v)1833         internal override object Subtract(decimal v)
1834         {
1835             return (v - m_value);
1836         }
1837         #endregion
1838         #region Multiply
Multiply(ArithmeticLiteral v)1839         internal override object Multiply(ArithmeticLiteral v)
1840         {
1841             return v.Multiply(m_value);
1842         }
Multiply()1843         internal override object Multiply()
1844         {
1845             return null;
1846         }
Multiply(int v)1847         internal override object Multiply(int v)
1848         {
1849             return (v * m_value);
1850         }
Multiply(long v)1851         internal override object Multiply(long v)
1852         {
1853             return (v * m_value);
1854         }
Multiply(ushort v)1855         internal override object Multiply(ushort v)
1856         {
1857             return (v * m_value);
1858         }
Multiply(uint v)1859         internal override object Multiply(uint v)
1860         {
1861             return (v * m_value);
1862         }
Multiply(ulong v)1863         internal override object Multiply(ulong v)
1864         {
1865             return (v * m_value);
1866         }
Multiply(float v)1867         internal override object Multiply(float v)
1868         {
1869             return (v * m_value);
1870         }
Multiply(double v)1871         internal override object Multiply(double v)
1872         {
1873             return (v * m_value);
1874         }
Multiply(decimal v)1875         internal override object Multiply(decimal v)
1876         {
1877             return (v * m_value);
1878         }
1879         #endregion
1880         #region Divide
Divide(ArithmeticLiteral v)1881         internal override object Divide(ArithmeticLiteral v)
1882         {
1883             return v.Divide(m_value);
1884         }
Divide()1885         internal override object Divide()
1886         {
1887             return null;
1888         }
Divide(int v)1889         internal override object Divide(int v)
1890         {
1891             return (v / m_value);
1892         }
Divide(long v)1893         internal override object Divide(long v)
1894         {
1895             return (v / m_value);
1896         }
Divide(ushort v)1897         internal override object Divide(ushort v)
1898         {
1899             return (v / m_value);
1900         }
Divide(uint v)1901         internal override object Divide(uint v)
1902         {
1903             return (v / m_value);
1904         }
Divide(ulong v)1905         internal override object Divide(ulong v)
1906         {
1907             return (v / m_value);
1908         }
Divide(float v)1909         internal override object Divide(float v)
1910         {
1911             return (v / m_value);
1912         }
Divide(double v)1913         internal override object Divide(double v)
1914         {
1915             return (v / m_value);
1916         }
Divide(decimal v)1917         internal override object Divide(decimal v)
1918         {
1919             return (v / m_value);
1920         }
1921         #endregion
1922         #region Modulus
Modulus(ArithmeticLiteral v)1923         internal override object Modulus(ArithmeticLiteral v)
1924         {
1925             return v.Modulus(m_value);
1926         }
Modulus()1927         internal override object Modulus()
1928         {
1929             return null;
1930         }
Modulus(int v)1931         internal override object Modulus(int v)
1932         {
1933             return (v % m_value);
1934         }
Modulus(long v)1935         internal override object Modulus(long v)
1936         {
1937             return (v % m_value);
1938         }
Modulus(ushort v)1939         internal override object Modulus(ushort v)
1940         {
1941             return (v % m_value);
1942         }
Modulus(uint v)1943         internal override object Modulus(uint v)
1944         {
1945             return (v % m_value);
1946         }
Modulus(ulong v)1947         internal override object Modulus(ulong v)
1948         {
1949             return (v % m_value);
1950         }
Modulus(float v)1951         internal override object Modulus(float v)
1952         {
1953             return (v % m_value);
1954         }
Modulus(double v)1955         internal override object Modulus(double v)
1956         {
1957             return (v % m_value);
1958         }
Modulus(decimal v)1959         internal override object Modulus(decimal v)
1960         {
1961             return (v % m_value);
1962         }
1963         #endregion
1964         #region BitAnd
BitAnd(ArithmeticLiteral v)1965         internal override object BitAnd(ArithmeticLiteral v)
1966         {
1967             return v.BitAnd(m_value);
1968         }
BitAnd()1969         internal override object BitAnd()
1970         {
1971             return null;
1972         }
BitAnd(int v)1973         internal override object BitAnd(int v)
1974         {
1975             return (v & m_value);
1976         }
BitAnd(long v)1977         internal override object BitAnd(long v)
1978         {
1979             return (v & m_value);
1980         }
BitAnd(ushort v)1981         internal override object BitAnd(ushort v)
1982         {
1983             return (v & m_value);
1984         }
BitAnd(uint v)1985         internal override object BitAnd(uint v)
1986         {
1987             return (v & m_value);
1988         }
BitAnd(ulong v)1989         internal override object BitAnd(ulong v)
1990         {
1991             return (v & m_value);
1992         }
1993         #endregion
1994         #region BitOr
BitOr(ArithmeticLiteral v)1995         internal override object BitOr(ArithmeticLiteral v)
1996         {
1997             return v.BitOr(m_value);
1998         }
BitOr()1999         internal override object BitOr()
2000         {
2001             return null;
2002         }
BitOr(int v)2003         internal override object BitOr(int v)
2004         {
2005             return (v | m_value);
2006         }
BitOr(long v)2007         internal override object BitOr(long v)
2008         {
2009             return (v | m_value);
2010         }
BitOr(ushort v)2011         internal override object BitOr(ushort v)
2012         {
2013             return (v | m_value);
2014         }
BitOr(uint v)2015         internal override object BitOr(uint v)
2016         {
2017             return (v | m_value);
2018         }
BitOr(ulong v)2019         internal override object BitOr(ulong v)
2020         {
2021             return (v | m_value);
2022         }
2023         #endregion
2024     }
2025     #endregion
2026 
2027     #region UIntArithmeticLiteral Class
2028     internal class UIntArithmeticLiteral : ArithmeticLiteral
2029     {
2030         private uint m_value;
UIntArithmeticLiteral(uint literalValue)2031         internal UIntArithmeticLiteral(uint literalValue)
2032         {
2033             m_value = literalValue;
2034             m_type = typeof(uint);
2035         }
2036         internal override object Value
2037         {
2038             get { return m_value; }
2039         }
2040         #region Add
Add(ArithmeticLiteral v)2041         internal override object Add(ArithmeticLiteral v)
2042         {
2043             return v.Add(m_value);
2044         }
Add()2045         internal override object Add()
2046         {
2047             return null;
2048         }
Add(int v)2049         internal override object Add(int v)
2050         {
2051             return (v + m_value);
2052         }
Add(long v)2053         internal override object Add(long v)
2054         {
2055             return (v + m_value);
2056         }
Add(char v)2057         internal override object Add(char v)
2058         {
2059             return (v + m_value);
2060         }
Add(ushort v)2061         internal override object Add(ushort v)
2062         {
2063             return (v + m_value);
2064         }
Add(uint v)2065         internal override object Add(uint v)
2066         {
2067             return (v + m_value);
2068         }
Add(ulong v)2069         internal override object Add(ulong v)
2070         {
2071             return (v + m_value);
2072         }
Add(float v)2073         internal override object Add(float v)
2074         {
2075             return (v + m_value);
2076         }
Add(double v)2077         internal override object Add(double v)
2078         {
2079             return (v + m_value);
2080         }
Add(decimal v)2081         internal override object Add(decimal v)
2082         {
2083             return (v + m_value);
2084         }
Add(string v)2085         internal override object Add(string v)
2086         {
2087             return (v + m_value.ToString(CultureInfo.CurrentCulture));
2088         }
2089         #endregion
2090         #region Subtract
Subtract(ArithmeticLiteral v)2091         internal override object Subtract(ArithmeticLiteral v)
2092         {
2093             return v.Subtract(m_value);
2094         }
Subtract()2095         internal override object Subtract()
2096         {
2097             return null;
2098         }
Subtract(int v)2099         internal override object Subtract(int v)
2100         {
2101             return (v - m_value);
2102         }
Subtract(long v)2103         internal override object Subtract(long v)
2104         {
2105             return (v - m_value);
2106         }
Subtract(ushort v)2107         internal override object Subtract(ushort v)
2108         {
2109             return (v - m_value);
2110         }
Subtract(uint v)2111         internal override object Subtract(uint v)
2112         {
2113             return (v - m_value);
2114         }
Subtract(ulong v)2115         internal override object Subtract(ulong v)
2116         {
2117             return (v - m_value);
2118         }
Subtract(float v)2119         internal override object Subtract(float v)
2120         {
2121             return (v - m_value);
2122         }
Subtract(double v)2123         internal override object Subtract(double v)
2124         {
2125             return (v - m_value);
2126         }
Subtract(decimal v)2127         internal override object Subtract(decimal v)
2128         {
2129             return (v - m_value);
2130         }
2131         #endregion
2132         #region Multiply
Multiply(ArithmeticLiteral v)2133         internal override object Multiply(ArithmeticLiteral v)
2134         {
2135             return v.Multiply(m_value);
2136         }
Multiply()2137         internal override object Multiply()
2138         {
2139             return null;
2140         }
Multiply(int v)2141         internal override object Multiply(int v)
2142         {
2143             return (v * m_value);
2144         }
Multiply(long v)2145         internal override object Multiply(long v)
2146         {
2147             return (v * m_value);
2148         }
Multiply(ushort v)2149         internal override object Multiply(ushort v)
2150         {
2151             return (v * m_value);
2152         }
Multiply(uint v)2153         internal override object Multiply(uint v)
2154         {
2155             return (v * m_value);
2156         }
Multiply(ulong v)2157         internal override object Multiply(ulong v)
2158         {
2159             return (v * m_value);
2160         }
Multiply(float v)2161         internal override object Multiply(float v)
2162         {
2163             return (v * m_value);
2164         }
Multiply(double v)2165         internal override object Multiply(double v)
2166         {
2167             return (v * m_value);
2168         }
Multiply(decimal v)2169         internal override object Multiply(decimal v)
2170         {
2171             return (v * m_value);
2172         }
2173         #endregion
2174         #region Divide
Divide(ArithmeticLiteral v)2175         internal override object Divide(ArithmeticLiteral v)
2176         {
2177             return v.Divide(m_value);
2178         }
Divide()2179         internal override object Divide()
2180         {
2181             return null;
2182         }
Divide(int v)2183         internal override object Divide(int v)
2184         {
2185             return (v / m_value);
2186         }
Divide(long v)2187         internal override object Divide(long v)
2188         {
2189             return (v / m_value);
2190         }
Divide(ushort v)2191         internal override object Divide(ushort v)
2192         {
2193             return (v / m_value);
2194         }
Divide(uint v)2195         internal override object Divide(uint v)
2196         {
2197             return (v / m_value);
2198         }
Divide(ulong v)2199         internal override object Divide(ulong v)
2200         {
2201             return (v / m_value);
2202         }
Divide(float v)2203         internal override object Divide(float v)
2204         {
2205             return (v / m_value);
2206         }
Divide(double v)2207         internal override object Divide(double v)
2208         {
2209             return (v / m_value);
2210         }
Divide(decimal v)2211         internal override object Divide(decimal v)
2212         {
2213             return (v / m_value);
2214         }
2215         #endregion
2216         #region Modulus
Modulus(ArithmeticLiteral v)2217         internal override object Modulus(ArithmeticLiteral v)
2218         {
2219             return v.Modulus(m_value);
2220         }
Modulus()2221         internal override object Modulus()
2222         {
2223             return null;
2224         }
Modulus(int v)2225         internal override object Modulus(int v)
2226         {
2227             return (v % m_value);
2228         }
Modulus(long v)2229         internal override object Modulus(long v)
2230         {
2231             return (v % m_value);
2232         }
Modulus(ushort v)2233         internal override object Modulus(ushort v)
2234         {
2235             return (v % m_value);
2236         }
Modulus(uint v)2237         internal override object Modulus(uint v)
2238         {
2239             return (v % m_value);
2240         }
Modulus(ulong v)2241         internal override object Modulus(ulong v)
2242         {
2243             return (v % m_value);
2244         }
Modulus(float v)2245         internal override object Modulus(float v)
2246         {
2247             return (v % m_value);
2248         }
Modulus(double v)2249         internal override object Modulus(double v)
2250         {
2251             return (v % m_value);
2252         }
Modulus(decimal v)2253         internal override object Modulus(decimal v)
2254         {
2255             return (v % m_value);
2256         }
2257         #endregion
2258         #region BitAnd
BitAnd(ArithmeticLiteral v)2259         internal override object BitAnd(ArithmeticLiteral v)
2260         {
2261             return v.BitAnd(m_value);
2262         }
BitAnd()2263         internal override object BitAnd()
2264         {
2265             return null;
2266         }
BitAnd(int v)2267         internal override object BitAnd(int v)
2268         {
2269             return (v & m_value);
2270         }
BitAnd(long v)2271         internal override object BitAnd(long v)
2272         {
2273             return (v & m_value);
2274         }
BitAnd(ushort v)2275         internal override object BitAnd(ushort v)
2276         {
2277             return (v & m_value);
2278         }
BitAnd(uint v)2279         internal override object BitAnd(uint v)
2280         {
2281             return (v & m_value);
2282         }
BitAnd(ulong v)2283         internal override object BitAnd(ulong v)
2284         {
2285             return (v & m_value);
2286         }
2287         #endregion
2288         #region BitOr
BitOr(ArithmeticLiteral v)2289         internal override object BitOr(ArithmeticLiteral v)
2290         {
2291             return v.BitOr(m_value);
2292         }
BitOr()2293         internal override object BitOr()
2294         {
2295             return null;
2296         }
BitOr(int v)2297         internal override object BitOr(int v)
2298         {
2299             long l = v;
2300             return (l | m_value);
2301         }
BitOr(long v)2302         internal override object BitOr(long v)
2303         {
2304             return (v | m_value);
2305         }
BitOr(ushort v)2306         internal override object BitOr(ushort v)
2307         {
2308             return (v | m_value);
2309         }
BitOr(uint v)2310         internal override object BitOr(uint v)
2311         {
2312             return (v | m_value);
2313         }
BitOr(ulong v)2314         internal override object BitOr(ulong v)
2315         {
2316             return (v | m_value);
2317         }
2318         #endregion
2319     }
2320     #endregion
2321 
2322     #region ULongArithmeticLiteral Class
2323     internal class ULongArithmeticLiteral : ArithmeticLiteral
2324     {
2325         private ulong m_value;
ULongArithmeticLiteral(ulong literalValue)2326         internal ULongArithmeticLiteral(ulong literalValue)
2327         {
2328             m_value = literalValue;
2329             m_type = typeof(ulong);
2330         }
2331         internal override object Value
2332         {
2333             get { return m_value; }
2334         }
2335         #region Add
Add(ArithmeticLiteral v)2336         internal override object Add(ArithmeticLiteral v)
2337         {
2338             return v.Add(m_value);
2339         }
Add()2340         internal override object Add()
2341         {
2342             return null;
2343         }
Add(int v)2344         internal override object Add(int v)
2345         {
2346             // this should only happen when using a constant (+ve) int and an ulong
2347             // if that's not the case, you get an error
2348             return (v >= 0) ? ((ulong)v + m_value) : base.Add(v);
2349         }
Add(long v)2350         internal override object Add(long v)
2351         {
2352             // this should only happen when using a constant (+ve) long and an ulong
2353             // if that's not the case, you get an error
2354             return (v >= 0) ? ((ulong)v + m_value) : base.Add(v);
2355         }
Add(char v)2356         internal override object Add(char v)
2357         {
2358             return (v + m_value);
2359         }
Add(ushort v)2360         internal override object Add(ushort v)
2361         {
2362             return (v + m_value);
2363         }
Add(uint v)2364         internal override object Add(uint v)
2365         {
2366             return (v + m_value);
2367         }
Add(ulong v)2368         internal override object Add(ulong v)
2369         {
2370             return (v + m_value);
2371         }
Add(float v)2372         internal override object Add(float v)
2373         {
2374             return (v + m_value);
2375         }
Add(double v)2376         internal override object Add(double v)
2377         {
2378             return (v + m_value);
2379         }
Add(decimal v)2380         internal override object Add(decimal v)
2381         {
2382             return (v + m_value);
2383         }
Add(string v)2384         internal override object Add(string v)
2385         {
2386             return (v + m_value.ToString(CultureInfo.CurrentCulture));
2387         }
2388         #endregion
2389         #region Subtract
Subtract(ArithmeticLiteral v)2390         internal override object Subtract(ArithmeticLiteral v)
2391         {
2392             return v.Subtract(m_value);
2393         }
Subtract()2394         internal override object Subtract()
2395         {
2396             return null;
2397         }
Subtract(int v)2398         internal override object Subtract(int v)
2399         {
2400             // this should only happen when using a constant (+ve) int and an ulong
2401             // if that's not the case, you get an error
2402             return (v >= 0) ? ((ulong)v - m_value) : base.Subtract(v);
2403         }
Subtract(long v)2404         internal override object Subtract(long v)
2405         {
2406             // this should only happen when using a constant (+ve) long and an ulong
2407             // if that's not the case, you get an error
2408             return (v >= 0) ? ((ulong)v - m_value) : base.Subtract(v);
2409         }
Subtract(ushort v)2410         internal override object Subtract(ushort v)
2411         {
2412             return (v - m_value);
2413         }
Subtract(uint v)2414         internal override object Subtract(uint v)
2415         {
2416             return (v - m_value);
2417         }
Subtract(ulong v)2418         internal override object Subtract(ulong v)
2419         {
2420             return (v - m_value);
2421         }
Subtract(float v)2422         internal override object Subtract(float v)
2423         {
2424             return (v - m_value);
2425         }
Subtract(double v)2426         internal override object Subtract(double v)
2427         {
2428             return (v - m_value);
2429         }
Subtract(decimal v)2430         internal override object Subtract(decimal v)
2431         {
2432             return (v - m_value);
2433         }
2434         #endregion
2435         #region Multiply
Multiply(ArithmeticLiteral v)2436         internal override object Multiply(ArithmeticLiteral v)
2437         {
2438             return v.Multiply(m_value);
2439         }
Multiply()2440         internal override object Multiply()
2441         {
2442             return null;
2443         }
Multiply(int v)2444         internal override object Multiply(int v)
2445         {
2446             // this should only happen when using a constant (+ve) int and an ulong
2447             // if that's not the case, you get an error
2448             return (v >= 0) ? ((ulong)v * m_value) : base.Multiply(v);
2449         }
Multiply(long v)2450         internal override object Multiply(long v)
2451         {
2452             // this should only happen when using a constant (+ve) long and an ulong
2453             // if that's not the case, you get an error
2454             return (v >= 0) ? ((ulong)v * m_value) : base.Multiply(v);
2455         }
Multiply(ushort v)2456         internal override object Multiply(ushort v)
2457         {
2458             return (v * m_value);
2459         }
Multiply(uint v)2460         internal override object Multiply(uint v)
2461         {
2462             return (v * m_value);
2463         }
Multiply(ulong v)2464         internal override object Multiply(ulong v)
2465         {
2466             return (v * m_value);
2467         }
Multiply(float v)2468         internal override object Multiply(float v)
2469         {
2470             return (v * m_value);
2471         }
Multiply(double v)2472         internal override object Multiply(double v)
2473         {
2474             return (v * m_value);
2475         }
Multiply(decimal v)2476         internal override object Multiply(decimal v)
2477         {
2478             return (v * m_value);
2479         }
2480         #endregion
2481         #region Divide
Divide(ArithmeticLiteral v)2482         internal override object Divide(ArithmeticLiteral v)
2483         {
2484             return v.Divide(m_value);
2485         }
Divide()2486         internal override object Divide()
2487         {
2488             return null;
2489         }
Divide(int v)2490         internal override object Divide(int v)
2491         {
2492             // this should only happen when using a constant (+ve) int and an ulong
2493             // if that's not the case, you get an error
2494             return (v >= 0) ? ((ulong)v / m_value) : base.Divide(v);
2495         }
Divide(long v)2496         internal override object Divide(long v)
2497         {
2498             // this should only happen when using a constant (+ve) long and an ulong
2499             // if that's not the case, you get an error
2500             return (v >= 0) ? ((ulong)v / m_value) : base.Divide(v);
2501         }
Divide(ushort v)2502         internal override object Divide(ushort v)
2503         {
2504             return (v / m_value);
2505         }
Divide(uint v)2506         internal override object Divide(uint v)
2507         {
2508             return (v / m_value);
2509         }
Divide(ulong v)2510         internal override object Divide(ulong v)
2511         {
2512             return (v / m_value);
2513         }
Divide(float v)2514         internal override object Divide(float v)
2515         {
2516             return (v / m_value);
2517         }
Divide(double v)2518         internal override object Divide(double v)
2519         {
2520             return (v / m_value);
2521         }
Divide(decimal v)2522         internal override object Divide(decimal v)
2523         {
2524             return (v / m_value);
2525         }
2526         #endregion
2527         #region Modulus
Modulus(ArithmeticLiteral v)2528         internal override object Modulus(ArithmeticLiteral v)
2529         {
2530             return v.Modulus(m_value);
2531         }
Modulus()2532         internal override object Modulus()
2533         {
2534             return null;
2535         }
Modulus(int v)2536         internal override object Modulus(int v)
2537         {
2538             // this should only happen when using a constant (+ve) int and an ulong
2539             // if that's not the case, you get an error
2540             return (v >= 0) ? ((ulong)v % m_value) : base.Modulus(v);
2541         }
Modulus(long v)2542         internal override object Modulus(long v)
2543         {
2544             // this should only happen when using a constant (+ve) long and an ulong
2545             // if that's not the case, you get an error
2546             return (v >= 0) ? ((ulong)v % m_value) : base.Modulus(v);
2547         }
Modulus(ushort v)2548         internal override object Modulus(ushort v)
2549         {
2550             return (v % m_value);
2551         }
Modulus(uint v)2552         internal override object Modulus(uint v)
2553         {
2554             return (v % m_value);
2555         }
Modulus(ulong v)2556         internal override object Modulus(ulong v)
2557         {
2558             return (v % m_value);
2559         }
Modulus(float v)2560         internal override object Modulus(float v)
2561         {
2562             return (v % m_value);
2563         }
Modulus(double v)2564         internal override object Modulus(double v)
2565         {
2566             return (v % m_value);
2567         }
Modulus(decimal v)2568         internal override object Modulus(decimal v)
2569         {
2570             return (v % m_value);
2571         }
2572         #endregion
2573         #region BitAnd
BitAnd(ArithmeticLiteral v)2574         internal override object BitAnd(ArithmeticLiteral v)
2575         {
2576             return v.BitAnd(m_value);
2577         }
BitAnd()2578         internal override object BitAnd()
2579         {
2580             return null;
2581         }
BitAnd(int v)2582         internal override object BitAnd(int v)
2583         {
2584             // this should only happen when using a constant (+ve) int and an ulong
2585             // if that's not the case, you get an error
2586             return (v >= 0) ? ((ulong)v & m_value) : base.BitAnd(v);
2587         }
BitAnd(long v)2588         internal override object BitAnd(long v)
2589         {
2590             // this should only happen when using a constant (+ve) long and an ulong
2591             // if that's not the case, you get an error
2592             return (v >= 0) ? ((ulong)v & m_value) : base.BitAnd(v);
2593         }
BitAnd(ushort v)2594         internal override object BitAnd(ushort v)
2595         {
2596             return (v & m_value);
2597         }
BitAnd(uint v)2598         internal override object BitAnd(uint v)
2599         {
2600             return (v & m_value);
2601         }
BitAnd(ulong v)2602         internal override object BitAnd(ulong v)
2603         {
2604             return (v & m_value);
2605         }
2606         #endregion
2607         #region BitOr
BitOr(ArithmeticLiteral v)2608         internal override object BitOr(ArithmeticLiteral v)
2609         {
2610             return v.BitOr(m_value);
2611         }
BitOr()2612         internal override object BitOr()
2613         {
2614             return null;
2615         }
BitOr(int v)2616         internal override object BitOr(int v)
2617         {
2618             // this should only happen when using a constant (+ve) int and an ulong
2619             // if that's not the case, you get an error
2620             long l = v;
2621             return (l >= 0) ? ((ulong)l | m_value) : base.BitOr(v);
2622         }
BitOr(long v)2623         internal override object BitOr(long v)
2624         {
2625             // this should only happen when using a constant (+ve) long and an ulong
2626             // if that's not the case, you get an error
2627             return (v >= 0) ? ((ulong)v | m_value) : base.BitOr(v);
2628         }
BitOr(ushort v)2629         internal override object BitOr(ushort v)
2630         {
2631             return (v | m_value);
2632         }
BitOr(uint v)2633         internal override object BitOr(uint v)
2634         {
2635             return (v | m_value);
2636         }
BitOr(ulong v)2637         internal override object BitOr(ulong v)
2638         {
2639             return (v | m_value);
2640         }
2641         #endregion
2642     }
2643     #endregion
2644 
2645     #region FloatArithmeticLiteral Class
2646     internal class FloatArithmeticLiteral : ArithmeticLiteral
2647     {
2648         private float m_value;
FloatArithmeticLiteral(float literalValue)2649         internal FloatArithmeticLiteral(float literalValue)
2650         {
2651             m_value = literalValue;
2652             m_type = typeof(float);
2653         }
2654 
2655         internal override object Value
2656         {
2657             get { return m_value; }
2658         }
2659         #region Add
Add(ArithmeticLiteral v)2660         internal override object Add(ArithmeticLiteral v)
2661         {
2662             return v.Add(m_value);
2663         }
Add()2664         internal override object Add()
2665         {
2666             return null;
2667         }
Add(int v)2668         internal override object Add(int v)
2669         {
2670             return (v + m_value);
2671         }
Add(long v)2672         internal override object Add(long v)
2673         {
2674             return (v + m_value);
2675         }
Add(char v)2676         internal override object Add(char v)
2677         {
2678             return (v + m_value);
2679         }
Add(ushort v)2680         internal override object Add(ushort v)
2681         {
2682             return (v + m_value);
2683         }
Add(uint v)2684         internal override object Add(uint v)
2685         {
2686             return (v + m_value);
2687         }
Add(ulong v)2688         internal override object Add(ulong v)
2689         {
2690             return (v + m_value);
2691         }
Add(float v)2692         internal override object Add(float v)
2693         {
2694             return (v + m_value);
2695         }
Add(double v)2696         internal override object Add(double v)
2697         {
2698             return (v + m_value);
2699         }
Add(string v)2700         internal override object Add(string v)
2701         {
2702             return (v + m_value.ToString(CultureInfo.CurrentCulture));
2703         }
2704         #endregion
2705         #region Subtract
Subtract(ArithmeticLiteral v)2706         internal override object Subtract(ArithmeticLiteral v)
2707         {
2708             return v.Subtract(m_value);
2709         }
Subtract()2710         internal override object Subtract()
2711         {
2712             return null;
2713         }
Subtract(int v)2714         internal override object Subtract(int v)
2715         {
2716             return (v - m_value);
2717         }
Subtract(long v)2718         internal override object Subtract(long v)
2719         {
2720             return (v - m_value);
2721         }
Subtract(ushort v)2722         internal override object Subtract(ushort v)
2723         {
2724             return (v - m_value);
2725         }
Subtract(uint v)2726         internal override object Subtract(uint v)
2727         {
2728             return (v - m_value);
2729         }
Subtract(ulong v)2730         internal override object Subtract(ulong v)
2731         {
2732             return (v - m_value);
2733         }
Subtract(float v)2734         internal override object Subtract(float v)
2735         {
2736             return (v - m_value);
2737         }
Subtract(double v)2738         internal override object Subtract(double v)
2739         {
2740             return (v - m_value);
2741         }
2742         #endregion
2743         #region Multiply
Multiply(ArithmeticLiteral v)2744         internal override object Multiply(ArithmeticLiteral v)
2745         {
2746             return v.Multiply(m_value);
2747         }
Multiply()2748         internal override object Multiply()
2749         {
2750             return null;
2751         }
Multiply(int v)2752         internal override object Multiply(int v)
2753         {
2754             return (v * m_value);
2755         }
Multiply(long v)2756         internal override object Multiply(long v)
2757         {
2758             return (v * m_value);
2759         }
Multiply(ushort v)2760         internal override object Multiply(ushort v)
2761         {
2762             return (v * m_value);
2763         }
Multiply(uint v)2764         internal override object Multiply(uint v)
2765         {
2766             return (v * m_value);
2767         }
Multiply(ulong v)2768         internal override object Multiply(ulong v)
2769         {
2770             return (v * m_value);
2771         }
Multiply(float v)2772         internal override object Multiply(float v)
2773         {
2774             return (v * m_value);
2775         }
Multiply(double v)2776         internal override object Multiply(double v)
2777         {
2778             return (v * m_value);
2779         }
2780         #endregion
2781         #region Divide
Divide(ArithmeticLiteral v)2782         internal override object Divide(ArithmeticLiteral v)
2783         {
2784             return v.Divide(m_value);
2785         }
Divide()2786         internal override object Divide()
2787         {
2788             return null;
2789         }
Divide(int v)2790         internal override object Divide(int v)
2791         {
2792             return (v / m_value);
2793         }
Divide(long v)2794         internal override object Divide(long v)
2795         {
2796             return (v / m_value);
2797         }
Divide(ushort v)2798         internal override object Divide(ushort v)
2799         {
2800             return (v / m_value);
2801         }
Divide(uint v)2802         internal override object Divide(uint v)
2803         {
2804             return (v / m_value);
2805         }
Divide(ulong v)2806         internal override object Divide(ulong v)
2807         {
2808             return (v / m_value);
2809         }
Divide(float v)2810         internal override object Divide(float v)
2811         {
2812             return (v / m_value);
2813         }
Divide(double v)2814         internal override object Divide(double v)
2815         {
2816             return (v / m_value);
2817         }
2818         #endregion
2819         #region Modulus
Modulus(ArithmeticLiteral v)2820         internal override object Modulus(ArithmeticLiteral v)
2821         {
2822             return v.Modulus(m_value);
2823         }
Modulus()2824         internal override object Modulus()
2825         {
2826             return null;
2827         }
Modulus(int v)2828         internal override object Modulus(int v)
2829         {
2830             return (v % m_value);
2831         }
Modulus(long v)2832         internal override object Modulus(long v)
2833         {
2834             return (v % m_value);
2835         }
Modulus(ushort v)2836         internal override object Modulus(ushort v)
2837         {
2838             return (v % m_value);
2839         }
Modulus(uint v)2840         internal override object Modulus(uint v)
2841         {
2842             return (v % m_value);
2843         }
Modulus(ulong v)2844         internal override object Modulus(ulong v)
2845         {
2846             return (v % m_value);
2847         }
Modulus(float v)2848         internal override object Modulus(float v)
2849         {
2850             return (v % m_value);
2851         }
Modulus(double v)2852         internal override object Modulus(double v)
2853         {
2854             return (v % m_value);
2855         }
2856         #endregion
2857     }
2858     #endregion
2859 
2860     #region DoubleArithmeticLiteral Class
2861     internal class DoubleArithmeticLiteral : ArithmeticLiteral
2862     {
2863         private double m_value;
DoubleArithmeticLiteral(double literalValue)2864         internal DoubleArithmeticLiteral(double literalValue)
2865         {
2866             m_value = literalValue;
2867             m_type = typeof(double);
2868         }
2869 
2870         internal override object Value
2871         {
2872             get { return m_value; }
2873         }
2874         #region Add
Add(ArithmeticLiteral v)2875         internal override object Add(ArithmeticLiteral v)
2876         {
2877             return v.Add(m_value);
2878         }
Add()2879         internal override object Add()
2880         {
2881             return null;
2882         }
Add(int v)2883         internal override object Add(int v)
2884         {
2885             return (v + m_value);
2886         }
Add(long v)2887         internal override object Add(long v)
2888         {
2889             return (v + m_value);
2890         }
Add(char v)2891         internal override object Add(char v)
2892         {
2893             return (v + m_value);
2894         }
Add(ushort v)2895         internal override object Add(ushort v)
2896         {
2897             return (v + m_value);
2898         }
Add(uint v)2899         internal override object Add(uint v)
2900         {
2901             return (v + m_value);
2902         }
Add(ulong v)2903         internal override object Add(ulong v)
2904         {
2905             return (v + m_value);
2906         }
Add(float v)2907         internal override object Add(float v)
2908         {
2909             return (v + m_value);
2910         }
Add(double v)2911         internal override object Add(double v)
2912         {
2913             return (v + m_value);
2914         }
Add(string v)2915         internal override object Add(string v)
2916         {
2917             return (v + m_value.ToString(CultureInfo.CurrentCulture));
2918         }
2919         #endregion
2920         #region Subtract
Subtract(ArithmeticLiteral v)2921         internal override object Subtract(ArithmeticLiteral v)
2922         {
2923             return v.Subtract(m_value);
2924         }
Subtract()2925         internal override object Subtract()
2926         {
2927             return null;
2928         }
Subtract(int v)2929         internal override object Subtract(int v)
2930         {
2931             return (v - m_value);
2932         }
Subtract(long v)2933         internal override object Subtract(long v)
2934         {
2935             return (v - m_value);
2936         }
Subtract(ushort v)2937         internal override object Subtract(ushort v)
2938         {
2939             return (v - m_value);
2940         }
Subtract(uint v)2941         internal override object Subtract(uint v)
2942         {
2943             return (v - m_value);
2944         }
Subtract(ulong v)2945         internal override object Subtract(ulong v)
2946         {
2947             return (v - m_value);
2948         }
Subtract(float v)2949         internal override object Subtract(float v)
2950         {
2951             return (v - m_value);
2952         }
Subtract(double v)2953         internal override object Subtract(double v)
2954         {
2955             return (v - m_value);
2956         }
2957         #endregion
2958         #region Multiply
Multiply(ArithmeticLiteral v)2959         internal override object Multiply(ArithmeticLiteral v)
2960         {
2961             return v.Multiply(m_value);
2962         }
Multiply()2963         internal override object Multiply()
2964         {
2965             return null;
2966         }
Multiply(int v)2967         internal override object Multiply(int v)
2968         {
2969             return (v * m_value);
2970         }
Multiply(long v)2971         internal override object Multiply(long v)
2972         {
2973             return (v * m_value);
2974         }
Multiply(ushort v)2975         internal override object Multiply(ushort v)
2976         {
2977             return (v * m_value);
2978         }
Multiply(uint v)2979         internal override object Multiply(uint v)
2980         {
2981             return (v * m_value);
2982         }
Multiply(ulong v)2983         internal override object Multiply(ulong v)
2984         {
2985             return (v * m_value);
2986         }
Multiply(float v)2987         internal override object Multiply(float v)
2988         {
2989             return (v * m_value);
2990         }
Multiply(double v)2991         internal override object Multiply(double v)
2992         {
2993             return (v * m_value);
2994         }
2995         #endregion
2996         #region Divide
Divide(ArithmeticLiteral v)2997         internal override object Divide(ArithmeticLiteral v)
2998         {
2999             return v.Divide(m_value);
3000         }
Divide()3001         internal override object Divide()
3002         {
3003             return null;
3004         }
Divide(int v)3005         internal override object Divide(int v)
3006         {
3007             return (v / m_value);
3008         }
Divide(long v)3009         internal override object Divide(long v)
3010         {
3011             return (v / m_value);
3012         }
Divide(ushort v)3013         internal override object Divide(ushort v)
3014         {
3015             return (v / m_value);
3016         }
Divide(uint v)3017         internal override object Divide(uint v)
3018         {
3019             return (v / m_value);
3020         }
Divide(ulong v)3021         internal override object Divide(ulong v)
3022         {
3023             return (v / m_value);
3024         }
Divide(float v)3025         internal override object Divide(float v)
3026         {
3027             return (v / m_value);
3028         }
Divide(double v)3029         internal override object Divide(double v)
3030         {
3031             return (v / m_value);
3032         }
3033         #endregion
3034         #region Modulus
Modulus(ArithmeticLiteral v)3035         internal override object Modulus(ArithmeticLiteral v)
3036         {
3037             return v.Modulus(m_value);
3038         }
Modulus()3039         internal override object Modulus()
3040         {
3041             return null;
3042         }
Modulus(int v)3043         internal override object Modulus(int v)
3044         {
3045             return (v % m_value);
3046         }
Modulus(long v)3047         internal override object Modulus(long v)
3048         {
3049             return (v % m_value);
3050         }
Modulus(ushort v)3051         internal override object Modulus(ushort v)
3052         {
3053             return (v % m_value);
3054         }
Modulus(uint v)3055         internal override object Modulus(uint v)
3056         {
3057             return (v % m_value);
3058         }
Modulus(ulong v)3059         internal override object Modulus(ulong v)
3060         {
3061             return (v % m_value);
3062         }
Modulus(float v)3063         internal override object Modulus(float v)
3064         {
3065             return (v % m_value);
3066         }
Modulus(double v)3067         internal override object Modulus(double v)
3068         {
3069             return (v % m_value);
3070         }
3071         #endregion
3072     }
3073     #endregion
3074 
3075     #region DecimalArithmeticLiteral Class
3076     internal class DecimalArithmeticLiteral : ArithmeticLiteral
3077     {
3078         private decimal m_value;
DecimalArithmeticLiteral(decimal literalValue)3079         internal DecimalArithmeticLiteral(decimal literalValue)
3080         {
3081             m_value = literalValue;
3082             m_type = typeof(decimal);
3083         }
3084 
3085         internal override object Value
3086         {
3087             get { return m_value; }
3088         }
3089         #region Add
Add(ArithmeticLiteral v)3090         internal override object Add(ArithmeticLiteral v)
3091         {
3092             return v.Add(m_value);
3093         }
Add()3094         internal override object Add()
3095         {
3096             return null;
3097         }
Add(int v)3098         internal override object Add(int v)
3099         {
3100             return (v + m_value);
3101         }
Add(long v)3102         internal override object Add(long v)
3103         {
3104             return (v + m_value);
3105         }
Add(char v)3106         internal override object Add(char v)
3107         {
3108             return (v + m_value);
3109         }
Add(ushort v)3110         internal override object Add(ushort v)
3111         {
3112             return (v + m_value);
3113         }
Add(uint v)3114         internal override object Add(uint v)
3115         {
3116             return (v + m_value);
3117         }
Add(ulong v)3118         internal override object Add(ulong v)
3119         {
3120             return (v + m_value);
3121         }
Add(decimal v)3122         internal override object Add(decimal v)
3123         {
3124             return (v + m_value);
3125         }
Add(string v)3126         internal override object Add(string v)
3127         {
3128             return (v + m_value.ToString(CultureInfo.CurrentCulture));
3129         }
3130         #endregion
3131         #region Subtract
Subtract(ArithmeticLiteral v)3132         internal override object Subtract(ArithmeticLiteral v)
3133         {
3134             return v.Subtract(m_value);
3135         }
Subtract()3136         internal override object Subtract()
3137         {
3138             return null;
3139         }
Subtract(int v)3140         internal override object Subtract(int v)
3141         {
3142             return (v - m_value);
3143         }
Subtract(long v)3144         internal override object Subtract(long v)
3145         {
3146             return (v - m_value);
3147         }
Subtract(ushort v)3148         internal override object Subtract(ushort v)
3149         {
3150             return (v - m_value);
3151         }
Subtract(uint v)3152         internal override object Subtract(uint v)
3153         {
3154             return (v - m_value);
3155         }
Subtract(ulong v)3156         internal override object Subtract(ulong v)
3157         {
3158             return (v - m_value);
3159         }
Subtract(decimal v)3160         internal override object Subtract(decimal v)
3161         {
3162             return (v - m_value);
3163         }
3164         #endregion
3165         #region Multiply
Multiply(ArithmeticLiteral v)3166         internal override object Multiply(ArithmeticLiteral v)
3167         {
3168             return v.Multiply(m_value);
3169         }
Multiply()3170         internal override object Multiply()
3171         {
3172             return null;
3173         }
Multiply(int v)3174         internal override object Multiply(int v)
3175         {
3176             return (v * m_value);
3177         }
Multiply(long v)3178         internal override object Multiply(long v)
3179         {
3180             return (v * m_value);
3181         }
Multiply(ushort v)3182         internal override object Multiply(ushort v)
3183         {
3184             return (v * m_value);
3185         }
Multiply(uint v)3186         internal override object Multiply(uint v)
3187         {
3188             return (v * m_value);
3189         }
Multiply(ulong v)3190         internal override object Multiply(ulong v)
3191         {
3192             return (v * m_value);
3193         }
Multiply(decimal v)3194         internal override object Multiply(decimal v)
3195         {
3196             return (v * m_value);
3197         }
3198         #endregion
3199         #region Divide
Divide(ArithmeticLiteral v)3200         internal override object Divide(ArithmeticLiteral v)
3201         {
3202             return v.Divide(m_value);
3203         }
Divide()3204         internal override object Divide()
3205         {
3206             return null;
3207         }
Divide(int v)3208         internal override object Divide(int v)
3209         {
3210             return (v / m_value);
3211         }
Divide(long v)3212         internal override object Divide(long v)
3213         {
3214             return (v / m_value);
3215         }
Divide(ushort v)3216         internal override object Divide(ushort v)
3217         {
3218             return (v / m_value);
3219         }
Divide(uint v)3220         internal override object Divide(uint v)
3221         {
3222             return (v / m_value);
3223         }
Divide(ulong v)3224         internal override object Divide(ulong v)
3225         {
3226             return (v / m_value);
3227         }
Divide(decimal v)3228         internal override object Divide(decimal v)
3229         {
3230             return (v / m_value);
3231         }
3232         #endregion
3233         #region Modulus
Modulus(ArithmeticLiteral v)3234         internal override object Modulus(ArithmeticLiteral v)
3235         {
3236             return v.Modulus(m_value);
3237         }
Modulus()3238         internal override object Modulus()
3239         {
3240             return null;
3241         }
Modulus(int v)3242         internal override object Modulus(int v)
3243         {
3244             return (v % m_value);
3245         }
Modulus(long v)3246         internal override object Modulus(long v)
3247         {
3248             return (v % m_value);
3249         }
Modulus(ushort v)3250         internal override object Modulus(ushort v)
3251         {
3252             return (v % m_value);
3253         }
Modulus(uint v)3254         internal override object Modulus(uint v)
3255         {
3256             return (v % m_value);
3257         }
Modulus(ulong v)3258         internal override object Modulus(ulong v)
3259         {
3260             return (v % m_value);
3261         }
Modulus(decimal v)3262         internal override object Modulus(decimal v)
3263         {
3264             return (v % m_value);
3265         }
3266         #endregion
3267     }
3268     #endregion
3269 
3270     #region BooleanArithmeticLiteral Class
3271     internal class BooleanArithmeticLiteral : ArithmeticLiteral
3272     {
3273         private bool m_value;
BooleanArithmeticLiteral(bool literalValue)3274         internal BooleanArithmeticLiteral(bool literalValue)
3275         {
3276             m_value = literalValue;
3277             m_type = typeof(bool);
3278         }
3279 
3280         internal override object Value
3281         {
3282             get { return m_value; }
3283         }
3284         #region Add
Add(ArithmeticLiteral v)3285         internal override object Add(ArithmeticLiteral v)
3286         {
3287             return v.Add(m_value);
3288         }
Add()3289         internal override object Add()
3290         {
3291             return null;
3292         }
Add(string v)3293         internal override object Add(string v)
3294         {
3295             return (v + m_value.ToString(CultureInfo.CurrentCulture));
3296         }
3297         #endregion
3298         #region BitAnd
BitAnd(ArithmeticLiteral v)3299         internal override object BitAnd(ArithmeticLiteral v)
3300         {
3301             return v.BitAnd(m_value);
3302         }
BitAnd()3303         internal override object BitAnd()
3304         {
3305             // special case from section 24.3.6 on bool? type
3306             return (m_value == false) ? (object)false : null;
3307         }
BitAnd(bool v)3308         internal override object BitAnd(bool v)
3309         {
3310             return (v & m_value);
3311         }
3312         #endregion
3313         #region BitOr
BitOr(ArithmeticLiteral v)3314         internal override object BitOr(ArithmeticLiteral v)
3315         {
3316             return v.BitOr(m_value);
3317         }
BitOr()3318         internal override object BitOr()
3319         {
3320             // special case from section 24.3.6 on bool? type
3321             return (m_value == true) ? (object)true : null;
3322         }
BitOr(bool v)3323         internal override object BitOr(bool v)
3324         {
3325             return (v | m_value);
3326         }
3327         #endregion
3328     }
3329     #endregion
3330 
3331     #region StringArithmeticLiteral Class
3332     internal class StringArithmeticLiteral : ArithmeticLiteral
3333     {
3334         private string m_value;
StringArithmeticLiteral(string literalValue)3335         internal StringArithmeticLiteral(string literalValue)
3336         {
3337             m_value = literalValue;
3338             m_type = typeof(string);
3339         }
3340 
3341         internal override object Value
3342         {
3343             get { return m_value; }
3344         }
3345         #region Add
Add(ArithmeticLiteral v)3346         internal override object Add(ArithmeticLiteral v)
3347         {
3348             return v.Add(m_value);
3349         }
Add()3350         internal override object Add()
3351         {
3352             return m_value;
3353         }
Add(char v)3354         internal override object Add(char v)
3355         {
3356             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3357         }
Add(ushort v)3358         internal override object Add(ushort v)
3359         {
3360             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3361         }
Add(int v)3362         internal override object Add(int v)
3363         {
3364             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3365         }
Add(uint v)3366         internal override object Add(uint v)
3367         {
3368             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3369         }
Add(long v)3370         internal override object Add(long v)
3371         {
3372             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3373         }
Add(ulong v)3374         internal override object Add(ulong v)
3375         {
3376             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3377         }
Add(float v)3378         internal override object Add(float v)
3379         {
3380             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3381         }
Add(double v)3382         internal override object Add(double v)
3383         {
3384             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3385         }
Add(decimal v)3386         internal override object Add(decimal v)
3387         {
3388             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3389         }
Add(bool v)3390         internal override object Add(bool v)
3391         {
3392             return (v.ToString(CultureInfo.CurrentCulture) + m_value);
3393         }
Add(string v)3394         internal override object Add(string v)
3395         {
3396             return (v + m_value);
3397         }
3398         #endregion
3399     }
3400     #endregion
3401 
3402     #region NullArithmeticLiteral Class
3403     internal class NullArithmeticLiteral : ArithmeticLiteral
3404     {
NullArithmeticLiteral(Type type)3405         internal NullArithmeticLiteral(Type type)
3406         {
3407             m_type = type;
3408         }
3409         protected override string TypeName
3410         {
3411             get { return Messages.NullValue; }
3412         }
3413         internal override object Value
3414         {
3415             get { return null; }
3416         }
3417         #region Add
Add(ArithmeticLiteral v)3418         internal override object Add(ArithmeticLiteral v)
3419         {
3420             return v.Add();
3421         }
Add()3422         internal override object Add()
3423         {
3424             return null;
3425         }
Add(int v)3426         internal override object Add(int v)
3427         {
3428             return null;
3429         }
Add(long v)3430         internal override object Add(long v)
3431         {
3432             return null;
3433         }
Add(char v)3434         internal override object Add(char v)
3435         {
3436             return null;
3437         }
Add(ushort v)3438         internal override object Add(ushort v)
3439         {
3440             return null;
3441         }
Add(uint v)3442         internal override object Add(uint v)
3443         {
3444             return null;
3445         }
Add(ulong v)3446         internal override object Add(ulong v)
3447         {
3448             return null;
3449         }
Add(float v)3450         internal override object Add(float v)
3451         {
3452             return null;
3453         }
Add(double v)3454         internal override object Add(double v)
3455         {
3456             return null;
3457         }
Add(decimal v)3458         internal override object Add(decimal v)
3459         {
3460             return null;
3461         }
Add(bool v)3462         internal override object Add(bool v)
3463         {
3464             return null;
3465         }
Add(string v)3466         internal override object Add(string v)
3467         {
3468             return null;
3469         }
3470         #endregion
3471         #region Subtract
Subtract(ArithmeticLiteral v)3472         internal override object Subtract(ArithmeticLiteral v)
3473         {
3474             return v.Subtract();
3475         }
Subtract()3476         internal override object Subtract()
3477         {
3478             return null;
3479         }
Subtract(int v)3480         internal override object Subtract(int v)
3481         {
3482             return null;
3483         }
Subtract(long v)3484         internal override object Subtract(long v)
3485         {
3486             return null;
3487         }
Subtract(ushort v)3488         internal override object Subtract(ushort v)
3489         {
3490             return null;
3491         }
Subtract(uint v)3492         internal override object Subtract(uint v)
3493         {
3494             return null;
3495         }
Subtract(ulong v)3496         internal override object Subtract(ulong v)
3497         {
3498             return null;
3499         }
Subtract(float v)3500         internal override object Subtract(float v)
3501         {
3502             return null;
3503         }
Subtract(double v)3504         internal override object Subtract(double v)
3505         {
3506             return null;
3507         }
Subtract(decimal v)3508         internal override object Subtract(decimal v)
3509         {
3510             return null;
3511         }
3512         #endregion
3513         #region Multiply
Multiply(ArithmeticLiteral v)3514         internal override object Multiply(ArithmeticLiteral v)
3515         {
3516             return v.Multiply();
3517         }
Multiply()3518         internal override object Multiply()
3519         {
3520             return null;
3521         }
Multiply(int v)3522         internal override object Multiply(int v)
3523         {
3524             return null;
3525         }
Multiply(long v)3526         internal override object Multiply(long v)
3527         {
3528             return null;
3529         }
Multiply(ushort v)3530         internal override object Multiply(ushort v)
3531         {
3532             return null;
3533         }
Multiply(uint v)3534         internal override object Multiply(uint v)
3535         {
3536             return null;
3537         }
Multiply(ulong v)3538         internal override object Multiply(ulong v)
3539         {
3540             return null;
3541         }
Multiply(float v)3542         internal override object Multiply(float v)
3543         {
3544             return null;
3545         }
Multiply(double v)3546         internal override object Multiply(double v)
3547         {
3548             return null;
3549         }
Multiply(decimal v)3550         internal override object Multiply(decimal v)
3551         {
3552             return null;
3553         }
3554         #endregion
3555         #region Divide
Divide(ArithmeticLiteral v)3556         internal override object Divide(ArithmeticLiteral v)
3557         {
3558             return v.Divide();
3559         }
Divide()3560         internal override object Divide()
3561         {
3562             return null;
3563         }
Divide(int v)3564         internal override object Divide(int v)
3565         {
3566             return null;
3567         }
Divide(long v)3568         internal override object Divide(long v)
3569         {
3570             return null;
3571         }
Divide(ushort v)3572         internal override object Divide(ushort v)
3573         {
3574             return null;
3575         }
Divide(uint v)3576         internal override object Divide(uint v)
3577         {
3578             return null;
3579         }
Divide(ulong v)3580         internal override object Divide(ulong v)
3581         {
3582             return null;
3583         }
Divide(float v)3584         internal override object Divide(float v)
3585         {
3586             return null;
3587         }
Divide(double v)3588         internal override object Divide(double v)
3589         {
3590             return null;
3591         }
Divide(decimal v)3592         internal override object Divide(decimal v)
3593         {
3594             return null;
3595         }
3596         #endregion
3597         #region Modulus
Modulus(ArithmeticLiteral v)3598         internal override object Modulus(ArithmeticLiteral v)
3599         {
3600             return v.Modulus();
3601         }
Modulus()3602         internal override object Modulus()
3603         {
3604             return null;
3605         }
Modulus(int v)3606         internal override object Modulus(int v)
3607         {
3608             return null;
3609         }
Modulus(long v)3610         internal override object Modulus(long v)
3611         {
3612             return null;
3613         }
Modulus(ushort v)3614         internal override object Modulus(ushort v)
3615         {
3616             return null;
3617         }
Modulus(uint v)3618         internal override object Modulus(uint v)
3619         {
3620             return null;
3621         }
Modulus(ulong v)3622         internal override object Modulus(ulong v)
3623         {
3624             return null;
3625         }
Modulus(float v)3626         internal override object Modulus(float v)
3627         {
3628             return null;
3629         }
Modulus(double v)3630         internal override object Modulus(double v)
3631         {
3632             return null;
3633         }
Modulus(decimal v)3634         internal override object Modulus(decimal v)
3635         {
3636             return null;
3637         }
3638         #endregion
3639         #region BitAnd
BitAnd(ArithmeticLiteral v)3640         internal override object BitAnd(ArithmeticLiteral v)
3641         {
3642             return v.BitAnd();
3643         }
BitAnd()3644         internal override object BitAnd()
3645         {
3646             return null;
3647         }
BitAnd(int v)3648         internal override object BitAnd(int v)
3649         {
3650             return null;
3651         }
BitAnd(long v)3652         internal override object BitAnd(long v)
3653         {
3654             return null;
3655         }
BitAnd(ushort v)3656         internal override object BitAnd(ushort v)
3657         {
3658             return null;
3659         }
BitAnd(uint v)3660         internal override object BitAnd(uint v)
3661         {
3662             return null;
3663         }
BitAnd(ulong v)3664         internal override object BitAnd(ulong v)
3665         {
3666             return null;
3667         }
BitAnd(bool v)3668         internal override object BitAnd(bool v)
3669         {
3670             // special case from section 24.3.6 on bool? type
3671             return (v == false) ? (object)false : null;
3672         }
3673         #endregion
3674         #region BitOr
BitOr(ArithmeticLiteral v)3675         internal override object BitOr(ArithmeticLiteral v)
3676         {
3677             return v.BitOr();
3678         }
BitOr()3679         internal override object BitOr()
3680         {
3681             return null;
3682         }
BitOr(int v)3683         internal override object BitOr(int v)
3684         {
3685             return null;
3686         }
BitOr(long v)3687         internal override object BitOr(long v)
3688         {
3689             return null;
3690         }
BitOr(ushort v)3691         internal override object BitOr(ushort v)
3692         {
3693             return null;
3694         }
BitOr(uint v)3695         internal override object BitOr(uint v)
3696         {
3697             return null;
3698         }
BitOr(ulong v)3699         internal override object BitOr(ulong v)
3700         {
3701             return null;
3702         }
BitOr(bool v)3703         internal override object BitOr(bool v)
3704         {
3705             // special case from section 24.3.6 on bool? type
3706             return (v == true) ? (object)true : null;
3707         }
3708         #endregion
3709     }
3710     #endregion
3711 }
3712