C# BreakEventInfo.SetStatus方法代码示例

		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent be)
		{
			BreakEventInfo binfo = new BreakEventInfo ();

			lock (documents) {
				Breakpoint bp = be as Breakpoint;
				if (bp != null) {
					if (bp is FunctionBreakpoint) {
						// FIXME: implement breaking on function name
						binfo.SetStatus (BreakEventStatus.Invalid, null);
						return binfo;
					} else {
						DocInfo doc;
						if (!documents.TryGetValue (System.IO.Path.GetFullPath (bp.FileName), out doc)) {
							binfo.SetStatus (BreakEventStatus.NotBound, null);
							return binfo;
						}
						
						int line;
						try {
							line = doc.Document.FindClosestLine(bp.Line);
						}
						catch {
							// Invalid line
							binfo.SetStatus (BreakEventStatus.Invalid, null);
							return binfo;
						}
						ISymbolMethod met = doc.Reader.GetMethodFromDocumentPosition (doc.Document, line, 0);
						if (met == null) {
							binfo.SetStatus (BreakEventStatus.Invalid, null);
							return binfo;
						}
						
						int offset = -1;
						foreach (SequencePoint sp in met.GetSequencePoints ()) {
							if (sp.Line == line && sp.Document.URL == doc.Document.URL) {
								offset = sp.Offset;
								break;
							}
						}
						if (offset == -1) {
							binfo.SetStatus (BreakEventStatus.Invalid, null);
							return binfo;
						}
						
						CorFunction func = doc.Module.GetFunctionFromToken (met.Token.GetToken ());
						CorFunctionBreakpoint corBp = func.ILCode.CreateBreakpoint (offset);
						corBp.Activate (bp.Enabled);
						breakpoints[corBp] = binfo;
						
						binfo.Handle = corBp;
						binfo.SetStatus (BreakEventStatus.Bound, null);
						return binfo;
					}
				}
			}
			return null;
		}

		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent be)
		{
			Breakpoint bp = be as Breakpoint;
			if (bp == null)
				throw new NotSupportedException ();
			
			BreakEventInfo bi = new BreakEventInfo ();
			
			lock (gdbLock) {
				bool dres = InternalStop ();
				try {
					string extraCmd = string.Empty;
					if (bp.HitCount > 0) {
						extraCmd += "-i " + bp.HitCount;
						breakpointsWithHitCount.Add (bi);
					}
					if (!string.IsNullOrEmpty (bp.ConditionExpression)) {
						if (!bp.BreakIfConditionChanges)
							extraCmd += " -c " + bp.ConditionExpression;
					}
					
					GdbCommandResult res = null;
					string errorMsg = null;
					
					if (bp is FunctionBreakpoint) {
						try {
							res = RunCommand ("-break-insert", extraCmd.Trim (), ((FunctionBreakpoint) bp).FunctionName);
						} catch (Exception ex) {
							errorMsg = ex.Message;
						}
					} else {
						// Breakpoint locations must be double-quoted if files contain spaces.
						// For example: -break-insert "\"C:/Documents and Settings/foo.c\":17"
						RunCommand ("-environment-directory", Escape (Path.GetDirectoryName (bp.FileName)));
						
						try {
							res = RunCommand ("-break-insert", extraCmd.Trim (), Escape (Escape (bp.FileName) + ":" + bp.Line));
						} catch (Exception ex) {
							errorMsg = ex.Message;
						}
						
						if (res == null) {
							try {
								res = RunCommand ("-break-insert", extraCmd.Trim (), Escape (Escape (Path.GetFileName (bp.FileName)) + ":" + bp.Line));
							}
							catch {
								// Ignore
							}
						}
					}
					
					if (res == null) {
						bi.SetStatus (BreakEventStatus.Invalid, errorMsg);
						return bi;
					}
					int bh = res.GetObject ("bkpt").GetInt ("number");
					if (!be.Enabled)
						RunCommand ("-break-disable", bh.ToString ());
					breakpoints [bh] = bi;
					bi.Handle = bh;
					bi.SetStatus (BreakEventStatus.Bound, null);
					return bi;
				} finally {
					InternalResume (dres);
				}
			}
		}

        protected override BreakEventInfo OnInsertBreakEvent(BreakEvent be)
        {
            LogWriter(false, "Break inserted\n");
            Breakpoint bp = be as Breakpoint;
            if (bp == null)
                throw new NotSupportedException ();

            BreakEventInfo bi = new BreakEventInfo ();

            //lock (debuggerLock) {
                LogWriter(false, "Location is " + PathHelper.CutOffClassPath(classPathes, bp.FileName) + ":" + bp.Line + '\n');
                breaks.Add (new Break (PathHelper.CutOffClassPath (classPathes, bp.FileName), bp.Line));
            //}

            //bi.Handle = TODO: add returned success value (break count etc)
            bi.SetStatus (BreakEventStatus.Bound, null);
            return bi;
        }

        protected override BreakEventInfo OnInsertBreakEvent(BreakEvent be)
        {
            Breakpoint bp = be as Breakpoint;
            if (bp == null)
                throw new NotSupportedException ();

            BreakEventInfo breakEventInfo = new BreakEventInfo ();

            //bool dres = InternalStop ();
            try {
                string extraCmd = string.Empty;
                if (bp.HitCount > 0) {
                    extraCmd += "-i " + bp.HitCount;
                    breakpointsWithHitCount.Add (breakEventInfo);
                }
                if (!string.IsNullOrEmpty (bp.ConditionExpression)) {
                    if (!bp.BreakIfConditionChanges)
                        extraCmd += " -c " + bp.ConditionExpression;
                }

                ulong bh = 0;
                DebugEngineWrapper.BreakPoint engineBreakPoint = null;
                ulong off = 0;
                if (Engine.Symbols.GetOffsetByLine(bp.FileName, (uint)bp.Line, out off))
                {
                    engineBreakPoint = Engine.AddBreakPoint(BreakPointOptions.Enabled);
                    engineBreakPoint.Offset = off;

                    bh = engineBreakPoint.Offset;
                    breakpoints[bh] = new BreakPointWrapper(breakEventInfo, engineBreakPoint);
                    breakEventInfo.Handle = bh;
                    breakEventInfo.SetStatus(BreakEventStatus.Bound, null);

                    //if (!be.Enabled)
                    //ToDo: tell debugger engine that breakpoint is disabled

                }
                else
                {
                    breakEventInfo.SetStatus(BreakEventStatus.BindError, null);
                }

                return breakEventInfo;
            } finally {
                //InternalResume (dres);
            }
        }

        void FireBreakPoint(ulong offset)
        {
            TargetEventArgs args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint);

                ulong tempoff = (ulong)offset;
                if (breakpoints.ContainsKey(tempoff))
                {
                    breakpoints[(ulong)tempoff].EventInfo.UpdateHitCount((int)breakpoints[(ulong)tempoff].Breakpoint.HitCount);
                    args.BreakEvent = breakpoints[(ulong)tempoff].EventInfo.BreakEvent;
                }
                else
                {
                    args = new TargetEventArgs(TargetEventType.TargetStopped);
                    BreakEventInfo breakInfo = new BreakEventInfo();
                    breakInfo.Handle = tempoff;
                    breakInfo.SetStatus (BreakEventStatus.Bound, null);
                    string fn;
                    uint ln;
                    if (Engine.Symbols.GetLineByOffset(offset, out fn, out ln))
                    {
                        //breakInfo.BreakEvent = new Breakpoint(fn, (int)ln);
                        args.BreakEvent = breakInfo.BreakEvent;
                    }
                }

                ProcessInfo process = OnGetProcesses()[0];
                args.Process = new ProcessInfo(process.Id, process.Name);

                args.Backtrace = new Backtrace(new DDebugBacktrace(this, activeThread, Engine));

                ThreadPool.QueueUserWorkItem(delegate(object data)
                {
                    try
                    {
                        OnTargetEvent((TargetEventArgs)data);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex);
                    }
                }, args);
        }

		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent breakEvent)
		{
			var bp = breakEvent as Breakpoint;

			if(bp == null)
				throw new NotImplementedException ();

			unityDebugProtocol.AddBreakpoint (bp.FileName, bp.Line);

			var eventInfo =  new BreakEventInfo ();
			eventInfo.SetStatus (BreakEventStatus.Bound, null);
			return eventInfo;
		}

		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent breakEvent)
		{
			var binfo = new BreakEventInfo ();

			var bp = breakEvent as Breakpoint;

			if (bp != null) {
				if (bp is FunctionBreakpoint) {
					// FIXME: implement breaking on function name
					binfo.SetStatus (BreakEventStatus.Invalid, null);
					return binfo;
				} else {
					DocInfo doc;
					if (!documents.TryGetValue (System.IO.Path.GetFullPath (bp.FileName), out doc)) {
						binfo.SetStatus (BreakEventStatus.NotBound, "Cannot find source file in pdb/mdb debugging database.");
						return binfo;
					}

					MethodSymbols met = doc.GetClosestMethod (bp.Line);

					int offset = -1;
					foreach (var sp in met.Instructions) {
						if (sp.SequencePoint.StartLine == bp.Line) {
							offset = sp.Offset;
							break;
						}
					}
					if (offset == -1) {
						if (bp.Line < met.Instructions.First ().SequencePoint.StartLine)
							offset = met.Instructions.First ().Offset;
						else
							offset = met.Instructions.Last ().Offset;
					}

					CorDebugFunction func = doc.Assembly.GetFunctionFromTokenCLR (met.MethodToken.ToUInt32 ());
					CorDebugFunctionBreakpoint corBp = func.ILCode.CreateBreakpoint ((uint)offset);
					corBp.Active = bp.Enabled;

					binfo.Handle = corBp;
					binfo.SetStatus (BreakEventStatus.Bound, null);
					return binfo;
				}
			}

//			var cp = breakEvent as Catchpoint;
//			if (cp != null) {
//				foreach (ModuleInfo mod in modules.Values) {
//					CorMetadataImport mi = mod.Importer;
//					if (mi != null) {
//						foreach (Type t in mi.DefinedTypes)
//							if (t.FullName == cp.ExceptionName) {
//								binfo.SetStatus (BreakEventStatus.Bound, null);
//								return binfo;
//							}
//					}
//				}
//			}

			binfo.SetStatus (BreakEventStatus.Invalid, null);
			return binfo;
		}

        protected override BreakEventInfo OnInsertBreakEvent(BreakEvent be)
        {
            Breakpoint bp = be as Breakpoint;
            if (bp == null)
                throw new NotSupportedException();

            BreakEventInfo breakEventInfo = new BreakEventInfo();

            if (bp.HitCount > 0)
            {
                breakpointsWithHitCount.Add(breakEventInfo);
            }

            ulong address = this.SymbolResolver.GetAddressFromCodeLine(bp.FileName, (ushort)bp.Line);
            if (address != 0)
            {
                breakpointcounter++;
                debuggee.SetBreakPoint(address);
                breakpoints[address] = new BreakPointWrapper(breakpointcounter, breakEventInfo);
                breakEventInfo.Handle = address;
                breakEventInfo.SetStatus(BreakEventStatus.Bound, null);
            }
            else
            {
                breakEventInfo.SetStatus(BreakEventStatus.BindError, null);
            }

            return breakEventInfo;

        }

        void FireBreakPoint(ulong address)
        {
            TargetEventArgs args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint);

            ulong tempAddress = address;
            if (breakpoints.ContainsKey(tempAddress))
            {
                //breakpoints[(ulong)tempoff].EventInfo.UpdateHitCount((int)breakpoints[(ulong)tempoff].Breakpoint.HitCount);
                args.BreakEvent = breakpoints[tempAddress].EventInfo.BreakEvent;
            }
            else
            {
                args = new TargetEventArgs(TargetEventType.TargetStopped);
                BreakEventInfo breakInfo = new BreakEventInfo();
                breakInfo.Handle = tempAddress;
                breakInfo.SetStatus(BreakEventStatus.Bound, null);
                string filename;
                uint line;
                if (this.SymbolResolver.GetCodeLineFromAddress(address, out filename, out line))
                {
                    args.BreakEvent = breakInfo.BreakEvent;                    
                }
            }

            ProcessInfo process = OnGetProcesses()[0];
            args.Process = new ProcessInfo(process.Id, process.Name);
            args.Backtrace = new Backtrace(new DDebugBacktrace(this, activeThread, this.debuggee));//, Engine));
            args.Thread = GetThread(activeThread);

            ThreadPool.QueueUserWorkItem(delegate(object data)
            {
                try
                {
                    OnTargetEvent((TargetEventArgs)data);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
            }, args);
        }

        protected override BreakEventInfo OnInsertBreakEvent(BreakEvent be)
        {
            Breakpoint bp = be as Breakpoint;
            if (bp == null)
                throw new NotSupportedException ();

            BreakEventInfo bi = new BreakEventInfo ();

            lock (nodeLock) {
                bool dres = InternalStop ();
                try {
                    string handle;
                    try {
                        if (bp is FunctionBreakpoint) {
                            var bf = (FunctionBreakpoint) bp;
                            handle = "function " + bf.FunctionName;
                            var ret = debugger.SetBreakpoint ("function", bf.FunctionName, be.Enabled, -1, -1, bp.ConditionExpression, bp.HitCount);
                        } else {
                            handle = string.Format ("{0} ({1},1)", bp.FileName, bp.Line);
                            var ret = debugger.SetBreakpoint ("script", bp.FileName, be.Enabled, bp.Line, 1, bp.ConditionExpression, bp.HitCount);
                        }
                    } catch (Exception ex) {
                        bi.SetStatus (BreakEventStatus.Invalid, ex.Message);
                        return bi;
                    }
                    bi.Handle = handle;
                    bi.SetStatus (BreakEventStatus.Bound, null);
                    return bi;
                } finally {
                    InternalResume (dres);
                }
            }
        }