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)
{
if (value != null)
{
HeronValue v = vm.Eval(value);
vm.AddVar(vardesc, v);
}
else
{
vm.AddVar(vardesc);
}
}
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)
{
if (expression != null)
{
HeronValue result = vm.Eval(expression);
vm.Return(result);
}
else
{
vm.Return(HeronValue.Void);
}
}
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 void Eval(VM vm)
{
vm.Eval(expression);
}
public override void Eval(VM vm)
{
vm.Eval(statement);
}
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 void Eval(VM vm)
{
vm.Eval(expression);
}
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()));
}
