public DebugTreeNodeStream(ITreeNodeStream input, IDebugEventListener dbg)
{
this.input = input;
this.adaptor = input.TreeAdaptor;
this.input.HasUniqueNavigationNodes = true;
SetDebugListener(dbg);
}
public DebugEventResponse OnChildProcessCreated(int threadID,
IProcessDebuggerService child, out IDebugEventListener childListener)
{
var childProcess = new ProcessDebugger(child);
childListener = childProcess.eventListener;
throw new NotImplementedException();
}
public DebugTokenStream(ITokenStream input, IDebugEventListener dbg) {
this.input = input;
DebugListener = dbg;
// force TokenStream to get at least first valid token
// so we know if there are any hidden tokens first in the stream
input.LT(1);
}
/** <summary>
* Provide a new debug event listener for this parser. Notify the
* input stream too that it should send events to this listener.
* </summary>
*/
public virtual void SetDebugListener(IDebugEventListener value) {
DebugTokenStream debugTokenStream = input as DebugTokenStream;
if (debugTokenStream != null)
debugTokenStream.DebugListener = value;
dbg = value;
}
public void EnterAlt(int alt)
{
for (int i = 0; i < listeners.Count; i++)
{
IDebugEventListener listener = (IDebugEventListener)listeners[i];
listener.EnterAlt(alt);
}
}
public void ErrorNode(object t)
{
for (int i = 0; i < listeners.Count; i++)
{
IDebugEventListener listener = (IDebugEventListener)listeners[i];
listener.ErrorNode(t);
}
}
public void EnterRule(string grammarFileName, string ruleName)
{
for (int i = 0; i < listeners.Count; i++)
{
IDebugEventListener listener = (IDebugEventListener)listeners[i];
listener.EnterRule(grammarFileName, ruleName);
}
}
public void Terminate()
{
for (int i = 0; i < listeners.Count; i++)
{
IDebugEventListener listener = (IDebugEventListener)listeners[i];
listener.Terminate();
}
}
public void Commence()
{
for (int i = 0; i < listeners.Count; i++)
{
IDebugEventListener listener = (IDebugEventListener)listeners[i];
listener.Commence();
}
}
public void EndResync()
{
for (int i = 0; i < listeners.Count; i++)
{
IDebugEventListener listener = (IDebugEventListener)listeners[i];
listener.EndResync();
}
}
public DebugTreeNodeStream(ITreeNodeStream input,
IDebugEventListener dbg)
{
this.input = input;
this.adaptor = input.TreeAdaptor;
this.input.UniqueNavigationNodes = true;
DebugListener = dbg;
}
public virtual void CreateNode(object node, IToken token)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.CreateNode(node, token);
}
}
public virtual void CreateNode(object t)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.CreateNode(t);
}
}
public virtual void Terminate()
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.Terminate();
}
}
public virtual void SemanticPredicate(bool result, string predicate)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.SemanticPredicate(result, predicate);
}
}
public virtual void Commence()
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.Commence();
}
}
public virtual void ExitRule(string grammarFileName, string ruleName)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.ExitRule(grammarFileName, ruleName);
}
}
public virtual void EndResync()
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.EndResync();
}
}
public virtual void BeginBacktrack(int level)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.BeginBacktrack(level);
}
}
public virtual void EndBacktrack(int level, bool successful)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.EndBacktrack(level, successful);
}
}
public virtual void Mark(int index)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.Mark(index);
}
}
public virtual void Rewind()
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.Rewind();
}
}
public virtual void Location(int line, int pos)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.Location(line, pos);
}
}
public virtual void ConsumeHiddenToken(IToken token)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.ConsumeHiddenToken(token);
}
}
public virtual void ExitDecision(int decisionNumber)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.ExitDecision(decisionNumber);
}
}
public virtual void EnterDecision(int decisionNumber, bool couldBacktrack)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.EnterDecision(decisionNumber, couldBacktrack);
}
}
public virtual void EnterSubRule(int decisionNumber)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.EnterSubRule(decisionNumber);
}
}
public virtual void LT(int index, object t)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.LT(index, t);
}
}
public virtual void RecognitionException(RecognitionException e)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.RecognitionException(e);
}
}
public virtual void SetTokenBoundaries(object t, int tokenStartIndex, int tokenStopIndex)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.SetTokenBoundaries(t, tokenStartIndex, tokenStopIndex);
}
}
public virtual void EnterAlt(int alt)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.EnterAlt(alt);
}
}
public virtual void AddChild(object root, object child)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.AddChild(root, child);
}
}
public DebugTokenStream(ITokenStream input, IDebugEventListener dbg)
{
this.input = input;
DebugListener = dbg;
// force TokenStream to get at least first valid token
// so we know if there are any hidden tokens first in the stream
input.LT(1);
}
public virtual void BecomeRoot(object newRoot, object oldRoot)
{
for (int i = 0; i < _listeners.Count; i++)
{
IDebugEventListener listener = _listeners[i];
listener.BecomeRoot(newRoot, oldRoot);
}
}
public ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg, RecognizerSharedState state )
: base( input, dbg, state )
{
Profiler p = (Profiler)dbg;
p.setParser(this);
ITreeAdaptor adap = new CommonTreeAdaptor();
TreeAdaptor = adap;
proxy.TreeAdaptor = adap;
}
public DebugGrammarParser( ITokenStream input, IDebugEventListener dbg )
: base( input, dbg )
{
ITreeAdaptor adap = new CommonTreeAdaptor();
TreeAdaptor = adap;
}
public ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg )
: base( input, dbg )
{
Profiler p = (Profiler)dbg;
p.setParser(this);
ITreeAdaptor adap = new CommonTreeAdaptor();
TreeAdaptor = adap;
}
public DebugGrammarParser( ITokenStream input, IDebugEventListener dbg )
: base( input, dbg )
{
InitializeTreeAdaptor();
if ( TreeAdaptor == null )
TreeAdaptor = new CommonTreeAdaptor();
ITreeAdaptor adap = new CommonTreeAdaptor();
TreeAdaptor = adap;
}
public void AttachToProcess(int id, IDebugEventListener listener)
{
if (listener == null) throw new ArgumentNullException(nameof(listener));
var workerThread = new Thread(param =>
{
var @this = (Win32DebuggerService)param;
@this.WorkerThreadMain(unchecked((uint)id), listener);
});
workerThread.Name = "Debugger message pump thread";
workerThread.Start(this);
}
public RemoteDebugEventSocketListener( IDebugEventListener listener,
string machine,
int port )
{
this.listener = listener;
this.machine = machine;
this.port = port;
if ( !OpenConnection() )
{
throw new SocketException();
}
}
public DebugParser(ITokenStream input, IDebugEventListener dbg)
: this(input is DebugTokenStream ? input : new DebugTokenStream(input, dbg), dbg, null) {
}
public DebugTreeAdaptor(IDebugEventListener dbg, ITreeAdaptor adaptor) {
this.dbg = dbg;
this.adaptor = adaptor;
}
/** <summary>
* Create a normal parser except wrap the token stream in a debug
* proxy that fires consume events.
* </summary>
*/
public DebugParser(ITokenStream input, IDebugEventListener dbg, RecognizerSharedState state)
: base(input is DebugTokenStream ? input : new DebugTokenStream(input, dbg), state) {
SetDebugListener(dbg);
}
public void SetDebugListener( IDebugEventListener dbg )
{
DebugListener = dbg;
}
public ProcessAttachment(IDebugEventListener listener)
{
this.listener = listener;
}
public void SetDebugListener(IDebugEventListener dbg)
{
this.dbg = dbg;
}
/** <summary>
* Add another listener to broadcast events too. Not thread-safe.
* Don't add events in one thread while parser fires events in another.
* </summary>
*/
public virtual void AddListener( IDebugEventListener listener )
{
_listeners.Add( listener );
}
// $ANTLR end "declaration1"
// Delegated rules
private void InitializeCyclicDFAs(IDebugEventListener dbg)
{
}
public ParserDebugger( Parser parser, IDebugEventListener dbg )
{
ITreeAdaptor adap = new CommonTreeAdaptor();
TreeAdaptor = adap;
}
public DebugEventRepeater(IDebugEventListener listener)
{
this.listener = listener;
}
/// <summary>
/// Create a normal parser except wrap the token stream in a debug
/// proxy that fires consume events.
/// </summary>
public DebugTreeParser(ITreeNodeStream input, IDebugEventListener dbg, RecognizerSharedState state)
: base((input is DebugTreeNodeStream ? input : new DebugTreeNodeStream(input, dbg)), state)
{
DebugListener = dbg;
}
public RemoteDebugEventSocketListener(IDebugEventListener listener, string hostName, int port)
{
this.listener = listener;
this.hostName = hostName;
this.port = port;
if (!OpenConnection())
{
throw new System.Exception();
}
}
private void WorkerThreadMain(uint rootProcessID, IDebugEventListener rootListener)
{
if (!DebugActiveProcess(rootProcessID))
{
rootListener.OnAttachFailed(GetLastWin32Exception());
return;
}
var processAttachments = new Dictionary<uint, ProcessAttachment>();
var rootProcessAttachment = new ProcessAttachment(rootListener);
processAttachments.Add(rootProcessID, rootProcessAttachment);
while (processAttachments.Count > 0)
{
DEBUG_EVENT debugEvent;
CheckWin32(WaitForDebugEventEx(out debugEvent, INFINITE));
ProcessAttachment processAttachment;
if (!processAttachments.TryGetValue(debugEvent.dwProcessId, out processAttachment))
{
// Unexpected, we should have been asked to attach to the process
throw new InvalidOperationException();
}
// If we've just attached to a new process, complete the attach event.
var listener = processAttachment.Listener;
int threadID = unchecked((int)debugEvent.dwThreadId);
DebugEventResponse response;
switch (debugEvent.dwDebugEventCode)
{
case EXCEPTION_DEBUG_EVENT:
{
var record = IntPtr.Size == sizeof(int)
? ExceptionRecord.FromStruct(ref debugEvent.Exception32.ExceptionRecord)
: ExceptionRecord.FromStruct(ref debugEvent.Exception64.ExceptionRecord);
response = listener.OnException(threadID, record);
}
break;
case CREATE_PROCESS_DEBUG_EVENT:
if (debugEvent.dwProcessId != rootProcessID)
throw new NotImplementedException("Attaching to child processes.");
response = processAttachment.OnAttachSucceeded(threadID, debugEvent.CreateProcessInfo);
break;
case CREATE_THREAD_DEBUG_EVENT:
response = processAttachment.OnThreadCreated(threadID, debugEvent.CreateThread);
break;
case EXIT_THREAD_DEBUG_EVENT:
response = processAttachment.OnThreadExited(threadID, debugEvent.ExitThread);
break;
case LOAD_DLL_DEBUG_EVENT:
{
var fileHandle = new SafeFileHandle(debugEvent.LoadDll.hFile, ownsHandle: false);
response = listener.OnModuleLoaded(threadID, new ForeignPtr(debugEvent.LoadDll.lpBaseOfDll), fileHandle);
}
break;
case OUTPUT_DEBUG_STRING_EVENT:
{
var str = debugEvent.DebugString.fUnicode == 0
? Marshal.PtrToStringAnsi(debugEvent.DebugString.lpDebugStringData, debugEvent.DebugString.nDebugStringLength)
: Marshal.PtrToStringUni(debugEvent.DebugString.lpDebugStringData, debugEvent.DebugString.nDebugStringLength);
response = listener.OnStringOutputted(threadID, str);
}
break;
case UNLOAD_DLL_DEBUG_EVENT:
response = listener.OnModuleUnloaded(threadID, new ForeignPtr(debugEvent.UnloadDll.lpBaseOfDll));
break;
default:
Debug.Fail("Unknown debug code.");
response = DebugEventResponse.ContinueUnhandled;
break;
}
if (response != DebugEventResponse.Break)
{
bool unhandledException = response == DebugEventResponse.ContinueUnhandled
&& debugEvent.dwDebugEventCode == EXCEPTION_DEBUG_EVENT;
CheckWin32(ContinueDebugEvent(debugEvent.dwProcessId, debugEvent.dwThreadId,
unhandledException ? DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE));
}
}
}
public DFA4(BaseRecognizer recognizer, IDebugEventListener dbg)
{
this.recognizer = recognizer;
this.decisionNumber = 4;
this.eot = DFA4_eot;
this.eof = DFA4_eof;
this.min = DFA4_min;
this.max = DFA4_max;
this.accept = DFA4_accept;
this.special = DFA4_special;
this.transition = DFA4_transition;
}
public DebugEventHub(IDebugEventListener listener)
{
listeners.Add(listener);
}
/** <summary>
* Provide a new debug event listener for this parser. Notify the
* input stream too that it should send events to this listener.
* </summary>
*/
public virtual void SetDebugListener(IDebugEventListener value)
{
if (input is DebugTreeNodeStream)
((DebugTreeNodeStream)input).DebugListener = value;
this.dbg = value;
}
partial void OnCreated()
{
Console.WriteLine("OnCreated");
debugEventListener = new TraceDebugEventListenerEx(TreeAdaptor);
}
public DebugTreeParser( ITreeNodeStream input, IDebugEventListener dbg )
: this(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream( input, dbg ), dbg, null)
{
}
public InterpParser(ITokenStream input, IDebugEventListener dbg)
: base(input, dbg) {
InitializeCyclicDFAs(dbg);
ITreeAdaptor adap = new CommonTreeAdaptor();
TreeAdaptor = adap;
}
/// <summary>
/// Add another listener to broadcast events too.
/// </summary>
/// <remarks>
/// Not thread-safe. Don't add events in one thread while parser
/// fires events in another.
/// </remarks>
public void AddListener(IDebugEventListener listener)
{
listeners.Add(listeners);
}
