Literal.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Activities / Rules / Literal.cs / 1305376 / Literal.cs

                            // ---------------------------------------------------------------------------- 
// Copyright (C) 2005 Microsoft Corporation All Rights Reserved
// ---------------------------------------------------------------------------

#define CODE_ANALYSIS 
using System.CodeDom;
using System.Collections.Generic; 
using System.Diagnostics; 
using System.Diagnostics.CodeAnalysis;
using System.Globalization; 
using System.Reflection;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.Activities.Common; 

namespace System.Workflow.Activities.Rules 
{ 
    #region Literal Class
    ///  
    /// Represents a typed literal value and is the base class for all type specific literal classes
    /// 
    internal abstract class Literal
    { 
        #region Properties
        ///  
        /// A delegate for literal factory methods 
        /// 
        private delegate Literal LiteralMaker(object literalValue); 

        /// 
        /// Collection of literal factory methods indexed by type
        ///  
        static private Dictionary types = CreateMakersDictionary();
 
        ///  
        /// The type of the literal
        ///  
        protected internal Type m_type;

        /// 
        /// Get the boxed literal 
        /// 
        internal abstract object Value { get; } 
 
        /// 
        /// Group types by similar characteristics so we can check if comparisons succeed 
        /// 
        [Flags()]
        enum TypeFlags
        { 
            SignedNumbers = 0x01,
            UnsignedNumbers = 0x02, 
            ULong = 0x04, 
            Float = 0x08,
            Decimal = 0x10, 
            String = 0x20,
            Bool = 0x40
        };
 
        /// 
        /// Collection of TypeFlags for the supported value types indexed by type 
        ///  
        private static Dictionary supportedTypes = CreateTypesDictionary();
 
        private static Dictionary CreateMakersDictionary()
        {
            // Create the literal class factory delegates
            Dictionary dictionary = new Dictionary(32); 
            dictionary.Add(typeof(byte), new LiteralMaker(Literal.MakeByte));
            dictionary.Add(typeof(sbyte), new LiteralMaker(Literal.MakeSByte)); 
            dictionary.Add(typeof(short), new LiteralMaker(Literal.MakeShort)); 
            dictionary.Add(typeof(int), new LiteralMaker(Literal.MakeInt));
            dictionary.Add(typeof(long), new LiteralMaker(Literal.MakeLong)); 
            dictionary.Add(typeof(ushort), new LiteralMaker(Literal.MakeUShort));
            dictionary.Add(typeof(uint), new LiteralMaker(Literal.MakeUInt));
            dictionary.Add(typeof(ulong), new LiteralMaker(Literal.MakeULong));
            dictionary.Add(typeof(float), new LiteralMaker(Literal.MakeFloat)); 
            dictionary.Add(typeof(double), new LiteralMaker(Literal.MakeDouble));
            dictionary.Add(typeof(char), new LiteralMaker(Literal.MakeChar)); 
            dictionary.Add(typeof(string), new LiteralMaker(Literal.MakeString)); 
            dictionary.Add(typeof(decimal), new LiteralMaker(Literal.MakeDecimal));
            dictionary.Add(typeof(bool), new LiteralMaker(Literal.MakeBool)); 
            dictionary.Add(typeof(byte?), new LiteralMaker(Literal.MakeByte));
            dictionary.Add(typeof(sbyte?), new LiteralMaker(Literal.MakeSByte));
            dictionary.Add(typeof(short?), new LiteralMaker(Literal.MakeShort));
            dictionary.Add(typeof(int?), new LiteralMaker(Literal.MakeInt)); 
            dictionary.Add(typeof(long?), new LiteralMaker(Literal.MakeLong));
            dictionary.Add(typeof(ushort?), new LiteralMaker(Literal.MakeUShort)); 
            dictionary.Add(typeof(uint?), new LiteralMaker(Literal.MakeUInt)); 
            dictionary.Add(typeof(ulong?), new LiteralMaker(Literal.MakeULong));
            dictionary.Add(typeof(float?), new LiteralMaker(Literal.MakeFloat)); 
            dictionary.Add(typeof(double?), new LiteralMaker(Literal.MakeDouble));
            dictionary.Add(typeof(char?), new LiteralMaker(Literal.MakeChar));
            dictionary.Add(typeof(decimal?), new LiteralMaker(Literal.MakeDecimal));
            dictionary.Add(typeof(bool?), new LiteralMaker(Literal.MakeBool)); 
            return dictionary;
        } 
 
        private static Dictionary CreateTypesDictionary()
        { 
            // Create the literal class factory delegates
            Dictionary dictionary = new Dictionary(32);
            dictionary.Add(typeof(byte), TypeFlags.UnsignedNumbers);
            dictionary.Add(typeof(byte?), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(sbyte), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(sbyte?), TypeFlags.SignedNumbers); 
            dictionary.Add(typeof(short), TypeFlags.SignedNumbers); 
            dictionary.Add(typeof(short?), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(int), TypeFlags.SignedNumbers); 
            dictionary.Add(typeof(int?), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(long), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(long?), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(ushort), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(ushort?), TypeFlags.UnsignedNumbers);
            dictionary.Add(typeof(uint), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(uint?), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(ulong), TypeFlags.ULong);
            dictionary.Add(typeof(ulong?), TypeFlags.ULong); 
            dictionary.Add(typeof(float), TypeFlags.Float);
            dictionary.Add(typeof(float?), TypeFlags.Float);
            dictionary.Add(typeof(double), TypeFlags.Float);
            dictionary.Add(typeof(double?), TypeFlags.Float); 
            dictionary.Add(typeof(char), TypeFlags.UnsignedNumbers);
            dictionary.Add(typeof(char?), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(string), TypeFlags.String); 
            dictionary.Add(typeof(decimal), TypeFlags.Decimal);
            dictionary.Add(typeof(decimal?), TypeFlags.Decimal); 
            dictionary.Add(typeof(bool), TypeFlags.Bool);
            dictionary.Add(typeof(bool?), TypeFlags.Bool);
            return dictionary;
        } 
        #endregion
 
        #region Factory Methods 
        internal static Literal MakeLiteral(Type literalType, object literalValue)
        { 
            if (literalValue == null)
                return new NullLiteral(literalType);

            LiteralMaker f; 
            if (types.TryGetValue(literalType, out f))
            { 
                try 
                {
                    return f(literalValue); 
                }
                catch (InvalidCastException e)
                {
                    throw new RuleEvaluationIncompatibleTypesException( 
                        string.Format(CultureInfo.CurrentCulture,
                            Messages.InvalidCast, 
                            RuleDecompiler.DecompileType(literalValue.GetType()), 
                            RuleDecompiler.DecompileType(literalType)),
                        literalType, 
                        CodeBinaryOperatorType.Assign,
                        literalValue.GetType(),
                        e);
                } 
            }
            return null; 
        } 

        ///  
        /// Factory function for a boolean type
        /// 
        /// 
        ///  
        private static Literal MakeBool(object literalValue)
        { 
            return new BoolLiteral((bool)literalValue); 
        }
 
        /// 
        /// Factory function for a byte type
        /// 
        ///  
        /// 
        private static Literal MakeByte(object literalValue) 
        { 
            return new ByteLiteral((byte)literalValue);
        } 

        /// 
        /// Factory function for a sbyte type
        ///  
        /// 
        ///  
        private static Literal MakeSByte(object literalValue) 
        {
            return new SByteLiteral((sbyte)literalValue); 
        }

        /// 
        /// Factory function for a char type 
        /// 
        ///  
        ///  
        private static Literal MakeChar(object literalValue)
        { 
            return new CharLiteral((char)literalValue);
        }

        ///  
        /// Factory function for a decimal type
        ///  
        ///  
        /// 
        private static Literal MakeDecimal(object literalValue) 
        {
            return new DecimalLiteral((decimal)literalValue);
        }
 
        /// 
        /// Factory function for an Int16 type 
        ///  
        /// 
        ///  
        private static Literal MakeShort(object literalValue)
        {
            return new ShortLiteral((short)literalValue);
        } 

        ///  
        /// Factory function for an Int32 type 
        /// 
        ///  
        /// 
        private static Literal MakeInt(object literalValue)
        {
            return new IntLiteral((int)literalValue); 
        }
 
        ///  
        /// Factory function for an Int64 type
        ///  
        /// 
        /// 
        private static Literal MakeLong(object literalValue)
        { 
            return new LongLiteral((long)literalValue);
        } 
 
        /// 
        /// Factory function for an UInt16 type 
        /// 
        /// 
        /// 
        private static Literal MakeUShort(object literalValue) 
        {
            return new UShortLiteral((ushort)literalValue); 
        } 

        ///  
        /// Factory function for an UInt32 type
        /// 
        /// 
        ///  
        private static Literal MakeUInt(object literalValue)
        { 
            return new UIntLiteral((uint)literalValue); 
        }
 
        /// 
        /// Factory function for an UInt64 type
        /// 
        ///  
        /// 
        private static Literal MakeULong(object literalValue) 
        { 
            return new ULongLiteral((ulong)literalValue);
        } 

        /// 
        /// Factory function for a float type
        ///  
        /// 
        ///  
        private static Literal MakeFloat(object literalValue) 
        {
            return new FloatLiteral((float)literalValue); 
        }

        /// 
        /// Factory function for a double type 
        /// 
        ///  
        ///  
        private static Literal MakeDouble(object literalValue)
        { 
            return new DoubleLiteral((double)literalValue);
        }

        ///  
        /// Factory function for a string type
        ///  
        ///  
        /// 
        private static Literal MakeString(object literalValue) 
        {
            return new StringLiteral((string)literalValue);
        }
        #endregion 

        #region Default Operators 
        internal static class DefaultOperators 
        {
            public static int Addition(int x, int y) { return x + y; } 
            public static uint Addition(uint x, uint y) { return x + y; }
            public static long Addition(long x, long y) { return x + y; }
            public static ulong Addition(ulong x, ulong y) { return x + y; }
            public static float Addition(float x, float y) { return x + y; } 
            public static double Addition(double x, double y) { return x + y; }
            public static decimal Addition(decimal x, decimal y) { return x + y; } 
            public static string Addition(string x, string y) { return x + y; } 
            public static string Addition(string x, object y) { return x + y; }
            public static string Addition(object x, string y) { return x + y; } 

            public static int Subtraction(int x, int y) { return x - y; }
            public static uint Subtraction(uint x, uint y) { return x - y; }
            public static long Subtraction(long x, long y) { return x - y; } 
            public static ulong Subtraction(ulong x, ulong y) { return x - y; }
            public static float Subtraction(float x, float y) { return x - y; } 
            public static double Subtraction(double x, double y) { return x - y; } 
            public static decimal Subtraction(decimal x, decimal y) { return x - y; }
 
            public static int Multiply(int x, int y) { return x * y; }
            public static uint Multiply(uint x, uint y) { return x * y; }
            public static long Multiply(long x, long y) { return x * y; }
            public static ulong Multiply(ulong x, ulong y) { return x * y; } 
            public static float Multiply(float x, float y) { return x * y; }
            public static double Multiply(double x, double y) { return x * y; } 
            public static decimal Multiply(decimal x, decimal y) { return x * y; } 

            public static int Division(int x, int y) { return x / y; } 
            public static uint Division(uint x, uint y) { return x / y; }
            public static long Division(long x, long y) { return x / y; }
            public static ulong Division(ulong x, ulong y) { return x / y; }
            public static float Division(float x, float y) { return x / y; } 
            public static double Division(double x, double y) { return x / y; }
            public static decimal Division(decimal x, decimal y) { return x / y; } 
 
            public static int Modulus(int x, int y) { return x % y; }
            public static uint Modulus(uint x, uint y) { return x % y; } 
            public static long Modulus(long x, long y) { return x % y; }
            public static ulong Modulus(ulong x, ulong y) { return x % y; }
            public static float Modulus(float x, float y) { return x % y; }
            public static double Modulus(double x, double y) { return x % y; } 
            public static decimal Modulus(decimal x, decimal y) { return x % y; }
 
            public static int BitwiseAnd(int x, int y) { return x & y; } 
            public static uint BitwiseAnd(uint x, uint y) { return x & y; }
            public static long BitwiseAnd(long x, long y) { return x & y; } 
            public static ulong BitwiseAnd(ulong x, ulong y) { return x & y; }
            public static bool BitwiseAnd(bool x, bool y) { return x & y; }

            public static int BitwiseOr(int x, int y) { return x | y; } 
            public static uint BitwiseOr(uint x, uint y) { return x | y; }
            public static long BitwiseOr(long x, long y) { return x | y; } 
            public static ulong BitwiseOr(ulong x, ulong y) { return x | y; } 
            public static bool BitwiseOr(bool x, bool y) { return x | y; }
 
            public static bool Equality(int x, int y) { return x == y; }
            public static bool Equality(uint x, uint y) { return x == y; }
            public static bool Equality(long x, long y) { return x == y; }
            public static bool Equality(ulong x, ulong y) { return x == y; } 
            public static bool Equality(float x, float y) { return x == y; }
            public static bool Equality(double x, double y) { return x == y; } 
            public static bool Equality(decimal x, decimal y) { return x == y; } 
            public static bool Equality(bool x, bool y) { return x == y; }
            public static bool Equality(string x, string y) { return x == y; } 
            // mark object == object since it has special rules
            public static bool ObjectEquality(object x, object y) { return x == y; }

            public static bool GreaterThan(int x, int y) { return x > y; } 
            public static bool GreaterThan(uint x, uint y) { return x > y; }
            public static bool GreaterThan(long x, long y) { return x > y; } 
            public static bool GreaterThan(ulong x, ulong y) { return x > y; } 
            public static bool GreaterThan(float x, float y) { return x > y; }
            public static bool GreaterThan(double x, double y) { return x > y; } 
            public static bool GreaterThan(decimal x, decimal y) { return x > y; }

            public static bool GreaterThanOrEqual(int x, int y) { return x >= y; }
            public static bool GreaterThanOrEqual(uint x, uint y) { return x >= y; } 
            public static bool GreaterThanOrEqual(long x, long y) { return x >= y; }
            public static bool GreaterThanOrEqual(ulong x, ulong y) { return x >= y; } 
            public static bool GreaterThanOrEqual(float x, float y) { return x >= y; } 
            public static bool GreaterThanOrEqual(double x, double y) { return x >= y; }
            public static bool GreaterThanOrEqual(decimal x, decimal y) { return x >= y; } 

            public static bool LessThan(int x, int y) { return x < y; }
            public static bool LessThan(uint x, uint y) { return x < y; }
            public static bool LessThan(long x, long y) { return x < y; } 
            public static bool LessThan(ulong x, ulong y) { return x < y; }
            public static bool LessThan(float x, float y) { return x < y; } 
            public static bool LessThan(double x, double y) { return x < y; } 
            public static bool LessThan(decimal x, decimal y) { return x < y; }
 
