Example #1
0
        public BreakpointAlreadySetException(IBreakpoint breakpoint)
            : base("This breakpoint is already set.")
        {
            Contract.Requires(breakpoint != null);

            Breakpoint = breakpoint;
        }
Example #2
0
 public void Remove(IBreakpoint bp)
 {
     dispatcher.UI(() => {
         if (theDebugger.IsDebugging)
         {
             var bph = bp as IDnBreakpointHolder;
             if (bph != null)
             {
                 var dnbp = bph.DnBreakpoint;
                 if (dnbp != null)
                 {
                     theDebugger.Debugger.RemoveBreakpoint(bph.DnBreakpoint);
                 }
             }
             else
             {
                 Debug.Fail("Unknown breakpoint: " + bp);
             }
         }
         else
         {
             bool b = breakpointsToInitialize.Remove(bp);
             Debug.Assert(b);
         }
     });
 }
Example #3
0
 private void debugger_Breakpoint(IWabbitemu debugger, IBreakpoint breakpoint)
 {
     if (OnBreakpoint != null)
     {
         OnBreakpoint(debugger, new BreakpointEventArgs(breakpoint));
     }
 }
Example #4
0
        private bool BindBreakpoint(ITypeMirror type, IBreakpoint bp)
        {
            foreach (var method in type.Methods)
            {
                var bestLocation = BestLocationIn(method, bp);
                if (bestLocation == null)
                {
                    continue;
                }

                var b = Factory.CreateBreakpoint(bestLocation);
                breakpoints[bp] = b;
                if (bp.Enabled)
                {
                    b.Enable();
                }

                if (BreakpointBound != null)
                {
                    BreakpointBound(bp, b, b.Location);
                }
                return(true);
            }
            return(false);
        }
        public bool RemoveBreakpoint(IBreakpoint breakpoint)
        {
            if (!breakpoints.ContainsKey (breakpoint))
                return false;

            breakpoints.Remove (breakpoint);
            return true;
        }
Example #6
0
        /// <summary>
        /// Create a SLED style breakpoint from a SyntaxEditorControl style breakpoint
        /// </summary>
        /// <param name="ibp">SyntaxEditorControl style breakpoint</param>
        /// <returns>SLED breakpoint</returns>
        public static SledProjectFilesBreakpointType Create(IBreakpoint ibp)
        {
            var node = new DomNode(SledSchema.SledProjectFilesBreakpointType.Type);
            var bp   = node.As <SledProjectFilesBreakpointType>();

            bp.Setup(ibp);
            return(bp);
        }
Example #7
0
 private void OnBreakpointEnabled(IBreakpoint breakpoint)
 {
     IBreakpoint bp;
     if (breakpoints.TryGetValue (breakpoint, out bp))
         bp.Enable ();
     else
         OnBreakpointAdded (breakpoint);
 }
Example #8
0
 private void OnBreakpointRemoved(IBreakpoint breakpoint)
 {
     IBreakpoint bp;
     if (breakpoints.TryGetValue (breakpoint, out bp)) {
         bp.Disable ();
         breakpoints.Remove (breakpoint);
     }
 }
Example #9
0
 private bool AddBreakpoint(IBreakpoint breakpoint)
 {
     if (breakpoints.ContainsKey(breakpoint))
     {
         return(false);
     }
     breakpoints.Add(breakpoint, null);
     return(true);
 }
        private void disableBreakpointToolStripMenuItem_Click(object sender, EventArgs e)
        {
            IBreakpoint bp = this.CurrentRow.Breakpoint;

            if (bp != null)
            {
                bp.Enabled = !bp.Enabled;
            }
        }
Example #11
0
        private void OnBreakpointDisabled(IBreakpoint breakpoint)
        {
            IBreakpoint bp;

            if (breakpoints.TryGetValue(breakpoint, out bp))
            {
                bp.Disable();
            }
        }
Example #12
0
        public bool RemoveBreakpoint(IBreakpoint breakpoint)
        {
            if (!breakpoints.ContainsKey(breakpoint))
            {
                return(false);
            }

            breakpoints.Remove(breakpoint);
            return(true);
        }
Example #13
0
        public void RemoveBreakpoint(IBreakpoint bp)
        {
            Contract.Requires(bp != null);

            lock (syncBreakpoint)
            {
                if (breakpoints.Remove(bp))
                {
                    bp.Remove(process);
                }
            }
        }
