/// <summary>
        /// Parses an expression in text form for later evaluation.
        /// </summary>
        /// <param name="pszCode">The expression to be parsed.</param>
        /// <param name="dwFlags">A combination of flags from the PARSEFLAGS enumeration that controls parsing.</param>
        /// <param name="nRadix">The radix to be used in parsing any numerical information in pszCode.</param>
        /// <param name="ppExpr">Returns the IDebugExpression2 object that represents the parsed expression, which is ready for binding and evaluation.</param>
        /// <param name="pbstrError">Returns the error message if the expression contains an error.</param>
        /// <param name="pichError">Returns the character index of the error in pszCode if the expression contains an error.</param>
        /// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
        /// <remarks>
        /// When this method is called, a debug engine (DE) should parse the expression and validate it for correctness.
        /// The pbstrError and pichError parameters may be filled in if the expression is invalid.
        /// 
        /// Note that the expression is not evaluated, only parsed. A later call to the IDebugExpression2.EvaluateSync
        /// or IDebugExpression2.EvaluateAsync methods evaluates the parsed expression.
        /// </remarks>
        public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
        {
            if (pszCode == null)
                throw new ArgumentNullException("pszCode");
            if (pszCode.Length == 0)
                throw new ArgumentException();
            // dwFlags=0 in the Immediate window
            if (dwFlags != enum_PARSEFLAGS.PARSE_EXPRESSION && dwFlags != 0)
                throw new NotImplementedException();

            try
            {
                var expressionInput = new ANTLRStringStream(pszCode);
                var expressionUnicodeInput = new JavaUnicodeStream(expressionInput);
                var expressionLexer = new Java2Lexer(expressionUnicodeInput);
                var expressionTokens = new CommonTokenStream(expressionLexer);
                var expressionParser = new Java2Parser(expressionTokens);
                IAstRuleReturnScope<CommonTree> result = expressionParser.standaloneExpression();

                ppExpr = new JavaDebugExpression(this, result.Tree, pszCode);
                pbstrError = null;
                pichError = 0;
                return VSConstants.S_OK;
            }
            catch (RecognitionException e)
            {
                ppExpr = null;
                pbstrError = e.Message;
                pichError = (uint)Math.Max(0, e.Index);
                return VSConstants.E_FAIL;
            }
        }
Exemple #2
0
        public int GetExpression(out IDebugExpression2 ppExpr) {
            if (_exception != null) {
                throw _exception;
            }

            ppExpr = _expression;
            return VSConstants.S_OK;
        }
        public DebugExpressionEvaluationCompleteEvent(enum_EVENTATTRIBUTES attributes, IDebugExpression2 expression, IDebugProperty2 property)
            : base(attributes)
        {
            Contract.Requires<ArgumentNullException>(expression != null, "expression");
            Contract.Requires<ArgumentNullException>(property != null, "property");

            _expression = expression;
            _property = property;
        }
        public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr,
            out string pbstrError, out uint pichError)
        {
            pbstrError = "";
            pichError = 0;
            ppExpr = null;
            string lookup = pszCode;


            LocalVariable result = ThreadContext.GetVisibleVariableByName(lookup);
            if (result != null)
            {
                ppExpr = new AD7Expression(new MonoProperty(ThreadContext, result));
                return VSConstants.S_OK;
            }

            pbstrError = "Unsupported Expression";
            pichError = (uint)pbstrError.Length;
            return VSConstants.S_FALSE;
        }
 int IDebugExpressionContext2.ParseText(
   string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, 
   out IDebugExpression2 ppExpr, 
   out string pbstrError, out uint pichError)
 {
   pbstrError = null;
   ppExpr = null;
   pichError = 0;
   try
   {
     AD7DebugExpression expr = new AD7DebugExpression(_stackFrame, pszCode);
     bool success = DebuggerManager.Instance.Debugger.TryParseExpression(pszCode, out pbstrError);
     if (success)
       ppExpr = (IDebugExpression2)expr;
   }
   catch (Exception e)
   {
     pbstrError = e.Message;
     return VSConstants.E_FAIL;
   }
   return VSConstants.S_OK;
 }
