Debug APIs | C# Online Compiler

Debug APIs by szKarlen

using System;
using System.Collections.Generic;
					
public class Program
{
	public static void Main()
	{
		// https://msdn.microsoft.com/en-us/magazine/cc301316.aspx
		Console.WriteLine("Hello World");
	}
	
	public interface IProcessDebugManager
    {
        IDebugApplication CreateApplication(object engine);
        void AddApplication(IDebugApplication pda);
        void RemoveApplication(IDebugApplication dwApp);
    }

    public interface IRemoteDebugApplication
    {
        void ConnectDebugger(IApplicationDebugger pad);
        void DisconnectDebugger();
        void GetDebugger();
        void EnumThreads();
        void EnumGlobalExpressionContexts();
        void ResumeFromBreakPoint(IRemoteDebugApplicationThread prptFocus, BREAKRESUME_ACTION bra, ERRORRESUME_ACTION era);
    }

    public interface IApplicationDebugger
    {
        /// <summary>
        /// Handles a debug output event.
        /// </summary>
        /// <param name="pstr">String to display in the debugger.</param>
        void OnDebugOutput(string pstr);

        /// <summary>
        /// Handles a breakpoint event.
        /// </summary>
        /// <param name="prpt">The thread where the breakpoint occurred.</param>
        /// <param name="br">The reason for the breakpoint.</param>
        /// <param name="pError">Runtime error information, provided when the value of br is BREAKREASON_ERROR.</param>
        /// <remarks>This method is called when a breakpoint is hit and IDebugApplication::HandleBreakPoint is called.
        /// The application will remain suspended until the debugger IDE calls IRemoteDebugApplication::ResumeFromBreakPoint.
        /// </remarks>
        void OnHandleBreakPoint(IRemoteDebugApplicationThread prpt, BREAKREASON br, IActiveScriptErrorDebug pError);

        /// <summary>
        /// Handles a debug application close event.
        /// </summary>
        void OnClose();
    }

    public interface IDebugSessionProvider
    {
        IRemoteDebugApplication StartDebugSession();
    }

    public delegate void IDebugAsyncOperation(object state);

    public interface IDebugApplication : IRemoteDebugApplication
    {
        void StartDebugSession();
        void HandleBreakPoint(BREAKREASON br, out BREAKRESUME_ACTION pbra);
        void Close();
        APPBREAKFLAGS GetBreakFlags(out IRemoteDebugApplicationThread pprdatSteppingThread);
        IDebugApplicationThread GetCurrentThread();
        void CreateAsyncDebugOperation();
        void AddStackFrameSniffer(IDebugStackFrameSniffer pdsfs);
        void RemoveStackFrameSniffer(IDebugStackFrameSniffer pdsfs);
        void SynchronousCallInDebuggerThread(ThreadCallHandler pptc);
        void HandleRuntimeError(IActiveScriptErrorDebug pErrorDebug, IActiveScriptSite pScriptSite, out BREAKRESUME_ACTION pbra, out ERRORRESUME_ACTION perra, out bool pfCallOnScriptError);
        void AddGlobalExpressionContextProvider(IProvideExpressionContexts pdsfs);
        void RemoveGlobalExpressionContextProvider(IProvideExpressionContexts pdsfs);
    }

    public delegate void ThreadCallHandler();

    public interface IDebugApplicationThread
    {
        void SynchronousCallIntoThread();
    }

    public enum ERRORRESUME_ACTION
    {
        ERRORRESUMEACTION_ReexecuteErrorStatement,
        ERRORRESUMEACTION_AbortCallAndReturnErrorToCaller,
        ERRORRESUMEACTION_SkipErrorStatement,
    }

    public interface IActiveScriptSite
    {
        /// <summary>
        /// Allows the scripting engine to obtain information about an item added with the IActiveScript::AddNamedItem method
        /// </summary>
        /// <param name="pstrName">// address of item name</param>
        /// <exception cref="KeyNotFoundException">An item of the specified name was not found.</exception>
        /// <returns>The item to be retrieved</returns>
        object GetItemInfo(string pstrName);

        /// <summary>
        /// Adds the name of a root-level item to the scripting engine's name space. A root-level item is an object with properties and methods, an event source, or all three
        /// </summary>
        /// <param name="pstrName"></param>
        void AddNamedItem(string pstrName);

        /// <summary>
        /// Informs the host that an execution error occurred while the engine was running the script.
        /// </summary>
        /// <param name="pase">Address of the error object's IActiveScriptError interface. A host can use this interface to obtain information about the execution error.</param>
        void OnScriptError(IActiveScriptError pase);

        /// <summary>
        /// Informs the host that the scripting engine has begun executing the script code.
        /// </summary>
        void OnEnterScript();

        /// <summary>
        /// Informs the host that the scripting engine has ended executing the script code.
        /// </summary>
        void OnExitScript();
    }

    public interface IActiveScriptSiteDebug
    {
        IDebugApplication GetApplication();
        void OnScriptErrorDebug(IActiveScriptErrorDebug pErrorDebug, out bool pfEnterDebugger, out bool pfCallOnScriptErrorWhenContinuing);
    }

