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

   1 namespace antlr.debug
   2 {
   3         using System;
   4         using System.Threading;
   5         using antlr;
   6
   7         using BitSet    = antlr.collections.impl.BitSet;
   8
   9         public abstract class DebuggingCharScanner : CharScanner, DebuggingParser
  10         {
  11                 private void  InitBlock()
  12                 {
  13                         eventSupport = new ScannerEventSupport(this);
  14                 }
  15                 public virtual void setDebugMode(bool mode)
  16                 {
  17                         _notDebugMode = !mode;
  18                 }
  19
  20                 private ScannerEventSupport eventSupport;
  21                 private bool _notDebugMode = false;
  22                 protected internal string[] ruleNames;
  23                 protected internal string[] semPredNames;
  24
  25
  26                 public DebuggingCharScanner(InputBuffer cb) : base(cb)
  27                 {
  28                         InitBlock();
  29                 }
  30                 public DebuggingCharScanner(LexerSharedInputState state) : base(state)
  31                 {
  32                         InitBlock();
  33                 }
  34                 public virtual void  addMessageListener(MessageListener l)
  35                 {
  36                         eventSupport.addMessageListener(l);
  37                 }
  38                 public virtual void  addNewLineListener(NewLineListener l)
  39                 {
  40                         eventSupport.addNewLineListener(l);
  41                 }
  42                 public virtual void  addParserListener(ParserListener l)
  43                 {
  44                         eventSupport.addParserListener(l);
  45                 }
  46                 public virtual void  addParserMatchListener(ParserMatchListener l)
  47                 {
  48                         eventSupport.addParserMatchListener(l);
  49                 }
  50                 public virtual void  addParserTokenListener(ParserTokenListener l)
  51                 {
  52                         eventSupport.addParserTokenListener(l);
  53                 }
  54                 public virtual void  addSemanticPredicateListener(SemanticPredicateListener l)
  55                 {
  56                         eventSupport.addSemanticPredicateListener(l);
  57                 }
  58                 public virtual void  addSyntacticPredicateListener(SyntacticPredicateListener l)
  59                 {
  60                         eventSupport.addSyntacticPredicateListener(l);
  61                 }
  62                 public virtual void  addTraceListener(TraceListener l)
  63                 {
  64                         eventSupport.addTraceListener(l);
  65                 }
  66                 public override void  consume()
  67                 {
  68                         int la_1 = - 99;
  69                         try
  70                         {
  71                                 la_1 = LA(1);
  72                         }
  73                         catch (CharStreamException)
  74                         {
  75                         }
  76                         base.consume();
  77                         eventSupport.fireConsume(la_1);
  78                 }
  79                 protected internal virtual void  fireEnterRule(int num, int data)
  80                 {
  81                         if (isDebugMode())
  82                                 eventSupport.fireEnterRule(num, inputState.guessing, data);
  83                 }
  84                 protected internal virtual void  fireExitRule(int num, int ttype)
  85                 {
  86                         if (isDebugMode())
  87                                 eventSupport.fireExitRule(num, inputState.guessing, ttype);
  88                 }
  89                 protected internal virtual bool fireSemanticPredicateEvaluated(int type, int num, bool condition)
  90                 {
  91                         if (isDebugMode())
  92                                 return eventSupport.fireSemanticPredicateEvaluated(type, num, condition, inputState.guessing);
  93                         else
  94                                 return condition;
  95                 }
  96                 protected internal virtual void  fireSyntacticPredicateFailed()
  97                 {
  98                         if (isDebugMode())
  99                                 eventSupport.fireSyntacticPredicateFailed(inputState.guessing);
 100                 }
 101                 protected internal virtual void  fireSyntacticPredicateStarted()
 102                 {
 103                         if (isDebugMode())
 104                                 eventSupport.fireSyntacticPredicateStarted(inputState.guessing);
 105                 }
 106                 protected internal virtual void  fireSyntacticPredicateSucceeded()
 107                 {
 108                         if (isDebugMode())
 109                                 eventSupport.fireSyntacticPredicateSucceeded(inputState.guessing);
 110                 }
 111                 public virtual string getRuleName(int num)
 112                 {
 113                         return ruleNames[num];
 114                 }
 115                 public virtual string getSemPredName(int num)
 116                 {
 117                         return semPredNames[num];
 118                 }
 119                 public virtual void  goToSleep()
 120                 {
 121                         lock(this)
 122                         {
 123                                 try
 124                                 {
 125                                         Monitor.Wait(this);
 126                                 }
 127                                 catch (System.Threading.ThreadInterruptedException)
 128                                 {
 129                                 }
 130                         }
 131                 }
 132                 public virtual bool isDebugMode()
 133                 {
 134                         return !_notDebugMode;
 135                 }
 136                 public override char LA(int i)
 137                 {
 138                         char la = base.LA(i);
 139                         eventSupport.fireLA(i, la);
 140                         return la;
 141                 }
 142                 protected internal override IToken makeToken(int t)
 143                 {
 144                         // do something with char buffer???
 145                         //              try {
 146                         //                      IToken tok = (Token)tokenObjectClass.newInstance();
 147                         //                      tok.setType(t);
 148                         //                      // tok.setText(getText()); done in generated lexer now
 149                         //                      tok.setLine(line);
 150                         //                      return tok;
 151                         //              }
 152                         //              catch (InstantiationException ie) {
 153                         //                      panic("can't instantiate a Token");
 154                         //              }
 155                         //              catch (IllegalAccessException iae) {
 156                         //                      panic("Token class is not accessible");
 157                         //              }
 158                         return base.makeToken(t);
 159                 }
 160                 public override void  match(int c)
 161                 {
 162                         char la_1 = LA(1);
 163                         try
 164                         {
 165                                 base.match(c);
 166                                 eventSupport.fireMatch(Convert.ToChar(c), inputState.guessing);
 167                         }
 168                         catch (MismatchedCharException e)
 169                         {
 170                                 if (inputState.guessing == 0)
 171                                         eventSupport.fireMismatch(la_1, Convert.ToChar(c), inputState.guessing);
 172                                 throw e;
 173                         }
 174                 }
 175                 public override void  match(BitSet b)
 176                 {
 177                         string text = this.text.ToString();
 178                         char la_1 = LA(1);
 179                         try
 180                         {
 181                                 base.match(b);
 182                                 eventSupport.fireMatch(la_1, b, text, inputState.guessing);
 183                         }
 184                         catch (MismatchedCharException e)
 185                         {
 186                                 if (inputState.guessing == 0)
 187                                         eventSupport.fireMismatch(la_1, b, text, inputState.guessing);
 188                                 throw e;
 189                         }
 190                 }
 191                 public override void  match(string s)
 192                 {
 193                         System.Text.StringBuilder la_s = new System.Text.StringBuilder("");
 194                         int len = s.Length;
 195                         // peek at the next len worth of characters
 196                         try
 197                         {
 198                                  for (int i = 1; i <= len; i++)
 199                                 {
 200                                         la_s.Append(base.LA(i));
 201                                 }
 202                         }
 203                         catch (System.Exception)
 204                         {
 205                         }
 206
 207                         try
 208                         {
 209                                 base.match(s);
 210                                 eventSupport.fireMatch(s, inputState.guessing);
 211                         }
 212                         catch (MismatchedCharException e)
 213                         {
 214                                 if (inputState.guessing == 0)
 215                                         eventSupport.fireMismatch(la_s.ToString(), s, inputState.guessing);
 216                                 throw e;
 217                         }
 218
 219                 }
 220                 public override void  matchNot(int c)
 221                 {
 222                         char la_1 = LA(1);
 223                         try
 224                         {
 225                                 base.matchNot(c);
 226                                 eventSupport.fireMatchNot(la_1, Convert.ToChar(c), inputState.guessing);
 227                         }
 228                         catch (MismatchedCharException e)
 229                         {
 230                                 if (inputState.guessing == 0)
 231                                         eventSupport.fireMismatchNot(la_1, Convert.ToChar(c), inputState.guessing);
 232                                 throw e;
 233                         }
 234
 235                 }
 236                 public override void  matchRange(int c1, int c2)
 237                 {
 238                         char la_1 = LA(1);
 239                         try
 240                         {
 241                                 base.matchRange(c1, c2);
 242                                 eventSupport.fireMatch(la_1, "" + c1 + c2, inputState.guessing);
 243                         }
 244                         catch (MismatchedCharException e)
 245                         {
 246                                 if (inputState.guessing == 0)
 247                                         eventSupport.fireMismatch(la_1, "" + c1 + c2, inputState.guessing);
 248                                 throw e;
 249                         }
 250
 251                 }
 252                 public override void  newline()
 253                 {
 254                         base.newline();
 255                         eventSupport.fireNewLine(getLine());
 256                 }
 257                 public virtual void  removeMessageListener(MessageListener l)
 258                 {
 259                         eventSupport.removeMessageListener(l);
 260                 }
 261                 public virtual void  removeNewLineListener(NewLineListener l)
 262                 {
 263                         eventSupport.removeNewLineListener(l);
 264                 }
 265                 public virtual void  removeParserListener(ParserListener l)
 266                 {
 267                         eventSupport.removeParserListener(l);
 268                 }
 269                 public virtual void  removeParserMatchListener(ParserMatchListener l)
 270                 {
 271                         eventSupport.removeParserMatchListener(l);
 272                 }
 273                 public virtual void  removeParserTokenListener(ParserTokenListener l)
 274                 {
 275                         eventSupport.removeParserTokenListener(l);
 276                 }
 277                 public virtual void  removeSemanticPredicateListener(SemanticPredicateListener l)
 278                 {
 279                         eventSupport.removeSemanticPredicateListener(l);
 280                 }
 281                 public virtual void  removeSyntacticPredicateListener(SyntacticPredicateListener l)
 282                 {
 283                         eventSupport.removeSyntacticPredicateListener(l);
 284                 }
 285                 public virtual void  removeTraceListener(TraceListener l)
 286                 {
 287                         eventSupport.removeTraceListener(l);
 288                 }
 289                 /// <summary>Report exception errors caught in nextToken()
 290                 /// </summary>
 291                 public virtual void  reportError(MismatchedCharException e)
 292                 {
 293                         eventSupport.fireReportError(e);
 294                         base.reportError(e);
 295                 }
 296                 /// <summary>Parser error-reporting function can be overridden in subclass
 297                 /// </summary>
 298                 public override void  reportError(string s)
 299                 {
 300                         eventSupport.fireReportError(s);
 301                         base.reportError(s);
 302                 }
 303                 /// <summary>Parser warning-reporting function can be overridden in subclass
 304                 /// </summary>
 305                 public override void  reportWarning(string s)
 306                 {
 307                         eventSupport.fireReportWarning(s);
 308                         base.reportWarning(s);
 309                 }
 310                 public virtual void  setupDebugging()
 311                 {
 312                 }
 313
 314                 public virtual void  wakeUp()
 315                 {
 316                         lock(this)
 317                         {
 318                                 Monitor.Pulse(this);
 319                         }
 320                 }
 321         }
 322 }