Exemple #6
0
 public int GetExpression(out IDebugExpression2 expr)
 {
     expr = new AD7Expression(_engine, _var);
     return(Constants.S_OK);
 }
Exemple #7
0
        /// <summary>
        /// Parses an expression in text form for later evaluation.
        /// </summary>
        public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
        {
            DLog.Debug(DContext.VSDebuggerComCall, "DebugStackFrame.ParseText");
            ppExpr = null;
            pbstrError = null;
            pichError = 0;

            // Try to match a local variable
            var locals = GetValues();
            var localVariable = locals.FirstOrDefault(x => x.Name == pszCode);
            if (localVariable != null)
            {
                ppExpr = new DebugExpression(new DebugValueProperty(localVariable, null));
                return VSConstants.S_OK;
            }

            return VSConstants.E_FAIL;
        }
Exemple #8
0
 public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
 {
     ppExpr = null;
     pbstrError = "";
     pichError = 0;
     return VSConstants.E_NOTIMPL;
 }
Exemple #9
0
 public int GetExpression(out IDebugExpression2 expr)
 {
     expr = new AD7Expression(_engine, _var);
     return Constants.S_OK;
 }
Exemple #10
0
 public int GetExpression(out IDebugExpression2 ppExpr)
 {
     ppExpr = _expression;
     return VSConstants.S_OK;
 }
 public static int OnEvaluationComplete(this IDebugEngineHandler handler,
                                        IDebugExpression2 expr, IDebugProperty2 result,
                                        IGgpDebugProgram program, IDebugThread2 thread) =>
 handler.SendEvent(new DebugExpressionEvaluationCompleteEvent(expr, result), program,
                   thread);
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode,
                                               enum_PARSEFLAGS dwFlags,
                                               uint nRadix,
                                               out IDebugExpression2 ppExpr,
                                               out string pbstrError,
                                               out uint pichError)
        {
            pbstrError = "";
            pichError = 0;

            if (_parameters != null)
            {
                foreach (NodeEvaluationResult currVariable in _parameters)
                {
                    if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
                    {
                        ppExpr = new AD7Expression(this, currVariable.Name);
                        return VSConstants.S_OK;
                    }
                }
            }

            if (_locals != null)
            {
                foreach (NodeEvaluationResult currVariable in _locals)
                {
                    if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
                    {
                        ppExpr = new AD7Expression(this, currVariable.Name);
                        return VSConstants.S_OK;
                    }
                }
            }

            string errorMsg;
            if (!_stackFrame.TryParseText(pszCode, out errorMsg))
            {
                pbstrError = "Error: " + errorMsg;
                pichError = (uint) pbstrError.Length;
            }

            ppExpr = new AD7Expression(this, pszCode);
            return VSConstants.S_OK;
        }
      int IDebugExpressionEvaluationCompleteEvent2.GetExpression (out IDebugExpression2 ppExpr)
      {
        LoggingUtils.PrintFunction ();

        ppExpr = m_debugExpression;

        return Constants.S_OK;
      }
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
        {
            pbstrError = "";
            pichError = 0;
            ppExpr = null;

            try {
                var localOrArg = m_parameters.Concat(m_locals).FirstOrDefault(v => String.CompareOrdinal(v.m_name, pszCode) == 0);
                if (localOrArg != null) {
                    ppExpr = new AD7Property(localOrArg);
                    return Constants.S_OK;
                }
                var result = m_engine.DebuggedProcess.Evaluate(m_threadContext, pszCode, out pbstrError);
                if (result != null) {
                    ppExpr = new AD7Property(result);
                    return Constants.S_OK;
                }
                pichError = (uint)pbstrError.Length;
                return Constants.S_FALSE;
            } catch (Exception e) {
                return EngineUtils.UnexpectedException(e);
            }
        }
Exemple #15
0
 public int GetExpression(out IDebugExpression2 ppExpr)
 {
     ppExpr = _expression;
     return(VisualStudioExtensionConstants.S_OK);
 }
