public static string Next(object on, string root, params IEnumerable <string>[] inUse)
{
var key = SigilTuple.Create(on, root);
lock (State)
{
int next;
if (!State.TryGetValue(key, out next))
{
next = 0;
State[key] = next;
}
State[key]++;
var ret = root + next;
if (LinqAlternative.Any(inUse, a => LinqAlternative.Any(a, x => x == ret)))
{
return(Next(on, root, inUse));
}
return(ret);
}
}
private LinqList <StackTransition> GetLegalTransitions(LinqList <StackTransition> ops, LinqStack <LinqList <TypeOnStack> > runningStack)
{
var ret = new LinqList <StackTransition>(ops.Count);
for (var i = 0; i < ops.Count; i++)
{
var w = ops[i];
if (LinqAlternative.All(w.PoppedFromStack, u => u == TypeOnStack.Get <PopAllType>()))
{
ret.Add(w);
continue;
}
var onStack = runningStack.Peek(IsBaseless, w.PoppedCount);
if (onStack == null)
{
continue;
}
if (LinqAlternative.Any(w.PushedToStack, p => p == TypeOnStack.Get <SamePointerType>()))
{
if (w.PushedToStack.Length > 1)
{
throw new Exception("SamePointerType can be only product of a transition which contains it");
}
var shouldBePointer = LinqAlternative.SelectMany(onStack, p => p.Where(x => x.IsPointer || x == TypeOnStack.Get <WildcardType>()).AsEnumerable()).Distinct().ToList();
if (shouldBePointer.Count == 0)
{
continue;
}
w = new StackTransition(w.PoppedFromStack, new [] { shouldBePointer.Single() });
}
if (LinqAlternative.Any(w.PushedToStack, p => p == TypeOnStack.Get <SameByRefType>()))
{
if (w.PushedToStack.Length > 1)
{
throw new Exception("SameByRefType can be only product of a transition which contains it");
}
var shouldBeByRef = LinqAlternative.SelectMany(onStack, p => p.Where(x => x.IsReference || x == TypeOnStack.Get <WildcardType>()).AsEnumerable()).Distinct().ToList();
if (shouldBeByRef.Count == 0)
{
continue;
}
w = new StackTransition(w.PoppedFromStack, new[] { shouldBeByRef.Single() });
}
bool outerContinue = false;
for (var j = 0; j < w.PoppedCount; j++)
{
var shouldBe = w.PoppedFromStack[j];
var actuallyIs = onStack[j];
if (!actuallyIs.Any(a => shouldBe.IsAssignableFrom(a)))
{
outerContinue = true;
break;
}
}
if (outerContinue)
{
continue;
}
ret.Add(w);
}
return(ret);
}
public bool Any(SigilFunc <T, bool> p)
{
return(LinqAlternative.Any(InnerEnumerable(), p));
}
private static void UpdateStack(LinqStack <LinqList <TypeOnStack> > stack, InstructionAndTransitions wrapped, bool isBaseless)
{
var legal = wrapped.Transitions;
var instr = wrapped.Instruction;
var legalSize = 0;
legal.Each(
t =>
{
legalSize += t.PushedToStack.Length;
if (t.Before != null)
{
t.Before(stack, isBaseless);
}
}
);
if (legal.Any(l => LinqAlternative.Any(l.PoppedFromStack, u => u == TypeOnStack.Get <PopAllType>())))
{
if (instr.HasValue)
{
for (var i = 0; i < stack.Count; i++)
{
var ix = stack.Count - i - 1;
stack.ElementAt(i).Each(y => y.Mark(wrapped, ix));
}
}
stack.Clear();
}
else
{
var toPop = legal.First().PoppedCount;
for (var j = 0; j < toPop && stack.Count > 0; j++)
{
var popped = stack.Pop();
if (instr.HasValue)
{
var ix = toPop - j - 1;
popped.Each(y => y.Mark(wrapped, ix));
}
}
}
var toPush = new LinqList <TypeOnStack>(legalSize);
var pushed = new LinqHashSet <TypeOnStack>();
for (var i = 0; i < legal.Count; i++)
{
foreach (var p in legal[i].PushedToStack)
{
if (pushed.Contains(p))
{
continue;
}
toPush.Add(p);
pushed.Add(p);
}
}
if (toPush.Count > 0)
{
stack.Push(toPush);
}
}