Example #14
0
        private void NativeDebuggerOnBreakpoint(Wabbitemu calc, IBreakpoint breakpoint)
        {
            if (breakpoint.Address != _mapLoadBreak.Address)
            {
                return;
            }

            _debuggerService.CurrentDebugger.NativeDebugger.Breakpoint -= NativeDebuggerOnBreakpoint;
            _debuggerService.CurrentDebugger.NativeDebugger.Breakpoints.Remove(_mapLoadBreak);
            _debuggerService.CurrentDebugger.Run();
            StartTesting();
        }
Example #15
0
        public void PrintInstruction(X86Instruction instruction, IBreakpoint breakpoint)
        {
            var original = System.Console.ForegroundColor;

            System.Console.ForegroundColor = breakpoint != null ? ConsoleColor.Black : ConsoleColor.DarkGray;

            if (breakpoint != null)
            {
                System.Console.BackgroundColor = breakpoint.Enabled ? ConsoleColor.Red : ConsoleColor.Yellow;
            }

            System.Console.Write(instruction.Offset.ToString("X8"));

            System.Console.ForegroundColor = ConsoleColor.DarkGray;
            System.Console.BackgroundColor = ConsoleColor.Black;
            System.Console.Write(": ");

            ConsoleColor color;

            if (!MnemonicColors.TryGetValue(instruction.Mnemonic, out color))
            {
                color = ConsoleColor.DarkGray;
            }

            System.Console.ForegroundColor = color;

            foreach (var prefix in instruction.Prefixes)
            {
                string formatted = _formatter.FormatPrefix(prefix);
                if (!string.IsNullOrEmpty(formatted))
                {
                    System.Console.Write(formatted + ' ');
                }
            }

            System.Console.Write(_formatter.FormatMnemonic(instruction.Mnemonic));

            if (instruction.Operand1 != null)
            {
                System.Console.Write(' ');
                System.Console.Write(_formatter.FormatOperand(instruction.Operand1));

                if (instruction.Operand2 != null)
                {
                    System.Console.Write(", ");
                    System.Console.Write(_formatter.FormatOperand(instruction.Operand2));
                }
            }

            System.Console.WriteLine();
            System.Console.ForegroundColor = original;
        }
Example #16
0
        private void OnBreakpointEnabled(IBreakpoint breakpoint)
        {
            IBreakpoint bp;

            if (breakpoints.TryGetValue(breakpoint, out bp))
            {
                bp.Enable();
            }
            else
            {
                OnBreakpointAdded(breakpoint);
            }
        }
Example #17
0
        private void Setup(IBreakpoint bp)
        {
            if (bp != null)
            {
                Line       = bp.LineNumber;
                Enabled    = bp.Enabled;
                LineText   = bp.LineText;
                Breakpoint = bp;
            }

            // Assume true for now
            ConditionResult = true;
        }
Example #18
0
        public void AddBreakpoint(IBreakpoint breakpoint)
        {
            Contract.Requires(breakpoint != null);

            lock (syncBreakpoint)
            {
                if (!breakpoints.Add(breakpoint))
                {
                    throw new BreakpointAlreadySetException(breakpoint);
                }

                breakpoint.Set(process);
            }
        }
Example #19
0
        public void Set(IEnumerable <IDebugBoundBreakpoint2> boundBreakpoints)
        {
            if (!boundBreakpoints.Any())
            {
                FiredBreakpoint = null;
                return;
            }

            IDebugPendingBreakpoint2 pendingBreakpoint;

            HResultChecker.Check(
                boundBreakpoints.First().GetPendingBreakpoint(out pendingBreakpoint));
            FiredBreakpoint = _pendingToBreakpoint[pendingBreakpoint];
        }
Example #20
0
        void Initialize(IBreakpoint bp)
        {
            Debug.Assert(theDebugger.IsDebugging);

            var bph = bp as IDnBreakpointHolder;

            if (bph != null)
            {
                bph.Initialize(theDebugger.Debugger);
                return;
            }

            Debug.Fail("Unknown breakpoint: " + bp);
        }
Example #21
0
        public int IndexOf(IBreakpoint breakpoint)
        {
            int i    = 0;
            var keys = breakpoints.Keys.ToArray();

            for (i = 0; i < keys.Length; i++)
            {
                if (keys[i] == breakpoint)
                {
                    return(i);
                }
            }
            return(-1);
        }
