public bool TryAddTree(Model model, Trees trees, int treeIndex, MortalityCause reason)
{
if (this.treeFilter.IsEmpty == false)
{
// skip trees if filter is present
TreeWrapper treeWrapper = new(model)
{
Trees = trees,
TreeIndex = treeIndex
};
this.treeFilter.Wrapper = treeWrapper;
if (this.treeFilter.Execute() == 0.0)
{
return(false);
}
}
if (this.removedTreesByResourceUnit.TryGetValue(trees.RU, out MutableTuple <Trees, List <MortalityCause> >?removedTreesOfSpecies) == false)
{
removedTreesOfSpecies = new MutableTuple <Trees, List <MortalityCause> >(new Trees(model.Landscape, trees.RU, trees.Species),
new List <MortalityCause>());
this.removedTreesByResourceUnit.Add(trees.RU, removedTreesOfSpecies);
}
removedTreesOfSpecies.Item1.Add(trees, treeIndex);
removedTreesOfSpecies.Item2.Add(reason);
return(true);
}
/// <summary>
/// Converts a term AST to a term, and expands symbolic constants as much as possible.
/// Returns null if there are errors.
/// Should only be called after the set has been successfully compiled.
/// </summary>
private Term Expand(AST <Node> ast, List <Flag> flags)
{
bool gotLock = false;
try
{
termIndexLock.Enter(ref gotLock);
UserSymbol other;
var symTable = index.SymbolTable;
var valParamToValue = new Map <UserCnstSymb, Term>(Symbol.Compare);
foreach (var kv in valueInputs)
{
valParamToValue.Add(
(UserCnstSymb)symTable.Resolve(string.Format("%{0}", kv.Key), out other, symTable.ModuleSpace),
kv.Value);
}
var nextDcVarId = new MutableTuple <int>(0);
var success = new SuccessToken();
var symbStack = new Stack <Tuple <Namespace, Symbol> >();
symbStack.Push(new Tuple <Namespace, Symbol>(index.SymbolTable.Root, null));
var result = ast.Compute <Tuple <Term, Term> >(
x => Expand_Unfold(x, symbStack, nextDcVarId, success, flags),
(x, y) => Expand_Fold(x, y, symbStack, valParamToValue, success, flags));
return(result == null ? null : result.Item1);
}
finally
{
if (gotLock)
{
termIndexLock.Exit();
}
}
}
/// <summary>
/// Python ctor - maps to function.__new__
///
/// y = func(x.__code__, globals(), 'foo', None, (a, ))
/// </summary>
public PythonFunction(CodeContext context, FunctionCode code, PythonDictionary globals, string name, PythonTuple defaults, PythonTuple closure)
{
if (closure != null && closure.__len__() != 0)
{
throw new NotImplementedException("non empty closure argument is not supported");
}
if (globals == context.GlobalDict)
{
_module = context.Module.GetName();
_context = context;
}
else
{
_module = null;
_context = new CodeContext(new PythonDictionary(), new ModuleContext(globals, DefaultContext.DefaultPythonContext));
}
_defaults = defaults == null ? ArrayUtils.EmptyObjects : defaults.ToArray();
_code = code;
_name = name;
_doc = code._initialDoc;
Closure = null;
var scopeStatement = _code.PythonCode;
if (scopeStatement.IsClosure)
{
throw new NotImplementedException("code containing closures is not supported");
}
scopeStatement.RewriteBody(FunctionDefinition.ArbitraryGlobalsVisitorInstance);
_compat = CalculatedCachedCompat();
}
public void TestNestedTupleSize()
{
int size = 8;
Type[] args = new Type[size];
for (int i = 0; i < size; i++)
{
if (i == 5)
{
var nestedTupleType = MutableTuple.MakeTupleType(typeof(int), typeof(int));
args[i] = nestedTupleType;
}
else
{
args[i] = typeof(int);
}
}
var tupleType = MutableTuple.MakeTupleType(args);
// these both fail - https://github.com/IronLanguages/dlr/issues/231
//Assert.AreEqual(MutableTuple.GetSize(tupleType), size);
//Assert.Throws<ArgumentException>(() => MutableTuple.GetAccessPath(tupleType, size).ToArray());
Assert.AreEqual(MutableTuple.GetSize(tupleType), size + 1);
Assert.Throws <InvalidOperationException>(() => MutableTuple.GetAccessPath(tupleType, size).ToArray());
}
internal static void CopyTupleFields(MutableTuple /*!*/ src, MutableTuple /*!*/ dst)
{
Debug.Assert(src.Capacity == dst.Capacity);
for (int i = 0; i < src.Capacity; i++)
{
dst.SetValue(i, src.GetValue(i));
}
}
public void MutableTuple_ChangeValue_ExpectedChange()
{
MutableTuple <string, string> test = new MutableTuple <string, string>("V1", "V2");
test.First = "Test";
Assert.That(test.First, Is.EqualTo("Test"));
Assert.That(test.Second, Is.EqualTo("V2"));
}
/// <summary>
/// Takes a single tile on the map and calculates all paths to every other tile, starting from that initial tile.
/// returns those pathways as a Dictionary
/// it's keys are ints representing the distance required to travel
/// its values are dictionaries with keys representing the destination and values representing the Queue path to follow
/// </summary>
/// <param name="start"> (x, y) coordinate to start from</param>
public Dictionary <int, Dictionary <Vector2Int, Queue <Vector2Int> > > ScanFromStart(Vector2Int start)
{
// create two data structures: tiles that need to be visited and tiles already visited
// visited is just a set of Vector2Int
// toVisit is a queue, storing the tile to visit, the path taken to get there, and the total movement spent to reach the tile
HashSet <Vector2Int> visited = new HashSet <Vector2Int>();
Queue <MutableTuple <Vector2Int, MutableTuple <Queue <Vector2Int>, int> > > toVisit = new Queue <MutableTuple <Vector2Int, MutableTuple <Queue <Vector2Int>, int> > >();
Dictionary <int, Dictionary <Vector2Int, Queue <Vector2Int> > > result = new Dictionary <int, Dictionary <Vector2Int, Queue <Vector2Int> > >();
toVisit.Enqueue(new MutableTuple <Vector2Int, MutableTuple <Queue <Vector2Int>, int> >(start, new MutableTuple <Queue <Vector2Int>, int>(new Queue <Vector2Int>(), 0)));
while (toVisit.Count != 0)
{
// get the next tile in line to visit
MutableTuple <Vector2Int, MutableTuple <Queue <Vector2Int>, int> > current = toVisit.Dequeue();
// make sure that this tile is valid to be visited. an Invalid tile:
// has already been visited does not exist within weightedMap or has a weight of OBSTRUCTED AND is not the starting tile
if (visited.Contains(current.Item1) || (!weightedMap.ContainsKey(current.Item1)) || (weightedMap[current.Item1] == (int)TileWeight.OBSTRUCTED && current.Item1 != start))
{
continue;
}
// this is the first time that we've reached a tile this much movement away. set it up.
if (!result.ContainsKey(current.Item2.Item2))
{
result.Add(current.Item2.Item2, new Dictionary <Vector2Int, Queue <Vector2Int> >());
}
// This is the first time that we've reached this tile with this amount of movement. it is the shortest path. store it
if (!result[current.Item2.Item2].ContainsKey(current.Item1))
{
result[current.Item2.Item2].Add(current.Item1, current.Item2.Item1);
}
// check each neighbor of this tile
Dictionary <Vector2Int, Direction> neighbors = MapMath.GetNeighbors(current.Item1);
foreach (Vector2Int neighbor in neighbors.Keys)
{
int movement = current.Item2.Item2;
if (weightedMap.ContainsKey(neighbor))
{
movement += weightedMap[neighbor];
}
Queue <Vector2Int> newPath = new Queue <Vector2Int>(current.Item2.Item1.ToArray());
newPath.Enqueue(neighbor);
// Debug.Log("Need to visit Tile " + neighbor);
toVisit.Enqueue(new MutableTuple <Vector2Int, MutableTuple <Queue <Vector2Int>, int> >(neighbor, new MutableTuple <Queue <Vector2Int>, int>(newPath, movement)));
}
// this tile has been officially 'visited'
visited.Add(current.Item1);
}
return(result);
}
internal Type GetClosureTupleType() {
if (TupleCells > 0) {
Type[] args = new Type[TupleCells];
for (int i = 0; i < TupleCells; i++) {
args[i] = typeof(ClosureCell);
}
return MutableTuple.MakeTupleType(args);
}
return null;
}
public override Expression Reduce()
{
Expression res = _tupleExpr.Value;
foreach (PropertyInfo pi in MutableTuple.GetAccessPath(_tupleType.Value, Index))
{
res = Expression.Property(res, pi);
}
return(res);
}
private MutableTuple <int, object> GetDataTuple()
{
MutableTuple <int, object> res = _data as MutableTuple <int, object>;
if (res == null)
{
res = GetBigData(_data);
}
return(res);
}
// This function will evaluate the tiles in which this ability can reach, and update the affectableTiles Dictionary to its correct state
public void EvaluateAffectableTiles()
{
ResetAffectableTiles();
ResetAffectableUnits();
// Attacks have affectable areas. Therefore, only those types of UnitAbilities need to be evaluated
// if not an Attack, this function will only add the tile that the unit is occupying
if (!(ability.GetType().IsSubclassOf(typeof(Attack))))
{
// add to affectableTiles, creating a new set at the key if it hasn't been made yet
if (!affectableTiles.ContainsKey(sourceUnit.GetMapPosition()))
{
affectableTiles[sourceUnit.GetMapPosition()] = new HashSet <Tuple <Vector2Int, Direction> >();
}
affectableTiles[sourceUnit.GetMapPosition()].Add(new Tuple <Vector2Int, Direction>(sourceUnit.GetMapPosition(), Direction.S));
affectableUnits[sourceUnit.GetMapPosition()] = new MutableTuple <Unit, float>(sourceUnit, 0.0f);
return;
}
// otherwise, if this ability is a type of Attack, iterate through
else
{
// iterate three times: first for all possible moveable tiles, second for all cardinal directions, third for each tile in the area of effect at that location
List <Direction> directionsToCheck = new List <Direction> {
Direction.N, Direction.S, Direction.E, Direction.W
};
foreach (Vector2Int tile in sourceUnit.MoveableTiles.Keys)
{
foreach (Direction direction in directionsToCheck)
{
List <Vector2Int> areaOfEffect = (ability as Attack).GetAreaOfEffect(tile, direction);
foreach (Vector2Int affectedTile in areaOfEffect)
{
// if this tile Key is new to the Dictionary:
if (!affectableTiles.ContainsKey(affectedTile))
{
// create the HashSet for this Key
affectableTiles[affectedTile] = new HashSet <Tuple <Vector2Int, Direction> >();
// check if there's a Unit here. if there is one and it's new, add it to the affectableUnits
Unit searchResult = sourceUnit.globalPositionalData.SearchLocation(affectedTile);
if (searchResult != null && !affectableUnits.ContainsKey(affectedTile))
{
affectableUnits[affectedTile] = new MutableTuple <Unit, float>(searchResult, 0.0f);
}
}
// add the movement information to the HashSet at this Key. (If it already exists, it will automatically do nothing since its a Set)
affectableTiles[affectedTile].Add(new Tuple <Vector2Int, Direction>(tile, direction));
}
}
}
}
}
public void CanUseTuple()
{
// ARRANGE & ACT
var tuple1 = new MutableTuple <string, int>("key", 7);
var tuple2 = new MutableTuple <string, int>("key", 7);
// ASSERT
Assert.AreEqual("key", tuple1.Item1);
Assert.AreEqual(7, tuple1.Item2);
Assert.AreEqual(tuple1, tuple2);
}
internal Type GetVariableType(Compiler compiler, out IEnumerable <PropertyInfo> tupleAccessPath, out bool localInTuple)
{
localInTuple = (this._tupleIndex >= 0) && (compiler.Optimize || (this._tupleIndex < 9));
tupleAccessPath = null;
if (localInTuple)
{
tupleAccessPath = MutableTuple.GetAccessPath(compiler.LocalVariablesTupleType, this._tupleIndex);
return(tupleAccessPath.Last <PropertyInfo>().PropertyType);
}
return(typeof(object));
}
public static MSA.Expression /*!*/ GetVariableAccessor(MSA.Expression /*!*/ tupleVariable, int tupleFieldIndex)
{
MSA.Expression accessor = tupleVariable;
foreach (var property in MutableTuple.GetAccessPath(tupleVariable.Type, tupleFieldIndex))
{
accessor = Ast.Property(accessor, property);
}
return(accessor);
}
private Type /*!*/ MakeLocalsTupleType()
{
// Note: The actual tuple type might be a subclass of the type used here. Accesses to the additional fields would need to down-cast.
// This will only happen if a hidden lifted variable is defined, which is needed only for flip-flop operator so far.
Type[] types = new Type[LiftedVisibleVariableCount];
for (int i = 0; i < types.Length; i++)
{
types[i] = typeof(object);
}
return(MutableTuple.MakeTupleType(types));
}
private static MutableTuple <int, object> GetBigData(MutableTuple data)
{
MutableTuple <int, object> smallGen;
do
{
data = (MutableTuple)data.GetValue(0);
} while ((smallGen = (data as MutableTuple <int, object>)) == null);
return(smallGen);
}
internal MSAst.MethodCallExpression CreateLocalContext(MSAst.Expression parentContext) {
var closureVariables = _closureVariables;
if (_closureVariables == null) {
closureVariables = new ClosureInfo[0];
}
return Ast.Call(
AstMethods.CreateLocalContext,
parentContext,
MutableTuple.Create(ArrayUtils.ConvertAll(closureVariables, x => GetClosureCell(x))),
Ast.Constant(ArrayUtils.ConvertAll(closureVariables, x => x.AccessedInScope ? x.Variable.Name : null))
);
}
private void DecrementRunningFuncCounter(string methodId = "")
{
Interlocked.Decrement(
ref _methodIdCounters.GetOrAdd(
methodId,
x => MutableTuple.Create(0)
).Item1
);
if (Interlocked.Decrement(ref _runningFuncCounter) <= 0)
{
_zeroFuncTrigger.OnNext(null);
}
}
private Tuple <Type, Dictionary <string, int> > FinishAnalysis(bool scriptCmdlet = false)
{
List <Block> list = Block.GenerateReverseDepthFirstOrder(this._entryBlock);
BitArray assignedBitArray = new BitArray(this._variables.Count);
list[0]._visitData = assignedBitArray;
this.AnalyzeBlock(assignedBitArray, list[0]);
for (int i = 1; i < list.Count; i++)
{
Block block = list[i];
assignedBitArray = new BitArray(this._variables.Count);
assignedBitArray.SetAll(true);
block._visitData = assignedBitArray;
int num2 = 0;
foreach (Block block2 in block._predecessors)
{
if (block2._visitData != null)
{
num2++;
assignedBitArray.And((BitArray)block2._visitData);
}
}
this.AnalyzeBlock(assignedBitArray, block);
}
var v = this._variables.Values.Where(x => x.LocalTupleIndex == -2).SelectMany(x => x.AssociatedAsts);
foreach (Ast ast in v)
{
FixTupleIndex(ast, -2);
}
VariableAnalysisDetails[] detailsArray = (from details in this._variables.Values
where details.LocalTupleIndex >= 0
orderby details.LocalTupleIndex
select details).ToArray <VariableAnalysisDetails>();
Dictionary <string, int> dictionary = new Dictionary <string, int>(0, StringComparer.OrdinalIgnoreCase);
for (int j = 0; j < detailsArray.Length; j++)
{
VariableAnalysisDetails details = detailsArray[j];
string name = details.Name;
dictionary.Add(name, j);
if (details.LocalTupleIndex != j)
{
foreach (Ast ast2 in details.AssociatedAsts)
{
FixTupleIndex(ast2, j);
}
}
}
return(Tuple.Create <Type, Dictionary <string, int> >(MutableTuple.MakeTupleType((from l in detailsArray select l.Type).ToArray <Type>()), dictionary));
}
private Unit MkSubRuleLocators_Fold(
Term t,
Term output,
LinkedList <Tuple <Term, int> > placeStack,
MutableTuple <int> matchCount)
{
placeStack.RemoveLast();
while (matchCount.Item1 > 0 && t == output.Args[matchCount.Item1 - 1])
{
--matchCount.Item1;
}
return(default(Unit));
}
internal PythonGenerator(PythonFunction function, Func <MutableTuple, object> /*!*/ next, MutableTuple data)
{
_function = function;
_next = next;
_data = data;
_dataTuple = GetDataTuple();
State = GeneratorRewriter.NotStarted;
if (_LastFinalizer == null || (_finalizer = Interlocked.Exchange(ref _LastFinalizer, null)) == null)
{
_finalizer = new GeneratorFinalizer(this);
}
else
{
_finalizer.Generator = this;
}
}
internal PythonFunction(CodeContext /*!*/ context, FunctionCode funcInfo, object modName, object[] defaults, MutableTuple closure)
{
Assert.NotNull(context, funcInfo);
_context = context;
_defaults = defaults ?? ArrayUtils.EmptyObjects;
_code = funcInfo;
_doc = funcInfo._initialDoc;
_name = funcInfo.co_name;
Debug.Assert(_defaults.Length <= _code.co_argcount);
if (modName != Uninitialized.Instance)
{
_module = modName;
}
Closure = closure;
_compat = CalculatedCachedCompat();
}
/// <summary>
/// If a subrule returns output Sub(t1,...,tn) from input with inputLocations, then finds all locations
/// of the terms t1, ..., tn.
/// </summary>
private LinkedList <Locator> MkSubRuleLocators(
Node subRuleHead,
Term input,
Term output,
LinkedList <Locator> inputLocations)
{
var outputLocs = new LinkedList <Locator>();
var placeStack = new LinkedList <Tuple <Term, int> >();
placeStack.AddLast(new Tuple <Term, int>(input, -1));
var matchCount = new MutableTuple <int>();
matchCount.Item1 = 0;
input.Compute <Unit>(
(x, s) => MkSubRuleLocators_Unfold(x, output, placeStack, inputLocations, outputLocs, subRuleHead, matchCount),
(x, ch, s) => MkSubRuleLocators_Fold(x, output, placeStack, matchCount));
Contract.Assert(placeStack.Count == 0 && matchCount.Item1 == 0 && outputLocs.Count > 0);
return(outputLocs);
}
private void GetCapacityRelative <AI>(VehicleInfo info, AI ai, ref Dictionary <string, MutableTuple <float, int> > relativeParts, out int totalCapacity, bool noLoop = false) where AI : VehicleAI
{
if (info == null)
{
totalCapacity = 0;
return;
}
totalCapacity = UpdateDefaultCapacity(ai);
if (relativeParts.ContainsKey(info.name))
{
relativeParts[info.name].Second++;
}
else
{
relativeParts[info.name] = MutableTuple.New((float)totalCapacity, 1);
}
if (!noLoop)
{
try
{
foreach (VehicleInfo.VehicleTrailer trailer in info.m_trailers)
{
if (trailer.m_info != null)
{
GetCapacityRelative(trailer.m_info, trailer.m_info.m_vehicleAI, ref relativeParts, out int capacity, true);
totalCapacity += capacity;
}
}
for (int i = 0; i < relativeParts.Keys.Count; i++)
{
relativeParts[relativeParts.Keys.ElementAt(i)].First /= totalCapacity;
}
}
catch (Exception e)
{
LogUtils.DoLog($"ERRO AO OBTER CAPACIDADE REL: [{info}] {e} {e.Message}\n{e.StackTrace}");
}
}
}
public override bool Equals(object obj)
{
MutableTuple <T1, T2> p = obj as MutableTuple <T1, T2>;
if (obj == null)
{
return(false);
}
if (Item1 == null)
{
if (p.Item1 != null)
{
return(false);
}
}
else
{
if (p.Item1 == null || !Item1.Equals(p.Item1))
{
return(false);
}
}
if (Item2 == null)
{
if (p.Item2 != null)
{
return(false);
}
}
else
{
if (p.Item2 == null || !Item2.Equals(p.Item2))
{
return(false);
}
}
return(true);
}
public override void SaveChanges()
{
AssignIds();
SaveReferencesIds();
var tuple
= new MutableTuple <Customer[], Order[], Car[]>
{
Item1 = GetCustomers().OrderBy(c => c.CustomerId).ToArray(),
Item2 = GetOrders().OrderBy(o => o.OrderId).ToArray(),
Item3 = GetCars().OrderBy(c => c.CarId).ToArray()
};
try
{
XmlHelper <MutableTuple <Customer[], Order[], Car[]> > .Save(FilePath, tuple);
}
catch (Exception e)
{
Logger.Log(e);
Logger.SetError(this);
}
}
internal PythonFunction(CodeContext /*!*/ context, FunctionCode funcInfo, object modName, object[] defaults, PythonDictionary kwdefaults, PythonDictionary annotations, MutableTuple closure)
{
Assert.NotNull(context, funcInfo);
_context = context;
_defaults = defaults ?? ArrayUtils.EmptyObjects;
__kwdefaults__ = kwdefaults;
_code = funcInfo;
_doc = funcInfo._initialDoc;
_name = funcInfo.co_name;
_annotations = annotations ?? new PythonDictionary();
Debug.Assert(_defaults.Length <= _code.co_argcount);
Debug.Assert((__kwdefaults__?.Count ?? 0) <= _code.co_kwonlyargcount);
if (modName != Uninitialized.Instance)
{
_module = modName;
}
Closure = closure;
FunctionCompatibility = CalculatedCachedCompat();
}
private void IncrementRunningFuncCounter(string methodId = "")
{
Interlocked.Increment(ref _runningFuncCounter);
Interlocked.Increment(
ref _methodIdCounters.GetOrAdd(
methodId,
x => MutableTuple.Create(0)
).Item1
);
if (_state != EDisposableObjectState.Initialized)
{
Interlocked.Decrement(ref _runningFuncCounter);
Interlocked.Decrement(
ref _methodIdCounters.GetOrAdd(
methodId,
x => MutableTuple.Create(0)
).Item1
);
throw new WrongDisposableObjectStateException()
{
ActualState = _state
};
}
}
private IEnumerable <Term> MkSubRuleLocators_Unfold(
Term t,
Term output,
LinkedList <Tuple <Term, int> > placeStack,
LinkedList <Locator> inputLocations,
LinkedList <Locator> outputLocations,
Node subRuleHead,
MutableTuple <int> matchCount)
{
//// t may extend the match (possibly one or more times)
if (t == output.Args[matchCount.Item1])
{
while (matchCount.Item1 < output.Symbol.Arity && t == output.Args[matchCount.Item1])
{
++matchCount.Item1;
}
}
//// The match is complete.
if (matchCount.Item1 >= output.Symbol.Arity)
{
int i = 0;
var argLocs = new LinkedList <Locator> [output.Symbol.Arity];
var prev = inputLocations;
LinkedList <Locator> next;
foreach (var place in placeStack)
{
if (place.Item2 < 0)
{
next = prev;
}
else
{
next = new LinkedList <Locator>();
foreach (var l in prev)
{
next.AddLast(l[place.Item2]);
}
}
while (i < output.Symbol.Arity && output.Args[i] == place.Item1)
{
argLocs[i] = next;
++i;
}
if (i >= output.Symbol.Arity)
{
break;
}
prev = next;
}
foreach (var alocs in Locator.MkPermutations(argLocs, maxLocationsPerProof))
{
outputLocations.AddLast(new CompositeLocator(subRuleHead.Span, alocs));
}
yield break;
}
for (int i = 0; i < t.Symbol.Arity; ++i)
{
placeStack.AddLast(new Tuple <Term, int>(t.Args[i], i));
yield return(t.Args[i]);
}
}
internal Expression Reduce(bool shouldInterpret, bool emitDebugSymbols, int compilationThreshold,
IList <ParameterExpression> parameters, Func <Expression <Func <MutableTuple, object> >,
Expression <Func <MutableTuple, object> > > bodyConverter)
{
_state = LiftVariable(Expression.Parameter(typeof(int), "state"));
_current = LiftVariable(Expression.Parameter(typeof(object), "current"));
// lift the parameters into the tuple
foreach (ParameterExpression pe in parameters)
{
LiftVariable(pe);
}
DelayedTupleExpression liftedGen = LiftVariable(_generatorParam);
// Visit body
Expression body = Visit(_body);
Debug.Assert(_returnLabels.Count == 1);
// Add the switch statement to the body
int count = _yields.Count;
var cases = new SwitchCase[count + 1];
for (int i = 0; i < count; i++)
{
cases[i] = Expression.SwitchCase(Expression.Goto(_yields[i].Label), AstUtils.Constant(_yields[i].State));
}
cases[count] = Expression.SwitchCase(Expression.Goto(_returnLabels.Peek()), AstUtils.Constant(Finished));
// Create the lambda for the PythonGeneratorNext, hoisting variables
// into a tuple outside the lambda
Expression[] tupleExprs = new Expression[_vars.Count];
foreach (var variable in _orderedVars)
{
// first 2 are our state & out var
if (variable.Value.Index >= 2 && variable.Value.Index < (parameters.Count + 2))
{
tupleExprs[variable.Value.Index] = parameters[variable.Value.Index - 2];
}
else
{
tupleExprs[variable.Value.Index] = Expression.Default(variable.Key.Type);
}
}
Expression newTuple = MutableTuple.Create(tupleExprs);
Type tupleType = _tupleType.Value = newTuple.Type;
ParameterExpression tupleExpr = _tupleExpr.Value = Expression.Parameter(tupleType, "tuple");
ParameterExpression tupleArg = Expression.Parameter(typeof(MutableTuple), "tupleArg");
_temps.Add(_gotoRouter);
_temps.Add(tupleExpr);
// temps for the outer lambda
ParameterExpression tupleTmp = Expression.Parameter(tupleType, "tuple");
ParameterExpression ret = Expression.Parameter(typeof(PythonGenerator), "ret");
var innerLambda = Expression.Lambda <Func <MutableTuple, object> >(
Expression.Block(
_temps.ToArray(),
Expression.Assign(
tupleExpr,
Expression.Convert(
tupleArg,
tupleType
)
),
Expression.Switch(Expression.Assign(_gotoRouter, _state), cases),
body,
MakeAssign(_state, AstUtils.Constant(Finished)),
Expression.Label(_returnLabels.Peek()),
_current
),
_name,
new ParameterExpression[] { tupleArg }
);
// Generate a call to PythonOps.MakeGeneratorClosure(Tuple data, object generatorCode)
return(Expression.Block(
new[] { tupleTmp, ret },
Expression.Assign(
ret,
Expression.Call(
typeof(PythonOps).GetMethod("MakeGenerator"),
parameters[0],
Expression.Assign(tupleTmp, newTuple),
emitDebugSymbols ?
(Expression)bodyConverter(innerLambda) :
(Expression)Expression.Constant(
new LazyCode <Func <MutableTuple, object> >(
bodyConverter(innerLambda),
shouldInterpret,
compilationThreshold
),
typeof(object)
)
)
),
new DelayedTupleAssign(
new DelayedTupleExpression(liftedGen.Index, new StrongBox <ParameterExpression>(tupleTmp), _tupleType, typeof(PythonGenerator)),
ret
),
ret
));
}
