public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: // ToDo: Maybe introduce a 'Duration' type to handle this! return(new Date(value + TimeSpan.FromDays(operand.AsDouble))); case BinaryOperator.Minus: // ToDo: Maybe introduce a 'Duration' type to handle this! return(new Float((value - operand.AsDateTime).TotalDays)); case BinaryOperator.LessThan: return(Boolean.FromBool(value < operand.AsDateTime)); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(value <= operand.AsDateTime)); case BinaryOperator.GreaterThan: return(Boolean.FromBool(value > operand.AsDateTime)); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(value >= operand.AsDateTime)); default: return(base.BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: { var result = new List <Dynamic>(list); result.AddRange(operand.AsList); return(new List(result)); } case BinaryOperator.Times: { var result = new List <Dynamic>(); int n = operand.AsInt32; for (int i = 0; i < n; ++i) { result.AddRange(list); } return(new List(result)); } case BinaryOperator.Contains: return(Boolean.FromBool(list.Contains(operand))); default: return(base.BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { try { switch (_operator) { case BinaryOperator.Plus: return(new Integer(checked (value + operand.AsInt32))); case BinaryOperator.Minus: return(new Integer(value - operand.AsInt32)); case BinaryOperator.Times: return(new Integer(checked (value * operand.AsInt32))); case BinaryOperator.Divide: return(Rational.Simplify(new Rational32(value, operand.AsInt32))); case BinaryOperator.Modulo: return(new Integer(value % operand.AsInt32)); case BinaryOperator.Power: return(new Integer(MathUtil.Power(value, operand.AsInt32))); case BinaryOperator.And: return(new Integer(value & operand.AsInt32)); case BinaryOperator.Or: return(new Integer(value | operand.AsInt32)); case BinaryOperator.ExclusiveOr: return(new Integer(value ^ operand.AsInt32)); case BinaryOperator.ShiftLeft: return(new Integer(value << operand.AsInt32)); case BinaryOperator.ShiftRight: return(new Integer(value >> operand.AsInt32)); case BinaryOperator.LessThan: return(Boolean.FromBool(value < operand.AsInt32)); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(value <= operand.AsInt32)); case BinaryOperator.GreaterThan: return(Boolean.FromBool(value > operand.AsInt32)); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(value >= operand.AsInt32)); default: return(base.BinaryOperation(_operator, operand)); } } catch (OverflowException) { return(new Long(value).BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: return(new Long(value + operand.AsBigInteger)); case BinaryOperator.Minus: return(new Long(value - operand.AsBigInteger)); case BinaryOperator.Times: return(new Long(value * operand.AsBigInteger)); case BinaryOperator.Divide: return(new Long(value / operand.AsBigInteger)); case BinaryOperator.Modulo: return(new Long(value % operand.AsBigInteger)); case BinaryOperator.Power: return(new Long(BigInteger.Pow(value, operand.AsInt32))); case BinaryOperator.And: return(new Long(value & operand.AsBigInteger)); case BinaryOperator.Or: return(new Long(value | operand.AsBigInteger)); case BinaryOperator.ExclusiveOr: return(new Long(value ^ operand.AsBigInteger)); case BinaryOperator.ShiftLeft: return(new Long(value << operand.AsInt32)); case BinaryOperator.ShiftRight: return(new Long(value >> operand.AsInt32)); case BinaryOperator.LessThan: return(Boolean.FromBool(value < operand.AsBigInteger)); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(value <= operand.AsBigInteger)); case BinaryOperator.GreaterThan: return(Boolean.FromBool(value > operand.AsBigInteger)); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(value >= operand.AsBigInteger)); default: return(base.BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: case BinaryOperator.Or: { var result = new HashSet <Dynamic>(hashSet); result.UnionWith(operand.AsHashSet); return(new Set(result)); } case BinaryOperator.Minus: { var result = new HashSet <Dynamic>(hashSet); result.ExceptWith(operand.AsHashSet); return(new Set(result)); } case BinaryOperator.And: { var result = new HashSet <Dynamic>(hashSet); result.IntersectWith(operand.AsHashSet); return(new Set(result)); } case BinaryOperator.ExclusiveOr: { var result = new HashSet <Dynamic>(hashSet); result.SymmetricExceptWith(operand.AsHashSet); return(new Set(result)); } case BinaryOperator.LessThan: return(Boolean.FromBool(hashSet.IsProperSubsetOf(operand.AsHashSet))); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(hashSet.IsSubsetOf(operand.AsHashSet))); case BinaryOperator.GreaterThan: return(Boolean.FromBool(hashSet.IsProperSupersetOf(operand.AsHashSet))); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(hashSet.IsSupersetOf(operand.AsHashSet))); case BinaryOperator.Contains: return(Boolean.FromBool(hashSet.Contains(operand))); default: return(base.BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: return(new Decimal(value + operand.AsBigDecimal)); case BinaryOperator.Minus: return(new Decimal(value - operand.AsBigDecimal)); case BinaryOperator.Times: return(new Decimal(value * operand.AsBigDecimal)); case BinaryOperator.Divide: return(new Decimal(value / operand.AsBigDecimal)); case BinaryOperator.Modulo: return(new Decimal(value % operand.AsBigDecimal)); case BinaryOperator.Power: return(new Decimal(value.Power(operand.AsInt32))); case BinaryOperator.LessThan: return(Boolean.FromBool(value < operand.AsBigDecimal)); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(value <= operand.AsBigDecimal)); case BinaryOperator.GreaterThan: return(Boolean.FromBool(value > operand.AsBigDecimal)); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(value >= operand.AsBigDecimal)); default: return(base.BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: return(new Float(value + operand.AsDouble)); case BinaryOperator.Minus: return(new Float(value - operand.AsDouble)); case BinaryOperator.Times: return(new Float(value * operand.AsDouble)); case BinaryOperator.Divide: return(new Float(value / operand.AsDouble)); case BinaryOperator.Modulo: return(new Float(MathUtil.Modulo(value, operand.AsDouble))); case BinaryOperator.Power: return(new Float(Math.Pow(value, operand.AsDouble))); case BinaryOperator.LessThan: return(Boolean.FromBool(value < operand.AsDouble)); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(value <= operand.AsDouble)); case BinaryOperator.GreaterThan: return(Boolean.FromBool(value > operand.AsDouble)); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(value >= operand.AsDouble)); default: return(base.BinaryOperation(_operator, operand)); } }
public override Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Plus: return(new String(value + operand)); case BinaryOperator.Times: return(new String(StringUtil.Repeat(value, operand.AsInt32))); case BinaryOperator.LessThan: return(Boolean.FromBool(string.Compare(value, operand.ToString()) < 0)); case BinaryOperator.LessThanOrEqual: return(Boolean.FromBool(string.Compare(value, operand.ToString()) <= 0)); case BinaryOperator.GreaterThan: return(Boolean.FromBool(string.Compare(value, operand.ToString()) > 0)); case BinaryOperator.GreaterThanOrEqual: return(Boolean.FromBool(string.Compare(value, operand.ToString()) >= 0)); case BinaryOperator.StartsWith: return(Boolean.FromBool(value.StartsWith(operand.ToString()))); case BinaryOperator.EndsWith: return(Boolean.FromBool(value.EndsWith(operand.ToString()))); case BinaryOperator.Contains: return(Boolean.FromBool(value.Contains(operand.ToString()))); case BinaryOperator.Matches: return(Boolean.FromBool(StringUtil.GetRegex(operand.ToString()).IsMatch(value))); default: return(base.BinaryOperation(_operator, operand)); } }
public virtual Dynamic BinaryOperation(BinaryOperator _operator, Dynamic operand) { switch (_operator) { case BinaryOperator.Equal: return(Boolean.FromBool(Equals(operand))); case BinaryOperator.NotEqual: return(Boolean.FromBool(!Equals(operand))); case BinaryOperator.Identical: return(Boolean.FromBool((Class == operand.Class) && Equals(operand))); case BinaryOperator.NotIdentical: return(Boolean.FromBool(!((Class == operand.Class) && Equals(operand)))); default: throw new InvalidOperationException( string.Format(Resources.OperatorCantBeApplied, CodeGenerator.BinaryOperatorToString(_operator), Class.Name)); } }
/// <summary> /// Recognizes atomic expressions like literals, initializers, /// simple references, simple calls, conversions, parenthesized /// expressions and the <b>typeof</b> expression. /// </summary> /// <returns>An <see cref="Expression"/></returns> protected Expression Atom() { SkipComments(); switch (token.TokenID) { case TokenID.LT_Null: return(Literal(null)); case TokenID.LT_Boolean: return(Literal(Boolean.FromBool((bool)token.Value))); case TokenID.LT_Integer: return(Literal(new Integer((int)token.Value))); case TokenID.LT_Long: return(Literal(new Long((BigInteger)token.Value))); case TokenID.LT_Float: return(Literal(new Float((double)token.Value))); case TokenID.LT_Decimal: return(Literal(new Decimal((BigDecimal)token.Value))); case TokenID.LT_Date: return(Literal(new Date((DateTime)token.Value))); case TokenID.LT_String: return(Literal(new String((string)token.Value))); case TokenID.KW_This: return(ThisReference()); case TokenID.KW_Super: return(AtomStartingWithSuper()); case TokenID.KW_New: return(AtomStartingWithNew()); case TokenID.KW_TypeOf: return(AtomStartingWithTypeOf()); case TokenID.TypeName: return(AtomStartingWithTypeName()); case TokenID.Identifier: return(AtomStartingWithId()); case TokenID.LeftParenthesis: return(AtomStartingWithLParen()); case TokenID.LeftBrace: return(AtomStartingWithLBrace()); case TokenID.LeftBracket: return(ListInitializer()); case TokenID.VerticalBar: return(Lambda()); case TokenID.KW_Function: return(InlineFunction()); default: return(null); } }
public static Dynamic CreateDynamic(object value) { if (value == null) { return(Void.Value); } if (value is Dynamic) { return((Dynamic)value); } if (value is Enum) { return(new String(value.ToString())); } if (value is char[]) { return(new String(new string((char[])value))); } if (value is byte[]) { return(new String(StringUtil.ByteArray2String((byte[])value))); } if (value is Array) { var array = (Array)value; var list = new List <Dynamic>(); foreach (object item in array) { list.Add(CreateDynamic(item)); } return(new List(list)); } switch (Type.GetTypeCode(value.GetType())) { case TypeCode.Boolean: return(Boolean.FromBool(Convert.ToBoolean(value))); case TypeCode.SByte: case TypeCode.Byte: case TypeCode.Int16: case TypeCode.UInt16: case TypeCode.Int32: return(new Integer(Convert.ToInt32(value))); case TypeCode.UInt32: case TypeCode.Int64: return(new Long(Convert.ToInt64(value))); case TypeCode.UInt64: return(new Long(Convert.ToUInt64(value))); case TypeCode.Single: case TypeCode.Double: return(new Float(Convert.ToDouble(value))); case TypeCode.Decimal: return(new Decimal(Convert.ToDecimal(value))); case TypeCode.DateTime: return(new Date(Convert.ToDateTime(value))); case TypeCode.Char: case TypeCode.String: return(new String(Convert.ToString(value))); case TypeCode.Object: if (value is BigInteger) { return(new Long((BigInteger)value)); } if (value is Rational32) { return(new Rational((Rational32)value)); } if (value is BigDecimal) { return(new Decimal((BigDecimal)value)); } if (value is Complex64) { return(new Complex((Complex64)value)); } if (value is List <Dynamic> ) { return(new List((List <Dynamic>)value)); } if (value is Dictionary <Dynamic, Dynamic> ) { return(new Map((Dictionary <Dynamic, Dynamic>)value)); } if (value is HashSet <Dynamic> ) { return(new Set((HashSet <Dynamic>)value)); } if (value is Queue <Dynamic> ) { return(new Queue((Queue <Dynamic>)value)); } if (value is Stack <Dynamic> ) { return(new Stack((Stack <Dynamic>)value)); } if (value is Tuple <Class, Dictionary <string, Dynamic> > ) { var couple = (Tuple <Class, Dictionary <string, Dynamic> >)value; return(new Object(couple.Item1, couple.Item2)); } if (value is Function) { return(new Closure((Function)value)); } return(new Resource(value)); default: return(new Resource(value)); } }
public virtual Dynamic ConvertTo(Class targetClass) { if (targetClass == Class) { return(this); } switch (targetClass.ClassID) { case ClassID.Boolean: return(Boolean.FromBool(AsBoolean)); case ClassID.Integer: return(new Integer(AsInt32)); case ClassID.Long: return(new Long(AsBigInteger)); case ClassID.Rational: return(new Rational(AsRational32)); case ClassID.Float: return(new Float(AsDouble)); case ClassID.Decimal: return(new Decimal(AsBigDecimal)); case ClassID.Complex: return(new Complex(AsComplex64)); case ClassID.Date: return(new Date(AsDateTime)); case ClassID.String: return(new String(ToString())); case ClassID.List: return(new List(AsList)); case ClassID.Map: return(new Map(AsDictionary)); case ClassID.Set: return(new Set(AsHashSet)); case ClassID.Queue: return(new Queue(AsQueue)); case ClassID.Stack: return(new Stack(AsStack)); case ClassID.Object: return(new Object(AsDynamicObject)); case ClassID.Resource: return(new Resource(AsNativeObject)); case ClassID.Closure: return(new Closure(AsFunction)); default: throw new InvalidCastException(); } }
/// <summary> /// Initializes a boolean constant. /// </summary> /// <param name="value">The constant's value</param> public Constant(bool value) { this.value = Boolean.FromBool(value); }