1 namespace antlr.debug
2 {
3 	using System;
4 	using System.Reflection;
5 	using Hashtable		= System.Collections.Hashtable;
6 	using ArrayList		= System.Collections.ArrayList;
7 
8 	using antlr.collections.impl;
9 
10 
11 	/// <summary>A class to assist in firing parser events
12 	/// NOTE: I intentionally _did_not_ synchronize the event firing and
13 	/// add/remove listener methods.  This is because the add/remove should
14 	/// _only_ be called by the parser at its start/end, and the _same_thread_
15 	/// should be performing the parsing.  This should help performance a tad...
16 	/// </summary>
17 	public class ScannerEventSupport
18 	{
19 		private object source;
20 		private Hashtable listeners;
21 		private MatchEventArgs matchEvent;
22 		private MessageEventArgs messageEvent;
23 		private TokenEventArgs tokenEvent;
24 		private SemanticPredicateEventArgs semPredEvent;
25 		private SyntacticPredicateEventArgs synPredEvent;
26 		private TraceEventArgs traceEvent;
27 		private NewLineEventArgs newLineEvent;
28 		//private ParserController controller;
29 
30 		private int ruleDepth = 0;
31 
32 
ScannerEventSupport(object source)33 		public ScannerEventSupport(object source)
34 		{
35 			matchEvent		= new MatchEventArgs();
36 			messageEvent	= new MessageEventArgs();
37 			tokenEvent		= new TokenEventArgs();
38 			traceEvent		= new TraceEventArgs();
39 			semPredEvent	= new SemanticPredicateEventArgs();
40 			synPredEvent	= new SyntacticPredicateEventArgs();
41 			newLineEvent	= new NewLineEventArgs();
42 			listeners		= new Hashtable();
43 			this.source		= source;
44 		}
45 
checkController()46 		public virtual void checkController()
47 		{
48 			//if (controller != null)
49 			//	controller.checkBreak();
50 		}
51 
addDoneListener(Listener l)52 		public virtual void  addDoneListener(Listener l)
53 		{
54 			((CharScanner)source).Done += new TraceEventHandler(l.doneParsing);
55 			listeners[l] = l;
56 		}
addMessageListener(MessageListener l)57 		public virtual void  addMessageListener(MessageListener l)
58 		{
59 			((CharScanner)source).ErrorReported   += new MessageEventHandler(l.reportError);
60 			((CharScanner)source).WarningReported += new MessageEventHandler(l.reportWarning);
61 			addDoneListener(l);
62 		}
addNewLineListener(NewLineListener l)63 		public virtual void  addNewLineListener(NewLineListener l)
64 		{
65 			((CharScanner)source).HitNewLine   += new NewLineEventHandler(l.hitNewLine);
66 			addDoneListener(l);
67 		}
addParserListener(ParserListener l)68 		public virtual void  addParserListener(ParserListener l)
69 		{
70 			if (l is ParserController)
71 			{
72 				//((ParserController) l).ParserEventSupport = this;
73 				//controller = (ParserController) l;
74 			}
75 			addParserMatchListener(l);
76 			addParserTokenListener(l);
77 
78 			addMessageListener(l);
79 			addTraceListener(l);
80 			addSemanticPredicateListener(l);
81 			addSyntacticPredicateListener(l);
82 		}
addParserMatchListener(ParserMatchListener l)83 		public virtual void  addParserMatchListener(ParserMatchListener l)
84 		{
85 			((CharScanner)source).MatchedChar		+= new MatchEventHandler(l.parserMatch);
86 			((CharScanner)source).MatchedNotChar	+= new MatchEventHandler(l.parserMatchNot);
87 			((CharScanner)source).MisMatchedChar	+= new MatchEventHandler(l.parserMismatch);
88 			((CharScanner)source).MisMatchedNotChar	+= new MatchEventHandler(l.parserMismatchNot);
89 			addDoneListener(l);
90 		}
addParserTokenListener(ParserTokenListener l)91 		public virtual void  addParserTokenListener(ParserTokenListener l)
92 		{
93 			((CharScanner)source).ConsumedChar	+= new TokenEventHandler(l.parserConsume);
94 			((CharScanner)source).CharLA		+= new TokenEventHandler(l.parserLA);
95 			addDoneListener(l);
96 		}
addSemanticPredicateListener(SemanticPredicateListener l)97 		public virtual void  addSemanticPredicateListener(SemanticPredicateListener l)
98 		{
99 			((CharScanner)source).SemPredEvaluated	+= new SemanticPredicateEventHandler(l.semanticPredicateEvaluated);
100 			addDoneListener(l);
101 		}
addSyntacticPredicateListener(SyntacticPredicateListener l)102 		public virtual void  addSyntacticPredicateListener(SyntacticPredicateListener l)
103 		{
104 			((CharScanner)source).SynPredStarted		+= new SyntacticPredicateEventHandler(l.syntacticPredicateStarted);
105 			((CharScanner)source).SynPredFailed		+= new SyntacticPredicateEventHandler(l.syntacticPredicateFailed);
106 			((CharScanner)source).SynPredSucceeded	+= new SyntacticPredicateEventHandler(l.syntacticPredicateSucceeded);
107 			addDoneListener(l);
108 		}
addTraceListener(TraceListener l)109 		public virtual void  addTraceListener(TraceListener l)
110 		{
111 			((CharScanner)source).EnterRule	+= new TraceEventHandler(l.enterRule);
112 			((CharScanner)source).ExitRule	+= new TraceEventHandler(l.exitRule);
113 			addDoneListener(l);
114 		}
fireConsume(int c)115 		public virtual void  fireConsume(int c)
116 		{
117 			TokenEventHandler eventDelegate = (TokenEventHandler)((CharScanner)source).Events[Parser.LAEventKey];
118 			if (eventDelegate != null)
119 			{
120 				tokenEvent.setValues(TokenEventArgs.CONSUME, 1, c);
121 				eventDelegate(source, tokenEvent);
122 			}
123 			checkController();
124 		}
fireDoneParsing()125 		public virtual void  fireDoneParsing()
126 		{
127 			TraceEventHandler eventDelegate = (TraceEventHandler)((CharScanner)source).Events[Parser.DoneEventKey];
128 			if (eventDelegate != null)
129 			{
130 				traceEvent.setValues(TraceEventArgs.DONE_PARSING, 0, 0, 0);
131 				eventDelegate(source, traceEvent);
132 			}
133 			checkController();
134 		}
fireEnterRule(int ruleNum, int guessing, int data)135 		public virtual void  fireEnterRule(int ruleNum, int guessing, int data)
136 		{
137 			ruleDepth++;
138 			TraceEventHandler eventDelegate = (TraceEventHandler)((CharScanner)source).Events[Parser.EnterRuleEventKey];
139 			if (eventDelegate != null)
140 			{
141 				traceEvent.setValues(TraceEventArgs.ENTER, ruleNum, guessing, data);
142 				eventDelegate(source, traceEvent);
143 			}
144 			checkController();
145 		}
fireExitRule(int ruleNum, int guessing, int data)146 		public virtual void  fireExitRule(int ruleNum, int guessing, int data)
147 		{
148 			TraceEventHandler eventDelegate = (TraceEventHandler)((CharScanner)source).Events[Parser.ExitRuleEventKey];
149 			if (eventDelegate != null)
150 			{
151 				traceEvent.setValues(TraceEventArgs.EXIT, ruleNum, guessing, data);
152 				eventDelegate(source, traceEvent);
153 			}
154 			checkController();
155 
156 			ruleDepth--;
157 			if (ruleDepth == 0)
158 				fireDoneParsing();
159 
160 		}
fireLA(int k, int la)161 		public virtual void  fireLA(int k, int la)
162 		{
163 			TokenEventHandler eventDelegate = (TokenEventHandler)((CharScanner)source).Events[Parser.LAEventKey];
164 			if (eventDelegate != null)
165 			{
166 				tokenEvent.setValues(TokenEventArgs.LA, k, la);
167 				eventDelegate(source, tokenEvent);
168 			}
169 			checkController();
170 		}
fireMatch(char c, int guessing)171 		public virtual void  fireMatch(char c, int guessing)
172 		{
173 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchEventKey];
174 			if (eventDelegate != null)
175 			{
176 				matchEvent.setValues(MatchEventArgs.CHAR, c, c, null, guessing, false, true);
177 				eventDelegate(source, matchEvent);
178 			}
179 			checkController();
180 		}
fireMatch(char c, BitSet b, int guessing)181 		public virtual void  fireMatch(char c, BitSet b, int guessing)
182 		{
183 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchEventKey];
184 			if (eventDelegate != null)
185 			{
186 				matchEvent.setValues(MatchEventArgs.CHAR_BITSET, c, b, null, guessing, false, true);
187 				eventDelegate(source, matchEvent);
188 			}
189 			checkController();
190 		}
fireMatch(char c, string target, int guessing)191 		public virtual void  fireMatch(char c, string target, int guessing)
192 		{
193 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchEventKey];
194 			if (eventDelegate != null)
195 			{
196 				matchEvent.setValues(MatchEventArgs.CHAR_RANGE, c, target, null, guessing, false, true);
197 				eventDelegate(source, matchEvent);
198 			}
199 			checkController();
200 		}
fireMatch(int c, BitSet b, string text, int guessing)201 		public virtual void  fireMatch(int c, BitSet b, string text, int guessing)
202 		{
203 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchEventKey];
204 			if (eventDelegate != null)
205 			{
206 				matchEvent.setValues(MatchEventArgs.BITSET, c, b, text, guessing, false, true);
207 				eventDelegate(source, matchEvent);
208 			}
209 			checkController();
210 		}
fireMatch(int n, string text, int guessing)211 		public virtual void  fireMatch(int n, string text, int guessing)
212 		{
213 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchEventKey];
214 			if (eventDelegate != null)
215 			{
216 				matchEvent.setValues(MatchEventArgs.TOKEN, n, n, text, guessing, false, true);
217 				eventDelegate(source, matchEvent);
218 			}
219 			checkController();
220 		}
fireMatch(string s, int guessing)221 		public virtual void  fireMatch(string s, int guessing)
222 		{
223 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchEventKey];
224 			if (eventDelegate != null)
225 			{
226 				matchEvent.setValues(MatchEventArgs.STRING, 0, s, null, guessing, false, true);
227 				eventDelegate(source, matchEvent);
228 			}
229 			checkController();
230 		}
fireMatchNot(char c, char n, int guessing)231 		public virtual void  fireMatchNot(char c, char n, int guessing)
232 		{
233 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchNotEventKey];
234 			if (eventDelegate != null)
235 			{
236 				matchEvent.setValues(MatchEventArgs.CHAR, c, n, null, guessing, true, true);
237 				eventDelegate(source, matchEvent);
238 			}
239 			checkController();
240 		}
fireMatchNot(int c, int n, string text, int guessing)241 		public virtual void  fireMatchNot(int c, int n, string text, int guessing)
242 		{
243 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MatchNotEventKey];
244 			if (eventDelegate != null)
245 			{
246 				matchEvent.setValues(MatchEventArgs.TOKEN, c, n, text, guessing, true, true);
247 				eventDelegate(source, matchEvent);
248 			}
249 			checkController();
250 		}
fireMismatch(char c, char n, int guessing)251 		public virtual void  fireMismatch(char c, char n, int guessing)
252 		{
253 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchEventKey];
254 			if (eventDelegate != null)
255 			{
256 				matchEvent.setValues(MatchEventArgs.CHAR, c, n, null, guessing, false, false);
257 				eventDelegate(source, matchEvent);
258 			}
259 			checkController();
260 		}
fireMismatch(char c, BitSet b, int guessing)261 		public virtual void  fireMismatch(char c, BitSet b, int guessing)
262 		{
263 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchEventKey];
264 			if (eventDelegate != null)
265 			{
266 				matchEvent.setValues(MatchEventArgs.CHAR_BITSET, c, b, null, guessing, false, true);
267 				eventDelegate(source, matchEvent);
268 			}
269 			checkController();
270 		}
fireMismatch(char c, string target, int guessing)271 		public virtual void  fireMismatch(char c, string target, int guessing)
272 		{
273 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchEventKey];
274 			if (eventDelegate != null)
275 			{
276 				matchEvent.setValues(MatchEventArgs.CHAR_RANGE, c, target, null, guessing, false, true);
277 				eventDelegate(source, matchEvent);
278 			}
279 			checkController();
280 		}
fireMismatch(int i, int n, string text, int guessing)281 		public virtual void  fireMismatch(int i, int n, string text, int guessing)
282 		{
283 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchEventKey];
284 			if (eventDelegate != null)
285 			{
286 				matchEvent.setValues(MatchEventArgs.TOKEN, i, n, text, guessing, false, false);
287 				eventDelegate(source, matchEvent);
288 			}
289 			checkController();
290 		}
fireMismatch(int i, BitSet b, string text, int guessing)291 		public virtual void  fireMismatch(int i, BitSet b, string text, int guessing)
292 		{
293 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchEventKey];
294 			if (eventDelegate != null)
295 			{
296 				matchEvent.setValues(MatchEventArgs.BITSET, i, b, text, guessing, false, true);
297 				eventDelegate(source, matchEvent);
298 			}
299 			checkController();
300 		}
fireMismatch(string s, string text, int guessing)301 		public virtual void  fireMismatch(string s, string text, int guessing)
302 		{
303 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchEventKey];
304 			if (eventDelegate != null)
305 			{
306 				matchEvent.setValues(MatchEventArgs.STRING, 0, text, s, guessing, false, true);
307 				eventDelegate(source, matchEvent);
308 			}
309 			checkController();
310 		}
fireMismatchNot(char v, char c, int guessing)311 		public virtual void  fireMismatchNot(char v, char c, int guessing)
312 		{
313 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchNotEventKey];
314 			if (eventDelegate != null)
315 			{
316 				matchEvent.setValues(MatchEventArgs.CHAR, v, c, null, guessing, true, true);
317 				eventDelegate(source, matchEvent);
318 			}
319 			checkController();
320 		}
fireMismatchNot(int i, int n, string text, int guessing)321 		public virtual void  fireMismatchNot(int i, int n, string text, int guessing)
322 		{
323 			MatchEventHandler eventDelegate = (MatchEventHandler)((CharScanner)source).Events[Parser.MisMatchNotEventKey];
324 			if (eventDelegate != null)
325 			{
326 				matchEvent.setValues(MatchEventArgs.TOKEN, i, n, text, guessing, true, true);
327 				eventDelegate(source, matchEvent);
328 			}
329 			checkController();
330 		}
fireNewLine(int line)331 		public virtual void  fireNewLine(int line)
332 		{
333 			NewLineEventHandler eventDelegate = (NewLineEventHandler)((CharScanner)source).Events[Parser.NewLineEventKey];
334 			if (eventDelegate != null)
335 			{
336 				newLineEvent.Line = line;
337 				eventDelegate(source, newLineEvent);
338 			}
339 			checkController();
340 		}
fireReportError(System.Exception e)341 		public virtual void  fireReportError(System.Exception e)
342 		{
343 			MessageEventHandler eventDelegate = (MessageEventHandler)((CharScanner)source).Events[Parser.ReportErrorEventKey];
344 			if (eventDelegate != null)
345 			{
346 				messageEvent.setValues(MessageEventArgs.ERROR, e.ToString());
347 				eventDelegate(source, messageEvent);
348 			}
349 			checkController();
350 		}
fireReportError(string s)351 		public virtual void  fireReportError(string s)
352 		{
353 			MessageEventHandler eventDelegate = (MessageEventHandler)((CharScanner)source).Events[Parser.ReportErrorEventKey];
354 			if (eventDelegate != null)
355 			{
356 				messageEvent.setValues(MessageEventArgs.ERROR, s);
357 				eventDelegate(source, messageEvent);
358 			}
359 			checkController();
360 		}
fireReportWarning(string s)361 		public virtual void  fireReportWarning(string s)
362 		{
363 			MessageEventHandler eventDelegate = (MessageEventHandler)((CharScanner)source).Events[Parser.ReportWarningEventKey];
364 			if (eventDelegate != null)
365 			{
366 				messageEvent.setValues(MessageEventArgs.WARNING, s);
367 				eventDelegate(source, messageEvent);
368 			}
369 			checkController();
370 		}
fireSemanticPredicateEvaluated(int type, int condition, bool result, int guessing)371 		public virtual bool fireSemanticPredicateEvaluated(int type, int condition, bool result, int guessing)
372 		{
373 			SemanticPredicateEventHandler eventDelegate = (SemanticPredicateEventHandler)((CharScanner)source).Events[Parser.SemPredEvaluatedEventKey];
374 			if (eventDelegate != null)
375 			{
376 				semPredEvent.setValues(type, condition, result, guessing);
377 				eventDelegate(source, semPredEvent);
378 			}
379 			checkController();
380 
381 			return result;
382 		}
fireSyntacticPredicateFailed(int guessing)383 		public virtual void  fireSyntacticPredicateFailed(int guessing)
384 		{
385 			SyntacticPredicateEventHandler eventDelegate = (SyntacticPredicateEventHandler)((CharScanner)source).Events[Parser.SynPredFailedEventKey];
386 			if (eventDelegate != null)
387 			{
388 				synPredEvent.setValues(0, guessing);
389 				eventDelegate(source, synPredEvent);
390 			}
391 			checkController();
392 		}
fireSyntacticPredicateStarted(int guessing)393 		public virtual void  fireSyntacticPredicateStarted(int guessing)
394 		{
395 			SyntacticPredicateEventHandler eventDelegate = (SyntacticPredicateEventHandler)((CharScanner)source).Events[Parser.SynPredStartedEventKey];
396 			if (eventDelegate != null)
397 			{
398 				synPredEvent.setValues(0, guessing);
399 				eventDelegate(source, synPredEvent);
400 			}
401 			checkController();
402 		}
fireSyntacticPredicateSucceeded(int guessing)403 		public virtual void  fireSyntacticPredicateSucceeded(int guessing)
404 		{
405 			SyntacticPredicateEventHandler eventDelegate = (SyntacticPredicateEventHandler)((CharScanner)source).Events[Parser.SynPredSucceededEventKey];
406 			if (eventDelegate != null)
407 			{
408 				synPredEvent.setValues(0, guessing);
409 				eventDelegate(source, synPredEvent);
410 			}
411 			checkController();
412 		}
refreshListeners()413 		public virtual void  refreshListeners()
414 		{
415 			Hashtable clonedTable;
416 
417 			lock(listeners.SyncRoot)
418 			{
419 				clonedTable = (Hashtable)listeners.Clone();
420 			}
421 			foreach (Listener l in clonedTable)
422 			{
423 				l.refresh();
424 			}
425 		}
removeDoneListener(Listener l)426 		public virtual void  removeDoneListener(Listener l)
427 		{
428 			((CharScanner)source).Done -= new TraceEventHandler(l.doneParsing);
429 			listeners.Remove(l);
430 		}
removeMessageListener(MessageListener l)431 		public virtual void  removeMessageListener(MessageListener l)
432 		{
433 			((CharScanner)source).ErrorReported   -= new MessageEventHandler(l.reportError);
434 			((CharScanner)source).WarningReported -= new MessageEventHandler(l.reportWarning);
435 			removeDoneListener(l);
436 		}
removeNewLineListener(NewLineListener l)437 		public virtual void  removeNewLineListener(NewLineListener l)
438 		{
439 			((CharScanner)source).HitNewLine   -= new NewLineEventHandler(l.hitNewLine);
440 			removeDoneListener(l);
441 		}
removeParserListener(ParserListener l)442 		public virtual void  removeParserListener(ParserListener l)
443 		{
444 			removeParserMatchListener(l);
445 			removeMessageListener(l);
446 			removeParserTokenListener(l);
447 			removeTraceListener(l);
448 			removeSemanticPredicateListener(l);
449 			removeSyntacticPredicateListener(l);
450 		}
removeParserMatchListener(ParserMatchListener l)451 		public virtual void  removeParserMatchListener(ParserMatchListener l)
452 		{
453 			((CharScanner)source).MatchedChar		-= new MatchEventHandler(l.parserMatch);
454 			((CharScanner)source).MatchedNotChar	-= new MatchEventHandler(l.parserMatchNot);
455 			((CharScanner)source).MisMatchedChar	-= new MatchEventHandler(l.parserMismatch);
456 			((CharScanner)source).MisMatchedNotChar	-= new MatchEventHandler(l.parserMismatchNot);
457 			removeDoneListener(l);
458 		}
removeParserTokenListener(ParserTokenListener l)459 		public virtual void  removeParserTokenListener(ParserTokenListener l)
460 		{
461 			((CharScanner)source).ConsumedChar	-= new TokenEventHandler(l.parserConsume);
462 			((CharScanner)source).CharLA		-= new TokenEventHandler(l.parserLA);
463 			removeDoneListener(l);
464 		}
removeSemanticPredicateListener(SemanticPredicateListener l)465 		public virtual void  removeSemanticPredicateListener(SemanticPredicateListener l)
466 		{
467 			((CharScanner)source).SemPredEvaluated	-= new SemanticPredicateEventHandler(l.semanticPredicateEvaluated);
468 			removeDoneListener(l);
469 		}
removeSyntacticPredicateListener(SyntacticPredicateListener l)470 		public virtual void  removeSyntacticPredicateListener(SyntacticPredicateListener l)
471 		{
472 			((CharScanner)source).SynPredStarted	-= new SyntacticPredicateEventHandler(l.syntacticPredicateStarted);
473 			((CharScanner)source).SynPredFailed		-= new SyntacticPredicateEventHandler(l.syntacticPredicateFailed);
474 			((CharScanner)source).SynPredSucceeded	-= new SyntacticPredicateEventHandler(l.syntacticPredicateSucceeded);
475 			removeDoneListener(l);
476 		}
removeTraceListener(TraceListener l)477 		public virtual void  removeTraceListener(TraceListener l)
478 		{
479 			((CharScanner)source).EnterRule	-= new TraceEventHandler(l.enterRule);
480 			((CharScanner)source).ExitRule	-= new TraceEventHandler(l.exitRule);
481 			removeDoneListener(l);
482 		}
483 	}
484 }