Experiments/Attic/Rook/Castle.Rook.Compiler/Parser/antlr/debug/ParserEventSupport.cs

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