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);
}
}
public static TypeOnStack GetKnownFunctionPointer(CallingConventions conv, Type instanceType, Type returnType, Type[] parameterTypes)
{
var key = SigilTuple.Create(conv, instanceType, returnType, parameterTypes);
TypeOnStack ret;
lock (KnownFunctionPointerCache)
{
if (!KnownFunctionPointerCache.TryGetValue(key, out ret))
{
ret =
new TypeOnStack
{
HasAttachedMethodInfo = true,
Type = typeof(NativeIntType),
CallingConvention = conv,
InstanceType = instanceType,
ReturnType = returnType,
ParameterTypes = parameterTypes,
UsedBy = new LinqHashSet <SigilTuple <InstructionAndTransitions, int> >()
};
KnownFunctionPointerCache[key] = ret;
}
}
return(ret);
}
private static IEnumerable <T> _QuickSort <T, V>(T[] data, int[] ixs, V[] keys, IComparer <V> c)
{
var nextYield = 0;
var stack = new Stack <SigilTuple <int, int> >();
stack.Push(SigilTuple.Create(0, ixs.Length - 1));
while (stack.Count > 0)
{
var leftRight = stack.Pop();
var left = leftRight.Item1;
var right = leftRight.Item2;
if (right > left)
{
int pivot = left + (right - left) / 2;
int pivotPosition = _Partition(ixs, keys, left, right, pivot, c);
stack.Push(SigilTuple.Create(pivotPosition + 1, right));
stack.Push(SigilTuple.Create(left, pivotPosition - 1));
}
else
{
while (nextYield <= right)
{
yield return(data[ixs[nextYield]]);
nextYield++;
}
}
}
}
private VerificationResult CompareStacks(Label label, SigilTuple <bool, LinqStack <LinqList <TypeOnStack> > > actual, SigilTuple <bool, LinqStack <LinqList <TypeOnStack> > > expected)
{
if (!actual.Item1 && !expected.Item1)
{
if (expected.Item2.Count != actual.Item2.Count)
{
// Both stacks are based, so the wrong size is a serious error as well
return(VerificationResult.FailureUnderflow(label, expected.Item2.Count));
}
}
for (var i = 0; i < expected.Item2.Count; i++)
{
if (i >= actual.Item2.Count && !actual.Item1)
{
// actual is based and expected wanted a value, this is an UNDERFLOW
return(VerificationResult.FailureUnderflow(label, expected.Item2.Count));
}
var expectedTypes = expected.Item2.ElementAt(i);
LinqList <TypeOnStack> actualTypes;
if (i < actual.Item2.Count)
{
actualTypes = actual.Item2.ElementAt(i);
}
else
{
// Underflowed, but our actual stack is baseless; so we assume we're good until proven otherwise
break;
}
bool typesMatch = false;
foreach (var a in actualTypes.AsEnumerable())
{
foreach (var e in expectedTypes.AsEnumerable())
{
typesMatch |= e.IsAssignableFrom(a);
}
}
if (!typesMatch)
{
// Just went through what's on the stack, and we the types are known to not be compatible
return(VerificationResult.FailureTypeMismatch(label, actualTypes, expectedTypes));
}
}
return(null);
}
private SigilTuple <bool, LinqStack <LinqList <TypeOnStack> > > GetCurrentStack()
{
SigilTuple <bool, LinqStack <LinqList <TypeOnStack> > > ret = null;
for (var i = 0; i < CurrentlyInScope.Count; i++)
{
var c = CurrentlyInScope[i];
var stack = CurrentlyInScopeStacks[i];
var stackCopy = CopyStack(stack);
var innerRet = SigilTuple.Create(c.IsBaseless, stackCopy);
if (ret == null || (innerRet.Item1 && !ret.Item1) || innerRet.Item2.Count > ret.Item2.Count)
{
ret = innerRet;
}
}
return(ret);
}
/// <summary>
/// Call to indicate that something on the stack was used
/// as the #{index}'d (starting at 0) parameter to the {code}
/// opcode.
/// </summary>
public void Mark(InstructionAndTransitions instr, int index)
{
UsedBy.Add(SigilTuple.Create(instr, index));
}