Example #22
0
        public GDBSnapshot(GDBConnector connector, IDebuggerStop lastDebuggerStop)
        {
            _connector = connector;

            if(lastDebuggerStop == null)
                throw new ArgumentException("No last stop address found");

            if(lastDebuggerStop.Address == 0 )
                throw new ArgumentException("Last stop does not provide address");

            _myBreakpoint = connector.SetSoftwareBreakpoint(lastDebuggerStop.Address, 0, "_snapshot");

            //Activate reverse debugging
            connector.QueueCommand(new RecordCmd(_connector));
        }
Example #23
0
        public void ClearBreakpoint(IBreakpoint breakpoint)
        {
            var breakpointNum = ThreadSafe(() => breakpoints
                                           .ToDictionary(x => x.Value, x => x.Key));

            if (!breakpointNum.ContainsKey(breakpoint))
            {
                return;
            }

            var reqClearBreak = Message.Create <ClearBreakpointRequest>(driver);

            reqClearBreak.Arguments.Breakpoint = breakpointNum[breakpoint];
            reqClearBreak.SendAsync();
        }
Example #24
0
        private void OnBreakpointAdded(IBreakpoint breakpoint)
        {
            var types = typeProvider.TypesFor (breakpoint.Location.SourceFile);
            foreach (var type in types)
            {
                foreach (var method in type.Methods)
                {
                    var bestLocation = BestLocationIn (method, breakpoint);
                    if (bestLocation == null)
                        continue;

                    breakpoints.Add (breakpoint, Factory.CreateBreakpoint (bestLocation));
                    break;
                }
            }
        }
Example #25
0
        void IComponentWithBreakpoints.DeleteBreakpoint(IBreakpoint breakpoint)
        {
            MemoryBreakpoint bp = breakpoint as MemoryBreakpoint;

            if (bp != null)
            {
                bp.PropertyChanged -= this.OnBreakpointPropertyChanged;

                this.disabledBreakpoints.Remove(bp);
                this.readBreakpoints.Remove(bp);
                this.writeBreakpoints.Remove(bp);

                this.readBreakpointsArray  = this.readBreakpoints.ToArray();
                this.writeBreakpointsArray = this.writeBreakpoints.ToArray();
            }
        }
Example #26
0
        public void SetBreakpoint(IBreakpoint breakpoint)
        {
            var setBreakpoint = Message.Create <SetBreakpointRequest>(driver);

            setBreakpoint.Arguments.TargetType = SetBreakpointRequest.TargetType.ScriptRegExp;
            setBreakpoint.Arguments.Target     = breakpoint.QrcPath;
            setBreakpoint.Arguments.Line       = (int)breakpoint.Line;
            setBreakpoint.Tag = breakpoint;
            if (driver.ConnectionState == DebugClientState.Connected)
            {
                setBreakpoint.SendAsync();
            }
            else
            {
                ThreadSafe(() => outbox.Add(setBreakpoint));
            }
        }
Example #27
0
        public void StepOver()
        {
            if (_isStepping)
            {
                return;
            }

            _isStepping = true;
            // need to clear the old breakpoint so lets save it
            ushort           currentPc = _debugger.CPU.PC;
            byte             oldPage   = GetRelativePageNum(currentPc);
            DocumentLocation key       = _symbolService.ListTable.GetFileLocation(oldPage, currentPc, currentPc >= 0x8000);

            string line = _fileService.GetLine(key.FileName, key.LineNumber);

            int commentIndex = line.IndexOf(";", StringComparison.Ordinal);

            if (commentIndex != -1)
            {
                line = line.Substring(0, commentIndex);
            }

            // if the line contains a special commmand (i.e. one that will go to who knows where)
            // we just want to step over it
            string[] specialCommands = { "jp", "jr", "ret", "djnz" };
            if (specialCommands.Any(s => line.Contains(s)))
            {
                _isStepping = false;
                Step();
                return;
            }

            do
            {
                currentPc++;
                oldPage = GetRelativePageNum(currentPc);
                key     = _symbolService.ListTable.GetFileLocation(oldPage, currentPc, currentPc >= 0x8000);
            } while (key == null);

            _stepOverBreakpoint     = _debugger.SetBreakpoint(currentPc >= 0x8000, GetAbsolutePageNum(currentPc), currentPc);
            _debugger.OnBreakpoint += StepOverBreakpointEvent;

            _debugger.Step();
            _debugger.Running = true;
        }