    public interface IActiveScriptParse
    {
        void InitNew();
        void AddScriptlet();
        object ParseScriptText(string pstrCode, string pstrItemName, object punkContext, uint ulStartingLineNumber, ScriptFlags dwFlags);
    }

    public enum ScriptFlags
	{
        SCRIPTTEXT_ISEXPRESSION,
        SCRIPTTEXT_ISPERSISTENT,
        SCRIPTTEXT_ISVISIBLE
	}

    public interface IActiveEngine : IActiveScript, IActiveScriptDebug, IActiveScriptParse
    {
        IActiveScript GetEngine(string name);
    }

    /// <summary>
    /// Provides the methods necessary to initialize the scripting engine. The scripting engine must implement the IActiveScript interface.
    /// </summary>
    public interface IActiveScript
    {
        void SetScriptSite(IActiveScriptSite pScriptSite);
        IActiveScriptSite GetScriptSite();
        void SetScriptState(SCRIPTSTATE scriptstate);
        SCRIPTSTATE GetScriptState();
        void Close();
        void AddNamedItem(string pstrName, NamedItemFlags dwFlags);
        void AddTypeLib(string assemblyName);
        void GetScriptDispatch();
        void GetCurrentScriptThreadID();
        void GetScriptThreadID();
        void GetScriptThreadState();
    }

    public interface IActiveScriptDebug
    {
        IEnumerable<IDebugCodeContext> EnumCodeContextsOfPosition();
    }

    public interface IActiveScriptErrorDebug
    {
        IDebugDocumentContext GetDocumentContext();
        IDebugStackFrame GetStackFrame();
    }

    public interface IDebugDocumentContext
    {
        IDebugDocument GetDocument();
        IEnumerable<IDebugCodeContext> EnumCodeContexts();
    }

    public interface IDebugDocument : IDebugDocumentInfo
    {
    }

    public interface IDebugDocumentInfo
    {
        string GetName(DOCUMENTNAMETYPE dnt);
    }

    public enum DOCUMENTNAMETYPE
    {
        DOCUMENTNAMETYPE_APPNODE,
        DOCUMENTNAMETYPE_TITLE,
        DOCUMENTNAMETYPE_FILE_TAIL,
        DOCUMENTNAMETYPE_URL,
        DOCUMENTNAMETYPE_UNIQUE_TITLE,
    }

    public enum SCRIPTSTATE
    {
        SCRIPTSTATE_UNINITIALIZED = 0,
        SCRIPTSTATE_INITIALIZED   = 5,
        SCRIPTSTATE_STARTED       = 1,
        SCRIPTSTATE_CONNECTED     = 2,
        SCRIPTSTATE_DISCONNECTED  = 3,
        SCRIPTSTATE_CLOSED        = 4
    }

    public enum NamedItemFlags
	{
        /// <summary>
        /// Indicates that the named item represents a code-only object, and that the host has no IUnknown to be associated with this code-only object. The host only has a name for this object. In object-oriented languages such as C++, this flag would create a class. Not all languages support this flag.
        /// </summary>
        SCRIPTITEM_CODEONLY,

        /// <summary>
        /// Indicates that the item is a collection of global properties and methods associated with the script. Normally, a scripting engine would ignore the object name (other than for the purpose of using it as a cookie for the IActiveScriptSite::GetItemInfo method, or for resolving explicit scoping) and expose its members as global variables and methods. This allows the host to extend the library (run-time functions and so on) available to the script. It is left to the scripting engine to deal with name conflicts (for example, when two SCRIPTITEM_GLOBALMEMBERS items have methods of the same name), although an error should not be returned because of this situation.
        /// </summary>
        SCRIPTITEM_GLOBALMEMBERS,

        /// <summary>
        /// Indicates that the item should be saved if the scripting engine is saved. Similarly, setting this flag indicates that a transition back to the initialized state should retain the item's name and type information (the scripting engine must, however, release all pointers to interfaces on the actual object).
        /// </summary>
        SCRIPTITEM_ISPERSISTENT,

        /// <summary>
        /// Indicates that the item sources events that the script can sink. Child objects (properties of the object that are in themselves objects) can also source events to the script. This is not recursive, but it provides a convenient mechanism for the common case, for example, of creating a container and all of its member controls.
        /// </summary>
        SCRIPTITEM_ISSOURCE,

        /// <summary>
        /// Indicates that the item's name is available in the name space of the script, allowing access to the properties, methods, and events of the item. By convention the properties of the item include the item's children; therefore, all child object properties and methods (and their children, recursively) will be accessible.
        /// </summary>
        SCRIPTITEM_ISVISIBLE,

        /// <summary>
        /// Indicates that the item is simply a name being added to the script's name space, and should not be treated as an item for which code should be associated. For example, without this flag being set, VBScript will create a separate module for the named item, and C++ might create a separate wrapper class for the named item.
        /// </summary>
        SCRIPTITEM_NOCODE
	}

    public interface IActiveScriptError
    {
        /// <summary>
        /// Retrieves information about an error that occurred while the scripting engine was running a script.
        /// </summary>
        /// <returns>An Exception that receives error information</returns>
        Exception GetExceptionInfo();