Exemple #16
0
        // Parses a text-based expression for evaluation.
        int IDebugExpressionContext2.ParseText(string pszCode,
                                               enum_PARSEFLAGS dwFlags,
                                               uint nRadix,
                                               out IDebugExpression2 ppExpr,
                                               out string pbstrError,
                                               out uint pichError)
        {
            pbstrError = "";
            pichError  = 0;
            ppExpr     = null;

            try
            {
                // Check if the expression belongs to the parameters
                foreach (var currVariable in _parameters)
                {
                    if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
                    {
                        ppExpr = new XamarinExpression(_engine, _thread, currVariable);
                        return(VisualStudioExtensionConstants.S_OK);
                    }
                }

                // Check if the expression belongs to the locals
                foreach (var currVariable in _locals)
                {
                    if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
                    {
                        ppExpr = new XamarinExpression(_engine, _thread, currVariable);
                        return(VisualStudioExtensionConstants.S_OK);
                    }
                }

                if (_thisObject != null)
                {
                    // Are we looking for "this"?
                    if (String.CompareOrdinal("this", pszCode) == 0)
                    {
                        ppExpr = new XamarinExpression(_engine, _thread, _thisObject);
                        return(VisualStudioExtensionConstants.S_OK);
                    }

                    // Lastly, check if it's a member of this
                    var parsedExpression = ParseThisInternals(_thisObject, pszCode);
                    if (parsedExpression != null)
                    {
                        ppExpr = parsedExpression;
                        return(VisualStudioExtensionConstants.S_OK);
                    }
                }

                pbstrError = "Invalid Expression";
                pichError  = (uint)pbstrError.Length;
                return(VisualStudioExtensionConstants.S_FALSE);
            }
            catch (ComponentException e)
            {
                return(e.HResult);
            }
            catch (Exception e)
            {
                NLogService.Logger.Error(e);
                return(VisualStudioExtensionConstants.S_FALSE);
            }
        }
Exemple #17
0
 public ExpressionEvalCompleteEvent(IDebugExpression2 pExpr, IDebugProperty2 pProp)
 {
     _expr = pExpr;
     _prop = pProp;
 }
            // Token: 0x060001F8 RID: 504 RVA: 0x00006E30 File Offset: 0x00005030
            int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
            {
                EvaluationOptions defaultOptions = StackFrame.DefaultOptions;

                defaultOptions.AllowMethodEvaluation   = false;
                defaultOptions.AllowTargetInvoke       = false;
                defaultOptions.AllowToStringCalls      = false;
                defaultOptions.EvaluationTimeout       = 1000;
                defaultOptions.MemberEvaluationTimeout = 1000;
                if (nRadix == 16U)
                {
                    defaultOptions.IntegerDisplayFormat = IntegerDisplayFormat.Hexadecimal;
                }
                else
                {
                    defaultOptions.IntegerDisplayFormat = IntegerDisplayFormat.Decimal;
                }
                ValidationResult validationResult = this.Frame.Frame.ValidateExpression(pszCode, defaultOptions);

                if (!validationResult.IsValid)
                {
                    pbstrError = validationResult.Message;
                    pichError  = 0U;
                    ppExpr     = null;
                    return(1);
                }
                pbstrError = null;
                pichError  = 0U;
                ppExpr     = new StackFrame.Expression(this.Frame, pszCode);
                return(0);
            }
