public static TypeOnStack Get(Type t)
{
lock (Cache)
{
TypeOnStack ret;
if (!Cache.TryGetValue(t, out ret))
{
ret =
new TypeOnStack
{
Type = t
};
Cache[t] = ret;
}
return(ret);
}
}
public bool IsAssignableFrom(TypeOnStack other)
{
return(ExtensionMethods.IsAssignableFrom(this, other));
}
public static bool IsAssignableFrom(Type type1, TypeOnStack type2)
{
return(TypeOnStack.Get(type1).IsAssignableFrom(type2));
}
public static bool IsAssignableFrom(TypeOnStack type1, TypeOnStack type2)
{
// voids aren't assignable
if (type1.IsVoid || type2.IsVoid)
{
return(false);
}
// wildcards match *everything*
if (type1 == TypeOnStack.Get <WildcardType>() || type2 == TypeOnStack.Get <WildcardType>())
{
return(true);
}
if (type1.IsArray && type2.IsArray)
{
if (type1.Type.GetArrayRank() == type2.Type.GetArrayRank())
{
var t1Elem = type1.Type.GetElementType();
var t2Elem = type2.Type.GetElementType();
while (t1Elem.HasElementType)
{
t1Elem = t1Elem.GetElementType();
}
while (t2Elem.HasElementType)
{
t2Elem = t2Elem.GetElementType();
}
if (t1Elem == typeof(WildcardType) || t2Elem == typeof(WildcardType))
{
return(true);
}
}
}
if (type1.IsPointer && type2.IsPointer)
{
if (type1.Type.GetElementType() == typeof(WildcardType) || type2.Type.GetElementType() == typeof(WildcardType))
{
return(true);
}
}
if (type1.IsReference && type2.IsReference)
{
if (type1.Type.GetElementType() == typeof(WildcardType) || type2.Type.GetElementType() == typeof(WildcardType))
{
return(true);
}
}
// any pointer type matches, well, any pointer
if (type1.Type == typeof(AnyPointerType) && type2.IsPointer)
{
return(true);
}
if (type2.Type == typeof(AnyPointerType) && type1.IsPointer)
{
return(true);
}
// likewise for any by ref
if (type1.Type == typeof(AnyByRefType) && type2.IsReference)
{
return(true);
}
if (type2.Type == typeof(AnyByRefType) && type1.IsReference)
{
return(true);
}
// Native int can be convereted to any pointer type
if (type1.IsPointer && type2 == TypeOnStack.Get <NativeIntType>())
{
return(true);
}
if (type2.IsPointer && type1 == TypeOnStack.Get <NativeIntType>())
{
return(true);
}
// it's possible to assign a struct* to an interface or object
if (!(type2.IsPointerToValueType && (type1.IsInterface || type1.Type.Equals(typeof(object)))))
{
if ((type1.IsPointer || type1.IsReference) && !(type2.IsPointer || type2.IsReference))
{
return(false);
}
if ((type2.IsPointer || type2.IsReference) && !(type1.IsPointer || type1.IsReference))
{
return(false);
}
}
if (type1.IsPointer || type1.IsReference)
{
return(type1.Type.GetElementType() == type2.Type.GetElementType());
}
var t1 = type1.Type;
var t2 = type2.Type;
// The null type can be assigned to any reference type
if (t1 == typeof(NullType) && !TypeHelpers.IsValueType(t2))
{
return(true);
}
if (t2 == typeof(NullType) && !TypeHelpers.IsValueType(t1))
{
return(true);
}
t1 = Alias(t1);
t2 = Alias(t2);
return(ReallyIsAssignableFrom(t1, t2));
}
public static StackTransition[] Pop(Type popType)
{
return(Pop(TypeOnStack.Get(popType)));
}
private static bool ReallyIsAssignableFrom(Type t1, Type t2)
{
if (t1 == t2)
{
return(true);
}
if (t1 == typeof(OnlyObjectType))
{
if (t2 == typeof(object))
{
return(true);
}
return(false);
}
// quick and dirty base case
if (t1 == typeof(object) && !TypeHelpers.IsValueType(t2))
{
return(true);
}
// you have to box in this case
if ((t1 == typeof(object) || TypeHelpers.IsInterface(t1)) && TypeHelpers.IsValueType(t2))
{
return(false);
}
var t1Bases = GetBases(t1);
var t2Bases = GetBases(t2);
if (t2Bases.Any(t2b => TypeOnStack.Get(t1).IsAssignableFrom(TypeOnStack.Get(t2b))))
{
return(true);
}
if (TypeHelpers.IsInterface(t1))
{
var t2Interfaces = t2.IsPointer ? (LinqArray <Type>)t2.GetElementType().GetInterfaces() : (LinqArray <Type>)t2.GetInterfaces();
return(t2Interfaces.Any(t2i => TypeOnStack.Get(t1).IsAssignableFrom(TypeOnStack.Get(t2i))));
}
if (TypeHelpers.IsGenericType(t1) && TypeHelpers.IsGenericType(t2))
{
var t1Def = t1.GetGenericTypeDefinition();
var t2Def = t2.GetGenericTypeDefinition();
if (t1Def != t2Def)
{
return(false);
}
var t1Args = t1.GetGenericArguments();
var t2Args = t2.GetGenericArguments();
for (var i = 0; i < t1Args.Length; i++)
{
if (!TypeOnStack.Get(t1Args[i]).IsAssignableFrom(TypeOnStack.Get(t2Args[i])))
{
return(false);
}
}
return(true);
}
try
{
return(t1.IsAssignableFrom(t2));
}
catch (NotSupportedException)
{
// Builders, some generic types, and so on don't implement this; just assume it's *no good* for now
return(false);
}
}
public static StackTransition[] Push(Type pushType)
{
return(Push(TypeOnStack.Get(pushType)));
}
public static StackTransition[] Push(TypeOnStack pushType)
{
return(new[] { new StackTransition(new TypeOnStack[0], new[] { pushType }) });
}
public StackTransition(bool isDuplicate)
: this(new TypeOnStack[0], new[] { TypeOnStack.Get <WildcardType>() }, null)
{
IsDuplicate = isDuplicate;
}
public static StackTransition[] Pop(TypeOnStack popType)
{
return(new[] { new StackTransition(new[] { popType }, new TypeOnStack[0]) });
}
public VerificationResult CollapseAndVerify()
{
var runningStack = CachedVerifyStack ?? new LinqStack <LinqList <TypeOnStack> >(StartingStack.Reverse());
int i = CachedVerifyIndex ?? 0;
for (; i < Transitions.Count; i++)
{
var wrapped = Transitions[i];
var ops = wrapped.Transitions;
if (ops.Any(o => o.StackSizeMustBe.HasValue))
{
if (ops.Count > 1)
{
throw new Exception("Shouldn't have multiple 'must be size' transitions at the same point");
}
var doIt = ops[0];
if (doIt.StackSizeMustBe != runningStack.Count)
{
return(VerificationResult.FailureStackSize(this, i, doIt.StackSizeMustBe.Value));
}
}
var legal = GetLegalTransitions(ops, runningStack);
if (legal.Count == 0)
{
var wouldPop = ops.GroupBy(g => g.PoppedFromStack.Length).Single().Key;
if (runningStack.Count < wouldPop)
{
return(VerificationResult.FailureUnderflow(this, i, wouldPop, runningStack));
}
IEnumerable <TypeOnStack> expected;
var stackI = FindStackFailureIndex(runningStack, ops.AsEnumerable(), out expected);
return(VerificationResult.FailureTypeMismatch(this, i, stackI, expected, runningStack));
}
if (legal.GroupBy(g => new { a = g.PoppedCount, b = g.PushedToStack.Length }).Count() > 1)
{
throw new Exception("Shouldn't be possible; legal transitions should have same push/pop #s");
}
// No reason to do all this work again
Transitions[i] = new InstructionAndTransitions(wrapped.Instruction, wrapped.InstructionIndex, legal);
bool popAll = legal.Any(l => ((LinqArray <TypeOnStack>)l.PoppedFromStack).Contains(TypeOnStack.Get <PopAllType>()));
if (popAll && legal.Count() != 1)
{
throw new Exception("PopAll cannot coexist with any other transitions");
}
if (!popAll)
{
var toPop = legal.First().PoppedCount;
if (toPop > runningStack.Count && !IsBaseless)
{
return(VerificationResult.FailureUnderflow(this, i, toPop, runningStack));
}
}
bool isDuplicate = legal.Any(l => l.IsDuplicate);
if (isDuplicate && legal.Count() > 1)
{
throw new Exception("Duplicate must be only transition");
}
if (isDuplicate)
{
if (!IsBaseless && runningStack.Count == 0)
{
return(VerificationResult.FailureUnderflow(this, i, 1, runningStack));
}
var toPush = runningStack.Count > 0 ? runningStack.Peek() : new LinqList <TypeOnStack>(new[] { TypeOnStack.Get <WildcardType>() });
UpdateStack(runningStack, new InstructionAndTransitions(wrapped.Instruction, wrapped.InstructionIndex, new LinqList <StackTransition>(new[] { new StackTransition(new TypeOnStack[0], toPush.AsEnumerable()) })), IsBaseless);
}
else
{
UpdateStack(runningStack, new InstructionAndTransitions(wrapped.Instruction, wrapped.InstructionIndex, legal), IsBaseless);
}
}
CachedVerifyIndex = i;
CachedVerifyStack = runningStack;
return(VerificationResult.Successful(this, runningStack));
}
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);
}
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);
}
}