示例#1
0
        internal void BreakpointHit(MonoPendingBreakpoint breakpoint, MonoThread thread)
        {
            var iid = new Guid(BreakPointHitEvent.IID);

            _callback.Event(_engine, _engine.RemoteProcess, _engine, thread, new BreakPointHitEvent(breakpoint), ref iid,
                            StoppingEvent.Attributes);
        }
示例#2
0
        internal void StepCompleted(MonoThread thread)
        {
            var iid = new Guid(StepCompleteEvent.IID);

            _callback.Event(_engine, _engine.RemoteProcess, _engine, thread, new StepCompleteEvent(), ref iid,
                            StoppingEvent.Attributes);
        }
示例#3
0
        public MonoStackFrame(MonoThread thread, DebuggedMonoProcess debuggedMonoProcess, StackFrame frame)
        {
            this.thread = thread;
            this.debuggedMonoProcess = debuggedMonoProcess;
            this.frame = frame;

            docContext = new MonoDocumentContext(this.frame.FileName,
                                                 this.frame.LineNumber,
                                                 this.frame.ColumnNumber);
            var locals = frame.GetVisibleVariables().ToList();

            this.locals = locals.Select(x => new MonoProperty(frame, x)).ToList();
        }
示例#4
0
        public MonoStackFrame(MonoThread thread, DebuggedMonoProcess debuggedMonoProcess, StackFrame frame)
        {
            this.thread = thread;
            this.debuggedMonoProcess = debuggedMonoProcess;
            this.frame = frame;

            docContext = new MonoDocumentContext(this.frame.FileName,
                this.frame.LineNumber,
                this.frame.ColumnNumber);
            var locals = frame.GetVisibleVariables().ToList();

            this.locals = locals.Select(x => new MonoProperty(frame, x)).ToList();
        }
 internal void Execute(MonoThread debuggedMonoThread)
 {
     _vm.Resume();
 }
        internal void Step(MonoThread thread, enum_STEPKIND sk)
        {
            if (isStepping)
                return;

            if (currentStepRequest == null)
                currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror);
            else
            {
                currentStepRequest.Disable();
            }

            isStepping = true;
            switch (sk)
            {
                case enum_STEPKIND.STEP_INTO:
                    currentStepRequest.Depth = StepDepth.Into;
                    break;
                case enum_STEPKIND.STEP_OUT:
                    currentStepRequest.Depth = StepDepth.Out;
                    break;
                case enum_STEPKIND.STEP_OVER:
                    currentStepRequest.Depth = StepDepth.Over;
                    break;
                default:
                    return;
            }

            currentStepRequest.Size = StepSize.Line;
            currentStepRequest.Enable();
            _vm.Resume();
        }
        internal void StartDebugging()
        {
            if (_vm != null)
                return;

            _vm = VirtualMachineManager.Connect(new IPEndPoint(_ipAddress, 11000));
            _vm.EnableEvents(EventType.AssemblyLoad,
                EventType.ThreadStart,
                EventType.ThreadDeath,
                EventType.AssemblyUnload,
                EventType.UserBreak,
                EventType.Exception,
                EventType.UserLog,
                EventType.KeepAlive,
                EventType.TypeLoad);

            EventSet set = _vm.GetNextEventSet();
            if (set.Events.OfType<VMStartEvent>().Any())
            {
                _mainThread = new MonoThread(this, _engine, set.Events[0].Thread);
                _engine.Events.ThreadStarted(_mainThread);

                Task.Factory.StartNew(ReceiveThread, TaskCreationOptions.LongRunning);
            }
            else
                throw new Exception("Didnt get VMStart-Event!");
        }
 internal void ThreadStarted(MonoThread thread)
 {
     var iid = new Guid(ThreadCreateEvent.IID);
     _callback.Event(_engine, _engine.RemoteProcess, _engine, thread, new ThreadCreateEvent(), ref iid,
         StoppingEvent.Attributes);
 }
 internal void BreakpointHit(MonoPendingBreakpoint breakpoint, MonoThread thread)
 {
     var iid = new Guid(BreakPointHitEvent.IID);
     _callback.Event(_engine, _engine.RemoteProcess, _engine, thread, new BreakPointHitEvent(breakpoint), ref iid,
         StoppingEvent.Attributes);
 }