Exemple #19
0
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode,
                                               enum_PARSEFLAGS dwFlags,
                                               uint nRadix,
                                               out IDebugExpression2 ppExpr,
                                               out string pbstrError,
                                               out uint pichError)
        {
            pbstrError = "";
            pichError  = 0;
            ppExpr     = null;

            if (IsDebuggingNPL())
            {
                VariableInformation varInfo = VariableInformation.Create(m_engine.DebuggedProcess, pszCode);
                if (varInfo != null)
                {
                    ppExpr = new AD7Expression(varInfo);
                    return(Constants.S_OK);
                }
                else
                {
                    return(Constants.S_FALSE);
                }
            }

            try
            {
                if (m_parameters != null)
                {
                    foreach (VariableInformation currVariable in m_parameters)
                    {
                        if (String.CompareOrdinal(currVariable.m_name, pszCode) == 0)
                        {
                            ppExpr = new AD7Expression(currVariable);
                            return(Constants.S_OK);
                        }
                    }
                }

                if (m_locals != null)
                {
                    foreach (VariableInformation currVariable in m_locals)
                    {
                        if (String.CompareOrdinal(currVariable.m_name, pszCode) == 0)
                        {
                            ppExpr = new AD7Expression(currVariable);
                            return(Constants.S_OK);
                        }
                    }
                }

                pbstrError = "Invalid Expression";
                pichError  = (uint)pbstrError.Length;
                return(Constants.S_FALSE);
            }
            catch (ComponentException e)
            {
                return(e.HResult);
            }
            catch (Exception e)
            {
                return(EngineUtils.UnexpectedException(e));
            }
        }
Exemple #20
0
 int IDebugExpressionEvaluationCompleteEvent2.GetExpression(out IDebugExpression2 ppExpr)
 {
     ppExpr = Expression;
     return(VSConstants.S_OK);
 }
Exemple #21
0
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode,
            enum_PARSEFLAGS dwFlags,
            uint nRadix,
            out IDebugExpression2 ppExpr,
            out string pbstrError,
            out uint pichError)
        {
            //            pbstrError = "";
            //            pichError = 0;
            //            ppExpr = null;

            //            return VSConstants.E_NOTIMPL;

            pbstrError = "";
            pichError = 0;
            ppExpr = null;

            // Parse here, if needed: verify if it is a valid expression, and store the parsed results into VariableInfo, or create another object.
            // if not: send a GDB command to evaluate the expression pszCode. It should return the result or an error message.
            // This object is indirectly sent to IDebugExpression2.EvaluateAsync
            // if pszCode is a variable, it must be found in Locals.

            //            VariableInfo vi = new VariableInfo(pszCode,"","");
            ppExpr = new AD7Expression(pszCode, this, m_engine.eDispatcher);
            return VSConstants.S_OK;
        }
Exemple #22
0
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr,
                                               out string pbstrError,
                                               out uint pichError)
        {
            //System.Windows.Forms.AD7Util.MessageBox("pszCode: " + pszCode);
            pbstrError = "";
            pichError  = 0;
            ppExpr     = null;

            try
            {
                if (mParams != null)
                {
                    foreach (DebugLocalInfo currVariable in mParams)
                    {
                        if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
                        {
                            ppExpr = new AD7Expression(currVariable, mProcess, this);
                            return(VSConstants.S_OK);
                        }
                    }
                }

                if (mLocals != null)
                {
                    foreach (DebugLocalInfo currVariable in mLocals)
                    {
                        if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
                        {
                            ppExpr = new AD7Expression(currVariable, mProcess, this);
                            return(VSConstants.S_OK);
                        }
                    }
                }

                pbstrError = "Invalid Expression";
                pichError  = (uint)pbstrError.Length;
                return(VSConstants.S_FALSE);
            }
            catch (Exception e)
            {
                return(EngineUtils.UnexpectedException(e));
            }
        }