        /// <summary>
        /// Retrieves the location in the source code where an error occurred while the scripting engine was running a script
        /// </summary>
        /// <param name="pulLineNumber">Address of a variable that receives the line number in the source file where the error occurred</param>
        /// <param name="pichCharPosition">Address of a variable that receives the character position in the line where the error occurred</param>
        /// <returns> Address of a variable that receives a cookie that identifies the context. The interpretation of this parameter depends on the host application.</returns>
        object GetSourcePosition(out int pulLineNumber, out int pichCharPosition);

        /// <summary>
        /// Retrieves the line in the source file where an error occurred while a scripting engine was running a script.
        /// </summary>
        /// <returns>Address of a buffer that receives the line of source code in which the error occurred.</returns>
        string GetSourceLineText();
    }

    public enum BREAKREASON
    {
        BREAKREASON_STEP,
        BREAKREASON_BREAKPOINT,
        BREAKREASON_DEBUGGER_BLOCK,
        BREAKREASON_HOST_INITIATED,
        BREAKREASON_LANGUAGE_INITIATED,
        BREAKREASON_DEBUGGER_HALT,
        BREAKREASON_ERROR,
        BREAKREASON_JIT
    }

    public enum BREAKRESUME_ACTION
    {
        BREAKRESUMEACTION_ABORT,
        BREAKRESUMEACTION_CONTINUE,
        BREAKRESUMEACTION_STEP_INTO,
        BREAKRESUMEACTION_STEP_OVER,
        BREAKRESUMEACTION_STEP_OUT,
        BREAKRESUMEACTION_IGNORE,
        BREAKRESUMEACTION_STEP_DOCUMENT
    }

    public enum APPBREAKFLAGS : uint
    {
        APPBREAKFLAG_DEBUGGER_BLOCK= 0x00000001,
        APPBREAKFLAG_DEBUGGER_HALT= 0x00000002,
        APPBREAKFLAG_STEP= 0x00010000,
        APPBREAKFLAG_NESTED= 0x00020000,
        APPBREAKFLAG_STEPTYPE_SOURCE= 0x00000000,
        APPBREAKFLAG_STEPTYPE_BYTECODE= 0x00100000,
        APPBREAKFLAG_STEPTYPE_MACHINE= 0x00200000,
        APPBREAKFLAG_STEPTYPE_MASK= 0x00F00000,
        APPBREAKFLAG_IN_BREAKPOINT= 0x80000000
    }

    public interface IRemoteDebugApplicationThread
    {
        IEnumerable<DebugStackFrameDescriptor> EnumStackFrames();
        string GetDescription();
        void Suspend(int milliseconds);
        void Resume();
        int GetSuspendCount();
    }

    public struct DebugStackFrameDescriptor
    {
        IDebugStackFrame pdsf;
    }

    public interface IDebugStackFrame
    {
        IDebugCodeContext GetCodeContext();
        string GetDescriptionString();
        string GetLanguageString();
        IDebugProperty GetDebugProperty();
    }

    public interface IDebugProperty
    {
        DebugPropertyInfo GetPropertyInfo();
        object[] GetExtendedInfo();
        void SetValueAsString(string pszValue);
        IEnumerable<DebugPropertyInfo> EnumMembers(DBGPROP_INFO_FLAGS dwFieldSpec);
        IDebugProperty GetParent();
    }

    public struct DebugPropertyInfo
    {
        /// <summary>
        /// An enumerated data type used to specify which fields are initialized.
        /// </summary>
        public DBGPROP_INFO_FLAGS dwValidFields;

        /// <summary>
        /// The property name within a context.
        /// </summary>
        public string bstrName;

        /// <summary>
        /// The property type, as formatted string.
        /// </summary>
        public string bstrType;

        /// <summary>
        /// The property value, as formatted string.
        /// </summary>
        public string bstrValue;

        /// <summary>
        /// The full name of the property.
        /// </summary>
        public string bstrFullName;

        /// <summary>
        /// An enumeration that specifies the flags for the debug property attributes.
        /// </summary>
        public DBGPROP_ATTRIB_FLAGS dwAttrib;

        /// <summary>
        /// The IDebugProperty described by the information in this DebugPropertyInfo structure.
        /// </summary>
        public IDebugProperty pDebugProp;
    }

    public enum DBGPROP_INFO_FLAGS
    {
        DBGPROP_INFO_NAME  =0x001,
        DBGPROP_INFO_TYPE  =0x002,
        DBGPROP_INFO_VALUE  =0x004,
        DBGPROP_INFO_FULLNAME  =0x020,
        DBGPROP_INFO_ATTRIBUTES  =0x008,
        DBGPROP_INFO_DEBUGPROP  =0x010,
        DBGPROP_INFO_AUTOEXPAND  =0x8000000
    }