Example #28
0
        private EvaluationResult RunToBreakpoint(Node node, Context context, ModuleLiteral env, EvaluationStackFrame args, Func <EvaluationResult> continuation)
        {
            IBreakpointStore breakpoints = GetBreakpointStore(context);

            if (breakpoints.IsEmpty)
            {
                return(continuation());
            }

            IBreakpoint atBreakpoint = breakpoints.Find(env.Path, node);

            // if at a breakpoint:
            if (atBreakpoint != null)
            {
                PauseEvaluation(node, context, env, args, PauseReasonBreakpoint);
            }

            return(continuation());
        }
Example #29
0
        private void OnBreakpointAdded(IBreakpoint breakpoint)
        {
            var types = typeProvider.TypesFor(breakpoint.Location.SourceFile);

            foreach (var type in types)
            {
                foreach (var method in type.Methods)
                {
                    var bestLocation = BestLocationIn(method, breakpoint);
                    if (bestLocation == null)
                    {
                        continue;
                    }

                    breakpoints.Add(breakpoint, Factory.CreateBreakpoint(bestLocation));
                    break;
                }
            }
        }
Example #30
0
        public bool RemoveBreakpoint(IBreakpoint breakpoint)
        {
            if (!breakpoints.ContainsKey(breakpoint))
            {
                return(false);
            }
            IBreakpoint bp;

            if (breakpoints.TryGetValue(breakpoint, out bp) && bp.Enabled)
            {
                breakpoint.Disable();
            }

            if (BreakpointRemoved != null)
            {
                BreakpointRemoved(breakpoint);
            }
            breakpoints.Remove(breakpoint);
            return(true);
        }
Example #31
0
        private void DebuggerService_OnDebuggingStarted(object sender, DebuggingEventArgs e)
        {
            var debugger = e.Debugger;

            debugger.DebuggerRunningChanged += Debugger_DebuggerRunningChanged;


            var mapLoadAddress = _symbolService.SymbolTable.GetAddressFromLabel("load_map");

            if (!mapLoadAddress.HasValue)
            {
                return;
            }

            var calcAddr = new CalcAddress();
            var calcPage = debugger.NativeDebugger.Memory.Flash[0x15 - (mapLoadAddress.Value >> 16)];

            calcAddr.Initialize(calcPage, (ushort)mapLoadAddress.Value);
            _mapLoadBreak = debugger.NativeDebugger.Breakpoints.Add(calcAddr);
            debugger.NativeDebugger.Breakpoint += NativeDebuggerOnBreakpoint;
        }
Example #32
0
        public void StepOut()
        {
            if (_isStepping)
            {
                return;
            }

            _isStepping = true;
            DocumentLocation lastCallLocation = CallStack.Last().CallLocation;
            CalcLocation     calcLocation     = _symbolService.ListTable.GetCalcLocation(lastCallLocation.FileName, lastCallLocation.LineNumber);
            DocumentLocation docLocation      = null;
            ushort           address          = calcLocation.Address;

            while (docLocation == null)
            {
                address++;
                docLocation = _symbolService.ListTable.GetFileLocation(calcLocation.Page, address, calcLocation.IsRam);
            }
            _stepOutBreakpoint      = _debugger.SetBreakpoint(calcLocation.IsRam, (byte)(_appPage - calcLocation.Page), address);
            _debugger.OnBreakpoint += StepOutBreakpointEvent;
            _debugger.Step();
            _debugger.Running = true;
        }
Example #33
0
        private void SetupInternalBreakpoints()
        {
            if (_debugger == null)
            {
                return;
            }

            // this is the start _JForceCmdNoChar
            const ushort jforceCmdNoChar = 0x4027;
            const ushort insertMem       = 0x42F7;
            const ushort delMem          = 0x4357;
            CalcLocation location        = LookupBcallAddress(jforceCmdNoChar);

            _jforceBreakpoint = _debugger.SetBreakpoint(location.IsRam, location.Page, location.Address);
            // most likely location that a crash will end up
            _ramClearBreakpoint = _debugger.SetBreakpoint(false, 0, 0x0000);
            // for restarts we want to manually delmem
            location             = LookupBcallAddress(insertMem);
            _insertMemBreakpoint = _debugger.SetBreakpoint(location.IsRam, location.Page, location.Address);
            // we need to track any memory freed as well
            location          = LookupBcallAddress(delMem);
            _delMemBreakpoint = _debugger.SetBreakpoint(location.IsRam, location.Page, location.Address);
        }