Exemple #23
0
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode,
                                                enum_PARSEFLAGS dwFlags, 
                                                uint nRadix, 
                                                out IDebugExpression2 ppExpr, 
                                                out string pbstrError, 
                                                out uint pichError)
        {
            pbstrError = "";
            pichError = 0;
            ppExpr = null;

            if(IsDebuggingNPL())
            {
                VariableInformation varInfo = VariableInformation.Create(m_engine.DebuggedProcess, pszCode);
                if (varInfo!=null)
                {
                    ppExpr = new AD7Expression(varInfo);
                    return Constants.S_OK;
                }
                else
                {
                    return Constants.S_FALSE;
                }
            }

            try
            {
                if (m_parameters != null)
                {
                    foreach (VariableInformation currVariable in m_parameters)
                    {
                        if (String.CompareOrdinal(currVariable.m_name, pszCode) == 0)
                        {
                            ppExpr = new AD7Expression(currVariable);
                            return Constants.S_OK;
                        }
                    }
                }

                if (m_locals != null)
                {
                    foreach (VariableInformation currVariable in m_locals)
                    {
                        if (String.CompareOrdinal(currVariable.m_name, pszCode) == 0)
                        {
                            ppExpr = new AD7Expression(currVariable);
                            return Constants.S_OK;
                        }
                    }
                }

                pbstrError = "Invalid Expression";
                pichError = (uint)pbstrError.Length;
                return Constants.S_FALSE;
            }
            catch (ComponentException e)
            {
                return e.HResult;
            }
            catch (Exception e)
            {
                return EngineUtils.UnexpectedException(e);
            }
        }
      public ExpressionEvaluationComplete (IDebugExpression2 expression, IDebugProperty2 property)
      {
        m_debugExpression = expression;

        m_debugProperty = property;
      }
        public DebugExpressionEvaluationCompleteEvent(enum_EVENTATTRIBUTES attributes, IDebugExpression2 expression, IDebugProperty2 property)
            : base(attributes)
        {
            Contract.Requires <ArgumentNullException>(expression != null, "expression");
            Contract.Requires <ArgumentNullException>(property != null, "property");

            _expression = expression;
            _property   = property;
        }
Exemple #26
0
        /// <summary>
        /// Parses an expression in text form for later evaluation.
        /// </summary>
        public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
        {
            DLog.Debug(DContext.VSDebuggerComCall, "DebugStackFrame.ParseText");
            ppExpr = null;
            pbstrError = null;
            pichError = 0;

            // special registers group?
            if (pszCode.StartsWith("$reg", StringComparison.InvariantCultureIgnoreCase))
            {
                ppExpr = new DebugExpression(new DebugRegisterGroupProperty(this, false));
                return VSConstants.S_OK;
            }

            // Try to match a local variable
            try
            {
                var locals = GetValues();
                var localVariable = locals == null ? null : locals.FirstOrDefault(x => x.Name == pszCode);
                if (localVariable != null)
                {
                    ppExpr = new DebugExpression(new DebugStackFrameValueProperty(localVariable, null, this));
                    return VSConstants.S_OK;
                }
            }
            catch
            {
            }

            // try to match any of the registers.
            var match = castRegisterExpression.Match(pszCode);
            if (match.Success)
            {
                var castExpr = match.Groups[1].Value.Trim();
                var registerType = match.Groups[2].Value;
                int index = int.Parse(match.Groups[3].Value);

                ppExpr = new DebugRegisterExpression(this, pszCode, registerType, index, castExpr);
                return VSConstants.S_OK;
            }

            // try to match opcode help (in disassembly)
            var opHelp = Opcodes.Lookup(pszCode);
            if (opHelp != null)
            {
                ppExpr = new DebugExpression(new DebugConstProperty(pszCode, opHelp.Syntax + "\r\n\r\n" + opHelp.Arguments + "\r\n\r\n" + opHelp.Description, "(opcode)", null));
                return VSConstants.S_OK;
            }

            return VSConstants.E_FAIL;
        }
 public int GetExpression(out IDebugExpression2 expr)
 {
     expr = new MonoExpression(engine, thread, expression, value);
     return(VSConstants.S_OK);
 }
Exemple #28
0
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode,
            enum_PARSEFLAGS dwFlags,
            uint nRadix,
            out IDebugExpression2 ppExpr,
            out string pbstrError,
            out uint pichError) {
            pbstrError = String.Empty;
            pichError = 0;

            IEnumerable<NodeEvaluationResult> evaluationResults = _stackFrame.Locals.Union(_stackFrame.Parameters);
            foreach (NodeEvaluationResult currVariable in evaluationResults) {
                if (String.CompareOrdinal(currVariable.Expression, pszCode) == 0) {
                    ppExpr = new UncalculatedAD7Expression(this, currVariable.Expression);
                    return VSConstants.S_OK;
                }
            }

            string errorMsg;
            if (!_stackFrame.TryParseText(pszCode, out errorMsg)) {
                pbstrError = "Error: " + errorMsg;
                pichError = (uint)pbstrError.Length;
            }

            ppExpr = new UncalculatedAD7Expression(this, pszCode);
            return VSConstants.S_OK;
        }
 public int GetExpression(out IDebugExpression2 ppExpr)
 {
     ppExpr = _evaluatedExpression;
     return(S_OK);
 }
 int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError) {
     pbstrError = "";
     pichError = 0;
     ppExpr = new AD7Expression(this, pszCode);
     return VSConstants.S_OK;
 }
