public void DeleteTemporaryBreakPonts()
{
if (Platform == null)
{
return;
}
if (BreakPoints.Count == 0)
{
return;
}
var temps = new List <BreakPoint>();
foreach (var breakpoint in BreakPoints)
{
if (breakpoint.Temporary && breakpoint.Address == InstructionPointer)
{
temps.Add(breakpoint);
}
}
foreach (var breakpoint in temps)
{
BreakPoints.Remove(breakpoint);
GDBConnector.ClearBreakPoint(breakpoint.Address);
}
if (temps.Count != 0)
{
NotifyBreakPointChange();
}
}
public Symbol FindSymbol(double value) //分级渲染。根据该属性值寻找对应的符号
{
Symbol output = new PointSymbol(1, System.Drawing.Color.Red, 3f); //同前赋值一个默认的符号
if (Symbols.Count() - BreakPoints.Count() == 1) //确保不会溢出
{
if (value <= BreakPoints[0]) //第一个
{
return(Symbols[0]);
}
else if (value >= BreakPoints.Last())//最后一个
{
return(Symbols.Last());
}
else//中间的
{
for (int i = 1; i < BreakPoints.Count(); i++)
{
if (value <= BreakPoints[i] && value > BreakPoints[i - 1])
{
output = Symbols[i];
}
}
return(output);
}
}
else
{
throw new IndexOutOfRangeException("分级渲染数据错误：断裂点 != 样式数目 - 1");
}
}
public void AddBreakPoint(BreakPoint bp)
{
if (_editingBreakPoint != null)
{
// Copy state (number, condition, trip count etc...)
bp.CopyState(_editingBreakPoint);
// Replace it
var index = _allBreakPoints.IndexOf(_editingBreakPoint);
_allBreakPoints[index] = bp;
PrepareBreakPoints();
// Save
OnSettingsChanged();
WriteLine("Edited {0}", bp);
return;
}
if (_allBreakPoints.Count > 0)
{
bp.Number = _allBreakPoints.Max(x => x.Number) + 1;
}
else
{
bp.Number = 1;
}
BreakPoints.Add(bp);
PrepareBreakPoints();
OnSettingsChanged();
WriteLine("Added {0}", bp.ToString());
}
// Method to handle the Debugger BreakpointUpdated event.
// This method will display the current breakpoint change and maintain a
// collection of all current breakpoints.
private void HandlerBreakpointUpdatedEvent(object sender, BreakpointUpdatedEventArgs args)
{
switch (args.UpdateType)
{
case BreakpointUpdateType.Set:
if (!BreakPoints.ContainsKey(args.Breakpoint.Id))
{
BreakPoints.Add(args.Breakpoint.Id, args.Breakpoint);
}
UserIOImpl.PrintMessage("HandlerBreakpointUpdatedEvent> breakpoint created");
break;
case BreakpointUpdateType.Removed:
BreakPoints.Remove(args.Breakpoint.Id);
UserIOImpl.PrintMessage("HandlerBreakpointUpdatedEvent> breakpoint removed");
break;
case BreakpointUpdateType.Enabled:
UserIOImpl.PrintMessage("HandlerBreakpointUpdatedEvent> breakpoint enabled");
break;
case BreakpointUpdateType.Disabled:
UserIOImpl.PrintMessage("HandlerBreakpointUpdatedEvent> breakpoint disabled");
break;
}
UserIOImpl.PrintMessage(args.Breakpoint.ToString());
}
private async Task Build(string str)
{
str = str.Trim();
var resultCode = CheckCode(str);
if (resultCode != 0)
{
Message = $"line {resultCode}: Error! IncorrectCommand";
return;
}
BreakPoints.Clear();
foreach (var command in Commands)
{
if (command.IsBreakpointSet)
{
BreakPoints.Add(command.CommandId);
}
}
Commands = FromsStringtoCommands(str);
for (int i = 0; i < Commands.Count; i++)
{
if (BreakPoints.Contains(Commands[i].CommandId))
{
Commands[i].IsBreakpointSet = true;
}
}
CurrentCommand = Commands.First();
SaveProjectCommand.Execute("Build");
await Task.Factory.StartNew(() => SendMessage("Sucessfully Compiled!"));
Start();
}
protected override void PrepareBreakPoints()
{
if (BreakPoints.OfType <WndProcBreakPoint>().Any())
{
foreach (var wpbp in BreakPoints.OfType <WndProcBreakPoint>())
{
wpbp.Prepare(_wndProcSymbolScope);
}
_machine.NotifyCallWndProc16 = () =>
{
foreach (var wpbp in BreakPoints.OfType <WndProcBreakPoint>())
{
wpbp.Break();
}
};
}
else
{
if (_machine != null)
{
_machine.NotifyCallWndProc16 = null;
}
}
base.PrepareBreakPoints();
}
//_____________________________________________________________________________________________________________________________________________________________
public void Export()
{
File.WriteAllLines(fullProjectFileName, Scripts.ToArray());
BreakPoints.Export();
Functions.Export();
File.WriteAllText(fullSettingsFileName, $"GroupTypes:{(Setting_GroupTypes?1:0)}");
}
//_____________________________________________________________________________________________________________________________________________________________
public void Rename(string name)
{
DeleteIfExists(fullProjectFileName);
BreakPoints.Rename(name);
Functions.Rename(name);
Name = name;
File.WriteAllLines(fullProjectFileName, Scripts.ToArray());
}
public void AddBreakPoint(BreakPoint breakpoint)
{
if (!BreakPoints.Any(b => b.Address == breakpoint.Address))
{
BreakPoints.Add(breakpoint);
GDBConnector.AddBreakPoint(breakpoint.Address);
NotifyBreakPointChange();
}
}
public void registerOnBreakEventCallback(string breakpointSignature, Func <O2MDbgCurrentLocation, Dictionary <string, O2MDbgVariable>, bool> callback)
{
if (registeredOnBreakEventCallbacks == null)
{
registeredOnBreakEventCallbacks = new Dictionary <string, List <Func <O2MDbgCurrentLocation, Dictionary <string, O2MDbgVariable>, bool> > >();
}
BreakPoints.addBreakPoint(breakpointSignature);
if (false == registeredOnBreakEventCallbacks.ContainsKey(breakpointSignature))
{
registeredOnBreakEventCallbacks.Add(breakpointSignature, new List <Func <O2MDbgCurrentLocation, Dictionary <string, O2MDbgVariable>, bool> >());
}
registeredOnBreakEventCallbacks[breakpointSignature].Add(callback);
}
protected void OnStep(object sender, DebugInformation info)
{
if (Step != null)
{
Step(this, info);
}
if (Break != null)
{
BreakPoint breakpoint = BreakPoints.Find(l =>
{
bool afterStart, beforeEnd;
if (l.Line == info.CurrentStatement.Source.Start.Line)
{
return(true);
}
afterStart = l.Line > info.CurrentStatement.Source.Start.Line ||
(l.Line == info.CurrentStatement.Source.Start.Line && l.Char >= info.CurrentStatement.Source.Start.Char);
if (!afterStart)
{
return(false);
}
beforeEnd = l.Line < info.CurrentStatement.Source.Stop.Line ||
(l.Line == info.CurrentStatement.Source.Stop.Line && l.Char <= info.CurrentStatement.Source.Stop.Char);
if (!beforeEnd)
{
return(false);
}
if (!String.IsNullOrEmpty(l.Condition))
{
return(Convert.ToBoolean(this.Run(l.Condition)));
}
return(true);
});
if (breakpoint != null)
{
Break(this, info);
}
}
}
public void ApplyBreakPoints()
{
Break -= OnBreakEvent;
int[] breakPoints = Debugger.GetBreakPoints(ModuleName);
if (breakPoints != null)
{
if (breakPoints.Length > 0)
{
BreakPoints.Clear();
foreach (int line in breakPoints)
{
var bp = new BreakPoint(line, 0);
BreakPoints.Add(bp);
}
Break += OnBreakEvent;
}
}
}
private bool CheckforCancellation()
{
if (IsPaused)
{
return(true);
}
if (_skipCycles && PictureProcessingUnit.TotalCycles >= cyclesToSkip)
{
_skipCycles = false;
return(true);
}
if (BreakPoints.Any(x => x.IsEnabled && x.BreakPointType == BreakPointType.Execute && x.ConvertedAddress == Processor.ProgramCounter))
{
return(true);
}
return(false);
}
internal void raiseOnBreakEvent(O2MDbgCurrentLocation o2MDbgCurrentLocation)
{
if (registeredOnBreakEventCallbacks == null)
{
registeredOnBreakEventCallbacks = new Dictionary <string, List <Func <O2MDbgCurrentLocation, Dictionary <string, O2MDbgVariable>, bool> > >();
}
Callbacks.raiseRegistedCallbacks(onBreakEvent);
// make sure all breakpoints are registed
var activeBreakPoints = BreakPoints.getBreakPointsAsStringList();
foreach (var breakpointSignature in registeredOnBreakEventCallbacks.Keys)
{
if (false == activeBreakPoints.Contains(breakpointSignature))
{
BreakPoints.addBreakPoint(breakpointSignature);
}
}
// check if we need to invoke a callback
//if (o2MDbgCurrentLocation.hasSourceCodeDetails)
//{
var currentLocationString = o2MDbgCurrentLocation.ToString();
if (registeredOnBreakEventCallbacks.ContainsKey(currentLocationString))
{
Dictionary <string, O2MDbgVariable> variablesDictionary = DI.o2MDbg.sessionData.getVariablesDictionary();
foreach (var callback in registeredOnBreakEventCallbacks[currentLocationString])
{
if (callback(o2MDbgCurrentLocation, variablesDictionary))
{
// means execution is supposed to continue
O2MDbgUtils.continueAttachedProjet();
return;
}
}
}
if (DI.o2MDbg.AutoContinueOnBreakPointEvent)
{
O2MDbgUtils.continueAttachedProjet();
}
}
private void RemoveBreakPoint(JToken bp) => BreakPoints.Remove(BreakPoints.Find(bp.ToObject <string>()));
public void DeleteAllBreakPonts()
{
BreakPoints.Clear();
GDBConnector.ClearAllBreakPoints();
NotifyBreakPointChange();
}
public void RemoveBreakPoint(BreakPoint breakpoint)
{
BreakPoints.Remove(breakpoint);
GDBConnector.ClearBreakPoint(breakpoint.Address);
NotifyBreakPointChange();
}
//_____________________________________________________________________________________________________________________________________________________________
public void Remove()
{
DeleteIfExists(fullProjectFileName);
BreakPoints.Remove();
Functions.Remove();
}
void IconBarMargin_MouseDown(AbstractMargin sender, Point mousepos, MouseButtons mouseButtons)
{
if (mouseButtons != MouseButtons.Left)
{
return;
}
var textArea = _textEditor.ActiveTextAreaControl.TextArea;
int yPos = mousepos.Y;
int lineHeight = textArea.TextView.FontHeight;
int lineNumber = (yPos + textArea.VirtualTop.Y) / lineHeight;
if (BreakPoints.Any(p => p.Line == lineNumber + 1) || lineNumber >= textArea.Document.TotalNumberOfLines)
{
return;
}
string text = textArea.Document.GetText(textArea.Document.GetLineSegment(lineNumber));
int offset = -1;
for (int i = 0; i < text.Length; i++)
{
if (
!Char.IsWhiteSpace(text[i]) &&
text[i] != '/'
)
{
offset = i;
break;
}
}
if (offset == -1)
{
return;
}
var breakPoint = new EditorBreakPoint(lineNumber + 1, offset);
BreakPoints.Add(breakPoint);
if (_script != null)
{
breakPoint.BreakPoint = new BreakPoint(Script.Script, lineNumber + 1, offset);
_script.Engine.BreakPoints.Add(breakPoint.BreakPoint);
}
var document = _textEditor.Document;
var mark = new BreakPointMark(
document,
new TextLocation(
offset,
lineNumber
)
);
mark.Removed += (s, e) =>
{
BreakPoints.Remove(breakPoint);
_script?.Engine.BreakPoints.Remove(breakPoint.BreakPoint);
};
document.BookmarkManager.AddMark(mark);
_textEditor.Refresh();
}
private void AddBreakPoint(JToken bp) => BreakPoints.Add(BreakPointsConverter.FromDto(bp.ToObject <BreakPointDto>()));