Example #34
0
        private bool AddBreakpoint(IBreakpoint breakpoint)
        {
            if (breakpoints.ContainsKey(breakpoint))
            {
                return(false);
            }

            breakpoints.Add(breakpoint, null);
            breakpoint.Enable();
            if (BreakpointAdded != null)
            {
                BreakpointAdded(breakpoint);
            }

            foreach (var type in typeProvider.TypesFor(breakpoint.Location.SourceFile))
            {
                if (BindBreakpoint(type, breakpoint))
                {
                    break;
                }
            }

            return(true);
        }
        private void _editorContextMenu_Opening(object sender, CancelEventArgs e)
        {
            IBreakpoint bp = this.CurrentRow.Breakpoint;

            undoToolStripMenuItem.Enabled          = this.CanUndo;
            redoToolStripMenuItem.Enabled          = this.CanRedo;
            insertBreakpointToolStripMenuItem.Text = bp == null ? "Insert Breakpoint" : "Delete Breakpoint";

            if (bp != null)
            {
                disableBreakpointToolStripMenuItem.Text = bp.Enabled ? "Disable Breakpoint" : "Enable Breakpoint";
            }

            disableBreakpointToolStripMenuItem.Visible = bp != null;
            toolStripMenuItem2.Visible                        = bp != null;
            conditionToolStripMenuItem.Visible                = bp != null;
            hitCountToolStripMenuItem.Visible                 = bp != null;
            cutToolStripMenuItem.Enabled                      = this.Editor.Selection.SelLength != 0;
            copyToolStripMenuItem.Enabled                     = this.Editor.Selection.SelLength != 0;
            pasteToolStripMenuItem.Enabled                    = Clipboard.ContainsText();
            stopOutliningToolStripMenuItem.Text               = this.IsOutlining ? "Stop Outlining" : "Start Outlining";
            toggleAllOutliningToolStripMenuItem.Visible       = this.IsOutlining;
            toggleOutliningExpansionToolStripMenuItem.Visible = this.IsOutlining;
        }
		public BreakpointEventArgs (IBreakpoint breakpoint)
		{
			this.breakpoint = breakpoint;
		}
Example #37
0
 public bool IsBound(IBreakpoint breakpoint)
 {
     IBreakpoint val = null;
     return breakpoints.TryGetValue (breakpoint, out val) && val != null;
 }
        private void Setup(IBreakpoint bp)
        {
            if (bp != null)
            {
                Line = bp.LineNumber;
                Enabled = bp.Enabled;
                LineText = bp.LineText;
                Breakpoint = bp;
            }

            // Assume true for now
            ConditionResult = true;
        }
Example #39
0
 private static SledProjectFilesBreakpointType FindBreakpointInFile(SledProjectFilesFileType file, IBreakpoint ibp)
 {
     return file.Breakpoints.FirstOrDefault(bp => bp.Breakpoint == ibp);
 }
Example #40
0
        private void AddBreakpoint(ISledDocument sd, IBreakpoint ibp)
        {
            // Called when click-adding a breakpoint in an open document

            AddBreakpoints(sd, new[] { ibp });
        }
 public DebuggerStop(StopReasonEnum stopReason, IBreakpoint breakpoint, UInt64 address, Int64 status)
 {
     _stopReason = stopReason;
     _breakpoint = breakpoint;
     _address = address;
     _status = status;
 }
Example #42
0
 public IEnumerable<ILocation> GetBoundLocations(IBreakpoint breakpoint)
 {
     return breakpoints.Where (x => x.Key == breakpoint).Select (b => b.Value.Location as ILocation);
 }
Example #43
0
 public ILocation GetBoundLocation(IBreakpoint breakpoint)
 {
     IBreakpoint val = null;
     return breakpoints.TryGetValue (breakpoint, out val) && val != null ? val.Location : null;
 }
Example #44
0
        private bool BindBreakpoint(ITypeMirror type, IBreakpoint bp)
        {
            foreach (var method in type.Methods)
            {
                var bestLocation = BestLocationIn (method, bp);
                if (bestLocation == null)
                    continue;

                var b = Factory.CreateBreakpoint (bestLocation);
                breakpoints[bp] = b;
                if (bp.Enabled) b.Enable ();

                if (BreakpointBound != null)
                        BreakpointBound (bp, b, b.Location);
                return true;
            }
            return false;
        }
