public override HeronValue Eval(VM vm) { HeronValue result = vm.Eval(expr); vm.Eval(ass); return(result); }
public override void Eval(VM vm) { HeronValue initVal = initial.Eval(vm); VarDesc desc = new VarDesc(name); using (vm.CreateScope()) { vm.AddVar(desc, initVal); while (true) { HeronValue condVal = vm.Eval(condition); bool b = condVal.ToBool(); if (!b) { return; } vm.Eval(body); if (vm.ShouldExitScope()) { return; } vm.Eval(next); } } }
public override HeronValue Eval(VM vm) { HeronValue val = vm.Eval(rvalue); if (lvalue is Name) { string name = (lvalue as Name).name; if (vm.HasVar(name)) { vm.SetVar(name, val); return(val); } else if (vm.HasField(name)) { vm.SetField(name, val); return(val); } else { throw new Exception(name + " is not a member field or local variable that can be assigned to"); } } else if (lvalue is ChooseField) { ChooseField field = lvalue as ChooseField; HeronValue self = vm.Eval(field.self); self.SetField(field.name, val); return(val); } else if (lvalue is ReadAt) { ReadAt ra = lvalue as ReadAt; HeronValue self = vm.Eval(ra.self); HeronValue index = vm.Eval(ra.index); ListValue list = self as ListValue; if (list != null) { list.SetAtIndex(index, val); return(val); } ArrayValue array = self as ArrayValue; if (array != null) { array.SetAtIndex(index, val); return(val); } throw new Exception("Unimplemented"); } else { throw new Exception("Cannot assign to expression " + lvalue.ToString()); } }
public override void Eval(VM vm) { bool b = condition.Eval(vm).ToBool(); if (b) { vm.Eval(ontrue); } else if (onfalse != null) { vm.Eval(onfalse); } }
public override HeronValue Eval(VM vm) { using (vm.CreateScope()) { vm.AddVar(new VarDesc(acc), vm.Eval(init)); vm.AddVar(new VarDesc(each), HeronValue.Null); foreach (HeronValue x in vm.EvalListAsDotNet(list)) { vm.SetVar(each, x); vm.SetVar(acc, vm.Eval(expr)); } return(vm.LookupName(acc)); } }
public override HeronValue Apply(VM vm, HeronValue[] args) { // Create a stack frame using (vm.CreateFrame(fun, GetClassInstance(), GetModuleInstance())) { try { // Convert the arguments into appropriate types PerformCoercions(args); // Push the arguments into the current scope PushArgs(vm, args); // Copy free vars if (freeVars != null) { vm.AddVars(freeVars); } // Eval the function body vm.Eval(fun.body); } catch (Exception e) { throw new VMException(fun, fun.FileName, vm.CurrentStatement, e); } } // Gets last result and resets it return(vm.GetAndResetResult()); }
/// <summary> /// Evaluates the map operation /// </summary> /// <param name="vm">Current state of virtual machine</param> /// <returns>An ArrayValue containing new values</returns> public override HeronValue Eval(VM vm) { SeqValue sv = vm.Eval(list) as SeqValue; if (sv == null) { throw new Exception("Expected list: " + list.ToString()); } // internal structure for indexing lists IInternalIndexable ii = sv.GetIndexable(); if (ii.InternalCount() == 0) { return(sv); } // Array of values used for output of map operations HeronValue[] output = new HeronValue[ii.InternalCount()]; // Create a parallel options object to limit parallelism ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = Config.maxThreads; // Create a partitioner var partitioner = Partitioner.Create(0, ii.InternalCount()); Parallel.ForEach( // Breaks the for loop up into sub-ranges partitioner, // Parellel options po, // Initialization of thread-local variables () => { LoopParams lp = new LoopParams(); lp.op = new OptimizationParams(); lp.acc = lp.op.AddNewAccessor(name); lp.vm = vm.Fork(); lp.expr = yield.Optimize(lp.op); return(lp); }, // Loop body (Tuple <int, int> range, ParallelLoopState state, LoopParams lp) => { for (int i = range.Item1; i < range.Item2; ++i) { lp.acc.Set(ii.InternalAt(i)); output[i] = lp.vm.Eval(lp.expr); } return(lp); }, // Finalization function (LoopParams lp) => { } ); return(new ArrayValue(output, sv.GetElementType())); }
public override HeronValue Eval(VM vm) { SeqValue sv = vm.Eval(list) as SeqValue; if (sv == null) throw new Exception("Expected list: " + list.ToString()); // internal structure for indexing lists IInternalIndexable ii = sv.GetIndexable(); if (ii.InternalCount() < 2) return sv; HeronValue[] output = new HeronValue[ii.InternalCount()]; ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = Config.maxThreads; var p = Partitioner.Create(1, ii.InternalCount()); HeronValue result = ii.InternalAt(0); object resultLock = new Object(); Parallel.ForEach( p, po, () => { LoopParams lp = new LoopParams(); lp.op = new OptimizationParams(); lp.acc = lp.op.AddNewAccessor(a); lp.acc2 = lp.op.AddNewAccessor(b); lp.vm = vm.Fork(); lp.expr = yield.Optimize(lp.op); return lp; }, (Tuple<int, int> range, ParallelLoopState state, LoopParams lp) => { if (range.Item1 == range.Item2) return lp; lp.acc.Set(ii.InternalAt(range.Item1)); for (int i = range.Item1 + 1; i < range.Item2; ++i) { lp.acc2.Set(ii.InternalAt(i)); lp.acc.Set(lp.vm.Eval(lp.expr)); } // Update the result lock (resultLock) { lp.acc2.Set(result); result = lp.vm.Eval(lp.expr); } return lp; }, (LoopParams lp) => { } ); return new ArrayValue(new HeronValue[] { result }, sv.GetElementType()); }
public override void Eval(VM vm) { HeronValue o = condition.Eval(vm); foreach (CaseStatement c in cases) { HeronValue cond = vm.Eval(c.condition); if (o.Equals(cond)) { vm.Eval(c.statement); return; } } if (ondefault != null) { vm.Eval(ondefault); } }
public override HeronValue Eval(VM vm) { ListValue list = new ListValue(PrimitiveTypes.AnyType); foreach (Expression expr in exprs) { list.Add(vm.Eval(expr)); } return(list); }
public override HeronValue Eval(VM vm) { RecordLayout layout = ComputeRecordLayout(); List <HeronValue> vals = new List <HeronValue>(); for (int i = 0; i < fields.Count; ++i) { vals.Add(vm.Eval(fields[i])); } return(new RecordValue(layout, vals)); }
public override void Eval(VM vm) { if (value != null) { HeronValue v = vm.Eval(value); vm.AddVar(vardesc, v); } else { vm.AddVar(vardesc); } }
public override void Eval(VM vm) { if (expression != null) { HeronValue result = vm.Eval(expression); vm.Return(result); } else { vm.Return(HeronValue.Void); } }
/// <summary> /// Evaluates the map operation /// </summary> /// <param name="vm">Current state of virtual machine</param> /// <returns>An ArrayValue containing new values</returns> public override HeronValue Eval(VM vm) { SeqValue sv = vm.Eval(list) as SeqValue; if (sv == null) throw new Exception("Expected list: " + list.ToString()); // internal structure for indexing lists IInternalIndexable ii = sv.GetIndexable(); if (ii.InternalCount() == 0) return sv; // Array of values used for output of map operations HeronValue[] output = new HeronValue[ii.InternalCount()]; // Create a parallel options object to limit parallelism ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = Config.maxThreads; // Create a partitioner var partitioner = Partitioner.Create(0, ii.InternalCount()); Parallel.ForEach( // Breaks the for loop up into sub-ranges partitioner, // Parellel options po, // Initialization of thread-local variables () => { LoopParams lp = new LoopParams(); lp.op = new OptimizationParams(); lp.acc = lp.op.AddNewAccessor(name); lp.vm = vm.Fork(); lp.expr = yield.Optimize(lp.op); return lp; }, // Loop body (Tuple<int, int> range, ParallelLoopState state, LoopParams lp) => { for (int i = range.Item1; i < range.Item2; ++i) { lp.acc.Set(ii.InternalAt(i)); output[i] = lp.vm.Eval(lp.expr); } return lp; }, // Finalization function (LoopParams lp) => { } ); return new ArrayValue(output, sv.GetElementType()); }
public override void Eval(VM vm) { using (vm.CreateScope()) { foreach (Statement s in statements) { vm.Eval(s); if (vm.ShouldExitScope()) { return; } } } }
public override HeronValue Eval(VM vm) { SeqValue sv = vm.Eval(list) as SeqValue; if (sv == null) throw new Exception("Expected list: " + list.ToString()); // internal structure for indexing lists IInternalIndexable ii = sv.GetIndexable(); if (ii.InternalCount() == 0) return sv; bool[] bools = new bool[ii.InternalCount()]; ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = Config.maxThreads; var p = Partitioner.Create(0, ii.InternalCount()); Parallel.ForEach( p, po, () => { LoopParams lp = new LoopParams(); lp.op = new OptimizationParams(); lp.acc = lp.op.AddNewAccessor(name); lp.vm = vm.Fork(); lp.expr = predicate.Optimize(lp.op); return lp; }, (Tuple<int, int> range, ParallelLoopState state, LoopParams lp) => { for (int i = range.Item1; i < range.Item2; ++i) { lp.acc.Set(ii.InternalAt(i)); bools[i] = lp.vm.Eval(lp.expr).ToBool(); } return lp; }, (LoopParams lp) => { } ); List<HeronValue> r = new List<HeronValue>(ii.InternalCount()); for (int i = 0; i < ii.InternalCount(); ++i) if (bools[i]) r.Add(ii.InternalAt(i)); r.Capacity = r.Count; return new ListValue(r, sv.GetElementType()); }
public override void Eval(VM vm) { VarDesc desc = new VarDesc(name); foreach (HeronValue x in vm.EvalListAsDotNet(collection)) { using (vm.CreateScope()) { vm.AddVar(desc, x); vm.Eval(body); if (vm.ShouldExitScope()) { return; } } } }
public override HeronValue Eval(VM vm) { RecordLayout layout = ComputeRecordLayout(); TableValue r = new TableValue(layout); foreach (ExpressionList row in rows) { List <HeronValue> vals = new List <HeronValue>(); for (int i = 0; i < row.Count; ++i) { vals.Add(vm.Eval(row[i])); } RecordValue rv = new RecordValue(layout, vals); r.Add(rv); } return(r); }
public override void Eval(VM vm) { while (true) { HeronValue o = condition.Eval(vm); bool b = o.ToBool(); if (!b) { break; } vm.Eval(body); if (vm.ShouldExitScope()) { break; } } }
public override void Eval(VM vm) { HeronValue initVal = initial.Eval(vm); VarDesc desc = new VarDesc(name); using (vm.CreateScope()) { vm.AddVar(desc, initVal); while (true) { HeronValue condVal = vm.Eval(condition); bool b = condVal.ToBool(); if (!b) return; vm.Eval(body); if (vm.ShouldExitScope()) return; vm.Eval(next); } } }
public override void Eval(VM vm) { bool b = condition.Eval(vm).ToBool(); if (b) vm.Eval(ontrue); else if (onfalse != null) vm.Eval(onfalse); }
public override HeronValue Apply(VM vm, HeronValue[] args) { // Create a stack frame using (vm.CreateFrame(fun, GetClassInstance(), GetModuleInstance())) { try { // Convert the arguments into appropriate types PerformCoercions(args); // Push the arguments into the current scope PushArgs(vm, args); // Copy free vars if (freeVars != null) vm.AddVars(freeVars); // Eval the function body vm.Eval(fun.body); } catch (Exception e) { throw new VMException(fun, fun.FileName, vm.CurrentStatement, e); } } // Gets last result and resets it return vm.GetAndResetResult(); }
public override HeronValue Eval(VM vm) { SeqValue sv = vm.Eval(list) as SeqValue; if (sv == null) { throw new Exception("Expected list: " + list.ToString()); } // internal structure for indexing lists IInternalIndexable ii = sv.GetIndexable(); if (ii.InternalCount() < 2) { return(sv); } HeronValue[] output = new HeronValue[ii.InternalCount()]; ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = Config.maxThreads; var p = Partitioner.Create(1, ii.InternalCount()); HeronValue result = ii.InternalAt(0); object resultLock = new Object(); Parallel.ForEach( p, po, () => { LoopParams lp = new LoopParams(); lp.op = new OptimizationParams(); lp.acc = lp.op.AddNewAccessor(a); lp.acc2 = lp.op.AddNewAccessor(b); lp.vm = vm.Fork(); lp.expr = yield.Optimize(lp.op); return(lp); }, (Tuple <int, int> range, ParallelLoopState state, LoopParams lp) => { if (range.Item1 == range.Item2) { return(lp); } lp.acc.Set(ii.InternalAt(range.Item1)); for (int i = range.Item1 + 1; i < range.Item2; ++i) { lp.acc2.Set(ii.InternalAt(i)); lp.acc.Set(lp.vm.Eval(lp.expr)); } // Update the result lock (resultLock) { lp.acc2.Set(result); result = lp.vm.Eval(lp.expr); } return(lp); }, (LoopParams lp) => { } ); return(new ArrayValue(new HeronValue[] { result }, sv.GetElementType())); }
public override void Eval(VM vm) { while (true) { HeronValue o = condition.Eval(vm); bool b = o.ToBool(); if (!b) break; vm.Eval(body); if (vm.ShouldExitScope()) break; } }
public override void Eval(VM vm) { vm.Eval(statement); }
public override void Eval(VM vm) { vm.Eval(expression); }
public override void Eval(VM vm) { VarDesc desc = new VarDesc(name); foreach (HeronValue x in vm.EvalListAsDotNet(collection)) { using (vm.CreateScope()) { vm.AddVar(desc, x); vm.Eval(body); if (vm.ShouldExitScope()) return; } } }
public override void Eval(VM vm) { using (vm.CreateScope()) { foreach (Statement s in statements) { vm.Eval(s); if (vm.ShouldExitScope()) return; } } }
public override HeronValue Eval(VM vm) { SeqValue sv = vm.Eval(list) as SeqValue; if (sv == null) { throw new Exception("Expected list: " + list.ToString()); } // internal structure for indexing lists IInternalIndexable ii = sv.GetIndexable(); if (ii.InternalCount() == 0) { return(sv); } bool[] bools = new bool[ii.InternalCount()]; ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = Config.maxThreads; var p = Partitioner.Create(0, ii.InternalCount()); Parallel.ForEach( p, po, () => { LoopParams lp = new LoopParams(); lp.op = new OptimizationParams(); lp.acc = lp.op.AddNewAccessor(name); lp.vm = vm.Fork(); lp.expr = predicate.Optimize(lp.op); return(lp); }, (Tuple <int, int> range, ParallelLoopState state, LoopParams lp) => { for (int i = range.Item1; i < range.Item2; ++i) { lp.acc.Set(ii.InternalAt(i)); bools[i] = lp.vm.Eval(lp.expr).ToBool(); } return(lp); }, (LoopParams lp) => { } ); List <HeronValue> r = new List <HeronValue>(ii.InternalCount()); for (int i = 0; i < ii.InternalCount(); ++i) { if (bools[i]) { r.Add(ii.InternalAt(i)); } } r.Capacity = r.Count; return(new ListValue(r, sv.GetElementType())); }