internal ElaValue Force() { if (Value.Ref == null) { var fun = Function; while (fun != null) { Value = fun.CallWithThrow( fun.LastParameter.Ref != null ? fun.LastParameter : new ElaValue(ElaUnit.Instance)); if (Value.Ref is ElaLazy) { var la = (ElaLazy)Value.Ref; if (la.Value.Ref == null && la.Function != null) fun = la.Function; else { Value = la.Value; fun = null; } } else fun = null; } } return Value; }
internal ElaValue GetField(ElaValue index, ExecutionContext ctx) { if (vm != null) { if (index.TypeId != ElaMachine.STR) { ctx.InvalidType(TCF.GetShortForm(ElaTypeCode.String), index); return(Default()); } var field = index.DirectGetString(); var frame = vm.Assembly.GetModule(Handle); ScopeVar sc; if (!frame.GlobalScope.Locals.TryGetValue(field, out sc)) { ctx.UnknownField(index.DirectGetString(), new ElaValue(this)); return(Default()); } if ((sc.Flags & ElaVariableFlags.Private) == ElaVariableFlags.Private) { ctx.Fail(new ElaError(ElaRuntimeError.PrivateVariable, field)); return(Default()); } return(vm.modules[Handle][sc.Address]); } ctx.Fail(ElaRuntimeError.Unknown, "VM is non present"); return(Default()); }
internal override ElaValue Quot(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.INT) { if (right.TypeId == ElaMachine.LNG) { var r = right.Ref.AsLong(); if (r == 0) { ctx.DivideByZero(left); return(Default()); } return(new ElaValue(left.I4 / r)); } else { ctx.NoOverload(left.GetTypeName() + "->" + left.GetTypeName() + "->*", left.GetTypeName() + "->" + right.GetTypeName() + "->*", "quot"); return(Default()); } } if (right.I4 == 0) { ctx.DivideByZero(left); return(Default()); } return(new ElaValue(left.I4 / right.I4)); }
internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.REA) { if (right.TypeId == ElaMachine.DBL) { return(left.DirectGetSingle() > right.Ref.AsDouble()); } else if (right.TypeId == ElaMachine.INT) { return(left.DirectGetSingle() > right.I4); } else if (right.TypeId == ElaMachine.LNG) { return(left.DirectGetSingle() > right.Ref.AsLong()); } else { NoOverloadBinary(TCF.SINGLE, right, "greater", ctx); return(false); } } return(left.DirectGetSingle() > right.DirectGetSingle()); }
internal override ElaValue Quot(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.LNG) { if (right.TypeId == ElaMachine.INT) { if (right.I4 == 0) { ctx.DivideByZero(left); return Default(); } return new ElaValue(left.Ref.AsLong() / right.I4); } else { ctx.NoOverload(left.GetTypeName() + "->" + left.GetTypeName() + "->*", left.GetTypeName() + "->" + right.GetTypeName() + "->*", "quot"); return Default(); } } var r = right.Ref.AsLong(); if (r == 0) { ctx.DivideByZero(left); return Default(); } return new ElaValue(left.Ref.AsLong() / right.Ref.AsLong()); }
internal override ElaValue Divide(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.INT) { if (right.TypeId == ElaMachine.LNG) { var r = right.Ref.AsLong(); return(new ElaValue((Double)left.I4 / r)); } else if (right.TypeId == ElaMachine.REA) { return(new ElaValue(left.I4 / right.DirectGetSingle())); } else if (right.TypeId == ElaMachine.DBL) { return(new ElaValue(left.I4 / right.Ref.AsDouble())); } else { NoOverloadBinary(TCF.INT, right, "divide", ctx); return(Default()); } } return(new ElaValue((Single)left.I4 / right.I4)); }
internal override bool LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.INT) { if (right.TypeId == ElaMachine.LNG) { return(left.I4 <= right.Ref.AsLong()); } else if (right.TypeId == ElaMachine.REA) { return(left.I4 <= right.DirectGetSingle()); } else if (right.TypeId == ElaMachine.DBL) { return(left.I4 <= right.Ref.AsDouble()); } else { NoOverloadBinary(TCF.INT, right, "lesserequal", ctx); return(false); } } return(left.I4 <= right.I4); }
public ElaRecord AddField(string field, ElaValue value, ElaRecord rec) { var fieldList = new List<ElaRecordField>(); fieldList.AddRange(rec); fieldList.Add(new ElaRecordField(field, value)); return new ElaRecord(fieldList.ToArray()); }
internal override ElaValue Multiply(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.LNG) { if (right.TypeId == ElaMachine.INT) { return(new ElaValue(left.Ref.AsLong() + right.I4)); } else if (right.TypeId == ElaMachine.REA) { return(new ElaValue(left.Ref.AsLong() + right.DirectGetSingle())); } else if (right.TypeId == ElaMachine.DBL) { return(new ElaValue(left.Ref.AsLong() + right.Ref.AsDouble())); } else { NoOverloadBinary(TCF.LONG, right, "multiply", ctx); return(Default()); } } return(new ElaValue(left.Ref.AsLong() * right.Ref.AsLong())); }
internal CallPoint(int modHandle, EvalStack stack, ElaValue[] locals, FastList<ElaValue[]> captures) { ModuleHandle = modHandle; Locals = locals; Captures = captures; Stack = stack; }
internal override ElaValue Remainder(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.REA) { if (right.TypeId == ElaMachine.DBL) { return(new ElaValue(left.DirectGetSingle() % right.Ref.AsDouble())); } else if (right.TypeId == ElaMachine.INT) { return(new ElaValue(left.DirectGetSingle() % right.I4)); } else if (right.TypeId == ElaMachine.LNG) { return(new ElaValue(left.DirectGetSingle() % right.Ref.AsLong())); } else { NoOverloadBinary(TCF.SINGLE, right, "remainder", ctx); return(Default()); } } if (right.DirectGetSingle() == 0) { ctx.DivideByZero(left); return(Default()); } return(new ElaValue(left.DirectGetSingle() % right.DirectGetSingle())); }
internal override ElaValue Divide(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.REA) { if (right.TypeId == ElaMachine.DBL) return new ElaValue(left.DirectGetSingle() / right.Ref.AsDouble()); else if (right.TypeId == ElaMachine.INT) return new ElaValue(left.DirectGetSingle() / right.I4); else if (right.TypeId == ElaMachine.LNG) return new ElaValue(left.DirectGetSingle() / right.Ref.AsLong()); else { NoOverloadBinary(TCF.SINGLE, right, "divide", ctx); return Default(); } } if (right.DirectGetSingle() == 0) { ctx.DivideByZero(left); return Default(); } return new ElaValue(left.DirectGetSingle() / right.DirectGetSingle()); }
public ElaValue AsString(ElaValue val) { if (val.TypeId > SysConst.MAX_TYP) { var tid = val.TypeId; var sb = new StringBuilder(); var usb = val.Ref as ElaUserType2; var xs = new List <String>(); while (usb != null) { xs.Add(usb.Value2.DirectGetString()); var td = usb.Value1.Ref; if (td.TypeId == tid) { usb = td as ElaUserType2; } else { usb = null; xs.Add(td.ToString()); } } for (var i = xs.Count - 1; i > -1; i--) { sb.Append(xs[i]); } return(new ElaValue(sb.ToString())); } return(new ElaValue(val.AsString())); }
internal override ElaValue Subtract(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.DBL) { if (right.TypeId == ElaMachine.REA) { return(new ElaValue(left.Ref.AsDouble() - right.DirectGetSingle())); } else if (right.TypeId == ElaMachine.INT) { return(new ElaValue(left.Ref.AsDouble() - right.I4)); } else if (right.TypeId == ElaMachine.LNG) { return(new ElaValue(left.Ref.AsDouble() - right.Ref.AsLong())); } else { NoOverloadBinary(TCF.DOUBLE, right, "subtract", ctx); return(Default()); } } return(new ElaValue(left.Ref.AsDouble() - right.Ref.AsDouble())); }
internal override ElaValue Modulus(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.REA) { if (right.TypeId == ElaMachine.DBL) { return(DoubleInstance.Modulus(left.DirectGetSingle(), right.Ref.AsDouble(), ctx)); } else if (right.TypeId == ElaMachine.INT) { return(Modulus(left.DirectGetSingle(), right.I4, ctx)); } else if (right.TypeId == ElaMachine.LNG) { return(Modulus(left.DirectGetSingle(), right.Ref.AsLong(), ctx)); } else { NoOverloadBinary(TCF.SINGLE, right, "modulus", ctx); return(Default()); } } return(Modulus(left.DirectGetSingle(), right.DirectGetSingle(), ctx)); }
internal override ElaValue Power(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.REA) { if (right.TypeId == ElaMachine.DBL) { return(new ElaValue(Math.Pow(left.DirectGetSingle(), right.Ref.AsDouble()))); } else if (right.TypeId == ElaMachine.INT) { return(new ElaValue((Single)Math.Pow(left.DirectGetSingle(), right.I4))); } else if (right.TypeId == ElaMachine.LNG) { return(new ElaValue((Single)Math.Pow(left.DirectGetSingle(), right.Ref.AsLong()))); } else { NoOverloadBinary(TCF.SINGLE, right, "power", ctx); return(Default()); } } return(new ElaValue(Math.Pow(left.DirectGetSingle(), right.DirectGetSingle()))); }
public ElaVariant GetValue(ElaValue key, ElaMap map) { if (map.Tree.IsEmpty) return ElaVariant.None(); var res = map.Tree.Search(key); return res.IsEmpty ? ElaVariant.None() : ElaVariant.Some(res.Value); }
protected override ElaValue Convert(ElaValue @this, ElaTypeInfo type, ExecutionContext ctx) { if (type.ReflectedTypeCode == ElaTypeCode.String) return new ElaValue(Value.ToString()); ctx.ConversionFailed(@this, type.ReflectedTypeName); return Default(); }
public ElaFun <T1, T2, T3, T4, R> ToDelegate <T1, T2, T3, T4, R>() { return((t1, t2, t3, t4) => { var ret = Call(ElaValue.FromObject(t1), ElaValue.FromObject(t2), ElaValue.FromObject(t3), ElaValue.FromObject(t4)); return ret.Convert <R>(); }); }
public ElaFun <T, R> ToDelegate <T, R>() { return(t => { var ret = Call(ElaValue.FromObject(t)); return ret.Convert <R>(); }); }
internal AvlTree(ElaValue key, ElaValue value, AvlTree left, AvlTree right) { Key = key; Value = value; Left = left; Right = right; TreeHeight = 1 + Math.Max(Height(left), Height(right)); }
public ElaRecord AddField(string field, ElaValue value, ElaRecord rec) { var fieldList = new List <ElaRecordField>(); fieldList.AddRange(rec); fieldList.Add(new ElaRecordField(field, value)); return(new ElaRecord(fieldList.ToArray())); }
internal override bool False(ElaValue @this, ExecutionContext ctx) { var ret = Force(ctx); if (ctx.Failed) return false; return ret.Ref.False(ret, ctx); }
internal override ElaValue Force(ElaValue @this, ExecutionContext ctx) { if (ctx == ElaObject.DummyContext) { return(Force()); } return(Force(ctx)); }
public ElaFun <T1, T2, T3, T4, T5, T6, T7, T8, R> ToDelegate <T1, T2, T3, T4, T5, T6, T7, T8, R>() { return((t1, t2, t3, t4, t5, t6, t7, t8) => { var ret = Call(ElaValue.FromObject(t1), ElaValue.FromObject(t2), ElaValue.FromObject(t3), ElaValue.FromObject(t4), ElaValue.FromObject(t5), ElaValue.FromObject(t6), ElaValue.FromObject(t7), ElaValue.FromObject(t8)); return ret.Convert <R>(); }); }
public ElaVariant Get(ElaValue key, ElaMutableMap map) { var val = default(ElaValue); if (!map.Map.TryGetValue(key, out val)) return ElaVariant.None(); return ElaVariant.Some(val); }
internal override bool Equal(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.UNI) { NoOverloadBinary(TCF.UNIT, right, "equal", ctx); return false; } return left.Ref == right.Ref; }
internal override ElaValue ShiftLeft(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.INT) { NoOverloadBinary(TCF.LONG, right, "shiftleft", ctx); return(Default()); } return(new ElaValue(left.Ref.AsLong() << right.I4)); }
internal override bool Equal(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.BYT) { NoOverloadBinary(TCF.BOOL, right, "equal", ctx); return(false); } return(left.I4 == right.I4); }
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.MOD) { NoOverloadBinary(TCF.MOD, right, "notequal", ctx); return false; } return ((ElaModule)left.Ref).Handle != ((ElaModule)right.Ref).Handle; }
internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.CHR) { NoOverloadBinary(TCF.CHAR, right, "greater", ctx); return(false); } return(left.I4 > right.I4); }
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.STR) { NoOverloadBinary(TCF.STRING, right, "notequal", ctx); return(false); } return(left.DirectGetString() != right.DirectGetString()); }
internal override ElaValue ShiftRight(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.INT) { NoOverloadBinary(TCF.INT, right, "shiftright", ctx); return(Default()); } return(new ElaValue(left.I4 >> right.I4)); }
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.BYT) { NoOverloadBinary(TCF.BOOL, right, "notequal", ctx); return false; } return left.I4 != right.I4; }
internal override bool Lesser(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.STR) { NoOverloadBinary(TCF.STRING, right, "lesser", ctx); return false; } return left.DirectGetString().CompareTo(right.DirectGetString()) > 0; }
internal override bool Equal(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.STR) { NoOverloadBinary(TCF.STRING, right, "equal", ctx); return false; } return left.DirectGetString() == right.DirectGetString(); }
internal override bool LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.CHR) { NoOverloadBinary(TCF.CHAR, right, "lesserequal", ctx); return false; } return left.I4 <= right.I4; }
internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.CHR) { NoOverloadBinary(TCF.CHAR, right, "greater", ctx); return false; } return left.I4 > right.I4; }
internal override bool LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.STR) { NoOverloadBinary(TCF.STRING, right, "lesserequal", ctx); return(false); } return(left.DirectGetString().CompareTo(right.DirectGetString()) >= 0); }
internal override bool LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.CHR) { NoOverloadBinary(TCF.CHAR, right, "lesserequal", ctx); return(false); } return(left.I4 <= right.I4); }
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.MOD) { NoOverloadBinary(TCF.MOD, right, "notequal", ctx); return(false); } return(((ElaModule)left.Ref).Handle != ((ElaModule)right.Ref).Handle); }
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.UNI) { NoOverloadBinary(TCF.UNIT, right, "notequal", ctx); return(false); } return(left.Ref == right.Ref); }
internal override bool False(ElaValue @this, ExecutionContext ctx) { var ret = Force(ctx); if (ctx.Failed) { return(false); } return(ret.Ref.False(ret, ctx)); }
internal virtual string Show(ElaValue value, ExecutionContext ctx) { if (show != null) { ctx.SetDeffered(show, 1); return(String.Empty); } ctx.NoOverload(value.GetTypeName(), "show"); return(String.Empty); }
internal virtual bool IsNil(ElaValue left, ExecutionContext ctx) { if (isnil != null) { ctx.SetDeffered(isnil, 1); return(false); } ctx.NoOverload(left.GetTypeName(), "isnil"); return(false); }
internal virtual ElaValue Tail(ElaValue left, ExecutionContext ctx) { if (tail != null) { ctx.SetDeffered(tail, 1); return(Default()); } ctx.NoOverload(left.GetTypeName(), "tail"); return(Default()); }
internal virtual ElaValue Head(ElaValue left, ExecutionContext ctx) { if (head != null) { ctx.SetDeffered(head, 1); return(Default()); } ctx.NoOverload(left.GetTypeName(), "head"); return(Default()); }
internal virtual AvlTree Add(ElaValue key, ElaValue value) { var result = default(AvlTree); if (key.CompareTo(Key) > 0) result = new AvlTree(Key, Value, Left, Right.Add(key, value)); else result = new AvlTree(Key, Value, Left.Add(key, value), Right); return MakeBalanced(result); }
protected override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { var lg = left.As<ElaGuid>(); var rg = right.As<ElaGuid>(); if (lg != null && rg != null) return lg.Value != rg.Value; else if (lg != null) return right.NotEqual(left, right, ctx); return true; }
public ElaRecord ChangeField(string field, ElaValue value, ElaRecord rec) { var fieldList = new List<ElaRecordField>(); foreach (var f in rec) if (f.Field == field) fieldList.Add(new ElaRecordField(f.Field, value)); else fieldList.Add(f); return new ElaRecord(fieldList.ToArray()); }
internal override ElaValue Concatenate(ElaValue left, ElaValue right, ExecutionContext ctx) { left = left.Ref.Force(left, ctx); right = right.Ref.Force(right, ctx); if (right.TypeId != ElaMachine.REC) { NoOverloadBinary(TCF.RECORD, right, "concatenate", ctx); return Default(); } return new ElaValue(ElaRecord.Concat((ElaRecord)left.Ref, (ElaRecord)right.Ref)); }
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.FUN) { NoOverloadBinary(TCF.FUN, right, "notequal", ctx); return false; } var f1 = (ElaFunction)left.Ref; var f2 = (ElaFunction)left.Ref; return f1.Handle != f2.Handle || f1.ModuleHandle != f2.ModuleHandle || f1.AppliedParameters != f2.AppliedParameters || f1.AppliedParameters != 0; }
internal override ElaValue BitwiseXor(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.LNG) { if (right.TypeId == ElaMachine.INT) return new ElaValue(left.Ref.AsLong() ^ right.I4); else { NoOverloadBinary(TCF.LONG, right, "bitwisexor", ctx); return Default(); } } return new ElaValue(left.Ref.AsLong() ^ right.Ref.AsLong()); }
internal override ElaValue Concatenate(ElaValue left, ElaValue right, ExecutionContext ctx) { right = right.Ref.Force(right, ctx); if (right.TypeId != ElaMachine.STR) { if (right.TypeId == ElaMachine.CHR) return new ElaValue(left.DirectGetString() + right.ToString()); NoOverloadBinary(TCF.STRING, right, "concatenate", ctx); return Default(); } return new ElaValue(left.DirectGetString() + right.DirectGetString()); }
internal override ElaValue GetValue(ElaValue value, ElaValue key, ExecutionContext ctx) { if (key.TypeId != ElaMachine.INT) { ctx.InvalidIndexType(key); return Default(); } var tup = (ElaTuple)value.Ref; if (key.I4 < tup.Length && key.I4 > -1) return tup.Values[key.I4]; ctx.IndexOutOfRange(key, value); return Default(); }
internal override ElaValue BitwiseOr(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.LNG) { if (right.TypeId == ElaMachine.INT) { var lo = (Int64)right.I4; return new ElaValue(left.Ref.AsLong() | lo); } else { NoOverloadBinary(TCF.LONG, right, "bitwiseor", ctx); return Default(); } } return new ElaValue(left.Ref.AsLong() | right.Ref.AsLong()); }
internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.REA) { if (right.TypeId == ElaMachine.DBL) return left.DirectGetSingle() > right.Ref.AsDouble(); else if (right.TypeId == ElaMachine.INT) return left.DirectGetSingle() > right.I4; else if (right.TypeId == ElaMachine.LNG) return left.DirectGetSingle() > right.Ref.AsLong(); else { NoOverloadBinary(TCF.SINGLE, right, "greater", ctx); return false; } } return left.DirectGetSingle() > right.DirectGetSingle(); }
internal override ElaValue Add(ElaValue left, ElaValue right, ExecutionContext ctx) { if (right.TypeId != ElaMachine.LNG) { if (right.TypeId == ElaMachine.INT) return new ElaValue(left.Ref.AsLong() + right.I4); else if (right.TypeId == ElaMachine.REA) return new ElaValue(left.Ref.AsLong() + right.DirectGetSingle()); else if (right.TypeId == ElaMachine.DBL) return new ElaValue(left.Ref.AsLong() + right.Ref.AsDouble()); else { NoOverloadBinary(TCF.LONG, right, "add", ctx); return Default(); } } return new ElaValue(left.Ref.AsLong() + right.Ref.AsLong()); }
public bool Contains(ElaValue key, ElaMutableMap map) { return map.Map.ContainsKey(key); }
public ElaMap Remove(ElaValue key, ElaMap map) { return map.Remove(key); }