// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { AutoResetEvent completion = new AutoResetEvent(false); PythonEvaluationResult result = null; TaskHelpers.RunSynchronouslyOnUIThread(ct => _frame.StackFrame.ExecuteTextAsync(_expression, (obj) => { result = obj; completion.Set(); }, ct)); while (!_frame.StackFrame.Thread.Process.HasExited && !completion.WaitOne(Math.Min((int)dwTimeout, 100))) { if (dwTimeout <= 100) { break; } dwTimeout -= 100; } if (_frame.StackFrame.Thread.Process.HasExited || result == null) { ppResult = null; return(VSConstants.E_FAIL); } else if (result == null) { ppResult = null; return(DebuggerConstants.E_EVALUATE_TIMEOUT); } ppResult = new AD7Property(_frame, result, _writable); return(VSConstants.S_OK); }
int IDebugExpression2.EvaluateAsync( enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { // For now, no async evaluation supported. return(VSConstants.E_NOTIMPL); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public int EvaluateSync(enum_EVALFLAGS evaluateFlags, uint timeout, IDebugEventCallback2 eventCallback, out IDebugProperty2 result) { // // Evaluate the expression synchronously. // LoggingUtils.PrintFunction(); try { CLangDebuggeeStackFrame stackFrame = m_stackFrame as CLangDebuggeeStackFrame; result = stackFrame.EvaluateCustomExpression(evaluateFlags, m_expression, m_radix); if (result == null) { return(Constants.E_FAIL); } return(Constants.S_OK); } catch (Exception e) { LoggingUtils.HandleException(e); result = null; return(Constants.E_FAIL); } }
int IDebugExpression2.EvaluateAsync( enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { // For now, no async evaluation supported. return VSConstants.E_NOTIMPL; }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { _tokenSource = new CancellationTokenSource(); _frame.StackFrame.ExecuteTextAsync(_expression, _tokenSource.Token) .ContinueWith(p => { try { IDebugProperty2 property; if (p.Exception != null && p.Exception.InnerException != null) { property = new AD7EvalErrorProperty(p.Exception.InnerException.Message); } else if (p.IsCanceled) { property = new AD7EvalErrorProperty("Evaluation canceled"); } else if (p.IsFaulted || p.Result == null) { property = new AD7EvalErrorProperty("Error"); } else { property = new AD7Property(_frame, p.Result); } _tokenSource.Token.ThrowIfCancellationRequested(); _frame.Engine.Send( new AD7ExpressionEvaluationCompleteEvent(this, property), AD7ExpressionEvaluationCompleteEvent.IID, _frame.Engine, _frame.Thread); } finally { _tokenSource.Dispose(); _tokenSource = null; } }, _tokenSource.Token); return VSConstants.S_OK; }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { if (pExprCallback == null) { return(VisualStudioExtensionConstants.S_FALSE); } if (_asyncEval == null || _asyncEval.ThreadState != System.Threading.ThreadState.Running) { _asyncEval = new System.Threading.Thread(() => { uint attributes; Guid riidEvent = new Guid(XamarinExpressionEvaluationCompleteEvent.IID); IDebugExpressionEvaluationCompleteEvent2 evnt = new XamarinExpressionEvaluationCompleteEvent(this, new XamarinProperty(_var)); IDebugEvent2 eventObject = evnt as IDebugEvent2; if (eventObject.GetAttributes(out attributes) != VisualStudioExtensionConstants.S_OK) { throw new InvalidOperationException("Failed to create and register a thread. The event object failed to get its attributes"); } if (pExprCallback.Event(_engine.MonoEngine, null, _engine.ActiveProgram, _thread, eventObject, ref riidEvent, attributes) != VisualStudioExtensionConstants.S_OK) { throw new InvalidOperationException("Failed to create and register a thread. The event has not been sent succesfully"); } }); _asyncEval.Start(); return(VisualStudioExtensionConstants.S_OK); } return(VisualStudioExtensionConstants.S_FALSE); }
public override async Task<Results> VarCreate(string expression, int threadId, uint frameLevel, enum_EVALFLAGS dwFlags, ResultClass resultClass = ResultClass.done) { string command = string.Format("-var-create - - \"{0}\"", expression); // use '-' to indicate that "--frame" should be used to determine the frame number Results results = await ThreadFrameCmdAsync(command, resultClass, threadId, frameLevel); return results; }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { AutoResetEvent completion = new AutoResetEvent(false); PythonEvaluationResult result = null; _frame.StackFrame.ExecuteText(_expression, (obj) => { result = obj; completion.Set(); }); while (!_frame.StackFrame.Thread.Process.HasExited && !completion.WaitOne(Math.Min((int)dwTimeout, 100))) { if (dwTimeout <= 100) { break; } dwTimeout -= 100; } if (_frame.StackFrame.Thread.Process.HasExited || result == null) { ppResult = null; return VSConstants.E_FAIL; } else if (result == null) { ppResult = null; return DebuggerConstants.E_EVALUATE_TIMEOUT; } ppResult = new AD7Property(_frame, result, _writable); return VSConstants.S_OK; }
int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { var res = TaskExtensions.RunSynchronouslyOnUIThread(ct => StackFrame.StackFrame.EvaluateAsync(_expression, AD7Property.PrefetchedFields, AD7Property.ReprMaxLength, ct)); ppResult = new AD7Property(StackFrame, res); return(VSConstants.S_OK); }
// Token: 0x06000201 RID: 513 RVA: 0x00006FC0 File Offset: 0x000051C0 int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { EvaluationOptions defaultOptions = StackFrame.DefaultOptions; defaultOptions.EvaluationTimeout = (int)dwTimeout; defaultOptions.MemberEvaluationTimeout = (int)dwTimeout; defaultOptions.EllipsizeStrings = false; defaultOptions.IntegerDisplayFormat = this.Frame.Session.EvaluationOptions.IntegerDisplayFormat; if ((dwFlags & enum_EVALFLAGS.EVAL_NOFUNCEVAL) != 0) { defaultOptions.AllowMethodEvaluation = false; defaultOptions.AllowTargetInvoke = false; } ObjectValue expressionValue = this.Frame.Frame.GetExpressionValue(this.Text, defaultOptions); if (expressionValue == null) { ppResult = null; return(1); } if (!expressionValue.WaitHandle.WaitOne((int)dwTimeout)) { ppResult = null; return(-2147221455); } if (expressionValue.IsError) { ppResult = null; return(1); } expressionValue.Name = this.Text; ppResult = new StackFrame.Property(this.Frame, expressionValue); return(0); }
public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { if (property != null) { ppResult = property; return(Constants.S_OK); } else { property = frame.Engine.DebuggedProcess.Resolve(frame, exp, dwTimeout) as ILProperty; ppResult = property; if (property != null) { if (string.IsNullOrEmpty(property.Name)) { property.Name = oriExp; } return(Constants.S_OK); } else { return(Constants.E_FAIL); } } }
public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { Log.Debug("EvaluateSync"); ppResult = ScriptPropertyFactory.MakeProperty(_debugger, _var, string.Empty); // no parent path return(VSConstants.S_OK); }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { //bool hex = SquirrelDebuggerEngine.SquirrelDebuggerEnginePackage.HexDisplayMode; ppResult = new AD7Property(var); return(EngineConstants.S_OK); }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { var timeout = TimeSpan.FromMilliseconds(dwTimeout); var tokenSource = new CancellationTokenSource(timeout); ppResult = null; NodeEvaluationResult result; try { result = this._frame.StackFrame.ExecuteTextAsync(this._expression, tokenSource.Token).WaitAsync(timeout, tokenSource.Token).WaitAndUnwrapExceptions(); } catch (DebuggerCommandException ex) { ppResult = new AD7EvalErrorProperty(ex.Message); return(VSConstants.S_OK); } catch (OperationCanceledException) { return(DebuggerConstants.E_EVALUATE_TIMEOUT); } if (result == null) { return(VSConstants.E_FAIL); } ppResult = new AD7Property(this._frame, result); return(VSConstants.S_OK); }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback // // This is primarily used for the immediate window which this engine does not currently support. int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { Thread m_processingThread; m_processingThread = new Thread(evaluatingAsync); m_processingThread.Start(); return VSConstants.S_OK; }
/// <summary> /// This method evaluates the expression synchronously. (http://msdn.microsoft.com/en-ca/library/bb146982.aspx) /// </summary> /// <param name="dwFlags"> A combination of flags from the EVALFLAGS enumeration that control expression evaluation. </param> /// <param name="dwTimeout"> Maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait /// indefinitely. </param> /// <param name="pExprCallback"> This parameter is always a null value. </param> /// <param name="ppResult"> Returns the IDebugProperty2 object that contains the result of the expression evaluation. </param> /// <returns> VSConstants.S_OK. </returns> int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { VariableInfo vi = VariableInfo.get(exp, m_eventDispatcher, m_frame); ppResult = new AD7Property(vi); m_frame._lastEvaluatedExpression = vi; return(VSConstants.S_OK); }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; int idx = _index; if (string.IsNullOrEmpty(_castExpr)) { var reg = _stackFrame.GetRegistersAsync().Await((int) dwTimeout) .FirstOrDefault(r => r.Name == _registerType + _index); if (reg != null) { ppResult = new DebugStackFrameValueProperty(reg, null, _stackFrame); return VSConstants.S_OK; } } else { var tag = GetTagFromString(_castExpr); if (!tag.IsPrimitive() && (dwFlags & enum_EVALFLAGS.EVAL_NOSIDEEFFECTS) != 0) { // this evaluation has "side effects" in that it might crash the VM // if the cast is to "object" or "string", but the register does not // hold an object or string. ppResult = new DebugConstProperty(_expression, "(this cast might crash the VM if the register is not of the casted type)", _castExpr, null) { HasSideEffects = true }; return VSConstants.E_FAIL; } var isParam = _registerType == "p"; if (isParam) { var loc = _stackFrame.GetDocumentLocationAsync().Await((int) dwTimeout); if (loc == null) return VSConstants.E_FAIL; var methodDiss = _stackFrame.Thread.Program.DisassemblyProvider.GetFromLocation(loc); if (methodDiss == null) return VSConstants.E_FAIL; idx += methodDiss.Method.Body.Registers.Count - methodDiss.Method.Body.IncomingArguments; } var reg = _stackFrame.GetRegistersAsync(false, tag, idx).Await((int) dwTimeout); if (reg != null && reg.Count > 0) { ppResult = new DebugStackFrameValueProperty(reg[0], null, _stackFrame, _expression) { HasSideEffects = !tag.IsPrimitive() }; return VSConstants.S_OK; } } return VSConstants.E_FAIL; }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> /// <param name="dwFlags">A combination of flags from the EVALFLAGS enumeration that control expression evaluation.</param> /// <param name="dwTimeout">Maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait indefinitely.</param> /// <param name="pExprCallback">This parameter is always a null value.</param> /// <param name="ppResult">Returns the IDebugProperty2 object that contains the result of the expression evaluation.</param> /// <returns> /// If successful, returns S_OK; otherwise returns an error code. Some typical error codes are: /// Error Description /// E_EVALUATE_BUSY_WITH_EVALUATION Another expression is currently being evaluated, and simultaneous expression evaluation is not supported. /// E_EVALUATE_TIMEOUT Evaluation timed out. /// </returns> /// <remarks>For synchronous evaluation, it is not necessary to send an event back to Visual Studio upon completion of the evaluation.</remarks> public int EvaluateSync( enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { Logger.Debug( string.Empty ); ppResult = null; return VSConstants.E_NOTIMPL; }
public int EvaluateSync(enum_EVALFLAGS flags, uint timeout, IDebugEventCallback2 callback, out IDebugProperty2 result) { EvaluationResult evalResult = taskExecutor .Run(async() => await asyncEvaluator.EvaluateExpressionAsync()); result = evalResult.Result; return(evalResult.Status); }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> /// <param name="dwFlags">A combination of flags from the EVALFLAGS enumeration that control expression evaluation.</param> /// <param name="dwTimeout">Maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait indefinitely.</param> /// <param name="pExprCallback">This parameter is always a null value.</param> /// <param name="ppResult">Returns the IDebugProperty2 object that contains the result of the expression evaluation.</param> /// <returns> /// If successful, returns S_OK; otherwise returns an error code. Some typical error codes are: /// Error Description /// E_EVALUATE_BUSY_WITH_EVALUATION Another expression is currently being evaluated, and simultaneous expression evaluation is not supported. /// E_EVALUATE_TIMEOUT Evaluation timed out. /// </returns> /// <remarks>For synchronous evaluation, it is not necessary to send an event back to Visual Studio upon completion of the evaluation.</remarks> public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { Logger.Debug(string.Empty); ppResult = null; return(VSConstants.E_NOTIMPL); }
public void SyncEval(enum_EVALFLAGS dwFlags = 0) { Task eval = Task.Run(async() => { await Eval(dwFlags); }); eval.Wait(); }
public int EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { // don't use pExprCallback! IDebugEventCallback2 callback = _context.StackFrame.Thread.Program.Callback; Task<IDebugProperty2> evaluateTask = Task.Factory.StartNew(() => EvaluateImpl(dwFlags)).HandleNonCriticalExceptions(); Task successCompletionTask = evaluateTask.ContinueWith(task => SendEvaluationCompleteEvent(task, callback), TaskContinuationOptions.OnlyOnRanToCompletion).HandleNonCriticalExceptions(); Task failureCompletionTask = evaluateTask.ContinueWith(task => SendEvaluationCompleteEvent(null, callback), TaskContinuationOptions.NotOnRanToCompletion).HandleNonCriticalExceptions(); return VSConstants.S_OK; }
/// <summary> /// This method evaluates the expression asynchronously. /// This is primarily used for the immediate window. (http://msdn.microsoft.com/en-ca/library/bb146752.aspx) /// </summary> /// <param name="dwFlags"> A combination of flags from the EVALFLAGS enumeration that control expression evaluation. </param> /// <param name="pExprCallback"> This parameter is always a null value. </param> /// <returns> VSConstants.S_OK. </returns> int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { // Creating a thread to evaluate the expression asynchronously. Thread m_processingThread; m_processingThread = new Thread(evaluatingAsync); m_processingThread.Start(); return(VSConstants.S_OK); }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback // // This is primarily used for the immediate window which this engine does not currently support. int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { _frame.StackFrame.ExecuteText(_expression, (obj) => { _frame.Engine.Send( new AD7ExpressionEvaluationCompleteEvent(this, new AD7Property(_frame, obj, _writable)), AD7ExpressionEvaluationCompleteEvent.IID, _frame.Engine, _frame.Thread); }); return VSConstants.S_OK; }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback // // This is primarily used for the immediate window which this engine does not currently support. int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { TaskHelpers.RunSynchronouslyOnUIThread(ct => _frame.StackFrame.ExecuteTextAsync(_expression, (obj) => { _frame.Engine.Send( new AD7ExpressionEvaluationCompleteEvent(this, new AD7Property(_frame, obj, _writable)), AD7ExpressionEvaluationCompleteEvent.IID, _frame.Engine, _frame.Thread); }, ct)); return(VSConstants.S_OK); }
public int EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { // don't use pExprCallback! IDebugEventCallback2 callback = _context.StackFrame.Thread.Program.Callback; Task <IDebugProperty2> evaluateTask = Task.Factory.StartNew(() => EvaluateImpl(dwFlags)).HandleNonCriticalExceptions(); Task successCompletionTask = evaluateTask.ContinueWith(task => SendEvaluationCompleteEvent(task, callback), TaskContinuationOptions.OnlyOnRanToCompletion).HandleNonCriticalExceptions(); Task failureCompletionTask = evaluateTask.ContinueWith(task => SendEvaluationCompleteEvent(null, callback), TaskContinuationOptions.NotOnRanToCompletion).HandleNonCriticalExceptions(); return(VSConstants.S_OK); }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; if (string.IsNullOrEmpty(_castExpr)) { var reg = _stackFrame.GetRegistersAsync().Await((int)dwTimeout) .FirstOrDefault(r => r.Name == _registerType + _index); if (reg != null) { ppResult = new DebugStackFrameValueProperty(reg, null, _stackFrame); return(VSConstants.S_OK); } } else { var tag = GetTagFromString(_castExpr); if (!tag.IsPrimitive() && (dwFlags & enum_EVALFLAGS.EVAL_NOSIDEEFFECTS) != 0) { // this evaluation has "side effects" in that it might crash the VM // if the cast is to "object" or "string", but the register does not // hold an object or string. ppResult = new DebugConstProperty(_expression, "(this cast might crash a DalvikVM if the register is not of the casted type)", _castExpr, null) { HasSideEffects = true }; return(VSConstants.E_FAIL); } var regNames = _stackFrame.GetRegisterNamesAsync().Await((int)dwTimeout); var vmIdx = regNames.GetVmIndex(_registerType == "p", _index); if (vmIdx < 0) { return(VSConstants.E_FAIL); } var reg = _stackFrame.GetRegistersAsync(false, tag, vmIdx).Await((int)dwTimeout); if (reg != null && reg.Count > 0) { ppResult = new DebugStackFrameValueProperty(reg[0], null, _stackFrame, _expression) { HasSideEffects = !tag.IsPrimitive() }; return(VSConstants.S_OK); } } return(VSConstants.E_FAIL); }
// Token: 0x060001FF RID: 511 RVA: 0x00006F1C File Offset: 0x0000511C int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { EvaluationOptions defaultOptions = StackFrame.DefaultOptions; defaultOptions.EvaluationTimeout = -1; defaultOptions.MemberEvaluationTimeout = -1; defaultOptions.EllipsizeStrings = false; defaultOptions.IntegerDisplayFormat = this.Frame.Session.EvaluationOptions.IntegerDisplayFormat; ObjectValue value = this.Frame.Frame.GetExpressionValue(this.Text, defaultOptions); value.ValueChanged += (o, e) => SendResult(new StackFrame.Property(this.Frame, value)); return(0); }
public int EvaluateAsync(enum_EVALFLAGS flags, IDebugEventCallback2 callback) { Func <Task> evaluationTask = () => taskExecutor.SubmitAsync(async() => { EvaluationResult evalResult = await asyncEvaluator.EvaluateExpressionAsync(); debugEngineHandler.OnEvaluationComplete(Self, evalResult.Result, program, thread); }, CancellationToken.None, nameof(EvaluateAsync), typeof(DebugExpression)); SafeErrorUtil.SafelyLogErrorAndForget(evaluationTask, "EvaluateAsync: error evaluating expression asynchronously"); return(VSConstants.S_OK); }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> /// <param name="dwFlags">[in] A combination of flags from the EVALFLAGS enumeration that control expression evaluation.</param> /// <param name="dwTimeout">[in] Maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait indefinitely.</param> /// <param name="pExprCallback">[in]This parameter is always a null value.</param> /// <param name="ppResult">[out] Returns the IDebugProperty2 object that contains the result of the expression evaluation.</param> /// <returns> /// If successful, returns S_OK; otherwise returns an error code. Some typical error codes are: /// * E_EVALUATE_BUSY_WITH_EVALUATION Another expression is currently being evaluated, and simultaneous /// expression evaluation is not supported. /// * E_EVALUATE_TIMEOUT Evaluation timed out. /// </returns> /// <remarks> /// For synchronous evaluation, it is not necessary to send an event back to Visual Studio upon completion of the evaluation. /// </remarks> public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; Task<IDebugProperty2> task = Task.Factory.StartNew(() => EvaluateImpl(dwFlags)).HandleNonCriticalExceptions(); if (!task.Wait((int)dwTimeout)) return AD7Constants.E_EVALUATE_TIMEOUT; if (task.Status != TaskStatus.RanToCompletion || task.Result == null) return VSConstants.E_FAIL; ppResult = task.Result; return VSConstants.S_OK; }
public int EvaluateAsync(enum_EVALFLAGS flags, IDebugEventCallback2 callback) { cancellationToken = new CancellationTokenSource(); Task.Run( () => { IDebugProperty2 result; EvaluateSync(flags, uint.MaxValue, callback, out result); callback = new MonoCallbackWrapper(callback ?? engine.Callback); callback.Send(engine, new MonoExpressionCompleteEvent(engine, thread, value, Expression), MonoExpressionCompleteEvent.IID, thread); }, cancellationToken.Token); return(VSConstants.S_OK); }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; if (string.IsNullOrEmpty(_castExpr)) { var reg = _stackFrame.GetRegistersAsync().Await((int) dwTimeout) .FirstOrDefault(r => r.Name == _registerType + _index); if (reg != null) { ppResult = new DebugStackFrameValueProperty(reg, null, _stackFrame); return VSConstants.S_OK; } } else { var tag = GetTagFromString(_castExpr); if (!tag.IsPrimitive() && (dwFlags & enum_EVALFLAGS.EVAL_NOSIDEEFFECTS) != 0) { // this evaluation has "side effects" in that it might crash the VM // if the cast is to "object" or "string", but the register does not // hold an object or string. ppResult = new DebugConstProperty(_expression, "(this cast might crash a DalvikVM if the register is not of the casted type)", _castExpr, null) { HasSideEffects = true }; return VSConstants.E_FAIL; } var regNames = _stackFrame.GetRegisterNamesAsync().Await((int)dwTimeout); var vmIdx = regNames.GetVmIndex(_registerType == "p", _index); if (vmIdx < 0) return VSConstants.E_FAIL; var reg = _stackFrame.GetRegistersAsync(false, tag, vmIdx).Await((int)dwTimeout); if (reg != null && reg.Count > 0) { ppResult = new DebugStackFrameValueProperty(reg[0], null, _stackFrame, _expression) { HasSideEffects = !tag.IsPrimitive() }; return VSConstants.S_OK; } } return VSConstants.E_FAIL; }
public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { if (property != null || resolved) { ppResult = property; return(Constants.S_OK); } else { DoResolve(); ppResult = property; return(Constants.S_OK); } }
int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { _cts = new CancellationTokenSource(); Task.Run(async () => { try { var res = await StackFrame.StackFrame.EvaluateAsync(_expression, reprMaxLength: AD7Property.ReprMaxLength); _cts.Token.ThrowIfCancellationRequested(); var prop = new AD7Property(StackFrame, res); StackFrame.Engine.Send(new AD7ExpressionEvaluationCompleteEvent(this, prop), AD7ExpressionEvaluationCompleteEvent.IID); } catch (Exception ex) when (!ex.IsCriticalException()) { StackFrame.Engine.Send(new AD7ExpressionEvaluationCompleteEvent(ex), AD7ExpressionEvaluationCompleteEvent.IID); } finally { _cts = null; } }); return VSConstants.S_OK; }
public async Task Eval(enum_EVALFLAGS dwFlags = (enum_EVALFLAGS)0) { var variable = _engine.DebuggedProcess.ThreadCache.GetVariable(Client.Id, Name); var val = String.Empty; if (variable != null && !variable.Value.Contains("roAssociativeArray")) { val = variable.Value; } else { val = await _engine.DebuggedProcess.CommandFactory.Print(FullName()); } foreach (var node in mapper) { if (val.StartsWith(node.Key)) { VariableNodeType = node.Value; val = val.Replace(node.Key, "").Trim(); } } Value = val; switch (VariableNodeType) { case NodeType.Field: var parts = val.Split(new char[] { '\n', '\r' }); foreach (var part in parts) { if (part.Contains(":")) { var vals = part.Split(':'); Children.Add(new VariableInformation(vals[0].Trim(), this)); } } break; default: break; } }
int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { _cts = new CancellationTokenSource(); Task.Run(async() => { try { var res = await StackFrame.StackFrame.EvaluateAsync(_expression, AD7Property.PrefetchedFields, AD7Property.ReprMaxLength); _cts.Token.ThrowIfCancellationRequested(); var prop = new AD7Property(StackFrame, res); StackFrame.Engine.Send(new AD7ExpressionEvaluationCompleteEvent(this, prop), AD7ExpressionEvaluationCompleteEvent.IID); } catch (Exception ex) when(!ex.IsCriticalException()) { StackFrame.Engine.Send(new AD7ExpressionEvaluationCompleteEvent(ex), AD7ExpressionEvaluationCompleteEvent.IID); } finally { _cts = null; } }); return(VSConstants.S_OK); }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { this._tokenSource = new CancellationTokenSource(); this._frame.StackFrame.ExecuteTextAsync(this._expression, this._tokenSource.Token) .ContinueWith(p => { try { IDebugProperty2 property; if (p.Exception != null && p.Exception.InnerException != null) { property = new AD7EvalErrorProperty(p.Exception.InnerException.Message); } else if (p.IsCanceled) { property = new AD7EvalErrorProperty("Evaluation canceled"); } else if (p.IsFaulted || p.Result == null) { property = new AD7EvalErrorProperty("Error"); } else { property = new AD7Property(this._frame, p.Result); } this._tokenSource.Token.ThrowIfCancellationRequested(); this._frame.Engine.Send( new AD7ExpressionEvaluationCompleteEvent(this, property), AD7ExpressionEvaluationCompleteEvent.IID, this._frame.Engine, this._frame.Thread); } finally { this._tokenSource.Dispose(); this._tokenSource = null; } }, this._tokenSource.Token); return(VSConstants.S_OK); }
int IDebugExpression2.EvaluateAsync( enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { _ = Task.Run(() => { var value = Debugger.Evaluate(StackFrame.FrameNumber, ExpressionString); if (value != null) { value.Name = ExpressionString; } Program.Refresh(); DebugEvent.Send(new ExpressionEvaluationCompleteEvent( pExprCallback, this, Property.Create(StackFrame, 0, value))); }); return(VSConstants.S_OK); }
/// <summary> /// This method evaluates the expression synchronously. /// </summary> /// <param name="dwFlags">[in] A combination of flags from the EVALFLAGS enumeration that control expression evaluation.</param> /// <param name="dwTimeout">[in] Maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait indefinitely.</param> /// <param name="pExprCallback">[in]This parameter is always a null value.</param> /// <param name="ppResult">[out] Returns the IDebugProperty2 object that contains the result of the expression evaluation.</param> /// <returns> /// If successful, returns S_OK; otherwise returns an error code. Some typical error codes are: /// * E_EVALUATE_BUSY_WITH_EVALUATION Another expression is currently being evaluated, and simultaneous /// expression evaluation is not supported. /// * E_EVALUATE_TIMEOUT Evaluation timed out. /// </returns> /// <remarks> /// For synchronous evaluation, it is not necessary to send an event back to Visual Studio upon completion of the evaluation. /// </remarks> public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; Task <IDebugProperty2> task = Task.Factory.StartNew(() => EvaluateImpl(dwFlags)).HandleNonCriticalExceptions(); if (!task.Wait((int)dwTimeout)) { return(AD7Constants.E_EVALUATE_TIMEOUT); } if (task.Status != TaskStatus.RanToCompletion || task.Result == null) { return(VSConstants.E_FAIL); } ppResult = task.Result; return(VSConstants.S_OK); }
int IDebugExpression2.EvaluateSync( enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; var value = Debugger.Evaluate(StackFrame.FrameNumber, ExpressionString); if (value == null || value is JsError) { return(VSConstants.S_FALSE); } Program.Refresh(); value.Name = ExpressionString; ppResult = Property.Create(StackFrame, 0, value); return(VSConstants.S_OK); }
public void GetAndCheckChildValue(string caller_trace, string ExpectedResult, string variable, int childIndex, bool setEvalFlags, enum_EVALFLAGS evalFlags) { var res = MIDebugger.Request("-var-create - * " + "\"" + variable + "\"" + (setEvalFlags ? (" --evalFlags " + (int)evalFlags) : "")); Assert.Equal(MIResultClass.Done, res.Class, @"__FILE__:__LINE__" + "\n" + caller_trace); string struct2 = ((MIConst)res["name"]).CString; res = MIDebugger.Request("-var-list-children --simple-values " + "\"" + struct2 + "\""); Assert.Equal(MIResultClass.Done, res.Class, @"__FILE__:__LINE__" + "\n" + caller_trace); var children = (MIList)res["children"]; var child = (MITuple)((MIResult)children[childIndex]).Value; Assert.Equal(ExpectedResult, ((MIConst)child["value"]).CString, @"__FILE__:__LINE__" + "\n" + caller_trace); }
int IDebugExpression2.EvaluateSync( enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { if (MySql.Debugger.Debugger.GetTagHashCode(_stackFrame._rs.OwningRoutine.SourceCode) != DebuggerManager.Instance.Debugger.CurrentScope.OwningRoutine.Hash) { // This should never happen. ppResult = null; return VSConstants.E_NOTIMPL; } AD7Property prop = new AD7Property( _expr,_stackFrame.Node, _stackFrame._rs ); ppResult = prop; // Send evaluation complete event DebuggerManager.Instance._events.ExpressionEvalCompleted( _stackFrame.Node, ( IDebugExpression2 )this, ( IDebugProperty2 )prop ); return VSConstants.S_OK; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #region IDebugExpression2 Members //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public int EvaluateAsync (enum_EVALFLAGS evaluateFlags, IDebugEventCallback2 eventCallback) { // // Evaluate the expression asynchronously. // Method should return immediately after starting the expression evaluation, when completed successfully // a 'IDebugExpressionEvaluationCompleteEvent2' event should be sent to the provided IDebugEventCallback2 callback. // LoggingUtils.PrintFunction (); try { ThreadPool.QueueUserWorkItem (delegate (object state) { try { IDebugProperty2 result; IDebugThread2 thread; LoggingUtils.RequireOk (m_stackFrame.GetThread (out thread)); LoggingUtils.RequireOk (EvaluateSync (evaluateFlags, 0, eventCallback, out result)); m_debugEngine.Broadcast (eventCallback, new DebugEngineEvent.ExpressionEvaluationComplete (this, result), m_debugEngine.Program, thread); } catch (Exception e) { LoggingUtils.HandleException (e); } }); return Constants.S_OK; } catch (Exception e) { LoggingUtils.HandleException (e); return Constants.E_FAIL; } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #region IDebugExpression2 Members //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public int EvaluateAsync(enum_EVALFLAGS evaluateFlags, IDebugEventCallback2 eventCallback) { // // Evaluate the expression asynchronously. // Method should return immediately after starting the expression evaluation, when completed successfully // a 'IDebugExpressionEvaluationCompleteEvent2' event should be sent to the provided IDebugEventCallback2 callback. // LoggingUtils.PrintFunction(); try { ThreadPool.QueueUserWorkItem(delegate(object state) { try { IDebugProperty2 result; IDebugThread2 thread; LoggingUtils.RequireOk(m_stackFrame.GetThread(out thread)); LoggingUtils.RequireOk(EvaluateSync(evaluateFlags, 0, eventCallback, out result)); m_debugEngine.Broadcast(eventCallback, new DebugEngineEvent.ExpressionEvaluationComplete(this, result), m_debugEngine.Program, thread); } catch (Exception e) { LoggingUtils.HandleException(e); } }); return(Constants.S_OK); } catch (Exception e) { LoggingUtils.HandleException(e); return(Constants.E_FAIL); } }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = null; if ((dwFlags & enum_EVALFLAGS.EVAL_NOSIDEEFFECTS) != 0 && _var.IsVisualized) { IVariableInformation variable = DebuggedProcess.g_Process.Natvis.Cache.Lookup(_var); if (variable == null) { ppResult = new AD7ErrorProperty(_var.Name, ResourceStrings.NoSideEffectsVisualizerMessage); } else { _var = variable; ppResult = new AD7Property(_var); } return Constants.S_OK; } _var.SyncEval(); ppResult = new AD7Property(_var); return Constants.S_OK; }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { NodeEvaluationResult result; ppResult = null; try { result = _frame.StackFrame.EvaluateExpressionAsync(_expression).Result; } catch (Exception) { return VSConstants.E_FAIL; } if (result == null) { return VSConstants.E_FAIL; } ppResult = new AD7Property(result); return VSConstants.S_OK; }
private IDebugProperty2 EvaluateImpl(enum_EVALFLAGS flags) { ITreeNodeStream input = new CommonTreeNodeStream(_expression); DebugExpressionEvaluatorWalker walker = new DebugExpressionEvaluatorWalker(input, _context.StackFrame.StackFrame); EvaluatedExpression evaluatedExpression = walker.standaloneExpression(); // make sure the Name and FullName of the evaluated expression match what the user typed evaluatedExpression = new EvaluatedExpression( _expressionText, _expressionText, evaluatedExpression.LocalVariable, evaluatedExpression.Referencer, evaluatedExpression.Field, evaluatedExpression.Method, evaluatedExpression.Index, evaluatedExpression.Value, evaluatedExpression.ValueType, evaluatedExpression.StrongReference, evaluatedExpression.HasSideEffects); return new JavaDebugProperty(null, evaluatedExpression); }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback // // This is primarily used for the immediate window int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { if (((dwFlags & enum_EVALFLAGS.EVAL_NOSIDEEFFECTS) != 0 && (dwFlags & enum_EVALFLAGS.EVAL_ALLOWBPS) == 0) && _var.IsVisualized) { IVariableInformation variable = DebuggedProcess.g_Process.Natvis.Cache.Lookup(_var); if (variable == null) { _var.AsyncError(pExprCallback, new AD7ErrorProperty(_var.Name, ResourceStrings.NoSideEffectsVisualizerMessage)); } else { _var = variable; // use the old value Task.Run(() => { new EngineCallback(DebuggedProcess.g_Process.Engine, pExprCallback).OnExpressionEvaluationComplete(variable); }); } } else { _var.AsyncEval(pExprCallback); } return Constants.S_OK; }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { TimeSpan timeout = TimeSpan.FromMilliseconds(dwTimeout); var tokenSource = new CancellationTokenSource(timeout); ppResult = null; NodeEvaluationResult result; try { result = _frame.StackFrame.ExecuteTextAsync(_expression, tokenSource.Token).WaitAsync(timeout, tokenSource.Token).WaitAndUnwrapExceptions(); } catch (DebuggerCommandException ex) { ppResult = new AD7EvalErrorProperty(ex.Message); return VSConstants.S_OK; } catch (OperationCanceledException) { return DebuggerConstants.E_EVALUATE_TIMEOUT; } if (result == null) { return VSConstants.E_FAIL; } ppResult = new AD7Property(_frame, result); return VSConstants.S_OK; }
int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { var res = TaskExtensions.RunSynchronouslyOnUIThread(ct => StackFrame.StackFrame.TryEvaluateAndDescribeAsync(_expression, AD7Property.PrefetchedProperties, AD7Property.Repr, ct)); ppResult = new AD7Property(StackFrame, res); return VSConstants.S_OK; }
public virtual async Task<Results> VarCreate(string expression, int threadId, uint frameLevel, enum_EVALFLAGS dwFlags, ResultClass resultClass = ResultClass.done) { string quoteEscapedExpression = EscapeQuotes(expression); string command = string.Format("-var-create - * \"{0}\"", quoteEscapedExpression); Results results = await ThreadFrameCmdAsync(command, resultClass, threadId, frameLevel); return results; }
// This method evaluates the expression asynchronously. // This method should return immediately after it has started the expression evaluation. // When the expression is successfully evaluated, an IDebugExpressionEvaluationCompleteEvent2 // must be sent to the IDebugEventCallback2 event callback // // This is primarily used for the immediate window which this engine does not currently support. int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { throw new NotImplementedException(); }
int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { var res = TaskExtensions.RunSynchronouslyOnUIThread(ct => StackFrame.StackFrame.EvaluateAsync(_expression, reprMaxLength: AD7Property.ReprMaxLength, cancellationToken:ct)); ppResult = new AD7Property(StackFrame, res); return VSConstants.S_OK; }
/// <summary> /// This method evaluates the expression asynchronously. /// This is primarily used for the immediate window. (http://msdn.microsoft.com/en-ca/library/bb146752.aspx) /// </summary> /// <param name="dwFlags"> A combination of flags from the EVALFLAGS enumeration that control expression evaluation. </param> /// <param name="pExprCallback"> This parameter is always a null value. </param> /// <returns> VSConstants.S_OK. </returns> int IDebugExpression2.EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { // Creating a thread to evaluate the expression asynchronously. Thread m_processingThread; m_processingThread = new Thread(evaluatingAsync); m_processingThread.Start(); return VSConstants.S_OK; }
public int EvaluateAsync(enum_EVALFLAGS dwFlags, IDebugEventCallback2 pExprCallback) { return VSConstants.E_NOTIMPL; }
public int EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = _monoProperty; return VSConstants.S_OK; }
public override async Task<Results> VarCreate(string expression, int threadId, uint frameLevel, enum_EVALFLAGS dwFlags, ResultClass resultClass = ResultClass.done) { string command = string.Format("-var-create - * \"{0}\" --evalFlags {1}", expression, (uint)dwFlags); Results results = await ThreadFrameCmdAsync(command, resultClass, threadId, frameLevel); return results; }
public void SyncEval(enum_EVALFLAGS dwFlags) { Parent.SyncEval(dwFlags); }
// This method evaluates the expression synchronously. int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { ppResult = this; return Constants.S_OK; }
/// <summary> /// This method evaluates the expression synchronously. (http://msdn.microsoft.com/en-ca/library/bb146982.aspx) /// </summary> /// <param name="dwFlags"> A combination of flags from the EVALFLAGS enumeration that control expression evaluation. </param> /// <param name="dwTimeout"> Maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait /// indefinitely. </param> /// <param name="pExprCallback"> This parameter is always a null value. </param> /// <param name="ppResult"> Returns the IDebugProperty2 object that contains the result of the expression evaluation. </param> /// <returns> VSConstants.S_OK. </returns> int IDebugExpression2.EvaluateSync(enum_EVALFLAGS dwFlags, uint dwTimeout, IDebugEventCallback2 pExprCallback, out IDebugProperty2 ppResult) { VariableInfo vi = VariableInfo.get(exp, m_eventDispatcher, m_frame); ppResult = new AD7Property(vi); m_frame._lastEvaluatedExpression = vi; return VSConstants.S_OK; }