// Returns the current stack *if* it can be inferred down to single types *and* is either based or verifiable to the given depth public LinqStack <TypeOnStack> InferStack(int ofDepth) { var res = CollapseAndVerify(); if (res.Stack.Count < ofDepth) { return(null); } var ret = new LinqStack <TypeOnStack>(); for (var i = ofDepth - 1; i >= 0; i--) { var couldBe = res.Stack.ElementAt(i); if (couldBe.Count() > 1) { return(null); } ret.Push(couldBe.Single()); } return(ret); }
private void Add(VerifiableTracker tracker, LinqStack <LinqList <TypeOnStack> > stack) { CurrentlyInScope.Add(tracker); CurrentlyInScopeStacks.Add(stack); if (CurrentlyInScope.Count != CurrentlyInScopeStacks.Count) { throw new Exception(); } }
private LinqStack <LinqList <TypeOnStack> > CopyStack(LinqStack <LinqList <TypeOnStack> > toCopy) { var ret = new LinqStack <LinqList <TypeOnStack> >(toCopy.Count); for (var i = toCopy.Count - 1; i >= 0; i--) { ret.Push(toCopy.ElementAt(i)); } return(ret); }
private static LinqStack <LinqList <TypeOnStack> > GetStack(VerifiableTracker tracker) { var retStack = new LinqStack <LinqList <TypeOnStack> >(tracker.StartingStack.Reverse()); foreach (var t in tracker.Transitions.AsEnumerable()) { UpdateStack(retStack, t, tracker.IsBaseless); } return(retStack); }
public VerifiableTracker(Label beganAt, bool baseless = false, VerifiableTracker createdFrom = null, bool canBePruned = true) { IsBaseless = baseless; BeganAt = beganAt; CanBePruned = canBePruned; MarkedLabelsAtTransitions[beganAt] = 0; if (createdFrom != null) { StartingStack = GetStack(createdFrom); } }
private int FindStackFailureIndex(LinqStack <LinqList <TypeOnStack> > types, IEnumerable <StackTransition> ops, out IEnumerable <TypeOnStack> expected) { var stillLegal = new LinqList <StackTransition>(ops); for (var i = 0; i < types.Count; i++) { var actuallyIs = types.ElementAt(i); var legal = stillLegal.Where(l => actuallyIs.Any(a => l.PoppedFromStack[i].IsAssignableFrom(a))).ToList(); if (legal.Count == 0) { expected = stillLegal.Select(l => l.PoppedFromStack[i]).Distinct().ToList().AsEnumerable(); return(i); } stillLegal = new LinqList <StackTransition>(legal); } throw new Exception("Shouldn't be possible"); }
public static VerificationResult FailureUnderflow(VerifiableTracker verifier, int transitionIndex, int expectedSize, LinqStack <LinqList <TypeOnStack> > stack) { return (new VerificationResult { Success = false, Verifier = verifier.Clone(), TransitionIndex = transitionIndex, IsStackUnderflow = true, ExpectedStackSize = expectedSize, Stack = stack }); }
public static VerificationResult Successful(VerifiableTracker verifier, LinqStack <LinqList <TypeOnStack> > stack) { return(new VerificationResult { Success = true, Stack = stack, Verifier = verifier }); }
public static VerificationResult FailureTypeMismatch(VerifiableTracker verifier, int transitionIndex, int stackIndex, IEnumerable <TypeOnStack> expectedTypes, LinqStack <LinqList <TypeOnStack> > stack) { return (new VerificationResult { Success = false, Verifier = verifier.Clone(), TransitionIndex = transitionIndex, IsTypeMismatch = true, StackIndex = stackIndex, ExpectedAtStackIndex = LinqEnumerable <TypeOnStack> .For(expectedTypes), Stack = stack }); }
public static VerificationResult FailureStackMismatch(VerifiableTracker verifier, LinqStack <LinqList <TypeOnStack> > expected, LinqStack <LinqList <TypeOnStack> > incoming) { return (new VerificationResult { Success = false, Verifier = verifier.Clone(), IsStackMismatch = true, ExpectedStack = expected, IncomingStack = incoming }); }
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); } }