    public enum DBGPROP_ATTRIB_FLAGS : uint
    {
        DBGPROP_ATTRIB_NO_ATTRIB  =0x00000000,
        DBGPROP_ATTRIB_VALUE_IS_INVALID  =0x00000008,
        DBGPROP_ATTRIB_VALUE_IS_EXPANDABLE  =0x00000010,
        DBGPROP_ATTRIB_VALUE_READONLY  =0x00000800,
        DBGPROP_ATTRIB_ACCESS_PUBLIC  =0x00001000,
        DBGPROP_ATTRIB_ACCESS_PRIVATE  =0x00002000,
        DBGPROP_ATTRIB_ACCESS_PROTECTED  =0x00004000,
        DBGPROP_ATTRIB_ACCESS_FINAL  =0x00008000,
        DBGPROP_ATTRIB_STORAGE_GLOBAL  =0x00010000,
        DBGPROP_ATTRIB_STORAGE_STATIC  =0x00020000,
        DBGPROP_ATTRIB_STORAGE_FIELD  =0x00040000,
        DBGPROP_ATTRIB_STORAGE_VIRTUAL  =0x00080000,
        DBGPROP_ATTRIB_TYPE_IS_CONSTANT  =0x00100000,
        DBGPROP_ATTRIB_TYPE_IS_SYNCHRONIZED  =0x00200000,
        DBGPROP_ATTRIB_TYPE_IS_VOLATILE  =0x00400000,
        DBGPROP_ATTRIB_HAS_EXTENDED_ATTRIBS  =0x00800000,
        DBGPROP_ATTRIB_VALUE_IS_RETURN_VALUE  =0x08000000
    }

    public interface IDebugCodeContext
    {
        IDebugDocumentContext GetDocumentContext();
        void SetBreakPoint(BREAKPOINT_STATE bps);
    }

    public enum BREAKPOINT_STATE
    {
        BREAKPOINT_DELETED = 0,
        BREAKPOINT_DISABLED = 1,
        BREAKPOINT_ENABLED = 2
    }

    /// <summary>
    /// Provides a way to enumerate the logical stack frames known by a component. Script engines typically implement this interface. The process debug manager uses this interface to find all stack frames associated with a given thread.
    /// </summary>
    /// <remarks>The debugger calls this interface from within the thread of interest. The script engine must identify the current thread and return an appropriate enumerator.</remarks>
    public interface IDebugStackFrameSniffer
    {
        void EnumStackFrames();
    }

    public interface IProvideExpressionContexts
    {
        IEnumerable<IDebugExpressionContext> EnumExpressionContexts();
    }

    public interface IDebugExpressionContext
    {
        IDebugExpression ParseLanguageText(string pstrCode, ParsingFlags dwFlags);
        string GetLanguageInfo(out Guid pLanguageID);
    }

    /// <summary>
    /// Represents an asynchronously evaluated expression. Script engines typically implement this interface. A debugger IDE typically uses this interface to enable an immediate execution window or watch window.
    /// </summary>
    /// <remarks>The IDebugExpression interface is available only from a stack frame.</remarks>
    public interface IDebugExpression
    {
        /// <summary>
        /// Begins the evaluation of the expression.
        /// </summary>
        /// <returns>Callback for indicating when the expression evaluation is complete. If this parameter is NULL, no events are fired and the client must poll the expression state by using QueryIsComplete</returns>
        IDebugExpressionCallBack Start();
        void Stop();
        bool QueryIsComplete();
        string GetResultAsString(out object result);
        IDebugProperty GetResultAsDebugProperty(object result);
    }

    public interface IDebugExpressionCallBack
    {
        /// <summary>
        /// This method is called when the expression evaluation is complete. The IDebugExpression::GetResultAsString method can be called from within this event handler.
        /// </summary>
        event EventHandler OnComplete;
    }

    public enum ParsingFlags
	{
        /// <summary>
        /// Indicates that the text is an expression as opposed to a statement. This flag may affect the way in which the text is parsed by some languages.
        /// </summary>
        DEBUG_TEXT_ISEXPRESSION = 0x00000001,

        /// <summary>
        /// If a return value is available, it will be used by the caller.
        /// </summary>
        DEBUG_TEXT_RETURNVALUE = 0x00000002,

        /// <summary>
        /// Do not allow side effects. If this flag is set, the evaluation of the expression should change no runtime state.
        /// </summary>
        DEBUG_TEXT_NOSIDEEFFECTS = 0x00000004,

        /// <summary>
        /// Allows breakpoints during the evaluation of the text. If this flag is not set then breakpoints are ignored during the evaluation of the text.
        /// </summary>
        DEBUG_TEXT_ALLOWBREAKPOINTS = 0x00000008,

        /// <summary>
        /// Allows error reports during the evaluation of the text. If this flag is not set then errors are not reported to the host during the evaluation.
        /// </summary>
        DEBUG_TEXT_ALLOWERRORREPORT = 0x00000010,

        /// <summary>
        /// Indicates the expression is to be evaluated to a code context rather than running the expression itself
        /// </summary>
        DEBUG_TEXT_EVALUATETOCODECONTEXT = 0x00000020
	}
}

​x
 
using System;
using System.Collections.Generic;
                    