Exemple #31
0
 public AD7ExpressionEvaluationCompleteEvent(IDebugExpression2 expression, IDebugProperty2 property)
 {
     this._expression = expression;
     this._property   = property;
 }
Exemple #32
0
    // Parses a text-based expression for evaluation.
    // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
    int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr,
                                            out string pbstrError,
                                            out uint pichError) {
      //System.Windows.Forms.MessageBox.Show("pszCode: " + pszCode);
      pbstrError = "";
      pichError = 0;
      ppExpr = null;

      try {
        if (mParams != null) {
          foreach (DebugLocalInfo currVariable in mParams) {
            if (String.CompareOrdinal(currVariable.Name, pszCode) == 0) {
              ppExpr = new AD7Expression(currVariable, mProcess, this);
              return VSConstants.S_OK;
            }
          }
        }

        if (mLocals != null) {
          foreach (DebugLocalInfo currVariable in mLocals) {
            if (String.CompareOrdinal(currVariable.Name, pszCode) == 0) {
              ppExpr = new AD7Expression(currVariable, mProcess, this);
              return VSConstants.S_OK;
            }
          }
        }

        pbstrError = "Invalid Expression";
        pichError = (uint)pbstrError.Length;
        return VSConstants.S_FALSE;
      } catch (Exception e) {
        return EngineUtils.UnexpectedException(e);
      }
    }
Exemple #33
0
 public int GetExpression(out IDebugExpression2 ppExpr)
 {
     ppExpr = _expression;
     return(VSConstants.S_OK);
 }
Exemple #34
0
 public AD7ExpressionEvaluationCompleteEvent(IDebugExpression2 expression, IDebugProperty2 property)
 {
     _expression = expression;
     _property = property;
 }
 public void ExpressionEvalCompleted(
   AD7ProgramNode node, IDebugExpression2 pExpr, IDebugProperty2 pProp)
 {
   Debug.WriteLine("Event ExpressionEvaluationCompleted");
   Guid iid = new Guid(ExpressionEvalCompleteEvent.IID);
   _callback.Event(
     _engine, null, node, node, new ExpressionEvalCompleteEvent( pExpr, pProp ), 
     ref iid, ExpressionEvalCompleteEvent.Attributes);
 }
 public ExpressionEvalCompleteEvent( IDebugExpression2 pExpr, IDebugProperty2 pProp )
 {
   _expr = pExpr;
   _prop = pProp;
 }
 int IDebugExpressionEvaluationCompleteEvent2.GetExpression(out IDebugExpression2 ppExpr)
 {
   ppExpr = _expr;
   return VSConstants.S_OK;
 }
Exemple #38
0
        // Parses a text-based expression for evaluation.
        // The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
        int IDebugExpressionContext2.ParseText(string pszCode,
                                                enum_PARSEFLAGS dwFlags,
                                                uint nRadix,
                                                out IDebugExpression2 ppExpr,
                                                out string pbstrError,
                                                out uint pichError)
        {
            pbstrError = null;
            pichError = 0;
            ppExpr = null;

            try
            {
                // we have no "parser" as such, so we accept anything that isn't blank and let the Evaluate method figure out the errors
                ppExpr = new AD7Expression(Engine.DebuggedProcess.Natvis.GetVariable(pszCode, this));
                return Constants.S_OK;
            }
            catch (MIException e)
            {
                return e.HResult;
            }
            catch (Exception e)
            {
                return EngineUtils.UnexpectedException(e);
            }
        }
Exemple #39
0
 int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
 {
     pbstrError = "";
     pichError  = 0;
     ppExpr     = new AD7Expression(this, pszCode);
     return(VSConstants.S_OK);
 }