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 }