/// <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);
}
