?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added ability to order the execution of dictionary adapter behaviors.
[castle.git] / Experiments / Attic / Rook / Castle.Rook.Compiler / Parser / antlr / debug / ScannerEventSupport.cs
blob790ca4ea8a40a31416abaa5f6371cd3c2ef1ee0e
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
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
46 public virtual void checkController()
47 {
48 //if (controller != null)
49 // controller.checkBreak();
50 }
51
52 public virtual void addDoneListener(Listener l)
53 {
54 ((CharScanner)source).Done += new TraceEventHandler(l.doneParsing);
55 listeners[l] = l;
56 }
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 }
63 public virtual void addNewLineListener(NewLineListener l)
64 {
65 ((CharScanner)source).HitNewLine += new NewLineEventHandler(l.hitNewLine);
66 addDoneListener(l);
67 }
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 }
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 }
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 }
97 public virtual void addSemanticPredicateListener(SemanticPredicateListener l)
98 {
99 ((CharScanner)source).SemPredEvaluated += new SemanticPredicateEventHandler(l.semanticPredicateEvaluated);
100 addDoneListener(l);
101 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
426 public virtual void removeDoneListener(Listener l)
427 {
428 ((CharScanner)source).Done -= new TraceEventHandler(l.doneParsing);
429 listeners.Remove(l);
430 }
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 }
437 public virtual void removeNewLineListener(NewLineListener l)
438 {
439 ((CharScanner)source).HitNewLine -= new NewLineEventHandler(l.hitNewLine);
440 removeDoneListener(l);
441 }
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 }
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 }
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 }
465 public virtual void removeSemanticPredicateListener(SemanticPredicateListener l)
466 {
467 ((CharScanner)source).SemPredEvaluated -= new SemanticPredicateEventHandler(l.semanticPredicateEvaluated);
468 removeDoneListener(l);
469 }
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 }
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 }
Git import of castle svn