Example #45
0
        private bool AddBreakpoint(IBreakpoint breakpoint)
        {
            if (breakpoints.ContainsKey (breakpoint))
                return false;

            breakpoints.Add (breakpoint, null);
            breakpoint.Enable ();
            if (BreakpointAdded != null)
                BreakpointAdded (breakpoint);

            foreach(var type in typeProvider.TypesFor (breakpoint.Location.SourceFile))
                if (BindBreakpoint (type, breakpoint))
                    break;

            return true;
        }
Example #46
0
        public bool RemoveBreakpoint(IBreakpoint breakpoint)
        {
            if (!breakpoints.ContainsKey (breakpoint))
                return false;
            IBreakpoint bp;
            if (breakpoints.TryGetValue (breakpoint, out bp) && bp.Enabled)
                breakpoint.Disable ();

            if (BreakpointRemoved != null)
                BreakpointRemoved (breakpoint);
            breakpoints.Remove (breakpoint);
            return true;
        }
Example #47
0
		public void Remove(IBreakpoint bp) {
			dispatcher.UI(() => {
				if (theDebugger.IsDebugging) {
					var bph = bp as IDnBreakpointHolder;
					if (bph != null) {
						var dnbp = bph.DnBreakpoint;
						if (dnbp != null)
							theDebugger.Debugger.RemoveBreakpoint(bph.DnBreakpoint);
					}
					else
						Debug.Fail("Unknown breakpoint: " + bp);
				}
				else {
					bool b = breakpointsToInitialize.Remove(bp);
					Debug.Assert(b);
				}
			});
		}
Example #48
0
 private bool AddBreakpoint(IBreakpoint breakpoint)
 {
     if (breakpoints.ContainsKey (breakpoint))
         return false;
     breakpoints.Add (breakpoint, null);
     return true;
 }
Example #49
0
        private void RemoveBreakpoint(ISledDocument sd, IBreakpoint ibp)
        {
            // Called when click-removing a breakpoint in an open document

            var file = sd.SledProjectFile;
            if (file == null)
                return;
            
            var bp = FindBreakpointInFile(file, ibp);
            if (bp == null)
                return;

            // Remove breakpoint from file (will fire event through Collection_Removing)
            if (file.Breakpoints.Contains(bp))
                file.Breakpoints.Remove(bp);

            // Save changes
            m_projectService.SaveSettings();
        }
Example #50
0
 private ILocation BestLocationIn(IMethodMirror method, IBreakpoint bp)
 {
     return method.Locations.FirstOrDefault (l => l.SourceFile == bp.Location.SourceFile && l.LineNumber == bp.Location.LineNumber);
 }
Example #51
0
		void Initialize(IBreakpoint bp) {
			Debug.Assert(theDebugger.IsDebugging);

			var bph = bp as IDnBreakpointHolder;
			if (bph != null) {
				bph.Initialize(theDebugger.Debugger);
				return;
			}

			Debug.Fail("Unknown breakpoint: " + bp);
		}
Example #52
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="bp"></param>
 public IBreakpointEventArgs(IBreakpoint bp)
 {
     Breakpoint = bp;
 }
 /// <summary>
 /// Create a SLED style breakpoint from a SyntaxEditorControl style breakpoint
 /// </summary>
 /// <param name="ibp">SyntaxEditorControl style breakpoint</param>
 /// <returns>SLED breakpoint</returns>
 public static SledProjectFilesBreakpointType Create(IBreakpoint ibp)
 {
     var node = new DomNode(SledSchema.SledProjectFilesBreakpointType.Type);
     var bp = node.As<SledProjectFilesBreakpointType>();
     bp.Setup(ibp);
     return bp;
 }
Example #54
0
 private void OnBreakpointDisabled(IBreakpoint breakpoint)
 {
     IBreakpoint bp;
     if (breakpoints.TryGetValue (breakpoint, out bp))
         bp.Disable ();
 }
 public FuzzDescription(IBreakpoint snapshotBreakpoint, IBreakpoint restoreBreakpoint)
 {
     _snapshotBreakpoint = snapshotBreakpoint;
     _restoreBreakpoint = restoreBreakpoint;
 }
Example #56
0
 public int IndexOf(IBreakpoint breakpoint)
 {
     int i  = 0;
     var keys = breakpoints.Keys.ToArray ();
     for (i = 0; i < keys.Length; i++)
         if (keys[i] == breakpoint)
             return i;
     return -1;
 }