            public static bool LessThanOrEqual(int x, int y) { return x <= y; }
            public static bool LessThanOrEqual(uint x, uint y) { return x <= y; }
            public static bool LessThanOrEqual(long x, long y) { return x <= y; }
            public static bool LessThanOrEqual(ulong x, ulong y) { return x <= y; } 
            public static bool LessThanOrEqual(float x, float y) { return x <= y; }
            public static bool LessThanOrEqual(double x, double y) { return x <= y; } 
            public static bool LessThanOrEqual(decimal x, decimal y) { return x <= y; } 
        }
        #endregion 

        #region Type Checking Methods

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] 
        internal static RuleBinaryExpressionInfo AllowedComparison(
            Type lhs, 
            CodeExpression lhsExpression, 
            Type rhs,
            CodeExpression rhsExpression, 
            CodeBinaryOperatorType comparison,
            RuleValidation validator,
            out ValidationError error)
        { 
            // note that null values come in as a NullLiteral type
            TypeFlags lhsFlags, rhsFlags; 
 
            // are the types supported?
            if ((supportedTypes.TryGetValue(lhs, out lhsFlags)) && (supportedTypes.TryGetValue(rhs, out rhsFlags))) 
            {
                // both sides supported
                if (lhsFlags == rhsFlags)
                { 
                    // both sides the same type, so it's allowed
                    // only allow equality on booleans 
                    if ((lhsFlags == TypeFlags.Bool) && (comparison != CodeBinaryOperatorType.ValueEquality)) 
                    {
                        string message = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), 
                            RuleDecompiler.DecompileType(lhs),
                            RuleDecompiler.DecompileType(rhs));
                        error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                        return null; 
                    }
                    error = null; 
                    return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); 
                }
 
                // if not the same, only certain combinations allowed
                switch (lhsFlags | rhsFlags)
                {
                    case TypeFlags.Decimal | TypeFlags.SignedNumbers: 
                    case TypeFlags.Decimal | TypeFlags.UnsignedNumbers:
                    case TypeFlags.Decimal | TypeFlags.ULong: 
                    case TypeFlags.Float | TypeFlags.SignedNumbers: 
                    case TypeFlags.Float | TypeFlags.UnsignedNumbers:
                    case TypeFlags.Float | TypeFlags.ULong: 
                    case TypeFlags.ULong | TypeFlags.UnsignedNumbers:
                    case TypeFlags.SignedNumbers | TypeFlags.UnsignedNumbers:
                        error = null;
                        return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); 
                }
                string message2 = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), 
                    (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs), 
                    (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs));
                error = new ValidationError(message2, ErrorNumbers.Error_OperandTypesIncompatible); 
                return null;
            }
            else
            { 
                // see if they override the operator
                MethodInfo operatorOverride = MapOperatorToMethod(comparison, lhs, lhsExpression, rhs, rhsExpression, validator, out error); 
                if (operatorOverride != null) 
                    return new RuleBinaryExpressionInfo(lhs, rhs, operatorOverride);
 
                // unable to evaluate, so return false
                return null;
            }
        } 

        internal enum OperatorGrouping 
        { 
            Arithmetic,
            Equality, 
            Relational
        }

        internal static MethodInfo ObjectEquality = typeof(DefaultOperators).GetMethod("ObjectEquality"); 

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] 
        [SuppressMessage("Microsoft.Performance", "CA1803:AvoidCostlyCallsWherePossible")] 
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]     // bogus since the casts are in different case statements
        internal static MethodInfo MapOperatorToMethod( 
            CodeBinaryOperatorType op,
            Type lhs,
            CodeExpression lhsExpression,
            Type rhs, 
            CodeExpression rhsExpression,
            RuleValidation validator, 
            out ValidationError error) 
        {
            // determine what the method name should be 
            string methodName;
            string message;
            OperatorGrouping group;
 
            switch (op)
            { 
                case CodeBinaryOperatorType.ValueEquality: 
                    methodName = "op_Equality";
                    group = OperatorGrouping.Equality; 
                    break;
                case CodeBinaryOperatorType.GreaterThan:
                    methodName = "op_GreaterThan";
                    group = OperatorGrouping.Relational; 
                    break;
                case CodeBinaryOperatorType.GreaterThanOrEqual: 
                    methodName = "op_GreaterThanOrEqual"; 
                    group = OperatorGrouping.Relational;
                    break; 
                case CodeBinaryOperatorType.LessThan:
                    methodName = "op_LessThan";
                    group = OperatorGrouping.Relational;
                    break; 
                case CodeBinaryOperatorType.LessThanOrEqual:
                    methodName = "op_LessThanOrEqual"; 
                    group = OperatorGrouping.Relational; 
                    break;
                case CodeBinaryOperatorType.Add: 
                    methodName = "op_Addition";
                    group = OperatorGrouping.Arithmetic;
                    break;
                case CodeBinaryOperatorType.Subtract: 
                    methodName = "op_Subtraction";
                    group = OperatorGrouping.Arithmetic; 
                    break; 
                case CodeBinaryOperatorType.Multiply:
                    methodName = "op_Multiply"; 
                    group = OperatorGrouping.Arithmetic;
                    break;
                case CodeBinaryOperatorType.Divide:
                    methodName = "op_Division"; 
                    group = OperatorGrouping.Arithmetic;
                    break; 
                case CodeBinaryOperatorType.Modulus: 
                    methodName = "op_Modulus";
                    group = OperatorGrouping.Arithmetic; 
                    break;
                case CodeBinaryOperatorType.BitwiseAnd:
                    methodName = "op_BitwiseAnd";
                    group = OperatorGrouping.Arithmetic; 
                    break;
                case CodeBinaryOperatorType.BitwiseOr: 
                    methodName = "op_BitwiseOr"; 
                    group = OperatorGrouping.Arithmetic;
                    break; 
                default:
                    Debug.Assert(false, "Operator " + op.ToString() + " not implemented");
                    message = string.Format(CultureInfo.CurrentCulture, Messages.BinaryOpNotSupported, op.ToString());
                    error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled); 
                    return null;
            } 
 
            // NOTE: types maybe NullLiteral, which signifies the constant "null"
            List candidates = new List(); 
            bool lhsNullable = ConditionHelper.IsNullableValueType(lhs);
            bool rhsNullable = ConditionHelper.IsNullableValueType(rhs);
            Type lhsType0 = (lhsNullable) ? Nullable.GetUnderlyingType(lhs) : lhs;
            Type rhsType0 = (rhsNullable) ? Nullable.GetUnderlyingType(rhs) : rhs; 

            // special cases for enums 
            if (lhsType0.IsEnum) 
            {
                // only 3 cases (U = underlying type of E): 
                //    E = E + U
                //    U = E - E
                //    E = E - U
                // plus the standard comparisons (E == E, E > E, etc.) 
                // need to also allow E == 0
                Type underlyingType; 
                switch (op) 
                {
                    case CodeBinaryOperatorType.Add: 
                        underlyingType = EnumHelper.GetUnderlyingType(lhsType0);
                        if ((underlyingType != null) &&
                            (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error)))
                        { 
                            error = null;
                            return new EnumOperationMethodInfo(lhs, op, rhs, false); 
                        } 
                        break;
                    case CodeBinaryOperatorType.Subtract: 
                        underlyingType = EnumHelper.GetUnderlyingType(lhsType0);
                        if (underlyingType != null)
                        {
                            if (lhsType0 == rhsType0) 
                            {
                                // E - E 
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, false);
                            } 
                            else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression))
                            {
                                // E - 0, can convert 0 to E
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, true);
                            } 
                            else if (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error)) 
                            {
                                // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about) 
                                error = null;
                                return new EnumOperationMethodInfo(lhs, op, rhs, false);
                            }
                        } 
                        break;
                    case CodeBinaryOperatorType.ValueEquality: 
                    case CodeBinaryOperatorType.LessThan: 
                    case CodeBinaryOperatorType.LessThanOrEqual:
                    case CodeBinaryOperatorType.GreaterThan: 
                    case CodeBinaryOperatorType.GreaterThanOrEqual:
                        if (lhsType0 == rhsType0)
                        {
                            error = null; 
                            return new EnumOperationMethodInfo(lhs, op, rhs, false);
                        } 
                        else if (lhsNullable && (rhs == typeof(NullLiteral))) 
                        {
                            // handle enum? op null 
                            // treat the rhs as the same nullable enum
                            error = null;
                            return new EnumOperationMethodInfo(lhs, op, lhs, false);
                        } 
                        else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression))
                        { 
                            error = null; 
                            return new EnumOperationMethodInfo(lhs, op, rhs, true);
                        } 
                        break;
                }
                // can't do it, sorry
                // but check if there is a user-defined operator that works 
            }
            else if (rhsType0.IsEnum) 
            { 
                // lhs != enum, so only 2 cases (U = underlying type of E):
                //    E = U + E 
                //    E = U - E
                // comparisons are E == E, etc., so if the lhs is not an enum, too bad
                // although we need to check for 0 == E
                Type underlyingType; 
                switch (op)
                { 
                    case CodeBinaryOperatorType.Add: 
                        underlyingType = EnumHelper.GetUnderlyingType(rhsType0);
                        if ((underlyingType != null) && 
                            (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error)))
                        {
                            error = null;
                            return new EnumOperationMethodInfo(lhs, op, rhs, false); 
                        }
                        break; 
 
                    case CodeBinaryOperatorType.Subtract:
                        underlyingType = EnumHelper.GetUnderlyingType(rhsType0); 
                        if (underlyingType != null)
                        {
                            CodePrimitiveExpression primitive = lhsExpression as CodePrimitiveExpression;
                            if (DecimalIntegerLiteralZero(lhs, primitive)) 
                            {
                                // 0 - E, can convert 0 to E 
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, true);
                            } 
                            else if (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error))
                            {
                                // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about)
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, false);
                            } 
                        } 
                        break;
 
                    case CodeBinaryOperatorType.ValueEquality:
                    case CodeBinaryOperatorType.LessThan:
                    case CodeBinaryOperatorType.LessThanOrEqual:
                    case CodeBinaryOperatorType.GreaterThan: 
                    case CodeBinaryOperatorType.GreaterThanOrEqual:
                        if (rhsNullable && (lhs == typeof(NullLiteral))) 
                        { 
                            // handle null op enum?
                            // treat the lhs as the same nullable enum type 
                            error = null;
                            return new EnumOperationMethodInfo(rhs, op, rhs, false);
                        }
                        else if (DecimalIntegerLiteralZero(lhs, lhsExpression as CodePrimitiveExpression)) 
                        {
                            error = null; 
                            return new EnumOperationMethodInfo(lhs, op, rhs, true); 
                        }
                        break; 
                }

                // can't do it, sorry
                // but check if there is a user-defined operator that works 
            }
 
            // enum specific operations already handled, see if one side (or both) define operators 
            AddOperatorOverloads(lhsType0, methodName, lhs, rhs, candidates);
            AddOperatorOverloads(rhsType0, methodName, lhs, rhs, candidates); 
            if (lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)))
            {
                // need to add in lifted methods
                AddLiftedOperators(lhsType0, methodName, group, lhsType0, rhsType0, candidates); 
                AddLiftedOperators(rhsType0, methodName, group, lhsType0, rhsType0, candidates);
            } 
 
            if (candidates.Count == 0)
            { 
                // no overrides, so get the default list
                methodName = methodName.Substring(3);		// strip off the op_
                foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods())
                { 
                    if (mi.Name == methodName)
                    { 
                        ParameterInfo[] parameters = mi.GetParameters(); 
                        Type parm1 = parameters[0].ParameterType;
                        Type parm2 = parameters[1].ParameterType; 
                        if (RuleValidation.ImplicitConversion(lhs, parm1) &&
                            RuleValidation.ImplicitConversion(rhs, parm2))
                        {
                            candidates.Add(mi); 
                        }
                    } 
                } 

                // if no candidates and ==, can we use object == object? 
                if ((candidates.Count == 0) && ("Equality" == methodName))
                {
                    // C# 7.9.6
                    // references must be compatible 
                    // no boxing
                    // value types can't be compared 
                    if ((!lhs.IsValueType) && (!rhs.IsValueType)) 
                    {
                        // they are not classes, so references need to be compatible 
                        // also check for null (which is NullLiteral type) -- null is compatible with any object type
                        if ((lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)) ||
                            (lhs.IsAssignableFrom(rhs)) || (rhs.IsAssignableFrom(lhs)))
                        { 
                            candidates.Add(ObjectEquality);
                        } 
                    } 
                }
 
                // if no candidates and nullable, add lifted operators
                if ((candidates.Count == 0) && ((lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)))))
                {
                    foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods()) 
                    {
                        if (mi.Name == methodName) 
                        { 
                            ParameterInfo[] parameters = mi.GetParameters();
                            MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, lhsType0, rhsType0); 
                            if (liftedMethod != null)
                                candidates.Add(liftedMethod);
                        }
                    } 
                }
            } 
            if (candidates.Count == 1) 
            {
                // only 1, so it is it 
                error = null;
                return candidates[0];
            }
            else if (candidates.Count == 0) 
            {
                // nothing matched 
                message = string.Format(CultureInfo.CurrentCulture, 
                    (group == OperatorGrouping.Arithmetic) ? Messages.ArithOpBadTypes : Messages.RelationalOpBadTypes,
                    op.ToString(), 
                    (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs),
                    (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs));
                error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                return null; 
            }
            else 
            { 
                // more than 1, so pick the best one
                MethodInfo bestFit = validator.FindBestCandidate(null, candidates, lhs, rhs); 
                if (bestFit != null)
                {
                    error = null;
                    return bestFit; 
                }
                // must be ambiguous. Since there are at least 2 choices, show only the first 2 
                message = string.Format(CultureInfo.CurrentCulture, 
                    Messages.AmbiguousOperator,
                    op.ToString(), 
                    RuleDecompiler.DecompileMethod(candidates[0]),
                    RuleDecompiler.DecompileMethod(candidates[1]));
                error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                return null; 
            }
        } 
 
        private static bool DecimalIntegerLiteralZero(Type type, CodePrimitiveExpression expression)
        { 
            if (expression != null)
            {
                if (type == typeof(int))
                    return expression.Value.Equals(0); 
                else if (type == typeof(uint))
                    return expression.Value.Equals(0U); 
                else if (type == typeof(long)) 
                    return expression.Value.Equals(0L);
                else if (type == typeof(ulong)) 
                    return expression.Value.Equals(0UL);
            }
            return false;
        } 

        private static void AddOperatorOverloads(Type type, string methodName, Type arg1, Type arg2, List candidates) 
        { 
            // append the list of methods that match the name specified
            int numAdded = 0; 
            MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
            foreach (MethodInfo mi in possible)
            {
                ParameterInfo[] parameters = mi.GetParameters(); 
                if ((mi.Name == methodName) && (parameters.Length == 2))
                { 
                    if (EvaluateMethod(parameters, arg1, arg2)) 
                    {
                        ++numAdded; 
                        if (!candidates.Contains(mi))
                            candidates.Add(mi);
                    }
                } 
            }
            if ((numAdded > 0) || (type == typeof(object))) 
                return; 

            // no matches, check direct base class (if there is one) 
            type = type.BaseType;
            if (type != null)
            {
                possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); 
                foreach (MethodInfo mi in possible)
                { 
                    ParameterInfo[] parameters = mi.GetParameters(); 
                    if ((mi.Name == methodName) && (parameters.Length == 2))
                    { 
                        if (EvaluateMethod(parameters, arg1, arg2))
                        {
                            if (!candidates.Contains(mi))
                                candidates.Add(mi); 
                        }
                    } 
                } 
            }
        } 

        private static void AddLiftedOperators(Type type, string methodName, OperatorGrouping group, Type arg1, Type arg2, List candidates)
        {
            // append the list of lifted methods that match the name specified 
            int numAdded = 0;
            MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); 
            foreach (MethodInfo mi in possible) 
            {
                ParameterInfo[] parameters = mi.GetParameters(); 
                if ((mi.Name == methodName) && (parameters.Length == 2))
                {
                    MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2);
                    if (liftedMethod != null) 
                    {
                        ++numAdded; 
                        if (!candidates.Contains(liftedMethod)) 
                            candidates.Add(liftedMethod);
                    } 
                }
            }
            if ((numAdded > 0) || (type == typeof(object)))
                return; 

            // no matches, check direct base class (if there is one) 
            type = type.BaseType; 
            if (type != null)
            { 
                possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
                foreach (MethodInfo mi in possible)
                {
                    ParameterInfo[] parameters = mi.GetParameters(); 
                    if ((mi.Name == methodName) && (parameters.Length == 2))
                    { 
                        MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2); 
                        if ((liftedMethod != null) && !candidates.Contains(liftedMethod))
                            candidates.Add(liftedMethod); 
                    }
                }
            }
        } 

        private static bool EvaluateMethod(ParameterInfo[] parameters, Type arg1, Type arg2) 
        { 
            Type parm1 = parameters[0].ParameterType;
            Type parm2 = parameters[1].ParameterType; 
            return (RuleValidation.ImplicitConversion(arg1, parm1) &&
                    RuleValidation.ImplicitConversion(arg2, parm2));
        }
 
        private static MethodInfo EvaluateLiftedMethod(MethodInfo mi, ParameterInfo[] parameters, OperatorGrouping group, Type arg1, Type arg2)
        { 
            Type parm1 = parameters[0].ParameterType; 
            Type parm2 = parameters[1].ParameterType;
            if (ConditionHelper.IsNonNullableValueType(parm1) && ConditionHelper.IsNonNullableValueType(parm2)) 
            {
                // lift the parameters for testing conversions, if possible
                parm1 = typeof(Nullable<>).MakeGenericType(parm1);
                parm2 = typeof(Nullable<>).MakeGenericType(parm2); 
                switch (group)
                { 
                    case OperatorGrouping.Equality:		// for == != 
                        if (mi.ReturnType == typeof(bool) &&
                            RuleValidation.ImplicitConversion(arg1, parm1) && 
                            RuleValidation.ImplicitConversion(arg2, parm2))
                        {
                            return new LiftedEqualityOperatorMethodInfo(mi);
                        } 
                        break;
                    case OperatorGrouping.Relational:		// for < > <= >= 
                        if (mi.ReturnType == typeof(bool) && 
                            RuleValidation.ImplicitConversion(arg1, parm1) &&
                            RuleValidation.ImplicitConversion(arg2, parm2)) 
                        {
                            return new LiftedRelationalOperatorMethodInfo(mi);
                        }
                        break; 
                    case OperatorGrouping.Arithmetic:		// for + - * / % & ^
                        if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) && 
                            RuleValidation.ImplicitConversion(arg1, parm1) && 
                            RuleValidation.ImplicitConversion(arg2, parm2))
                        { 
                            return new LiftedArithmeticOperatorMethodInfo(mi);
                        }
                        break;
                } 
            }
            return null; 
        } 
        #endregion
 
        #region Value Type Dispatch Methods

        /// 
        /// Relational equal operator 
        /// Value-equality if we can do it, otherwise reference-equality
        ///  
        ///  
        /// 
        internal abstract bool Equal(Literal rhs); 
        internal virtual bool Equal(byte literalValue)
        {
            return false;
        } 
        internal virtual bool Equal(sbyte literalValue)
        { 
            return false; 
        }
        internal virtual bool Equal(short literalValue) 
        {
            return false;
        }
        internal virtual bool Equal(int literalValue) 
        {
            return false; 
        } 
        internal virtual bool Equal(long literalValue)
        { 
            return false;
        }
        internal virtual bool Equal(ushort literalValue)
        { 
            return false;
        } 
        internal virtual bool Equal(uint literalValue) 
        {
            return false; 
        }
        internal virtual bool Equal(ulong literalValue)
        {
            return false; 
        }
        internal virtual bool Equal(float literalValue) 
        { 
            return false;
        } 
        internal virtual bool Equal(double literalValue)
        {
            return false;
        } 
        internal virtual bool Equal(char literalValue)
        { 
            return false; 
        }
        internal virtual bool Equal(string literalValue) 
        {
            return false;
        }
        internal virtual bool Equal(decimal literalValue) 
        {
            return false; 
        } 
        internal virtual bool Equal(bool literalValue)
        { 
            return false;
        }

        ///  
        /// Relational less than operator
        ///  
        ///  
        /// 
        internal abstract bool LessThan(Literal rhs); 
        internal virtual bool LessThan()
        {
            return false;
        } 
        internal virtual bool LessThan(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        }
        internal virtual bool LessThan(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        } 
        internal virtual bool LessThan(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        }
        internal virtual bool LessThan(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        }

        ///  
        /// Relational greater than operator
        ///  
        ///  
        /// 
        internal abstract bool GreaterThan(Literal rhs); 
        internal virtual bool GreaterThan()
        {
            return false;
        } 
        internal virtual bool GreaterThan(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        }
        internal virtual bool GreaterThan(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        } 
        internal virtual bool GreaterThan(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        }
        internal virtual bool GreaterThan(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        }

        ///  
        /// Relational less than or equal to operator
        ///  
        ///  
        /// 
        internal abstract bool LessThanOrEqual(Literal rhs); 
        internal virtual bool LessThanOrEqual()
        {
            return false;
        } 
        internal virtual bool LessThanOrEqual(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        }
        internal virtual bool LessThanOrEqual(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        } 
        internal virtual bool LessThanOrEqual(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        }
        internal virtual bool LessThanOrEqual(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        }

        ///  
        /// Relational greater than or equal to operator
        ///  
        ///  
        /// 
        internal abstract bool GreaterThanOrEqual(Literal rhs); 
        internal virtual bool GreaterThanOrEqual()
        {
            return false;
        } 
        internal virtual bool GreaterThanOrEqual(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        }
        internal virtual bool GreaterThanOrEqual(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        } 
        internal virtual bool GreaterThanOrEqual(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        }
        internal virtual bool GreaterThanOrEqual(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        }
        #endregion
    } 
    #endregion
 
    #region Null Literal Class 
    /// 
    /// Represents an null literal 
    /// 
    internal class NullLiteral : Literal
    {
        // NOTE (from MSDN page on IComparable.CompareTo Method): 
        // By definition, any object compares greater than a null reference
        // But C# (24.3.1) doesn't -- if either side is null, result is false 
 
        internal NullLiteral(Type type)
        { 
            m_type = type;
        }

        internal override object Value 
        {
            get { return null; } 
        } 

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Value == null;
        }
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(); 
        }
        internal override bool LessThan(byte literalValue) 
        {
            return false;
        }
        internal override bool LessThan(char literalValue) 
        {
            return false; 
        } 
        internal override bool LessThan(sbyte literalValue)
        { 
            return false;
        }
        internal override bool LessThan(short literalValue)
        { 
            return false;
        } 
        internal override bool LessThan(int literalValue) 
        {
            return false; 
        }
        internal override bool LessThan(long literalValue)
        {
            return false; 
        }
        internal override bool LessThan(ushort literalValue) 
        { 
            return false;
        } 
        internal override bool LessThan(uint literalValue)
        {
            return false;
        } 
        internal override bool LessThan(ulong literalValue)
        { 
            return false; 
        }
        internal override bool LessThan(float literalValue) 
        {
            return false;
        }
        internal override bool LessThan(double literalValue) 
        {
            return false; 
        } 
        internal override bool LessThan(string literalValue)
        { 
            // for strings, maintain compatibility with v1
            return true;
        }
        internal override bool LessThan(decimal literalValue) 
        {
            return false; 
        } 

        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan();
        }
        internal override bool GreaterThan(byte literalValue) 
        {
            return false; 
        } 
        internal override bool GreaterThan(char literalValue)
        { 
            return false;
        }
        internal override bool GreaterThan(sbyte literalValue)
        { 
            return false;
        } 
        internal override bool GreaterThan(short literalValue) 
        {
            return false; 
        }
        internal override bool GreaterThan(int literalValue)
        {
            return false; 
        }
        internal override bool GreaterThan(long literalValue) 
        { 
            return false;
        } 
        internal override bool GreaterThan(ushort literalValue)
        {
            return false;
        } 
        internal override bool GreaterThan(uint literalValue)
        { 
            return false; 
        }
        internal override bool GreaterThan(ulong literalValue) 
        {
            return false;
        }
        internal override bool GreaterThan(float literalValue) 
        {
            return false; 
        } 
        internal override bool GreaterThan(double literalValue)
        { 
            return false;
        }
        internal override bool GreaterThan(string literalValue)
        { 
            return false;
        } 
        internal override bool GreaterThan(decimal literalValue) 
        {
            return false; 
        }

        /// 
        /// Relational less than or equal to operator 
        /// 
        ///  
        ///  
        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual();
        }
        internal override bool LessThanOrEqual()
        { 
            return (m_type == typeof(string));		// null == null for strings only
        } 
        internal override bool LessThanOrEqual(byte literalValue) 
        {
            return false; 
        }
        internal override bool LessThanOrEqual(char literalValue)
        {
            return false; 
        }
        internal override bool LessThanOrEqual(sbyte literalValue) 
        { 
            return false;
        } 
        internal override bool LessThanOrEqual(short literalValue)
        {
            return false;
        } 
        internal override bool LessThanOrEqual(int literalValue)
        { 
            return false; 
        }
        internal override bool LessThanOrEqual(long literalValue) 
        {
            return false;
        }
        internal override bool LessThanOrEqual(ushort literalValue) 
        {
            return false; 
        } 
        internal override bool LessThanOrEqual(uint literalValue)
        { 
            return false;
        }
        internal override bool LessThanOrEqual(ulong literalValue)
        { 
            return false;
        } 
        internal override bool LessThanOrEqual(float literalValue) 
        {
            return false; 
        }
        internal override bool LessThanOrEqual(double literalValue)
        {
            return false; 
        }
        internal override bool LessThanOrEqual(string literalValue) 
        { 
            // for strings, maintain compatibility with v1
            return true; 
        }
        internal override bool LessThanOrEqual(decimal literalValue)
        {
            return false; 
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(); 
        }
        internal override bool GreaterThanOrEqual()
        {
            return (m_type == typeof(string));		// null == null for strings only 
        }
        internal override bool GreaterThanOrEqual(byte literalValue) 
        { 
            return false;
        } 
        internal override bool GreaterThanOrEqual(char literalValue)
        {
            return false;
        } 
        internal override bool GreaterThanOrEqual(sbyte literalValue)
        { 
            return false; 
        }
        internal override bool GreaterThanOrEqual(short literalValue) 
        {
            return false;
        }
        internal override bool GreaterThanOrEqual(int literalValue) 
        {
            return false; 
        } 
        internal override bool GreaterThanOrEqual(long literalValue)
        { 
            return false;
        }
        internal override bool GreaterThanOrEqual(ushort literalValue)
        { 
            return false;
        } 
        internal override bool GreaterThanOrEqual(uint literalValue) 
        {
            return false; 
        }
        internal override bool GreaterThanOrEqual(ulong literalValue)
        {
            return false; 
        }
        internal override bool GreaterThanOrEqual(float literalValue) 
        { 
            return false;
        } 
        internal override bool GreaterThanOrEqual(double literalValue)
        {
            return false;
        } 
        internal override bool GreaterThanOrEqual(string literalValue)
        { 
            return false; 
        }
        internal override bool GreaterThanOrEqual(decimal literalValue) 
        {
            return false;
        }
    } 
    #endregion
 
    #region Boolean Literal Class 
    /// 
    /// Represents a boolean literal 
    /// 
    internal class BoolLiteral : Literal
    {
        private bool m_value; 

        internal override object Value 
        { 
            get { return m_value; }
        } 

        internal BoolLiteral(bool literalValue)
        {
            m_value = literalValue; 
            m_type = typeof(bool);
        } 
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        }
        internal override bool Equal(bool rhs)
        { 
            return m_value == rhs;
        } 
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        }

        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan(m_value); 
        } 

        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value);
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value); 
        }
    } 
    #endregion

    #region Byte Literal Class
    ///  
    /// Represents a byte literal
    ///  
    internal class ByteLiteral : Literal 
    {
        private byte m_value; 

        internal override object Value
        {
            get { return m_value; } 
        }
 
        internal ByteLiteral(byte literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(byte);
        }

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value); 
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ushort rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs; 
        }

        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        } 
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        { 
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs)
        { 
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(long rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs; 
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value);
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs)
        {
            return m_value >= rhs; 
        }
 
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(double rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs; 
        } 
    }
    #endregion 

    #region SByte Literal Class
    /// 
    /// Represents a byte literal 
    /// 
    internal class SByteLiteral : Literal 
    { 
        private sbyte m_value;
 
        internal override object Value
        {
            get { return m_value; }
        } 

        internal SByteLiteral(sbyte literalValue) 
        { 
            m_value = literalValue;
            m_type = typeof(sbyte); 
        }

        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(short rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(ulong rhs) 
        {
            return (m_value >= 0) && ((ulong)m_value == rhs);
        }
        internal override bool Equal(int rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(long rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(double rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        { 
            return m_value == rhs;
        } 

        internal override bool LessThan(Literal rhs)
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(float rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs)
        {
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs) 
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(long rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs)
        { 
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(long rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs;
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(short rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 

        }
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(float rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(decimal rhs)
        { 
            return m_value >= rhs; 
        }
    } 
    #endregion

    #region Char Literal Class
    ///  
    /// Represents a byte literal
    ///  
    internal class CharLiteral : Literal 
    {
        private char m_value; 

        internal override object Value
        {
            get { return m_value; } 
        }
 
        internal CharLiteral(char literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(char);
        }

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value); 
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ushort rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs; 
        }

        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        } 
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        { 
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs)
        { 
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(long rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs; 
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value);
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(int rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(long rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(float rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(decimal rhs)
        { 
            return m_value >= rhs;
        } 
    } 
    #endregion
 
    #region Decimal Literal Class
    /// 
    /// Represents a decimal literal
    ///  
    internal class DecimalLiteral : Literal
    { 
        private decimal m_value; 

        internal override object Value 
        {
            get { return m_value; }
        }
 
        internal DecimalLiteral(decimal literalValue)
        { 
            m_value = literalValue; 
            m_type = typeof(decimal);
        } 

        internal override bool Equal(Literal rhs)
        {
            return rhs.Equal(m_value); 
        }
        internal override bool Equal(sbyte rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(int rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ulong rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        { 
            return m_value == rhs;
        } 

        internal override bool LessThan(Literal rhs)
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        { 
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        { 
            return m_value > rhs;
        } 

        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(int rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        { 
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs)
        {
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        { 
            return m_value >= rhs;
        } 
    }
    #endregion

    #region Int16 Literal Class 
    /// 
    /// Represents an Int16 literal 
    ///  
    internal class ShortLiteral : Literal
    { 
        private short m_value;

        internal override object Value
        { 
            get { return m_value; }
        } 
 
        internal ShortLiteral(short literalValue)
        { 
            m_value = literalValue;
            m_type = typeof(short);
        }
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value); 
        }
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(short rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(int rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(long rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value == rhs); 
        }
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(decimal rhs)
        { 
            return m_value == rhs;
        }

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value); 
        } 
        internal override bool LessThan(sbyte rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(byte rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(int rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(decimal rhs)
        { 
            return m_value < rhs;
        } 
 
        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        }
        internal override bool GreaterThan(sbyte rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(float rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(double rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs; 
        }

        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(short rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(float rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs)
        {
            return m_value <= rhs; 
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(short rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(long rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(double rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        { 
            return m_value >= rhs;
        } 
    }
    #endregion

    #region Int32 Literal Class 
    /// 
    /// Represents an Int32 literal 
    ///  
    internal class IntLiteral : Literal
    { 
        private int m_value;

        internal override object Value
        { 
            get { return m_value; }
        } 
 
        internal IntLiteral(int literalValue)
        { 
            m_value = literalValue;
            m_type = typeof(int);
        }
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value); 
        }
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(short rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(int rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(long rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value == rhs); 
        }
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(decimal rhs)
        { 
            return m_value == rhs;
        }

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value); 
        } 
        internal override bool LessThan(sbyte rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(byte rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(int rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs) 
        {
            return (m_value < 0) || ((ulong)m_value < rhs); 
        } 
        internal override bool LessThan(float rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs) 
        {
            return m_value < rhs; 
        }

        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(short rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(long rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value > rhs);
        } 
        internal override bool GreaterThan(float rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        { 
            return m_value > rhs;
        } 

        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(int rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return (m_value < 0) || ((ulong)m_value <= rhs); 
        }
        internal override bool LessThanOrEqual(float rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(decimal rhs)
        { 
            return m_value <= rhs; 
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        {
            return rhs.LessThanOrEqual(m_value);
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(short rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ushort rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return (m_value >= 0) && ((ulong)m_value >= rhs);
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(double rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs; 
        } 
    }
    #endregion 

    #region Int64 Literal Class
    /// 
    /// Represents an Int64 literal 
    /// 
    internal class LongLiteral : Literal 
    { 
        private long m_value;
 
        internal override object Value
        {
            get { return m_value; }
        } 

        internal LongLiteral(long literalValue) 
        { 
            m_value = literalValue;
            m_type = typeof(long); 
        }

        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(short rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(int rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(uint rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(long rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value == rhs);
        } 
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(double rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        { 
            return m_value == rhs;
        } 

        internal override bool LessThan(Literal rhs)
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs)
        {
            return (m_value < 0) || ((ulong)m_value < rhs); 
        }
        internal override bool LessThan(float rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs)
        { 
            return m_value < rhs; 
        }
 
        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(char rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(short rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(long rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ulong rhs)
        {
            return (m_value >= 0) && ((ulong)m_value > rhs);
        } 
        internal override bool GreaterThan(float rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs; 
        } 

        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value);
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(byte rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ushort rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(int rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs) 
        {
            return (m_value < 0) || ((ulong)m_value <= rhs);
        }
        internal override bool LessThanOrEqual(float rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(double rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(decimal rhs)
        { 
            return m_value <= rhs;
        } 
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value);
        }
        internal override bool GreaterThanOrEqual(sbyte rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(char rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ushort rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value >= rhs);
        }
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs)
        {
            return m_value >= rhs; 
        }
    } 
    #endregion 

    #region UInt16 Literal Class 
    /// 
    /// Represents an UInt16 literal
    /// 
    internal class UShortLiteral : Literal 
    {
        private ushort m_value; 
 
        internal override object Value
        { 
            get { return m_value; }
        }

        internal UShortLiteral(ushort literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(ushort); 
        }
 
        internal override bool Equal(Literal rhs)
        {
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(short rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(ushort rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ulong rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs; 
        } 

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value);
        }
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(byte rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(uint rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(decimal rhs)
        { 
            return m_value < rhs;
        } 
 
        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        }
        internal override bool GreaterThan(sbyte rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(ulong rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(float rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs)
        {
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(decimal rhs)
        {
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        { 
            return rhs.LessThanOrEqual(m_value);
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(ushort rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs;
        }
    } 
    #endregion
 
    #region UInt32 Literal Class 
    /// 
    /// Represents an UInt32 literal 
    /// 
    internal class UIntLiteral : Literal
    {
        private uint m_value; 

        internal override object Value 
        { 
            get { return m_value; }
        } 

        internal UIntLiteral(uint literalValue)
        {
            m_value = literalValue; 
            m_type = typeof(uint);
        } 
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        }
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(ulong rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs)
        {
            return m_value == rhs; 
        }
 
        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(ulong rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(float rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs)
        {
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs) 
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(long rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(float rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs;
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(int rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(decimal rhs)
        { 
            return m_value <= rhs;
        }

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value); 
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs; 
        }
    }
    #endregion
 
    #region UInt64 Literal Class
    ///  
    /// Represents an UInt64 literal 
    /// 
    internal class ULongLiteral : Literal 
    {
        private ulong m_value;

        internal override object Value 
        {
            get { return m_value; } 
        } 

        internal ULongLiteral(ulong literalValue) 
        {
            m_value = literalValue;
            m_type = typeof(ulong);
        } 

        internal override bool Equal(Literal rhs) 
        { 
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return (rhs >= 0) && (m_value == (ulong)rhs); 
        }
        internal override bool Equal(short rhs) 
        {
            return (rhs >= 0) && (m_value == (ulong)rhs);
        }
        internal override bool Equal(int rhs) 
        {
            return (rhs >= 0) && (m_value == (ulong)rhs); 
        } 
        internal override bool Equal(long rhs)
        { 
            return (rhs >= 0) && (m_value == (ulong)rhs);
        }
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ulong rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(float rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs;
        }
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(byte rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(int rhs) 
        {
            return (rhs >= 0) && (m_value < (ulong)rhs); 
        } 
        internal override bool LessThan(long rhs)
        { 
            return (rhs >= 0) && (m_value < (ulong)rhs);
        }
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(uint rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        {
            return m_value < rhs;
        }
 
        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs) 
        {
            return (rhs < 0) || (m_value > (ulong)rhs); 
        } 
        internal override bool GreaterThan(long rhs)
        { 
            return (rhs < 0) || (m_value > (ulong)rhs);
        }
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(float rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs;
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return (rhs >= 0) && (m_value <= (ulong)rhs); 
        } 
        internal override bool LessThanOrEqual(long rhs)
        { 
            return (rhs >= 0) && (m_value <= (ulong)rhs);
        }
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs;
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return (rhs < 0) || (m_value >= (ulong)rhs); 
        } 
        internal override bool GreaterThanOrEqual(long rhs)
        { 
            return (rhs < 0) || (m_value >= (ulong)rhs);
        }
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs;
        }
    } 
    #endregion
 
    #region Double Literal Class 
    /// 
    /// Represents a double literal 
    /// 
    internal class DoubleLiteral : Literal
    {
        private double m_value; 

        internal override object Value 
        { 
            get { return m_value; }
        } 

        internal DoubleLiteral(double literalValue)
        {
            m_value = literalValue; 
            m_type = typeof(double);
        } 
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        }
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(ulong rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        }

        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        } 
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs; 
        }
 
        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(short rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(long rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ulong rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs) 
        { 
            return m_value > rhs;
        } 

        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(int rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        {
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        { 
            return rhs.LessThanOrEqual(m_value);
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(ushort rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs; 
        }
    } 
    #endregion

    #region Float Literal Class
    ///  
    /// Represents a float literal
    ///  
    internal class FloatLiteral : Literal 
    {
        private float m_value; 

        internal override object Value
        {
            get { return m_value; } 
        }
 
        internal FloatLiteral(float literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(float);
        }

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value); 
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ushort rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs;
        } 
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        }
        internal override bool LessThan(sbyte rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(float rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(double rhs) 
        {
            return m_value < rhs; 
        }

        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(short rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(long rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(ulong rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(float rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        { 
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs)
        {
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(float rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        {
            return m_value >= rhs;
        } 
    }
    #endregion 
 
    #region String Literal Class
    ///  
    /// Represents a string literal
    /// 
    internal class StringLiteral : Literal
    { 
        private string m_value;
 
        internal override object Value 
        {
            get { return m_value; } 
        }

        internal StringLiteral(string internalValue)
        { 
            m_value = internalValue;
            m_type = typeof(string); 
        } 

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value);
        }
        internal override bool Equal(string rhs) 
        {
            return m_value == rhs; 
        } 

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value);
        }
        internal override bool LessThan(string rhs) 
        {
            return 0 > string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); 
        } 

        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan(m_value);
        }
        internal override bool GreaterThan() 
        {
            return true; 
        } 
        internal override bool GreaterThan(string rhs)
        { 
            return 0 < string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture);
        }

        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value); 
        } 
        internal override bool LessThanOrEqual(string rhs)
        { 
            return 0 >= string.Compare(m_value, (string)rhs, false, System.Globalization.CultureInfo.CurrentCulture);
        }

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value); 
        } 
        internal override bool GreaterThanOrEqual()
        { 
            return true;
        }
        internal override bool GreaterThanOrEqual(string rhs)
        { 
            return 0 <= string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture);
        } 
    } 
    #endregion
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
// ---------------------------------------------------------------------------- 
// Copyright (C) 2005 Microsoft Corporation All Rights Reserved
// ---------------------------------------------------------------------------

#define CODE_ANALYSIS 
using System.CodeDom;
using System.Collections.Generic; 
using System.Diagnostics; 
using System.Diagnostics.CodeAnalysis;
using System.Globalization; 
using System.Reflection;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.Activities.Common; 

namespace System.Workflow.Activities.Rules 
{ 
    #region Literal Class
    ///  
    /// Represents a typed literal value and is the base class for all type specific literal classes
    /// 
    internal abstract class Literal
    { 
        #region Properties
        ///  
        /// A delegate for literal factory methods 
        /// 
        private delegate Literal LiteralMaker(object literalValue); 

        /// 
        /// Collection of literal factory methods indexed by type
        ///  
        static private Dictionary types = CreateMakersDictionary();
 
        ///  
        /// The type of the literal
        ///  
        protected internal Type m_type;

        /// 
        /// Get the boxed literal 
        /// 
        internal abstract object Value { get; } 
 
        /// 
        /// Group types by similar characteristics so we can check if comparisons succeed 
        /// 
        [Flags()]
        enum TypeFlags
        { 
            SignedNumbers = 0x01,
            UnsignedNumbers = 0x02, 
            ULong = 0x04, 
            Float = 0x08,
            Decimal = 0x10, 
            String = 0x20,
            Bool = 0x40
        };
 
        /// 
        /// Collection of TypeFlags for the supported value types indexed by type 
        ///  
        private static Dictionary supportedTypes = CreateTypesDictionary();
 
        private static Dictionary CreateMakersDictionary()
        {
            // Create the literal class factory delegates
            Dictionary dictionary = new Dictionary(32); 
            dictionary.Add(typeof(byte), new LiteralMaker(Literal.MakeByte));
            dictionary.Add(typeof(sbyte), new LiteralMaker(Literal.MakeSByte)); 
            dictionary.Add(typeof(short), new LiteralMaker(Literal.MakeShort)); 
            dictionary.Add(typeof(int), new LiteralMaker(Literal.MakeInt));
            dictionary.Add(typeof(long), new LiteralMaker(Literal.MakeLong)); 
            dictionary.Add(typeof(ushort), new LiteralMaker(Literal.MakeUShort));
            dictionary.Add(typeof(uint), new LiteralMaker(Literal.MakeUInt));
            dictionary.Add(typeof(ulong), new LiteralMaker(Literal.MakeULong));
            dictionary.Add(typeof(float), new LiteralMaker(Literal.MakeFloat)); 
            dictionary.Add(typeof(double), new LiteralMaker(Literal.MakeDouble));
            dictionary.Add(typeof(char), new LiteralMaker(Literal.MakeChar)); 
            dictionary.Add(typeof(string), new LiteralMaker(Literal.MakeString)); 
            dictionary.Add(typeof(decimal), new LiteralMaker(Literal.MakeDecimal));
            dictionary.Add(typeof(bool), new LiteralMaker(Literal.MakeBool)); 
            dictionary.Add(typeof(byte?), new LiteralMaker(Literal.MakeByte));
            dictionary.Add(typeof(sbyte?), new LiteralMaker(Literal.MakeSByte));
            dictionary.Add(typeof(short?), new LiteralMaker(Literal.MakeShort));
            dictionary.Add(typeof(int?), new LiteralMaker(Literal.MakeInt)); 
            dictionary.Add(typeof(long?), new LiteralMaker(Literal.MakeLong));
            dictionary.Add(typeof(ushort?), new LiteralMaker(Literal.MakeUShort)); 
            dictionary.Add(typeof(uint?), new LiteralMaker(Literal.MakeUInt)); 
            dictionary.Add(typeof(ulong?), new LiteralMaker(Literal.MakeULong));
            dictionary.Add(typeof(float?), new LiteralMaker(Literal.MakeFloat)); 
            dictionary.Add(typeof(double?), new LiteralMaker(Literal.MakeDouble));
            dictionary.Add(typeof(char?), new LiteralMaker(Literal.MakeChar));
            dictionary.Add(typeof(decimal?), new LiteralMaker(Literal.MakeDecimal));
            dictionary.Add(typeof(bool?), new LiteralMaker(Literal.MakeBool)); 
            return dictionary;
        } 
 
        private static Dictionary CreateTypesDictionary()
        { 
            // Create the literal class factory delegates
            Dictionary dictionary = new Dictionary(32);
            dictionary.Add(typeof(byte), TypeFlags.UnsignedNumbers);
            dictionary.Add(typeof(byte?), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(sbyte), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(sbyte?), TypeFlags.SignedNumbers); 
            dictionary.Add(typeof(short), TypeFlags.SignedNumbers); 
            dictionary.Add(typeof(short?), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(int), TypeFlags.SignedNumbers); 
            dictionary.Add(typeof(int?), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(long), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(long?), TypeFlags.SignedNumbers);
            dictionary.Add(typeof(ushort), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(ushort?), TypeFlags.UnsignedNumbers);
            dictionary.Add(typeof(uint), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(uint?), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(ulong), TypeFlags.ULong);
            dictionary.Add(typeof(ulong?), TypeFlags.ULong); 
            dictionary.Add(typeof(float), TypeFlags.Float);
            dictionary.Add(typeof(float?), TypeFlags.Float);
            dictionary.Add(typeof(double), TypeFlags.Float);
            dictionary.Add(typeof(double?), TypeFlags.Float); 
            dictionary.Add(typeof(char), TypeFlags.UnsignedNumbers);
            dictionary.Add(typeof(char?), TypeFlags.UnsignedNumbers); 
            dictionary.Add(typeof(string), TypeFlags.String); 
            dictionary.Add(typeof(decimal), TypeFlags.Decimal);
            dictionary.Add(typeof(decimal?), TypeFlags.Decimal); 
            dictionary.Add(typeof(bool), TypeFlags.Bool);
            dictionary.Add(typeof(bool?), TypeFlags.Bool);
            return dictionary;
        } 
        #endregion
 
        #region Factory Methods 
        internal static Literal MakeLiteral(Type literalType, object literalValue)
        { 
            if (literalValue == null)
                return new NullLiteral(literalType);

            LiteralMaker f; 
            if (types.TryGetValue(literalType, out f))
            { 
                try 
                {
                    return f(literalValue); 
                }
                catch (InvalidCastException e)
                {
                    throw new RuleEvaluationIncompatibleTypesException( 
                        string.Format(CultureInfo.CurrentCulture,
                            Messages.InvalidCast, 
                            RuleDecompiler.DecompileType(literalValue.GetType()), 
                            RuleDecompiler.DecompileType(literalType)),
                        literalType, 
                        CodeBinaryOperatorType.Assign,
                        literalValue.GetType(),
                        e);
                } 
            }
            return null; 
        } 

        ///  
        /// Factory function for a boolean type
        /// 
        /// 
        ///  
        private static Literal MakeBool(object literalValue)
        { 
            return new BoolLiteral((bool)literalValue); 
        }
 
        /// 
        /// Factory function for a byte type
        /// 
        ///  
        /// 
        private static Literal MakeByte(object literalValue) 
        { 
            return new ByteLiteral((byte)literalValue);
        } 

        /// 
        /// Factory function for a sbyte type
        ///  
        /// 
        ///  
        private static Literal MakeSByte(object literalValue) 
        {
            return new SByteLiteral((sbyte)literalValue); 
        }

        /// 
        /// Factory function for a char type 
        /// 
        ///  
        ///  
        private static Literal MakeChar(object literalValue)
        { 
            return new CharLiteral((char)literalValue);
        }

        ///  
        /// Factory function for a decimal type
        ///  
        ///  
        /// 
        private static Literal MakeDecimal(object literalValue) 
        {
            return new DecimalLiteral((decimal)literalValue);
        }
 
        /// 
        /// Factory function for an Int16 type 
        ///  
        /// 
        ///  
        private static Literal MakeShort(object literalValue)
        {
            return new ShortLiteral((short)literalValue);
        } 

        ///  
        /// Factory function for an Int32 type 
        /// 
        ///  
        /// 
        private static Literal MakeInt(object literalValue)
        {
            return new IntLiteral((int)literalValue); 
        }
 
        ///  
        /// Factory function for an Int64 type
        ///  
        /// 
        /// 
        private static Literal MakeLong(object literalValue)
        { 
            return new LongLiteral((long)literalValue);
        } 
 
        /// 
        /// Factory function for an UInt16 type 
        /// 
        /// 
        /// 
        private static Literal MakeUShort(object literalValue) 
        {
            return new UShortLiteral((ushort)literalValue); 
        } 

        ///  
        /// Factory function for an UInt32 type
        /// 
        /// 
        ///  
        private static Literal MakeUInt(object literalValue)
        { 
            return new UIntLiteral((uint)literalValue); 
        }
 
        /// 
        /// Factory function for an UInt64 type
        /// 
        ///  
        /// 
        private static Literal MakeULong(object literalValue) 
        { 
            return new ULongLiteral((ulong)literalValue);
        } 

        /// 
        /// Factory function for a float type
        ///  
        /// 
        ///  
        private static Literal MakeFloat(object literalValue) 
        {
            return new FloatLiteral((float)literalValue); 
        }

        /// 
        /// Factory function for a double type 
        /// 
        ///  
        ///  
        private static Literal MakeDouble(object literalValue)
        { 
            return new DoubleLiteral((double)literalValue);
        }

        ///  
        /// Factory function for a string type
        ///  
        ///  
        /// 
        private static Literal MakeString(object literalValue) 
        {
            return new StringLiteral((string)literalValue);
        }
        #endregion 

        #region Default Operators 
        internal static class DefaultOperators 
        {
            public static int Addition(int x, int y) { return x + y; } 
            public static uint Addition(uint x, uint y) { return x + y; }
            public static long Addition(long x, long y) { return x + y; }
            public static ulong Addition(ulong x, ulong y) { return x + y; }
            public static float Addition(float x, float y) { return x + y; } 
            public static double Addition(double x, double y) { return x + y; }
            public static decimal Addition(decimal x, decimal y) { return x + y; } 
            public static string Addition(string x, string y) { return x + y; } 
            public static string Addition(string x, object y) { return x + y; }
            public static string Addition(object x, string y) { return x + y; } 

            public static int Subtraction(int x, int y) { return x - y; }
            public static uint Subtraction(uint x, uint y) { return x - y; }
            public static long Subtraction(long x, long y) { return x - y; } 
            public static ulong Subtraction(ulong x, ulong y) { return x - y; }
            public static float Subtraction(float x, float y) { return x - y; } 
            public static double Subtraction(double x, double y) { return x - y; } 
            public static decimal Subtraction(decimal x, decimal y) { return x - y; }
 
            public static int Multiply(int x, int y) { return x * y; }
            public static uint Multiply(uint x, uint y) { return x * y; }
            public static long Multiply(long x, long y) { return x * y; }
            public static ulong Multiply(ulong x, ulong y) { return x * y; } 
            public static float Multiply(float x, float y) { return x * y; }
            public static double Multiply(double x, double y) { return x * y; } 
            public static decimal Multiply(decimal x, decimal y) { return x * y; } 

            public static int Division(int x, int y) { return x / y; } 
            public static uint Division(uint x, uint y) { return x / y; }
            public static long Division(long x, long y) { return x / y; }
            public static ulong Division(ulong x, ulong y) { return x / y; }
            public static float Division(float x, float y) { return x / y; } 
            public static double Division(double x, double y) { return x / y; }
            public static decimal Division(decimal x, decimal y) { return x / y; } 
 
            public static int Modulus(int x, int y) { return x % y; }
            public static uint Modulus(uint x, uint y) { return x % y; } 
            public static long Modulus(long x, long y) { return x % y; }
            public static ulong Modulus(ulong x, ulong y) { return x % y; }
            public static float Modulus(float x, float y) { return x % y; }
            public static double Modulus(double x, double y) { return x % y; } 
            public static decimal Modulus(decimal x, decimal y) { return x % y; }
 
            public static int BitwiseAnd(int x, int y) { return x & y; } 
            public static uint BitwiseAnd(uint x, uint y) { return x & y; }
            public static long BitwiseAnd(long x, long y) { return x & y; } 
            public static ulong BitwiseAnd(ulong x, ulong y) { return x & y; }
            public static bool BitwiseAnd(bool x, bool y) { return x & y; }

            public static int BitwiseOr(int x, int y) { return x | y; } 
            public static uint BitwiseOr(uint x, uint y) { return x | y; }
            public static long BitwiseOr(long x, long y) { return x | y; } 
            public static ulong BitwiseOr(ulong x, ulong y) { return x | y; } 
            public static bool BitwiseOr(bool x, bool y) { return x | y; }
 
            public static bool Equality(int x, int y) { return x == y; }
            public static bool Equality(uint x, uint y) { return x == y; }
            public static bool Equality(long x, long y) { return x == y; }
            public static bool Equality(ulong x, ulong y) { return x == y; } 
            public static bool Equality(float x, float y) { return x == y; }
            public static bool Equality(double x, double y) { return x == y; } 
            public static bool Equality(decimal x, decimal y) { return x == y; } 
            public static bool Equality(bool x, bool y) { return x == y; }
            public static bool Equality(string x, string y) { return x == y; } 
            // mark object == object since it has special rules
            public static bool ObjectEquality(object x, object y) { return x == y; }

            public static bool GreaterThan(int x, int y) { return x > y; } 
            public static bool GreaterThan(uint x, uint y) { return x > y; }
            public static bool GreaterThan(long x, long y) { return x > y; } 
            public static bool GreaterThan(ulong x, ulong y) { return x > y; } 
            public static bool GreaterThan(float x, float y) { return x > y; }
            public static bool GreaterThan(double x, double y) { return x > y; } 
            public static bool GreaterThan(decimal x, decimal y) { return x > y; }

            public static bool GreaterThanOrEqual(int x, int y) { return x >= y; }
            public static bool GreaterThanOrEqual(uint x, uint y) { return x >= y; } 
            public static bool GreaterThanOrEqual(long x, long y) { return x >= y; }
            public static bool GreaterThanOrEqual(ulong x, ulong y) { return x >= y; } 
            public static bool GreaterThanOrEqual(float x, float y) { return x >= y; } 
            public static bool GreaterThanOrEqual(double x, double y) { return x >= y; }
            public static bool GreaterThanOrEqual(decimal x, decimal y) { return x >= y; } 

            public static bool LessThan(int x, int y) { return x < y; }
            public static bool LessThan(uint x, uint y) { return x < y; }
            public static bool LessThan(long x, long y) { return x < y; } 
            public static bool LessThan(ulong x, ulong y) { return x < y; }
            public static bool LessThan(float x, float y) { return x < y; } 
            public static bool LessThan(double x, double y) { return x < y; } 
            public static bool LessThan(decimal x, decimal y) { return x < y; }
 
            public static bool LessThanOrEqual(int x, int y) { return x <= y; }
            public static bool LessThanOrEqual(uint x, uint y) { return x <= y; }
            public static bool LessThanOrEqual(long x, long y) { return x <= y; }
            public static bool LessThanOrEqual(ulong x, ulong y) { return x <= y; } 
            public static bool LessThanOrEqual(float x, float y) { return x <= y; }
            public static bool LessThanOrEqual(double x, double y) { return x <= y; } 
            public static bool LessThanOrEqual(decimal x, decimal y) { return x <= y; } 
        }
        #endregion 

        #region Type Checking Methods

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] 
        internal static RuleBinaryExpressionInfo AllowedComparison(
            Type lhs, 
            CodeExpression lhsExpression, 
            Type rhs,
            CodeExpression rhsExpression, 
            CodeBinaryOperatorType comparison,
            RuleValidation validator,
            out ValidationError error)
        { 
            // note that null values come in as a NullLiteral type
            TypeFlags lhsFlags, rhsFlags; 
 
            // are the types supported?
            if ((supportedTypes.TryGetValue(lhs, out lhsFlags)) && (supportedTypes.TryGetValue(rhs, out rhsFlags))) 
            {
                // both sides supported
                if (lhsFlags == rhsFlags)
                { 
                    // both sides the same type, so it's allowed
                    // only allow equality on booleans 
                    if ((lhsFlags == TypeFlags.Bool) && (comparison != CodeBinaryOperatorType.ValueEquality)) 
                    {
                        string message = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), 
                            RuleDecompiler.DecompileType(lhs),
                            RuleDecompiler.DecompileType(rhs));
                        error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                        return null; 
                    }
                    error = null; 
                    return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); 
                }
 
                // if not the same, only certain combinations allowed
                switch (lhsFlags | rhsFlags)
                {
                    case TypeFlags.Decimal | TypeFlags.SignedNumbers: 
                    case TypeFlags.Decimal | TypeFlags.UnsignedNumbers:
                    case TypeFlags.Decimal | TypeFlags.ULong: 
                    case TypeFlags.Float | TypeFlags.SignedNumbers: 
                    case TypeFlags.Float | TypeFlags.UnsignedNumbers:
                    case TypeFlags.Float | TypeFlags.ULong: 
                    case TypeFlags.ULong | TypeFlags.UnsignedNumbers:
                    case TypeFlags.SignedNumbers | TypeFlags.UnsignedNumbers:
                        error = null;
                        return new RuleBinaryExpressionInfo(lhs, rhs, typeof(bool)); 
                }
                string message2 = string.Format(CultureInfo.CurrentCulture, Messages.RelationalOpBadTypes, comparison.ToString(), 
                    (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs), 
                    (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs));
                error = new ValidationError(message2, ErrorNumbers.Error_OperandTypesIncompatible); 
                return null;
            }
            else
            { 
                // see if they override the operator
                MethodInfo operatorOverride = MapOperatorToMethod(comparison, lhs, lhsExpression, rhs, rhsExpression, validator, out error); 
                if (operatorOverride != null) 
                    return new RuleBinaryExpressionInfo(lhs, rhs, operatorOverride);
 
                // unable to evaluate, so return false
                return null;
            }
        } 

        internal enum OperatorGrouping 
        { 
            Arithmetic,
            Equality, 
            Relational
        }

        internal static MethodInfo ObjectEquality = typeof(DefaultOperators).GetMethod("ObjectEquality"); 

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] 
        [SuppressMessage("Microsoft.Performance", "CA1803:AvoidCostlyCallsWherePossible")] 
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]     // bogus since the casts are in different case statements
        internal static MethodInfo MapOperatorToMethod( 
            CodeBinaryOperatorType op,
            Type lhs,
            CodeExpression lhsExpression,
            Type rhs, 
            CodeExpression rhsExpression,
            RuleValidation validator, 
            out ValidationError error) 
        {
            // determine what the method name should be 
            string methodName;
            string message;
            OperatorGrouping group;
 
            switch (op)
            { 
                case CodeBinaryOperatorType.ValueEquality: 
                    methodName = "op_Equality";
                    group = OperatorGrouping.Equality; 
                    break;
                case CodeBinaryOperatorType.GreaterThan:
                    methodName = "op_GreaterThan";
                    group = OperatorGrouping.Relational; 
                    break;
                case CodeBinaryOperatorType.GreaterThanOrEqual: 
                    methodName = "op_GreaterThanOrEqual"; 
                    group = OperatorGrouping.Relational;
                    break; 
                case CodeBinaryOperatorType.LessThan:
                    methodName = "op_LessThan";
                    group = OperatorGrouping.Relational;
                    break; 
                case CodeBinaryOperatorType.LessThanOrEqual:
                    methodName = "op_LessThanOrEqual"; 
                    group = OperatorGrouping.Relational; 
                    break;
                case CodeBinaryOperatorType.Add: 
                    methodName = "op_Addition";
                    group = OperatorGrouping.Arithmetic;
                    break;
                case CodeBinaryOperatorType.Subtract: 
                    methodName = "op_Subtraction";
                    group = OperatorGrouping.Arithmetic; 
                    break; 
                case CodeBinaryOperatorType.Multiply:
                    methodName = "op_Multiply"; 
                    group = OperatorGrouping.Arithmetic;
                    break;
                case CodeBinaryOperatorType.Divide:
                    methodName = "op_Division"; 
                    group = OperatorGrouping.Arithmetic;
                    break; 
                case CodeBinaryOperatorType.Modulus: 
                    methodName = "op_Modulus";
                    group = OperatorGrouping.Arithmetic; 
                    break;
                case CodeBinaryOperatorType.BitwiseAnd:
                    methodName = "op_BitwiseAnd";
                    group = OperatorGrouping.Arithmetic; 
                    break;
                case CodeBinaryOperatorType.BitwiseOr: 
                    methodName = "op_BitwiseOr"; 
                    group = OperatorGrouping.Arithmetic;
                    break; 
                default:
                    Debug.Assert(false, "Operator " + op.ToString() + " not implemented");
                    message = string.Format(CultureInfo.CurrentCulture, Messages.BinaryOpNotSupported, op.ToString());
                    error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled); 
                    return null;
            } 
 
            // NOTE: types maybe NullLiteral, which signifies the constant "null"
            List candidates = new List(); 
            bool lhsNullable = ConditionHelper.IsNullableValueType(lhs);
            bool rhsNullable = ConditionHelper.IsNullableValueType(rhs);
            Type lhsType0 = (lhsNullable) ? Nullable.GetUnderlyingType(lhs) : lhs;
            Type rhsType0 = (rhsNullable) ? Nullable.GetUnderlyingType(rhs) : rhs; 

            // special cases for enums 
            if (lhsType0.IsEnum) 
            {
                // only 3 cases (U = underlying type of E): 
                //    E = E + U
                //    U = E - E
                //    E = E - U
                // plus the standard comparisons (E == E, E > E, etc.) 
                // need to also allow E == 0
                Type underlyingType; 
                switch (op) 
                {
                    case CodeBinaryOperatorType.Add: 
                        underlyingType = EnumHelper.GetUnderlyingType(lhsType0);
                        if ((underlyingType != null) &&
                            (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error)))
                        { 
                            error = null;
                            return new EnumOperationMethodInfo(lhs, op, rhs, false); 
                        } 
                        break;
                    case CodeBinaryOperatorType.Subtract: 
                        underlyingType = EnumHelper.GetUnderlyingType(lhsType0);
                        if (underlyingType != null)
                        {
                            if (lhsType0 == rhsType0) 
                            {
                                // E - E 
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, false);
                            } 
                            else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression))
                            {
                                // E - 0, can convert 0 to E
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, true);
                            } 
                            else if (RuleValidation.TypesAreAssignable(rhsType0, underlyingType, rhsExpression, out error)) 
                            {
                                // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about) 
                                error = null;
                                return new EnumOperationMethodInfo(lhs, op, rhs, false);
                            }
                        } 
                        break;
                    case CodeBinaryOperatorType.ValueEquality: 
                    case CodeBinaryOperatorType.LessThan: 
                    case CodeBinaryOperatorType.LessThanOrEqual:
                    case CodeBinaryOperatorType.GreaterThan: 
                    case CodeBinaryOperatorType.GreaterThanOrEqual:
                        if (lhsType0 == rhsType0)
                        {
                            error = null; 
                            return new EnumOperationMethodInfo(lhs, op, rhs, false);
                        } 
                        else if (lhsNullable && (rhs == typeof(NullLiteral))) 
                        {
                            // handle enum? op null 
                            // treat the rhs as the same nullable enum
                            error = null;
                            return new EnumOperationMethodInfo(lhs, op, lhs, false);
                        } 
                        else if (DecimalIntegerLiteralZero(rhs, rhsExpression as CodePrimitiveExpression))
                        { 
                            error = null; 
                            return new EnumOperationMethodInfo(lhs, op, rhs, true);
                        } 
                        break;
                }
                // can't do it, sorry
                // but check if there is a user-defined operator that works 
            }
            else if (rhsType0.IsEnum) 
            { 
                // lhs != enum, so only 2 cases (U = underlying type of E):
                //    E = U + E 
                //    E = U - E
                // comparisons are E == E, etc., so if the lhs is not an enum, too bad
                // although we need to check for 0 == E
                Type underlyingType; 
                switch (op)
                { 
                    case CodeBinaryOperatorType.Add: 
                        underlyingType = EnumHelper.GetUnderlyingType(rhsType0);
                        if ((underlyingType != null) && 
                            (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error)))
                        {
                            error = null;
                            return new EnumOperationMethodInfo(lhs, op, rhs, false); 
                        }
                        break; 
 
                    case CodeBinaryOperatorType.Subtract:
                        underlyingType = EnumHelper.GetUnderlyingType(rhsType0); 
                        if (underlyingType != null)
                        {
                            CodePrimitiveExpression primitive = lhsExpression as CodePrimitiveExpression;
                            if (DecimalIntegerLiteralZero(lhs, primitive)) 
                            {
                                // 0 - E, can convert 0 to E 
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, true);
                            } 
                            else if (RuleValidation.TypesAreAssignable(lhsType0, underlyingType, lhsExpression, out error))
                            {
                                // expression not passed to TypesAreAssignable, so not looking for constants (since 0 is all we care about)
                                error = null; 
                                return new EnumOperationMethodInfo(lhs, op, rhs, false);
                            } 
                        } 
                        break;
 
                    case CodeBinaryOperatorType.ValueEquality:
                    case CodeBinaryOperatorType.LessThan:
                    case CodeBinaryOperatorType.LessThanOrEqual:
                    case CodeBinaryOperatorType.GreaterThan: 
                    case CodeBinaryOperatorType.GreaterThanOrEqual:
                        if (rhsNullable && (lhs == typeof(NullLiteral))) 
                        { 
                            // handle null op enum?
                            // treat the lhs as the same nullable enum type 
                            error = null;
                            return new EnumOperationMethodInfo(rhs, op, rhs, false);
                        }
                        else if (DecimalIntegerLiteralZero(lhs, lhsExpression as CodePrimitiveExpression)) 
                        {
                            error = null; 
                            return new EnumOperationMethodInfo(lhs, op, rhs, true); 
                        }
                        break; 
                }

                // can't do it, sorry
                // but check if there is a user-defined operator that works 
            }
 
            // enum specific operations already handled, see if one side (or both) define operators 
            AddOperatorOverloads(lhsType0, methodName, lhs, rhs, candidates);
            AddOperatorOverloads(rhsType0, methodName, lhs, rhs, candidates); 
            if (lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)))
            {
                // need to add in lifted methods
                AddLiftedOperators(lhsType0, methodName, group, lhsType0, rhsType0, candidates); 
                AddLiftedOperators(rhsType0, methodName, group, lhsType0, rhsType0, candidates);
            } 
 
            if (candidates.Count == 0)
            { 
                // no overrides, so get the default list
                methodName = methodName.Substring(3);		// strip off the op_
                foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods())
                { 
                    if (mi.Name == methodName)
                    { 
                        ParameterInfo[] parameters = mi.GetParameters(); 
                        Type parm1 = parameters[0].ParameterType;
                        Type parm2 = parameters[1].ParameterType; 
                        if (RuleValidation.ImplicitConversion(lhs, parm1) &&
                            RuleValidation.ImplicitConversion(rhs, parm2))
                        {
                            candidates.Add(mi); 
                        }
                    } 
                } 

                // if no candidates and ==, can we use object == object? 
                if ((candidates.Count == 0) && ("Equality" == methodName))
                {
                    // C# 7.9.6
                    // references must be compatible 
                    // no boxing
                    // value types can't be compared 
                    if ((!lhs.IsValueType) && (!rhs.IsValueType)) 
                    {
                        // they are not classes, so references need to be compatible 
                        // also check for null (which is NullLiteral type) -- null is compatible with any object type
                        if ((lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)) ||
                            (lhs.IsAssignableFrom(rhs)) || (rhs.IsAssignableFrom(lhs)))
                        { 
                            candidates.Add(ObjectEquality);
                        } 
                    } 
                }
 
                // if no candidates and nullable, add lifted operators
                if ((candidates.Count == 0) && ((lhsNullable || rhsNullable || (lhs == typeof(NullLiteral)) || (rhs == typeof(NullLiteral)))))
                {
                    foreach (MethodInfo mi in typeof(DefaultOperators).GetMethods()) 
                    {
                        if (mi.Name == methodName) 
                        { 
                            ParameterInfo[] parameters = mi.GetParameters();
                            MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, lhsType0, rhsType0); 
                            if (liftedMethod != null)
                                candidates.Add(liftedMethod);
                        }
                    } 
                }
            } 
            if (candidates.Count == 1) 
            {
                // only 1, so it is it 
                error = null;
                return candidates[0];
            }
            else if (candidates.Count == 0) 
            {
                // nothing matched 
                message = string.Format(CultureInfo.CurrentCulture, 
                    (group == OperatorGrouping.Arithmetic) ? Messages.ArithOpBadTypes : Messages.RelationalOpBadTypes,
                    op.ToString(), 
                    (lhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(lhs),
                    (rhs == typeof(NullLiteral)) ? Messages.NullValue : RuleDecompiler.DecompileType(rhs));
                error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                return null; 
            }
            else 
            { 
                // more than 1, so pick the best one
                MethodInfo bestFit = validator.FindBestCandidate(null, candidates, lhs, rhs); 
                if (bestFit != null)
                {
                    error = null;
                    return bestFit; 
                }
                // must be ambiguous. Since there are at least 2 choices, show only the first 2 
                message = string.Format(CultureInfo.CurrentCulture, 
                    Messages.AmbiguousOperator,
                    op.ToString(), 
                    RuleDecompiler.DecompileMethod(candidates[0]),
                    RuleDecompiler.DecompileMethod(candidates[1]));
                error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                return null; 
            }
        } 
 
        private static bool DecimalIntegerLiteralZero(Type type, CodePrimitiveExpression expression)
        { 
            if (expression != null)
            {
                if (type == typeof(int))
                    return expression.Value.Equals(0); 
                else if (type == typeof(uint))
                    return expression.Value.Equals(0U); 
                else if (type == typeof(long)) 
                    return expression.Value.Equals(0L);
                else if (type == typeof(ulong)) 
                    return expression.Value.Equals(0UL);
            }
            return false;
        } 

        private static void AddOperatorOverloads(Type type, string methodName, Type arg1, Type arg2, List candidates) 
        { 
            // append the list of methods that match the name specified
            int numAdded = 0; 
            MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
            foreach (MethodInfo mi in possible)
            {
                ParameterInfo[] parameters = mi.GetParameters(); 
                if ((mi.Name == methodName) && (parameters.Length == 2))
                { 
                    if (EvaluateMethod(parameters, arg1, arg2)) 
                    {
                        ++numAdded; 
                        if (!candidates.Contains(mi))
                            candidates.Add(mi);
                    }
                } 
            }
            if ((numAdded > 0) || (type == typeof(object))) 
                return; 

            // no matches, check direct base class (if there is one) 
            type = type.BaseType;
            if (type != null)
            {
                possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); 
                foreach (MethodInfo mi in possible)
                { 
                    ParameterInfo[] parameters = mi.GetParameters(); 
                    if ((mi.Name == methodName) && (parameters.Length == 2))
                    { 
                        if (EvaluateMethod(parameters, arg1, arg2))
                        {
                            if (!candidates.Contains(mi))
                                candidates.Add(mi); 
                        }
                    } 
                } 
            }
        } 

        private static void AddLiftedOperators(Type type, string methodName, OperatorGrouping group, Type arg1, Type arg2, List candidates)
        {
            // append the list of lifted methods that match the name specified 
            int numAdded = 0;
            MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public); 
            foreach (MethodInfo mi in possible) 
            {
                ParameterInfo[] parameters = mi.GetParameters(); 
                if ((mi.Name == methodName) && (parameters.Length == 2))
                {
                    MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2);
                    if (liftedMethod != null) 
                    {
                        ++numAdded; 
                        if (!candidates.Contains(liftedMethod)) 
                            candidates.Add(liftedMethod);
                    } 
                }
            }
            if ((numAdded > 0) || (type == typeof(object)))
                return; 

            // no matches, check direct base class (if there is one) 
            type = type.BaseType; 
            if (type != null)
            { 
                possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
                foreach (MethodInfo mi in possible)
                {
                    ParameterInfo[] parameters = mi.GetParameters(); 
                    if ((mi.Name == methodName) && (parameters.Length == 2))
                    { 
                        MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2); 
                        if ((liftedMethod != null) && !candidates.Contains(liftedMethod))
                            candidates.Add(liftedMethod); 
                    }
                }
            }
        } 

        private static bool EvaluateMethod(ParameterInfo[] parameters, Type arg1, Type arg2) 
        { 
            Type parm1 = parameters[0].ParameterType;
            Type parm2 = parameters[1].ParameterType; 
            return (RuleValidation.ImplicitConversion(arg1, parm1) &&
                    RuleValidation.ImplicitConversion(arg2, parm2));
        }
 
        private static MethodInfo EvaluateLiftedMethod(MethodInfo mi, ParameterInfo[] parameters, OperatorGrouping group, Type arg1, Type arg2)
        { 
            Type parm1 = parameters[0].ParameterType; 
            Type parm2 = parameters[1].ParameterType;
            if (ConditionHelper.IsNonNullableValueType(parm1) && ConditionHelper.IsNonNullableValueType(parm2)) 
            {
                // lift the parameters for testing conversions, if possible
                parm1 = typeof(Nullable<>).MakeGenericType(parm1);
                parm2 = typeof(Nullable<>).MakeGenericType(parm2); 
                switch (group)
                { 
                    case OperatorGrouping.Equality:		// for == != 
                        if (mi.ReturnType == typeof(bool) &&
                            RuleValidation.ImplicitConversion(arg1, parm1) && 
                            RuleValidation.ImplicitConversion(arg2, parm2))
                        {
                            return new LiftedEqualityOperatorMethodInfo(mi);
                        } 
                        break;
                    case OperatorGrouping.Relational:		// for < > <= >= 
                        if (mi.ReturnType == typeof(bool) && 
                            RuleValidation.ImplicitConversion(arg1, parm1) &&
                            RuleValidation.ImplicitConversion(arg2, parm2)) 
                        {
                            return new LiftedRelationalOperatorMethodInfo(mi);
                        }
                        break; 
                    case OperatorGrouping.Arithmetic:		// for + - * / % & ^
                        if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) && 
                            RuleValidation.ImplicitConversion(arg1, parm1) && 
                            RuleValidation.ImplicitConversion(arg2, parm2))
                        { 
                            return new LiftedArithmeticOperatorMethodInfo(mi);
                        }
                        break;
                } 
            }
            return null; 
        } 
        #endregion
 
        #region Value Type Dispatch Methods

        /// 
        /// Relational equal operator 
        /// Value-equality if we can do it, otherwise reference-equality
        ///  
        ///  
        /// 
        internal abstract bool Equal(Literal rhs); 
        internal virtual bool Equal(byte literalValue)
        {
            return false;
        } 
        internal virtual bool Equal(sbyte literalValue)
        { 
            return false; 
        }
        internal virtual bool Equal(short literalValue) 
        {
            return false;
        }
        internal virtual bool Equal(int literalValue) 
        {
            return false; 
        } 
        internal virtual bool Equal(long literalValue)
        { 
            return false;
        }
        internal virtual bool Equal(ushort literalValue)
        { 
            return false;
        } 
        internal virtual bool Equal(uint literalValue) 
        {
            return false; 
        }
        internal virtual bool Equal(ulong literalValue)
        {
            return false; 
        }
        internal virtual bool Equal(float literalValue) 
        { 
            return false;
        } 
        internal virtual bool Equal(double literalValue)
        {
            return false;
        } 
        internal virtual bool Equal(char literalValue)
        { 
            return false; 
        }
        internal virtual bool Equal(string literalValue) 
        {
            return false;
        }
        internal virtual bool Equal(decimal literalValue) 
        {
            return false; 
        } 
        internal virtual bool Equal(bool literalValue)
        { 
            return false;
        }

        ///  
        /// Relational less than operator
        ///  
        ///  
        /// 
        internal abstract bool LessThan(Literal rhs); 
        internal virtual bool LessThan()
        {
            return false;
        } 
        internal virtual bool LessThan(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        }
        internal virtual bool LessThan(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        } 
        internal virtual bool LessThan(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        }
        internal virtual bool LessThan(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type); 
        }
        internal virtual bool LessThan(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        } 
        internal virtual bool LessThan(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThan, m_type);
        }

        ///  
        /// Relational greater than operator
        ///  
        ///  
        /// 
        internal abstract bool GreaterThan(Literal rhs); 
        internal virtual bool GreaterThan()
        {
            return false;
        } 
        internal virtual bool GreaterThan(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        }
        internal virtual bool GreaterThan(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        } 
        internal virtual bool GreaterThan(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        }
        internal virtual bool GreaterThan(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type); 
        }
        internal virtual bool GreaterThan(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        } 
        internal virtual bool GreaterThan(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThan, m_type);
        }

        ///  
        /// Relational less than or equal to operator
        ///  
        ///  
        /// 
        internal abstract bool LessThanOrEqual(Literal rhs); 
        internal virtual bool LessThanOrEqual()
        {
            return false;
        } 
        internal virtual bool LessThanOrEqual(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        }
        internal virtual bool LessThanOrEqual(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        } 
        internal virtual bool LessThanOrEqual(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        }
        internal virtual bool LessThanOrEqual(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type); 
        }
        internal virtual bool LessThanOrEqual(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        } 
        internal virtual bool LessThanOrEqual(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.LessThanOrEqual, m_type);
        }

        ///  
        /// Relational greater than or equal to operator
        ///  
        ///  
        /// 
        internal abstract bool GreaterThanOrEqual(Literal rhs); 
        internal virtual bool GreaterThanOrEqual()
        {
            return false;
        } 
        internal virtual bool GreaterThanOrEqual(byte literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(char literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(sbyte literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(short literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(int literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        }
        internal virtual bool GreaterThanOrEqual(long literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        } 
        internal virtual bool GreaterThanOrEqual(ushort literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        }
        internal virtual bool GreaterThanOrEqual(uint literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(ulong literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(float literalValue)
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(double literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(string literalValue) 
        { 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type);
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type); 
        }
        internal virtual bool GreaterThanOrEqual(decimal literalValue)
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        } 
        internal virtual bool GreaterThanOrEqual(bool literalValue) 
        {
            string message = string.Format(CultureInfo.CurrentCulture, Messages.IncompatibleComparisonTypes, literalValue.GetType(), m_type); 
            throw new RuleEvaluationIncompatibleTypesException(message, literalValue.GetType(), CodeBinaryOperatorType.GreaterThanOrEqual, m_type);
        }
        #endregion
    } 
    #endregion
 
    #region Null Literal Class 
    /// 
    /// Represents an null literal 
    /// 
    internal class NullLiteral : Literal
    {
        // NOTE (from MSDN page on IComparable.CompareTo Method): 
        // By definition, any object compares greater than a null reference
        // But C# (24.3.1) doesn't -- if either side is null, result is false 
 
        internal NullLiteral(Type type)
        { 
            m_type = type;
        }

        internal override object Value 
        {
            get { return null; } 
        } 

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Value == null;
        }
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(); 
        }
        internal override bool LessThan(byte literalValue) 
        {
            return false;
        }
        internal override bool LessThan(char literalValue) 
        {
            return false; 
        } 
        internal override bool LessThan(sbyte literalValue)
        { 
            return false;
        }
        internal override bool LessThan(short literalValue)
        { 
            return false;
        } 
        internal override bool LessThan(int literalValue) 
        {
            return false; 
        }
        internal override bool LessThan(long literalValue)
        {
            return false; 
        }
        internal override bool LessThan(ushort literalValue) 
        { 
            return false;
        } 
        internal override bool LessThan(uint literalValue)
        {
            return false;
        } 
        internal override bool LessThan(ulong literalValue)
        { 
            return false; 
        }
        internal override bool LessThan(float literalValue) 
        {
            return false;
        }
        internal override bool LessThan(double literalValue) 
        {
            return false; 
        } 
        internal override bool LessThan(string literalValue)
        { 
            // for strings, maintain compatibility with v1
            return true;
        }
        internal override bool LessThan(decimal literalValue) 
        {
            return false; 
        } 

        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan();
        }
        internal override bool GreaterThan(byte literalValue) 
        {
            return false; 
        } 
        internal override bool GreaterThan(char literalValue)
        { 
            return false;
        }
        internal override bool GreaterThan(sbyte literalValue)
        { 
            return false;
        } 
        internal override bool GreaterThan(short literalValue) 
        {
            return false; 
        }
        internal override bool GreaterThan(int literalValue)
        {
            return false; 
        }
        internal override bool GreaterThan(long literalValue) 
        { 
            return false;
        } 
        internal override bool GreaterThan(ushort literalValue)
        {
            return false;
        } 
        internal override bool GreaterThan(uint literalValue)
        { 
            return false; 
        }
        internal override bool GreaterThan(ulong literalValue) 
        {
            return false;
        }
        internal override bool GreaterThan(float literalValue) 
        {
            return false; 
        } 
        internal override bool GreaterThan(double literalValue)
        { 
            return false;
        }
        internal override bool GreaterThan(string literalValue)
        { 
            return false;
        } 
        internal override bool GreaterThan(decimal literalValue) 
        {
            return false; 
        }

        /// 
        /// Relational less than or equal to operator 
        /// 
        ///  
        ///  
        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual();
        }
        internal override bool LessThanOrEqual()
        { 
            return (m_type == typeof(string));		// null == null for strings only
        } 
        internal override bool LessThanOrEqual(byte literalValue) 
        {
            return false; 
        }
        internal override bool LessThanOrEqual(char literalValue)
        {
            return false; 
        }
        internal override bool LessThanOrEqual(sbyte literalValue) 
        { 
            return false;
        } 
        internal override bool LessThanOrEqual(short literalValue)
        {
            return false;
        } 
        internal override bool LessThanOrEqual(int literalValue)
        { 
            return false; 
        }
        internal override bool LessThanOrEqual(long literalValue) 
        {
            return false;
        }
        internal override bool LessThanOrEqual(ushort literalValue) 
        {
            return false; 
        } 
        internal override bool LessThanOrEqual(uint literalValue)
        { 
            return false;
        }
        internal override bool LessThanOrEqual(ulong literalValue)
        { 
            return false;
        } 
        internal override bool LessThanOrEqual(float literalValue) 
        {
            return false; 
        }
        internal override bool LessThanOrEqual(double literalValue)
        {
            return false; 
        }
        internal override bool LessThanOrEqual(string literalValue) 
        { 
            // for strings, maintain compatibility with v1
            return true; 
        }
        internal override bool LessThanOrEqual(decimal literalValue)
        {
            return false; 
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(); 
        }
        internal override bool GreaterThanOrEqual()
        {
            return (m_type == typeof(string));		// null == null for strings only 
        }
        internal override bool GreaterThanOrEqual(byte literalValue) 
        { 
            return false;
        } 
        internal override bool GreaterThanOrEqual(char literalValue)
        {
            return false;
        } 
        internal override bool GreaterThanOrEqual(sbyte literalValue)
        { 
            return false; 
        }
        internal override bool GreaterThanOrEqual(short literalValue) 
        {
            return false;
        }
        internal override bool GreaterThanOrEqual(int literalValue) 
        {
            return false; 
        } 
        internal override bool GreaterThanOrEqual(long literalValue)
        { 
            return false;
        }
        internal override bool GreaterThanOrEqual(ushort literalValue)
        { 
            return false;
        } 
        internal override bool GreaterThanOrEqual(uint literalValue) 
        {
            return false; 
        }
        internal override bool GreaterThanOrEqual(ulong literalValue)
        {
            return false; 
        }
        internal override bool GreaterThanOrEqual(float literalValue) 
        { 
            return false;
        } 
        internal override bool GreaterThanOrEqual(double literalValue)
        {
            return false;
        } 
        internal override bool GreaterThanOrEqual(string literalValue)
        { 
            return false; 
        }
        internal override bool GreaterThanOrEqual(decimal literalValue) 
        {
            return false;
        }
    } 
    #endregion
 
    #region Boolean Literal Class 
    /// 
    /// Represents a boolean literal 
    /// 
    internal class BoolLiteral : Literal
    {
        private bool m_value; 

        internal override object Value 
        { 
            get { return m_value; }
        } 

        internal BoolLiteral(bool literalValue)
        {
            m_value = literalValue; 
            m_type = typeof(bool);
        } 
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        }
        internal override bool Equal(bool rhs)
        { 
            return m_value == rhs;
        } 
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        }

        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan(m_value); 
        } 

        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value);
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value); 
        }
    } 
    #endregion

    #region Byte Literal Class
    ///  
    /// Represents a byte literal
    ///  
    internal class ByteLiteral : Literal 
    {
        private byte m_value; 

        internal override object Value
        {
            get { return m_value; } 
        }
 
        internal ByteLiteral(byte literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(byte);
        }

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value); 
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ushort rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs; 
        }

        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        } 
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        { 
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs)
        { 
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(long rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs; 
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value);
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs)
        {
            return m_value >= rhs; 
        }
 
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(double rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs; 
        } 
    }
    #endregion 

    #region SByte Literal Class
    /// 
    /// Represents a byte literal 
    /// 
    internal class SByteLiteral : Literal 
    { 
        private sbyte m_value;
 
        internal override object Value
        {
            get { return m_value; }
        } 

        internal SByteLiteral(sbyte literalValue) 
        { 
            m_value = literalValue;
            m_type = typeof(sbyte); 
        }

        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(short rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(ulong rhs) 
        {
            return (m_value >= 0) && ((ulong)m_value == rhs);
        }
        internal override bool Equal(int rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(long rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(double rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        { 
            return m_value == rhs;
        } 

        internal override bool LessThan(Literal rhs)
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(float rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs)
        {
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs) 
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(long rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs)
        { 
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(long rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs;
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(short rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 

        }
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(float rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(decimal rhs)
        { 
            return m_value >= rhs; 
        }
    } 
    #endregion

    #region Char Literal Class
    ///  
    /// Represents a byte literal
    ///  
    internal class CharLiteral : Literal 
    {
        private char m_value; 

        internal override object Value
        {
            get { return m_value; } 
        }
 
        internal CharLiteral(char literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(char);
        }

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value); 
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ushort rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs; 
        }

        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        } 
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        { 
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs)
        { 
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(long rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs; 
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value);
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(int rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(long rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(float rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(decimal rhs)
        { 
            return m_value >= rhs;
        } 
    } 
    #endregion
 
    #region Decimal Literal Class
    /// 
    /// Represents a decimal literal
    ///  
    internal class DecimalLiteral : Literal
    { 
        private decimal m_value; 

        internal override object Value 
        {
            get { return m_value; }
        }
 
        internal DecimalLiteral(decimal literalValue)
        { 
            m_value = literalValue; 
            m_type = typeof(decimal);
        } 

        internal override bool Equal(Literal rhs)
        {
            return rhs.Equal(m_value); 
        }
        internal override bool Equal(sbyte rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(int rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ulong rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        { 
            return m_value == rhs;
        } 

        internal override bool LessThan(Literal rhs)
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        { 
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        { 
            return m_value > rhs;
        } 

        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(int rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        { 
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs)
        {
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        { 
            return m_value >= rhs;
        } 
    }
    #endregion

    #region Int16 Literal Class 
    /// 
    /// Represents an Int16 literal 
    ///  
    internal class ShortLiteral : Literal
    { 
        private short m_value;

        internal override object Value
        { 
            get { return m_value; }
        } 
 
        internal ShortLiteral(short literalValue)
        { 
            m_value = literalValue;
            m_type = typeof(short);
        }
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value); 
        }
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(short rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(int rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(long rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value == rhs); 
        }
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(decimal rhs)
        { 
            return m_value == rhs;
        }

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value); 
        } 
        internal override bool LessThan(sbyte rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(byte rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(int rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(decimal rhs)
        { 
            return m_value < rhs;
        } 
 
        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        }
        internal override bool GreaterThan(sbyte rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(float rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(double rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs; 
        }

        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual(m_value);
        } 
        internal override bool LessThanOrEqual(sbyte rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(short rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ushort rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(float rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs)
        {
            return m_value <= rhs; 
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(short rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(long rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(double rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        { 
            return m_value >= rhs;
        } 
    }
    #endregion

    #region Int32 Literal Class 
    /// 
    /// Represents an Int32 literal 
    ///  
    internal class IntLiteral : Literal
    { 
        private int m_value;

        internal override object Value
        { 
            get { return m_value; }
        } 
 
        internal IntLiteral(int literalValue)
        { 
            m_value = literalValue;
            m_type = typeof(int);
        }
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value); 
        }
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(short rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(int rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(long rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value == rhs); 
        }
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(decimal rhs)
        { 
            return m_value == rhs;
        }

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value); 
        } 
        internal override bool LessThan(sbyte rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(byte rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(int rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs) 
        {
            return (m_value < 0) || ((ulong)m_value < rhs); 
        } 
        internal override bool LessThan(float rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs) 
        {
            return m_value < rhs; 
        }

        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(short rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(long rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value > rhs);
        } 
        internal override bool GreaterThan(float rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        { 
            return m_value > rhs;
        } 

        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(int rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return (m_value < 0) || ((ulong)m_value <= rhs); 
        }
        internal override bool LessThanOrEqual(float rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(decimal rhs)
        { 
            return m_value <= rhs; 
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        {
            return rhs.LessThanOrEqual(m_value);
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(short rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ushort rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return (m_value >= 0) && ((ulong)m_value >= rhs);
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(double rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs; 
        } 
    }
    #endregion 

    #region Int64 Literal Class
    /// 
    /// Represents an Int64 literal 
    /// 
    internal class LongLiteral : Literal 
    { 
        private long m_value;
 
        internal override object Value
        {
            get { return m_value; }
        } 

        internal LongLiteral(long literalValue) 
        { 
            m_value = literalValue;
            m_type = typeof(long); 
        }

        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(sbyte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(short rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(int rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(uint rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(long rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value == rhs);
        } 
        internal override bool Equal(float rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(double rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        { 
            return m_value == rhs;
        } 

        internal override bool LessThan(Literal rhs)
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs)
        {
            return (m_value < 0) || ((ulong)m_value < rhs); 
        }
        internal override bool LessThan(float rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs)
        { 
            return m_value < rhs; 
        }
 
        internal override bool GreaterThan(Literal rhs)
        {
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(char rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(short rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(long rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ulong rhs)
        {
            return (m_value >= 0) && ((ulong)m_value > rhs);
        } 
        internal override bool GreaterThan(float rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs; 
        } 

        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value);
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(byte rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ushort rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(int rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs) 
        {
            return (m_value < 0) || ((ulong)m_value <= rhs);
        }
        internal override bool LessThanOrEqual(float rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(double rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(decimal rhs)
        { 
            return m_value <= rhs;
        } 
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value);
        }
        internal override bool GreaterThanOrEqual(sbyte rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(char rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ushort rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(ulong rhs)
        { 
            return (m_value >= 0) && ((ulong)m_value >= rhs);
        }
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs)
        {
            return m_value >= rhs; 
        }
    } 
    #endregion 

    #region UInt16 Literal Class 
    /// 
    /// Represents an UInt16 literal
    /// 
    internal class UShortLiteral : Literal 
    {
        private ushort m_value; 
 
        internal override object Value
        { 
            get { return m_value; }
        }

        internal UShortLiteral(ushort literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(ushort); 
        }
 
        internal override bool Equal(Literal rhs)
        {
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(short rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(ushort rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ulong rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs; 
        } 

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value);
        }
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(byte rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(uint rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(decimal rhs)
        { 
            return m_value < rhs;
        } 
 
        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        }
        internal override bool GreaterThan(sbyte rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(short rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(long rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(ulong rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(float rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs)
        {
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(decimal rhs)
        {
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        { 
            return rhs.LessThanOrEqual(m_value);
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(ushort rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs;
        }
    } 
    #endregion
 
    #region UInt32 Literal Class 
    /// 
    /// Represents an UInt32 literal 
    /// 
    internal class UIntLiteral : Literal
    {
        private uint m_value; 

        internal override object Value 
        { 
            get { return m_value; }
        } 

        internal UIntLiteral(uint literalValue)
        {
            m_value = literalValue; 
            m_type = typeof(uint);
        } 
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        }
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(ulong rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs)
        {
            return m_value == rhs; 
        }
 
        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(sbyte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(char rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(uint rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(ulong rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(float rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(decimal rhs)
        {
            return m_value < rhs;
        } 

        internal override bool GreaterThan(Literal rhs) 
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(byte rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(short rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(long rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(float rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs;
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(int rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(double rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(decimal rhs)
        { 
            return m_value <= rhs;
        }

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value); 
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs; 
        }
    }
    #endregion
 
    #region UInt64 Literal Class
    ///  
    /// Represents an UInt64 literal 
    /// 
    internal class ULongLiteral : Literal 
    {
        private ulong m_value;

        internal override object Value 
        {
            get { return m_value; } 
        } 

        internal ULongLiteral(ulong literalValue) 
        {
            m_value = literalValue;
            m_type = typeof(ulong);
        } 

        internal override bool Equal(Literal rhs) 
        { 
            return rhs.Equal(m_value);
        } 
        internal override bool Equal(byte rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return (rhs >= 0) && (m_value == (ulong)rhs); 
        }
        internal override bool Equal(short rhs) 
        {
            return (rhs >= 0) && (m_value == (ulong)rhs);
        }
        internal override bool Equal(int rhs) 
        {
            return (rhs >= 0) && (m_value == (ulong)rhs); 
        } 
        internal override bool Equal(long rhs)
        { 
            return (rhs >= 0) && (m_value == (ulong)rhs);
        }
        internal override bool Equal(char rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ulong rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(float rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(decimal rhs) 
        {
            return m_value == rhs;
        }
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value); 
        }
        internal override bool LessThan(byte rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(int rhs) 
        {
            return (rhs >= 0) && (m_value < (ulong)rhs); 
        } 
        internal override bool LessThan(long rhs)
        { 
            return (rhs >= 0) && (m_value < (ulong)rhs);
        }
        internal override bool LessThan(char rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(uint rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(ulong rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(double rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(decimal rhs) 
        {
            return m_value < rhs;
        }
 
        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(byte rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs) 
        {
            return (rhs < 0) || (m_value > (ulong)rhs); 
        } 
        internal override bool GreaterThan(long rhs)
        { 
            return (rhs < 0) || (m_value > (ulong)rhs);
        }
        internal override bool GreaterThan(char rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(uint rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ulong rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(float rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(double rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(decimal rhs) 
        {
            return m_value > rhs;
        }
 
        internal override bool LessThanOrEqual(Literal rhs)
        { 
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return (rhs >= 0) && (m_value <= (ulong)rhs); 
        } 
        internal override bool LessThanOrEqual(long rhs)
        { 
            return (rhs >= 0) && (m_value <= (ulong)rhs);
        }
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(uint rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(decimal rhs) 
        {
            return m_value <= rhs;
        }
 
        internal override bool GreaterThanOrEqual(Literal rhs)
        { 
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(byte rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs) 
        {
            return (rhs < 0) || (m_value >= (ulong)rhs); 
        } 
        internal override bool GreaterThanOrEqual(long rhs)
        { 
            return (rhs < 0) || (m_value >= (ulong)rhs);
        }
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(decimal rhs) 
        {
            return m_value >= rhs;
        }
    } 
    #endregion
 
    #region Double Literal Class 
    /// 
    /// Represents a double literal 
    /// 
    internal class DoubleLiteral : Literal
    {
        private double m_value; 

        internal override object Value 
        { 
            get { return m_value; }
        } 

        internal DoubleLiteral(double literalValue)
        {
            m_value = literalValue; 
            m_type = typeof(double);
        } 
 
        internal override bool Equal(Literal rhs)
        { 
            return rhs.Equal(m_value);
        }
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(byte rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(char rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(ushort rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(uint rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(ulong rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(double rhs) 
        {
            return m_value == rhs; 
        }

        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        } 
        internal override bool LessThan(sbyte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(byte rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(short rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(int rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(long rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(float rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(double rhs)
        {
            return m_value < rhs; 
        }
 
        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan(m_value); 
        }
        internal override bool GreaterThan(sbyte rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(char rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(short rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(ushort rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(uint rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(long rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ulong rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(float rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs) 
        { 
            return m_value > rhs;
        } 

        internal override bool LessThanOrEqual(Literal rhs)
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(byte rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(char rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(int rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(long rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ulong rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(double rhs)
        {
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs) 
        { 
            return rhs.LessThanOrEqual(m_value);
        } 
        internal override bool GreaterThanOrEqual(sbyte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(char rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(ushort rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(uint rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(long rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(float rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        { 
            return m_value >= rhs; 
        }
    } 
    #endregion

    #region Float Literal Class
    ///  
    /// Represents a float literal
    ///  
    internal class FloatLiteral : Literal 
    {
        private float m_value; 

        internal override object Value
        {
            get { return m_value; } 
        }
 
        internal FloatLiteral(float literalValue) 
        {
            m_value = literalValue; 
            m_type = typeof(float);
        }

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value); 
        } 
        internal override bool Equal(sbyte rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(byte rhs)
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(char rhs) 
        {
            return m_value == rhs; 
        }
        internal override bool Equal(short rhs)
        {
            return m_value == rhs; 
        }
        internal override bool Equal(ushort rhs) 
        { 
            return m_value == rhs;
        } 
        internal override bool Equal(int rhs)
        {
            return m_value == rhs;
        } 
        internal override bool Equal(uint rhs)
        { 
            return m_value == rhs; 
        }
        internal override bool Equal(long rhs) 
        {
            return m_value == rhs;
        }
        internal override bool Equal(ulong rhs) 
        {
            return m_value == rhs; 
        } 
        internal override bool Equal(float rhs)
        { 
            return m_value == rhs;
        }
        internal override bool Equal(double rhs)
        { 
            return m_value == rhs;
        } 
 
        internal override bool LessThan(Literal rhs)
        { 
            return rhs.GreaterThan(m_value);
        }
        internal override bool LessThan(sbyte rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(byte rhs) 
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(char rhs)
        {
            return m_value < rhs; 
        }
        internal override bool LessThan(short rhs) 
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(ushort rhs)
        {
            return m_value < rhs;
        } 
        internal override bool LessThan(int rhs)
        { 
            return m_value < rhs; 
        }
        internal override bool LessThan(uint rhs) 
        {
            return m_value < rhs;
        }
        internal override bool LessThan(long rhs) 
        {
            return m_value < rhs; 
        } 
        internal override bool LessThan(ulong rhs)
        { 
            return m_value < rhs;
        }
        internal override bool LessThan(float rhs)
        { 
            return m_value < rhs;
        } 
        internal override bool LessThan(double rhs) 
        {
            return m_value < rhs; 
        }

        internal override bool GreaterThan(Literal rhs)
        { 
            return rhs.LessThan(m_value);
        } 
        internal override bool GreaterThan(sbyte rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(byte rhs)
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(char rhs) 
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(short rhs)
        {
            return m_value > rhs;
        } 
        internal override bool GreaterThan(ushort rhs)
        { 
            return m_value > rhs; 
        }
        internal override bool GreaterThan(int rhs) 
        {
            return m_value > rhs;
        }
        internal override bool GreaterThan(uint rhs) 
        {
            return m_value > rhs; 
        } 
        internal override bool GreaterThan(long rhs)
        { 
            return m_value > rhs;
        }
        internal override bool GreaterThan(ulong rhs)
        { 
            return m_value > rhs;
        } 
        internal override bool GreaterThan(float rhs) 
        {
            return m_value > rhs; 
        }
        internal override bool GreaterThan(double rhs)
        {
            return m_value > rhs; 
        }
 
        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value); 
        }
        internal override bool LessThanOrEqual(sbyte rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(byte rhs) 
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(short rhs)
        {
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(char rhs)
        { 
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(ushort rhs) 
        {
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(int rhs) 
        {
            return m_value <= rhs; 
        } 
        internal override bool LessThanOrEqual(uint rhs)
        { 
            return m_value <= rhs;
        }
        internal override bool LessThanOrEqual(long rhs)
        { 
            return m_value <= rhs;
        } 
        internal override bool LessThanOrEqual(ulong rhs) 
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(float rhs)
        {
            return m_value <= rhs; 
        }
        internal override bool LessThanOrEqual(double rhs) 
        { 
            return m_value <= rhs;
        } 

        internal override bool GreaterThanOrEqual(Literal rhs)
        {
            return rhs.LessThanOrEqual(m_value); 
        }
        internal override bool GreaterThanOrEqual(sbyte rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(byte rhs)
        {
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(char rhs)
        { 
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(short rhs) 
        {
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(ushort rhs) 
        {
            return m_value >= rhs; 
        } 
        internal override bool GreaterThanOrEqual(int rhs)
        { 
            return m_value >= rhs;
        }
        internal override bool GreaterThanOrEqual(uint rhs)
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(long rhs) 
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(ulong rhs)
        {
            return m_value >= rhs; 
        }
        internal override bool GreaterThanOrEqual(float rhs) 
        { 
            return m_value >= rhs;
        } 
        internal override bool GreaterThanOrEqual(double rhs)
        {
            return m_value >= rhs;
        } 
    }
    #endregion 
 
    #region String Literal Class
    ///  
    /// Represents a string literal
    /// 
    internal class StringLiteral : Literal
    { 
        private string m_value;
 
        internal override object Value 
        {
            get { return m_value; } 
        }

        internal StringLiteral(string internalValue)
        { 
            m_value = internalValue;
            m_type = typeof(string); 
        } 

        internal override bool Equal(Literal rhs) 
        {
            return rhs.Equal(m_value);
        }
        internal override bool Equal(string rhs) 
        {
            return m_value == rhs; 
        } 

        internal override bool LessThan(Literal rhs) 
        {
            return rhs.GreaterThan(m_value);
        }
        internal override bool LessThan(string rhs) 
        {
            return 0 > string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture); 
        } 

        internal override bool GreaterThan(Literal rhs) 
        {
            return rhs.LessThan(m_value);
        }
        internal override bool GreaterThan() 
        {
            return true; 
        } 
        internal override bool GreaterThan(string rhs)
        { 
            return 0 < string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture);
        }

        internal override bool LessThanOrEqual(Literal rhs) 
        {
            return rhs.GreaterThanOrEqual(m_value); 
        } 
        internal override bool LessThanOrEqual(string rhs)
        { 
            return 0 >= string.Compare(m_value, (string)rhs, false, System.Globalization.CultureInfo.CurrentCulture);
        }

        internal override bool GreaterThanOrEqual(Literal rhs) 
        {
            return rhs.LessThanOrEqual(m_value); 
        } 
        internal override bool GreaterThanOrEqual()
        { 
            return true;
        }
        internal override bool GreaterThanOrEqual(string rhs)
        { 
            return 0 <= string.Compare(m_value, rhs, false, System.Globalization.CultureInfo.CurrentCulture);
        } 
    } 
    #endregion
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK