private void SetOperand(IConvertible operand)
 {
     switch (Instruction)
     {
         case BFInstruction.SetVariable:
         case BFInstruction.PushVariable:
         case BFInstruction.PushUInt16:
         case BFInstruction.JumpIfFalse:
         case BFInstruction.Jump:
         case BFInstruction.CallProcedure:
         case BFInstruction.CallNative:
         case BFInstruction.BeginProcedure:
         case BFInstruction.PushUInt32:
             if (operand == null)
                 throw new ArgumentException("You must specify 1 operand for this instruction.");
             _operand = new BFOperand(Convert.ToInt64(operand));
             break;
         case BFInstruction.PushFloat:
             if (operand == null)
                 throw new ArgumentException("You must specify 1 operand for this instruction.");
             _operand = new BFOperand(Convert.ToSingle(operand));
             break;
         default:
             if (operand != null)
                 _operand = new BFOperand(Convert.ToInt64(operand));
             break;
     }
 }

        protected override IConvertible DoBinOp(IConvertible left, IConvertible right)
        {
            Boolean left1 = Convert.ToBoolean(left);
            Boolean right1 = Convert.ToBoolean(right);

            return left1 && right1;
        }

 protected SpriteKernel(IConvertible initialVersion)
 {
     SourceList = new Dictionary<IConvertible, SpriteSource>();
     Animation = new PeriodicFunction<SpriteTransformation>(stage => new SpriteTransformation(0));
     RegisteredVersion = new Collection<IConvertible>();
     Version = initialVersion;
 }

        protected override IConvertible GetValue()
        {
           // if (!isGotValue)
           // {
                if (OnGetValue == null)
                {
                    throw new InvalidOperationException("This variable is not bound to a formula, so it's value cannot be read.");
                }
                VariableReadEventArgs args = new VariableReadEventArgs(Name);
                args.Type = Type;
                OnGetValue(this, args);

                if (Type != typeof(IConvertible))
                {
                    _Value = (IConvertible)Convert.ChangeType(args.Value, Type);
                }
                else
                {
                    _Value = args.Value;
                }
              //  isGotValue = true;
         //   }
            return _Value;
            
        }

 public ValueCell(StructField def, IConvertible value, string displayValue, int offset)
     : base(def)
 {
     _value = value;
     _displayValue = displayValue;
     _offset = offset;
 }

 public override string AddNumber(IConvertible number, IList<DbParameter> parameters)
 {
     if (number == null)
     {
         throw new ArgumentNullException("number");
     }
     return number.ToString();
 }

 public ProxyNumber( IConvertible value )
 {
     if (value is string)
     {
         this.value = Parse( value as string );
     }
     else
     {
         this.value = value;
     }
 }

        protected override IConvertible DoBinOp(IConvertible left, IConvertible right)
        {
            IComparable left1 = (IComparable)left;
            IComparable right1 = (IComparable)right;

            if (left1.CompareTo(right1) > 0)
            {
                return true;
            }
            return false;
        }

 public Tokenizer Ignore(int priority, IConvertible tokenName, String tokenRegex)
 {
     try {
         Regex.Replace("", tokenRegex, "");
         tokenPriorities[tokenName] = priority;
         tokens[tokenName] = new Regex("^" + tokenRegex + "$");
         ignore[tokenName] = true;
     } catch (Exception e) {
         throw (e);
     }
     return (this);
 }

 private static object AddDecimal(IConvertible Left, IConvertible Right)
 {
     decimal num = Left.ToDecimal(null);
     decimal num2 = Right.ToDecimal(null);
     try
     {
         return decimal.Add(num, num2);
     }
     catch (OverflowException)
     {
         return (Convert.ToDouble(num) + Convert.ToDouble(num2));
     }
 }

        /// <summary>
        /// Set one or more properties for the set of matched elements.
        /// </summary>
        ///
        /// <param name="name">
        /// The property to set
        /// </param>
        /// <param name="value">
        /// The value
        /// </param>
        ///
        /// <returns>
        /// The current CQ object
        /// </returns>

        public CQ Prop(string name, IConvertible value)
        {
            // Prop actually works on things other than boolean - e.g. SelectedIndex. For now though only use prop for booleans

            if (HtmlData.IsBoolean(name))
            {
                SetProp(name, value);
            }
            else
            {
                Attr(name, value);
            }
            return this;
        }

 public DateTimeFormatPartOptionTO(int length, Func<string, bool, bool> predicate, bool isNumeric,
     IConvertible actualValue, Action<IDateTimeResultTO, bool, IConvertible> assignAction, int resultLength = -1)
 {
     Length = length;
     Predicate = predicate;
     IsNumeric = isNumeric;
     ActualValue = actualValue;
     AssignAction = assignAction;
     if (resultLength == -1)
     {
         ResultLength = Length;
     }
     else
     {
         ResultLength = resultLength;
     }
 }

 private static object AddDecimal(IConvertible conv1, IConvertible conv2)
 {
     decimal num;
     if (conv1 != null)
     {
         num = conv1.ToDecimal(null);
     }
     decimal num2 = conv2.ToDecimal(null);
     try
     {
         return decimal.Add(num, num2);
     }
     catch (OverflowException)
     {
         return (Convert.ToDouble(num) + Convert.ToDouble(num2));
     }
 }

		public override object Eval (DataRow row)
		{
			//TODO: implement a better caching strategy and a mechanism for cache invalidation.
			//for now only aggregation over the table owning 'row' (e.g. 'sum(parts)'
			//in constrast to 'sum(parent.parts)' and 'sum(child.parts)') is cached.
			if (cacheResults && result != null && column.ReferencedTable == ReferencedTable.Self)
				return result;
				
			count = 0;
			result = null;
			
			object[] values;
			if (rows == null)
				values = column.GetValues (column.GetReferencedRows (row));
			else
				values = column.GetValues (rows);
			
			foreach (object val in values) {
				if (val == null)
					continue;
					
				count++;
				Aggregate ((IConvertible)val);
			}
			
			switch (function) {
			case AggregationFunction.StDev:
			case AggregationFunction.Var:
				result = CalcStatisticalFunction (values);
				break;
					
			case AggregationFunction.Avg:
				result = Numeric.Divide (result, count);
				break;
			
			case AggregationFunction.Count:
				result = count;
				break;
			}
			
			if (result == null)
				result = DBNull.Value;
				
			return result;
		}

        public void SetProperty(string property, IConvertible prop_val)
        {
            PropertyInfo prop_info = item.GetType ().GetProperty (property);

            if (prop_info == null)
                throw new ApplicationException (String.Format (
                    "Unable to set property {0}.{1} to \"{2}\"",
                    item.GetType (), property, prop_val));

            Type prop_type = prop_info.PropertyType;
            object param;

            try {
                param = prop_val.ToType (prop_type, NumberFormatInfo.InvariantInfo);
            } catch (FormatException e) {
                throw new ApplicationException (String.Format (
                    "prop_val cannot be converted to a {0}", prop_type), e);
            }

            prop_info.SetValue (item, param, null);
        }

        protected override IConvertible DoBinOp(IConvertible left, IConvertible right)
        {
            TypeCode typeCode = GetValueType(left, right);

            switch (typeCode)
            {
                case TypeCode.SByte:
                    return (Convert.ToSByte(left) + Convert.ToSByte(right));

                case TypeCode.Byte:
                    return (Convert.ToByte(left) + Convert.ToByte(right));

                case TypeCode.Int16:
                    return (Convert.ToInt16(left) + Convert.ToInt16(right));

                case TypeCode.UInt16:
                    return (Convert.ToUInt16(left) + Convert.ToUInt16(right));

                case TypeCode.Int32:
                    return (Convert.ToInt32(left) + Convert.ToInt32(right));

                case TypeCode.UInt32:
                    return (Convert.ToUInt32(left) + Convert.ToUInt32(right));

                case TypeCode.Int64:
                    return (Convert.ToInt64(left) + Convert.ToInt64(right));

                case TypeCode.UInt64:
                    return (Convert.ToUInt64(left) + Convert.ToUInt64(right));

                case TypeCode.Double:
                    return (Convert.ToDouble(left) + Convert.ToDouble(right));

                case TypeCode.Decimal:
                    return (Convert.ToDecimal(left) + Convert.ToDecimal(right));

            }

            return left.ToString() + right.ToString();
        }

        protected override IConvertible DoBinOp(IConvertible left, IConvertible right)
        {
            TypeCode typeCode = GetValueType(left, right);

            switch (typeCode)
            {
                case TypeCode.SByte:
                    return (Convert.ToSByte(left) * Convert.ToSByte(right));

                case TypeCode.Byte:
                    return (Convert.ToByte(left) * Convert.ToByte(right));

                case TypeCode.Int16:
                    return (Convert.ToInt16(left) * Convert.ToInt16(right));

                case TypeCode.UInt16:
                    return (Convert.ToUInt16(left) * Convert.ToUInt16(right));

                case TypeCode.Int32:
                    return (Convert.ToInt32(left) * Convert.ToInt32(right));

                case TypeCode.UInt32:
                    return (Convert.ToUInt32(left) * Convert.ToUInt32(right));

                case TypeCode.Int64:
                    return (Convert.ToInt64(left) * Convert.ToInt64(right));

                case TypeCode.UInt64:
                    return (Convert.ToUInt64(left) * Convert.ToUInt64(right));

                case TypeCode.Double:
                    return (Convert.ToDouble(left) * Convert.ToDouble(right));

                case TypeCode.Decimal:
                    return (Convert.ToDecimal(left) * Convert.ToDecimal(right));

            }

            throw new Exception("invalid type for MULTIPLY");
        }

		//extends to Int32/Int64/Decimal/Double
		internal static IConvertible Unify (IConvertible o)
		{
			switch (o.GetTypeCode()) {
			case TypeCode.Char:
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
				return (IConvertible)Convert.ChangeType (o, TypeCode.Int32);
			
			case TypeCode.UInt32:
				return (IConvertible)Convert.ChangeType (o, TypeCode.Int64);
				
			case TypeCode.UInt64:
				return (IConvertible)Convert.ChangeType (o, TypeCode.Decimal);
				
			case TypeCode.Single:
				return (IConvertible)Convert.ChangeType (o, TypeCode.Double);
			
			default:
				return o;
			}
		}

        /// <summary>
        /// Set a specific item, identified by the 2nd parameter, of a named option group, identified by
        /// the first parameter, as selected.
        /// </summary>
        ///
        /// <param name="groupName">
        /// The value of the name attribute identifying this option group.
        /// </param>
        /// <param name="value">
        /// The option value to set as selected
        /// </param>
        ///
        /// <returns>
        /// The current CQ object
        /// </returns>

        public CQ SetSelected(string groupName, IConvertible value)
        {
            var group = this.Find("input[name='" + groupName + "']");
            var item = group.Filter("[value='" + value + "']");
            if (group.Length == 0)
            {
                item = this.Find("#" + groupName);
            }
            if (item.Length > 0)
            {
                ushort nodeNameID = group[0].NodeNameID;
                string type = group[0]["type"].ToUpper();
                if (nodeNameID == HtmlData.tagOPTION)
                {
                    var ownerMultiple = group.Closest("select").Prop("multiple");
                    if (Objects.IsTruthy(ownerMultiple))
                    {
                        item.Prop("selected", true);
                    }
                    else
                    {
                        group.Prop("selected", false);
                        item.Prop("selected", true);
                    }
                }
                else if (nodeNameID == HtmlData.tagINPUT && 
                    (type == "radio" || type == "checkbox"))
                {
                    if (type == "radio")
                    {
                        group.Prop("checked", false);
                    }
                    item.Prop("checked", true);
                }
            }
            return this;
        }

		//(note: o1 and o2 must both be of type Int32/Int64/Decimal/Double)
		internal static TypeCode ToSameType (ref IConvertible o1, ref IConvertible o2)
		{
			TypeCode tc1 = o1.GetTypeCode();
			TypeCode tc2 = o2.GetTypeCode();
			
			if (tc1 == tc2)
				return tc1;

			if (tc1 == TypeCode.DBNull || tc2 == TypeCode.DBNull)
				return TypeCode.DBNull;


			// is it ok to make such assumptions about the order of an enum?
			if (tc1 < tc2)
			{
				o1 = (IConvertible)Convert.ChangeType (o1, tc2);
				return tc2;
			}
			else
			{
				o2 = (IConvertible)Convert.ChangeType (o2, tc1);
				return tc1;
			}
		}