public class Program
{
    public static void Main()
    {
        // https://msdn.microsoft.com/en-us/magazine/cc301316.aspx
        Console.WriteLine("Hello World");
    }
    
    public interface IProcessDebugManager
    {
        IDebugApplication CreateApplication(object engine);
        void AddApplication(IDebugApplication pda);
        void RemoveApplication(IDebugApplication dwApp);
    }
​
    public interface IRemoteDebugApplication
    {
        void ConnectDebugger(IApplicationDebugger pad);
        void DisconnectDebugger();
        void GetDebugger();
        void EnumThreads();
        void EnumGlobalExpressionContexts();
        void ResumeFromBreakPoint(IRemoteDebugApplicationThread prptFocus, BREAKRESUME_ACTION bra, ERRORRESUME_ACTION era);
    }
​
    public interface IApplicationDebugger
    {
        /// <summary>
        /// Handles a debug output event.
        /// </summary>
        /// <param name="pstr">String to display in the debugger.</param>
        void OnDebugOutput(string pstr);
​
        /// <summary>
        /// Handles a breakpoint event.
        /// </summary>
        /// <param name="prpt">The thread where the breakpoint occurred.</param>
        /// <param name="br">The reason for the breakpoint.</param>
        /// <param name="pError">Runtime error information, provided when the value of br is BREAKREASON_ERROR.</param>
        /// <remarks>This method is called when a breakpoint is hit and IDebugApplication::HandleBreakPoint is called.
        /// The application will remain suspended until the debugger IDE calls IRemoteDebugApplication::ResumeFromBreakPoint.
        /// </remarks>
        void OnHandleBreakPoint(IRemoteDebugApplicationThread prpt, BREAKREASON br, IActiveScriptErrorDebug pError);
​
        /// <summary>
        /// Handles a debug application close event.
        /// </summary>
        void OnClose();
    }
​
    public interface IDebugSessionProvider
    {
        IRemoteDebugApplication StartDebugSession();
    }
​
    public delegate void IDebugAsyncOperation(object state);
​
    public interface IDebugApplication : IRemoteDebugApplication
    {
        void StartDebugSession();
        void HandleBreakPoint(BREAKREASON br, out BREAKRESUME_ACTION pbra);
        void Close();
        APPBREAKFLAGS GetBreakFlags(out IRemoteDebugApplicationThread pprdatSteppingThread);
        IDebugApplicationThread GetCurrentThread();
        void CreateAsyncDebugOperation();
        void AddStackFrameSniffer(IDebugStackFrameSniffer pdsfs);
        void RemoveStackFrameSniffer(IDebugStackFrameSniffer pdsfs);
        void SynchronousCallInDebuggerThread(ThreadCallHandler pptc);
        void HandleRuntimeError(IActiveScriptErrorDebug pErrorDebug, IActiveScriptSite pScriptSite, out BREAKRESUME_ACTION pbra, out ERRORRESUME_ACTION perra, out bool pfCallOnScriptError);
        void AddGlobalExpressionContextProvider(IProvideExpressionContexts pdsfs);
        void RemoveGlobalExpressionContextProvider(IProvideExpressionContexts pdsfs);
    }
​
    public delegate void ThreadCallHandler();
​
    public interface IDebugApplicationThread
    {
        void SynchronousCallIntoThread();
    }
​
    public enum ERRORRESUME_ACTION
    {
        ERRORRESUMEACTION_ReexecuteErrorStatement,
        ERRORRESUMEACTION_AbortCallAndReturnErrorToCaller,
        ERRORRESUMEACTION_SkipErrorStatement,
    }
​
    public interface IActiveScriptSite
    {
        /// <summary>
        /// Allows the scripting engine to obtain information about an item added with the IActiveScript::AddNamedItem method
        /// </summary>
        /// <param name="pstrName">// address of item name</param>
        /// <exception cref="KeyNotFoundException">An item of the specified name was not found.</exception>
        /// <returns>The item to be retrieved</returns>
        object GetItemInfo(string pstrName);
​
        /// <summary>
        /// Adds the name of a root-level item to the scripting engine's name space. A root-level item is an object with properties and methods, an event source, or all three
        /// </summary>
        /// <param name="pstrName"></param>
        void AddNamedItem(string pstrName);
​
        /// <summary>
        /// Informs the host that an execution error occurred while the engine was running the script.
        /// </summary>
        /// <param name="pase">Address of the error object's IActiveScriptError interface. A host can use this interface to obtain information about the execution error.</param>
        void OnScriptError(IActiveScriptError pase);
​
        /// <summary>
        /// Informs the host that the scripting engine has begun executing the script code.
        /// </summary>
        void OnEnterScript();
​
        /// <summary>
        /// Informs the host that the scripting engine has ended executing the script code.
        /// </summary>
        void OnExitScript();
    }
​
    public interface IActiveScriptSiteDebug
    {
        IDebugApplication GetApplication();
        void OnScriptErrorDebug(IActiveScriptErrorDebug pErrorDebug, out bool pfEnterDebugger, out bool pfCallOnScriptErrorWhenContinuing);
    }
​
    public interface IActiveScriptParse
    {
        void InitNew();
        void AddScriptlet();
        object ParseScriptText(string pstrCode, string pstrItemName, object punkContext, uint ulStartingLineNumber, ScriptFlags dwFlags);
    }
​
    public enum ScriptFlags
    {
        SCRIPTTEXT_ISEXPRESSION,
        SCRIPTTEXT_ISPERSISTENT,
        SCRIPTTEXT_ISVISIBLE
    }
​
    public interface IActiveEngine : IActiveScript, IActiveScriptDebug, IActiveScriptParse
    {
        IActiveScript GetEngine(string name);
    }
​
    /// <summary>
    /// Provides the methods necessary to initialize the scripting engine. The scripting engine must implement the IActiveScript interface.
    /// </summary>
    public interface IActiveScript
    {
        void SetScriptSite(IActiveScriptSite pScriptSite);
        IActiveScriptSite GetScriptSite();
        void SetScriptState(SCRIPTSTATE scriptstate);
        SCRIPTSTATE GetScriptState();
        void Close();
        void AddNamedItem(string pstrName, NamedItemFlags dwFlags);
        void AddTypeLib(string assemblyName);
        void GetScriptDispatch();
        void GetCurrentScriptThreadID();
        void GetScriptThreadID();
        void GetScriptThreadState();
    }
​
    public interface IActiveScriptDebug
    {
        IEnumerable<IDebugCodeContext> EnumCodeContextsOfPosition();
    }
​
    public interface IActiveScriptErrorDebug
    {
        IDebugDocumentContext GetDocumentContext();
        IDebugStackFrame GetStackFrame();
    }
​
    public interface IDebugDocumentContext
    {
        IDebugDocument GetDocument();
        IEnumerable<IDebugCodeContext> EnumCodeContexts();
    }
​
    public interface IDebugDocument : IDebugDocumentInfo
    {
    }
​
    public interface IDebugDocumentInfo
    {
        string GetName(DOCUMENTNAMETYPE dnt);
    }
​
    public enum DOCUMENTNAMETYPE
    {
        DOCUMENTNAMETYPE_APPNODE,
        DOCUMENTNAMETYPE_TITLE,
        DOCUMENTNAMETYPE_FILE_TAIL,
        DOCUMENTNAMETYPE_URL,
        DOCUMENTNAMETYPE_UNIQUE_TITLE,
    }
​
    public enum SCRIPTSTATE
    {
        SCRIPTSTATE_UNINITIALIZED = 0,
        SCRIPTSTATE_INITIALIZED   = 5,
        SCRIPTSTATE_STARTED       = 1,
        SCRIPTSTATE_CONNECTED     = 2,
        SCRIPTSTATE_DISCONNECTED  = 3,
        SCRIPTSTATE_CLOSED        = 4
    }
​
    public enum NamedItemFlags
    {
        /// <summary>
        /// Indicates that the named item represents a code-only object, and that the host has no IUnknown to be associated with this code-only object. The host only has a name for this object. In object-oriented languages such as C++, this flag would create a class. Not all languages support this flag.
        /// </summary>
        SCRIPTITEM_CODEONLY,
​
        /// <summary>
        /// Indicates that the item is a collection of global properties and methods associated with the script. Normally, a scripting engine would ignore the object name (other than for the purpose of using it as a cookie for the IActiveScriptSite::GetItemInfo method, or for resolving explicit scoping) and expose its members as global variables and methods. This allows the host to extend the library (run-time functions and so on) available to the script. It is left to the scripting engine to deal with name conflicts (for example, when two SCRIPTITEM_GLOBALMEMBERS items have methods of the same name), although an error should not be returned because of this situation.
        /// </summary>
        SCRIPTITEM_GLOBALMEMBERS,
​
        /// <summary>
        /// Indicates that the item should be saved if the scripting engine is saved. Similarly, setting this flag indicates that a transition back to the initialized state should retain the item's name and type information (the scripting engine must, however, release all pointers to interfaces on the actual object).
        /// </summary>
        SCRIPTITEM_ISPERSISTENT,
​
        /// <summary>
        /// Indicates that the item sources events that the script can sink. Child objects (properties of the object that are in themselves objects) can also source events to the script. This is not recursive, but it provides a convenient mechanism for the common case, for example, of creating a container and all of its member controls.
        /// </summary>
        SCRIPTITEM_ISSOURCE,
​
        /// <summary>
        /// Indicates that the item's name is available in the name space of the script, allowing access to the properties, methods, and events of the item. By convention the properties of the item include the item's children; therefore, all child object properties and methods (and their children, recursively) will be accessible.
        /// </summary>
        SCRIPTITEM_ISVISIBLE,
​
        /// <summary>
        /// Indicates that the item is simply a name being added to the script's name space, and should not be treated as an item for which code should be associated. For example, without this flag being set, VBScript will create a separate module for the named item, and C++ might create a separate wrapper class for the named item.
        /// </summary>
        SCRIPTITEM_NOCODE
    }
​
    public interface IActiveScriptError
    {
        /// <summary>
        /// Retrieves information about an error that occurred while the scripting engine was running a script.
        /// </summary>
        /// <returns>An Exception that receives error information</returns>
        Exception GetExceptionInfo();
​
        /// <summary>
        /// Retrieves the location in the source code where an error occurred while the scripting engine was running a script
        /// </summary>
        /// <param name="pulLineNumber">Address of a variable that receives the line number in the source file where the error occurred</param>
        /// <param name="pichCharPosition">Address of a variable that receives the character position in the line where the error occurred</param>
        /// <returns> Address of a variable that receives a cookie that identifies the context. The interpretation of this parameter depends on the host application.</returns>
        object GetSourcePosition(out int pulLineNumber, out int pichCharPosition);
​
        /// <summary>
        /// Retrieves the line in the source file where an error occurred while a scripting engine was running a script.
        /// </summary>
        /// <returns>Address of a buffer that receives the line of source code in which the error occurred.</returns>
        string GetSourceLineText();
    }
​
    public enum BREAKREASON
    {
        BREAKREASON_STEP,
        BREAKREASON_BREAKPOINT,
        BREAKREASON_DEBUGGER_BLOCK,
        BREAKREASON_HOST_INITIATED,
        BREAKREASON_LANGUAGE_INITIATED,
        BREAKREASON_DEBUGGER_HALT,
        BREAKREASON_ERROR,
        BREAKREASON_JIT
    }
​
    public enum BREAKRESUME_ACTION
    {
        BREAKRESUMEACTION_ABORT,
        BREAKRESUMEACTION_CONTINUE,
        BREAKRESUMEACTION_STEP_INTO,
        BREAKRESUMEACTION_STEP_OVER,
        BREAKRESUMEACTION_STEP_OUT,
        BREAKRESUMEACTION_IGNORE,
        BREAKRESUMEACTION_STEP_DOCUMENT
    }
​
    public enum APPBREAKFLAGS : uint
    {
        APPBREAKFLAG_DEBUGGER_BLOCK= 0x00000001,
        APPBREAKFLAG_DEBUGGER_HALT= 0x00000002,
        APPBREAKFLAG_STEP= 0x00010000,
        APPBREAKFLAG_NESTED= 0x00020000,
        APPBREAKFLAG_STEPTYPE_SOURCE= 0x00000000,
        APPBREAKFLAG_STEPTYPE_BYTECODE= 0x00100000,
        APPBREAKFLAG_STEPTYPE_MACHINE= 0x00200000,
        APPBREAKFLAG_STEPTYPE_MASK= 0x00F00000,
        APPBREAKFLAG_IN_BREAKPOINT= 0x80000000
    }
​
    public interface IRemoteDebugApplicationThread
    {
        IEnumerable<DebugStackFrameDescriptor> EnumStackFrames();
        string GetDescription();
        void Suspend(int milliseconds);
        void Resume();
        int GetSuspendCount();
    }
​
    public struct DebugStackFrameDescriptor
    {
        IDebugStackFrame pdsf;
    }
​
    public interface IDebugStackFrame
    {
        IDebugCodeContext GetCodeContext();
        string GetDescriptionString();
        string GetLanguageString();
        IDebugProperty GetDebugProperty();
    }
​
    public interface IDebugProperty
    {
        DebugPropertyInfo GetPropertyInfo();
        object[] GetExtendedInfo();
        void SetValueAsString(string pszValue);
        IEnumerable<DebugPropertyInfo> EnumMembers(DBGPROP_INFO_FLAGS dwFieldSpec);
        IDebugProperty GetParent();
    }
​
    public struct DebugPropertyInfo
    {
        /// <summary>
        /// An enumerated data type used to specify which fields are initialized.
        /// </summary>
        public DBGPROP_INFO_FLAGS dwValidFields;
​
        /// <summary>
        /// The property name within a context.
        /// </summary>
        public string bstrName;
​
        /// <summary>
        /// The property type, as formatted string.
        /// </summary>
        public string bstrType;
​
        /// <summary>
        /// The property value, as formatted string.
        /// </summary>
        public string bstrValue;
​
        /// <summary>
        /// The full name of the property.
        /// </summary>
        public string bstrFullName;
​
        /// <summary>
        /// An enumeration that specifies the flags for the debug property attributes.
        /// </summary>
        public DBGPROP_ATTRIB_FLAGS dwAttrib;
​
        /// <summary>
        /// The IDebugProperty described by the information in this DebugPropertyInfo structure.
        /// </summary>
        public IDebugProperty pDebugProp;
    }
​
    public enum DBGPROP_INFO_FLAGS
    {
        DBGPROP_INFO_NAME  =0x001,
        DBGPROP_INFO_TYPE  =0x002,
        DBGPROP_INFO_VALUE  =0x004,
        DBGPROP_INFO_FULLNAME  =0x020,
        DBGPROP_INFO_ATTRIBUTES  =0x008,
        DBGPROP_INFO_DEBUGPROP  =0x010,
        DBGPROP_INFO_AUTOEXPAND  =0x8000000
    }
​
    public enum DBGPROP_ATTRIB_FLAGS : uint
    {
        DBGPROP_ATTRIB_NO_ATTRIB  =0x00000000,
        DBGPROP_ATTRIB_VALUE_IS_INVALID  =0x00000008,
        DBGPROP_ATTRIB_VALUE_IS_EXPANDABLE  =0x00000010,
        DBGPROP_ATTRIB_VALUE_READONLY  =0x00000800,
        DBGPROP_ATTRIB_ACCESS_PUBLIC  =0x00001000,
        DBGPROP_ATTRIB_ACCESS_PRIVATE  =0x00002000,
        DBGPROP_ATTRIB_ACCESS_PROTECTED  =0x00004000,
        DBGPROP_ATTRIB_ACCESS_FINAL  =0x00008000,
        DBGPROP_ATTRIB_STORAGE_GLOBAL  =0x00010000,
        DBGPROP_ATTRIB_STORAGE_STATIC  =0x00020000,
        DBGPROP_ATTRIB_STORAGE_FIELD  =0x00040000,
        DBGPROP_ATTRIB_STORAGE_VIRTUAL  =0x00080000,
        DBGPROP_ATTRIB_TYPE_IS_CONSTANT  =0x00100000,
        DBGPROP_ATTRIB_TYPE_IS_SYNCHRONIZED  =0x00200000,
        DBGPROP_ATTRIB_TYPE_IS_VOLATILE  =0x00400000,
        DBGPROP_ATTRIB_HAS_EXTENDED_ATTRIBS  =0x00800000,
        DBGPROP_ATTRIB_VALUE_IS_RETURN_VALUE  =0x08000000
    }
​
    public interface IDebugCodeContext
    {
        IDebugDocumentContext GetDocumentContext();
        void SetBreakPoint(BREAKPOINT_STATE bps);
    }
​
    public enum BREAKPOINT_STATE
    {
        BREAKPOINT_DELETED = 0,
        BREAKPOINT_DISABLED = 1,
        BREAKPOINT_ENABLED = 2
    }
​
    /// <summary>
    /// Provides a way to enumerate the logical stack frames known by a component. Script engines typically implement this interface. The process debug manager uses this interface to find all stack frames associated with a given thread.
    /// </summary>
    /// <remarks>The debugger calls this interface from within the thread of interest. The script engine must identify the current thread and return an appropriate enumerator.</remarks>
    public interface IDebugStackFrameSniffer
    {
        void EnumStackFrames();
    }
​
    public interface IProvideExpressionContexts
    {
        IEnumerable<IDebugExpressionContext> EnumExpressionContexts();
    }
​
    public interface IDebugExpressionContext
    {
        IDebugExpression ParseLanguageText(string pstrCode, ParsingFlags dwFlags);
        string GetLanguageInfo(out Guid pLanguageID);
    }
​
    /// <summary>
    /// Represents an asynchronously evaluated expression. Script engines typically implement this interface. A debugger IDE typically uses this interface to enable an immediate execution window or watch window.
    /// </summary>
    /// <remarks>The IDebugExpression interface is available only from a stack frame.</remarks>
    public interface IDebugExpression
    {
        /// <summary>
        /// Begins the evaluation of the expression.
        /// </summary>
        /// <returns>Callback for indicating when the expression evaluation is complete. If this parameter is NULL, no events are fired and the client must poll the expression state by using QueryIsComplete</returns>
        IDebugExpressionCallBack Start();
        void Stop();
        bool QueryIsComplete();
        string GetResultAsString(out object result);
        IDebugProperty GetResultAsDebugProperty(object result);
    }
​
    public interface IDebugExpressionCallBack
    {
        /// <summary>
        /// This method is called when the expression evaluation is complete. The IDebugExpression::GetResultAsString method can be called from within this event handler.
        /// </summary>
        event EventHandler OnComplete;
    }
​
    public enum ParsingFlags
    {
        /// <summary>
        /// Indicates that the text is an expression as opposed to a statement. This flag may affect the way in which the text is parsed by some languages.
        /// </summary>
        DEBUG_TEXT_ISEXPRESSION = 0x00000001,
​
        /// <summary>
        /// If a return value is available, it will be used by the caller.
        /// </summary>
        DEBUG_TEXT_RETURNVALUE = 0x00000002,
​
        /// <summary>
        /// Do not allow side effects. If this flag is set, the evaluation of the expression should change no runtime state.
        /// </summary>
        DEBUG_TEXT_NOSIDEEFFECTS = 0x00000004,
​
        /// <summary>
        /// Allows breakpoints during the evaluation of the text. If this flag is not set then breakpoints are ignored during the evaluation of the text.
        /// </summary>
        DEBUG_TEXT_ALLOWBREAKPOINTS = 0x00000008,
​
        /// <summary>
        /// Allows error reports during the evaluation of the text. If this flag is not set then errors are not reported to the host during the evaluation.
        /// </summary>
        DEBUG_TEXT_ALLOWERRORREPORT = 0x00000010,
​
        /// <summary>
        /// Indicates the expression is to be evaluated to a code context rather than running the expression itself
        /// </summary>
        DEBUG_TEXT_EVALUATETOCODECONTEXT = 0x00000020
    }
}

View IL Code