/// <summary> /// Comparator for Breakpoint. /// </summary> /// <param name="other">Another breakpoint.</param> /// <returns>Return negative integer if this is less than other breakpoint, zero if equals, positive integer if more.</returns> public int CompareTo(IBreakPoint other) { int x = Time.CompareTo(other.Time); int y = Priority.CompareTo(other.Priority); int z; if (other is BreakPoint) { z = NumberOfMessage.CompareTo(((BreakPoint)other).NumberOfMessage); } else { z = Key.CompareTo(other.Key); } if (x != 0) { return(x); } else if (y != 0) { return(y); } else { return(z); } }
private ActiveNode TryBreakHere( IParagraphModel <TLine, TState> paragraph, IFrameModel frame, IBreakPoint breakPoint, ActiveNode prevNode, out bool doDeactivate) { var nextLineNumber = prevNode.LineNumber + 1; var suitableLength = frame.LengthOf(nextLineNumber); var constraint = new LineConstraint { SuitableLength = suitableLength }; var newStyle = new TState(); var line = paragraph.CreateLine(constraint, prevNode.Point, breakPoint, prevNode.Style, out newStyle); double ratio = _evaluator.ComputeAdjustmentRatio(line, suitableLength); doDeactivate = (ratio < -1 || _evaluator.IsForcedBreakPoint(breakPoint)); if (-1 <= ratio && ratio <= _tolerance) { var fitnessClass = _evaluator.ComputeFitnessClass(ratio); var prevIsFlagged = prevNode.Point.IsFlagged; var prevFitnessClass = prevNode.FitnessClass; var demerits = _evaluator.ComputeDemerits(breakPoint, ratio, fitnessClass, prevIsFlagged, prevFitnessClass); return(ActiveNode.CreateBreakNode(breakPoint, line, fitnessClass, newStyle, ratio, demerits, prevNode)); } else { return(null); } }
public BreakPointDto ToDto(IBreakPoint bp) { return(new BreakPointDto { Name = bp.Name, Address = bp.Address.ToUInt() }); }
public PauseContext(IMemory memory, ICpu cpu, StopReason stopReason, IBreakPoint stopBreakPoint, string stopMessage) { Memory = memory; Cpu = cpu; StopReason = stopReason; StopMessage = stopMessage; StopBreakPoint = stopBreakPoint; }
public void Add(IBreakPoint breakPoint) { if (!breakPoints.TryGetValue(breakPoint.Address, out var set)) { breakPoints[breakPoint.Address] = set = new HashSet <IBreakPoint>(); } set.Add(breakPoint); nameToBreakPoint[breakPoint.Name] = breakPoint; }
public void Remove(IBreakPoint breakPoint) { if (breakPoints.TryGetValue(breakPoint.Address, out var set)) { set.Remove(breakPoint); } if (nameToBreakPoint.TryGetValue(breakPoint.Name, out var bp) && bp.Equals(breakPoint)) { nameToBreakPoint.Remove(breakPoint.Name); } }
public static ActiveNode CreateBreakNode(IBreakPoint here, IUnjustifiedLine <TLine> lineBeforeHere, FitnessClass fitnessClass, TState style, double ratio, double demerits, ActiveNode prevNode) { return(new ActiveNode { Point = here, FitnessClass = fitnessClass, Style = style, Ratio = ratio, TotalDemerits = demerits + prevNode.TotalDemerits, LineNumber = prevNode.LineNumber + 1, PrevNode = prevNode, LineBeforeHere = lineBeforeHere }); }
public static ActiveNode CreateStartNode(IBreakPoint startPoint) { return(new ActiveNode { Point = startPoint, FitnessClass = LineBreaking.FitnessClass.VeryTight, Style = new TState(), Ratio = 0.0, TotalDemerits = 0.0, LineNumber = 0, PrevNode = null, LineBeforeHere = null }); }
protected override void HandleBreakpointHit(IBreakPoint bp, IThread bpThread) { VSCodeBreakPoint codeBp = (VSCodeBreakPoint)bp; da.Protocol.SendEvent(new StoppedEvent() { AllThreadsStopped = true, HitBreakpointIds = new List <int>() { codeBp.GetHashCode() }, Reason = StoppedEvent.ReasonValue.Breakpoint, ThreadId = bpThread.ThreadID, }); }
public double ComputeDemerits( IBreakPoint point, double ratio, FitnessClass fitnessClass, bool prevIsFlagged, FitnessClass prevFitnessClass) { double demerits = ComputeDemerits(point.Penalty, ratio, IsForcedBreakPoint(point)); //continuous flagged if (point.IsFlagged && prevIsFlagged) { demerits += _flaggedDemerit; } //unmatched fitness //TODO: let fitnessDemerit is 0 when prevNode is head. if (Math.Abs(fitnessClass - prevFitnessClass) > 1) { demerits += _fitnessDemerit; } return(demerits); }
public bool IsForcedBreakPoint(IBreakPoint breakPoint) { return(breakPoint.Penalty == Constants.PenaltyToForceBreak); }
protected override void HandleBreakpointHit(IBreakPoint bp, IThread bpThread) { engine.Callback.BreakpointHit((AD7PendingBreakPoint)bp, (AD7Thread)bpThread); }